diff options
Diffstat (limited to 'thirdparty/fmt')
72 files changed, 315 insertions, 51851 deletions
diff --git a/thirdparty/fmt/ChangeLog.md b/thirdparty/fmt/ChangeLog.md index b91b6f62b..e96f9df8c 100644 --- a/thirdparty/fmt/ChangeLog.md +++ b/thirdparty/fmt/ChangeLog.md @@ -1,3 +1,77 @@ +# 12.1.0 - 2025-10-29 + +- Optimized `buffer::append`, resulting in up to ~16% improvement on spdlog + benchmarks (https://github.com/fmtlib/fmt/pull/4541). Thanks @fyrsta7. + +- Worked around an ABI incompatibility in `std::locale_ref` between clang and + gcc (https://github.com/fmtlib/fmt/issues/4573). + +- Made `std::variant` and `std::expected` formatters work with `format_as` + (https://github.com/fmtlib/fmt/issues/4574, + https://github.com/fmtlib/fmt/pull/4575). Thanks @phprus. + +- Made `fmt::join<string_view>` work with C++ modules + (https://github.com/fmtlib/fmt/issues/4379, + https://github.com/fmtlib/fmt/pull/4577). Thanks @Arghnews. + +- Exported `fmt::is_compiled_string` and `operator""_cf` from the module + (https://github.com/fmtlib/fmt/pull/4544). Thanks @CrackedMatter. + +- Fixed a compatibility issue with C++ modules in clang + (https://github.com/fmtlib/fmt/pull/4548). Thanks @tsarn. + +- Added support for cv-qualified types to the `std::optional` formatter + (https://github.com/fmtlib/fmt/issues/4561, + https://github.com/fmtlib/fmt/pull/4562). Thanks @OleksandrKvl. + +- Added demangling support (used in exception and `std::type_info` formatters) + for libc++ and clang-cl + (https://github.com/fmtlib/fmt/issues/4542, + https://github.com/fmtlib/fmt/pull/4560, + https://github.com/fmtlib/fmt/issues/4568, + https://github.com/fmtlib/fmt/pull/4571). + Thanks @FatihBAKIR and @rohitsutreja. + +- Switched to global `malloc`/`free` to enable allocator customization + (https://github.com/fmtlib/fmt/issues/4569, + https://github.com/fmtlib/fmt/pull/4570). Thanks @rohitsutreja. + +- Made the `FMT_USE_CONSTEVAL` macro configurable by users + (https://github.com/fmtlib/fmt/pull/4546). Thanks @SnapperTT. + +- Fixed compilation with locales disabled in the header-only mode + (https://github.com/fmtlib/fmt/issues/4550). + +- Fixed compilation with clang 21 and `-std=c++20` + (https://github.com/fmtlib/fmt/issues/4552). + +- Fixed a dynamic linking issue with clang-cl + (https://github.com/fmtlib/fmt/issues/4576, + https://github.com/fmtlib/fmt/pull/4584). Thanks @FatihBAKIR. + +- Fixed a warning suppression leakage on gcc + (https://github.com/fmtlib/fmt/pull/4588). Thanks @ZedThree. + +- Made more internal color APIs `constexpr` + (https://github.com/fmtlib/fmt/pull/4581). Thanks @ishani. + +- Fixed compatibility with clang as a host compiler for NVCC + (https://github.com/fmtlib/fmt/pull/4564). Thanks @valgur. + +- Fixed various warnings and lint issues + (https://github.com/fmtlib/fmt/issues/4565, + https://github.com/fmtlib/fmt/pull/4572, + https://github.com/fmtlib/fmt/pull/4557). + Thanks @LiangHuDream and @teruyamato0731. + +- Improved documentation + (https://github.com/fmtlib/fmt/issues/4549, + https://github.com/fmtlib/fmt/pull/4551, + https://github.com/fmtlib/fmt/issues/4566, + https://github.com/fmtlib/fmt/pull/4567, + https://github.com/fmtlib/fmt/pull/4578,). + Thanks @teruyamato0731, @petersteneteg and @zimmerman-dev. + # 12.0.0 - 2025-09-17 - Optimized the default floating point formatting diff --git a/thirdparty/fmt/doc/api.md b/thirdparty/fmt/doc/api.md index 2c584abc0..9fbc9f2fe 100644 --- a/thirdparty/fmt/doc/api.md +++ b/thirdparty/fmt/doc/api.md @@ -708,3 +708,53 @@ following differences: `std::to_chars` which tries to generate the smallest number of characters (ignoring redundant digits and sign in exponent) and may procude more decimal digits than necessary. + +## Configuration Options + +{fmt} provides configuration via CMake options and preprocessor macros to +enable or disable features and to optimize for binary size. For example, you +can disable OS-specific APIs defined in `fmt/os.h` with `-DFMT_OS=OFF` when +configuring CMake. + +### CMake Options + +- **`FMT_OS`**: When set to `OFF`, disables OS-specific APIs (`fmt/os.h`). +- **`FMT_UNICODE`**: When set of `OFF`, disables Unicode support on + Windows/MSVC. Unicode support is always enabled on other platforms. + +### Macros + +- **`FMT_HEADER_ONLY`**: Enables the header-only mode when defined. It is an + alternative to using the `fmt::fmt-header-only` CMake target. + Default: not defined. + +- **`FMT_USE_EXCEPTIONS`**: Disables the use of exceptions when set to `0`. + Default: `1` (`0` if compiled with `-fno-exceptions`). + +- **`FMT_USE_LOCALE`**: When set to `0`, disables locale support. + Default: `1` (`0` when `FMT_OPTIMIZE_SIZE > 1`). + +- **`FMT_CUSTOM_ASSERT_FAIL`**: When set to `1`, allows users to provide a + custom `fmt::assert_fail` function which is called on assertion failures and, + if exceptions are disabled, on runtime errors. Default: `0`. + +- **`FMT_BUILTIN_TYPES`**: When set to `0`, disables built-in handling of + arithmetic and string types other than `int`. This reduces library size at + the cost of per-call overhead. Default: `1`. + +- **`FMT_OPTIMIZE_SIZE`**: Controls binary size optimizations: + - `0` - off (default) + - `1` - disables locale support and applies some optimizations + - `2` - disables some Unicode features, named arguments and applies more + aggresive optimizations + +### Binary Size Optimization + +To minimize the binary footprint of {fmt} as much as possible at the cost of +some features, you can use the following configuration: + +- CMake options: + - `FMT_OS=OFF` +- Macros: + - `FMT_BUILTIN_TYPES=0` + - `FMT_OPTIMIZE_SIZE=2` diff --git a/thirdparty/fmt/doc/syntax.md b/thirdparty/fmt/doc/syntax.md index 46d7d2fd2..ac5128233 100644 --- a/thirdparty/fmt/doc/syntax.md +++ b/thirdparty/fmt/doc/syntax.md @@ -251,7 +251,7 @@ The available integer presentation types are: <td><code>'b'</code></td> <td> Binary format. Outputs the number in base 2. Using the <code>'#'</code> - option with this type adds the prefix <code>"0b"</code> to the output value. + option with this type adds the prefix <code>"0b"</code> to the output value. </td> </tr> <tr> @@ -718,7 +718,7 @@ These modifiers are only supported for the `'H'`, `'I'`, `'M'`, `'S'`, `'U'`, Format specifications for range types have the following syntax: <pre><code class="language-json" ->range_format_spec ::= ["n"][range_type][range_underlying_spec]</code> +>range_format_spec ::= ["n"][range_type][":" range_underlying_spec]</code> </pre> The `'n'` option formats the range without the opening and closing brackets. @@ -761,14 +761,16 @@ fmt::print("{::}", std::vector{'h', 'e', 'l', 'l', 'o'}); // Output: [h, e, l, l, o] fmt::print("{::d}", std::vector{'h', 'e', 'l', 'l', 'o'}); // Output: [104, 101, 108, 108, 111] +fmt::print("{:n:f}", std::array{std::numbers::pi, std::numbers::e}); +// Output: 3.141593, 2.718282 ``` ## Format Examples This section contains examples of the format syntax and comparison with -the printf formatting. +the `printf` formatting. -In most of the cases the syntax is similar to the printf formatting, +In most of the cases the syntax is similar to the `printf` formatting, with the addition of the `{}` and with `:` used instead of `%`. For example, `"%03.2f"` can be translated to `"{:03.2f}"`. diff --git a/thirdparty/fmt/include/fmt/base.h b/thirdparty/fmt/include/fmt/base.h index 42e192aca..0d5786778 100644 --- a/thirdparty/fmt/include/fmt/base.h +++ b/thirdparty/fmt/include/fmt/base.h @@ -21,7 +21,7 @@ #endif // The fmt library version in the form major * 10000 + minor * 100 + patch. -#define FMT_VERSION 120000 +#define FMT_VERSION 120100 // Detect compiler versions. #if defined(__clang__) && !defined(__ibmxl__) @@ -114,7 +114,9 @@ #endif // Detect consteval, C++20 constexpr extensions and std::is_constant_evaluated. -#if !defined(__cpp_lib_is_constant_evaluated) +#ifdef FMT_USE_CONSTEVAL +// Use the provided definition. +#elif !defined(__cpp_lib_is_constant_evaluated) # define FMT_USE_CONSTEVAL 0 #elif FMT_CPLUSPLUS < 201709L # define FMT_USE_CONSTEVAL 0 @@ -234,6 +236,7 @@ FMT_PRAGMA_GCC(optimize("Og")) # define FMT_GCC_OPTIMIZED #endif FMT_PRAGMA_CLANG(diagnostic push) +FMT_PRAGMA_GCC(diagnostic push) #ifdef FMT_ALWAYS_INLINE // Use the provided definition. @@ -414,8 +417,12 @@ inline auto map(int128_opt) -> monostate { return {}; } inline auto map(uint128_opt) -> monostate { return {}; } #endif -#ifndef FMT_USE_BITINT -# define FMT_USE_BITINT (FMT_CLANG_VERSION >= 1500) +#ifdef FMT_USE_BITINT +// Use the provided definition. +#elif FMT_CLANG_VERSION >= 1500 && !defined(__CUDACC__) +# define FMT_USE_BITINT 1 +#else +# define FMT_USE_BITINT 0 #endif #if FMT_USE_BITINT @@ -918,7 +925,10 @@ class locale_ref { constexpr locale_ref() : locale_(nullptr) {} template <typename Locale, FMT_ENABLE_IF(sizeof(Locale::collate) != 0)> - locale_ref(const Locale& loc); + locale_ref(const Locale& loc) : locale_(&loc) { + // Check if std::isalpha is found via ADL to reduce the chance of misuse. + isalpha('x', loc); + } inline explicit operator bool() const noexcept { return locale_ != nullptr; } #endif // FMT_USE_LOCALE @@ -1844,12 +1854,17 @@ template <typename T> class buffer { void append(const U* begin, const U* end) { while (begin != end) { + auto size = size_; + auto free_cap = capacity_ - size; auto count = to_unsigned(end - begin); - try_reserve(size_ + count); - auto free_cap = capacity_ - size_; - if (free_cap < count) count = free_cap; + if (free_cap < count) { + grow_(*this, size + count); + size = size_; + free_cap = capacity_ - size; + count = count < free_cap ? count : free_cap; + } // A loop is faster than memcpy on small sizes. - T* out = ptr_ + size_; + T* out = ptr_ + size; for (size_t i = 0; i < count; ++i) out[i] = begin[i]; size_ += count; begin += count; @@ -2983,6 +2998,7 @@ FMT_INLINE void println(format_string<T...> fmt, T&&... args) { return fmt::println(stdout, fmt, static_cast<T&&>(args)...); } +FMT_PRAGMA_GCC(diagnostic pop) FMT_PRAGMA_CLANG(diagnostic pop) FMT_PRAGMA_GCC(pop_options) FMT_END_EXPORT diff --git a/thirdparty/fmt/include/fmt/chrono.h b/thirdparty/fmt/include/fmt/chrono.h index a788d3ecf..9fbeeed67 100644 --- a/thirdparty/fmt/include/fmt/chrono.h +++ b/thirdparty/fmt/include/fmt/chrono.h @@ -1594,8 +1594,13 @@ class get_locale { public: inline get_locale(bool localized, locale_ref loc) : has_locale_(localized) { - if (localized) - ::new (&locale_) std::locale(loc.template get<std::locale>()); + if (!localized) return; + ignore_unused(loc); + ::new (&locale_) std::locale( +#if FMT_USE_LOCALE + loc.template get<std::locale>() +#endif + ); } inline ~get_locale() { if (has_locale_) locale_.~locale(); diff --git a/thirdparty/fmt/include/fmt/color.h b/thirdparty/fmt/include/fmt/color.h index b69c14886..2cbc53ca3 100644 --- a/thirdparty/fmt/include/fmt/color.h +++ b/thirdparty/fmt/include/fmt/color.h @@ -429,7 +429,7 @@ template <typename Char> struct ansi_color_escape { private: static constexpr size_t num_emphases = 8; - Char buffer[7u + 4u * num_emphases]; + Char buffer[7u + 4u * num_emphases] = {}; size_t size = 0; static FMT_CONSTEXPR void to_esc(uint8_t c, Char* out, diff --git a/thirdparty/fmt/include/fmt/compile.h b/thirdparty/fmt/include/fmt/compile.h index f711ba41e..64eb7a20d 100644 --- a/thirdparty/fmt/include/fmt/compile.h +++ b/thirdparty/fmt/include/fmt/compile.h @@ -15,9 +15,10 @@ #include "format.h" FMT_BEGIN_NAMESPACE +FMT_BEGIN_EXPORT // A compile-time string which is compiled into fast formatting code. -FMT_EXPORT class compiled_string {}; +class compiled_string {}; template <typename S> struct is_compiled_string : std::is_base_of<compiled_string, S> {}; @@ -59,6 +60,8 @@ template <detail::fixed_string Str> constexpr auto operator""_cf() { } // namespace literals #endif +FMT_END_EXPORT + namespace detail { template <typename T, typename... Tail> diff --git a/thirdparty/fmt/include/fmt/format-inl.h b/thirdparty/fmt/include/fmt/format-inl.h index 9d568dca1..945cb912a 100644 --- a/thirdparty/fmt/include/fmt/format-inl.h +++ b/thirdparty/fmt/include/fmt/format-inl.h @@ -36,7 +36,7 @@ FMT_BEGIN_NAMESPACE FMT_FUNC void assert_fail(const char* file, int line, const char* message) { // Use unchecked std::fprintf to avoid triggering another assertion when // writing to stderr fails. - fprintf(stderr, "%s:%d: assertion failed: %s", file, line, message); + std::fprintf(stderr, "%s:%d: assertion failed: %s", file, line, message); abort(); } #endif @@ -47,11 +47,6 @@ using std::locale; using std::numpunct; using std::use_facet; } // namespace detail - -template <typename Locale, enable_if_t<(sizeof(Locale::collate) != 0), int>> -locale_ref::locale_ref(const Locale& loc) : locale_(&loc) { - static_assert(std::is_same<Locale, std::locale>::value, ""); -} #else namespace detail { struct locale {}; diff --git a/thirdparty/fmt/include/fmt/format.h b/thirdparty/fmt/include/fmt/format.h index c3a1bda09..4a6530072 100644 --- a/thirdparty/fmt/include/fmt/format.h +++ b/thirdparty/fmt/include/fmt/format.h @@ -40,11 +40,18 @@ #include "base.h" +// libc++ supports string_view in pre-c++17. +#if FMT_HAS_INCLUDE(<string_view>) && \ + (FMT_CPLUSPLUS >= 201703L || defined(_LIBCPP_VERSION)) +# define FMT_USE_STRING_VIEW +#endif + #ifndef FMT_MODULE +# include <stdlib.h> // malloc, free + # include <cmath> // std::signbit # include <cstddef> // std::byte # include <cstdint> // uint32_t -# include <cstdlib> // std::malloc, std::free # include <cstring> // std::memcpy # include <limits> // std::numeric_limits # include <new> // std::bad_alloc @@ -61,11 +68,8 @@ # include <bit> // std::bit_cast # endif -// libc++ supports string_view in pre-c++17. -# if FMT_HAS_INCLUDE(<string_view>) && \ - (FMT_CPLUSPLUS >= 201703L || defined(_LIBCPP_VERSION)) +# if defined(FMT_USE_STRING_VIEW) # include <string_view> -# define FMT_USE_STRING_VIEW # endif # if FMT_MSC_VERSION @@ -744,12 +748,12 @@ template <typename T> struct allocator : private std::decay<void> { auto allocate(size_t n) -> T* { FMT_ASSERT(n <= max_value<size_t>() / sizeof(T), ""); - T* p = static_cast<T*>(std::malloc(n * sizeof(T))); + T* p = static_cast<T*>(malloc(n * sizeof(T))); if (!p) FMT_THROW(std::bad_alloc()); return p; } - void deallocate(T* p, size_t) { std::free(p); } + void deallocate(T* p, size_t) { free(p); } constexpr friend auto operator==(allocator, allocator) noexcept -> bool { return true; // All instances of this allocator are equivalent. @@ -759,6 +763,14 @@ template <typename T> struct allocator : private std::decay<void> { } }; +template <typename Formatter> +FMT_CONSTEXPR auto maybe_set_debug_format(Formatter& f, bool set) + -> decltype(f.set_debug_format(set)) { + f.set_debug_format(set); +} +template <typename Formatter> +FMT_CONSTEXPR void maybe_set_debug_format(Formatter&, ...) {} + } // namespace detail FMT_BEGIN_EXPORT @@ -2506,7 +2518,7 @@ FMT_CONSTEXPR20 auto write_fixed(OutputIt out, const DecimalFP& f, auto grouping = Grouping(loc, specs.localized()); size += grouping.count_separators(exp); return write_padded<Char, align::right>( - out, specs, to_unsigned(size), [&](iterator it) { + out, specs, static_cast<size_t>(size), [&](iterator it) { if (s != sign::none) *it++ = detail::getsign<Char>(s); it = write_significand<Char>(it, f.significand, significand_size, f.exponent, grouping); diff --git a/thirdparty/fmt/include/fmt/os.h b/thirdparty/fmt/include/fmt/os.h index 40cdcdd4f..94d730de2 100644 --- a/thirdparty/fmt/include/fmt/os.h +++ b/thirdparty/fmt/include/fmt/os.h @@ -136,10 +136,9 @@ FMT_API std::system_error vwindows_error(int error_code, string_view fmt, * **Example**: * * // This throws a system_error with the description - * // cannot open file 'madeup': The system cannot find the file - * specified. - * // or similar (system message may vary). - * const char *filename = "madeup"; + * // cannot open file 'foo': The system cannot find the file specified. + * // or similar (system message may vary) if the file doesn't exist. + * const char *filename = "foo"; * LPOFSTRUCT of = LPOFSTRUCT(); * HFILE file = OpenFile(filename, &of, OF_READ); * if (file == HFILE_ERROR) { @@ -365,17 +364,17 @@ FMT_INLINE_VARIABLE constexpr auto buffer_size = detail::buffer_size(); /// A fast buffered output stream for writing from a single thread. Writing from /// multiple threads without external synchronization may result in a data race. -class FMT_API ostream : private detail::buffer<char> { +class ostream : private detail::buffer<char> { private: file file_; - ostream(cstring_view path, const detail::ostream_params& params); + FMT_API ostream(cstring_view path, const detail::ostream_params& params); - static void grow(buffer<char>& buf, size_t); + FMT_API static void grow(buffer<char>& buf, size_t); public: - ostream(ostream&& other) noexcept; - ~ostream(); + FMT_API ostream(ostream&& other) noexcept; + FMT_API ~ostream(); operator writer() { detail::buffer<char>& buf = *this; diff --git a/thirdparty/fmt/include/fmt/ranges.h b/thirdparty/fmt/include/fmt/ranges.h index 24c61e93b..36b38e296 100644 --- a/thirdparty/fmt/include/fmt/ranges.h +++ b/thirdparty/fmt/include/fmt/ranges.h @@ -18,6 +18,13 @@ #include "format.h" +#if FMT_HAS_CPP_ATTRIBUTE(clang::lifetimebound) +# define FMT_LIFETIMEBOUND [[clang::lifetimebound]] +#else +# define FMT_LIFETIMEBOUND +#endif +FMT_PRAGMA_CLANG(diagnostic error "-Wreturn-stack-address") + FMT_BEGIN_NAMESPACE FMT_EXPORT @@ -234,14 +241,6 @@ using range_reference_type = template <typename Range> using uncvref_type = remove_cvref_t<range_reference_type<Range>>; -template <typename Formatter> -FMT_CONSTEXPR auto maybe_set_debug_format(Formatter& f, bool set) - -> decltype(f.set_debug_format(set)) { - f.set_debug_format(set); -} -template <typename Formatter> -FMT_CONSTEXPR void maybe_set_debug_format(Formatter&, ...) {} - template <typename T> struct range_format_kind_ : std::integral_constant<range_format, @@ -821,12 +820,12 @@ auto join(Range&& r, string_view sep) * * **Example**: * - * auto t = std::tuple<int, char>{1, 'a'}; + * auto t = std::tuple<int, char>(1, 'a'); * fmt::print("{}", fmt::join(t, ", ")); * // Output: 1, a */ template <typename Tuple, FMT_ENABLE_IF(is_tuple_like<Tuple>::value)> -FMT_CONSTEXPR auto join(const Tuple& tuple, string_view sep) +FMT_CONSTEXPR auto join(const Tuple& tuple FMT_LIFETIMEBOUND, string_view sep) -> tuple_join_view<Tuple, char> { return {tuple, sep}; } diff --git a/thirdparty/fmt/include/fmt/std.h b/thirdparty/fmt/include/fmt/std.h index 5cf106181..184c6d26d 100644 --- a/thirdparty/fmt/include/fmt/std.h +++ b/thirdparty/fmt/include/fmt/std.h @@ -111,12 +111,17 @@ void write_escaped_path(basic_memory_buffer<Char>& quoted, #endif // FMT_CPP_LIB_FILESYSTEM #if defined(__cpp_lib_expected) || FMT_CPP_LIB_VARIANT -template <typename Char, typename OutputIt, typename T> -auto write_escaped_alternative(OutputIt out, const T& v) -> OutputIt { + +template <typename Char, typename OutputIt, typename T, typename FormatContext> +auto write_escaped_alternative(OutputIt out, const T& v, FormatContext& ctx) + -> OutputIt { if constexpr (has_to_string_view<T>::value) return write_escaped_string<Char>(out, detail::to_string_view(v)); if constexpr (std::is_same_v<T, Char>) return write_escaped_char(out, v); - return write<Char>(out, v); + + formatter<std::remove_cv_t<T>, Char> underlying; + maybe_set_debug_format(underlying, true); + return underlying.format(v, ctx); } #endif @@ -139,50 +144,39 @@ template <typename Variant, typename Char> class is_variant_formattable { #endif // FMT_CPP_LIB_VARIANT #if FMT_USE_RTTI - -template <typename OutputIt> -auto write_demangled_name(OutputIt out, const std::type_info& ti) -> OutputIt { -# ifdef FMT_HAS_ABI_CXA_DEMANGLE - int status = 0; - size_t size = 0; - std::unique_ptr<char, void (*)(void*)> demangled_name_ptr( - abi::__cxa_demangle(ti.name(), nullptr, &size, &status), &std::free); - - string_view demangled_name_view; - if (demangled_name_ptr) { - demangled_name_view = demangled_name_ptr.get(); - - // Normalization of stdlib inline namespace names. - // libc++ inline namespaces. - // std::__1::* -> std::* - // std::__1::__fs::* -> std::* - // libstdc++ inline namespaces. - // std::__cxx11::* -> std::* - // std::filesystem::__cxx11::* -> std::filesystem::* - if (demangled_name_view.starts_with("std::")) { - char* begin = demangled_name_ptr.get(); - char* to = begin + 5; // std:: - for (char *from = to, *end = begin + demangled_name_view.size(); - from < end;) { - // This is safe, because demangled_name is NUL-terminated. - if (from[0] == '_' && from[1] == '_') { - char* next = from + 1; - while (next < end && *next != ':') next++; - if (next[0] == ':' && next[1] == ':') { - from = next + 2; - continue; - } +inline auto normalize_libcxx_inline_namespaces(string_view demangled_name_view, + char* begin) -> string_view { + // Normalization of stdlib inline namespace names. + // libc++ inline namespaces. + // std::__1::* -> std::* + // std::__1::__fs::* -> std::* + // libstdc++ inline namespaces. + // std::__cxx11::* -> std::* + // std::filesystem::__cxx11::* -> std::filesystem::* + if (demangled_name_view.starts_with("std::")) { + char* to = begin + 5; // std:: + for (const char *from = to, *end = begin + demangled_name_view.size(); + from < end;) { + // This is safe, because demangled_name is NUL-terminated. + if (from[0] == '_' && from[1] == '_') { + const char* next = from + 1; + while (next < end && *next != ':') next++; + if (next[0] == ':' && next[1] == ':') { + from = next + 2; + continue; } - *to++ = *from++; } - demangled_name_view = {begin, detail::to_unsigned(to - begin)}; + *to++ = *from++; } - } else { - demangled_name_view = string_view(ti.name()); + demangled_name_view = {begin, detail::to_unsigned(to - begin)}; } - return detail::write_bytes<char>(out, demangled_name_view); -# elif FMT_MSC_VERSION - const string_view demangled_name(ti.name()); + return demangled_name_view; +} + +template <class OutputIt> +auto normalize_msvc_abi_name(string_view abi_name_view, OutputIt out) + -> OutputIt { + const string_view demangled_name(abi_name_view); for (size_t i = 0; i < demangled_name.size(); ++i) { auto sub = demangled_name; sub.remove_prefix(i); @@ -201,6 +195,39 @@ auto write_demangled_name(OutputIt out, const std::type_info& ti) -> OutputIt { if (*sub.begin() != ' ') *out++ = *sub.begin(); } return out; +} + +template <typename OutputIt> +auto write_demangled_name(OutputIt out, const std::type_info& ti) -> OutputIt { +# ifdef FMT_HAS_ABI_CXA_DEMANGLE + int status = 0; + size_t size = 0; + std::unique_ptr<char, void (*)(void*)> demangled_name_ptr( + abi::__cxa_demangle(ti.name(), nullptr, &size, &status), &free); + + string_view demangled_name_view; + if (demangled_name_ptr) { + demangled_name_view = normalize_libcxx_inline_namespaces( + demangled_name_ptr.get(), demangled_name_ptr.get()); + } else { + demangled_name_view = string_view(ti.name()); + } + return detail::write_bytes<char>(out, demangled_name_view); +# elif FMT_MSC_VERSION && defined(_MSVC_STL_UPDATE) + return normalize_msvc_abi_name(ti.name(), out); +# elif FMT_MSC_VERSION && defined(_LIBCPP_VERSION) + const string_view demangled_name = ti.name(); + std::string name_copy(demangled_name.size(), '\0'); + // normalize_msvc_abi_name removes class, struct, union etc that MSVC has in + // front of types + name_copy.erase(normalize_msvc_abi_name(demangled_name, name_copy.begin()), + name_copy.end()); + // normalize_libcxx_inline_namespaces removes the inline __1, __2, etc + // namespaces libc++ uses for ABI versioning On MSVC ABI + libc++ + // environments, we need to eliminate both of them. + const string_view normalized_name = + normalize_libcxx_inline_namespaces(name_copy, name_copy.data()); + return detail::write_bytes<char>(out, normalized_name); # else return detail::write_bytes<char>(out, string_view(ti.name())); # endif @@ -255,21 +282,6 @@ template <typename T> auto ptr(const std::shared_ptr<T>& p) -> const void* { #if FMT_CPP_LIB_FILESYSTEM -class path : public std::filesystem::path { - public: - auto display_string() const -> std::string { - const std::filesystem::path& base = *this; - return fmt::format(FMT_STRING("{}"), base); - } - auto system_string() const -> std::string { return string(); } - - auto generic_display_string() const -> std::string { - const std::filesystem::path& base = *this; - return fmt::format(FMT_STRING("{:g}"), base); - } - auto generic_system_string() const -> std::string { return generic_string(); } -}; - template <typename Char> struct formatter<std::filesystem::path, Char> { private: format_specs specs_; @@ -319,6 +331,21 @@ template <typename Char> struct formatter<std::filesystem::path, Char> { } }; +class path : public std::filesystem::path { + public: + auto display_string() const -> std::string { + const std::filesystem::path& base = *this; + return fmt::format(FMT_STRING("{}"), base); + } + auto system_string() const -> std::string { return string(); } + + auto generic_display_string() const -> std::string { + const std::filesystem::path& base = *this; + return fmt::format(FMT_STRING("{:g}"), base); + } + auto generic_system_string() const -> std::string { return generic_string(); } +}; + #endif // FMT_CPP_LIB_FILESYSTEM template <size_t N, typename Char> @@ -353,25 +380,16 @@ template <typename T, typename Char> struct formatter<std::optional<T>, Char, std::enable_if_t<is_formattable<T, Char>::value>> { private: - formatter<T, Char> underlying_; + formatter<std::remove_cv_t<T>, Char> underlying_; static constexpr basic_string_view<Char> optional = detail::string_literal<Char, 'o', 'p', 't', 'i', 'o', 'n', 'a', 'l', '('>{}; static constexpr basic_string_view<Char> none = detail::string_literal<Char, 'n', 'o', 'n', 'e'>{}; - template <class U> - FMT_CONSTEXPR static auto maybe_set_debug_format(U& u, bool set) - -> decltype(u.set_debug_format(set)) { - u.set_debug_format(set); - } - - template <class U> - FMT_CONSTEXPR static void maybe_set_debug_format(U&, ...) {} - public: FMT_CONSTEXPR auto parse(parse_context<Char>& ctx) { - maybe_set_debug_format(underlying_, true); + detail::maybe_set_debug_format(underlying_, true); return underlying_.parse(ctx); } @@ -407,10 +425,10 @@ struct formatter<std::expected<T, E>, Char, if (value.has_value()) { out = detail::write<Char>(out, "expected("); if constexpr (!std::is_void<T>::value) - out = detail::write_escaped_alternative<Char>(out, *value); + out = detail::write_escaped_alternative<Char>(out, *value, ctx); } else { out = detail::write<Char>(out, "unexpected("); - out = detail::write_escaped_alternative<Char>(out, value.error()); + out = detail::write_escaped_alternative<Char>(out, value.error(), ctx); } *out++ = ')'; return out; @@ -474,7 +492,7 @@ struct formatter<Variant, Char, FMT_TRY { std::visit( [&](const auto& v) { - out = detail::write_escaped_alternative<Char>(out, v); + out = detail::write_escaped_alternative<Char>(out, v, ctx); }, value); } @@ -495,6 +513,8 @@ template <> struct formatter<std::error_code> { bool debug_ = false; public: + FMT_CONSTEXPR void set_debug_format(bool set = true) { debug_ = set; } + FMT_CONSTEXPR auto parse(parse_context<>& ctx) -> const char* { auto it = ctx.begin(), end = ctx.end(); if (it == end) return it; diff --git a/thirdparty/fmt/src/format.cc b/thirdparty/fmt/src/format.cc index 05d0105bc..526082e34 100644 --- a/thirdparty/fmt/src/format.cc +++ b/thirdparty/fmt/src/format.cc @@ -10,7 +10,7 @@ FMT_BEGIN_NAMESPACE #if FMT_USE_LOCALE -template FMT_API locale_ref::locale_ref(const std::locale& loc); +template FMT_API locale_ref::locale_ref(const std::locale& loc); // DEPRECATED! template FMT_API auto locale_ref::get<std::locale>() const -> std::locale; #endif diff --git a/thirdparty/fmt/support/mkdocs b/thirdparty/fmt/support/mkdocs index 610d81d67..94eddae3f 100755 --- a/thirdparty/fmt/support/mkdocs +++ b/thirdparty/fmt/support/mkdocs @@ -2,6 +2,10 @@ # A script to invoke mkdocs with the correct environment. # Additionally supports deploying via mike: # ./mkdocs deploy [mike-deploy-options] +# For example: +# ./mkdocs deploy <version> +# This will checkout the website to fmt/build/fmt.dev and deploy documentation +# <version> there. import errno, os, shutil, sys from subprocess import call @@ -40,7 +44,7 @@ config_path = os.path.join(support_dir, 'mkdocs.yml') args = sys.argv[1:] if len(args) > 0: command = args[0] - if command == 'deploy': + if command == 'deploy' or command == 'set-default': git_url = 'https://github.com/' if 'CI' in os.environ else '[email protected]:' site_repo = git_url + 'fmtlib/fmt.dev.git' @@ -64,14 +68,18 @@ if len(args) > 0: if ret != 0 or version == 'dev': sys.exit(ret) current_doc_path = os.path.join(site_dir, version) - os.makedirs(current_doc_path, exist_ok=True) - redirect_page_path = os.path.join(current_doc_path, 'api.html') - with open(redirect_page_path, "w") as file: - file.write(redirect_page) - ret = call(['git', 'add', redirect_page_path], cwd=site_dir) - if ret != 0: - sys.exit(ret) - ret = call(['git', 'commit', '--amend', '--no-edit'], cwd=site_dir) + # mike stages files added by deploy for deletion for unclear reason, + # undo it. + ret = call(['git', 'reset', '--hard'], cwd=site_dir) + if False: + os.makedirs(current_doc_path, exist_ok=True) + redirect_page_path = os.path.join(current_doc_path, 'api.html') + with open(redirect_page_path, "w") as file: + file.write(redirect_page) + ret = call(['git', 'add', redirect_page_path], cwd=site_dir) + if ret != 0: + sys.exit(ret) + ret = call(['git', 'commit', '--amend', '--no-edit'], cwd=site_dir) sys.exit(ret) elif not command.startswith('-'): args += ['-f', config_path] diff --git a/thirdparty/fmt/test/add-subdirectory-test/main.cc b/thirdparty/fmt/test/add-subdirectory-test/main.cc deleted file mode 100644 index 1d31cb905..000000000 --- a/thirdparty/fmt/test/add-subdirectory-test/main.cc +++ /dev/null @@ -1,5 +0,0 @@ -#include "fmt/base.h" - -int main(int argc, char** argv) { - for (int i = 0; i < argc; ++i) fmt::print("{}: {}\n", i, argv[i]); -} diff --git a/thirdparty/fmt/test/args-test.cc b/thirdparty/fmt/test/args-test.cc deleted file mode 100644 index dd0e57dca..000000000 --- a/thirdparty/fmt/test/args-test.cc +++ /dev/null @@ -1,202 +0,0 @@ -// Formatting library for C++ - dynamic argument store tests -// -// Copyright (c) 2012 - present, Victor Zverovich -// All rights reserved. -// -// For the license information refer to format.h. - -#include "fmt/args.h" - -#include <memory> - -#include "gtest/gtest.h" - -TEST(args_test, basic) { - fmt::dynamic_format_arg_store<fmt::format_context> store; - store.push_back(42); - store.push_back("abc1"); - store.push_back(1.5f); - EXPECT_EQ("42 and abc1 and 1.5", fmt::vformat("{} and {} and {}", store)); -} - -TEST(args_test, strings_and_refs) { - // Unfortunately the tests are compiled with old ABI so strings use COW. - fmt::dynamic_format_arg_store<fmt::format_context> store; - char str[] = "1234567890"; - store.push_back(str); - store.push_back(std::cref(str)); - store.push_back(fmt::string_view{str}); - str[0] = 'X'; - - auto result = fmt::vformat("{} and {} and {}", store); - EXPECT_EQ("1234567890 and X234567890 and X234567890", result); -} - -struct custom_type { - int i = 0; -}; - -FMT_BEGIN_NAMESPACE -template <> struct formatter<custom_type> { - auto parse(format_parse_context& ctx) -> decltype(ctx.begin()) { - return ctx.begin(); - } - - template <typename FormatContext> - auto format(const custom_type& p, FormatContext& ctx) const - -> decltype(ctx.out()) { - return fmt::format_to(ctx.out(), "cust={}", p.i); - } -}; -FMT_END_NAMESPACE - -TEST(args_test, custom_format) { - fmt::dynamic_format_arg_store<fmt::format_context> store; - auto c = custom_type(); - store.push_back(c); - ++c.i; - store.push_back(c); - ++c.i; - store.push_back(std::cref(c)); - ++c.i; - auto result = fmt::vformat("{} and {} and {}", store); - EXPECT_EQ("cust=0 and cust=1 and cust=3", result); -} - -struct to_stringable { - friend auto to_string_view(to_stringable) -> fmt::string_view { return {}; } -}; - -FMT_BEGIN_NAMESPACE -template <> struct formatter<to_stringable> { - auto parse(format_parse_context& ctx) -> decltype(ctx.begin()) { - return ctx.begin(); - } - - auto format(to_stringable, format_context& ctx) const -> decltype(ctx.out()) { - return ctx.out(); - } -}; -FMT_END_NAMESPACE - -TEST(args_test, to_string_and_formatter) { - fmt::dynamic_format_arg_store<fmt::format_context> store; - auto s = to_stringable(); - store.push_back(s); - store.push_back(std::cref(s)); - fmt::vformat("", store); -} - -TEST(args_test, named_int) { - fmt::dynamic_format_arg_store<fmt::format_context> store; - store.push_back(fmt::arg("a1", 42)); - EXPECT_EQ("42", fmt::vformat("{a1}", store)); -} - -TEST(args_test, named_strings) { - fmt::dynamic_format_arg_store<fmt::format_context> store; - char str[] = "1234567890"; - store.push_back(fmt::arg("a1", str)); - store.push_back(fmt::arg("a2", std::cref(str))); - str[0] = 'X'; - EXPECT_EQ("1234567890 and X234567890", fmt::vformat("{a1} and {a2}", store)); -} - -TEST(args_test, named_arg_by_ref) { - fmt::dynamic_format_arg_store<fmt::format_context> store; - char band[] = "Rolling Stones"; - store.push_back(fmt::arg("band", std::cref(band))); - band[9] = 'c'; // Changing band affects the output. - EXPECT_EQ(fmt::vformat("{band}", store), "Rolling Scones"); -} - -TEST(args_test, named_custom_format) { - fmt::dynamic_format_arg_store<fmt::format_context> store; - auto c = custom_type(); - store.push_back(fmt::arg("c1", c)); - ++c.i; - store.push_back(fmt::arg("c2", c)); - ++c.i; - store.push_back(fmt::arg("c_ref", std::cref(c))); - ++c.i; - auto result = fmt::vformat("{c1} and {c2} and {c_ref}", store); - EXPECT_EQ("cust=0 and cust=1 and cust=3", result); -} - -TEST(args_test, clear) { - fmt::dynamic_format_arg_store<fmt::format_context> store; - store.push_back(42); - - auto result = fmt::vformat("{}", store); - EXPECT_EQ("42", result); - - store.push_back(43); - result = fmt::vformat("{} and {}", store); - EXPECT_EQ("42 and 43", result); - - store.clear(); - store.push_back(44); - result = fmt::vformat("{}", store); - EXPECT_EQ("44", result); -} - -TEST(args_test, reserve) { - fmt::dynamic_format_arg_store<fmt::format_context> store; - store.reserve(2, 1); - store.push_back(1.5f); - store.push_back(fmt::arg("a", 42)); - auto result = fmt::vformat("{} and {a}", store); - EXPECT_EQ("1.5 and 42", result); -} - -struct copy_throwable { - copy_throwable() {} - copy_throwable(const copy_throwable&) { throw "deal with it"; } -}; - -FMT_BEGIN_NAMESPACE -template <> struct formatter<copy_throwable> { - auto parse(format_parse_context& ctx) -> decltype(ctx.begin()) { - return ctx.begin(); - } - auto format(copy_throwable, format_context& ctx) const - -> decltype(ctx.out()) { - return ctx.out(); - } -}; -FMT_END_NAMESPACE - -TEST(args_test, throw_on_copy) { - fmt::dynamic_format_arg_store<fmt::format_context> store; - store.push_back(std::string("foo")); - try { - store.push_back(copy_throwable()); - } catch (...) { - } - EXPECT_EQ(fmt::vformat("{}", store), "foo"); -} - -TEST(args_test, move_constructor) { - using store_type = fmt::dynamic_format_arg_store<fmt::format_context>; - auto store = std::unique_ptr<store_type>(new store_type()); - store->push_back(42); - store->push_back(std::string("foo")); - store->push_back(fmt::arg("a1", "foo")); - auto moved_store = std::move(*store); - store.reset(); - EXPECT_EQ(fmt::vformat("{} {} {a1}", moved_store), "42 foo foo"); -} - -TEST(args_test, size) { - fmt::dynamic_format_arg_store<fmt::format_context> store; - EXPECT_EQ(store.size(), 0); - - store.push_back(42); - EXPECT_EQ(store.size(), 1); - - store.push_back("Molybdenum"); - EXPECT_EQ(store.size(), 2); - - store.clear(); - EXPECT_EQ(store.size(), 0); -} diff --git a/thirdparty/fmt/test/assert-test.cc b/thirdparty/fmt/test/assert-test.cc deleted file mode 100644 index 368fb5878..000000000 --- a/thirdparty/fmt/test/assert-test.cc +++ /dev/null @@ -1,31 +0,0 @@ -// Formatting library for C++ - FMT_ASSERT test -// -// It is a separate test to minimize the number of EXPECT_DEBUG_DEATH checks -// which are slow on some platforms. In other tests FMT_ASSERT is made to throw -// an exception which is much faster and easier to check. -// -// Copyright (c) 2012 - present, Victor Zverovich -// All rights reserved. -// -// For the license information refer to format.h. - -#include "fmt/base.h" -#include "gtest/gtest.h" - -TEST(assert_test, fail) { -#if GTEST_HAS_DEATH_TEST - EXPECT_DEBUG_DEATH(FMT_ASSERT(false, "don't panic!"), "don't panic!"); -#else - fmt::print("warning: death tests are not supported\n"); -#endif -} - -TEST(assert_test, dangling_else) { - bool test_condition = false; - bool executed_else = false; - if (test_condition) - FMT_ASSERT(true, ""); - else - executed_else = true; - EXPECT_TRUE(executed_else); -} diff --git a/thirdparty/fmt/test/base-test.cc b/thirdparty/fmt/test/base-test.cc deleted file mode 100644 index 0231e422d..000000000 --- a/thirdparty/fmt/test/base-test.cc +++ /dev/null @@ -1,911 +0,0 @@ -// Formatting library for C++ - core tests -// -// Copyright (c) 2012 - present, Victor Zverovich -// All rights reserved. -// -// For the license information refer to format.h. - -// Turn assertion failures into exceptions for testing. -// clang-format off -#include "test-assert.h" -// clang-format on - -#include "fmt/base.h" - -#include <limits.h> // INT_MAX -#include <string.h> // strlen - -#include <functional> // std::equal_to -#include <iterator> // std::back_insert_iterator, std::distance -#include <limits> // std::numeric_limits -#include <string> // std::string -#include <type_traits> // std::is_same - -#include "gmock/gmock.h" - -#ifdef FMT_FORMAT_H_ -# error base-test includes format.h -#endif - -using testing::_; -using testing::Invoke; -using testing::Return; - -auto copy(fmt::string_view s, fmt::appender out) -> fmt::appender { - for (char c : s) *out++ = c; - return out; -} - -TEST(string_view_test, value_type) { - static_assert(std::is_same<fmt::string_view::value_type, char>::value, ""); -} - -TEST(string_view_test, ctor) { - EXPECT_STREQ(fmt::string_view("abc").data(), "abc"); - EXPECT_EQ(fmt::string_view("abc").size(), 3u); - - EXPECT_STREQ(fmt::string_view(std::string("defg")).data(), "defg"); - EXPECT_EQ(fmt::string_view(std::string("defg")).size(), 4u); -} - -TEST(string_view_test, length) { - // Test that string_view::size() returns string length, not buffer size. - char str[100] = "some string"; - EXPECT_EQ(fmt::string_view(str).size(), strlen(str)); - EXPECT_LT(strlen(str), sizeof(str)); -} - -// Check string_view's comparison operator. -template <template <typename> class Op> void check_op() { - const char* inputs[] = {"foo", "fop", "fo"}; - size_t num_inputs = sizeof(inputs) / sizeof(*inputs); - for (size_t i = 0; i < num_inputs; ++i) { - for (size_t j = 0; j < num_inputs; ++j) { - fmt::string_view lhs(inputs[i]), rhs(inputs[j]); - EXPECT_EQ(Op<int>()(lhs.compare(rhs), 0), - Op<fmt::string_view>()(lhs, rhs)); - } - } -} - -TEST(string_view_test, compare) { - using fmt::string_view; - - EXPECT_EQ(string_view("foo").compare(string_view("foo")), 0); - EXPECT_GT(string_view("fop").compare(string_view("foo")), 0); - EXPECT_LT(string_view("foo").compare(string_view("fop")), 0); - EXPECT_GT(string_view("foo").compare(string_view("fo")), 0); - EXPECT_LT(string_view("fo").compare(string_view("foo")), 0); - - EXPECT_TRUE(string_view("foo").starts_with('f')); - EXPECT_FALSE(string_view("foo").starts_with('o')); - EXPECT_FALSE(string_view().starts_with('o')); - - EXPECT_TRUE(string_view("foo").starts_with("fo")); - EXPECT_TRUE(string_view("foo").starts_with("foo")); - EXPECT_FALSE(string_view("foo").starts_with("fooo")); - EXPECT_FALSE(string_view().starts_with("fooo")); - - check_op<std::equal_to>(); - check_op<std::not_equal_to>(); - check_op<std::less>(); - check_op<std::less_equal>(); - check_op<std::greater>(); - check_op<std::greater_equal>(); -} - -#if FMT_USE_CONSTEVAL -TEST(string_view_test, from_constexpr_fixed_string) { - constexpr int size = 4; - - struct fixed_string { - char data[size] = {}; - - constexpr fixed_string(const char (&m)[size]) { - for (size_t i = 0; i != size; ++i) data[i] = m[i]; - } - }; - - static constexpr auto fs = fixed_string("foo"); - static constexpr auto sv = fmt::string_view(fs.data); - EXPECT_EQ(sv, "foo"); -} -#endif // FMT_USE_CONSTEVAL - -TEST(buffer_test, noncopyable) { - EXPECT_FALSE(std::is_copy_constructible<fmt::detail::buffer<char>>::value); - EXPECT_FALSE(std::is_copy_assignable<fmt::detail::buffer<char>>::value); -} - -TEST(buffer_test, nonmoveable) { - EXPECT_FALSE(std::is_move_constructible<fmt::detail::buffer<char>>::value); - EXPECT_FALSE(std::is_move_assignable<fmt::detail::buffer<char>>::value); -} - -TEST(buffer_test, indestructible) { - static_assert(!std::is_destructible<fmt::detail::buffer<int>>(), - "buffer's destructor is protected"); -} - -template <typename T> struct mock_buffer final : fmt::detail::buffer<T> { - MOCK_METHOD(size_t, do_grow, (size_t)); - - static void grow(fmt::detail::buffer<T>& buf, size_t capacity) { - auto& self = static_cast<mock_buffer&>(buf); - self.set(buf.data(), self.do_grow(capacity)); - } - - mock_buffer(T* data = nullptr, size_t buf_capacity = 0) - : fmt::detail::buffer<T>(grow) { - this->set(data, buf_capacity); - ON_CALL(*this, do_grow(_)).WillByDefault(Invoke([](size_t capacity) { - return capacity; - })); - } -}; - -TEST(buffer_test, ctor) { - { - mock_buffer<int> buffer; - EXPECT_EQ(buffer.data(), nullptr); - EXPECT_EQ(buffer.size(), 0u); - EXPECT_EQ(buffer.capacity(), 0u); - } - { - int data; - mock_buffer<int> buffer(&data); - EXPECT_EQ(&buffer[0], &data); - EXPECT_EQ(buffer.size(), 0u); - EXPECT_EQ(buffer.capacity(), 0u); - } - { - int data; - size_t capacity = std::numeric_limits<size_t>::max(); - mock_buffer<int> buffer(&data, capacity); - EXPECT_EQ(&buffer[0], &data); - EXPECT_EQ(buffer.size(), 0u); - EXPECT_EQ(buffer.capacity(), capacity); - } -} - -TEST(buffer_test, access) { - char data[10]; - mock_buffer<char> buffer(data, sizeof(data)); - buffer[0] = 11; - EXPECT_EQ(buffer[0], 11); - buffer[3] = 42; - EXPECT_EQ(*(&buffer[0] + 3), 42); - const fmt::detail::buffer<char>& const_buffer = buffer; - EXPECT_EQ(const_buffer[3], 42); -} - -TEST(buffer_test, try_resize) { - char data[123]; - mock_buffer<char> buffer(data, sizeof(data)); - buffer[10] = 42; - EXPECT_EQ(buffer[10], 42); - buffer.try_resize(20); - EXPECT_EQ(buffer.size(), 20u); - EXPECT_EQ(buffer.capacity(), 123u); - EXPECT_EQ(buffer[10], 42); - buffer.try_resize(5); - EXPECT_EQ(buffer.size(), 5u); - EXPECT_EQ(buffer.capacity(), 123u); - EXPECT_EQ(buffer[10], 42); - // Check if try_resize calls grow. - EXPECT_CALL(buffer, do_grow(124)); - buffer.try_resize(124); - EXPECT_CALL(buffer, do_grow(200)); - buffer.try_resize(200); -} - -TEST(buffer_test, try_resize_partial) { - char data[10]; - mock_buffer<char> buffer(data, sizeof(data)); - EXPECT_CALL(buffer, do_grow(20)).WillOnce(Return(15)); - buffer.try_resize(20); - EXPECT_EQ(buffer.capacity(), 15); - EXPECT_EQ(buffer.size(), 15); -} - -TEST(buffer_test, clear) { - mock_buffer<char> buffer; - EXPECT_CALL(buffer, do_grow(20)); - buffer.try_resize(20); - buffer.try_resize(0); - EXPECT_EQ(buffer.size(), 0u); - EXPECT_EQ(buffer.capacity(), 20u); -} - -TEST(buffer_test, append) { - char data[15]; - mock_buffer<char> buffer(data, 10); - auto test = "test"; - buffer.append(test, test + 5); - EXPECT_STREQ(&buffer[0], test); - EXPECT_EQ(buffer.size(), 5u); - buffer.try_resize(10); - EXPECT_CALL(buffer, do_grow(12)); - buffer.append(test, test + 2); - EXPECT_EQ(buffer[10], 't'); - EXPECT_EQ(buffer[11], 'e'); - EXPECT_EQ(buffer.size(), 12u); -} - -TEST(buffer_test, append_partial) { - char data[10]; - mock_buffer<char> buffer(data, sizeof(data)); - testing::InSequence seq; - EXPECT_CALL(buffer, do_grow(15)).WillOnce(Return(10)); - EXPECT_CALL(buffer, do_grow(15)).WillOnce(Invoke([&buffer](size_t) { - EXPECT_EQ(fmt::string_view(buffer.data(), buffer.size()), "0123456789"); - buffer.clear(); - return 10; - })); - auto test = "0123456789abcde"; - buffer.append(test, test + 15); -} - -TEST(buffer_test, append_allocates_enough_storage) { - char data[19]; - mock_buffer<char> buffer(data, 10); - auto test = "abcdefgh"; - buffer.try_resize(10); - EXPECT_CALL(buffer, do_grow(19)); - buffer.append(test, test + 9); -} - -TEST(base_test, is_locking) { - EXPECT_FALSE(fmt::detail::is_locking<const char(&)[3]>()); -} - -TEST(base_test, is_output_iterator) { - EXPECT_TRUE((fmt::detail::is_output_iterator<char*, char>::value)); - EXPECT_FALSE((fmt::detail::is_output_iterator<const char*, char>::value)); - EXPECT_FALSE((fmt::detail::is_output_iterator<std::string, char>::value)); - EXPECT_TRUE( - (fmt::detail::is_output_iterator<std::back_insert_iterator<std::string>, - char>::value)); - EXPECT_TRUE( - (fmt::detail::is_output_iterator<std::string::iterator, char>::value)); - EXPECT_FALSE((fmt::detail::is_output_iterator<std::string::const_iterator, - char>::value)); -} - -TEST(base_test, is_back_insert_iterator) { - EXPECT_TRUE(fmt::detail::is_back_insert_iterator< - std::back_insert_iterator<std::string>>::value); - EXPECT_FALSE(fmt::detail::is_back_insert_iterator< - std::front_insert_iterator<std::string>>::value); -} - -struct minimal_container { - using value_type = char; - void push_back(char) {} -}; - -TEST(base_test, copy) { - minimal_container c; - static constexpr char str[] = "a"; - fmt::detail::copy<char>(str, str + 1, std::back_inserter(c)); -} - -TEST(base_test, get_buffer) { - mock_buffer<char> buffer; - void* buffer_ptr = &buffer; - auto&& appender_result = fmt::detail::get_buffer<char>(fmt::appender(buffer)); - EXPECT_EQ(&appender_result, buffer_ptr); - auto&& back_inserter_result = - fmt::detail::get_buffer<char>(std::back_inserter(buffer)); - EXPECT_EQ(&back_inserter_result, buffer_ptr); -} - -struct test_struct {}; - -FMT_BEGIN_NAMESPACE -template <typename Char> struct formatter<test_struct, Char> { - FMT_CONSTEXPR auto parse(format_parse_context& ctx) -> decltype(ctx.begin()) { - return ctx.begin(); - } - - auto format(test_struct, format_context& ctx) const -> decltype(ctx.out()) { - return copy("test", ctx.out()); - } -}; -FMT_END_NAMESPACE - -// Use a unique result type to make sure that there are no undesirable -// conversions. -struct test_result {}; - -template <typename T> struct mock_visitor { - template <typename U> struct result { - using type = test_result; - }; - - mock_visitor() { - ON_CALL(*this, visit(_)).WillByDefault(Return(test_result())); - } - - MOCK_METHOD(test_result, visit, (T)); - MOCK_METHOD(void, unexpected, ()); - - auto operator()(T value) -> test_result { return visit(value); } - - template <typename U> auto operator()(U) -> test_result { - unexpected(); - return test_result(); - } -}; - -template <typename T> struct visit_type { - using type = T; -}; - -#define VISIT_TYPE(type_, visit_type_) \ - template <> struct visit_type<type_> { \ - using type = visit_type_; \ - } - -VISIT_TYPE(signed char, int); -VISIT_TYPE(unsigned char, unsigned); -VISIT_TYPE(short, int); -VISIT_TYPE(unsigned short, unsigned); - -#if LONG_MAX == INT_MAX -VISIT_TYPE(long, int); -VISIT_TYPE(unsigned long, unsigned); -#else -VISIT_TYPE(long, long long); -VISIT_TYPE(unsigned long, unsigned long long); -#endif - -#if FMT_BUILTIN_TYPES -# define CHECK_ARG(expected, value) \ - { \ - testing::StrictMock<mock_visitor<decltype(expected)>> visitor; \ - EXPECT_CALL(visitor, visit(expected)); \ - auto var = value; \ - fmt::basic_format_arg<fmt::format_context>(var).visit(visitor); \ - } -#else -# define CHECK_ARG(expected, value) -#endif - -#define CHECK_ARG_SIMPLE(value) \ - { \ - using value_type = decltype(value); \ - typename visit_type<value_type>::type expected = value; \ - CHECK_ARG(expected, value) \ - } - -TEST(arg_test, format_args) { - auto args = fmt::format_args(); - EXPECT_FALSE(args.get(1)); -} - -TEST(arg_test, char_arg) { CHECK_ARG('a', 'a'); } - -TEST(arg_test, string_arg) { - char str_data[] = "test"; - char* str = str_data; - const char* cstr = str; - CHECK_ARG(cstr, str); - - auto sv = fmt::string_view(str); - CHECK_ARG(sv, std::string(str)); -} - -TEST(arg_test, pointer_arg) { - void* p = nullptr; - const void* cp = nullptr; - CHECK_ARG(cp, p); - CHECK_ARG_SIMPLE(cp); -} - -TEST(arg_test, volatile_pointer_arg) { - const void* p = nullptr; - volatile int* vip = nullptr; - const volatile int* cvip = nullptr; - CHECK_ARG(p, static_cast<volatile void*>(vip)); - CHECK_ARG(p, static_cast<const volatile void*>(cvip)); -} - -struct check_custom { - auto operator()(fmt::basic_format_arg<fmt::format_context>::handle h) const - -> test_result { - struct test_buffer final : fmt::detail::buffer<char> { - char data[10]; - test_buffer() - : fmt::detail::buffer<char>([](buffer<char>&, size_t) {}, data, 0, - 10) {} - } buffer; - auto parse_ctx = fmt::format_parse_context(""); - auto ctx = fmt::format_context(fmt::appender(buffer), fmt::format_args()); - h.format(parse_ctx, ctx); - EXPECT_EQ(std::string(buffer.data, buffer.size()), "test"); - return test_result(); - } -}; - -TEST(arg_test, custom_arg) { - auto test = test_struct(); - using visitor = - mock_visitor<fmt::basic_format_arg<fmt::format_context>::handle>; - auto&& v = testing::StrictMock<visitor>(); - EXPECT_CALL(v, visit(_)).WillOnce(Invoke(check_custom())); - fmt::basic_format_arg<fmt::format_context>(test).visit(v); -} - -TEST(arg_test, visit_invalid_arg) { - auto&& visitor = testing::StrictMock<mock_visitor<fmt::monostate>>(); - EXPECT_CALL(visitor, visit(_)); - fmt::basic_format_arg<fmt::format_context>().visit(visitor); -} - -template <typename T> class numeric_arg_test : public testing::Test {}; - -#if FMT_BUILTIN_TYPES -using test_types = - testing::Types<bool, signed char, unsigned char, short, unsigned short, int, - unsigned, long, unsigned long, long long, unsigned long long, - float, double, long double>; -#else -using test_types = testing::Types<int>; -#endif -TYPED_TEST_SUITE(numeric_arg_test, test_types); - -template <typename T, fmt::enable_if_t<std::is_integral<T>::value, int> = 0> -auto test_value() -> T { - return static_cast<T>(42); -} - -template <typename T, - fmt::enable_if_t<std::is_floating_point<T>::value, int> = 0> -auto test_value() -> T { - return static_cast<T>(4.2); -} - -TYPED_TEST(numeric_arg_test, make_and_visit) { - CHECK_ARG_SIMPLE(test_value<TypeParam>()); - CHECK_ARG_SIMPLE(std::numeric_limits<TypeParam>::min()); - CHECK_ARG_SIMPLE(std::numeric_limits<TypeParam>::max()); -} - -#if FMT_USE_CONSTEXPR - -enum class arg_id_result { none, index, name }; - -struct test_arg_id_handler { - arg_id_result res = arg_id_result::none; - int index = 0; - fmt::string_view name; - - constexpr void on_index(int i) { - res = arg_id_result::index; - index = i; - } - - constexpr void on_name(fmt::string_view n) { - res = arg_id_result::name; - name = n; - } -}; - -template <size_t N> -constexpr auto parse_arg_id(const char (&s)[N]) -> test_arg_id_handler { - auto h = test_arg_id_handler(); - fmt::detail::parse_arg_id(s, s + N, h); - return h; -} - -TEST(base_test, constexpr_parse_arg_id) { - static_assert(parse_arg_id("42:").res == arg_id_result::index, ""); - static_assert(parse_arg_id("42:").index == 42, ""); - static_assert(parse_arg_id("foo:").res == arg_id_result::name, ""); - static_assert(parse_arg_id("foo:").name.size() == 3, ""); -} - -template <size_t N> constexpr auto parse_test_specs(const char (&s)[N]) { - auto ctx = fmt::detail::compile_parse_context<char>(fmt::string_view(s, N), - 43, nullptr); - auto specs = fmt::detail::dynamic_format_specs<>(); - fmt::detail::parse_format_specs(s, s + N - 1, specs, ctx, - fmt::detail::type::float_type); - return specs; -} - -TEST(base_test, constexpr_parse_format_specs) { - static_assert(parse_test_specs("<").align() == fmt::align::left, ""); - static_assert(parse_test_specs("*^").fill_unit<char>() == '*', ""); - static_assert(parse_test_specs("+").sign() == fmt::sign::plus, ""); - static_assert(parse_test_specs("-").sign() == fmt::sign::none, ""); - static_assert(parse_test_specs(" ").sign() == fmt::sign::space, ""); - static_assert(parse_test_specs("#").alt(), ""); - static_assert(parse_test_specs("0").align() == fmt::align::numeric, ""); - static_assert(parse_test_specs("L").localized(), ""); - static_assert(parse_test_specs("42").width == 42, ""); - static_assert(parse_test_specs("{42}").width_ref.index == 42, ""); - static_assert(parse_test_specs(".42").precision == 42, ""); - static_assert(parse_test_specs(".{42}").precision_ref.index == 42, ""); - static_assert(parse_test_specs("f").type() == fmt::presentation_type::fixed, - ""); -} - -struct test_format_string_handler { - constexpr void on_text(const char*, const char*) {} - - constexpr auto on_arg_id() -> int { return 0; } - - template <typename T> constexpr auto on_arg_id(T) -> int { return 0; } - - constexpr void on_replacement_field(int, const char*) {} - - constexpr auto on_format_specs(int, const char* begin, const char*) -> const - char* { - return begin; - } - - constexpr void on_error(const char*) { error = true; } - - bool error = false; -}; - -template <size_t N> constexpr auto parse_string(const char (&s)[N]) -> bool { - auto h = test_format_string_handler(); - fmt::detail::parse_format_string(fmt::string_view(s, N - 1), h); - return !h.error; -} - -TEST(base_test, constexpr_parse_format_string) { - static_assert(parse_string("foo"), ""); - static_assert(!parse_string("}"), ""); - static_assert(parse_string("{}"), ""); - static_assert(parse_string("{42}"), ""); - static_assert(parse_string("{foo}"), ""); - static_assert(parse_string("{:}"), ""); -} - -#endif // FMT_USE_CONSTEXPR - -struct enabled_formatter {}; -struct enabled_ptr_formatter {}; -struct disabled_formatter {}; -struct disabled_formatter_convertible { - operator int() const { return 42; } -}; - -FMT_BEGIN_NAMESPACE -template <> struct formatter<enabled_formatter> { - FMT_CONSTEXPR auto parse(format_parse_context& ctx) -> decltype(ctx.begin()) { - return ctx.begin(); - } - auto format(enabled_formatter, format_context& ctx) const - -> decltype(ctx.out()) { - return ctx.out(); - } -}; - -template <> struct formatter<enabled_ptr_formatter*> { - FMT_CONSTEXPR auto parse(format_parse_context& ctx) -> decltype(ctx.begin()) { - return ctx.begin(); - } - auto format(enabled_ptr_formatter*, format_context& ctx) const - -> decltype(ctx.out()) { - return ctx.out(); - } -}; -FMT_END_NAMESPACE - -struct const_formattable {}; -struct nonconst_formattable {}; - -FMT_BEGIN_NAMESPACE -template <> struct formatter<const_formattable> { - FMT_CONSTEXPR auto parse(format_parse_context& ctx) -> decltype(ctx.begin()) { - return ctx.begin(); - } - - auto format(const const_formattable&, format_context& ctx) const - -> decltype(ctx.out()) { - return copy("test", ctx.out()); - } -}; - -template <> struct formatter<nonconst_formattable> { - FMT_CONSTEXPR auto parse(format_parse_context& ctx) -> decltype(ctx.begin()) { - return ctx.begin(); - } - - auto format(nonconst_formattable&, format_context& ctx) const - -> decltype(ctx.out()) { - return copy("test", ctx.out()); - } -}; -FMT_END_NAMESPACE - -struct convertible_to_pointer { - operator const int*() const { return nullptr; } -}; - -struct convertible_to_pointer_formattable { - operator const int*() const { return nullptr; } -}; - -FMT_BEGIN_NAMESPACE -template <> struct formatter<convertible_to_pointer_formattable> { - FMT_CONSTEXPR auto parse(format_parse_context& ctx) -> decltype(ctx.begin()) { - return ctx.begin(); - } - - auto format(convertible_to_pointer_formattable, format_context& ctx) const - -> decltype(ctx.out()) { - return copy("test", ctx.out()); - } -}; -FMT_END_NAMESPACE - -enum class unformattable_scoped_enum {}; - -TEST(base_test, is_formattable) { - EXPECT_FALSE(fmt::is_formattable<void>::value); - EXPECT_FALSE(fmt::is_formattable<wchar_t>::value); -#ifdef __cpp_char8_t - EXPECT_FALSE(fmt::is_formattable<char8_t>::value); -#endif - EXPECT_FALSE(fmt::is_formattable<char16_t>::value); - EXPECT_FALSE(fmt::is_formattable<char32_t>::value); - EXPECT_FALSE(fmt::is_formattable<signed char*>::value); - EXPECT_FALSE(fmt::is_formattable<unsigned char*>::value); - EXPECT_FALSE(fmt::is_formattable<const signed char*>::value); - EXPECT_FALSE(fmt::is_formattable<const unsigned char*>::value); - EXPECT_FALSE(fmt::is_formattable<const wchar_t*>::value); - EXPECT_FALSE(fmt::is_formattable<const wchar_t[3]>::value); - EXPECT_FALSE(fmt::is_formattable<fmt::basic_string_view<wchar_t>>::value); - EXPECT_FALSE(fmt::is_formattable<enabled_ptr_formatter*>::value); - EXPECT_FALSE(fmt::is_formattable<disabled_formatter>::value); - EXPECT_FALSE(fmt::is_formattable<disabled_formatter_convertible>::value); - - EXPECT_TRUE(fmt::is_formattable<enabled_formatter>::value); - EXPECT_TRUE(fmt::is_formattable<const_formattable&>::value); - EXPECT_TRUE(fmt::is_formattable<const const_formattable&>::value); - - EXPECT_TRUE(fmt::is_formattable<nonconst_formattable&>::value); - EXPECT_FALSE(fmt::is_formattable<const nonconst_formattable&>::value); - - EXPECT_FALSE(fmt::is_formattable<convertible_to_pointer>::value); - const auto f = convertible_to_pointer_formattable(); - auto str = std::string(); - fmt::format_to(std::back_inserter(str), "{}", f); - EXPECT_EQ(str, "test"); - - EXPECT_FALSE(fmt::is_formattable<void (*)()>::value); - - struct s; - EXPECT_FALSE(fmt::is_formattable<int(s::*)>::value); - EXPECT_FALSE(fmt::is_formattable<int (s::*)()>::value); - EXPECT_FALSE(fmt::is_formattable<unformattable_scoped_enum>::value); - EXPECT_FALSE(fmt::is_formattable<unformattable_scoped_enum>::value); -} - -#ifdef __cpp_concepts -TEST(base_test, formattable_concept) { - static_assert(fmt::formattable<char>); - static_assert(fmt::formattable<char&>); - static_assert(fmt::formattable<char&&>); - static_assert(fmt::formattable<const char>); - static_assert(fmt::formattable<const char&>); - static_assert(fmt::formattable<const char&&>); - static_assert(fmt::formattable<int>); - static_assert(!fmt::formattable<wchar_t>); -} -#endif - -TEST(base_test, format_to) { - auto s = std::string(); - fmt::format_to(std::back_inserter(s), "{}", 42); - EXPECT_EQ(s, "42"); -} - -TEST(base_test, format_to_array) { - char buffer[4]; - auto result = fmt::format_to(buffer, "{}", 12345); - EXPECT_EQ(std::distance(&buffer[0], result.out), 4); - EXPECT_TRUE(result.truncated); - EXPECT_EQ(result.out, buffer + 4); - EXPECT_EQ(fmt::string_view(buffer, 4), "1234"); - - char* out = nullptr; - EXPECT_THROW(out = result, std::runtime_error); - (void)out; - - result = fmt::format_to(buffer, "{:s}", "foobar"); - EXPECT_EQ(std::distance(&buffer[0], result.out), 4); - EXPECT_TRUE(result.truncated); - EXPECT_EQ(result.out, buffer + 4); - EXPECT_EQ(fmt::string_view(buffer, 4), "foob"); - - buffer[0] = 'x'; - buffer[1] = 'x'; - buffer[2] = 'x'; - buffer[3] = 'x'; - result = fmt::format_to(buffer, "{}", 'A'); - EXPECT_EQ(std::distance(&buffer[0], result.out), 1); - EXPECT_FALSE(result.truncated); - EXPECT_EQ(result.out, buffer + 1); - EXPECT_EQ(fmt::string_view(buffer, 4), "Axxx"); - - result = fmt::format_to(buffer, "{}{} ", 'B', 'C'); - EXPECT_EQ(std::distance(&buffer[0], result.out), 3); - EXPECT_FALSE(result.truncated); - EXPECT_EQ(result.out, buffer + 3); - EXPECT_EQ(fmt::string_view(buffer, 4), "BC x"); - - result = fmt::format_to(buffer, "{}", "ABCDE"); - EXPECT_EQ(std::distance(&buffer[0], result.out), 4); - EXPECT_TRUE(result.truncated); - EXPECT_EQ(fmt::string_view(buffer, 4), "ABCD"); - - result = fmt::format_to(buffer, "{}", std::string(1000, '*').c_str()); - EXPECT_EQ(std::distance(&buffer[0], result.out), 4); - EXPECT_TRUE(result.truncated); - EXPECT_EQ(fmt::string_view(buffer, 4), "****"); -} - -// Test that check is not found by ADL. -template <typename T> void check(T); -TEST(base_test, adl_check) { - auto s = std::string(); - fmt::format_to(std::back_inserter(s), "{}", test_struct()); - EXPECT_EQ(s, "test"); -} - -struct implicitly_convertible_to_string_view { - operator fmt::string_view() const { return "foo"; } -}; - -TEST(base_test, no_implicit_conversion_to_string_view) { - EXPECT_FALSE( - fmt::is_formattable<implicitly_convertible_to_string_view>::value); -} - -struct explicitly_convertible_to_string_view { - explicit operator fmt::string_view() const { return "foo"; } -}; - -TEST(base_test, format_explicitly_convertible_to_string_view) { - // Types explicitly convertible to string_view are not formattable by - // default because it may introduce ODR violations. - static_assert( - !fmt::is_formattable<explicitly_convertible_to_string_view>::value, ""); -} - -#if FMT_CPLUSPLUS >= 201703L -struct implicitly_convertible_to_std_string_view { - operator std::string_view() const { return "foo"; } -}; - -TEST(base_test, no_implicit_conversion_to_std_string_view) { - EXPECT_FALSE( - fmt::is_formattable<implicitly_convertible_to_std_string_view>::value); -} - -struct explicitly_convertible_to_std_string_view { - explicit operator std::string_view() const { return "foo"; } -}; - -TEST(base_test, format_explicitly_convertible_to_std_string_view) { - // Types explicitly convertible to string_view are not formattable by - // default because it may introduce ODR violations. - static_assert( - !fmt::is_formattable<explicitly_convertible_to_std_string_view>::value, - ""); -} -#endif // FMT_CPLUSPLUS >= 201703L - -TEST(base_test, has_formatter) { - EXPECT_TRUE((fmt::detail::has_formatter<const const_formattable, char>())); - EXPECT_FALSE( - (fmt::detail::has_formatter<const nonconst_formattable, char>())); -} - -TEST(base_test, format_nonconst) { - auto s = std::string(); - fmt::format_to(std::back_inserter(s), "{}", nonconst_formattable()); - EXPECT_EQ(s, "test"); -} - -TEST(base_test, throw_in_buffer_dtor) { - constexpr int buffer_size = 256; - - struct throwing_iterator { - int& count; - - auto operator=(char) -> throwing_iterator& { - if (++count > buffer_size) throw std::exception(); - return *this; - } - auto operator*() -> throwing_iterator& { return *this; } - auto operator++() -> throwing_iterator& { return *this; } - auto operator++(int) -> throwing_iterator { return *this; } - }; - - try { - int count = 0; - fmt::format_to(throwing_iterator{count}, fmt::runtime("{:{}}{"), "", - buffer_size + 1); - } catch (const std::exception&) { - } -} - -struct convertible_to_any_type_with_member_x { - template <typename T> operator T() const { - auto v = T(); - v.x = 42; - return v; - } -}; - -FMT_BEGIN_NAMESPACE -template <> struct formatter<convertible_to_any_type_with_member_x> { - FMT_CONSTEXPR auto parse(format_parse_context& ctx) -> decltype(ctx.begin()) { - return ctx.begin(); - } - - auto format(convertible_to_any_type_with_member_x, format_context& ctx) const - -> decltype(ctx.out()) const { - auto out = ctx.out(); - *out++ = 'x'; - return out; - } -}; -FMT_END_NAMESPACE - -TEST(base_test, promiscuous_conversions) { - auto s = std::string(); - fmt::format_to(std::back_inserter(s), "{}", - convertible_to_any_type_with_member_x()); - EXPECT_EQ(s, "x"); -} - -struct custom_container { - char data; - - using value_type = char; - - auto size() const -> size_t { return 0; } - void resize(size_t) {} - - void push_back(char) {} - auto operator[](size_t) -> char& { return data; } -}; - -FMT_BEGIN_NAMESPACE -template <> struct is_contiguous<custom_container> : std::true_type {}; -FMT_END_NAMESPACE - -TEST(base_test, format_to_custom_container) { - auto c = custom_container(); - fmt::format_to(std::back_inserter(c), ""); -} - -TEST(base_test, no_repeated_format_string_conversions) { - struct nondeterministic_format_string { - mutable int i = 0; - FMT_CONSTEXPR operator fmt::string_view() const { - return {"{}", i++ != 0 ? 2u : 0u}; - } - }; - -#if !FMT_GCC_VERSION || FMT_GCC_VERSION >= 1200 - char buf[10]; - fmt::format_to(buf, nondeterministic_format_string()); -#endif -} - -TEST(base_test, format_context_accessors) { - auto copy = [](fmt::appender app, const fmt::format_context& ctx) { - return fmt::format_context(app, ctx.args(), ctx.locale()); - }; - fmt::detail::ignore_unused(copy); -} diff --git a/thirdparty/fmt/test/chrono-test.cc b/thirdparty/fmt/test/chrono-test.cc deleted file mode 100644 index 98b37000b..000000000 --- a/thirdparty/fmt/test/chrono-test.cc +++ /dev/null @@ -1,1023 +0,0 @@ -// Formatting library for C++ - time formatting tests -// -// Copyright (c) 2012 - present, Victor Zverovich -// All rights reserved. -// -// For the license information refer to format.h. - -#include "fmt/chrono.h" - -#include <algorithm> -#include <ctime> -#include <vector> - -#include "gtest-extra.h" // EXPECT_THROW_MSG -#include "util.h" // get_locale - -using fmt::runtime; -using fmt::sys_time; -using testing::Contains; - -#if defined(__MINGW32__) && !defined(_UCRT) -// Only C89 conversion specifiers when using MSVCRT instead of UCRT -# define FMT_HAS_C99_STRFTIME 0 -#else -# define FMT_HAS_C99_STRFTIME 1 -#endif - -#if defined(__cpp_lib_chrono) && __cpp_lib_chrono >= 201907L -using days = std::chrono::days; -#else -using days = std::chrono::duration<std::chrono::hours::rep, std::ratio<86400>>; -#endif - -auto make_tm() -> std::tm { - auto time = std::tm(); - time.tm_mday = 1; - return time; -} - -auto make_hour(int h) -> std::tm { - auto time = make_tm(); - time.tm_hour = h; - return time; -} - -auto make_minute(int m) -> std::tm { - auto time = make_tm(); - time.tm_min = m; - return time; -} - -auto make_second(int s) -> std::tm { - auto time = make_tm(); - time.tm_sec = s; - return time; -} - -auto system_strftime(const std::string& format, const std::tm* timeptr, - std::locale* locptr = nullptr) -> std::string { - auto loc = locptr ? *locptr : std::locale::classic(); - auto& facet = std::use_facet<std::time_put<char>>(loc); - std::ostringstream os; - os.imbue(loc); - facet.put(os, os, ' ', timeptr, format.c_str(), - format.c_str() + format.size()); -#ifdef _WIN32 - // Workaround a bug in older versions of Universal CRT. - auto str = os.str(); - if (str == "-0000") str = "+0000"; - return str; -#else - return os.str(); -#endif -} - -FMT_CONSTEXPR auto make_tm(int year, int mon, int mday, int hour, int min, - int sec) -> std::tm { - auto tm = std::tm(); - tm.tm_sec = sec; - tm.tm_min = min; - tm.tm_hour = hour; - tm.tm_mday = mday; - tm.tm_mon = mon - 1; - tm.tm_year = year - 1900; - return tm; -} - -TEST(chrono_test, format_tm) { - auto tm = std::tm(); - tm.tm_year = 116; - tm.tm_mon = 3; - tm.tm_mday = 25; - tm.tm_hour = 11; - tm.tm_min = 22; - tm.tm_sec = 33; - EXPECT_EQ(fmt::format("The date is {:%Y-%m-%d %H:%M:%S}.", tm), - "The date is 2016-04-25 11:22:33."); - EXPECT_EQ(fmt::format("{:%Y}", tm), "2016"); - EXPECT_EQ(fmt::format("{:%C}", tm), "20"); - EXPECT_EQ(fmt::format("{:%C%y}", tm), fmt::format("{:%Y}", tm)); - EXPECT_EQ(fmt::format("{:%e}", tm), "25"); - EXPECT_EQ(fmt::format("{:%D}", tm), "04/25/16"); - EXPECT_EQ(fmt::format("{:%F}", tm), "2016-04-25"); - EXPECT_EQ(fmt::format("{:%T}", tm), "11:22:33"); - - // Short year - tm.tm_year = 999 - 1900; - tm.tm_mon = 0; // for %G - tm.tm_mday = 2; // for %G - tm.tm_wday = 3; // for %G - tm.tm_yday = 1; // for %G - EXPECT_EQ(fmt::format("{:%Y}", tm), "0999"); - EXPECT_EQ(fmt::format("{:%C%y}", tm), "0999"); - EXPECT_EQ(fmt::format("{:%G}", tm), "0999"); - - tm.tm_year = 27 - 1900; - EXPECT_EQ(fmt::format("{:%Y}", tm), "0027"); - EXPECT_EQ(fmt::format("{:%C%y}", tm), "0027"); - - // Overflow year - tm.tm_year = 2147483647; - EXPECT_EQ(fmt::format("{:%Y}", tm), "2147485547"); - - tm.tm_year = -2147483648; - EXPECT_EQ(fmt::format("{:%Y}", tm), "-2147481748"); - - // for week on the year - // https://www.cl.cam.ac.uk/~mgk25/iso-time.html - std::vector<std::tm> tm_list = { - make_tm(1975, 12, 29, 12, 14, 16), // W01 - make_tm(1977, 1, 2, 12, 14, 16), // W53 - make_tm(1999, 12, 27, 12, 14, 16), // W52 - make_tm(1999, 12, 31, 12, 14, 16), // W52 - make_tm(2000, 1, 1, 12, 14, 16), // W52 - make_tm(2000, 1, 2, 12, 14, 16), // W52 - make_tm(2000, 1, 3, 12, 14, 16) // W1 - }; - -#if !FMT_HAS_C99_STRFTIME - GTEST_SKIP() << "Skip the rest of this test because it relies on strftime() " - "conforming to C99, but on this platform, MINGW + MSVCRT, " - "the function conforms only to C89."; -#endif - - const std::string iso_week_spec = "%Y-%m-%d: %G %g %V"; - for (auto ctm : tm_list) { - // Calculate tm_yday, tm_wday, etc. - std::time_t t = std::mktime(&ctm); - tm = *std::localtime(&t); - - auto fmt_spec = fmt::format("{{:{}}}", iso_week_spec); - EXPECT_EQ(system_strftime(iso_week_spec, &tm), - fmt::format(fmt::runtime(fmt_spec), tm)); - } - - // Every day from 1970-01-01 - std::time_t time_now = std::time(nullptr); - for (std::time_t t = 6 * 3600; t < time_now; t += 86400) { - tm = *std::localtime(&t); - - auto fmt_spec = fmt::format("{{:{}}}", iso_week_spec); - EXPECT_EQ(system_strftime(iso_week_spec, &tm), - fmt::format(fmt::runtime(fmt_spec), tm)); - } -} - -// MSVC: -// minkernel\crts\ucrt\src\appcrt\time\wcsftime.cpp(971) : Assertion failed: -// timeptr->tm_year >= -1900 && timeptr->tm_year <= 8099 -#ifndef _WIN32 -TEST(chrono_test, format_tm_future) { - auto tm = std::tm(); - tm.tm_year = 10445; // 10000+ years - tm.tm_mon = 3; - tm.tm_mday = 25; - tm.tm_hour = 11; - tm.tm_min = 22; - tm.tm_sec = 33; - EXPECT_EQ(fmt::format("The date is {:%Y-%m-%d %H:%M:%S}.", tm), - "The date is 12345-04-25 11:22:33."); - EXPECT_EQ(fmt::format("{:%Y}", tm), "12345"); - EXPECT_EQ(fmt::format("{:%C}", tm), "123"); - EXPECT_EQ(fmt::format("{:%C%y}", tm), fmt::format("{:%Y}", tm)); - EXPECT_EQ(fmt::format("{:%D}", tm), "04/25/45"); - EXPECT_EQ(fmt::format("{:%F}", tm), "12345-04-25"); - EXPECT_EQ(fmt::format("{:%T}", tm), "11:22:33"); -} - -TEST(chrono_test, format_tm_past) { - auto tm = std::tm(); - tm.tm_year = -2001; - tm.tm_mon = 3; - tm.tm_mday = 25; - tm.tm_hour = 11; - tm.tm_min = 22; - tm.tm_sec = 33; - EXPECT_EQ(fmt::format("The date is {:%Y-%m-%d %H:%M:%S}.", tm), - "The date is -101-04-25 11:22:33."); - EXPECT_EQ(fmt::format("{:%Y}", tm), "-101"); - - // macOS %C - "-1" - // Linux %C - "-2" - // fmt %C - "-1" - EXPECT_EQ(fmt::format("{:%C}", tm), "-1"); - EXPECT_EQ(fmt::format("{:%C%y}", tm), fmt::format("{:%Y}", tm)); - - // macOS %D - "04/25/01" (%y) - // Linux %D - "04/25/99" (%y) - // fmt %D - "04/25/01" (%y) - EXPECT_EQ(fmt::format("{:%D}", tm), "04/25/01"); - - EXPECT_EQ(fmt::format("{:%F}", tm), "-101-04-25"); - EXPECT_EQ(fmt::format("{:%T}", tm), "11:22:33"); - - tm.tm_year = -1901; // -1 - EXPECT_EQ(fmt::format("{:%Y}", tm), "-001"); - EXPECT_EQ(fmt::format("{:%C%y}", tm), fmt::format("{:%Y}", tm)); - - tm.tm_year = -1911; // -11 - EXPECT_EQ(fmt::format("{:%Y}", tm), "-011"); - EXPECT_EQ(fmt::format("{:%C%y}", tm), fmt::format("{:%Y}", tm)); -} -#endif - -TEST(chrono_test, grow_buffer) { - auto s = std::string("{:"); - for (int i = 0; i < 30; ++i) s += "%c"; - s += "}\n"; - auto t = std::time(nullptr); - (void)fmt::format(fmt::runtime(s), *std::localtime(&t)); -} - -TEST(chrono_test, format_to_empty_container) { - auto time = std::tm(); - time.tm_sec = 42; - auto s = std::string(); - fmt::format_to(std::back_inserter(s), "{:%S}", time); - EXPECT_EQ(s, "42"); -} - -TEST(chrono_test, gmtime) { - auto t = std::time(nullptr); - auto expected = *std::gmtime(&t); - auto actual = fmt::gmtime(t); - EXPECT_EQ(actual.tm_sec, expected.tm_sec); - EXPECT_EQ(actual.tm_min, expected.tm_min); - EXPECT_EQ(actual.tm_hour, expected.tm_hour); - EXPECT_EQ(actual.tm_mday, expected.tm_mday); - EXPECT_EQ(actual.tm_mon, expected.tm_mon); - EXPECT_EQ(actual.tm_year, expected.tm_year); - EXPECT_EQ(actual.tm_wday, expected.tm_wday); - EXPECT_EQ(actual.tm_yday, expected.tm_yday); - EXPECT_EQ(actual.tm_isdst, expected.tm_isdst); -} - -template <typename Time> void test_time(Time time) { - EXPECT_EQ(fmt::format("{}", time), "1979-03-12 12:00:00"); - EXPECT_EQ(fmt::format("{:}", time), "1979-03-12 12:00:00"); - - EXPECT_EQ(fmt::format("{:%%}", time), "%"); - EXPECT_EQ(fmt::format("{:%n}", time), "\n"); - EXPECT_EQ(fmt::format("{:%t}", time), "\t"); - EXPECT_EQ(fmt::format("{:%Y}", time), "1979"); - EXPECT_EQ(fmt::format("{:%EY}", time), "1979"); - EXPECT_EQ(fmt::format("{:%y}", time), "79"); - EXPECT_EQ(fmt::format("{:%Oy}", time), "79"); - EXPECT_EQ(fmt::format("{:%Ey}", time), "79"); - EXPECT_EQ(fmt::format("{:%C}", time), "19"); - EXPECT_EQ(fmt::format("{:%EC}", time), "19"); - EXPECT_EQ(fmt::format("{:%G}", time), "1979"); - EXPECT_EQ(fmt::format("{:%g}", time), "79"); - EXPECT_EQ(fmt::format("{:%b}", time), "Mar"); - EXPECT_EQ(fmt::format("{:%h}", time), "Mar"); - EXPECT_EQ(fmt::format("{:%B}", time), "March"); - EXPECT_EQ(fmt::format("{:%m}", time), "03"); - EXPECT_EQ(fmt::format("{:%Om}", time), "03"); - EXPECT_EQ(fmt::format("{:%U}", time), "10"); - EXPECT_EQ(fmt::format("{:%OU}", time), "10"); - EXPECT_EQ(fmt::format("{:%W}", time), "11"); - EXPECT_EQ(fmt::format("{:%OW}", time), "11"); - EXPECT_EQ(fmt::format("{:%V}", time), "11"); - EXPECT_EQ(fmt::format("{:%OV}", time), "11"); - EXPECT_EQ(fmt::format("{:%j}", time), "071"); - EXPECT_EQ(fmt::format("{:%d}", time), "12"); - EXPECT_EQ(fmt::format("{:%Od}", time), "12"); - EXPECT_EQ(fmt::format("{:%e}", time), "12"); - EXPECT_EQ(fmt::format("{:%Oe}", time), "12"); - EXPECT_EQ(fmt::format("{:%a}", time), "Mon"); - EXPECT_EQ(fmt::format("{:%A}", time), "Monday"); - EXPECT_EQ(fmt::format("{:%w}", time), "1"); - EXPECT_EQ(fmt::format("{:%Ow}", time), "1"); - EXPECT_EQ(fmt::format("{:%u}", time), "1"); - EXPECT_EQ(fmt::format("{:%Ou}", time), "1"); - EXPECT_EQ(fmt::format("{:%H}", time), "12"); - EXPECT_EQ(fmt::format("{:%OH}", time), "12"); - EXPECT_EQ(fmt::format("{:%I}", time), "12"); - EXPECT_EQ(fmt::format("{:%OI}", time), "12"); - EXPECT_EQ(fmt::format("{:%M}", time), "00"); - EXPECT_EQ(fmt::format("{:%OM}", time), "00"); - EXPECT_EQ(fmt::format("{:%S}", time), "00"); - EXPECT_EQ(fmt::format("{:%OS}", time), "00"); - EXPECT_EQ(fmt::format("{:%x}", time), "03/12/79"); - EXPECT_EQ(fmt::format("{:%Ex}", time), "03/12/79"); - EXPECT_EQ(fmt::format("{:%X}", time), "12:00:00"); - EXPECT_EQ(fmt::format("{:%EX}", time), "12:00:00"); - EXPECT_EQ(fmt::format("{:%D}", time), "03/12/79"); - EXPECT_EQ(fmt::format("{:%F}", time), "1979-03-12"); - EXPECT_EQ(fmt::format("{:%R}", time), "12:00"); - EXPECT_EQ(fmt::format("{:%T}", time), "12:00:00"); - EXPECT_EQ(fmt::format("{:%p}", time), "PM"); - EXPECT_EQ(fmt::format("{:%c}", time), "Mon Mar 12 12:00:00 1979"); - EXPECT_EQ(fmt::format("{:%Ec}", time), "Mon Mar 12 12:00:00 1979"); - EXPECT_EQ(fmt::format("{:%r}", time), "12:00:00 PM"); - - EXPECT_EQ(fmt::format("{:%Y-%m-%d %H:%M:%S}", time), "1979-03-12 12:00:00"); -} - -TEST(chrono_test, sys_time) { - auto time = - fmt::sys_time<std::chrono::seconds>(std::chrono::seconds(290088000)); - test_time(time); - EXPECT_EQ(fmt::format("{:%z}", time), "+0000"); - EXPECT_EQ(fmt::format("{:%Ez}", time), "+00:00"); - EXPECT_EQ(fmt::format("{:%Oz}", time), "+00:00"); - EXPECT_EQ(fmt::format("{:%Z}", time), "UTC"); -} - -TEST(chrono_test, local_time) { - auto time = - fmt::local_time<std::chrono::seconds>(std::chrono::seconds(290088000)); - test_time(time); - EXPECT_THROW_MSG((void)fmt::format(fmt::runtime("{:%z}"), time), - fmt::format_error, "no timezone"); - EXPECT_THROW_MSG((void)fmt::format(fmt::runtime("{:%Z}"), time), - fmt::format_error, "no timezone"); -} - -template <typename T, FMT_ENABLE_IF(fmt::detail::has_tm_gmtoff<T>::value)> -auto set_tm_gmtoff(T& time, long offset) -> bool { - time.tm_gmtoff = offset; - return true; -} -template <typename T, FMT_ENABLE_IF(!fmt::detail::has_tm_gmtoff<T>::value)> -auto set_tm_gmtoff(T&, long) -> bool { - return false; -} - -TEST(chrono_test, tm) { - auto time = fmt::gmtime(290088000); - test_time(time); - if (set_tm_gmtoff(time, -28800)) { - EXPECT_EQ(fmt::format(fmt::runtime("{:%z}"), time), "-0800"); - EXPECT_EQ(fmt::format(fmt::runtime("{:%Ez}"), time), "-08:00"); - EXPECT_EQ(fmt::format(fmt::runtime("{:%Oz}"), time), "-08:00"); - } else { - EXPECT_THROW_MSG((void)fmt::format(fmt::runtime("{:%z}"), time), - fmt::format_error, "no timezone"); - } - char tz[] = "EET"; - if (fmt::detail::set_tm_zone(time, tz)) { - EXPECT_EQ(fmt::format(fmt::runtime("{:%Z}"), time), "EET"); - } else { - EXPECT_THROW_MSG((void)fmt::format(fmt::runtime("{:%Z}"), time), - fmt::format_error, "no timezone"); - } -} - -TEST(chrono_test, daylight_savings_time_end) { - // 2024-10-27 03:05 as the number of seconds since epoch in Europe/Kyiv time. - // It is slightly after the DST end and passing it to to_sys will result in - // an ambiguous time error: - // 2024-10-27 03:05:00 is ambiguous. It could be - // 2024-10-27 03:05:00 EEST == 2024-10-27 00:05:00 UTC or - // 2024-10-27 03:05:00 EET == 2024-10-27 01:05:00 UTC - auto t = - fmt::local_time<std::chrono::seconds>(std::chrono::seconds(1729998300)); - EXPECT_EQ(fmt::format("{}", t), "2024-10-27 03:05:00"); -} - -TEST(chrono_test, format_default) { - EXPECT_EQ(fmt::format("{}", std::chrono::seconds(42)), "42s"); - EXPECT_EQ(fmt::format("{}", std::chrono::duration<int, std::atto>(42)), - "42as"); - EXPECT_EQ(fmt::format("{}", std::chrono::duration<int, std::femto>(42)), - "42fs"); - EXPECT_EQ(fmt::format("{}", std::chrono::duration<int, std::pico>(42)), - "42ps"); - EXPECT_EQ(fmt::format("{}", std::chrono::nanoseconds(42)), "42ns"); - EXPECT_EQ(fmt::format("{}", std::chrono::microseconds(42)), "42µs"); - EXPECT_EQ(fmt::format("{}", std::chrono::milliseconds(42)), "42ms"); - EXPECT_EQ(fmt::format("{}", std::chrono::duration<int, std::centi>(42)), - "42cs"); - EXPECT_EQ(fmt::format("{}", std::chrono::duration<int, std::deci>(42)), - "42ds"); - EXPECT_EQ(fmt::format("{}", std::chrono::seconds(42)), "42s"); - EXPECT_EQ(fmt::format("{}", std::chrono::duration<int, std::deca>(42)), - "42das"); - EXPECT_EQ(fmt::format("{}", std::chrono::duration<int, std::hecto>(42)), - "42hs"); - EXPECT_EQ(fmt::format("{}", std::chrono::duration<int, std::kilo>(42)), - "42ks"); - EXPECT_EQ(fmt::format("{}", std::chrono::duration<int, std::mega>(42)), - "42Ms"); - EXPECT_EQ(fmt::format("{}", std::chrono::duration<int, std::giga>(42)), - "42Gs"); - EXPECT_EQ(fmt::format("{}", std::chrono::duration<int, std::tera>(42)), - "42Ts"); - EXPECT_EQ(fmt::format("{}", std::chrono::duration<int, std::peta>(42)), - "42Ps"); - EXPECT_EQ(fmt::format("{}", std::chrono::duration<int, std::exa>(42)), - "42Es"); - EXPECT_EQ(fmt::format("{}", std::chrono::minutes(42)), "42min"); - EXPECT_EQ(fmt::format("{}", std::chrono::hours(42)), "42h"); - EXPECT_EQ(fmt::format("{}", days(42)), "42d"); - EXPECT_EQ( - fmt::format("{}", std::chrono::duration<int, std::ratio<15, 1>>(42)), - "42[15]s"); - EXPECT_EQ( - fmt::format("{}", std::chrono::duration<int, std::ratio<15, 4>>(42)), - "42[15/4]s"); -} - -TEST(chrono_test, duration_align) { - auto s = std::chrono::seconds(42); - EXPECT_EQ(fmt::format("{:5}", s), "42s "); - EXPECT_EQ(fmt::format("{:{}}", s, 5), "42s "); - EXPECT_EQ(fmt::format("{:>5}", s), " 42s"); - EXPECT_EQ(fmt::format("{:*^7}", s), "**42s**"); - EXPECT_EQ(fmt::format("{:12%H:%M:%S}", std::chrono::seconds(12345)), - "03:25:45 "); - EXPECT_EQ(fmt::format("{:>12%H:%M:%S}", std::chrono::seconds(12345)), - " 03:25:45"); - EXPECT_EQ(fmt::format("{:~^12%H:%M:%S}", std::chrono::seconds(12345)), - "~~03:25:45~~"); - EXPECT_EQ(fmt::format("{:{}%H:%M:%S}", std::chrono::seconds(12345), 12), - "03:25:45 "); -} - -TEST(chrono_test, tm_align) { - auto t = make_tm(1975, 12, 29, 12, 14, 16); - EXPECT_EQ(fmt::format("{:%F %T}", t), "1975-12-29 12:14:16"); - EXPECT_EQ(fmt::format("{:30%F %T}", t), "1975-12-29 12:14:16 "); - EXPECT_EQ(fmt::format("{:{}%F %T}", t, 30), "1975-12-29 12:14:16 "); - EXPECT_EQ(fmt::format("{:<30%F %T}", t), "1975-12-29 12:14:16 "); - EXPECT_EQ(fmt::format("{:^30%F %T}", t), " 1975-12-29 12:14:16 "); - EXPECT_EQ(fmt::format("{:>30%F %T}", t), " 1975-12-29 12:14:16"); - - EXPECT_EQ(fmt::format("{:*<30%F %T}", t), "1975-12-29 12:14:16***********"); - EXPECT_EQ(fmt::format("{:*^30%F %T}", t), "*****1975-12-29 12:14:16******"); - EXPECT_EQ(fmt::format("{:*>30%F %T}", t), "***********1975-12-29 12:14:16"); -} - -TEST(chrono_test, tp_align) { - auto tp = std::chrono::time_point_cast<std::chrono::microseconds>( - std::chrono::system_clock::from_time_t(0)); - EXPECT_EQ(fmt::format("{:%M:%S}", tp), "00:00.000000"); - EXPECT_EQ(fmt::format("{:15%M:%S}", tp), "00:00.000000 "); - EXPECT_EQ(fmt::format("{:{}%M:%S}", tp, 15), "00:00.000000 "); - EXPECT_EQ(fmt::format("{:<15%M:%S}", tp), "00:00.000000 "); - EXPECT_EQ(fmt::format("{:^15%M:%S}", tp), " 00:00.000000 "); - EXPECT_EQ(fmt::format("{:>15%M:%S}", tp), " 00:00.000000"); - - EXPECT_EQ(fmt::format("{:*<15%M:%S}", tp), "00:00.000000***"); - EXPECT_EQ(fmt::format("{:*^15%M:%S}", tp), "*00:00.000000**"); - EXPECT_EQ(fmt::format("{:*>15%M:%S}", tp), "***00:00.000000"); -} - -TEST(chrono_test, format_specs) { - EXPECT_EQ(fmt::format("{:%%}", std::chrono::seconds(0)), "%"); - EXPECT_EQ(fmt::format("{:%n}", std::chrono::seconds(0)), "\n"); - EXPECT_EQ(fmt::format("{:%t}", std::chrono::seconds(0)), "\t"); - EXPECT_EQ(fmt::format("{:%S}", std::chrono::seconds(0)), "00"); - EXPECT_EQ(fmt::format("{:%S}", std::chrono::seconds(60)), "00"); - EXPECT_EQ(fmt::format("{:%S}", std::chrono::seconds(42)), "42"); - EXPECT_EQ(fmt::format("{:%S}", std::chrono::milliseconds(1234)), "01.234"); - EXPECT_EQ(fmt::format("{:%M}", std::chrono::minutes(0)), "00"); - EXPECT_EQ(fmt::format("{:%M}", std::chrono::minutes(60)), "00"); - EXPECT_EQ(fmt::format("{:%M}", std::chrono::minutes(42)), "42"); - EXPECT_EQ(fmt::format("{:%M}", std::chrono::seconds(61)), "01"); - EXPECT_EQ(fmt::format("{:%H}", std::chrono::hours(0)), "00"); - EXPECT_EQ(fmt::format("{:%H}", std::chrono::hours(24)), "00"); - EXPECT_EQ(fmt::format("{:%H}", std::chrono::hours(14)), "14"); - EXPECT_EQ(fmt::format("{:%H}", std::chrono::minutes(61)), "01"); - EXPECT_EQ(fmt::format("{:%I}", std::chrono::hours(0)), "12"); - EXPECT_EQ(fmt::format("{:%I}", std::chrono::hours(12)), "12"); - EXPECT_EQ(fmt::format("{:%I}", std::chrono::hours(24)), "12"); - EXPECT_EQ(fmt::format("{:%I}", std::chrono::hours(4)), "04"); - EXPECT_EQ(fmt::format("{:%I}", std::chrono::hours(14)), "02"); - EXPECT_EQ(fmt::format("{:%j}", days(12)), "12"); - EXPECT_EQ(fmt::format("{:%j}", days(12345)), "12345"); - EXPECT_EQ(fmt::format("{:%j}", std::chrono::hours(12345 * 24 + 12)), "12345"); - EXPECT_EQ(fmt::format("{:%H:%M:%S}", std::chrono::seconds(12345)), - "03:25:45"); - EXPECT_EQ(fmt::format("{:%R}", std::chrono::seconds(12345)), "03:25"); - EXPECT_EQ(fmt::format("{:%T}", std::chrono::seconds(12345)), "03:25:45"); - EXPECT_EQ(fmt::format("{:%Q}", std::chrono::seconds(12345)), "12345"); - EXPECT_EQ(fmt::format("{:%q}", std::chrono::seconds(12345)), "s"); -} - -TEST(chrono_test, invalid_specs) { - auto sec = std::chrono::seconds(0); - EXPECT_THROW_MSG((void)fmt::format(runtime("{:%a}"), sec), fmt::format_error, - "no date"); - EXPECT_THROW_MSG((void)fmt::format(runtime("{:%A}"), sec), fmt::format_error, - "no date"); - EXPECT_THROW_MSG((void)fmt::format(runtime("{:%c}"), sec), fmt::format_error, - "no date"); - EXPECT_THROW_MSG((void)fmt::format(runtime("{:%x}"), sec), fmt::format_error, - "no date"); - EXPECT_THROW_MSG((void)fmt::format(runtime("{:%Ex}"), sec), fmt::format_error, - "no date"); - EXPECT_THROW_MSG((void)fmt::format(runtime("{:%X}"), sec), fmt::format_error, - "no date"); - EXPECT_THROW_MSG((void)fmt::format(runtime("{:%EX}"), sec), fmt::format_error, - "no date"); - EXPECT_THROW_MSG((void)fmt::format(runtime("{:%D}"), sec), fmt::format_error, - "no date"); - EXPECT_THROW_MSG((void)fmt::format(runtime("{:%F}"), sec), fmt::format_error, - "no date"); - EXPECT_THROW_MSG((void)fmt::format(runtime("{:%Ec}"), sec), fmt::format_error, - "no date"); - EXPECT_THROW_MSG((void)fmt::format(runtime("{:%w}"), sec), fmt::format_error, - "no date"); - EXPECT_THROW_MSG((void)fmt::format(runtime("{:%u}"), sec), fmt::format_error, - "no date"); - EXPECT_THROW_MSG((void)fmt::format(runtime("{:%b}"), sec), fmt::format_error, - "no date"); - EXPECT_THROW_MSG((void)fmt::format(runtime("{:%B}"), sec), fmt::format_error, - "no date"); - EXPECT_THROW_MSG((void)fmt::format(runtime("{:%z}"), sec), fmt::format_error, - "no date"); - EXPECT_THROW_MSG((void)fmt::format(runtime("{:%Z}"), sec), fmt::format_error, - "no date"); - EXPECT_THROW_MSG((void)fmt::format(runtime("{:%Eq}"), sec), fmt::format_error, - "invalid format"); - EXPECT_THROW_MSG((void)fmt::format(runtime("{:%Oq}"), sec), fmt::format_error, - "invalid format"); - EXPECT_THROW_MSG((void)fmt::format(runtime("{:abc}"), sec), fmt::format_error, - "invalid format"); - EXPECT_THROW_MSG((void)fmt::format(runtime("{:.2f}"), sec), fmt::format_error, - "invalid format"); -} - -auto format_tm(const std::tm& time, fmt::string_view spec, - const std::locale& loc) -> std::string { - auto& facet = std::use_facet<std::time_put<char>>(loc); - std::ostringstream os; - os.imbue(loc); - facet.put(os, os, ' ', &time, spec.begin(), spec.end()); - return os.str(); -} - -TEST(chrono_test, locale) { - auto loc = get_locale("ja_JP.utf8"); - if (loc == std::locale::classic()) return; -#define EXPECT_TIME(spec, time, duration) \ - { \ - auto jp_loc = std::locale("ja_JP.utf8"); \ - EXPECT_EQ(format_tm(time, spec, jp_loc), \ - fmt::format(jp_loc, "{:L" spec "}", duration)); \ - } - EXPECT_TIME("%OH", make_hour(14), std::chrono::hours(14)); - EXPECT_TIME("%OI", make_hour(14), std::chrono::hours(14)); - EXPECT_TIME("%OM", make_minute(42), std::chrono::minutes(42)); - EXPECT_TIME("%OS", make_second(42), std::chrono::seconds(42)); - auto time = make_tm(); - time.tm_hour = 3; - time.tm_min = 25; - time.tm_sec = 45; - auto sec = std::chrono::seconds(12345); - EXPECT_TIME("%r", time, sec); - EXPECT_TIME("%p", time, sec); -} - -using dms = std::chrono::duration<double, std::milli>; - -TEST(chrono_test, format_default_fp) { - EXPECT_EQ(fmt::format("{}", std::chrono::duration<float>(1.234)), "1.234s"); - EXPECT_EQ(fmt::format("{}", std::chrono::duration<float, std::milli>(1.234)), - "1.234ms"); - EXPECT_EQ(fmt::format("{}", std::chrono::duration<double>(1.234)), "1.234s"); - EXPECT_EQ(fmt::format("{}", dms(1.234)), "1.234ms"); -} - -TEST(chrono_test, format_precision) { - EXPECT_THROW_MSG( - (void)fmt::format(runtime("{:.2%Q}"), std::chrono::seconds(42)), - fmt::format_error, "precision not allowed for this argument type"); - EXPECT_EQ(fmt::format("{:.0}", dms(1.234)), "1ms"); - EXPECT_EQ(fmt::format("{:.1}", dms(1.234)), "1.2ms"); - EXPECT_EQ(fmt::format("{:.{}}", dms(1.234), 2), "1.23ms"); - - EXPECT_EQ(fmt::format("{:.0}", dms(12.56)), "13ms"); - EXPECT_EQ(fmt::format("{:.1}", dms(12.56)), "12.6ms"); - EXPECT_EQ(fmt::format("{:.2}", dms(12.56)), "12.56ms"); -} - -TEST(chrono_test, format_full_specs) { - EXPECT_EQ(fmt::format("{:6.0}", dms(1.234)), "1ms "); - EXPECT_EQ(fmt::format("{:6.1}", dms(1.234)), "1.2ms "); - EXPECT_EQ(fmt::format("{:>8.{}}", dms(1.234), 2), " 1.23ms"); - EXPECT_EQ(fmt::format("{:^{}.{}}", dms(1.234), 7, 1), " 1.2ms "); - EXPECT_EQ(fmt::format("{0:^{2}.{1}}", dms(1.234), 2, 8), " 1.23ms "); - EXPECT_EQ(fmt::format("{:=^{}.{}}", dms(1.234), 9, 3), "=1.234ms="); - EXPECT_EQ(fmt::format("{:*^10.4}", dms(1.234)), "*1.2340ms*"); - - EXPECT_EQ(fmt::format("{:6.0}", dms(12.56)), "13ms "); - EXPECT_EQ(fmt::format("{:>8.{}}", dms(12.56), 0), " 13ms"); - EXPECT_EQ(fmt::format("{:^{}.{}}", dms(12.56), 6, 0), " 13ms "); - EXPECT_EQ(fmt::format("{0:^{2}.{1}}", dms(12.56), 0, 8), " 13ms "); - EXPECT_EQ(fmt::format("{:=^{}.{}}", dms(12.56), 9, 0), "==13ms==="); - EXPECT_EQ(fmt::format("{:*^10.0}", dms(12.56)), "***13ms***"); -} - -TEST(chrono_test, format_simple_q) { - EXPECT_EQ(fmt::format("{:%Q %q}", std::chrono::duration<float>(1.234)), - "1.234 s"); - EXPECT_EQ( - fmt::format("{:%Q %q}", std::chrono::duration<float, std::milli>(1.234)), - "1.234 ms"); - EXPECT_EQ(fmt::format("{:%Q %q}", std::chrono::duration<double>(1.234)), - "1.234 s"); - EXPECT_EQ(fmt::format("{:%Q %q}", dms(1.234)), "1.234 ms"); -} - -TEST(chrono_test, format_precision_q) { - EXPECT_THROW_MSG( - (void)fmt::format(runtime("{:.2%Q %q}"), std::chrono::seconds(42)), - fmt::format_error, "precision not allowed for this argument type"); - EXPECT_EQ(fmt::format("{:.1%Q %q}", dms(1.234)), "1.2 ms"); - EXPECT_EQ(fmt::format("{:.{}%Q %q}", dms(1.234), 2), "1.23 ms"); -} - -TEST(chrono_test, format_full_specs_q) { - EXPECT_EQ(fmt::format("{:7.0%Q %q}", dms(1.234)), "1 ms "); - EXPECT_EQ(fmt::format("{:7.1%Q %q}", dms(1.234)), "1.2 ms "); - EXPECT_EQ(fmt::format("{:>8.{}%Q %q}", dms(1.234), 2), " 1.23 ms"); - EXPECT_EQ(fmt::format("{:^{}.{}%Q %q}", dms(1.234), 8, 1), " 1.2 ms "); - EXPECT_EQ(fmt::format("{0:^{2}.{1}%Q %q}", dms(1.234), 2, 9), " 1.23 ms "); - EXPECT_EQ(fmt::format("{:=^{}.{}%Q %q}", dms(1.234), 10, 3), "=1.234 ms="); - EXPECT_EQ(fmt::format("{:*^11.4%Q %q}", dms(1.234)), "*1.2340 ms*"); - - EXPECT_EQ(fmt::format("{:7.0%Q %q}", dms(12.56)), "13 ms "); - EXPECT_EQ(fmt::format("{:>8.{}%Q %q}", dms(12.56), 0), " 13 ms"); - EXPECT_EQ(fmt::format("{:^{}.{}%Q %q}", dms(12.56), 8, 0), " 13 ms "); - EXPECT_EQ(fmt::format("{0:^{2}.{1}%Q %q}", dms(12.56), 0, 9), " 13 ms "); - EXPECT_EQ(fmt::format("{:=^{}.{}%Q %q}", dms(12.56), 9, 0), "==13 ms=="); - EXPECT_EQ(fmt::format("{:*^11.0%Q %q}", dms(12.56)), "***13 ms***"); -} - -TEST(chrono_test, invalid_width_id) { - EXPECT_THROW((void)fmt::format(runtime("{:{o}"), std::chrono::seconds(0)), - fmt::format_error); -} - -TEST(chrono_test, invalid_colons) { - EXPECT_THROW((void)fmt::format(runtime("{0}=:{0::"), std::chrono::seconds(0)), - fmt::format_error); -} - -TEST(chrono_test, negative_durations) { - EXPECT_EQ(fmt::format("{:%Q}", std::chrono::seconds(-12345)), "-12345"); - EXPECT_EQ(fmt::format("{:%H:%M:%S}", std::chrono::seconds(-12345)), - "-03:25:45"); - EXPECT_EQ(fmt::format("{:%M:%S}", std::chrono::duration<double>(-1)), - "-00:01"); - EXPECT_EQ(fmt::format("{:%q}", std::chrono::seconds(-12345)), "s"); - EXPECT_EQ(fmt::format("{:%S}", - std::chrono::duration<signed char, std::milli>(-127)), - "-00.127"); - auto min = std::numeric_limits<int>::min(); - EXPECT_EQ(fmt::format("{}", min), - fmt::format("{:%Q}", std::chrono::duration<int>(min))); -} - -TEST(chrono_test, special_durations) { - EXPECT_EQ(fmt::format("{:%S}", std::chrono::duration<double>(1e20)), "40"); - auto nan = std::numeric_limits<double>::quiet_NaN(); - EXPECT_EQ( - fmt::format("{:%I %H %M %S %R %r}", std::chrono::duration<double>(nan)), - "nan nan nan nan nan:nan nan"); - EXPECT_EQ(fmt::format("{}", std::chrono::duration<float, std::exa>(1)), - "1Es"); - EXPECT_EQ(fmt::format("{}", std::chrono::duration<float, std::atto>(1)), - "1as"); - EXPECT_EQ(fmt::format("{:%R}", std::chrono::duration<char, std::mega>{2}), - "03:33"); - EXPECT_EQ(fmt::format("{:%T}", std::chrono::duration<char, std::mega>{2}), - "03:33:20"); - EXPECT_EQ( - fmt::format("{:.3%S}", std::chrono::duration<float, std::pico>(1.234e12)), - "01.234"); -} - -TEST(chrono_test, unsigned_duration) { - EXPECT_EQ(fmt::format("{}", std::chrono::duration<unsigned>(42)), "42s"); -} - -TEST(chrono_test, weekday) { - auto loc = get_locale("es_ES.UTF-8"); - std::locale::global(loc); - - auto sat = fmt::weekday(6); - - auto tm = std::tm(); - tm.tm_wday = static_cast<int>(sat.c_encoding()); - - EXPECT_EQ(fmt::format("{}", sat), "Sat"); - EXPECT_EQ(fmt::format("{:%a}", sat), "Sat"); - EXPECT_EQ(fmt::format("{:%A}", sat), "Saturday"); - EXPECT_EQ(fmt::format("{:%a}", tm), "Sat"); - - if (loc != std::locale::classic()) { - auto saturdays = std::vector<std::string>{"sáb", "sá.", "sáb."}; - EXPECT_THAT(saturdays, Contains(fmt::format(loc, "{:L}", sat))); - EXPECT_THAT(saturdays, Contains(fmt::format(loc, "{:L%a}", sat))); - EXPECT_THAT(saturdays, Contains(fmt::format(loc, "{:L%a}", tm))); - } -} - -TEST(chrono_test, cpp20_duration_subsecond_support) { - using attoseconds = std::chrono::duration<long long, std::atto>; - // Check that 18 digits of subsecond precision are supported. - EXPECT_EQ(fmt::format("{:%S}", attoseconds{999999999999999999}), - "00.999999999999999999"); - EXPECT_EQ(fmt::format("{:%S}", attoseconds{673231113420148734}), - "00.673231113420148734"); - EXPECT_EQ(fmt::format("{:%S}", attoseconds{-673231113420148734}), - "-00.673231113420148734"); - EXPECT_EQ(fmt::format("{:%S}", std::chrono::nanoseconds{13420148734}), - "13.420148734"); - EXPECT_EQ(fmt::format("{:%S}", std::chrono::nanoseconds{-13420148734}), - "-13.420148734"); - EXPECT_EQ(fmt::format("{:%S}", std::chrono::milliseconds{1234}), "01.234"); - // Check subsecond presision modifier. - EXPECT_EQ(fmt::format("{:.6%S}", std::chrono::nanoseconds{1234}), - "00.000001"); - EXPECT_EQ(fmt::format("{:.18%S}", std::chrono::nanoseconds{1234}), - "00.000001234000000000"); - EXPECT_EQ(fmt::format("{:.{}%S}", std::chrono::nanoseconds{1234}, 6), - "00.000001"); - EXPECT_EQ(fmt::format("{:.6%S}", std::chrono::milliseconds{1234}), - "01.234000"); - EXPECT_EQ(fmt::format("{:.6%S}", std::chrono::milliseconds{-1234}), - "-01.234000"); - EXPECT_EQ(fmt::format("{:.2%S}", std::chrono::milliseconds{12345}), "12.34"); - EXPECT_EQ(fmt::format("{:.2%S}", std::chrono::milliseconds{12375}), "12.37"); - EXPECT_EQ(fmt::format("{:.2%S}", std::chrono::milliseconds{-12375}), - "-12.37"); - EXPECT_EQ(fmt::format("{:.0%S}", std::chrono::milliseconds{12054}), "12"); - EXPECT_EQ(fmt::format("{:.2%S}", std::chrono::milliseconds{99999}), "39.99"); - EXPECT_EQ(fmt::format("{:.2%S}", std::chrono::milliseconds{1000}), "01.00"); - EXPECT_EQ(fmt::format("{:.3%S}", std::chrono::milliseconds{1}), "00.001"); - EXPECT_EQ(fmt::format("{:.3%S}", std::chrono::seconds{1234}), "34.000"); - EXPECT_EQ(fmt::format("{:.3%S}", std::chrono::hours{1234}), "00.000"); - EXPECT_EQ(fmt::format("{:.5%S}", dms(1.234)), "00.00123"); - EXPECT_EQ(fmt::format("{:.8%S}", dms(1.234)), "00.00123400"); - { - // Check that {:%H:%M:%S} is equivalent to {:%T}. - auto dur = std::chrono::milliseconds{3601234}; - auto formatted_dur = fmt::format("{:%T}", dur); - EXPECT_EQ(formatted_dur, "01:00:01.234"); - EXPECT_EQ(fmt::format("{:%H:%M:%S}", dur), formatted_dur); - EXPECT_EQ(fmt::format("{:.6%H:%M:%S}", dur), "01:00:01.234000"); - } - using nanoseconds_dbl = std::chrono::duration<double, std::nano>; - EXPECT_EQ(fmt::format("{:%S}", nanoseconds_dbl(-123456789)), "-00.123456789"); - EXPECT_EQ(fmt::format("{:%S}", nanoseconds_dbl(9123456789)), "09.123456789"); - // Verify that only the seconds part is extracted and printed. - EXPECT_EQ(fmt::format("{:%S}", nanoseconds_dbl(99123456789)), "39.123456789"); - EXPECT_EQ(fmt::format("{:%S}", nanoseconds_dbl(99123000000)), "39.123000000"); - { - // Now the hour is printed, and we also test if negative doubles work. - auto dur = nanoseconds_dbl{-99123456789}; - auto formatted_dur = fmt::format("{:%T}", dur); - EXPECT_EQ(formatted_dur, "-00:01:39.123456789"); - EXPECT_EQ(fmt::format("{:%H:%M:%S}", dur), formatted_dur); - EXPECT_EQ(fmt::format("{:.3%H:%M:%S}", dur), "-00:01:39.123"); - } - // Check that durations with precision greater than std::chrono::seconds have - // fixed precision, and print zeros even if there is no fractional part. - EXPECT_EQ(fmt::format("{:%S}", std::chrono::microseconds(7000000)), - "07.000000"); - EXPECT_EQ(fmt::format("{:%S}", - std::chrono::duration<long long, std::ratio<1, 3>>(1)), - "00.333333"); - EXPECT_EQ(fmt::format("{:%S}", - std::chrono::duration<long long, std::ratio<1, 7>>(1)), - "00.142857"); - - EXPECT_EQ( - fmt::format("{:%S}", - std::chrono::duration<signed char, std::ratio<1, 100>>(0x80)), - "-01.28"); - - EXPECT_EQ( - fmt::format("{:%M:%S}", - std::chrono::duration<short, std::ratio<1, 100>>(0x8000)), - "-05:27.68"); - - // Check that floating point seconds with ratio<1,1> are printed. - EXPECT_EQ(fmt::format("{:%S}", std::chrono::duration<double>(1.5)), - "01.500000"); - EXPECT_EQ(fmt::format("{:%M:%S}", std::chrono::duration<double>(-61.25)), - "-01:01.250000"); -} - -// Disable the utc_clock test for windows, as the icu.dll used for tzdb -// (time zone database) is not shipped with many windows versions. -#if FMT_USE_UTC_TIME && !defined(_WIN32) -TEST(chrono_test, utc_clock) { - auto t1 = std::chrono::system_clock::now(); - auto t1_utc = std::chrono::utc_clock::from_sys(t1); - EXPECT_EQ(fmt::format("{:%Y-%m-%d %H:%M:%S}", t1), - fmt::format("{:%Y-%m-%d %H:%M:%S}", t1_utc)); -} -#endif - -TEST(chrono_test, timestamp_ratios) { - auto t1 = - sys_time<std::chrono::milliseconds>(std::chrono::milliseconds(67890)); - EXPECT_EQ(fmt::format("{:%M:%S}", t1), "01:07.890"); - - auto t2 = sys_time<std::chrono::minutes>(std::chrono::minutes(7)); - EXPECT_EQ(fmt::format("{:%M:%S}", t2), "07:00"); - - auto t3 = sys_time<std::chrono::duration<int, std::ratio<9>>>( - std::chrono::duration<int, std::ratio<9>>(7)); - EXPECT_EQ(fmt::format("{:%M:%S}", t3), "01:03"); - - auto t4 = sys_time<std::chrono::duration<int, std::ratio<63>>>( - std::chrono::duration<int, std::ratio<63>>(1)); - EXPECT_EQ(fmt::format("{:%M:%S}", t4), "01:03"); - - if (sizeof(time_t) > 4) { - auto tp = - sys_time<std::chrono::milliseconds>(std::chrono::seconds(32503680000)); - EXPECT_EQ(fmt::format("{:%Y-%m-%d}", tp), "3000-01-01"); - } - - if (FMT_SAFE_DURATION_CAST) { - using years = std::chrono::duration<std::int64_t, std::ratio<31556952>>; - auto tp = sys_time<years>(years(std::numeric_limits<std::int64_t>::max())); - EXPECT_THROW_MSG((void)fmt::format("{:%Y-%m-%d}", tp), fmt::format_error, - "cannot format duration"); - } -} - -TEST(chrono_test, timestamp_sub_seconds) { - auto t1 = sys_time<std::chrono::duration<long long, std::ratio<1, 3>>>( - std::chrono::duration<long long, std::ratio<1, 3>>(4)); - EXPECT_EQ(fmt::format("{:%S}", t1), "01.333333"); - - auto t2 = sys_time<std::chrono::duration<double, std::ratio<1, 3>>>( - std::chrono::duration<double, std::ratio<1, 3>>(4)); - EXPECT_EQ(fmt::format("{:%S}", t2), "01.333333"); - - auto t3 = sys_time<std::chrono::seconds>(std::chrono::seconds(2)); - EXPECT_EQ(fmt::format("{:%S}", t3), "02"); - - auto t4 = sys_time<std::chrono::duration<double>>( - std::chrono::duration<double, std::ratio<1, 1>>(9.5)); - EXPECT_EQ(fmt::format("{:%S}", t4), "09.500000"); - - auto t5 = sys_time<std::chrono::duration<double>>( - std::chrono::duration<double, std::ratio<1, 1>>(9)); - EXPECT_EQ(fmt::format("{:%S}", t5), "09"); - - auto t6 = sys_time<std::chrono::milliseconds>(std::chrono::seconds(1) + - std::chrono::milliseconds(120)); - EXPECT_EQ(fmt::format("{:%S}", t6), "01.120"); - - auto t7 = - sys_time<std::chrono::microseconds>(std::chrono::microseconds(1234567)); - EXPECT_EQ(fmt::format("{:%S}", t7), "01.234567"); - - auto t8 = - sys_time<std::chrono::nanoseconds>(std::chrono::nanoseconds(123456789)); - EXPECT_EQ(fmt::format("{:%S}", t8), "00.123456789"); - EXPECT_EQ(fmt::format("{:%T}", t8), "00:00:00.123456789"); - - auto t9 = - sys_time<std::chrono::milliseconds>(std::chrono::milliseconds(2000)); - EXPECT_EQ(fmt::format("{:%S}", t9), "02.000"); - - auto epoch = sys_time<std::chrono::milliseconds>(); - auto d = std::chrono::milliseconds(250); - EXPECT_EQ(fmt::format("{:%S}", epoch - d), "59.750"); - EXPECT_EQ(fmt::format("{:%S}", epoch), "00.000"); - EXPECT_EQ(fmt::format("{:%S}", epoch + d), "00.250"); -} - -TEST(chrono_test, glibc_extensions) { - EXPECT_THROW_MSG((void)fmt::format(runtime("{:%0}"), std::chrono::seconds()), - fmt::format_error, "invalid format"); - EXPECT_THROW_MSG((void)fmt::format(runtime("{:%_}"), std::chrono::seconds()), - fmt::format_error, "invalid format"); - EXPECT_THROW_MSG((void)fmt::format(runtime("{:%-}"), std::chrono::seconds()), - fmt::format_error, "invalid format"); - - { - const auto d = std::chrono::hours(1) + std::chrono::minutes(2) + - std::chrono::seconds(3); - - EXPECT_EQ(fmt::format("{:%I,%H,%M,%S}", d), "01,01,02,03"); - EXPECT_EQ(fmt::format("{:%_I,%_H,%_M,%_S}", d), " 1, 1, 2, 3"); - EXPECT_EQ(fmt::format("{:%-I,%-H,%-M,%-S}", d), "1,1,2,3"); - EXPECT_EQ(fmt::format("{:%-I,%H,%M,%S}", d), "1,01,02,03"); - - EXPECT_EQ(fmt::format("{:%OI,%OH,%OM,%OS}", d), "01,01,02,03"); - EXPECT_EQ(fmt::format("{:%_OI,%_OH,%_OM,%_OS}", d), " 1, 1, 2, 3"); - EXPECT_EQ(fmt::format("{:%-OI,%-OH,%-OM,%-OS}", d), "1,1,2,3"); - } - - { - const auto tm = make_tm(1970, 1, 1, 1, 2, 3); - EXPECT_EQ(fmt::format("{:%I,%H,%M,%S}", tm), "01,01,02,03"); - EXPECT_EQ(fmt::format("{:%_I,%_H,%_M,%_S}", tm), " 1, 1, 2, 3"); - EXPECT_EQ(fmt::format("{:%-I,%-H,%-M,%-S}", tm), "1,1,2,3"); - - EXPECT_EQ(fmt::format("{:%OI,%OH,%OM,%OS}", tm), "01,01,02,03"); - EXPECT_EQ(fmt::format("{:%_OI,%_OH,%_OM,%_OS}", tm), " 1, 1, 2, 3"); - EXPECT_EQ(fmt::format("{:%-OI,%-OH,%-OM,%-OS}", tm), "1,1,2,3"); - } - - { - const auto d = std::chrono::seconds(3) + std::chrono::milliseconds(140); - EXPECT_EQ(fmt::format("{:%S}", d), "03.140"); - EXPECT_EQ(fmt::format("{:%_S}", d), " 3.140"); - EXPECT_EQ(fmt::format("{:%-S}", d), "3.140"); - } - - { - auto d = std::chrono::duration<double>(3.14); - EXPECT_EQ(fmt::format("{:%S}", d), "03.140000"); - EXPECT_EQ(fmt::format("{:%_S}", d), " 3.140000"); - EXPECT_EQ(fmt::format("{:%-S}", d), "3.140000"); - } - - { - auto t = std::tm(); - t.tm_yday = 7; - EXPECT_EQ(fmt::format("{:%U,%W,%V}", t), "02,01,01"); - EXPECT_EQ(fmt::format("{:%_U,%_W,%_V}", t), " 2, 1, 1"); - EXPECT_EQ(fmt::format("{:%-U,%-W,%-V}", t), "2,1,1"); - - EXPECT_EQ(fmt::format("{:%j}", t), "008"); - EXPECT_EQ(fmt::format("{:%_j}", t), " 8"); - EXPECT_EQ(fmt::format("{:%-j}", t), "8"); - } - - { - auto t = std::tm(); - t.tm_mday = 7; - EXPECT_EQ(fmt::format("{:%d}", t), "07"); - EXPECT_EQ(fmt::format("{:%_d}", t), " 7"); - EXPECT_EQ(fmt::format("{:%-d}", t), "7"); - - EXPECT_EQ(fmt::format("{:%e}", t), " 7"); - } - - { - auto t = std::tm(); - t.tm_year = 7 - 1900; - EXPECT_EQ(fmt::format("{:%Y}", t), "0007"); - EXPECT_EQ(fmt::format("{:%_Y}", t), " 7"); - EXPECT_EQ(fmt::format("{:%-Y}", t), "7"); - } - - { - auto t = std::tm(); - t.tm_year = -5 - 1900; - EXPECT_EQ(fmt::format("{:%Y}", t), "-005"); - EXPECT_EQ(fmt::format("{:%_Y}", t), " -5"); - EXPECT_EQ(fmt::format("{:%-Y}", t), "-5"); - } - - { - auto t = std::tm(); - t.tm_mon = 7 - 1; - EXPECT_EQ(fmt::format("{:%m}", t), "07"); - EXPECT_EQ(fmt::format("{:%_m}", t), " 7"); - EXPECT_EQ(fmt::format("{:%-m}", t), "7"); - } -} - -TEST(chrono_test, out_of_range) { - auto d = std::chrono::duration<unsigned long, std::giga>(538976288); - EXPECT_THROW((void)fmt::format("{:%j}", d), fmt::format_error); -} - -TEST(chrono_test, year_month_day) { - auto loc = get_locale("es_ES.UTF-8"); - std::locale::global(loc); - - auto year = fmt::year(2024); - auto month = fmt::month(1); - auto day = fmt::day(1); - auto ymd = fmt::year_month_day(year, month, day); - - EXPECT_EQ(fmt::format("{}", year), "2024"); - EXPECT_EQ(fmt::format("{:%Y}", year), "2024"); - EXPECT_EQ(fmt::format("{:%y}", year), "24"); - - EXPECT_EQ(fmt::format("{}", month), "Jan"); - EXPECT_EQ(fmt::format("{:%m}", month), "01"); - EXPECT_EQ(fmt::format("{:%b}", month), "Jan"); - EXPECT_EQ(fmt::format("{:%B}", month), "January"); - - EXPECT_EQ(fmt::format("{}", day), "01"); - EXPECT_EQ(fmt::format("{:%d}", day), "01"); - - EXPECT_EQ(fmt::format("{}", ymd), "2024-01-01"); - EXPECT_EQ(fmt::format("{:%Y-%m-%d}", ymd), "2024-01-01"); - EXPECT_EQ(fmt::format("{:%Y-%b-%d}", ymd), "2024-Jan-01"); - EXPECT_EQ(fmt::format("{:%Y-%B-%d}", ymd), "2024-January-01"); - - if (loc != std::locale::classic()) { - auto months = std::vector<std::string>{"ene.", "ene"}; - EXPECT_THAT(months, Contains(fmt::format(loc, "{:L}", month))); - EXPECT_THAT(months, Contains(fmt::format(loc, "{:L%b}", month))); - } -} diff --git a/thirdparty/fmt/test/color-test.cc b/thirdparty/fmt/test/color-test.cc deleted file mode 100644 index 45d8cd921..000000000 --- a/thirdparty/fmt/test/color-test.cc +++ /dev/null @@ -1,138 +0,0 @@ -// Formatting library for C++ - color tests -// -// Copyright (c) 2012 - present, Victor Zverovich -// All rights reserved. -// -// For the license information refer to format.h. - -#include "fmt/color.h" - -#include <iterator> // std::back_inserter - -#include "gtest-extra.h" // EXPECT_WRITE, EXPECT_THROW_MSG - -TEST(color_test, text_style) { - EXPECT_FALSE(fmt::text_style().has_foreground()); - EXPECT_FALSE(fmt::text_style().has_background()); - EXPECT_FALSE(fmt::text_style().has_emphasis()); - - EXPECT_TRUE(fg(fmt::rgb(0)).has_foreground()); - EXPECT_FALSE(fg(fmt::rgb(0)).has_background()); - EXPECT_FALSE(fg(fmt::rgb(0)).has_emphasis()); - EXPECT_TRUE(bg(fmt::rgb(0)).has_background()); - EXPECT_FALSE(bg(fmt::rgb(0)).has_foreground()); - EXPECT_FALSE(bg(fmt::rgb(0)).has_emphasis()); - - EXPECT_TRUE( - (fg(fmt::rgb(0xFFFFFF)) | bg(fmt::rgb(0xFFFFFF))).has_foreground()); - EXPECT_TRUE( - (fg(fmt::rgb(0xFFFFFF)) | bg(fmt::rgb(0xFFFFFF))).has_background()); - EXPECT_FALSE( - (fg(fmt::rgb(0xFFFFFF)) | bg(fmt::rgb(0xFFFFFF))).has_emphasis()); - - EXPECT_EQ(fg(fmt::rgb(0x000000)) | fg(fmt::rgb(0x000000)), - fg(fmt::rgb(0x000000))); - EXPECT_EQ(fg(fmt::rgb(0x00000F)) | fg(fmt::rgb(0x00000F)), - fg(fmt::rgb(0x00000F))); - EXPECT_EQ(fg(fmt::rgb(0xC0F000)) | fg(fmt::rgb(0x000FEE)), - fg(fmt::rgb(0xC0FFEE))); - - EXPECT_THROW_MSG( - fg(fmt::terminal_color::black) | fg(fmt::terminal_color::black), - fmt::format_error, "can't OR a terminal color"); - EXPECT_THROW_MSG( - fg(fmt::terminal_color::black) | fg(fmt::terminal_color::white), - fmt::format_error, "can't OR a terminal color"); - EXPECT_THROW_MSG( - bg(fmt::terminal_color::black) | bg(fmt::terminal_color::black), - fmt::format_error, "can't OR a terminal color"); - EXPECT_THROW_MSG( - bg(fmt::terminal_color::black) | bg(fmt::terminal_color::white), - fmt::format_error, "can't OR a terminal color"); - EXPECT_THROW_MSG(fg(fmt::terminal_color::black) | fg(fmt::color::black), - fmt::format_error, "can't OR a terminal color"); - EXPECT_THROW_MSG(bg(fmt::terminal_color::black) | bg(fmt::color::black), - fmt::format_error, "can't OR a terminal color"); - - EXPECT_NO_THROW(fg(fmt::terminal_color::white) | - bg(fmt::terminal_color::white)); - EXPECT_NO_THROW(fg(fmt::terminal_color::white) | bg(fmt::rgb(0xFFFFFF))); - EXPECT_NO_THROW(fg(fmt::terminal_color::white) | fmt::text_style()); - EXPECT_NO_THROW(bg(fmt::terminal_color::white) | fmt::text_style()); -} - -TEST(color_test, format) { - EXPECT_EQ(fmt::format(fmt::text_style(), "no style"), "no style"); - EXPECT_EQ(fmt::format(fg(fmt::rgb(255, 20, 30)), "rgb(255,20,30)"), - "\x1b[38;2;255;020;030mrgb(255,20,30)\x1b[0m"); - EXPECT_EQ(fmt::format(fg(fmt::rgb(255, 0, 0)) | fg(fmt::rgb(0, 20, 30)), - "rgb(255,20,30)"), - "\x1b[38;2;255;020;030mrgb(255,20,30)\x1b[0m"); - EXPECT_EQ( - fmt::format(fg(fmt::rgb(0, 0, 0)) | fg(fmt::rgb(0, 0, 0)), "rgb(0,0,0)"), - "\x1b[38;2;000;000;000mrgb(0,0,0)\x1b[0m"); - EXPECT_EQ(fmt::format(fg(fmt::color::blue), "blue"), - "\x1b[38;2;000;000;255mblue\x1b[0m"); - EXPECT_EQ( - fmt::format(fg(fmt::color::blue) | bg(fmt::color::red), "two color"), - "\x1b[38;2;000;000;255m\x1b[48;2;255;000;000mtwo color\x1b[0m"); - EXPECT_EQ(fmt::format(fmt::emphasis::bold, "bold"), "\x1b[1mbold\x1b[0m"); - EXPECT_EQ(fmt::format(fmt::emphasis::faint, "faint"), "\x1b[2mfaint\x1b[0m"); - EXPECT_EQ(fmt::format(fmt::emphasis::italic, "italic"), - "\x1b[3mitalic\x1b[0m"); - EXPECT_EQ(fmt::format(fmt::emphasis::underline, "underline"), - "\x1b[4munderline\x1b[0m"); - EXPECT_EQ(fmt::format(fmt::emphasis::blink, "blink"), "\x1b[5mblink\x1b[0m"); - EXPECT_EQ(fmt::format(fmt::emphasis::reverse, "reverse"), - "\x1b[7mreverse\x1b[0m"); - EXPECT_EQ(fmt::format(fmt::emphasis::conceal, "conceal"), - "\x1b[8mconceal\x1b[0m"); - EXPECT_EQ(fmt::format(fmt::emphasis::strikethrough, "strikethrough"), - "\x1b[9mstrikethrough\x1b[0m"); - EXPECT_EQ( - fmt::format(fg(fmt::color::blue) | fmt::emphasis::bold, "blue/bold"), - "\x1b[1m\x1b[38;2;000;000;255mblue/bold\x1b[0m"); - EXPECT_EQ(fmt::format(fmt::emphasis::bold, "bold error"), - "\x1b[1mbold error\x1b[0m"); - EXPECT_EQ(fmt::format(fg(fmt::color::blue), "blue log"), - "\x1b[38;2;000;000;255mblue log\x1b[0m"); - EXPECT_EQ(fmt::format(fmt::text_style(), "hi"), "hi"); - EXPECT_EQ(fmt::format(fg(fmt::terminal_color::red), "tred"), - "\x1b[31mtred\x1b[0m"); - EXPECT_EQ(fmt::format(bg(fmt::terminal_color::cyan), "tcyan"), - "\x1b[46mtcyan\x1b[0m"); - EXPECT_EQ(fmt::format(fg(fmt::terminal_color::bright_green), "tbgreen"), - "\x1b[92mtbgreen\x1b[0m"); - EXPECT_EQ(fmt::format(bg(fmt::terminal_color::bright_magenta), "tbmagenta"), - "\x1b[105mtbmagenta\x1b[0m"); - EXPECT_EQ(fmt::format(fg(fmt::terminal_color::red), "{}", "foo"), - "\x1b[31mfoo\x1b[0m"); - EXPECT_EQ(fmt::format("{}{}", fmt::styled("red", fg(fmt::color::red)), - fmt::styled("bold", fmt::emphasis::bold)), - "\x1b[38;2;255;000;000mred\x1b[0m\x1b[1mbold\x1b[0m"); - EXPECT_EQ(fmt::format("{}", fmt::styled("bar", fg(fmt::color::blue) | - fmt::emphasis::underline)), - "\x1b[4m\x1b[38;2;000;000;255mbar\x1b[0m"); - EXPECT_EQ( - fmt::format( - "{}", fmt::styled( - "all", fmt::emphasis::bold | fmt::emphasis::faint | - fmt::emphasis::italic | - fmt::emphasis::underline | fmt::emphasis::blink | - fmt::emphasis::reverse | fmt::emphasis::conceal | - fmt::emphasis::strikethrough)), - "\x1b[1;2;3;4;5;7;8;9mall\x1b[0m"); -} - -TEST(color_test, format_to) { - auto out = std::string(); - fmt::format_to(std::back_inserter(out), fg(fmt::rgb(255, 20, 30)), - "rgb(255,20,30){}{}{}", 1, 2, 3); - EXPECT_EQ(fmt::to_string(out), - "\x1b[38;2;255;020;030mrgb(255,20,30)123\x1b[0m"); -} - -TEST(color_test, print) { - EXPECT_WRITE(stdout, fmt::print(fg(fmt::rgb(255, 20, 30)), "rgb(255,20,30)"), - "\x1b[38;2;255;020;030mrgb(255,20,30)\x1b[0m"); -} diff --git a/thirdparty/fmt/test/compile-fp-test.cc b/thirdparty/fmt/test/compile-fp-test.cc deleted file mode 100644 index e1522c728..000000000 --- a/thirdparty/fmt/test/compile-fp-test.cc +++ /dev/null @@ -1,62 +0,0 @@ -// Formatting library for C++ - formatting library tests -// -// Copyright (c) 2012 - present, Victor Zverovich -// All rights reserved. -// -// For the license information refer to format.h. - -#include "fmt/compile.h" -#include "gmock/gmock.h" - -#if FMT_USE_CONSTEVAL - -template <size_t max_string_length, typename Char = char> struct test_string { - Char buffer[max_string_length] = {}; - - template <typename T> constexpr bool operator==(const T& rhs) const noexcept { - return fmt::basic_string_view<Char>(rhs).compare(buffer) == 0; - } -}; - -template <size_t max_string_length, typename Char = char, typename... Args> -consteval auto test_format(auto format, const Args&... args) { - test_string<max_string_length, Char> string{}; - fmt::format_to(string.buffer, format, args...); - return string; -} - -TEST(compile_time_formatting_test, floating_point) { - EXPECT_EQ("0", test_format<2>(FMT_COMPILE("{}"), 0.0f)); - EXPECT_EQ("392.500000", test_format<11>(FMT_COMPILE("{0:f}"), 392.5f)); - - EXPECT_EQ("0", test_format<2>(FMT_COMPILE("{:}"), 0.0)); - EXPECT_EQ("0.000000", test_format<9>(FMT_COMPILE("{:f}"), 0.0)); - EXPECT_EQ("0", test_format<2>(FMT_COMPILE("{:g}"), 0.0)); - EXPECT_EQ("392.65", test_format<7>(FMT_COMPILE("{:}"), 392.65)); - EXPECT_EQ("392.65", test_format<7>(FMT_COMPILE("{:g}"), 392.65)); - EXPECT_EQ("392.65", test_format<7>(FMT_COMPILE("{:G}"), 392.65)); - EXPECT_EQ("4.9014e+06", test_format<11>(FMT_COMPILE("{:g}"), 4.9014e6)); - EXPECT_EQ("-392.650000", test_format<12>(FMT_COMPILE("{:f}"), -392.65)); - EXPECT_EQ("-392.650000", test_format<12>(FMT_COMPILE("{:F}"), -392.65)); - - EXPECT_EQ("3.926500e+02", test_format<13>(FMT_COMPILE("{0:e}"), 392.65)); - EXPECT_EQ("3.926500E+02", test_format<13>(FMT_COMPILE("{0:E}"), 392.65)); - EXPECT_EQ("+0000392.6", test_format<11>(FMT_COMPILE("{0:+010.4g}"), 392.65)); - EXPECT_EQ("9223372036854775808.000000", - test_format<27>(FMT_COMPILE("{:f}"), 9223372036854775807.0)); - - constexpr double nan = std::numeric_limits<double>::quiet_NaN(); - EXPECT_EQ("nan", test_format<4>(FMT_COMPILE("{}"), nan)); - EXPECT_EQ("+nan", test_format<5>(FMT_COMPILE("{:+}"), nan)); - if (std::signbit(-nan)) - EXPECT_EQ("-nan", test_format<5>(FMT_COMPILE("{}"), -nan)); - else - fmt::print("Warning: compiler doesn't handle negative NaN correctly"); - - constexpr double inf = std::numeric_limits<double>::infinity(); - EXPECT_EQ("inf", test_format<4>(FMT_COMPILE("{}"), inf)); - EXPECT_EQ("+inf", test_format<5>(FMT_COMPILE("{:+}"), inf)); - EXPECT_EQ("-inf", test_format<5>(FMT_COMPILE("{}"), -inf)); -} - -#endif // FMT_USE_CONSTEVAL diff --git a/thirdparty/fmt/test/compile-test.cc b/thirdparty/fmt/test/compile-test.cc deleted file mode 100644 index e0a9bc9b7..000000000 --- a/thirdparty/fmt/test/compile-test.cc +++ /dev/null @@ -1,444 +0,0 @@ -// Formatting library for C++ - formatting library tests -// -// Copyright (c) 2012 - present, Victor Zverovich -// All rights reserved. -// -// For the license information refer to format.h. - -#include "fmt/compile.h" - -#include <iterator> -#include <list> -#include <type_traits> -#include <vector> - -#include "fmt/chrono.h" -#include "fmt/ranges.h" -#include "gmock/gmock.h" -#include "gtest-extra.h" - -TEST(compile_test, compile_fallback) { - // FMT_COMPILE should fallback on runtime formatting when `if constexpr` is - // not available. - EXPECT_EQ("42", fmt::format(FMT_COMPILE("{}"), 42)); -} - -struct type_with_get { - template <int> friend void get(type_with_get); -}; - -FMT_BEGIN_NAMESPACE -template <> struct formatter<type_with_get> : formatter<int> { - template <typename FormatContext> - auto format(type_with_get, FormatContext& ctx) const -> decltype(ctx.out()) { - return formatter<int>::format(42, ctx); - } -}; -FMT_END_NAMESPACE - -TEST(compile_test, compile_type_with_get) { - EXPECT_EQ("42", fmt::format(FMT_COMPILE("{}"), type_with_get())); -} - -#if defined(__cpp_if_constexpr) && defined(__cpp_return_type_deduction) -struct test_formattable {}; - -FMT_BEGIN_NAMESPACE -template <> struct formatter<test_formattable> : formatter<const char*> { - char word_spec = 'f'; - constexpr auto parse(format_parse_context& ctx) { - auto it = ctx.begin(), end = ctx.end(); - if (it == end || *it == '}') return it; - if (it != end && (*it == 'f' || *it == 'b')) word_spec = *it++; - if (it != end && *it != '}') throw format_error("invalid format"); - return it; - } - template <typename FormatContext> - constexpr auto format(test_formattable, FormatContext& ctx) const - -> decltype(ctx.out()) { - return formatter<const char*>::format(word_spec == 'f' ? "foo" : "bar", - ctx); - } -}; -FMT_END_NAMESPACE - -TEST(compile_test, format_default) { - EXPECT_EQ("42", fmt::format(FMT_COMPILE("{}"), 42)); - EXPECT_EQ("42", fmt::format(FMT_COMPILE("{}"), 42u)); - EXPECT_EQ("42", fmt::format(FMT_COMPILE("{}"), 42ll)); - EXPECT_EQ("42", fmt::format(FMT_COMPILE("{}"), 42ull)); - EXPECT_EQ("true", fmt::format(FMT_COMPILE("{}"), true)); - EXPECT_EQ("x", fmt::format(FMT_COMPILE("{}"), 'x')); - EXPECT_EQ("4.2", fmt::format(FMT_COMPILE("{}"), 4.2)); - EXPECT_EQ("foo", fmt::format(FMT_COMPILE("{}"), "foo")); - EXPECT_EQ("foo", fmt::format(FMT_COMPILE("{}"), std::string("foo"))); - EXPECT_EQ("foo", fmt::format(FMT_COMPILE("{}"), test_formattable())); - auto t = std::chrono::system_clock::now(); - EXPECT_EQ(fmt::format("{}", t), fmt::format(FMT_COMPILE("{}"), t)); -# ifdef __cpp_lib_byte - EXPECT_EQ("42", fmt::format(FMT_COMPILE("{}"), std::byte{42})); -# endif -} - -TEST(compile_test, format_escape) { - EXPECT_EQ("\"string\"", fmt::format(FMT_COMPILE("{:?}"), "string")); - EXPECT_EQ("prefix \"string\"", - fmt::format(FMT_COMPILE("prefix {:?}"), "string")); - EXPECT_EQ("\"string\" suffix", - fmt::format(FMT_COMPILE("{:?} suffix"), "string")); - EXPECT_EQ("\"abc\"", fmt::format(FMT_COMPILE("{0:<5?}"), "abc")); - EXPECT_EQ("\"abc\" ", fmt::format(FMT_COMPILE("{0:<7?}"), "abc")); -} - -TEST(compile_test, format_wide_string) { - EXPECT_EQ(L"42", fmt::format(FMT_COMPILE(L"{}"), 42)); -} - -TEST(compile_test, format_specs) { - EXPECT_EQ("42", fmt::format(FMT_COMPILE("{:x}"), 0x42)); - EXPECT_EQ("1.2 ms ", - fmt::format(FMT_COMPILE("{:7.1%Q %q}"), - std::chrono::duration<double, std::milli>(1.234))); -} - -TEST(compile_test, dynamic_format_specs) { - EXPECT_EQ("foo ", fmt::format(FMT_COMPILE("{:{}}"), "foo", 5)); - EXPECT_EQ(" 3.14", fmt::format(FMT_COMPILE("{:{}.{}f}"), 3.141592, 6, 2)); - EXPECT_EQ( - "=1.234ms=", - fmt::format(FMT_COMPILE("{:=^{}.{}}"), - std::chrono::duration<double, std::milli>(1.234), 9, 3)); -} - -TEST(compile_test, manual_ordering) { - EXPECT_EQ("42", fmt::format(FMT_COMPILE("{0}"), 42)); - EXPECT_EQ(" -42", fmt::format(FMT_COMPILE("{0:4}"), -42)); - EXPECT_EQ("41 43", fmt::format(FMT_COMPILE("{0} {1}"), 41, 43)); - EXPECT_EQ("41 43", fmt::format(FMT_COMPILE("{1} {0}"), 43, 41)); - EXPECT_EQ("41 43", fmt::format(FMT_COMPILE("{0} {2}"), 41, 42, 43)); - EXPECT_EQ(" 41 43", fmt::format(FMT_COMPILE("{1:{2}} {0:4}"), 43, 41, 4)); - EXPECT_EQ("42 1.2 ms ", - fmt::format(FMT_COMPILE("{0} {1:7.1%Q %q}"), 42, - std::chrono::duration<double, std::milli>(1.234))); - EXPECT_EQ( - "true 42 42 foo 0x1234 foo", - fmt::format(FMT_COMPILE("{0} {1} {2} {3} {4} {5}"), true, 42, 42.0f, - "foo", reinterpret_cast<void*>(0x1234), test_formattable())); - EXPECT_EQ(L"42", fmt::format(FMT_COMPILE(L"{0}"), 42)); -} - -TEST(compile_test, named) { - auto runtime_named_field_compiled = - fmt::detail::compile<decltype(fmt::arg("arg", 42))>(FMT_COMPILE("{arg}")); - static_assert(std::is_same_v<decltype(runtime_named_field_compiled), - fmt::detail::runtime_named_field<char>>); - - EXPECT_EQ("42", fmt::format(FMT_COMPILE("{}"), fmt::arg("arg", 42))); - EXPECT_EQ("41 43", fmt::format(FMT_COMPILE("{} {}"), fmt::arg("arg", 41), - fmt::arg("arg", 43))); - - EXPECT_EQ("foobar", - fmt::format(FMT_COMPILE("{a0}{a1}"), fmt::arg("a0", "foo"), - fmt::arg("a1", "bar"))); - EXPECT_EQ("foobar", fmt::format(FMT_COMPILE("{}{a1}"), fmt::arg("a0", "foo"), - fmt::arg("a1", "bar"))); - EXPECT_EQ("foofoo", fmt::format(FMT_COMPILE("{a0}{}"), fmt::arg("a0", "foo"), - fmt::arg("a1", "bar"))); - EXPECT_EQ("foobar", fmt::format(FMT_COMPILE("{0}{a1}"), fmt::arg("a0", "foo"), - fmt::arg("a1", "bar"))); - EXPECT_EQ("foobar", fmt::format(FMT_COMPILE("{a0}{1}"), fmt::arg("a0", "foo"), - fmt::arg("a1", "bar"))); - - EXPECT_EQ("foobar", - fmt::format(FMT_COMPILE("{}{a1}"), "foo", fmt::arg("a1", "bar"))); - EXPECT_EQ("foobar", - fmt::format(FMT_COMPILE("{a0}{a1}"), fmt::arg("a1", "bar"), - fmt::arg("a2", "baz"), fmt::arg("a0", "foo"))); - EXPECT_EQ(" bar foo ", - fmt::format(FMT_COMPILE(" {foo} {bar} "), fmt::arg("foo", "bar"), - fmt::arg("bar", "foo"))); - - EXPECT_THROW(fmt::format(FMT_COMPILE("{invalid}"), fmt::arg("valid", 42)), - fmt::format_error); - -# if FMT_USE_NONTYPE_TEMPLATE_ARGS - using namespace fmt::literals; - auto statically_named_field_compiled = - fmt::detail::compile<decltype("arg"_a = 42)>(FMT_COMPILE("{arg}")); - static_assert(std::is_same_v<decltype(statically_named_field_compiled), - fmt::detail::field<char, int, 0>>); - - EXPECT_EQ("41 43", - fmt::format(FMT_COMPILE("{a0} {a1}"), "a0"_a = 41, "a1"_a = 43)); - EXPECT_EQ("41 43", - fmt::format(FMT_COMPILE("{a1} {a0}"), "a0"_a = 43, "a1"_a = 41)); -# endif -} - -TEST(compile_test, join) { - unsigned char data[] = {0x1, 0x2, 0xaf}; - EXPECT_EQ("0102af", fmt::format(FMT_COMPILE("{:02x}"), fmt::join(data, ""))); -} - -TEST(compile_test, format_to) { - char buf[8]; - auto end = fmt::format_to(buf, FMT_COMPILE("{}"), 42); - *end = '\0'; - EXPECT_STREQ("42", buf); - end = fmt::format_to(buf, FMT_COMPILE("{:x}"), 42); - *end = '\0'; - EXPECT_STREQ("2a", buf); -} - -TEST(compile_test, format_to_n) { - constexpr auto buffer_size = 8; - char buffer[buffer_size]; - auto res = fmt::format_to_n(buffer, buffer_size, FMT_COMPILE("{}"), 42); - *res.out = '\0'; - EXPECT_STREQ("42", buffer); - res = fmt::format_to_n(buffer, buffer_size, FMT_COMPILE("{:x}"), 42); - *res.out = '\0'; - EXPECT_STREQ("2a", buffer); -} - -TEST(compile_test, output_iterators) { - std::list<char> out; - fmt::format_to(std::back_inserter(out), FMT_COMPILE("{}"), 42); - EXPECT_EQ("42", std::string(out.begin(), out.end())); - - std::stringstream s; - fmt::format_to(std::ostream_iterator<char>(s), FMT_COMPILE("{}"), 42); - EXPECT_EQ("42", s.str()); - - std::stringstream s2; - fmt::format_to(std::ostreambuf_iterator<char>(s2), FMT_COMPILE("{}.{:06d}"), - 42, 43); - EXPECT_EQ("42.000043", s2.str()); -} - -# if FMT_USE_CONSTEVAL && (!FMT_MSC_VERSION || FMT_MSC_VERSION >= 1940) -TEST(compile_test, constexpr_formatted_size) { - FMT_CONSTEXPR20 size_t size = fmt::formatted_size(FMT_COMPILE("{}"), 42); - EXPECT_EQ(size, 2); - FMT_CONSTEXPR20 size_t hex_size = - fmt::formatted_size(FMT_COMPILE("{:x}"), 15); - EXPECT_EQ(hex_size, 1); - FMT_CONSTEXPR20 size_t binary_size = - fmt::formatted_size(FMT_COMPILE("{:b}"), 15); - EXPECT_EQ(binary_size, 4); - FMT_CONSTEXPR20 size_t padded_size = - fmt::formatted_size(FMT_COMPILE("{:*^6}"), 42); - EXPECT_EQ(padded_size, 6); - FMT_CONSTEXPR20 size_t float_size = - fmt::formatted_size(FMT_COMPILE("{:.3}"), 12.345); - EXPECT_EQ(float_size, 4); - FMT_CONSTEXPR20 size_t str_size = - fmt::formatted_size(FMT_COMPILE("{:s}"), "abc"); - EXPECT_EQ(str_size, 3); -} - -TEST(compile_test, static_format) { - constexpr auto result = FMT_STATIC_FORMAT("{}", 42); - EXPECT_STREQ(result.c_str(), "42"); - EXPECT_EQ(result.str(), "42"); -} -# endif - -TEST(compile_test, text_and_arg) { - EXPECT_EQ(">>>42<<<", fmt::format(FMT_COMPILE(">>>{}<<<"), 42)); - EXPECT_EQ("42!", fmt::format(FMT_COMPILE("{}!"), 42)); -} - -TEST(compile_test, unknown_format_fallback) { - EXPECT_EQ(" 42 ", - fmt::format(FMT_COMPILE("{name:^4}"), fmt::arg("name", 42))); - - std::vector<char> v1; - fmt::format_to(std::back_inserter(v1), FMT_COMPILE("{}"), 42); - EXPECT_EQ("42", fmt::string_view(v1.data(), v1.size())); - - std::vector<char> v2; - fmt::format_to(std::back_inserter(v2), FMT_COMPILE("{name:^4}"), - fmt::arg("name", 42)); - EXPECT_EQ(" 42 ", fmt::string_view(v2.data(), v2.size())); - - char buffer[4]; - auto result = fmt::format_to_n(buffer, 4, FMT_COMPILE("{name:^5}"), - fmt::arg("name", 42)); - EXPECT_EQ(5u, result.size); - EXPECT_EQ(buffer + 4, result.out); - EXPECT_EQ(" 42 ", fmt::string_view(buffer, 4)); -} - -TEST(compile_test, empty) { EXPECT_EQ("", fmt::format(FMT_COMPILE(""))); } - -struct to_stringable { - friend fmt::string_view to_string_view(to_stringable) { return {}; } -}; - -FMT_BEGIN_NAMESPACE -template <> struct formatter<to_stringable> { - auto parse(format_parse_context& ctx) const -> decltype(ctx.begin()) { - return ctx.begin(); - } - - template <typename FormatContext> - auto format(const to_stringable&, FormatContext& ctx) -> decltype(ctx.out()) { - return ctx.out(); - } -}; -FMT_END_NAMESPACE - -TEST(compile_test, to_string_and_formatter) { - fmt::format(FMT_COMPILE("{}"), to_stringable()); -} - -struct std_context_test {}; - -FMT_BEGIN_NAMESPACE -template <> struct formatter<std_context_test> : formatter<int> { - auto format(std_context_test, format_context& ctx) const - -> decltype(ctx.out()) { - return ctx.out(); - } -}; -FMT_END_NAMESPACE - -TEST(compile_test, print) { - EXPECT_WRITE(stdout, fmt::print(FMT_COMPILE("Don't {}!"), "panic"), - "Don't panic!"); - EXPECT_WRITE(stderr, fmt::print(stderr, FMT_COMPILE("Don't {}!"), "panic"), - "Don't panic!"); - fmt::print(FMT_COMPILE("{}"), std_context_test()); -} -#endif - -#if FMT_USE_NONTYPE_TEMPLATE_ARGS -TEST(compile_test, compile_format_string_literal) { - using namespace fmt::literals; - EXPECT_EQ("", fmt::format(""_cf)); - EXPECT_EQ("42", fmt::format("{}"_cf, 42)); - EXPECT_EQ(L"42", fmt::format(L"{}"_cf, 42)); -} -#endif - -#if defined(__cpp_if_constexpr) && defined(__cpp_return_type_deduction) -template <typename S> auto check_is_compiled_string(const S&) -> bool { - return fmt::is_compiled_string<S>::value; -} - -TEST(compile_test, is_compiled_string) { - EXPECT_TRUE(check_is_compiled_string(FMT_COMPILE("asdf"))); - EXPECT_TRUE(check_is_compiled_string(FMT_COMPILE("{}"))); -} -#endif - -// MSVS 2019 19.29.30145.0 - OK -// MSVS 2022 19.32.31332.0, 19.37.32826.1 - compile-test.cc(362,3): fatal error -// C1001: Internal compiler error. -// (compiler file -// 'D:\a\_work\1\s\src\vctools\Compiler\CxxFE\sl\p1\c\constexpr\constexpr.cpp', -// line 8635) -#if FMT_USE_CONSTEVAL && \ - (!FMT_MSC_VERSION || \ - (FMT_MSC_VERSION >= 1928 && FMT_MSC_VERSION < 1930)) && \ - defined(__cpp_lib_is_constant_evaluated) -template <size_t max_string_length, typename Char = char> struct test_string { - template <typename T> constexpr auto operator==(const T& rhs) const -> bool { - return fmt::basic_string_view<Char>(rhs).compare(buffer) == 0; - } - Char buffer[max_string_length]{}; -}; - -template <size_t max_string_length, typename Char = char, typename... Args> -consteval auto test_format(auto format, const Args&... args) { - test_string<max_string_length, Char> string{}; - fmt::format_to(string.buffer, format, args...); - return string; -} - -TEST(compile_time_formatting_test, bool) { - EXPECT_EQ("true", test_format<5>(FMT_COMPILE("{}"), true)); - EXPECT_EQ("false", test_format<6>(FMT_COMPILE("{}"), false)); - EXPECT_EQ("true ", test_format<6>(FMT_COMPILE("{:5}"), true)); - EXPECT_EQ("1", test_format<2>(FMT_COMPILE("{:d}"), true)); -} - -TEST(compile_time_formatting_test, integer) { - EXPECT_EQ("42", test_format<3>(FMT_COMPILE("{}"), 42)); - EXPECT_EQ("420", test_format<4>(FMT_COMPILE("{}"), 420)); - EXPECT_EQ("42 42", test_format<6>(FMT_COMPILE("{} {}"), 42, 42)); - EXPECT_EQ("42 42", - test_format<6>(FMT_COMPILE("{} {}"), uint32_t{42}, uint64_t{42})); - - EXPECT_EQ("+42", test_format<4>(FMT_COMPILE("{:+}"), 42)); - EXPECT_EQ("42", test_format<3>(FMT_COMPILE("{:-}"), 42)); - EXPECT_EQ(" 42", test_format<4>(FMT_COMPILE("{: }"), 42)); - - EXPECT_EQ("-0042", test_format<6>(FMT_COMPILE("{:05}"), -42)); - - EXPECT_EQ("101010", test_format<7>(FMT_COMPILE("{:b}"), 42)); - EXPECT_EQ("0b101010", test_format<9>(FMT_COMPILE("{:#b}"), 42)); - EXPECT_EQ("0B101010", test_format<9>(FMT_COMPILE("{:#B}"), 42)); - EXPECT_EQ("042", test_format<4>(FMT_COMPILE("{:#o}"), 042)); - EXPECT_EQ("0x4a", test_format<5>(FMT_COMPILE("{:#x}"), 0x4a)); - EXPECT_EQ("0X4A", test_format<5>(FMT_COMPILE("{:#X}"), 0x4a)); - - EXPECT_EQ(" 42", test_format<6>(FMT_COMPILE("{:5}"), 42)); - EXPECT_EQ(" 42", test_format<6>(FMT_COMPILE("{:5}"), 42l)); - EXPECT_EQ(" 42", test_format<6>(FMT_COMPILE("{:5}"), 42ll)); - EXPECT_EQ(" 42", test_format<6>(FMT_COMPILE("{:5}"), 42ull)); - - EXPECT_EQ("42 ", test_format<5>(FMT_COMPILE("{:<4}"), 42)); - EXPECT_EQ(" 42", test_format<5>(FMT_COMPILE("{:>4}"), 42)); - EXPECT_EQ(" 42 ", test_format<5>(FMT_COMPILE("{:^4}"), 42)); - EXPECT_EQ("**-42", test_format<6>(FMT_COMPILE("{:*>5}"), -42)); -} - -TEST(compile_time_formatting_test, char) { - EXPECT_EQ("c", test_format<2>(FMT_COMPILE("{}"), 'c')); - - EXPECT_EQ("c ", test_format<4>(FMT_COMPILE("{:3}"), 'c')); - EXPECT_EQ("99", test_format<3>(FMT_COMPILE("{:d}"), 'c')); -} - -TEST(compile_time_formatting_test, string) { - EXPECT_EQ("42", test_format<3>(FMT_COMPILE("{}"), "42")); - EXPECT_EQ("The answer is 42", - test_format<17>(FMT_COMPILE("{} is {}"), "The answer", "42")); - - EXPECT_EQ("abc**", test_format<6>(FMT_COMPILE("{:*<5}"), "abc")); - EXPECT_EQ("**🤡**", test_format<9>(FMT_COMPILE("{:*^6}"), "🤡")); -} - -TEST(compile_time_formatting_test, combination) { - EXPECT_EQ("420, true, answer", - test_format<18>(FMT_COMPILE("{}, {}, {}"), 420, true, "answer")); - - EXPECT_EQ(" -42", test_format<5>(FMT_COMPILE("{:{}}"), -42, 4)); -} - -TEST(compile_time_formatting_test, custom_type) { - EXPECT_EQ("foo", test_format<4>(FMT_COMPILE("{}"), test_formattable())); - EXPECT_EQ("bar", test_format<4>(FMT_COMPILE("{:b}"), test_formattable())); -} - -TEST(compile_time_formatting_test, multibyte_fill) { - EXPECT_EQ("жж42", test_format<8>(FMT_COMPILE("{:ж>4}"), 42)); -} -#endif - -#if FMT_USE_CONSTEXPR_STRING -TEST(compile_test, constexpr_string_format) { - constexpr auto result = []() { - return fmt::format(FMT_COMPILE("{}"), 42) == "42"; - }(); - EXPECT_TRUE(result); - - // Test with a larger string to avoid small string optimization. - constexpr auto big = []() { - return fmt::format(FMT_COMPILE("{:100}"), ' ') == std::string(100, ' '); - }(); - EXPECT_TRUE(big); -} -#endif // FMT_USE_CONSTEXPR_STRING diff --git a/thirdparty/fmt/test/cuda-test/cpp14.cc b/thirdparty/fmt/test/cuda-test/cpp14.cc deleted file mode 100644 index 59db442ed..000000000 --- a/thirdparty/fmt/test/cuda-test/cpp14.cc +++ /dev/null @@ -1,11 +0,0 @@ -#include <fmt/base.h> - -// The purpose of this part is to ensure NVCC's host compiler also supports -// the standard version. See 'cuda-cpp14.cu'. -// -// https://en.cppreference.com/w/cpp/preprocessor/replace#Predefined_macros -static_assert(__cplusplus >= 201402L, "expect C++ 2014 for host compiler"); - -auto make_message_cpp() -> std::string { - return fmt::format("host compiler \t: __cplusplus == {}", __cplusplus); -} diff --git a/thirdparty/fmt/test/cuda-test/cuda-cpp14.cu b/thirdparty/fmt/test/cuda-test/cuda-cpp14.cu deleted file mode 100644 index 9fc36c931..000000000 --- a/thirdparty/fmt/test/cuda-test/cuda-cpp14.cu +++ /dev/null @@ -1,28 +0,0 @@ -// Direct NVCC command line example: -// -// nvcc ./cuda-cpp14.cu -x cu -I"../include" -l"fmtd" -L"../build/Debug" \ -// -std=c++14 -Xcompiler /std:c++14 -Xcompiler /Zc:__cplusplus - -// Ensure that we are using the latest C++ standard for NVCC -// The version is C++14 -// -// https://docs.nvidia.com/cuda/cuda-c-programming-guide/index.html#c-cplusplus-language-support -// https://en.cppreference.com/w/cpp/preprocessor/replace#Predefined_macros -static_assert(__cplusplus >= 201402L, "expect C++ 2014 for nvcc"); - -#include <fmt/base.h> - -#include <cuda.h> -#include <iostream> - -extern auto make_message_cpp() -> std::string; -extern auto make_message_cuda() -> std::string; - -int main() { - std::cout << make_message_cuda() << std::endl; - std::cout << make_message_cpp() << std::endl; -} - -auto make_message_cuda() -> std::string { - return fmt::format("nvcc compiler \t: __cplusplus == {}", __cplusplus); -} diff --git a/thirdparty/fmt/test/detect-stdfs.cc b/thirdparty/fmt/test/detect-stdfs.cc deleted file mode 100644 index 2dc665383..000000000 --- a/thirdparty/fmt/test/detect-stdfs.cc +++ /dev/null @@ -1,18 +0,0 @@ -// Formatting library for C++ - tests of formatters for standard library types -// -// Copyright (c) 2012 - present, Victor Zverovich -// All rights reserved. -// -// For the license information refer to format.h. - -#include <exception> // _GLIBCXX_RELEASE & _LIBCPP_VERSION - -#if defined(_GLIBCXX_RELEASE) && _GLIBCXX_RELEASE == 8 -# error libfound "stdc++fs" -#elif !defined(__apple_build_version__) && defined(_LIBCPP_VERSION) && \ - _LIBCPP_VERSION >= 7000 && _LIBCPP_VERSION < 9000 -# error libfound "c++fs" -#else -// none if std::filesystem does not require additional libraries -# error libfound "" -#endif diff --git a/thirdparty/fmt/test/enforce-checks-test.cc b/thirdparty/fmt/test/enforce-checks-test.cc deleted file mode 100644 index 960a7fcda..000000000 --- a/thirdparty/fmt/test/enforce-checks-test.cc +++ /dev/null @@ -1,65 +0,0 @@ -// Formatting library for C++ - formatting library tests -// -// Copyright (c) 2012 - present, Victor Zverovich -// All rights reserved. -// -// For the license information refer to format.h. - -#include <iterator> -#include <vector> - -#define I 42 // simulate https://en.cppreference.com/w/c/numeric/complex/I -#include "fmt/chrono.h" -#include "fmt/color.h" -#include "fmt/format.h" -#include "fmt/ostream.h" -#include "fmt/ranges.h" -#include "fmt/xchar.h" -#undef I - -// Exercise the API to verify that everything we expect to can compile. -void test_format_api() { - (void)fmt::format(FMT_STRING("{}"), 42); - (void)fmt::format(FMT_STRING(L"{}"), 42); - (void)fmt::format(FMT_STRING("noop")); - - (void)fmt::to_string(42); - (void)fmt::to_wstring(42); - - std::vector<char> out; - fmt::format_to(std::back_inserter(out), FMT_STRING("{}"), 42); - - char buffer[4]; - fmt::format_to_n(buffer, 3, FMT_STRING("{}"), 12345); - - wchar_t wbuffer[4]; - fmt::format_to_n(wbuffer, 3, FMT_STRING(L"{}"), 12345); -} - -void test_chrono() { - (void)fmt::format(FMT_STRING("{}"), std::chrono::seconds(42)); - (void)fmt::format(FMT_STRING(L"{}"), std::chrono::seconds(42)); -} - -void test_text_style() { - fmt::print(fg(fmt::rgb(255, 20, 30)), FMT_STRING("{}"), "rgb(255,20,30)"); - (void)fmt::format(fg(fmt::rgb(255, 20, 30)), FMT_STRING("{}"), - "rgb(255,20,30)"); - - fmt::text_style ts = fg(fmt::rgb(255, 20, 30)); - std::string out; - fmt::format_to(std::back_inserter(out), ts, - FMT_STRING("rgb(255,20,30){}{}{}"), 1, 2, 3); -} - -void test_range() { - std::vector<char> hello = {'h', 'e', 'l', 'l', 'o'}; - (void)fmt::format(FMT_STRING("{}"), hello); -} - -int main() { - test_format_api(); - test_chrono(); - test_text_style(); - test_range(); -} diff --git a/thirdparty/fmt/test/find-package-test/main.cc b/thirdparty/fmt/test/find-package-test/main.cc deleted file mode 100644 index 911e0e8d1..000000000 --- a/thirdparty/fmt/test/find-package-test/main.cc +++ /dev/null @@ -1,5 +0,0 @@ -#include "fmt/format.h" - -int main(int argc, char** argv) { - for (int i = 0; i < argc; ++i) fmt::print("{}: {}\n", i, argv[i]); -} diff --git a/thirdparty/fmt/test/format-impl-test.cc b/thirdparty/fmt/test/format-impl-test.cc deleted file mode 100644 index 3b0e07e32..000000000 --- a/thirdparty/fmt/test/format-impl-test.cc +++ /dev/null @@ -1,477 +0,0 @@ -// Formatting library for C++ - formatting library implementation tests -// -// Copyright (c) 2012 - present, Victor Zverovich -// All rights reserved. -// -// For the license information refer to format.h. - -#include <algorithm> -#include <cstring> - -// clang-format off -#include "test-assert.h" -// clang-format on - -#include "fmt/format.h" -#include "gmock/gmock.h" -#include "util.h" - -using fmt::detail::bigint; -using fmt::detail::fp; -using fmt::detail::max_value; - -static_assert(!std::is_copy_constructible<bigint>::value, ""); -static_assert(!std::is_copy_assignable<bigint>::value, ""); - -TEST(bigint_test, construct) { - EXPECT_EQ(fmt::to_string(bigint()), ""); - EXPECT_EQ(fmt::to_string(bigint(0x42)), "42"); - EXPECT_EQ(fmt::to_string(bigint(0x123456789abcedf0)), "123456789abcedf0"); -} - -TEST(bigint_test, compare) { - bigint n1(42); - bigint n2(42); - EXPECT_EQ(compare(n1, n2), 0); - n2 <<= 32; - EXPECT_LT(compare(n1, n2), 0); - bigint n3(43); - EXPECT_LT(compare(n1, n3), 0); - EXPECT_GT(compare(n3, n1), 0); - bigint n4(42 * 0x100000001); - EXPECT_LT(compare(n2, n4), 0); - EXPECT_GT(compare(n4, n2), 0); -} - -TEST(bigint_test, add_compare) { - EXPECT_LT( - add_compare(bigint(0xffffffff), bigint(0xffffffff), bigint(1) <<= 64), 0); - EXPECT_LT(add_compare(bigint(1) <<= 32, bigint(1), bigint(1) <<= 96), 0); - EXPECT_GT(add_compare(bigint(1) <<= 32, bigint(0), bigint(0xffffffff)), 0); - EXPECT_GT(add_compare(bigint(0), bigint(1) <<= 32, bigint(0xffffffff)), 0); - EXPECT_GT(add_compare(bigint(42), bigint(1), bigint(42)), 0); - EXPECT_GT(add_compare(bigint(0xffffffff), bigint(1), bigint(0xffffffff)), 0); - EXPECT_LT(add_compare(bigint(10), bigint(10), bigint(22)), 0); - EXPECT_LT(add_compare(bigint(0x100000010), bigint(0x100000010), - bigint(0x300000010)), - 0); - EXPECT_GT(add_compare(bigint(0x1ffffffff), bigint(0x100000002), - bigint(0x300000000)), - 0); - EXPECT_EQ(add_compare(bigint(0x1ffffffff), bigint(0x100000002), - bigint(0x300000001)), - 0); - EXPECT_LT(add_compare(bigint(0x1ffffffff), bigint(0x100000002), - bigint(0x300000002)), - 0); - EXPECT_LT(add_compare(bigint(0x1ffffffff), bigint(0x100000002), - bigint(0x300000003)), - 0); -} - -TEST(bigint_test, shift_left) { - bigint n(0x42); - n <<= 0; - EXPECT_EQ(fmt::to_string(n), "42"); - n <<= 1; - EXPECT_EQ(fmt::to_string(n), "84"); - n <<= 25; - EXPECT_EQ(fmt::to_string(n), "108000000"); -} - -TEST(bigint_test, multiply) { - bigint n(0x42); - EXPECT_THROW(n *= 0, assertion_failure); - n *= 1; - EXPECT_EQ(fmt::to_string(n), "42"); - - n *= 2; - EXPECT_EQ(fmt::to_string(n), "84"); - n *= 0x12345678; - EXPECT_EQ(fmt::to_string(n), "962fc95e0"); - - bigint bigmax(max_value<uint32_t>()); - bigmax *= max_value<uint32_t>(); - EXPECT_EQ(fmt::to_string(bigmax), "fffffffe00000001"); - - const auto max64 = max_value<uint64_t>(); - bigmax = max64; - bigmax *= max64; - EXPECT_EQ(fmt::to_string(bigmax), "fffffffffffffffe0000000000000001"); - - const auto max128 = (fmt::detail::uint128_t(max64) << 64) | max64; - bigmax = max128; - bigmax *= max128; - EXPECT_EQ(fmt::to_string(bigmax), - "fffffffffffffffffffffffffffffffe00000000000000000000000000000001"); -} - -TEST(bigint_test, square) { - bigint n0(0); - n0.square(); - EXPECT_EQ(fmt::to_string(n0), "0"); - bigint n1(0x100); - n1.square(); - EXPECT_EQ(fmt::to_string(n1), "10000"); - bigint n2(0xfffffffff); - n2.square(); - EXPECT_EQ(fmt::to_string(n2), "ffffffffe000000001"); - bigint n3(max_value<uint64_t>()); - n3.square(); - EXPECT_EQ(fmt::to_string(n3), "fffffffffffffffe0000000000000001"); - bigint n4; - n4.assign_pow10(10); - EXPECT_EQ(fmt::to_string(n4), "2540be400"); -} - -TEST(bigint_test, divmod_assign_zero_divisor) { - bigint zero(0); - EXPECT_THROW(bigint(0).divmod_assign(zero), assertion_failure); - EXPECT_THROW(bigint(42).divmod_assign(zero), assertion_failure); -} - -TEST(bigint_test, divmod_assign_self) { - bigint n(100); - EXPECT_THROW(n.divmod_assign(n), assertion_failure); -} - -TEST(bigint_test, divmod_assign_unaligned) { - // (42 << 340) / pow(10, 100): - bigint n1(42); - n1 <<= 340; - bigint n2; - n2.assign_pow10(100); - int result = n1.divmod_assign(n2); - EXPECT_EQ(result, 9406); - EXPECT_EQ(fmt::to_string(n1), - "10f8353019583bfc29ffc8f564e1b9f9d819dbb4cf783e4507eca1539220p96"); -} - -TEST(bigint_test, divmod_assign) { - // 100 / 10: - bigint n1(100); - int result = n1.divmod_assign(bigint(10)); - EXPECT_EQ(result, 10); - EXPECT_EQ(fmt::to_string(n1), "0"); - // pow(10, 100) / (42 << 320): - n1.assign_pow10(100); - result = n1.divmod_assign(bigint(42) <<= 320); - EXPECT_EQ(result, 111); - EXPECT_EQ(fmt::to_string(n1), - "13ad2594c37ceb0b2784c4ce0bf38ace408e211a7caab24308a82e8f10p96"); - // 42 / 100: - bigint n2(42); - n1.assign_pow10(2); - result = n2.divmod_assign(n1); - EXPECT_EQ(result, 0); - EXPECT_EQ(fmt::to_string(n2), "2a"); -} - -template <bool is_iec559> void run_double_tests() { - fmt::print("warning: double is not IEC559, skipping FP tests\n"); -} - -template <> void run_double_tests<true>() { - // Construct from double. - EXPECT_EQ(fp(1.23), fp(0x13ae147ae147aeu, -52)); -} - -TEST(fp_test, double_tests) { - run_double_tests<std::numeric_limits<double>::is_iec559>(); -} - -TEST(fp_test, normalize) { - const auto v = fp(0xbeef, 42); - auto normalized = normalize(v); - EXPECT_EQ(normalized.f, 0xbeef000000000000); - EXPECT_EQ(normalized.e, -6); -} - -TEST(fp_test, multiply) { - auto v = fp(123ULL << 32, 4) * fp(56ULL << 32, 7); - EXPECT_EQ(v.f, 123u * 56u); - EXPECT_EQ(v.e, 4 + 7 + 64); - v = fp(123ULL << 32, 4) * fp(567ULL << 31, 8); - EXPECT_EQ(v.f, (123 * 567 + 1u) / 2); - EXPECT_EQ(v.e, 4 + 8 + 64); -} - -TEST(fp_test, dragonbox_max_k) { - using fmt::detail::dragonbox::floor_log10_pow2; - using float_info = fmt::detail::dragonbox::float_info<float>; - EXPECT_EQ( - fmt::detail::const_check(float_info::max_k), - float_info::kappa - - floor_log10_pow2(std::numeric_limits<float>::min_exponent - - fmt::detail::num_significand_bits<float>() - 1)); - using double_info = fmt::detail::dragonbox::float_info<double>; - EXPECT_EQ(fmt::detail::const_check(double_info::max_k), - double_info::kappa - - floor_log10_pow2( - std::numeric_limits<double>::min_exponent - - 2 * fmt::detail::num_significand_bits<double>() - 1)); -} - -TEST(format_impl_test, format_error_code) { - std::string msg = "error 42", sep = ": "; - { - auto buffer = fmt::memory_buffer(); - fmt::format_to(fmt::appender(buffer), "garbage"); - fmt::detail::format_error_code(buffer, 42, "test"); - EXPECT_EQ(to_string(buffer), "test: " + msg); - } - { - auto buffer = fmt::memory_buffer(); - auto prefix = - std::string(fmt::inline_buffer_size - msg.size() - sep.size() + 1, 'x'); - fmt::detail::format_error_code(buffer, 42, prefix); - EXPECT_EQ(msg, to_string(buffer)); - } - int codes[] = {42, -1}; - for (size_t i = 0, n = sizeof(codes) / sizeof(*codes); i < n; ++i) { - // Test maximum buffer size. - msg = fmt::format("error {}", codes[i]); - fmt::memory_buffer buffer; - auto prefix = - std::string(fmt::inline_buffer_size - msg.size() - sep.size(), 'x'); - fmt::detail::format_error_code(buffer, codes[i], prefix); - EXPECT_EQ(prefix + sep + msg, to_string(buffer)); - size_t size = fmt::inline_buffer_size; - EXPECT_EQ(size, buffer.size()); - buffer.resize(0); - // Test with a message that doesn't fit into the buffer. - prefix += 'x'; - fmt::detail::format_error_code(buffer, codes[i], prefix); - EXPECT_EQ(to_string(buffer), msg); - } -} - -// Tests fmt::detail::count_digits for integer type Int. -template <typename Int> void test_count_digits() { - for (Int i = 0; i < 10; ++i) EXPECT_EQ(1u, fmt::detail::count_digits(i)); - for (Int i = 1, n = 1, end = max_value<Int>() / 10; n <= end; ++i) { - n *= 10; - EXPECT_EQ(fmt::detail::count_digits(n - 1), i); - EXPECT_EQ(fmt::detail::count_digits(n), i + 1); - } -} - -TEST(format_impl_test, count_digits) { - test_count_digits<uint32_t>(); - test_count_digits<uint64_t>(); -} - -TEST(format_impl_test, countl_zero) { - constexpr auto num_bits = fmt::detail::num_bits<uint32_t>(); - uint32_t n = 1u; - for (int i = 1; i < num_bits - 1; i++) { - n <<= 1; - EXPECT_EQ(fmt::detail::countl_zero(n - 1), num_bits - i); - EXPECT_EQ(fmt::detail::countl_zero(n), num_bits - i - 1); - } -} - -#if FMT_USE_FLOAT128 -TEST(format_impl_test, write_float128) { - auto s = std::string(); - fmt::detail::write<char>(std::back_inserter(s), __float128(42)); - EXPECT_EQ(s, "42"); -} -#endif - -struct double_double { - double a; - double b; - - constexpr explicit double_double(double a_val = 0, double b_val = 0) - : a(a_val), b(b_val) {} - - operator double() const { return a + b; } - auto operator-() const -> double_double { return double_double(-a, -b); } -}; - -auto format_as(double_double d) -> double { return d; } - -auto operator>=(const double_double& lhs, const double_double& rhs) -> bool { - return lhs.a + lhs.b >= rhs.a + rhs.b; -} - -struct slow_float { - float value; - - constexpr explicit slow_float(float val = 0) : value(val) {} - operator float() const { return value; } - auto operator-() const -> slow_float { return slow_float(-value); } -}; - -auto format_as(slow_float f) -> float { return f; } - -namespace std { -template <> struct numeric_limits<double_double> { - // is_iec559 is true for double-double in libstdc++. - static constexpr bool is_iec559 = true; - static constexpr int digits = 106; - static constexpr int digits10 = 33; -}; - -template <> struct numeric_limits<slow_float> : numeric_limits<float> {}; -} // namespace std - -FMT_BEGIN_NAMESPACE -namespace detail { -template <> struct is_floating_point<double_double> : std::true_type {}; -template <> struct is_floating_point<slow_float> : std::true_type {}; -template <> struct is_fast_float<slow_float> : std::false_type {}; -namespace dragonbox { -template <> struct float_info<slow_float> { - using carrier_uint = uint32_t; - static const int exponent_bits = 8; -}; -} // namespace dragonbox -} // namespace detail -FMT_END_NAMESPACE - -TEST(format_impl_test, write_double_double) { - auto s = std::string(); - fmt::detail::write<char>(std::back_inserter(s), double_double(42), {}); - // Specializing is_floating_point is broken in MSVC. - if (!FMT_MSC_VERSION) EXPECT_EQ(s, "42"); -} - -TEST(format_impl_test, write_dragon_even) { - auto s = std::string(); - fmt::detail::write<char>(std::back_inserter(s), slow_float(33554450.0f), {}); - // Specializing is_floating_point is broken in MSVC. - if (!FMT_MSC_VERSION) EXPECT_EQ(s, "3.355445e+07"); -} - -#if defined(_WIN32) && !defined(FMT_USE_WRITE_CONSOLE) -# include <windows.h> - -TEST(format_impl_test, write_console_signature) { - decltype(::WriteConsoleW)* p = fmt::detail::WriteConsoleW; - (void)p; -} -#endif - -// A public domain branchless UTF-8 decoder by Christopher Wellons: -// https://github.com/skeeto/branchless-utf8 -constexpr auto unicode_is_surrogate(uint32_t c) -> bool { - return c >= 0xD800U && c <= 0xDFFFU; -} - -FMT_CONSTEXPR auto utf8_encode(char* s, uint32_t c) -> char* { - if (c >= (1UL << 16)) { - s[0] = static_cast<char>(0xf0 | (c >> 18)); - s[1] = static_cast<char>(0x80 | ((c >> 12) & 0x3f)); - s[2] = static_cast<char>(0x80 | ((c >> 6) & 0x3f)); - s[3] = static_cast<char>(0x80 | ((c >> 0) & 0x3f)); - return s + 4; - } else if (c >= (1UL << 11)) { - s[0] = static_cast<char>(0xe0 | (c >> 12)); - s[1] = static_cast<char>(0x80 | ((c >> 6) & 0x3f)); - s[2] = static_cast<char>(0x80 | ((c >> 0) & 0x3f)); - return s + 3; - } else if (c >= (1UL << 7)) { - s[0] = static_cast<char>(0xc0 | (c >> 6)); - s[1] = static_cast<char>(0x80 | ((c >> 0) & 0x3f)); - return s + 2; - } else { - s[0] = static_cast<char>(c); - return s + 1; - } -} - -// Make sure it can decode every character -TEST(format_impl_test, utf8_decode_decode_all) { - for (uint32_t i = 0; i < 0x10ffff; i++) { - if (!unicode_is_surrogate(i)) { - int e; - uint32_t c; - char buf[8] = {0}; - char* end = utf8_encode(buf, i); - const char* res = fmt::detail::utf8_decode(buf, &c, &e); - EXPECT_EQ(end, res); - EXPECT_EQ(c, i); - EXPECT_EQ(e, 0); - } - } -} - -// Reject everything outside of U+0000..U+10FFFF -TEST(format_impl_test, utf8_decode_out_of_range) { - for (uint32_t i = 0x110000; i < 0x1fffff; i++) { - int e; - uint32_t c; - char buf[8] = {0}; - utf8_encode(buf, i); - const char* end = fmt::detail::utf8_decode(buf, &c, &e); - EXPECT_NE(e, 0); - EXPECT_EQ(end - buf, 4); - } -} - -// Does it reject all surrogate halves? -TEST(format_impl_test, utf8_decode_surrogate_halves) { - for (uint32_t i = 0xd800; i <= 0xdfff; i++) { - int e; - uint32_t c; - char buf[8] = {0}; - utf8_encode(buf, i); - fmt::detail::utf8_decode(buf, &c, &e); - EXPECT_NE(e, 0); - } -} - -// How about non-canonical encodings? -TEST(format_impl_test, utf8_decode_non_canonical_encodings) { - int e; - uint32_t c; - const char* end; - - char buf2[8] = {char(0xc0), char(0xA4)}; - end = fmt::detail::utf8_decode(buf2, &c, &e); - EXPECT_NE(e, 0); // non-canonical len 2 - EXPECT_EQ(end, buf2 + 2); // non-canonical recover 2 - - char buf3[8] = {char(0xe0), char(0x80), char(0xA4)}; - end = fmt::detail::utf8_decode(buf3, &c, &e); - EXPECT_NE(e, 0); // non-canonical len 3 - EXPECT_EQ(end, buf3 + 3); // non-canonical recover 3 - - char buf4[8] = {char(0xf0), char(0x80), char(0x80), char(0xA4)}; - end = fmt::detail::utf8_decode(buf4, &c, &e); - EXPECT_NE(e, 0); // non-canonical encoding len 4 - EXPECT_EQ(end, buf4 + 4); // non-canonical recover 4 -} - -// Let's try some bogus byte sequences -TEST(format_impl_test, utf8_decode_bogus_byte_sequences) { - int e; - uint32_t c; - - // Invalid first byte - char buf0[4] = {char(0xff)}; - auto len = fmt::detail::utf8_decode(buf0, &c, &e) - buf0; - EXPECT_NE(e, 0); // "bogus [ff] 0x%02x U+%04lx", e, (unsigned long)c); - EXPECT_EQ(len, 1); // "bogus [ff] recovery %d", len); - - // Invalid first byte - char buf1[4] = {char(0x80)}; - len = fmt::detail::utf8_decode(buf1, &c, &e) - buf1; - EXPECT_NE(e, 0); // "bogus [80] 0x%02x U+%04lx", e, (unsigned long)c); - EXPECT_EQ(len, 1); // "bogus [80] recovery %d", len); - - // Looks like a two-byte sequence but second byte is wrong - char buf2[4] = {char(0xc0), char(0x0a)}; - len = fmt::detail::utf8_decode(buf2, &c, &e) - buf2; - EXPECT_NE(e, 0); // "bogus [c0 0a] 0x%02x U+%04lx", e, (unsigned long)c - EXPECT_EQ(len, 2); // "bogus [c0 0a] recovery %d", len); -} - -TEST(format_impl_test, to_utf8) { - auto s = std::string("ёжик"); - auto u = fmt::detail::to_utf8<wchar_t>(L"\x0451\x0436\x0438\x043A"); - EXPECT_EQ(s, u.str()); - EXPECT_EQ(s.size(), u.size()); -} diff --git a/thirdparty/fmt/test/format-test.cc b/thirdparty/fmt/test/format-test.cc deleted file mode 100644 index 71bfe61d4..000000000 --- a/thirdparty/fmt/test/format-test.cc +++ /dev/null @@ -1,2679 +0,0 @@ -// Formatting library for C++ - formatting library tests -// -// Copyright (c) 2012 - present, Victor Zverovich -// All rights reserved. -// -// For the license information refer to format.h. - -// Check if fmt/format.h compiles with windows.h included before it. -#ifdef _WIN32 -# include <windows.h> -#endif -// clang-format off -#include "fmt/format.h" -// clang-format on - -#include <stdint.h> // uint32_t - -#include <cfenv> // fegetexceptflag and FE_ALL_EXCEPT -#include <climits> // INT_MAX -#include <cmath> // std::signbit -#include <condition_variable> // std::condition_variable -#include <cstring> // std::strlen -#include <iterator> // std::back_inserter -#include <list> // std::list -#include <mutex> // std::mutex -#include <string> // std::string -#include <thread> // std::thread -#include <type_traits> // std::is_default_constructible -#if FMT_CPLUSPLUS > 201703L && FMT_HAS_INCLUDE(<version>) -# include <version> -#endif - -#include <limits.h> - -#include <limits> - -#include "gtest-extra.h" -#include "mock-allocator.h" -#include "util.h" -using fmt::basic_memory_buffer; -using fmt::format_error; -using fmt::memory_buffer; -using fmt::runtime; -using fmt::string_view; -using fmt::detail::max_value; -using fmt::detail::uint128_fallback; - -using testing::Return; -using testing::StrictMock; - -#ifdef __cpp_lib_concepts -static_assert(std::output_iterator<fmt::appender, char>); -#endif - -enum { buffer_size = 256 }; - -TEST(uint128_test, ctor) { - auto n = uint128_fallback(); - EXPECT_EQ(n, 0); - n = uint128_fallback(42); - EXPECT_EQ(n, 42); - EXPECT_EQ(static_cast<uint64_t>(n), 42); -} - -TEST(uint128_test, shift) { - auto n = uint128_fallback(42); - n = n << 64; - EXPECT_EQ(static_cast<uint64_t>(n), 0); - n = n >> 64; - EXPECT_EQ(static_cast<uint64_t>(n), 42); - n = n << 62; - EXPECT_EQ(static_cast<uint64_t>(n >> 64), 0xa); - EXPECT_EQ(static_cast<uint64_t>(n), 0x8000000000000000); - n = n >> 62; - EXPECT_EQ(static_cast<uint64_t>(n), 42); - EXPECT_EQ(uint128_fallback(1) << 112, uint128_fallback(0x1000000000000, 0)); - EXPECT_EQ(uint128_fallback(0x1000000000000, 0) >> 112, uint128_fallback(1)); -} - -TEST(uint128_test, minus) { - auto n = uint128_fallback(42); - EXPECT_EQ(n - 2, 40); -} - -TEST(uint128_test, plus_assign) { - auto n = uint128_fallback(32); - n += uint128_fallback(10); - EXPECT_EQ(n, 42); - n = uint128_fallback(max_value<uint64_t>()); - n += uint128_fallback(1); - EXPECT_EQ(n, uint128_fallback(1) << 64); -} - -TEST(uint128_test, multiply) { - auto n = uint128_fallback(2251799813685247); - n = n * 3611864890; - EXPECT_EQ(static_cast<uint64_t>(n >> 64), 440901); -} - -template <typename Float> void check_isfinite() { - using fmt::detail::isfinite; - EXPECT_TRUE(isfinite(Float(0.0))); - EXPECT_TRUE(isfinite(Float(42.0))); - EXPECT_TRUE(isfinite(Float(-42.0))); - EXPECT_TRUE(isfinite(Float(fmt::detail::max_value<double>()))); - // Use double because std::numeric_limits is broken for __float128. - using limits = std::numeric_limits<double>; - FMT_CONSTEXPR20 auto result = isfinite(Float(limits::infinity())); - EXPECT_FALSE(result); - EXPECT_FALSE(isfinite(Float(limits::infinity()))); - EXPECT_FALSE(isfinite(Float(-limits::infinity()))); - EXPECT_FALSE(isfinite(Float(limits::quiet_NaN()))); - EXPECT_FALSE(isfinite(Float(-limits::quiet_NaN()))); -} - -TEST(float_test, isfinite) { - check_isfinite<double>(); -#if FMT_USE_FLOAT128 - check_isfinite<fmt::detail::float128>(); -#endif -} - -void check_no_fp_exception() { - fexcept_t fe; - fegetexceptflag(&fe, FE_ALL_EXCEPT); - - // No exception flags should have been set - EXPECT_TRUE(fe == 0); -} - -template <typename Float> void check_isnan() { - using fmt::detail::isnan; - EXPECT_FALSE(isnan(Float(0.0))); - EXPECT_FALSE(isnan(Float(42.0))); - EXPECT_FALSE(isnan(Float(-42.0))); - EXPECT_FALSE(isnan(Float(fmt::detail::max_value<double>()))); - // Use double because std::numeric_limits is broken for __float128. - using limits = std::numeric_limits<double>; - EXPECT_FALSE(isnan(Float(limits::infinity()))); - EXPECT_FALSE(isnan(Float(-limits::infinity()))); - EXPECT_TRUE(isnan(Float(limits::quiet_NaN()))); - EXPECT_TRUE(isnan(Float(-limits::quiet_NaN()))); - - // Sanity check: make sure no error has occurred before we start - check_no_fp_exception(); - - // Check that no exception is raised for the non-NaN case - isnan(Float(42.0)); - check_no_fp_exception(); - - // Check that no exception is raised for the NaN case - isnan(Float(limits::quiet_NaN())); - check_no_fp_exception(); -} - -TEST(float_test, isnan) { - check_isnan<double>(); -#if FMT_USE_FLOAT128 - check_isnan<fmt::detail::float128>(); -#endif -} - -struct uint32_pair { - uint32_t u[2]; -}; - -TEST(util_test, bit_cast) { - auto s = fmt::detail::bit_cast<uint32_pair>(uint64_t{42}); - EXPECT_EQ(fmt::detail::bit_cast<uint64_t>(s), 42ull); - s = fmt::detail::bit_cast<uint32_pair>(~uint64_t{0}); - EXPECT_EQ(fmt::detail::bit_cast<uint64_t>(s), ~0ull); -} - -// Increment a number in a string. -void increment(char* s) { - for (int i = static_cast<int>(std::strlen(s)) - 1; i >= 0; --i) { - if (s[i] != '9') { - ++s[i]; - break; - } - s[i] = '0'; - } -} - -TEST(util_test, increment) { - char s[10] = "123"; - increment(s); - EXPECT_STREQ("124", s); - s[2] = '8'; - increment(s); - EXPECT_STREQ("129", s); - increment(s); - EXPECT_STREQ("130", s); - s[1] = s[2] = '9'; - increment(s); - EXPECT_STREQ("200", s); -} - -TEST(util_test, parse_nonnegative_int) { - auto s = fmt::string_view("10000000000"); - auto begin = s.begin(), end = s.end(); - EXPECT_EQ(fmt::detail::parse_nonnegative_int(begin, end, -1), -1); - s = "2147483649"; - begin = s.begin(); - end = s.end(); - EXPECT_EQ(fmt::detail::parse_nonnegative_int(begin, end, -1), -1); -} - -TEST(util_test, utf8_to_utf16) { - auto u = fmt::detail::utf8_to_utf16("лошадка"); - EXPECT_EQ(L"\x043B\x043E\x0448\x0430\x0434\x043A\x0430", u.str()); - EXPECT_EQ(7, u.size()); - // U+10437 { DESERET SMALL LETTER YEE } - EXPECT_EQ(L"\xD801\xDC37", fmt::detail::utf8_to_utf16("𐐷").str()); - EXPECT_THROW_MSG(fmt::detail::utf8_to_utf16("\xc3\x28"), std::runtime_error, - "invalid utf8"); - EXPECT_THROW_MSG(fmt::detail::utf8_to_utf16(fmt::string_view("л", 1)), - std::runtime_error, "invalid utf8"); - EXPECT_EQ(L"123456", fmt::detail::utf8_to_utf16("123456").str()); -} - -TEST(util_test, utf8_to_utf16_empty_string) { - auto s = std::string(); - auto u = fmt::detail::utf8_to_utf16(s.c_str()); - EXPECT_EQ(L"", u.str()); - EXPECT_EQ(s.size(), u.size()); -} - -TEST(util_test, allocator_ref) { - using test_allocator_ref = allocator_ref<mock_allocator<int>>; - auto check_forwarding = [](mock_allocator<int>& alloc, - test_allocator_ref& ref) { - int mem; - // Check if value_type is properly defined. - allocator_ref<mock_allocator<int>>::value_type* ptr = &mem; - // Check forwarding. - EXPECT_CALL(alloc, allocate(42)).WillOnce(Return(ptr)); - ref.allocate(42); - EXPECT_CALL(alloc, deallocate(ptr, 42)); - ref.deallocate(ptr, 42); - }; - - StrictMock<mock_allocator<int>> alloc; - auto ref = test_allocator_ref(&alloc); - // Check if allocator_ref forwards to the underlying allocator. - check_forwarding(alloc, ref); - test_allocator_ref ref2(ref); - check_forwarding(alloc, ref2); - test_allocator_ref ref3; - EXPECT_EQ(nullptr, ref3.get()); - ref3 = ref; - check_forwarding(alloc, ref3); -} - -TEST(util_test, format_system_error) { - fmt::memory_buffer message; - fmt::format_system_error(message, EDOM, "test"); - auto ec = std::error_code(EDOM, std::generic_category()); - EXPECT_EQ(to_string(message), std::system_error(ec, "test").what()); - message = fmt::memory_buffer(); - - // Check if std::allocator throws on allocating max size_t / 2 chars. - size_t max_size = max_value<size_t>() / 2; - bool throws_on_alloc = false; - try { - auto alloc = std::allocator<char>(); - alloc.deallocate(alloc.allocate(max_size), max_size); - } catch (const std::bad_alloc&) { - throws_on_alloc = true; - } - if (!throws_on_alloc) { - fmt::print(stderr, "warning: std::allocator allocates {} chars\n", - max_size); - return; - } -} - -TEST(util_test, system_error) { - auto test_error = fmt::system_error(EDOM, "test"); - auto ec = std::error_code(EDOM, std::generic_category()); - EXPECT_STREQ(test_error.what(), std::system_error(ec, "test").what()); - EXPECT_EQ(test_error.code(), ec); - - auto error = std::system_error(std::error_code()); - try { - throw fmt::system_error(EDOM, "test {}", "error"); - } catch (const std::system_error& e) { - error = e; - } - fmt::memory_buffer message; - fmt::format_system_error(message, EDOM, "test error"); - EXPECT_EQ(error.what(), to_string(message)); - EXPECT_EQ(error.code(), std::error_code(EDOM, std::generic_category())); -} - -TEST(util_test, report_system_error) { - fmt::memory_buffer out; - fmt::format_system_error(out, EDOM, "test error"); - out.push_back('\n'); - EXPECT_WRITE(stderr, fmt::report_system_error(EDOM, "test error"), - to_string(out)); -} - -TEST(memory_buffer_test, ctor) { - basic_memory_buffer<char, 123> buffer; - EXPECT_EQ(static_cast<size_t>(0), buffer.size()); - EXPECT_EQ(123u, buffer.capacity()); -} - -using std_allocator = allocator_ref<std::allocator<char>>; - -TEST(memory_buffer_test, move_ctor_inline_buffer) { - auto check_move_buffer = - [](const char* str, basic_memory_buffer<char, 5, std_allocator>& buffer) { - std::allocator<char>* alloc = buffer.get_allocator().get(); - basic_memory_buffer<char, 5, std_allocator> buffer2(std::move(buffer)); - // Move shouldn't destroy the inline content of the first buffer. - EXPECT_EQ(std::string(buffer.data(), buffer.size()), str); - EXPECT_EQ(std::string(&buffer2[0], buffer2.size()), str); - EXPECT_EQ(buffer2.capacity(), 5u); - // Move should transfer allocator. - EXPECT_EQ(buffer.get_allocator().get(), nullptr); - EXPECT_EQ(buffer2.get_allocator().get(), alloc); - }; - - auto alloc = std::allocator<char>(); - basic_memory_buffer<char, 5, std_allocator> buffer((std_allocator(&alloc))); - buffer.append(string_view("test")); - check_move_buffer("test", buffer); - // Adding one more character fills the inline buffer, but doesn't cause - // dynamic allocation. - buffer.push_back('a'); - check_move_buffer("testa", buffer); -} - -TEST(memory_buffer_test, move_ctor_dynamic_buffer) { - auto alloc = std::allocator<char>(); - basic_memory_buffer<char, 4, std_allocator> buffer((std_allocator(&alloc))); - const char test[] = "test"; - buffer.append(test, test + 4); - const char* inline_buffer_ptr = &buffer[0]; - // Adding one more character causes the content to move from the inline to - // a dynamically allocated buffer. - buffer.push_back('a'); - basic_memory_buffer<char, 4, std_allocator> buffer2(std::move(buffer)); - // Move should rip the guts of the first buffer. - EXPECT_EQ(&buffer[0], inline_buffer_ptr); - EXPECT_EQ(buffer.size(), 0); - EXPECT_EQ(std::string(&buffer2[0], buffer2.size()), "testa"); - EXPECT_GT(buffer2.capacity(), 4u); -} - -using std_allocator_noprop = allocator_ref<std::allocator<char>, false>; - -TEST(memory_buffer_test, move_ctor_inline_buffer_non_propagating) { - auto check_move_buffer = - [](const char* str, - basic_memory_buffer<char, 5, std_allocator_noprop>& buffer) { - std::allocator<char>* original_alloc_ptr = buffer.get_allocator().get(); - const char* original_data_ptr = &buffer[0]; - basic_memory_buffer<char, 5, std_allocator_noprop> buffer2( - std::move(buffer)); - const char* new_data_ptr = &buffer2[0]; - EXPECT_NE(new_data_ptr, original_data_ptr); - EXPECT_EQ(std::string(buffer.data(), buffer.size()), str); - EXPECT_EQ(std::string(buffer2.data(), buffer2.size()), str); - EXPECT_EQ(buffer2.capacity(), 5u); - // Allocators should NOT be transferred; they remain distinct instances. - // The original buffer's allocator pointer should still be valid (not - // nullptr). - EXPECT_EQ(buffer.get_allocator().get(), original_alloc_ptr); - EXPECT_NE(buffer2.get_allocator().get(), original_alloc_ptr); - }; - auto alloc = std::allocator<char>(); - basic_memory_buffer<char, 5, std_allocator_noprop> buffer( - (std_allocator_noprop(&alloc))); - buffer.append(string_view("test", 4)); - check_move_buffer("test", buffer); - buffer.push_back('a'); - check_move_buffer("testa", buffer); -} - -TEST(memory_buffer_test, move_ctor_dynamic_buffer_non_propagating) { - auto alloc = std::allocator<char>(); - basic_memory_buffer<char, 4, std_allocator_noprop> buffer( - (std_allocator_noprop(&alloc))); - const char test[] = "test"; - buffer.append(test, test + 4); - const char* inline_buffer_ptr = &buffer[0]; - buffer.push_back('a'); - EXPECT_NE(buffer.data(), inline_buffer_ptr); - std::allocator<char>* original_alloc_ptr = buffer.get_allocator().get(); - basic_memory_buffer<char, 4, std_allocator_noprop> buffer2; - buffer2 = std::move(buffer); - EXPECT_EQ(std::string(buffer2.data(), buffer2.size()), "testa"); - EXPECT_GT(buffer2.capacity(), 4u); - EXPECT_NE(buffer2.data(), inline_buffer_ptr); - EXPECT_EQ(buffer.get_allocator().get(), original_alloc_ptr); - EXPECT_NE(buffer2.get_allocator().get(), original_alloc_ptr); -} - -void check_move_assign_buffer(const char* str, - basic_memory_buffer<char, 5>& buffer) { - basic_memory_buffer<char, 5> buffer2; - buffer2 = std::move(buffer); - // Move shouldn't destroy the inline content of the first buffer. - EXPECT_EQ(std::string(&buffer[0], buffer.size()), str); - EXPECT_EQ(std::string(&buffer2[0], buffer2.size()), str); - EXPECT_EQ(buffer2.capacity(), 5u); -} - -TEST(memory_buffer_test, move_assignment) { - basic_memory_buffer<char, 5> buffer; - const char test[] = "test"; - buffer.append(test, test + 4); - check_move_assign_buffer("test", buffer); - // Adding one more character fills the inline buffer, but doesn't cause - // dynamic allocation. - buffer.push_back('a'); - check_move_assign_buffer("testa", buffer); - const char* inline_buffer_ptr = &buffer[0]; - // Adding one more character causes the content to move from the inline to - // a dynamically allocated buffer. - buffer.push_back('b'); - basic_memory_buffer<char, 5> buffer2; - buffer2 = std::move(buffer); - // Move should rip the guts of the first buffer. - EXPECT_EQ(buffer.data(), inline_buffer_ptr); - EXPECT_EQ(std::string(buffer2.data(), buffer2.size()), "testab"); - EXPECT_GT(buffer2.capacity(), 5u); -} - -TEST(memory_buffer_test, grow) { - using allocator = allocator_ref<mock_allocator<int>>; - mock_allocator<int> alloc; - basic_memory_buffer<int, 10, allocator> buffer((allocator(&alloc))); - buffer.resize(7); - using fmt::detail::to_unsigned; - for (int i = 0; i < 7; ++i) buffer[to_unsigned(i)] = i * i; - EXPECT_EQ(10u, buffer.capacity()); - int mem[20]; - mem[7] = 0xdead; - EXPECT_CALL(alloc, allocate(20)).WillOnce(Return(mem)); - buffer.try_reserve(20); - EXPECT_EQ(20u, buffer.capacity()); - // Check if size elements have been copied - for (int i = 0; i < 7; ++i) EXPECT_EQ(i * i, buffer[to_unsigned(i)]); - // and no more than that. - EXPECT_EQ(0xdead, buffer[7]); - EXPECT_CALL(alloc, deallocate(mem, 20)); -} - -TEST(memory_buffer_test, allocator) { - using test_allocator = allocator_ref<mock_allocator<char>>; - basic_memory_buffer<char, 10, test_allocator> buffer; - EXPECT_EQ(nullptr, buffer.get_allocator().get()); - StrictMock<mock_allocator<char>> alloc; - char mem; - { - basic_memory_buffer<char, 10, test_allocator> buffer2( - (test_allocator(&alloc))); - EXPECT_EQ(&alloc, buffer2.get_allocator().get()); - size_t size = 2 * fmt::inline_buffer_size; - EXPECT_CALL(alloc, allocate(size)).WillOnce(Return(&mem)); - buffer2.reserve(size); - EXPECT_CALL(alloc, deallocate(&mem, size)); - } -} - -TEST(memory_buffer_test, exception_in_deallocate) { - using test_allocator = allocator_ref<mock_allocator<char>>; - StrictMock<mock_allocator<char>> alloc; - basic_memory_buffer<char, 10, test_allocator> buffer( - (test_allocator(&alloc))); - size_t size = 2 * fmt::inline_buffer_size; - auto mem = std::vector<char>(size); - { - EXPECT_CALL(alloc, allocate(size)).WillOnce(Return(&mem[0])); - buffer.resize(size); - std::fill(&buffer[0], &buffer[0] + size, 'x'); - } - auto mem2 = std::vector<char>(2 * size); - { - EXPECT_CALL(alloc, allocate(2 * size)).WillOnce(Return(&mem2[0])); - auto e = std::exception(); - EXPECT_CALL(alloc, deallocate(&mem[0], size)).WillOnce(testing::Throw(e)); - EXPECT_THROW(buffer.reserve(2 * size), std::exception); - EXPECT_EQ(&mem2[0], &buffer[0]); - // Check that the data has been copied. - for (size_t i = 0; i < size; ++i) EXPECT_EQ('x', buffer[i]); - } - EXPECT_CALL(alloc, deallocate(&mem2[0], 2 * size)); -} - -template <typename Allocator, size_t MaxSize> -class max_size_allocator : public Allocator { - public: - using typename Allocator::value_type; - size_t max_size() const noexcept { return MaxSize; } - value_type* allocate(size_t n) { - if (n > max_size()) { - throw std::length_error("size > max_size"); - } - return std::allocator_traits<Allocator>::allocate( - *static_cast<Allocator*>(this), n); - } - void deallocate(value_type* p, size_t n) { - std::allocator_traits<Allocator>::deallocate(*static_cast<Allocator*>(this), - p, n); - } -}; - -TEST(memory_buffer_test, max_size_allocator) { - // 160 = 128 + 32 - using test_allocator = max_size_allocator<std::allocator<char>, 160>; - basic_memory_buffer<char, 10, test_allocator> buffer; - buffer.resize(128); - // new_capacity = 128 + 128/2 = 192 > 160 - buffer.resize(160); // Shouldn't throw. -} - -TEST(memory_buffer_test, max_size_allocator_overflow) { - using test_allocator = max_size_allocator<std::allocator<char>, 160>; - basic_memory_buffer<char, 10, test_allocator> buffer; - EXPECT_THROW(buffer.resize(161), std::exception); -} - -TEST(memory_buffer_test, back_insert_iterator) { - fmt::memory_buffer buf; - using iterator = decltype(std::back_inserter(buf)); - EXPECT_TRUE(fmt::detail::is_back_insert_iterator<iterator>::value); -} - -TEST(format_test, digits2_alignment) { - auto p = - fmt::detail::bit_cast<fmt::detail::uintptr_t>(fmt::detail::digits2(0)); - EXPECT_EQ(p % 2, 0); -} - -TEST(format_test, exception_from_lib) { - EXPECT_THROW_MSG(fmt::report_error("test"), format_error, "test"); -} - -TEST(format_test, escape) { - EXPECT_EQ(fmt::format("{{"), "{"); - EXPECT_EQ(fmt::format("before {{"), "before {"); - EXPECT_EQ(fmt::format("{{ after"), "{ after"); - EXPECT_EQ(fmt::format("before {{ after"), "before { after"); - - EXPECT_EQ(fmt::format("}}"), "}"); - EXPECT_EQ(fmt::format("before }}"), "before }"); - EXPECT_EQ(fmt::format("}} after"), "} after"); - EXPECT_EQ(fmt::format("before }} after"), "before } after"); - - EXPECT_EQ(fmt::format("{{}}"), "{}"); - EXPECT_EQ(fmt::format("{{{0}}}", 42), "{42}"); -} - -TEST(format_test, unmatched_braces) { - EXPECT_THROW_MSG((void)fmt::format(runtime("{")), format_error, - "invalid format string"); - EXPECT_THROW_MSG((void)fmt::format(runtime("}")), format_error, - "unmatched '}' in format string"); - EXPECT_THROW_MSG((void)fmt::format(runtime("{0{}")), format_error, - "invalid format string"); -} - -TEST(format_test, no_args) { EXPECT_EQ(fmt::format("test"), "test"); } - -TEST(format_test, args_in_different_positions) { - EXPECT_EQ(fmt::format("{0}", 42), "42"); - EXPECT_EQ(fmt::format("before {0}", 42), "before 42"); - EXPECT_EQ(fmt::format("{0} after", 42), "42 after"); - EXPECT_EQ(fmt::format("before {0} after", 42), "before 42 after"); - EXPECT_EQ(fmt::format("{0} = {1}", "answer", 42), "answer = 42"); - EXPECT_EQ(fmt::format("{1} is the {0}", "answer", 42), "42 is the answer"); - EXPECT_EQ(fmt::format("{0}{1}{0}", "abra", "cad"), "abracadabra"); -} - -TEST(format_test, arg_errors) { - EXPECT_THROW_MSG((void)fmt::format(runtime("{")), format_error, - "invalid format string"); - EXPECT_THROW_MSG((void)fmt::format(runtime("{?}")), format_error, - "invalid format string"); - EXPECT_THROW_MSG((void)fmt::format(runtime("{0")), format_error, - "invalid format string"); - EXPECT_THROW_MSG((void)fmt::format(runtime("{0}")), format_error, - "argument not found"); - EXPECT_THROW_MSG((void)fmt::format(runtime("{00}"), 42), format_error, - "invalid format string"); - - auto int_max = std::to_string(INT_MAX); - EXPECT_THROW_MSG((void)fmt::format(runtime("{" + int_max)), format_error, - "invalid format string"); - EXPECT_THROW_MSG((void)fmt::format(runtime("{" + int_max + "}")), - format_error, "argument not found"); - - auto int_maxer = std::to_string(INT_MAX + 1u); - EXPECT_THROW_MSG((void)fmt::format(runtime("{" + int_maxer)), format_error, - "invalid format string"); - EXPECT_THROW_MSG((void)fmt::format(runtime("{" + int_maxer + "}")), - format_error, "argument not found"); -} - -TEST(format_test, display_width_precision) { - EXPECT_EQ(fmt::format("{:.5}", "🐱🐱🐱"), "🐱🐱"); -} - -template <int N> struct test_format { - template <typename... T> - static auto format(fmt::string_view fmt, const T&... args) -> std::string { - return test_format<N - 1>::format(fmt, N - 1, args...); - } -}; - -template <> struct test_format<0> { - template <typename... T> - static auto format(fmt::string_view fmt, const T&... args) -> std::string { - return fmt::format(runtime(fmt), args...); - } -}; - -TEST(format_test, many_args) { - EXPECT_EQ("19", test_format<20>::format("{19}")); - EXPECT_THROW_MSG(test_format<20>::format("{20}"), format_error, - "argument not found"); - EXPECT_THROW_MSG(test_format<21>::format("{21}"), format_error, - "argument not found"); - using fmt::detail::max_packed_args; - std::string format_str = fmt::format("{{{}}}", max_packed_args + 1); - EXPECT_THROW_MSG(test_format<max_packed_args>::format(format_str), - format_error, "argument not found"); -} - -TEST(format_test, named_arg) { - EXPECT_EQ("1/a/A", fmt::format("{_1}/{a_}/{A_}", fmt::arg("a_", 'a'), - fmt::arg("A_", "A"), fmt::arg("_1", 1))); - EXPECT_EQ(fmt::format("{0:{width}}", -42, fmt::arg("width", 4)), " -42"); - EXPECT_EQ(fmt::format("{value:{width}}", fmt::arg("value", -42), - fmt::arg("width", 4)), - " -42"); - EXPECT_EQ("st", - fmt::format("{0:.{precision}}", "str", fmt::arg("precision", 2))); - EXPECT_EQ(fmt::format("{} {two}", 1, fmt::arg("two", 2)), "1 2"); - EXPECT_EQ("42", - fmt::format("{c}", fmt::arg("a", 0), fmt::arg("b", 0), - fmt::arg("c", 42), fmt::arg("d", 0), fmt::arg("e", 0), - fmt::arg("f", 0), fmt::arg("g", 0), fmt::arg("h", 0), - fmt::arg("i", 0), fmt::arg("j", 0), fmt::arg("k", 0), - fmt::arg("l", 0), fmt::arg("m", 0), fmt::arg("n", 0), - fmt::arg("o", 0), fmt::arg("p", 0))); - EXPECT_THROW_MSG((void)fmt::format(runtime("{a}")), format_error, - "argument not found"); - EXPECT_THROW_MSG((void)fmt::format(runtime("{a}"), 42), format_error, - "argument not found"); - EXPECT_THROW_MSG((void)fmt::format(runtime("{a} {}"), fmt::arg("a", 2), 42), - format_error, - "cannot switch from manual to automatic argument indexing"); - EXPECT_THROW_MSG( - (void)fmt::format("{a}", fmt::arg("a", 1), fmt::arg("a", 10)), - format_error, "duplicate named arg"); -} - -TEST(format_test, auto_arg_index) { - EXPECT_EQ(fmt::format("{}{}{}", 'a', 'b', 'c'), "abc"); - EXPECT_THROW_MSG((void)fmt::format(runtime("{0}{}"), 'a', 'b'), format_error, - "cannot switch from manual to automatic argument indexing"); - EXPECT_THROW_MSG((void)fmt::format(runtime("{}{0}"), 'a', 'b'), format_error, - "cannot switch from automatic to manual argument indexing"); - EXPECT_EQ(fmt::format("{:.{}}", 1.2345, 2), "1.2"); - EXPECT_THROW_MSG((void)fmt::format(runtime("{0}:.{}"), 1.2345, 2), - format_error, - "cannot switch from manual to automatic argument indexing"); - EXPECT_THROW_MSG((void)fmt::format(runtime("{:.{0}}"), 1.2345, 2), - format_error, - "cannot switch from automatic to manual argument indexing"); - EXPECT_THROW_MSG((void)fmt::format(runtime("{}")), format_error, - "argument not found"); -} - -TEST(format_test, empty_specs) { EXPECT_EQ(fmt::format("{0:}", 42), "42"); } - -TEST(format_test, left_align) { - EXPECT_EQ(fmt::format("{0:<4}", 42), "42 "); - EXPECT_EQ(fmt::format("{0:<4o}", 042), "42 "); - EXPECT_EQ(fmt::format("{0:<4x}", 0x42), "42 "); - EXPECT_EQ(fmt::format("{0:<5}", -42), "-42 "); - EXPECT_EQ(fmt::format("{0:<5}", 42u), "42 "); - EXPECT_EQ(fmt::format("{0:<5}", -42l), "-42 "); - EXPECT_EQ(fmt::format("{0:<5}", 42ul), "42 "); - EXPECT_EQ(fmt::format("{0:<5}", -42ll), "-42 "); - EXPECT_EQ(fmt::format("{0:<5}", 42ull), "42 "); - EXPECT_EQ(fmt::format("{0:<5}", -42.0), "-42 "); - EXPECT_EQ(fmt::format("{0:<5}", -42.0l), "-42 "); - EXPECT_EQ(fmt::format("{0:<5}", 'c'), "c "); - EXPECT_EQ(fmt::format("{0:<5}", "abc"), "abc "); - EXPECT_EQ(fmt::format("{0:<8}", reinterpret_cast<void*>(0xface)), "0xface "); -} - -TEST(format_test, right_align) { - EXPECT_EQ(fmt::format("{0:>4}", 42), " 42"); - EXPECT_EQ(fmt::format("{0:>4o}", 042), " 42"); - EXPECT_EQ(fmt::format("{0:>4x}", 0x42), " 42"); - EXPECT_EQ(fmt::format("{0:>5}", -42), " -42"); - EXPECT_EQ(fmt::format("{0:>5}", 42u), " 42"); - EXPECT_EQ(fmt::format("{0:>5}", -42l), " -42"); - EXPECT_EQ(fmt::format("{0:>5}", 42ul), " 42"); - EXPECT_EQ(fmt::format("{0:>5}", -42ll), " -42"); - EXPECT_EQ(fmt::format("{0:>5}", 42ull), " 42"); - EXPECT_EQ(fmt::format("{0:>5}", -42.0), " -42"); - EXPECT_EQ(fmt::format("{0:>5}", -42.0l), " -42"); - EXPECT_EQ(fmt::format("{0:>5}", 'c'), " c"); - EXPECT_EQ(fmt::format("{0:>5}", "abc"), " abc"); - EXPECT_EQ(fmt::format("{0:>8}", reinterpret_cast<void*>(0xface)), " 0xface"); -} - -TEST(format_test, center_align) { - EXPECT_EQ(fmt::format("{0:^5}", 42), " 42 "); - EXPECT_EQ(fmt::format("{0:^5o}", 042), " 42 "); - EXPECT_EQ(fmt::format("{0:^5x}", 0x42), " 42 "); - EXPECT_EQ(fmt::format("{0:^5}", -42), " -42 "); - EXPECT_EQ(fmt::format("{0:^5}", 42u), " 42 "); - EXPECT_EQ(fmt::format("{0:^5}", -42l), " -42 "); - EXPECT_EQ(fmt::format("{0:^5}", 42ul), " 42 "); - EXPECT_EQ(fmt::format("{0:^5}", -42ll), " -42 "); - EXPECT_EQ(fmt::format("{0:^5}", 42ull), " 42 "); - EXPECT_EQ(fmt::format("{0:^5}", -42.0), " -42 "); - EXPECT_EQ(fmt::format("{0:^5}", -42.0l), " -42 "); - EXPECT_EQ(fmt::format("{0:^5}", 'c'), " c "); - EXPECT_EQ(fmt::format("{0:^6}", "abc"), " abc "); - EXPECT_EQ(fmt::format("{0:^8}", reinterpret_cast<void*>(0xface)), " 0xface "); -} - -TEST(format_test, fill) { - EXPECT_THROW_MSG((void)fmt::format(runtime("{0:{<5}"), 'c'), format_error, - "invalid fill character '{'"); - EXPECT_THROW_MSG((void)fmt::format(runtime("{0:{<5}}"), 'c'), format_error, - "invalid fill character '{'"); - EXPECT_EQ(fmt::format("{0:*>4}", 42), "**42"); - EXPECT_EQ(fmt::format("{0:*>5}", -42), "**-42"); - EXPECT_EQ(fmt::format("{0:*>5}", 42u), "***42"); - EXPECT_EQ(fmt::format("{0:*>5}", -42l), "**-42"); - EXPECT_EQ(fmt::format("{0:*>5}", 42ul), "***42"); - EXPECT_EQ(fmt::format("{0:*>5}", -42ll), "**-42"); - EXPECT_EQ(fmt::format("{0:*>5}", 42ull), "***42"); - EXPECT_EQ(fmt::format("{0:*>5}", -42.0), "**-42"); - EXPECT_EQ(fmt::format("{0:*>5}", -42.0l), "**-42"); - EXPECT_EQ(fmt::format("{0:*<5}", 'c'), "c****"); - EXPECT_EQ(fmt::format("{0:*<5}", "abc"), "abc**"); - EXPECT_EQ("**0xface", - fmt::format("{0:*>8}", reinterpret_cast<void*>(0xface))); - EXPECT_EQ(fmt::format("{:}=", "foo"), "foo="); - EXPECT_EQ(std::string("\0\0\0*", 4), - fmt::format(string_view("{:\0>4}", 6), '*')); - EXPECT_EQ(fmt::format("{0:ж>4}", 42), "жж42"); - EXPECT_THROW_MSG((void)fmt::format(runtime("{:\x80\x80\x80\x80\x80>}"), 0), - format_error, "invalid format specifier"); -} - -TEST(format_test, plus_sign) { - EXPECT_EQ(fmt::format("{0:+}", 42), "+42"); - EXPECT_EQ(fmt::format("{0:+}", -42), "-42"); - EXPECT_EQ(fmt::format("{0:+}", 42), "+42"); - EXPECT_THROW_MSG((void)fmt::format(runtime("{0:+}"), 42u), format_error, - "invalid format specifier"); - EXPECT_EQ(fmt::format("{0:+}", 42l), "+42"); - EXPECT_THROW_MSG((void)fmt::format(runtime("{0:+}"), 42ul), format_error, - "invalid format specifier"); - EXPECT_EQ(fmt::format("{0:+}", 42ll), "+42"); -#if FMT_USE_INT128 - EXPECT_EQ(fmt::format("{0:+}", __int128_t(42)), "+42"); -#endif - EXPECT_THROW_MSG((void)fmt::format(runtime("{0:+}"), 42ull), format_error, - "invalid format specifier"); - EXPECT_EQ(fmt::format("{0:+}", 42.0), "+42"); - EXPECT_EQ(fmt::format("{0:+}", 42.0l), "+42"); - EXPECT_THROW_MSG((void)fmt::format(runtime("{0:+}"), 'c'), format_error, - "invalid format specifier"); - EXPECT_THROW_MSG((void)fmt::format(runtime("{0:+}"), "abc"), format_error, - "invalid format specifier"); - EXPECT_THROW_MSG( - (void)fmt::format(runtime("{0:+}"), reinterpret_cast<void*>(0x42)), - format_error, "invalid format specifier"); -} - -TEST(format_test, minus_sign) { - EXPECT_EQ(fmt::format("{0:-}", 42), "42"); - EXPECT_EQ(fmt::format("{0:-}", -42), "-42"); - EXPECT_EQ(fmt::format("{0:-}", 42), "42"); - EXPECT_THROW_MSG((void)fmt::format(runtime("{0:-}"), 42u), format_error, - "invalid format specifier"); - EXPECT_EQ(fmt::format("{0:-}", 42l), "42"); - EXPECT_THROW_MSG((void)fmt::format(runtime("{0:-}"), 42ul), format_error, - "invalid format specifier"); - EXPECT_EQ(fmt::format("{0:-}", 42ll), "42"); - EXPECT_THROW_MSG((void)fmt::format(runtime("{0:-}"), 42ull), format_error, - "invalid format specifier"); - EXPECT_EQ(fmt::format("{0:-}", 42.0), "42"); - EXPECT_EQ(fmt::format("{0:-}", 42.0l), "42"); - EXPECT_THROW_MSG((void)fmt::format(runtime("{0:-}"), 'c'), format_error, - "invalid format specifier"); - EXPECT_THROW_MSG((void)fmt::format(runtime("{0:-}"), "abc"), format_error, - "invalid format specifier"); - EXPECT_THROW_MSG( - (void)fmt::format(runtime("{0:-}"), reinterpret_cast<void*>(0x42)), - format_error, "invalid format specifier"); -} - -TEST(format_test, space_sign) { - EXPECT_EQ(fmt::format("{0: }", 42), " 42"); - EXPECT_EQ(fmt::format("{0: }", -42), "-42"); - EXPECT_EQ(fmt::format("{0: }", 42), " 42"); - EXPECT_THROW_MSG((void)fmt::format(runtime("{0: }"), 42u), format_error, - "invalid format specifier"); - EXPECT_EQ(fmt::format("{0: }", 42l), " 42"); - EXPECT_THROW_MSG((void)fmt::format(runtime("{0: }"), 42ul), format_error, - "invalid format specifier"); - EXPECT_EQ(fmt::format("{0: }", 42ll), " 42"); - EXPECT_THROW_MSG((void)fmt::format(runtime("{0: }"), 42ull), format_error, - "invalid format specifier"); - EXPECT_EQ(fmt::format("{0: }", 42.0), " 42"); - EXPECT_EQ(fmt::format("{0: }", 42.0l), " 42"); - EXPECT_THROW_MSG((void)fmt::format(runtime("{0: }"), 'c'), format_error, - "invalid format specifier"); - EXPECT_THROW_MSG((void)fmt::format(runtime("{0: }"), "abc"), format_error, - "invalid format specifier"); - EXPECT_THROW_MSG( - (void)fmt::format(runtime("{0: }"), reinterpret_cast<void*>(0x42)), - format_error, "invalid format specifier"); -} - -TEST(format_test, hash_flag) { - EXPECT_EQ(fmt::format("{0:#}", 42), "42"); - EXPECT_EQ(fmt::format("{0:#}", -42), "-42"); - EXPECT_EQ(fmt::format("{0:#b}", 42), "0b101010"); - EXPECT_EQ(fmt::format("{0:#B}", 42), "0B101010"); - EXPECT_EQ(fmt::format("{0:#b}", -42), "-0b101010"); - EXPECT_EQ(fmt::format("{0:#x}", 0x42), "0x42"); - EXPECT_EQ(fmt::format("{0:#X}", 0x42), "0X42"); - EXPECT_EQ(fmt::format("{0:#x}", -0x42), "-0x42"); - EXPECT_EQ(fmt::format("{0:#o}", 0), "0"); - EXPECT_EQ(fmt::format("{0:#o}", 042), "042"); - EXPECT_EQ(fmt::format("{0:#o}", -042), "-042"); - EXPECT_EQ(fmt::format("{0:#}", 42u), "42"); - EXPECT_EQ(fmt::format("{0:#x}", 0x42u), "0x42"); - EXPECT_EQ(fmt::format("{0:#o}", 042u), "042"); - - EXPECT_EQ(fmt::format("{0:#}", -42l), "-42"); - EXPECT_EQ(fmt::format("{0:#x}", 0x42l), "0x42"); - EXPECT_EQ(fmt::format("{0:#x}", -0x42l), "-0x42"); - EXPECT_EQ(fmt::format("{0:#o}", 042l), "042"); - EXPECT_EQ(fmt::format("{0:#o}", -042l), "-042"); - EXPECT_EQ(fmt::format("{0:#}", 42ul), "42"); - EXPECT_EQ(fmt::format("{0:#x}", 0x42ul), "0x42"); - EXPECT_EQ(fmt::format("{0:#o}", 042ul), "042"); - - EXPECT_EQ(fmt::format("{0:#}", -42ll), "-42"); - EXPECT_EQ(fmt::format("{0:#x}", 0x42ll), "0x42"); - EXPECT_EQ(fmt::format("{0:#x}", -0x42ll), "-0x42"); - EXPECT_EQ(fmt::format("{0:#o}", 042ll), "042"); - EXPECT_EQ(fmt::format("{0:#o}", -042ll), "-042"); - EXPECT_EQ(fmt::format("{0:#}", 42ull), "42"); - EXPECT_EQ(fmt::format("{0:#x}", 0x42ull), "0x42"); - EXPECT_EQ(fmt::format("{0:#o}", 042ull), "042"); - - EXPECT_EQ(fmt::format("{0:#}", -42.0), "-42."); - EXPECT_EQ(fmt::format("{0:#}", -42.0l), "-42."); - EXPECT_EQ(fmt::format("{:#.0e}", 42.0), "4.e+01"); - EXPECT_EQ(fmt::format("{:#.0f}", 0.01), "0."); - EXPECT_EQ(fmt::format("{:#.2g}", 0.5), "0.50"); - EXPECT_EQ(fmt::format("{:#.0f}", 0.5), "0."); - EXPECT_THROW_MSG((void)fmt::format(runtime("{0:#"), 'c'), format_error, - "invalid format specifier for char"); - EXPECT_THROW_MSG((void)fmt::format(runtime("{0:#}"), 'c'), format_error, - "invalid format specifier for char"); - EXPECT_THROW_MSG((void)fmt::format(runtime("{0:#}"), "abc"), format_error, - "invalid format specifier"); - EXPECT_THROW_MSG( - (void)fmt::format(runtime("{0:#}"), reinterpret_cast<void*>(0x42)), - format_error, "invalid format specifier"); -} - -TEST(format_test, zero_flag) { - EXPECT_EQ(fmt::format("{0:0}", 42), "42"); - EXPECT_EQ(fmt::format("{0:05}", -42), "-0042"); - EXPECT_EQ(fmt::format("{0:05}", 42u), "00042"); - EXPECT_EQ(fmt::format("{0:05}", -42l), "-0042"); - EXPECT_EQ(fmt::format("{0:05}", 42ul), "00042"); - EXPECT_EQ(fmt::format("{0:05}", -42ll), "-0042"); - EXPECT_EQ(fmt::format("{0:05}", 42ull), "00042"); - EXPECT_EQ(fmt::format("{0:07}", -42.0), "-000042"); - EXPECT_EQ(fmt::format("{0:07}", -42.0l), "-000042"); - EXPECT_THROW_MSG((void)fmt::format(runtime("{0:0"), 'c'), format_error, - "invalid format specifier for char"); - EXPECT_THROW_MSG((void)fmt::format(runtime("{0:05}"), 'c'), format_error, - "invalid format specifier for char"); - EXPECT_THROW_MSG((void)fmt::format(runtime("{0:05}"), "abc"), format_error, - "format specifier requires numeric argument"); - EXPECT_THROW_MSG( - (void)fmt::format(runtime("{0:05}"), reinterpret_cast<void*>(0x42)), - format_error, "format specifier requires numeric argument"); -} - -TEST(format_test, zero_flag_and_align) { - // If the 0 character and an align option both appear, the 0 character is - // ignored. - EXPECT_EQ(fmt::format("{:<05}", 42), "42 "); - EXPECT_EQ(fmt::format("{:<05}", -42), "-42 "); - EXPECT_EQ(fmt::format("{:^05}", 42), " 42 "); - EXPECT_EQ(fmt::format("{:^05}", -42), " -42 "); - EXPECT_EQ(fmt::format("{:>05}", 42), " 42"); - EXPECT_EQ(fmt::format("{:>05}", -42), " -42"); -} - -TEST(format_test, width) { - auto int_maxer = std::to_string(INT_MAX + 1u); - EXPECT_THROW_MSG((void)fmt::format(runtime("{:" + int_maxer), 0), - format_error, "number is too big"); - EXPECT_THROW_MSG((void)fmt::format(runtime("{:" + int_maxer + "}"), 0), - format_error, "number is too big"); - - EXPECT_EQ(fmt::format("{:4}", -42), " -42"); - EXPECT_EQ(fmt::format("{:5}", 42u), " 42"); - EXPECT_EQ(fmt::format("{:6}", -42l), " -42"); - EXPECT_EQ(fmt::format("{:7}", 42ul), " 42"); - EXPECT_EQ(fmt::format("{:6}", -42ll), " -42"); - EXPECT_EQ(fmt::format("{:7}", 42ull), " 42"); - EXPECT_EQ(fmt::format("{:8}", -1.23), " -1.23"); - EXPECT_EQ(fmt::format("{:9}", -1.23l), " -1.23"); - EXPECT_EQ(fmt::format("{:10}", reinterpret_cast<void*>(0xcafe)), - " 0xcafe"); - EXPECT_EQ(fmt::format("{:11}", 'x'), "x "); - EXPECT_EQ(fmt::format("{:12}", "str"), "str "); - EXPECT_EQ(fmt::format("{:*^5}", "🤡"), "*🤡**"); - EXPECT_EQ(fmt::format("{:*^6}", "🤡"), "**🤡**"); - EXPECT_EQ(fmt::format("{:*^8}", "你好"), "**你好**"); - EXPECT_EQ(fmt::format("{:#6}", 42.0), " 42."); - EXPECT_EQ(fmt::format("{:6c}", static_cast<int>('x')), "x "); - EXPECT_EQ(fmt::format("{:>06.0f}", 0.00884311), " 0"); -} - -TEST(format_test, debug_presentation) { - EXPECT_EQ(fmt::format("{:?}", ""), R"("")"); - - EXPECT_EQ(fmt::format("{:*<5.0?}", "\n"), R"(*****)"); - EXPECT_EQ(fmt::format("{:*<5.1?}", "\n"), R"("****)"); - EXPECT_EQ(fmt::format("{:*<5.2?}", "\n"), R"("\***)"); - EXPECT_EQ(fmt::format("{:*<5.3?}", "\n"), R"("\n**)"); - EXPECT_EQ(fmt::format("{:*<5.4?}", "\n"), R"("\n"*)"); - - EXPECT_EQ(fmt::format("{:*<5.1?}", "Σ"), R"("****)"); - EXPECT_EQ(fmt::format("{:*<5.2?}", "Σ"), R"("Σ***)"); - EXPECT_EQ(fmt::format("{:*<5.3?}", "Σ"), R"("Σ"**)"); - - EXPECT_EQ(fmt::format("{:*<5.1?}", "笑"), R"("****)"); - EXPECT_EQ(fmt::format("{:*<5.2?}", "笑"), R"("****)"); - EXPECT_EQ(fmt::format("{:*<5.3?}", "笑"), R"("笑**)"); - EXPECT_EQ(fmt::format("{:*<5.4?}", "笑"), R"("笑"*)"); - - EXPECT_EQ(fmt::format("{:*<8?}", "туда"), R"("туда"**)"); - EXPECT_EQ(fmt::format("{:*>8?}", "сюда"), R"(**"сюда")"); - EXPECT_EQ(fmt::format("{:*^8?}", "中心"), R"(*"中心"*)"); - - EXPECT_EQ(fmt::format("{:*^14?}", "A\t👈🤯ы猫"), R"(*"A\t👈🤯ы猫"*)"); -} - -auto bad_dynamic_spec_msg = FMT_BUILTIN_TYPES - ? "width/precision is out of range" - : "width/precision is not integer"; - -TEST(format_test, runtime_width) { - auto int_maxer = std::to_string(INT_MAX + 1u); - EXPECT_THROW_MSG((void)fmt::format(runtime("{0:{" + int_maxer), 0), - format_error, "invalid format string"); - EXPECT_THROW_MSG((void)fmt::format(runtime("{0:{" + int_maxer + "}"), 0), - format_error, "argument not found"); - EXPECT_THROW_MSG((void)fmt::format(runtime("{0:{" + int_maxer + "}}"), 0), - format_error, "argument not found"); - - EXPECT_THROW_MSG((void)fmt::format(runtime("{0:{"), 0), format_error, - "invalid format string"); - EXPECT_THROW_MSG((void)fmt::format(runtime("{0:{}"), 0), format_error, - "cannot switch from manual to automatic argument indexing"); - EXPECT_THROW_MSG((void)fmt::format(runtime("{0:{?}}"), 0), format_error, - "invalid format string"); - EXPECT_THROW_MSG((void)fmt::format(runtime("{0:{1}}"), 0), format_error, - "argument not found"); - - EXPECT_THROW_MSG((void)fmt::format(runtime("{0:{0:}}"), 0), format_error, - "invalid format string"); - - EXPECT_THROW_MSG((void)fmt::format(runtime("{0:{1}}"), 0, -1), format_error, - "width/precision is out of range"); - EXPECT_THROW_MSG((void)fmt::format(runtime("{0:{1}}"), 0, (INT_MAX + 1u)), - format_error, bad_dynamic_spec_msg); - EXPECT_THROW_MSG((void)fmt::format(runtime("{0:{1}}"), 0, -1l), format_error, - bad_dynamic_spec_msg); - if (fmt::detail::const_check(sizeof(long) > sizeof(int))) { - long value = INT_MAX; - EXPECT_THROW_MSG((void)fmt::format(runtime("{0:{1}}"), 0, (value + 1)), - format_error, bad_dynamic_spec_msg); - } - EXPECT_THROW_MSG((void)fmt::format(runtime("{0:{1}}"), 0, (INT_MAX + 1ul)), - format_error, bad_dynamic_spec_msg); - - EXPECT_THROW_MSG((void)fmt::format(runtime("{0:{1}}"), 0, '0'), format_error, - "width/precision is not integer"); - EXPECT_THROW_MSG((void)fmt::format(runtime("{0:{1}}"), 0, 0.0), format_error, - "width/precision is not integer"); - - EXPECT_EQ(fmt::format("{0:{1}}", -42, 4), " -42"); - EXPECT_EQ(fmt::format("{0:{1}}", 42u, 5), " 42"); - EXPECT_EQ(fmt::format("{0:{1}}", -42l, 6), " -42"); - EXPECT_EQ(fmt::format("{0:{1}}", 42ul, 7), " 42"); - EXPECT_EQ(fmt::format("{0:{1}}", -42ll, 6), " -42"); - EXPECT_EQ(fmt::format("{0:{1}}", 42ull, 7), " 42"); - EXPECT_EQ(fmt::format("{0:{1}}", -1.23, 8), " -1.23"); - EXPECT_EQ(fmt::format("{0:{1}}", -1.23l, 9), " -1.23"); - EXPECT_EQ(" 0xcafe", - fmt::format("{0:{1}}", reinterpret_cast<void*>(0xcafe), 10)); - EXPECT_EQ(fmt::format("{0:{1}}", 'x', 11), "x "); - EXPECT_EQ(fmt::format("{0:{1}}", "str", 12), "str "); - EXPECT_EQ(fmt::format("{:{}}", 42, short(4)), " 42"); -} - -TEST(format_test, exponent_range) { - for (int e = -1074; e <= 1023; ++e) (void)fmt::format("{}", std::ldexp(1, e)); -} - -TEST(format_test, precision) { - char format_str[buffer_size]; - safe_sprintf(format_str, "{0:.%u", UINT_MAX); - increment(format_str + 4); - EXPECT_THROW_MSG((void)fmt::format(runtime(format_str), 0.0), format_error, - "number is too big"); - size_t size = std::strlen(format_str); - format_str[size] = '}'; - format_str[size + 1] = 0; - EXPECT_THROW_MSG((void)fmt::format(runtime(format_str), 0.0), format_error, - "number is too big"); - - safe_sprintf(format_str, "{0:.%u", INT_MAX + 1u); - EXPECT_THROW_MSG((void)fmt::format(runtime(format_str), 0.0), format_error, - "number is too big"); - safe_sprintf(format_str, "{0:.%u}", INT_MAX + 1u); - EXPECT_THROW_MSG((void)fmt::format(runtime(format_str), 0.0), format_error, - "number is too big"); - - EXPECT_THROW_MSG((void)fmt::format(runtime("{0:."), 0.0), format_error, - "invalid precision"); - EXPECT_THROW_MSG((void)fmt::format(runtime("{0:.}"), 0.0), format_error, - "invalid format string"); - - EXPECT_THROW_MSG((void)fmt::format(runtime("{0:.2"), 0), format_error, - "invalid format specifier"); - EXPECT_THROW_MSG((void)fmt::format(runtime("{0:.2}"), 42), format_error, - "invalid format specifier"); - EXPECT_THROW_MSG((void)fmt::format(runtime("{0:.2f}"), 42), format_error, - "invalid format specifier"); - EXPECT_THROW_MSG((void)fmt::format(runtime("{0:.2}"), 42u), format_error, - "invalid format specifier"); - EXPECT_THROW_MSG((void)fmt::format(runtime("{0:.2f}"), 42u), format_error, - "invalid format specifier"); - EXPECT_THROW_MSG((void)fmt::format(runtime("{0:.2}"), 42l), format_error, - "invalid format specifier"); - EXPECT_THROW_MSG((void)fmt::format(runtime("{0:.2f}"), 42l), format_error, - "invalid format specifier"); - EXPECT_THROW_MSG((void)fmt::format(runtime("{0:.2}"), 42ul), format_error, - "invalid format specifier"); - EXPECT_THROW_MSG((void)fmt::format(runtime("{0:.2f}"), 42ul), format_error, - "invalid format specifier"); - EXPECT_THROW_MSG((void)fmt::format(runtime("{0:.2}"), 42ll), format_error, - "invalid format specifier"); - EXPECT_THROW_MSG((void)fmt::format(runtime("{0:.2f}"), 42ll), format_error, - "invalid format specifier"); - EXPECT_THROW_MSG((void)fmt::format(runtime("{0:.2}"), 42ull), format_error, - "invalid format specifier"); - EXPECT_THROW_MSG((void)fmt::format(runtime("{0:.2f}"), 42ull), format_error, - "invalid format specifier"); - EXPECT_THROW_MSG((void)fmt::format(runtime("{0:3.0}"), 'x'), format_error, - "invalid format specifier"); - EXPECT_EQ(fmt::format("{0:.2}", 1.2345), "1.2"); - EXPECT_EQ(fmt::format("{0:.2}", 1.2345l), "1.2"); - EXPECT_EQ(fmt::format("{:.2}", 1.234e56), "1.2e+56"); - EXPECT_EQ(fmt::format("{0:.3}", 1.1), "1.1"); - EXPECT_EQ(fmt::format("{:.0e}", 1.0L), "1e+00"); - EXPECT_EQ(fmt::format("{:9.1e}", 0.0), " 0.0e+00"); - EXPECT_EQ(fmt::format("{:.7f}", 0.0000000000000071054273576010018587L), - "0.0000000"); - - EXPECT_EQ( - fmt::format("{:.494}", 4.9406564584124654E-324), - "4.9406564584124654417656879286822137236505980261432476442558568250067550" - "727020875186529983636163599237979656469544571773092665671035593979639877" - "479601078187812630071319031140452784581716784898210368871863605699873072" - "305000638740915356498438731247339727316961514003171538539807412623856559" - "117102665855668676818703956031062493194527159149245532930545654440112748" - "012970999954193198940908041656332452475714786901472678015935523861155013" - "480352649347201937902681071074917033322268447533357208324319361e-324"); - EXPECT_EQ( - fmt::format("{:.1074f}", 1.1125369292536e-308), - "0.0000000000000000000000000000000000000000000000000000000000000000000000" - "000000000000000000000000000000000000000000000000000000000000000000000000" - "000000000000000000000000000000000000000000000000000000000000000000000000" - "000000000000000000000000000000000000000000000000000000000000000000000000" - "000000000000000000000111253692925360019747947051741965785554081512200979" - "355021686109411883779182127659725163430929750364498219730822952552570601" - "152163505899912777129583674906301179059298598412303893909188340988729019" - "014361467448914817838555156840459458527907308695109202499990850735085304" - "478476991912072201449236975063640913461919914396877093174125167509869762" - "482369631100360266123742648159508919592746619553246586039571522788247697" - "156360766271842991667238355464496455107749716934387136380536472531224398" - "559833794807213172371254492216255558078524900147957309382830827524104234" - "530961756787819847850302379672357738807808384667004752163416921762619527" - "462847642037420991432005657440259928195996762610375541867198059294212446" - "81962777939941034720757232455434770912461317493580281734466552734375"); - - std::string outputs[] = { - "-0X1.41FE3FFE71C9E000000000000000000000000000000000000000000000000000000" - "000000000000000000000000000000000000000000000000000000000000000000000000" - "000000000000000000000000000000000000000000000000000000000000000000000000" - "000000000000000000000000000000000000000000000000000000000000000000000000" - "000000000000000000000000000000000000000000000000000000000000000000000000" - "000000000000000000000000000000000000000000000000000000000000000000000000" - "000000000000000000000000000000000000000000000000000000000000000000000000" - "000000000000000000000000000000000000000000000000000000000000000000000000" - "000000000000000000000000000000000000000000000000000000000000000000000000" - "000000000000000000000000000000000000000000000000000000000000000000000000" - "000000000000000000000000000000000000000000000000000000000000000000000000" - "000000000000000000000000000000000000000000000000000P+127", - "-0XA.0FF1FFF38E4F0000000000000000000000000000000000000000000000000000000" - "000000000000000000000000000000000000000000000000000000000000000000000000" - "000000000000000000000000000000000000000000000000000000000000000000000000" - "000000000000000000000000000000000000000000000000000000000000000000000000" - "000000000000000000000000000000000000000000000000000000000000000000000000" - "000000000000000000000000000000000000000000000000000000000000000000000000" - "000000000000000000000000000000000000000000000000000000000000000000000000" - "000000000000000000000000000000000000000000000000000000000000000000000000" - "000000000000000000000000000000000000000000000000000000000000000000000000" - "000000000000000000000000000000000000000000000000000000000000000000000000" - "000000000000000000000000000000000000000000000000000000000000000000000000" - "000000000000000000000000000000000000000000000000000P+124"}; - EXPECT_THAT(outputs, - testing::Contains(fmt::format("{:.838A}", -2.14001164E+38))); - - if (std::numeric_limits<long double>::digits == 64) { - auto ld = (std::numeric_limits<long double>::min)(); - EXPECT_EQ(fmt::format("{:.0}", ld), "3e-4932"); - EXPECT_EQ( - fmt::format("{:0g}", std::numeric_limits<long double>::denorm_min()), - "3.6452e-4951"); - } - - EXPECT_EQ(fmt::format("{:#.0f}", 123.0), "123."); - EXPECT_EQ(fmt::format("{:.02f}", 1.234), "1.23"); - EXPECT_EQ(fmt::format("{:.1g}", 0.001), "0.001"); - EXPECT_EQ(fmt::format("{}", 123456789.0f), "1.2345679e+08"); - EXPECT_EQ(fmt::format("{}", 1019666432.0f), "1.0196664e+09"); - EXPECT_EQ(fmt::format("{:.0e}", 9.5), "1e+01"); - EXPECT_EQ(fmt::format("{:.1e}", 1e-34), "1.0e-34"); - - EXPECT_THROW_MSG( - (void)fmt::format(runtime("{0:.2}"), reinterpret_cast<void*>(0xcafe)), - format_error, "invalid format specifier"); - EXPECT_THROW_MSG( - (void)fmt::format(runtime("{0:.2f}"), reinterpret_cast<void*>(0xcafe)), - format_error, "invalid format specifier"); - EXPECT_THROW_MSG( - (void)fmt::format("{:.2147483646f}", -2.2121295195081227E+304), - format_error, "number is too big"); - EXPECT_THROW_MSG((void)fmt::format(runtime("{:.f}"), 42.0), format_error, - "invalid format string"); - - EXPECT_EQ(fmt::format("{0:.2}", "str"), "st"); - EXPECT_EQ(fmt::format("{0:.5}", "вожыкі"), "вожык"); - EXPECT_EQ(fmt::format("{0:.6}", "123456\xad"), "123456"); -} - -TEST(format_test, large_precision) { - // Iterator used to abort the actual output. - struct throwing_iterator { - auto operator=(char) -> throwing_iterator& { - throw std::runtime_error("aborted"); - return *this; - } - auto operator*() -> throwing_iterator& { return *this; } - auto operator++() -> throwing_iterator& { return *this; } - auto operator++(int) -> throwing_iterator { return *this; } - }; - auto it = throwing_iterator(); - - EXPECT_THROW_MSG(fmt::format_to(it, fmt::runtime("{:#.{}}"), 1.0, - fmt::detail::max_value<int>()), - std::runtime_error, "aborted"); - - EXPECT_THROW_MSG(fmt::format_to(it, fmt::runtime("{:#.{}e}"), 1.0, - fmt::detail::max_value<int>() - 1), - std::runtime_error, "aborted"); - - EXPECT_THROW_MSG((void)fmt::format(fmt::runtime("{:.{}e}"), 42.0, - fmt::detail::max_value<int>()), - format_error, "number is too big"); -} - -TEST(format_test, utf8_precision) { - auto result = fmt::format("{:.4}", "caf\u00e9s"); // cafés - EXPECT_EQ(result, "caf\u00e9"); -} - -TEST(format_test, runtime_precision) { - char format_str[buffer_size]; - safe_sprintf(format_str, "{0:.{%u", UINT_MAX); - increment(format_str + 5); - EXPECT_THROW_MSG((void)fmt::format(runtime(format_str), 0.0), format_error, - "invalid format string"); - size_t size = std::strlen(format_str); - format_str[size] = '}'; - format_str[size + 1] = 0; - EXPECT_THROW_MSG((void)fmt::format(runtime(format_str), 0.0), format_error, - "argument not found"); - format_str[size + 1] = '}'; - format_str[size + 2] = 0; - EXPECT_THROW_MSG((void)fmt::format(runtime(format_str), 0.0), format_error, - "argument not found"); - - EXPECT_THROW_MSG((void)fmt::format(runtime("{0:.{"), 0.0), format_error, - "invalid format string"); - EXPECT_THROW_MSG((void)fmt::format(runtime("{0:.{}"), 0.0), format_error, - "cannot switch from manual to automatic argument indexing"); - EXPECT_THROW_MSG((void)fmt::format(runtime("{0:.{?}}"), 0.0), format_error, - "invalid format string"); - EXPECT_THROW_MSG((void)fmt::format(runtime("{0:.{1}"), 0, 0), format_error, - "invalid format specifier"); - EXPECT_THROW_MSG((void)fmt::format(runtime("{0:.{1}}"), 0.0), format_error, - "argument not found"); - - EXPECT_THROW_MSG((void)fmt::format(runtime("{0:.{0:}}"), 0.0), format_error, - "invalid format string"); - - EXPECT_THROW_MSG((void)fmt::format(runtime("{0:.{1}}"), 0.0, -1), - format_error, "width/precision is out of range"); - EXPECT_THROW_MSG((void)fmt::format(runtime("{0:.{1}}"), 0.0, (INT_MAX + 1u)), - format_error, bad_dynamic_spec_msg); - EXPECT_THROW_MSG((void)fmt::format(runtime("{0:.{1}}"), 0.0, -1l), - format_error, bad_dynamic_spec_msg); - if (fmt::detail::const_check(sizeof(long) > sizeof(int))) { - long value = INT_MAX; - EXPECT_THROW_MSG((void)fmt::format(runtime("{0:.{1}}"), 0.0, (value + 1)), - format_error, bad_dynamic_spec_msg); - } - EXPECT_THROW_MSG((void)fmt::format(runtime("{0:.{1}}"), 0.0, (INT_MAX + 1ul)), - format_error, bad_dynamic_spec_msg); - - EXPECT_THROW_MSG((void)fmt::format(runtime("{0:.{1}}"), 0.0, '0'), - format_error, "width/precision is not integer"); - EXPECT_THROW_MSG((void)fmt::format(runtime("{0:.{1}}"), 0.0, 0.0), - format_error, "width/precision is not integer"); - - EXPECT_THROW_MSG((void)fmt::format(runtime("{0:.{1}}"), 42, 2), format_error, - "invalid format specifier"); - EXPECT_THROW_MSG((void)fmt::format(runtime("{0:.{1}f}"), 42, 2), format_error, - "invalid format specifier"); - EXPECT_THROW_MSG((void)fmt::format(runtime("{0:.{1}}"), 42u, 2), format_error, - "invalid format specifier"); - EXPECT_THROW_MSG((void)fmt::format(runtime("{0:.{1}f}"), 42u, 2), - format_error, "invalid format specifier"); - EXPECT_THROW_MSG((void)fmt::format(runtime("{0:.{1}}"), 42l, 2), format_error, - "invalid format specifier"); - EXPECT_THROW_MSG((void)fmt::format(runtime("{0:.{1}f}"), 42l, 2), - format_error, "invalid format specifier"); - EXPECT_THROW_MSG((void)fmt::format(runtime("{0:.{1}}"), 42ul, 2), - format_error, "invalid format specifier"); - EXPECT_THROW_MSG((void)fmt::format(runtime("{0:.{1}f}"), 42ul, 2), - format_error, "invalid format specifier"); - EXPECT_THROW_MSG((void)fmt::format(runtime("{0:.{1}}"), 42ll, 2), - format_error, "invalid format specifier"); - EXPECT_THROW_MSG((void)fmt::format(runtime("{0:.{1}f}"), 42ll, 2), - format_error, "invalid format specifier"); - EXPECT_THROW_MSG((void)fmt::format(runtime("{0:.{1}}"), 42ull, 2), - format_error, "invalid format specifier"); - EXPECT_THROW_MSG((void)fmt::format(runtime("{0:.{1}f}"), 42ull, 2), - format_error, "invalid format specifier"); - EXPECT_THROW_MSG((void)fmt::format(runtime("{0:3.{1}}"), 'x', 0), - format_error, "invalid format specifier"); - EXPECT_EQ(fmt::format("{0:.{1}}", 1.2345, 2), "1.2"); - EXPECT_EQ(fmt::format("{1:.{0}}", 2, 1.2345l), "1.2"); - - EXPECT_THROW_MSG((void)fmt::format(runtime("{0:.{1}}"), - reinterpret_cast<void*>(0xcafe), 2), - format_error, "invalid format specifier"); - EXPECT_THROW_MSG((void)fmt::format(runtime("{0:.{1}f}"), - reinterpret_cast<void*>(0xcafe), 2), - format_error, "invalid format specifier"); - - EXPECT_EQ(fmt::format("{0:.{1}}", "str", 2), "st"); -} - -TEST(format_test, format_bool) { - EXPECT_EQ(fmt::format("{}", true), "true"); - EXPECT_EQ(fmt::format("{}", false), "false"); - EXPECT_EQ(fmt::format("{:d}", true), "1"); - EXPECT_EQ(fmt::format("{:5}", true), "true "); - EXPECT_EQ(fmt::format("{:s}", true), "true"); - EXPECT_EQ(fmt::format("{:s}", false), "false"); - EXPECT_EQ(fmt::format("{:6s}", false), "false "); - EXPECT_THROW_MSG((void)fmt::format(runtime("{:c}"), false), format_error, - "invalid format specifier"); -} - -TEST(format_test, format_short) { - short s = 42; - EXPECT_EQ(fmt::format("{0:d}", s), "42"); - unsigned short us = 42; - EXPECT_EQ(fmt::format("{0:d}", us), "42"); -} - -template <typename T> -void check_unknown_types(const T& value, const char* types, const char*) { - char format_str[buffer_size]; - const char* special = ".0123456789L?}"; - for (int i = CHAR_MIN; i <= CHAR_MAX; ++i) { - char c = static_cast<char>(i); - if (std::strchr(types, c) || std::strchr(special, c) || !c) continue; - safe_sprintf(format_str, "{0:10%c}", c); - const char* message = "invalid format specifier"; - EXPECT_THROW_MSG((void)fmt::format(runtime(format_str), value), - format_error, message) - << format_str << " " << message; - } -} - -TEST(format_test, format_int) { - EXPECT_THROW_MSG((void)fmt::format(runtime("{0:v"), 42), format_error, - "invalid format specifier"); - check_unknown_types(42, "bBdoxXnLc", "integer"); - EXPECT_EQ(fmt::format("{:c}", static_cast<int>('x')), "x"); -} - -TEST(format_test, format_bin) { - EXPECT_EQ(fmt::format("{0:b}", 0), "0"); - EXPECT_EQ(fmt::format("{0:b}", 42), "101010"); - EXPECT_EQ(fmt::format("{0:b}", 42u), "101010"); - EXPECT_EQ(fmt::format("{0:b}", -42), "-101010"); - EXPECT_EQ(fmt::format("{0:b}", 12345), "11000000111001"); - EXPECT_EQ(fmt::format("{0:b}", 0x12345678), "10010001101000101011001111000"); - EXPECT_EQ("10010000101010111100110111101111", - fmt::format("{0:b}", 0x90ABCDEF)); - EXPECT_EQ("11111111111111111111111111111111", - fmt::format("{0:b}", max_value<uint32_t>())); -} - -#if FMT_USE_INT128 -constexpr auto int128_max = static_cast<__int128_t>( - (static_cast<__uint128_t>(1) << ((__SIZEOF_INT128__ * CHAR_BIT) - 1)) - 1); -constexpr auto int128_min = -int128_max - 1; - -constexpr auto uint128_max = ~static_cast<__uint128_t>(0); -#endif - -TEST(format_test, format_dec) { - EXPECT_EQ(fmt::format("{0}", 0), "0"); - EXPECT_EQ(fmt::format("{0}", 42), "42"); - EXPECT_EQ(fmt::format("{:}>", 42), "42>"); - EXPECT_EQ(fmt::format("{0:d}", 42), "42"); - EXPECT_EQ(fmt::format("{0}", 42u), "42"); - EXPECT_EQ(fmt::format("{0}", -42), "-42"); - EXPECT_EQ(fmt::format("{0}", 12345), "12345"); - EXPECT_EQ(fmt::format("{0}", 67890), "67890"); -#if FMT_USE_INT128 - EXPECT_EQ(fmt::format("{0}", static_cast<__int128_t>(0)), "0"); - EXPECT_EQ(fmt::format("{0}", static_cast<__uint128_t>(0)), "0"); - EXPECT_EQ("9223372036854775808", - fmt::format("{0}", static_cast<__int128_t>(INT64_MAX) + 1)); - EXPECT_EQ("-9223372036854775809", - fmt::format("{0}", static_cast<__int128_t>(INT64_MIN) - 1)); - EXPECT_EQ("18446744073709551616", - fmt::format("{0}", static_cast<__int128_t>(UINT64_MAX) + 1)); - EXPECT_EQ("170141183460469231731687303715884105727", - fmt::format("{0}", int128_max)); - EXPECT_EQ("-170141183460469231731687303715884105728", - fmt::format("{0}", int128_min)); - EXPECT_EQ("340282366920938463463374607431768211455", - fmt::format("{0}", uint128_max)); -#endif - - char buffer[buffer_size]; - safe_sprintf(buffer, "%d", INT_MIN); - EXPECT_EQ(buffer, fmt::format("{0}", INT_MIN)); - safe_sprintf(buffer, "%d", INT_MAX); - EXPECT_EQ(buffer, fmt::format("{0}", INT_MAX)); - safe_sprintf(buffer, "%u", UINT_MAX); - EXPECT_EQ(buffer, fmt::format("{0}", UINT_MAX)); - safe_sprintf(buffer, "%ld", 0 - static_cast<unsigned long>(LONG_MIN)); - EXPECT_EQ(buffer, fmt::format("{0}", LONG_MIN)); - safe_sprintf(buffer, "%ld", LONG_MAX); - EXPECT_EQ(buffer, fmt::format("{0}", LONG_MAX)); - safe_sprintf(buffer, "%lu", ULONG_MAX); - EXPECT_EQ(buffer, fmt::format("{0}", ULONG_MAX)); -} - -TEST(format_test, format_hex) { - EXPECT_EQ(fmt::format("{0:x}", 0), "0"); - EXPECT_EQ(fmt::format("{0:x}", 0x42), "42"); - EXPECT_EQ(fmt::format("{0:x}", 0x42u), "42"); - EXPECT_EQ(fmt::format("{0:x}", -0x42), "-42"); - EXPECT_EQ(fmt::format("{0:x}", 0x12345678), "12345678"); - EXPECT_EQ(fmt::format("{0:x}", 0x90abcdef), "90abcdef"); - EXPECT_EQ(fmt::format("{0:X}", 0x12345678), "12345678"); - EXPECT_EQ(fmt::format("{0:X}", 0x90ABCDEF), "90ABCDEF"); -#if FMT_USE_INT128 - EXPECT_EQ(fmt::format("{0:x}", static_cast<__int128_t>(0)), "0"); - EXPECT_EQ(fmt::format("{0:x}", static_cast<__uint128_t>(0)), "0"); - EXPECT_EQ("8000000000000000", - fmt::format("{0:x}", static_cast<__int128_t>(INT64_MAX) + 1)); - EXPECT_EQ("-8000000000000001", - fmt::format("{0:x}", static_cast<__int128_t>(INT64_MIN) - 1)); - EXPECT_EQ("10000000000000000", - fmt::format("{0:x}", static_cast<__int128_t>(UINT64_MAX) + 1)); - EXPECT_EQ("7fffffffffffffffffffffffffffffff", - fmt::format("{0:x}", int128_max)); - EXPECT_EQ("-80000000000000000000000000000000", - fmt::format("{0:x}", int128_min)); - EXPECT_EQ("ffffffffffffffffffffffffffffffff", - fmt::format("{0:x}", uint128_max)); -#endif - - char buffer[buffer_size]; - safe_sprintf(buffer, "-%x", 0 - static_cast<unsigned>(INT_MIN)); - EXPECT_EQ(buffer, fmt::format("{0:x}", INT_MIN)); - safe_sprintf(buffer, "%x", INT_MAX); - EXPECT_EQ(buffer, fmt::format("{0:x}", INT_MAX)); - safe_sprintf(buffer, "%x", UINT_MAX); - EXPECT_EQ(buffer, fmt::format("{0:x}", UINT_MAX)); - safe_sprintf(buffer, "-%lx", 0 - static_cast<unsigned long>(LONG_MIN)); - EXPECT_EQ(buffer, fmt::format("{0:x}", LONG_MIN)); - safe_sprintf(buffer, "%lx", LONG_MAX); - EXPECT_EQ(buffer, fmt::format("{0:x}", LONG_MAX)); - safe_sprintf(buffer, "%lx", ULONG_MAX); - EXPECT_EQ(buffer, fmt::format("{0:x}", ULONG_MAX)); -} - -TEST(format_test, format_oct) { - EXPECT_EQ(fmt::format("{0:o}", 0), "0"); - EXPECT_EQ(fmt::format("{0:o}", 042), "42"); - EXPECT_EQ(fmt::format("{0:o}", 042u), "42"); - EXPECT_EQ(fmt::format("{0:o}", -042), "-42"); - EXPECT_EQ(fmt::format("{0:o}", 012345670), "12345670"); -#if FMT_USE_INT128 - EXPECT_EQ(fmt::format("{0:o}", static_cast<__int128_t>(0)), "0"); - EXPECT_EQ(fmt::format("{0:o}", static_cast<__uint128_t>(0)), "0"); - EXPECT_EQ("1000000000000000000000", - fmt::format("{0:o}", static_cast<__int128_t>(INT64_MAX) + 1)); - EXPECT_EQ("-1000000000000000000001", - fmt::format("{0:o}", static_cast<__int128_t>(INT64_MIN) - 1)); - EXPECT_EQ("2000000000000000000000", - fmt::format("{0:o}", static_cast<__int128_t>(UINT64_MAX) + 1)); - EXPECT_EQ("1777777777777777777777777777777777777777777", - fmt::format("{0:o}", int128_max)); - EXPECT_EQ("-2000000000000000000000000000000000000000000", - fmt::format("{0:o}", int128_min)); - EXPECT_EQ("3777777777777777777777777777777777777777777", - fmt::format("{0:o}", uint128_max)); -#endif - - char buffer[buffer_size]; - safe_sprintf(buffer, "-%o", 0 - static_cast<unsigned>(INT_MIN)); - EXPECT_EQ(buffer, fmt::format("{0:o}", INT_MIN)); - safe_sprintf(buffer, "%o", INT_MAX); - EXPECT_EQ(buffer, fmt::format("{0:o}", INT_MAX)); - safe_sprintf(buffer, "%o", UINT_MAX); - EXPECT_EQ(buffer, fmt::format("{0:o}", UINT_MAX)); - safe_sprintf(buffer, "-%lo", 0 - static_cast<unsigned long>(LONG_MIN)); - EXPECT_EQ(buffer, fmt::format("{0:o}", LONG_MIN)); - safe_sprintf(buffer, "%lo", LONG_MAX); - EXPECT_EQ(buffer, fmt::format("{0:o}", LONG_MAX)); - safe_sprintf(buffer, "%lo", ULONG_MAX); - EXPECT_EQ(buffer, fmt::format("{0:o}", ULONG_MAX)); -} - -TEST(format_test, format_int_locale) { - EXPECT_EQ(fmt::format("{:L}", 1234), "1234"); -} - -TEST(format_test, format_float) { - EXPECT_EQ(fmt::format("{}", 0.0f), "0"); - EXPECT_EQ(fmt::format("{0:f}", 392.5f), "392.500000"); -} - -TEST(format_test, format_double) { - EXPECT_EQ(fmt::format("{}", 0.0), "0"); - check_unknown_types(1.2, "eEfFgGaAnL%", "double"); - EXPECT_EQ(fmt::format("{:}", 0.0), "0"); - EXPECT_EQ(fmt::format("{:f}", 0.0), "0.000000"); - EXPECT_EQ(fmt::format("{:g}", 0.0), "0"); - EXPECT_EQ(fmt::format("{:}", 392.65), "392.65"); - EXPECT_EQ(fmt::format("{:g}", 392.65), "392.65"); - EXPECT_EQ(fmt::format("{:G}", 392.65), "392.65"); - EXPECT_EQ(fmt::format("{:g}", 4.9014e6), "4.9014e+06"); - EXPECT_EQ(fmt::format("{:f}", 392.65), "392.650000"); - EXPECT_EQ(fmt::format("{:F}", 392.65), "392.650000"); - EXPECT_EQ(fmt::format("{:L}", 42.0), "42"); - EXPECT_EQ(fmt::format("{:24a}", 4.2f), " 0x1.0cccccp+2"); - EXPECT_EQ(fmt::format("{:24a}", 4.2), " 0x1.0cccccccccccdp+2"); - EXPECT_EQ(fmt::format("{:<24a}", 4.2), "0x1.0cccccccccccdp+2 "); - EXPECT_EQ(fmt::format("{0:e}", 392.65), "3.926500e+02"); - EXPECT_EQ(fmt::format("{0:E}", 392.65), "3.926500E+02"); - EXPECT_EQ(fmt::format("{0:+010.4g}", 392.65), "+0000392.6"); - -#if FMT_CPLUSPLUS >= 201703L - double xd = 0x1.ffffffffffp+2; - EXPECT_EQ(fmt::format("{:.10a}", xd), "0x1.ffffffffffp+2"); - EXPECT_EQ(fmt::format("{:.9a}", xd), "0x2.000000000p+2"); - - if (std::numeric_limits<long double>::digits == 64) { - auto ld = 0xf.ffffffffffp-3l; - EXPECT_EQ(fmt::format("{:a}", ld), "0xf.ffffffffffp-3"); - EXPECT_EQ(fmt::format("{:.10a}", ld), "0xf.ffffffffffp-3"); - EXPECT_EQ(fmt::format("{:.9a}", ld), "0x1.000000000p+1"); - } -#endif - - if (fmt::detail::const_check(std::numeric_limits<double>::is_iec559)) { - double d = (std::numeric_limits<double>::min)(); - EXPECT_EQ(fmt::format("{:a}", d), "0x1p-1022"); - EXPECT_EQ(fmt::format("{:#a}", d), "0x1.p-1022"); - - d = (std::numeric_limits<double>::max)(); - EXPECT_EQ(fmt::format("{:a}", d), "0x1.fffffffffffffp+1023"); - - d = std::numeric_limits<double>::denorm_min(); - EXPECT_EQ(fmt::format("{:a}", d), "0x0.0000000000001p-1022"); - } - - if (std::numeric_limits<long double>::digits == 64) { - auto ld = (std::numeric_limits<long double>::min)(); - EXPECT_EQ(fmt::format("{:a}", ld), "0x8p-16385"); - - ld = (std::numeric_limits<long double>::max)(); - EXPECT_EQ(fmt::format("{:a}", ld), "0xf.fffffffffffffffp+16380"); - - ld = std::numeric_limits<long double>::denorm_min(); - EXPECT_EQ(fmt::format("{:a}", ld), "0x0.000000000000001p-16382"); - } - - EXPECT_EQ(fmt::format("{:.10a}", 4.2), "0x1.0ccccccccdp+2"); - - EXPECT_EQ(fmt::format("{:a}", -42.0), "-0x1.5p+5"); - EXPECT_EQ(fmt::format("{:A}", -42.0), "-0X1.5P+5"); - - EXPECT_EQ(fmt::format("{:f}", 9223372036854775807.0), - "9223372036854775808.000000"); -} - -TEST(format_test, precision_rounding) { - EXPECT_EQ(fmt::format("{:.0f}", 0.0), "0"); - EXPECT_EQ(fmt::format("{:.0f}", 0.01), "0"); - EXPECT_EQ(fmt::format("{:.0f}", 0.1), "0"); - EXPECT_EQ(fmt::format("{:.3f}", 0.00049), "0.000"); - EXPECT_EQ(fmt::format("{:.3f}", 0.0005), "0.001"); - EXPECT_EQ(fmt::format("{:.3f}", 0.00149), "0.001"); - EXPECT_EQ(fmt::format("{:.3f}", 0.0015), "0.002"); - EXPECT_EQ(fmt::format("{:.3f}", 0.9999), "1.000"); - EXPECT_EQ(fmt::format("{:.3}", 0.00123), "0.00123"); - EXPECT_EQ(fmt::format("{:.16g}", 0.1), "0.1"); - EXPECT_EQ(fmt::format("{:.0}", 1.0), "1"); - EXPECT_EQ("225.51575035152063720", - fmt::format("{:.17f}", 225.51575035152064)); - EXPECT_EQ(fmt::format("{:.1f}", -761519619559038.2), "-761519619559038.2"); - EXPECT_EQ("1.9156918820264798e-56", - fmt::format("{}", 1.9156918820264798e-56)); - EXPECT_EQ(fmt::format("{:.4f}", 7.2809479766055470e-15), "0.0000"); -} - -TEST(format_test, prettify_float) { - EXPECT_EQ(fmt::format("{}", 1e-4), "0.0001"); - EXPECT_EQ(fmt::format("{}", 1e-5), "1e-05"); - EXPECT_EQ(fmt::format("{}", 1e15), "1000000000000000"); - EXPECT_EQ(fmt::format("{}", 1e16), "1e+16"); - EXPECT_EQ(fmt::format("{}", 9.999e-5), "9.999e-05"); - EXPECT_EQ(fmt::format("{}", 1e10), "10000000000"); - EXPECT_EQ(fmt::format("{}", 1e11), "100000000000"); - EXPECT_EQ(fmt::format("{}", 1234e7), "12340000000"); - EXPECT_EQ(fmt::format("{}", 1234e-2), "12.34"); - EXPECT_EQ(fmt::format("{}", 1234e-6), "0.001234"); - EXPECT_EQ(fmt::format("{}", 0.1f), "0.1"); - EXPECT_EQ(fmt::format("{}", 1.35631564e-19f), "1.3563156e-19"); -} - -TEST(format_test, format_nan) { - double nan = std::numeric_limits<double>::quiet_NaN(); - EXPECT_EQ(fmt::format("{}", nan), "nan"); - EXPECT_EQ(fmt::format("{:+}", nan), "+nan"); - EXPECT_EQ(fmt::format("{:+06}", nan), " +nan"); - EXPECT_EQ(fmt::format("{:<+06}", nan), "+nan "); - EXPECT_EQ(fmt::format("{:^+06}", nan), " +nan "); - EXPECT_EQ(fmt::format("{:>+06}", nan), " +nan"); - if (std::signbit(-nan)) { - EXPECT_EQ(fmt::format("{}", -nan), "-nan"); - EXPECT_EQ(fmt::format("{:+06}", -nan), " -nan"); - } else { - fmt::print("Warning: compiler doesn't handle negative NaN correctly"); - } - EXPECT_EQ(fmt::format("{: }", nan), " nan"); - EXPECT_EQ(fmt::format("{:F}", nan), "NAN"); - EXPECT_EQ(fmt::format("{:<7}", nan), "nan "); - EXPECT_EQ(fmt::format("{:^7}", nan), " nan "); - EXPECT_EQ(fmt::format("{:>7}", nan), " nan"); -} - -TEST(format_test, format_infinity) { - double inf = std::numeric_limits<double>::infinity(); - EXPECT_EQ(fmt::format("{}", inf), "inf"); - EXPECT_EQ(fmt::format("{:+}", inf), "+inf"); - EXPECT_EQ(fmt::format("{}", -inf), "-inf"); - EXPECT_EQ(fmt::format("{:+06}", inf), " +inf"); - EXPECT_EQ(fmt::format("{:+06}", -inf), " -inf"); - EXPECT_EQ(fmt::format("{:<+06}", inf), "+inf "); - EXPECT_EQ(fmt::format("{:^+06}", inf), " +inf "); - EXPECT_EQ(fmt::format("{:>+06}", inf), " +inf"); - EXPECT_EQ(fmt::format("{: }", inf), " inf"); - EXPECT_EQ(fmt::format("{:F}", inf), "INF"); - EXPECT_EQ(fmt::format("{:<7}", inf), "inf "); - EXPECT_EQ(fmt::format("{:^7}", inf), " inf "); - EXPECT_EQ(fmt::format("{:>7}", inf), " inf"); -} - -TEST(format_test, format_long_double) { - EXPECT_EQ(fmt::format("{0:}", 0.0l), "0"); - EXPECT_EQ(fmt::format("{0:f}", 0.0l), "0.000000"); - EXPECT_EQ(fmt::format("{:.1f}", 0.000000001l), "0.0"); - EXPECT_EQ(fmt::format("{:.2f}", 0.099l), "0.10"); - EXPECT_EQ(fmt::format("{0:}", 392.65l), "392.65"); - EXPECT_EQ(fmt::format("{0:g}", 392.65l), "392.65"); - EXPECT_EQ(fmt::format("{0:G}", 392.65l), "392.65"); - EXPECT_EQ(fmt::format("{0:f}", 392.65l), "392.650000"); - EXPECT_EQ(fmt::format("{0:F}", 392.65l), "392.650000"); - char buffer[buffer_size]; - safe_sprintf(buffer, "%Le", 392.65l); - EXPECT_EQ(buffer, fmt::format("{0:e}", 392.65l)); - EXPECT_EQ(fmt::format("{0:+010.4g}", 392.64l), "+0000392.6"); - - auto ld = 3.31l; - if (fmt::detail::is_double_double<decltype(ld)>::value) { - safe_sprintf(buffer, "%a", static_cast<double>(ld)); - EXPECT_EQ(buffer, fmt::format("{:a}", ld)); - } else if (std::numeric_limits<long double>::digits == 64) { - EXPECT_EQ(fmt::format("{:a}", ld), "0xd.3d70a3d70a3d70ap-2"); - } -} - -TEST(format_test, format_char) { - const char types[] = "cbBdoxX"; - check_unknown_types('a', types, "char"); - EXPECT_EQ(fmt::format("{0}", 'a'), "a"); - EXPECT_EQ(fmt::format("{0:c}", 'z'), "z"); - int n = 'x'; - for (const char* type = types + 1; *type; ++type) { - std::string format_str = fmt::format("{{:{}}}", *type); - EXPECT_EQ(fmt::format(runtime(format_str), n), - fmt::format(runtime(format_str), 'x')) - << format_str; - } - EXPECT_EQ(fmt::format("{:02X}", n), fmt::format("{:02X}", 'x')); - - EXPECT_EQ(fmt::format("{}", '\n'), "\n"); - EXPECT_EQ(fmt::format("{:?}", '\n'), "'\\n'"); - EXPECT_EQ(fmt::format("{:x}", '\xff'), "ff"); -} - -TEST(format_test, format_volatile_char) { - volatile char c = 'x'; - EXPECT_EQ(fmt::format("{}", c), "x"); -} - -TEST(format_test, format_unsigned_char) { - EXPECT_EQ(fmt::format("{}", static_cast<unsigned char>(42)), "42"); - EXPECT_EQ(fmt::format("{}", static_cast<uint8_t>(42)), "42"); -} - -TEST(format_test, format_cstring) { - check_unknown_types("test", "sp", "string"); - EXPECT_EQ(fmt::format("{0}", "test"), "test"); - EXPECT_EQ(fmt::format("{0:s}", "test"), "test"); - char nonconst[] = "nonconst"; - EXPECT_EQ(fmt::format("{0}", nonconst), "nonconst"); - auto nullstr = static_cast<const char*>(nullptr); - EXPECT_THROW_MSG((void)fmt::format("{}", nullstr), format_error, - "string pointer is null"); - EXPECT_THROW_MSG((void)fmt::format("{:s}", nullstr), format_error, - "string pointer is null"); -} - -void function_pointer_test(int, double, std::string) {} - -TEST(format_test, format_pointer) { - check_unknown_types(reinterpret_cast<void*>(0x1234), "p", "pointer"); - EXPECT_EQ(fmt::format("{0}", static_cast<void*>(nullptr)), "0x0"); - EXPECT_EQ(fmt::format("{0}", reinterpret_cast<void*>(0x1234)), "0x1234"); - EXPECT_EQ(fmt::format("{0:p}", reinterpret_cast<void*>(0x1234)), "0x1234"); - // On CHERI (or other fat-pointer) systems, the size of a pointer is greater - // than the size an integer that can hold a virtual address. There is no - // portable address-as-an-integer type (yet) in C++, so we use `size_t` as - // the closest equivalent for now. - EXPECT_EQ("0x" + std::string(sizeof(size_t) * CHAR_BIT / 4, 'f'), - fmt::format("{0}", reinterpret_cast<void*>(~uintptr_t()))); - EXPECT_EQ("0x1234", - fmt::format("{}", fmt::ptr(reinterpret_cast<int*>(0x1234)))); - EXPECT_EQ(fmt::format("{}", fmt::detail::bit_cast<const void*>( - &function_pointer_test)), - fmt::format("{}", fmt::ptr(function_pointer_test))); - EXPECT_EQ(fmt::format("{}", nullptr), "0x0"); -} - -TEST(format_test, write_uintptr_fallback) { - // Test that formatting a pointer by converting it to uint128_fallback works. - // This is needed to support systems without uintptr_t. - auto s = std::string(); - fmt::detail::write_ptr<char>( - std::back_inserter(s), - fmt::detail::bit_cast<fmt::detail::uint128_fallback>( - reinterpret_cast<void*>(0xface)), - nullptr); - EXPECT_EQ(s, "0xface"); -} - -enum class color { red, green, blue }; - -namespace test_ns { -enum class color { red, green, blue }; -using fmt::enums::format_as; -} // namespace test_ns - -TEST(format_test, format_enum_class) { - EXPECT_EQ(fmt::format("{}", fmt::underlying(color::red)), "0"); - EXPECT_EQ(fmt::format("{}", test_ns::color::red), "0"); -} - -TEST(format_test, format_string) { - EXPECT_EQ(fmt::format("{0}", std::string("test")), "test"); - EXPECT_EQ(fmt::format("{0}", std::string("test")), "test"); - EXPECT_EQ(fmt::format("{:?}", std::string("test")), "\"test\""); - EXPECT_EQ(fmt::format("{:*^10?}", std::string("test")), "**\"test\"**"); - EXPECT_EQ(fmt::format("{:?}", std::string("\test")), "\"\\test\""); - EXPECT_THROW((void)fmt::format(fmt::runtime("{:x}"), std::string("test")), - fmt::format_error); -} - -TEST(format_test, format_string_view) { - EXPECT_EQ(fmt::format("{}", string_view("test")), "test"); - EXPECT_EQ(fmt::format("{:?}", string_view("t\nst")), "\"t\\nst\""); - EXPECT_EQ(fmt::format("{}", string_view()), ""); -} - -#ifdef FMT_USE_STRING_VIEW -struct string_viewable {}; - -FMT_BEGIN_NAMESPACE -template <> struct formatter<string_viewable> : formatter<std::string_view> { - auto format(string_viewable, format_context& ctx) const - -> decltype(ctx.out()) { - return formatter<std::string_view>::format("foo", ctx); - } -}; -FMT_END_NAMESPACE - -TEST(format_test, format_std_string_view) { - EXPECT_EQ(fmt::format("{}", std::string_view("test")), "test"); - EXPECT_EQ(fmt::format("{}", string_viewable()), "foo"); -} - -struct explicitly_convertible_to_std_string_view { - explicit operator std::string_view() const { return "foo"; } -}; - -template <> -struct fmt::formatter<explicitly_convertible_to_std_string_view> - : formatter<std::string_view> { - auto format(explicitly_convertible_to_std_string_view v, - format_context& ctx) const -> decltype(ctx.out()) { - return fmt::format_to(ctx.out(), "'{}'", std::string_view(v)); - } -}; - -TEST(format_test, format_explicitly_convertible_to_std_string_view) { - EXPECT_EQ("'foo'", - fmt::format("{}", explicitly_convertible_to_std_string_view())); -} - -struct convertible_to_std_string_view { - operator std::string_view() const noexcept { return "Hi there"; } -}; -FMT_BEGIN_NAMESPACE -template <> -class formatter<convertible_to_std_string_view> - : public formatter<std::string_view> {}; -FMT_END_NAMESPACE - -TEST(format_test, format_implicitly_convertible_and_inherits_string_view) { - static_assert(fmt::is_formattable<convertible_to_std_string_view>{}, ""); - EXPECT_EQ("Hi there", fmt::format("{}", convertible_to_std_string_view{})); -} -#endif - -class Answer {}; - -FMT_BEGIN_NAMESPACE -template <> struct formatter<date> { - template <typename ParseContext> - FMT_CONSTEXPR auto parse(ParseContext& ctx) -> decltype(ctx.begin()) { - auto it = ctx.begin(); - if (it != ctx.end() && *it == 'd') ++it; - return it; - } - - auto format(const date& d, format_context& ctx) const -> decltype(ctx.out()) { - // Namespace-qualify to avoid ambiguity with std::format_to. - fmt::format_to(ctx.out(), "{}-{}-{}", d.year(), d.month(), d.day()); - return ctx.out(); - } -}; - -template <> struct formatter<Answer> : formatter<int> { - template <typename FormatContext> - auto format(Answer, FormatContext& ctx) const -> decltype(ctx.out()) { - return formatter<int>::format(42, ctx); - } -}; -FMT_END_NAMESPACE - -TEST(format_test, format_custom) { - EXPECT_THROW_MSG((void)fmt::format(runtime("{:s}"), date(2012, 12, 9)), - format_error, "unknown format specifier"); - EXPECT_EQ(fmt::format("{0}", Answer()), "42"); - EXPECT_EQ(fmt::format("{:04}", Answer()), "0042"); -} - -TEST(format_test, format_to_custom) { - char buf[10] = {}; - auto end = fmt::format_to(buf, "{}", Answer()); - EXPECT_EQ(end, buf + 2); - EXPECT_STREQ(buf, "42"); -} - -TEST(format_test, format_string_from_speed_test) { - EXPECT_EQ("1.2340000000:0042:+3.13:str:0x3e8:X:%", - fmt::format("{0:0.10f}:{1:04}:{2:+g}:{3}:{4}:{5}:%", 1.234, 42, - 3.13, "str", reinterpret_cast<void*>(1000), 'X')); -} - -TEST(format_test, format_examples) { - std::string message = fmt::format("The answer is {}", 42); - EXPECT_EQ("The answer is 42", message); - - EXPECT_EQ(fmt::format("{}", 42), "42"); - - memory_buffer out; - fmt::format_to(std::back_inserter(out), "The answer is {}.", 42); - EXPECT_EQ("The answer is 42.", to_string(out)); - - EXPECT_THROW( - { - const char* filename = "madeup"; - FILE* file = fopen(filename, "r"); - if (!file) - throw fmt::system_error(errno, "cannot open file '{}'", filename); - fclose(file); - }, - std::system_error); - - EXPECT_EQ("First, thou shalt count to three", - fmt::format("First, thou shalt count to {0}", "three")); - EXPECT_EQ(fmt::format("Bring me a {}", "shrubbery"), "Bring me a shrubbery"); - EXPECT_EQ(fmt::format("From {} to {}", 1, 3), "From 1 to 3"); - - char buffer[buffer_size]; - safe_sprintf(buffer, "%03.2f", -1.2); - EXPECT_EQ(buffer, fmt::format("{:03.2f}", -1.2)); - - EXPECT_EQ(fmt::format("{0}, {1}, {2}", 'a', 'b', 'c'), "a, b, c"); - EXPECT_EQ(fmt::format("{}, {}, {}", 'a', 'b', 'c'), "a, b, c"); - EXPECT_EQ(fmt::format("{2}, {1}, {0}", 'a', 'b', 'c'), "c, b, a"); - EXPECT_EQ(fmt::format("{0}{1}{0}", "abra", "cad"), "abracadabra"); - - EXPECT_EQ("left aligned ", - fmt::format("{:<30}", "left aligned")); - EXPECT_EQ(" right aligned", - fmt::format("{:>30}", "right aligned")); - EXPECT_EQ(" centered ", - fmt::format("{:^30}", "centered")); - EXPECT_EQ("***********centered***********", - fmt::format("{:*^30}", "centered")); - - EXPECT_EQ(fmt::format("{:+f}; {:+f}", 3.14, -3.14), "+3.140000; -3.140000"); - EXPECT_EQ(fmt::format("{: f}; {: f}", 3.14, -3.14), " 3.140000; -3.140000"); - EXPECT_EQ(fmt::format("{:-f}; {:-f}", 3.14, -3.14), "3.140000; -3.140000"); - - EXPECT_EQ("int: 42; hex: 2a; oct: 52", - fmt::format("int: {0:d}; hex: {0:x}; oct: {0:o}", 42)); - EXPECT_EQ("int: 42; hex: 0x2a; oct: 052", - fmt::format("int: {0:d}; hex: {0:#x}; oct: {0:#o}", 42)); - - EXPECT_EQ(fmt::format("The answer is {}", 42), "The answer is 42"); - EXPECT_THROW_MSG( - (void)fmt::format(runtime("The answer is {:d}"), "forty-two"), - format_error, "invalid format specifier"); - - EXPECT_WRITE( - stdout, fmt::print("{}", std::numeric_limits<double>::infinity()), "inf"); -} - -TEST(format_test, print) { - EXPECT_WRITE(stdout, fmt::print("Don't {}!", "panic"), "Don't panic!"); - EXPECT_WRITE(stderr, fmt::print(stderr, "Don't {}!", "panic"), - "Don't panic!"); - EXPECT_WRITE(stdout, fmt::println("Don't {}!", "panic"), "Don't panic!\n"); - EXPECT_WRITE(stderr, fmt::println(stderr, "Don't {}!", "panic"), - "Don't panic!\n"); -} - -TEST(format_test, big_print) { - enum { count = 5000 }; - auto big_print = []() { - for (int i = 0; i < count / 5; ++i) fmt::print("xxxxx"); - }; - EXPECT_WRITE(stdout, big_print(), std::string(count, 'x')); -} - -struct deadlockable { - int value = 0; - mutable std::mutex mutex; -}; - -FMT_BEGIN_NAMESPACE -template <> struct formatter<deadlockable> { - FMT_CONSTEXPR auto parse(format_parse_context& ctx) -> decltype(ctx.begin()) { - return ctx.begin(); - } - - auto format(const deadlockable& d, format_context& ctx) const - -> decltype(ctx.out()) { - std::lock_guard<std::mutex> lock(d.mutex); - return format_to(ctx.out(), "{}", d.value); - } -}; -FMT_END_NAMESPACE - -TEST(format_test, locking_formatter) { - auto f = fmt::buffered_file(); - try { - f = fmt::buffered_file("/dev/null", "w"); - } catch (const std::system_error&) { - fmt::print(stderr, "warning: /dev/null is not supported\n"); - return; - } - deadlockable d; - auto t = std::thread([&]() { - fmt::print(f.get(), "start t\n"); - std::lock_guard<std::mutex> lock(d.mutex); - for (int i = 0; i < 1000000; ++i) d.value += 10; - fmt::print(f.get(), "done\n"); - }); - for (int i = 0; i < 100; ++i) fmt::print(f.get(), "{}", d); - t.join(); -} - -TEST(format_test, variadic) { - EXPECT_EQ(fmt::format("{}c{}", "ab", 1), "abc1"); -} - -TEST(format_test, bytes) { - auto s = fmt::format("{:10}", fmt::bytes("ёжик")); - EXPECT_EQ("ёжик ", s); - EXPECT_EQ(10, s.size()); -} - -TEST(format_test, group_digits_view) { - EXPECT_EQ(fmt::format("{}", fmt::group_digits(10000000)), "10,000,000"); - EXPECT_EQ(fmt::format("{:8}", fmt::group_digits(1000)), " 1,000"); - EXPECT_EQ(fmt::format("{}", fmt::group_digits(-10000000)), "-10,000,000"); - EXPECT_EQ(fmt::format("{:8}", fmt::group_digits(-1000)), " -1,000"); - EXPECT_EQ(fmt::format("{:8}", fmt::group_digits(-100)), " -100"); -} - -#ifdef __cpp_generic_lambdas -struct point { - double x, y; -}; - -FMT_BEGIN_NAMESPACE -template <> struct formatter<point> : nested_formatter<double> { - auto format(point p, format_context& ctx) const -> decltype(ctx.out()) { - return write_padded(ctx, [this, p](auto out) -> decltype(out) { - return fmt::format_to(out, "({}, {})", this->nested(p.x), - this->nested(p.y)); - }); - } -}; -FMT_END_NAMESPACE - -TEST(format_test, nested_formatter) { - EXPECT_EQ(fmt::format("{:>16.2f}", point{1, 2}), " (1.00, 2.00)"); -} -#endif // __cpp_generic_lambdas - -enum test_enum { foo, bar }; -auto format_as(test_enum e) -> int { return e; } - -std::string vformat_message(int id, const char* format, fmt::format_args args) { - auto buffer = fmt::memory_buffer(); - fmt::format_to(fmt::appender(buffer), "[{}] ", id); - vformat_to(fmt::appender(buffer), format, args); - return to_string(buffer); -} - -template <typename... Args> -std::string format_message(int id, const char* format, const Args&... args) { - auto va = fmt::make_format_args(args...); - return vformat_message(id, format, va); -} - -TEST(format_test, format_message_example) { - EXPECT_EQ("[42] something happened", - format_message(42, "{} happened", "something")); -} - -template <typename... Args> -void print_error(const char* file, int line, const char* format, - const Args&... args) { - fmt::print("{}: {}: ", file, line); - fmt::print(format, args...); -} - -TEST(format_test, unpacked_args) { - EXPECT_EQ("0123456789abcdefg", - fmt::format("{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}", 0, 1, 2, 3, 4, 5, - 6, 7, 8, 9, 'a', 'b', 'c', 'd', 'e', 'f', 'g')); -} - -constexpr char with_null[3] = {'{', '}', '\0'}; -constexpr char no_null[2] = {'{', '}'}; -static constexpr char static_with_null[3] = {'{', '}', '\0'}; -static constexpr char static_no_null[2] = {'{', '}'}; - -TEST(format_test, compile_time_string) { - EXPECT_EQ(fmt::format(FMT_STRING("foo")), "foo"); - EXPECT_EQ(fmt::format(FMT_STRING("{}"), 42), "42"); - -#if FMT_USE_NONTYPE_TEMPLATE_ARGS - using namespace fmt::literals; - EXPECT_EQ("foobar", fmt::format(FMT_STRING("{foo}{bar}"), "bar"_a = "bar", - "foo"_a = "foo")); - EXPECT_EQ(fmt::format(FMT_STRING("")), ""); - EXPECT_EQ(fmt::format(FMT_STRING(""), "arg"_a = 42), ""); - EXPECT_EQ(fmt::format(FMT_STRING("{answer}"), "answer"_a = Answer()), "42"); - EXPECT_EQ(fmt::format(FMT_STRING("{} {two}"), 1, "two"_a = 2), "1 2"); -#endif - - (void)static_with_null; - (void)static_no_null; -#ifndef _MSC_VER - EXPECT_EQ(fmt::format(FMT_STRING(static_with_null), 42), "42"); - EXPECT_EQ(fmt::format(FMT_STRING(static_no_null), 42), "42"); -#endif - - (void)with_null; - (void)no_null; -#if FMT_CPLUSPLUS >= 201703L - EXPECT_EQ(fmt::format(FMT_STRING(with_null), 42), "42"); - EXPECT_EQ(fmt::format(FMT_STRING(no_null), 42), "42"); -#endif -#if defined(FMT_USE_STRING_VIEW) && FMT_CPLUSPLUS >= 201703L - EXPECT_EQ(fmt::format(FMT_STRING(std::string_view("{}")), 42), "42"); -#endif -} - -TEST(format_test, custom_format_compile_time_string) { - EXPECT_EQ(fmt::format(FMT_STRING("{}"), Answer()), "42"); - auto answer = Answer(); - EXPECT_EQ(fmt::format(FMT_STRING("{}"), answer), "42"); - char buf[10] = {}; - fmt::format_to(buf, FMT_STRING("{}"), answer); - const Answer const_answer = Answer(); - EXPECT_EQ(fmt::format(FMT_STRING("{}"), const_answer), "42"); -} - -TEST(format_test, named_arg_udl) { - using namespace fmt::literals; - auto udl_a = fmt::format("{first}{second}{first}{third}", "first"_a = "abra", - "second"_a = "cad", "third"_a = 99); - EXPECT_EQ( - fmt::format("{first}{second}{first}{third}", fmt::arg("first", "abra"), - fmt::arg("second", "cad"), fmt::arg("third", 99)), - udl_a); - - EXPECT_EQ(fmt::format("{answer}", "answer"_a = Answer()), "42"); -} - -TEST(format_test, enum) { EXPECT_EQ(fmt::format("{}", foo), "0"); } - -TEST(format_test, formatter_not_specialized) { - static_assert(!fmt::is_formattable<fmt::formatter<test_enum>, - fmt::format_context>::value, - ""); -} - -#if FMT_HAS_FEATURE(cxx_strong_enums) -enum big_enum : unsigned long long { big_enum_value = 5000000000ULL }; -auto format_as(big_enum e) -> unsigned long long { return e; } - -TEST(format_test, strong_enum) { - auto arg = fmt::basic_format_arg<fmt::context>(big_enum_value); - EXPECT_EQ(arg.type(), fmt::detail::type::ulong_long_type); - EXPECT_EQ(fmt::format("{}", big_enum_value), "5000000000"); -} -#endif - -TEST(format_test, non_null_terminated_format_string) { - EXPECT_EQ(fmt::format(string_view("{}foo", 2), 42), "42"); -} - -namespace adl_test { -namespace fmt { -namespace detail { -struct foo {}; -template <typename, typename OutputIt> void write(OutputIt, foo) = delete; -} // namespace detail -} // namespace fmt -} // namespace adl_test - -FMT_BEGIN_NAMESPACE -template <> -struct formatter<adl_test::fmt::detail::foo> : formatter<std::string> { - auto format(adl_test::fmt::detail::foo, format_context& ctx) const - -> decltype(ctx.out()) { - return formatter<std::string>::format("foo", ctx); - } -}; -FMT_END_NAMESPACE - -TEST(format_test, to_string) { - EXPECT_EQ(fmt::to_string(42), "42"); - EXPECT_EQ(fmt::to_string(reinterpret_cast<void*>(0x1234)), "0x1234"); - EXPECT_EQ(fmt::to_string(adl_test::fmt::detail::foo()), "foo"); - EXPECT_EQ(fmt::to_string(foo), "0"); - -#if FMT_USE_FLOAT128 - EXPECT_EQ(fmt::to_string(__float128(0.5)), "0.5"); -#endif - -#if defined(FMT_USE_STRING_VIEW) && FMT_CPLUSPLUS >= 201703L - EXPECT_EQ(fmt::to_string(std::string_view()), ""); -#endif -} - -TEST(format_test, output_iterators) { - std::list<char> out; - fmt::format_to(std::back_inserter(out), "{}", 42); - EXPECT_EQ("42", std::string(out.begin(), out.end())); - std::stringstream s; - fmt::format_to(std::ostream_iterator<char>(s), "{}", 42); - EXPECT_EQ("42", s.str()); - - std::stringstream s2; - fmt::format_to(std::ostreambuf_iterator<char>(s2), "{}.{:06d}", 42, 43); - EXPECT_EQ("42.000043", s2.str()); -} - -TEST(format_test, fill_via_appender) { - fmt::memory_buffer buf; - auto it = fmt::appender(buf); - std::fill_n(it, 3, '~'); - EXPECT_EQ(fmt::to_string(buf), "~~~"); -} - -TEST(format_test, formatted_size) { - EXPECT_EQ(2u, fmt::formatted_size("{}", 42)); - EXPECT_EQ(2u, fmt::formatted_size(std::locale(), "{}", 42)); -} - -TEST(format_test, format_to_no_args) { - std::string s; - fmt::format_to(std::back_inserter(s), "test"); - EXPECT_EQ("test", s); -} - -TEST(format_test, format_to) { - std::string s; - fmt::format_to(std::back_inserter(s), "part{0}", 1); - EXPECT_EQ("part1", s); - fmt::format_to(std::back_inserter(s), "part{0}", 2); - EXPECT_EQ("part1part2", s); -} - -TEST(format_test, format_to_memory_buffer) { - auto buf = fmt::basic_memory_buffer<char, 100>(); - fmt::format_to(fmt::appender(buf), "{}", "foo"); - EXPECT_EQ("foo", to_string(buf)); -} - -TEST(format_test, format_to_vector) { - std::vector<char> v; - fmt::format_to(std::back_inserter(v), "{}", "foo"); - EXPECT_EQ(string_view(v.data(), v.size()), "foo"); -} - -struct nongrowing_container { - using value_type = char; - void push_back(char) { throw std::runtime_error("can't take it any more"); } -}; - -TEST(format_test, format_to_propagates_exceptions) { - auto c = nongrowing_container(); - EXPECT_THROW(fmt::format_to(std::back_inserter(c), "{}", 42), - std::runtime_error); -} - -TEST(format_test, format_to_n) { - char buffer[4]; - buffer[3] = 'x'; - auto result = fmt::format_to_n(buffer, 3, "{}", 12345); - EXPECT_EQ(5u, result.size); - EXPECT_EQ(buffer + 3, result.out); - EXPECT_EQ("123x", fmt::string_view(buffer, 4)); - - result = fmt::format_to_n(buffer, 3, "{:s}", "foobar"); - EXPECT_EQ(6u, result.size); - EXPECT_EQ(buffer + 3, result.out); - EXPECT_EQ("foox", fmt::string_view(buffer, 4)); - - buffer[0] = 'x'; - buffer[1] = 'x'; - buffer[2] = 'x'; - result = fmt::format_to_n(buffer, 3, "{}", 'A'); - EXPECT_EQ(1u, result.size); - EXPECT_EQ(buffer + 1, result.out); - EXPECT_EQ("Axxx", fmt::string_view(buffer, 4)); - - result = fmt::format_to_n(buffer, 3, "{}{} ", 'B', 'C'); - EXPECT_EQ(3u, result.size); - EXPECT_EQ(buffer + 3, result.out); - EXPECT_EQ("BC x", fmt::string_view(buffer, 4)); - - result = fmt::format_to_n(buffer, 4, "{}", "ABCDE"); - EXPECT_EQ(5u, result.size); - EXPECT_EQ("ABCD", fmt::string_view(buffer, 4)); - - buffer[3] = 'x'; - result = fmt::format_to_n(buffer, 3, "{}", std::string(1000, '*')); - EXPECT_EQ(1000u, result.size); - EXPECT_EQ("***x", fmt::string_view(buffer, 4)); -} - -struct test_output_iterator { - char* data; - - using iterator_category = std::output_iterator_tag; - using value_type = void; - using difference_type = void; - using pointer = void; - using reference = void; - - auto operator++() -> test_output_iterator& { - ++data; - return *this; - } - auto operator++(int) -> test_output_iterator { - auto tmp = *this; - ++data; - return tmp; - } - auto operator*() -> char& { return *data; } -}; - -TEST(format_test, format_to_n_output_iterator) { - char buf[10] = {}; - fmt::format_to_n(test_output_iterator{buf}, 10, "{}", 42); - EXPECT_STREQ(buf, "42"); -} - -TEST(format_test, vformat_to) { - using context = fmt::format_context; - int n = 42; - auto args = fmt::make_format_args<context>(n); - auto s = std::string(); - fmt::vformat_to(std::back_inserter(s), "{}", args); - EXPECT_EQ(s, "42"); - s.clear(); - fmt::vformat_to(std::back_inserter(s), "{}", args); - EXPECT_EQ(s, "42"); -} - -TEST(format_test, char_traits_not_ambiguous) { - // Test that we don't inject detail names into the std namespace. - using namespace std; - auto c = char_traits<char>::char_type(); - (void)c; -#if FMT_CPLUSPLUS >= 201103L - auto s = std::string(); - auto lval = begin(s); - (void)lval; -#endif -} - -struct check_back_appender {}; - -FMT_BEGIN_NAMESPACE -template <> struct formatter<check_back_appender> { - FMT_CONSTEXPR auto parse(format_parse_context& ctx) -> decltype(ctx.begin()) { - return ctx.begin(); - } - - template <typename Context> - auto format(check_back_appender, Context& ctx) const -> decltype(ctx.out()) { - auto out = ctx.out(); - static_assert(std::is_same<decltype(++out), decltype(out)&>::value, - "needs to satisfy weakly_incrementable"); - *out = 'y'; - return ++out; - } -}; -FMT_END_NAMESPACE - -TEST(format_test, back_insert_slicing) { - EXPECT_EQ(fmt::format("{}", check_back_appender{}), "y"); -} - -namespace test { -enum class scoped_enum_as_int {}; -auto format_as(scoped_enum_as_int) -> int { return 42; } - -enum class scoped_enum_as_string_view {}; -auto format_as(scoped_enum_as_string_view) -> fmt::string_view { return "foo"; } - -enum class scoped_enum_as_string {}; -auto format_as(scoped_enum_as_string) -> std::string { return "foo"; } - -struct struct_as_int {}; -auto format_as(struct_as_int) -> int { return 42; } - -struct struct_as_const_reference { - const std::string name = "foo"; -}; -auto format_as(const struct_as_const_reference& s) -> const std::string& { - return s.name; -} -} // namespace test - -TEST(format_test, format_as) { - EXPECT_EQ(fmt::format("{}", test::scoped_enum_as_int()), "42"); - EXPECT_EQ(fmt::format("{}", test::scoped_enum_as_string_view()), "foo"); - EXPECT_EQ(fmt::format("{}", test::scoped_enum_as_string()), "foo"); - EXPECT_EQ(fmt::format("{}", test::struct_as_int()), "42"); - EXPECT_EQ(fmt::format("{}", test::struct_as_const_reference()), "foo"); -} - -TEST(format_test, format_as_to_string) { - EXPECT_EQ(fmt::to_string(test::scoped_enum_as_int()), "42"); - EXPECT_EQ(fmt::to_string(test::scoped_enum_as_string_view()), "foo"); - EXPECT_EQ(fmt::to_string(test::scoped_enum_as_string()), "foo"); - EXPECT_EQ(fmt::to_string(test::struct_as_int()), "42"); -} - -template <typename Char, typename T> auto check_enabled_formatter() -> bool { - static_assert(std::is_default_constructible<fmt::formatter<T, Char>>::value, - ""); - return true; -} - -template <typename Char, typename... T> void check_enabled_formatters() { - auto dummy = {check_enabled_formatter<Char, T>()...}; - (void)dummy; -} - -TEST(format_test, test_formatters_enabled) { - using custom_string = - std::basic_string<char, std::char_traits<char>, mock_allocator<char>>; - using custom_wstring = std::basic_string<wchar_t, std::char_traits<wchar_t>, - mock_allocator<wchar_t>>; - - check_enabled_formatters<char, bool, char, signed char, unsigned char, short, - unsigned short, int, unsigned, long, unsigned long, - long long, unsigned long long, float, double, - long double, void*, const void*, char*, const char*, - std::string, custom_string, std::nullptr_t>(); - check_enabled_formatters< - wchar_t, bool, wchar_t, signed char, unsigned char, short, unsigned short, - int, unsigned, long, unsigned long, long long, unsigned long long, float, - double, long double, void*, const void*, wchar_t*, const wchar_t*, - std::wstring, custom_wstring, std::nullptr_t>(); -} - -TEST(format_int_test, data) { - fmt::format_int format_int(42); - EXPECT_EQ(std::string(format_int.data(), format_int.size()), "42"); -} - -TEST(format_int_test, format_int) { - EXPECT_EQ(fmt::format_int(42).str(), "42"); - EXPECT_EQ(fmt::format_int(42).size(), 2u); - EXPECT_EQ(fmt::format_int(-42).str(), "-42"); - EXPECT_EQ(fmt::format_int(-42).size(), 3u); - EXPECT_EQ(fmt::format_int(42ul).str(), "42"); - EXPECT_EQ(fmt::format_int(-42l).str(), "-42"); - EXPECT_EQ(fmt::format_int(42ull).str(), "42"); - EXPECT_EQ(fmt::format_int(-42ll).str(), "-42"); - EXPECT_EQ(fmt::format_int(max_value<int64_t>()).str(), - std::to_string(max_value<int64_t>())); -} - -#ifndef FMT_STATIC_THOUSANDS_SEPARATOR - -# include <locale> - -class format_facet : public fmt::format_facet<std::locale> { - protected: - struct int_formatter { - fmt::appender out; - - template <typename T, FMT_ENABLE_IF(fmt::detail::is_integer<T>::value)> - auto operator()(T value) -> bool { - fmt::format_to(out, "[{}]", value); - return true; - } - - template <typename T, FMT_ENABLE_IF(!fmt::detail::is_integer<T>::value)> - auto operator()(T) -> bool { - return false; - } - }; - - auto do_put(fmt::appender out, fmt::loc_value val, - const fmt::format_specs&) const -> bool override; -}; - -auto format_facet::do_put(fmt::appender out, fmt::loc_value val, - const fmt::format_specs&) const -> bool { - return val.visit(int_formatter{out}); -} - -TEST(format_test, format_facet) { - auto loc = std::locale(std::locale(), new format_facet()); - EXPECT_EQ(fmt::format(loc, "{:L}", 42), "[42]"); - EXPECT_EQ(fmt::format(loc, "{:L}", -42), "[-42]"); -} - -TEST(format_test, format_facet_separator) { - // U+2019 RIGHT SINGLE QUOTATION MARK is a digit separator in the de_CH - // locale. - auto loc = - std::locale({}, new fmt::format_facet<std::locale>("\xe2\x80\x99")); - EXPECT_EQ(fmt::format(loc, "{:L}", 1000), - "1\xe2\x80\x99" - "000"); -} - -TEST(format_test, format_facet_grouping) { - auto loc = - std::locale({}, new fmt::format_facet<std::locale>(",", {1, 2, 3})); - EXPECT_EQ(fmt::format(loc, "{:L}", 1234567890), "1,234,567,89,0"); -} - -TEST(format_test, format_named_arg_with_locale) { - EXPECT_EQ(fmt::format(std::locale(), "{answer}", fmt::arg("answer", 42)), - "42"); -} - -TEST(format_test, format_locale) { - auto loc = std::locale({}, new fmt::format_facet<std::locale>(",")); - EXPECT_EQ(fmt::format(loc, "{:Lx}", 123456789), "7,5bc,d15"); - EXPECT_EQ(fmt::format(loc, "{:#Lb}", -123456789), - "-0b111,010,110,111,100,110,100,010,101"); - EXPECT_EQ(fmt::format(loc, "{:10Lo}", 12345), " 30,071"); -} - -#endif // FMT_STATIC_THOUSANDS_SEPARATOR - -struct convertible_to_nonconst_cstring { - operator char*() const { - static char c[] = "bar"; - return c; - } -}; - -FMT_BEGIN_NAMESPACE -template <> -struct formatter<convertible_to_nonconst_cstring> : formatter<char*> {}; -FMT_END_NAMESPACE - -TEST(format_test, formatter_nonconst_char) { - EXPECT_EQ(fmt::format("{}", convertible_to_nonconst_cstring()), "bar"); -} - -namespace adl_test { -template <typename... T> void make_format_args(const T&...) = delete; - -struct string : std::string {}; -auto format_as(const string& s) -> std::string { return s; } -} // namespace adl_test - -// Test that formatting functions compile when make_format_args is found by ADL. -TEST(format_test, adl) { - // Only check compilation and don't run the code to avoid polluting the output - // and since the output is tested elsewhere. - if (fmt::detail::const_check(true)) return; - auto s = adl_test::string(); - char buf[10]; - (void)fmt::format("{}", s); - fmt::format_to(buf, "{}", s); - fmt::format_to_n(buf, 10, "{}", s); - (void)fmt::formatted_size("{}", s); - fmt::print("{}", s); - fmt::print(stdout, "{}", s); -} - -struct convertible_to_int { - operator int() const { return 42; } -}; - -struct convertible_to_cstring { - operator const char*() const { return "foo"; } -}; - -FMT_BEGIN_NAMESPACE -template <> struct formatter<convertible_to_int> { - FMT_CONSTEXPR auto parse(format_parse_context& ctx) -> decltype(ctx.begin()) { - return ctx.begin(); - } - auto format(convertible_to_int, format_context& ctx) const - -> decltype(ctx.out()) { - auto out = ctx.out(); - *out++ = 'x'; - return out; - } -}; - -template <> struct formatter<convertible_to_cstring> { - FMT_CONSTEXPR auto parse(format_parse_context& ctx) -> decltype(ctx.begin()) { - return ctx.begin(); - } - auto format(convertible_to_cstring, format_context& ctx) const - -> decltype(ctx.out()) { - auto out = ctx.out(); - *out++ = 'y'; - return out; - } -}; -FMT_END_NAMESPACE - -TEST(format_test, formatter_overrides_implicit_conversion) { - EXPECT_EQ(fmt::format("{}", convertible_to_int()), "x"); - EXPECT_EQ(fmt::format("{}", convertible_to_cstring()), "y"); -} - -struct ustring { - using value_type = unsigned; - - auto find_first_of(value_type, size_t) const -> size_t; - - auto data() const -> const char*; - auto size() const -> size_t; -}; - -FMT_BEGIN_NAMESPACE -template <> struct formatter<ustring> : formatter<std::string> { - auto format(const ustring&, format_context& ctx) const - -> decltype(ctx.out()) { - return formatter<std::string>::format("ustring", ctx); - } -}; -FMT_END_NAMESPACE - -TEST(format_test, ustring) { - EXPECT_EQ(fmt::format("{}", ustring()), "ustring"); -} - -TEST(format_test, writer) { - auto write_to_stdout = []() { - auto w = fmt::writer(stdout); - w.print("{}", 42); - }; - EXPECT_WRITE(stdout, write_to_stdout(), "42"); - -#if FMT_USE_FCNTL - auto pipe = fmt::pipe(); - auto write_end = pipe.write_end.fdopen("w"); - fmt::writer(write_end.get()).print("42"); - write_end.close(); - auto read_end = pipe.read_end.fdopen("r"); - int n = 0; - int result = fscanf(read_end.get(), "%d", &n); - (void)result; - EXPECT_EQ(n, 42); -#endif - - auto s = fmt::string_buffer(); - fmt::writer(s).print("foo"); - EXPECT_EQ(s.str(), "foo"); -} - -#if FMT_USE_FCNTL && !defined(_WIN32) -TEST(format_test, invalid_glibc_buffer) { - auto pipe = fmt::pipe(); - auto write_end = pipe.write_end.fdopen("w"); - auto file = write_end.get(); - - // This results in _IO_write_ptr < _IO_write_end. - fprintf(file, "111\n"); - setvbuf(file, nullptr, _IOLBF, 0); - - fmt::print(file, "------\n"); -} -#endif // FMT_USE_FCNTL - -#if FMT_USE_BITINT -FMT_PRAGMA_CLANG(diagnostic ignored "-Wbit-int-extension") - -TEST(format_test, bitint) { - using fmt::detail::bitint; - using fmt::detail::ubitint; - - EXPECT_EQ(fmt::format("{}", ubitint<3>(7)), "7"); - EXPECT_EQ(fmt::format("{}", bitint<7>()), "0"); - - EXPECT_EQ(fmt::format("{}", ubitint<15>(31000)), "31000"); - EXPECT_EQ(fmt::format("{}", bitint<16>(INT16_MIN)), "-32768"); - EXPECT_EQ(fmt::format("{}", bitint<16>(INT16_MAX)), "32767"); - - EXPECT_EQ(fmt::format("{}", ubitint<32>(4294967295)), "4294967295"); - - EXPECT_EQ(fmt::format("{}", ubitint<47>(140737488355327ULL)), - "140737488355327"); - EXPECT_EQ(fmt::format("{}", bitint<47>(-40737488355327LL)), - "-40737488355327"); - - // Check lvalues and const - auto a = bitint<8>(0); - auto b = ubitint<32>(4294967295); - const auto c = bitint<7>(0); - const auto d = ubitint<32>(4294967295); - EXPECT_EQ(fmt::format("{}", a), "0"); - EXPECT_EQ(fmt::format("{}", b), "4294967295"); - EXPECT_EQ(fmt::format("{}", c), "0"); - EXPECT_EQ(fmt::format("{}", d), "4294967295"); - - static_assert(fmt::is_formattable<bitint<64>, char>{}, ""); - static_assert(fmt::is_formattable<ubitint<64>, char>{}, ""); -} -#endif - -#ifdef __cpp_lib_byte -TEST(base_test, format_byte) { - auto s = std::string(); - fmt::format_to(std::back_inserter(s), "{}", std::byte(42)); - EXPECT_EQ(s, "42"); -} -#endif - -// Only defined after the test case. -struct incomplete_type; -extern const incomplete_type& external_instance; - -FMT_BEGIN_NAMESPACE -template <> struct formatter<incomplete_type> : formatter<int> { - auto format(const incomplete_type& x, context& ctx) const -> appender; -}; -FMT_END_NAMESPACE - -TEST(incomplete_type_test, format) { - EXPECT_EQ(fmt::format("{}", external_instance), "42"); -} - -struct incomplete_type {}; -const incomplete_type& external_instance = {}; - -auto fmt::formatter<incomplete_type>::format(const incomplete_type&, - fmt::context& ctx) const - -> fmt::appender { - return formatter<int>::format(42, ctx); -} diff --git a/thirdparty/fmt/test/fuzzing/.gitignore b/thirdparty/fmt/test/fuzzing/.gitignore deleted file mode 100644 index ea4104026..000000000 --- a/thirdparty/fmt/test/fuzzing/.gitignore +++ /dev/null @@ -1,3 +0,0 @@ -# ignore artifacts from the build.sh script -build-*/ - diff --git a/thirdparty/fmt/test/fuzzing/README.md b/thirdparty/fmt/test/fuzzing/README.md deleted file mode 100644 index bb3d0e04f..000000000 --- a/thirdparty/fmt/test/fuzzing/README.md +++ /dev/null @@ -1,25 +0,0 @@ -# Running the fuzzers locally - -There is a [helper script](build.sh) to build the fuzzers, which has only been -tested on Debian and Ubuntu linux so far. There should be no problems fuzzing on -Windows (using clang>=8) or on Mac, but the script will probably not work out of -the box. - -Something along -```sh -mkdir build -cd build -export CXX=clang++ -export CXXFLAGS="-fsanitize=fuzzer-no-link -DFUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION= -g" -cmake .. -DFMT_SAFE_DURATION_CAST=On -DFMT_FUZZ=On -DFMT_FUZZ_LINKMAIN=Off -DFMT_FUZZ_LDFLAGS="-fsanitize=fuzzer" -cmake --build . -``` -should work to build the fuzzers for all platforms which clang supports. - -Execute a fuzzer with for instance -```sh -cd build -export UBSAN_OPTIONS=halt_on_error=1 -mkdir out_chrono -bin/fuzzer_chrono_duration out_chrono -``` diff --git a/thirdparty/fmt/test/fuzzing/build.sh b/thirdparty/fmt/test/fuzzing/build.sh deleted file mode 100755 index 4497b62c1..000000000 --- a/thirdparty/fmt/test/fuzzing/build.sh +++ /dev/null @@ -1,90 +0,0 @@ -#!/bin/sh -# -# Creates fuzzer builds of various kinds -# - oss-fuzz emulated mode (makes sure a simulated invocation by oss-fuzz works) -# - libFuzzer build (you will need clang) -# - afl build (you will need afl) -# -# -# Copyright (c) 2019 Paul Dreik -# -# For the license information refer to format.h. - -set -e -me=$(basename $0) -root=$(readlink -f "$(dirname "$0")/../..") - - -echo $me: root=$root - -here=$(pwd) - -CXXFLAGSALL="-DFUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION= -g" -CMAKEFLAGSALL="$root -GNinja -DCMAKE_BUILD_TYPE=Debug -DFMT_DOC=Off -DFMT_TEST=Off -DFMT_FUZZ=On -DCMAKE_CXX_STANDARD=17" - -CLANG=clang++-11 - -# For performance analysis of the fuzzers. -builddir=$here/build-fuzzers-perfanalysis -mkdir -p $builddir -cd $builddir -CXX="ccache g++" CXXFLAGS="$CXXFLAGSALL -g" cmake \ -$CMAKEFLAGSALL \ --DFMT_FUZZ_LINKMAIN=On \ --DCMAKE_BUILD_TYPE=Release - -cmake --build $builddir - -# Builds the fuzzers as oss-fuzz does. -builddir=$here/build-fuzzers-ossfuzz -mkdir -p $builddir -cd $builddir -CXX=$CLANG \ -CXXFLAGS="$CXXFLAGSALL -fsanitize=fuzzer-no-link" cmake \ -cmake $CMAKEFLAGSALL \ --DFMT_FUZZ_LINKMAIN=Off \ --DFMT_FUZZ_LDFLAGS="-fsanitize=fuzzer" - -cmake --build $builddir - - -# Builds fuzzers for local fuzzing with libfuzzer with asan+usan. -builddir=$here/build-fuzzers-libfuzzer -mkdir -p $builddir -cd $builddir -CXX=$CLANG \ -CXXFLAGS="$CXXFLAGSALL -fsanitize=fuzzer-no-link,address,undefined" cmake \ -cmake $CMAKEFLAGSALL \ --DFMT_FUZZ_LINKMAIN=Off \ --DFMT_FUZZ_LDFLAGS="-fsanitize=fuzzer" - -cmake --build $builddir - -# Builds a fast fuzzer for making coverage fast. -builddir=$here/build-fuzzers-fast -mkdir -p $builddir -cd $builddir -CXX=$CLANG \ -CXXFLAGS="$CXXFLAGSALL -fsanitize=fuzzer-no-link -O3" cmake \ -cmake $CMAKEFLAGSALL \ --DFMT_FUZZ_LINKMAIN=Off \ --DFMT_FUZZ_LDFLAGS="-fsanitize=fuzzer" \ - -DCMAKE_BUILD_TYPE=Release - -cmake --build $builddir - - -# Builds fuzzers for local fuzzing with afl. -builddir=$here/build-fuzzers-afl -mkdir -p $builddir -cd $builddir -CXX="afl-g++" \ -CXXFLAGS="$CXXFLAGSALL -fsanitize=address,undefined" \ -cmake $CMAKEFLAGSALL \ --DFMT_FUZZ_LINKMAIN=On - -cmake --build $builddir - - -echo $me: all good - diff --git a/thirdparty/fmt/test/fuzzing/chrono-duration.cc b/thirdparty/fmt/test/fuzzing/chrono-duration.cc deleted file mode 100644 index d66068d9c..000000000 --- a/thirdparty/fmt/test/fuzzing/chrono-duration.cc +++ /dev/null @@ -1,136 +0,0 @@ -// Copyright (c) 2019, Paul Dreik -// For the license information refer to format.h. - -#include <fmt/chrono.h> - -#include <cstdint> - -#include "fuzzer-common.h" - -template <typename Period, typename Rep> -void invoke_inner(fmt::string_view format_str, Rep rep) { - auto value = std::chrono::duration<Rep, Period>(rep); - try { -#if FMT_FUZZ_FORMAT_TO_STRING - std::string message = fmt::format(format_str, value); -#else - auto buf = fmt::memory_buffer(); - fmt::format_to(std::back_inserter(buf), format_str, value); -#endif - } catch (std::exception&) { - } -} - -// Rep is a duration's representation type. -template <typename Rep> -void invoke_outer(const uint8_t* data, size_t size, int period) { - // Always use a fixed location of the data. - static_assert(sizeof(Rep) <= fixed_size, "fixed size is too small"); - if (size <= fixed_size + 1) return; - - const Rep rep = assign_from_buf<Rep>(data); - data += fixed_size; - size -= fixed_size; - - // data is already allocated separately in libFuzzer so reading past the end - // will most likely be detected anyway. - const auto format_str = fmt::string_view(as_chars(data), size); - - // yocto, zepto, zetta and yotta are not handled. - switch (period) { - case 1: - invoke_inner<std::atto>(format_str, rep); - break; - case 2: - invoke_inner<std::femto>(format_str, rep); - break; - case 3: - invoke_inner<std::pico>(format_str, rep); - break; - case 4: - invoke_inner<std::nano>(format_str, rep); - break; - case 5: - invoke_inner<std::micro>(format_str, rep); - break; - case 6: - invoke_inner<std::milli>(format_str, rep); - break; - case 7: - invoke_inner<std::centi>(format_str, rep); - break; - case 8: - invoke_inner<std::deci>(format_str, rep); - break; - case 9: - invoke_inner<std::deca>(format_str, rep); - break; - case 10: - invoke_inner<std::kilo>(format_str, rep); - break; - case 11: - invoke_inner<std::mega>(format_str, rep); - break; - case 12: - invoke_inner<std::giga>(format_str, rep); - break; - case 13: - invoke_inner<std::tera>(format_str, rep); - break; - case 14: - invoke_inner<std::peta>(format_str, rep); - break; - case 15: - invoke_inner<std::exa>(format_str, rep); - break; - } -} - -extern "C" int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size) { - if (size <= 4) return 0; - - const auto representation = data[0]; - const auto period = data[1]; - data += 2; - size -= 2; - - switch (representation) { - case 1: - invoke_outer<char>(data, size, period); - break; - case 2: - invoke_outer<signed char>(data, size, period); - break; - case 3: - invoke_outer<unsigned char>(data, size, period); - break; - case 4: - invoke_outer<short>(data, size, period); - break; - case 5: - invoke_outer<unsigned short>(data, size, period); - break; - case 6: - invoke_outer<int>(data, size, period); - break; - case 7: - invoke_outer<unsigned int>(data, size, period); - break; - case 8: - invoke_outer<long>(data, size, period); - break; - case 9: - invoke_outer<unsigned long>(data, size, period); - break; - case 10: - invoke_outer<float>(data, size, period); - break; - case 11: - invoke_outer<double>(data, size, period); - break; - case 12: - invoke_outer<long double>(data, size, period); - break; - } - return 0; -} diff --git a/thirdparty/fmt/test/fuzzing/chrono-timepoint.cc b/thirdparty/fmt/test/fuzzing/chrono-timepoint.cc deleted file mode 100644 index 8a1b24d29..000000000 --- a/thirdparty/fmt/test/fuzzing/chrono-timepoint.cc +++ /dev/null @@ -1,32 +0,0 @@ -// Copyright (c) 2021, Paul Dreik -// For license information refer to format.h. -#include <fmt/chrono.h> - -#include "fuzzer-common.h" - -/* - * a fuzzer for the chrono timepoints formatters - * C is a clock (std::chrono::system_clock etc) - */ -template <typename C> void doit(const uint8_t* data, size_t size) { - using Rep = typename C::time_point::rep; - constexpr auto N = sizeof(Rep); - if (size < N) return; - - const auto x = assign_from_buf<Rep>(data); - typename C::duration dur{x}; - typename C::time_point timepoint{dur}; - data += N; - size -= N; - data_to_string format_str(data, size); - - std::string message = fmt::format(format_str.get(), timepoint); -} - -extern "C" int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size) { - try { - doit<std::chrono::system_clock>(data, size); - } catch (...) { - } - return 0; -} diff --git a/thirdparty/fmt/test/fuzzing/float.cc b/thirdparty/fmt/test/fuzzing/float.cc deleted file mode 100644 index d4c9e4f57..000000000 --- a/thirdparty/fmt/test/fuzzing/float.cc +++ /dev/null @@ -1,39 +0,0 @@ -// A fuzzer for floating-point formatter. -// For the license information refer to format.h. - -#include <fmt/format.h> - -#include <cstdint> -#include <cstdlib> -#include <limits> -#include <stdexcept> - -#include "fuzzer-common.h" - -void check_round_trip(fmt::string_view format_str, double value) { - auto buffer = fmt::memory_buffer(); - fmt::format_to(std::back_inserter(buffer), format_str, value); - - if (std::isnan(value)) { - auto nan = std::signbit(value) ? "-nan" : "nan"; - if (fmt::string_view(buffer.data(), buffer.size()) != nan) - throw std::runtime_error("round trip failure"); - return; - } - - buffer.push_back('\0'); - char* ptr = nullptr; - if (std::strtod(buffer.data(), &ptr) != value) - throw std::runtime_error("round trip failure"); - if (ptr + 1 != buffer.end()) throw std::runtime_error("unparsed output"); -} - -extern "C" int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size) { - if (size <= sizeof(double) || !std::numeric_limits<double>::is_iec559) - return 0; - check_round_trip("{}", assign_from_buf<double>(data)); - // A larger than necessary precision is used to trigger the fallback - // formatter. - check_round_trip("{:.50g}", assign_from_buf<double>(data)); - return 0; -} diff --git a/thirdparty/fmt/test/fuzzing/fuzzer-common.h b/thirdparty/fmt/test/fuzzing/fuzzer-common.h deleted file mode 100644 index eaae5a6e4..000000000 --- a/thirdparty/fmt/test/fuzzing/fuzzer-common.h +++ /dev/null @@ -1,77 +0,0 @@ -// Copyright (c) 2019, Paul Dreik -// For the license information refer to format.h. - -#ifndef FUZZER_COMMON_H -#define FUZZER_COMMON_H - -#include <fmt/base.h> - -#include <cstdint> // std::uint8_t -#include <cstring> // memcpy -#include <vector> - -// One can format to either a string, or a buffer. The latter is faster, but -// one may be interested in formatting to a string instead to verify it works -// as intended. To avoid a combinatoric explosion, select this at compile time -// instead of dynamically from the fuzz data. -#define FMT_FUZZ_FORMAT_TO_STRING 0 - -// If {fmt} is given a buffer that is separately allocated, chances that address -// sanitizer detects out of bound reads is much higher. However, it slows down -// the fuzzing. -#define FMT_FUZZ_SEPARATE_ALLOCATION 1 - -// The size of the largest possible type in use. -// To let the the fuzzer mutation be efficient at cross pollinating between -// different types, use a fixed size format. The same bit pattern, interpreted -// as another type, is likely interesting. -constexpr auto fixed_size = 16; - -// Casts data to a char pointer. -template <typename T> inline const char* as_chars(const T* data) { - return reinterpret_cast<const char*>(data); -} - -// Casts data to a byte pointer. -template <typename T> inline const std::uint8_t* as_bytes(const T* data) { - return reinterpret_cast<const std::uint8_t*>(data); -} - -// Blits bytes from data to form an (assumed trivially constructible) object -// of type Item. -template <class Item> inline Item assign_from_buf(const std::uint8_t* data) { - auto item = Item(); - std::memcpy(&item, data, sizeof(Item)); - return item; -} - -// Reads a boolean value by looking at the first byte from data. -template <> inline bool assign_from_buf<bool>(const std::uint8_t* data) { - return *data != 0; -} - -struct data_to_string { -#if FMT_FUZZ_SEPARATE_ALLOCATION - std::vector<char> buffer; - - data_to_string(const uint8_t* data, size_t size, bool add_terminator = false) - : buffer(size + (add_terminator ? 1 : 0)) { - if (size) { - std::memcpy(buffer.data(), data, size); - } - } - - fmt::string_view get() const { return {buffer.data(), buffer.size()}; } -#else - fmt::string_view sv; - - data_to_string(const uint8_t* data, size_t size, bool = false) - : str(as_chars(data), size) {} - - fmt::string_view get() const { return sv; } -#endif - - const char* data() const { return get().data(); } -}; - -#endif // FUZZER_COMMON_H diff --git a/thirdparty/fmt/test/fuzzing/main.cc b/thirdparty/fmt/test/fuzzing/main.cc deleted file mode 100644 index 8f8c719b7..000000000 --- a/thirdparty/fmt/test/fuzzing/main.cc +++ /dev/null @@ -1,22 +0,0 @@ -#include <cassert> -#include <fstream> -#include <vector> - -#include "fuzzer-common.h" - -extern "C" int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size); - -int main(int argc, char** argv) { - for (int i = 1; i < argc; ++i) { - std::ifstream in(argv[i]); - assert(in); - in.seekg(0, std::ios_base::end); - const auto size = in.tellg(); - assert(size >= 0); - in.seekg(0, std::ios_base::beg); - std::vector<char> buf(static_cast<size_t>(size)); - in.read(buf.data(), size); - assert(in.gcount() == size); - LLVMFuzzerTestOneInput(as_bytes(buf.data()), buf.size()); - } -} diff --git a/thirdparty/fmt/test/fuzzing/named-arg.cc b/thirdparty/fmt/test/fuzzing/named-arg.cc deleted file mode 100644 index 3bee1ae3b..000000000 --- a/thirdparty/fmt/test/fuzzing/named-arg.cc +++ /dev/null @@ -1,102 +0,0 @@ -// Copyright (c) 2019, Paul Dreik -// For the license information refer to format.h. - -#include <fmt/chrono.h> - -#include <cstdint> -#include <type_traits> -#include <vector> - -#include "fuzzer-common.h" - -template <typename T> -void invoke_fmt(const uint8_t* data, size_t size, unsigned arg_name_size) { - static_assert(sizeof(T) <= fixed_size, "fixed_size too small"); - if (size <= fixed_size) return; - const T value = assign_from_buf<T>(data); - data += fixed_size; - size -= fixed_size; - - if (arg_name_size <= 0 || arg_name_size >= size) return; - data_to_string arg_name(data, arg_name_size, true); - data += arg_name_size; - size -= arg_name_size; - - data_to_string format_str(data, size); - try { -#if FMT_FUZZ_FORMAT_TO_STRING - std::string message = - fmt::format(format_str.get(), fmt::arg(arg_name.data(), value)); -#else - fmt::memory_buffer out; - fmt::format_to(std::back_inserter(out), format_str.get(), - fmt::arg(arg_name.data(), value)); -#endif - } catch (std::exception&) { - } -} - -// For dynamic dispatching to an explicit instantiation. -template <typename Callback> void invoke(int type, Callback callback) { - switch (type) { - case 0: - callback(bool()); - break; - case 1: - callback(char()); - break; - case 2: - using sc = signed char; - callback(sc()); - break; - case 3: - using uc = unsigned char; - callback(uc()); - break; - case 4: - callback(short()); - break; - case 5: - using us = unsigned short; - callback(us()); - break; - case 6: - callback(int()); - break; - case 7: - callback(unsigned()); - break; - case 8: - callback(long()); - break; - case 9: - using ul = unsigned long; - callback(ul()); - break; - case 10: - callback(float()); - break; - case 11: - callback(double()); - break; - case 12: - using LD = long double; - callback(LD()); - break; - } -} - -extern "C" int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size) { - if (size <= 3) return 0; - - // Switch types depending on the first byte of the input. - const auto type = data[0] & 0x0F; - const unsigned arg_name_size = (data[0] & 0xF0) >> 4; - data++; - size--; - - invoke(type, [=](auto arg) { - invoke_fmt<decltype(arg)>(data, size, arg_name_size); - }); - return 0; -} diff --git a/thirdparty/fmt/test/fuzzing/one-arg.cc b/thirdparty/fmt/test/fuzzing/one-arg.cc deleted file mode 100644 index af9787f81..000000000 --- a/thirdparty/fmt/test/fuzzing/one-arg.cc +++ /dev/null @@ -1,92 +0,0 @@ -// Copyright (c) 2019, Paul Dreik -// For the license information refer to format.h. - -#include <fmt/chrono.h> - -#include <cstdint> -#include <exception> - -#include "fuzzer-common.h" - -template <typename T, typename Repr> const T* from_repr(const Repr& r) { - return &r; -} - -template <> const std::tm* from_repr<std::tm>(const std::time_t& t) { - return std::localtime(&t); -} - -template <typename T, typename Repr = T> -void invoke_fmt(const uint8_t* data, size_t size) { - static_assert(sizeof(Repr) <= fixed_size, "Nfixed is too small"); - if (size <= fixed_size) return; - auto repr = assign_from_buf<Repr>(data); - const T* value = from_repr<T>(repr); - if (!value) return; - data += fixed_size; - size -= fixed_size; - data_to_string format_str(data, size); - try { -#if FMT_FUZZ_FORMAT_TO_STRING - std::string message = fmt::format(format_str.get(), *value); -#else - auto buf = fmt::memory_buffer(); - fmt::format_to(std::back_inserter(buf), format_str.get(), *value); -#endif - } catch (std::exception&) { - } -} - -extern "C" int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size) { - if (size <= 3) return 0; - - const auto first = data[0]; - data++; - size--; - - switch (first) { - case 0: - invoke_fmt<bool>(data, size); - break; - case 1: - invoke_fmt<char>(data, size); - break; - case 2: - invoke_fmt<unsigned char>(data, size); - break; - case 3: - invoke_fmt<signed char>(data, size); - break; - case 4: - invoke_fmt<short>(data, size); - break; - case 5: - invoke_fmt<unsigned short>(data, size); - break; - case 6: - invoke_fmt<int>(data, size); - break; - case 7: - invoke_fmt<unsigned int>(data, size); - break; - case 8: - invoke_fmt<long>(data, size); - break; - case 9: - invoke_fmt<unsigned long>(data, size); - break; - case 10: - invoke_fmt<float>(data, size); - break; - case 11: - invoke_fmt<double>(data, size); - break; - case 12: - invoke_fmt<long double>(data, size); - break; - case 13: - invoke_fmt<std::tm, std::time_t>(data, size); - break; - } - return 0; -} diff --git a/thirdparty/fmt/test/fuzzing/two-args.cc b/thirdparty/fmt/test/fuzzing/two-args.cc deleted file mode 100644 index 931c64656..000000000 --- a/thirdparty/fmt/test/fuzzing/two-args.cc +++ /dev/null @@ -1,106 +0,0 @@ -// Copyright (c) 2019, Paul Dreik -// For the license information refer to format.h. - -#include <fmt/format.h> - -#include <cstdint> -#include <exception> -#include <string> - -#include "fuzzer-common.h" - -template <typename Item1, typename Item2> -void invoke_fmt(const uint8_t* data, size_t size) { - static_assert(sizeof(Item1) <= fixed_size, "size1 exceeded"); - static_assert(sizeof(Item2) <= fixed_size, "size2 exceeded"); - if (size <= fixed_size + fixed_size) return; - - const Item1 item1 = assign_from_buf<Item1>(data); - data += fixed_size; - size -= fixed_size; - - const Item2 item2 = assign_from_buf<Item2>(data); - data += fixed_size; - size -= fixed_size; - - auto format_str = fmt::string_view(as_chars(data), size); -#if FMT_FUZZ_FORMAT_TO_STRING - std::string message = fmt::format(format_str, item1, item2); -#else - auto buf = fmt::memory_buffer(); - fmt::format_to(std::back_inserter(buf), format_str, item1, item2); -#endif -} - -// For dynamic dispatching to an explicit instantiation. -template <typename Callback> void invoke(int index, Callback callback) { - switch (index) { - case 0: - callback(bool()); - break; - case 1: - callback(char()); - break; - case 2: - using sc = signed char; - callback(sc()); - break; - case 3: - using uc = unsigned char; - callback(uc()); - break; - case 4: - callback(short()); - break; - case 5: - using us = unsigned short; - callback(us()); - break; - case 6: - callback(int()); - break; - case 7: - callback(unsigned()); - break; - case 8: - callback(long()); - break; - case 9: - using ul = unsigned long; - callback(ul()); - break; - case 10: - callback(float()); - break; - case 11: - callback(double()); - break; - case 12: - using LD = long double; - callback(LD()); - break; - case 13: - using ptr = void*; - callback(ptr()); - break; - } -} - -extern "C" int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size) { - if (size <= 3) return 0; - - // Switch types depending on the first byte of the input. - const auto type1 = data[0] & 0x0F; - const auto type2 = (data[0] & 0xF0) >> 4; - data++; - size--; - try { - invoke(type1, [=](auto param1) { - invoke(type2, [=](auto param2) { - invoke_fmt<decltype(param1), decltype(param2)>(data, size); - }); - }); - } catch (std::exception&) { - } - return 0; -} diff --git a/thirdparty/fmt/test/gtest-extra-test.cc b/thirdparty/fmt/test/gtest-extra-test.cc deleted file mode 100644 index 5c8604001..000000000 --- a/thirdparty/fmt/test/gtest-extra-test.cc +++ /dev/null @@ -1,410 +0,0 @@ -// Formatting library for C++ - tests of custom Google Test assertions -// -// Copyright (c) 2012 - present, Victor Zverovich -// All rights reserved. -// -// For the license information refer to format.h. - -#include "gtest-extra.h" - -#include <gtest/gtest-spi.h> - -#include <cstring> -#include <memory> -#include <stdexcept> - -#include "fmt/os.h" -#include "util.h" - -// Tests that assertion macros evaluate their arguments exactly once. -namespace { -class single_evaluation_test : public ::testing::Test { - protected: - single_evaluation_test() { - p_ = s_; - a_ = 0; - b_ = 0; - } - - static const char* const s_; - static const char* p_; - - static int a_; - static int b_; -}; -} // namespace - -const char* const single_evaluation_test::s_ = "01234"; -const char* single_evaluation_test::p_; -int single_evaluation_test::a_; -int single_evaluation_test::b_; - -void do_nothing() {} - -FMT_NORETURN void throw_exception() { throw std::runtime_error("test"); } - -FMT_NORETURN void throw_system_error() { - throw fmt::system_error(EDOM, "test"); -} - -// Tests that when EXPECT_THROW_MSG fails, it evaluates its message argument -// exactly once. -TEST_F(single_evaluation_test, failed_expect_throw_msg) { - EXPECT_NONFATAL_FAILURE( - EXPECT_THROW_MSG(throw_exception(), std::exception, p_++), "01234"); - EXPECT_EQ(s_ + 1, p_); -} - -// Tests that when EXPECT_SYSTEM_ERROR fails, it evaluates its message argument -// exactly once. -TEST_F(single_evaluation_test, failed_expect_system_error) { - EXPECT_NONFATAL_FAILURE(EXPECT_SYSTEM_ERROR(throw_system_error(), EDOM, p_++), - "01234"); - EXPECT_EQ(s_ + 1, p_); -} - -// Tests that assertion arguments are evaluated exactly once. -TEST_F(single_evaluation_test, exception_tests) { - // successful EXPECT_THROW_MSG - EXPECT_THROW_MSG( - { // NOLINT - a_++; - throw_exception(); - }, - std::exception, (b_++, "test")); - EXPECT_EQ(1, a_); - EXPECT_EQ(1, b_); - - // failed EXPECT_THROW_MSG, throws different type - EXPECT_NONFATAL_FAILURE(EXPECT_THROW_MSG( - { // NOLINT - a_++; - throw_exception(); - }, - std::logic_error, (b_++, "test")), - "throws a different type"); - EXPECT_EQ(2, a_); - EXPECT_EQ(2, b_); - - // failed EXPECT_THROW_MSG, throws an exception with different message - EXPECT_NONFATAL_FAILURE(EXPECT_THROW_MSG( - { // NOLINT - a_++; - throw_exception(); - }, - std::exception, (b_++, "other")), - "throws an exception with a different message"); - EXPECT_EQ(3, a_); - EXPECT_EQ(3, b_); - - // failed EXPECT_THROW_MSG, throws nothing - EXPECT_NONFATAL_FAILURE( - EXPECT_THROW_MSG(a_++, std::exception, (b_++, "test")), "throws nothing"); - EXPECT_EQ(4, a_); - EXPECT_EQ(4, b_); -} - -TEST_F(single_evaluation_test, system_error_tests) { - // successful EXPECT_SYSTEM_ERROR - EXPECT_SYSTEM_ERROR( - { // NOLINT - a_++; - throw_system_error(); - }, - EDOM, (b_++, "test")); - EXPECT_EQ(1, a_); - EXPECT_EQ(1, b_); - - // failed EXPECT_SYSTEM_ERROR, throws different type - EXPECT_NONFATAL_FAILURE(EXPECT_SYSTEM_ERROR( - { // NOLINT - a_++; - throw_exception(); - }, - EDOM, (b_++, "test")), - "throws a different type"); - EXPECT_EQ(2, a_); - EXPECT_EQ(2, b_); - - // failed EXPECT_SYSTEM_ERROR, throws an exception with different message - EXPECT_NONFATAL_FAILURE(EXPECT_SYSTEM_ERROR( - { // NOLINT - a_++; - throw_system_error(); - }, - EDOM, (b_++, "other")), - "throws an exception with a different message"); - EXPECT_EQ(3, a_); - EXPECT_EQ(3, b_); - - // failed EXPECT_SYSTEM_ERROR, throws nothing - EXPECT_NONFATAL_FAILURE(EXPECT_SYSTEM_ERROR(a_++, EDOM, (b_++, "test")), - "throws nothing"); - EXPECT_EQ(4, a_); - EXPECT_EQ(4, b_); -} - -#if FMT_USE_FCNTL -// Tests that when EXPECT_WRITE fails, it evaluates its message argument -// exactly once. -TEST_F(single_evaluation_test, failed_expect_write) { - EXPECT_NONFATAL_FAILURE(EXPECT_WRITE(stdout, std::printf("test"), p_++), - "01234"); - EXPECT_EQ(s_ + 1, p_); -} - -// Tests that assertion arguments are evaluated exactly once. -TEST_F(single_evaluation_test, write_tests) { - // successful EXPECT_WRITE - EXPECT_WRITE( - stdout, - { // NOLINT - a_++; - std::printf("test"); - }, - (b_++, "test")); - EXPECT_EQ(1, a_); - EXPECT_EQ(1, b_); - - // failed EXPECT_WRITE - EXPECT_NONFATAL_FAILURE(EXPECT_WRITE( - stdout, - { // NOLINT - a_++; - std::printf("test"); - }, - (b_++, "other")), - "Actual: test"); - EXPECT_EQ(2, a_); - EXPECT_EQ(2, b_); -} - -// Tests EXPECT_WRITE. -TEST(gtest_extra_test, expect_write) { - EXPECT_WRITE(stdout, do_nothing(), ""); - EXPECT_WRITE(stdout, std::printf("test"), "test"); - EXPECT_WRITE(stderr, std::fprintf(stderr, "test"), "test"); - EXPECT_NONFATAL_FAILURE(EXPECT_WRITE(stdout, std::printf("that"), "this"), - "Expected: this\n" - " Actual: that"); -} - -TEST(gtest_extra_test, expect_write_streaming) { - EXPECT_WRITE(stdout, std::printf("test"), "test") << "unexpected failure"; - EXPECT_NONFATAL_FAILURE(EXPECT_WRITE(stdout, std::printf("test"), "other") - << "expected failure", - "expected failure"); -} -#endif // FMT_USE_FCNTL - -// Tests that the compiler will not complain about unreachable code in the -// EXPECT_THROW_MSG macro. -TEST(gtest_extra_test, expect_throw_no_unreachable_code_warning) { - int n = 0; - (void)n; - using std::runtime_error; - EXPECT_THROW_MSG(throw runtime_error(""), runtime_error, ""); - EXPECT_NONFATAL_FAILURE(EXPECT_THROW_MSG(n++, runtime_error, ""), ""); - EXPECT_NONFATAL_FAILURE(EXPECT_THROW_MSG(throw 1, runtime_error, ""), ""); - EXPECT_NONFATAL_FAILURE( - EXPECT_THROW_MSG(throw runtime_error("a"), runtime_error, "b"), ""); -} - -// Tests that the compiler will not complain about unreachable code in the -// EXPECT_SYSTEM_ERROR macro. -TEST(gtest_extra_test, expect_system_error_no_unreachable_code_warning) { - int n = 0; - (void)n; - EXPECT_SYSTEM_ERROR(throw fmt::system_error(EDOM, "test"), EDOM, "test"); - EXPECT_NONFATAL_FAILURE(EXPECT_SYSTEM_ERROR(n++, EDOM, ""), ""); - EXPECT_NONFATAL_FAILURE(EXPECT_SYSTEM_ERROR(throw 1, EDOM, ""), ""); - EXPECT_NONFATAL_FAILURE( - EXPECT_SYSTEM_ERROR(throw fmt::system_error(EDOM, "aaa"), EDOM, "bbb"), - ""); -} - -TEST(gtest_extra_test, expect_throw_behaves_like_single_statement) { - if (::testing::internal::AlwaysFalse()) - EXPECT_THROW_MSG(do_nothing(), std::exception, ""); - - if (::testing::internal::AlwaysTrue()) - EXPECT_THROW_MSG(throw_exception(), std::exception, "test"); - else - do_nothing(); -} - -TEST(gtest_extra_test, expect_system_error_behaves_like_single_statement) { - if (::testing::internal::AlwaysFalse()) - EXPECT_SYSTEM_ERROR(do_nothing(), EDOM, ""); - - if (::testing::internal::AlwaysTrue()) - EXPECT_SYSTEM_ERROR(throw_system_error(), EDOM, "test"); - else - do_nothing(); -} - -TEST(gtest_extra_test, expect_write_behaves_like_single_statement) { - if (::testing::internal::AlwaysFalse()) - EXPECT_WRITE(stdout, std::printf("x"), "x"); - - if (::testing::internal::AlwaysTrue()) - EXPECT_WRITE(stdout, std::printf("x"), "x"); - else - do_nothing(); -} - -// Tests EXPECT_THROW_MSG. -TEST(gtest_extra_test, expect_throw_msg) { - EXPECT_THROW_MSG(throw_exception(), std::exception, "test"); - EXPECT_NONFATAL_FAILURE( - EXPECT_THROW_MSG(throw_exception(), std::logic_error, "test"), - "Expected: throw_exception() throws an exception of " - "type std::logic_error.\n Actual: it throws a different type."); - EXPECT_NONFATAL_FAILURE( - EXPECT_THROW_MSG(do_nothing(), std::exception, "test"), - "Expected: do_nothing() throws an exception of type std::exception.\n" - " Actual: it throws nothing."); - EXPECT_NONFATAL_FAILURE( - EXPECT_THROW_MSG(throw_exception(), std::exception, "other"), - "throw_exception() throws an exception with a different message.\n" - "Expected: other\n" - " Actual: test"); -} - -// Tests EXPECT_SYSTEM_ERROR. -TEST(gtest_extra_test, expect_system_error) { - EXPECT_SYSTEM_ERROR(throw_system_error(), EDOM, "test"); - EXPECT_NONFATAL_FAILURE( - EXPECT_SYSTEM_ERROR(throw_exception(), EDOM, "test"), - "Expected: throw_exception() throws an exception of " - "type std::system_error.\n Actual: it throws a different type."); - EXPECT_NONFATAL_FAILURE( - EXPECT_SYSTEM_ERROR(do_nothing(), EDOM, "test"), - "Expected: do_nothing() throws an exception of type std::system_error.\n" - " Actual: it throws nothing."); - EXPECT_NONFATAL_FAILURE( - EXPECT_SYSTEM_ERROR(throw_system_error(), EDOM, "other"), - fmt::format( - "throw_system_error() throws an exception with a different message.\n" - "Expected: {}\n" - " Actual: {}", - system_error_message(EDOM, "other"), - system_error_message(EDOM, "test"))); -} - -TEST(gtest_extra_test, expect_throw_msg_streaming) { - EXPECT_THROW_MSG(throw_exception(), std::exception, "test") - << "unexpected failure"; - EXPECT_NONFATAL_FAILURE( - EXPECT_THROW_MSG(throw_exception(), std::exception, "other") - << "expected failure", - "expected failure"); -} - -TEST(gtest_extra_test, expect_system_error_streaming) { - EXPECT_SYSTEM_ERROR(throw_system_error(), EDOM, "test") - << "unexpected failure"; - EXPECT_NONFATAL_FAILURE( - EXPECT_SYSTEM_ERROR(throw_system_error(), EDOM, "other") - << "expected failure", - "expected failure"); -} - -#if FMT_USE_FCNTL - -using fmt::buffered_file; -using fmt::file; - -TEST(output_redirect_test, scoped_redirect) { - auto pipe = fmt::pipe(); - { - buffered_file file(pipe.write_end.fdopen("w")); - std::fprintf(file.get(), "[[["); - { - output_redirect redir(file.get()); - std::fprintf(file.get(), "censored"); - } - std::fprintf(file.get(), "]]]"); - } - EXPECT_READ(pipe.read_end, "[[[]]]"); -} - -// Test that output_redirect handles errors in flush correctly. -TEST(output_redirect_test, flush_error_in_ctor) { - auto pipe = fmt::pipe(); - int write_fd = pipe.write_end.descriptor(); - file write_copy = pipe.write_end.dup(write_fd); - buffered_file f = pipe.write_end.fdopen("w"); - // Put a character in a file buffer. - EXPECT_EQ('x', fputc('x', f.get())); - FMT_POSIX(close(write_fd)); - std::unique_ptr<output_redirect> redir{nullptr}; - EXPECT_SYSTEM_ERROR_NOASSERT(redir.reset(new output_redirect(f.get())), EBADF, - "cannot flush stream"); - redir.reset(nullptr); - write_copy.dup2(write_fd); // "undo" close or dtor will fail -} - -TEST(output_redirect_test, dup_error_in_ctor) { - buffered_file f = open_buffered_file(); - int fd = (f.descriptor)(); - file copy = file::dup(fd); - FMT_POSIX(close(fd)); - std::unique_ptr<output_redirect> redir{nullptr}; - EXPECT_SYSTEM_ERROR_NOASSERT( - redir.reset(new output_redirect(f.get(), false)), EBADF, - fmt::format("cannot duplicate file descriptor {}", fd)); - copy.dup2(fd); // "undo" close or dtor will fail -} - -TEST(output_redirect_test, restore_and_read) { - auto pipe = fmt::pipe(); - buffered_file file(pipe.write_end.fdopen("w")); - std::fprintf(file.get(), "[[["); - output_redirect redir(file.get()); - std::fprintf(file.get(), "censored"); - EXPECT_EQ("censored", redir.restore_and_read()); - EXPECT_EQ("", redir.restore_and_read()); - std::fprintf(file.get(), "]]]"); - file = buffered_file(); - EXPECT_READ(pipe.read_end, "[[[]]]"); -} - -// Test that OutputRedirect handles errors in flush correctly. -TEST(output_redirect_test, flush_error_in_restore_and_read) { - auto pipe = fmt::pipe(); - int write_fd = pipe.write_end.descriptor(); - file write_copy = pipe.write_end.dup(write_fd); - buffered_file f = pipe.write_end.fdopen("w"); - output_redirect redir(f.get()); - // Put a character in a file buffer. - EXPECT_EQ('x', fputc('x', f.get())); - FMT_POSIX(close(write_fd)); - EXPECT_SYSTEM_ERROR_NOASSERT(redir.restore_and_read(), EBADF, - "cannot flush stream"); - write_copy.dup2(write_fd); // "undo" close or dtor will fail -} - -TEST(output_redirect_test, error_in_dtor) { - auto pipe = fmt::pipe(); - int write_fd = pipe.write_end.descriptor(); - file write_copy = pipe.write_end.dup(write_fd); - buffered_file f = pipe.write_end.fdopen("w"); - std::unique_ptr<output_redirect> redir(new output_redirect(f.get())); - // Put a character in a file buffer. - EXPECT_EQ('x', fputc('x', f.get())); - EXPECT_WRITE( - stderr, - { - // The close function must be called inside EXPECT_WRITE, - // otherwise the system may recycle closed file descriptor when - // redirecting the output in EXPECT_STDERR and the second close - // will break output redirection. - FMT_POSIX(close(write_fd)); - SUPPRESS_ASSERT(redir.reset(nullptr)); - }, - system_error_message(EBADF, "cannot flush stream")); - write_copy.dup2(write_fd); // "undo" close or dtor of buffered_file will fail -} - -#endif // FMT_USE_FCNTL diff --git a/thirdparty/fmt/test/gtest-extra.cc b/thirdparty/fmt/test/gtest-extra.cc deleted file mode 100644 index 0f9fff5ee..000000000 --- a/thirdparty/fmt/test/gtest-extra.cc +++ /dev/null @@ -1,80 +0,0 @@ -// Formatting library for C++ - custom Google Test assertions -// -// Copyright (c) 2012 - present, Victor Zverovich -// All rights reserved. -// -// For the license information refer to format.h. - -#include "gtest-extra.h" - -#if FMT_USE_FCNTL - -using fmt::file; - -output_redirect::output_redirect(FILE* f, bool flush) : file_(f) { - if (flush) this->flush(); - int fd = FMT_POSIX(fileno(f)); - // Create a file object referring to the original file. - original_ = file::dup(fd); - // Create a pipe. - auto pipe = fmt::pipe(); - read_end_ = std::move(pipe.read_end); - // Connect the passed FILE object to the write end of the pipe. - pipe.write_end.dup2(fd); -} - -output_redirect::~output_redirect() noexcept { - try { - restore(); - } catch (const std::exception& e) { - std::fputs(e.what(), stderr); - } -} - -void output_redirect::flush() { - int result = 0; - do { - result = fflush(file_); - } while (result == EOF && errno == EINTR); - if (result != 0) throw fmt::system_error(errno, "cannot flush stream"); -} - -void output_redirect::restore() { - if (original_.descriptor() == -1) return; // Already restored. - flush(); - // Restore the original file. - original_.dup2(FMT_POSIX(fileno(file_))); - original_.close(); -} - -std::string output_redirect::restore_and_read() { - // Restore output. - restore(); - - // Read everything from the pipe. - std::string content; - if (read_end_.descriptor() == -1) return content; // Already read. - enum { BUFFER_SIZE = 4096 }; - char buffer[BUFFER_SIZE]; - size_t count = 0; - do { - count = read_end_.read(buffer, BUFFER_SIZE); - content.append(buffer, count); - } while (count != 0); - read_end_.close(); - return content; -} - -std::string read(file& f, size_t count) { - std::string buffer(count, '\0'); - size_t n = 0, offset = 0; - do { - n = f.read(&buffer[offset], count - offset); - // We can't read more than size_t bytes since count has type size_t. - offset += n; - } while (offset < count && n != 0); - buffer.resize(offset); - return buffer; -} - -#endif // FMT_USE_FCNTL diff --git a/thirdparty/fmt/test/gtest-extra.h b/thirdparty/fmt/test/gtest-extra.h deleted file mode 100644 index 718598351..000000000 --- a/thirdparty/fmt/test/gtest-extra.h +++ /dev/null @@ -1,169 +0,0 @@ -// Formatting library for C++ - custom Google Test assertions -// -// Copyright (c) 2012 - present, Victor Zverovich -// All rights reserved. -// -// For the license information refer to format.h. - -#ifndef FMT_GTEST_EXTRA_H_ -#define FMT_GTEST_EXTRA_H_ - -#include <stdlib.h> // _invalid_parameter_handler - -#include <string> - -#include "fmt/os.h" -#include "gmock/gmock.h" - -#ifdef _MSC_VER -# include <crtdbg.h> -#endif - -#define FMT_TEST_THROW_(statement, expected_exception, expected_message, fail) \ - GTEST_AMBIGUOUS_ELSE_BLOCKER_ \ - if (::testing::AssertionResult gtest_ar = ::testing::AssertionSuccess()) { \ - std::string gtest_expected_message = expected_message; \ - bool gtest_caught_expected = false; \ - try { \ - GTEST_SUPPRESS_UNREACHABLE_CODE_WARNING_BELOW_(statement); \ - } catch (expected_exception const& e) { \ - if (gtest_expected_message != e.what()) { \ - gtest_ar << #statement \ - " throws an exception with a different message.\n" \ - << "Expected: " << gtest_expected_message << "\n" \ - << " Actual: " << e.what(); \ - goto GTEST_CONCAT_TOKEN_(gtest_label_testthrow_, __LINE__); \ - } \ - gtest_caught_expected = true; \ - } catch (...) { \ - gtest_ar << "Expected: " #statement \ - " throws an exception of type " #expected_exception \ - ".\n Actual: it throws a different type."; \ - goto GTEST_CONCAT_TOKEN_(gtest_label_testthrow_, __LINE__); \ - } \ - if (!gtest_caught_expected) { \ - gtest_ar << "Expected: " #statement \ - " throws an exception of type " #expected_exception \ - ".\n Actual: it throws nothing."; \ - goto GTEST_CONCAT_TOKEN_(gtest_label_testthrow_, __LINE__); \ - } \ - } else \ - GTEST_CONCAT_TOKEN_(gtest_label_testthrow_, __LINE__) \ - : fail(gtest_ar.failure_message()) - -// Tests that the statement throws the expected exception and the exception's -// what() method returns expected message. -#define EXPECT_THROW_MSG(statement, expected_exception, expected_message) \ - FMT_TEST_THROW_(statement, expected_exception, expected_message, \ - GTEST_NONFATAL_FAILURE_) - -inline std::string system_error_message(int error_code, - const std::string& message) { - auto ec = std::error_code(error_code, std::generic_category()); - return std::system_error(ec, message).what(); -} - -#define EXPECT_SYSTEM_ERROR(statement, error_code, message) \ - EXPECT_THROW_MSG(statement, std::system_error, \ - system_error_message(error_code, message)) - -#if FMT_USE_FCNTL - -// Captures file output by redirecting it to a pipe. -// The output it can handle is limited by the pipe capacity. -class output_redirect { - private: - FILE* file_; - fmt::file original_; // Original file passed to redirector. - fmt::file read_end_; // Read end of the pipe where the output is redirected. - - void flush(); - void restore(); - - public: - explicit output_redirect(FILE* file, bool flush = true); - ~output_redirect() noexcept; - - output_redirect(const output_redirect&) = delete; - void operator=(const output_redirect&) = delete; - - // Restores the original file, reads output from the pipe into a string - // and returns it. - std::string restore_and_read(); -}; - -# define FMT_TEST_WRITE_(statement, expected_output, file, fail) \ - GTEST_AMBIGUOUS_ELSE_BLOCKER_ \ - if (::testing::AssertionResult gtest_ar = ::testing::AssertionSuccess()) { \ - std::string gtest_expected_output = expected_output; \ - output_redirect gtest_redir(file); \ - GTEST_SUPPRESS_UNREACHABLE_CODE_WARNING_BELOW_(statement); \ - std::string gtest_output = gtest_redir.restore_and_read(); \ - if (gtest_output != gtest_expected_output) { \ - gtest_ar << #statement " produces different output.\n" \ - << "Expected: " << gtest_expected_output << "\n" \ - << " Actual: " << gtest_output; \ - goto GTEST_CONCAT_TOKEN_(gtest_label_testthrow_, __LINE__); \ - } \ - } else \ - GTEST_CONCAT_TOKEN_(gtest_label_testthrow_, __LINE__) \ - : fail(gtest_ar.failure_message()) - -// Tests that the statement writes the expected output to file. -# define EXPECT_WRITE(file, statement, expected_output) \ - FMT_TEST_WRITE_(statement, expected_output, file, GTEST_NONFATAL_FAILURE_) - -# ifdef _MSC_VER - -// Suppresses Windows assertions on invalid file descriptors, making -// POSIX functions return proper error codes instead of crashing on Windows. -class suppress_assert { - private: - _invalid_parameter_handler original_handler_; - int original_report_mode_; - - static void handle_invalid_parameter(const wchar_t*, const wchar_t*, - const wchar_t*, unsigned, uintptr_t) {} - - public: - suppress_assert() - : original_handler_( - _set_invalid_parameter_handler(handle_invalid_parameter)), - original_report_mode_(_CrtSetReportMode(_CRT_ASSERT, 0)) {} - ~suppress_assert() { - _set_invalid_parameter_handler(original_handler_); - _CrtSetReportMode(_CRT_ASSERT, original_report_mode_); - (void)original_report_mode_; - } -}; - -# define SUPPRESS_ASSERT(statement) \ - { \ - suppress_assert sa; \ - statement; \ - } -# else -# define SUPPRESS_ASSERT(statement) statement -# endif // _MSC_VER - -# define EXPECT_SYSTEM_ERROR_NOASSERT(statement, error_code, message) \ - EXPECT_SYSTEM_ERROR(SUPPRESS_ASSERT(statement), error_code, message) - -// Attempts to read count characters from a file. -std::string read(fmt::file& f, size_t count); - -# define EXPECT_READ(file, expected_content) \ - EXPECT_EQ(expected_content, \ - read(file, fmt::string_view(expected_content).size())) - -#else -# define EXPECT_WRITE(file, statement, expected_output) \ - do { \ - (void)(file); \ - (void)(statement); \ - (void)(expected_output); \ - SUCCEED(); \ - } while (false) -#endif // FMT_USE_FCNTL - -#endif // FMT_GTEST_EXTRA_H_ diff --git a/thirdparty/fmt/test/gtest/.clang-format b/thirdparty/fmt/test/gtest/.clang-format deleted file mode 100644 index ec09b9b6b..000000000 --- a/thirdparty/fmt/test/gtest/.clang-format +++ /dev/null @@ -1,3 +0,0 @@ -# Disable clang-format here -DisableFormat: true -SortIncludes: Never diff --git a/thirdparty/fmt/test/gtest/gmock-gtest-all.cc b/thirdparty/fmt/test/gtest/gmock-gtest-all.cc deleted file mode 100644 index 6642abef8..000000000 --- a/thirdparty/fmt/test/gtest/gmock-gtest-all.cc +++ /dev/null @@ -1,14442 +0,0 @@ -// Copyright 2008, 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. - -// -// Google C++ Testing and Mocking Framework (Google Test) -// -// Sometimes it's desirable to build Google Test by compiling a single file. -// This file serves this purpose. - -// This line ensures that gtest.h can be compiled on its own, even -// when it's fused. -#include "gtest/gtest.h" - -// The following lines pull in the real gtest *.cc files. -// 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. - -// -// The Google C++ Testing and Mocking Framework (Google Test) - -// Copyright 2007, 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. - -// -// Utilities for testing Google Test itself and code that uses Google Test -// (e.g. frameworks built on top of Google Test). - -// GOOGLETEST_CM0004 DO NOT DELETE - -#ifndef GOOGLETEST_INCLUDE_GTEST_GTEST_SPI_H_ -#define GOOGLETEST_INCLUDE_GTEST_GTEST_SPI_H_ - - -GTEST_DISABLE_MSC_WARNINGS_PUSH_(4251 \ -/* class A needs to have dll-interface to be used by clients of class B */) - -namespace testing { - -// This helper class can be used to mock out Google Test failure reporting -// so that we can test Google Test or code that builds on Google Test. -// -// An object of this class appends a TestPartResult object to the -// TestPartResultArray object given in the constructor whenever a Google Test -// failure is reported. It can either intercept only failures that are -// generated in the same thread that created this object or it can intercept -// all generated failures. The scope of this mock object can be controlled with -// the second argument to the two arguments constructor. -class GTEST_API_ ScopedFakeTestPartResultReporter - : public TestPartResultReporterInterface { - public: - // The two possible mocking modes of this object. - enum InterceptMode { - INTERCEPT_ONLY_CURRENT_THREAD, // Intercepts only thread local failures. - INTERCEPT_ALL_THREADS // Intercepts all failures. - }; - - // The c'tor sets this object as the test part result reporter used - // by Google Test. The 'result' parameter specifies where to report the - // results. This reporter will only catch failures generated in the current - // thread. DEPRECATED - explicit ScopedFakeTestPartResultReporter(TestPartResultArray* result); - - // Same as above, but you can choose the interception scope of this object. - ScopedFakeTestPartResultReporter(InterceptMode intercept_mode, - TestPartResultArray* result); - - // The d'tor restores the previous test part result reporter. - ~ScopedFakeTestPartResultReporter() override; - - // Appends the TestPartResult object to the TestPartResultArray - // received in the constructor. - // - // This method is from the TestPartResultReporterInterface - // interface. - void ReportTestPartResult(const TestPartResult& result) override; - - private: - void Init(); - - const InterceptMode intercept_mode_; - TestPartResultReporterInterface* old_reporter_; - TestPartResultArray* const result_; - - GTEST_DISALLOW_COPY_AND_ASSIGN_(ScopedFakeTestPartResultReporter); -}; - -namespace internal { - -// A helper class for implementing EXPECT_FATAL_FAILURE() and -// EXPECT_NONFATAL_FAILURE(). Its destructor verifies that the given -// TestPartResultArray contains exactly one failure that has the given -// type and contains the given substring. If that's not the case, a -// non-fatal failure will be generated. -class GTEST_API_ SingleFailureChecker { - public: - // The constructor remembers the arguments. - SingleFailureChecker(const TestPartResultArray* results, - TestPartResult::Type type, const std::string& substr); - ~SingleFailureChecker(); - private: - const TestPartResultArray* const results_; - const TestPartResult::Type type_; - const std::string substr_; - - GTEST_DISALLOW_COPY_AND_ASSIGN_(SingleFailureChecker); -}; - -} // namespace internal - -} // namespace testing - -GTEST_DISABLE_MSC_WARNINGS_POP_() // 4251 - -// A set of macros for testing Google Test assertions or code that's expected -// to generate Google Test fatal failures. It verifies that the given -// statement will cause exactly one fatal Google Test failure with 'substr' -// being part of the failure message. -// -// There are two different versions of this macro. EXPECT_FATAL_FAILURE only -// affects and considers failures generated in the current thread and -// EXPECT_FATAL_FAILURE_ON_ALL_THREADS does the same but for all threads. -// -// The verification of the assertion is done correctly even when the statement -// throws an exception or aborts the current function. -// -// Known restrictions: -// - 'statement' cannot reference local non-static variables or -// non-static members of the current object. -// - 'statement' cannot return a value. -// - You cannot stream a failure message to this macro. -// -// Note that even though the implementations of the following two -// macros are much alike, we cannot refactor them to use a common -// helper macro, due to some peculiarity in how the preprocessor -// works. The AcceptsMacroThatExpandsToUnprotectedComma test in -// gtest_unittest.cc will fail to compile if we do that. -#define EXPECT_FATAL_FAILURE(statement, substr) \ - do { \ - class GTestExpectFatalFailureHelper {\ - public:\ - static void Execute() { statement; }\ - };\ - ::testing::TestPartResultArray gtest_failures;\ - ::testing::internal::SingleFailureChecker gtest_checker(\ - >est_failures, ::testing::TestPartResult::kFatalFailure, (substr));\ - {\ - ::testing::ScopedFakeTestPartResultReporter gtest_reporter(\ - ::testing::ScopedFakeTestPartResultReporter:: \ - INTERCEPT_ONLY_CURRENT_THREAD, >est_failures);\ - GTestExpectFatalFailureHelper::Execute();\ - }\ - } while (::testing::internal::AlwaysFalse()) - -#define EXPECT_FATAL_FAILURE_ON_ALL_THREADS(statement, substr) \ - do { \ - class GTestExpectFatalFailureHelper {\ - public:\ - static void Execute() { statement; }\ - };\ - ::testing::TestPartResultArray gtest_failures;\ - ::testing::internal::SingleFailureChecker gtest_checker(\ - >est_failures, ::testing::TestPartResult::kFatalFailure, (substr));\ - {\ - ::testing::ScopedFakeTestPartResultReporter gtest_reporter(\ - ::testing::ScopedFakeTestPartResultReporter:: \ - INTERCEPT_ALL_THREADS, >est_failures);\ - GTestExpectFatalFailureHelper::Execute();\ - }\ - } while (::testing::internal::AlwaysFalse()) - -// A macro for testing Google Test assertions or code that's expected to -// generate Google Test non-fatal failures. It asserts that the given -// statement will cause exactly one non-fatal Google Test failure with 'substr' -// being part of the failure message. -// -// There are two different versions of this macro. EXPECT_NONFATAL_FAILURE only -// affects and considers failures generated in the current thread and -// EXPECT_NONFATAL_FAILURE_ON_ALL_THREADS does the same but for all threads. -// -// 'statement' is allowed to reference local variables and members of -// the current object. -// -// The verification of the assertion is done correctly even when the statement -// throws an exception or aborts the current function. -// -// Known restrictions: -// - You cannot stream a failure message to this macro. -// -// Note that even though the implementations of the following two -// macros are much alike, we cannot refactor them to use a common -// helper macro, due to some peculiarity in how the preprocessor -// works. If we do that, the code won't compile when the user gives -// EXPECT_NONFATAL_FAILURE() a statement that contains a macro that -// expands to code containing an unprotected comma. The -// AcceptsMacroThatExpandsToUnprotectedComma test in gtest_unittest.cc -// catches that. -// -// For the same reason, we have to write -// if (::testing::internal::AlwaysTrue()) { statement; } -// instead of -// GTEST_SUPPRESS_UNREACHABLE_CODE_WARNING_BELOW_(statement) -// to avoid an MSVC warning on unreachable code. -#define EXPECT_NONFATAL_FAILURE(statement, substr) \ - do {\ - ::testing::TestPartResultArray gtest_failures;\ - ::testing::internal::SingleFailureChecker gtest_checker(\ - >est_failures, ::testing::TestPartResult::kNonFatalFailure, \ - (substr));\ - {\ - ::testing::ScopedFakeTestPartResultReporter gtest_reporter(\ - ::testing::ScopedFakeTestPartResultReporter:: \ - INTERCEPT_ONLY_CURRENT_THREAD, >est_failures);\ - if (::testing::internal::AlwaysTrue()) { statement; }\ - }\ - } while (::testing::internal::AlwaysFalse()) - -#define EXPECT_NONFATAL_FAILURE_ON_ALL_THREADS(statement, substr) \ - do {\ - ::testing::TestPartResultArray gtest_failures;\ - ::testing::internal::SingleFailureChecker gtest_checker(\ - >est_failures, ::testing::TestPartResult::kNonFatalFailure, \ - (substr));\ - {\ - ::testing::ScopedFakeTestPartResultReporter gtest_reporter(\ - ::testing::ScopedFakeTestPartResultReporter::INTERCEPT_ALL_THREADS, \ - >est_failures);\ - if (::testing::internal::AlwaysTrue()) { statement; }\ - }\ - } while (::testing::internal::AlwaysFalse()) - -#endif // GOOGLETEST_INCLUDE_GTEST_GTEST_SPI_H_ - -#include <ctype.h> -#include <stdarg.h> -#include <stdio.h> -#include <stdlib.h> -#include <time.h> -#include <wchar.h> -#include <wctype.h> - -#include <algorithm> -#include <chrono> // NOLINT -#include <cmath> -#include <cstdint> -#include <iomanip> -#include <limits> -#include <list> -#include <map> -#include <ostream> // NOLINT -#include <sstream> -#include <vector> - -#if GTEST_OS_LINUX - -# include <fcntl.h> // NOLINT -# include <limits.h> // NOLINT -# include <sched.h> // NOLINT -// Declares vsnprintf(). This header is not available on Windows. -# include <strings.h> // NOLINT -# include <sys/mman.h> // NOLINT -# include <sys/time.h> // NOLINT -# include <unistd.h> // NOLINT -# include <string> - -#elif GTEST_OS_ZOS -# include <sys/time.h> // NOLINT - -// On z/OS we additionally need strings.h for strcasecmp. -# include <strings.h> // NOLINT - -#elif GTEST_OS_WINDOWS_MOBILE // We are on Windows CE. - -# include <windows.h> // NOLINT -# undef min - -#elif GTEST_OS_WINDOWS // We are on Windows proper. - -# include <windows.h> // NOLINT -# undef min - -#ifdef _MSC_VER -# include <crtdbg.h> // NOLINT -#endif - -# include <io.h> // NOLINT -# include <sys/timeb.h> // NOLINT -# include <sys/types.h> // NOLINT -# include <sys/stat.h> // NOLINT - -# if GTEST_OS_WINDOWS_MINGW -# include <sys/time.h> // NOLINT -# endif // GTEST_OS_WINDOWS_MINGW - -#else - -// cpplint thinks that the header is already included, so we want to -// silence it. -# include <sys/time.h> // NOLINT -# include <unistd.h> // NOLINT - -#endif // GTEST_OS_LINUX - -#if GTEST_HAS_EXCEPTIONS -# include <stdexcept> -#endif - -#if GTEST_CAN_STREAM_RESULTS_ -# include <arpa/inet.h> // NOLINT -# include <netdb.h> // NOLINT -# include <sys/socket.h> // NOLINT -# include <sys/types.h> // NOLINT -#endif - -// 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. - -// Utility functions and classes used by the Google C++ testing framework.// -// This file contains purely Google Test's internal implementation. Please -// DO NOT #INCLUDE IT IN A USER PROGRAM. - -#ifndef GOOGLETEST_SRC_GTEST_INTERNAL_INL_H_ -#define GOOGLETEST_SRC_GTEST_INTERNAL_INL_H_ - -#ifndef _WIN32_WCE -# include <errno.h> -#endif // !_WIN32_WCE -#include <stddef.h> -#include <stdlib.h> // For strtoll/_strtoul64/malloc/free. -#include <string.h> // For memmove. - -#include <algorithm> -#include <cstdint> -#include <memory> -#include <string> -#include <vector> - - -#if GTEST_CAN_STREAM_RESULTS_ -# include <arpa/inet.h> // NOLINT -# include <netdb.h> // NOLINT -#endif - -#if GTEST_OS_WINDOWS -# include <windows.h> // NOLINT -#endif // GTEST_OS_WINDOWS - - -GTEST_DISABLE_MSC_WARNINGS_PUSH_(4251 \ -/* class A needs to have dll-interface to be used by clients of class B */) - -namespace testing { - -// Declares the flags. -// -// We don't want the users to modify this flag in the code, but want -// Google Test's own unit tests to be able to access it. Therefore we -// declare it here as opposed to in gtest.h. -GTEST_DECLARE_bool_(death_test_use_fork); - -namespace internal { - -// The value of GetTestTypeId() as seen from within the Google Test -// library. This is solely for testing GetTestTypeId(). -GTEST_API_ extern const TypeId kTestTypeIdInGoogleTest; - -// Names of the flags (needed for parsing Google Test flags). -const char kAlsoRunDisabledTestsFlag[] = "also_run_disabled_tests"; -const char kBreakOnFailureFlag[] = "break_on_failure"; -const char kCatchExceptionsFlag[] = "catch_exceptions"; -const char kColorFlag[] = "color"; -const char kFailFast[] = "fail_fast"; -const char kFilterFlag[] = "filter"; -const char kListTestsFlag[] = "list_tests"; -const char kOutputFlag[] = "output"; -const char kBriefFlag[] = "brief"; -const char kPrintTimeFlag[] = "print_time"; -const char kPrintUTF8Flag[] = "print_utf8"; -const char kRandomSeedFlag[] = "random_seed"; -const char kRepeatFlag[] = "repeat"; -const char kShuffleFlag[] = "shuffle"; -const char kStackTraceDepthFlag[] = "stack_trace_depth"; -const char kStreamResultToFlag[] = "stream_result_to"; -const char kThrowOnFailureFlag[] = "throw_on_failure"; -const char kFlagfileFlag[] = "flagfile"; - -// A valid random seed must be in [1, kMaxRandomSeed]. -const int kMaxRandomSeed = 99999; - -// g_help_flag is true if and only if the --help flag or an equivalent form -// is specified on the command line. -GTEST_API_ extern bool g_help_flag; - -// Returns the current time in milliseconds. -GTEST_API_ TimeInMillis GetTimeInMillis(); - -// Returns true if and only if Google Test should use colors in the output. -GTEST_API_ bool ShouldUseColor(bool stdout_is_tty); - -// Formats the given time in milliseconds as seconds. -GTEST_API_ std::string FormatTimeInMillisAsSeconds(TimeInMillis ms); - -// Converts the given time in milliseconds to a date string in the ISO 8601 -// format, without the timezone information. N.B.: due to the use the -// non-reentrant localtime() function, this function is not thread safe. Do -// not use it in any code that can be called from multiple threads. -GTEST_API_ std::string FormatEpochTimeInMillisAsIso8601(TimeInMillis ms); - -// Parses a string for an Int32 flag, in the form of "--flag=value". -// -// On success, stores the value of the flag in *value, and returns -// true. On failure, returns false without changing *value. -GTEST_API_ bool ParseInt32Flag( - const char* str, const char* flag, int32_t* value); - -// Returns a random seed in range [1, kMaxRandomSeed] based on the -// given --gtest_random_seed flag value. -inline int GetRandomSeedFromFlag(int32_t random_seed_flag) { - const unsigned int raw_seed = (random_seed_flag == 0) ? - static_cast<unsigned int>(GetTimeInMillis()) : - static_cast<unsigned int>(random_seed_flag); - - // Normalizes the actual seed to range [1, kMaxRandomSeed] such that - // it's easy to type. - const int normalized_seed = - static_cast<int>((raw_seed - 1U) % - static_cast<unsigned int>(kMaxRandomSeed)) + 1; - return normalized_seed; -} - -// Returns the first valid random seed after 'seed'. The behavior is -// undefined if 'seed' is invalid. The seed after kMaxRandomSeed is -// considered to be 1. -inline int GetNextRandomSeed(int seed) { - GTEST_CHECK_(1 <= seed && seed <= kMaxRandomSeed) - << "Invalid random seed " << seed << " - must be in [1, " - << kMaxRandomSeed << "]."; - const int next_seed = seed + 1; - return (next_seed > kMaxRandomSeed) ? 1 : next_seed; -} - -// This class saves the values of all Google Test flags in its c'tor, and -// restores them in its d'tor. -class GTestFlagSaver { - public: - // The c'tor. - GTestFlagSaver() { - also_run_disabled_tests_ = GTEST_FLAG(also_run_disabled_tests); - break_on_failure_ = GTEST_FLAG(break_on_failure); - catch_exceptions_ = GTEST_FLAG(catch_exceptions); - color_ = GTEST_FLAG(color); - death_test_style_ = GTEST_FLAG(death_test_style); - death_test_use_fork_ = GTEST_FLAG(death_test_use_fork); - fail_fast_ = GTEST_FLAG(fail_fast); - filter_ = GTEST_FLAG(filter); - internal_run_death_test_ = GTEST_FLAG(internal_run_death_test); - list_tests_ = GTEST_FLAG(list_tests); - output_ = GTEST_FLAG(output); - brief_ = GTEST_FLAG(brief); - print_time_ = GTEST_FLAG(print_time); - print_utf8_ = GTEST_FLAG(print_utf8); - random_seed_ = GTEST_FLAG(random_seed); - repeat_ = GTEST_FLAG(repeat); - shuffle_ = GTEST_FLAG(shuffle); - stack_trace_depth_ = GTEST_FLAG(stack_trace_depth); - stream_result_to_ = GTEST_FLAG(stream_result_to); - throw_on_failure_ = GTEST_FLAG(throw_on_failure); - } - - // The d'tor is not virtual. DO NOT INHERIT FROM THIS CLASS. - ~GTestFlagSaver() { - GTEST_FLAG(also_run_disabled_tests) = also_run_disabled_tests_; - GTEST_FLAG(break_on_failure) = break_on_failure_; - GTEST_FLAG(catch_exceptions) = catch_exceptions_; - GTEST_FLAG(color) = color_; - GTEST_FLAG(death_test_style) = death_test_style_; - GTEST_FLAG(death_test_use_fork) = death_test_use_fork_; - GTEST_FLAG(filter) = filter_; - GTEST_FLAG(fail_fast) = fail_fast_; - GTEST_FLAG(internal_run_death_test) = internal_run_death_test_; - GTEST_FLAG(list_tests) = list_tests_; - GTEST_FLAG(output) = output_; - GTEST_FLAG(brief) = brief_; - GTEST_FLAG(print_time) = print_time_; - GTEST_FLAG(print_utf8) = print_utf8_; - GTEST_FLAG(random_seed) = random_seed_; - GTEST_FLAG(repeat) = repeat_; - GTEST_FLAG(shuffle) = shuffle_; - GTEST_FLAG(stack_trace_depth) = stack_trace_depth_; - GTEST_FLAG(stream_result_to) = stream_result_to_; - GTEST_FLAG(throw_on_failure) = throw_on_failure_; - } - - private: - // Fields for saving the original values of flags. - bool also_run_disabled_tests_; - bool break_on_failure_; - bool catch_exceptions_; - std::string color_; - std::string death_test_style_; - bool death_test_use_fork_; - bool fail_fast_; - std::string filter_; - std::string internal_run_death_test_; - bool list_tests_; - std::string output_; - bool brief_; - bool print_time_; - bool print_utf8_; - int32_t random_seed_; - int32_t repeat_; - bool shuffle_; - int32_t stack_trace_depth_; - std::string stream_result_to_; - bool throw_on_failure_; -} GTEST_ATTRIBUTE_UNUSED_; - -// Converts a Unicode code point to a narrow string in UTF-8 encoding. -// code_point parameter is of type UInt32 because wchar_t may not be -// wide enough to contain a code point. -// If the code_point is not a valid Unicode code point -// (i.e. outside of Unicode range U+0 to U+10FFFF) it will be converted -// to "(Invalid Unicode 0xXXXXXXXX)". -GTEST_API_ std::string CodePointToUtf8(uint32_t code_point); - -// Converts a wide string to a narrow string in UTF-8 encoding. -// The wide string is assumed to have the following encoding: -// UTF-16 if sizeof(wchar_t) == 2 (on Windows, Cygwin) -// UTF-32 if sizeof(wchar_t) == 4 (on Linux) -// Parameter str points to a null-terminated wide string. -// Parameter num_chars may additionally limit the number -// of wchar_t characters processed. -1 is used when the entire string -// should be processed. -// If the string contains code points that are not valid Unicode code points -// (i.e. outside of Unicode range U+0 to U+10FFFF) they will be output -// as '(Invalid Unicode 0xXXXXXXXX)'. If the string is in UTF16 encoding -// and contains invalid UTF-16 surrogate pairs, values in those pairs -// will be encoded as individual Unicode characters from Basic Normal Plane. -GTEST_API_ std::string WideStringToUtf8(const wchar_t* str, int num_chars); - -// Reads the GTEST_SHARD_STATUS_FILE environment variable, and creates the file -// if the variable is present. If a file already exists at this location, this -// function will write over it. If the variable is present, but the file cannot -// be created, prints an error and exits. -void WriteToShardStatusFileIfNeeded(); - -// Checks whether sharding is enabled by examining the relevant -// environment variable values. If the variables are present, -// but inconsistent (e.g., shard_index >= total_shards), prints -// an error and exits. If in_subprocess_for_death_test, sharding is -// disabled because it must only be applied to the original test -// process. Otherwise, we could filter out death tests we intended to execute. -GTEST_API_ bool ShouldShard(const char* total_shards_str, - const char* shard_index_str, - bool in_subprocess_for_death_test); - -// Parses the environment variable var as a 32-bit integer. If it is unset, -// returns default_val. If it is not a 32-bit integer, prints an error and -// and aborts. -GTEST_API_ int32_t Int32FromEnvOrDie(const char* env_var, int32_t default_val); - -// Given the total number of shards, the shard index, and the test id, -// returns true if and only if the test should be run on this shard. The test id -// is some arbitrary but unique non-negative integer assigned to each test -// method. Assumes that 0 <= shard_index < total_shards. -GTEST_API_ bool ShouldRunTestOnShard( - int total_shards, int shard_index, int test_id); - -// STL container utilities. - -// Returns the number of elements in the given container that satisfy -// the given predicate. -template <class Container, typename Predicate> -inline int CountIf(const Container& c, Predicate predicate) { - // Implemented as an explicit loop since std::count_if() in libCstd on - // Solaris has a non-standard signature. - int count = 0; - for (typename Container::const_iterator it = c.begin(); it != c.end(); ++it) { - if (predicate(*it)) - ++count; - } - return count; -} - -// Applies a function/functor to each element in the container. -template <class Container, typename Functor> -void ForEach(const Container& c, Functor functor) { - std::for_each(c.begin(), c.end(), functor); -} - -// Returns the i-th element of the vector, or default_value if i is not -// in range [0, v.size()). -template <typename E> -inline E GetElementOr(const std::vector<E>& v, int i, E default_value) { - return (i < 0 || i >= static_cast<int>(v.size())) ? default_value - : v[static_cast<size_t>(i)]; -} - -// Performs an in-place shuffle of a range of the vector's elements. -// 'begin' and 'end' are element indices as an STL-style range; -// i.e. [begin, end) are shuffled, where 'end' == size() means to -// shuffle to the end of the vector. -template <typename E> -void ShuffleRange(internal::Random* random, int begin, int end, - std::vector<E>* v) { - const int size = static_cast<int>(v->size()); - GTEST_CHECK_(0 <= begin && begin <= size) - << "Invalid shuffle range start " << begin << ": must be in range [0, " - << size << "]."; - GTEST_CHECK_(begin <= end && end <= size) - << "Invalid shuffle range finish " << end << ": must be in range [" - << begin << ", " << size << "]."; - - // Fisher-Yates shuffle, from - // http://en.wikipedia.org/wiki/Fisher-Yates_shuffle - for (int range_width = end - begin; range_width >= 2; range_width--) { - const int last_in_range = begin + range_width - 1; - const int selected = - begin + - static_cast<int>(random->Generate(static_cast<uint32_t>(range_width))); - std::swap((*v)[static_cast<size_t>(selected)], - (*v)[static_cast<size_t>(last_in_range)]); - } -} - -// Performs an in-place shuffle of the vector's elements. -template <typename E> -inline void Shuffle(internal::Random* random, std::vector<E>* v) { - ShuffleRange(random, 0, static_cast<int>(v->size()), v); -} - -// A function for deleting an object. Handy for being used as a -// functor. -template <typename T> -static void Delete(T* x) { - delete x; -} - -// A predicate that checks the key of a TestProperty against a known key. -// -// TestPropertyKeyIs is copyable. -class TestPropertyKeyIs { - public: - // Constructor. - // - // TestPropertyKeyIs has NO default constructor. - explicit TestPropertyKeyIs(const std::string& key) : key_(key) {} - - // Returns true if and only if the test name of test property matches on key_. - bool operator()(const TestProperty& test_property) const { - return test_property.key() == key_; - } - - private: - std::string key_; -}; - -// Class UnitTestOptions. -// -// This class contains functions for processing options the user -// specifies when running the tests. It has only static members. -// -// In most cases, the user can specify an option using either an -// environment variable or a command line flag. E.g. you can set the -// test filter using either GTEST_FILTER or --gtest_filter. If both -// the variable and the flag are present, the latter overrides the -// former. -class GTEST_API_ UnitTestOptions { - public: - // Functions for processing the gtest_output flag. - - // Returns the output format, or "" for normal printed output. - static std::string GetOutputFormat(); - - // Returns the absolute path of the requested output file, or the - // default (test_detail.xml in the original working directory) if - // none was explicitly specified. - static std::string GetAbsolutePathToOutputFile(); - - // Functions for processing the gtest_filter flag. - - // Returns true if and only if the user-specified filter matches the test - // suite name and the test name. - static bool FilterMatchesTest(const std::string& test_suite_name, - const std::string& test_name); - -#if GTEST_OS_WINDOWS - // Function for supporting the gtest_catch_exception flag. - - // Returns EXCEPTION_EXECUTE_HANDLER if Google Test should handle the - // given SEH exception, or EXCEPTION_CONTINUE_SEARCH otherwise. - // This function is useful as an __except condition. - static int GTestShouldProcessSEH(DWORD exception_code); -#endif // GTEST_OS_WINDOWS - - // Returns true if "name" matches the ':' separated list of glob-style - // filters in "filter". - static bool MatchesFilter(const std::string& name, const char* filter); -}; - -// Returns the current application's name, removing directory path if that -// is present. Used by UnitTestOptions::GetOutputFile. -GTEST_API_ FilePath GetCurrentExecutableName(); - -// The role interface for getting the OS stack trace as a string. -class OsStackTraceGetterInterface { - public: - OsStackTraceGetterInterface() {} - virtual ~OsStackTraceGetterInterface() {} - - // Returns the current OS stack trace as an std::string. Parameters: - // - // max_depth - the maximum number of stack frames to be included - // in the trace. - // skip_count - the number of top frames to be skipped; doesn't count - // against max_depth. - virtual std::string CurrentStackTrace(int max_depth, int skip_count) = 0; - - // UponLeavingGTest() should be called immediately before Google Test calls - // user code. It saves some information about the current stack that - // CurrentStackTrace() will use to find and hide Google Test stack frames. - virtual void UponLeavingGTest() = 0; - - // This string is inserted in place of stack frames that are part of - // Google Test's implementation. - static const char* const kElidedFramesMarker; - - private: - GTEST_DISALLOW_COPY_AND_ASSIGN_(OsStackTraceGetterInterface); -}; - -// A working implementation of the OsStackTraceGetterInterface interface. -class OsStackTraceGetter : public OsStackTraceGetterInterface { - public: - OsStackTraceGetter() {} - - std::string CurrentStackTrace(int max_depth, int skip_count) override; - void UponLeavingGTest() override; - - private: -#if GTEST_HAS_ABSL - Mutex mutex_; // Protects all internal state. - - // We save the stack frame below the frame that calls user code. - // We do this because the address of the frame immediately below - // the user code changes between the call to UponLeavingGTest() - // and any calls to the stack trace code from within the user code. - void* caller_frame_ = nullptr; -#endif // GTEST_HAS_ABSL - - GTEST_DISALLOW_COPY_AND_ASSIGN_(OsStackTraceGetter); -}; - -// Information about a Google Test trace point. -struct TraceInfo { - const char* file; - int line; - std::string message; -}; - -// This is the default global test part result reporter used in UnitTestImpl. -// This class should only be used by UnitTestImpl. -class DefaultGlobalTestPartResultReporter - : public TestPartResultReporterInterface { - public: - explicit DefaultGlobalTestPartResultReporter(UnitTestImpl* unit_test); - // Implements the TestPartResultReporterInterface. Reports the test part - // result in the current test. - void ReportTestPartResult(const TestPartResult& result) override; - - private: - UnitTestImpl* const unit_test_; - - GTEST_DISALLOW_COPY_AND_ASSIGN_(DefaultGlobalTestPartResultReporter); -}; - -// This is the default per thread test part result reporter used in -// UnitTestImpl. This class should only be used by UnitTestImpl. -class DefaultPerThreadTestPartResultReporter - : public TestPartResultReporterInterface { - public: - explicit DefaultPerThreadTestPartResultReporter(UnitTestImpl* unit_test); - // Implements the TestPartResultReporterInterface. The implementation just - // delegates to the current global test part result reporter of *unit_test_. - void ReportTestPartResult(const TestPartResult& result) override; - - private: - UnitTestImpl* const unit_test_; - - GTEST_DISALLOW_COPY_AND_ASSIGN_(DefaultPerThreadTestPartResultReporter); -}; - -// The private implementation of the UnitTest class. We don't protect -// the methods under a mutex, as this class is not accessible by a -// user and the UnitTest class that delegates work to this class does -// proper locking. -class GTEST_API_ UnitTestImpl { - public: - explicit UnitTestImpl(UnitTest* parent); - virtual ~UnitTestImpl(); - - // There are two different ways to register your own TestPartResultReporter. - // You can register your own repoter to listen either only for test results - // from the current thread or for results from all threads. - // By default, each per-thread test result repoter just passes a new - // TestPartResult to the global test result reporter, which registers the - // test part result for the currently running test. - - // Returns the global test part result reporter. - TestPartResultReporterInterface* GetGlobalTestPartResultReporter(); - - // Sets the global test part result reporter. - void SetGlobalTestPartResultReporter( - TestPartResultReporterInterface* reporter); - - // Returns the test part result reporter for the current thread. - TestPartResultReporterInterface* GetTestPartResultReporterForCurrentThread(); - - // Sets the test part result reporter for the current thread. - void SetTestPartResultReporterForCurrentThread( - TestPartResultReporterInterface* reporter); - - // Gets the number of successful test suites. - int successful_test_suite_count() const; - - // Gets the number of failed test suites. - int failed_test_suite_count() const; - - // Gets the number of all test suites. - int total_test_suite_count() const; - - // Gets the number of all test suites that contain at least one test - // that should run. - int test_suite_to_run_count() const; - - // Gets the number of successful tests. - int successful_test_count() const; - - // Gets the number of skipped tests. - int skipped_test_count() const; - - // Gets the number of failed tests. - int failed_test_count() const; - - // Gets the number of disabled tests that will be reported in the XML report. - int reportable_disabled_test_count() const; - - // Gets the number of disabled tests. - int disabled_test_count() const; - - // Gets the number of tests to be printed in the XML report. - int reportable_test_count() const; - - // Gets the number of all tests. - int total_test_count() const; - - // Gets the number of tests that should run. - int test_to_run_count() const; - - // Gets the time of the test program start, in ms from the start of the - // UNIX epoch. - TimeInMillis start_timestamp() const { return start_timestamp_; } - - // Gets the elapsed time, in milliseconds. - TimeInMillis elapsed_time() const { return elapsed_time_; } - - // Returns true if and only if the unit test passed (i.e. all test suites - // passed). - bool Passed() const { return !Failed(); } - - // Returns true if and only if the unit test failed (i.e. some test suite - // failed or something outside of all tests failed). - bool Failed() const { - return failed_test_suite_count() > 0 || ad_hoc_test_result()->Failed(); - } - - // Gets the i-th test suite among all the test suites. i can range from 0 to - // total_test_suite_count() - 1. If i is not in that range, returns NULL. - const TestSuite* GetTestSuite(int i) const { - const int index = GetElementOr(test_suite_indices_, i, -1); - return index < 0 ? nullptr : test_suites_[static_cast<size_t>(i)]; - } - - // Legacy API is deprecated but still available -#ifndef GTEST_REMOVE_LEGACY_TEST_CASEAPI_ - const TestCase* GetTestCase(int i) const { return GetTestSuite(i); } -#endif // GTEST_REMOVE_LEGACY_TEST_CASEAPI_ - - // Gets the i-th test suite among all the test suites. i can range from 0 to - // total_test_suite_count() - 1. If i is not in that range, returns NULL. - TestSuite* GetMutableSuiteCase(int i) { - const int index = GetElementOr(test_suite_indices_, i, -1); - return index < 0 ? nullptr : test_suites_[static_cast<size_t>(index)]; - } - - // Provides access to the event listener list. - TestEventListeners* listeners() { return &listeners_; } - - // Returns the TestResult for the test that's currently running, or - // the TestResult for the ad hoc test if no test is running. - TestResult* current_test_result(); - - // Returns the TestResult for the ad hoc test. - const TestResult* ad_hoc_test_result() const { return &ad_hoc_test_result_; } - - // Sets the OS stack trace getter. - // - // Does nothing if the input and the current OS stack trace getter - // are the same; otherwise, deletes the old getter and makes the - // input the current getter. - void set_os_stack_trace_getter(OsStackTraceGetterInterface* getter); - - // Returns the current OS stack trace getter if it is not NULL; - // otherwise, creates an OsStackTraceGetter, makes it the current - // getter, and returns it. - OsStackTraceGetterInterface* os_stack_trace_getter(); - - // Returns the current OS stack trace as an std::string. - // - // The maximum number of stack frames to be included is specified by - // the gtest_stack_trace_depth flag. The skip_count parameter - // specifies the number of top frames to be skipped, which doesn't - // count against the number of frames to be included. - // - // For example, if Foo() calls Bar(), which in turn calls - // CurrentOsStackTraceExceptTop(1), Foo() will be included in the - // trace but Bar() and CurrentOsStackTraceExceptTop() won't. - std::string CurrentOsStackTraceExceptTop(int skip_count) GTEST_NO_INLINE_; - - // Finds and returns a TestSuite with the given name. If one doesn't - // exist, creates one and returns it. - // - // Arguments: - // - // test_suite_name: name of the test suite - // type_param: the name of the test's type parameter, or NULL if - // this is not a typed or a type-parameterized test. - // set_up_tc: pointer to the function that sets up the test suite - // tear_down_tc: pointer to the function that tears down the test suite - TestSuite* GetTestSuite(const char* test_suite_name, const char* type_param, - internal::SetUpTestSuiteFunc set_up_tc, - internal::TearDownTestSuiteFunc tear_down_tc); - -// Legacy API is deprecated but still available -#ifndef GTEST_REMOVE_LEGACY_TEST_CASEAPI_ - TestCase* GetTestCase(const char* test_case_name, const char* type_param, - internal::SetUpTestSuiteFunc set_up_tc, - internal::TearDownTestSuiteFunc tear_down_tc) { - return GetTestSuite(test_case_name, type_param, set_up_tc, tear_down_tc); - } -#endif // GTEST_REMOVE_LEGACY_TEST_CASEAPI_ - - // Adds a TestInfo to the unit test. - // - // Arguments: - // - // set_up_tc: pointer to the function that sets up the test suite - // tear_down_tc: pointer to the function that tears down the test suite - // test_info: the TestInfo object - void AddTestInfo(internal::SetUpTestSuiteFunc set_up_tc, - internal::TearDownTestSuiteFunc tear_down_tc, - TestInfo* test_info) { -#if GTEST_HAS_DEATH_TEST - // In order to support thread-safe death tests, we need to - // remember the original working directory when the test program - // was first invoked. We cannot do this in RUN_ALL_TESTS(), as - // the user may have changed the current directory before calling - // RUN_ALL_TESTS(). Therefore we capture the current directory in - // AddTestInfo(), which is called to register a TEST or TEST_F - // before main() is reached. - if (original_working_dir_.IsEmpty()) { - original_working_dir_.Set(FilePath::GetCurrentDir()); - GTEST_CHECK_(!original_working_dir_.IsEmpty()) - << "Failed to get the current working directory."; - } -#endif // GTEST_HAS_DEATH_TEST - - GetTestSuite(test_info->test_suite_name(), test_info->type_param(), - set_up_tc, tear_down_tc) - ->AddTestInfo(test_info); - } - - // Returns ParameterizedTestSuiteRegistry object used to keep track of - // value-parameterized tests and instantiate and register them. - internal::ParameterizedTestSuiteRegistry& parameterized_test_registry() { - return parameterized_test_registry_; - } - - std::set<std::string>* ignored_parameterized_test_suites() { - return &ignored_parameterized_test_suites_; - } - - // Returns TypeParameterizedTestSuiteRegistry object used to keep track of - // type-parameterized tests and instantiations of them. - internal::TypeParameterizedTestSuiteRegistry& - type_parameterized_test_registry() { - return type_parameterized_test_registry_; - } - - // Sets the TestSuite object for the test that's currently running. - void set_current_test_suite(TestSuite* a_current_test_suite) { - current_test_suite_ = a_current_test_suite; - } - - // Sets the TestInfo object for the test that's currently running. If - // current_test_info is NULL, the assertion results will be stored in - // ad_hoc_test_result_. - void set_current_test_info(TestInfo* a_current_test_info) { - current_test_info_ = a_current_test_info; - } - - // Registers all parameterized tests defined using TEST_P and - // INSTANTIATE_TEST_SUITE_P, creating regular tests for each test/parameter - // combination. This method can be called more then once; it has guards - // protecting from registering the tests more then once. If - // value-parameterized tests are disabled, RegisterParameterizedTests is - // present but does nothing. - void RegisterParameterizedTests(); - - // Runs all tests in this UnitTest object, prints the result, and - // returns true if all tests are successful. If any exception is - // thrown during a test, this test is considered to be failed, but - // the rest of the tests will still be run. - bool RunAllTests(); - - // Clears the results of all tests, except the ad hoc tests. - void ClearNonAdHocTestResult() { - ForEach(test_suites_, TestSuite::ClearTestSuiteResult); - } - - // Clears the results of ad-hoc test assertions. - void ClearAdHocTestResult() { - ad_hoc_test_result_.Clear(); - } - - // Adds a TestProperty to the current TestResult object when invoked in a - // context of a test or a test suite, or to the global property set. If the - // result already contains a property with the same key, the value will be - // updated. - void RecordProperty(const TestProperty& test_property); - - enum ReactionToSharding { - HONOR_SHARDING_PROTOCOL, - IGNORE_SHARDING_PROTOCOL - }; - - // Matches the full name of each test against the user-specified - // filter to decide whether the test should run, then records the - // result in each TestSuite and TestInfo object. - // If shard_tests == HONOR_SHARDING_PROTOCOL, further filters tests - // based on sharding variables in the environment. - // Returns the number of tests that should run. - int FilterTests(ReactionToSharding shard_tests); - - // Prints the names of the tests matching the user-specified filter flag. - void ListTestsMatchingFilter(); - - const TestSuite* current_test_suite() const { return current_test_suite_; } - TestInfo* current_test_info() { return current_test_info_; } - const TestInfo* current_test_info() const { return current_test_info_; } - - // Returns the vector of environments that need to be set-up/torn-down - // before/after the tests are run. - std::vector<Environment*>& environments() { return environments_; } - - // Getters for the per-thread Google Test trace stack. - std::vector<TraceInfo>& gtest_trace_stack() { - return *(gtest_trace_stack_.pointer()); - } - const std::vector<TraceInfo>& gtest_trace_stack() const { - return gtest_trace_stack_.get(); - } - -#if GTEST_HAS_DEATH_TEST - void InitDeathTestSubprocessControlInfo() { - internal_run_death_test_flag_.reset(ParseInternalRunDeathTestFlag()); - } - // Returns a pointer to the parsed --gtest_internal_run_death_test - // flag, or NULL if that flag was not specified. - // This information is useful only in a death test child process. - // Must not be called before a call to InitGoogleTest. - const InternalRunDeathTestFlag* internal_run_death_test_flag() const { - return internal_run_death_test_flag_.get(); - } - - // Returns a pointer to the current death test factory. - internal::DeathTestFactory* death_test_factory() { - return death_test_factory_.get(); - } - - void SuppressTestEventsIfInSubprocess(); - - friend class ReplaceDeathTestFactory; -#endif // GTEST_HAS_DEATH_TEST - - // Initializes the event listener performing XML output as specified by - // UnitTestOptions. Must not be called before InitGoogleTest. - void ConfigureXmlOutput(); - -#if GTEST_CAN_STREAM_RESULTS_ - // Initializes the event listener for streaming test results to a socket. - // Must not be called before InitGoogleTest. - void ConfigureStreamingOutput(); -#endif - - // Performs initialization dependent upon flag values obtained in - // ParseGoogleTestFlagsOnly. Is called from InitGoogleTest after the call to - // ParseGoogleTestFlagsOnly. In case a user neglects to call InitGoogleTest - // this function is also called from RunAllTests. Since this function can be - // called more than once, it has to be idempotent. - void PostFlagParsingInit(); - - // Gets the random seed used at the start of the current test iteration. - int random_seed() const { return random_seed_; } - - // Gets the random number generator. - internal::Random* random() { return &random_; } - - // Shuffles all test suites, and the tests within each test suite, - // making sure that death tests are still run first. - void ShuffleTests(); - - // Restores the test suites and tests to their order before the first shuffle. - void UnshuffleTests(); - - // Returns the value of GTEST_FLAG(catch_exceptions) at the moment - // UnitTest::Run() starts. - bool catch_exceptions() const { return catch_exceptions_; } - - private: - friend class ::testing::UnitTest; - - // Used by UnitTest::Run() to capture the state of - // GTEST_FLAG(catch_exceptions) at the moment it starts. - void set_catch_exceptions(bool value) { catch_exceptions_ = value; } - - // The UnitTest object that owns this implementation object. - UnitTest* const parent_; - - // The working directory when the first TEST() or TEST_F() was - // executed. - internal::FilePath original_working_dir_; - - // The default test part result reporters. - DefaultGlobalTestPartResultReporter default_global_test_part_result_reporter_; - DefaultPerThreadTestPartResultReporter - default_per_thread_test_part_result_reporter_; - - // Points to (but doesn't own) the global test part result reporter. - TestPartResultReporterInterface* global_test_part_result_repoter_; - - // Protects read and write access to global_test_part_result_reporter_. - internal::Mutex global_test_part_result_reporter_mutex_; - - // Points to (but doesn't own) the per-thread test part result reporter. - internal::ThreadLocal<TestPartResultReporterInterface*> - per_thread_test_part_result_reporter_; - - // The vector of environments that need to be set-up/torn-down - // before/after the tests are run. - std::vector<Environment*> environments_; - - // The vector of TestSuites in their original order. It owns the - // elements in the vector. - std::vector<TestSuite*> test_suites_; - - // Provides a level of indirection for the test suite list to allow - // easy shuffling and restoring the test suite order. The i-th - // element of this vector is the index of the i-th test suite in the - // shuffled order. - std::vector<int> test_suite_indices_; - - // ParameterizedTestRegistry object used to register value-parameterized - // tests. - internal::ParameterizedTestSuiteRegistry parameterized_test_registry_; - internal::TypeParameterizedTestSuiteRegistry - type_parameterized_test_registry_; - - // The set holding the name of parameterized - // test suites that may go uninstantiated. - std::set<std::string> ignored_parameterized_test_suites_; - - // Indicates whether RegisterParameterizedTests() has been called already. - bool parameterized_tests_registered_; - - // Index of the last death test suite registered. Initially -1. - int last_death_test_suite_; - - // This points to the TestSuite for the currently running test. It - // changes as Google Test goes through one test suite after another. - // When no test is running, this is set to NULL and Google Test - // stores assertion results in ad_hoc_test_result_. Initially NULL. - TestSuite* current_test_suite_; - - // This points to the TestInfo for the currently running test. It - // changes as Google Test goes through one test after another. When - // no test is running, this is set to NULL and Google Test stores - // assertion results in ad_hoc_test_result_. Initially NULL. - TestInfo* current_test_info_; - - // Normally, a user only writes assertions inside a TEST or TEST_F, - // or inside a function called by a TEST or TEST_F. Since Google - // Test keeps track of which test is current running, it can - // associate such an assertion with the test it belongs to. - // - // If an assertion is encountered when no TEST or TEST_F is running, - // Google Test attributes the assertion result to an imaginary "ad hoc" - // test, and records the result in ad_hoc_test_result_. - TestResult ad_hoc_test_result_; - - // The list of event listeners that can be used to track events inside - // Google Test. - TestEventListeners listeners_; - - // The OS stack trace getter. Will be deleted when the UnitTest - // object is destructed. By default, an OsStackTraceGetter is used, - // but the user can set this field to use a custom getter if that is - // desired. - OsStackTraceGetterInterface* os_stack_trace_getter_; - - // True if and only if PostFlagParsingInit() has been called. - bool post_flag_parse_init_performed_; - - // The random number seed used at the beginning of the test run. - int random_seed_; - - // Our random number generator. - internal::Random random_; - - // The time of the test program start, in ms from the start of the - // UNIX epoch. - TimeInMillis start_timestamp_; - - // How long the test took to run, in milliseconds. - TimeInMillis elapsed_time_; - -#if GTEST_HAS_DEATH_TEST - // The decomposed components of the gtest_internal_run_death_test flag, - // parsed when RUN_ALL_TESTS is called. - std::unique_ptr<InternalRunDeathTestFlag> internal_run_death_test_flag_; - std::unique_ptr<internal::DeathTestFactory> death_test_factory_; -#endif // GTEST_HAS_DEATH_TEST - - // A per-thread stack of traces created by the SCOPED_TRACE() macro. - internal::ThreadLocal<std::vector<TraceInfo> > gtest_trace_stack_; - - // The value of GTEST_FLAG(catch_exceptions) at the moment RunAllTests() - // starts. - bool catch_exceptions_; - - GTEST_DISALLOW_COPY_AND_ASSIGN_(UnitTestImpl); -}; // class UnitTestImpl - -// Convenience function for accessing the global UnitTest -// implementation object. -inline UnitTestImpl* GetUnitTestImpl() { - return UnitTest::GetInstance()->impl(); -} - -#if GTEST_USES_SIMPLE_RE - -// Internal helper functions for implementing the simple regular -// expression matcher. -GTEST_API_ bool IsInSet(char ch, const char* str); -GTEST_API_ bool IsAsciiDigit(char ch); -GTEST_API_ bool IsAsciiPunct(char ch); -GTEST_API_ bool IsRepeat(char ch); -GTEST_API_ bool IsAsciiWhiteSpace(char ch); -GTEST_API_ bool IsAsciiWordChar(char ch); -GTEST_API_ bool IsValidEscape(char ch); -GTEST_API_ bool AtomMatchesChar(bool escaped, char pattern, char ch); -GTEST_API_ bool ValidateRegex(const char* regex); -GTEST_API_ bool MatchRegexAtHead(const char* regex, const char* str); -GTEST_API_ bool MatchRepetitionAndRegexAtHead( - bool escaped, char ch, char repeat, const char* regex, const char* str); -GTEST_API_ bool MatchRegexAnywhere(const char* regex, const char* str); - -#endif // GTEST_USES_SIMPLE_RE - -// Parses the command line for Google Test flags, without initializing -// other parts of Google Test. -GTEST_API_ void ParseGoogleTestFlagsOnly(int* argc, char** argv); -GTEST_API_ void ParseGoogleTestFlagsOnly(int* argc, wchar_t** argv); - -#if GTEST_HAS_DEATH_TEST - -// Returns the message describing the last system error, regardless of the -// platform. -GTEST_API_ std::string GetLastErrnoDescription(); - -// Attempts to parse a string into a positive integer pointed to by the -// number parameter. Returns true if that is possible. -// GTEST_HAS_DEATH_TEST implies that we have ::std::string, so we can use -// it here. -template <typename Integer> -bool ParseNaturalNumber(const ::std::string& str, Integer* number) { - // Fail fast if the given string does not begin with a digit; - // this bypasses strtoXXX's "optional leading whitespace and plus - // or minus sign" semantics, which are undesirable here. - if (str.empty() || !IsDigit(str[0])) { - return false; - } - errno = 0; - - char* end; - // BiggestConvertible is the largest integer type that system-provided - // string-to-number conversion routines can return. - using BiggestConvertible = unsigned long long; // NOLINT - - const BiggestConvertible parsed = strtoull(str.c_str(), &end, 10); // NOLINT - const bool parse_success = *end == '\0' && errno == 0; - - GTEST_CHECK_(sizeof(Integer) <= sizeof(parsed)); - - const Integer result = static_cast<Integer>(parsed); - if (parse_success && static_cast<BiggestConvertible>(result) == parsed) { - *number = result; - return true; - } - return false; -} -#endif // GTEST_HAS_DEATH_TEST - -// TestResult contains some private methods that should be hidden from -// Google Test user but are required for testing. This class allow our tests -// to access them. -// -// This class is supplied only for the purpose of testing Google Test's own -// constructs. Do not use it in user tests, either directly or indirectly. -class TestResultAccessor { - public: - static void RecordProperty(TestResult* test_result, - const std::string& xml_element, - const TestProperty& property) { - test_result->RecordProperty(xml_element, property); - } - - static void ClearTestPartResults(TestResult* test_result) { - test_result->ClearTestPartResults(); - } - - static const std::vector<testing::TestPartResult>& test_part_results( - const TestResult& test_result) { - return test_result.test_part_results(); - } -}; - -#if GTEST_CAN_STREAM_RESULTS_ - -// Streams test results to the given port on the given host machine. -class StreamingListener : public EmptyTestEventListener { - public: - // Abstract base class for writing strings to a socket. - class AbstractSocketWriter { - public: - virtual ~AbstractSocketWriter() {} - - // Sends a string to the socket. - virtual void Send(const std::string& message) = 0; - - // Closes the socket. - virtual void CloseConnection() {} - - // Sends a string and a newline to the socket. - void SendLn(const std::string& message) { Send(message + "\n"); } - }; - - // Concrete class for actually writing strings to a socket. - class SocketWriter : public AbstractSocketWriter { - public: - SocketWriter(const std::string& host, const std::string& port) - : sockfd_(-1), host_name_(host), port_num_(port) { - MakeConnection(); - } - - ~SocketWriter() override { - if (sockfd_ != -1) - CloseConnection(); - } - - // Sends a string to the socket. - void Send(const std::string& message) override { - GTEST_CHECK_(sockfd_ != -1) - << "Send() can be called only when there is a connection."; - - const auto len = static_cast<size_t>(message.length()); - if (write(sockfd_, message.c_str(), len) != static_cast<ssize_t>(len)) { - GTEST_LOG_(WARNING) - << "stream_result_to: failed to stream to " - << host_name_ << ":" << port_num_; - } - } - - private: - // Creates a client socket and connects to the server. - void MakeConnection(); - - // Closes the socket. - void CloseConnection() override { - GTEST_CHECK_(sockfd_ != -1) - << "CloseConnection() can be called only when there is a connection."; - - close(sockfd_); - sockfd_ = -1; - } - - int sockfd_; // socket file descriptor - const std::string host_name_; - const std::string port_num_; - - GTEST_DISALLOW_COPY_AND_ASSIGN_(SocketWriter); - }; // class SocketWriter - - // Escapes '=', '&', '%', and '\n' characters in str as "%xx". - static std::string UrlEncode(const char* str); - - StreamingListener(const std::string& host, const std::string& port) - : socket_writer_(new SocketWriter(host, port)) { - Start(); - } - - explicit StreamingListener(AbstractSocketWriter* socket_writer) - : socket_writer_(socket_writer) { Start(); } - - void OnTestProgramStart(const UnitTest& /* unit_test */) override { - SendLn("event=TestProgramStart"); - } - - void OnTestProgramEnd(const UnitTest& unit_test) override { - // Note that Google Test current only report elapsed time for each - // test iteration, not for the entire test program. - SendLn("event=TestProgramEnd&passed=" + FormatBool(unit_test.Passed())); - - // Notify the streaming server to stop. - socket_writer_->CloseConnection(); - } - - void OnTestIterationStart(const UnitTest& /* unit_test */, - int iteration) override { - SendLn("event=TestIterationStart&iteration=" + - StreamableToString(iteration)); - } - - void OnTestIterationEnd(const UnitTest& unit_test, - int /* iteration */) override { - SendLn("event=TestIterationEnd&passed=" + - FormatBool(unit_test.Passed()) + "&elapsed_time=" + - StreamableToString(unit_test.elapsed_time()) + "ms"); - } - - // Note that "event=TestCaseStart" is a wire format and has to remain - // "case" for compatibility - void OnTestCaseStart(const TestCase& test_case) override { - SendLn(std::string("event=TestCaseStart&name=") + test_case.name()); - } - - // Note that "event=TestCaseEnd" is a wire format and has to remain - // "case" for compatibility - void OnTestCaseEnd(const TestCase& test_case) override { - SendLn("event=TestCaseEnd&passed=" + FormatBool(test_case.Passed()) + - "&elapsed_time=" + StreamableToString(test_case.elapsed_time()) + - "ms"); - } - - void OnTestStart(const TestInfo& test_info) override { - SendLn(std::string("event=TestStart&name=") + test_info.name()); - } - - void OnTestEnd(const TestInfo& test_info) override { - SendLn("event=TestEnd&passed=" + - FormatBool((test_info.result())->Passed()) + - "&elapsed_time=" + - StreamableToString((test_info.result())->elapsed_time()) + "ms"); - } - - void OnTestPartResult(const TestPartResult& test_part_result) override { - const char* file_name = test_part_result.file_name(); - if (file_name == nullptr) file_name = ""; - SendLn("event=TestPartResult&file=" + UrlEncode(file_name) + - "&line=" + StreamableToString(test_part_result.line_number()) + - "&message=" + UrlEncode(test_part_result.message())); - } - - private: - // Sends the given message and a newline to the socket. - void SendLn(const std::string& message) { socket_writer_->SendLn(message); } - - // Called at the start of streaming to notify the receiver what - // protocol we are using. - void Start() { SendLn("gtest_streaming_protocol_version=1.0"); } - - std::string FormatBool(bool value) { return value ? "1" : "0"; } - - const std::unique_ptr<AbstractSocketWriter> socket_writer_; - - GTEST_DISALLOW_COPY_AND_ASSIGN_(StreamingListener); -}; // class StreamingListener - -#endif // GTEST_CAN_STREAM_RESULTS_ - -} // namespace internal -} // namespace testing - -GTEST_DISABLE_MSC_WARNINGS_POP_() // 4251 - -#endif // GOOGLETEST_SRC_GTEST_INTERNAL_INL_H_ - -#if GTEST_OS_WINDOWS -# define vsnprintf _vsnprintf -#endif // GTEST_OS_WINDOWS - -#if GTEST_OS_MAC -#ifndef GTEST_OS_IOS -#include <crt_externs.h> -#endif -#endif - -#if GTEST_HAS_ABSL -#include "absl/debugging/failure_signal_handler.h" -#include "absl/debugging/stacktrace.h" -#include "absl/debugging/symbolize.h" -#include "absl/strings/str_cat.h" -#endif // GTEST_HAS_ABSL - -namespace testing { - -using internal::CountIf; -using internal::ForEach; -using internal::GetElementOr; -using internal::Shuffle; - -// Constants. - -// A test whose test suite name or test name matches this filter is -// disabled and not run. -static const char kDisableTestFilter[] = "DISABLED_*:*/DISABLED_*"; - -// A test suite whose name matches this filter is considered a death -// test suite and will be run before test suites whose name doesn't -// match this filter. -static const char kDeathTestSuiteFilter[] = "*DeathTest:*DeathTest/*"; - -// A test filter that matches everything. -static const char kUniversalFilter[] = "*"; - -// The default output format. -static const char kDefaultOutputFormat[] = "xml"; -// The default output file. -static const char kDefaultOutputFile[] = "test_detail"; - -// The environment variable name for the test shard index. -static const char kTestShardIndex[] = "GTEST_SHARD_INDEX"; -// The environment variable name for the total number of test shards. -static const char kTestTotalShards[] = "GTEST_TOTAL_SHARDS"; -// The environment variable name for the test shard status file. -static const char kTestShardStatusFile[] = "GTEST_SHARD_STATUS_FILE"; - -namespace internal { - -// The text used in failure messages to indicate the start of the -// stack trace. -const char kStackTraceMarker[] = "\nStack trace:\n"; - -// g_help_flag is true if and only if the --help flag or an equivalent form -// is specified on the command line. -bool g_help_flag = false; - -// Utilty function to Open File for Writing -static FILE* OpenFileForWriting(const std::string& output_file) { - FILE* fileout = nullptr; - FilePath output_file_path(output_file); - FilePath output_dir(output_file_path.RemoveFileName()); - - if (output_dir.CreateDirectoriesRecursively()) { - fileout = posix::FOpen(output_file.c_str(), "w"); - } - if (fileout == nullptr) { - GTEST_LOG_(FATAL) << "Unable to open file \"" << output_file << "\""; - } - return fileout; -} - -} // namespace internal - -// Bazel passes in the argument to '--test_filter' via the TESTBRIDGE_TEST_ONLY -// environment variable. -static const char* GetDefaultFilter() { - const char* const testbridge_test_only = - internal::posix::GetEnv("TESTBRIDGE_TEST_ONLY"); - if (testbridge_test_only != nullptr) { - return testbridge_test_only; - } - return kUniversalFilter; -} - -// Bazel passes in the argument to '--test_runner_fail_fast' via the -// TESTBRIDGE_TEST_RUNNER_FAIL_FAST environment variable. -static bool GetDefaultFailFast() { - const char* const testbridge_test_runner_fail_fast = - internal::posix::GetEnv("TESTBRIDGE_TEST_RUNNER_FAIL_FAST"); - if (testbridge_test_runner_fail_fast != nullptr) { - return strcmp(testbridge_test_runner_fail_fast, "1") == 0; - } - return false; -} - -GTEST_DEFINE_bool_( - fail_fast, internal::BoolFromGTestEnv("fail_fast", GetDefaultFailFast()), - "True if and only if a test failure should stop further test execution."); - -GTEST_DEFINE_bool_( - also_run_disabled_tests, - internal::BoolFromGTestEnv("also_run_disabled_tests", false), - "Run disabled tests too, in addition to the tests normally being run."); - -GTEST_DEFINE_bool_( - break_on_failure, internal::BoolFromGTestEnv("break_on_failure", false), - "True if and only if a failed assertion should be a debugger " - "break-point."); - -GTEST_DEFINE_bool_(catch_exceptions, - internal::BoolFromGTestEnv("catch_exceptions", true), - "True if and only if " GTEST_NAME_ - " should catch exceptions and treat them as test failures."); - -GTEST_DEFINE_string_( - color, - internal::StringFromGTestEnv("color", "auto"), - "Whether to use colors in the output. Valid values: yes, no, " - "and auto. 'auto' means to use colors if the output is " - "being sent to a terminal and the TERM environment variable " - "is set to a terminal type that supports colors."); - -GTEST_DEFINE_string_( - filter, - internal::StringFromGTestEnv("filter", GetDefaultFilter()), - "A colon-separated list of glob (not regex) patterns " - "for filtering the tests to run, optionally followed by a " - "'-' and a : separated list of negative patterns (tests to " - "exclude). A test is run if it matches one of the positive " - "patterns and does not match any of the negative patterns."); - -GTEST_DEFINE_bool_( - install_failure_signal_handler, - internal::BoolFromGTestEnv("install_failure_signal_handler", false), - "If true and supported on the current platform, " GTEST_NAME_ " should " - "install a signal handler that dumps debugging information when fatal " - "signals are raised."); - -GTEST_DEFINE_bool_(list_tests, false, - "List all tests without running them."); - -// The net priority order after flag processing is thus: -// --gtest_output command line flag -// GTEST_OUTPUT environment variable -// XML_OUTPUT_FILE environment variable -// '' -GTEST_DEFINE_string_( - output, - internal::StringFromGTestEnv("output", - internal::OutputFlagAlsoCheckEnvVar().c_str()), - "A format (defaults to \"xml\" but can be specified to be \"json\"), " - "optionally followed by a colon and an output file name or directory. " - "A directory is indicated by a trailing pathname separator. " - "Examples: \"xml:filename.xml\", \"xml::directoryname/\". " - "If a directory is specified, output files will be created " - "within that directory, with file-names based on the test " - "executable's name and, if necessary, made unique by adding " - "digits."); - -GTEST_DEFINE_bool_( - brief, internal::BoolFromGTestEnv("brief", false), - "True if only test failures should be displayed in text output."); - -GTEST_DEFINE_bool_(print_time, internal::BoolFromGTestEnv("print_time", true), - "True if and only if " GTEST_NAME_ - " should display elapsed time in text output."); - -GTEST_DEFINE_bool_(print_utf8, internal::BoolFromGTestEnv("print_utf8", true), - "True if and only if " GTEST_NAME_ - " prints UTF8 characters as text."); - -GTEST_DEFINE_int32_( - random_seed, - internal::Int32FromGTestEnv("random_seed", 0), - "Random number seed to use when shuffling test orders. Must be in range " - "[1, 99999], or 0 to use a seed based on the current time."); - -GTEST_DEFINE_int32_( - repeat, - internal::Int32FromGTestEnv("repeat", 1), - "How many times to repeat each test. Specify a negative number " - "for repeating forever. Useful for shaking out flaky tests."); - -GTEST_DEFINE_bool_(show_internal_stack_frames, false, - "True if and only if " GTEST_NAME_ - " should include internal stack frames when " - "printing test failure stack traces."); - -GTEST_DEFINE_bool_(shuffle, internal::BoolFromGTestEnv("shuffle", false), - "True if and only if " GTEST_NAME_ - " should randomize tests' order on every run."); - -GTEST_DEFINE_int32_( - stack_trace_depth, - internal::Int32FromGTestEnv("stack_trace_depth", kMaxStackTraceDepth), - "The maximum number of stack frames to print when an " - "assertion fails. The valid range is 0 through 100, inclusive."); - -GTEST_DEFINE_string_( - stream_result_to, - internal::StringFromGTestEnv("stream_result_to", ""), - "This flag specifies the host name and the port number on which to stream " - "test results. Example: \"localhost:555\". The flag is effective only on " - "Linux."); - -GTEST_DEFINE_bool_( - throw_on_failure, - internal::BoolFromGTestEnv("throw_on_failure", false), - "When this flag is specified, a failed assertion will throw an exception " - "if exceptions are enabled or exit the program with a non-zero code " - "otherwise. For use with an external test framework."); - -#if GTEST_USE_OWN_FLAGFILE_FLAG_ -GTEST_DEFINE_string_( - flagfile, - internal::StringFromGTestEnv("flagfile", ""), - "This flag specifies the flagfile to read command-line flags from."); -#endif // GTEST_USE_OWN_FLAGFILE_FLAG_ - -namespace internal { - -// Generates a random number from [0, range), using a Linear -// Congruential Generator (LCG). Crashes if 'range' is 0 or greater -// than kMaxRange. -uint32_t Random::Generate(uint32_t range) { - // These constants are the same as are used in glibc's rand(3). - // Use wider types than necessary to prevent unsigned overflow diagnostics. - state_ = static_cast<uint32_t>(1103515245ULL*state_ + 12345U) % kMaxRange; - - GTEST_CHECK_(range > 0) - << "Cannot generate a number in the range [0, 0)."; - GTEST_CHECK_(range <= kMaxRange) - << "Generation of a number in [0, " << range << ") was requested, " - << "but this can only generate numbers in [0, " << kMaxRange << ")."; - - // Converting via modulus introduces a bit of downward bias, but - // it's simple, and a linear congruential generator isn't too good - // to begin with. - return state_ % range; -} - -// GTestIsInitialized() returns true if and only if the user has initialized -// Google Test. Useful for catching the user mistake of not initializing -// Google Test before calling RUN_ALL_TESTS(). -static bool GTestIsInitialized() { return GetArgvs().size() > 0; } - -// Iterates over a vector of TestSuites, keeping a running sum of the -// results of calling a given int-returning method on each. -// Returns the sum. -static int SumOverTestSuiteList(const std::vector<TestSuite*>& case_list, - int (TestSuite::*method)() const) { - int sum = 0; - for (size_t i = 0; i < case_list.size(); i++) { - sum += (case_list[i]->*method)(); - } - return sum; -} - -// Returns true if and only if the test suite passed. -static bool TestSuitePassed(const TestSuite* test_suite) { - return test_suite->should_run() && test_suite->Passed(); -} - -// Returns true if and only if the test suite failed. -static bool TestSuiteFailed(const TestSuite* test_suite) { - return test_suite->should_run() && test_suite->Failed(); -} - -// Returns true if and only if test_suite contains at least one test that -// should run. -static bool ShouldRunTestSuite(const TestSuite* test_suite) { - return test_suite->should_run(); -} - -// AssertHelper constructor. -AssertHelper::AssertHelper(TestPartResult::Type type, - const char* file, - int line, - const char* message) - : data_(new AssertHelperData(type, file, line, message)) { -} - -AssertHelper::~AssertHelper() { - delete data_; -} - -// Message assignment, for assertion streaming support. -void AssertHelper::operator=(const Message& message) const { - UnitTest::GetInstance()-> - AddTestPartResult(data_->type, data_->file, data_->line, - AppendUserMessage(data_->message, message), - UnitTest::GetInstance()->impl() - ->CurrentOsStackTraceExceptTop(1) - // Skips the stack frame for this function itself. - ); // NOLINT -} - -namespace { - -// When TEST_P is found without a matching INSTANTIATE_TEST_SUITE_P -// to creates test cases for it, a synthetic test case is -// inserted to report ether an error or a log message. -// -// This configuration bit will likely be removed at some point. -constexpr bool kErrorOnUninstantiatedParameterizedTest = true; -constexpr bool kErrorOnUninstantiatedTypeParameterizedTest = true; - -// A test that fails at a given file/line location with a given message. -class FailureTest : public Test { - public: - explicit FailureTest(const CodeLocation& loc, std::string error_message, - bool as_error) - : loc_(loc), - error_message_(std::move(error_message)), - as_error_(as_error) {} - - void TestBody() override { - if (as_error_) { - AssertHelper(TestPartResult::kNonFatalFailure, loc_.file.c_str(), - loc_.line, "") = Message() << error_message_; - } else { - std::cout << error_message_ << std::endl; - } - } - - private: - const CodeLocation loc_; - const std::string error_message_; - const bool as_error_; -}; - - -} // namespace - -std::set<std::string>* GetIgnoredParameterizedTestSuites() { - return UnitTest::GetInstance()->impl()->ignored_parameterized_test_suites(); -} - -// Add a given test_suit to the list of them allow to go un-instantiated. -MarkAsIgnored::MarkAsIgnored(const char* test_suite) { - GetIgnoredParameterizedTestSuites()->insert(test_suite); -} - -// If this parameterized test suite has no instantiations (and that -// has not been marked as okay), emit a test case reporting that. -void InsertSyntheticTestCase(const std::string& name, CodeLocation location, - bool has_test_p) { - const auto& ignored = *GetIgnoredParameterizedTestSuites(); - if (ignored.find(name) != ignored.end()) return; - - const char kMissingInstantiation[] = // - " is defined via TEST_P, but never instantiated. None of the test cases " - "will run. Either no INSTANTIATE_TEST_SUITE_P is provided or the only " - "ones provided expand to nothing." - "\n\n" - "Ideally, TEST_P definitions should only ever be included as part of " - "binaries that intend to use them. (As opposed to, for example, being " - "placed in a library that may be linked in to get other utilities.)"; - - const char kMissingTestCase[] = // - " is instantiated via INSTANTIATE_TEST_SUITE_P, but no tests are " - "defined via TEST_P . No test cases will run." - "\n\n" - "Ideally, INSTANTIATE_TEST_SUITE_P should only ever be invoked from " - "code that always depend on code that provides TEST_P. Failing to do " - "so is often an indication of dead code, e.g. the last TEST_P was " - "removed but the rest got left behind."; - - std::string message = - "Parameterized test suite " + name + - (has_test_p ? kMissingInstantiation : kMissingTestCase) + - "\n\n" - "To suppress this error for this test suite, insert the following line " - "(in a non-header) in the namespace it is defined in:" - "\n\n" - "GTEST_ALLOW_UNINSTANTIATED_PARAMETERIZED_TEST(" + name + ");"; - - std::string full_name = "UninstantiatedParameterizedTestSuite<" + name + ">"; - RegisterTest( // - "GoogleTestVerification", full_name.c_str(), - nullptr, // No type parameter. - nullptr, // No value parameter. - location.file.c_str(), location.line, [message, location] { - return new FailureTest(location, message, - kErrorOnUninstantiatedParameterizedTest); - }); -} - -void RegisterTypeParameterizedTestSuite(const char* test_suite_name, - CodeLocation code_location) { - GetUnitTestImpl()->type_parameterized_test_registry().RegisterTestSuite( - test_suite_name, code_location); -} - -void RegisterTypeParameterizedTestSuiteInstantiation(const char* case_name) { - GetUnitTestImpl() - ->type_parameterized_test_registry() - .RegisterInstantiation(case_name); -} - -void TypeParameterizedTestSuiteRegistry::RegisterTestSuite( - const char* test_suite_name, CodeLocation code_location) { - suites_.emplace(std::string(test_suite_name), - TypeParameterizedTestSuiteInfo(code_location)); -} - -void TypeParameterizedTestSuiteRegistry::RegisterInstantiation( - const char* test_suite_name) { - auto it = suites_.find(std::string(test_suite_name)); - if (it != suites_.end()) { - it->second.instantiated = true; - } else { - GTEST_LOG_(ERROR) << "Unknown type parameterized test suit '" - << test_suite_name << "'"; - } -} - -void TypeParameterizedTestSuiteRegistry::CheckForInstantiations() { - const auto& ignored = *GetIgnoredParameterizedTestSuites(); - for (const auto& testcase : suites_) { - if (testcase.second.instantiated) continue; - if (ignored.find(testcase.first) != ignored.end()) continue; - - std::string message = - "Type parameterized test suite " + testcase.first + - " is defined via REGISTER_TYPED_TEST_SUITE_P, but never instantiated " - "via INSTANTIATE_TYPED_TEST_SUITE_P. None of the test cases will run." - "\n\n" - "Ideally, TYPED_TEST_P definitions should only ever be included as " - "part of binaries that intend to use them. (As opposed to, for " - "example, being placed in a library that may be linked in to get other " - "utilities.)" - "\n\n" - "To suppress this error for this test suite, insert the following line " - "(in a non-header) in the namespace it is defined in:" - "\n\n" - "GTEST_ALLOW_UNINSTANTIATED_PARAMETERIZED_TEST(" + - testcase.first + ");"; - - std::string full_name = - "UninstantiatedTypeParameterizedTestSuite<" + testcase.first + ">"; - RegisterTest( // - "GoogleTestVerification", full_name.c_str(), - nullptr, // No type parameter. - nullptr, // No value parameter. - testcase.second.code_location.file.c_str(), - testcase.second.code_location.line, [message, testcase] { - return new FailureTest(testcase.second.code_location, message, - kErrorOnUninstantiatedTypeParameterizedTest); - }); - } -} - -// A copy of all command line arguments. Set by InitGoogleTest(). -static ::std::vector<std::string> g_argvs; - -::std::vector<std::string> GetArgvs() { -#if defined(GTEST_CUSTOM_GET_ARGVS_) - // GTEST_CUSTOM_GET_ARGVS_() may return a container of std::string or - // ::string. This code converts it to the appropriate type. - const auto& custom = GTEST_CUSTOM_GET_ARGVS_(); - return ::std::vector<std::string>(custom.begin(), custom.end()); -#else // defined(GTEST_CUSTOM_GET_ARGVS_) - return g_argvs; -#endif // defined(GTEST_CUSTOM_GET_ARGVS_) -} - -// Returns the current application's name, removing directory path if that -// is present. -FilePath GetCurrentExecutableName() { - FilePath result; - -#if GTEST_OS_WINDOWS || GTEST_OS_OS2 - result.Set(FilePath(GetArgvs()[0]).RemoveExtension("exe")); -#else - result.Set(FilePath(GetArgvs()[0])); -#endif // GTEST_OS_WINDOWS - - return result.RemoveDirectoryName(); -} - -// Functions for processing the gtest_output flag. - -// Returns the output format, or "" for normal printed output. -std::string UnitTestOptions::GetOutputFormat() { - const char* const gtest_output_flag = GTEST_FLAG(output).c_str(); - const char* const colon = strchr(gtest_output_flag, ':'); - return (colon == nullptr) - ? std::string(gtest_output_flag) - : std::string(gtest_output_flag, - static_cast<size_t>(colon - gtest_output_flag)); -} - -// Returns the name of the requested output file, or the default if none -// was explicitly specified. -std::string UnitTestOptions::GetAbsolutePathToOutputFile() { - const char* const gtest_output_flag = GTEST_FLAG(output).c_str(); - - std::string format = GetOutputFormat(); - if (format.empty()) - format = std::string(kDefaultOutputFormat); - - const char* const colon = strchr(gtest_output_flag, ':'); - if (colon == nullptr) - return internal::FilePath::MakeFileName( - internal::FilePath( - UnitTest::GetInstance()->original_working_dir()), - internal::FilePath(kDefaultOutputFile), 0, - format.c_str()).string(); - - internal::FilePath output_name(colon + 1); - if (!output_name.IsAbsolutePath()) - output_name = internal::FilePath::ConcatPaths( - internal::FilePath(UnitTest::GetInstance()->original_working_dir()), - internal::FilePath(colon + 1)); - - if (!output_name.IsDirectory()) - return output_name.string(); - - internal::FilePath result(internal::FilePath::GenerateUniqueFileName( - output_name, internal::GetCurrentExecutableName(), - GetOutputFormat().c_str())); - return result.string(); -} - -// Returns true if and only if the wildcard pattern matches the string. Each -// pattern consists of regular characters, single-character wildcards (?), and -// multi-character wildcards (*). -// -// This function implements a linear-time string globbing algorithm based on -// https://research.swtch.com/glob. -static bool PatternMatchesString(const std::string& name_str, - const char* pattern, const char* pattern_end) { - const char* name = name_str.c_str(); - const char* const name_begin = name; - const char* const name_end = name + name_str.size(); - - const char* pattern_next = pattern; - const char* name_next = name; - - while (pattern < pattern_end || name < name_end) { - if (pattern < pattern_end) { - switch (*pattern) { - default: // Match an ordinary character. - if (name < name_end && *name == *pattern) { - ++pattern; - ++name; - continue; - } - break; - case '?': // Match any single character. - if (name < name_end) { - ++pattern; - ++name; - continue; - } - break; - case '*': - // Match zero or more characters. Start by skipping over the wildcard - // and matching zero characters from name. If that fails, restart and - // match one more character than the last attempt. - pattern_next = pattern; - name_next = name + 1; - ++pattern; - continue; - } - } - // Failed to match a character. Restart if possible. - if (name_begin < name_next && name_next <= name_end) { - pattern = pattern_next; - name = name_next; - continue; - } - return false; - } - return true; -} - -bool UnitTestOptions::MatchesFilter(const std::string& name_str, - const char* filter) { - // The filter is a list of patterns separated by colons (:). - const char* pattern = filter; - while (true) { - // Find the bounds of this pattern. - const char* const next_sep = strchr(pattern, ':'); - const char* const pattern_end = - next_sep != nullptr ? next_sep : pattern + strlen(pattern); - - // Check if this pattern matches name_str. - if (PatternMatchesString(name_str, pattern, pattern_end)) { - break; - } - - // Give up on this pattern. However, if we found a pattern separator (:), - // advance to the next pattern (skipping over the separator) and restart. - if (next_sep == nullptr) { - return false; - } - pattern = next_sep + 1; - } - return true; -} - -// Returns true if and only if the user-specified filter matches the test -// suite name and the test name. -bool UnitTestOptions::FilterMatchesTest(const std::string& test_suite_name, - const std::string& test_name) { - const std::string& full_name = test_suite_name + "." + test_name.c_str(); - - // Split --gtest_filter at '-', if there is one, to separate into - // positive filter and negative filter portions - const char* const p = GTEST_FLAG(filter).c_str(); - const char* const dash = strchr(p, '-'); - std::string positive; - std::string negative; - if (dash == nullptr) { - positive = GTEST_FLAG(filter).c_str(); // Whole string is a positive filter - negative = ""; - } else { - positive = std::string(p, dash); // Everything up to the dash - negative = std::string(dash + 1); // Everything after the dash - if (positive.empty()) { - // Treat '-test1' as the same as '*-test1' - positive = kUniversalFilter; - } - } - - // A filter is a colon-separated list of patterns. It matches a - // test if any pattern in it matches the test. - return (MatchesFilter(full_name, positive.c_str()) && - !MatchesFilter(full_name, negative.c_str())); -} - -#if GTEST_HAS_SEH -// Returns EXCEPTION_EXECUTE_HANDLER if Google Test should handle the -// given SEH exception, or EXCEPTION_CONTINUE_SEARCH otherwise. -// This function is useful as an __except condition. -int UnitTestOptions::GTestShouldProcessSEH(DWORD exception_code) { - // Google Test should handle a SEH exception if: - // 1. the user wants it to, AND - // 2. this is not a breakpoint exception, AND - // 3. this is not a C++ exception (VC++ implements them via SEH, - // apparently). - // - // SEH exception code for C++ exceptions. - // (see http://support.microsoft.com/kb/185294 for more information). - const DWORD kCxxExceptionCode = 0xe06d7363; - - bool should_handle = true; - - if (!GTEST_FLAG(catch_exceptions)) - should_handle = false; - else if (exception_code == EXCEPTION_BREAKPOINT) - should_handle = false; - else if (exception_code == kCxxExceptionCode) - should_handle = false; - - return should_handle ? EXCEPTION_EXECUTE_HANDLER : EXCEPTION_CONTINUE_SEARCH; -} -#endif // GTEST_HAS_SEH - -} // namespace internal - -// The c'tor sets this object as the test part result reporter used by -// Google Test. The 'result' parameter specifies where to report the -// results. Intercepts only failures from the current thread. -ScopedFakeTestPartResultReporter::ScopedFakeTestPartResultReporter( - TestPartResultArray* result) - : intercept_mode_(INTERCEPT_ONLY_CURRENT_THREAD), - result_(result) { - Init(); -} - -// The c'tor sets this object as the test part result reporter used by -// Google Test. The 'result' parameter specifies where to report the -// results. -ScopedFakeTestPartResultReporter::ScopedFakeTestPartResultReporter( - InterceptMode intercept_mode, TestPartResultArray* result) - : intercept_mode_(intercept_mode), - result_(result) { - Init(); -} - -void ScopedFakeTestPartResultReporter::Init() { - internal::UnitTestImpl* const impl = internal::GetUnitTestImpl(); - if (intercept_mode_ == INTERCEPT_ALL_THREADS) { - old_reporter_ = impl->GetGlobalTestPartResultReporter(); - impl->SetGlobalTestPartResultReporter(this); - } else { - old_reporter_ = impl->GetTestPartResultReporterForCurrentThread(); - impl->SetTestPartResultReporterForCurrentThread(this); - } -} - -// The d'tor restores the test part result reporter used by Google Test -// before. -ScopedFakeTestPartResultReporter::~ScopedFakeTestPartResultReporter() { - internal::UnitTestImpl* const impl = internal::GetUnitTestImpl(); - if (intercept_mode_ == INTERCEPT_ALL_THREADS) { - impl->SetGlobalTestPartResultReporter(old_reporter_); - } else { - impl->SetTestPartResultReporterForCurrentThread(old_reporter_); - } -} - -// Increments the test part result count and remembers the result. -// This method is from the TestPartResultReporterInterface interface. -void ScopedFakeTestPartResultReporter::ReportTestPartResult( - const TestPartResult& result) { - result_->Append(result); -} - -namespace internal { - -// Returns the type ID of ::testing::Test. We should always call this -// instead of GetTypeId< ::testing::Test>() to get the type ID of -// testing::Test. This is to work around a suspected linker bug when -// using Google Test as a framework on Mac OS X. The bug causes -// GetTypeId< ::testing::Test>() to return different values depending -// on whether the call is from the Google Test framework itself or -// from user test code. GetTestTypeId() is guaranteed to always -// return the same value, as it always calls GetTypeId<>() from the -// gtest.cc, which is within the Google Test framework. -TypeId GetTestTypeId() { - return GetTypeId<Test>(); -} - -// The value of GetTestTypeId() as seen from within the Google Test -// library. This is solely for testing GetTestTypeId(). -extern const TypeId kTestTypeIdInGoogleTest = GetTestTypeId(); - -// This predicate-formatter checks that 'results' contains a test part -// failure of the given type and that the failure message contains the -// given substring. -static AssertionResult HasOneFailure(const char* /* results_expr */, - const char* /* type_expr */, - const char* /* substr_expr */, - const TestPartResultArray& results, - TestPartResult::Type type, - const std::string& substr) { - const std::string expected(type == TestPartResult::kFatalFailure ? - "1 fatal failure" : - "1 non-fatal failure"); - Message msg; - if (results.size() != 1) { - msg << "Expected: " << expected << "\n" - << " Actual: " << results.size() << " failures"; - for (int i = 0; i < results.size(); i++) { - msg << "\n" << results.GetTestPartResult(i); - } - return AssertionFailure() << msg; - } - - const TestPartResult& r = results.GetTestPartResult(0); - if (r.type() != type) { - return AssertionFailure() << "Expected: " << expected << "\n" - << " Actual:\n" - << r; - } - - if (strstr(r.message(), substr.c_str()) == nullptr) { - return AssertionFailure() << "Expected: " << expected << " containing \"" - << substr << "\"\n" - << " Actual:\n" - << r; - } - - return AssertionSuccess(); -} - -// The constructor of SingleFailureChecker remembers where to look up -// test part results, what type of failure we expect, and what -// substring the failure message should contain. -SingleFailureChecker::SingleFailureChecker(const TestPartResultArray* results, - TestPartResult::Type type, - const std::string& substr) - : results_(results), type_(type), substr_(substr) {} - -// The destructor of SingleFailureChecker verifies that the given -// TestPartResultArray contains exactly one failure that has the given -// type and contains the given substring. If that's not the case, a -// non-fatal failure will be generated. -SingleFailureChecker::~SingleFailureChecker() { - EXPECT_PRED_FORMAT3(HasOneFailure, *results_, type_, substr_); -} - -DefaultGlobalTestPartResultReporter::DefaultGlobalTestPartResultReporter( - UnitTestImpl* unit_test) : unit_test_(unit_test) {} - -void DefaultGlobalTestPartResultReporter::ReportTestPartResult( - const TestPartResult& result) { - unit_test_->current_test_result()->AddTestPartResult(result); - unit_test_->listeners()->repeater()->OnTestPartResult(result); -} - -DefaultPerThreadTestPartResultReporter::DefaultPerThreadTestPartResultReporter( - UnitTestImpl* unit_test) : unit_test_(unit_test) {} - -void DefaultPerThreadTestPartResultReporter::ReportTestPartResult( - const TestPartResult& result) { - unit_test_->GetGlobalTestPartResultReporter()->ReportTestPartResult(result); -} - -// Returns the global test part result reporter. -TestPartResultReporterInterface* -UnitTestImpl::GetGlobalTestPartResultReporter() { - internal::MutexLock lock(&global_test_part_result_reporter_mutex_); - return global_test_part_result_repoter_; -} - -// Sets the global test part result reporter. -void UnitTestImpl::SetGlobalTestPartResultReporter( - TestPartResultReporterInterface* reporter) { - internal::MutexLock lock(&global_test_part_result_reporter_mutex_); - global_test_part_result_repoter_ = reporter; -} - -// Returns the test part result reporter for the current thread. -TestPartResultReporterInterface* -UnitTestImpl::GetTestPartResultReporterForCurrentThread() { - return per_thread_test_part_result_reporter_.get(); -} - -// Sets the test part result reporter for the current thread. -void UnitTestImpl::SetTestPartResultReporterForCurrentThread( - TestPartResultReporterInterface* reporter) { - per_thread_test_part_result_reporter_.set(reporter); -} - -// Gets the number of successful test suites. -int UnitTestImpl::successful_test_suite_count() const { - return CountIf(test_suites_, TestSuitePassed); -} - -// Gets the number of failed test suites. -int UnitTestImpl::failed_test_suite_count() const { - return CountIf(test_suites_, TestSuiteFailed); -} - -// Gets the number of all test suites. -int UnitTestImpl::total_test_suite_count() const { - return static_cast<int>(test_suites_.size()); -} - -// Gets the number of all test suites that contain at least one test -// that should run. -int UnitTestImpl::test_suite_to_run_count() const { - return CountIf(test_suites_, ShouldRunTestSuite); -} - -// Gets the number of successful tests. -int UnitTestImpl::successful_test_count() const { - return SumOverTestSuiteList(test_suites_, &TestSuite::successful_test_count); -} - -// Gets the number of skipped tests. -int UnitTestImpl::skipped_test_count() const { - return SumOverTestSuiteList(test_suites_, &TestSuite::skipped_test_count); -} - -// Gets the number of failed tests. -int UnitTestImpl::failed_test_count() const { - return SumOverTestSuiteList(test_suites_, &TestSuite::failed_test_count); -} - -// Gets the number of disabled tests that will be reported in the XML report. -int UnitTestImpl::reportable_disabled_test_count() const { - return SumOverTestSuiteList(test_suites_, - &TestSuite::reportable_disabled_test_count); -} - -// Gets the number of disabled tests. -int UnitTestImpl::disabled_test_count() const { - return SumOverTestSuiteList(test_suites_, &TestSuite::disabled_test_count); -} - -// Gets the number of tests to be printed in the XML report. -int UnitTestImpl::reportable_test_count() const { - return SumOverTestSuiteList(test_suites_, &TestSuite::reportable_test_count); -} - -// Gets the number of all tests. -int UnitTestImpl::total_test_count() const { - return SumOverTestSuiteList(test_suites_, &TestSuite::total_test_count); -} - -// Gets the number of tests that should run. -int UnitTestImpl::test_to_run_count() const { - return SumOverTestSuiteList(test_suites_, &TestSuite::test_to_run_count); -} - -// Returns the current OS stack trace as an std::string. -// -// The maximum number of stack frames to be included is specified by -// the gtest_stack_trace_depth flag. The skip_count parameter -// specifies the number of top frames to be skipped, which doesn't -// count against the number of frames to be included. -// -// For example, if Foo() calls Bar(), which in turn calls -// CurrentOsStackTraceExceptTop(1), Foo() will be included in the -// trace but Bar() and CurrentOsStackTraceExceptTop() won't. -std::string UnitTestImpl::CurrentOsStackTraceExceptTop(int skip_count) { - return os_stack_trace_getter()->CurrentStackTrace( - static_cast<int>(GTEST_FLAG(stack_trace_depth)), - skip_count + 1 - // Skips the user-specified number of frames plus this function - // itself. - ); // NOLINT -} - -// A helper class for measuring elapsed times. -class Timer { - public: - Timer() : start_(std::chrono::steady_clock::now()) {} - - // Return time elapsed in milliseconds since the timer was created. - TimeInMillis Elapsed() { - return std::chrono::duration_cast<std::chrono::milliseconds>( - std::chrono::steady_clock::now() - start_) - .count(); - } - - private: - std::chrono::steady_clock::time_point start_; -}; - -// Returns a timestamp as milliseconds since the epoch. Note this time may jump -// around subject to adjustments by the system, to measure elapsed time use -// Timer instead. -TimeInMillis GetTimeInMillis() { - return std::chrono::duration_cast<std::chrono::milliseconds>( - std::chrono::system_clock::now() - - std::chrono::system_clock::from_time_t(0)) - .count(); -} - -// Utilities - -// class String. - -#if GTEST_OS_WINDOWS_MOBILE -// 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. -LPCWSTR String::AnsiToUtf16(const char* ansi) { - if (!ansi) return nullptr; - const int length = strlen(ansi); - const int unicode_length = - MultiByteToWideChar(CP_ACP, 0, ansi, length, nullptr, 0); - WCHAR* unicode = new WCHAR[unicode_length + 1]; - MultiByteToWideChar(CP_ACP, 0, ansi, length, - unicode, unicode_length); - unicode[unicode_length] = 0; - return unicode; -} - -// 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. -const char* String::Utf16ToAnsi(LPCWSTR utf16_str) { - if (!utf16_str) return nullptr; - const int ansi_length = WideCharToMultiByte(CP_ACP, 0, utf16_str, -1, nullptr, - 0, nullptr, nullptr); - char* ansi = new char[ansi_length + 1]; - WideCharToMultiByte(CP_ACP, 0, utf16_str, -1, ansi, ansi_length, nullptr, - nullptr); - ansi[ansi_length] = 0; - return ansi; -} - -#endif // GTEST_OS_WINDOWS_MOBILE - -// Compares two C strings. Returns true if and only if 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. -bool String::CStringEquals(const char * lhs, const char * rhs) { - if (lhs == nullptr) return rhs == nullptr; - - if (rhs == nullptr) return false; - - return strcmp(lhs, rhs) == 0; -} - -#if GTEST_HAS_STD_WSTRING - -// Converts an array of wide chars to a narrow string using the UTF-8 -// encoding, and streams the result to the given Message object. -static void StreamWideCharsToMessage(const wchar_t* wstr, size_t length, - Message* msg) { - for (size_t i = 0; i != length; ) { // NOLINT - if (wstr[i] != L'\0') { - *msg << WideStringToUtf8(wstr + i, static_cast<int>(length - i)); - while (i != length && wstr[i] != L'\0') - i++; - } else { - *msg << '\0'; - i++; - } - } -} - -#endif // GTEST_HAS_STD_WSTRING - -void SplitString(const ::std::string& str, char delimiter, - ::std::vector< ::std::string>* dest) { - ::std::vector< ::std::string> parsed; - ::std::string::size_type pos = 0; - while (::testing::internal::AlwaysTrue()) { - const ::std::string::size_type colon = str.find(delimiter, pos); - if (colon == ::std::string::npos) { - parsed.push_back(str.substr(pos)); - break; - } else { - parsed.push_back(str.substr(pos, colon - pos)); - pos = colon + 1; - } - } - dest->swap(parsed); -} - -} // namespace internal - -// 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::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); -} - -// These two overloads allow streaming a wide C string to a Message -// using the UTF-8 encoding. -Message& Message::operator <<(const wchar_t* wide_c_str) { - return *this << internal::String::ShowWideCString(wide_c_str); -} -Message& 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& Message::operator <<(const ::std::wstring& wstr) { - internal::StreamWideCharsToMessage(wstr.c_str(), wstr.length(), this); - return *this; -} -#endif // GTEST_HAS_STD_WSTRING - -// Gets the text streamed to this object so far as an std::string. -// Each '\0' character in the buffer is replaced with "\\0". -std::string Message::GetString() const { - return internal::StringStreamToString(ss_.get()); -} - -// AssertionResult constructors. -// Used in EXPECT_TRUE/FALSE(assertion_result). -AssertionResult::AssertionResult(const AssertionResult& other) - : success_(other.success_), - message_(other.message_.get() != nullptr - ? new ::std::string(*other.message_) - : static_cast< ::std::string*>(nullptr)) {} - -// Swaps two AssertionResults. -void AssertionResult::swap(AssertionResult& other) { - using std::swap; - swap(success_, other.success_); - swap(message_, other.message_); -} - -// Returns the assertion's negation. Used with EXPECT/ASSERT_FALSE. -AssertionResult AssertionResult::operator!() const { - AssertionResult negation(!success_); - if (message_.get() != nullptr) negation << *message_; - return negation; -} - -// Makes a successful assertion result. -AssertionResult AssertionSuccess() { - return AssertionResult(true); -} - -// Makes a failed assertion result. -AssertionResult AssertionFailure() { - return AssertionResult(false); -} - -// Makes a failed assertion result with the given failure message. -// Deprecated; use AssertionFailure() << message. -AssertionResult AssertionFailure(const Message& message) { - return AssertionFailure() << message; -} - -namespace internal { - -namespace edit_distance { -std::vector<EditType> CalculateOptimalEdits(const std::vector<size_t>& left, - const std::vector<size_t>& right) { - std::vector<std::vector<double> > costs( - left.size() + 1, std::vector<double>(right.size() + 1)); - std::vector<std::vector<EditType> > best_move( - left.size() + 1, std::vector<EditType>(right.size() + 1)); - - // Populate for empty right. - for (size_t l_i = 0; l_i < costs.size(); ++l_i) { - costs[l_i][0] = static_cast<double>(l_i); - best_move[l_i][0] = kRemove; - } - // Populate for empty left. - for (size_t r_i = 1; r_i < costs[0].size(); ++r_i) { - costs[0][r_i] = static_cast<double>(r_i); - best_move[0][r_i] = kAdd; - } - - for (size_t l_i = 0; l_i < left.size(); ++l_i) { - for (size_t r_i = 0; r_i < right.size(); ++r_i) { - if (left[l_i] == right[r_i]) { - // Found a match. Consume it. - costs[l_i + 1][r_i + 1] = costs[l_i][r_i]; - best_move[l_i + 1][r_i + 1] = kMatch; - continue; - } - - const double add = costs[l_i + 1][r_i]; - const double remove = costs[l_i][r_i + 1]; - const double replace = costs[l_i][r_i]; - if (add < remove && add < replace) { - costs[l_i + 1][r_i + 1] = add + 1; - best_move[l_i + 1][r_i + 1] = kAdd; - } else if (remove < add && remove < replace) { - costs[l_i + 1][r_i + 1] = remove + 1; - best_move[l_i + 1][r_i + 1] = kRemove; - } else { - // We make replace a little more expensive than add/remove to lower - // their priority. - costs[l_i + 1][r_i + 1] = replace + 1.00001; - best_move[l_i + 1][r_i + 1] = kReplace; - } - } - } - - // Reconstruct the best path. We do it in reverse order. - std::vector<EditType> best_path; - for (size_t l_i = left.size(), r_i = right.size(); l_i > 0 || r_i > 0;) { - EditType move = best_move[l_i][r_i]; - best_path.push_back(move); - l_i -= move != kAdd; - r_i -= move != kRemove; - } - std::reverse(best_path.begin(), best_path.end()); - return best_path; -} - -namespace { - -// Helper class to convert string into ids with deduplication. -class InternalStrings { - public: - size_t GetId(const std::string& str) { - IdMap::iterator it = ids_.find(str); - if (it != ids_.end()) return it->second; - size_t id = ids_.size(); - return ids_[str] = id; - } - - private: - typedef std::map<std::string, size_t> IdMap; - IdMap ids_; -}; - -} // namespace - -std::vector<EditType> CalculateOptimalEdits( - const std::vector<std::string>& left, - const std::vector<std::string>& right) { - std::vector<size_t> left_ids, right_ids; - { - InternalStrings intern_table; - for (size_t i = 0; i < left.size(); ++i) { - left_ids.push_back(intern_table.GetId(left[i])); - } - for (size_t i = 0; i < right.size(); ++i) { - right_ids.push_back(intern_table.GetId(right[i])); - } - } - return CalculateOptimalEdits(left_ids, right_ids); -} - -namespace { - -// Helper class that holds the state for one hunk and prints it out to the -// stream. -// It reorders adds/removes when possible to group all removes before all -// adds. It also adds the hunk header before printint into the stream. -class Hunk { - public: - Hunk(size_t left_start, size_t right_start) - : left_start_(left_start), - right_start_(right_start), - adds_(), - removes_(), - common_() {} - - void PushLine(char edit, const char* line) { - switch (edit) { - case ' ': - ++common_; - FlushEdits(); - hunk_.push_back(std::make_pair(' ', line)); - break; - case '-': - ++removes_; - hunk_removes_.push_back(std::make_pair('-', line)); - break; - case '+': - ++adds_; - hunk_adds_.push_back(std::make_pair('+', line)); - break; - } - } - - void PrintTo(std::ostream* os) { - PrintHeader(os); - FlushEdits(); - for (std::list<std::pair<char, const char*> >::const_iterator it = - hunk_.begin(); - it != hunk_.end(); ++it) { - *os << it->first << it->second << "\n"; - } - } - - bool has_edits() const { return adds_ || removes_; } - - private: - void FlushEdits() { - hunk_.splice(hunk_.end(), hunk_removes_); - hunk_.splice(hunk_.end(), hunk_adds_); - } - - // Print a unified diff header for one hunk. - // The format is - // "@@ -<left_start>,<left_length> +<right_start>,<right_length> @@" - // where the left/right parts are omitted if unnecessary. - void PrintHeader(std::ostream* ss) const { - *ss << "@@ "; - if (removes_) { - *ss << "-" << left_start_ << "," << (removes_ + common_); - } - if (removes_ && adds_) { - *ss << " "; - } - if (adds_) { - *ss << "+" << right_start_ << "," << (adds_ + common_); - } - *ss << " @@\n"; - } - - size_t left_start_, right_start_; - size_t adds_, removes_, common_; - std::list<std::pair<char, const char*> > hunk_, hunk_adds_, hunk_removes_; -}; - -} // namespace - -// Create a list of diff hunks in Unified diff format. -// Each hunk has a header generated by PrintHeader above plus a body with -// lines prefixed with ' ' for no change, '-' for deletion and '+' for -// addition. -// 'context' represents the desired unchanged prefix/suffix around the diff. -// If two hunks are close enough that their contexts overlap, then they are -// joined into one hunk. -std::string CreateUnifiedDiff(const std::vector<std::string>& left, - const std::vector<std::string>& right, - size_t context) { - const std::vector<EditType> edits = CalculateOptimalEdits(left, right); - - size_t l_i = 0, r_i = 0, edit_i = 0; - std::stringstream ss; - while (edit_i < edits.size()) { - // Find first edit. - while (edit_i < edits.size() && edits[edit_i] == kMatch) { - ++l_i; - ++r_i; - ++edit_i; - } - - // Find the first line to include in the hunk. - const size_t prefix_context = std::min(l_i, context); - Hunk hunk(l_i - prefix_context + 1, r_i - prefix_context + 1); - for (size_t i = prefix_context; i > 0; --i) { - hunk.PushLine(' ', left[l_i - i].c_str()); - } - - // Iterate the edits until we found enough suffix for the hunk or the input - // is over. - size_t n_suffix = 0; - for (; edit_i < edits.size(); ++edit_i) { - if (n_suffix >= context) { - // Continue only if the next hunk is very close. - auto it = edits.begin() + static_cast<int>(edit_i); - while (it != edits.end() && *it == kMatch) ++it; - if (it == edits.end() || - static_cast<size_t>(it - edits.begin()) - edit_i >= context) { - // There is no next edit or it is too far away. - break; - } - } - - EditType edit = edits[edit_i]; - // Reset count when a non match is found. - n_suffix = edit == kMatch ? n_suffix + 1 : 0; - - if (edit == kMatch || edit == kRemove || edit == kReplace) { - hunk.PushLine(edit == kMatch ? ' ' : '-', left[l_i].c_str()); - } - if (edit == kAdd || edit == kReplace) { - hunk.PushLine('+', right[r_i].c_str()); - } - - // Advance indices, depending on edit type. - l_i += edit != kAdd; - r_i += edit != kRemove; - } - - if (!hunk.has_edits()) { - // We are done. We don't want this hunk. - break; - } - - hunk.PrintTo(&ss); - } - return ss.str(); -} - -} // namespace edit_distance - -namespace { - -// The string representation of the values received in EqFailure() are already -// escaped. Split them on escaped '\n' boundaries. Leave all other escaped -// characters the same. -std::vector<std::string> SplitEscapedString(const std::string& str) { - std::vector<std::string> lines; - size_t start = 0, end = str.size(); - if (end > 2 && str[0] == '"' && str[end - 1] == '"') { - ++start; - --end; - } - bool escaped = false; - for (size_t i = start; i + 1 < end; ++i) { - if (escaped) { - escaped = false; - if (str[i] == 'n') { - lines.push_back(str.substr(start, i - start - 1)); - start = i + 1; - } - } else { - escaped = str[i] == '\\'; - } - } - lines.push_back(str.substr(start, end - start)); - return lines; -} - -} // namespace - -// Constructs and returns the message for an equality assertion -// (e.g. ASSERT_EQ, EXPECT_STREQ, etc) failure. -// -// The first four parameters are the expressions used in the assertion -// and their values, as strings. For example, for ASSERT_EQ(foo, bar) -// where foo is 5 and bar is 6, we have: -// -// lhs_expression: "foo" -// rhs_expression: "bar" -// lhs_value: "5" -// rhs_value: "6" -// -// The ignoring_case parameter is true if and only if the assertion is a -// *_STRCASEEQ*. When it's true, the string "Ignoring case" will -// be inserted into the message. -AssertionResult EqFailure(const char* lhs_expression, - const char* rhs_expression, - const std::string& lhs_value, - const std::string& rhs_value, - bool ignoring_case) { - Message msg; - msg << "Expected equality of these values:"; - msg << "\n " << lhs_expression; - if (lhs_value != lhs_expression) { - msg << "\n Which is: " << lhs_value; - } - msg << "\n " << rhs_expression; - if (rhs_value != rhs_expression) { - msg << "\n Which is: " << rhs_value; - } - - if (ignoring_case) { - msg << "\nIgnoring case"; - } - - if (!lhs_value.empty() && !rhs_value.empty()) { - const std::vector<std::string> lhs_lines = - SplitEscapedString(lhs_value); - const std::vector<std::string> rhs_lines = - SplitEscapedString(rhs_value); - if (lhs_lines.size() > 1 || rhs_lines.size() > 1) { - msg << "\nWith diff:\n" - << edit_distance::CreateUnifiedDiff(lhs_lines, rhs_lines); - } - } - - return AssertionFailure() << msg; -} - -// Constructs a failure message for Boolean assertions such as EXPECT_TRUE. -std::string GetBoolAssertionFailureMessage( - const AssertionResult& assertion_result, - const char* expression_text, - const char* actual_predicate_value, - const char* expected_predicate_value) { - const char* actual_message = assertion_result.message(); - Message msg; - msg << "Value of: " << expression_text - << "\n Actual: " << actual_predicate_value; - if (actual_message[0] != '\0') - msg << " (" << actual_message << ")"; - msg << "\nExpected: " << expected_predicate_value; - return msg.GetString(); -} - -// Helper function for implementing ASSERT_NEAR. -AssertionResult DoubleNearPredFormat(const char* expr1, - const char* expr2, - const char* abs_error_expr, - double val1, - double val2, - double abs_error) { - const double diff = fabs(val1 - val2); - if (diff <= abs_error) return AssertionSuccess(); - - // Find the value which is closest to zero. - const double min_abs = std::min(fabs(val1), fabs(val2)); - // Find the distance to the next double from that value. - const double epsilon = - nextafter(min_abs, std::numeric_limits<double>::infinity()) - min_abs; - // Detect the case where abs_error is so small that EXPECT_NEAR is - // effectively the same as EXPECT_EQUAL, and give an informative error - // message so that the situation can be more easily understood without - // requiring exotic floating-point knowledge. - // Don't do an epsilon check if abs_error is zero because that implies - // that an equality check was actually intended. - if (!(std::isnan)(val1) && !(std::isnan)(val2) && abs_error > 0 && - abs_error < epsilon) { - return AssertionFailure() - << "The difference between " << expr1 << " and " << expr2 << " is " - << diff << ", where\n" - << expr1 << " evaluates to " << val1 << ",\n" - << expr2 << " evaluates to " << val2 << ".\nThe abs_error parameter " - << abs_error_expr << " evaluates to " << abs_error - << " which is smaller than the minimum distance between doubles for " - "numbers of this magnitude which is " - << epsilon - << ", thus making this EXPECT_NEAR check equivalent to " - "EXPECT_EQUAL. Consider using EXPECT_DOUBLE_EQ instead."; - } - return AssertionFailure() - << "The difference between " << expr1 << " and " << expr2 - << " is " << diff << ", which exceeds " << abs_error_expr << ", where\n" - << expr1 << " evaluates to " << val1 << ",\n" - << expr2 << " evaluates to " << val2 << ", and\n" - << abs_error_expr << " evaluates to " << abs_error << "."; -} - - -// Helper template for implementing FloatLE() and DoubleLE(). -template <typename RawType> -AssertionResult FloatingPointLE(const char* expr1, - const char* expr2, - RawType val1, - RawType val2) { - // Returns success if val1 is less than val2, - if (val1 < val2) { - return AssertionSuccess(); - } - - // or if val1 is almost equal to val2. - const FloatingPoint<RawType> lhs(val1), rhs(val2); - if (lhs.AlmostEquals(rhs)) { - return AssertionSuccess(); - } - - // Note that the above two checks will both fail if either val1 or - // val2 is NaN, as the IEEE floating-point standard requires that - // any predicate involving a NaN must return false. - - ::std::stringstream val1_ss; - val1_ss << std::setprecision(std::numeric_limits<RawType>::digits10 + 2) - << val1; - - ::std::stringstream val2_ss; - val2_ss << std::setprecision(std::numeric_limits<RawType>::digits10 + 2) - << val2; - - return AssertionFailure() - << "Expected: (" << expr1 << ") <= (" << expr2 << ")\n" - << " Actual: " << StringStreamToString(&val1_ss) << " vs " - << StringStreamToString(&val2_ss); -} - -} // namespace internal - -// Asserts that val1 is less than, or almost equal to, val2. Fails -// otherwise. In particular, it fails if either val1 or val2 is NaN. -AssertionResult FloatLE(const char* expr1, const char* expr2, - float val1, float val2) { - return internal::FloatingPointLE<float>(expr1, expr2, val1, val2); -} - -// Asserts that val1 is less than, or almost equal to, val2. Fails -// otherwise. In particular, it fails if either val1 or val2 is NaN. -AssertionResult DoubleLE(const char* expr1, const char* expr2, - double val1, double val2) { - return internal::FloatingPointLE<double>(expr1, expr2, val1, val2); -} - -namespace internal { - -// The helper function for {ASSERT|EXPECT}_STREQ. -AssertionResult CmpHelperSTREQ(const char* lhs_expression, - const char* rhs_expression, - const char* lhs, - const char* rhs) { - if (String::CStringEquals(lhs, rhs)) { - return AssertionSuccess(); - } - - return EqFailure(lhs_expression, - rhs_expression, - PrintToString(lhs), - PrintToString(rhs), - false); -} - -// The helper function for {ASSERT|EXPECT}_STRCASEEQ. -AssertionResult CmpHelperSTRCASEEQ(const char* lhs_expression, - const char* rhs_expression, - const char* lhs, - const char* rhs) { - if (String::CaseInsensitiveCStringEquals(lhs, rhs)) { - return AssertionSuccess(); - } - - return EqFailure(lhs_expression, - rhs_expression, - PrintToString(lhs), - PrintToString(rhs), - true); -} - -// The helper function for {ASSERT|EXPECT}_STRNE. -AssertionResult CmpHelperSTRNE(const char* s1_expression, - const char* s2_expression, - const char* s1, - const char* s2) { - if (!String::CStringEquals(s1, s2)) { - return AssertionSuccess(); - } else { - return AssertionFailure() << "Expected: (" << s1_expression << ") != (" - << s2_expression << "), actual: \"" - << s1 << "\" vs \"" << s2 << "\""; - } -} - -// The helper function for {ASSERT|EXPECT}_STRCASENE. -AssertionResult CmpHelperSTRCASENE(const char* s1_expression, - const char* s2_expression, - const char* s1, - const char* s2) { - if (!String::CaseInsensitiveCStringEquals(s1, s2)) { - return AssertionSuccess(); - } else { - return AssertionFailure() - << "Expected: (" << s1_expression << ") != (" - << s2_expression << ") (ignoring case), actual: \"" - << s1 << "\" vs \"" << s2 << "\""; - } -} - -} // namespace internal - -namespace { - -// Helper functions for implementing IsSubString() and IsNotSubstring(). - -// This group of overloaded functions return true if and only if needle -// is a substring of haystack. NULL is considered a substring of -// itself only. - -bool IsSubstringPred(const char* needle, const char* haystack) { - if (needle == nullptr || haystack == nullptr) return needle == haystack; - - return strstr(haystack, needle) != nullptr; -} - -bool IsSubstringPred(const wchar_t* needle, const wchar_t* haystack) { - if (needle == nullptr || haystack == nullptr) return needle == haystack; - - return wcsstr(haystack, needle) != nullptr; -} - -// StringType here can be either ::std::string or ::std::wstring. -template <typename StringType> -bool IsSubstringPred(const StringType& needle, - const StringType& haystack) { - return haystack.find(needle) != StringType::npos; -} - -// This function implements either IsSubstring() or IsNotSubstring(), -// depending on the value of the expected_to_be_substring parameter. -// StringType here can be const char*, const wchar_t*, ::std::string, -// or ::std::wstring. -template <typename StringType> -AssertionResult IsSubstringImpl( - bool expected_to_be_substring, - const char* needle_expr, const char* haystack_expr, - const StringType& needle, const StringType& haystack) { - if (IsSubstringPred(needle, haystack) == expected_to_be_substring) - return AssertionSuccess(); - - const bool is_wide_string = sizeof(needle[0]) > 1; - const char* const begin_string_quote = is_wide_string ? "L\"" : "\""; - return AssertionFailure() - << "Value of: " << needle_expr << "\n" - << " Actual: " << begin_string_quote << needle << "\"\n" - << "Expected: " << (expected_to_be_substring ? "" : "not ") - << "a substring of " << haystack_expr << "\n" - << "Which is: " << begin_string_quote << haystack << "\""; -} - -} // namespace - -// IsSubstring() and IsNotSubstring() check whether needle is a -// substring of haystack (NULL is considered a substring of itself -// only), and return an appropriate error message when they fail. - -AssertionResult IsSubstring( - const char* needle_expr, const char* haystack_expr, - const char* needle, const char* haystack) { - return IsSubstringImpl(true, needle_expr, haystack_expr, needle, haystack); -} - -AssertionResult IsSubstring( - const char* needle_expr, const char* haystack_expr, - const wchar_t* needle, const wchar_t* haystack) { - return IsSubstringImpl(true, needle_expr, haystack_expr, needle, haystack); -} - -AssertionResult IsNotSubstring( - const char* needle_expr, const char* haystack_expr, - const char* needle, const char* haystack) { - return IsSubstringImpl(false, needle_expr, haystack_expr, needle, haystack); -} - -AssertionResult IsNotSubstring( - const char* needle_expr, const char* haystack_expr, - const wchar_t* needle, const wchar_t* haystack) { - return IsSubstringImpl(false, needle_expr, haystack_expr, needle, haystack); -} - -AssertionResult IsSubstring( - const char* needle_expr, const char* haystack_expr, - const ::std::string& needle, const ::std::string& haystack) { - return IsSubstringImpl(true, needle_expr, haystack_expr, needle, haystack); -} - -AssertionResult IsNotSubstring( - const char* needle_expr, const char* haystack_expr, - const ::std::string& needle, const ::std::string& haystack) { - return IsSubstringImpl(false, needle_expr, haystack_expr, needle, haystack); -} - -#if GTEST_HAS_STD_WSTRING -AssertionResult IsSubstring( - const char* needle_expr, const char* haystack_expr, - const ::std::wstring& needle, const ::std::wstring& haystack) { - return IsSubstringImpl(true, needle_expr, haystack_expr, needle, haystack); -} - -AssertionResult IsNotSubstring( - const char* needle_expr, const char* haystack_expr, - const ::std::wstring& needle, const ::std::wstring& haystack) { - return IsSubstringImpl(false, needle_expr, haystack_expr, needle, haystack); -} -#endif // GTEST_HAS_STD_WSTRING - -namespace internal { - -#if GTEST_OS_WINDOWS - -namespace { - -// Helper function for IsHRESULT{SuccessFailure} predicates -AssertionResult HRESULTFailureHelper(const char* expr, - const char* expected, - long hr) { // NOLINT -# if GTEST_OS_WINDOWS_MOBILE || GTEST_OS_WINDOWS_TV_TITLE - - // Windows CE doesn't support FormatMessage. - const char error_text[] = ""; - -# else - - // Looks up the human-readable system message for the HRESULT code - // and since we're not passing any params to FormatMessage, we don't - // want inserts expanded. - const DWORD kFlags = FORMAT_MESSAGE_FROM_SYSTEM | - FORMAT_MESSAGE_IGNORE_INSERTS; - const DWORD kBufSize = 4096; - // Gets the system's human readable message string for this HRESULT. - char error_text[kBufSize] = { '\0' }; - DWORD message_length = ::FormatMessageA(kFlags, - 0, // no source, we're asking system - static_cast<DWORD>(hr), // the error - 0, // no line width restrictions - error_text, // output buffer - kBufSize, // buf size - nullptr); // no arguments for inserts - // Trims tailing white space (FormatMessage leaves a trailing CR-LF) - for (; message_length && IsSpace(error_text[message_length - 1]); - --message_length) { - error_text[message_length - 1] = '\0'; - } - -# endif // GTEST_OS_WINDOWS_MOBILE - - const std::string error_hex("0x" + String::FormatHexInt(hr)); - return ::testing::AssertionFailure() - << "Expected: " << expr << " " << expected << ".\n" - << " Actual: " << error_hex << " " << error_text << "\n"; -} - -} // namespace - -AssertionResult IsHRESULTSuccess(const char* expr, long hr) { // NOLINT - if (SUCCEEDED(hr)) { - return AssertionSuccess(); - } - return HRESULTFailureHelper(expr, "succeeds", hr); -} - -AssertionResult IsHRESULTFailure(const char* expr, long hr) { // NOLINT - if (FAILED(hr)) { - return AssertionSuccess(); - } - return HRESULTFailureHelper(expr, "fails", hr); -} - -#endif // GTEST_OS_WINDOWS - -// Utility functions for encoding Unicode text (wide strings) in -// UTF-8. - -// A Unicode code-point can have up to 21 bits, and is encoded in UTF-8 -// like this: -// -// Code-point length Encoding -// 0 - 7 bits 0xxxxxxx -// 8 - 11 bits 110xxxxx 10xxxxxx -// 12 - 16 bits 1110xxxx 10xxxxxx 10xxxxxx -// 17 - 21 bits 11110xxx 10xxxxxx 10xxxxxx 10xxxxxx - -// The maximum code-point a one-byte UTF-8 sequence can represent. -constexpr uint32_t kMaxCodePoint1 = (static_cast<uint32_t>(1) << 7) - 1; - -// The maximum code-point a two-byte UTF-8 sequence can represent. -constexpr uint32_t kMaxCodePoint2 = (static_cast<uint32_t>(1) << (5 + 6)) - 1; - -// The maximum code-point a three-byte UTF-8 sequence can represent. -constexpr uint32_t kMaxCodePoint3 = (static_cast<uint32_t>(1) << (4 + 2*6)) - 1; - -// The maximum code-point a four-byte UTF-8 sequence can represent. -constexpr uint32_t kMaxCodePoint4 = (static_cast<uint32_t>(1) << (3 + 3*6)) - 1; - -// Chops off the n lowest bits from a bit pattern. Returns the n -// lowest bits. As a side effect, the original bit pattern will be -// shifted to the right by n bits. -inline uint32_t ChopLowBits(uint32_t* bits, int n) { - const uint32_t low_bits = *bits & ((static_cast<uint32_t>(1) << n) - 1); - *bits >>= n; - return low_bits; -} - -// Converts a Unicode code point to a narrow string in UTF-8 encoding. -// code_point parameter is of type uint32_t because wchar_t may not be -// wide enough to contain a code point. -// If the code_point is not a valid Unicode code point -// (i.e. outside of Unicode range U+0 to U+10FFFF) it will be converted -// to "(Invalid Unicode 0xXXXXXXXX)". -std::string CodePointToUtf8(uint32_t code_point) { - if (code_point > kMaxCodePoint4) { - return "(Invalid Unicode 0x" + String::FormatHexUInt32(code_point) + ")"; - } - - char str[5]; // Big enough for the largest valid code point. - if (code_point <= kMaxCodePoint1) { - str[1] = '\0'; - str[0] = static_cast<char>(code_point); // 0xxxxxxx - } else if (code_point <= kMaxCodePoint2) { - str[2] = '\0'; - str[1] = static_cast<char>(0x80 | ChopLowBits(&code_point, 6)); // 10xxxxxx - str[0] = static_cast<char>(0xC0 | code_point); // 110xxxxx - } else if (code_point <= kMaxCodePoint3) { - str[3] = '\0'; - str[2] = static_cast<char>(0x80 | ChopLowBits(&code_point, 6)); // 10xxxxxx - str[1] = static_cast<char>(0x80 | ChopLowBits(&code_point, 6)); // 10xxxxxx - str[0] = static_cast<char>(0xE0 | code_point); // 1110xxxx - } else { // code_point <= kMaxCodePoint4 - str[4] = '\0'; - str[3] = static_cast<char>(0x80 | ChopLowBits(&code_point, 6)); // 10xxxxxx - str[2] = static_cast<char>(0x80 | ChopLowBits(&code_point, 6)); // 10xxxxxx - str[1] = static_cast<char>(0x80 | ChopLowBits(&code_point, 6)); // 10xxxxxx - str[0] = static_cast<char>(0xF0 | code_point); // 11110xxx - } - return str; -} - -// The following two functions only make sense if the system -// uses UTF-16 for wide string encoding. All supported systems -// with 16 bit wchar_t (Windows, Cygwin) do use UTF-16. - -// Determines if the arguments constitute UTF-16 surrogate pair -// and thus should be combined into a single Unicode code point -// using CreateCodePointFromUtf16SurrogatePair. -inline bool IsUtf16SurrogatePair(wchar_t first, wchar_t second) { - return sizeof(wchar_t) == 2 && - (first & 0xFC00) == 0xD800 && (second & 0xFC00) == 0xDC00; -} - -// Creates a Unicode code point from UTF16 surrogate pair. -inline uint32_t CreateCodePointFromUtf16SurrogatePair(wchar_t first, - wchar_t second) { - const auto first_u = static_cast<uint32_t>(first); - const auto second_u = static_cast<uint32_t>(second); - const uint32_t mask = (1 << 10) - 1; - return (sizeof(wchar_t) == 2) - ? (((first_u & mask) << 10) | (second_u & mask)) + 0x10000 - : - // This function should not be called when the condition is - // false, but we provide a sensible default in case it is. - first_u; -} - -// Converts a wide string to a narrow string in UTF-8 encoding. -// The wide string is assumed to have the following encoding: -// UTF-16 if sizeof(wchar_t) == 2 (on Windows, Cygwin) -// UTF-32 if sizeof(wchar_t) == 4 (on Linux) -// Parameter str points to a null-terminated wide string. -// Parameter num_chars may additionally limit the number -// of wchar_t characters processed. -1 is used when the entire string -// should be processed. -// If the string contains code points that are not valid Unicode code points -// (i.e. outside of Unicode range U+0 to U+10FFFF) they will be output -// as '(Invalid Unicode 0xXXXXXXXX)'. If the string is in UTF16 encoding -// and contains invalid UTF-16 surrogate pairs, values in those pairs -// will be encoded as individual Unicode characters from Basic Normal Plane. -std::string WideStringToUtf8(const wchar_t* str, int num_chars) { - if (num_chars == -1) - num_chars = static_cast<int>(wcslen(str)); - - ::std::stringstream stream; - for (int i = 0; i < num_chars; ++i) { - uint32_t unicode_code_point; - - if (str[i] == L'\0') { - break; - } else if (i + 1 < num_chars && IsUtf16SurrogatePair(str[i], str[i + 1])) { - unicode_code_point = CreateCodePointFromUtf16SurrogatePair(str[i], - str[i + 1]); - i++; - } else { - unicode_code_point = static_cast<uint32_t>(str[i]); - } - - stream << CodePointToUtf8(unicode_code_point); - } - return StringStreamToString(&stream); -} - -// Converts a wide C string to an std::string using the UTF-8 encoding. -// NULL will be converted to "(null)". -std::string String::ShowWideCString(const wchar_t * wide_c_str) { - if (wide_c_str == nullptr) return "(null)"; - - return internal::WideStringToUtf8(wide_c_str, -1); -} - -// Compares two wide C strings. Returns true if and only if 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. -bool String::WideCStringEquals(const wchar_t * lhs, const wchar_t * rhs) { - if (lhs == nullptr) return rhs == nullptr; - - if (rhs == nullptr) return false; - - return wcscmp(lhs, rhs) == 0; -} - -// Helper function for *_STREQ on wide strings. -AssertionResult CmpHelperSTREQ(const char* lhs_expression, - const char* rhs_expression, - const wchar_t* lhs, - const wchar_t* rhs) { - if (String::WideCStringEquals(lhs, rhs)) { - return AssertionSuccess(); - } - - return EqFailure(lhs_expression, - rhs_expression, - PrintToString(lhs), - PrintToString(rhs), - false); -} - -// Helper function for *_STRNE on wide strings. -AssertionResult CmpHelperSTRNE(const char* s1_expression, - const char* s2_expression, - const wchar_t* s1, - const wchar_t* s2) { - if (!String::WideCStringEquals(s1, s2)) { - return AssertionSuccess(); - } - - return AssertionFailure() << "Expected: (" << s1_expression << ") != (" - << s2_expression << "), actual: " - << PrintToString(s1) - << " vs " << PrintToString(s2); -} - -// Compares two C strings, ignoring case. Returns true if and only if 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. -bool String::CaseInsensitiveCStringEquals(const char * lhs, const char * rhs) { - if (lhs == nullptr) return rhs == nullptr; - if (rhs == nullptr) return false; - return posix::StrCaseCmp(lhs, rhs) == 0; -} - -// Compares two wide C strings, ignoring case. Returns true if and only if 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. -bool String::CaseInsensitiveWideCStringEquals(const wchar_t* lhs, - const wchar_t* rhs) { - if (lhs == nullptr) return rhs == nullptr; - - if (rhs == nullptr) return false; - -#if GTEST_OS_WINDOWS - return _wcsicmp(lhs, rhs) == 0; -#elif GTEST_OS_LINUX && !GTEST_OS_LINUX_ANDROID - return wcscasecmp(lhs, rhs) == 0; -#else - // Android, Mac OS X and Cygwin don't define wcscasecmp. - // Other unknown OSes may not define it either. - wint_t left, right; - do { - left = towlower(static_cast<wint_t>(*lhs++)); - right = towlower(static_cast<wint_t>(*rhs++)); - } while (left && left == right); - return left == right; -#endif // OS selector -} - -// Returns true if and only if str ends with the given suffix, ignoring case. -// Any string is considered to end with an empty suffix. -bool String::EndsWithCaseInsensitive( - const std::string& str, const std::string& suffix) { - const size_t str_len = str.length(); - const size_t suffix_len = suffix.length(); - return (str_len >= suffix_len) && - CaseInsensitiveCStringEquals(str.c_str() + str_len - suffix_len, - suffix.c_str()); -} - -// Formats an int value as "%02d". -std::string String::FormatIntWidth2(int value) { - return FormatIntWidthN(value, 2); -} - -// Formats an int value to given width with leading zeros. -std::string String::FormatIntWidthN(int value, int width) { - std::stringstream ss; - ss << std::setfill('0') << std::setw(width) << value; - return ss.str(); -} - -// Formats an int value as "%X". -std::string String::FormatHexUInt32(uint32_t value) { - std::stringstream ss; - ss << std::hex << std::uppercase << value; - return ss.str(); -} - -// Formats an int value as "%X". -std::string String::FormatHexInt(int value) { - return FormatHexUInt32(static_cast<uint32_t>(value)); -} - -// Formats a byte as "%02X". -std::string String::FormatByte(unsigned char value) { - std::stringstream ss; - ss << std::setfill('0') << std::setw(2) << std::hex << std::uppercase - << static_cast<unsigned int>(value); - return ss.str(); -} - -// Converts the buffer in a stringstream to an std::string, converting NUL -// bytes to "\\0" along the way. -std::string StringStreamToString(::std::stringstream* ss) { - const ::std::string& str = ss->str(); - const char* const start = str.c_str(); - const char* const end = start + str.length(); - - std::string result; - result.reserve(static_cast<size_t>(2 * (end - start))); - for (const char* ch = start; ch != end; ++ch) { - if (*ch == '\0') { - result += "\\0"; // Replaces NUL with "\\0"; - } else { - result += *ch; - } - } - - return result; -} - -// Appends the user-supplied message to the Google-Test-generated message. -std::string AppendUserMessage(const std::string& gtest_msg, - const Message& user_msg) { - // Appends the user message if it's non-empty. - const std::string user_msg_string = user_msg.GetString(); - if (user_msg_string.empty()) { - return gtest_msg; - } - if (gtest_msg.empty()) { - return user_msg_string; - } - return gtest_msg + "\n" + user_msg_string; -} - -} // namespace internal - -// class TestResult - -// Creates an empty TestResult. -TestResult::TestResult() - : death_test_count_(0), start_timestamp_(0), elapsed_time_(0) {} - -// D'tor. -TestResult::~TestResult() { -} - -// Returns the i-th test part result among all the results. i can -// range from 0 to total_part_count() - 1. If i is not in that range, -// aborts the program. -const TestPartResult& TestResult::GetTestPartResult(int i) const { - if (i < 0 || i >= total_part_count()) - internal::posix::Abort(); - return test_part_results_.at(static_cast<size_t>(i)); -} - -// Returns the i-th test property. i can range from 0 to -// test_property_count() - 1. If i is not in that range, aborts the -// program. -const TestProperty& TestResult::GetTestProperty(int i) const { - if (i < 0 || i >= test_property_count()) - internal::posix::Abort(); - return test_properties_.at(static_cast<size_t>(i)); -} - -// Clears the test part results. -void TestResult::ClearTestPartResults() { - test_part_results_.clear(); -} - -// Adds a test part result to the list. -void TestResult::AddTestPartResult(const TestPartResult& test_part_result) { - test_part_results_.push_back(test_part_result); -} - -// Adds a test property to the list. If a property with the same key as the -// supplied property is already represented, the value of this test_property -// replaces the old value for that key. -void TestResult::RecordProperty(const std::string& xml_element, - const TestProperty& test_property) { - if (!ValidateTestProperty(xml_element, test_property)) { - return; - } - internal::MutexLock lock(&test_properties_mutex_); - const std::vector<TestProperty>::iterator property_with_matching_key = - std::find_if(test_properties_.begin(), test_properties_.end(), - internal::TestPropertyKeyIs(test_property.key())); - if (property_with_matching_key == test_properties_.end()) { - test_properties_.push_back(test_property); - return; - } - property_with_matching_key->SetValue(test_property.value()); -} - -// The list of reserved attributes used in the <testsuites> element of XML -// output. -static const char* const kReservedTestSuitesAttributes[] = { - "disabled", - "errors", - "failures", - "name", - "random_seed", - "tests", - "time", - "timestamp" -}; - -// The list of reserved attributes used in the <testsuite> element of XML -// output. -static const char* const kReservedTestSuiteAttributes[] = { - "disabled", "errors", "failures", "name", - "tests", "time", "timestamp", "skipped"}; - -// The list of reserved attributes used in the <testcase> element of XML output. -static const char* const kReservedTestCaseAttributes[] = { - "classname", "name", "status", "time", "type_param", - "value_param", "file", "line"}; - -// Use a slightly different set for allowed output to ensure existing tests can -// still RecordProperty("result") or "RecordProperty(timestamp") -static const char* const kReservedOutputTestCaseAttributes[] = { - "classname", "name", "status", "time", "type_param", - "value_param", "file", "line", "result", "timestamp"}; - -template <size_t kSize> -std::vector<std::string> ArrayAsVector(const char* const (&array)[kSize]) { - return std::vector<std::string>(array, array + kSize); -} - -static std::vector<std::string> GetReservedAttributesForElement( - const std::string& xml_element) { - if (xml_element == "testsuites") { - return ArrayAsVector(kReservedTestSuitesAttributes); - } else if (xml_element == "testsuite") { - return ArrayAsVector(kReservedTestSuiteAttributes); - } else if (xml_element == "testcase") { - return ArrayAsVector(kReservedTestCaseAttributes); - } else { - GTEST_CHECK_(false) << "Unrecognized xml_element provided: " << xml_element; - } - // This code is unreachable but some compilers may not realizes that. - return std::vector<std::string>(); -} - -// TODO(jdesprez): Merge the two getReserved attributes once skip is improved -static std::vector<std::string> GetReservedOutputAttributesForElement( - const std::string& xml_element) { - if (xml_element == "testsuites") { - return ArrayAsVector(kReservedTestSuitesAttributes); - } else if (xml_element == "testsuite") { - return ArrayAsVector(kReservedTestSuiteAttributes); - } else if (xml_element == "testcase") { - return ArrayAsVector(kReservedOutputTestCaseAttributes); - } else { - GTEST_CHECK_(false) << "Unrecognized xml_element provided: " << xml_element; - } - // This code is unreachable but some compilers may not realizes that. - return std::vector<std::string>(); -} - -static std::string FormatWordList(const std::vector<std::string>& words) { - Message word_list; - for (size_t i = 0; i < words.size(); ++i) { - if (i > 0 && words.size() > 2) { - word_list << ", "; - } - if (i == words.size() - 1) { - word_list << "and "; - } - word_list << "'" << words[i] << "'"; - } - return word_list.GetString(); -} - -static bool ValidateTestPropertyName( - const std::string& property_name, - const std::vector<std::string>& reserved_names) { - if (std::find(reserved_names.begin(), reserved_names.end(), property_name) != - reserved_names.end()) { - ADD_FAILURE() << "Reserved key used in RecordProperty(): " << property_name - << " (" << FormatWordList(reserved_names) - << " are reserved by " << GTEST_NAME_ << ")"; - return false; - } - return true; -} - -// Adds a failure if the key is a reserved attribute of the element named -// xml_element. Returns true if the property is valid. -bool TestResult::ValidateTestProperty(const std::string& xml_element, - const TestProperty& test_property) { - return ValidateTestPropertyName(test_property.key(), - GetReservedAttributesForElement(xml_element)); -} - -// Clears the object. -void TestResult::Clear() { - test_part_results_.clear(); - test_properties_.clear(); - death_test_count_ = 0; - elapsed_time_ = 0; -} - -// Returns true off the test part was skipped. -static bool TestPartSkipped(const TestPartResult& result) { - return result.skipped(); -} - -// Returns true if and only if the test was skipped. -bool TestResult::Skipped() const { - return !Failed() && CountIf(test_part_results_, TestPartSkipped) > 0; -} - -// Returns true if and only if the test failed. -bool TestResult::Failed() const { - for (int i = 0; i < total_part_count(); ++i) { - if (GetTestPartResult(i).failed()) - return true; - } - return false; -} - -// Returns true if and only if the test part fatally failed. -static bool TestPartFatallyFailed(const TestPartResult& result) { - return result.fatally_failed(); -} - -// Returns true if and only if the test fatally failed. -bool TestResult::HasFatalFailure() const { - return CountIf(test_part_results_, TestPartFatallyFailed) > 0; -} - -// Returns true if and only if the test part non-fatally failed. -static bool TestPartNonfatallyFailed(const TestPartResult& result) { - return result.nonfatally_failed(); -} - -// Returns true if and only if the test has a non-fatal failure. -bool TestResult::HasNonfatalFailure() const { - return CountIf(test_part_results_, TestPartNonfatallyFailed) > 0; -} - -// Gets the number of all test parts. This is the sum of the number -// of successful test parts and the number of failed test parts. -int TestResult::total_part_count() const { - return static_cast<int>(test_part_results_.size()); -} - -// Returns the number of the test properties. -int TestResult::test_property_count() const { - return static_cast<int>(test_properties_.size()); -} - -// class Test - -// Creates a Test object. - -// The c'tor saves the states of all flags. -Test::Test() - : gtest_flag_saver_(new GTEST_FLAG_SAVER_) { -} - -// The d'tor restores the states of all flags. The actual work is -// done by the d'tor of the gtest_flag_saver_ field, and thus not -// visible here. -Test::~Test() { -} - -// Sets up the test fixture. -// -// A sub-class may override this. -void Test::SetUp() { -} - -// Tears down the test fixture. -// -// A sub-class may override this. -void Test::TearDown() { -} - -// Allows user supplied key value pairs to be recorded for later output. -void Test::RecordProperty(const std::string& key, const std::string& value) { - UnitTest::GetInstance()->RecordProperty(key, value); -} - -// Allows user supplied key value pairs to be recorded for later output. -void Test::RecordProperty(const std::string& key, int value) { - Message value_message; - value_message << value; - RecordProperty(key, value_message.GetString().c_str()); -} - -namespace internal { - -void ReportFailureInUnknownLocation(TestPartResult::Type result_type, - const std::string& message) { - // This function is a friend of UnitTest and as such has access to - // AddTestPartResult. - UnitTest::GetInstance()->AddTestPartResult( - result_type, - nullptr, // No info about the source file where the exception occurred. - -1, // We have no info on which line caused the exception. - message, - ""); // No stack trace, either. -} - -} // namespace internal - -// Google Test requires all tests in the same test suite to use the same test -// fixture class. This function checks if the current test has the -// same fixture class as the first test in the current test suite. If -// yes, it returns true; otherwise it generates a Google Test failure and -// returns false. -bool Test::HasSameFixtureClass() { - internal::UnitTestImpl* const impl = internal::GetUnitTestImpl(); - const TestSuite* const test_suite = impl->current_test_suite(); - - // Info about the first test in the current test suite. - const TestInfo* const first_test_info = test_suite->test_info_list()[0]; - const internal::TypeId first_fixture_id = first_test_info->fixture_class_id_; - const char* const first_test_name = first_test_info->name(); - - // Info about the current test. - const TestInfo* const this_test_info = impl->current_test_info(); - const internal::TypeId this_fixture_id = this_test_info->fixture_class_id_; - const char* const this_test_name = this_test_info->name(); - - if (this_fixture_id != first_fixture_id) { - // Is the first test defined using TEST? - const bool first_is_TEST = first_fixture_id == internal::GetTestTypeId(); - // Is this test defined using TEST? - const bool this_is_TEST = this_fixture_id == internal::GetTestTypeId(); - - if (first_is_TEST || this_is_TEST) { - // Both TEST and TEST_F appear in same test suite, which is incorrect. - // Tell the user how to fix this. - - // Gets the name of the TEST and the name of the TEST_F. Note - // that first_is_TEST and this_is_TEST cannot both be true, as - // the fixture IDs are different for the two tests. - const char* const TEST_name = - first_is_TEST ? first_test_name : this_test_name; - const char* const TEST_F_name = - first_is_TEST ? this_test_name : first_test_name; - - ADD_FAILURE() - << "All tests in the same test suite must use the same test fixture\n" - << "class, so mixing TEST_F and TEST in the same test suite is\n" - << "illegal. In test suite " << this_test_info->test_suite_name() - << ",\n" - << "test " << TEST_F_name << " is defined using TEST_F but\n" - << "test " << TEST_name << " is defined using TEST. You probably\n" - << "want to change the TEST to TEST_F or move it to another test\n" - << "case."; - } else { - // Two fixture classes with the same name appear in two different - // namespaces, which is not allowed. Tell the user how to fix this. - ADD_FAILURE() - << "All tests in the same test suite must use the same test fixture\n" - << "class. However, in test suite " - << this_test_info->test_suite_name() << ",\n" - << "you defined test " << first_test_name << " and test " - << this_test_name << "\n" - << "using two different test fixture classes. This can happen if\n" - << "the two classes are from different namespaces or translation\n" - << "units and have the same name. You should probably rename one\n" - << "of the classes to put the tests into different test suites."; - } - return false; - } - - return true; -} - -#if GTEST_HAS_SEH - -// Adds an "exception thrown" fatal failure to the current test. This -// function returns its result via an output parameter pointer because VC++ -// prohibits creation of objects with destructors on stack in functions -// using __try (see error C2712). -static std::string* FormatSehExceptionMessage(DWORD exception_code, - const char* location) { - Message message; - message << "SEH exception with code 0x" << std::setbase(16) << - exception_code << std::setbase(10) << " thrown in " << location << "."; - - return new std::string(message.GetString()); -} - -#endif // GTEST_HAS_SEH - -namespace internal { - -#if GTEST_HAS_EXCEPTIONS - -// Adds an "exception thrown" fatal failure to the current test. -static std::string FormatCxxExceptionMessage(const char* description, - const char* location) { - Message message; - if (description != nullptr) { - message << "C++ exception with description \"" << description << "\""; - } else { - message << "Unknown C++ exception"; - } - message << " thrown in " << location << "."; - - return message.GetString(); -} - -static std::string PrintTestPartResultToString( - const TestPartResult& test_part_result); - -GoogleTestFailureException::GoogleTestFailureException( - const TestPartResult& failure) - : ::std::runtime_error(PrintTestPartResultToString(failure).c_str()) {} - -#endif // GTEST_HAS_EXCEPTIONS - -// We put these helper functions in the internal namespace as IBM's xlC -// compiler rejects the code if they were declared static. - -// Runs the given method and handles SEH exceptions it throws, when -// SEH is supported; returns the 0-value for type Result in case of an -// SEH exception. (Microsoft compilers cannot handle SEH and C++ -// exceptions in the same function. Therefore, we provide a separate -// wrapper function for handling SEH exceptions.) -template <class T, typename Result> -Result HandleSehExceptionsInMethodIfSupported( - T* object, Result (T::*method)(), const char* location) { -#if GTEST_HAS_SEH - __try { - return (object->*method)(); - } __except (internal::UnitTestOptions::GTestShouldProcessSEH( // NOLINT - GetExceptionCode())) { - // We create the exception message on the heap because VC++ prohibits - // creation of objects with destructors on stack in functions using __try - // (see error C2712). - std::string* exception_message = FormatSehExceptionMessage( - GetExceptionCode(), location); - internal::ReportFailureInUnknownLocation(TestPartResult::kFatalFailure, - *exception_message); - delete exception_message; - return static_cast<Result>(0); - } -#else - (void)location; - return (object->*method)(); -#endif // GTEST_HAS_SEH -} - -// Runs the given method and catches and reports C++ and/or SEH-style -// exceptions, if they are supported; returns the 0-value for type -// Result in case of an SEH exception. -template <class T, typename Result> -Result HandleExceptionsInMethodIfSupported( - T* object, Result (T::*method)(), const char* location) { - // NOTE: The user code can affect the way in which Google Test handles - // exceptions by setting GTEST_FLAG(catch_exceptions), but only before - // RUN_ALL_TESTS() starts. It is technically possible to check the flag - // after the exception is caught and either report or re-throw the - // exception based on the flag's value: - // - // try { - // // Perform the test method. - // } catch (...) { - // if (GTEST_FLAG(catch_exceptions)) - // // Report the exception as failure. - // else - // throw; // Re-throws the original exception. - // } - // - // However, the purpose of this flag is to allow the program to drop into - // the debugger when the exception is thrown. On most platforms, once the - // control enters the catch block, the exception origin information is - // lost and the debugger will stop the program at the point of the - // re-throw in this function -- instead of at the point of the original - // throw statement in the code under test. For this reason, we perform - // the check early, sacrificing the ability to affect Google Test's - // exception handling in the method where the exception is thrown. - if (internal::GetUnitTestImpl()->catch_exceptions()) { -#if GTEST_HAS_EXCEPTIONS - try { - return HandleSehExceptionsInMethodIfSupported(object, method, location); - } catch (const AssertionException&) { // NOLINT - // This failure was reported already. - } catch (const internal::GoogleTestFailureException&) { // NOLINT - // This exception type can only be thrown by a failed Google - // Test assertion with the intention of letting another testing - // framework catch it. Therefore we just re-throw it. - throw; - } catch (const std::exception& e) { // NOLINT - internal::ReportFailureInUnknownLocation( - TestPartResult::kFatalFailure, - FormatCxxExceptionMessage(e.what(), location)); - } catch (...) { // NOLINT - internal::ReportFailureInUnknownLocation( - TestPartResult::kFatalFailure, - FormatCxxExceptionMessage(nullptr, location)); - } - return static_cast<Result>(0); -#else - return HandleSehExceptionsInMethodIfSupported(object, method, location); -#endif // GTEST_HAS_EXCEPTIONS - } else { - return (object->*method)(); - } -} - -} // namespace internal - -// Runs the test and updates the test result. -void Test::Run() { - if (!HasSameFixtureClass()) return; - - internal::UnitTestImpl* const impl = internal::GetUnitTestImpl(); - impl->os_stack_trace_getter()->UponLeavingGTest(); - internal::HandleExceptionsInMethodIfSupported(this, &Test::SetUp, "SetUp()"); - // We will run the test only if SetUp() was successful and didn't call - // GTEST_SKIP(). - if (!HasFatalFailure() && !IsSkipped()) { - impl->os_stack_trace_getter()->UponLeavingGTest(); - internal::HandleExceptionsInMethodIfSupported( - this, &Test::TestBody, "the test body"); - } - - // However, we want to clean up as much as possible. Hence we will - // always call TearDown(), even if SetUp() or the test body has - // failed. - impl->os_stack_trace_getter()->UponLeavingGTest(); - internal::HandleExceptionsInMethodIfSupported( - this, &Test::TearDown, "TearDown()"); -} - -// Returns true if and only if the current test has a fatal failure. -bool Test::HasFatalFailure() { - return internal::GetUnitTestImpl()->current_test_result()->HasFatalFailure(); -} - -// Returns true if and only if the current test has a non-fatal failure. -bool Test::HasNonfatalFailure() { - return internal::GetUnitTestImpl()->current_test_result()-> - HasNonfatalFailure(); -} - -// Returns true if and only if the current test was skipped. -bool Test::IsSkipped() { - return internal::GetUnitTestImpl()->current_test_result()->Skipped(); -} - -// class TestInfo - -// Constructs a TestInfo object. It assumes ownership of the test factory -// object. -TestInfo::TestInfo(const std::string& a_test_suite_name, - const std::string& a_name, const char* a_type_param, - const char* a_value_param, - internal::CodeLocation a_code_location, - internal::TypeId fixture_class_id, - internal::TestFactoryBase* factory) - : test_suite_name_(a_test_suite_name), - name_(a_name), - type_param_(a_type_param ? new std::string(a_type_param) : nullptr), - value_param_(a_value_param ? new std::string(a_value_param) : nullptr), - location_(a_code_location), - fixture_class_id_(fixture_class_id), - should_run_(false), - is_disabled_(false), - matches_filter_(false), - is_in_another_shard_(false), - factory_(factory), - result_() {} - -// Destructs a TestInfo object. -TestInfo::~TestInfo() { delete factory_; } - -namespace internal { - -// Creates a new TestInfo object and registers it with Google Test; -// returns the created object. -// -// Arguments: -// -// test_suite_name: name of the test suite -// name: name of the test -// type_param: the name of the test's type parameter, or NULL if -// this is not a typed or a type-parameterized test. -// value_param: text representation of the test's value parameter, -// or NULL if this is not a value-parameterized test. -// code_location: code location where the test is defined -// fixture_class_id: ID of the test fixture class -// set_up_tc: pointer to the function that sets up the test suite -// tear_down_tc: pointer to the function that tears down the test suite -// factory: pointer to the factory that creates a test object. -// The newly created TestInfo instance will assume -// ownership of the factory object. -TestInfo* MakeAndRegisterTestInfo( - const char* test_suite_name, const char* name, const char* type_param, - const char* value_param, CodeLocation code_location, - TypeId fixture_class_id, SetUpTestSuiteFunc set_up_tc, - TearDownTestSuiteFunc tear_down_tc, TestFactoryBase* factory) { - TestInfo* const test_info = - new TestInfo(test_suite_name, name, type_param, value_param, - code_location, fixture_class_id, factory); - GetUnitTestImpl()->AddTestInfo(set_up_tc, tear_down_tc, test_info); - return test_info; -} - -void ReportInvalidTestSuiteType(const char* test_suite_name, - CodeLocation code_location) { - Message errors; - errors - << "Attempted redefinition of test suite " << test_suite_name << ".\n" - << "All tests in the same test suite must use the same test fixture\n" - << "class. However, in test suite " << test_suite_name << ", you tried\n" - << "to define a test using a fixture class different from the one\n" - << "used earlier. This can happen if the two fixture classes are\n" - << "from different namespaces and have the same name. You should\n" - << "probably rename one of the classes to put the tests into different\n" - << "test suites."; - - GTEST_LOG_(ERROR) << FormatFileLocation(code_location.file.c_str(), - code_location.line) - << " " << errors.GetString(); -} -} // namespace internal - -namespace { - -// A predicate that checks the test name of a TestInfo against a known -// value. -// -// This is used for implementation of the TestSuite class only. We put -// it in the anonymous namespace to prevent polluting the outer -// namespace. -// -// TestNameIs is copyable. -class TestNameIs { - public: - // Constructor. - // - // TestNameIs has NO default constructor. - explicit TestNameIs(const char* name) - : name_(name) {} - - // Returns true if and only if the test name of test_info matches name_. - bool operator()(const TestInfo * test_info) const { - return test_info && test_info->name() == name_; - } - - private: - std::string name_; -}; - -} // namespace - -namespace internal { - -// This method expands all parameterized tests registered with macros TEST_P -// and INSTANTIATE_TEST_SUITE_P into regular tests and registers those. -// This will be done just once during the program runtime. -void UnitTestImpl::RegisterParameterizedTests() { - if (!parameterized_tests_registered_) { - parameterized_test_registry_.RegisterTests(); - type_parameterized_test_registry_.CheckForInstantiations(); - parameterized_tests_registered_ = true; - } -} - -} // namespace internal - -// Creates the test object, runs it, records its result, and then -// deletes it. -void TestInfo::Run() { - if (!should_run_) return; - - // Tells UnitTest where to store test result. - internal::UnitTestImpl* const impl = internal::GetUnitTestImpl(); - impl->set_current_test_info(this); - - TestEventListener* repeater = UnitTest::GetInstance()->listeners().repeater(); - - // Notifies the unit test event listeners that a test is about to start. - repeater->OnTestStart(*this); - - result_.set_start_timestamp(internal::GetTimeInMillis()); - internal::Timer timer; - - impl->os_stack_trace_getter()->UponLeavingGTest(); - - // Creates the test object. - Test* const test = internal::HandleExceptionsInMethodIfSupported( - factory_, &internal::TestFactoryBase::CreateTest, - "the test fixture's constructor"); - - // Runs the test if the constructor didn't generate a fatal failure or invoke - // GTEST_SKIP(). - // Note that the object will not be null - if (!Test::HasFatalFailure() && !Test::IsSkipped()) { - // This doesn't throw as all user code that can throw are wrapped into - // exception handling code. - test->Run(); - } - - if (test != nullptr) { - // Deletes the test object. - impl->os_stack_trace_getter()->UponLeavingGTest(); - internal::HandleExceptionsInMethodIfSupported( - test, &Test::DeleteSelf_, "the test fixture's destructor"); - } - - result_.set_elapsed_time(timer.Elapsed()); - - // Notifies the unit test event listener that a test has just finished. - repeater->OnTestEnd(*this); - - // Tells UnitTest to stop associating assertion results to this - // test. - impl->set_current_test_info(nullptr); -} - -// Skip and records a skipped test result for this object. -void TestInfo::Skip() { - if (!should_run_) return; - - internal::UnitTestImpl* const impl = internal::GetUnitTestImpl(); - impl->set_current_test_info(this); - - TestEventListener* repeater = UnitTest::GetInstance()->listeners().repeater(); - - // Notifies the unit test event listeners that a test is about to start. - repeater->OnTestStart(*this); - - const TestPartResult test_part_result = - TestPartResult(TestPartResult::kSkip, this->file(), this->line(), ""); - impl->GetTestPartResultReporterForCurrentThread()->ReportTestPartResult( - test_part_result); - - // Notifies the unit test event listener that a test has just finished. - repeater->OnTestEnd(*this); - impl->set_current_test_info(nullptr); -} - -// class TestSuite - -// Gets the number of successful tests in this test suite. -int TestSuite::successful_test_count() const { - return CountIf(test_info_list_, TestPassed); -} - -// Gets the number of successful tests in this test suite. -int TestSuite::skipped_test_count() const { - return CountIf(test_info_list_, TestSkipped); -} - -// Gets the number of failed tests in this test suite. -int TestSuite::failed_test_count() const { - return CountIf(test_info_list_, TestFailed); -} - -// Gets the number of disabled tests that will be reported in the XML report. -int TestSuite::reportable_disabled_test_count() const { - return CountIf(test_info_list_, TestReportableDisabled); -} - -// Gets the number of disabled tests in this test suite. -int TestSuite::disabled_test_count() const { - return CountIf(test_info_list_, TestDisabled); -} - -// Gets the number of tests to be printed in the XML report. -int TestSuite::reportable_test_count() const { - return CountIf(test_info_list_, TestReportable); -} - -// Get the number of tests in this test suite that should run. -int TestSuite::test_to_run_count() const { - return CountIf(test_info_list_, ShouldRunTest); -} - -// Gets the number of all tests. -int TestSuite::total_test_count() const { - return static_cast<int>(test_info_list_.size()); -} - -// Creates a TestSuite with the given name. -// -// Arguments: -// -// a_name: name of the test suite -// a_type_param: the name of the test suite's type parameter, or NULL if -// this is not a typed or a type-parameterized test suite. -// set_up_tc: pointer to the function that sets up the test suite -// tear_down_tc: pointer to the function that tears down the test suite -TestSuite::TestSuite(const char* a_name, const char* a_type_param, - internal::SetUpTestSuiteFunc set_up_tc, - internal::TearDownTestSuiteFunc tear_down_tc) - : name_(a_name), - type_param_(a_type_param ? new std::string(a_type_param) : nullptr), - set_up_tc_(set_up_tc), - tear_down_tc_(tear_down_tc), - should_run_(false), - start_timestamp_(0), - elapsed_time_(0) {} - -// Destructor of TestSuite. -TestSuite::~TestSuite() { - // Deletes every Test in the collection. - ForEach(test_info_list_, internal::Delete<TestInfo>); -} - -// Returns the i-th test among all the tests. i can range from 0 to -// total_test_count() - 1. If i is not in that range, returns NULL. -const TestInfo* TestSuite::GetTestInfo(int i) const { - const int index = GetElementOr(test_indices_, i, -1); - return index < 0 ? nullptr : test_info_list_[static_cast<size_t>(index)]; -} - -// Returns the i-th test among all the tests. i can range from 0 to -// total_test_count() - 1. If i is not in that range, returns NULL. -TestInfo* TestSuite::GetMutableTestInfo(int i) { - const int index = GetElementOr(test_indices_, i, -1); - return index < 0 ? nullptr : test_info_list_[static_cast<size_t>(index)]; -} - -// Adds a test to this test suite. Will delete the test upon -// destruction of the TestSuite object. -void TestSuite::AddTestInfo(TestInfo* test_info) { - test_info_list_.push_back(test_info); - test_indices_.push_back(static_cast<int>(test_indices_.size())); -} - -// Runs every test in this TestSuite. -void TestSuite::Run() { - if (!should_run_) return; - - internal::UnitTestImpl* const impl = internal::GetUnitTestImpl(); - impl->set_current_test_suite(this); - - TestEventListener* repeater = UnitTest::GetInstance()->listeners().repeater(); - - // Call both legacy and the new API - repeater->OnTestSuiteStart(*this); -// Legacy API is deprecated but still available -#ifndef GTEST_REMOVE_LEGACY_TEST_CASEAPI_ - repeater->OnTestCaseStart(*this); -#endif // GTEST_REMOVE_LEGACY_TEST_CASEAPI_ - - impl->os_stack_trace_getter()->UponLeavingGTest(); - internal::HandleExceptionsInMethodIfSupported( - this, &TestSuite::RunSetUpTestSuite, "SetUpTestSuite()"); - - start_timestamp_ = internal::GetTimeInMillis(); - internal::Timer timer; - for (int i = 0; i < total_test_count(); i++) { - GetMutableTestInfo(i)->Run(); - if (GTEST_FLAG(fail_fast) && GetMutableTestInfo(i)->result()->Failed()) { - for (int j = i + 1; j < total_test_count(); j++) { - GetMutableTestInfo(j)->Skip(); - } - break; - } - } - elapsed_time_ = timer.Elapsed(); - - impl->os_stack_trace_getter()->UponLeavingGTest(); - internal::HandleExceptionsInMethodIfSupported( - this, &TestSuite::RunTearDownTestSuite, "TearDownTestSuite()"); - - // Call both legacy and the new API - repeater->OnTestSuiteEnd(*this); -// Legacy API is deprecated but still available -#ifndef GTEST_REMOVE_LEGACY_TEST_CASEAPI_ - repeater->OnTestCaseEnd(*this); -#endif // GTEST_REMOVE_LEGACY_TEST_CASEAPI_ - - impl->set_current_test_suite(nullptr); -} - -// Skips all tests under this TestSuite. -void TestSuite::Skip() { - if (!should_run_) return; - - internal::UnitTestImpl* const impl = internal::GetUnitTestImpl(); - impl->set_current_test_suite(this); - - TestEventListener* repeater = UnitTest::GetInstance()->listeners().repeater(); - - // Call both legacy and the new API - repeater->OnTestSuiteStart(*this); -// Legacy API is deprecated but still available -#ifndef GTEST_REMOVE_LEGACY_TEST_CASEAPI_ - repeater->OnTestCaseStart(*this); -#endif // GTEST_REMOVE_LEGACY_TEST_CASEAPI_ - - for (int i = 0; i < total_test_count(); i++) { - GetMutableTestInfo(i)->Skip(); - } - - // Call both legacy and the new API - repeater->OnTestSuiteEnd(*this); - // Legacy API is deprecated but still available -#ifndef GTEST_REMOVE_LEGACY_TEST_CASEAPI_ - repeater->OnTestCaseEnd(*this); -#endif // GTEST_REMOVE_LEGACY_TEST_CASEAPI_ - - impl->set_current_test_suite(nullptr); -} - -// Clears the results of all tests in this test suite. -void TestSuite::ClearResult() { - ad_hoc_test_result_.Clear(); - ForEach(test_info_list_, TestInfo::ClearTestResult); -} - -// Shuffles the tests in this test suite. -void TestSuite::ShuffleTests(internal::Random* random) { - Shuffle(random, &test_indices_); -} - -// Restores the test order to before the first shuffle. -void TestSuite::UnshuffleTests() { - for (size_t i = 0; i < test_indices_.size(); i++) { - test_indices_[i] = static_cast<int>(i); - } -} - -// Formats a countable noun. Depending on its quantity, either the -// singular form or the plural form is used. e.g. -// -// FormatCountableNoun(1, "formula", "formuli") returns "1 formula". -// FormatCountableNoun(5, "book", "books") returns "5 books". -static std::string FormatCountableNoun(int count, - const char * singular_form, - const char * plural_form) { - return internal::StreamableToString(count) + " " + - (count == 1 ? singular_form : plural_form); -} - -// Formats the count of tests. -static std::string FormatTestCount(int test_count) { - return FormatCountableNoun(test_count, "test", "tests"); -} - -// Formats the count of test suites. -static std::string FormatTestSuiteCount(int test_suite_count) { - return FormatCountableNoun(test_suite_count, "test suite", "test suites"); -} - -// Converts a TestPartResult::Type enum to human-friendly string -// representation. Both kNonFatalFailure and kFatalFailure are translated -// to "Failure", as the user usually doesn't care about the difference -// between the two when viewing the test result. -static const char * TestPartResultTypeToString(TestPartResult::Type type) { - switch (type) { - case TestPartResult::kSkip: - return "Skipped\n"; - case TestPartResult::kSuccess: - return "Success"; - - case TestPartResult::kNonFatalFailure: - case TestPartResult::kFatalFailure: -#ifdef _MSC_VER - return "error: "; -#else - return "Failure\n"; -#endif - default: - return "Unknown result type"; - } -} - -namespace internal { -namespace { -enum class GTestColor { kDefault, kRed, kGreen, kYellow }; -} // namespace - -// Prints a TestPartResult to an std::string. -static std::string PrintTestPartResultToString( - const TestPartResult& test_part_result) { - return (Message() - << internal::FormatFileLocation(test_part_result.file_name(), - test_part_result.line_number()) - << " " << TestPartResultTypeToString(test_part_result.type()) - << test_part_result.message()).GetString(); -} - -// Prints a TestPartResult. -static void PrintTestPartResult(const TestPartResult& test_part_result) { - const std::string& result = - PrintTestPartResultToString(test_part_result); - printf("%s\n", result.c_str()); - fflush(stdout); - // If the test program runs in Visual Studio or a debugger, the - // following statements add the test part result message to the Output - // window such that the user can double-click on it to jump to the - // corresponding source code location; otherwise they do nothing. -#if GTEST_OS_WINDOWS && !GTEST_OS_WINDOWS_MOBILE - // We don't call OutputDebugString*() on Windows Mobile, as printing - // to stdout is done by OutputDebugString() there already - we don't - // want the same message printed twice. - ::OutputDebugStringA(result.c_str()); - ::OutputDebugStringA("\n"); -#endif -} - -// class PrettyUnitTestResultPrinter -#if GTEST_OS_WINDOWS && !GTEST_OS_WINDOWS_MOBILE && \ - !GTEST_OS_WINDOWS_PHONE && !GTEST_OS_WINDOWS_RT && !GTEST_OS_WINDOWS_MINGW - -// Returns the character attribute for the given color. -static WORD GetColorAttribute(GTestColor color) { - switch (color) { - case GTestColor::kRed: - return FOREGROUND_RED; - case GTestColor::kGreen: - return FOREGROUND_GREEN; - case GTestColor::kYellow: - return FOREGROUND_RED | FOREGROUND_GREEN; - default: return 0; - } -} - -static int GetBitOffset(WORD color_mask) { - if (color_mask == 0) return 0; - - int bitOffset = 0; - while ((color_mask & 1) == 0) { - color_mask >>= 1; - ++bitOffset; - } - return bitOffset; -} - -static WORD GetNewColor(GTestColor color, WORD old_color_attrs) { - // Let's reuse the BG - static const WORD background_mask = BACKGROUND_BLUE | BACKGROUND_GREEN | - BACKGROUND_RED | BACKGROUND_INTENSITY; - static const WORD foreground_mask = FOREGROUND_BLUE | FOREGROUND_GREEN | - FOREGROUND_RED | FOREGROUND_INTENSITY; - const WORD existing_bg = old_color_attrs & background_mask; - - WORD new_color = - GetColorAttribute(color) | existing_bg | FOREGROUND_INTENSITY; - static const int bg_bitOffset = GetBitOffset(background_mask); - static const int fg_bitOffset = GetBitOffset(foreground_mask); - - if (((new_color & background_mask) >> bg_bitOffset) == - ((new_color & foreground_mask) >> fg_bitOffset)) { - new_color ^= FOREGROUND_INTENSITY; // invert intensity - } - return new_color; -} - -#else - -// Returns the ANSI color code for the given color. GTestColor::kDefault is -// an invalid input. -static const char* GetAnsiColorCode(GTestColor color) { - switch (color) { - case GTestColor::kRed: - return "1"; - case GTestColor::kGreen: - return "2"; - case GTestColor::kYellow: - return "3"; - default: - return nullptr; - } -} - -#endif // GTEST_OS_WINDOWS && !GTEST_OS_WINDOWS_MOBILE - -// Returns true if and only if Google Test should use colors in the output. -bool ShouldUseColor(bool stdout_is_tty) { - const char* const gtest_color = GTEST_FLAG(color).c_str(); - - if (String::CaseInsensitiveCStringEquals(gtest_color, "auto")) { -#if GTEST_OS_WINDOWS && !GTEST_OS_WINDOWS_MINGW - // On Windows the TERM variable is usually not set, but the - // console there does support colors. - return stdout_is_tty; -#else - // On non-Windows platforms, we rely on the TERM variable. - const char* const term = posix::GetEnv("TERM"); - const bool term_supports_color = - String::CStringEquals(term, "xterm") || - String::CStringEquals(term, "xterm-color") || - String::CStringEquals(term, "xterm-256color") || - String::CStringEquals(term, "screen") || - String::CStringEquals(term, "screen-256color") || - String::CStringEquals(term, "tmux") || - String::CStringEquals(term, "tmux-256color") || - String::CStringEquals(term, "rxvt-unicode") || - String::CStringEquals(term, "rxvt-unicode-256color") || - String::CStringEquals(term, "linux") || - String::CStringEquals(term, "cygwin"); - return stdout_is_tty && term_supports_color; -#endif // GTEST_OS_WINDOWS - } - - return String::CaseInsensitiveCStringEquals(gtest_color, "yes") || - String::CaseInsensitiveCStringEquals(gtest_color, "true") || - String::CaseInsensitiveCStringEquals(gtest_color, "t") || - String::CStringEquals(gtest_color, "1"); - // We take "yes", "true", "t", and "1" as meaning "yes". If the - // value is neither one of these nor "auto", we treat it as "no" to - // be conservative. -} - -// Helpers for printing colored strings to stdout. Note that on Windows, we -// cannot simply emit special characters and have the terminal change colors. -// This routine must actually emit the characters rather than return a string -// that would be colored when printed, as can be done on Linux. - -GTEST_ATTRIBUTE_PRINTF_(2, 3) -static void ColoredPrintf(GTestColor color, const char *fmt, ...) { - va_list args; - va_start(args, fmt); - -#if GTEST_OS_WINDOWS_MOBILE || GTEST_OS_ZOS || GTEST_OS_IOS || \ - GTEST_OS_WINDOWS_PHONE || GTEST_OS_WINDOWS_RT || defined(ESP_PLATFORM) - const bool use_color = AlwaysFalse(); -#else - static const bool in_color_mode = - ShouldUseColor(posix::IsATTY(posix::FileNo(stdout)) != 0); - const bool use_color = in_color_mode && (color != GTestColor::kDefault); -#endif // GTEST_OS_WINDOWS_MOBILE || GTEST_OS_ZOS - - if (!use_color) { - vprintf(fmt, args); - va_end(args); - return; - } - -#if GTEST_OS_WINDOWS && !GTEST_OS_WINDOWS_MOBILE && \ - !GTEST_OS_WINDOWS_PHONE && !GTEST_OS_WINDOWS_RT && !GTEST_OS_WINDOWS_MINGW - const HANDLE stdout_handle = GetStdHandle(STD_OUTPUT_HANDLE); - - // Gets the current text color. - CONSOLE_SCREEN_BUFFER_INFO buffer_info; - GetConsoleScreenBufferInfo(stdout_handle, &buffer_info); - const WORD old_color_attrs = buffer_info.wAttributes; - const WORD new_color = GetNewColor(color, old_color_attrs); - - // We need to flush the stream buffers into the console before each - // SetConsoleTextAttribute call lest it affect the text that is already - // printed but has not yet reached the console. - fflush(stdout); - SetConsoleTextAttribute(stdout_handle, new_color); - - vprintf(fmt, args); - - fflush(stdout); - // Restores the text color. - SetConsoleTextAttribute(stdout_handle, old_color_attrs); -#else - printf("\033[0;3%sm", GetAnsiColorCode(color)); - vprintf(fmt, args); - printf("\033[m"); // Resets the terminal to default. -#endif // GTEST_OS_WINDOWS && !GTEST_OS_WINDOWS_MOBILE - va_end(args); -} - -// Text printed in Google Test's text output and --gtest_list_tests -// output to label the type parameter and value parameter for a test. -static const char kTypeParamLabel[] = "TypeParam"; -static const char kValueParamLabel[] = "GetParam()"; - -static void PrintFullTestCommentIfPresent(const TestInfo& test_info) { - const char* const type_param = test_info.type_param(); - const char* const value_param = test_info.value_param(); - - if (type_param != nullptr || value_param != nullptr) { - printf(", where "); - if (type_param != nullptr) { - printf("%s = %s", kTypeParamLabel, type_param); - if (value_param != nullptr) printf(" and "); - } - if (value_param != nullptr) { - printf("%s = %s", kValueParamLabel, value_param); - } - } -} - -// This class implements the TestEventListener interface. -// -// Class PrettyUnitTestResultPrinter is copyable. -class PrettyUnitTestResultPrinter : public TestEventListener { - public: - PrettyUnitTestResultPrinter() {} - static void PrintTestName(const char* test_suite, const char* test) { - printf("%s.%s", test_suite, test); - } - - // The following methods override what's in the TestEventListener class. - void OnTestProgramStart(const UnitTest& /*unit_test*/) override {} - void OnTestIterationStart(const UnitTest& unit_test, int iteration) override; - void OnEnvironmentsSetUpStart(const UnitTest& unit_test) override; - void OnEnvironmentsSetUpEnd(const UnitTest& /*unit_test*/) override {} -#ifndef GTEST_REMOVE_LEGACY_TEST_CASEAPI_ - void OnTestCaseStart(const TestCase& test_case) override; -#else - void OnTestSuiteStart(const TestSuite& test_suite) override; -#endif // OnTestCaseStart - - void OnTestStart(const TestInfo& test_info) override; - - void OnTestPartResult(const TestPartResult& result) override; - void OnTestEnd(const TestInfo& test_info) override; -#ifndef GTEST_REMOVE_LEGACY_TEST_CASEAPI_ - void OnTestCaseEnd(const TestCase& test_case) override; -#else - void OnTestSuiteEnd(const TestSuite& test_suite) override; -#endif // GTEST_REMOVE_LEGACY_TEST_CASEAPI_ - - void OnEnvironmentsTearDownStart(const UnitTest& unit_test) override; - void OnEnvironmentsTearDownEnd(const UnitTest& /*unit_test*/) override {} - void OnTestIterationEnd(const UnitTest& unit_test, int iteration) override; - void OnTestProgramEnd(const UnitTest& /*unit_test*/) override {} - - private: - static void PrintFailedTests(const UnitTest& unit_test); - static void PrintFailedTestSuites(const UnitTest& unit_test); - static void PrintSkippedTests(const UnitTest& unit_test); -}; - - // Fired before each iteration of tests starts. -void PrettyUnitTestResultPrinter::OnTestIterationStart( - const UnitTest& unit_test, int iteration) { - if (GTEST_FLAG(repeat) != 1) - printf("\nRepeating all tests (iteration %d) . . .\n\n", iteration + 1); - - const char* const filter = GTEST_FLAG(filter).c_str(); - - // Prints the filter if it's not *. This reminds the user that some - // tests may be skipped. - if (!String::CStringEquals(filter, kUniversalFilter)) { - ColoredPrintf(GTestColor::kYellow, "Note: %s filter = %s\n", GTEST_NAME_, - filter); - } - - if (internal::ShouldShard(kTestTotalShards, kTestShardIndex, false)) { - const int32_t shard_index = Int32FromEnvOrDie(kTestShardIndex, -1); - ColoredPrintf(GTestColor::kYellow, "Note: This is test shard %d of %s.\n", - static_cast<int>(shard_index) + 1, - internal::posix::GetEnv(kTestTotalShards)); - } - - if (GTEST_FLAG(shuffle)) { - ColoredPrintf(GTestColor::kYellow, - "Note: Randomizing tests' orders with a seed of %d .\n", - unit_test.random_seed()); - } - - ColoredPrintf(GTestColor::kGreen, "[==========] "); - printf("Running %s from %s.\n", - FormatTestCount(unit_test.test_to_run_count()).c_str(), - FormatTestSuiteCount(unit_test.test_suite_to_run_count()).c_str()); - fflush(stdout); -} - -void PrettyUnitTestResultPrinter::OnEnvironmentsSetUpStart( - const UnitTest& /*unit_test*/) { - ColoredPrintf(GTestColor::kGreen, "[----------] "); - printf("Global test environment set-up.\n"); - fflush(stdout); -} - -#ifndef GTEST_REMOVE_LEGACY_TEST_CASEAPI_ -void PrettyUnitTestResultPrinter::OnTestCaseStart(const TestCase& test_case) { - const std::string counts = - FormatCountableNoun(test_case.test_to_run_count(), "test", "tests"); - ColoredPrintf(GTestColor::kGreen, "[----------] "); - printf("%s from %s", counts.c_str(), test_case.name()); - if (test_case.type_param() == nullptr) { - printf("\n"); - } else { - printf(", where %s = %s\n", kTypeParamLabel, test_case.type_param()); - } - fflush(stdout); -} -#else -void PrettyUnitTestResultPrinter::OnTestSuiteStart( - const TestSuite& test_suite) { - const std::string counts = - FormatCountableNoun(test_suite.test_to_run_count(), "test", "tests"); - ColoredPrintf(GTestColor::kGreen, "[----------] "); - printf("%s from %s", counts.c_str(), test_suite.name()); - if (test_suite.type_param() == nullptr) { - printf("\n"); - } else { - printf(", where %s = %s\n", kTypeParamLabel, test_suite.type_param()); - } - fflush(stdout); -} -#endif // GTEST_REMOVE_LEGACY_TEST_CASEAPI_ - -void PrettyUnitTestResultPrinter::OnTestStart(const TestInfo& test_info) { - ColoredPrintf(GTestColor::kGreen, "[ RUN ] "); - PrintTestName(test_info.test_suite_name(), test_info.name()); - printf("\n"); - fflush(stdout); -} - -// Called after an assertion failure. -void PrettyUnitTestResultPrinter::OnTestPartResult( - const TestPartResult& result) { - switch (result.type()) { - // If the test part succeeded, we don't need to do anything. - case TestPartResult::kSuccess: - return; - default: - // Print failure message from the assertion - // (e.g. expected this and got that). - PrintTestPartResult(result); - fflush(stdout); - } -} - -void PrettyUnitTestResultPrinter::OnTestEnd(const TestInfo& test_info) { - if (test_info.result()->Passed()) { - ColoredPrintf(GTestColor::kGreen, "[ OK ] "); - } else if (test_info.result()->Skipped()) { - ColoredPrintf(GTestColor::kGreen, "[ SKIPPED ] "); - } else { - ColoredPrintf(GTestColor::kRed, "[ FAILED ] "); - } - PrintTestName(test_info.test_suite_name(), test_info.name()); - if (test_info.result()->Failed()) - PrintFullTestCommentIfPresent(test_info); - - if (GTEST_FLAG(print_time)) { - printf(" (%s ms)\n", internal::StreamableToString( - test_info.result()->elapsed_time()).c_str()); - } else { - printf("\n"); - } - fflush(stdout); -} - -#ifndef GTEST_REMOVE_LEGACY_TEST_CASEAPI_ -void PrettyUnitTestResultPrinter::OnTestCaseEnd(const TestCase& test_case) { - if (!GTEST_FLAG(print_time)) return; - - const std::string counts = - FormatCountableNoun(test_case.test_to_run_count(), "test", "tests"); - ColoredPrintf(GTestColor::kGreen, "[----------] "); - printf("%s from %s (%s ms total)\n\n", counts.c_str(), test_case.name(), - internal::StreamableToString(test_case.elapsed_time()).c_str()); - fflush(stdout); -} -#else -void PrettyUnitTestResultPrinter::OnTestSuiteEnd(const TestSuite& test_suite) { - if (!GTEST_FLAG(print_time)) return; - - const std::string counts = - FormatCountableNoun(test_suite.test_to_run_count(), "test", "tests"); - ColoredPrintf(GTestColor::kGreen, "[----------] "); - printf("%s from %s (%s ms total)\n\n", counts.c_str(), test_suite.name(), - internal::StreamableToString(test_suite.elapsed_time()).c_str()); - fflush(stdout); -} -#endif // GTEST_REMOVE_LEGACY_TEST_CASEAPI_ - -void PrettyUnitTestResultPrinter::OnEnvironmentsTearDownStart( - const UnitTest& /*unit_test*/) { - ColoredPrintf(GTestColor::kGreen, "[----------] "); - printf("Global test environment tear-down\n"); - fflush(stdout); -} - -// Internal helper for printing the list of failed tests. -void PrettyUnitTestResultPrinter::PrintFailedTests(const UnitTest& unit_test) { - const int failed_test_count = unit_test.failed_test_count(); - ColoredPrintf(GTestColor::kRed, "[ FAILED ] "); - printf("%s, listed below:\n", FormatTestCount(failed_test_count).c_str()); - - for (int i = 0; i < unit_test.total_test_suite_count(); ++i) { - const TestSuite& test_suite = *unit_test.GetTestSuite(i); - if (!test_suite.should_run() || (test_suite.failed_test_count() == 0)) { - continue; - } - for (int j = 0; j < test_suite.total_test_count(); ++j) { - const TestInfo& test_info = *test_suite.GetTestInfo(j); - if (!test_info.should_run() || !test_info.result()->Failed()) { - continue; - } - ColoredPrintf(GTestColor::kRed, "[ FAILED ] "); - printf("%s.%s", test_suite.name(), test_info.name()); - PrintFullTestCommentIfPresent(test_info); - printf("\n"); - } - } - printf("\n%2d FAILED %s\n", failed_test_count, - failed_test_count == 1 ? "TEST" : "TESTS"); -} - -// Internal helper for printing the list of test suite failures not covered by -// PrintFailedTests. -void PrettyUnitTestResultPrinter::PrintFailedTestSuites( - const UnitTest& unit_test) { - int suite_failure_count = 0; - for (int i = 0; i < unit_test.total_test_suite_count(); ++i) { - const TestSuite& test_suite = *unit_test.GetTestSuite(i); - if (!test_suite.should_run()) { - continue; - } - if (test_suite.ad_hoc_test_result().Failed()) { - ColoredPrintf(GTestColor::kRed, "[ FAILED ] "); - printf("%s: SetUpTestSuite or TearDownTestSuite\n", test_suite.name()); - ++suite_failure_count; - } - } - if (suite_failure_count > 0) { - printf("\n%2d FAILED TEST %s\n", suite_failure_count, - suite_failure_count == 1 ? "SUITE" : "SUITES"); - } -} - -// Internal helper for printing the list of skipped tests. -void PrettyUnitTestResultPrinter::PrintSkippedTests(const UnitTest& unit_test) { - const int skipped_test_count = unit_test.skipped_test_count(); - if (skipped_test_count == 0) { - return; - } - - for (int i = 0; i < unit_test.total_test_suite_count(); ++i) { - const TestSuite& test_suite = *unit_test.GetTestSuite(i); - if (!test_suite.should_run() || (test_suite.skipped_test_count() == 0)) { - continue; - } - for (int j = 0; j < test_suite.total_test_count(); ++j) { - const TestInfo& test_info = *test_suite.GetTestInfo(j); - if (!test_info.should_run() || !test_info.result()->Skipped()) { - continue; - } - ColoredPrintf(GTestColor::kGreen, "[ SKIPPED ] "); - printf("%s.%s", test_suite.name(), test_info.name()); - printf("\n"); - } - } -} - -void PrettyUnitTestResultPrinter::OnTestIterationEnd(const UnitTest& unit_test, - int /*iteration*/) { - ColoredPrintf(GTestColor::kGreen, "[==========] "); - printf("%s from %s ran.", - FormatTestCount(unit_test.test_to_run_count()).c_str(), - FormatTestSuiteCount(unit_test.test_suite_to_run_count()).c_str()); - if (GTEST_FLAG(print_time)) { - printf(" (%s ms total)", - internal::StreamableToString(unit_test.elapsed_time()).c_str()); - } - printf("\n"); - ColoredPrintf(GTestColor::kGreen, "[ PASSED ] "); - printf("%s.\n", FormatTestCount(unit_test.successful_test_count()).c_str()); - - const int skipped_test_count = unit_test.skipped_test_count(); - if (skipped_test_count > 0) { - ColoredPrintf(GTestColor::kGreen, "[ SKIPPED ] "); - printf("%s, listed below:\n", FormatTestCount(skipped_test_count).c_str()); - PrintSkippedTests(unit_test); - } - - if (!unit_test.Passed()) { - PrintFailedTests(unit_test); - PrintFailedTestSuites(unit_test); - } - - int num_disabled = unit_test.reportable_disabled_test_count(); - if (num_disabled && !GTEST_FLAG(also_run_disabled_tests)) { - if (unit_test.Passed()) { - printf("\n"); // Add a spacer if no FAILURE banner is displayed. - } - ColoredPrintf(GTestColor::kYellow, " YOU HAVE %d DISABLED %s\n\n", - num_disabled, num_disabled == 1 ? "TEST" : "TESTS"); - } - // Ensure that Google Test output is printed before, e.g., heapchecker output. - fflush(stdout); -} - -// End PrettyUnitTestResultPrinter - -// This class implements the TestEventListener interface. -// -// Class BriefUnitTestResultPrinter is copyable. -class BriefUnitTestResultPrinter : public TestEventListener { - public: - BriefUnitTestResultPrinter() {} - static void PrintTestName(const char* test_suite, const char* test) { - printf("%s.%s", test_suite, test); - } - - // The following methods override what's in the TestEventListener class. - void OnTestProgramStart(const UnitTest& /*unit_test*/) override {} - void OnTestIterationStart(const UnitTest& /*unit_test*/, - int /*iteration*/) override {} - void OnEnvironmentsSetUpStart(const UnitTest& /*unit_test*/) override {} - void OnEnvironmentsSetUpEnd(const UnitTest& /*unit_test*/) override {} -#ifndef GTEST_REMOVE_LEGACY_TEST_CASEAPI_ - void OnTestCaseStart(const TestCase& /*test_case*/) override {} -#else - void OnTestSuiteStart(const TestSuite& /*test_suite*/) override {} -#endif // OnTestCaseStart - - void OnTestStart(const TestInfo& /*test_info*/) override {} - - void OnTestPartResult(const TestPartResult& result) override; - void OnTestEnd(const TestInfo& test_info) override; -#ifndef GTEST_REMOVE_LEGACY_TEST_CASEAPI_ - void OnTestCaseEnd(const TestCase& /*test_case*/) override {} -#else - void OnTestSuiteEnd(const TestSuite& /*test_suite*/) override {} -#endif // GTEST_REMOVE_LEGACY_TEST_CASEAPI_ - - void OnEnvironmentsTearDownStart(const UnitTest& /*unit_test*/) override {} - void OnEnvironmentsTearDownEnd(const UnitTest& /*unit_test*/) override {} - void OnTestIterationEnd(const UnitTest& unit_test, int iteration) override; - void OnTestProgramEnd(const UnitTest& /*unit_test*/) override {} -}; - -// Called after an assertion failure. -void BriefUnitTestResultPrinter::OnTestPartResult( - const TestPartResult& result) { - switch (result.type()) { - // If the test part succeeded, we don't need to do anything. - case TestPartResult::kSuccess: - return; - default: - // Print failure message from the assertion - // (e.g. expected this and got that). - PrintTestPartResult(result); - fflush(stdout); - } -} - -void BriefUnitTestResultPrinter::OnTestEnd(const TestInfo& test_info) { - if (test_info.result()->Failed()) { - ColoredPrintf(GTestColor::kRed, "[ FAILED ] "); - PrintTestName(test_info.test_suite_name(), test_info.name()); - PrintFullTestCommentIfPresent(test_info); - - if (GTEST_FLAG(print_time)) { - printf(" (%s ms)\n", - internal::StreamableToString(test_info.result()->elapsed_time()) - .c_str()); - } else { - printf("\n"); - } - fflush(stdout); - } -} - -void BriefUnitTestResultPrinter::OnTestIterationEnd(const UnitTest& unit_test, - int /*iteration*/) { - ColoredPrintf(GTestColor::kGreen, "[==========] "); - printf("%s from %s ran.", - FormatTestCount(unit_test.test_to_run_count()).c_str(), - FormatTestSuiteCount(unit_test.test_suite_to_run_count()).c_str()); - if (GTEST_FLAG(print_time)) { - printf(" (%s ms total)", - internal::StreamableToString(unit_test.elapsed_time()).c_str()); - } - printf("\n"); - ColoredPrintf(GTestColor::kGreen, "[ PASSED ] "); - printf("%s.\n", FormatTestCount(unit_test.successful_test_count()).c_str()); - - const int skipped_test_count = unit_test.skipped_test_count(); - if (skipped_test_count > 0) { - ColoredPrintf(GTestColor::kGreen, "[ SKIPPED ] "); - printf("%s.\n", FormatTestCount(skipped_test_count).c_str()); - } - - int num_disabled = unit_test.reportable_disabled_test_count(); - if (num_disabled && !GTEST_FLAG(also_run_disabled_tests)) { - if (unit_test.Passed()) { - printf("\n"); // Add a spacer if no FAILURE banner is displayed. - } - ColoredPrintf(GTestColor::kYellow, " YOU HAVE %d DISABLED %s\n\n", - num_disabled, num_disabled == 1 ? "TEST" : "TESTS"); - } - // Ensure that Google Test output is printed before, e.g., heapchecker output. - fflush(stdout); -} - -// End BriefUnitTestResultPrinter - -// class TestEventRepeater -// -// This class forwards events to other event listeners. -class TestEventRepeater : public TestEventListener { - public: - TestEventRepeater() : forwarding_enabled_(true) {} - ~TestEventRepeater() override; - void Append(TestEventListener *listener); - TestEventListener* Release(TestEventListener* listener); - - // Controls whether events will be forwarded to listeners_. Set to false - // in death test child processes. - bool forwarding_enabled() const { return forwarding_enabled_; } - void set_forwarding_enabled(bool enable) { forwarding_enabled_ = enable; } - - void OnTestProgramStart(const UnitTest& unit_test) override; - void OnTestIterationStart(const UnitTest& unit_test, int iteration) override; - void OnEnvironmentsSetUpStart(const UnitTest& unit_test) override; - void OnEnvironmentsSetUpEnd(const UnitTest& unit_test) override; -// Legacy API is deprecated but still available -#ifndef GTEST_REMOVE_LEGACY_TEST_CASEAPI_ - void OnTestCaseStart(const TestSuite& parameter) override; -#endif // GTEST_REMOVE_LEGACY_TEST_CASEAPI_ - void OnTestSuiteStart(const TestSuite& parameter) override; - void OnTestStart(const TestInfo& test_info) override; - void OnTestPartResult(const TestPartResult& result) override; - void OnTestEnd(const TestInfo& test_info) override; -// Legacy API is deprecated but still available -#ifndef GTEST_REMOVE_LEGACY_TEST_CASEAPI_ - void OnTestCaseEnd(const TestCase& parameter) override; -#endif // GTEST_REMOVE_LEGACY_TEST_CASEAPI_ - void OnTestSuiteEnd(const TestSuite& parameter) override; - void OnEnvironmentsTearDownStart(const UnitTest& unit_test) override; - void OnEnvironmentsTearDownEnd(const UnitTest& unit_test) override; - void OnTestIterationEnd(const UnitTest& unit_test, int iteration) override; - void OnTestProgramEnd(const UnitTest& unit_test) override; - - private: - // Controls whether events will be forwarded to listeners_. Set to false - // in death test child processes. - bool forwarding_enabled_; - // The list of listeners that receive events. - std::vector<TestEventListener*> listeners_; - - GTEST_DISALLOW_COPY_AND_ASSIGN_(TestEventRepeater); -}; - -TestEventRepeater::~TestEventRepeater() { - ForEach(listeners_, Delete<TestEventListener>); -} - -void TestEventRepeater::Append(TestEventListener *listener) { - listeners_.push_back(listener); -} - -TestEventListener* TestEventRepeater::Release(TestEventListener *listener) { - for (size_t i = 0; i < listeners_.size(); ++i) { - if (listeners_[i] == listener) { - listeners_.erase(listeners_.begin() + static_cast<int>(i)); - return listener; - } - } - - return nullptr; -} - -// Since most methods are very similar, use macros to reduce boilerplate. -// This defines a member that forwards the call to all listeners. -#define GTEST_REPEATER_METHOD_(Name, Type) \ -void TestEventRepeater::Name(const Type& parameter) { \ - if (forwarding_enabled_) { \ - for (size_t i = 0; i < listeners_.size(); i++) { \ - listeners_[i]->Name(parameter); \ - } \ - } \ -} -// This defines a member that forwards the call to all listeners in reverse -// order. -#define GTEST_REVERSE_REPEATER_METHOD_(Name, Type) \ - void TestEventRepeater::Name(const Type& parameter) { \ - if (forwarding_enabled_) { \ - for (size_t i = listeners_.size(); i != 0; i--) { \ - listeners_[i - 1]->Name(parameter); \ - } \ - } \ - } - -GTEST_REPEATER_METHOD_(OnTestProgramStart, UnitTest) -GTEST_REPEATER_METHOD_(OnEnvironmentsSetUpStart, UnitTest) -// Legacy API is deprecated but still available -#ifndef GTEST_REMOVE_LEGACY_TEST_CASEAPI_ -GTEST_REPEATER_METHOD_(OnTestCaseStart, TestSuite) -#endif // GTEST_REMOVE_LEGACY_TEST_CASEAPI_ -GTEST_REPEATER_METHOD_(OnTestSuiteStart, TestSuite) -GTEST_REPEATER_METHOD_(OnTestStart, TestInfo) -GTEST_REPEATER_METHOD_(OnTestPartResult, TestPartResult) -GTEST_REPEATER_METHOD_(OnEnvironmentsTearDownStart, UnitTest) -GTEST_REVERSE_REPEATER_METHOD_(OnEnvironmentsSetUpEnd, UnitTest) -GTEST_REVERSE_REPEATER_METHOD_(OnEnvironmentsTearDownEnd, UnitTest) -GTEST_REVERSE_REPEATER_METHOD_(OnTestEnd, TestInfo) -// Legacy API is deprecated but still available -#ifndef GTEST_REMOVE_LEGACY_TEST_CASEAPI_ -GTEST_REVERSE_REPEATER_METHOD_(OnTestCaseEnd, TestSuite) -#endif // GTEST_REMOVE_LEGACY_TEST_CASEAPI_ -GTEST_REVERSE_REPEATER_METHOD_(OnTestSuiteEnd, TestSuite) -GTEST_REVERSE_REPEATER_METHOD_(OnTestProgramEnd, UnitTest) - -#undef GTEST_REPEATER_METHOD_ -#undef GTEST_REVERSE_REPEATER_METHOD_ - -void TestEventRepeater::OnTestIterationStart(const UnitTest& unit_test, - int iteration) { - if (forwarding_enabled_) { - for (size_t i = 0; i < listeners_.size(); i++) { - listeners_[i]->OnTestIterationStart(unit_test, iteration); - } - } -} - -void TestEventRepeater::OnTestIterationEnd(const UnitTest& unit_test, - int iteration) { - if (forwarding_enabled_) { - for (size_t i = listeners_.size(); i > 0; i--) { - listeners_[i - 1]->OnTestIterationEnd(unit_test, iteration); - } - } -} - -// End TestEventRepeater - -// This class generates an XML output file. -class XmlUnitTestResultPrinter : public EmptyTestEventListener { - public: - explicit XmlUnitTestResultPrinter(const char* output_file); - - void OnTestIterationEnd(const UnitTest& unit_test, int iteration) override; - void ListTestsMatchingFilter(const std::vector<TestSuite*>& test_suites); - - // Prints an XML summary of all unit tests. - static void PrintXmlTestsList(std::ostream* stream, - const std::vector<TestSuite*>& test_suites); - - private: - // Is c a whitespace character that is normalized to a space character - // when it appears in an XML attribute value? - static bool IsNormalizableWhitespace(char c) { - return c == 0x9 || c == 0xA || c == 0xD; - } - - // May c appear in a well-formed XML document? - static bool IsValidXmlCharacter(char c) { - return IsNormalizableWhitespace(c) || c >= 0x20; - } - - // Returns an XML-escaped copy of the input string str. If - // is_attribute is true, the text is meant to appear as an attribute - // value, and normalizable whitespace is preserved by replacing it - // with character references. - static std::string EscapeXml(const std::string& str, bool is_attribute); - - // Returns the given string with all characters invalid in XML removed. - static std::string RemoveInvalidXmlCharacters(const std::string& str); - - // Convenience wrapper around EscapeXml when str is an attribute value. - static std::string EscapeXmlAttribute(const std::string& str) { - return EscapeXml(str, true); - } - - // Convenience wrapper around EscapeXml when str is not an attribute value. - static std::string EscapeXmlText(const char* str) { - return EscapeXml(str, false); - } - - // Verifies that the given attribute belongs to the given element and - // streams the attribute as XML. - static void OutputXmlAttribute(std::ostream* stream, - const std::string& element_name, - const std::string& name, - const std::string& value); - - // Streams an XML CDATA section, escaping invalid CDATA sequences as needed. - static void OutputXmlCDataSection(::std::ostream* stream, const char* data); - - // Streams a test suite XML stanza containing the given test result. - // - // Requires: result.Failed() - static void OutputXmlTestSuiteForTestResult(::std::ostream* stream, - const TestResult& result); - - // Streams an XML representation of a TestResult object. - static void OutputXmlTestResult(::std::ostream* stream, - const TestResult& result); - - // Streams an XML representation of a TestInfo object. - static void OutputXmlTestInfo(::std::ostream* stream, - const char* test_suite_name, - const TestInfo& test_info); - - // Prints an XML representation of a TestSuite object - static void PrintXmlTestSuite(::std::ostream* stream, - const TestSuite& test_suite); - - // Prints an XML summary of unit_test to output stream out. - static void PrintXmlUnitTest(::std::ostream* stream, - const UnitTest& unit_test); - - // Produces a string representing the test properties in a result as space - // delimited XML attributes based on the property key="value" pairs. - // When the std::string is not empty, it includes a space at the beginning, - // to delimit this attribute from prior attributes. - static std::string TestPropertiesAsXmlAttributes(const TestResult& result); - - // Streams an XML representation of the test properties of a TestResult - // object. - static void OutputXmlTestProperties(std::ostream* stream, - const TestResult& result); - - // The output file. - const std::string output_file_; - - GTEST_DISALLOW_COPY_AND_ASSIGN_(XmlUnitTestResultPrinter); -}; - -// Creates a new XmlUnitTestResultPrinter. -XmlUnitTestResultPrinter::XmlUnitTestResultPrinter(const char* output_file) - : output_file_(output_file) { - if (output_file_.empty()) { - GTEST_LOG_(FATAL) << "XML output file may not be null"; - } -} - -// Called after the unit test ends. -void XmlUnitTestResultPrinter::OnTestIterationEnd(const UnitTest& unit_test, - int /*iteration*/) { - FILE* xmlout = OpenFileForWriting(output_file_); - std::stringstream stream; - PrintXmlUnitTest(&stream, unit_test); - fprintf(xmlout, "%s", StringStreamToString(&stream).c_str()); - fclose(xmlout); -} - -void XmlUnitTestResultPrinter::ListTestsMatchingFilter( - const std::vector<TestSuite*>& test_suites) { - FILE* xmlout = OpenFileForWriting(output_file_); - std::stringstream stream; - PrintXmlTestsList(&stream, test_suites); - fprintf(xmlout, "%s", StringStreamToString(&stream).c_str()); - fclose(xmlout); -} - -// Returns an XML-escaped copy of the input string str. If is_attribute -// is true, the text is meant to appear as an attribute value, and -// normalizable whitespace is preserved by replacing it with character -// references. -// -// Invalid XML characters in str, if any, are stripped from the output. -// It is expected that most, if not all, of the text processed by this -// module will consist of ordinary English text. -// If this module is ever modified to produce version 1.1 XML output, -// most invalid characters can be retained using character references. -std::string XmlUnitTestResultPrinter::EscapeXml( - const std::string& str, bool is_attribute) { - Message m; - - for (size_t i = 0; i < str.size(); ++i) { - const char ch = str[i]; - switch (ch) { - case '<': - m << "<"; - break; - case '>': - m << ">"; - break; - case '&': - m << "&"; - break; - case '\'': - if (is_attribute) - m << "'"; - else - m << '\''; - break; - case '"': - if (is_attribute) - m << """; - else - m << '"'; - break; - default: - if (IsValidXmlCharacter(ch)) { - if (is_attribute && IsNormalizableWhitespace(ch)) - m << "&#x" << String::FormatByte(static_cast<unsigned char>(ch)) - << ";"; - else - m << ch; - } - break; - } - } - - return m.GetString(); -} - -// Returns the given string with all characters invalid in XML removed. -// Currently invalid characters are dropped from the string. An -// alternative is to replace them with certain characters such as . or ?. -std::string XmlUnitTestResultPrinter::RemoveInvalidXmlCharacters( - const std::string& str) { - std::string output; - output.reserve(str.size()); - for (std::string::const_iterator it = str.begin(); it != str.end(); ++it) - if (IsValidXmlCharacter(*it)) - output.push_back(*it); - - return output; -} - -// The following routines generate an XML representation of a UnitTest -// object. -// GOOGLETEST_CM0009 DO NOT DELETE -// -// This is how Google Test concepts map to the DTD: -// -// <testsuites name="AllTests"> <-- corresponds to a UnitTest object -// <testsuite name="testcase-name"> <-- corresponds to a TestSuite object -// <testcase name="test-name"> <-- corresponds to a TestInfo object -// <failure message="...">...</failure> -// <failure message="...">...</failure> -// <failure message="...">...</failure> -// <-- individual assertion failures -// </testcase> -// </testsuite> -// </testsuites> - -// Formats the given time in milliseconds as seconds. -std::string FormatTimeInMillisAsSeconds(TimeInMillis ms) { - ::std::stringstream ss; - ss << (static_cast<double>(ms) * 1e-3); - return ss.str(); -} - -static bool PortableLocaltime(time_t seconds, struct tm* out) { -#if defined(_MSC_VER) - return localtime_s(out, &seconds) == 0; -#elif defined(__MINGW32__) || defined(__MINGW64__) - // MINGW <time.h> provides neither localtime_r nor localtime_s, but uses - // Windows' localtime(), which has a thread-local tm buffer. - struct tm* tm_ptr = localtime(&seconds); // NOLINT - if (tm_ptr == nullptr) return false; - *out = *tm_ptr; - return true; -#elif defined(__STDC_LIB_EXT1__) - // Uses localtime_s when available as localtime_r is only available from - // C23 standard. - return localtime_s(&seconds, out) != nullptr; -#else - return localtime_r(&seconds, out) != nullptr; -#endif -} - -// Converts the given epoch time in milliseconds to a date string in the ISO -// 8601 format, without the timezone information. -std::string FormatEpochTimeInMillisAsIso8601(TimeInMillis ms) { - struct tm time_struct; - if (!PortableLocaltime(static_cast<time_t>(ms / 1000), &time_struct)) - return ""; - // YYYY-MM-DDThh:mm:ss.sss - return StreamableToString(time_struct.tm_year + 1900) + "-" + - String::FormatIntWidth2(time_struct.tm_mon + 1) + "-" + - String::FormatIntWidth2(time_struct.tm_mday) + "T" + - String::FormatIntWidth2(time_struct.tm_hour) + ":" + - String::FormatIntWidth2(time_struct.tm_min) + ":" + - String::FormatIntWidth2(time_struct.tm_sec) + "." + - String::FormatIntWidthN(static_cast<int>(ms % 1000), 3); -} - -// Streams an XML CDATA section, escaping invalid CDATA sequences as needed. -void XmlUnitTestResultPrinter::OutputXmlCDataSection(::std::ostream* stream, - const char* data) { - const char* segment = data; - *stream << "<![CDATA["; - for (;;) { - const char* const next_segment = strstr(segment, "]]>"); - if (next_segment != nullptr) { - stream->write( - segment, static_cast<std::streamsize>(next_segment - segment)); - *stream << "]]>]]><![CDATA["; - segment = next_segment + strlen("]]>"); - } else { - *stream << segment; - break; - } - } - *stream << "]]>"; -} - -void XmlUnitTestResultPrinter::OutputXmlAttribute( - std::ostream* stream, - const std::string& element_name, - const std::string& name, - const std::string& value) { - const std::vector<std::string>& allowed_names = - GetReservedOutputAttributesForElement(element_name); - - GTEST_CHECK_(std::find(allowed_names.begin(), allowed_names.end(), name) != - allowed_names.end()) - << "Attribute " << name << " is not allowed for element <" << element_name - << ">."; - - *stream << " " << name << "=\"" << EscapeXmlAttribute(value) << "\""; -} - -// Streams a test suite XML stanza containing the given test result. -void XmlUnitTestResultPrinter::OutputXmlTestSuiteForTestResult( - ::std::ostream* stream, const TestResult& result) { - // Output the boilerplate for a minimal test suite with one test. - *stream << " <testsuite"; - OutputXmlAttribute(stream, "testsuite", "name", "NonTestSuiteFailure"); - OutputXmlAttribute(stream, "testsuite", "tests", "1"); - OutputXmlAttribute(stream, "testsuite", "failures", "1"); - OutputXmlAttribute(stream, "testsuite", "disabled", "0"); - OutputXmlAttribute(stream, "testsuite", "skipped", "0"); - OutputXmlAttribute(stream, "testsuite", "errors", "0"); - OutputXmlAttribute(stream, "testsuite", "time", - FormatTimeInMillisAsSeconds(result.elapsed_time())); - OutputXmlAttribute( - stream, "testsuite", "timestamp", - FormatEpochTimeInMillisAsIso8601(result.start_timestamp())); - *stream << ">"; - - // Output the boilerplate for a minimal test case with a single test. - *stream << " <testcase"; - OutputXmlAttribute(stream, "testcase", "name", ""); - OutputXmlAttribute(stream, "testcase", "status", "run"); - OutputXmlAttribute(stream, "testcase", "result", "completed"); - OutputXmlAttribute(stream, "testcase", "classname", ""); - OutputXmlAttribute(stream, "testcase", "time", - FormatTimeInMillisAsSeconds(result.elapsed_time())); - OutputXmlAttribute( - stream, "testcase", "timestamp", - FormatEpochTimeInMillisAsIso8601(result.start_timestamp())); - - // Output the actual test result. - OutputXmlTestResult(stream, result); - - // Complete the test suite. - *stream << " </testsuite>\n"; -} - -// Prints an XML representation of a TestInfo object. -void XmlUnitTestResultPrinter::OutputXmlTestInfo(::std::ostream* stream, - const char* test_suite_name, - const TestInfo& test_info) { - const TestResult& result = *test_info.result(); - const std::string kTestsuite = "testcase"; - - if (test_info.is_in_another_shard()) { - return; - } - - *stream << " <testcase"; - OutputXmlAttribute(stream, kTestsuite, "name", test_info.name()); - - if (test_info.value_param() != nullptr) { - OutputXmlAttribute(stream, kTestsuite, "value_param", - test_info.value_param()); - } - if (test_info.type_param() != nullptr) { - OutputXmlAttribute(stream, kTestsuite, "type_param", - test_info.type_param()); - } - if (GTEST_FLAG(list_tests)) { - OutputXmlAttribute(stream, kTestsuite, "file", test_info.file()); - OutputXmlAttribute(stream, kTestsuite, "line", - StreamableToString(test_info.line())); - *stream << " />\n"; - return; - } - - OutputXmlAttribute(stream, kTestsuite, "status", - test_info.should_run() ? "run" : "notrun"); - OutputXmlAttribute(stream, kTestsuite, "result", - test_info.should_run() - ? (result.Skipped() ? "skipped" : "completed") - : "suppressed"); - OutputXmlAttribute(stream, kTestsuite, "time", - FormatTimeInMillisAsSeconds(result.elapsed_time())); - OutputXmlAttribute( - stream, kTestsuite, "timestamp", - FormatEpochTimeInMillisAsIso8601(result.start_timestamp())); - OutputXmlAttribute(stream, kTestsuite, "classname", test_suite_name); - - OutputXmlTestResult(stream, result); -} - -void XmlUnitTestResultPrinter::OutputXmlTestResult(::std::ostream* stream, - const TestResult& result) { - int failures = 0; - int skips = 0; - for (int i = 0; i < result.total_part_count(); ++i) { - const TestPartResult& part = result.GetTestPartResult(i); - if (part.failed()) { - if (++failures == 1 && skips == 0) { - *stream << ">\n"; - } - const std::string location = - internal::FormatCompilerIndependentFileLocation(part.file_name(), - part.line_number()); - const std::string summary = location + "\n" + part.summary(); - *stream << " <failure message=\"" - << EscapeXmlAttribute(summary) - << "\" type=\"\">"; - const std::string detail = location + "\n" + part.message(); - OutputXmlCDataSection(stream, RemoveInvalidXmlCharacters(detail).c_str()); - *stream << "</failure>\n"; - } else if (part.skipped()) { - if (++skips == 1 && failures == 0) { - *stream << ">\n"; - } - const std::string location = - internal::FormatCompilerIndependentFileLocation(part.file_name(), - part.line_number()); - const std::string summary = location + "\n" + part.summary(); - *stream << " <skipped message=\"" - << EscapeXmlAttribute(summary.c_str()) << "\">"; - const std::string detail = location + "\n" + part.message(); - OutputXmlCDataSection(stream, RemoveInvalidXmlCharacters(detail).c_str()); - *stream << "</skipped>\n"; - } - } - - if (failures == 0 && skips == 0 && result.test_property_count() == 0) { - *stream << " />\n"; - } else { - if (failures == 0 && skips == 0) { - *stream << ">\n"; - } - OutputXmlTestProperties(stream, result); - *stream << " </testcase>\n"; - } -} - -// Prints an XML representation of a TestSuite object -void XmlUnitTestResultPrinter::PrintXmlTestSuite(std::ostream* stream, - const TestSuite& test_suite) { - const std::string kTestsuite = "testsuite"; - *stream << " <" << kTestsuite; - OutputXmlAttribute(stream, kTestsuite, "name", test_suite.name()); - OutputXmlAttribute(stream, kTestsuite, "tests", - StreamableToString(test_suite.reportable_test_count())); - if (!GTEST_FLAG(list_tests)) { - OutputXmlAttribute(stream, kTestsuite, "failures", - StreamableToString(test_suite.failed_test_count())); - OutputXmlAttribute( - stream, kTestsuite, "disabled", - StreamableToString(test_suite.reportable_disabled_test_count())); - OutputXmlAttribute(stream, kTestsuite, "skipped", - StreamableToString(test_suite.skipped_test_count())); - - OutputXmlAttribute(stream, kTestsuite, "errors", "0"); - - OutputXmlAttribute(stream, kTestsuite, "time", - FormatTimeInMillisAsSeconds(test_suite.elapsed_time())); - OutputXmlAttribute( - stream, kTestsuite, "timestamp", - FormatEpochTimeInMillisAsIso8601(test_suite.start_timestamp())); - *stream << TestPropertiesAsXmlAttributes(test_suite.ad_hoc_test_result()); - } - *stream << ">\n"; - for (int i = 0; i < test_suite.total_test_count(); ++i) { - if (test_suite.GetTestInfo(i)->is_reportable()) - OutputXmlTestInfo(stream, test_suite.name(), *test_suite.GetTestInfo(i)); - } - *stream << " </" << kTestsuite << ">\n"; -} - -// Prints an XML summary of unit_test to output stream out. -void XmlUnitTestResultPrinter::PrintXmlUnitTest(std::ostream* stream, - const UnitTest& unit_test) { - const std::string kTestsuites = "testsuites"; - - *stream << "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n"; - *stream << "<" << kTestsuites; - - OutputXmlAttribute(stream, kTestsuites, "tests", - StreamableToString(unit_test.reportable_test_count())); - OutputXmlAttribute(stream, kTestsuites, "failures", - StreamableToString(unit_test.failed_test_count())); - OutputXmlAttribute( - stream, kTestsuites, "disabled", - StreamableToString(unit_test.reportable_disabled_test_count())); - OutputXmlAttribute(stream, kTestsuites, "errors", "0"); - OutputXmlAttribute(stream, kTestsuites, "time", - FormatTimeInMillisAsSeconds(unit_test.elapsed_time())); - OutputXmlAttribute( - stream, kTestsuites, "timestamp", - FormatEpochTimeInMillisAsIso8601(unit_test.start_timestamp())); - - if (GTEST_FLAG(shuffle)) { - OutputXmlAttribute(stream, kTestsuites, "random_seed", - StreamableToString(unit_test.random_seed())); - } - *stream << TestPropertiesAsXmlAttributes(unit_test.ad_hoc_test_result()); - - OutputXmlAttribute(stream, kTestsuites, "name", "AllTests"); - *stream << ">\n"; - - for (int i = 0; i < unit_test.total_test_suite_count(); ++i) { - if (unit_test.GetTestSuite(i)->reportable_test_count() > 0) - PrintXmlTestSuite(stream, *unit_test.GetTestSuite(i)); - } - - // If there was a test failure outside of one of the test suites (like in a - // test environment) include that in the output. - if (unit_test.ad_hoc_test_result().Failed()) { - OutputXmlTestSuiteForTestResult(stream, unit_test.ad_hoc_test_result()); - } - - *stream << "</" << kTestsuites << ">\n"; -} - -void XmlUnitTestResultPrinter::PrintXmlTestsList( - std::ostream* stream, const std::vector<TestSuite*>& test_suites) { - const std::string kTestsuites = "testsuites"; - - *stream << "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n"; - *stream << "<" << kTestsuites; - - int total_tests = 0; - for (auto test_suite : test_suites) { - total_tests += test_suite->total_test_count(); - } - OutputXmlAttribute(stream, kTestsuites, "tests", - StreamableToString(total_tests)); - OutputXmlAttribute(stream, kTestsuites, "name", "AllTests"); - *stream << ">\n"; - - for (auto test_suite : test_suites) { - PrintXmlTestSuite(stream, *test_suite); - } - *stream << "</" << kTestsuites << ">\n"; -} - -// Produces a string representing the test properties in a result as space -// delimited XML attributes based on the property key="value" pairs. -std::string XmlUnitTestResultPrinter::TestPropertiesAsXmlAttributes( - const TestResult& result) { - Message attributes; - for (int i = 0; i < result.test_property_count(); ++i) { - const TestProperty& property = result.GetTestProperty(i); - attributes << " " << property.key() << "=" - << "\"" << EscapeXmlAttribute(property.value()) << "\""; - } - return attributes.GetString(); -} - -void XmlUnitTestResultPrinter::OutputXmlTestProperties( - std::ostream* stream, const TestResult& result) { - const std::string kProperties = "properties"; - const std::string kProperty = "property"; - - if (result.test_property_count() <= 0) { - return; - } - - *stream << "<" << kProperties << ">\n"; - for (int i = 0; i < result.test_property_count(); ++i) { - const TestProperty& property = result.GetTestProperty(i); - *stream << "<" << kProperty; - *stream << " name=\"" << EscapeXmlAttribute(property.key()) << "\""; - *stream << " value=\"" << EscapeXmlAttribute(property.value()) << "\""; - *stream << "/>\n"; - } - *stream << "</" << kProperties << ">\n"; -} - -// End XmlUnitTestResultPrinter - -// This class generates an JSON output file. -class JsonUnitTestResultPrinter : public EmptyTestEventListener { - public: - explicit JsonUnitTestResultPrinter(const char* output_file); - - void OnTestIterationEnd(const UnitTest& unit_test, int iteration) override; - - // Prints an JSON summary of all unit tests. - static void PrintJsonTestList(::std::ostream* stream, - const std::vector<TestSuite*>& test_suites); - - private: - // Returns an JSON-escaped copy of the input string str. - static std::string EscapeJson(const std::string& str); - - //// Verifies that the given attribute belongs to the given element and - //// streams the attribute as JSON. - static void OutputJsonKey(std::ostream* stream, - const std::string& element_name, - const std::string& name, - const std::string& value, - const std::string& indent, - bool comma = true); - static void OutputJsonKey(std::ostream* stream, - const std::string& element_name, - const std::string& name, - int value, - const std::string& indent, - bool comma = true); - - // Streams a test suite JSON stanza containing the given test result. - // - // Requires: result.Failed() - static void OutputJsonTestSuiteForTestResult(::std::ostream* stream, - const TestResult& result); - - // Streams a JSON representation of a TestResult object. - static void OutputJsonTestResult(::std::ostream* stream, - const TestResult& result); - - // Streams a JSON representation of a TestInfo object. - static void OutputJsonTestInfo(::std::ostream* stream, - const char* test_suite_name, - const TestInfo& test_info); - - // Prints a JSON representation of a TestSuite object - static void PrintJsonTestSuite(::std::ostream* stream, - const TestSuite& test_suite); - - // Prints a JSON summary of unit_test to output stream out. - static void PrintJsonUnitTest(::std::ostream* stream, - const UnitTest& unit_test); - - // Produces a string representing the test properties in a result as - // a JSON dictionary. - static std::string TestPropertiesAsJson(const TestResult& result, - const std::string& indent); - - // The output file. - const std::string output_file_; - - GTEST_DISALLOW_COPY_AND_ASSIGN_(JsonUnitTestResultPrinter); -}; - -// Creates a new JsonUnitTestResultPrinter. -JsonUnitTestResultPrinter::JsonUnitTestResultPrinter(const char* output_file) - : output_file_(output_file) { - if (output_file_.empty()) { - GTEST_LOG_(FATAL) << "JSON output file may not be null"; - } -} - -void JsonUnitTestResultPrinter::OnTestIterationEnd(const UnitTest& unit_test, - int /*iteration*/) { - FILE* jsonout = OpenFileForWriting(output_file_); - std::stringstream stream; - PrintJsonUnitTest(&stream, unit_test); - fprintf(jsonout, "%s", StringStreamToString(&stream).c_str()); - fclose(jsonout); -} - -// Returns an JSON-escaped copy of the input string str. -std::string JsonUnitTestResultPrinter::EscapeJson(const std::string& str) { - Message m; - - for (size_t i = 0; i < str.size(); ++i) { - const char ch = str[i]; - switch (ch) { - case '\\': - case '"': - case '/': - m << '\\' << ch; - break; - case '\b': - m << "\\b"; - break; - case '\t': - m << "\\t"; - break; - case '\n': - m << "\\n"; - break; - case '\f': - m << "\\f"; - break; - case '\r': - m << "\\r"; - break; - default: - if (ch < ' ') { - m << "\\u00" << String::FormatByte(static_cast<unsigned char>(ch)); - } else { - m << ch; - } - break; - } - } - - return m.GetString(); -} - -// The following routines generate an JSON representation of a UnitTest -// object. - -// Formats the given time in milliseconds as seconds. -static std::string FormatTimeInMillisAsDuration(TimeInMillis ms) { - ::std::stringstream ss; - ss << (static_cast<double>(ms) * 1e-3) << "s"; - return ss.str(); -} - -// Converts the given epoch time in milliseconds to a date string in the -// RFC3339 format, without the timezone information. -static std::string FormatEpochTimeInMillisAsRFC3339(TimeInMillis ms) { - struct tm time_struct; - if (!PortableLocaltime(static_cast<time_t>(ms / 1000), &time_struct)) - return ""; - // YYYY-MM-DDThh:mm:ss - return StreamableToString(time_struct.tm_year + 1900) + "-" + - String::FormatIntWidth2(time_struct.tm_mon + 1) + "-" + - String::FormatIntWidth2(time_struct.tm_mday) + "T" + - String::FormatIntWidth2(time_struct.tm_hour) + ":" + - String::FormatIntWidth2(time_struct.tm_min) + ":" + - String::FormatIntWidth2(time_struct.tm_sec) + "Z"; -} - -static inline std::string Indent(size_t width) { - return std::string(width, ' '); -} - -void JsonUnitTestResultPrinter::OutputJsonKey( - std::ostream* stream, - const std::string& element_name, - const std::string& name, - const std::string& value, - const std::string& indent, - bool comma) { - const std::vector<std::string>& allowed_names = - GetReservedOutputAttributesForElement(element_name); - - GTEST_CHECK_(std::find(allowed_names.begin(), allowed_names.end(), name) != - allowed_names.end()) - << "Key \"" << name << "\" is not allowed for value \"" << element_name - << "\"."; - - *stream << indent << "\"" << name << "\": \"" << EscapeJson(value) << "\""; - if (comma) - *stream << ",\n"; -} - -void JsonUnitTestResultPrinter::OutputJsonKey( - std::ostream* stream, - const std::string& element_name, - const std::string& name, - int value, - const std::string& indent, - bool comma) { - const std::vector<std::string>& allowed_names = - GetReservedOutputAttributesForElement(element_name); - - GTEST_CHECK_(std::find(allowed_names.begin(), allowed_names.end(), name) != - allowed_names.end()) - << "Key \"" << name << "\" is not allowed for value \"" << element_name - << "\"."; - - *stream << indent << "\"" << name << "\": " << StreamableToString(value); - if (comma) - *stream << ",\n"; -} - -// Streams a test suite JSON stanza containing the given test result. -void JsonUnitTestResultPrinter::OutputJsonTestSuiteForTestResult( - ::std::ostream* stream, const TestResult& result) { - // Output the boilerplate for a new test suite. - *stream << Indent(4) << "{\n"; - OutputJsonKey(stream, "testsuite", "name", "NonTestSuiteFailure", Indent(6)); - OutputJsonKey(stream, "testsuite", "tests", 1, Indent(6)); - if (!GTEST_FLAG(list_tests)) { - OutputJsonKey(stream, "testsuite", "failures", 1, Indent(6)); - OutputJsonKey(stream, "testsuite", "disabled", 0, Indent(6)); - OutputJsonKey(stream, "testsuite", "skipped", 0, Indent(6)); - OutputJsonKey(stream, "testsuite", "errors", 0, Indent(6)); - OutputJsonKey(stream, "testsuite", "time", - FormatTimeInMillisAsDuration(result.elapsed_time()), - Indent(6)); - OutputJsonKey(stream, "testsuite", "timestamp", - FormatEpochTimeInMillisAsRFC3339(result.start_timestamp()), - Indent(6)); - } - *stream << Indent(6) << "\"testsuite\": [\n"; - - // Output the boilerplate for a new test case. - *stream << Indent(8) << "{\n"; - OutputJsonKey(stream, "testcase", "name", "", Indent(10)); - OutputJsonKey(stream, "testcase", "status", "RUN", Indent(10)); - OutputJsonKey(stream, "testcase", "result", "COMPLETED", Indent(10)); - OutputJsonKey(stream, "testcase", "timestamp", - FormatEpochTimeInMillisAsRFC3339(result.start_timestamp()), - Indent(10)); - OutputJsonKey(stream, "testcase", "time", - FormatTimeInMillisAsDuration(result.elapsed_time()), - Indent(10)); - OutputJsonKey(stream, "testcase", "classname", "", Indent(10), false); - *stream << TestPropertiesAsJson(result, Indent(10)); - - // Output the actual test result. - OutputJsonTestResult(stream, result); - - // Finish the test suite. - *stream << "\n" << Indent(6) << "]\n" << Indent(4) << "}"; -} - -// Prints a JSON representation of a TestInfo object. -void JsonUnitTestResultPrinter::OutputJsonTestInfo(::std::ostream* stream, - const char* test_suite_name, - const TestInfo& test_info) { - const TestResult& result = *test_info.result(); - const std::string kTestsuite = "testcase"; - const std::string kIndent = Indent(10); - - *stream << Indent(8) << "{\n"; - OutputJsonKey(stream, kTestsuite, "name", test_info.name(), kIndent); - - if (test_info.value_param() != nullptr) { - OutputJsonKey(stream, kTestsuite, "value_param", test_info.value_param(), - kIndent); - } - if (test_info.type_param() != nullptr) { - OutputJsonKey(stream, kTestsuite, "type_param", test_info.type_param(), - kIndent); - } - if (GTEST_FLAG(list_tests)) { - OutputJsonKey(stream, kTestsuite, "file", test_info.file(), kIndent); - OutputJsonKey(stream, kTestsuite, "line", test_info.line(), kIndent, false); - *stream << "\n" << Indent(8) << "}"; - return; - } - - OutputJsonKey(stream, kTestsuite, "status", - test_info.should_run() ? "RUN" : "NOTRUN", kIndent); - OutputJsonKey(stream, kTestsuite, "result", - test_info.should_run() - ? (result.Skipped() ? "SKIPPED" : "COMPLETED") - : "SUPPRESSED", - kIndent); - OutputJsonKey(stream, kTestsuite, "timestamp", - FormatEpochTimeInMillisAsRFC3339(result.start_timestamp()), - kIndent); - OutputJsonKey(stream, kTestsuite, "time", - FormatTimeInMillisAsDuration(result.elapsed_time()), kIndent); - OutputJsonKey(stream, kTestsuite, "classname", test_suite_name, kIndent, - false); - *stream << TestPropertiesAsJson(result, kIndent); - - OutputJsonTestResult(stream, result); -} - -void JsonUnitTestResultPrinter::OutputJsonTestResult(::std::ostream* stream, - const TestResult& result) { - const std::string kIndent = Indent(10); - - int failures = 0; - for (int i = 0; i < result.total_part_count(); ++i) { - const TestPartResult& part = result.GetTestPartResult(i); - if (part.failed()) { - *stream << ",\n"; - if (++failures == 1) { - *stream << kIndent << "\"" << "failures" << "\": [\n"; - } - const std::string location = - internal::FormatCompilerIndependentFileLocation(part.file_name(), - part.line_number()); - const std::string message = EscapeJson(location + "\n" + part.message()); - *stream << kIndent << " {\n" - << kIndent << " \"failure\": \"" << message << "\",\n" - << kIndent << " \"type\": \"\"\n" - << kIndent << " }"; - } - } - - if (failures > 0) - *stream << "\n" << kIndent << "]"; - *stream << "\n" << Indent(8) << "}"; -} - -// Prints an JSON representation of a TestSuite object -void JsonUnitTestResultPrinter::PrintJsonTestSuite( - std::ostream* stream, const TestSuite& test_suite) { - const std::string kTestsuite = "testsuite"; - const std::string kIndent = Indent(6); - - *stream << Indent(4) << "{\n"; - OutputJsonKey(stream, kTestsuite, "name", test_suite.name(), kIndent); - OutputJsonKey(stream, kTestsuite, "tests", test_suite.reportable_test_count(), - kIndent); - if (!GTEST_FLAG(list_tests)) { - OutputJsonKey(stream, kTestsuite, "failures", - test_suite.failed_test_count(), kIndent); - OutputJsonKey(stream, kTestsuite, "disabled", - test_suite.reportable_disabled_test_count(), kIndent); - OutputJsonKey(stream, kTestsuite, "errors", 0, kIndent); - OutputJsonKey( - stream, kTestsuite, "timestamp", - FormatEpochTimeInMillisAsRFC3339(test_suite.start_timestamp()), - kIndent); - OutputJsonKey(stream, kTestsuite, "time", - FormatTimeInMillisAsDuration(test_suite.elapsed_time()), - kIndent, false); - *stream << TestPropertiesAsJson(test_suite.ad_hoc_test_result(), kIndent) - << ",\n"; - } - - *stream << kIndent << "\"" << kTestsuite << "\": [\n"; - - bool comma = false; - for (int i = 0; i < test_suite.total_test_count(); ++i) { - if (test_suite.GetTestInfo(i)->is_reportable()) { - if (comma) { - *stream << ",\n"; - } else { - comma = true; - } - OutputJsonTestInfo(stream, test_suite.name(), *test_suite.GetTestInfo(i)); - } - } - *stream << "\n" << kIndent << "]\n" << Indent(4) << "}"; -} - -// Prints a JSON summary of unit_test to output stream out. -void JsonUnitTestResultPrinter::PrintJsonUnitTest(std::ostream* stream, - const UnitTest& unit_test) { - const std::string kTestsuites = "testsuites"; - const std::string kIndent = Indent(2); - *stream << "{\n"; - - OutputJsonKey(stream, kTestsuites, "tests", unit_test.reportable_test_count(), - kIndent); - OutputJsonKey(stream, kTestsuites, "failures", unit_test.failed_test_count(), - kIndent); - OutputJsonKey(stream, kTestsuites, "disabled", - unit_test.reportable_disabled_test_count(), kIndent); - OutputJsonKey(stream, kTestsuites, "errors", 0, kIndent); - if (GTEST_FLAG(shuffle)) { - OutputJsonKey(stream, kTestsuites, "random_seed", unit_test.random_seed(), - kIndent); - } - OutputJsonKey(stream, kTestsuites, "timestamp", - FormatEpochTimeInMillisAsRFC3339(unit_test.start_timestamp()), - kIndent); - OutputJsonKey(stream, kTestsuites, "time", - FormatTimeInMillisAsDuration(unit_test.elapsed_time()), kIndent, - false); - - *stream << TestPropertiesAsJson(unit_test.ad_hoc_test_result(), kIndent) - << ",\n"; - - OutputJsonKey(stream, kTestsuites, "name", "AllTests", kIndent); - *stream << kIndent << "\"" << kTestsuites << "\": [\n"; - - bool comma = false; - for (int i = 0; i < unit_test.total_test_suite_count(); ++i) { - if (unit_test.GetTestSuite(i)->reportable_test_count() > 0) { - if (comma) { - *stream << ",\n"; - } else { - comma = true; - } - PrintJsonTestSuite(stream, *unit_test.GetTestSuite(i)); - } - } - - // If there was a test failure outside of one of the test suites (like in a - // test environment) include that in the output. - if (unit_test.ad_hoc_test_result().Failed()) { - OutputJsonTestSuiteForTestResult(stream, unit_test.ad_hoc_test_result()); - } - - *stream << "\n" << kIndent << "]\n" << "}\n"; -} - -void JsonUnitTestResultPrinter::PrintJsonTestList( - std::ostream* stream, const std::vector<TestSuite*>& test_suites) { - const std::string kTestsuites = "testsuites"; - const std::string kIndent = Indent(2); - *stream << "{\n"; - int total_tests = 0; - for (auto test_suite : test_suites) { - total_tests += test_suite->total_test_count(); - } - OutputJsonKey(stream, kTestsuites, "tests", total_tests, kIndent); - - OutputJsonKey(stream, kTestsuites, "name", "AllTests", kIndent); - *stream << kIndent << "\"" << kTestsuites << "\": [\n"; - - for (size_t i = 0; i < test_suites.size(); ++i) { - if (i != 0) { - *stream << ",\n"; - } - PrintJsonTestSuite(stream, *test_suites[i]); - } - - *stream << "\n" - << kIndent << "]\n" - << "}\n"; -} -// Produces a string representing the test properties in a result as -// a JSON dictionary. -std::string JsonUnitTestResultPrinter::TestPropertiesAsJson( - const TestResult& result, const std::string& indent) { - Message attributes; - for (int i = 0; i < result.test_property_count(); ++i) { - const TestProperty& property = result.GetTestProperty(i); - attributes << ",\n" << indent << "\"" << property.key() << "\": " - << "\"" << EscapeJson(property.value()) << "\""; - } - return attributes.GetString(); -} - -// End JsonUnitTestResultPrinter - -#if GTEST_CAN_STREAM_RESULTS_ - -// Checks if str contains '=', '&', '%' or '\n' characters. If yes, -// replaces them by "%xx" where xx is their hexadecimal value. For -// example, replaces "=" with "%3D". This algorithm is O(strlen(str)) -// in both time and space -- important as the input str may contain an -// arbitrarily long test failure message and stack trace. -std::string StreamingListener::UrlEncode(const char* str) { - std::string result; - result.reserve(strlen(str) + 1); - for (char ch = *str; ch != '\0'; ch = *++str) { - switch (ch) { - case '%': - case '=': - case '&': - case '\n': - result.append("%" + String::FormatByte(static_cast<unsigned char>(ch))); - break; - default: - result.push_back(ch); - break; - } - } - return result; -} - -void StreamingListener::SocketWriter::MakeConnection() { - GTEST_CHECK_(sockfd_ == -1) - << "MakeConnection() can't be called when there is already a connection."; - - addrinfo hints; - memset(&hints, 0, sizeof(hints)); - hints.ai_family = AF_UNSPEC; // To allow both IPv4 and IPv6 addresses. - hints.ai_socktype = SOCK_STREAM; - addrinfo* servinfo = nullptr; - - // Use the getaddrinfo() to get a linked list of IP addresses for - // the given host name. - const int error_num = getaddrinfo( - host_name_.c_str(), port_num_.c_str(), &hints, &servinfo); - if (error_num != 0) { - GTEST_LOG_(WARNING) << "stream_result_to: getaddrinfo() failed: " - << gai_strerror(error_num); - } - - // Loop through all the results and connect to the first we can. - for (addrinfo* cur_addr = servinfo; sockfd_ == -1 && cur_addr != nullptr; - cur_addr = cur_addr->ai_next) { - sockfd_ = socket( - cur_addr->ai_family, cur_addr->ai_socktype, cur_addr->ai_protocol); - if (sockfd_ != -1) { - // Connect the client socket to the server socket. - if (connect(sockfd_, cur_addr->ai_addr, cur_addr->ai_addrlen) == -1) { - close(sockfd_); - sockfd_ = -1; - } - } - } - - freeaddrinfo(servinfo); // all done with this structure - - if (sockfd_ == -1) { - GTEST_LOG_(WARNING) << "stream_result_to: failed to connect to " - << host_name_ << ":" << port_num_; - } -} - -// End of class Streaming Listener -#endif // GTEST_CAN_STREAM_RESULTS__ - -// class OsStackTraceGetter - -const char* const OsStackTraceGetterInterface::kElidedFramesMarker = - "... " GTEST_NAME_ " internal frames ..."; - -std::string OsStackTraceGetter::CurrentStackTrace(int max_depth, int skip_count) - GTEST_LOCK_EXCLUDED_(mutex_) { -#if GTEST_HAS_ABSL - std::string result; - - if (max_depth <= 0) { - return result; - } - - max_depth = std::min(max_depth, kMaxStackTraceDepth); - - std::vector<void*> raw_stack(max_depth); - // Skips the frames requested by the caller, plus this function. - const int raw_stack_size = - absl::GetStackTrace(&raw_stack[0], max_depth, skip_count + 1); - - void* caller_frame = nullptr; - { - MutexLock lock(&mutex_); - caller_frame = caller_frame_; - } - - for (int i = 0; i < raw_stack_size; ++i) { - if (raw_stack[i] == caller_frame && - !GTEST_FLAG(show_internal_stack_frames)) { - // Add a marker to the trace and stop adding frames. - absl::StrAppend(&result, kElidedFramesMarker, "\n"); - break; - } - - char tmp[1024]; - const char* symbol = "(unknown)"; - if (absl::Symbolize(raw_stack[i], tmp, sizeof(tmp))) { - symbol = tmp; - } - - char line[1024]; - snprintf(line, sizeof(line), " %p: %s\n", raw_stack[i], symbol); - result += line; - } - - return result; - -#else // !GTEST_HAS_ABSL - static_cast<void>(max_depth); - static_cast<void>(skip_count); - return ""; -#endif // GTEST_HAS_ABSL -} - -void OsStackTraceGetter::UponLeavingGTest() GTEST_LOCK_EXCLUDED_(mutex_) { -#if GTEST_HAS_ABSL - void* caller_frame = nullptr; - if (absl::GetStackTrace(&caller_frame, 1, 3) <= 0) { - caller_frame = nullptr; - } - - MutexLock lock(&mutex_); - caller_frame_ = caller_frame; -#endif // GTEST_HAS_ABSL -} - -// A helper class that creates the premature-exit file in its -// constructor and deletes the file in its destructor. -class ScopedPrematureExitFile { - public: - explicit ScopedPrematureExitFile(const char* premature_exit_filepath) - : premature_exit_filepath_(premature_exit_filepath ? - premature_exit_filepath : "") { - // If a path to the premature-exit file is specified... - if (!premature_exit_filepath_.empty()) { - // create the file with a single "0" character in it. I/O - // errors are ignored as there's nothing better we can do and we - // don't want to fail the test because of this. - FILE* pfile = posix::FOpen(premature_exit_filepath, "w"); - fwrite("0", 1, 1, pfile); - fclose(pfile); - } - } - - ~ScopedPrematureExitFile() { -#if !defined GTEST_OS_ESP8266 - if (!premature_exit_filepath_.empty()) { - int retval = remove(premature_exit_filepath_.c_str()); - if (retval) { - GTEST_LOG_(ERROR) << "Failed to remove premature exit filepath \"" - << premature_exit_filepath_ << "\" with error " - << retval; - } - } -#endif - } - - private: - const std::string premature_exit_filepath_; - - GTEST_DISALLOW_COPY_AND_ASSIGN_(ScopedPrematureExitFile); -}; - -} // namespace internal - -// class TestEventListeners - -TestEventListeners::TestEventListeners() - : repeater_(new internal::TestEventRepeater()), - default_result_printer_(nullptr), - default_xml_generator_(nullptr) {} - -TestEventListeners::~TestEventListeners() { delete repeater_; } - -// Returns the standard listener responsible for the default console -// output. Can be removed from the listeners list to shut down default -// console output. Note that removing this object from the listener list -// with Release transfers its ownership to the user. -void TestEventListeners::Append(TestEventListener* listener) { - repeater_->Append(listener); -} - -// Removes the given event listener from the list and returns it. It then -// becomes the caller's responsibility to delete the listener. Returns -// NULL if the listener is not found in the list. -TestEventListener* TestEventListeners::Release(TestEventListener* listener) { - if (listener == default_result_printer_) - default_result_printer_ = nullptr; - else if (listener == default_xml_generator_) - default_xml_generator_ = nullptr; - return repeater_->Release(listener); -} - -// Returns repeater that broadcasts the TestEventListener events to all -// subscribers. -TestEventListener* TestEventListeners::repeater() { return repeater_; } - -// Sets the default_result_printer attribute to the provided listener. -// The listener is also added to the listener list and previous -// default_result_printer is removed from it and deleted. The listener can -// also be NULL in which case it will not be added to the list. Does -// nothing if the previous and the current listener objects are the same. -void TestEventListeners::SetDefaultResultPrinter(TestEventListener* listener) { - if (default_result_printer_ != listener) { - // It is an error to pass this method a listener that is already in the - // list. - delete Release(default_result_printer_); - default_result_printer_ = listener; - if (listener != nullptr) Append(listener); - } -} - -// Sets the default_xml_generator attribute to the provided listener. The -// listener is also added to the listener list and previous -// default_xml_generator is removed from it and deleted. The listener can -// also be NULL in which case it will not be added to the list. Does -// nothing if the previous and the current listener objects are the same. -void TestEventListeners::SetDefaultXmlGenerator(TestEventListener* listener) { - if (default_xml_generator_ != listener) { - // It is an error to pass this method a listener that is already in the - // list. - delete Release(default_xml_generator_); - default_xml_generator_ = listener; - if (listener != nullptr) Append(listener); - } -} - -// Controls whether events will be forwarded by the repeater to the -// listeners in the list. -bool TestEventListeners::EventForwardingEnabled() const { - return repeater_->forwarding_enabled(); -} - -void TestEventListeners::SuppressEventForwarding() { - repeater_->set_forwarding_enabled(false); -} - -// class UnitTest - -// Gets the singleton UnitTest object. The first time this method is -// called, a UnitTest object is constructed and returned. Consecutive -// calls will return the same object. -// -// We don't protect this under mutex_ as a user is not supposed to -// call this before main() starts, from which point on the return -// value will never change. -UnitTest* UnitTest::GetInstance() { - // CodeGear C++Builder insists on a public destructor for the - // default implementation. Use this implementation to keep good OO - // design with private destructor. - -#if defined(__BORLANDC__) - static UnitTest* const instance = new UnitTest; - return instance; -#else - static UnitTest instance; - return &instance; -#endif // defined(__BORLANDC__) -} - -// Gets the number of successful test suites. -int UnitTest::successful_test_suite_count() const { - return impl()->successful_test_suite_count(); -} - -// Gets the number of failed test suites. -int UnitTest::failed_test_suite_count() const { - return impl()->failed_test_suite_count(); -} - -// Gets the number of all test suites. -int UnitTest::total_test_suite_count() const { - return impl()->total_test_suite_count(); -} - -// Gets the number of all test suites that contain at least one test -// that should run. -int UnitTest::test_suite_to_run_count() const { - return impl()->test_suite_to_run_count(); -} - -// Legacy API is deprecated but still available -#ifndef GTEST_REMOVE_LEGACY_TEST_CASEAPI_ -int UnitTest::successful_test_case_count() const { - return impl()->successful_test_suite_count(); -} -int UnitTest::failed_test_case_count() const { - return impl()->failed_test_suite_count(); -} -int UnitTest::total_test_case_count() const { - return impl()->total_test_suite_count(); -} -int UnitTest::test_case_to_run_count() const { - return impl()->test_suite_to_run_count(); -} -#endif // GTEST_REMOVE_LEGACY_TEST_CASEAPI_ - -// Gets the number of successful tests. -int UnitTest::successful_test_count() const { - return impl()->successful_test_count(); -} - -// Gets the number of skipped tests. -int UnitTest::skipped_test_count() const { - return impl()->skipped_test_count(); -} - -// Gets the number of failed tests. -int UnitTest::failed_test_count() const { return impl()->failed_test_count(); } - -// Gets the number of disabled tests that will be reported in the XML report. -int UnitTest::reportable_disabled_test_count() const { - return impl()->reportable_disabled_test_count(); -} - -// Gets the number of disabled tests. -int UnitTest::disabled_test_count() const { - return impl()->disabled_test_count(); -} - -// Gets the number of tests to be printed in the XML report. -int UnitTest::reportable_test_count() const { - return impl()->reportable_test_count(); -} - -// Gets the number of all tests. -int UnitTest::total_test_count() const { return impl()->total_test_count(); } - -// Gets the number of tests that should run. -int UnitTest::test_to_run_count() const { return impl()->test_to_run_count(); } - -// Gets the time of the test program start, in ms from the start of the -// UNIX epoch. -internal::TimeInMillis UnitTest::start_timestamp() const { - return impl()->start_timestamp(); -} - -// Gets the elapsed time, in milliseconds. -internal::TimeInMillis UnitTest::elapsed_time() const { - return impl()->elapsed_time(); -} - -// Returns true if and only if the unit test passed (i.e. all test suites -// passed). -bool UnitTest::Passed() const { return impl()->Passed(); } - -// Returns true if and only if the unit test failed (i.e. some test suite -// failed or something outside of all tests failed). -bool UnitTest::Failed() const { return impl()->Failed(); } - -// Gets the i-th test suite among all the test suites. i can range from 0 to -// total_test_suite_count() - 1. If i is not in that range, returns NULL. -const TestSuite* UnitTest::GetTestSuite(int i) const { - return impl()->GetTestSuite(i); -} - -// Legacy API is deprecated but still available -#ifndef GTEST_REMOVE_LEGACY_TEST_CASEAPI_ -const TestCase* UnitTest::GetTestCase(int i) const { - return impl()->GetTestCase(i); -} -#endif // GTEST_REMOVE_LEGACY_TEST_CASEAPI_ - -// Returns the TestResult containing information on test failures and -// properties logged outside of individual test suites. -const TestResult& UnitTest::ad_hoc_test_result() const { - return *impl()->ad_hoc_test_result(); -} - -// Gets the i-th test suite among all the test suites. i can range from 0 to -// total_test_suite_count() - 1. If i is not in that range, returns NULL. -TestSuite* UnitTest::GetMutableTestSuite(int i) { - return impl()->GetMutableSuiteCase(i); -} - -// Returns the list of event listeners that can be used to track events -// inside Google Test. -TestEventListeners& UnitTest::listeners() { - return *impl()->listeners(); -} - -// Registers and returns a global test environment. When a test -// program is run, all global test environments will be set-up in the -// order they were registered. After all tests in the program have -// finished, all global test environments will be torn-down in the -// *reverse* order they were registered. -// -// The UnitTest object takes ownership of the given environment. -// -// We don't protect this under mutex_, as we only support calling it -// from the main thread. -Environment* UnitTest::AddEnvironment(Environment* env) { - if (env == nullptr) { - return nullptr; - } - - impl_->environments().push_back(env); - return env; -} - -// Adds a TestPartResult to the current TestResult object. All Google Test -// assertion macros (e.g. ASSERT_TRUE, EXPECT_EQ, etc) eventually call -// this to report their results. The user code should use the -// assertion macros instead of calling this directly. -void UnitTest::AddTestPartResult( - TestPartResult::Type result_type, - const char* file_name, - int line_number, - const std::string& message, - const std::string& os_stack_trace) GTEST_LOCK_EXCLUDED_(mutex_) { - Message msg; - msg << message; - - internal::MutexLock lock(&mutex_); - if (impl_->gtest_trace_stack().size() > 0) { - msg << "\n" << GTEST_NAME_ << " trace:"; - - for (size_t i = impl_->gtest_trace_stack().size(); i > 0; --i) { - const internal::TraceInfo& trace = impl_->gtest_trace_stack()[i - 1]; - msg << "\n" << internal::FormatFileLocation(trace.file, trace.line) - << " " << trace.message; - } - } - - if (os_stack_trace.c_str() != nullptr && !os_stack_trace.empty()) { - msg << internal::kStackTraceMarker << os_stack_trace; - } - - const TestPartResult result = TestPartResult( - result_type, file_name, line_number, msg.GetString().c_str()); - impl_->GetTestPartResultReporterForCurrentThread()-> - ReportTestPartResult(result); - - if (result_type != TestPartResult::kSuccess && - result_type != TestPartResult::kSkip) { - // gtest_break_on_failure takes precedence over - // gtest_throw_on_failure. This allows a user to set the latter - // in the code (perhaps in order to use Google Test assertions - // with another testing framework) and specify the former on the - // command line for debugging. - if (GTEST_FLAG(break_on_failure)) { -#if GTEST_OS_WINDOWS && !GTEST_OS_WINDOWS_PHONE && !GTEST_OS_WINDOWS_RT - // Using DebugBreak on Windows allows gtest to still break into a debugger - // when a failure happens and both the --gtest_break_on_failure and - // the --gtest_catch_exceptions flags are specified. - DebugBreak(); -#elif (!defined(__native_client__)) && \ - ((defined(__clang__) || defined(__GNUC__)) && \ - (defined(__x86_64__) || defined(__i386__))) - // with clang/gcc we can achieve the same effect on x86 by invoking int3 - asm("int3"); -#else - // Dereference nullptr through a volatile pointer to prevent the compiler - // from removing. We use this rather than abort() or __builtin_trap() for - // portability: some debuggers don't correctly trap abort(). - *static_cast<volatile int*>(nullptr) = 1; -#endif // GTEST_OS_WINDOWS - } else if (GTEST_FLAG(throw_on_failure)) { -#if GTEST_HAS_EXCEPTIONS - throw internal::GoogleTestFailureException(result); -#else - // We cannot call abort() as it generates a pop-up in debug mode - // that cannot be suppressed in VC 7.1 or below. - exit(1); -#endif - } - } -} - -// Adds a TestProperty to the current TestResult object when invoked from -// inside a test, to current TestSuite's ad_hoc_test_result_ when invoked -// from SetUpTestSuite or TearDownTestSuite, or to the global property set -// when invoked elsewhere. If the result already contains a property with -// the same key, the value will be updated. -void UnitTest::RecordProperty(const std::string& key, - const std::string& value) { - impl_->RecordProperty(TestProperty(key, value)); -} - -// Runs all tests in this UnitTest object and prints the result. -// Returns 0 if successful, or 1 otherwise. -// -// We don't protect this under mutex_, as we only support calling it -// from the main thread. -int UnitTest::Run() { - const bool in_death_test_child_process = - internal::GTEST_FLAG(internal_run_death_test).length() > 0; - - // Google Test implements this protocol for catching that a test - // program exits before returning control to Google Test: - // - // 1. Upon start, Google Test creates a file whose absolute path - // is specified by the environment variable - // TEST_PREMATURE_EXIT_FILE. - // 2. When Google Test has finished its work, it deletes the file. - // - // This allows a test runner to set TEST_PREMATURE_EXIT_FILE before - // running a Google-Test-based test program and check the existence - // of the file at the end of the test execution to see if it has - // exited prematurely. - - // If we are in the child process of a death test, don't - // create/delete the premature exit file, as doing so is unnecessary - // and will confuse the parent process. Otherwise, create/delete - // the file upon entering/leaving this function. If the program - // somehow exits before this function has a chance to return, the - // premature-exit file will be left undeleted, causing a test runner - // that understands the premature-exit-file protocol to report the - // test as having failed. - const internal::ScopedPrematureExitFile premature_exit_file( - in_death_test_child_process - ? nullptr - : internal::posix::GetEnv("TEST_PREMATURE_EXIT_FILE")); - - // Captures the value of GTEST_FLAG(catch_exceptions). This value will be - // used for the duration of the program. - impl()->set_catch_exceptions(GTEST_FLAG(catch_exceptions)); - -#if GTEST_OS_WINDOWS - // Either the user wants Google Test to catch exceptions thrown by the - // tests or this is executing in the context of death test child - // process. In either case the user does not want to see pop-up dialogs - // about crashes - they are expected. - if (impl()->catch_exceptions() || in_death_test_child_process) { -# if !GTEST_OS_WINDOWS_MOBILE && !GTEST_OS_WINDOWS_PHONE && !GTEST_OS_WINDOWS_RT - // SetErrorMode doesn't exist on CE. - SetErrorMode(SEM_FAILCRITICALERRORS | SEM_NOALIGNMENTFAULTEXCEPT | - SEM_NOGPFAULTERRORBOX | SEM_NOOPENFILEERRORBOX); -# endif // !GTEST_OS_WINDOWS_MOBILE - -# if (defined(_MSC_VER) || GTEST_OS_WINDOWS_MINGW) && !GTEST_OS_WINDOWS_MOBILE - // Death test children can be terminated with _abort(). On Windows, - // _abort() can show a dialog with a warning message. This forces the - // abort message to go to stderr instead. - _set_error_mode(_OUT_TO_STDERR); -# endif - -# if defined(_MSC_VER) && !GTEST_OS_WINDOWS_MOBILE - // In the debug version, Visual Studio pops up a separate dialog - // offering a choice to debug the aborted program. We need to suppress - // this dialog or it will pop up for every EXPECT/ASSERT_DEATH statement - // executed. Google Test will notify the user of any unexpected - // failure via stderr. - if (!GTEST_FLAG(break_on_failure)) - _set_abort_behavior( - 0x0, // Clear the following flags: - _WRITE_ABORT_MSG | _CALL_REPORTFAULT); // pop-up window, core dump. - - // In debug mode, the Windows CRT can crash with an assertion over invalid - // input (e.g. passing an invalid file descriptor). The default handling - // for these assertions is to pop up a dialog and wait for user input. - // Instead ask the CRT to dump such assertions to stderr non-interactively. - if (!IsDebuggerPresent()) { - (void)_CrtSetReportMode(_CRT_ASSERT, - _CRTDBG_MODE_FILE | _CRTDBG_MODE_DEBUG); - (void)_CrtSetReportFile(_CRT_ASSERT, _CRTDBG_FILE_STDERR); - } -# endif - } -#endif // GTEST_OS_WINDOWS - - return internal::HandleExceptionsInMethodIfSupported( - impl(), - &internal::UnitTestImpl::RunAllTests, - "auxiliary test code (environments or event listeners)") ? 0 : 1; -} - -// Returns the working directory when the first TEST() or TEST_F() was -// executed. -const char* UnitTest::original_working_dir() const { - return impl_->original_working_dir_.c_str(); -} - -// Returns the TestSuite object for the test that's currently running, -// or NULL if no test is running. -const TestSuite* UnitTest::current_test_suite() const - GTEST_LOCK_EXCLUDED_(mutex_) { - internal::MutexLock lock(&mutex_); - return impl_->current_test_suite(); -} - -// Legacy API is still available but deprecated -#ifndef GTEST_REMOVE_LEGACY_TEST_CASEAPI_ -const TestCase* UnitTest::current_test_case() const - GTEST_LOCK_EXCLUDED_(mutex_) { - internal::MutexLock lock(&mutex_); - return impl_->current_test_suite(); -} -#endif - -// Returns the TestInfo object for the test that's currently running, -// or NULL if no test is running. -const TestInfo* UnitTest::current_test_info() const - GTEST_LOCK_EXCLUDED_(mutex_) { - internal::MutexLock lock(&mutex_); - return impl_->current_test_info(); -} - -// Returns the random seed used at the start of the current test run. -int UnitTest::random_seed() const { return impl_->random_seed(); } - -// Returns ParameterizedTestSuiteRegistry object used to keep track of -// value-parameterized tests and instantiate and register them. -internal::ParameterizedTestSuiteRegistry& -UnitTest::parameterized_test_registry() GTEST_LOCK_EXCLUDED_(mutex_) { - return impl_->parameterized_test_registry(); -} - -// Creates an empty UnitTest. -UnitTest::UnitTest() { - impl_ = new internal::UnitTestImpl(this); -} - -// Destructor of UnitTest. -UnitTest::~UnitTest() { - delete impl_; -} - -// Pushes a trace defined by SCOPED_TRACE() on to the per-thread -// Google Test trace stack. -void UnitTest::PushGTestTrace(const internal::TraceInfo& trace) - GTEST_LOCK_EXCLUDED_(mutex_) { - internal::MutexLock lock(&mutex_); - impl_->gtest_trace_stack().push_back(trace); -} - -// Pops a trace from the per-thread Google Test trace stack. -void UnitTest::PopGTestTrace() - GTEST_LOCK_EXCLUDED_(mutex_) { - internal::MutexLock lock(&mutex_); - impl_->gtest_trace_stack().pop_back(); -} - -namespace internal { - -UnitTestImpl::UnitTestImpl(UnitTest* parent) - : parent_(parent), - GTEST_DISABLE_MSC_WARNINGS_PUSH_(4355 /* using this in initializer */) - default_global_test_part_result_reporter_(this), - default_per_thread_test_part_result_reporter_(this), - GTEST_DISABLE_MSC_WARNINGS_POP_() global_test_part_result_repoter_( - &default_global_test_part_result_reporter_), - per_thread_test_part_result_reporter_( - &default_per_thread_test_part_result_reporter_), - parameterized_test_registry_(), - parameterized_tests_registered_(false), - last_death_test_suite_(-1), - current_test_suite_(nullptr), - current_test_info_(nullptr), - ad_hoc_test_result_(), - os_stack_trace_getter_(nullptr), - post_flag_parse_init_performed_(false), - random_seed_(0), // Will be overridden by the flag before first use. - random_(0), // Will be reseeded before first use. - start_timestamp_(0), - elapsed_time_(0), -#if GTEST_HAS_DEATH_TEST - death_test_factory_(new DefaultDeathTestFactory), -#endif - // Will be overridden by the flag before first use. - catch_exceptions_(false) { - listeners()->SetDefaultResultPrinter(new PrettyUnitTestResultPrinter); -} - -UnitTestImpl::~UnitTestImpl() { - // Deletes every TestSuite. - ForEach(test_suites_, internal::Delete<TestSuite>); - - // Deletes every Environment. - ForEach(environments_, internal::Delete<Environment>); - - delete os_stack_trace_getter_; -} - -// Adds a TestProperty to the current TestResult object when invoked in a -// context of a test, to current test suite's ad_hoc_test_result when invoke -// from SetUpTestSuite/TearDownTestSuite, or to the global property set -// otherwise. If the result already contains a property with the same key, -// the value will be updated. -void UnitTestImpl::RecordProperty(const TestProperty& test_property) { - std::string xml_element; - TestResult* test_result; // TestResult appropriate for property recording. - - if (current_test_info_ != nullptr) { - xml_element = "testcase"; - test_result = &(current_test_info_->result_); - } else if (current_test_suite_ != nullptr) { - xml_element = "testsuite"; - test_result = &(current_test_suite_->ad_hoc_test_result_); - } else { - xml_element = "testsuites"; - test_result = &ad_hoc_test_result_; - } - test_result->RecordProperty(xml_element, test_property); -} - -#if GTEST_HAS_DEATH_TEST -// Disables event forwarding if the control is currently in a death test -// subprocess. Must not be called before InitGoogleTest. -void UnitTestImpl::SuppressTestEventsIfInSubprocess() { - if (internal_run_death_test_flag_.get() != nullptr) - listeners()->SuppressEventForwarding(); -} -#endif // GTEST_HAS_DEATH_TEST - -// Initializes event listeners performing XML output as specified by -// UnitTestOptions. Must not be called before InitGoogleTest. -void UnitTestImpl::ConfigureXmlOutput() { - const std::string& output_format = UnitTestOptions::GetOutputFormat(); - if (output_format == "xml") { - listeners()->SetDefaultXmlGenerator(new XmlUnitTestResultPrinter( - UnitTestOptions::GetAbsolutePathToOutputFile().c_str())); - } else if (output_format == "json") { - listeners()->SetDefaultXmlGenerator(new JsonUnitTestResultPrinter( - UnitTestOptions::GetAbsolutePathToOutputFile().c_str())); - } else if (output_format != "") { - GTEST_LOG_(WARNING) << "WARNING: unrecognized output format \"" - << output_format << "\" ignored."; - } -} - -#if GTEST_CAN_STREAM_RESULTS_ -// Initializes event listeners for streaming test results in string form. -// Must not be called before InitGoogleTest. -void UnitTestImpl::ConfigureStreamingOutput() { - const std::string& target = GTEST_FLAG(stream_result_to); - if (!target.empty()) { - const size_t pos = target.find(':'); - if (pos != std::string::npos) { - listeners()->Append(new StreamingListener(target.substr(0, pos), - target.substr(pos+1))); - } else { - GTEST_LOG_(WARNING) << "unrecognized streaming target \"" << target - << "\" ignored."; - } - } -} -#endif // GTEST_CAN_STREAM_RESULTS_ - -// Performs initialization dependent upon flag values obtained in -// ParseGoogleTestFlagsOnly. Is called from InitGoogleTest after the call to -// ParseGoogleTestFlagsOnly. In case a user neglects to call InitGoogleTest -// this function is also called from RunAllTests. Since this function can be -// called more than once, it has to be idempotent. -void UnitTestImpl::PostFlagParsingInit() { - // Ensures that this function does not execute more than once. - if (!post_flag_parse_init_performed_) { - post_flag_parse_init_performed_ = true; - -#if defined(GTEST_CUSTOM_TEST_EVENT_LISTENER_) - // Register to send notifications about key process state changes. - listeners()->Append(new GTEST_CUSTOM_TEST_EVENT_LISTENER_()); -#endif // defined(GTEST_CUSTOM_TEST_EVENT_LISTENER_) - -#if GTEST_HAS_DEATH_TEST - InitDeathTestSubprocessControlInfo(); - SuppressTestEventsIfInSubprocess(); -#endif // GTEST_HAS_DEATH_TEST - - // Registers parameterized tests. This makes parameterized tests - // available to the UnitTest reflection API without running - // RUN_ALL_TESTS. - RegisterParameterizedTests(); - - // Configures listeners for XML output. This makes it possible for users - // to shut down the default XML output before invoking RUN_ALL_TESTS. - ConfigureXmlOutput(); - - if (GTEST_FLAG(brief)) { - listeners()->SetDefaultResultPrinter(new BriefUnitTestResultPrinter); - } - -#if GTEST_CAN_STREAM_RESULTS_ - // Configures listeners for streaming test results to the specified server. - ConfigureStreamingOutput(); -#endif // GTEST_CAN_STREAM_RESULTS_ - -#if GTEST_HAS_ABSL - if (GTEST_FLAG(install_failure_signal_handler)) { - absl::FailureSignalHandlerOptions options; - absl::InstallFailureSignalHandler(options); - } -#endif // GTEST_HAS_ABSL - } -} - -// A predicate that checks the name of a TestSuite against a known -// value. -// -// This is used for implementation of the UnitTest class only. We put -// it in the anonymous namespace to prevent polluting the outer -// namespace. -// -// TestSuiteNameIs is copyable. -class TestSuiteNameIs { - public: - // Constructor. - explicit TestSuiteNameIs(const std::string& name) : name_(name) {} - - // Returns true if and only if the name of test_suite matches name_. - bool operator()(const TestSuite* test_suite) const { - return test_suite != nullptr && - strcmp(test_suite->name(), name_.c_str()) == 0; - } - - private: - std::string name_; -}; - -// Finds and returns a TestSuite with the given name. If one doesn't -// exist, creates one and returns it. It's the CALLER'S -// RESPONSIBILITY to ensure that this function is only called WHEN THE -// TESTS ARE NOT SHUFFLED. -// -// Arguments: -// -// test_suite_name: name of the test suite -// type_param: the name of the test suite's type parameter, or NULL if -// this is not a typed or a type-parameterized test suite. -// set_up_tc: pointer to the function that sets up the test suite -// tear_down_tc: pointer to the function that tears down the test suite -TestSuite* UnitTestImpl::GetTestSuite( - const char* test_suite_name, const char* type_param, - internal::SetUpTestSuiteFunc set_up_tc, - internal::TearDownTestSuiteFunc tear_down_tc) { - // Can we find a TestSuite with the given name? - const auto test_suite = - std::find_if(test_suites_.rbegin(), test_suites_.rend(), - TestSuiteNameIs(test_suite_name)); - - if (test_suite != test_suites_.rend()) return *test_suite; - - // No. Let's create one. - auto* const new_test_suite = - new TestSuite(test_suite_name, type_param, set_up_tc, tear_down_tc); - - // Is this a death test suite? - if (internal::UnitTestOptions::MatchesFilter(test_suite_name, - kDeathTestSuiteFilter)) { - // Yes. Inserts the test suite after the last death test suite - // defined so far. This only works when the test suites haven't - // been shuffled. Otherwise we may end up running a death test - // after a non-death test. - ++last_death_test_suite_; - test_suites_.insert(test_suites_.begin() + last_death_test_suite_, - new_test_suite); - } else { - // No. Appends to the end of the list. - test_suites_.push_back(new_test_suite); - } - - test_suite_indices_.push_back(static_cast<int>(test_suite_indices_.size())); - return new_test_suite; -} - -// Helpers for setting up / tearing down the given environment. They -// are for use in the ForEach() function. -static void SetUpEnvironment(Environment* env) { env->SetUp(); } -static void TearDownEnvironment(Environment* env) { env->TearDown(); } - -// Runs all tests in this UnitTest object, prints the result, and -// returns true if all tests are successful. If any exception is -// thrown during a test, the test is considered to be failed, but the -// rest of the tests will still be run. -// -// When parameterized tests are enabled, it expands and registers -// parameterized tests first in RegisterParameterizedTests(). -// All other functions called from RunAllTests() may safely assume that -// parameterized tests are ready to be counted and run. -bool UnitTestImpl::RunAllTests() { - // True if and only if Google Test is initialized before RUN_ALL_TESTS() is - // called. - const bool gtest_is_initialized_before_run_all_tests = GTestIsInitialized(); - - // Do not run any test if the --help flag was specified. - if (g_help_flag) - return true; - - // Repeats the call to the post-flag parsing initialization in case the - // user didn't call InitGoogleTest. - PostFlagParsingInit(); - - // Even if sharding is not on, test runners may want to use the - // GTEST_SHARD_STATUS_FILE to query whether the test supports the sharding - // protocol. - internal::WriteToShardStatusFileIfNeeded(); - - // True if and only if we are in a subprocess for running a thread-safe-style - // death test. - bool in_subprocess_for_death_test = false; - -#if GTEST_HAS_DEATH_TEST - in_subprocess_for_death_test = - (internal_run_death_test_flag_.get() != nullptr); -# if defined(GTEST_EXTRA_DEATH_TEST_CHILD_SETUP_) - if (in_subprocess_for_death_test) { - GTEST_EXTRA_DEATH_TEST_CHILD_SETUP_(); - } -# endif // defined(GTEST_EXTRA_DEATH_TEST_CHILD_SETUP_) -#endif // GTEST_HAS_DEATH_TEST - - const bool should_shard = ShouldShard(kTestTotalShards, kTestShardIndex, - in_subprocess_for_death_test); - - // Compares the full test names with the filter to decide which - // tests to run. - const bool has_tests_to_run = FilterTests(should_shard - ? HONOR_SHARDING_PROTOCOL - : IGNORE_SHARDING_PROTOCOL) > 0; - - // Lists the tests and exits if the --gtest_list_tests flag was specified. - if (GTEST_FLAG(list_tests)) { - // This must be called *after* FilterTests() has been called. - ListTestsMatchingFilter(); - return true; - } - - random_seed_ = GTEST_FLAG(shuffle) ? - GetRandomSeedFromFlag(GTEST_FLAG(random_seed)) : 0; - - // True if and only if at least one test has failed. - bool failed = false; - - TestEventListener* repeater = listeners()->repeater(); - - start_timestamp_ = GetTimeInMillis(); - repeater->OnTestProgramStart(*parent_); - - // How many times to repeat the tests? We don't want to repeat them - // when we are inside the subprocess of a death test. - const int repeat = in_subprocess_for_death_test ? 1 : GTEST_FLAG(repeat); - // Repeats forever if the repeat count is negative. - const bool gtest_repeat_forever = repeat < 0; - for (int i = 0; gtest_repeat_forever || i != repeat; i++) { - // We want to preserve failures generated by ad-hoc test - // assertions executed before RUN_ALL_TESTS(). - ClearNonAdHocTestResult(); - - Timer timer; - - // Shuffles test suites and tests if requested. - if (has_tests_to_run && GTEST_FLAG(shuffle)) { - random()->Reseed(static_cast<uint32_t>(random_seed_)); - // This should be done before calling OnTestIterationStart(), - // such that a test event listener can see the actual test order - // in the event. - ShuffleTests(); - } - - // Tells the unit test event listeners that the tests are about to start. - repeater->OnTestIterationStart(*parent_, i); - - // Runs each test suite if there is at least one test to run. - if (has_tests_to_run) { - // Sets up all environments beforehand. - repeater->OnEnvironmentsSetUpStart(*parent_); - ForEach(environments_, SetUpEnvironment); - repeater->OnEnvironmentsSetUpEnd(*parent_); - - // Runs the tests only if there was no fatal failure or skip triggered - // during global set-up. - if (Test::IsSkipped()) { - // Emit diagnostics when global set-up calls skip, as it will not be - // emitted by default. - TestResult& test_result = - *internal::GetUnitTestImpl()->current_test_result(); - for (int j = 0; j < test_result.total_part_count(); ++j) { - const TestPartResult& test_part_result = - test_result.GetTestPartResult(j); - if (test_part_result.type() == TestPartResult::kSkip) { - const std::string& result = test_part_result.message(); - printf("%s\n", result.c_str()); - } - } - fflush(stdout); - } else if (!Test::HasFatalFailure()) { - for (int test_index = 0; test_index < total_test_suite_count(); - test_index++) { - GetMutableSuiteCase(test_index)->Run(); - if (GTEST_FLAG(fail_fast) && - GetMutableSuiteCase(test_index)->Failed()) { - for (int j = test_index + 1; j < total_test_suite_count(); j++) { - GetMutableSuiteCase(j)->Skip(); - } - break; - } - } - } else if (Test::HasFatalFailure()) { - // If there was a fatal failure during the global setup then we know we - // aren't going to run any tests. Explicitly mark all of the tests as - // skipped to make this obvious in the output. - for (int test_index = 0; test_index < total_test_suite_count(); - test_index++) { - GetMutableSuiteCase(test_index)->Skip(); - } - } - - // Tears down all environments in reverse order afterwards. - repeater->OnEnvironmentsTearDownStart(*parent_); - std::for_each(environments_.rbegin(), environments_.rend(), - TearDownEnvironment); - repeater->OnEnvironmentsTearDownEnd(*parent_); - } - - elapsed_time_ = timer.Elapsed(); - - // Tells the unit test event listener that the tests have just finished. - repeater->OnTestIterationEnd(*parent_, i); - - // Gets the result and clears it. - if (!Passed()) { - failed = true; - } - - // Restores the original test order after the iteration. This - // allows the user to quickly repro a failure that happens in the - // N-th iteration without repeating the first (N - 1) iterations. - // This is not enclosed in "if (GTEST_FLAG(shuffle)) { ... }", in - // case the user somehow changes the value of the flag somewhere - // (it's always safe to unshuffle the tests). - UnshuffleTests(); - - if (GTEST_FLAG(shuffle)) { - // Picks a new random seed for each iteration. - random_seed_ = GetNextRandomSeed(random_seed_); - } - } - - repeater->OnTestProgramEnd(*parent_); - - if (!gtest_is_initialized_before_run_all_tests) { - ColoredPrintf( - GTestColor::kRed, - "\nIMPORTANT NOTICE - DO NOT IGNORE:\n" - "This test program did NOT call " GTEST_INIT_GOOGLE_TEST_NAME_ - "() before calling RUN_ALL_TESTS(). This is INVALID. Soon " GTEST_NAME_ - " will start to enforce the valid usage. " - "Please fix it ASAP, or IT WILL START TO FAIL.\n"); // NOLINT -#if GTEST_FOR_GOOGLE_ - ColoredPrintf(GTestColor::kRed, - "For more details, see http://wiki/Main/ValidGUnitMain.\n"); -#endif // GTEST_FOR_GOOGLE_ - } - - return !failed; -} - -// Reads the GTEST_SHARD_STATUS_FILE environment variable, and creates the file -// if the variable is present. If a file already exists at this location, this -// function will write over it. If the variable is present, but the file cannot -// be created, prints an error and exits. -void WriteToShardStatusFileIfNeeded() { - const char* const test_shard_file = posix::GetEnv(kTestShardStatusFile); - if (test_shard_file != nullptr) { - FILE* const file = posix::FOpen(test_shard_file, "w"); - if (file == nullptr) { - ColoredPrintf(GTestColor::kRed, - "Could not write to the test shard status file \"%s\" " - "specified by the %s environment variable.\n", - test_shard_file, kTestShardStatusFile); - fflush(stdout); - exit(EXIT_FAILURE); - } - fclose(file); - } -} - -// Checks whether sharding is enabled by examining the relevant -// environment variable values. If the variables are present, -// but inconsistent (i.e., shard_index >= total_shards), prints -// an error and exits. If in_subprocess_for_death_test, sharding is -// disabled because it must only be applied to the original test -// process. Otherwise, we could filter out death tests we intended to execute. -bool ShouldShard(const char* total_shards_env, - const char* shard_index_env, - bool in_subprocess_for_death_test) { - if (in_subprocess_for_death_test) { - return false; - } - - const int32_t total_shards = Int32FromEnvOrDie(total_shards_env, -1); - const int32_t shard_index = Int32FromEnvOrDie(shard_index_env, -1); - - if (total_shards == -1 && shard_index == -1) { - return false; - } else if (total_shards == -1 && shard_index != -1) { - const Message msg = Message() - << "Invalid environment variables: you have " - << kTestShardIndex << " = " << shard_index - << ", but have left " << kTestTotalShards << " unset.\n"; - ColoredPrintf(GTestColor::kRed, "%s", msg.GetString().c_str()); - fflush(stdout); - exit(EXIT_FAILURE); - } else if (total_shards != -1 && shard_index == -1) { - const Message msg = Message() - << "Invalid environment variables: you have " - << kTestTotalShards << " = " << total_shards - << ", but have left " << kTestShardIndex << " unset.\n"; - ColoredPrintf(GTestColor::kRed, "%s", msg.GetString().c_str()); - fflush(stdout); - exit(EXIT_FAILURE); - } else if (shard_index < 0 || shard_index >= total_shards) { - const Message msg = Message() - << "Invalid environment variables: we require 0 <= " - << kTestShardIndex << " < " << kTestTotalShards - << ", but you have " << kTestShardIndex << "=" << shard_index - << ", " << kTestTotalShards << "=" << total_shards << ".\n"; - ColoredPrintf(GTestColor::kRed, "%s", msg.GetString().c_str()); - fflush(stdout); - exit(EXIT_FAILURE); - } - - return total_shards > 1; -} - -// Parses the environment variable var as an Int32. If it is unset, -// returns default_val. If it is not an Int32, prints an error -// and aborts. -int32_t Int32FromEnvOrDie(const char* var, int32_t default_val) { - const char* str_val = posix::GetEnv(var); - if (str_val == nullptr) { - return default_val; - } - - int32_t result; - if (!ParseInt32(Message() << "The value of environment variable " << var, - str_val, &result)) { - exit(EXIT_FAILURE); - } - return result; -} - -// Given the total number of shards, the shard index, and the test id, -// returns true if and only if the test should be run on this shard. The test id -// is some arbitrary but unique non-negative integer assigned to each test -// method. Assumes that 0 <= shard_index < total_shards. -bool ShouldRunTestOnShard(int total_shards, int shard_index, int test_id) { - return (test_id % total_shards) == shard_index; -} - -// Compares the name of each test with the user-specified filter to -// decide whether the test should be run, then records the result in -// each TestSuite and TestInfo object. -// If shard_tests == true, further filters tests based on sharding -// variables in the environment - see -// https://github.com/google/googletest/blob/master/googletest/docs/advanced.md -// . Returns the number of tests that should run. -int UnitTestImpl::FilterTests(ReactionToSharding shard_tests) { - const int32_t total_shards = shard_tests == HONOR_SHARDING_PROTOCOL ? - Int32FromEnvOrDie(kTestTotalShards, -1) : -1; - const int32_t shard_index = shard_tests == HONOR_SHARDING_PROTOCOL ? - Int32FromEnvOrDie(kTestShardIndex, -1) : -1; - - // num_runnable_tests are the number of tests that will - // run across all shards (i.e., match filter and are not disabled). - // num_selected_tests are the number of tests to be run on - // this shard. - int num_runnable_tests = 0; - int num_selected_tests = 0; - for (auto* test_suite : test_suites_) { - const std::string& test_suite_name = test_suite->name(); - test_suite->set_should_run(false); - - for (size_t j = 0; j < test_suite->test_info_list().size(); j++) { - TestInfo* const test_info = test_suite->test_info_list()[j]; - const std::string test_name(test_info->name()); - // A test is disabled if test suite name or test name matches - // kDisableTestFilter. - const bool is_disabled = internal::UnitTestOptions::MatchesFilter( - test_suite_name, kDisableTestFilter) || - internal::UnitTestOptions::MatchesFilter( - test_name, kDisableTestFilter); - test_info->is_disabled_ = is_disabled; - - const bool matches_filter = internal::UnitTestOptions::FilterMatchesTest( - test_suite_name, test_name); - test_info->matches_filter_ = matches_filter; - - const bool is_runnable = - (GTEST_FLAG(also_run_disabled_tests) || !is_disabled) && - matches_filter; - - const bool is_in_another_shard = - shard_tests != IGNORE_SHARDING_PROTOCOL && - !ShouldRunTestOnShard(total_shards, shard_index, num_runnable_tests); - test_info->is_in_another_shard_ = is_in_another_shard; - const bool is_selected = is_runnable && !is_in_another_shard; - - num_runnable_tests += is_runnable; - num_selected_tests += is_selected; - - test_info->should_run_ = is_selected; - test_suite->set_should_run(test_suite->should_run() || is_selected); - } - } - return num_selected_tests; -} - -// Prints the given C-string on a single line by replacing all '\n' -// characters with string "\\n". If the output takes more than -// max_length characters, only prints the first max_length characters -// and "...". -static void PrintOnOneLine(const char* str, int max_length) { - if (str != nullptr) { - for (int i = 0; *str != '\0'; ++str) { - if (i >= max_length) { - printf("..."); - break; - } - if (*str == '\n') { - printf("\\n"); - i += 2; - } else { - printf("%c", *str); - ++i; - } - } - } -} - -// Prints the names of the tests matching the user-specified filter flag. -void UnitTestImpl::ListTestsMatchingFilter() { - // Print at most this many characters for each type/value parameter. - const int kMaxParamLength = 250; - - for (auto* test_suite : test_suites_) { - bool printed_test_suite_name = false; - - for (size_t j = 0; j < test_suite->test_info_list().size(); j++) { - const TestInfo* const test_info = test_suite->test_info_list()[j]; - if (test_info->matches_filter_) { - if (!printed_test_suite_name) { - printed_test_suite_name = true; - printf("%s.", test_suite->name()); - if (test_suite->type_param() != nullptr) { - printf(" # %s = ", kTypeParamLabel); - // We print the type parameter on a single line to make - // the output easy to parse by a program. - PrintOnOneLine(test_suite->type_param(), kMaxParamLength); - } - printf("\n"); - } - printf(" %s", test_info->name()); - if (test_info->value_param() != nullptr) { - printf(" # %s = ", kValueParamLabel); - // We print the value parameter on a single line to make the - // output easy to parse by a program. - PrintOnOneLine(test_info->value_param(), kMaxParamLength); - } - printf("\n"); - } - } - } - fflush(stdout); - const std::string& output_format = UnitTestOptions::GetOutputFormat(); - if (output_format == "xml" || output_format == "json") { - FILE* fileout = OpenFileForWriting( - UnitTestOptions::GetAbsolutePathToOutputFile().c_str()); - std::stringstream stream; - if (output_format == "xml") { - XmlUnitTestResultPrinter( - UnitTestOptions::GetAbsolutePathToOutputFile().c_str()) - .PrintXmlTestsList(&stream, test_suites_); - } else if (output_format == "json") { - JsonUnitTestResultPrinter( - UnitTestOptions::GetAbsolutePathToOutputFile().c_str()) - .PrintJsonTestList(&stream, test_suites_); - } - fprintf(fileout, "%s", StringStreamToString(&stream).c_str()); - fclose(fileout); - } -} - -// Sets the OS stack trace getter. -// -// Does nothing if the input and the current OS stack trace getter are -// the same; otherwise, deletes the old getter and makes the input the -// current getter. -void UnitTestImpl::set_os_stack_trace_getter( - OsStackTraceGetterInterface* getter) { - if (os_stack_trace_getter_ != getter) { - delete os_stack_trace_getter_; - os_stack_trace_getter_ = getter; - } -} - -// Returns the current OS stack trace getter if it is not NULL; -// otherwise, creates an OsStackTraceGetter, makes it the current -// getter, and returns it. -OsStackTraceGetterInterface* UnitTestImpl::os_stack_trace_getter() { - if (os_stack_trace_getter_ == nullptr) { -#ifdef GTEST_OS_STACK_TRACE_GETTER_ - os_stack_trace_getter_ = new GTEST_OS_STACK_TRACE_GETTER_; -#else - os_stack_trace_getter_ = new OsStackTraceGetter; -#endif // GTEST_OS_STACK_TRACE_GETTER_ - } - - return os_stack_trace_getter_; -} - -// Returns the most specific TestResult currently running. -TestResult* UnitTestImpl::current_test_result() { - if (current_test_info_ != nullptr) { - return ¤t_test_info_->result_; - } - if (current_test_suite_ != nullptr) { - return ¤t_test_suite_->ad_hoc_test_result_; - } - return &ad_hoc_test_result_; -} - -// Shuffles all test suites, and the tests within each test suite, -// making sure that death tests are still run first. -void UnitTestImpl::ShuffleTests() { - // Shuffles the death test suites. - ShuffleRange(random(), 0, last_death_test_suite_ + 1, &test_suite_indices_); - - // Shuffles the non-death test suites. - ShuffleRange(random(), last_death_test_suite_ + 1, - static_cast<int>(test_suites_.size()), &test_suite_indices_); - - // Shuffles the tests inside each test suite. - for (auto& test_suite : test_suites_) { - test_suite->ShuffleTests(random()); - } -} - -// Restores the test suites and tests to their order before the first shuffle. -void UnitTestImpl::UnshuffleTests() { - for (size_t i = 0; i < test_suites_.size(); i++) { - // Unshuffles the tests in each test suite. - test_suites_[i]->UnshuffleTests(); - // Resets the index of each test suite. - test_suite_indices_[i] = static_cast<int>(i); - } -} - -// Returns the current OS stack trace as an std::string. -// -// The maximum number of stack frames to be included is specified by -// the gtest_stack_trace_depth flag. The skip_count parameter -// specifies the number of top frames to be skipped, which doesn't -// count against the number of frames to be included. -// -// For example, if Foo() calls Bar(), which in turn calls -// GetCurrentOsStackTraceExceptTop(..., 1), Foo() will be included in -// the trace but Bar() and GetCurrentOsStackTraceExceptTop() won't. -std::string GetCurrentOsStackTraceExceptTop(UnitTest* /*unit_test*/, - int skip_count) { - // We pass skip_count + 1 to skip this wrapper function in addition - // to what the user really wants to skip. - return GetUnitTestImpl()->CurrentOsStackTraceExceptTop(skip_count + 1); -} - -// Used by the GTEST_SUPPRESS_UNREACHABLE_CODE_WARNING_BELOW_ macro to -// suppress unreachable code warnings. -namespace { -class ClassUniqueToAlwaysTrue {}; -} - -bool IsTrue(bool condition) { return condition; } - -bool AlwaysTrue() { -#if GTEST_HAS_EXCEPTIONS - // This condition is always false so AlwaysTrue() never actually throws, - // but it makes the compiler think that it may throw. - if (IsTrue(false)) - throw ClassUniqueToAlwaysTrue(); -#endif // GTEST_HAS_EXCEPTIONS - return true; -} - -// If *pstr starts with the given prefix, modifies *pstr to be right -// past the prefix and returns true; otherwise leaves *pstr unchanged -// and returns false. None of pstr, *pstr, and prefix can be NULL. -bool SkipPrefix(const char* prefix, const char** pstr) { - const size_t prefix_len = strlen(prefix); - if (strncmp(*pstr, prefix, prefix_len) == 0) { - *pstr += prefix_len; - return true; - } - return false; -} - -// Parses a string as a command line flag. The string should have -// the format "--flag=value". When def_optional is true, the "=value" -// part can be omitted. -// -// Returns the value of the flag, or NULL if the parsing failed. -static const char* ParseFlagValue(const char* str, const char* flag, - bool def_optional) { - // str and flag must not be NULL. - if (str == nullptr || flag == nullptr) return nullptr; - - // The flag must start with "--" followed by GTEST_FLAG_PREFIX_. - const std::string flag_str = std::string("--") + GTEST_FLAG_PREFIX_ + flag; - const size_t flag_len = flag_str.length(); - if (strncmp(str, flag_str.c_str(), flag_len) != 0) return nullptr; - - // Skips the flag name. - const char* flag_end = str + flag_len; - - // When def_optional is true, it's OK to not have a "=value" part. - if (def_optional && (flag_end[0] == '\0')) { - return flag_end; - } - - // If def_optional is true and there are more characters after the - // flag name, or if def_optional is false, there must be a '=' after - // the flag name. - if (flag_end[0] != '=') return nullptr; - - // Returns the string after "=". - return flag_end + 1; -} - -// Parses a string for a bool flag, in the form of either -// "--flag=value" or "--flag". -// -// In the former case, the value is taken as true as long as it does -// not start with '0', 'f', or 'F'. -// -// In the latter case, the value is taken as true. -// -// On success, stores the value of the flag in *value, and returns -// true. On failure, returns false without changing *value. -static bool ParseBoolFlag(const char* str, const char* flag, bool* value) { - // Gets the value of the flag as a string. - const char* const value_str = ParseFlagValue(str, flag, true); - - // Aborts if the parsing failed. - if (value_str == nullptr) return false; - - // Converts the string value to a bool. - *value = !(*value_str == '0' || *value_str == 'f' || *value_str == 'F'); - return true; -} - -// Parses a string for an int32_t flag, in the form of "--flag=value". -// -// On success, stores the value of the flag in *value, and returns -// true. On failure, returns false without changing *value. -bool ParseInt32Flag(const char* str, const char* flag, int32_t* value) { - // Gets the value of the flag as a string. - const char* const value_str = ParseFlagValue(str, flag, false); - - // Aborts if the parsing failed. - if (value_str == nullptr) return false; - - // Sets *value to the value of the flag. - return ParseInt32(Message() << "The value of flag --" << flag, - value_str, value); -} - -// Parses a string for a string flag, in the form of "--flag=value". -// -// On success, stores the value of the flag in *value, and returns -// true. On failure, returns false without changing *value. -template <typename String> -static bool ParseStringFlag(const char* str, const char* flag, String* value) { - // Gets the value of the flag as a string. - const char* const value_str = ParseFlagValue(str, flag, false); - - // Aborts if the parsing failed. - if (value_str == nullptr) return false; - - // Sets *value to the value of the flag. - *value = value_str; - return true; -} - -// Determines whether a string has a prefix that Google Test uses for its -// flags, i.e., starts with GTEST_FLAG_PREFIX_ or GTEST_FLAG_PREFIX_DASH_. -// If Google Test detects that a command line flag has its prefix but is not -// recognized, it will print its help message. Flags starting with -// GTEST_INTERNAL_PREFIX_ followed by "internal_" are considered Google Test -// internal flags and do not trigger the help message. -static bool HasGoogleTestFlagPrefix(const char* str) { - return (SkipPrefix("--", &str) || - SkipPrefix("-", &str) || - SkipPrefix("/", &str)) && - !SkipPrefix(GTEST_FLAG_PREFIX_ "internal_", &str) && - (SkipPrefix(GTEST_FLAG_PREFIX_, &str) || - SkipPrefix(GTEST_FLAG_PREFIX_DASH_, &str)); -} - -// Prints a string containing code-encoded text. The following escape -// sequences can be used in the string to control the text color: -// -// @@ prints a single '@' character. -// @R changes the color to red. -// @G changes the color to green. -// @Y changes the color to yellow. -// @D changes to the default terminal text color. -// -static void PrintColorEncoded(const char* str) { - GTestColor color = GTestColor::kDefault; // The current color. - - // Conceptually, we split the string into segments divided by escape - // sequences. Then we print one segment at a time. At the end of - // each iteration, the str pointer advances to the beginning of the - // next segment. - for (;;) { - const char* p = strchr(str, '@'); - if (p == nullptr) { - ColoredPrintf(color, "%s", str); - return; - } - - ColoredPrintf(color, "%s", std::string(str, p).c_str()); - - const char ch = p[1]; - str = p + 2; - if (ch == '@') { - ColoredPrintf(color, "@"); - } else if (ch == 'D') { - color = GTestColor::kDefault; - } else if (ch == 'R') { - color = GTestColor::kRed; - } else if (ch == 'G') { - color = GTestColor::kGreen; - } else if (ch == 'Y') { - color = GTestColor::kYellow; - } else { - --str; - } - } -} - -static const char kColorEncodedHelpMessage[] = - "This program contains tests written using " GTEST_NAME_ - ". You can use the\n" - "following command line flags to control its behavior:\n" - "\n" - "Test Selection:\n" - " @G--" GTEST_FLAG_PREFIX_ - "list_tests@D\n" - " List the names of all tests instead of running them. The name of\n" - " TEST(Foo, Bar) is \"Foo.Bar\".\n" - " @G--" GTEST_FLAG_PREFIX_ - "filter=@YPOSITIVE_PATTERNS" - "[@G-@YNEGATIVE_PATTERNS]@D\n" - " Run only the tests whose name matches one of the positive patterns " - "but\n" - " none of the negative patterns. '?' matches any single character; " - "'*'\n" - " matches any substring; ':' separates two patterns.\n" - " @G--" GTEST_FLAG_PREFIX_ - "also_run_disabled_tests@D\n" - " Run all disabled tests too.\n" - "\n" - "Test Execution:\n" - " @G--" GTEST_FLAG_PREFIX_ - "repeat=@Y[COUNT]@D\n" - " Run the tests repeatedly; use a negative count to repeat forever.\n" - " @G--" GTEST_FLAG_PREFIX_ - "shuffle@D\n" - " Randomize tests' orders on every iteration.\n" - " @G--" GTEST_FLAG_PREFIX_ - "random_seed=@Y[NUMBER]@D\n" - " Random number seed to use for shuffling test orders (between 1 and\n" - " 99999, or 0 to use a seed based on the current time).\n" - "\n" - "Test Output:\n" - " @G--" GTEST_FLAG_PREFIX_ - "color=@Y(@Gyes@Y|@Gno@Y|@Gauto@Y)@D\n" - " Enable/disable colored output. The default is @Gauto@D.\n" - " @G--" GTEST_FLAG_PREFIX_ - "brief=1@D\n" - " Only print test failures.\n" - " @G--" GTEST_FLAG_PREFIX_ - "print_time=0@D\n" - " Don't print the elapsed time of each test.\n" - " @G--" GTEST_FLAG_PREFIX_ - "output=@Y(@Gjson@Y|@Gxml@Y)[@G:@YDIRECTORY_PATH@G" GTEST_PATH_SEP_ - "@Y|@G:@YFILE_PATH]@D\n" - " Generate a JSON or XML report in the given directory or with the " - "given\n" - " file name. @YFILE_PATH@D defaults to @Gtest_detail.xml@D.\n" -# if GTEST_CAN_STREAM_RESULTS_ - " @G--" GTEST_FLAG_PREFIX_ - "stream_result_to=@YHOST@G:@YPORT@D\n" - " Stream test results to the given server.\n" -# endif // GTEST_CAN_STREAM_RESULTS_ - "\n" - "Assertion Behavior:\n" -# if GTEST_HAS_DEATH_TEST && !GTEST_OS_WINDOWS - " @G--" GTEST_FLAG_PREFIX_ - "death_test_style=@Y(@Gfast@Y|@Gthreadsafe@Y)@D\n" - " Set the default death test style.\n" -# endif // GTEST_HAS_DEATH_TEST && !GTEST_OS_WINDOWS - " @G--" GTEST_FLAG_PREFIX_ - "break_on_failure@D\n" - " Turn assertion failures into debugger break-points.\n" - " @G--" GTEST_FLAG_PREFIX_ - "throw_on_failure@D\n" - " Turn assertion failures into C++ exceptions for use by an external\n" - " test framework.\n" - " @G--" GTEST_FLAG_PREFIX_ - "catch_exceptions=0@D\n" - " Do not report exceptions as test failures. Instead, allow them\n" - " to crash the program or throw a pop-up (on Windows).\n" - "\n" - "Except for @G--" GTEST_FLAG_PREFIX_ - "list_tests@D, you can alternatively set " - "the corresponding\n" - "environment variable of a flag (all letters in upper-case). For example, " - "to\n" - "disable colored text output, you can either specify " - "@G--" GTEST_FLAG_PREFIX_ - "color=no@D or set\n" - "the @G" GTEST_FLAG_PREFIX_UPPER_ - "COLOR@D environment variable to @Gno@D.\n" - "\n" - "For more information, please read the " GTEST_NAME_ - " documentation at\n" - "@G" GTEST_PROJECT_URL_ "@D. If you find a bug in " GTEST_NAME_ - "\n" - "(not one in your own code or tests), please report it to\n" - "@G<" GTEST_DEV_EMAIL_ ">@D.\n"; - -static bool ParseGoogleTestFlag(const char* const arg) { - return ParseBoolFlag(arg, kAlsoRunDisabledTestsFlag, - >EST_FLAG(also_run_disabled_tests)) || - ParseBoolFlag(arg, kBreakOnFailureFlag, - >EST_FLAG(break_on_failure)) || - ParseBoolFlag(arg, kCatchExceptionsFlag, - >EST_FLAG(catch_exceptions)) || - ParseStringFlag(arg, kColorFlag, >EST_FLAG(color)) || - ParseStringFlag(arg, kDeathTestStyleFlag, - >EST_FLAG(death_test_style)) || - ParseBoolFlag(arg, kDeathTestUseFork, - >EST_FLAG(death_test_use_fork)) || - ParseBoolFlag(arg, kFailFast, >EST_FLAG(fail_fast)) || - ParseStringFlag(arg, kFilterFlag, >EST_FLAG(filter)) || - ParseStringFlag(arg, kInternalRunDeathTestFlag, - >EST_FLAG(internal_run_death_test)) || - ParseBoolFlag(arg, kListTestsFlag, >EST_FLAG(list_tests)) || - ParseStringFlag(arg, kOutputFlag, >EST_FLAG(output)) || - ParseBoolFlag(arg, kBriefFlag, >EST_FLAG(brief)) || - ParseBoolFlag(arg, kPrintTimeFlag, >EST_FLAG(print_time)) || - ParseBoolFlag(arg, kPrintUTF8Flag, >EST_FLAG(print_utf8)) || - ParseInt32Flag(arg, kRandomSeedFlag, >EST_FLAG(random_seed)) || - ParseInt32Flag(arg, kRepeatFlag, >EST_FLAG(repeat)) || - ParseBoolFlag(arg, kShuffleFlag, >EST_FLAG(shuffle)) || - ParseInt32Flag(arg, kStackTraceDepthFlag, - >EST_FLAG(stack_trace_depth)) || - ParseStringFlag(arg, kStreamResultToFlag, - >EST_FLAG(stream_result_to)) || - ParseBoolFlag(arg, kThrowOnFailureFlag, >EST_FLAG(throw_on_failure)); -} - -#if GTEST_USE_OWN_FLAGFILE_FLAG_ -static void LoadFlagsFromFile(const std::string& path) { - FILE* flagfile = posix::FOpen(path.c_str(), "r"); - if (!flagfile) { - GTEST_LOG_(FATAL) << "Unable to open file \"" << GTEST_FLAG(flagfile) - << "\""; - } - std::string contents(ReadEntireFile(flagfile)); - posix::FClose(flagfile); - std::vector<std::string> lines; - SplitString(contents, '\n', &lines); - for (size_t i = 0; i < lines.size(); ++i) { - if (lines[i].empty()) - continue; - if (!ParseGoogleTestFlag(lines[i].c_str())) - g_help_flag = true; - } -} -#endif // GTEST_USE_OWN_FLAGFILE_FLAG_ - -// Parses the command line for Google Test flags, without initializing -// other parts of Google Test. The type parameter CharType can be -// instantiated to either char or wchar_t. -template <typename CharType> -void ParseGoogleTestFlagsOnlyImpl(int* argc, CharType** argv) { - for (int i = 1; i < *argc; i++) { - const std::string arg_string = StreamableToString(argv[i]); - const char* const arg = arg_string.c_str(); - - using internal::ParseBoolFlag; - using internal::ParseInt32Flag; - using internal::ParseStringFlag; - - bool remove_flag = false; - if (ParseGoogleTestFlag(arg)) { - remove_flag = true; -#if GTEST_USE_OWN_FLAGFILE_FLAG_ - } else if (ParseStringFlag(arg, kFlagfileFlag, >EST_FLAG(flagfile))) { - LoadFlagsFromFile(GTEST_FLAG(flagfile)); - remove_flag = true; -#endif // GTEST_USE_OWN_FLAGFILE_FLAG_ - } else if (arg_string == "--help" || arg_string == "-h" || - arg_string == "-?" || arg_string == "/?" || - HasGoogleTestFlagPrefix(arg)) { - // Both help flag and unrecognized Google Test flags (excluding - // internal ones) trigger help display. - g_help_flag = true; - } - - if (remove_flag) { - // Shift the remainder of the argv list left by one. Note - // that argv has (*argc + 1) elements, the last one always being - // NULL. The following loop moves the trailing NULL element as - // well. - for (int j = i; j != *argc; j++) { - argv[j] = argv[j + 1]; - } - - // Decrements the argument count. - (*argc)--; - - // We also need to decrement the iterator as we just removed - // an element. - i--; - } - } - - if (g_help_flag) { - // We print the help here instead of in RUN_ALL_TESTS(), as the - // latter may not be called at all if the user is using Google - // Test with another testing framework. - PrintColorEncoded(kColorEncodedHelpMessage); - } -} - -// Parses the command line for Google Test flags, without initializing -// other parts of Google Test. -void ParseGoogleTestFlagsOnly(int* argc, char** argv) { - ParseGoogleTestFlagsOnlyImpl(argc, argv); - - // Fix the value of *_NSGetArgc() on macOS, but if and only if - // *_NSGetArgv() == argv - // Only applicable to char** version of argv -#if GTEST_OS_MAC -#ifndef GTEST_OS_IOS - if (*_NSGetArgv() == argv) { - *_NSGetArgc() = *argc; - } -#endif -#endif -} -void ParseGoogleTestFlagsOnly(int* argc, wchar_t** argv) { - ParseGoogleTestFlagsOnlyImpl(argc, argv); -} - -// The internal implementation of InitGoogleTest(). -// -// The type parameter CharType can be instantiated to either char or -// wchar_t. -template <typename CharType> -void InitGoogleTestImpl(int* argc, CharType** argv) { - // We don't want to run the initialization code twice. - if (GTestIsInitialized()) return; - - if (*argc <= 0) return; - - g_argvs.clear(); - for (int i = 0; i != *argc; i++) { - g_argvs.push_back(StreamableToString(argv[i])); - } - -#if GTEST_HAS_ABSL - absl::InitializeSymbolizer(g_argvs[0].c_str()); -#endif // GTEST_HAS_ABSL - - ParseGoogleTestFlagsOnly(argc, argv); - GetUnitTestImpl()->PostFlagParsingInit(); -} - -} // namespace internal - -// Initializes Google Test. This must be called before calling -// RUN_ALL_TESTS(). In particular, it parses a command line for the -// flags that Google Test recognizes. Whenever a Google Test flag is -// seen, it is removed from argv, and *argc is decremented. -// -// No value is returned. Instead, the Google Test flag variables are -// updated. -// -// Calling the function for the second time has no user-visible effect. -void InitGoogleTest(int* argc, char** argv) { -#if defined(GTEST_CUSTOM_INIT_GOOGLE_TEST_FUNCTION_) - GTEST_CUSTOM_INIT_GOOGLE_TEST_FUNCTION_(argc, argv); -#else // defined(GTEST_CUSTOM_INIT_GOOGLE_TEST_FUNCTION_) - internal::InitGoogleTestImpl(argc, argv); -#endif // defined(GTEST_CUSTOM_INIT_GOOGLE_TEST_FUNCTION_) -} - -// This overloaded version can be used in Windows programs compiled in -// UNICODE mode. -void InitGoogleTest(int* argc, wchar_t** argv) { -#if defined(GTEST_CUSTOM_INIT_GOOGLE_TEST_FUNCTION_) - GTEST_CUSTOM_INIT_GOOGLE_TEST_FUNCTION_(argc, argv); -#else // defined(GTEST_CUSTOM_INIT_GOOGLE_TEST_FUNCTION_) - internal::InitGoogleTestImpl(argc, argv); -#endif // defined(GTEST_CUSTOM_INIT_GOOGLE_TEST_FUNCTION_) -} - -// This overloaded version can be used on Arduino/embedded platforms where -// there is no argc/argv. -void InitGoogleTest() { - // Since Arduino doesn't have a command line, fake out the argc/argv arguments - int argc = 1; - const auto arg0 = "dummy"; - char* argv0 = const_cast<char*>(arg0); - char** argv = &argv0; - -#if defined(GTEST_CUSTOM_INIT_GOOGLE_TEST_FUNCTION_) - GTEST_CUSTOM_INIT_GOOGLE_TEST_FUNCTION_(&argc, argv); -#else // defined(GTEST_CUSTOM_INIT_GOOGLE_TEST_FUNCTION_) - internal::InitGoogleTestImpl(&argc, argv); -#endif // defined(GTEST_CUSTOM_INIT_GOOGLE_TEST_FUNCTION_) -} - -std::string TempDir() { -#if defined(GTEST_CUSTOM_TEMPDIR_FUNCTION_) - return GTEST_CUSTOM_TEMPDIR_FUNCTION_(); -#elif GTEST_OS_WINDOWS_MOBILE - return "\\temp\\"; -#elif GTEST_OS_WINDOWS - const char* temp_dir = internal::posix::GetEnv("TEMP"); - if (temp_dir == nullptr || temp_dir[0] == '\0') { - return "\\temp\\"; - } else if (temp_dir[strlen(temp_dir) - 1] == '\\') { - return temp_dir; - } else { - return std::string(temp_dir) + "\\"; - } -#elif GTEST_OS_LINUX_ANDROID - const char* temp_dir = internal::posix::GetEnv("TEST_TMPDIR"); - if (temp_dir == nullptr || temp_dir[0] == '\0') { - return "/data/local/tmp/"; - } else { - return temp_dir; - } -#elif GTEST_OS_LINUX - const char* temp_dir = internal::posix::GetEnv("TEST_TMPDIR"); - if (temp_dir == nullptr || temp_dir[0] == '\0') { - return "/tmp/"; - } else { - return temp_dir; - } -#else - return "/tmp/"; -#endif // GTEST_OS_WINDOWS_MOBILE -} - -// Class ScopedTrace - -// Pushes the given source file location and message onto a per-thread -// trace stack maintained by Google Test. -void ScopedTrace::PushTrace(const char* file, int line, std::string message) { - internal::TraceInfo trace; - trace.file = file; - trace.line = line; - trace.message.swap(message); - - UnitTest::GetInstance()->PushGTestTrace(trace); -} - -// Pops the info pushed by the c'tor. -ScopedTrace::~ScopedTrace() - GTEST_LOCK_EXCLUDED_(&UnitTest::mutex_) { - UnitTest::GetInstance()->PopGTestTrace(); -} - -} // namespace testing -// 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. - -// -// This file implements death tests. - - -#include <functional> -#include <utility> - - -#if GTEST_HAS_DEATH_TEST - -# if GTEST_OS_MAC -# include <crt_externs.h> -# endif // GTEST_OS_MAC - -# include <errno.h> -# include <fcntl.h> -# include <limits.h> - -# if GTEST_OS_LINUX -# include <signal.h> -# endif // GTEST_OS_LINUX - -# include <stdarg.h> - -# if GTEST_OS_WINDOWS -# include <windows.h> -# else -# include <sys/mman.h> -# include <sys/wait.h> -# endif // GTEST_OS_WINDOWS - -# if GTEST_OS_QNX -# include <spawn.h> -# endif // GTEST_OS_QNX - -# if GTEST_OS_FUCHSIA -# include <lib/fdio/fd.h> -# include <lib/fdio/io.h> -# include <lib/fdio/spawn.h> -# include <lib/zx/channel.h> -# include <lib/zx/port.h> -# include <lib/zx/process.h> -# include <lib/zx/socket.h> -# include <zircon/processargs.h> -# include <zircon/syscalls.h> -# include <zircon/syscalls/policy.h> -# include <zircon/syscalls/port.h> -# endif // GTEST_OS_FUCHSIA - -#endif // GTEST_HAS_DEATH_TEST - - -namespace testing { - -// Constants. - -// The default death test style. -// -// This is defined in internal/gtest-port.h as "fast", but can be overridden by -// a definition in internal/custom/gtest-port.h. The recommended value, which is -// used internally at Google, is "threadsafe". -static const char kDefaultDeathTestStyle[] = GTEST_DEFAULT_DEATH_TEST_STYLE; - -GTEST_DEFINE_string_( - death_test_style, - internal::StringFromGTestEnv("death_test_style", kDefaultDeathTestStyle), - "Indicates how to run a death test in a forked child process: " - "\"threadsafe\" (child process re-executes the test binary " - "from the beginning, running only the specific death test) or " - "\"fast\" (child process runs the death test immediately " - "after forking)."); - -GTEST_DEFINE_bool_( - death_test_use_fork, - internal::BoolFromGTestEnv("death_test_use_fork", false), - "Instructs to use fork()/_exit() instead of clone() in death tests. " - "Ignored and always uses fork() on POSIX systems where clone() is not " - "implemented. Useful when running under valgrind or similar tools if " - "those do not support clone(). Valgrind 3.3.1 will just fail if " - "it sees an unsupported combination of clone() flags. " - "It is not recommended to use this flag w/o valgrind though it will " - "work in 99% of the cases. Once valgrind is fixed, this flag will " - "most likely be removed."); - -namespace internal { -GTEST_DEFINE_string_( - internal_run_death_test, "", - "Indicates the file, line number, temporal index of " - "the single death test to run, and a file descriptor to " - "which a success code may be sent, all separated by " - "the '|' characters. This flag is specified if and only if the " - "current process is a sub-process launched for running a thread-safe " - "death test. FOR INTERNAL USE ONLY."); -} // namespace internal - -#if GTEST_HAS_DEATH_TEST - -namespace internal { - -// Valid only for fast death tests. Indicates the code is running in the -// child process of a fast style death test. -# if !GTEST_OS_WINDOWS && !GTEST_OS_FUCHSIA -static bool g_in_fast_death_test_child = false; -# endif - -// Returns a Boolean value indicating whether the caller is currently -// executing in the context of the death test child process. Tools such as -// Valgrind heap checkers may need this to modify their behavior in death -// tests. IMPORTANT: This is an internal utility. Using it may break the -// implementation of death tests. User code MUST NOT use it. -bool InDeathTestChild() { -# if GTEST_OS_WINDOWS || GTEST_OS_FUCHSIA - - // On Windows and Fuchsia, death tests are thread-safe regardless of the value - // of the death_test_style flag. - return !GTEST_FLAG(internal_run_death_test).empty(); - -# else - - if (GTEST_FLAG(death_test_style) == "threadsafe") - return !GTEST_FLAG(internal_run_death_test).empty(); - else - return g_in_fast_death_test_child; -#endif -} - -} // namespace internal - -// ExitedWithCode constructor. -ExitedWithCode::ExitedWithCode(int exit_code) : exit_code_(exit_code) { -} - -// ExitedWithCode function-call operator. -bool ExitedWithCode::operator()(int exit_status) const { -# if GTEST_OS_WINDOWS || GTEST_OS_FUCHSIA - - return exit_status == exit_code_; - -# else - - return WIFEXITED(exit_status) && WEXITSTATUS(exit_status) == exit_code_; - -# endif // GTEST_OS_WINDOWS || GTEST_OS_FUCHSIA -} - -# if !GTEST_OS_WINDOWS && !GTEST_OS_FUCHSIA -// KilledBySignal constructor. -KilledBySignal::KilledBySignal(int signum) : signum_(signum) { -} - -// KilledBySignal function-call operator. -bool KilledBySignal::operator()(int exit_status) const { -# if defined(GTEST_KILLED_BY_SIGNAL_OVERRIDE_) - { - bool result; - if (GTEST_KILLED_BY_SIGNAL_OVERRIDE_(signum_, exit_status, &result)) { - return result; - } - } -# endif // defined(GTEST_KILLED_BY_SIGNAL_OVERRIDE_) - return WIFSIGNALED(exit_status) && WTERMSIG(exit_status) == signum_; -} -# endif // !GTEST_OS_WINDOWS && !GTEST_OS_FUCHSIA - -namespace internal { - -// Utilities needed for death tests. - -// Generates a textual description of a given exit code, in the format -// specified by wait(2). -static std::string ExitSummary(int exit_code) { - Message m; - -# if GTEST_OS_WINDOWS || GTEST_OS_FUCHSIA - - m << "Exited with exit status " << exit_code; - -# else - - if (WIFEXITED(exit_code)) { - m << "Exited with exit status " << WEXITSTATUS(exit_code); - } else if (WIFSIGNALED(exit_code)) { - m << "Terminated by signal " << WTERMSIG(exit_code); - } -# ifdef WCOREDUMP - if (WCOREDUMP(exit_code)) { - m << " (core dumped)"; - } -# endif -# endif // GTEST_OS_WINDOWS || GTEST_OS_FUCHSIA - - return m.GetString(); -} - -// Returns true if exit_status describes a process that was terminated -// by a signal, or exited normally with a nonzero exit code. -bool ExitedUnsuccessfully(int exit_status) { - return !ExitedWithCode(0)(exit_status); -} - -# if !GTEST_OS_WINDOWS && !GTEST_OS_FUCHSIA -// Generates a textual failure message when a death test finds more than -// one thread running, or cannot determine the number of threads, prior -// to executing the given statement. It is the responsibility of the -// caller not to pass a thread_count of 1. -static std::string DeathTestThreadWarning(size_t thread_count) { - Message msg; - msg << "Death tests use fork(), which is unsafe particularly" - << " in a threaded context. For this test, " << GTEST_NAME_ << " "; - if (thread_count == 0) { - msg << "couldn't detect the number of threads."; - } else { - msg << "detected " << thread_count << " threads."; - } - msg << " See " - "https://github.com/google/googletest/blob/master/docs/" - "advanced.md#death-tests-and-threads" - << " for more explanation and suggested solutions, especially if" - << " this is the last message you see before your test times out."; - return msg.GetString(); -} -# endif // !GTEST_OS_WINDOWS && !GTEST_OS_FUCHSIA - -// Flag characters for reporting a death test that did not die. -static const char kDeathTestLived = 'L'; -static const char kDeathTestReturned = 'R'; -static const char kDeathTestThrew = 'T'; -static const char kDeathTestInternalError = 'I'; - -#if GTEST_OS_FUCHSIA - -// File descriptor used for the pipe in the child process. -static const int kFuchsiaReadPipeFd = 3; - -#endif - -// An enumeration describing all of the possible ways that a death test can -// conclude. DIED means that the process died while executing the test -// code; LIVED means that process lived beyond the end of the test code; -// RETURNED means that the test statement attempted to execute a return -// statement, which is not allowed; THREW means that the test statement -// returned control by throwing an exception. IN_PROGRESS means the test -// has not yet concluded. -enum DeathTestOutcome { IN_PROGRESS, DIED, LIVED, RETURNED, THREW }; - -// Routine for aborting the program which is safe to call from an -// exec-style death test child process, in which case the error -// message is propagated back to the parent process. Otherwise, the -// message is simply printed to stderr. In either case, the program -// then exits with status 1. -static void DeathTestAbort(const std::string& message) { - // On a POSIX system, this function may be called from a threadsafe-style - // death test child process, which operates on a very small stack. Use - // the heap for any additional non-minuscule memory requirements. - const InternalRunDeathTestFlag* const flag = - GetUnitTestImpl()->internal_run_death_test_flag(); - if (flag != nullptr) { - FILE* parent = posix::FDOpen(flag->write_fd(), "w"); - fputc(kDeathTestInternalError, parent); - fprintf(parent, "%s", message.c_str()); - fflush(parent); - _exit(1); - } else { - fprintf(stderr, "%s", message.c_str()); - fflush(stderr); - posix::Abort(); - } -} - -// A replacement for CHECK that calls DeathTestAbort if the assertion -// fails. -# define GTEST_DEATH_TEST_CHECK_(expression) \ - do { \ - if (!::testing::internal::IsTrue(expression)) { \ - DeathTestAbort( \ - ::std::string("CHECK failed: File ") + __FILE__ + ", line " \ - + ::testing::internal::StreamableToString(__LINE__) + ": " \ - + #expression); \ - } \ - } while (::testing::internal::AlwaysFalse()) - -// This macro is similar to GTEST_DEATH_TEST_CHECK_, but it is meant for -// evaluating any system call that fulfills two conditions: it must return -// -1 on failure, and set errno to EINTR when it is interrupted and -// should be tried again. The macro expands to a loop that repeatedly -// evaluates the expression as long as it evaluates to -1 and sets -// errno to EINTR. If the expression evaluates to -1 but errno is -// something other than EINTR, DeathTestAbort is called. -# define GTEST_DEATH_TEST_CHECK_SYSCALL_(expression) \ - do { \ - int gtest_retval; \ - do { \ - gtest_retval = (expression); \ - } while (gtest_retval == -1 && errno == EINTR); \ - if (gtest_retval == -1) { \ - DeathTestAbort( \ - ::std::string("CHECK failed: File ") + __FILE__ + ", line " \ - + ::testing::internal::StreamableToString(__LINE__) + ": " \ - + #expression + " != -1"); \ - } \ - } while (::testing::internal::AlwaysFalse()) - -// Returns the message describing the last system error in errno. -std::string GetLastErrnoDescription() { - return errno == 0 ? "" : posix::StrError(errno); -} - -// This is called from a death test parent process to read a failure -// message from the death test child process and log it with the FATAL -// severity. On Windows, the message is read from a pipe handle. On other -// platforms, it is read from a file descriptor. -static void FailFromInternalError(int fd) { - Message error; - char buffer[256]; - int num_read; - - do { - while ((num_read = posix::Read(fd, buffer, 255)) > 0) { - buffer[num_read] = '\0'; - error << buffer; - } - } while (num_read == -1 && errno == EINTR); - - if (num_read == 0) { - GTEST_LOG_(FATAL) << error.GetString(); - } else { - const int last_error = errno; - GTEST_LOG_(FATAL) << "Error while reading death test internal: " - << GetLastErrnoDescription() << " [" << last_error << "]"; - } -} - -// Death test constructor. Increments the running death test count -// for the current test. -DeathTest::DeathTest() { - TestInfo* const info = GetUnitTestImpl()->current_test_info(); - if (info == nullptr) { - DeathTestAbort("Cannot run a death test outside of a TEST or " - "TEST_F construct"); - } -} - -// Creates and returns a death test by dispatching to the current -// death test factory. -bool DeathTest::Create(const char* statement, - Matcher<const std::string&> matcher, const char* file, - int line, DeathTest** test) { - return GetUnitTestImpl()->death_test_factory()->Create( - statement, std::move(matcher), file, line, test); -} - -const char* DeathTest::LastMessage() { - return last_death_test_message_.c_str(); -} - -void DeathTest::set_last_death_test_message(const std::string& message) { - last_death_test_message_ = message; -} - -std::string DeathTest::last_death_test_message_; - -// Provides cross platform implementation for some death functionality. -class DeathTestImpl : public DeathTest { - protected: - DeathTestImpl(const char* a_statement, Matcher<const std::string&> matcher) - : statement_(a_statement), - matcher_(std::move(matcher)), - spawned_(false), - status_(-1), - outcome_(IN_PROGRESS), - read_fd_(-1), - write_fd_(-1) {} - - // read_fd_ is expected to be closed and cleared by a derived class. - ~DeathTestImpl() override { GTEST_DEATH_TEST_CHECK_(read_fd_ == -1); } - - void Abort(AbortReason reason) override; - bool Passed(bool status_ok) override; - - const char* statement() const { return statement_; } - bool spawned() const { return spawned_; } - void set_spawned(bool is_spawned) { spawned_ = is_spawned; } - int status() const { return status_; } - void set_status(int a_status) { status_ = a_status; } - DeathTestOutcome outcome() const { return outcome_; } - void set_outcome(DeathTestOutcome an_outcome) { outcome_ = an_outcome; } - int read_fd() const { return read_fd_; } - void set_read_fd(int fd) { read_fd_ = fd; } - int write_fd() const { return write_fd_; } - void set_write_fd(int fd) { write_fd_ = fd; } - - // Called in the parent process only. Reads the result code of the death - // test child process via a pipe, interprets it to set the outcome_ - // member, and closes read_fd_. Outputs diagnostics and terminates in - // case of unexpected codes. - void ReadAndInterpretStatusByte(); - - // Returns stderr output from the child process. - virtual std::string GetErrorLogs(); - - private: - // The textual content of the code this object is testing. This class - // doesn't own this string and should not attempt to delete it. - const char* const statement_; - // A matcher that's expected to match the stderr output by the child process. - Matcher<const std::string&> matcher_; - // True if the death test child process has been successfully spawned. - bool spawned_; - // The exit status of the child process. - int status_; - // How the death test concluded. - DeathTestOutcome outcome_; - // Descriptor to the read end of the pipe to the child process. It is - // always -1 in the child process. The child keeps its write end of the - // pipe in write_fd_. - int read_fd_; - // Descriptor to the child's write end of the pipe to the parent process. - // It is always -1 in the parent process. The parent keeps its end of the - // pipe in read_fd_. - int write_fd_; -}; - -// Called in the parent process only. Reads the result code of the death -// test child process via a pipe, interprets it to set the outcome_ -// member, and closes read_fd_. Outputs diagnostics and terminates in -// case of unexpected codes. -void DeathTestImpl::ReadAndInterpretStatusByte() { - char flag; - int bytes_read; - - // The read() here blocks until data is available (signifying the - // failure of the death test) or until the pipe is closed (signifying - // its success), so it's okay to call this in the parent before - // the child process has exited. - do { - bytes_read = posix::Read(read_fd(), &flag, 1); - } while (bytes_read == -1 && errno == EINTR); - - if (bytes_read == 0) { - set_outcome(DIED); - } else if (bytes_read == 1) { - switch (flag) { - case kDeathTestReturned: - set_outcome(RETURNED); - break; - case kDeathTestThrew: - set_outcome(THREW); - break; - case kDeathTestLived: - set_outcome(LIVED); - break; - case kDeathTestInternalError: - FailFromInternalError(read_fd()); // Does not return. - break; - default: - GTEST_LOG_(FATAL) << "Death test child process reported " - << "unexpected status byte (" - << static_cast<unsigned int>(flag) << ")"; - } - } else { - GTEST_LOG_(FATAL) << "Read from death test child process failed: " - << GetLastErrnoDescription(); - } - GTEST_DEATH_TEST_CHECK_SYSCALL_(posix::Close(read_fd())); - set_read_fd(-1); -} - -std::string DeathTestImpl::GetErrorLogs() { - return GetCapturedStderr(); -} - -// Signals that the death test code which should have exited, didn't. -// Should be called only in a death test child process. -// Writes a status byte to the child's status file descriptor, then -// calls _exit(1). -void DeathTestImpl::Abort(AbortReason reason) { - // The parent process considers the death test to be a failure if - // it finds any data in our pipe. So, here we write a single flag byte - // to the pipe, then exit. - const char status_ch = - reason == TEST_DID_NOT_DIE ? kDeathTestLived : - reason == TEST_THREW_EXCEPTION ? kDeathTestThrew : kDeathTestReturned; - - GTEST_DEATH_TEST_CHECK_SYSCALL_(posix::Write(write_fd(), &status_ch, 1)); - // We are leaking the descriptor here because on some platforms (i.e., - // when built as Windows DLL), destructors of global objects will still - // run after calling _exit(). On such systems, write_fd_ will be - // indirectly closed from the destructor of UnitTestImpl, causing double - // close if it is also closed here. On debug configurations, double close - // may assert. As there are no in-process buffers to flush here, we are - // relying on the OS to close the descriptor after the process terminates - // when the destructors are not run. - _exit(1); // Exits w/o any normal exit hooks (we were supposed to crash) -} - -// Returns an indented copy of stderr output for a death test. -// This makes distinguishing death test output lines from regular log lines -// much easier. -static ::std::string FormatDeathTestOutput(const ::std::string& output) { - ::std::string ret; - for (size_t at = 0; ; ) { - const size_t line_end = output.find('\n', at); - ret += "[ DEATH ] "; - if (line_end == ::std::string::npos) { - ret += output.substr(at); - break; - } - ret += output.substr(at, line_end + 1 - at); - at = line_end + 1; - } - return ret; -} - -// Assesses the success or failure of a death test, using both private -// members which have previously been set, and one argument: -// -// Private data members: -// outcome: An enumeration describing how the death test -// concluded: DIED, LIVED, THREW, or RETURNED. The death test -// fails in the latter three cases. -// status: The exit status of the child process. On *nix, it is in the -// in the format specified by wait(2). On Windows, this is the -// value supplied to the ExitProcess() API or a numeric code -// of the exception that terminated the program. -// matcher_: A matcher that's expected to match the stderr output by the child -// process. -// -// Argument: -// status_ok: true if exit_status is acceptable in the context of -// this particular death test, which fails if it is false -// -// Returns true if and only if all of the above conditions are met. Otherwise, -// the first failing condition, in the order given above, is the one that is -// reported. Also sets the last death test message string. -bool DeathTestImpl::Passed(bool status_ok) { - if (!spawned()) - return false; - - const std::string error_message = GetErrorLogs(); - - bool success = false; - Message buffer; - - buffer << "Death test: " << statement() << "\n"; - switch (outcome()) { - case LIVED: - buffer << " Result: failed to die.\n" - << " Error msg:\n" << FormatDeathTestOutput(error_message); - break; - case THREW: - buffer << " Result: threw an exception.\n" - << " Error msg:\n" << FormatDeathTestOutput(error_message); - break; - case RETURNED: - buffer << " Result: illegal return in test statement.\n" - << " Error msg:\n" << FormatDeathTestOutput(error_message); - break; - case DIED: - if (status_ok) { - if (matcher_.Matches(error_message)) { - success = true; - } else { - std::ostringstream stream; - matcher_.DescribeTo(&stream); - buffer << " Result: died but not with expected error.\n" - << " Expected: " << stream.str() << "\n" - << "Actual msg:\n" - << FormatDeathTestOutput(error_message); - } - } else { - buffer << " Result: died but not with expected exit code:\n" - << " " << ExitSummary(status()) << "\n" - << "Actual msg:\n" << FormatDeathTestOutput(error_message); - } - break; - case IN_PROGRESS: - default: - GTEST_LOG_(FATAL) - << "DeathTest::Passed somehow called before conclusion of test"; - } - - DeathTest::set_last_death_test_message(buffer.GetString()); - return success; -} - -# if GTEST_OS_WINDOWS -// WindowsDeathTest implements death tests on Windows. Due to the -// specifics of starting new processes on Windows, death tests there are -// always threadsafe, and Google Test considers the -// --gtest_death_test_style=fast setting to be equivalent to -// --gtest_death_test_style=threadsafe there. -// -// A few implementation notes: Like the Linux version, the Windows -// implementation uses pipes for child-to-parent communication. But due to -// the specifics of pipes on Windows, some extra steps are required: -// -// 1. The parent creates a communication pipe and stores handles to both -// ends of it. -// 2. The parent starts the child and provides it with the information -// necessary to acquire the handle to the write end of the pipe. -// 3. The child acquires the write end of the pipe and signals the parent -// using a Windows event. -// 4. Now the parent can release the write end of the pipe on its side. If -// this is done before step 3, the object's reference count goes down to -// 0 and it is destroyed, preventing the child from acquiring it. The -// parent now has to release it, or read operations on the read end of -// the pipe will not return when the child terminates. -// 5. The parent reads child's output through the pipe (outcome code and -// any possible error messages) from the pipe, and its stderr and then -// determines whether to fail the test. -// -// Note: to distinguish Win32 API calls from the local method and function -// calls, the former are explicitly resolved in the global namespace. -// -class WindowsDeathTest : public DeathTestImpl { - public: - WindowsDeathTest(const char* a_statement, Matcher<const std::string&> matcher, - const char* file, int line) - : DeathTestImpl(a_statement, std::move(matcher)), - file_(file), - line_(line) {} - - // All of these virtual functions are inherited from DeathTest. - virtual int Wait(); - virtual TestRole AssumeRole(); - - private: - // The name of the file in which the death test is located. - const char* const file_; - // The line number on which the death test is located. - const int line_; - // Handle to the write end of the pipe to the child process. - AutoHandle write_handle_; - // Child process handle. - AutoHandle child_handle_; - // Event the child process uses to signal the parent that it has - // acquired the handle to the write end of the pipe. After seeing this - // event the parent can release its own handles to make sure its - // ReadFile() calls return when the child terminates. - AutoHandle event_handle_; -}; - -// Waits for the child in a death test to exit, returning its exit -// status, or 0 if no child process exists. As a side effect, sets the -// outcome data member. -int WindowsDeathTest::Wait() { - if (!spawned()) - return 0; - - // Wait until the child either signals that it has acquired the write end - // of the pipe or it dies. - const HANDLE wait_handles[2] = { child_handle_.Get(), event_handle_.Get() }; - switch (::WaitForMultipleObjects(2, - wait_handles, - FALSE, // Waits for any of the handles. - INFINITE)) { - case WAIT_OBJECT_0: - case WAIT_OBJECT_0 + 1: - break; - default: - GTEST_DEATH_TEST_CHECK_(false); // Should not get here. - } - - // The child has acquired the write end of the pipe or exited. - // We release the handle on our side and continue. - write_handle_.Reset(); - event_handle_.Reset(); - - ReadAndInterpretStatusByte(); - - // Waits for the child process to exit if it haven't already. This - // returns immediately if the child has already exited, regardless of - // whether previous calls to WaitForMultipleObjects synchronized on this - // handle or not. - GTEST_DEATH_TEST_CHECK_( - WAIT_OBJECT_0 == ::WaitForSingleObject(child_handle_.Get(), - INFINITE)); - DWORD status_code; - GTEST_DEATH_TEST_CHECK_( - ::GetExitCodeProcess(child_handle_.Get(), &status_code) != FALSE); - child_handle_.Reset(); - set_status(static_cast<int>(status_code)); - return status(); -} - -// The AssumeRole process for a Windows death test. It creates a child -// process with the same executable as the current process to run the -// death test. The child process is given the --gtest_filter and -// --gtest_internal_run_death_test flags such that it knows to run the -// current death test only. -DeathTest::TestRole WindowsDeathTest::AssumeRole() { - const UnitTestImpl* const impl = GetUnitTestImpl(); - const InternalRunDeathTestFlag* const flag = - impl->internal_run_death_test_flag(); - const TestInfo* const info = impl->current_test_info(); - const int death_test_index = info->result()->death_test_count(); - - if (flag != nullptr) { - // ParseInternalRunDeathTestFlag() has performed all the necessary - // processing. - set_write_fd(flag->write_fd()); - return EXECUTE_TEST; - } - - // WindowsDeathTest uses an anonymous pipe to communicate results of - // a death test. - SECURITY_ATTRIBUTES handles_are_inheritable = {sizeof(SECURITY_ATTRIBUTES), - nullptr, TRUE}; - HANDLE read_handle, write_handle; - GTEST_DEATH_TEST_CHECK_( - ::CreatePipe(&read_handle, &write_handle, &handles_are_inheritable, - 0) // Default buffer size. - != FALSE); - set_read_fd(::_open_osfhandle(reinterpret_cast<intptr_t>(read_handle), - O_RDONLY)); - write_handle_.Reset(write_handle); - event_handle_.Reset(::CreateEvent( - &handles_are_inheritable, - TRUE, // The event will automatically reset to non-signaled state. - FALSE, // The initial state is non-signalled. - nullptr)); // The even is unnamed. - GTEST_DEATH_TEST_CHECK_(event_handle_.Get() != nullptr); - const std::string filter_flag = std::string("--") + GTEST_FLAG_PREFIX_ + - kFilterFlag + "=" + info->test_suite_name() + - "." + info->name(); - const std::string internal_flag = - std::string("--") + GTEST_FLAG_PREFIX_ + kInternalRunDeathTestFlag + - "=" + file_ + "|" + StreamableToString(line_) + "|" + - StreamableToString(death_test_index) + "|" + - StreamableToString(static_cast<unsigned int>(::GetCurrentProcessId())) + - // size_t has the same width as pointers on both 32-bit and 64-bit - // Windows platforms. - // See http://msdn.microsoft.com/en-us/library/tcxf1dw6.aspx. - "|" + StreamableToString(reinterpret_cast<size_t>(write_handle)) + - "|" + StreamableToString(reinterpret_cast<size_t>(event_handle_.Get())); - - char executable_path[_MAX_PATH + 1]; // NOLINT - GTEST_DEATH_TEST_CHECK_(_MAX_PATH + 1 != ::GetModuleFileNameA(nullptr, - executable_path, - _MAX_PATH)); - - std::string command_line = - std::string(::GetCommandLineA()) + " " + filter_flag + " \"" + - internal_flag + "\""; - - DeathTest::set_last_death_test_message(""); - - CaptureStderr(); - // Flush the log buffers since the log streams are shared with the child. - FlushInfoLog(); - - // The child process will share the standard handles with the parent. - STARTUPINFOA startup_info; - memset(&startup_info, 0, sizeof(STARTUPINFO)); - startup_info.dwFlags = STARTF_USESTDHANDLES; - startup_info.hStdInput = ::GetStdHandle(STD_INPUT_HANDLE); - startup_info.hStdOutput = ::GetStdHandle(STD_OUTPUT_HANDLE); - startup_info.hStdError = ::GetStdHandle(STD_ERROR_HANDLE); - - PROCESS_INFORMATION process_info; - GTEST_DEATH_TEST_CHECK_( - ::CreateProcessA( - executable_path, const_cast<char*>(command_line.c_str()), - nullptr, // Retuned process handle is not inheritable. - nullptr, // Retuned thread handle is not inheritable. - TRUE, // Child inherits all inheritable handles (for write_handle_). - 0x0, // Default creation flags. - nullptr, // Inherit the parent's environment. - UnitTest::GetInstance()->original_working_dir(), &startup_info, - &process_info) != FALSE); - child_handle_.Reset(process_info.hProcess); - ::CloseHandle(process_info.hThread); - set_spawned(true); - return OVERSEE_TEST; -} - -# elif GTEST_OS_FUCHSIA - -class FuchsiaDeathTest : public DeathTestImpl { - public: - FuchsiaDeathTest(const char* a_statement, Matcher<const std::string&> matcher, - const char* file, int line) - : DeathTestImpl(a_statement, std::move(matcher)), - file_(file), - line_(line) {} - - // All of these virtual functions are inherited from DeathTest. - int Wait() override; - TestRole AssumeRole() override; - std::string GetErrorLogs() override; - - private: - // The name of the file in which the death test is located. - const char* const file_; - // The line number on which the death test is located. - const int line_; - // The stderr data captured by the child process. - std::string captured_stderr_; - - zx::process child_process_; - zx::channel exception_channel_; - zx::socket stderr_socket_; -}; - -// Utility class for accumulating command-line arguments. -class Arguments { - public: - Arguments() { args_.push_back(nullptr); } - - ~Arguments() { - for (std::vector<char*>::iterator i = args_.begin(); i != args_.end(); - ++i) { - free(*i); - } - } - void AddArgument(const char* argument) { - args_.insert(args_.end() - 1, posix::StrDup(argument)); - } - - template <typename Str> - void AddArguments(const ::std::vector<Str>& arguments) { - for (typename ::std::vector<Str>::const_iterator i = arguments.begin(); - i != arguments.end(); - ++i) { - args_.insert(args_.end() - 1, posix::StrDup(i->c_str())); - } - } - char* const* Argv() { - return &args_[0]; - } - - int size() { - return static_cast<int>(args_.size()) - 1; - } - - private: - std::vector<char*> args_; -}; - -// Waits for the child in a death test to exit, returning its exit -// status, or 0 if no child process exists. As a side effect, sets the -// outcome data member. -int FuchsiaDeathTest::Wait() { - const int kProcessKey = 0; - const int kSocketKey = 1; - const int kExceptionKey = 2; - - if (!spawned()) - return 0; - - // Create a port to wait for socket/task/exception events. - zx_status_t status_zx; - zx::port port; - status_zx = zx::port::create(0, &port); - GTEST_DEATH_TEST_CHECK_(status_zx == ZX_OK); - - // Register to wait for the child process to terminate. - status_zx = child_process_.wait_async( - port, kProcessKey, ZX_PROCESS_TERMINATED, 0); - GTEST_DEATH_TEST_CHECK_(status_zx == ZX_OK); - - // Register to wait for the socket to be readable or closed. - status_zx = stderr_socket_.wait_async( - port, kSocketKey, ZX_SOCKET_READABLE | ZX_SOCKET_PEER_CLOSED, 0); - GTEST_DEATH_TEST_CHECK_(status_zx == ZX_OK); - - // Register to wait for an exception. - status_zx = exception_channel_.wait_async( - port, kExceptionKey, ZX_CHANNEL_READABLE, 0); - GTEST_DEATH_TEST_CHECK_(status_zx == ZX_OK); - - bool process_terminated = false; - bool socket_closed = false; - do { - zx_port_packet_t packet = {}; - status_zx = port.wait(zx::time::infinite(), &packet); - GTEST_DEATH_TEST_CHECK_(status_zx == ZX_OK); - - if (packet.key == kExceptionKey) { - // Process encountered an exception. Kill it directly rather than - // letting other handlers process the event. We will get a kProcessKey - // event when the process actually terminates. - status_zx = child_process_.kill(); - GTEST_DEATH_TEST_CHECK_(status_zx == ZX_OK); - } else if (packet.key == kProcessKey) { - // Process terminated. - GTEST_DEATH_TEST_CHECK_(ZX_PKT_IS_SIGNAL_ONE(packet.type)); - GTEST_DEATH_TEST_CHECK_(packet.signal.observed & ZX_PROCESS_TERMINATED); - process_terminated = true; - } else if (packet.key == kSocketKey) { - GTEST_DEATH_TEST_CHECK_(ZX_PKT_IS_SIGNAL_ONE(packet.type)); - if (packet.signal.observed & ZX_SOCKET_READABLE) { - // Read data from the socket. - constexpr size_t kBufferSize = 1024; - do { - size_t old_length = captured_stderr_.length(); - size_t bytes_read = 0; - captured_stderr_.resize(old_length + kBufferSize); - status_zx = stderr_socket_.read( - 0, &captured_stderr_.front() + old_length, kBufferSize, - &bytes_read); - captured_stderr_.resize(old_length + bytes_read); - } while (status_zx == ZX_OK); - if (status_zx == ZX_ERR_PEER_CLOSED) { - socket_closed = true; - } else { - GTEST_DEATH_TEST_CHECK_(status_zx == ZX_ERR_SHOULD_WAIT); - status_zx = stderr_socket_.wait_async( - port, kSocketKey, ZX_SOCKET_READABLE | ZX_SOCKET_PEER_CLOSED, 0); - GTEST_DEATH_TEST_CHECK_(status_zx == ZX_OK); - } - } else { - GTEST_DEATH_TEST_CHECK_(packet.signal.observed & ZX_SOCKET_PEER_CLOSED); - socket_closed = true; - } - } - } while (!process_terminated && !socket_closed); - - ReadAndInterpretStatusByte(); - - zx_info_process_v2_t buffer; - status_zx = child_process_.get_info( - ZX_INFO_PROCESS_V2, &buffer, sizeof(buffer), nullptr, nullptr); - GTEST_DEATH_TEST_CHECK_(status_zx == ZX_OK); - - GTEST_DEATH_TEST_CHECK_(buffer.flags & ZX_INFO_PROCESS_FLAG_EXITED); - set_status(static_cast<int>(buffer.return_code)); - return status(); -} - -// The AssumeRole process for a Fuchsia death test. It creates a child -// process with the same executable as the current process to run the -// death test. The child process is given the --gtest_filter and -// --gtest_internal_run_death_test flags such that it knows to run the -// current death test only. -DeathTest::TestRole FuchsiaDeathTest::AssumeRole() { - const UnitTestImpl* const impl = GetUnitTestImpl(); - const InternalRunDeathTestFlag* const flag = - impl->internal_run_death_test_flag(); - const TestInfo* const info = impl->current_test_info(); - const int death_test_index = info->result()->death_test_count(); - - if (flag != nullptr) { - // ParseInternalRunDeathTestFlag() has performed all the necessary - // processing. - set_write_fd(kFuchsiaReadPipeFd); - return EXECUTE_TEST; - } - - // Flush the log buffers since the log streams are shared with the child. - FlushInfoLog(); - - // Build the child process command line. - const std::string filter_flag = std::string("--") + GTEST_FLAG_PREFIX_ + - kFilterFlag + "=" + info->test_suite_name() + - "." + info->name(); - const std::string internal_flag = - std::string("--") + GTEST_FLAG_PREFIX_ + kInternalRunDeathTestFlag + "=" - + file_ + "|" - + StreamableToString(line_) + "|" - + StreamableToString(death_test_index); - Arguments args; - args.AddArguments(GetInjectableArgvs()); - args.AddArgument(filter_flag.c_str()); - args.AddArgument(internal_flag.c_str()); - - // Build the pipe for communication with the child. - zx_status_t status; - zx_handle_t child_pipe_handle; - int child_pipe_fd; - status = fdio_pipe_half(&child_pipe_fd, &child_pipe_handle); - GTEST_DEATH_TEST_CHECK_(status == ZX_OK); - set_read_fd(child_pipe_fd); - - // Set the pipe handle for the child. - fdio_spawn_action_t spawn_actions[2] = {}; - fdio_spawn_action_t* add_handle_action = &spawn_actions[0]; - add_handle_action->action = FDIO_SPAWN_ACTION_ADD_HANDLE; - add_handle_action->h.id = PA_HND(PA_FD, kFuchsiaReadPipeFd); - add_handle_action->h.handle = child_pipe_handle; - - // Create a socket pair will be used to receive the child process' stderr. - zx::socket stderr_producer_socket; - status = - zx::socket::create(0, &stderr_producer_socket, &stderr_socket_); - GTEST_DEATH_TEST_CHECK_(status >= 0); - int stderr_producer_fd = -1; - status = - fdio_fd_create(stderr_producer_socket.release(), &stderr_producer_fd); - GTEST_DEATH_TEST_CHECK_(status >= 0); - - // Make the stderr socket nonblocking. - GTEST_DEATH_TEST_CHECK_(fcntl(stderr_producer_fd, F_SETFL, 0) == 0); - - fdio_spawn_action_t* add_stderr_action = &spawn_actions[1]; - add_stderr_action->action = FDIO_SPAWN_ACTION_CLONE_FD; - add_stderr_action->fd.local_fd = stderr_producer_fd; - add_stderr_action->fd.target_fd = STDERR_FILENO; - - // Create a child job. - zx_handle_t child_job = ZX_HANDLE_INVALID; - status = zx_job_create(zx_job_default(), 0, & child_job); - GTEST_DEATH_TEST_CHECK_(status == ZX_OK); - zx_policy_basic_t policy; - policy.condition = ZX_POL_NEW_ANY; - policy.policy = ZX_POL_ACTION_ALLOW; - status = zx_job_set_policy( - child_job, ZX_JOB_POL_RELATIVE, ZX_JOB_POL_BASIC, &policy, 1); - GTEST_DEATH_TEST_CHECK_(status == ZX_OK); - - // Create an exception channel attached to the |child_job|, to allow - // us to suppress the system default exception handler from firing. - status = - zx_task_create_exception_channel( - child_job, 0, exception_channel_.reset_and_get_address()); - GTEST_DEATH_TEST_CHECK_(status == ZX_OK); - - // Spawn the child process. - status = fdio_spawn_etc( - child_job, FDIO_SPAWN_CLONE_ALL, args.Argv()[0], args.Argv(), nullptr, - 2, spawn_actions, child_process_.reset_and_get_address(), nullptr); - GTEST_DEATH_TEST_CHECK_(status == ZX_OK); - - set_spawned(true); - return OVERSEE_TEST; -} - -std::string FuchsiaDeathTest::GetErrorLogs() { - return captured_stderr_; -} - -#else // We are neither on Windows, nor on Fuchsia. - -// ForkingDeathTest provides implementations for most of the abstract -// methods of the DeathTest interface. Only the AssumeRole method is -// left undefined. -class ForkingDeathTest : public DeathTestImpl { - public: - ForkingDeathTest(const char* statement, Matcher<const std::string&> matcher); - - // All of these virtual functions are inherited from DeathTest. - int Wait() override; - - protected: - void set_child_pid(pid_t child_pid) { child_pid_ = child_pid; } - - private: - // PID of child process during death test; 0 in the child process itself. - pid_t child_pid_; -}; - -// Constructs a ForkingDeathTest. -ForkingDeathTest::ForkingDeathTest(const char* a_statement, - Matcher<const std::string&> matcher) - : DeathTestImpl(a_statement, std::move(matcher)), child_pid_(-1) {} - -// Waits for the child in a death test to exit, returning its exit -// status, or 0 if no child process exists. As a side effect, sets the -// outcome data member. -int ForkingDeathTest::Wait() { - if (!spawned()) - return 0; - - ReadAndInterpretStatusByte(); - - int status_value; - GTEST_DEATH_TEST_CHECK_SYSCALL_(waitpid(child_pid_, &status_value, 0)); - set_status(status_value); - return status_value; -} - -// A concrete death test class that forks, then immediately runs the test -// in the child process. -class NoExecDeathTest : public ForkingDeathTest { - public: - NoExecDeathTest(const char* a_statement, Matcher<const std::string&> matcher) - : ForkingDeathTest(a_statement, std::move(matcher)) {} - TestRole AssumeRole() override; -}; - -// The AssumeRole process for a fork-and-run death test. It implements a -// straightforward fork, with a simple pipe to transmit the status byte. -DeathTest::TestRole NoExecDeathTest::AssumeRole() { - const size_t thread_count = GetThreadCount(); - if (thread_count != 1) { - GTEST_LOG_(WARNING) << DeathTestThreadWarning(thread_count); - } - - int pipe_fd[2]; - GTEST_DEATH_TEST_CHECK_(pipe(pipe_fd) != -1); - - DeathTest::set_last_death_test_message(""); - CaptureStderr(); - // When we fork the process below, the log file buffers are copied, but the - // file descriptors are shared. We flush all log files here so that closing - // the file descriptors in the child process doesn't throw off the - // synchronization between descriptors and buffers in the parent process. - // This is as close to the fork as possible to avoid a race condition in case - // there are multiple threads running before the death test, and another - // thread writes to the log file. - FlushInfoLog(); - - const pid_t child_pid = fork(); - GTEST_DEATH_TEST_CHECK_(child_pid != -1); - set_child_pid(child_pid); - if (child_pid == 0) { - GTEST_DEATH_TEST_CHECK_SYSCALL_(close(pipe_fd[0])); - set_write_fd(pipe_fd[1]); - // Redirects all logging to stderr in the child process to prevent - // concurrent writes to the log files. We capture stderr in the parent - // process and append the child process' output to a log. - LogToStderr(); - // Event forwarding to the listeners of event listener API mush be shut - // down in death test subprocesses. - GetUnitTestImpl()->listeners()->SuppressEventForwarding(); - g_in_fast_death_test_child = true; - return EXECUTE_TEST; - } else { - GTEST_DEATH_TEST_CHECK_SYSCALL_(close(pipe_fd[1])); - set_read_fd(pipe_fd[0]); - set_spawned(true); - return OVERSEE_TEST; - } -} - -// A concrete death test class that forks and re-executes the main -// program from the beginning, with command-line flags set that cause -// only this specific death test to be run. -class ExecDeathTest : public ForkingDeathTest { - public: - ExecDeathTest(const char* a_statement, Matcher<const std::string&> matcher, - const char* file, int line) - : ForkingDeathTest(a_statement, std::move(matcher)), - file_(file), - line_(line) {} - TestRole AssumeRole() override; - - private: - static ::std::vector<std::string> GetArgvsForDeathTestChildProcess() { - ::std::vector<std::string> args = GetInjectableArgvs(); -# if defined(GTEST_EXTRA_DEATH_TEST_COMMAND_LINE_ARGS_) - ::std::vector<std::string> extra_args = - GTEST_EXTRA_DEATH_TEST_COMMAND_LINE_ARGS_(); - args.insert(args.end(), extra_args.begin(), extra_args.end()); -# endif // defined(GTEST_EXTRA_DEATH_TEST_COMMAND_LINE_ARGS_) - return args; - } - // The name of the file in which the death test is located. - const char* const file_; - // The line number on which the death test is located. - const int line_; -}; - -// Utility class for accumulating command-line arguments. -class Arguments { - public: - Arguments() { args_.push_back(nullptr); } - - ~Arguments() { - for (std::vector<char*>::iterator i = args_.begin(); i != args_.end(); - ++i) { - free(*i); - } - } - void AddArgument(const char* argument) { - args_.insert(args_.end() - 1, posix::StrDup(argument)); - } - - template <typename Str> - void AddArguments(const ::std::vector<Str>& arguments) { - for (typename ::std::vector<Str>::const_iterator i = arguments.begin(); - i != arguments.end(); - ++i) { - args_.insert(args_.end() - 1, posix::StrDup(i->c_str())); - } - } - char* const* Argv() { - return &args_[0]; - } - - private: - std::vector<char*> args_; -}; - -// A struct that encompasses the arguments to the child process of a -// threadsafe-style death test process. -struct ExecDeathTestArgs { - char* const* argv; // Command-line arguments for the child's call to exec - int close_fd; // File descriptor to close; the read end of a pipe -}; - -# if GTEST_OS_QNX -extern "C" char** environ; -# else // GTEST_OS_QNX -// The main function for a threadsafe-style death test child process. -// This function is called in a clone()-ed process and thus must avoid -// any potentially unsafe operations like malloc or libc functions. -static int ExecDeathTestChildMain(void* child_arg) { - ExecDeathTestArgs* const args = static_cast<ExecDeathTestArgs*>(child_arg); - GTEST_DEATH_TEST_CHECK_SYSCALL_(close(args->close_fd)); - - // We need to execute the test program in the same environment where - // it was originally invoked. Therefore we change to the original - // working directory first. - const char* const original_dir = - UnitTest::GetInstance()->original_working_dir(); - // We can safely call chdir() as it's a direct system call. - if (chdir(original_dir) != 0) { - DeathTestAbort(std::string("chdir(\"") + original_dir + "\") failed: " + - GetLastErrnoDescription()); - return EXIT_FAILURE; - } - - // We can safely call execv() as it's almost a direct system call. We - // cannot use execvp() as it's a libc function and thus potentially - // unsafe. Since execv() doesn't search the PATH, the user must - // invoke the test program via a valid path that contains at least - // one path separator. - execv(args->argv[0], args->argv); - DeathTestAbort(std::string("execv(") + args->argv[0] + ", ...) in " + - original_dir + " failed: " + - GetLastErrnoDescription()); - return EXIT_FAILURE; -} -# endif // GTEST_OS_QNX - -# if GTEST_HAS_CLONE -// Two utility routines that together determine the direction the stack -// grows. -// This could be accomplished more elegantly by a single recursive -// function, but we want to guard against the unlikely possibility of -// a smart compiler optimizing the recursion away. -// -// GTEST_NO_INLINE_ is required to prevent GCC 4.6 from inlining -// StackLowerThanAddress into StackGrowsDown, which then doesn't give -// correct answer. -static void StackLowerThanAddress(const void* ptr, - bool* result) GTEST_NO_INLINE_; -// Make sure sanitizers do not tamper with the stack here. -// Ideally, we want to use `__builtin_frame_address` instead of a local variable -// address with sanitizer disabled, but it does not work when the -// compiler optimizes the stack frame out, which happens on PowerPC targets. -// HWAddressSanitizer add a random tag to the MSB of the local variable address, -// making comparison result unpredictable. -GTEST_ATTRIBUTE_NO_SANITIZE_ADDRESS_ -GTEST_ATTRIBUTE_NO_SANITIZE_HWADDRESS_ -static void StackLowerThanAddress(const void* ptr, bool* result) { - int dummy = 0; - *result = std::less<const void*>()(&dummy, ptr); -} - -// Make sure AddressSanitizer does not tamper with the stack here. -GTEST_ATTRIBUTE_NO_SANITIZE_ADDRESS_ -GTEST_ATTRIBUTE_NO_SANITIZE_HWADDRESS_ -static bool StackGrowsDown() { - int dummy = 0; - bool result; - StackLowerThanAddress(&dummy, &result); - return result; -} -# endif // GTEST_HAS_CLONE - -// Spawns a child process with the same executable as the current process in -// a thread-safe manner and instructs it to run the death test. The -// implementation uses fork(2) + exec. On systems where clone(2) is -// available, it is used instead, being slightly more thread-safe. On QNX, -// fork supports only single-threaded environments, so this function uses -// spawn(2) there instead. The function dies with an error message if -// anything goes wrong. -static pid_t ExecDeathTestSpawnChild(char* const* argv, int close_fd) { - ExecDeathTestArgs args = { argv, close_fd }; - pid_t child_pid = -1; - -# if GTEST_OS_QNX - // Obtains the current directory and sets it to be closed in the child - // process. - const int cwd_fd = open(".", O_RDONLY); - GTEST_DEATH_TEST_CHECK_(cwd_fd != -1); - GTEST_DEATH_TEST_CHECK_SYSCALL_(fcntl(cwd_fd, F_SETFD, FD_CLOEXEC)); - // We need to execute the test program in the same environment where - // it was originally invoked. Therefore we change to the original - // working directory first. - const char* const original_dir = - UnitTest::GetInstance()->original_working_dir(); - // We can safely call chdir() as it's a direct system call. - if (chdir(original_dir) != 0) { - DeathTestAbort(std::string("chdir(\"") + original_dir + "\") failed: " + - GetLastErrnoDescription()); - return EXIT_FAILURE; - } - - int fd_flags; - // Set close_fd to be closed after spawn. - GTEST_DEATH_TEST_CHECK_SYSCALL_(fd_flags = fcntl(close_fd, F_GETFD)); - GTEST_DEATH_TEST_CHECK_SYSCALL_(fcntl(close_fd, F_SETFD, - fd_flags | FD_CLOEXEC)); - struct inheritance inherit = {0}; - // spawn is a system call. - child_pid = spawn(args.argv[0], 0, nullptr, &inherit, args.argv, environ); - // Restores the current working directory. - GTEST_DEATH_TEST_CHECK_(fchdir(cwd_fd) != -1); - GTEST_DEATH_TEST_CHECK_SYSCALL_(close(cwd_fd)); - -# else // GTEST_OS_QNX -# if GTEST_OS_LINUX - // When a SIGPROF signal is received while fork() or clone() are executing, - // the process may hang. To avoid this, we ignore SIGPROF here and re-enable - // it after the call to fork()/clone() is complete. - struct sigaction saved_sigprof_action; - struct sigaction ignore_sigprof_action; - memset(&ignore_sigprof_action, 0, sizeof(ignore_sigprof_action)); - sigemptyset(&ignore_sigprof_action.sa_mask); - ignore_sigprof_action.sa_handler = SIG_IGN; - GTEST_DEATH_TEST_CHECK_SYSCALL_(sigaction( - SIGPROF, &ignore_sigprof_action, &saved_sigprof_action)); -# endif // GTEST_OS_LINUX - -# if GTEST_HAS_CLONE - const bool use_fork = GTEST_FLAG(death_test_use_fork); - - if (!use_fork) { - static const bool stack_grows_down = StackGrowsDown(); - const auto stack_size = static_cast<size_t>(getpagesize() * 2); - // MMAP_ANONYMOUS is not defined on Mac, so we use MAP_ANON instead. - void* const stack = mmap(nullptr, stack_size, PROT_READ | PROT_WRITE, - MAP_ANON | MAP_PRIVATE, -1, 0); - GTEST_DEATH_TEST_CHECK_(stack != MAP_FAILED); - - // Maximum stack alignment in bytes: For a downward-growing stack, this - // amount is subtracted from size of the stack space to get an address - // that is within the stack space and is aligned on all systems we care - // about. As far as I know there is no ABI with stack alignment greater - // than 64. We assume stack and stack_size already have alignment of - // kMaxStackAlignment. - const size_t kMaxStackAlignment = 64; - void* const stack_top = - static_cast<char*>(stack) + - (stack_grows_down ? stack_size - kMaxStackAlignment : 0); - GTEST_DEATH_TEST_CHECK_( - static_cast<size_t>(stack_size) > kMaxStackAlignment && - reinterpret_cast<uintptr_t>(stack_top) % kMaxStackAlignment == 0); - - child_pid = clone(&ExecDeathTestChildMain, stack_top, SIGCHLD, &args); - - GTEST_DEATH_TEST_CHECK_(munmap(stack, stack_size) != -1); - } -# else - const bool use_fork = true; -# endif // GTEST_HAS_CLONE - - if (use_fork && (child_pid = fork()) == 0) { - ExecDeathTestChildMain(&args); - _exit(0); - } -# endif // GTEST_OS_QNX -# if GTEST_OS_LINUX - GTEST_DEATH_TEST_CHECK_SYSCALL_( - sigaction(SIGPROF, &saved_sigprof_action, nullptr)); -# endif // GTEST_OS_LINUX - - GTEST_DEATH_TEST_CHECK_(child_pid != -1); - return child_pid; -} - -// The AssumeRole process for a fork-and-exec death test. It re-executes the -// main program from the beginning, setting the --gtest_filter -// and --gtest_internal_run_death_test flags to cause only the current -// death test to be re-run. -DeathTest::TestRole ExecDeathTest::AssumeRole() { - const UnitTestImpl* const impl = GetUnitTestImpl(); - const InternalRunDeathTestFlag* const flag = - impl->internal_run_death_test_flag(); - const TestInfo* const info = impl->current_test_info(); - const int death_test_index = info->result()->death_test_count(); - - if (flag != nullptr) { - set_write_fd(flag->write_fd()); - return EXECUTE_TEST; - } - - int pipe_fd[2]; - GTEST_DEATH_TEST_CHECK_(pipe(pipe_fd) != -1); - // Clear the close-on-exec flag on the write end of the pipe, lest - // it be closed when the child process does an exec: - GTEST_DEATH_TEST_CHECK_(fcntl(pipe_fd[1], F_SETFD, 0) != -1); - - const std::string filter_flag = std::string("--") + GTEST_FLAG_PREFIX_ + - kFilterFlag + "=" + info->test_suite_name() + - "." + info->name(); - const std::string internal_flag = - std::string("--") + GTEST_FLAG_PREFIX_ + kInternalRunDeathTestFlag + "=" - + file_ + "|" + StreamableToString(line_) + "|" - + StreamableToString(death_test_index) + "|" - + StreamableToString(pipe_fd[1]); - Arguments args; - args.AddArguments(GetArgvsForDeathTestChildProcess()); - args.AddArgument(filter_flag.c_str()); - args.AddArgument(internal_flag.c_str()); - - DeathTest::set_last_death_test_message(""); - - CaptureStderr(); - // See the comment in NoExecDeathTest::AssumeRole for why the next line - // is necessary. - FlushInfoLog(); - - const pid_t child_pid = ExecDeathTestSpawnChild(args.Argv(), pipe_fd[0]); - GTEST_DEATH_TEST_CHECK_SYSCALL_(close(pipe_fd[1])); - set_child_pid(child_pid); - set_read_fd(pipe_fd[0]); - set_spawned(true); - return OVERSEE_TEST; -} - -# endif // !GTEST_OS_WINDOWS - -// Creates a concrete DeathTest-derived class that depends on the -// --gtest_death_test_style flag, and sets the pointer pointed to -// by the "test" argument to its address. If the test should be -// skipped, sets that pointer to NULL. Returns true, unless the -// flag is set to an invalid value. -bool DefaultDeathTestFactory::Create(const char* statement, - Matcher<const std::string&> matcher, - const char* file, int line, - DeathTest** test) { - UnitTestImpl* const impl = GetUnitTestImpl(); - const InternalRunDeathTestFlag* const flag = - impl->internal_run_death_test_flag(); - const int death_test_index = impl->current_test_info() - ->increment_death_test_count(); - - if (flag != nullptr) { - if (death_test_index > flag->index()) { - DeathTest::set_last_death_test_message( - "Death test count (" + StreamableToString(death_test_index) - + ") somehow exceeded expected maximum (" - + StreamableToString(flag->index()) + ")"); - return false; - } - - if (!(flag->file() == file && flag->line() == line && - flag->index() == death_test_index)) { - *test = nullptr; - return true; - } - } - -# if GTEST_OS_WINDOWS - - if (GTEST_FLAG(death_test_style) == "threadsafe" || - GTEST_FLAG(death_test_style) == "fast") { - *test = new WindowsDeathTest(statement, std::move(matcher), file, line); - } - -# elif GTEST_OS_FUCHSIA - - if (GTEST_FLAG(death_test_style) == "threadsafe" || - GTEST_FLAG(death_test_style) == "fast") { - *test = new FuchsiaDeathTest(statement, std::move(matcher), file, line); - } - -# else - - if (GTEST_FLAG(death_test_style) == "threadsafe") { - *test = new ExecDeathTest(statement, std::move(matcher), file, line); - } else if (GTEST_FLAG(death_test_style) == "fast") { - *test = new NoExecDeathTest(statement, std::move(matcher)); - } - -# endif // GTEST_OS_WINDOWS - - else { // NOLINT - this is more readable than unbalanced brackets inside #if. - DeathTest::set_last_death_test_message( - "Unknown death test style \"" + GTEST_FLAG(death_test_style) - + "\" encountered"); - return false; - } - - return true; -} - -# if GTEST_OS_WINDOWS -// Recreates the pipe and event handles from the provided parameters, -// signals the event, and returns a file descriptor wrapped around the pipe -// handle. This function is called in the child process only. -static int GetStatusFileDescriptor(unsigned int parent_process_id, - size_t write_handle_as_size_t, - size_t event_handle_as_size_t) { - AutoHandle parent_process_handle(::OpenProcess(PROCESS_DUP_HANDLE, - FALSE, // Non-inheritable. - parent_process_id)); - if (parent_process_handle.Get() == INVALID_HANDLE_VALUE) { - DeathTestAbort("Unable to open parent process " + - StreamableToString(parent_process_id)); - } - - GTEST_CHECK_(sizeof(HANDLE) <= sizeof(size_t)); - - const HANDLE write_handle = - reinterpret_cast<HANDLE>(write_handle_as_size_t); - HANDLE dup_write_handle; - - // The newly initialized handle is accessible only in the parent - // process. To obtain one accessible within the child, we need to use - // DuplicateHandle. - if (!::DuplicateHandle(parent_process_handle.Get(), write_handle, - ::GetCurrentProcess(), &dup_write_handle, - 0x0, // Requested privileges ignored since - // DUPLICATE_SAME_ACCESS is used. - FALSE, // Request non-inheritable handler. - DUPLICATE_SAME_ACCESS)) { - DeathTestAbort("Unable to duplicate the pipe handle " + - StreamableToString(write_handle_as_size_t) + - " from the parent process " + - StreamableToString(parent_process_id)); - } - - const HANDLE event_handle = reinterpret_cast<HANDLE>(event_handle_as_size_t); - HANDLE dup_event_handle; - - if (!::DuplicateHandle(parent_process_handle.Get(), event_handle, - ::GetCurrentProcess(), &dup_event_handle, - 0x0, - FALSE, - DUPLICATE_SAME_ACCESS)) { - DeathTestAbort("Unable to duplicate the event handle " + - StreamableToString(event_handle_as_size_t) + - " from the parent process " + - StreamableToString(parent_process_id)); - } - - const int write_fd = - ::_open_osfhandle(reinterpret_cast<intptr_t>(dup_write_handle), O_APPEND); - if (write_fd == -1) { - DeathTestAbort("Unable to convert pipe handle " + - StreamableToString(write_handle_as_size_t) + - " to a file descriptor"); - } - - // Signals the parent that the write end of the pipe has been acquired - // so the parent can release its own write end. - ::SetEvent(dup_event_handle); - - return write_fd; -} -# endif // GTEST_OS_WINDOWS - -// Returns a newly created InternalRunDeathTestFlag object with fields -// initialized from the GTEST_FLAG(internal_run_death_test) flag if -// the flag is specified; otherwise returns NULL. -InternalRunDeathTestFlag* ParseInternalRunDeathTestFlag() { - if (GTEST_FLAG(internal_run_death_test) == "") return nullptr; - - // GTEST_HAS_DEATH_TEST implies that we have ::std::string, so we - // can use it here. - int line = -1; - int index = -1; - ::std::vector< ::std::string> fields; - SplitString(GTEST_FLAG(internal_run_death_test).c_str(), '|', &fields); - int write_fd = -1; - -# if GTEST_OS_WINDOWS - - unsigned int parent_process_id = 0; - size_t write_handle_as_size_t = 0; - size_t event_handle_as_size_t = 0; - - if (fields.size() != 6 - || !ParseNaturalNumber(fields[1], &line) - || !ParseNaturalNumber(fields[2], &index) - || !ParseNaturalNumber(fields[3], &parent_process_id) - || !ParseNaturalNumber(fields[4], &write_handle_as_size_t) - || !ParseNaturalNumber(fields[5], &event_handle_as_size_t)) { - DeathTestAbort("Bad --gtest_internal_run_death_test flag: " + - GTEST_FLAG(internal_run_death_test)); - } - write_fd = GetStatusFileDescriptor(parent_process_id, - write_handle_as_size_t, - event_handle_as_size_t); - -# elif GTEST_OS_FUCHSIA - - if (fields.size() != 3 - || !ParseNaturalNumber(fields[1], &line) - || !ParseNaturalNumber(fields[2], &index)) { - DeathTestAbort("Bad --gtest_internal_run_death_test flag: " - + GTEST_FLAG(internal_run_death_test)); - } - -# else - - if (fields.size() != 4 - || !ParseNaturalNumber(fields[1], &line) - || !ParseNaturalNumber(fields[2], &index) - || !ParseNaturalNumber(fields[3], &write_fd)) { - DeathTestAbort("Bad --gtest_internal_run_death_test flag: " - + GTEST_FLAG(internal_run_death_test)); - } - -# endif // GTEST_OS_WINDOWS - - return new InternalRunDeathTestFlag(fields[0], line, index, write_fd); -} - -} // namespace internal - -#endif // GTEST_HAS_DEATH_TEST - -} // namespace testing -// Copyright 2008, 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. - - -#include <stdlib.h> - -#if GTEST_OS_WINDOWS_MOBILE -# include <windows.h> -#elif GTEST_OS_WINDOWS -# include <direct.h> -# include <io.h> -#else -# include <limits.h> -# include <climits> // Some Linux distributions define PATH_MAX here. -#endif // GTEST_OS_WINDOWS_MOBILE - - -#if GTEST_OS_WINDOWS -# define GTEST_PATH_MAX_ _MAX_PATH -#elif defined(PATH_MAX) -# define GTEST_PATH_MAX_ PATH_MAX -#elif defined(_XOPEN_PATH_MAX) -# define GTEST_PATH_MAX_ _XOPEN_PATH_MAX -#else -# define GTEST_PATH_MAX_ _POSIX_PATH_MAX -#endif // GTEST_OS_WINDOWS - -namespace testing { -namespace internal { - -#if GTEST_OS_WINDOWS -// On Windows, '\\' is the standard path separator, but many tools and the -// Windows API also accept '/' as an alternate path separator. Unless otherwise -// noted, a file path can contain either kind of path separators, or a mixture -// of them. -const char kPathSeparator = '\\'; -const char kAlternatePathSeparator = '/'; -const char kAlternatePathSeparatorString[] = "/"; -# if GTEST_OS_WINDOWS_MOBILE -// Windows CE doesn't have a current directory. You should not use -// the current directory in tests on Windows CE, but this at least -// provides a reasonable fallback. -const char kCurrentDirectoryString[] = "\\"; -// Windows CE doesn't define INVALID_FILE_ATTRIBUTES -const DWORD kInvalidFileAttributes = 0xffffffff; -# else -const char kCurrentDirectoryString[] = ".\\"; -# endif // GTEST_OS_WINDOWS_MOBILE -#else -const char kPathSeparator = '/'; -const char kCurrentDirectoryString[] = "./"; -#endif // GTEST_OS_WINDOWS - -// Returns whether the given character is a valid path separator. -static bool IsPathSeparator(char c) { -#if GTEST_HAS_ALT_PATH_SEP_ - return (c == kPathSeparator) || (c == kAlternatePathSeparator); -#else - return c == kPathSeparator; -#endif -} - -// Returns the current working directory, or "" if unsuccessful. -FilePath FilePath::GetCurrentDir() { -#if GTEST_OS_WINDOWS_MOBILE || GTEST_OS_WINDOWS_PHONE || \ - GTEST_OS_WINDOWS_RT || GTEST_OS_ESP8266 || GTEST_OS_ESP32 || \ - GTEST_OS_XTENSA - // These platforms do not have a current directory, so we just return - // something reasonable. - return FilePath(kCurrentDirectoryString); -#elif GTEST_OS_WINDOWS - char cwd[GTEST_PATH_MAX_ + 1] = { '\0' }; - return FilePath(_getcwd(cwd, sizeof(cwd)) == nullptr ? "" : cwd); -#else - char cwd[GTEST_PATH_MAX_ + 1] = { '\0' }; - char* result = getcwd(cwd, sizeof(cwd)); -# if GTEST_OS_NACL - // getcwd will likely fail in NaCl due to the sandbox, so return something - // reasonable. The user may have provided a shim implementation for getcwd, - // however, so fallback only when failure is detected. - return FilePath(result == nullptr ? kCurrentDirectoryString : cwd); -# endif // GTEST_OS_NACL - return FilePath(result == nullptr ? "" : cwd); -#endif // GTEST_OS_WINDOWS_MOBILE -} - -// Returns a copy of the FilePath with the case-insensitive extension removed. -// Example: FilePath("dir/file.exe").RemoveExtension("EXE") returns -// FilePath("dir/file"). If a case-insensitive extension is not -// found, returns a copy of the original FilePath. -FilePath FilePath::RemoveExtension(const char* extension) const { - const std::string dot_extension = std::string(".") + extension; - if (String::EndsWithCaseInsensitive(pathname_, dot_extension)) { - return FilePath(pathname_.substr( - 0, pathname_.length() - dot_extension.length())); - } - return *this; -} - -// Returns a pointer to the last occurrence of a valid path separator in -// the FilePath. On Windows, for example, both '/' and '\' are valid path -// separators. Returns NULL if no path separator was found. -const char* FilePath::FindLastPathSeparator() const { - const char* const last_sep = strrchr(c_str(), kPathSeparator); -#if GTEST_HAS_ALT_PATH_SEP_ - const char* const last_alt_sep = strrchr(c_str(), kAlternatePathSeparator); - // Comparing two pointers of which only one is NULL is undefined. - if (last_alt_sep != nullptr && - (last_sep == nullptr || last_alt_sep > last_sep)) { - return last_alt_sep; - } -#endif - return last_sep; -} - -// Returns a copy of the FilePath with the directory part removed. -// Example: FilePath("path/to/file").RemoveDirectoryName() returns -// FilePath("file"). If there is no directory part ("just_a_file"), it returns -// the FilePath unmodified. If there is no file part ("just_a_dir/") it -// returns an empty FilePath (""). -// On Windows platform, '\' is the path separator, otherwise it is '/'. -FilePath FilePath::RemoveDirectoryName() const { - const char* const last_sep = FindLastPathSeparator(); - return last_sep ? FilePath(last_sep + 1) : *this; -} - -// RemoveFileName returns the directory path with the filename removed. -// Example: FilePath("path/to/file").RemoveFileName() returns "path/to/". -// If the FilePath is "a_file" or "/a_file", RemoveFileName returns -// FilePath("./") or, on Windows, FilePath(".\\"). If the filepath does -// not have a file, like "just/a/dir/", it returns the FilePath unmodified. -// On Windows platform, '\' is the path separator, otherwise it is '/'. -FilePath FilePath::RemoveFileName() const { - const char* const last_sep = FindLastPathSeparator(); - std::string dir; - if (last_sep) { - dir = std::string(c_str(), static_cast<size_t>(last_sep + 1 - c_str())); - } else { - dir = kCurrentDirectoryString; - } - return FilePath(dir); -} - -// Helper functions for naming files in a directory for xml output. - -// Given directory = "dir", base_name = "test", number = 0, -// extension = "xml", returns "dir/test.xml". If number is greater -// than zero (e.g., 12), returns "dir/test_12.xml". -// On Windows platform, uses \ as the separator rather than /. -FilePath FilePath::MakeFileName(const FilePath& directory, - const FilePath& base_name, - int number, - const char* extension) { - std::string file; - if (number == 0) { - file = base_name.string() + "." + extension; - } else { - file = base_name.string() + "_" + StreamableToString(number) - + "." + extension; - } - return ConcatPaths(directory, FilePath(file)); -} - -// Given directory = "dir", relative_path = "test.xml", returns "dir/test.xml". -// On Windows, uses \ as the separator rather than /. -FilePath FilePath::ConcatPaths(const FilePath& directory, - const FilePath& relative_path) { - if (directory.IsEmpty()) - return relative_path; - const FilePath dir(directory.RemoveTrailingPathSeparator()); - return FilePath(dir.string() + kPathSeparator + relative_path.string()); -} - -// Returns true if pathname describes something findable in the file-system, -// either a file, directory, or whatever. -bool FilePath::FileOrDirectoryExists() const { -#if GTEST_OS_WINDOWS_MOBILE - LPCWSTR unicode = String::AnsiToUtf16(pathname_.c_str()); - const DWORD attributes = GetFileAttributes(unicode); - delete [] unicode; - return attributes != kInvalidFileAttributes; -#else - posix::StatStruct file_stat; - return posix::Stat(pathname_.c_str(), &file_stat) == 0; -#endif // GTEST_OS_WINDOWS_MOBILE -} - -// Returns true if pathname describes a directory in the file-system -// that exists. -bool FilePath::DirectoryExists() const { - bool result = false; -#if GTEST_OS_WINDOWS - // Don't strip off trailing separator if path is a root directory on - // Windows (like "C:\\"). - const FilePath& path(IsRootDirectory() ? *this : - RemoveTrailingPathSeparator()); -#else - const FilePath& path(*this); -#endif - -#if GTEST_OS_WINDOWS_MOBILE - LPCWSTR unicode = String::AnsiToUtf16(path.c_str()); - const DWORD attributes = GetFileAttributes(unicode); - delete [] unicode; - if ((attributes != kInvalidFileAttributes) && - (attributes & FILE_ATTRIBUTE_DIRECTORY)) { - result = true; - } -#else - posix::StatStruct file_stat; - result = posix::Stat(path.c_str(), &file_stat) == 0 && - posix::IsDir(file_stat); -#endif // GTEST_OS_WINDOWS_MOBILE - - return result; -} - -// Returns true if pathname describes a root directory. (Windows has one -// root directory per disk drive.) -bool FilePath::IsRootDirectory() const { -#if GTEST_OS_WINDOWS - return pathname_.length() == 3 && IsAbsolutePath(); -#else - return pathname_.length() == 1 && IsPathSeparator(pathname_.c_str()[0]); -#endif -} - -// Returns true if pathname describes an absolute path. -bool FilePath::IsAbsolutePath() const { - const char* const name = pathname_.c_str(); -#if GTEST_OS_WINDOWS - return pathname_.length() >= 3 && - ((name[0] >= 'a' && name[0] <= 'z') || - (name[0] >= 'A' && name[0] <= 'Z')) && - name[1] == ':' && - IsPathSeparator(name[2]); -#else - return IsPathSeparator(name[0]); -#endif -} - -// Returns a pathname for a file that does not currently exist. The pathname -// will be directory/base_name.extension or -// directory/base_name_<number>.extension if directory/base_name.extension -// already exists. The number will be incremented until a pathname is found -// that does not already exist. -// Examples: 'dir/foo_test.xml' or 'dir/foo_test_1.xml'. -// There could be a race condition if two or more processes are calling this -// function at the same time -- they could both pick the same filename. -FilePath FilePath::GenerateUniqueFileName(const FilePath& directory, - const FilePath& base_name, - const char* extension) { - FilePath full_pathname; - int number = 0; - do { - full_pathname.Set(MakeFileName(directory, base_name, number++, extension)); - } while (full_pathname.FileOrDirectoryExists()); - return full_pathname; -} - -// Returns true if FilePath ends with a path separator, which indicates that -// it is intended to represent a directory. Returns false otherwise. -// This does NOT check that a directory (or file) actually exists. -bool FilePath::IsDirectory() const { - return !pathname_.empty() && - IsPathSeparator(pathname_.c_str()[pathname_.length() - 1]); -} - -// Create directories so that path exists. Returns true if successful or if -// the directories already exist; returns false if unable to create directories -// for any reason. -bool FilePath::CreateDirectoriesRecursively() const { - if (!this->IsDirectory()) { - return false; - } - - if (pathname_.length() == 0 || this->DirectoryExists()) { - return true; - } - - const FilePath parent(this->RemoveTrailingPathSeparator().RemoveFileName()); - return parent.CreateDirectoriesRecursively() && this->CreateFolder(); -} - -// Create the directory so that path exists. Returns true if successful or -// if the directory already exists; returns false if unable to create the -// directory for any reason, including if the parent directory does not -// exist. Not named "CreateDirectory" because that's a macro on Windows. -bool FilePath::CreateFolder() const { -#if GTEST_OS_WINDOWS_MOBILE - FilePath removed_sep(this->RemoveTrailingPathSeparator()); - LPCWSTR unicode = String::AnsiToUtf16(removed_sep.c_str()); - int result = CreateDirectory(unicode, nullptr) ? 0 : -1; - delete [] unicode; -#elif GTEST_OS_WINDOWS - int result = _mkdir(pathname_.c_str()); -#elif GTEST_OS_ESP8266 || GTEST_OS_XTENSA - // do nothing - int result = 0; -#else - int result = mkdir(pathname_.c_str(), 0777); -#endif // GTEST_OS_WINDOWS_MOBILE - - if (result == -1) { - return this->DirectoryExists(); // An error is OK if the directory exists. - } - return true; // No error. -} - -// If input name has a trailing separator character, remove it and return the -// name, otherwise return the name string unmodified. -// On Windows platform, uses \ as the separator, other platforms use /. -FilePath FilePath::RemoveTrailingPathSeparator() const { - return IsDirectory() - ? FilePath(pathname_.substr(0, pathname_.length() - 1)) - : *this; -} - -// Removes any redundant separators that might be in the pathname. -// For example, "bar///foo" becomes "bar/foo". Does not eliminate other -// redundancies that might be in a pathname involving "." or "..". -void FilePath::Normalize() { - auto out = pathname_.begin(); - - for (const char character : pathname_) { - if (!IsPathSeparator(character)) { - *(out++) = character; - } else if (out == pathname_.begin() || *std::prev(out) != kPathSeparator) { - *(out++) = kPathSeparator; - } else { - continue; - } - } - - pathname_.erase(out, pathname_.end()); -} - -} // namespace internal -} // namespace testing -// Copyright 2007, 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. - -// The Google C++ Testing and Mocking Framework (Google Test) -// -// This file implements just enough of the matcher interface to allow -// EXPECT_DEATH and friends to accept a matcher argument. - - -#include <string> - -namespace testing { - -// Constructs a matcher that matches a const std::string& whose value is -// equal to s. -Matcher<const std::string&>::Matcher(const std::string& s) { *this = Eq(s); } - -// Constructs a matcher that matches a const std::string& whose value is -// equal to s. -Matcher<const std::string&>::Matcher(const char* s) { - *this = Eq(std::string(s)); -} - -// Constructs a matcher that matches a std::string whose value is equal to -// s. -Matcher<std::string>::Matcher(const std::string& s) { *this = Eq(s); } - -// Constructs a matcher that matches a std::string whose value is equal to -// s. -Matcher<std::string>::Matcher(const char* s) { *this = Eq(std::string(s)); } - -#if GTEST_INTERNAL_HAS_STRING_VIEW -// Constructs a matcher that matches a const StringView& whose value is -// equal to s. -Matcher<const internal::StringView&>::Matcher(const std::string& s) { - *this = Eq(s); -} - -// Constructs a matcher that matches a const StringView& whose value is -// equal to s. -Matcher<const internal::StringView&>::Matcher(const char* s) { - *this = Eq(std::string(s)); -} - -// Constructs a matcher that matches a const StringView& whose value is -// equal to s. -Matcher<const internal::StringView&>::Matcher(internal::StringView s) { - *this = Eq(std::string(s)); -} - -// Constructs a matcher that matches a StringView whose value is equal to -// s. -Matcher<internal::StringView>::Matcher(const std::string& s) { *this = Eq(s); } - -// Constructs a matcher that matches a StringView whose value is equal to -// s. -Matcher<internal::StringView>::Matcher(const char* s) { - *this = Eq(std::string(s)); -} - -// Constructs a matcher that matches a StringView whose value is equal to -// s. -Matcher<internal::StringView>::Matcher(internal::StringView s) { - *this = Eq(std::string(s)); -} -#endif // GTEST_INTERNAL_HAS_STRING_VIEW - -} // namespace testing -// Copyright 2008, 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. - - - -#include <limits.h> -#include <stdio.h> -#include <stdlib.h> -#include <string.h> -#include <cstdint> -#include <fstream> -#include <memory> - -#if GTEST_OS_WINDOWS -# include <windows.h> -# include <io.h> -# include <sys/stat.h> -# include <map> // Used in ThreadLocal. -# ifdef _MSC_VER -# include <crtdbg.h> -# endif // _MSC_VER -#else -# include <unistd.h> -#endif // GTEST_OS_WINDOWS - -#if GTEST_OS_MAC -# include <mach/mach_init.h> -# include <mach/task.h> -# include <mach/vm_map.h> -#endif // GTEST_OS_MAC - -#if GTEST_OS_DRAGONFLY || GTEST_OS_FREEBSD || GTEST_OS_GNU_KFREEBSD || \ - GTEST_OS_NETBSD || GTEST_OS_OPENBSD -# include <sys/sysctl.h> -# if GTEST_OS_DRAGONFLY || GTEST_OS_FREEBSD || GTEST_OS_GNU_KFREEBSD -# include <sys/user.h> -# endif -#endif - -#if GTEST_OS_QNX -# include <devctl.h> -# include <fcntl.h> -# include <sys/procfs.h> -#endif // GTEST_OS_QNX - -#if GTEST_OS_AIX -# include <procinfo.h> -# include <sys/types.h> -#endif // GTEST_OS_AIX - -#if GTEST_OS_FUCHSIA -# include <zircon/process.h> -# include <zircon/syscalls.h> -#endif // GTEST_OS_FUCHSIA - - -namespace testing { -namespace internal { - -#if defined(_MSC_VER) || defined(__BORLANDC__) -// MSVC and C++Builder do not provide a definition of STDERR_FILENO. -const int kStdOutFileno = 1; -const int kStdErrFileno = 2; -#else -const int kStdOutFileno = STDOUT_FILENO; -const int kStdErrFileno = STDERR_FILENO; -#endif // _MSC_VER - -#if GTEST_OS_LINUX - -namespace { -template <typename T> -T ReadProcFileField(const std::string& filename, int field) { - std::string dummy; - std::ifstream file(filename.c_str()); - while (field-- > 0) { - file >> dummy; - } - T output = 0; - file >> output; - return output; -} -} // namespace - -// Returns the number of active threads, or 0 when there is an error. -size_t GetThreadCount() { - const std::string filename = - (Message() << "/proc/" << getpid() << "/stat").GetString(); - return ReadProcFileField<size_t>(filename, 19); -} - -#elif GTEST_OS_MAC - -size_t GetThreadCount() { - const task_t task = mach_task_self(); - mach_msg_type_number_t thread_count; - thread_act_array_t thread_list; - const kern_return_t status = task_threads(task, &thread_list, &thread_count); - if (status == KERN_SUCCESS) { - // task_threads allocates resources in thread_list and we need to free them - // to avoid leaks. - vm_deallocate(task, - reinterpret_cast<vm_address_t>(thread_list), - sizeof(thread_t) * thread_count); - return static_cast<size_t>(thread_count); - } else { - return 0; - } -} - -#elif GTEST_OS_DRAGONFLY || GTEST_OS_FREEBSD || GTEST_OS_GNU_KFREEBSD || \ - GTEST_OS_NETBSD - -#if GTEST_OS_NETBSD -#undef KERN_PROC -#define KERN_PROC KERN_PROC2 -#define kinfo_proc kinfo_proc2 -#endif - -#if GTEST_OS_DRAGONFLY -#define KP_NLWP(kp) (kp.kp_nthreads) -#elif GTEST_OS_FREEBSD || GTEST_OS_GNU_KFREEBSD -#define KP_NLWP(kp) (kp.ki_numthreads) -#elif GTEST_OS_NETBSD -#define KP_NLWP(kp) (kp.p_nlwps) -#endif - -// Returns the number of threads running in the process, or 0 to indicate that -// we cannot detect it. -size_t GetThreadCount() { - int mib[] = { - CTL_KERN, - KERN_PROC, - KERN_PROC_PID, - getpid(), -#if GTEST_OS_NETBSD - sizeof(struct kinfo_proc), - 1, -#endif - }; - u_int miblen = sizeof(mib) / sizeof(mib[0]); - struct kinfo_proc info; - size_t size = sizeof(info); - if (sysctl(mib, miblen, &info, &size, NULL, 0)) { - return 0; - } - return static_cast<size_t>(KP_NLWP(info)); -} -#elif GTEST_OS_OPENBSD - -// Returns the number of threads running in the process, or 0 to indicate that -// we cannot detect it. -size_t GetThreadCount() { - int mib[] = { - CTL_KERN, - KERN_PROC, - KERN_PROC_PID | KERN_PROC_SHOW_THREADS, - getpid(), - sizeof(struct kinfo_proc), - 0, - }; - u_int miblen = sizeof(mib) / sizeof(mib[0]); - - // get number of structs - size_t size; - if (sysctl(mib, miblen, NULL, &size, NULL, 0)) { - return 0; - } - - mib[5] = static_cast<int>(size / static_cast<size_t>(mib[4])); - - // populate array of structs - struct kinfo_proc info[mib[5]]; - if (sysctl(mib, miblen, &info, &size, NULL, 0)) { - return 0; - } - - // exclude empty members - size_t nthreads = 0; - for (size_t i = 0; i < size / static_cast<size_t>(mib[4]); i++) { - if (info[i].p_tid != -1) - nthreads++; - } - return nthreads; -} - -#elif GTEST_OS_QNX - -// Returns the number of threads running in the process, or 0 to indicate that -// we cannot detect it. -size_t GetThreadCount() { - const int fd = open("/proc/self/as", O_RDONLY); - if (fd < 0) { - return 0; - } - procfs_info process_info; - const int status = - devctl(fd, DCMD_PROC_INFO, &process_info, sizeof(process_info), nullptr); - close(fd); - if (status == EOK) { - return static_cast<size_t>(process_info.num_threads); - } else { - return 0; - } -} - -#elif GTEST_OS_AIX - -size_t GetThreadCount() { - struct procentry64 entry; - pid_t pid = getpid(); - int status = getprocs64(&entry, sizeof(entry), nullptr, 0, &pid, 1); - if (status == 1) { - return entry.pi_thcount; - } else { - return 0; - } -} - -#elif GTEST_OS_FUCHSIA - -size_t GetThreadCount() { - int dummy_buffer; - size_t avail; - zx_status_t status = zx_object_get_info( - zx_process_self(), - ZX_INFO_PROCESS_THREADS, - &dummy_buffer, - 0, - nullptr, - &avail); - if (status == ZX_OK) { - return avail; - } else { - return 0; - } -} - -#else - -size_t GetThreadCount() { - // There's no portable way to detect the number of threads, so we just - // return 0 to indicate that we cannot detect it. - return 0; -} - -#endif // GTEST_OS_LINUX - -#if GTEST_IS_THREADSAFE && GTEST_OS_WINDOWS - -void SleepMilliseconds(int n) { - ::Sleep(static_cast<DWORD>(n)); -} - -AutoHandle::AutoHandle() - : handle_(INVALID_HANDLE_VALUE) {} - -AutoHandle::AutoHandle(Handle handle) - : handle_(handle) {} - -AutoHandle::~AutoHandle() { - Reset(); -} - -AutoHandle::Handle AutoHandle::Get() const { - return handle_; -} - -void AutoHandle::Reset() { - Reset(INVALID_HANDLE_VALUE); -} - -void AutoHandle::Reset(HANDLE handle) { - // Resetting with the same handle we already own is invalid. - if (handle_ != handle) { - if (IsCloseable()) { - ::CloseHandle(handle_); - } - handle_ = handle; - } else { - GTEST_CHECK_(!IsCloseable()) - << "Resetting a valid handle to itself is likely a programmer error " - "and thus not allowed."; - } -} - -bool AutoHandle::IsCloseable() const { - // Different Windows APIs may use either of these values to represent an - // invalid handle. - return handle_ != nullptr && handle_ != INVALID_HANDLE_VALUE; -} - -Notification::Notification() - : event_(::CreateEvent(nullptr, // Default security attributes. - TRUE, // Do not reset automatically. - FALSE, // Initially unset. - nullptr)) { // Anonymous event. - GTEST_CHECK_(event_.Get() != nullptr); -} - -void Notification::Notify() { - GTEST_CHECK_(::SetEvent(event_.Get()) != FALSE); -} - -void Notification::WaitForNotification() { - GTEST_CHECK_( - ::WaitForSingleObject(event_.Get(), INFINITE) == WAIT_OBJECT_0); -} - -Mutex::Mutex() - : owner_thread_id_(0), - type_(kDynamic), - critical_section_init_phase_(0), - critical_section_(new CRITICAL_SECTION) { - ::InitializeCriticalSection(critical_section_); -} - -Mutex::~Mutex() { - // Static mutexes are leaked intentionally. It is not thread-safe to try - // to clean them up. - if (type_ == kDynamic) { - ::DeleteCriticalSection(critical_section_); - delete critical_section_; - critical_section_ = nullptr; - } -} - -void Mutex::Lock() { - ThreadSafeLazyInit(); - ::EnterCriticalSection(critical_section_); - owner_thread_id_ = ::GetCurrentThreadId(); -} - -void Mutex::Unlock() { - ThreadSafeLazyInit(); - // We don't protect writing to owner_thread_id_ here, as it's the - // caller's responsibility to ensure that the current thread holds the - // mutex when this is called. - owner_thread_id_ = 0; - ::LeaveCriticalSection(critical_section_); -} - -// Does nothing if the current thread holds the mutex. Otherwise, crashes -// with high probability. -void Mutex::AssertHeld() { - ThreadSafeLazyInit(); - GTEST_CHECK_(owner_thread_id_ == ::GetCurrentThreadId()) - << "The current thread is not holding the mutex @" << this; -} - -namespace { - -#ifdef _MSC_VER -// Use the RAII idiom to flag mem allocs that are intentionally never -// deallocated. The motivation is to silence the false positive mem leaks -// that are reported by the debug version of MS's CRT which can only detect -// if an alloc is missing a matching deallocation. -// Example: -// MemoryIsNotDeallocated memory_is_not_deallocated; -// critical_section_ = new CRITICAL_SECTION; -// -class MemoryIsNotDeallocated -{ - public: - MemoryIsNotDeallocated() : old_crtdbg_flag_(0) { - old_crtdbg_flag_ = _CrtSetDbgFlag(_CRTDBG_REPORT_FLAG); - // Set heap allocation block type to _IGNORE_BLOCK so that MS debug CRT - // doesn't report mem leak if there's no matching deallocation. - _CrtSetDbgFlag(old_crtdbg_flag_ & ~_CRTDBG_ALLOC_MEM_DF); - } - - ~MemoryIsNotDeallocated() { - // Restore the original _CRTDBG_ALLOC_MEM_DF flag - _CrtSetDbgFlag(old_crtdbg_flag_); - } - - private: - int old_crtdbg_flag_; - - GTEST_DISALLOW_COPY_AND_ASSIGN_(MemoryIsNotDeallocated); -}; -#endif // _MSC_VER - -} // namespace - -// Initializes owner_thread_id_ and critical_section_ in static mutexes. -void Mutex::ThreadSafeLazyInit() { - // Dynamic mutexes are initialized in the constructor. - if (type_ == kStatic) { - switch ( - ::InterlockedCompareExchange(&critical_section_init_phase_, 1L, 0L)) { - case 0: - // If critical_section_init_phase_ was 0 before the exchange, we - // are the first to test it and need to perform the initialization. - owner_thread_id_ = 0; - { - // Use RAII to flag that following mem alloc is never deallocated. -#ifdef _MSC_VER - MemoryIsNotDeallocated memory_is_not_deallocated; -#endif // _MSC_VER - critical_section_ = new CRITICAL_SECTION; - } - ::InitializeCriticalSection(critical_section_); - // Updates the critical_section_init_phase_ to 2 to signal - // initialization complete. - GTEST_CHECK_(::InterlockedCompareExchange( - &critical_section_init_phase_, 2L, 1L) == - 1L); - break; - case 1: - // Somebody else is already initializing the mutex; spin until they - // are done. - while (::InterlockedCompareExchange(&critical_section_init_phase_, - 2L, - 2L) != 2L) { - // Possibly yields the rest of the thread's time slice to other - // threads. - ::Sleep(0); - } - break; - - case 2: - break; // The mutex is already initialized and ready for use. - - default: - GTEST_CHECK_(false) - << "Unexpected value of critical_section_init_phase_ " - << "while initializing a static mutex."; - } - } -} - -namespace { - -class ThreadWithParamSupport : public ThreadWithParamBase { - public: - static HANDLE CreateThread(Runnable* runnable, - Notification* thread_can_start) { - ThreadMainParam* param = new ThreadMainParam(runnable, thread_can_start); - DWORD thread_id; - HANDLE thread_handle = ::CreateThread( - nullptr, // Default security. - 0, // Default stack size. - &ThreadWithParamSupport::ThreadMain, - param, // Parameter to ThreadMainStatic - 0x0, // Default creation flags. - &thread_id); // Need a valid pointer for the call to work under Win98. - GTEST_CHECK_(thread_handle != nullptr) - << "CreateThread failed with error " << ::GetLastError() << "."; - if (thread_handle == nullptr) { - delete param; - } - return thread_handle; - } - - private: - struct ThreadMainParam { - ThreadMainParam(Runnable* runnable, Notification* thread_can_start) - : runnable_(runnable), - thread_can_start_(thread_can_start) { - } - std::unique_ptr<Runnable> runnable_; - // Does not own. - Notification* thread_can_start_; - }; - - static DWORD WINAPI ThreadMain(void* ptr) { - // Transfers ownership. - std::unique_ptr<ThreadMainParam> param(static_cast<ThreadMainParam*>(ptr)); - if (param->thread_can_start_ != nullptr) - param->thread_can_start_->WaitForNotification(); - param->runnable_->Run(); - return 0; - } - - // Prohibit instantiation. - ThreadWithParamSupport(); - - GTEST_DISALLOW_COPY_AND_ASSIGN_(ThreadWithParamSupport); -}; - -} // namespace - -ThreadWithParamBase::ThreadWithParamBase(Runnable *runnable, - Notification* thread_can_start) - : thread_(ThreadWithParamSupport::CreateThread(runnable, - thread_can_start)) { -} - -ThreadWithParamBase::~ThreadWithParamBase() { - Join(); -} - -void ThreadWithParamBase::Join() { - GTEST_CHECK_(::WaitForSingleObject(thread_.Get(), INFINITE) == WAIT_OBJECT_0) - << "Failed to join the thread with error " << ::GetLastError() << "."; -} - -// Maps a thread to a set of ThreadIdToThreadLocals that have values -// instantiated on that thread and notifies them when the thread exits. A -// ThreadLocal instance is expected to persist until all threads it has -// values on have terminated. -class ThreadLocalRegistryImpl { - public: - // Registers thread_local_instance as having value on the current thread. - // Returns a value that can be used to identify the thread from other threads. - static ThreadLocalValueHolderBase* GetValueOnCurrentThread( - const ThreadLocalBase* thread_local_instance) { -#ifdef _MSC_VER - MemoryIsNotDeallocated memory_is_not_deallocated; -#endif // _MSC_VER - DWORD current_thread = ::GetCurrentThreadId(); - MutexLock lock(&mutex_); - ThreadIdToThreadLocals* const thread_to_thread_locals = - GetThreadLocalsMapLocked(); - ThreadIdToThreadLocals::iterator thread_local_pos = - thread_to_thread_locals->find(current_thread); - if (thread_local_pos == thread_to_thread_locals->end()) { - thread_local_pos = thread_to_thread_locals->insert( - std::make_pair(current_thread, ThreadLocalValues())).first; - StartWatcherThreadFor(current_thread); - } - ThreadLocalValues& thread_local_values = thread_local_pos->second; - ThreadLocalValues::iterator value_pos = - thread_local_values.find(thread_local_instance); - if (value_pos == thread_local_values.end()) { - value_pos = - thread_local_values - .insert(std::make_pair( - thread_local_instance, - std::shared_ptr<ThreadLocalValueHolderBase>( - thread_local_instance->NewValueForCurrentThread()))) - .first; - } - return value_pos->second.get(); - } - - static void OnThreadLocalDestroyed( - const ThreadLocalBase* thread_local_instance) { - std::vector<std::shared_ptr<ThreadLocalValueHolderBase> > value_holders; - // Clean up the ThreadLocalValues data structure while holding the lock, but - // defer the destruction of the ThreadLocalValueHolderBases. - { - MutexLock lock(&mutex_); - ThreadIdToThreadLocals* const thread_to_thread_locals = - GetThreadLocalsMapLocked(); - for (ThreadIdToThreadLocals::iterator it = - thread_to_thread_locals->begin(); - it != thread_to_thread_locals->end(); - ++it) { - ThreadLocalValues& thread_local_values = it->second; - ThreadLocalValues::iterator value_pos = - thread_local_values.find(thread_local_instance); - if (value_pos != thread_local_values.end()) { - value_holders.push_back(value_pos->second); - thread_local_values.erase(value_pos); - // This 'if' can only be successful at most once, so theoretically we - // could break out of the loop here, but we don't bother doing so. - } - } - } - // Outside the lock, let the destructor for 'value_holders' deallocate the - // ThreadLocalValueHolderBases. - } - - static void OnThreadExit(DWORD thread_id) { - GTEST_CHECK_(thread_id != 0) << ::GetLastError(); - std::vector<std::shared_ptr<ThreadLocalValueHolderBase> > value_holders; - // Clean up the ThreadIdToThreadLocals data structure while holding the - // lock, but defer the destruction of the ThreadLocalValueHolderBases. - { - MutexLock lock(&mutex_); - ThreadIdToThreadLocals* const thread_to_thread_locals = - GetThreadLocalsMapLocked(); - ThreadIdToThreadLocals::iterator thread_local_pos = - thread_to_thread_locals->find(thread_id); - if (thread_local_pos != thread_to_thread_locals->end()) { - ThreadLocalValues& thread_local_values = thread_local_pos->second; - for (ThreadLocalValues::iterator value_pos = - thread_local_values.begin(); - value_pos != thread_local_values.end(); - ++value_pos) { - value_holders.push_back(value_pos->second); - } - thread_to_thread_locals->erase(thread_local_pos); - } - } - // Outside the lock, let the destructor for 'value_holders' deallocate the - // ThreadLocalValueHolderBases. - } - - private: - // In a particular thread, maps a ThreadLocal object to its value. - typedef std::map<const ThreadLocalBase*, - std::shared_ptr<ThreadLocalValueHolderBase> > - ThreadLocalValues; - // Stores all ThreadIdToThreadLocals having values in a thread, indexed by - // thread's ID. - typedef std::map<DWORD, ThreadLocalValues> ThreadIdToThreadLocals; - - // Holds the thread id and thread handle that we pass from - // StartWatcherThreadFor to WatcherThreadFunc. - typedef std::pair<DWORD, HANDLE> ThreadIdAndHandle; - - static void StartWatcherThreadFor(DWORD thread_id) { - // The returned handle will be kept in thread_map and closed by - // watcher_thread in WatcherThreadFunc. - HANDLE thread = ::OpenThread(SYNCHRONIZE | THREAD_QUERY_INFORMATION, - FALSE, - thread_id); - GTEST_CHECK_(thread != nullptr); - // We need to pass a valid thread ID pointer into CreateThread for it - // to work correctly under Win98. - DWORD watcher_thread_id; - HANDLE watcher_thread = ::CreateThread( - nullptr, // Default security. - 0, // Default stack size - &ThreadLocalRegistryImpl::WatcherThreadFunc, - reinterpret_cast<LPVOID>(new ThreadIdAndHandle(thread_id, thread)), - CREATE_SUSPENDED, &watcher_thread_id); - GTEST_CHECK_(watcher_thread != nullptr); - // Give the watcher thread the same priority as ours to avoid being - // blocked by it. - ::SetThreadPriority(watcher_thread, - ::GetThreadPriority(::GetCurrentThread())); - ::ResumeThread(watcher_thread); - ::CloseHandle(watcher_thread); - } - - // Monitors exit from a given thread and notifies those - // ThreadIdToThreadLocals about thread termination. - static DWORD WINAPI WatcherThreadFunc(LPVOID param) { - const ThreadIdAndHandle* tah = - reinterpret_cast<const ThreadIdAndHandle*>(param); - GTEST_CHECK_( - ::WaitForSingleObject(tah->second, INFINITE) == WAIT_OBJECT_0); - OnThreadExit(tah->first); - ::CloseHandle(tah->second); - delete tah; - return 0; - } - - // Returns map of thread local instances. - static ThreadIdToThreadLocals* GetThreadLocalsMapLocked() { - mutex_.AssertHeld(); -#ifdef _MSC_VER - MemoryIsNotDeallocated memory_is_not_deallocated; -#endif // _MSC_VER - static ThreadIdToThreadLocals* map = new ThreadIdToThreadLocals(); - return map; - } - - // Protects access to GetThreadLocalsMapLocked() and its return value. - static Mutex mutex_; - // Protects access to GetThreadMapLocked() and its return value. - static Mutex thread_map_mutex_; -}; - -Mutex ThreadLocalRegistryImpl::mutex_(Mutex::kStaticMutex); -Mutex ThreadLocalRegistryImpl::thread_map_mutex_(Mutex::kStaticMutex); - -ThreadLocalValueHolderBase* ThreadLocalRegistry::GetValueOnCurrentThread( - const ThreadLocalBase* thread_local_instance) { - return ThreadLocalRegistryImpl::GetValueOnCurrentThread( - thread_local_instance); -} - -void ThreadLocalRegistry::OnThreadLocalDestroyed( - const ThreadLocalBase* thread_local_instance) { - ThreadLocalRegistryImpl::OnThreadLocalDestroyed(thread_local_instance); -} - -#endif // GTEST_IS_THREADSAFE && GTEST_OS_WINDOWS - -#if GTEST_USES_POSIX_RE - -// Implements RE. Currently only needed for death tests. - -RE::~RE() { - if (is_valid_) { - // regfree'ing an invalid regex might crash because the content - // of the regex is undefined. Since the regex's are essentially - // the same, one cannot be valid (or invalid) without the other - // being so too. - regfree(&partial_regex_); - regfree(&full_regex_); - } - free(const_cast<char*>(pattern_)); -} - -// Returns true if and only if regular expression re matches the entire str. -bool RE::FullMatch(const char* str, const RE& re) { - if (!re.is_valid_) return false; - - regmatch_t match; - return regexec(&re.full_regex_, str, 1, &match, 0) == 0; -} - -// Returns true if and only if regular expression re matches a substring of -// str (including str itself). -bool RE::PartialMatch(const char* str, const RE& re) { - if (!re.is_valid_) return false; - - regmatch_t match; - return regexec(&re.partial_regex_, str, 1, &match, 0) == 0; -} - -// Initializes an RE from its string representation. -void RE::Init(const char* regex) { - pattern_ = posix::StrDup(regex); - - // Reserves enough bytes to hold the regular expression used for a - // full match. - const size_t full_regex_len = strlen(regex) + 10; - char* const full_pattern = new char[full_regex_len]; - - snprintf(full_pattern, full_regex_len, "^(%s)$", regex); - is_valid_ = regcomp(&full_regex_, full_pattern, REG_EXTENDED) == 0; - // We want to call regcomp(&partial_regex_, ...) even if the - // previous expression returns false. Otherwise partial_regex_ may - // not be properly initialized can may cause trouble when it's - // freed. - // - // Some implementation of POSIX regex (e.g. on at least some - // versions of Cygwin) doesn't accept the empty string as a valid - // regex. We change it to an equivalent form "()" to be safe. - if (is_valid_) { - const char* const partial_regex = (*regex == '\0') ? "()" : regex; - is_valid_ = regcomp(&partial_regex_, partial_regex, REG_EXTENDED) == 0; - } - EXPECT_TRUE(is_valid_) - << "Regular expression \"" << regex - << "\" is not a valid POSIX Extended regular expression."; - - delete[] full_pattern; -} - -#elif GTEST_USES_SIMPLE_RE - -// Returns true if and only if ch appears anywhere in str (excluding the -// terminating '\0' character). -bool IsInSet(char ch, const char* str) { - return ch != '\0' && strchr(str, ch) != nullptr; -} - -// Returns true if and only if ch belongs to the given classification. -// Unlike similar functions in <ctype.h>, these aren't affected by the -// current locale. -bool IsAsciiDigit(char ch) { return '0' <= ch && ch <= '9'; } -bool IsAsciiPunct(char ch) { - return IsInSet(ch, "^-!\"#$%&'()*+,./:;<=>?@[\\]_`{|}~"); -} -bool IsRepeat(char ch) { return IsInSet(ch, "?*+"); } -bool IsAsciiWhiteSpace(char ch) { return IsInSet(ch, " \f\n\r\t\v"); } -bool IsAsciiWordChar(char ch) { - return ('a' <= ch && ch <= 'z') || ('A' <= ch && ch <= 'Z') || - ('0' <= ch && ch <= '9') || ch == '_'; -} - -// Returns true if and only if "\\c" is a supported escape sequence. -bool IsValidEscape(char c) { - return (IsAsciiPunct(c) || IsInSet(c, "dDfnrsStvwW")); -} - -// Returns true if and only if the given atom (specified by escaped and -// pattern) matches ch. The result is undefined if the atom is invalid. -bool AtomMatchesChar(bool escaped, char pattern_char, char ch) { - if (escaped) { // "\\p" where p is pattern_char. - switch (pattern_char) { - case 'd': return IsAsciiDigit(ch); - case 'D': return !IsAsciiDigit(ch); - case 'f': return ch == '\f'; - case 'n': return ch == '\n'; - case 'r': return ch == '\r'; - case 's': return IsAsciiWhiteSpace(ch); - case 'S': return !IsAsciiWhiteSpace(ch); - case 't': return ch == '\t'; - case 'v': return ch == '\v'; - case 'w': return IsAsciiWordChar(ch); - case 'W': return !IsAsciiWordChar(ch); - } - return IsAsciiPunct(pattern_char) && pattern_char == ch; - } - - return (pattern_char == '.' && ch != '\n') || pattern_char == ch; -} - -// Helper function used by ValidateRegex() to format error messages. -static std::string FormatRegexSyntaxError(const char* regex, int index) { - return (Message() << "Syntax error at index " << index - << " in simple regular expression \"" << regex << "\": ").GetString(); -} - -// Generates non-fatal failures and returns false if regex is invalid; -// otherwise returns true. -bool ValidateRegex(const char* regex) { - if (regex == nullptr) { - ADD_FAILURE() << "NULL is not a valid simple regular expression."; - return false; - } - - bool is_valid = true; - - // True if and only if ?, *, or + can follow the previous atom. - bool prev_repeatable = false; - for (int i = 0; regex[i]; i++) { - if (regex[i] == '\\') { // An escape sequence - i++; - if (regex[i] == '\0') { - ADD_FAILURE() << FormatRegexSyntaxError(regex, i - 1) - << "'\\' cannot appear at the end."; - return false; - } - - if (!IsValidEscape(regex[i])) { - ADD_FAILURE() << FormatRegexSyntaxError(regex, i - 1) - << "invalid escape sequence \"\\" << regex[i] << "\"."; - is_valid = false; - } - prev_repeatable = true; - } else { // Not an escape sequence. - const char ch = regex[i]; - - if (ch == '^' && i > 0) { - ADD_FAILURE() << FormatRegexSyntaxError(regex, i) - << "'^' can only appear at the beginning."; - is_valid = false; - } else if (ch == '$' && regex[i + 1] != '\0') { - ADD_FAILURE() << FormatRegexSyntaxError(regex, i) - << "'$' can only appear at the end."; - is_valid = false; - } else if (IsInSet(ch, "()[]{}|")) { - ADD_FAILURE() << FormatRegexSyntaxError(regex, i) - << "'" << ch << "' is unsupported."; - is_valid = false; - } else if (IsRepeat(ch) && !prev_repeatable) { - ADD_FAILURE() << FormatRegexSyntaxError(regex, i) - << "'" << ch << "' can only follow a repeatable token."; - is_valid = false; - } - - prev_repeatable = !IsInSet(ch, "^$?*+"); - } - } - - return is_valid; -} - -// Matches a repeated regex atom followed by a valid simple regular -// expression. The regex atom is defined as c if escaped is false, -// or \c otherwise. repeat is the repetition meta character (?, *, -// or +). The behavior is undefined if str contains too many -// characters to be indexable by size_t, in which case the test will -// probably time out anyway. We are fine with this limitation as -// std::string has it too. -bool MatchRepetitionAndRegexAtHead( - bool escaped, char c, char repeat, const char* regex, - const char* str) { - const size_t min_count = (repeat == '+') ? 1 : 0; - const size_t max_count = (repeat == '?') ? 1 : - static_cast<size_t>(-1) - 1; - // We cannot call numeric_limits::max() as it conflicts with the - // max() macro on Windows. - - for (size_t i = 0; i <= max_count; ++i) { - // We know that the atom matches each of the first i characters in str. - if (i >= min_count && MatchRegexAtHead(regex, str + i)) { - // We have enough matches at the head, and the tail matches too. - // Since we only care about *whether* the pattern matches str - // (as opposed to *how* it matches), there is no need to find a - // greedy match. - return true; - } - if (str[i] == '\0' || !AtomMatchesChar(escaped, c, str[i])) - return false; - } - return false; -} - -// Returns true if and only if regex matches a prefix of str. regex must -// be a valid simple regular expression and not start with "^", or the -// result is undefined. -bool MatchRegexAtHead(const char* regex, const char* str) { - if (*regex == '\0') // An empty regex matches a prefix of anything. - return true; - - // "$" only matches the end of a string. Note that regex being - // valid guarantees that there's nothing after "$" in it. - if (*regex == '$') - return *str == '\0'; - - // Is the first thing in regex an escape sequence? - const bool escaped = *regex == '\\'; - if (escaped) - ++regex; - if (IsRepeat(regex[1])) { - // MatchRepetitionAndRegexAtHead() calls MatchRegexAtHead(), so - // here's an indirect recursion. It terminates as the regex gets - // shorter in each recursion. - return MatchRepetitionAndRegexAtHead( - escaped, regex[0], regex[1], regex + 2, str); - } else { - // regex isn't empty, isn't "$", and doesn't start with a - // repetition. We match the first atom of regex with the first - // character of str and recurse. - return (*str != '\0') && AtomMatchesChar(escaped, *regex, *str) && - MatchRegexAtHead(regex + 1, str + 1); - } -} - -// Returns true if and only if regex matches any substring of str. regex must -// be a valid simple regular expression, or the result is undefined. -// -// The algorithm is recursive, but the recursion depth doesn't exceed -// the regex length, so we won't need to worry about running out of -// stack space normally. In rare cases the time complexity can be -// exponential with respect to the regex length + the string length, -// but usually it's must faster (often close to linear). -bool MatchRegexAnywhere(const char* regex, const char* str) { - if (regex == nullptr || str == nullptr) return false; - - if (*regex == '^') - return MatchRegexAtHead(regex + 1, str); - - // A successful match can be anywhere in str. - do { - if (MatchRegexAtHead(regex, str)) - return true; - } while (*str++ != '\0'); - return false; -} - -// Implements the RE class. - -RE::~RE() { - free(const_cast<char*>(pattern_)); - free(const_cast<char*>(full_pattern_)); -} - -// Returns true if and only if regular expression re matches the entire str. -bool RE::FullMatch(const char* str, const RE& re) { - return re.is_valid_ && MatchRegexAnywhere(re.full_pattern_, str); -} - -// Returns true if and only if regular expression re matches a substring of -// str (including str itself). -bool RE::PartialMatch(const char* str, const RE& re) { - return re.is_valid_ && MatchRegexAnywhere(re.pattern_, str); -} - -// Initializes an RE from its string representation. -void RE::Init(const char* regex) { - pattern_ = full_pattern_ = nullptr; - if (regex != nullptr) { - pattern_ = posix::StrDup(regex); - } - - is_valid_ = ValidateRegex(regex); - if (!is_valid_) { - // No need to calculate the full pattern when the regex is invalid. - return; - } - - const size_t len = strlen(regex); - // Reserves enough bytes to hold the regular expression used for a - // full match: we need space to prepend a '^', append a '$', and - // terminate the string with '\0'. - char* buffer = static_cast<char*>(malloc(len + 3)); - full_pattern_ = buffer; - - if (*regex != '^') - *buffer++ = '^'; // Makes sure full_pattern_ starts with '^'. - - // We don't use snprintf or strncpy, as they trigger a warning when - // compiled with VC++ 8.0. - memcpy(buffer, regex, len); - buffer += len; - - if (len == 0 || regex[len - 1] != '$') - *buffer++ = '$'; // Makes sure full_pattern_ ends with '$'. - - *buffer = '\0'; -} - -#endif // GTEST_USES_POSIX_RE - -const char kUnknownFile[] = "unknown file"; - -// Formats a source file path and a line number as they would appear -// in an error message from the compiler used to compile this code. -GTEST_API_ ::std::string FormatFileLocation(const char* file, int line) { - const std::string file_name(file == nullptr ? kUnknownFile : file); - - if (line < 0) { - return file_name + ":"; - } -#ifdef _MSC_VER - return file_name + "(" + StreamableToString(line) + "):"; -#else - return file_name + ":" + StreamableToString(line) + ":"; -#endif // _MSC_VER -} - -// Formats a file location for compiler-independent XML output. -// Although this function is not platform dependent, we put it next to -// FormatFileLocation in order to contrast the two functions. -// Note that FormatCompilerIndependentFileLocation() does NOT append colon -// to the file location it produces, unlike FormatFileLocation(). -GTEST_API_ ::std::string FormatCompilerIndependentFileLocation( - const char* file, int line) { - const std::string file_name(file == nullptr ? kUnknownFile : file); - - if (line < 0) - return file_name; - else - return file_name + ":" + StreamableToString(line); -} - -GTestLog::GTestLog(GTestLogSeverity severity, const char* file, int line) - : severity_(severity) { - const char* const marker = - severity == GTEST_INFO ? "[ INFO ]" : - severity == GTEST_WARNING ? "[WARNING]" : - severity == GTEST_ERROR ? "[ ERROR ]" : "[ FATAL ]"; - GetStream() << ::std::endl << marker << " " - << FormatFileLocation(file, line).c_str() << ": "; -} - -// Flushes the buffers and, if severity is GTEST_FATAL, aborts the program. -GTestLog::~GTestLog() { - GetStream() << ::std::endl; - if (severity_ == GTEST_FATAL) { - fflush(stderr); - posix::Abort(); - } -} - -// Disable Microsoft deprecation warnings for POSIX functions called from -// this class (creat, dup, dup2, and close) -GTEST_DISABLE_MSC_DEPRECATED_PUSH_() - -#if GTEST_HAS_STREAM_REDIRECTION - -// Object that captures an output stream (stdout/stderr). -class CapturedStream { - public: - // The ctor redirects the stream to a temporary file. - explicit CapturedStream(int fd) : fd_(fd), uncaptured_fd_(dup(fd)) { -# if GTEST_OS_WINDOWS - char temp_dir_path[MAX_PATH + 1] = { '\0' }; // NOLINT - char temp_file_path[MAX_PATH + 1] = { '\0' }; // NOLINT - - ::GetTempPathA(sizeof(temp_dir_path), temp_dir_path); - const UINT success = ::GetTempFileNameA(temp_dir_path, - "gtest_redir", - 0, // Generate unique file name. - temp_file_path); - GTEST_CHECK_(success != 0) - << "Unable to create a temporary file in " << temp_dir_path; - const int captured_fd = creat(temp_file_path, _S_IREAD | _S_IWRITE); - GTEST_CHECK_(captured_fd != -1) << "Unable to open temporary file " - << temp_file_path; - filename_ = temp_file_path; -# else - // There's no guarantee that a test has write access to the current - // directory, so we create the temporary file in the /tmp directory - // instead. We use /tmp on most systems, and /sdcard on Android. - // That's because Android doesn't have /tmp. -# if GTEST_OS_LINUX_ANDROID - // Note: Android applications are expected to call the framework's - // Context.getExternalStorageDirectory() method through JNI to get - // the location of the world-writable SD Card directory. However, - // this requires a Context handle, which cannot be retrieved - // globally from native code. Doing so also precludes running the - // code as part of a regular standalone executable, which doesn't - // run in a Dalvik process (e.g. when running it through 'adb shell'). - // - // The location /data/local/tmp is directly accessible from native code. - // '/sdcard' and other variants cannot be relied on, as they are not - // guaranteed to be mounted, or may have a delay in mounting. - char name_template[] = "/data/local/tmp/gtest_captured_stream.XXXXXX"; -# else - char name_template[] = "/tmp/captured_stream.XXXXXX"; -# endif // GTEST_OS_LINUX_ANDROID - const int captured_fd = mkstemp(name_template); - if (captured_fd == -1) { - GTEST_LOG_(WARNING) - << "Failed to create tmp file " << name_template - << " for test; does the test have access to the /tmp directory?"; - } - filename_ = name_template; -# endif // GTEST_OS_WINDOWS - fflush(nullptr); - dup2(captured_fd, fd_); - close(captured_fd); - } - - ~CapturedStream() { - remove(filename_.c_str()); - } - - std::string GetCapturedString() { - if (uncaptured_fd_ != -1) { - // Restores the original stream. - fflush(nullptr); - dup2(uncaptured_fd_, fd_); - close(uncaptured_fd_); - uncaptured_fd_ = -1; - } - - FILE* const file = posix::FOpen(filename_.c_str(), "r"); - if (file == nullptr) { - GTEST_LOG_(FATAL) << "Failed to open tmp file " << filename_ - << " for capturing stream."; - } - const std::string content = ReadEntireFile(file); - posix::FClose(file); - return content; - } - - private: - const int fd_; // A stream to capture. - int uncaptured_fd_; - // Name of the temporary file holding the stderr output. - ::std::string filename_; - - GTEST_DISALLOW_COPY_AND_ASSIGN_(CapturedStream); -}; - -GTEST_DISABLE_MSC_DEPRECATED_POP_() - -static CapturedStream* g_captured_stderr = nullptr; -static CapturedStream* g_captured_stdout = nullptr; - -// Starts capturing an output stream (stdout/stderr). -static void CaptureStream(int fd, const char* stream_name, - CapturedStream** stream) { - if (*stream != nullptr) { - GTEST_LOG_(FATAL) << "Only one " << stream_name - << " capturer can exist at a time."; - } - *stream = new CapturedStream(fd); -} - -// Stops capturing the output stream and returns the captured string. -static std::string GetCapturedStream(CapturedStream** captured_stream) { - const std::string content = (*captured_stream)->GetCapturedString(); - - delete *captured_stream; - *captured_stream = nullptr; - - return content; -} - -// Starts capturing stdout. -void CaptureStdout() { - CaptureStream(kStdOutFileno, "stdout", &g_captured_stdout); -} - -// Starts capturing stderr. -void CaptureStderr() { - CaptureStream(kStdErrFileno, "stderr", &g_captured_stderr); -} - -// Stops capturing stdout and returns the captured string. -std::string GetCapturedStdout() { - return GetCapturedStream(&g_captured_stdout); -} - -// Stops capturing stderr and returns the captured string. -std::string GetCapturedStderr() { - return GetCapturedStream(&g_captured_stderr); -} - -#endif // GTEST_HAS_STREAM_REDIRECTION - - - - - -size_t GetFileSize(FILE* file) { - fseek(file, 0, SEEK_END); - return static_cast<size_t>(ftell(file)); -} - -std::string ReadEntireFile(FILE* file) { - const size_t file_size = GetFileSize(file); - char* const buffer = new char[file_size]; - - size_t bytes_last_read = 0; // # of bytes read in the last fread() - size_t bytes_read = 0; // # of bytes read so far - - fseek(file, 0, SEEK_SET); - - // Keeps reading the file until we cannot read further or the - // pre-determined file size is reached. - do { - bytes_last_read = fread(buffer+bytes_read, 1, file_size-bytes_read, file); - bytes_read += bytes_last_read; - } while (bytes_last_read > 0 && bytes_read < file_size); - - const std::string content(buffer, bytes_read); - delete[] buffer; - - return content; -} - -#if GTEST_HAS_DEATH_TEST -static const std::vector<std::string>* g_injected_test_argvs = - nullptr; // Owned. - -std::vector<std::string> GetInjectableArgvs() { - if (g_injected_test_argvs != nullptr) { - return *g_injected_test_argvs; - } - return GetArgvs(); -} - -void SetInjectableArgvs(const std::vector<std::string>* new_argvs) { - if (g_injected_test_argvs != new_argvs) delete g_injected_test_argvs; - g_injected_test_argvs = new_argvs; -} - -void SetInjectableArgvs(const std::vector<std::string>& new_argvs) { - SetInjectableArgvs( - new std::vector<std::string>(new_argvs.begin(), new_argvs.end())); -} - -void ClearInjectableArgvs() { - delete g_injected_test_argvs; - g_injected_test_argvs = nullptr; -} -#endif // GTEST_HAS_DEATH_TEST - -#if GTEST_OS_WINDOWS_MOBILE -namespace posix { -void Abort() { - DebugBreak(); - TerminateProcess(GetCurrentProcess(), 1); -} -} // namespace posix -#endif // GTEST_OS_WINDOWS_MOBILE - -// Returns the name of the environment variable corresponding to the -// given flag. For example, FlagToEnvVar("foo") will return -// "GTEST_FOO" in the open-source version. -static std::string FlagToEnvVar(const char* flag) { - const std::string full_flag = - (Message() << GTEST_FLAG_PREFIX_ << flag).GetString(); - - Message env_var; - for (size_t i = 0; i != full_flag.length(); i++) { - env_var << ToUpper(full_flag.c_str()[i]); - } - - return env_var.GetString(); -} - -// Parses 'str' for a 32-bit signed integer. If successful, writes -// the result to *value and returns true; otherwise leaves *value -// unchanged and returns false. -bool ParseInt32(const Message& src_text, const char* str, int32_t* value) { - // Parses the environment variable as a decimal integer. - char* end = nullptr; - const long long_value = strtol(str, &end, 10); // NOLINT - - // Has strtol() consumed all characters in the string? - if (*end != '\0') { - // No - an invalid character was encountered. - Message msg; - msg << "WARNING: " << src_text - << " is expected to be a 32-bit integer, but actually" - << " has value \"" << str << "\".\n"; - printf("%s", msg.GetString().c_str()); - fflush(stdout); - return false; - } - - // Is the parsed value in the range of an int32_t? - const auto result = static_cast<int32_t>(long_value); - if (long_value == LONG_MAX || long_value == LONG_MIN || - // The parsed value overflows as a long. (strtol() returns - // LONG_MAX or LONG_MIN when the input overflows.) - result != long_value - // The parsed value overflows as an int32_t. - ) { - Message msg; - msg << "WARNING: " << src_text - << " is expected to be a 32-bit integer, but actually" - << " has value " << str << ", which overflows.\n"; - printf("%s", msg.GetString().c_str()); - fflush(stdout); - return false; - } - - *value = result; - return true; -} - -// Reads and returns the Boolean environment variable corresponding to -// the given flag; if it's not set, returns default_value. -// -// The value is considered true if and only if it's not "0". -bool BoolFromGTestEnv(const char* flag, bool default_value) { -#if defined(GTEST_GET_BOOL_FROM_ENV_) - return GTEST_GET_BOOL_FROM_ENV_(flag, default_value); -#else - const std::string env_var = FlagToEnvVar(flag); - const char* const string_value = posix::GetEnv(env_var.c_str()); - return string_value == nullptr ? default_value - : strcmp(string_value, "0") != 0; -#endif // defined(GTEST_GET_BOOL_FROM_ENV_) -} - -// Reads and returns a 32-bit integer stored in the environment -// variable corresponding to the given flag; if it isn't set or -// doesn't represent a valid 32-bit integer, returns default_value. -int32_t Int32FromGTestEnv(const char* flag, int32_t default_value) { -#if defined(GTEST_GET_INT32_FROM_ENV_) - return GTEST_GET_INT32_FROM_ENV_(flag, default_value); -#else - const std::string env_var = FlagToEnvVar(flag); - const char* const string_value = posix::GetEnv(env_var.c_str()); - if (string_value == nullptr) { - // The environment variable is not set. - return default_value; - } - - int32_t result = default_value; - if (!ParseInt32(Message() << "Environment variable " << env_var, - string_value, &result)) { - printf("The default value %s is used.\n", - (Message() << default_value).GetString().c_str()); - fflush(stdout); - return default_value; - } - - return result; -#endif // defined(GTEST_GET_INT32_FROM_ENV_) -} - -// As a special case for the 'output' flag, if GTEST_OUTPUT is not -// set, we look for XML_OUTPUT_FILE, which is set by the Bazel build -// system. The value of XML_OUTPUT_FILE is a filename without the -// "xml:" prefix of GTEST_OUTPUT. -// Note that this is meant to be called at the call site so it does -// not check that the flag is 'output' -// In essence this checks an env variable called XML_OUTPUT_FILE -// and if it is set we prepend "xml:" to its value, if it not set we return "" -std::string OutputFlagAlsoCheckEnvVar(){ - std::string default_value_for_output_flag = ""; - const char* xml_output_file_env = posix::GetEnv("XML_OUTPUT_FILE"); - if (nullptr != xml_output_file_env) { - default_value_for_output_flag = std::string("xml:") + xml_output_file_env; - } - return default_value_for_output_flag; -} - -// Reads and returns the string environment variable corresponding to -// the given flag; if it's not set, returns default_value. -const char* StringFromGTestEnv(const char* flag, const char* default_value) { -#if defined(GTEST_GET_STRING_FROM_ENV_) - return GTEST_GET_STRING_FROM_ENV_(flag, default_value); -#else - const std::string env_var = FlagToEnvVar(flag); - const char* const value = posix::GetEnv(env_var.c_str()); - return value == nullptr ? default_value : value; -#endif // defined(GTEST_GET_STRING_FROM_ENV_) -} - -} // namespace internal -} // namespace testing -// Copyright 2007, 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. - - -// Google Test - The Google C++ Testing and Mocking Framework -// -// This file implements a universal value printer that can print a -// value of any type T: -// -// void ::testing::internal::UniversalPrinter<T>::Print(value, ostream_ptr); -// -// It uses the << operator when possible, and prints the bytes in the -// object otherwise. A user can override its behavior for a class -// type Foo by defining either operator<<(::std::ostream&, const Foo&) -// or void PrintTo(const Foo&, ::std::ostream*) in the namespace that -// defines Foo. - - -#include <stdio.h> - -#include <cctype> -#include <cstdint> -#include <cwchar> -#include <ostream> // NOLINT -#include <string> -#include <type_traits> - - -namespace testing { - -namespace { - -using ::std::ostream; - -// Prints a segment of bytes in the given object. -GTEST_ATTRIBUTE_NO_SANITIZE_MEMORY_ -GTEST_ATTRIBUTE_NO_SANITIZE_ADDRESS_ -GTEST_ATTRIBUTE_NO_SANITIZE_HWADDRESS_ -GTEST_ATTRIBUTE_NO_SANITIZE_THREAD_ -void PrintByteSegmentInObjectTo(const unsigned char* obj_bytes, size_t start, - size_t count, ostream* os) { - char text[5] = ""; - for (size_t i = 0; i != count; i++) { - const size_t j = start + i; - if (i != 0) { - // Organizes the bytes into groups of 2 for easy parsing by - // human. - if ((j % 2) == 0) - *os << ' '; - else - *os << '-'; - } - GTEST_SNPRINTF_(text, sizeof(text), "%02X", obj_bytes[j]); - *os << text; - } -} - -// Prints the bytes in the given value to the given ostream. -void PrintBytesInObjectToImpl(const unsigned char* obj_bytes, size_t count, - ostream* os) { - // Tells the user how big the object is. - *os << count << "-byte object <"; - - const size_t kThreshold = 132; - const size_t kChunkSize = 64; - // If the object size is bigger than kThreshold, we'll have to omit - // some details by printing only the first and the last kChunkSize - // bytes. - if (count < kThreshold) { - PrintByteSegmentInObjectTo(obj_bytes, 0, count, os); - } else { - PrintByteSegmentInObjectTo(obj_bytes, 0, kChunkSize, os); - *os << " ... "; - // Rounds up to 2-byte boundary. - const size_t resume_pos = (count - kChunkSize + 1)/2*2; - PrintByteSegmentInObjectTo(obj_bytes, resume_pos, count - resume_pos, os); - } - *os << ">"; -} - -// Helpers for widening a character to char32_t. Since the standard does not -// specify if char / wchar_t is signed or unsigned, it is important to first -// convert it to the unsigned type of the same width before widening it to -// char32_t. -template <typename CharType> -char32_t ToChar32(CharType in) { - return static_cast<char32_t>( - static_cast<typename std::make_unsigned<CharType>::type>(in)); -} - -} // namespace - -namespace internal { - -// Delegates to PrintBytesInObjectToImpl() to print the bytes in the -// given object. The delegation simplifies the implementation, which -// uses the << operator and thus is easier done outside of the -// ::testing::internal namespace, which contains a << operator that -// sometimes conflicts with the one in STL. -void PrintBytesInObjectTo(const unsigned char* obj_bytes, size_t count, - ostream* os) { - PrintBytesInObjectToImpl(obj_bytes, count, os); -} - -// Depending on the value of a char (or wchar_t), we print it in one -// of three formats: -// - as is if it's a printable ASCII (e.g. 'a', '2', ' '), -// - as a hexadecimal escape sequence (e.g. '\x7F'), or -// - as a special escape sequence (e.g. '\r', '\n'). -enum CharFormat { - kAsIs, - kHexEscape, - kSpecialEscape -}; - -// Returns true if c is a printable ASCII character. We test the -// value of c directly instead of calling isprint(), which is buggy on -// Windows Mobile. -inline bool IsPrintableAscii(char32_t c) { return 0x20 <= c && c <= 0x7E; } - -// Prints c (of type char, char8_t, char16_t, char32_t, or wchar_t) as a -// character literal without the quotes, escaping it when necessary; returns how -// c was formatted. -template <typename Char> -static CharFormat PrintAsCharLiteralTo(Char c, ostream* os) { - const char32_t u_c = ToChar32(c); - switch (u_c) { - case L'\0': - *os << "\\0"; - break; - case L'\'': - *os << "\\'"; - break; - case L'\\': - *os << "\\\\"; - break; - case L'\a': - *os << "\\a"; - break; - case L'\b': - *os << "\\b"; - break; - case L'\f': - *os << "\\f"; - break; - case L'\n': - *os << "\\n"; - break; - case L'\r': - *os << "\\r"; - break; - case L'\t': - *os << "\\t"; - break; - case L'\v': - *os << "\\v"; - break; - default: - if (IsPrintableAscii(u_c)) { - *os << static_cast<char>(c); - return kAsIs; - } else { - ostream::fmtflags flags = os->flags(); - *os << "\\x" << std::hex << std::uppercase << static_cast<int>(u_c); - os->flags(flags); - return kHexEscape; - } - } - return kSpecialEscape; -} - -// Prints a char32_t c as if it's part of a string literal, escaping it when -// necessary; returns how c was formatted. -static CharFormat PrintAsStringLiteralTo(char32_t c, ostream* os) { - switch (c) { - case L'\'': - *os << "'"; - return kAsIs; - case L'"': - *os << "\\\""; - return kSpecialEscape; - default: - return PrintAsCharLiteralTo(c, os); - } -} - -static const char* GetCharWidthPrefix(char) { - return ""; -} - -static const char* GetCharWidthPrefix(signed char) { - return ""; -} - -static const char* GetCharWidthPrefix(unsigned char) { - return ""; -} - -#ifdef __cpp_char8_t -static const char* GetCharWidthPrefix(char8_t) { - return "u8"; -} -#endif - -static const char* GetCharWidthPrefix(char16_t) { - return "u"; -} - -static const char* GetCharWidthPrefix(char32_t) { - return "U"; -} - -static const char* GetCharWidthPrefix(wchar_t) { - return "L"; -} - -// Prints a char c as if it's part of a string literal, escaping it when -// necessary; returns how c was formatted. -static CharFormat PrintAsStringLiteralTo(char c, ostream* os) { - return PrintAsStringLiteralTo(ToChar32(c), os); -} - -#ifdef __cpp_char8_t -static CharFormat PrintAsStringLiteralTo(char8_t c, ostream* os) { - return PrintAsStringLiteralTo(ToChar32(c), os); -} -#endif - -static CharFormat PrintAsStringLiteralTo(char16_t c, ostream* os) { - return PrintAsStringLiteralTo(ToChar32(c), os); -} - -static CharFormat PrintAsStringLiteralTo(wchar_t c, ostream* os) { - return PrintAsStringLiteralTo(ToChar32(c), os); -} - -// Prints a character c (of type char, char8_t, char16_t, char32_t, or wchar_t) -// and its code. '\0' is printed as "'\\0'", other unprintable characters are -// also properly escaped using the standard C++ escape sequence. -template <typename Char> -void PrintCharAndCodeTo(Char c, ostream* os) { - // First, print c as a literal in the most readable form we can find. - *os << GetCharWidthPrefix(c) << "'"; - const CharFormat format = PrintAsCharLiteralTo(c, os); - *os << "'"; - - // To aid user debugging, we also print c's code in decimal, unless - // it's 0 (in which case c was printed as '\\0', making the code - // obvious). - if (c == 0) - return; - *os << " (" << static_cast<int>(c); - - // For more convenience, we print c's code again in hexadecimal, - // unless c was already printed in the form '\x##' or the code is in - // [1, 9]. - if (format == kHexEscape || (1 <= c && c <= 9)) { - // Do nothing. - } else { - *os << ", 0x" << String::FormatHexInt(static_cast<int>(c)); - } - *os << ")"; -} - -void PrintTo(unsigned char c, ::std::ostream* os) { PrintCharAndCodeTo(c, os); } -void PrintTo(signed char c, ::std::ostream* os) { PrintCharAndCodeTo(c, os); } - -// Prints a wchar_t as a symbol if it is printable or as its internal -// code otherwise and also as its code. L'\0' is printed as "L'\\0'". -void PrintTo(wchar_t wc, ostream* os) { PrintCharAndCodeTo(wc, os); } - -// TODO(dcheng): Consider making this delegate to PrintCharAndCodeTo() as well. -void PrintTo(char32_t c, ::std::ostream* os) { - *os << std::hex << "U+" << std::uppercase << std::setfill('0') << std::setw(4) - << static_cast<uint32_t>(c); -} - -// Prints the given array of characters to the ostream. CharType must be either -// char, char8_t, char16_t, char32_t, or wchar_t. -// The array starts at begin, the length is len, it may include '\0' characters -// and may not be NUL-terminated. -template <typename CharType> -GTEST_ATTRIBUTE_NO_SANITIZE_MEMORY_ -GTEST_ATTRIBUTE_NO_SANITIZE_ADDRESS_ -GTEST_ATTRIBUTE_NO_SANITIZE_HWADDRESS_ -GTEST_ATTRIBUTE_NO_SANITIZE_THREAD_ -static CharFormat PrintCharsAsStringTo( - const CharType* begin, size_t len, ostream* os) { - const char* const quote_prefix = GetCharWidthPrefix(*begin); - *os << quote_prefix << "\""; - bool is_previous_hex = false; - CharFormat print_format = kAsIs; - for (size_t index = 0; index < len; ++index) { - const CharType cur = begin[index]; - if (is_previous_hex && IsXDigit(cur)) { - // Previous character is of '\x..' form and this character can be - // interpreted as another hexadecimal digit in its number. Break string to - // disambiguate. - *os << "\" " << quote_prefix << "\""; - } - is_previous_hex = PrintAsStringLiteralTo(cur, os) == kHexEscape; - // Remember if any characters required hex escaping. - if (is_previous_hex) { - print_format = kHexEscape; - } - } - *os << "\""; - return print_format; -} - -// Prints a (const) char/wchar_t array of 'len' elements, starting at address -// 'begin'. CharType must be either char or wchar_t. -template <typename CharType> -GTEST_ATTRIBUTE_NO_SANITIZE_MEMORY_ -GTEST_ATTRIBUTE_NO_SANITIZE_ADDRESS_ -GTEST_ATTRIBUTE_NO_SANITIZE_HWADDRESS_ -GTEST_ATTRIBUTE_NO_SANITIZE_THREAD_ -static void UniversalPrintCharArray( - const CharType* begin, size_t len, ostream* os) { - // The code - // const char kFoo[] = "foo"; - // generates an array of 4, not 3, elements, with the last one being '\0'. - // - // Therefore when printing a char array, we don't print the last element if - // it's '\0', such that the output matches the string literal as it's - // written in the source code. - if (len > 0 && begin[len - 1] == '\0') { - PrintCharsAsStringTo(begin, len - 1, os); - return; - } - - // If, however, the last element in the array is not '\0', e.g. - // const char kFoo[] = { 'f', 'o', 'o' }; - // we must print the entire array. We also print a message to indicate - // that the array is not NUL-terminated. - PrintCharsAsStringTo(begin, len, os); - *os << " (no terminating NUL)"; -} - -// Prints a (const) char array of 'len' elements, starting at address 'begin'. -void UniversalPrintArray(const char* begin, size_t len, ostream* os) { - UniversalPrintCharArray(begin, len, os); -} - -#ifdef __cpp_char8_t -// Prints a (const) char8_t array of 'len' elements, starting at address -// 'begin'. -void UniversalPrintArray(const char8_t* begin, size_t len, ostream* os) { - UniversalPrintCharArray(begin, len, os); -} -#endif - -// Prints a (const) char16_t array of 'len' elements, starting at address -// 'begin'. -void UniversalPrintArray(const char16_t* begin, size_t len, ostream* os) { - UniversalPrintCharArray(begin, len, os); -} - -// Prints a (const) char32_t array of 'len' elements, starting at address -// 'begin'. -void UniversalPrintArray(const char32_t* begin, size_t len, ostream* os) { - UniversalPrintCharArray(begin, len, os); -} - -// Prints a (const) wchar_t array of 'len' elements, starting at address -// 'begin'. -void UniversalPrintArray(const wchar_t* begin, size_t len, ostream* os) { - UniversalPrintCharArray(begin, len, os); -} - -namespace { - -// Prints a null-terminated C-style string to the ostream. -template <typename Char> -void PrintCStringTo(const Char* s, ostream* os) { - if (s == nullptr) { - *os << "NULL"; - } else { - *os << ImplicitCast_<const void*>(s) << " pointing to "; - PrintCharsAsStringTo(s, std::char_traits<Char>::length(s), os); - } -} - -} // anonymous namespace - -void PrintTo(const char* s, ostream* os) { PrintCStringTo(s, os); } - -#ifdef __cpp_char8_t -void PrintTo(const char8_t* s, ostream* os) { PrintCStringTo(s, os); } -#endif - -void PrintTo(const char16_t* s, ostream* os) { PrintCStringTo(s, os); } - -void PrintTo(const char32_t* s, ostream* os) { PrintCStringTo(s, os); } - -// MSVC compiler can be configured to define whar_t as a typedef -// of unsigned short. Defining an overload for const wchar_t* in that case -// would cause pointers to unsigned shorts be printed as wide strings, -// possibly accessing more memory than intended and causing invalid -// memory accesses. MSVC defines _NATIVE_WCHAR_T_DEFINED symbol when -// wchar_t is implemented as a native type. -#if !defined(_MSC_VER) || defined(_NATIVE_WCHAR_T_DEFINED) -// Prints the given wide C string to the ostream. -void PrintTo(const wchar_t* s, ostream* os) { PrintCStringTo(s, os); } -#endif // wchar_t is native - -namespace { - -bool ContainsUnprintableControlCodes(const char* str, size_t length) { - const unsigned char *s = reinterpret_cast<const unsigned char *>(str); - - for (size_t i = 0; i < length; i++) { - unsigned char ch = *s++; - if (std::iscntrl(ch)) { - switch (ch) { - case '\t': - case '\n': - case '\r': - break; - default: - return true; - } - } - } - return false; -} - -bool IsUTF8TrailByte(unsigned char t) { return 0x80 <= t && t<= 0xbf; } - -bool IsValidUTF8(const char* str, size_t length) { - const unsigned char *s = reinterpret_cast<const unsigned char *>(str); - - for (size_t i = 0; i < length;) { - unsigned char lead = s[i++]; - - if (lead <= 0x7f) { - continue; // single-byte character (ASCII) 0..7F - } - if (lead < 0xc2) { - return false; // trail byte or non-shortest form - } else if (lead <= 0xdf && (i + 1) <= length && IsUTF8TrailByte(s[i])) { - ++i; // 2-byte character - } else if (0xe0 <= lead && lead <= 0xef && (i + 2) <= length && - IsUTF8TrailByte(s[i]) && - IsUTF8TrailByte(s[i + 1]) && - // check for non-shortest form and surrogate - (lead != 0xe0 || s[i] >= 0xa0) && - (lead != 0xed || s[i] < 0xa0)) { - i += 2; // 3-byte character - } else if (0xf0 <= lead && lead <= 0xf4 && (i + 3) <= length && - IsUTF8TrailByte(s[i]) && - IsUTF8TrailByte(s[i + 1]) && - IsUTF8TrailByte(s[i + 2]) && - // check for non-shortest form - (lead != 0xf0 || s[i] >= 0x90) && - (lead != 0xf4 || s[i] < 0x90)) { - i += 3; // 4-byte character - } else { - return false; - } - } - return true; -} - -void ConditionalPrintAsText(const char* str, size_t length, ostream* os) { - if (!ContainsUnprintableControlCodes(str, length) && - IsValidUTF8(str, length)) { - *os << "\n As Text: \"" << str << "\""; - } -} - -} // anonymous namespace - -void PrintStringTo(const ::std::string& s, ostream* os) { - if (PrintCharsAsStringTo(s.data(), s.size(), os) == kHexEscape) { - if (GTEST_FLAG(print_utf8)) { - ConditionalPrintAsText(s.data(), s.size(), os); - } - } -} - -#ifdef __cpp_char8_t -void PrintU8StringTo(const ::std::u8string& s, ostream* os) { - PrintCharsAsStringTo(s.data(), s.size(), os); -} -#endif - -void PrintU16StringTo(const ::std::u16string& s, ostream* os) { - PrintCharsAsStringTo(s.data(), s.size(), os); -} - -void PrintU32StringTo(const ::std::u32string& s, ostream* os) { - PrintCharsAsStringTo(s.data(), s.size(), os); -} - -#if GTEST_HAS_STD_WSTRING -void PrintWideStringTo(const ::std::wstring& s, ostream* os) { - PrintCharsAsStringTo(s.data(), s.size(), os); -} -#endif // GTEST_HAS_STD_WSTRING - -} // namespace internal - -} // namespace testing -// Copyright 2008, 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. - -// -// The Google C++ Testing and Mocking Framework (Google Test) - - - -namespace testing { - -using internal::GetUnitTestImpl; - -// Gets the summary of the failure message by omitting the stack trace -// in it. -std::string TestPartResult::ExtractSummary(const char* message) { - const char* const stack_trace = strstr(message, internal::kStackTraceMarker); - return stack_trace == nullptr ? message : std::string(message, stack_trace); -} - -// Prints a TestPartResult object. -std::ostream& operator<<(std::ostream& os, const TestPartResult& result) { - return os << internal::FormatFileLocation(result.file_name(), - result.line_number()) - << " " - << (result.type() == TestPartResult::kSuccess - ? "Success" - : result.type() == TestPartResult::kSkip - ? "Skipped" - : result.type() == TestPartResult::kFatalFailure - ? "Fatal failure" - : "Non-fatal failure") - << ":\n" - << result.message() << std::endl; -} - -// Appends a TestPartResult to the array. -void TestPartResultArray::Append(const TestPartResult& result) { - array_.push_back(result); -} - -// Returns the TestPartResult at the given index (0-based). -const TestPartResult& TestPartResultArray::GetTestPartResult(int index) const { - if (index < 0 || index >= size()) { - printf("\nInvalid index (%d) into TestPartResultArray.\n", index); - internal::posix::Abort(); - } - - return array_[static_cast<size_t>(index)]; -} - -// Returns the number of TestPartResult objects in the array. -int TestPartResultArray::size() const { - return static_cast<int>(array_.size()); -} - -namespace internal { - -HasNewFatalFailureHelper::HasNewFatalFailureHelper() - : has_new_fatal_failure_(false), - original_reporter_(GetUnitTestImpl()-> - GetTestPartResultReporterForCurrentThread()) { - GetUnitTestImpl()->SetTestPartResultReporterForCurrentThread(this); -} - -HasNewFatalFailureHelper::~HasNewFatalFailureHelper() { - GetUnitTestImpl()->SetTestPartResultReporterForCurrentThread( - original_reporter_); -} - -void HasNewFatalFailureHelper::ReportTestPartResult( - const TestPartResult& result) { - if (result.fatally_failed()) - has_new_fatal_failure_ = true; - original_reporter_->ReportTestPartResult(result); -} - -} // namespace internal - -} // namespace testing -// Copyright 2008 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. - - - - -namespace testing { -namespace internal { - -// Skips to the first non-space char in str. Returns an empty string if str -// contains only whitespace characters. -static const char* SkipSpaces(const char* str) { - while (IsSpace(*str)) - str++; - return str; -} - -static std::vector<std::string> SplitIntoTestNames(const char* src) { - std::vector<std::string> name_vec; - src = SkipSpaces(src); - for (; src != nullptr; src = SkipComma(src)) { - name_vec.push_back(StripTrailingSpaces(GetPrefixUntilComma(src))); - } - return name_vec; -} - -// Verifies that registered_tests match the test names in -// registered_tests_; returns registered_tests if successful, or -// aborts the program otherwise. -const char* TypedTestSuitePState::VerifyRegisteredTestNames( - const char* test_suite_name, const char* file, int line, - const char* registered_tests) { - RegisterTypeParameterizedTestSuite(test_suite_name, CodeLocation(file, line)); - - typedef RegisteredTestsMap::const_iterator RegisteredTestIter; - registered_ = true; - - std::vector<std::string> name_vec = SplitIntoTestNames(registered_tests); - - Message errors; - - std::set<std::string> tests; - for (std::vector<std::string>::const_iterator name_it = name_vec.begin(); - name_it != name_vec.end(); ++name_it) { - const std::string& name = *name_it; - if (tests.count(name) != 0) { - errors << "Test " << name << " is listed more than once.\n"; - continue; - } - - if (registered_tests_.count(name) != 0) { - tests.insert(name); - } else { - errors << "No test named " << name - << " can be found in this test suite.\n"; - } - } - - for (RegisteredTestIter it = registered_tests_.begin(); - it != registered_tests_.end(); - ++it) { - if (tests.count(it->first) == 0) { - errors << "You forgot to list test " << it->first << ".\n"; - } - } - - const std::string& errors_str = errors.GetString(); - if (errors_str != "") { - fprintf(stderr, "%s %s", FormatFileLocation(file, line).c_str(), - errors_str.c_str()); - fflush(stderr); - posix::Abort(); - } - - return registered_tests; -} - -} // namespace internal -} // namespace testing -// Copyright 2008, 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. - -// -// Google C++ Mocking Framework (Google Mock) -// -// This file #includes all Google Mock implementation .cc files. The -// purpose is to allow a user to build Google Mock by compiling this -// file alone. - -// This line ensures that gmock.h can be compiled on its own, even -// when it's fused. -#include "gmock/gmock.h" - -// The following lines pull in the real gmock *.cc files. -// Copyright 2007, 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. - - -// Google Mock - a framework for writing C++ mock classes. -// -// This file implements cardinalities. - - -#include <limits.h> -#include <ostream> // NOLINT -#include <sstream> -#include <string> - -namespace testing { - -namespace { - -// Implements the Between(m, n) cardinality. -class BetweenCardinalityImpl : public CardinalityInterface { - public: - BetweenCardinalityImpl(int min, int max) - : min_(min >= 0 ? min : 0), - max_(max >= min_ ? max : min_) { - std::stringstream ss; - if (min < 0) { - ss << "The invocation lower bound must be >= 0, " - << "but is actually " << min << "."; - internal::Expect(false, __FILE__, __LINE__, ss.str()); - } else if (max < 0) { - ss << "The invocation upper bound must be >= 0, " - << "but is actually " << max << "."; - internal::Expect(false, __FILE__, __LINE__, ss.str()); - } else if (min > max) { - ss << "The invocation upper bound (" << max - << ") must be >= the invocation lower bound (" << min - << ")."; - internal::Expect(false, __FILE__, __LINE__, ss.str()); - } - } - - // Conservative estimate on the lower/upper bound of the number of - // calls allowed. - int ConservativeLowerBound() const override { return min_; } - int ConservativeUpperBound() const override { return max_; } - - bool IsSatisfiedByCallCount(int call_count) const override { - return min_ <= call_count && call_count <= max_; - } - - bool IsSaturatedByCallCount(int call_count) const override { - return call_count >= max_; - } - - void DescribeTo(::std::ostream* os) const override; - - private: - const int min_; - const int max_; - - GTEST_DISALLOW_COPY_AND_ASSIGN_(BetweenCardinalityImpl); -}; - -// Formats "n times" in a human-friendly way. -inline std::string FormatTimes(int n) { - if (n == 1) { - return "once"; - } else if (n == 2) { - return "twice"; - } else { - std::stringstream ss; - ss << n << " times"; - return ss.str(); - } -} - -// Describes the Between(m, n) cardinality in human-friendly text. -void BetweenCardinalityImpl::DescribeTo(::std::ostream* os) const { - if (min_ == 0) { - if (max_ == 0) { - *os << "never called"; - } else if (max_ == INT_MAX) { - *os << "called any number of times"; - } else { - *os << "called at most " << FormatTimes(max_); - } - } else if (min_ == max_) { - *os << "called " << FormatTimes(min_); - } else if (max_ == INT_MAX) { - *os << "called at least " << FormatTimes(min_); - } else { - // 0 < min_ < max_ < INT_MAX - *os << "called between " << min_ << " and " << max_ << " times"; - } -} - -} // Unnamed namespace - -// Describes the given call count to an ostream. -void Cardinality::DescribeActualCallCountTo(int actual_call_count, - ::std::ostream* os) { - if (actual_call_count > 0) { - *os << "called " << FormatTimes(actual_call_count); - } else { - *os << "never called"; - } -} - -// Creates a cardinality that allows at least n calls. -GTEST_API_ Cardinality AtLeast(int n) { return Between(n, INT_MAX); } - -// Creates a cardinality that allows at most n calls. -GTEST_API_ Cardinality AtMost(int n) { return Between(0, n); } - -// Creates a cardinality that allows any number of calls. -GTEST_API_ Cardinality AnyNumber() { return AtLeast(0); } - -// Creates a cardinality that allows between min and max calls. -GTEST_API_ Cardinality Between(int min, int max) { - return Cardinality(new BetweenCardinalityImpl(min, max)); -} - -// Creates a cardinality that allows exactly n calls. -GTEST_API_ Cardinality Exactly(int n) { return Between(n, n); } - -} // namespace testing -// Copyright 2007, 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. - - -// Google Mock - a framework for writing C++ mock classes. -// -// This file defines some utilities useful for implementing Google -// Mock. They are subject to change without notice, so please DO NOT -// USE THEM IN USER CODE. - - -#include <ctype.h> -#include <ostream> // NOLINT -#include <string> - -namespace testing { -namespace internal { - -// Joins a vector of strings as if they are fields of a tuple; returns -// the joined string. -GTEST_API_ std::string JoinAsTuple(const Strings& fields) { - switch (fields.size()) { - case 0: - return ""; - case 1: - return fields[0]; - default: - std::string result = "(" + fields[0]; - for (size_t i = 1; i < fields.size(); i++) { - result += ", "; - result += fields[i]; - } - result += ")"; - return result; - } -} - -// 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 -// treated as one word. For example, both "FooBar123" and -// "foo_bar_123" are converted to "foo bar 123". -GTEST_API_ std::string ConvertIdentifierNameToWords(const char* id_name) { - std::string result; - char prev_char = '\0'; - for (const char* p = id_name; *p != '\0'; prev_char = *(p++)) { - // We don't care about the current locale as the input is - // guaranteed to be a valid C++ identifier name. - const bool starts_new_word = IsUpper(*p) || - (!IsAlpha(prev_char) && IsLower(*p)) || - (!IsDigit(prev_char) && IsDigit(*p)); - - if (IsAlNum(*p)) { - if (starts_new_word && result != "") - result += ' '; - result += ToLower(*p); - } - } - return result; -} - -// This class reports Google Mock failures as Google Test failures. A -// user can define another class in a similar fashion if they intend to -// use Google Mock with a testing framework other than Google Test. -class GoogleTestFailureReporter : public FailureReporterInterface { - public: - void ReportFailure(FailureType type, const char* file, int line, - const std::string& message) override { - AssertHelper(type == kFatal ? - TestPartResult::kFatalFailure : - TestPartResult::kNonFatalFailure, - file, - line, - message.c_str()) = Message(); - if (type == kFatal) { - posix::Abort(); - } - } -}; - -// Returns the global failure reporter. Will create a -// GoogleTestFailureReporter and return it the first time called. -GTEST_API_ FailureReporterInterface* GetFailureReporter() { - // Points to the global failure reporter used by Google Mock. gcc - // guarantees that the following use of failure_reporter is - // thread-safe. We may need to add additional synchronization to - // protect failure_reporter if we port Google Mock to other - // compilers. - static FailureReporterInterface* const failure_reporter = - new GoogleTestFailureReporter(); - return failure_reporter; -} - -// Protects global resources (stdout in particular) used by Log(). -static GTEST_DEFINE_STATIC_MUTEX_(g_log_mutex); - -// Returns true if and only if a log with the given severity is visible -// according to the --gmock_verbose flag. -GTEST_API_ bool LogIsVisible(LogSeverity severity) { - if (GMOCK_FLAG(verbose) == kInfoVerbosity) { - // Always show the log if --gmock_verbose=info. - return true; - } else if (GMOCK_FLAG(verbose) == kErrorVerbosity) { - // Always hide it if --gmock_verbose=error. - return false; - } else { - // If --gmock_verbose is neither "info" nor "error", we treat it - // as "warning" (its default value). - return severity == kWarning; - } -} - -// Prints the given message to stdout if and only if 'severity' >= the level -// specified by the --gmock_verbose flag. If stack_frames_to_skip >= -// 0, also prints the stack trace excluding the top -// stack_frames_to_skip frames. In opt mode, any positive -// 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 -// conservative. -GTEST_API_ void Log(LogSeverity severity, const std::string& message, - int stack_frames_to_skip) { - if (!LogIsVisible(severity)) - return; - - // Ensures that logs from different threads don't interleave. - MutexLock l(&g_log_mutex); - - if (severity == kWarning) { - // Prints a GMOCK WARNING marker to make the warnings easily searchable. - std::cout << "\nGMOCK WARNING:"; - } - // Pre-pends a new-line to message if it doesn't start with one. - if (message.empty() || message[0] != '\n') { - std::cout << "\n"; - } - std::cout << message; - if (stack_frames_to_skip >= 0) { -#ifdef NDEBUG - // In opt mode, we have to be conservative and skip no stack frame. - const int actual_to_skip = 0; -#else - // In dbg mode, we can do what the caller tell us to do (plus one - // for skipping this function's stack frame). - const int actual_to_skip = stack_frames_to_skip + 1; -#endif // NDEBUG - - // Appends a new-line to message if it doesn't end with one. - if (!message.empty() && *message.rbegin() != '\n') { - std::cout << "\n"; - } - std::cout << "Stack trace:\n" - << ::testing::internal::GetCurrentOsStackTraceExceptTop( - ::testing::UnitTest::GetInstance(), actual_to_skip); - } - std::cout << ::std::flush; -} - -GTEST_API_ WithoutMatchers GetWithoutMatchers() { return WithoutMatchers(); } - -GTEST_API_ void IllegalDoDefault(const char* file, int line) { - internal::Assert( - false, file, line, - "You are using DoDefault() inside a composite action like " - "DoAll() or WithArgs(). This is not supported for technical " - "reasons. Please instead spell out the default action, or " - "assign the default action to an Action variable and use " - "the variable in various places."); -} - -} // namespace internal -} // namespace testing -// Copyright 2007, 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. - - -// Google Mock - a framework for writing C++ mock classes. -// -// This file implements Matcher<const string&>, Matcher<string>, and -// utilities for defining matchers. - - -#include <string.h> -#include <iostream> -#include <sstream> -#include <string> - -namespace testing { -namespace internal { - -// Returns the description for a matcher defined using the MATCHER*() -// macro where the user-supplied description string is "", if -// 'negation' is false; otherwise returns the description of the -// negation of the matcher. 'param_values' contains a list of strings -// that are the print-out of the matcher's parameters. -GTEST_API_ std::string FormatMatcherDescription(bool negation, - const char* matcher_name, - const Strings& param_values) { - std::string result = ConvertIdentifierNameToWords(matcher_name); - if (param_values.size() >= 1) result += " " + JoinAsTuple(param_values); - return negation ? "not (" + result + ")" : result; -} - -// FindMaxBipartiteMatching and its helper class. -// -// Uses the well-known Ford-Fulkerson max flow method to find a maximum -// bipartite matching. Flow is considered to be from left to right. -// There is an implicit source node that is connected to all of the left -// nodes, and an implicit sink node that is connected to all of the -// right nodes. All edges have unit capacity. -// -// Neither the flow graph nor the residual flow graph are represented -// explicitly. Instead, they are implied by the information in 'graph' and -// a vector<int> called 'left_' whose elements are initialized to the -// value kUnused. This represents the initial state of the algorithm, -// where the flow graph is empty, and the residual flow graph has the -// following edges: -// - An edge from source to each left_ node -// - An edge from each right_ node to sink -// - An edge from each left_ node to each right_ node, if the -// corresponding edge exists in 'graph'. -// -// When the TryAugment() method adds a flow, it sets left_[l] = r for some -// nodes l and r. This induces the following changes: -// - The edges (source, l), (l, r), and (r, sink) are added to the -// flow graph. -// - The same three edges are removed from the residual flow graph. -// - The reverse edges (l, source), (r, l), and (sink, r) are added -// to the residual flow graph, which is a directional graph -// representing unused flow capacity. -// -// When the method augments a flow (moving left_[l] from some r1 to some -// other r2), this can be thought of as "undoing" the above steps with -// respect to r1 and "redoing" them with respect to r2. -// -// It bears repeating that the flow graph and residual flow graph are -// never represented explicitly, but can be derived by looking at the -// information in 'graph' and in left_. -// -// As an optimization, there is a second vector<int> called right_ which -// does not provide any new information. Instead, it enables more -// efficient queries about edges entering or leaving the right-side nodes -// of the flow or residual flow graphs. The following invariants are -// maintained: -// -// left[l] == kUnused or right[left[l]] == l -// right[r] == kUnused or left[right[r]] == r -// -// . [ source ] . -// . ||| . -// . ||| . -// . ||\--> left[0]=1 ---\ right[0]=-1 ----\ . -// . || | | . -// . |\---> left[1]=-1 \--> right[1]=0 ---\| . -// . | || . -// . \----> left[2]=2 ------> right[2]=2 --\|| . -// . ||| . -// . elements matchers vvv . -// . [ sink ] . -// -// See Also: -// [1] Cormen, et al (2001). "Section 26.2: The Ford-Fulkerson method". -// "Introduction to Algorithms (Second ed.)", pp. 651-664. -// [2] "Ford-Fulkerson algorithm", Wikipedia, -// 'http://en.wikipedia.org/wiki/Ford%E2%80%93Fulkerson_algorithm' -class MaxBipartiteMatchState { - public: - explicit MaxBipartiteMatchState(const MatchMatrix& graph) - : graph_(&graph), - left_(graph_->LhsSize(), kUnused), - right_(graph_->RhsSize(), kUnused) {} - - // Returns the edges of a maximal match, each in the form {left, right}. - ElementMatcherPairs Compute() { - // 'seen' is used for path finding { 0: unseen, 1: seen }. - ::std::vector<char> seen; - // Searches the residual flow graph for a path from each left node to - // the sink in the residual flow graph, and if one is found, add flow - // to the graph. It's okay to search through the left nodes once. The - // edge from the implicit source node to each previously-visited left - // node will have flow if that left node has any path to the sink - // whatsoever. Subsequent augmentations can only add flow to the - // network, and cannot take away that previous flow unit from the source. - // Since the source-to-left edge can only carry one flow unit (or, - // each element can be matched to only one matcher), there is no need - // to visit the left nodes more than once looking for augmented paths. - // The flow is known to be possible or impossible by looking at the - // node once. - for (size_t ilhs = 0; ilhs < graph_->LhsSize(); ++ilhs) { - // Reset the path-marking vector and try to find a path from - // source to sink starting at the left_[ilhs] node. - GTEST_CHECK_(left_[ilhs] == kUnused) - << "ilhs: " << ilhs << ", left_[ilhs]: " << left_[ilhs]; - // 'seen' initialized to 'graph_->RhsSize()' copies of 0. - seen.assign(graph_->RhsSize(), 0); - TryAugment(ilhs, &seen); - } - ElementMatcherPairs result; - for (size_t ilhs = 0; ilhs < left_.size(); ++ilhs) { - size_t irhs = left_[ilhs]; - if (irhs == kUnused) continue; - result.push_back(ElementMatcherPair(ilhs, irhs)); - } - return result; - } - - private: - static const size_t kUnused = static_cast<size_t>(-1); - - // Perform a depth-first search from left node ilhs to the sink. If a - // path is found, flow is added to the network by linking the left and - // right vector elements corresponding each segment of the path. - // Returns true if a path to sink was found, which means that a unit of - // flow was added to the network. The 'seen' vector elements correspond - // to right nodes and are marked to eliminate cycles from the search. - // - // Left nodes will only be explored at most once because they - // are accessible from at most one right node in the residual flow - // graph. - // - // Note that left_[ilhs] is the only element of left_ that TryAugment will - // potentially transition from kUnused to another value. Any other - // left_ element holding kUnused before TryAugment will be holding it - // when TryAugment returns. - // - bool TryAugment(size_t ilhs, ::std::vector<char>* seen) { - for (size_t irhs = 0; irhs < graph_->RhsSize(); ++irhs) { - if ((*seen)[irhs]) continue; - if (!graph_->HasEdge(ilhs, irhs)) continue; - // There's an available edge from ilhs to irhs. - (*seen)[irhs] = 1; - // Next a search is performed to determine whether - // this edge is a dead end or leads to the sink. - // - // right_[irhs] == kUnused means that there is residual flow from - // right node irhs to the sink, so we can use that to finish this - // flow path and return success. - // - // Otherwise there is residual flow to some ilhs. We push flow - // along that path and call ourselves recursively to see if this - // ultimately leads to sink. - if (right_[irhs] == kUnused || TryAugment(right_[irhs], seen)) { - // Add flow from left_[ilhs] to right_[irhs]. - left_[ilhs] = irhs; - right_[irhs] = ilhs; - return true; - } - } - return false; - } - - const MatchMatrix* graph_; // not owned - // Each element of the left_ vector represents a left hand side node - // (i.e. an element) and each element of right_ is a right hand side - // node (i.e. a matcher). The values in the left_ vector indicate - // outflow from that node to a node on the right_ side. The values - // in the right_ indicate inflow, and specify which left_ node is - // feeding that right_ node, if any. For example, left_[3] == 1 means - // there's a flow from element #3 to matcher #1. Such a flow would also - // be redundantly represented in the right_ vector as right_[1] == 3. - // Elements of left_ and right_ are either kUnused or mutually - // referent. Mutually referent means that left_[right_[i]] = i and - // right_[left_[i]] = i. - ::std::vector<size_t> left_; - ::std::vector<size_t> right_; -}; - -const size_t MaxBipartiteMatchState::kUnused; - -GTEST_API_ ElementMatcherPairs FindMaxBipartiteMatching(const MatchMatrix& g) { - return MaxBipartiteMatchState(g).Compute(); -} - -static void LogElementMatcherPairVec(const ElementMatcherPairs& pairs, - ::std::ostream* stream) { - typedef ElementMatcherPairs::const_iterator Iter; - ::std::ostream& os = *stream; - os << "{"; - const char* sep = ""; - for (Iter it = pairs.begin(); it != pairs.end(); ++it) { - os << sep << "\n (" - << "element #" << it->first << ", " - << "matcher #" << it->second << ")"; - sep = ","; - } - os << "\n}"; -} - -bool MatchMatrix::NextGraph() { - for (size_t ilhs = 0; ilhs < LhsSize(); ++ilhs) { - for (size_t irhs = 0; irhs < RhsSize(); ++irhs) { - char& b = matched_[SpaceIndex(ilhs, irhs)]; - if (!b) { - b = 1; - return true; - } - b = 0; - } - } - return false; -} - -void MatchMatrix::Randomize() { - for (size_t ilhs = 0; ilhs < LhsSize(); ++ilhs) { - for (size_t irhs = 0; irhs < RhsSize(); ++irhs) { - char& b = matched_[SpaceIndex(ilhs, irhs)]; - b = static_cast<char>(rand() & 1); // NOLINT - } - } -} - -std::string MatchMatrix::DebugString() const { - ::std::stringstream ss; - const char* sep = ""; - for (size_t i = 0; i < LhsSize(); ++i) { - ss << sep; - for (size_t j = 0; j < RhsSize(); ++j) { - ss << HasEdge(i, j); - } - sep = ";"; - } - return ss.str(); -} - -void UnorderedElementsAreMatcherImplBase::DescribeToImpl( - ::std::ostream* os) const { - switch (match_flags()) { - case UnorderedMatcherRequire::ExactMatch: - if (matcher_describers_.empty()) { - *os << "is empty"; - return; - } - if (matcher_describers_.size() == 1) { - *os << "has " << Elements(1) << " and that element "; - matcher_describers_[0]->DescribeTo(os); - return; - } - *os << "has " << Elements(matcher_describers_.size()) - << " and there exists some permutation of elements such that:\n"; - break; - case UnorderedMatcherRequire::Superset: - *os << "a surjection from elements to requirements exists such that:\n"; - break; - case UnorderedMatcherRequire::Subset: - *os << "an injection from elements to requirements exists such that:\n"; - break; - } - - const char* sep = ""; - for (size_t i = 0; i != matcher_describers_.size(); ++i) { - *os << sep; - if (match_flags() == UnorderedMatcherRequire::ExactMatch) { - *os << " - element #" << i << " "; - } else { - *os << " - an element "; - } - matcher_describers_[i]->DescribeTo(os); - if (match_flags() == UnorderedMatcherRequire::ExactMatch) { - sep = ", and\n"; - } else { - sep = "\n"; - } - } -} - -void UnorderedElementsAreMatcherImplBase::DescribeNegationToImpl( - ::std::ostream* os) const { - switch (match_flags()) { - case UnorderedMatcherRequire::ExactMatch: - if (matcher_describers_.empty()) { - *os << "isn't empty"; - return; - } - if (matcher_describers_.size() == 1) { - *os << "doesn't have " << Elements(1) << ", or has " << Elements(1) - << " that "; - matcher_describers_[0]->DescribeNegationTo(os); - return; - } - *os << "doesn't have " << Elements(matcher_describers_.size()) - << ", or there exists no permutation of elements such that:\n"; - break; - case UnorderedMatcherRequire::Superset: - *os << "no surjection from elements to requirements exists such that:\n"; - break; - case UnorderedMatcherRequire::Subset: - *os << "no injection from elements to requirements exists such that:\n"; - break; - } - const char* sep = ""; - for (size_t i = 0; i != matcher_describers_.size(); ++i) { - *os << sep; - if (match_flags() == UnorderedMatcherRequire::ExactMatch) { - *os << " - element #" << i << " "; - } else { - *os << " - an element "; - } - matcher_describers_[i]->DescribeTo(os); - if (match_flags() == UnorderedMatcherRequire::ExactMatch) { - sep = ", and\n"; - } else { - sep = "\n"; - } - } -} - -// Checks that all matchers match at least one element, and that all -// elements match at least one matcher. This enables faster matching -// and better error reporting. -// Returns false, writing an explanation to 'listener', if and only -// if the success criteria are not met. -bool UnorderedElementsAreMatcherImplBase::VerifyMatchMatrix( - const ::std::vector<std::string>& element_printouts, - const MatchMatrix& matrix, MatchResultListener* listener) const { - bool result = true; - ::std::vector<char> element_matched(matrix.LhsSize(), 0); - ::std::vector<char> matcher_matched(matrix.RhsSize(), 0); - - for (size_t ilhs = 0; ilhs < matrix.LhsSize(); ilhs++) { - for (size_t irhs = 0; irhs < matrix.RhsSize(); irhs++) { - char matched = matrix.HasEdge(ilhs, irhs); - element_matched[ilhs] |= matched; - matcher_matched[irhs] |= matched; - } - } - - if (match_flags() & UnorderedMatcherRequire::Superset) { - const char* sep = - "where the following matchers don't match any elements:\n"; - for (size_t mi = 0; mi < matcher_matched.size(); ++mi) { - if (matcher_matched[mi]) continue; - result = false; - if (listener->IsInterested()) { - *listener << sep << "matcher #" << mi << ": "; - matcher_describers_[mi]->DescribeTo(listener->stream()); - sep = ",\n"; - } - } - } - - if (match_flags() & UnorderedMatcherRequire::Subset) { - const char* sep = - "where the following elements don't match any matchers:\n"; - const char* outer_sep = ""; - if (!result) { - outer_sep = "\nand "; - } - for (size_t ei = 0; ei < element_matched.size(); ++ei) { - if (element_matched[ei]) continue; - result = false; - if (listener->IsInterested()) { - *listener << outer_sep << sep << "element #" << ei << ": " - << element_printouts[ei]; - sep = ",\n"; - outer_sep = ""; - } - } - } - return result; -} - -bool UnorderedElementsAreMatcherImplBase::FindPairing( - const MatchMatrix& matrix, MatchResultListener* listener) const { - ElementMatcherPairs matches = FindMaxBipartiteMatching(matrix); - - size_t max_flow = matches.size(); - if ((match_flags() & UnorderedMatcherRequire::Superset) && - max_flow < matrix.RhsSize()) { - if (listener->IsInterested()) { - *listener << "where no permutation of the elements can satisfy all " - "matchers, and the closest match is " - << max_flow << " of " << matrix.RhsSize() - << " matchers with the pairings:\n"; - LogElementMatcherPairVec(matches, listener->stream()); - } - return false; - } - if ((match_flags() & UnorderedMatcherRequire::Subset) && - max_flow < matrix.LhsSize()) { - if (listener->IsInterested()) { - *listener - << "where not all elements can be matched, and the closest match is " - << max_flow << " of " << matrix.RhsSize() - << " matchers with the pairings:\n"; - LogElementMatcherPairVec(matches, listener->stream()); - } - return false; - } - - if (matches.size() > 1) { - if (listener->IsInterested()) { - const char* sep = "where:\n"; - for (size_t mi = 0; mi < matches.size(); ++mi) { - *listener << sep << " - element #" << matches[mi].first - << " is matched by matcher #" << matches[mi].second; - sep = ",\n"; - } - } - } - return true; -} - -} // namespace internal -} // namespace testing -// Copyright 2007, 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. - - -// Google Mock - a framework for writing C++ mock classes. -// -// This file implements the spec builder syntax (ON_CALL and -// EXPECT_CALL). - - -#include <stdlib.h> - -#include <iostream> // NOLINT -#include <map> -#include <memory> -#include <set> -#include <string> -#include <unordered_map> -#include <vector> - - -#if GTEST_OS_CYGWIN || GTEST_OS_LINUX || GTEST_OS_MAC -# include <unistd.h> // NOLINT -#endif - -// Silence C4800 (C4800: 'int *const ': forcing value -// to bool 'true' or 'false') for MSVC 15 -#ifdef _MSC_VER -#if _MSC_VER == 1900 -# pragma warning(push) -# pragma warning(disable:4800) -#endif -#endif - -namespace testing { -namespace internal { - -// Protects the mock object registry (in class Mock), all function -// mockers, and all expectations. -GTEST_API_ GTEST_DEFINE_STATIC_MUTEX_(g_gmock_mutex); - -// Logs a message including file and line number information. -GTEST_API_ void LogWithLocation(testing::internal::LogSeverity severity, - const char* file, int line, - const std::string& message) { - ::std::ostringstream s; - s << internal::FormatFileLocation(file, line) << " " << message - << ::std::endl; - Log(severity, s.str(), 0); -} - -// Constructs an ExpectationBase object. -ExpectationBase::ExpectationBase(const char* a_file, int a_line, - const std::string& a_source_text) - : file_(a_file), - line_(a_line), - source_text_(a_source_text), - cardinality_specified_(false), - cardinality_(Exactly(1)), - call_count_(0), - retired_(false), - extra_matcher_specified_(false), - repeated_action_specified_(false), - retires_on_saturation_(false), - last_clause_(kNone), - action_count_checked_(false) {} - -// Destructs an ExpectationBase object. -ExpectationBase::~ExpectationBase() {} - -// Explicitly specifies the cardinality of this expectation. Used by -// the subclasses to implement the .Times() clause. -void ExpectationBase::SpecifyCardinality(const Cardinality& a_cardinality) { - cardinality_specified_ = true; - cardinality_ = a_cardinality; -} - -// Retires all pre-requisites of this expectation. -void ExpectationBase::RetireAllPreRequisites() - GTEST_EXCLUSIVE_LOCK_REQUIRED_(g_gmock_mutex) { - if (is_retired()) { - // We can take this short-cut as we never retire an expectation - // until we have retired all its pre-requisites. - return; - } - - ::std::vector<ExpectationBase*> expectations(1, this); - while (!expectations.empty()) { - ExpectationBase* exp = expectations.back(); - expectations.pop_back(); - - for (ExpectationSet::const_iterator it = - exp->immediate_prerequisites_.begin(); - it != exp->immediate_prerequisites_.end(); ++it) { - ExpectationBase* next = it->expectation_base().get(); - if (!next->is_retired()) { - next->Retire(); - expectations.push_back(next); - } - } - } -} - -// Returns true if and only if all pre-requisites of this expectation -// have been satisfied. -bool ExpectationBase::AllPrerequisitesAreSatisfied() const - GTEST_EXCLUSIVE_LOCK_REQUIRED_(g_gmock_mutex) { - g_gmock_mutex.AssertHeld(); - ::std::vector<const ExpectationBase*> expectations(1, this); - while (!expectations.empty()) { - const ExpectationBase* exp = expectations.back(); - expectations.pop_back(); - - for (ExpectationSet::const_iterator it = - exp->immediate_prerequisites_.begin(); - it != exp->immediate_prerequisites_.end(); ++it) { - const ExpectationBase* next = it->expectation_base().get(); - if (!next->IsSatisfied()) return false; - expectations.push_back(next); - } - } - return true; -} - -// Adds unsatisfied pre-requisites of this expectation to 'result'. -void ExpectationBase::FindUnsatisfiedPrerequisites(ExpectationSet* result) const - GTEST_EXCLUSIVE_LOCK_REQUIRED_(g_gmock_mutex) { - g_gmock_mutex.AssertHeld(); - ::std::vector<const ExpectationBase*> expectations(1, this); - while (!expectations.empty()) { - const ExpectationBase* exp = expectations.back(); - expectations.pop_back(); - - for (ExpectationSet::const_iterator it = - exp->immediate_prerequisites_.begin(); - it != exp->immediate_prerequisites_.end(); ++it) { - const ExpectationBase* next = it->expectation_base().get(); - - if (next->IsSatisfied()) { - // If *it is satisfied and has a call count of 0, some of its - // pre-requisites may not be satisfied yet. - if (next->call_count_ == 0) { - expectations.push_back(next); - } - } else { - // Now that we know next is unsatisfied, we are not so interested - // in whether its pre-requisites are satisfied. Therefore we - // don't iterate into it here. - *result += *it; - } - } - } -} - -// Describes how many times a function call matching this -// expectation has occurred. -void ExpectationBase::DescribeCallCountTo(::std::ostream* os) const - GTEST_EXCLUSIVE_LOCK_REQUIRED_(g_gmock_mutex) { - g_gmock_mutex.AssertHeld(); - - // Describes how many times the function is expected to be called. - *os << " Expected: to be "; - cardinality().DescribeTo(os); - *os << "\n Actual: "; - Cardinality::DescribeActualCallCountTo(call_count(), os); - - // Describes the state of the expectation (e.g. is it satisfied? - // is it active?). - *os << " - " << (IsOverSaturated() ? "over-saturated" : - IsSaturated() ? "saturated" : - IsSatisfied() ? "satisfied" : "unsatisfied") - << " and " - << (is_retired() ? "retired" : "active"); -} - -// Checks the action count (i.e. the number of WillOnce() and -// WillRepeatedly() clauses) against the cardinality if this hasn't -// been done before. Prints a warning if there are too many or too -// few actions. -void ExpectationBase::CheckActionCountIfNotDone() const - GTEST_LOCK_EXCLUDED_(mutex_) { - bool should_check = false; - { - MutexLock l(&mutex_); - if (!action_count_checked_) { - action_count_checked_ = true; - should_check = true; - } - } - - if (should_check) { - if (!cardinality_specified_) { - // The cardinality was inferred - no need to check the action - // count against it. - return; - } - - // The cardinality was explicitly specified. - const int action_count = static_cast<int>(untyped_actions_.size()); - const int upper_bound = cardinality().ConservativeUpperBound(); - const int lower_bound = cardinality().ConservativeLowerBound(); - bool too_many; // True if there are too many actions, or false - // if there are too few. - if (action_count > upper_bound || - (action_count == upper_bound && repeated_action_specified_)) { - too_many = true; - } else if (0 < action_count && action_count < lower_bound && - !repeated_action_specified_) { - too_many = false; - } else { - return; - } - - ::std::stringstream ss; - DescribeLocationTo(&ss); - ss << "Too " << (too_many ? "many" : "few") - << " actions specified in " << source_text() << "...\n" - << "Expected to be "; - cardinality().DescribeTo(&ss); - ss << ", but has " << (too_many ? "" : "only ") - << action_count << " WillOnce()" - << (action_count == 1 ? "" : "s"); - if (repeated_action_specified_) { - ss << " and a WillRepeatedly()"; - } - ss << "."; - Log(kWarning, ss.str(), -1); // -1 means "don't print stack trace". - } -} - -// Implements the .Times() clause. -void ExpectationBase::UntypedTimes(const Cardinality& a_cardinality) { - if (last_clause_ == kTimes) { - ExpectSpecProperty(false, - ".Times() cannot appear " - "more than once in an EXPECT_CALL()."); - } else { - ExpectSpecProperty(last_clause_ < kTimes, - ".Times() cannot appear after " - ".InSequence(), .WillOnce(), .WillRepeatedly(), " - "or .RetiresOnSaturation()."); - } - last_clause_ = kTimes; - - SpecifyCardinality(a_cardinality); -} - -// Points to the implicit sequence introduced by a living InSequence -// object (if any) in the current thread or NULL. -GTEST_API_ ThreadLocal<Sequence*> g_gmock_implicit_sequence; - -// Reports an uninteresting call (whose description is in msg) in the -// manner specified by 'reaction'. -void ReportUninterestingCall(CallReaction reaction, const std::string& msg) { - // Include a stack trace only if --gmock_verbose=info is specified. - const int stack_frames_to_skip = - GMOCK_FLAG(verbose) == kInfoVerbosity ? 3 : -1; - switch (reaction) { - case kAllow: - Log(kInfo, msg, stack_frames_to_skip); - break; - case kWarn: - Log(kWarning, - msg + - "\nNOTE: You can safely ignore the above warning unless this " - "call should not happen. Do not suppress it by blindly adding " - "an EXPECT_CALL() if you don't mean to enforce the call. " - "See " - "https://github.com/google/googletest/blob/master/docs/" - "gmock_cook_book.md#" - "knowing-when-to-expect for details.\n", - stack_frames_to_skip); - break; - default: // FAIL - Expect(false, nullptr, -1, msg); - } -} - -UntypedFunctionMockerBase::UntypedFunctionMockerBase() - : mock_obj_(nullptr), name_("") {} - -UntypedFunctionMockerBase::~UntypedFunctionMockerBase() {} - -// Sets the mock object this mock method belongs to, and registers -// this information in the global mock registry. Will be called -// whenever an EXPECT_CALL() or ON_CALL() is executed on this mock -// method. -void UntypedFunctionMockerBase::RegisterOwner(const void* mock_obj) - GTEST_LOCK_EXCLUDED_(g_gmock_mutex) { - { - MutexLock l(&g_gmock_mutex); - mock_obj_ = mock_obj; - } - Mock::Register(mock_obj, this); -} - -// Sets the mock object this mock method belongs to, and sets the name -// of the mock function. Will be called upon each invocation of this -// mock function. -void UntypedFunctionMockerBase::SetOwnerAndName(const void* mock_obj, - const char* name) - GTEST_LOCK_EXCLUDED_(g_gmock_mutex) { - // We protect name_ under g_gmock_mutex in case this mock function - // is called from two threads concurrently. - MutexLock l(&g_gmock_mutex); - mock_obj_ = mock_obj; - name_ = name; -} - -// Returns the name of the function being mocked. Must be called -// after RegisterOwner() or SetOwnerAndName() has been called. -const void* UntypedFunctionMockerBase::MockObject() const - GTEST_LOCK_EXCLUDED_(g_gmock_mutex) { - const void* mock_obj; - { - // We protect mock_obj_ under g_gmock_mutex in case this mock - // function is called from two threads concurrently. - MutexLock l(&g_gmock_mutex); - Assert(mock_obj_ != nullptr, __FILE__, __LINE__, - "MockObject() must not be called before RegisterOwner() or " - "SetOwnerAndName() has been called."); - mock_obj = mock_obj_; - } - return mock_obj; -} - -// Returns the name of this mock method. Must be called after -// SetOwnerAndName() has been called. -const char* UntypedFunctionMockerBase::Name() const - GTEST_LOCK_EXCLUDED_(g_gmock_mutex) { - const char* name; - { - // We protect name_ under g_gmock_mutex in case this mock - // function is called from two threads concurrently. - MutexLock l(&g_gmock_mutex); - Assert(name_ != nullptr, __FILE__, __LINE__, - "Name() must not be called before SetOwnerAndName() has " - "been called."); - name = name_; - } - return name; -} - -// Calculates the result of invoking this mock function with the given -// arguments, prints it, and returns it. The caller is responsible -// for deleting the result. -UntypedActionResultHolderBase* UntypedFunctionMockerBase::UntypedInvokeWith( - void* const untyped_args) GTEST_LOCK_EXCLUDED_(g_gmock_mutex) { - // See the definition of untyped_expectations_ for why access to it - // is unprotected here. - if (untyped_expectations_.size() == 0) { - // No expectation is set on this mock method - we have an - // uninteresting call. - - // We must get Google Mock's reaction on uninteresting calls - // made on this mock object BEFORE performing the action, - // because the action may DELETE the mock object and make the - // following expression meaningless. - const CallReaction reaction = - Mock::GetReactionOnUninterestingCalls(MockObject()); - - // True if and only if we need to print this call's arguments and return - // value. This definition must be kept in sync with - // the behavior of ReportUninterestingCall(). - const bool need_to_report_uninteresting_call = - // If the user allows this uninteresting call, we print it - // only when they want informational messages. - reaction == kAllow ? LogIsVisible(kInfo) : - // If the user wants this to be a warning, we print - // it only when they want to see warnings. - reaction == kWarn - ? LogIsVisible(kWarning) - : - // Otherwise, the user wants this to be an error, and we - // should always print detailed information in the error. - true; - - if (!need_to_report_uninteresting_call) { - // Perform the action without printing the call information. - return this->UntypedPerformDefaultAction( - untyped_args, "Function call: " + std::string(Name())); - } - - // Warns about the uninteresting call. - ::std::stringstream ss; - this->UntypedDescribeUninterestingCall(untyped_args, &ss); - - // Calculates the function result. - UntypedActionResultHolderBase* const result = - this->UntypedPerformDefaultAction(untyped_args, ss.str()); - - // Prints the function result. - if (result != nullptr) result->PrintAsActionResult(&ss); - - ReportUninterestingCall(reaction, ss.str()); - return result; - } - - bool is_excessive = false; - ::std::stringstream ss; - ::std::stringstream why; - ::std::stringstream loc; - const void* untyped_action = nullptr; - - // The UntypedFindMatchingExpectation() function acquires and - // releases g_gmock_mutex. - - const ExpectationBase* const untyped_expectation = - this->UntypedFindMatchingExpectation(untyped_args, &untyped_action, - &is_excessive, &ss, &why); - const bool found = untyped_expectation != nullptr; - - // True if and only if we need to print the call's arguments - // and return value. - // This definition must be kept in sync with the uses of Expect() - // and Log() in this function. - const bool need_to_report_call = - !found || is_excessive || LogIsVisible(kInfo); - if (!need_to_report_call) { - // Perform the action without printing the call information. - return untyped_action == nullptr - ? this->UntypedPerformDefaultAction(untyped_args, "") - : this->UntypedPerformAction(untyped_action, untyped_args); - } - - ss << " Function call: " << Name(); - this->UntypedPrintArgs(untyped_args, &ss); - - // In case the action deletes a piece of the expectation, we - // generate the message beforehand. - if (found && !is_excessive) { - untyped_expectation->DescribeLocationTo(&loc); - } - - UntypedActionResultHolderBase* result = nullptr; - - auto perform_action = [&, this] { - return untyped_action == nullptr - ? this->UntypedPerformDefaultAction(untyped_args, ss.str()) - : this->UntypedPerformAction(untyped_action, untyped_args); - }; - auto handle_failures = [&] { - ss << "\n" << why.str(); - - if (!found) { - // No expectation matches this call - reports a failure. - Expect(false, nullptr, -1, ss.str()); - } else if (is_excessive) { - // We had an upper-bound violation and the failure message is in ss. - Expect(false, untyped_expectation->file(), untyped_expectation->line(), - ss.str()); - } else { - // We had an expected call and the matching expectation is - // described in ss. - Log(kInfo, loc.str() + ss.str(), 2); - } - }; -#if GTEST_HAS_EXCEPTIONS - try { - result = perform_action(); - } catch (...) { - handle_failures(); - throw; - } -#else - result = perform_action(); -#endif - - if (result != nullptr) result->PrintAsActionResult(&ss); - handle_failures(); - return result; -} - -// Returns an Expectation object that references and co-owns exp, -// which must be an expectation on this mock function. -Expectation UntypedFunctionMockerBase::GetHandleOf(ExpectationBase* exp) { - // See the definition of untyped_expectations_ for why access to it - // is unprotected here. - for (UntypedExpectations::const_iterator it = - untyped_expectations_.begin(); - it != untyped_expectations_.end(); ++it) { - if (it->get() == exp) { - return Expectation(*it); - } - } - - Assert(false, __FILE__, __LINE__, "Cannot find expectation."); - return Expectation(); - // The above statement is just to make the code compile, and will - // never be executed. -} - -// Verifies that all expectations on this mock function have been -// satisfied. Reports one or more Google Test non-fatal failures -// and returns false if not. -bool UntypedFunctionMockerBase::VerifyAndClearExpectationsLocked() - GTEST_EXCLUSIVE_LOCK_REQUIRED_(g_gmock_mutex) { - g_gmock_mutex.AssertHeld(); - bool expectations_met = true; - for (UntypedExpectations::const_iterator it = - untyped_expectations_.begin(); - it != untyped_expectations_.end(); ++it) { - ExpectationBase* const untyped_expectation = it->get(); - if (untyped_expectation->IsOverSaturated()) { - // There was an upper-bound violation. Since the error was - // already reported when it occurred, there is no need to do - // anything here. - expectations_met = false; - } else if (!untyped_expectation->IsSatisfied()) { - expectations_met = false; - ::std::stringstream ss; - ss << "Actual function call count doesn't match " - << untyped_expectation->source_text() << "...\n"; - // No need to show the source file location of the expectation - // in the description, as the Expect() call that follows already - // takes care of it. - untyped_expectation->MaybeDescribeExtraMatcherTo(&ss); - untyped_expectation->DescribeCallCountTo(&ss); - Expect(false, untyped_expectation->file(), - untyped_expectation->line(), ss.str()); - } - } - - // Deleting our expectations may trigger other mock objects to be deleted, for - // example if an action contains a reference counted smart pointer to that - // mock object, and that is the last reference. So if we delete our - // expectations within the context of the global mutex we may deadlock when - // this method is called again. Instead, make a copy of the set of - // expectations to delete, clear our set within the mutex, and then clear the - // copied set outside of it. - UntypedExpectations expectations_to_delete; - untyped_expectations_.swap(expectations_to_delete); - - g_gmock_mutex.Unlock(); - expectations_to_delete.clear(); - g_gmock_mutex.Lock(); - - return expectations_met; -} - -CallReaction intToCallReaction(int mock_behavior) { - if (mock_behavior >= kAllow && mock_behavior <= kFail) { - return static_cast<internal::CallReaction>(mock_behavior); - } - return kWarn; -} - -} // namespace internal - -// Class Mock. - -namespace { - -typedef std::set<internal::UntypedFunctionMockerBase*> FunctionMockers; - -// The current state of a mock object. Such information is needed for -// detecting leaked mock objects and explicitly verifying a mock's -// expectations. -struct MockObjectState { - MockObjectState() - : first_used_file(nullptr), first_used_line(-1), leakable(false) {} - - // Where in the source file an ON_CALL or EXPECT_CALL is first - // invoked on this mock object. - const char* first_used_file; - int first_used_line; - ::std::string first_used_test_suite; - ::std::string first_used_test; - bool leakable; // true if and only if it's OK to leak the object. - FunctionMockers function_mockers; // All registered methods of the object. -}; - -// A global registry holding the state of all mock objects that are -// alive. A mock object is added to this registry the first time -// Mock::AllowLeak(), ON_CALL(), or EXPECT_CALL() is called on it. It -// is removed from the registry in the mock object's destructor. -class MockObjectRegistry { - public: - // Maps a mock object (identified by its address) to its state. - typedef std::map<const void*, MockObjectState> StateMap; - - // This destructor will be called when a program exits, after all - // tests in it have been run. By then, there should be no mock - // object alive. Therefore we report any living object as test - // failure, unless the user explicitly asked us to ignore it. - ~MockObjectRegistry() { - if (!GMOCK_FLAG(catch_leaked_mocks)) - return; - - int leaked_count = 0; - for (StateMap::const_iterator it = states_.begin(); it != states_.end(); - ++it) { - if (it->second.leakable) // The user said it's fine to leak this object. - continue; - - // FIXME: Print the type of the leaked object. - // This can help the user identify the leaked object. - std::cout << "\n"; - const MockObjectState& state = it->second; - std::cout << internal::FormatFileLocation(state.first_used_file, - state.first_used_line); - std::cout << " ERROR: this mock object"; - if (state.first_used_test != "") { - std::cout << " (used in test " << state.first_used_test_suite << "." - << state.first_used_test << ")"; - } - std::cout << " should be deleted but never is. Its address is @" - << it->first << "."; - leaked_count++; - } - if (leaked_count > 0) { - std::cout << "\nERROR: " << leaked_count << " leaked mock " - << (leaked_count == 1 ? "object" : "objects") - << " found at program exit. Expectations on a mock object are " - "verified when the object is destructed. Leaking a mock " - "means that its expectations aren't verified, which is " - "usually a test bug. If you really intend to leak a mock, " - "you can suppress this error using " - "testing::Mock::AllowLeak(mock_object), or you may use a " - "fake or stub instead of a mock.\n"; - std::cout.flush(); - ::std::cerr.flush(); - // RUN_ALL_TESTS() has already returned when this destructor is - // called. Therefore we cannot use the normal Google Test - // failure reporting mechanism. - _exit(1); // We cannot call exit() as it is not reentrant and - // may already have been called. - } - } - - StateMap& states() { return states_; } - - private: - StateMap states_; -}; - -// Protected by g_gmock_mutex. -MockObjectRegistry g_mock_object_registry; - -// Maps a mock object to the reaction Google Mock should have when an -// uninteresting method is called. Protected by g_gmock_mutex. -std::unordered_map<uintptr_t, internal::CallReaction>& -UninterestingCallReactionMap() { - static auto* map = new std::unordered_map<uintptr_t, internal::CallReaction>; - return *map; -} - -// Sets the reaction Google Mock should have when an uninteresting -// method of the given mock object is called. -void SetReactionOnUninterestingCalls(uintptr_t mock_obj, - internal::CallReaction reaction) - GTEST_LOCK_EXCLUDED_(internal::g_gmock_mutex) { - internal::MutexLock l(&internal::g_gmock_mutex); - UninterestingCallReactionMap()[mock_obj] = reaction; -} - -} // namespace - -// Tells Google Mock to allow uninteresting calls on the given mock -// object. -void Mock::AllowUninterestingCalls(uintptr_t mock_obj) - GTEST_LOCK_EXCLUDED_(internal::g_gmock_mutex) { - SetReactionOnUninterestingCalls(mock_obj, internal::kAllow); -} - -// Tells Google Mock to warn the user about uninteresting calls on the -// given mock object. -void Mock::WarnUninterestingCalls(uintptr_t mock_obj) - GTEST_LOCK_EXCLUDED_(internal::g_gmock_mutex) { - SetReactionOnUninterestingCalls(mock_obj, internal::kWarn); -} - -// Tells Google Mock to fail uninteresting calls on the given mock -// object. -void Mock::FailUninterestingCalls(uintptr_t mock_obj) - GTEST_LOCK_EXCLUDED_(internal::g_gmock_mutex) { - SetReactionOnUninterestingCalls(mock_obj, internal::kFail); -} - -// Tells Google Mock the given mock object is being destroyed and its -// entry in the call-reaction table should be removed. -void Mock::UnregisterCallReaction(uintptr_t mock_obj) - GTEST_LOCK_EXCLUDED_(internal::g_gmock_mutex) { - internal::MutexLock l(&internal::g_gmock_mutex); - UninterestingCallReactionMap().erase(static_cast<uintptr_t>(mock_obj)); -} - -// Returns the reaction Google Mock will have on uninteresting calls -// made on the given mock object. -internal::CallReaction Mock::GetReactionOnUninterestingCalls( - const void* mock_obj) - GTEST_LOCK_EXCLUDED_(internal::g_gmock_mutex) { - internal::MutexLock l(&internal::g_gmock_mutex); - return (UninterestingCallReactionMap().count( - reinterpret_cast<uintptr_t>(mock_obj)) == 0) - ? internal::intToCallReaction( - GMOCK_FLAG(default_mock_behavior)) - : UninterestingCallReactionMap()[reinterpret_cast<uintptr_t>( - mock_obj)]; -} - -// Tells Google Mock to ignore mock_obj when checking for leaked mock -// objects. -void Mock::AllowLeak(const void* mock_obj) - GTEST_LOCK_EXCLUDED_(internal::g_gmock_mutex) { - internal::MutexLock l(&internal::g_gmock_mutex); - g_mock_object_registry.states()[mock_obj].leakable = true; -} - -// Verifies and clears all expectations on the given mock object. If -// the expectations aren't satisfied, generates one or more Google -// Test non-fatal failures and returns false. -bool Mock::VerifyAndClearExpectations(void* mock_obj) - GTEST_LOCK_EXCLUDED_(internal::g_gmock_mutex) { - internal::MutexLock l(&internal::g_gmock_mutex); - return VerifyAndClearExpectationsLocked(mock_obj); -} - -// Verifies all expectations on the given mock object and clears its -// default actions and expectations. Returns true if and only if the -// verification was successful. -bool Mock::VerifyAndClear(void* mock_obj) - GTEST_LOCK_EXCLUDED_(internal::g_gmock_mutex) { - internal::MutexLock l(&internal::g_gmock_mutex); - ClearDefaultActionsLocked(mock_obj); - return VerifyAndClearExpectationsLocked(mock_obj); -} - -// Verifies and clears all expectations on the given mock object. If -// the expectations aren't satisfied, generates one or more Google -// Test non-fatal failures and returns false. -bool Mock::VerifyAndClearExpectationsLocked(void* mock_obj) - GTEST_EXCLUSIVE_LOCK_REQUIRED_(internal::g_gmock_mutex) { - internal::g_gmock_mutex.AssertHeld(); - if (g_mock_object_registry.states().count(mock_obj) == 0) { - // No EXPECT_CALL() was set on the given mock object. - return true; - } - - // Verifies and clears the expectations on each mock method in the - // given mock object. - bool expectations_met = true; - FunctionMockers& mockers = - g_mock_object_registry.states()[mock_obj].function_mockers; - for (FunctionMockers::const_iterator it = mockers.begin(); - it != mockers.end(); ++it) { - if (!(*it)->VerifyAndClearExpectationsLocked()) { - expectations_met = false; - } - } - - // We don't clear the content of mockers, as they may still be - // needed by ClearDefaultActionsLocked(). - return expectations_met; -} - -bool Mock::IsNaggy(void* mock_obj) - GTEST_LOCK_EXCLUDED_(internal::g_gmock_mutex) { - return Mock::GetReactionOnUninterestingCalls(mock_obj) == internal::kWarn; -} -bool Mock::IsNice(void* mock_obj) - GTEST_LOCK_EXCLUDED_(internal::g_gmock_mutex) { - return Mock::GetReactionOnUninterestingCalls(mock_obj) == internal::kAllow; -} -bool Mock::IsStrict(void* mock_obj) - GTEST_LOCK_EXCLUDED_(internal::g_gmock_mutex) { - return Mock::GetReactionOnUninterestingCalls(mock_obj) == internal::kFail; -} - -// Registers a mock object and a mock method it owns. -void Mock::Register(const void* mock_obj, - internal::UntypedFunctionMockerBase* mocker) - GTEST_LOCK_EXCLUDED_(internal::g_gmock_mutex) { - internal::MutexLock l(&internal::g_gmock_mutex); - g_mock_object_registry.states()[mock_obj].function_mockers.insert(mocker); -} - -// Tells Google Mock where in the source code mock_obj is used in an -// ON_CALL or EXPECT_CALL. In case mock_obj is leaked, this -// information helps the user identify which object it is. -void Mock::RegisterUseByOnCallOrExpectCall(const void* mock_obj, - const char* file, int line) - GTEST_LOCK_EXCLUDED_(internal::g_gmock_mutex) { - internal::MutexLock l(&internal::g_gmock_mutex); - MockObjectState& state = g_mock_object_registry.states()[mock_obj]; - if (state.first_used_file == nullptr) { - state.first_used_file = file; - state.first_used_line = line; - const TestInfo* const test_info = - UnitTest::GetInstance()->current_test_info(); - if (test_info != nullptr) { - state.first_used_test_suite = test_info->test_suite_name(); - state.first_used_test = test_info->name(); - } - } -} - -// Unregisters a mock method; removes the owning mock object from the -// registry when the last mock method associated with it has been -// unregistered. This is called only in the destructor of -// FunctionMockerBase. -void Mock::UnregisterLocked(internal::UntypedFunctionMockerBase* mocker) - GTEST_EXCLUSIVE_LOCK_REQUIRED_(internal::g_gmock_mutex) { - internal::g_gmock_mutex.AssertHeld(); - for (MockObjectRegistry::StateMap::iterator it = - g_mock_object_registry.states().begin(); - it != g_mock_object_registry.states().end(); ++it) { - FunctionMockers& mockers = it->second.function_mockers; - if (mockers.erase(mocker) > 0) { - // mocker was in mockers and has been just removed. - if (mockers.empty()) { - g_mock_object_registry.states().erase(it); - } - return; - } - } -} - -// Clears all ON_CALL()s set on the given mock object. -void Mock::ClearDefaultActionsLocked(void* mock_obj) - GTEST_EXCLUSIVE_LOCK_REQUIRED_(internal::g_gmock_mutex) { - internal::g_gmock_mutex.AssertHeld(); - - if (g_mock_object_registry.states().count(mock_obj) == 0) { - // No ON_CALL() was set on the given mock object. - return; - } - - // Clears the default actions for each mock method in the given mock - // object. - FunctionMockers& mockers = - g_mock_object_registry.states()[mock_obj].function_mockers; - for (FunctionMockers::const_iterator it = mockers.begin(); - it != mockers.end(); ++it) { - (*it)->ClearDefaultActionsLocked(); - } - - // We don't clear the content of mockers, as they may still be - // needed by VerifyAndClearExpectationsLocked(). -} - -Expectation::Expectation() {} - -Expectation::Expectation( - const std::shared_ptr<internal::ExpectationBase>& an_expectation_base) - : expectation_base_(an_expectation_base) {} - -Expectation::~Expectation() {} - -// Adds an expectation to a sequence. -void Sequence::AddExpectation(const Expectation& expectation) const { - if (*last_expectation_ != expectation) { - if (last_expectation_->expectation_base() != nullptr) { - expectation.expectation_base()->immediate_prerequisites_ - += *last_expectation_; - } - *last_expectation_ = expectation; - } -} - -// Creates the implicit sequence if there isn't one. -InSequence::InSequence() { - if (internal::g_gmock_implicit_sequence.get() == nullptr) { - internal::g_gmock_implicit_sequence.set(new Sequence); - sequence_created_ = true; - } else { - sequence_created_ = false; - } -} - -// Deletes the implicit sequence if it was created by the constructor -// of this object. -InSequence::~InSequence() { - if (sequence_created_) { - delete internal::g_gmock_implicit_sequence.get(); - internal::g_gmock_implicit_sequence.set(nullptr); - } -} - -} // namespace testing - -#ifdef _MSC_VER -#if _MSC_VER == 1900 -# pragma warning(pop) -#endif -#endif -// Copyright 2008, 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. - - - -namespace testing { - -GMOCK_DEFINE_bool_(catch_leaked_mocks, true, - "true if and only if Google Mock should report leaked " - "mock objects as failures."); - -GMOCK_DEFINE_string_(verbose, internal::kWarningVerbosity, - "Controls how verbose Google Mock's output is." - " Valid values:\n" - " info - prints all messages.\n" - " warning - prints warnings and errors.\n" - " error - prints errors only."); - -GMOCK_DEFINE_int32_(default_mock_behavior, 1, - "Controls the default behavior of mocks." - " Valid values:\n" - " 0 - by default, mocks act as NiceMocks.\n" - " 1 - by default, mocks act as NaggyMocks.\n" - " 2 - by default, mocks act as StrictMocks."); - -namespace internal { - -// Parses a string as a command line flag. The string should have the -// format "--gmock_flag=value". When def_optional is true, the -// "=value" part can be omitted. -// -// Returns the value of the flag, or NULL if the parsing failed. -static const char* ParseGoogleMockFlagValue(const char* str, - const char* flag, - bool def_optional) { - // str and flag must not be NULL. - if (str == nullptr || flag == nullptr) return nullptr; - - // The flag must start with "--gmock_". - const std::string flag_str = std::string("--gmock_") + flag; - const size_t flag_len = flag_str.length(); - if (strncmp(str, flag_str.c_str(), flag_len) != 0) return nullptr; - - // Skips the flag name. - const char* flag_end = str + flag_len; - - // When def_optional is true, it's OK to not have a "=value" part. - if (def_optional && (flag_end[0] == '\0')) { - return flag_end; - } - - // If def_optional is true and there are more characters after the - // flag name, or if def_optional is false, there must be a '=' after - // the flag name. - if (flag_end[0] != '=') return nullptr; - - // Returns the string after "=". - return flag_end + 1; -} - -// Parses a string for a Google Mock bool flag, in the form of -// "--gmock_flag=value". -// -// On success, stores the value of the flag in *value, and returns -// true. On failure, returns false without changing *value. -static bool ParseGoogleMockBoolFlag(const char* str, const char* flag, - bool* value) { - // Gets the value of the flag as a string. - const char* const value_str = ParseGoogleMockFlagValue(str, flag, true); - - // Aborts if the parsing failed. - if (value_str == nullptr) return false; - - // Converts the string value to a bool. - *value = !(*value_str == '0' || *value_str == 'f' || *value_str == 'F'); - return true; -} - -// Parses a string for a Google Mock string flag, in the form of -// "--gmock_flag=value". -// -// On success, stores the value of the flag in *value, and returns -// true. On failure, returns false without changing *value. -template <typename String> -static bool ParseGoogleMockStringFlag(const char* str, const char* flag, - String* value) { - // Gets the value of the flag as a string. - const char* const value_str = ParseGoogleMockFlagValue(str, flag, false); - - // Aborts if the parsing failed. - if (value_str == nullptr) return false; - - // Sets *value to the value of the flag. - *value = value_str; - return true; -} - -static bool ParseGoogleMockIntFlag(const char* str, const char* flag, - int32_t* value) { - // Gets the value of the flag as a string. - const char* const value_str = ParseGoogleMockFlagValue(str, flag, true); - - // Aborts if the parsing failed. - if (value_str == nullptr) return false; - - // Sets *value to the value of the flag. - return ParseInt32(Message() << "The value of flag --" << flag, - value_str, value); -} - -// The internal implementation of InitGoogleMock(). -// -// The type parameter CharType can be instantiated to either char or -// wchar_t. -template <typename CharType> -void InitGoogleMockImpl(int* argc, CharType** argv) { - // Makes sure Google Test is initialized. InitGoogleTest() is - // idempotent, so it's fine if the user has already called it. - InitGoogleTest(argc, argv); - if (*argc <= 0) return; - - for (int i = 1; i != *argc; i++) { - const std::string arg_string = StreamableToString(argv[i]); - const char* const arg = arg_string.c_str(); - - // Do we see a Google Mock flag? - if (ParseGoogleMockBoolFlag(arg, "catch_leaked_mocks", - &GMOCK_FLAG(catch_leaked_mocks)) || - ParseGoogleMockStringFlag(arg, "verbose", &GMOCK_FLAG(verbose)) || - ParseGoogleMockIntFlag(arg, "default_mock_behavior", - &GMOCK_FLAG(default_mock_behavior))) { - // Yes. Shift the remainder of the argv list left by one. Note - // that argv has (*argc + 1) elements, the last one always being - // NULL. The following loop moves the trailing NULL element as - // well. - for (int j = i; j != *argc; j++) { - argv[j] = argv[j + 1]; - } - - // Decrements the argument count. - (*argc)--; - - // We also need to decrement the iterator as we just removed - // an element. - i--; - } - } -} - -} // namespace internal - -// Initializes Google Mock. This must be called before running the -// tests. In particular, it parses a command line for the flags that -// Google Mock recognizes. Whenever a Google Mock flag is seen, it is -// removed from argv, and *argc is decremented. -// -// No value is returned. Instead, the Google Mock flag variables are -// updated. -// -// Since Google Test is needed for Google Mock to work, this function -// also initializes Google Test and parses its flags, if that hasn't -// been done. -GTEST_API_ void InitGoogleMock(int* argc, char** argv) { - internal::InitGoogleMockImpl(argc, argv); -} - -// This overloaded version can be used in Windows programs compiled in -// UNICODE mode. -GTEST_API_ void InitGoogleMock(int* argc, wchar_t** argv) { - internal::InitGoogleMockImpl(argc, argv); -} - -// This overloaded version can be used on Arduino/embedded platforms where -// there is no argc/argv. -GTEST_API_ void InitGoogleMock() { - // Since Arduino doesn't have a command line, fake out the argc/argv arguments - int argc = 1; - const auto arg0 = "dummy"; - char* argv0 = const_cast<char*>(arg0); - char** argv = &argv0; - - internal::InitGoogleMockImpl(&argc, argv); -} - -} // namespace testing diff --git a/thirdparty/fmt/test/gtest/gmock/gmock.h b/thirdparty/fmt/test/gtest/gmock/gmock.h deleted file mode 100644 index c6eef5318..000000000 --- a/thirdparty/fmt/test/gtest/gmock/gmock.h +++ /dev/null @@ -1,11659 +0,0 @@ -// Copyright 2007, 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. - - -// Google Mock - a framework for writing C++ mock classes. -// -// This is the main header file a user should include. - -// GOOGLETEST_CM0002 DO NOT DELETE - -#ifndef GOOGLEMOCK_INCLUDE_GMOCK_GMOCK_H_ -#define GOOGLEMOCK_INCLUDE_GMOCK_GMOCK_H_ - -// This file implements the following syntax: -// -// ON_CALL(mock_object, Method(...)) -// .With(...) ? -// .WillByDefault(...); -// -// where With() is optional and WillByDefault() must appear exactly -// once. -// -// EXPECT_CALL(mock_object, Method(...)) -// .With(...) ? -// .Times(...) ? -// .InSequence(...) * -// .WillOnce(...) * -// .WillRepeatedly(...) ? -// .RetiresOnSaturation() ? ; -// -// where all clauses are optional and WillOnce() can be repeated. - -// Copyright 2007, 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. - - -// Google Mock - a framework for writing C++ mock classes. -// -// The ACTION* family of macros can be used in a namespace scope to -// define custom actions easily. The syntax: -// -// ACTION(name) { statements; } -// -// will define an action with the given name that executes the -// statements. The value returned by the statements will be used as -// the return value of the action. Inside the statements, you can -// refer to the K-th (0-based) argument of the mock function by -// 'argK', and refer to its type by 'argK_type'. For example: -// -// ACTION(IncrementArg1) { -// arg1_type temp = arg1; -// return ++(*temp); -// } -// -// allows you to write -// -// ...WillOnce(IncrementArg1()); -// -// You can also refer to the entire argument tuple and its type by -// 'args' and 'args_type', and refer to the mock function type and its -// return type by 'function_type' and 'return_type'. -// -// Note that you don't need to specify the types of the mock function -// arguments. However rest assured that your code is still type-safe: -// you'll get a compiler error if *arg1 doesn't support the ++ -// operator, or if the type of ++(*arg1) isn't compatible with the -// mock function's return type, for example. -// -// Sometimes you'll want to parameterize the action. For that you can use -// another macro: -// -// ACTION_P(name, param_name) { statements; } -// -// For example: -// -// ACTION_P(Add, n) { return arg0 + n; } -// -// will allow you to write: -// -// ...WillOnce(Add(5)); -// -// Note that you don't need to provide the type of the parameter -// either. If you need to reference the type of a parameter named -// 'foo', you can write 'foo_type'. For example, in the body of -// ACTION_P(Add, n) above, you can write 'n_type' to refer to the type -// of 'n'. -// -// We also provide ACTION_P2, ACTION_P3, ..., up to ACTION_P10 to support -// multi-parameter actions. -// -// For the purpose of typing, you can view -// -// ACTION_Pk(Foo, p1, ..., pk) { ... } -// -// as shorthand for -// -// template <typename p1_type, ..., typename pk_type> -// FooActionPk<p1_type, ..., pk_type> Foo(p1_type p1, ..., pk_type pk) { ... } -// -// In particular, you can provide the template type arguments -// explicitly when invoking Foo(), as in Foo<long, bool>(5, false); -// although usually you can rely on the compiler to infer the types -// for you automatically. You can assign the result of expression -// Foo(p1, ..., pk) to a variable of type FooActionPk<p1_type, ..., -// pk_type>. This can be useful when composing actions. -// -// You can also overload actions with different numbers of parameters: -// -// ACTION_P(Plus, a) { ... } -// ACTION_P2(Plus, a, b) { ... } -// -// While it's tempting to always use the ACTION* macros when defining -// a new action, you should also consider implementing ActionInterface -// or using MakePolymorphicAction() instead, especially if you need to -// use the action a lot. While these approaches require more work, -// they give you more control on the types of the mock function -// arguments and the action parameters, which in general leads to -// better compiler error messages that pay off in the long run. They -// also allow overloading actions based on parameter types (as opposed -// to just based on the number of parameters). -// -// CAVEAT: -// -// ACTION*() can only be used in a namespace scope as templates cannot be -// declared inside of a local class. -// Users can, however, define any local functors (e.g. a lambda) that -// can be used as actions. -// -// MORE INFORMATION: -// -// To learn more about using these macros, please search for 'ACTION' on -// https://github.com/google/googletest/blob/master/docs/gmock_cook_book.md - -// GOOGLETEST_CM0002 DO NOT DELETE - -#ifndef GOOGLEMOCK_INCLUDE_GMOCK_GMOCK_ACTIONS_H_ -#define GOOGLEMOCK_INCLUDE_GMOCK_GMOCK_ACTIONS_H_ - -#ifndef _WIN32_WCE -# include <errno.h> -#endif - -#include <algorithm> -#include <functional> -#include <memory> -#include <string> -#include <tuple> -#include <type_traits> -#include <utility> - -// Copyright 2007, 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. - - -// Google Mock - a framework for writing C++ mock classes. -// -// This file defines some utilities useful for implementing Google -// Mock. They are subject to change without notice, so please DO NOT -// USE THEM IN USER CODE. - -// GOOGLETEST_CM0002 DO NOT DELETE - -#ifndef GOOGLEMOCK_INCLUDE_GMOCK_INTERNAL_GMOCK_INTERNAL_UTILS_H_ -#define GOOGLEMOCK_INCLUDE_GMOCK_INTERNAL_GMOCK_INTERNAL_UTILS_H_ - -#include <stdio.h> -#include <ostream> // NOLINT -#include <string> -#include <type_traits> -// Copyright 2008, 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. - -// -// Low-level types and utilities for porting Google Mock to various -// platforms. All macros ending with _ and symbols defined in an -// internal namespace are subject to change without notice. Code -// outside Google Mock MUST NOT USE THEM DIRECTLY. Macros that don't -// end with _ are part of Google Mock's public API and can be used by -// code outside Google Mock. - -// GOOGLETEST_CM0002 DO NOT DELETE - -#ifndef GOOGLEMOCK_INCLUDE_GMOCK_INTERNAL_GMOCK_PORT_H_ -#define GOOGLEMOCK_INCLUDE_GMOCK_INTERNAL_GMOCK_PORT_H_ - -#include <assert.h> -#include <stdlib.h> -#include <cstdint> -#include <iostream> - -// Most of the utilities needed for porting Google Mock are also -// required for Google Test and are defined in gtest-port.h. -// -// Note to maintainers: to reduce code duplication, prefer adding -// portability utilities to Google Test's gtest-port.h instead of -// here, as Google Mock depends on Google Test. Only add a utility -// here if it's truly specific to Google Mock. - -#include "gtest/gtest.h" -// Copyright 2015, 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. -// -// Injection point for custom user configurations. See README for details -// -// ** Custom implementation starts here ** - -// GOOGLETEST_CM0002 DO NOT DELETE - -#ifndef GOOGLEMOCK_INCLUDE_GMOCK_INTERNAL_CUSTOM_GMOCK_PORT_H_ -#define GOOGLEMOCK_INCLUDE_GMOCK_INTERNAL_CUSTOM_GMOCK_PORT_H_ - -#endif // GOOGLEMOCK_INCLUDE_GMOCK_INTERNAL_CUSTOM_GMOCK_PORT_H_ - -// For MS Visual C++, check the compiler version. At least VS 2015 is -// required to compile Google Mock. -#if defined(_MSC_VER) && _MSC_VER < 1900 -# error "At least Visual C++ 2015 (14.0) is required to compile Google Mock." -#endif - -// Macro for referencing flags. This is public as we want the user to -// use this syntax to reference Google Mock flags. -#define GMOCK_FLAG(name) FLAGS_gmock_##name - -#if !defined(GMOCK_DECLARE_bool_) - -// Macros for declaring flags. -# define GMOCK_DECLARE_bool_(name) extern GTEST_API_ bool GMOCK_FLAG(name) -# define GMOCK_DECLARE_int32_(name) extern GTEST_API_ int32_t GMOCK_FLAG(name) -# define GMOCK_DECLARE_string_(name) \ - extern GTEST_API_ ::std::string GMOCK_FLAG(name) - -// Macros for defining flags. -# define GMOCK_DEFINE_bool_(name, default_val, doc) \ - GTEST_API_ bool GMOCK_FLAG(name) = (default_val) -# define GMOCK_DEFINE_int32_(name, default_val, doc) \ - GTEST_API_ int32_t GMOCK_FLAG(name) = (default_val) -# define GMOCK_DEFINE_string_(name, default_val, doc) \ - GTEST_API_ ::std::string GMOCK_FLAG(name) = (default_val) - -#endif // !defined(GMOCK_DECLARE_bool_) - -#endif // GOOGLEMOCK_INCLUDE_GMOCK_INTERNAL_GMOCK_PORT_H_ - -namespace testing { - -template <typename> -class Matcher; - -namespace internal { - -// Silence MSVC C4100 (unreferenced formal parameter) and -// C4805('==': unsafe mix of type 'const int' and type 'const bool') -#ifdef _MSC_VER -# pragma warning(push) -# pragma warning(disable:4100) -# pragma warning(disable:4805) -#endif - -// Joins a vector of strings as if they are fields of a tuple; returns -// the joined string. -GTEST_API_ std::string JoinAsTuple(const Strings& fields); - -// 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 -// treated as one word. For example, both "FooBar123" and -// "foo_bar_123" are converted to "foo bar 123". -GTEST_API_ std::string ConvertIdentifierNameToWords(const char* id_name); - -// GetRawPointer(p) returns the raw pointer underlying p when p is a -// smart pointer, or returns p itself when p is already a raw pointer. -// The following default implementation is for the smart pointer case. -template <typename Pointer> -inline const typename Pointer::element_type* GetRawPointer(const Pointer& p) { - return p.get(); -} -// This overloaded version is for the raw pointer case. -template <typename Element> -inline Element* GetRawPointer(Element* p) { return p; } - -// MSVC treats wchar_t as a native type usually, but treats it as the -// same as unsigned short when the compiler option /Zc:wchar_t- is -// specified. It defines _NATIVE_WCHAR_T_DEFINED symbol when wchar_t -// is a native type. -#if defined(_MSC_VER) && !defined(_NATIVE_WCHAR_T_DEFINED) -// wchar_t is a typedef. -#else -# define GMOCK_WCHAR_T_IS_NATIVE_ 1 -#endif - -// In what follows, we use the term "kind" to indicate whether a type -// is bool, an integer type (excluding bool), a floating-point type, -// or none of them. This categorization is useful for determining -// when a matcher argument type can be safely converted to another -// type in the implementation of SafeMatcherCast. -enum TypeKind { - kBool, kInteger, kFloatingPoint, kOther -}; - -// KindOf<T>::value is the kind of type T. -template <typename T> struct KindOf { - enum { value = kOther }; // The default kind. -}; - -// This macro declares that the kind of 'type' is 'kind'. -#define GMOCK_DECLARE_KIND_(type, kind) \ - template <> struct KindOf<type> { enum { value = kind }; } - -GMOCK_DECLARE_KIND_(bool, kBool); - -// All standard integer types. -GMOCK_DECLARE_KIND_(char, kInteger); -GMOCK_DECLARE_KIND_(signed char, kInteger); -GMOCK_DECLARE_KIND_(unsigned char, kInteger); -GMOCK_DECLARE_KIND_(short, kInteger); // NOLINT -GMOCK_DECLARE_KIND_(unsigned short, kInteger); // NOLINT -GMOCK_DECLARE_KIND_(int, kInteger); -GMOCK_DECLARE_KIND_(unsigned int, kInteger); -GMOCK_DECLARE_KIND_(long, kInteger); // NOLINT -GMOCK_DECLARE_KIND_(unsigned long, kInteger); // NOLINT -GMOCK_DECLARE_KIND_(long long, kInteger); // NOLINT -GMOCK_DECLARE_KIND_(unsigned long long, kInteger); // NOLINT - -#if GMOCK_WCHAR_T_IS_NATIVE_ -GMOCK_DECLARE_KIND_(wchar_t, kInteger); -#endif - -// All standard floating-point types. -GMOCK_DECLARE_KIND_(float, kFloatingPoint); -GMOCK_DECLARE_KIND_(double, kFloatingPoint); -GMOCK_DECLARE_KIND_(long double, kFloatingPoint); - -#undef GMOCK_DECLARE_KIND_ - -// Evaluates to the kind of 'type'. -#define GMOCK_KIND_OF_(type) \ - static_cast< ::testing::internal::TypeKind>( \ - ::testing::internal::KindOf<type>::value) - -// LosslessArithmeticConvertibleImpl<kFromKind, From, kToKind, To>::value -// is true if and only if arithmetic type From can be losslessly converted to -// arithmetic type To. -// -// It's the user's responsibility to ensure that both From and To are -// raw (i.e. has no CV modifier, is not a pointer, and is not a -// reference) built-in arithmetic types, kFromKind is the kind of -// From, and kToKind is the kind of To; the value is -// implementation-defined when the above pre-condition is violated. -template <TypeKind kFromKind, typename From, TypeKind kToKind, typename To> -using LosslessArithmeticConvertibleImpl = std::integral_constant< - bool, - // clang-format off - // Converting from bool is always lossless - (kFromKind == kBool) ? true - // Converting between any other type kinds will be lossy if the type - // kinds are not the same. - : (kFromKind != kToKind) ? false - : (kFromKind == kInteger && - // Converting between integers of different widths is allowed so long - // as the conversion does not go from signed to unsigned. - (((sizeof(From) < sizeof(To)) && - !(std::is_signed<From>::value && !std::is_signed<To>::value)) || - // Converting between integers of the same width only requires the - // two types to have the same signedness. - ((sizeof(From) == sizeof(To)) && - (std::is_signed<From>::value == std::is_signed<To>::value))) - ) ? true - // Floating point conversions are lossless if and only if `To` is at least - // as wide as `From`. - : (kFromKind == kFloatingPoint && (sizeof(From) <= sizeof(To))) ? true - : false - // clang-format on - >; - -// LosslessArithmeticConvertible<From, To>::value is true if and only if -// arithmetic type From can be losslessly converted to arithmetic type To. -// -// It's the user's responsibility to ensure that both From and To are -// raw (i.e. has no CV modifier, is not a pointer, and is not a -// reference) built-in arithmetic types; the value is -// implementation-defined when the above pre-condition is violated. -template <typename From, typename To> -using LosslessArithmeticConvertible = - LosslessArithmeticConvertibleImpl<GMOCK_KIND_OF_(From), From, - GMOCK_KIND_OF_(To), To>; - -// This interface knows how to report a Google Mock failure (either -// non-fatal or fatal). -class FailureReporterInterface { - public: - // The type of a failure (either non-fatal or fatal). - enum FailureType { - kNonfatal, kFatal - }; - - virtual ~FailureReporterInterface() {} - - // Reports a failure that occurred at the given source file location. - virtual void ReportFailure(FailureType type, const char* file, int line, - const std::string& message) = 0; -}; - -// Returns the failure reporter used by Google Mock. -GTEST_API_ FailureReporterInterface* GetFailureReporter(); - -// Asserts that condition is true; aborts the process with the given -// message if condition is false. We cannot use LOG(FATAL) or CHECK() -// as Google Mock might be used to mock the log sink itself. We -// inline this function to prevent it from showing up in the stack -// trace. -inline void Assert(bool condition, const char* file, int line, - const std::string& msg) { - if (!condition) { - GetFailureReporter()->ReportFailure(FailureReporterInterface::kFatal, - file, line, msg); - } -} -inline void Assert(bool condition, const char* file, int line) { - Assert(condition, file, line, "Assertion failed."); -} - -// Verifies that condition is true; generates a non-fatal failure if -// condition is false. -inline void Expect(bool condition, const char* file, int line, - const std::string& msg) { - if (!condition) { - GetFailureReporter()->ReportFailure(FailureReporterInterface::kNonfatal, - file, line, msg); - } -} -inline void Expect(bool condition, const char* file, int line) { - Expect(condition, file, line, "Expectation failed."); -} - -// Severity level of a log. -enum LogSeverity { - kInfo = 0, - kWarning = 1 -}; - -// Valid values for the --gmock_verbose flag. - -// All logs (informational and warnings) are printed. -const char kInfoVerbosity[] = "info"; -// Only warnings are printed. -const char kWarningVerbosity[] = "warning"; -// No logs are printed. -const char kErrorVerbosity[] = "error"; - -// Returns true if and only if a log with the given severity is visible -// according to the --gmock_verbose flag. -GTEST_API_ bool LogIsVisible(LogSeverity severity); - -// Prints the given message to stdout if and only if 'severity' >= the level -// specified by the --gmock_verbose flag. If stack_frames_to_skip >= -// 0, also prints the stack trace excluding the top -// stack_frames_to_skip frames. In opt mode, any positive -// 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 -// conservative. -GTEST_API_ void Log(LogSeverity severity, const std::string& message, - int stack_frames_to_skip); - -// A marker class that is used to resolve parameterless expectations to the -// correct overload. This must not be instantiable, to prevent client code from -// accidentally resolving to the overload; for example: -// -// ON_CALL(mock, Method({}, nullptr))... -// -class WithoutMatchers { - private: - WithoutMatchers() {} - friend GTEST_API_ WithoutMatchers GetWithoutMatchers(); -}; - -// Internal use only: access the singleton instance of WithoutMatchers. -GTEST_API_ WithoutMatchers GetWithoutMatchers(); - -// Disable MSVC warnings for infinite recursion, since in this case the -// the recursion is unreachable. -#ifdef _MSC_VER -# pragma warning(push) -# pragma warning(disable:4717) -#endif - -// Invalid<T>() is usable as an expression of type T, but will terminate -// the program with an assertion failure if actually run. This is useful -// when a value of type T is needed for compilation, but the statement -// will not really be executed (or we don't care if the statement -// crashes). -template <typename T> -inline T Invalid() { - Assert(false, "", -1, "Internal error: attempt to return invalid value"); - // This statement is unreachable, and would never terminate even if it - // could be reached. It is provided only to placate compiler warnings - // about missing return statements. - return Invalid<T>(); -} - -#ifdef _MSC_VER -# pragma warning(pop) -#endif - -// Given a raw type (i.e. having no top-level reference or const -// modifier) RawContainer that's either an STL-style container or a -// native array, class StlContainerView<RawContainer> has the -// following members: -// -// - type is a type that provides an STL-style container view to -// (i.e. implements the STL container concept for) RawContainer; -// - const_reference is a type that provides a reference to a const -// RawContainer; -// - ConstReference(raw_container) returns a const reference to an STL-style -// container view to raw_container, which is a RawContainer. -// - Copy(raw_container) returns an STL-style container view of a -// copy of raw_container, which is a RawContainer. -// -// This generic version is used when RawContainer itself is already an -// STL-style container. -template <class RawContainer> -class StlContainerView { - public: - typedef RawContainer type; - typedef const type& const_reference; - - static const_reference ConstReference(const RawContainer& container) { - static_assert(!std::is_const<RawContainer>::value, - "RawContainer type must not be const"); - return container; - } - static type Copy(const RawContainer& container) { return container; } -}; - -// This specialization is used when RawContainer is a native array type. -template <typename Element, size_t N> -class StlContainerView<Element[N]> { - public: - typedef typename std::remove_const<Element>::type RawElement; - typedef internal::NativeArray<RawElement> type; - // NativeArray<T> can represent a native array either by value or by - // reference (selected by a constructor argument), so 'const type' - // can be used to reference a const native array. We cannot - // 'typedef const type& const_reference' here, as that would mean - // ConstReference() has to return a reference to a local variable. - typedef const type const_reference; - - static const_reference ConstReference(const Element (&array)[N]) { - static_assert(std::is_same<Element, RawElement>::value, - "Element type must not be const"); - return type(array, N, RelationToSourceReference()); - } - static type Copy(const Element (&array)[N]) { - return type(array, N, RelationToSourceCopy()); - } -}; - -// This specialization is used when RawContainer is a native array -// represented as a (pointer, size) tuple. -template <typename ElementPointer, typename Size> -class StlContainerView< ::std::tuple<ElementPointer, Size> > { - public: - typedef typename std::remove_const< - typename std::pointer_traits<ElementPointer>::element_type>::type - RawElement; - typedef internal::NativeArray<RawElement> type; - typedef const type const_reference; - - static const_reference ConstReference( - const ::std::tuple<ElementPointer, Size>& array) { - return type(std::get<0>(array), std::get<1>(array), - RelationToSourceReference()); - } - static type Copy(const ::std::tuple<ElementPointer, Size>& array) { - return type(std::get<0>(array), std::get<1>(array), RelationToSourceCopy()); - } -}; - -// The following specialization prevents the user from instantiating -// StlContainer with a reference type. -template <typename T> class StlContainerView<T&>; - -// A type transform to remove constness from the first part of a pair. -// Pairs like that are used as the value_type of associative containers, -// and this transform produces a similar but assignable pair. -template <typename T> -struct RemoveConstFromKey { - typedef T type; -}; - -// Partially specialized to remove constness from std::pair<const K, V>. -template <typename K, typename V> -struct RemoveConstFromKey<std::pair<const K, V> > { - typedef std::pair<K, V> type; -}; - -// Emit an assertion failure due to incorrect DoDefault() usage. Out-of-lined to -// reduce code size. -GTEST_API_ void IllegalDoDefault(const char* file, int line); - -template <typename F, typename Tuple, size_t... Idx> -auto ApplyImpl(F&& f, Tuple&& args, IndexSequence<Idx...>) -> decltype( - std::forward<F>(f)(std::get<Idx>(std::forward<Tuple>(args))...)) { - return std::forward<F>(f)(std::get<Idx>(std::forward<Tuple>(args))...); -} - -// Apply the function to a tuple of arguments. -template <typename F, typename Tuple> -auto Apply(F&& f, Tuple&& args) -> decltype( - ApplyImpl(std::forward<F>(f), std::forward<Tuple>(args), - MakeIndexSequence<std::tuple_size< - typename std::remove_reference<Tuple>::type>::value>())) { - return ApplyImpl(std::forward<F>(f), std::forward<Tuple>(args), - MakeIndexSequence<std::tuple_size< - typename std::remove_reference<Tuple>::type>::value>()); -} - -// Template struct Function<F>, where F must be a function type, contains -// the following typedefs: -// -// Result: the function's return type. -// Arg<N>: the type of the N-th argument, where N starts with 0. -// ArgumentTuple: the tuple type consisting of all parameters of F. -// ArgumentMatcherTuple: the tuple type consisting of Matchers for all -// parameters of F. -// MakeResultVoid: the function type obtained by substituting void -// for the return type of F. -// MakeResultIgnoredValue: -// the function type obtained by substituting Something -// for the return type of F. -template <typename T> -struct Function; - -template <typename R, typename... Args> -struct Function<R(Args...)> { - using Result = R; - static constexpr size_t ArgumentCount = sizeof...(Args); - template <size_t I> - using Arg = ElemFromList<I, Args...>; - using ArgumentTuple = std::tuple<Args...>; - using ArgumentMatcherTuple = std::tuple<Matcher<Args>...>; - using MakeResultVoid = void(Args...); - using MakeResultIgnoredValue = IgnoredValue(Args...); -}; - -template <typename R, typename... Args> -constexpr size_t Function<R(Args...)>::ArgumentCount; - -#ifdef _MSC_VER -# pragma warning(pop) -#endif - -} // namespace internal -} // namespace testing - -#endif // GOOGLEMOCK_INCLUDE_GMOCK_INTERNAL_GMOCK_INTERNAL_UTILS_H_ -#ifndef GOOGLEMOCK_INCLUDE_GMOCK_INTERNAL_GMOCK_PP_H_ -#define GOOGLEMOCK_INCLUDE_GMOCK_INTERNAL_GMOCK_PP_H_ - -// Expands and concatenates the arguments. Constructed macros reevaluate. -#define GMOCK_PP_CAT(_1, _2) GMOCK_PP_INTERNAL_CAT(_1, _2) - -// Expands and stringifies the only argument. -#define GMOCK_PP_STRINGIZE(...) GMOCK_PP_INTERNAL_STRINGIZE(__VA_ARGS__) - -// Returns empty. Given a variadic number of arguments. -#define GMOCK_PP_EMPTY(...) - -// Returns a comma. Given a variadic number of arguments. -#define GMOCK_PP_COMMA(...) , - -// Returns the only argument. -#define GMOCK_PP_IDENTITY(_1) _1 - -// Evaluates to the number of arguments after expansion. -// -// #define PAIR x, y -// -// GMOCK_PP_NARG() => 1 -// GMOCK_PP_NARG(x) => 1 -// GMOCK_PP_NARG(x, y) => 2 -// GMOCK_PP_NARG(PAIR) => 2 -// -// Requires: the number of arguments after expansion is at most 15. -#define GMOCK_PP_NARG(...) \ - GMOCK_PP_INTERNAL_16TH( \ - (__VA_ARGS__, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0)) - -// Returns 1 if the expansion of arguments has an unprotected comma. Otherwise -// returns 0. Requires no more than 15 unprotected commas. -#define GMOCK_PP_HAS_COMMA(...) \ - GMOCK_PP_INTERNAL_16TH( \ - (__VA_ARGS__, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0)) - -// Returns the first argument. -#define GMOCK_PP_HEAD(...) GMOCK_PP_INTERNAL_HEAD((__VA_ARGS__, unusedArg)) - -// Returns the tail. A variadic list of all arguments minus the first. Requires -// at least one argument. -#define GMOCK_PP_TAIL(...) GMOCK_PP_INTERNAL_TAIL((__VA_ARGS__)) - -// Calls CAT(_Macro, NARG(__VA_ARGS__))(__VA_ARGS__) -#define GMOCK_PP_VARIADIC_CALL(_Macro, ...) \ - GMOCK_PP_IDENTITY( \ - GMOCK_PP_CAT(_Macro, GMOCK_PP_NARG(__VA_ARGS__))(__VA_ARGS__)) - -// If the arguments after expansion have no tokens, evaluates to `1`. Otherwise -// evaluates to `0`. -// -// Requires: * the number of arguments after expansion is at most 15. -// * If the argument is a macro, it must be able to be called with one -// argument. -// -// Implementation details: -// -// There is one case when it generates a compile error: if the argument is macro -// that cannot be called with one argument. -// -// #define M(a, b) // it doesn't matter what it expands to -// -// // Expected: expands to `0`. -// // Actual: compile error. -// GMOCK_PP_IS_EMPTY(M) -// -// There are 4 cases tested: -// -// * __VA_ARGS__ possible expansion has no unparen'd commas. Expected 0. -// * __VA_ARGS__ possible expansion is not enclosed in parenthesis. Expected 0. -// * __VA_ARGS__ possible expansion is not a macro that ()-evaluates to a comma. -// Expected 0 -// * __VA_ARGS__ is empty, or has unparen'd commas, or is enclosed in -// parenthesis, or is a macro that ()-evaluates to comma. Expected 1. -// -// We trigger detection on '0001', i.e. on empty. -#define GMOCK_PP_IS_EMPTY(...) \ - GMOCK_PP_INTERNAL_IS_EMPTY(GMOCK_PP_HAS_COMMA(__VA_ARGS__), \ - GMOCK_PP_HAS_COMMA(GMOCK_PP_COMMA __VA_ARGS__), \ - GMOCK_PP_HAS_COMMA(__VA_ARGS__()), \ - GMOCK_PP_HAS_COMMA(GMOCK_PP_COMMA __VA_ARGS__())) - -// Evaluates to _Then if _Cond is 1 and _Else if _Cond is 0. -#define GMOCK_PP_IF(_Cond, _Then, _Else) \ - GMOCK_PP_CAT(GMOCK_PP_INTERNAL_IF_, _Cond)(_Then, _Else) - -// Similar to GMOCK_PP_IF but takes _Then and _Else in parentheses. -// -// GMOCK_PP_GENERIC_IF(1, (a, b, c), (d, e, f)) => a, b, c -// GMOCK_PP_GENERIC_IF(0, (a, b, c), (d, e, f)) => d, e, f -// -#define GMOCK_PP_GENERIC_IF(_Cond, _Then, _Else) \ - GMOCK_PP_REMOVE_PARENS(GMOCK_PP_IF(_Cond, _Then, _Else)) - -// Evaluates to the number of arguments after expansion. Identifies 'empty' as -// 0. -// -// #define PAIR x, y -// -// GMOCK_PP_NARG0() => 0 -// GMOCK_PP_NARG0(x) => 1 -// GMOCK_PP_NARG0(x, y) => 2 -// GMOCK_PP_NARG0(PAIR) => 2 -// -// Requires: * the number of arguments after expansion is at most 15. -// * If the argument is a macro, it must be able to be called with one -// argument. -#define GMOCK_PP_NARG0(...) \ - GMOCK_PP_IF(GMOCK_PP_IS_EMPTY(__VA_ARGS__), 0, GMOCK_PP_NARG(__VA_ARGS__)) - -// Expands to 1 if the first argument starts with something in parentheses, -// otherwise to 0. -#define GMOCK_PP_IS_BEGIN_PARENS(...) \ - GMOCK_PP_HEAD(GMOCK_PP_CAT(GMOCK_PP_INTERNAL_IBP_IS_VARIADIC_R_, \ - GMOCK_PP_INTERNAL_IBP_IS_VARIADIC_C __VA_ARGS__)) - -// Expands to 1 is there is only one argument and it is enclosed in parentheses. -#define GMOCK_PP_IS_ENCLOSED_PARENS(...) \ - GMOCK_PP_IF(GMOCK_PP_IS_BEGIN_PARENS(__VA_ARGS__), \ - GMOCK_PP_IS_EMPTY(GMOCK_PP_EMPTY __VA_ARGS__), 0) - -// Remove the parens, requires GMOCK_PP_IS_ENCLOSED_PARENS(args) => 1. -#define GMOCK_PP_REMOVE_PARENS(...) GMOCK_PP_INTERNAL_REMOVE_PARENS __VA_ARGS__ - -// Expands to _Macro(0, _Data, e1) _Macro(1, _Data, e2) ... _Macro(K -1, _Data, -// eK) as many of GMOCK_INTERNAL_NARG0 _Tuple. -// Requires: * |_Macro| can be called with 3 arguments. -// * |_Tuple| expansion has no more than 15 elements. -#define GMOCK_PP_FOR_EACH(_Macro, _Data, _Tuple) \ - GMOCK_PP_CAT(GMOCK_PP_INTERNAL_FOR_EACH_IMPL_, GMOCK_PP_NARG0 _Tuple) \ - (0, _Macro, _Data, _Tuple) - -// Expands to _Macro(0, _Data, ) _Macro(1, _Data, ) ... _Macro(K - 1, _Data, ) -// Empty if _K = 0. -// Requires: * |_Macro| can be called with 3 arguments. -// * |_K| literal between 0 and 15 -#define GMOCK_PP_REPEAT(_Macro, _Data, _N) \ - GMOCK_PP_CAT(GMOCK_PP_INTERNAL_FOR_EACH_IMPL_, _N) \ - (0, _Macro, _Data, GMOCK_PP_INTENRAL_EMPTY_TUPLE) - -// Increments the argument, requires the argument to be between 0 and 15. -#define GMOCK_PP_INC(_i) GMOCK_PP_CAT(GMOCK_PP_INTERNAL_INC_, _i) - -// Returns comma if _i != 0. Requires _i to be between 0 and 15. -#define GMOCK_PP_COMMA_IF(_i) GMOCK_PP_CAT(GMOCK_PP_INTERNAL_COMMA_IF_, _i) - -// Internal details follow. Do not use any of these symbols outside of this -// file or we will break your code. -#define GMOCK_PP_INTENRAL_EMPTY_TUPLE (, , , , , , , , , , , , , , , ) -#define GMOCK_PP_INTERNAL_CAT(_1, _2) _1##_2 -#define GMOCK_PP_INTERNAL_STRINGIZE(...) #__VA_ARGS__ -#define GMOCK_PP_INTERNAL_CAT_5(_1, _2, _3, _4, _5) _1##_2##_3##_4##_5 -#define GMOCK_PP_INTERNAL_IS_EMPTY(_1, _2, _3, _4) \ - GMOCK_PP_HAS_COMMA(GMOCK_PP_INTERNAL_CAT_5(GMOCK_PP_INTERNAL_IS_EMPTY_CASE_, \ - _1, _2, _3, _4)) -#define GMOCK_PP_INTERNAL_IS_EMPTY_CASE_0001 , -#define GMOCK_PP_INTERNAL_IF_1(_Then, _Else) _Then -#define GMOCK_PP_INTERNAL_IF_0(_Then, _Else) _Else - -// Because of MSVC treating a token with a comma in it as a single token when -// passed to another macro, we need to force it to evaluate it as multiple -// tokens. We do that by using a "IDENTITY(MACRO PARENTHESIZED_ARGS)" macro. We -// define one per possible macro that relies on this behavior. Note "_Args" must -// be parenthesized. -#define GMOCK_PP_INTERNAL_INTERNAL_16TH(_1, _2, _3, _4, _5, _6, _7, _8, _9, \ - _10, _11, _12, _13, _14, _15, _16, \ - ...) \ - _16 -#define GMOCK_PP_INTERNAL_16TH(_Args) \ - GMOCK_PP_IDENTITY(GMOCK_PP_INTERNAL_INTERNAL_16TH _Args) -#define GMOCK_PP_INTERNAL_INTERNAL_HEAD(_1, ...) _1 -#define GMOCK_PP_INTERNAL_HEAD(_Args) \ - GMOCK_PP_IDENTITY(GMOCK_PP_INTERNAL_INTERNAL_HEAD _Args) -#define GMOCK_PP_INTERNAL_INTERNAL_TAIL(_1, ...) __VA_ARGS__ -#define GMOCK_PP_INTERNAL_TAIL(_Args) \ - GMOCK_PP_IDENTITY(GMOCK_PP_INTERNAL_INTERNAL_TAIL _Args) - -#define GMOCK_PP_INTERNAL_IBP_IS_VARIADIC_C(...) 1 _ -#define GMOCK_PP_INTERNAL_IBP_IS_VARIADIC_R_1 1, -#define GMOCK_PP_INTERNAL_IBP_IS_VARIADIC_R_GMOCK_PP_INTERNAL_IBP_IS_VARIADIC_C \ - 0, -#define GMOCK_PP_INTERNAL_REMOVE_PARENS(...) __VA_ARGS__ -#define GMOCK_PP_INTERNAL_INC_0 1 -#define GMOCK_PP_INTERNAL_INC_1 2 -#define GMOCK_PP_INTERNAL_INC_2 3 -#define GMOCK_PP_INTERNAL_INC_3 4 -#define GMOCK_PP_INTERNAL_INC_4 5 -#define GMOCK_PP_INTERNAL_INC_5 6 -#define GMOCK_PP_INTERNAL_INC_6 7 -#define GMOCK_PP_INTERNAL_INC_7 8 -#define GMOCK_PP_INTERNAL_INC_8 9 -#define GMOCK_PP_INTERNAL_INC_9 10 -#define GMOCK_PP_INTERNAL_INC_10 11 -#define GMOCK_PP_INTERNAL_INC_11 12 -#define GMOCK_PP_INTERNAL_INC_12 13 -#define GMOCK_PP_INTERNAL_INC_13 14 -#define GMOCK_PP_INTERNAL_INC_14 15 -#define GMOCK_PP_INTERNAL_INC_15 16 -#define GMOCK_PP_INTERNAL_COMMA_IF_0 -#define GMOCK_PP_INTERNAL_COMMA_IF_1 , -#define GMOCK_PP_INTERNAL_COMMA_IF_2 , -#define GMOCK_PP_INTERNAL_COMMA_IF_3 , -#define GMOCK_PP_INTERNAL_COMMA_IF_4 , -#define GMOCK_PP_INTERNAL_COMMA_IF_5 , -#define GMOCK_PP_INTERNAL_COMMA_IF_6 , -#define GMOCK_PP_INTERNAL_COMMA_IF_7 , -#define GMOCK_PP_INTERNAL_COMMA_IF_8 , -#define GMOCK_PP_INTERNAL_COMMA_IF_9 , -#define GMOCK_PP_INTERNAL_COMMA_IF_10 , -#define GMOCK_PP_INTERNAL_COMMA_IF_11 , -#define GMOCK_PP_INTERNAL_COMMA_IF_12 , -#define GMOCK_PP_INTERNAL_COMMA_IF_13 , -#define GMOCK_PP_INTERNAL_COMMA_IF_14 , -#define GMOCK_PP_INTERNAL_COMMA_IF_15 , -#define GMOCK_PP_INTERNAL_CALL_MACRO(_Macro, _i, _Data, _element) \ - _Macro(_i, _Data, _element) -#define GMOCK_PP_INTERNAL_FOR_EACH_IMPL_0(_i, _Macro, _Data, _Tuple) -#define GMOCK_PP_INTERNAL_FOR_EACH_IMPL_1(_i, _Macro, _Data, _Tuple) \ - GMOCK_PP_INTERNAL_CALL_MACRO(_Macro, _i, _Data, GMOCK_PP_HEAD _Tuple) -#define GMOCK_PP_INTERNAL_FOR_EACH_IMPL_2(_i, _Macro, _Data, _Tuple) \ - GMOCK_PP_INTERNAL_CALL_MACRO(_Macro, _i, _Data, GMOCK_PP_HEAD _Tuple) \ - GMOCK_PP_INTERNAL_FOR_EACH_IMPL_1(GMOCK_PP_INC(_i), _Macro, _Data, \ - (GMOCK_PP_TAIL _Tuple)) -#define GMOCK_PP_INTERNAL_FOR_EACH_IMPL_3(_i, _Macro, _Data, _Tuple) \ - GMOCK_PP_INTERNAL_CALL_MACRO(_Macro, _i, _Data, GMOCK_PP_HEAD _Tuple) \ - GMOCK_PP_INTERNAL_FOR_EACH_IMPL_2(GMOCK_PP_INC(_i), _Macro, _Data, \ - (GMOCK_PP_TAIL _Tuple)) -#define GMOCK_PP_INTERNAL_FOR_EACH_IMPL_4(_i, _Macro, _Data, _Tuple) \ - GMOCK_PP_INTERNAL_CALL_MACRO(_Macro, _i, _Data, GMOCK_PP_HEAD _Tuple) \ - GMOCK_PP_INTERNAL_FOR_EACH_IMPL_3(GMOCK_PP_INC(_i), _Macro, _Data, \ - (GMOCK_PP_TAIL _Tuple)) -#define GMOCK_PP_INTERNAL_FOR_EACH_IMPL_5(_i, _Macro, _Data, _Tuple) \ - GMOCK_PP_INTERNAL_CALL_MACRO(_Macro, _i, _Data, GMOCK_PP_HEAD _Tuple) \ - GMOCK_PP_INTERNAL_FOR_EACH_IMPL_4(GMOCK_PP_INC(_i), _Macro, _Data, \ - (GMOCK_PP_TAIL _Tuple)) -#define GMOCK_PP_INTERNAL_FOR_EACH_IMPL_6(_i, _Macro, _Data, _Tuple) \ - GMOCK_PP_INTERNAL_CALL_MACRO(_Macro, _i, _Data, GMOCK_PP_HEAD _Tuple) \ - GMOCK_PP_INTERNAL_FOR_EACH_IMPL_5(GMOCK_PP_INC(_i), _Macro, _Data, \ - (GMOCK_PP_TAIL _Tuple)) -#define GMOCK_PP_INTERNAL_FOR_EACH_IMPL_7(_i, _Macro, _Data, _Tuple) \ - GMOCK_PP_INTERNAL_CALL_MACRO(_Macro, _i, _Data, GMOCK_PP_HEAD _Tuple) \ - GMOCK_PP_INTERNAL_FOR_EACH_IMPL_6(GMOCK_PP_INC(_i), _Macro, _Data, \ - (GMOCK_PP_TAIL _Tuple)) -#define GMOCK_PP_INTERNAL_FOR_EACH_IMPL_8(_i, _Macro, _Data, _Tuple) \ - GMOCK_PP_INTERNAL_CALL_MACRO(_Macro, _i, _Data, GMOCK_PP_HEAD _Tuple) \ - GMOCK_PP_INTERNAL_FOR_EACH_IMPL_7(GMOCK_PP_INC(_i), _Macro, _Data, \ - (GMOCK_PP_TAIL _Tuple)) -#define GMOCK_PP_INTERNAL_FOR_EACH_IMPL_9(_i, _Macro, _Data, _Tuple) \ - GMOCK_PP_INTERNAL_CALL_MACRO(_Macro, _i, _Data, GMOCK_PP_HEAD _Tuple) \ - GMOCK_PP_INTERNAL_FOR_EACH_IMPL_8(GMOCK_PP_INC(_i), _Macro, _Data, \ - (GMOCK_PP_TAIL _Tuple)) -#define GMOCK_PP_INTERNAL_FOR_EACH_IMPL_10(_i, _Macro, _Data, _Tuple) \ - GMOCK_PP_INTERNAL_CALL_MACRO(_Macro, _i, _Data, GMOCK_PP_HEAD _Tuple) \ - GMOCK_PP_INTERNAL_FOR_EACH_IMPL_9(GMOCK_PP_INC(_i), _Macro, _Data, \ - (GMOCK_PP_TAIL _Tuple)) -#define GMOCK_PP_INTERNAL_FOR_EACH_IMPL_11(_i, _Macro, _Data, _Tuple) \ - GMOCK_PP_INTERNAL_CALL_MACRO(_Macro, _i, _Data, GMOCK_PP_HEAD _Tuple) \ - GMOCK_PP_INTERNAL_FOR_EACH_IMPL_10(GMOCK_PP_INC(_i), _Macro, _Data, \ - (GMOCK_PP_TAIL _Tuple)) -#define GMOCK_PP_INTERNAL_FOR_EACH_IMPL_12(_i, _Macro, _Data, _Tuple) \ - GMOCK_PP_INTERNAL_CALL_MACRO(_Macro, _i, _Data, GMOCK_PP_HEAD _Tuple) \ - GMOCK_PP_INTERNAL_FOR_EACH_IMPL_11(GMOCK_PP_INC(_i), _Macro, _Data, \ - (GMOCK_PP_TAIL _Tuple)) -#define GMOCK_PP_INTERNAL_FOR_EACH_IMPL_13(_i, _Macro, _Data, _Tuple) \ - GMOCK_PP_INTERNAL_CALL_MACRO(_Macro, _i, _Data, GMOCK_PP_HEAD _Tuple) \ - GMOCK_PP_INTERNAL_FOR_EACH_IMPL_12(GMOCK_PP_INC(_i), _Macro, _Data, \ - (GMOCK_PP_TAIL _Tuple)) -#define GMOCK_PP_INTERNAL_FOR_EACH_IMPL_14(_i, _Macro, _Data, _Tuple) \ - GMOCK_PP_INTERNAL_CALL_MACRO(_Macro, _i, _Data, GMOCK_PP_HEAD _Tuple) \ - GMOCK_PP_INTERNAL_FOR_EACH_IMPL_13(GMOCK_PP_INC(_i), _Macro, _Data, \ - (GMOCK_PP_TAIL _Tuple)) -#define GMOCK_PP_INTERNAL_FOR_EACH_IMPL_15(_i, _Macro, _Data, _Tuple) \ - GMOCK_PP_INTERNAL_CALL_MACRO(_Macro, _i, _Data, GMOCK_PP_HEAD _Tuple) \ - GMOCK_PP_INTERNAL_FOR_EACH_IMPL_14(GMOCK_PP_INC(_i), _Macro, _Data, \ - (GMOCK_PP_TAIL _Tuple)) - -#endif // GOOGLEMOCK_INCLUDE_GMOCK_INTERNAL_GMOCK_PP_H_ - -#ifdef _MSC_VER -# pragma warning(push) -# pragma warning(disable:4100) -#endif - -namespace testing { - -// To implement an action Foo, define: -// 1. a class FooAction that implements the ActionInterface interface, and -// 2. a factory function that creates an Action object from a -// const FooAction*. -// -// The two-level delegation design follows that of Matcher, providing -// consistency for extension developers. It also eases ownership -// management as Action objects can now be copied like plain values. - -namespace internal { - -// BuiltInDefaultValueGetter<T, true>::Get() returns a -// default-constructed T value. BuiltInDefaultValueGetter<T, -// false>::Get() crashes with an error. -// -// This primary template is used when kDefaultConstructible is true. -template <typename T, bool kDefaultConstructible> -struct BuiltInDefaultValueGetter { - static T Get() { return T(); } -}; -template <typename T> -struct BuiltInDefaultValueGetter<T, false> { - static T Get() { - Assert(false, __FILE__, __LINE__, - "Default action undefined for the function return type."); - return internal::Invalid<T>(); - // The above statement will never be reached, but is required in - // order for this function to compile. - } -}; - -// BuiltInDefaultValue<T>::Get() returns the "built-in" default value -// for type T, which is NULL when T is a raw pointer type, 0 when T is -// a numeric type, false when T is bool, or "" when T is string or -// std::string. In addition, in C++11 and above, it turns a -// default-constructed T value if T is default constructible. For any -// other type T, the built-in default T value is undefined, and the -// function will abort the process. -template <typename T> -class BuiltInDefaultValue { - public: - // This function returns true if and only if type T has a built-in default - // value. - static bool Exists() { - return ::std::is_default_constructible<T>::value; - } - - static T Get() { - return BuiltInDefaultValueGetter< - T, ::std::is_default_constructible<T>::value>::Get(); - } -}; - -// This partial specialization says that we use the same built-in -// default value for T and const T. -template <typename T> -class BuiltInDefaultValue<const T> { - public: - static bool Exists() { return BuiltInDefaultValue<T>::Exists(); } - static T Get() { return BuiltInDefaultValue<T>::Get(); } -}; - -// This partial specialization defines the default values for pointer -// types. -template <typename T> -class BuiltInDefaultValue<T*> { - public: - static bool Exists() { return true; } - static T* Get() { return nullptr; } -}; - -// The following specializations define the default values for -// specific types we care about. -#define GMOCK_DEFINE_DEFAULT_ACTION_FOR_RETURN_TYPE_(type, value) \ - template <> \ - class BuiltInDefaultValue<type> { \ - public: \ - static bool Exists() { return true; } \ - static type Get() { return value; } \ - } - -GMOCK_DEFINE_DEFAULT_ACTION_FOR_RETURN_TYPE_(void, ); // NOLINT -GMOCK_DEFINE_DEFAULT_ACTION_FOR_RETURN_TYPE_(::std::string, ""); -GMOCK_DEFINE_DEFAULT_ACTION_FOR_RETURN_TYPE_(bool, false); -GMOCK_DEFINE_DEFAULT_ACTION_FOR_RETURN_TYPE_(unsigned char, '\0'); -GMOCK_DEFINE_DEFAULT_ACTION_FOR_RETURN_TYPE_(signed char, '\0'); -GMOCK_DEFINE_DEFAULT_ACTION_FOR_RETURN_TYPE_(char, '\0'); - -// There's no need for a default action for signed wchar_t, as that -// type is the same as wchar_t for gcc, and invalid for MSVC. -// -// There's also no need for a default action for unsigned wchar_t, as -// that type is the same as unsigned int for gcc, and invalid for -// MSVC. -#if GMOCK_WCHAR_T_IS_NATIVE_ -GMOCK_DEFINE_DEFAULT_ACTION_FOR_RETURN_TYPE_(wchar_t, 0U); // NOLINT -#endif - -GMOCK_DEFINE_DEFAULT_ACTION_FOR_RETURN_TYPE_(unsigned short, 0U); // NOLINT -GMOCK_DEFINE_DEFAULT_ACTION_FOR_RETURN_TYPE_(signed short, 0); // NOLINT -GMOCK_DEFINE_DEFAULT_ACTION_FOR_RETURN_TYPE_(unsigned int, 0U); -GMOCK_DEFINE_DEFAULT_ACTION_FOR_RETURN_TYPE_(signed int, 0); -GMOCK_DEFINE_DEFAULT_ACTION_FOR_RETURN_TYPE_(unsigned long, 0UL); // NOLINT -GMOCK_DEFINE_DEFAULT_ACTION_FOR_RETURN_TYPE_(signed long, 0L); // NOLINT -GMOCK_DEFINE_DEFAULT_ACTION_FOR_RETURN_TYPE_(unsigned long long, 0); // NOLINT -GMOCK_DEFINE_DEFAULT_ACTION_FOR_RETURN_TYPE_(signed long long, 0); // NOLINT -GMOCK_DEFINE_DEFAULT_ACTION_FOR_RETURN_TYPE_(float, 0); -GMOCK_DEFINE_DEFAULT_ACTION_FOR_RETURN_TYPE_(double, 0); - -#undef GMOCK_DEFINE_DEFAULT_ACTION_FOR_RETURN_TYPE_ - -// Simple two-arg form of std::disjunction. -template <typename P, typename Q> -using disjunction = typename ::std::conditional<P::value, P, Q>::type; - -} // namespace internal - -// When an unexpected function call is encountered, Google Mock will -// let it return a default value if the user has specified one for its -// return type, or if the return type has a built-in default value; -// otherwise Google Mock won't know what value to return and will have -// to abort the process. -// -// The DefaultValue<T> class allows a user to specify the -// default value for a type T that is both copyable and publicly -// destructible (i.e. anything that can be used as a function return -// type). The usage is: -// -// // Sets the default value for type T to be foo. -// DefaultValue<T>::Set(foo); -template <typename T> -class DefaultValue { - public: - // Sets the default value for type T; requires T to be - // copy-constructable and have a public destructor. - static void Set(T x) { - delete producer_; - producer_ = new FixedValueProducer(x); - } - - // Provides a factory function to be called to generate the default value. - // This method can be used even if T is only move-constructible, but it is not - // limited to that case. - typedef T (*FactoryFunction)(); - static void SetFactory(FactoryFunction factory) { - delete producer_; - producer_ = new FactoryValueProducer(factory); - } - - // Unsets the default value for type T. - static void Clear() { - delete producer_; - producer_ = nullptr; - } - - // Returns true if and only if the user has set the default value for type T. - static bool IsSet() { return producer_ != nullptr; } - - // Returns true if T has a default return value set by the user or there - // exists a built-in default value. - static bool Exists() { - return IsSet() || internal::BuiltInDefaultValue<T>::Exists(); - } - - // Returns the default value for type T if the user has set one; - // otherwise returns the built-in default value. Requires that Exists() - // is true, which ensures that the return value is well-defined. - static T Get() { - return producer_ == nullptr ? internal::BuiltInDefaultValue<T>::Get() - : producer_->Produce(); - } - - private: - class ValueProducer { - public: - virtual ~ValueProducer() {} - virtual T Produce() = 0; - }; - - class FixedValueProducer : public ValueProducer { - public: - explicit FixedValueProducer(T value) : value_(value) {} - T Produce() override { return value_; } - - private: - const T value_; - GTEST_DISALLOW_COPY_AND_ASSIGN_(FixedValueProducer); - }; - - class FactoryValueProducer : public ValueProducer { - public: - explicit FactoryValueProducer(FactoryFunction factory) - : factory_(factory) {} - T Produce() override { return factory_(); } - - private: - const FactoryFunction factory_; - GTEST_DISALLOW_COPY_AND_ASSIGN_(FactoryValueProducer); - }; - - static ValueProducer* producer_; -}; - -// This partial specialization allows a user to set default values for -// reference types. -template <typename T> -class DefaultValue<T&> { - public: - // Sets the default value for type T&. - static void Set(T& x) { // NOLINT - address_ = &x; - } - - // Unsets the default value for type T&. - static void Clear() { address_ = nullptr; } - - // Returns true if and only if the user has set the default value for type T&. - static bool IsSet() { return address_ != nullptr; } - - // Returns true if T has a default return value set by the user or there - // exists a built-in default value. - static bool Exists() { - return IsSet() || internal::BuiltInDefaultValue<T&>::Exists(); - } - - // Returns the default value for type T& if the user has set one; - // otherwise returns the built-in default value if there is one; - // otherwise aborts the process. - static T& Get() { - return address_ == nullptr ? internal::BuiltInDefaultValue<T&>::Get() - : *address_; - } - - private: - static T* address_; -}; - -// This specialization allows DefaultValue<void>::Get() to -// compile. -template <> -class DefaultValue<void> { - public: - static bool Exists() { return true; } - static void Get() {} -}; - -// Points to the user-set default value for type T. -template <typename T> -typename DefaultValue<T>::ValueProducer* DefaultValue<T>::producer_ = nullptr; - -// Points to the user-set default value for type T&. -template <typename T> -T* DefaultValue<T&>::address_ = nullptr; - -// Implement this interface to define an action for function type F. -template <typename F> -class ActionInterface { - public: - typedef typename internal::Function<F>::Result Result; - typedef typename internal::Function<F>::ArgumentTuple ArgumentTuple; - - ActionInterface() {} - virtual ~ActionInterface() {} - - // Performs the action. This method is not const, as in general an - // action can have side effects and be stateful. For example, a - // get-the-next-element-from-the-collection action will need to - // remember the current element. - virtual Result Perform(const ArgumentTuple& args) = 0; - - private: - GTEST_DISALLOW_COPY_AND_ASSIGN_(ActionInterface); -}; - -// An Action<F> is a copyable and IMMUTABLE (except by assignment) -// object that represents an action to be taken when a mock function -// of type F is called. The implementation of Action<T> is just a -// std::shared_ptr to const ActionInterface<T>. Don't inherit from Action! -// You can view an object implementing ActionInterface<F> as a -// concrete action (including its current state), and an Action<F> -// object as a handle to it. -template <typename F> -class Action { - // Adapter class to allow constructing Action from a legacy ActionInterface. - // New code should create Actions from functors instead. - struct ActionAdapter { - // Adapter must be copyable to satisfy std::function requirements. - ::std::shared_ptr<ActionInterface<F>> impl_; - - template <typename... Args> - typename internal::Function<F>::Result operator()(Args&&... args) { - return impl_->Perform( - ::std::forward_as_tuple(::std::forward<Args>(args)...)); - } - }; - - template <typename G> - using IsCompatibleFunctor = std::is_constructible<std::function<F>, G>; - - public: - typedef typename internal::Function<F>::Result Result; - typedef typename internal::Function<F>::ArgumentTuple ArgumentTuple; - - // Constructs a null Action. Needed for storing Action objects in - // STL containers. - Action() {} - - // Construct an Action from a specified callable. - // This cannot take std::function directly, because then Action would not be - // directly constructible from lambda (it would require two conversions). - template < - typename G, - typename = typename std::enable_if<internal::disjunction< - IsCompatibleFunctor<G>, std::is_constructible<std::function<Result()>, - G>>::value>::type> - Action(G&& fun) { // NOLINT - Init(::std::forward<G>(fun), IsCompatibleFunctor<G>()); - } - - // Constructs an Action from its implementation. - explicit Action(ActionInterface<F>* impl) - : fun_(ActionAdapter{::std::shared_ptr<ActionInterface<F>>(impl)}) {} - - // This constructor allows us to turn an Action<Func> object into an - // Action<F>, as long as F's arguments can be implicitly converted - // to Func's and Func's return type can be implicitly converted to F's. - template <typename Func> - explicit Action(const Action<Func>& action) : fun_(action.fun_) {} - - // Returns true if and only if this is the DoDefault() action. - bool IsDoDefault() const { return fun_ == nullptr; } - - // Performs the action. Note that this method is const even though - // the corresponding method in ActionInterface is not. The reason - // is that a const Action<F> means that it cannot be re-bound to - // another concrete action, not that the concrete action it binds to - // cannot change state. (Think of the difference between a const - // pointer and a pointer to const.) - Result Perform(ArgumentTuple args) const { - if (IsDoDefault()) { - internal::IllegalDoDefault(__FILE__, __LINE__); - } - return internal::Apply(fun_, ::std::move(args)); - } - - private: - template <typename G> - friend class Action; - - template <typename G> - void Init(G&& g, ::std::true_type) { - fun_ = ::std::forward<G>(g); - } - - template <typename G> - void Init(G&& g, ::std::false_type) { - fun_ = IgnoreArgs<typename ::std::decay<G>::type>{::std::forward<G>(g)}; - } - - template <typename FunctionImpl> - struct IgnoreArgs { - template <typename... Args> - Result operator()(const Args&...) const { - return function_impl(); - } - - FunctionImpl function_impl; - }; - - // fun_ is an empty function if and only if this is the DoDefault() action. - ::std::function<F> fun_; -}; - -// The PolymorphicAction class template makes it easy to implement a -// polymorphic action (i.e. an action that can be used in mock -// functions of than one type, e.g. Return()). -// -// To define a polymorphic action, a user first provides a COPYABLE -// implementation class that has a Perform() method template: -// -// class FooAction { -// public: -// template <typename Result, typename ArgumentTuple> -// Result Perform(const ArgumentTuple& args) const { -// // Processes the arguments and returns a result, using -// // std::get<N>(args) to get the N-th (0-based) argument in the tuple. -// } -// ... -// }; -// -// Then the user creates the polymorphic action using -// MakePolymorphicAction(object) where object has type FooAction. See -// the definition of Return(void) and SetArgumentPointee<N>(value) for -// complete examples. -template <typename Impl> -class PolymorphicAction { - public: - explicit PolymorphicAction(const Impl& impl) : impl_(impl) {} - - template <typename F> - operator Action<F>() const { - return Action<F>(new MonomorphicImpl<F>(impl_)); - } - - private: - template <typename F> - class MonomorphicImpl : public ActionInterface<F> { - public: - typedef typename internal::Function<F>::Result Result; - typedef typename internal::Function<F>::ArgumentTuple ArgumentTuple; - - explicit MonomorphicImpl(const Impl& impl) : impl_(impl) {} - - Result Perform(const ArgumentTuple& args) override { - return impl_.template Perform<Result>(args); - } - - private: - Impl impl_; - }; - - Impl impl_; -}; - -// Creates an Action from its implementation and returns it. The -// created Action object owns the implementation. -template <typename F> -Action<F> MakeAction(ActionInterface<F>* impl) { - return Action<F>(impl); -} - -// Creates a polymorphic action from its implementation. This is -// easier to use than the PolymorphicAction<Impl> constructor as it -// doesn't require you to explicitly write the template argument, e.g. -// -// MakePolymorphicAction(foo); -// vs -// PolymorphicAction<TypeOfFoo>(foo); -template <typename Impl> -inline PolymorphicAction<Impl> MakePolymorphicAction(const Impl& impl) { - return PolymorphicAction<Impl>(impl); -} - -namespace internal { - -// Helper struct to specialize ReturnAction to execute a move instead of a copy -// on return. Useful for move-only types, but could be used on any type. -template <typename T> -struct ByMoveWrapper { - explicit ByMoveWrapper(T value) : payload(std::move(value)) {} - T payload; -}; - -// Implements the polymorphic Return(x) action, which can be used in -// any function that returns the type of x, regardless of the argument -// types. -// -// Note: The value passed into Return must be converted into -// Function<F>::Result when this action is cast to Action<F> rather than -// when that action is performed. This is important in scenarios like -// -// MOCK_METHOD1(Method, T(U)); -// ... -// { -// Foo foo; -// X x(&foo); -// EXPECT_CALL(mock, Method(_)).WillOnce(Return(x)); -// } -// -// In the example above the variable x holds reference to foo which leaves -// scope and gets destroyed. If copying X just copies a reference to foo, -// that copy will be left with a hanging reference. If conversion to T -// makes a copy of foo, the above code is safe. To support that scenario, we -// need to make sure that the type conversion happens inside the EXPECT_CALL -// statement, and conversion of the result of Return to Action<T(U)> is a -// good place for that. -// -// The real life example of the above scenario happens when an invocation -// of gtl::Container() is passed into Return. -// -template <typename R> -class ReturnAction { - public: - // Constructs a ReturnAction object from the value to be returned. - // 'value' is passed by value instead of by const reference in order - // to allow Return("string literal") to compile. - explicit ReturnAction(R value) : value_(new R(std::move(value))) {} - - // This template type conversion operator allows Return(x) to be - // used in ANY function that returns x's type. - template <typename F> - operator Action<F>() const { // NOLINT - // Assert statement belongs here because this is the best place to verify - // conditions on F. It produces the clearest error messages - // in most compilers. - // Impl really belongs in this scope as a local class but can't - // because MSVC produces duplicate symbols in different translation units - // in this case. Until MS fixes that bug we put Impl into the class scope - // and put the typedef both here (for use in assert statement) and - // in the Impl class. But both definitions must be the same. - typedef typename Function<F>::Result Result; - GTEST_COMPILE_ASSERT_( - !std::is_reference<Result>::value, - use_ReturnRef_instead_of_Return_to_return_a_reference); - static_assert(!std::is_void<Result>::value, - "Can't use Return() on an action expected to return `void`."); - return Action<F>(new Impl<R, F>(value_)); - } - - private: - // Implements the Return(x) action for a particular function type F. - template <typename R_, typename F> - class Impl : public ActionInterface<F> { - public: - typedef typename Function<F>::Result Result; - typedef typename Function<F>::ArgumentTuple ArgumentTuple; - - // The implicit cast is necessary when Result has more than one - // single-argument constructor (e.g. Result is std::vector<int>) and R - // has a type conversion operator template. In that case, value_(value) - // won't compile as the compiler doesn't known which constructor of - // Result to call. ImplicitCast_ forces the compiler to convert R to - // Result without considering explicit constructors, thus resolving the - // ambiguity. value_ is then initialized using its copy constructor. - explicit Impl(const std::shared_ptr<R>& value) - : value_before_cast_(*value), - value_(ImplicitCast_<Result>(value_before_cast_)) {} - - Result Perform(const ArgumentTuple&) override { return value_; } - - private: - GTEST_COMPILE_ASSERT_(!std::is_reference<Result>::value, - Result_cannot_be_a_reference_type); - // We save the value before casting just in case it is being cast to a - // wrapper type. - R value_before_cast_; - Result value_; - - GTEST_DISALLOW_COPY_AND_ASSIGN_(Impl); - }; - - // Partially specialize for ByMoveWrapper. This version of ReturnAction will - // move its contents instead. - template <typename R_, typename F> - class Impl<ByMoveWrapper<R_>, F> : public ActionInterface<F> { - public: - typedef typename Function<F>::Result Result; - typedef typename Function<F>::ArgumentTuple ArgumentTuple; - - explicit Impl(const std::shared_ptr<R>& wrapper) - : performed_(false), wrapper_(wrapper) {} - - Result Perform(const ArgumentTuple&) override { - GTEST_CHECK_(!performed_) - << "A ByMove() action should only be performed once."; - performed_ = true; - return std::move(wrapper_->payload); - } - - private: - bool performed_; - const std::shared_ptr<R> wrapper_; - }; - - const std::shared_ptr<R> value_; -}; - -// Implements the ReturnNull() action. -class ReturnNullAction { - public: - // Allows ReturnNull() to be used in any pointer-returning function. In C++11 - // this is enforced by returning nullptr, and in non-C++11 by asserting a - // pointer type on compile time. - template <typename Result, typename ArgumentTuple> - static Result Perform(const ArgumentTuple&) { - return nullptr; - } -}; - -// Implements the Return() action. -class ReturnVoidAction { - public: - // Allows Return() to be used in any void-returning function. - template <typename Result, typename ArgumentTuple> - static void Perform(const ArgumentTuple&) { - static_assert(std::is_void<Result>::value, "Result should be void."); - } -}; - -// Implements the polymorphic ReturnRef(x) action, which can be used -// in any function that returns a reference to the type of x, -// regardless of the argument types. -template <typename T> -class ReturnRefAction { - public: - // Constructs a ReturnRefAction object from the reference to be returned. - explicit ReturnRefAction(T& ref) : ref_(ref) {} // NOLINT - - // This template type conversion operator allows ReturnRef(x) to be - // used in ANY function that returns a reference to x's type. - template <typename F> - operator Action<F>() const { - typedef typename Function<F>::Result Result; - // Asserts that the function return type is a reference. This - // catches the user error of using ReturnRef(x) when Return(x) - // should be used, and generates some helpful error message. - GTEST_COMPILE_ASSERT_(std::is_reference<Result>::value, - use_Return_instead_of_ReturnRef_to_return_a_value); - return Action<F>(new Impl<F>(ref_)); - } - - private: - // Implements the ReturnRef(x) action for a particular function type F. - template <typename F> - class Impl : public ActionInterface<F> { - public: - typedef typename Function<F>::Result Result; - typedef typename Function<F>::ArgumentTuple ArgumentTuple; - - explicit Impl(T& ref) : ref_(ref) {} // NOLINT - - Result Perform(const ArgumentTuple&) override { return ref_; } - - private: - T& ref_; - }; - - T& ref_; -}; - -// Implements the polymorphic ReturnRefOfCopy(x) action, which can be -// used in any function that returns a reference to the type of x, -// regardless of the argument types. -template <typename T> -class ReturnRefOfCopyAction { - public: - // Constructs a ReturnRefOfCopyAction object from the reference to - // be returned. - explicit ReturnRefOfCopyAction(const T& value) : value_(value) {} // NOLINT - - // This template type conversion operator allows ReturnRefOfCopy(x) to be - // used in ANY function that returns a reference to x's type. - template <typename F> - operator Action<F>() const { - typedef typename Function<F>::Result Result; - // Asserts that the function return type is a reference. This - // catches the user error of using ReturnRefOfCopy(x) when Return(x) - // should be used, and generates some helpful error message. - GTEST_COMPILE_ASSERT_( - std::is_reference<Result>::value, - use_Return_instead_of_ReturnRefOfCopy_to_return_a_value); - return Action<F>(new Impl<F>(value_)); - } - - private: - // Implements the ReturnRefOfCopy(x) action for a particular function type F. - template <typename F> - class Impl : public ActionInterface<F> { - public: - typedef typename Function<F>::Result Result; - typedef typename Function<F>::ArgumentTuple ArgumentTuple; - - explicit Impl(const T& value) : value_(value) {} // NOLINT - - Result Perform(const ArgumentTuple&) override { return value_; } - - private: - T value_; - }; - - const T value_; -}; - -// Implements the polymorphic ReturnRoundRobin(v) action, which can be -// used in any function that returns the element_type of v. -template <typename T> -class ReturnRoundRobinAction { - public: - explicit ReturnRoundRobinAction(std::vector<T> values) { - GTEST_CHECK_(!values.empty()) - << "ReturnRoundRobin requires at least one element."; - state_->values = std::move(values); - } - - template <typename... Args> - T operator()(Args&&...) const { - return state_->Next(); - } - - private: - struct State { - T Next() { - T ret_val = values[i++]; - if (i == values.size()) i = 0; - return ret_val; - } - - std::vector<T> values; - size_t i = 0; - }; - std::shared_ptr<State> state_ = std::make_shared<State>(); -}; - -// Implements the polymorphic DoDefault() action. -class DoDefaultAction { - public: - // This template type conversion operator allows DoDefault() to be - // used in any function. - template <typename F> - operator Action<F>() const { return Action<F>(); } // NOLINT -}; - -// Implements the Assign action to set a given pointer referent to a -// particular value. -template <typename T1, typename T2> -class AssignAction { - public: - AssignAction(T1* ptr, T2 value) : ptr_(ptr), value_(value) {} - - template <typename Result, typename ArgumentTuple> - void Perform(const ArgumentTuple& /* args */) const { - *ptr_ = value_; - } - - private: - T1* const ptr_; - const T2 value_; -}; - -#if !GTEST_OS_WINDOWS_MOBILE - -// Implements the SetErrnoAndReturn action to simulate return from -// various system calls and libc functions. -template <typename T> -class SetErrnoAndReturnAction { - public: - SetErrnoAndReturnAction(int errno_value, T result) - : errno_(errno_value), - result_(result) {} - template <typename Result, typename ArgumentTuple> - Result Perform(const ArgumentTuple& /* args */) const { - errno = errno_; - return result_; - } - - private: - const int errno_; - const T result_; -}; - -#endif // !GTEST_OS_WINDOWS_MOBILE - -// Implements the SetArgumentPointee<N>(x) action for any function -// whose N-th argument (0-based) is a pointer to x's type. -template <size_t N, typename A, typename = void> -struct SetArgumentPointeeAction { - A value; - - template <typename... Args> - void operator()(const Args&... args) const { - *::std::get<N>(std::tie(args...)) = value; - } -}; - -// Implements the Invoke(object_ptr, &Class::Method) action. -template <class Class, typename MethodPtr> -struct InvokeMethodAction { - Class* const obj_ptr; - const MethodPtr method_ptr; - - template <typename... Args> - auto operator()(Args&&... args) const - -> decltype((obj_ptr->*method_ptr)(std::forward<Args>(args)...)) { - return (obj_ptr->*method_ptr)(std::forward<Args>(args)...); - } -}; - -// Implements the InvokeWithoutArgs(f) action. The template argument -// FunctionImpl is the implementation type of f, which can be either a -// function pointer or a functor. InvokeWithoutArgs(f) can be used as an -// Action<F> as long as f's type is compatible with F. -template <typename FunctionImpl> -struct InvokeWithoutArgsAction { - FunctionImpl function_impl; - - // Allows InvokeWithoutArgs(f) to be used as any action whose type is - // compatible with f. - template <typename... Args> - auto operator()(const Args&...) -> decltype(function_impl()) { - return function_impl(); - } -}; - -// Implements the InvokeWithoutArgs(object_ptr, &Class::Method) action. -template <class Class, typename MethodPtr> -struct InvokeMethodWithoutArgsAction { - Class* const obj_ptr; - const MethodPtr method_ptr; - - using ReturnType = - decltype((std::declval<Class*>()->*std::declval<MethodPtr>())()); - - template <typename... Args> - ReturnType operator()(const Args&...) const { - return (obj_ptr->*method_ptr)(); - } -}; - -// Implements the IgnoreResult(action) action. -template <typename A> -class IgnoreResultAction { - public: - explicit IgnoreResultAction(const A& action) : action_(action) {} - - template <typename F> - operator Action<F>() const { - // Assert statement belongs here because this is the best place to verify - // conditions on F. It produces the clearest error messages - // in most compilers. - // Impl really belongs in this scope as a local class but can't - // because MSVC produces duplicate symbols in different translation units - // in this case. Until MS fixes that bug we put Impl into the class scope - // and put the typedef both here (for use in assert statement) and - // in the Impl class. But both definitions must be the same. - typedef typename internal::Function<F>::Result Result; - - // Asserts at compile time that F returns void. - static_assert(std::is_void<Result>::value, "Result type should be void."); - - return Action<F>(new Impl<F>(action_)); - } - - private: - template <typename F> - class Impl : public ActionInterface<F> { - public: - typedef typename internal::Function<F>::Result Result; - typedef typename internal::Function<F>::ArgumentTuple ArgumentTuple; - - explicit Impl(const A& action) : action_(action) {} - - void Perform(const ArgumentTuple& args) override { - // Performs the action and ignores its result. - action_.Perform(args); - } - - private: - // Type OriginalFunction is the same as F except that its return - // type is IgnoredValue. - typedef typename internal::Function<F>::MakeResultIgnoredValue - OriginalFunction; - - const Action<OriginalFunction> action_; - }; - - const A action_; -}; - -template <typename InnerAction, size_t... I> -struct WithArgsAction { - InnerAction action; - - // The inner action could be anything convertible to Action<X>. - // We use the conversion operator to detect the signature of the inner Action. - template <typename R, typename... Args> - operator Action<R(Args...)>() const { // NOLINT - using TupleType = std::tuple<Args...>; - Action<R(typename std::tuple_element<I, TupleType>::type...)> - converted(action); - - return [converted](Args... args) -> R { - return converted.Perform(std::forward_as_tuple( - std::get<I>(std::forward_as_tuple(std::forward<Args>(args)...))...)); - }; - } -}; - -template <typename... Actions> -struct DoAllAction { - private: - template <typename T> - using NonFinalType = - typename std::conditional<std::is_scalar<T>::value, T, const T&>::type; - - template <typename ActionT, size_t... I> - std::vector<ActionT> Convert(IndexSequence<I...>) const { - return {ActionT(std::get<I>(actions))...}; - } - - public: - std::tuple<Actions...> actions; - - template <typename R, typename... Args> - operator Action<R(Args...)>() const { // NOLINT - struct Op { - std::vector<Action<void(NonFinalType<Args>...)>> converted; - Action<R(Args...)> last; - R operator()(Args... args) const { - auto tuple_args = std::forward_as_tuple(std::forward<Args>(args)...); - for (auto& a : converted) { - a.Perform(tuple_args); - } - return last.Perform(std::move(tuple_args)); - } - }; - return Op{Convert<Action<void(NonFinalType<Args>...)>>( - MakeIndexSequence<sizeof...(Actions) - 1>()), - std::get<sizeof...(Actions) - 1>(actions)}; - } -}; - -template <typename T, typename... Params> -struct ReturnNewAction { - T* operator()() const { - return internal::Apply( - [](const Params&... unpacked_params) { - return new T(unpacked_params...); - }, - params); - } - std::tuple<Params...> params; -}; - -template <size_t k> -struct ReturnArgAction { - template <typename... Args> - auto operator()(const Args&... args) const -> - typename std::tuple_element<k, std::tuple<Args...>>::type { - return std::get<k>(std::tie(args...)); - } -}; - -template <size_t k, typename Ptr> -struct SaveArgAction { - Ptr pointer; - - template <typename... Args> - void operator()(const Args&... args) const { - *pointer = std::get<k>(std::tie(args...)); - } -}; - -template <size_t k, typename Ptr> -struct SaveArgPointeeAction { - Ptr pointer; - - template <typename... Args> - void operator()(const Args&... args) const { - *pointer = *std::get<k>(std::tie(args...)); - } -}; - -template <size_t k, typename T> -struct SetArgRefereeAction { - T value; - - template <typename... Args> - void operator()(Args&&... args) const { - using argk_type = - typename ::std::tuple_element<k, std::tuple<Args...>>::type; - static_assert(std::is_lvalue_reference<argk_type>::value, - "Argument must be a reference type."); - std::get<k>(std::tie(args...)) = value; - } -}; - -template <size_t k, typename I1, typename I2> -struct SetArrayArgumentAction { - I1 first; - I2 last; - - template <typename... Args> - void operator()(const Args&... args) const { - auto value = std::get<k>(std::tie(args...)); - for (auto it = first; it != last; ++it, (void)++value) { - *value = *it; - } - } -}; - -template <size_t k> -struct DeleteArgAction { - template <typename... Args> - void operator()(const Args&... args) const { - delete std::get<k>(std::tie(args...)); - } -}; - -template <typename Ptr> -struct ReturnPointeeAction { - Ptr pointer; - template <typename... Args> - auto operator()(const Args&...) const -> decltype(*pointer) { - return *pointer; - } -}; - -#if GTEST_HAS_EXCEPTIONS -template <typename T> -struct ThrowAction { - T exception; - // We use a conversion operator to adapt to any return type. - template <typename R, typename... Args> - operator Action<R(Args...)>() const { // NOLINT - T copy = exception; - return [copy](Args...) -> R { throw copy; }; - } -}; -#endif // GTEST_HAS_EXCEPTIONS - -} // namespace internal - -// An Unused object can be implicitly constructed from ANY value. -// This is handy when defining actions that ignore some or all of the -// mock function arguments. For example, given -// -// MOCK_METHOD3(Foo, double(const string& label, double x, double y)); -// MOCK_METHOD3(Bar, double(int index, double x, double y)); -// -// instead of -// -// double DistanceToOriginWithLabel(const string& label, double x, double y) { -// return sqrt(x*x + y*y); -// } -// double DistanceToOriginWithIndex(int index, double x, double y) { -// return sqrt(x*x + y*y); -// } -// ... -// EXPECT_CALL(mock, Foo("abc", _, _)) -// .WillOnce(Invoke(DistanceToOriginWithLabel)); -// EXPECT_CALL(mock, Bar(5, _, _)) -// .WillOnce(Invoke(DistanceToOriginWithIndex)); -// -// you could write -// -// // We can declare any uninteresting argument as Unused. -// double DistanceToOrigin(Unused, double x, double y) { -// return sqrt(x*x + y*y); -// } -// ... -// EXPECT_CALL(mock, Foo("abc", _, _)).WillOnce(Invoke(DistanceToOrigin)); -// EXPECT_CALL(mock, Bar(5, _, _)).WillOnce(Invoke(DistanceToOrigin)); -typedef internal::IgnoredValue Unused; - -// Creates an action that does actions a1, a2, ..., sequentially in -// each invocation. All but the last action will have a readonly view of the -// arguments. -template <typename... Action> -internal::DoAllAction<typename std::decay<Action>::type...> DoAll( - Action&&... action) { - return {std::forward_as_tuple(std::forward<Action>(action)...)}; -} - -// WithArg<k>(an_action) creates an action that passes the k-th -// (0-based) argument of the mock function to an_action and performs -// it. It adapts an action accepting one argument to one that accepts -// multiple arguments. For convenience, we also provide -// WithArgs<k>(an_action) (defined below) as a synonym. -template <size_t k, typename InnerAction> -internal::WithArgsAction<typename std::decay<InnerAction>::type, k> -WithArg(InnerAction&& action) { - return {std::forward<InnerAction>(action)}; -} - -// WithArgs<N1, N2, ..., Nk>(an_action) creates an action that passes -// the selected arguments of the mock function to an_action and -// performs it. It serves as an adaptor between actions with -// different argument lists. -template <size_t k, size_t... ks, typename InnerAction> -internal::WithArgsAction<typename std::decay<InnerAction>::type, k, ks...> -WithArgs(InnerAction&& action) { - return {std::forward<InnerAction>(action)}; -} - -// WithoutArgs(inner_action) can be used in a mock function with a -// non-empty argument list to perform inner_action, which takes no -// argument. In other words, it adapts an action accepting no -// argument to one that accepts (and ignores) arguments. -template <typename InnerAction> -internal::WithArgsAction<typename std::decay<InnerAction>::type> -WithoutArgs(InnerAction&& action) { - return {std::forward<InnerAction>(action)}; -} - -// Creates an action that returns 'value'. 'value' is passed by value -// instead of const reference - otherwise Return("string literal") -// will trigger a compiler error about using array as initializer. -template <typename R> -internal::ReturnAction<R> Return(R value) { - return internal::ReturnAction<R>(std::move(value)); -} - -// Creates an action that returns NULL. -inline PolymorphicAction<internal::ReturnNullAction> ReturnNull() { - return MakePolymorphicAction(internal::ReturnNullAction()); -} - -// Creates an action that returns from a void function. -inline PolymorphicAction<internal::ReturnVoidAction> Return() { - return MakePolymorphicAction(internal::ReturnVoidAction()); -} - -// Creates an action that returns the reference to a variable. -template <typename R> -inline internal::ReturnRefAction<R> ReturnRef(R& x) { // NOLINT - return internal::ReturnRefAction<R>(x); -} - -// Prevent using ReturnRef on reference to temporary. -template <typename R, R* = nullptr> -internal::ReturnRefAction<R> ReturnRef(R&&) = delete; - -// Creates an action that returns the reference to a copy of the -// argument. The copy is created when the action is constructed and -// lives as long as the action. -template <typename R> -inline internal::ReturnRefOfCopyAction<R> ReturnRefOfCopy(const R& x) { - return internal::ReturnRefOfCopyAction<R>(x); -} - -// Modifies the parent action (a Return() action) to perform a move of the -// argument instead of a copy. -// Return(ByMove()) actions can only be executed once and will assert this -// invariant. -template <typename R> -internal::ByMoveWrapper<R> ByMove(R x) { - return internal::ByMoveWrapper<R>(std::move(x)); -} - -// Creates an action that returns an element of `vals`. Calling this action will -// repeatedly return the next value from `vals` until it reaches the end and -// will restart from the beginning. -template <typename T> -internal::ReturnRoundRobinAction<T> ReturnRoundRobin(std::vector<T> vals) { - return internal::ReturnRoundRobinAction<T>(std::move(vals)); -} - -// Creates an action that returns an element of `vals`. Calling this action will -// repeatedly return the next value from `vals` until it reaches the end and -// will restart from the beginning. -template <typename T> -internal::ReturnRoundRobinAction<T> ReturnRoundRobin( - std::initializer_list<T> vals) { - return internal::ReturnRoundRobinAction<T>(std::vector<T>(vals)); -} - -// Creates an action that does the default action for the give mock function. -inline internal::DoDefaultAction DoDefault() { - return internal::DoDefaultAction(); -} - -// Creates an action that sets the variable pointed by the N-th -// (0-based) function argument to 'value'. -template <size_t N, typename T> -internal::SetArgumentPointeeAction<N, T> SetArgPointee(T value) { - return {std::move(value)}; -} - -// The following version is DEPRECATED. -template <size_t N, typename T> -internal::SetArgumentPointeeAction<N, T> SetArgumentPointee(T value) { - return {std::move(value)}; -} - -// Creates an action that sets a pointer referent to a given value. -template <typename T1, typename T2> -PolymorphicAction<internal::AssignAction<T1, T2> > Assign(T1* ptr, T2 val) { - return MakePolymorphicAction(internal::AssignAction<T1, T2>(ptr, val)); -} - -#if !GTEST_OS_WINDOWS_MOBILE - -// Creates an action that sets errno and returns the appropriate error. -template <typename T> -PolymorphicAction<internal::SetErrnoAndReturnAction<T> > -SetErrnoAndReturn(int errval, T result) { - return MakePolymorphicAction( - internal::SetErrnoAndReturnAction<T>(errval, result)); -} - -#endif // !GTEST_OS_WINDOWS_MOBILE - -// Various overloads for Invoke(). - -// Legacy function. -// Actions can now be implicitly constructed from callables. No need to create -// wrapper objects. -// This function exists for backwards compatibility. -template <typename FunctionImpl> -typename std::decay<FunctionImpl>::type Invoke(FunctionImpl&& function_impl) { - return std::forward<FunctionImpl>(function_impl); -} - -// Creates an action that invokes the given method on the given object -// with the mock function's arguments. -template <class Class, typename MethodPtr> -internal::InvokeMethodAction<Class, MethodPtr> Invoke(Class* obj_ptr, - MethodPtr method_ptr) { - return {obj_ptr, method_ptr}; -} - -// Creates an action that invokes 'function_impl' with no argument. -template <typename FunctionImpl> -internal::InvokeWithoutArgsAction<typename std::decay<FunctionImpl>::type> -InvokeWithoutArgs(FunctionImpl function_impl) { - return {std::move(function_impl)}; -} - -// Creates an action that invokes the given method on the given object -// with no argument. -template <class Class, typename MethodPtr> -internal::InvokeMethodWithoutArgsAction<Class, MethodPtr> InvokeWithoutArgs( - Class* obj_ptr, MethodPtr method_ptr) { - return {obj_ptr, method_ptr}; -} - -// Creates an action that performs an_action and throws away its -// result. In other words, it changes the return type of an_action to -// void. an_action MUST NOT return void, or the code won't compile. -template <typename A> -inline internal::IgnoreResultAction<A> IgnoreResult(const A& an_action) { - return internal::IgnoreResultAction<A>(an_action); -} - -// Creates a reference wrapper for the given L-value. If necessary, -// you can explicitly specify the type of the reference. For example, -// suppose 'derived' is an object of type Derived, ByRef(derived) -// would wrap a Derived&. If you want to wrap a const Base& instead, -// where Base is a base class of Derived, just write: -// -// ByRef<const Base>(derived) -// -// N.B. ByRef is redundant with std::ref, std::cref and std::reference_wrapper. -// However, it may still be used for consistency with ByMove(). -template <typename T> -inline ::std::reference_wrapper<T> ByRef(T& l_value) { // NOLINT - return ::std::reference_wrapper<T>(l_value); -} - -// The ReturnNew<T>(a1, a2, ..., a_k) action returns a pointer to a new -// instance of type T, constructed on the heap with constructor arguments -// a1, a2, ..., and a_k. The caller assumes ownership of the returned value. -template <typename T, typename... Params> -internal::ReturnNewAction<T, typename std::decay<Params>::type...> ReturnNew( - Params&&... params) { - return {std::forward_as_tuple(std::forward<Params>(params)...)}; -} - -// Action ReturnArg<k>() returns the k-th argument of the mock function. -template <size_t k> -internal::ReturnArgAction<k> ReturnArg() { - return {}; -} - -// Action SaveArg<k>(pointer) saves the k-th (0-based) argument of the -// mock function to *pointer. -template <size_t k, typename Ptr> -internal::SaveArgAction<k, Ptr> SaveArg(Ptr pointer) { - return {pointer}; -} - -// Action SaveArgPointee<k>(pointer) saves the value pointed to -// by the k-th (0-based) argument of the mock function to *pointer. -template <size_t k, typename Ptr> -internal::SaveArgPointeeAction<k, Ptr> SaveArgPointee(Ptr pointer) { - return {pointer}; -} - -// Action SetArgReferee<k>(value) assigns 'value' to the variable -// referenced by the k-th (0-based) argument of the mock function. -template <size_t k, typename T> -internal::SetArgRefereeAction<k, typename std::decay<T>::type> SetArgReferee( - T&& value) { - return {std::forward<T>(value)}; -} - -// Action SetArrayArgument<k>(first, last) copies the elements in -// source range [first, last) to the array pointed to by the k-th -// (0-based) argument, which can be either a pointer or an -// iterator. The action does not take ownership of the elements in the -// source range. -template <size_t k, typename I1, typename I2> -internal::SetArrayArgumentAction<k, I1, I2> SetArrayArgument(I1 first, - I2 last) { - return {first, last}; -} - -// Action DeleteArg<k>() deletes the k-th (0-based) argument of the mock -// function. -template <size_t k> -internal::DeleteArgAction<k> DeleteArg() { - return {}; -} - -// This action returns the value pointed to by 'pointer'. -template <typename Ptr> -internal::ReturnPointeeAction<Ptr> ReturnPointee(Ptr pointer) { - return {pointer}; -} - -// Action Throw(exception) can be used in a mock function of any type -// to throw the given exception. Any copyable value can be thrown. -#if GTEST_HAS_EXCEPTIONS -template <typename T> -internal::ThrowAction<typename std::decay<T>::type> Throw(T&& exception) { - return {std::forward<T>(exception)}; -} -#endif // GTEST_HAS_EXCEPTIONS - -namespace internal { - -// A macro from the ACTION* family (defined later in gmock-generated-actions.h) -// defines an action that can be used in a mock function. Typically, -// these actions only care about a subset of the arguments of the mock -// function. For example, if such an action only uses the second -// argument, it can be used in any mock function that takes >= 2 -// arguments where the type of the second argument is compatible. -// -// Therefore, the action implementation must be prepared to take more -// arguments than it needs. The ExcessiveArg type is used to -// represent those excessive arguments. In order to keep the compiler -// error messages tractable, we define it in the testing namespace -// instead of testing::internal. However, this is an INTERNAL TYPE -// and subject to change without notice, so a user MUST NOT USE THIS -// TYPE DIRECTLY. -struct ExcessiveArg {}; - -// Builds an implementation of an Action<> for some particular signature, using -// a class defined by an ACTION* macro. -template <typename F, typename Impl> struct ActionImpl; - -template <typename Impl> -struct ImplBase { - struct Holder { - // Allows each copy of the Action<> to get to the Impl. - explicit operator const Impl&() const { return *ptr; } - std::shared_ptr<Impl> ptr; - }; - using type = typename std::conditional<std::is_constructible<Impl>::value, - Impl, Holder>::type; -}; - -template <typename R, typename... Args, typename Impl> -struct ActionImpl<R(Args...), Impl> : ImplBase<Impl>::type { - using Base = typename ImplBase<Impl>::type; - using function_type = R(Args...); - using args_type = std::tuple<Args...>; - - ActionImpl() = default; // Only defined if appropriate for Base. - explicit ActionImpl(std::shared_ptr<Impl> impl) : Base{std::move(impl)} { } - - R operator()(Args&&... arg) const { - static constexpr size_t kMaxArgs = - sizeof...(Args) <= 10 ? sizeof...(Args) : 10; - return Apply(MakeIndexSequence<kMaxArgs>{}, - MakeIndexSequence<10 - kMaxArgs>{}, - args_type{std::forward<Args>(arg)...}); - } - - template <std::size_t... arg_id, std::size_t... excess_id> - R Apply(IndexSequence<arg_id...>, IndexSequence<excess_id...>, - const args_type& args) const { - // Impl need not be specific to the signature of action being implemented; - // only the implementing function body needs to have all of the specific - // types instantiated. Up to 10 of the args that are provided by the - // args_type get passed, followed by a dummy of unspecified type for the - // remainder up to 10 explicit args. - static constexpr ExcessiveArg kExcessArg{}; - return static_cast<const Impl&>(*this).template gmock_PerformImpl< - /*function_type=*/function_type, /*return_type=*/R, - /*args_type=*/args_type, - /*argN_type=*/typename std::tuple_element<arg_id, args_type>::type...>( - /*args=*/args, std::get<arg_id>(args)..., - ((void)excess_id, kExcessArg)...); - } -}; - -// Stores a default-constructed Impl as part of the Action<>'s -// std::function<>. The Impl should be trivial to copy. -template <typename F, typename Impl> -::testing::Action<F> MakeAction() { - return ::testing::Action<F>(ActionImpl<F, Impl>()); -} - -// Stores just the one given instance of Impl. -template <typename F, typename Impl> -::testing::Action<F> MakeAction(std::shared_ptr<Impl> impl) { - return ::testing::Action<F>(ActionImpl<F, Impl>(std::move(impl))); -} - -#define GMOCK_INTERNAL_ARG_UNUSED(i, data, el) \ - , const arg##i##_type& arg##i GTEST_ATTRIBUTE_UNUSED_ -#define GMOCK_ACTION_ARG_TYPES_AND_NAMES_UNUSED_ \ - const args_type& args GTEST_ATTRIBUTE_UNUSED_ GMOCK_PP_REPEAT( \ - GMOCK_INTERNAL_ARG_UNUSED, , 10) - -#define GMOCK_INTERNAL_ARG(i, data, el) , const arg##i##_type& arg##i -#define GMOCK_ACTION_ARG_TYPES_AND_NAMES_ \ - const args_type& args GMOCK_PP_REPEAT(GMOCK_INTERNAL_ARG, , 10) - -#define GMOCK_INTERNAL_TEMPLATE_ARG(i, data, el) , typename arg##i##_type -#define GMOCK_ACTION_TEMPLATE_ARGS_NAMES_ \ - GMOCK_PP_TAIL(GMOCK_PP_REPEAT(GMOCK_INTERNAL_TEMPLATE_ARG, , 10)) - -#define GMOCK_INTERNAL_TYPENAME_PARAM(i, data, param) , typename param##_type -#define GMOCK_ACTION_TYPENAME_PARAMS_(params) \ - GMOCK_PP_TAIL(GMOCK_PP_FOR_EACH(GMOCK_INTERNAL_TYPENAME_PARAM, , params)) - -#define GMOCK_INTERNAL_TYPE_PARAM(i, data, param) , param##_type -#define GMOCK_ACTION_TYPE_PARAMS_(params) \ - GMOCK_PP_TAIL(GMOCK_PP_FOR_EACH(GMOCK_INTERNAL_TYPE_PARAM, , params)) - -#define GMOCK_INTERNAL_TYPE_GVALUE_PARAM(i, data, param) \ - , param##_type gmock_p##i -#define GMOCK_ACTION_TYPE_GVALUE_PARAMS_(params) \ - GMOCK_PP_TAIL(GMOCK_PP_FOR_EACH(GMOCK_INTERNAL_TYPE_GVALUE_PARAM, , params)) - -#define GMOCK_INTERNAL_GVALUE_PARAM(i, data, param) \ - , std::forward<param##_type>(gmock_p##i) -#define GMOCK_ACTION_GVALUE_PARAMS_(params) \ - GMOCK_PP_TAIL(GMOCK_PP_FOR_EACH(GMOCK_INTERNAL_GVALUE_PARAM, , params)) - -#define GMOCK_INTERNAL_INIT_PARAM(i, data, param) \ - , param(::std::forward<param##_type>(gmock_p##i)) -#define GMOCK_ACTION_INIT_PARAMS_(params) \ - GMOCK_PP_TAIL(GMOCK_PP_FOR_EACH(GMOCK_INTERNAL_INIT_PARAM, , params)) - -#define GMOCK_INTERNAL_FIELD_PARAM(i, data, param) param##_type param; -#define GMOCK_ACTION_FIELD_PARAMS_(params) \ - GMOCK_PP_FOR_EACH(GMOCK_INTERNAL_FIELD_PARAM, , params) - -#define GMOCK_INTERNAL_ACTION(name, full_name, params) \ - template <GMOCK_ACTION_TYPENAME_PARAMS_(params)> \ - class full_name { \ - public: \ - explicit full_name(GMOCK_ACTION_TYPE_GVALUE_PARAMS_(params)) \ - : impl_(std::make_shared<gmock_Impl>( \ - GMOCK_ACTION_GVALUE_PARAMS_(params))) { } \ - full_name(const full_name&) = default; \ - full_name(full_name&&) noexcept = default; \ - template <typename F> \ - operator ::testing::Action<F>() const { \ - return ::testing::internal::MakeAction<F>(impl_); \ - } \ - private: \ - class gmock_Impl { \ - public: \ - explicit gmock_Impl(GMOCK_ACTION_TYPE_GVALUE_PARAMS_(params)) \ - : GMOCK_ACTION_INIT_PARAMS_(params) {} \ - template <typename function_type, typename return_type, \ - typename args_type, GMOCK_ACTION_TEMPLATE_ARGS_NAMES_> \ - return_type gmock_PerformImpl(GMOCK_ACTION_ARG_TYPES_AND_NAMES_) const; \ - GMOCK_ACTION_FIELD_PARAMS_(params) \ - }; \ - std::shared_ptr<const gmock_Impl> impl_; \ - }; \ - template <GMOCK_ACTION_TYPENAME_PARAMS_(params)> \ - inline full_name<GMOCK_ACTION_TYPE_PARAMS_(params)> name( \ - GMOCK_ACTION_TYPE_GVALUE_PARAMS_(params)) { \ - return full_name<GMOCK_ACTION_TYPE_PARAMS_(params)>( \ - GMOCK_ACTION_GVALUE_PARAMS_(params)); \ - } \ - template <GMOCK_ACTION_TYPENAME_PARAMS_(params)> \ - template <typename function_type, typename return_type, typename args_type, \ - GMOCK_ACTION_TEMPLATE_ARGS_NAMES_> \ - return_type full_name<GMOCK_ACTION_TYPE_PARAMS_(params)>::gmock_Impl:: \ - gmock_PerformImpl(GMOCK_ACTION_ARG_TYPES_AND_NAMES_UNUSED_) const - -} // namespace internal - -// Similar to GMOCK_INTERNAL_ACTION, but no bound parameters are stored. -#define ACTION(name) \ - class name##Action { \ - public: \ - explicit name##Action() noexcept {} \ - name##Action(const name##Action&) noexcept {} \ - template <typename F> \ - operator ::testing::Action<F>() const { \ - return ::testing::internal::MakeAction<F, gmock_Impl>(); \ - } \ - private: \ - class gmock_Impl { \ - public: \ - template <typename function_type, typename return_type, \ - typename args_type, GMOCK_ACTION_TEMPLATE_ARGS_NAMES_> \ - return_type gmock_PerformImpl(GMOCK_ACTION_ARG_TYPES_AND_NAMES_) const; \ - }; \ - }; \ - inline name##Action name() GTEST_MUST_USE_RESULT_; \ - inline name##Action name() { return name##Action(); } \ - template <typename function_type, typename return_type, typename args_type, \ - GMOCK_ACTION_TEMPLATE_ARGS_NAMES_> \ - return_type name##Action::gmock_Impl::gmock_PerformImpl( \ - GMOCK_ACTION_ARG_TYPES_AND_NAMES_UNUSED_) const - -#define ACTION_P(name, ...) \ - GMOCK_INTERNAL_ACTION(name, name##ActionP, (__VA_ARGS__)) - -#define ACTION_P2(name, ...) \ - GMOCK_INTERNAL_ACTION(name, name##ActionP2, (__VA_ARGS__)) - -#define ACTION_P3(name, ...) \ - GMOCK_INTERNAL_ACTION(name, name##ActionP3, (__VA_ARGS__)) - -#define ACTION_P4(name, ...) \ - GMOCK_INTERNAL_ACTION(name, name##ActionP4, (__VA_ARGS__)) - -#define ACTION_P5(name, ...) \ - GMOCK_INTERNAL_ACTION(name, name##ActionP5, (__VA_ARGS__)) - -#define ACTION_P6(name, ...) \ - GMOCK_INTERNAL_ACTION(name, name##ActionP6, (__VA_ARGS__)) - -#define ACTION_P7(name, ...) \ - GMOCK_INTERNAL_ACTION(name, name##ActionP7, (__VA_ARGS__)) - -#define ACTION_P8(name, ...) \ - GMOCK_INTERNAL_ACTION(name, name##ActionP8, (__VA_ARGS__)) - -#define ACTION_P9(name, ...) \ - GMOCK_INTERNAL_ACTION(name, name##ActionP9, (__VA_ARGS__)) - -#define ACTION_P10(name, ...) \ - GMOCK_INTERNAL_ACTION(name, name##ActionP10, (__VA_ARGS__)) - -} // namespace testing - -#ifdef _MSC_VER -# pragma warning(pop) -#endif - -#endif // GOOGLEMOCK_INCLUDE_GMOCK_GMOCK_ACTIONS_H_ -// Copyright 2007, 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. - - -// Google Mock - a framework for writing C++ mock classes. -// -// This file implements some commonly used cardinalities. More -// cardinalities can be defined by the user implementing the -// CardinalityInterface interface if necessary. - -// GOOGLETEST_CM0002 DO NOT DELETE - -#ifndef GOOGLEMOCK_INCLUDE_GMOCK_GMOCK_CARDINALITIES_H_ -#define GOOGLEMOCK_INCLUDE_GMOCK_GMOCK_CARDINALITIES_H_ - -#include <limits.h> -#include <memory> -#include <ostream> // NOLINT - -GTEST_DISABLE_MSC_WARNINGS_PUSH_(4251 \ -/* class A needs to have dll-interface to be used by clients of class B */) - -namespace testing { - -// To implement a cardinality Foo, define: -// 1. a class FooCardinality that implements the -// CardinalityInterface interface, and -// 2. a factory function that creates a Cardinality object from a -// const FooCardinality*. -// -// The two-level delegation design follows that of Matcher, providing -// consistency for extension developers. It also eases ownership -// management as Cardinality objects can now be copied like plain values. - -// The implementation of a cardinality. -class CardinalityInterface { - public: - virtual ~CardinalityInterface() {} - - // Conservative estimate on the lower/upper bound of the number of - // calls allowed. - virtual int ConservativeLowerBound() const { return 0; } - virtual int ConservativeUpperBound() const { return INT_MAX; } - - // Returns true if and only if call_count calls will satisfy this - // cardinality. - virtual bool IsSatisfiedByCallCount(int call_count) const = 0; - - // Returns true if and only if call_count calls will saturate this - // cardinality. - virtual bool IsSaturatedByCallCount(int call_count) const = 0; - - // Describes self to an ostream. - virtual void DescribeTo(::std::ostream* os) const = 0; -}; - -// A Cardinality is a copyable and IMMUTABLE (except by assignment) -// object that specifies how many times a mock function is expected to -// be called. The implementation of Cardinality is just a std::shared_ptr -// to const CardinalityInterface. Don't inherit from Cardinality! -class GTEST_API_ Cardinality { - public: - // Constructs a null cardinality. Needed for storing Cardinality - // objects in STL containers. - Cardinality() {} - - // Constructs a Cardinality from its implementation. - explicit Cardinality(const CardinalityInterface* impl) : impl_(impl) {} - - // Conservative estimate on the lower/upper bound of the number of - // calls allowed. - int ConservativeLowerBound() const { return impl_->ConservativeLowerBound(); } - int ConservativeUpperBound() const { return impl_->ConservativeUpperBound(); } - - // Returns true if and only if call_count calls will satisfy this - // cardinality. - bool IsSatisfiedByCallCount(int call_count) const { - return impl_->IsSatisfiedByCallCount(call_count); - } - - // Returns true if and only if call_count calls will saturate this - // cardinality. - bool IsSaturatedByCallCount(int call_count) const { - return impl_->IsSaturatedByCallCount(call_count); - } - - // Returns true if and only if call_count calls will over-saturate this - // cardinality, i.e. exceed the maximum number of allowed calls. - bool IsOverSaturatedByCallCount(int call_count) const { - return impl_->IsSaturatedByCallCount(call_count) && - !impl_->IsSatisfiedByCallCount(call_count); - } - - // Describes self to an ostream - void DescribeTo(::std::ostream* os) const { impl_->DescribeTo(os); } - - // Describes the given actual call count to an ostream. - static void DescribeActualCallCountTo(int actual_call_count, - ::std::ostream* os); - - private: - std::shared_ptr<const CardinalityInterface> impl_; -}; - -// Creates a cardinality that allows at least n calls. -GTEST_API_ Cardinality AtLeast(int n); - -// Creates a cardinality that allows at most n calls. -GTEST_API_ Cardinality AtMost(int n); - -// Creates a cardinality that allows any number of calls. -GTEST_API_ Cardinality AnyNumber(); - -// Creates a cardinality that allows between min and max calls. -GTEST_API_ Cardinality Between(int min, int max); - -// Creates a cardinality that allows exactly n calls. -GTEST_API_ Cardinality Exactly(int n); - -// Creates a cardinality from its implementation. -inline Cardinality MakeCardinality(const CardinalityInterface* c) { - return Cardinality(c); -} - -} // namespace testing - -GTEST_DISABLE_MSC_WARNINGS_POP_() // 4251 - -#endif // GOOGLEMOCK_INCLUDE_GMOCK_GMOCK_CARDINALITIES_H_ -// Copyright 2007, 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. - -// Google Mock - a framework for writing C++ mock classes. -// -// This file implements MOCK_METHOD. - -// GOOGLETEST_CM0002 DO NOT DELETE - -#ifndef GOOGLEMOCK_INCLUDE_GMOCK_INTERNAL_GMOCK_FUNCTION_MOCKER_H_ // NOLINT -#define GOOGLEMOCK_INCLUDE_GMOCK_INTERNAL_GMOCK_FUNCTION_MOCKER_H_ // NOLINT - -#include <type_traits> // IWYU pragma: keep -#include <utility> // IWYU pragma: keep - -// Copyright 2007, 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. - - -// Google Mock - a framework for writing C++ mock classes. -// -// This file implements the ON_CALL() and EXPECT_CALL() macros. -// -// A user can use the ON_CALL() macro to specify the default action of -// a mock method. The syntax is: -// -// ON_CALL(mock_object, Method(argument-matchers)) -// .With(multi-argument-matcher) -// .WillByDefault(action); -// -// where the .With() clause is optional. -// -// A user can use the EXPECT_CALL() macro to specify an expectation on -// a mock method. The syntax is: -// -// EXPECT_CALL(mock_object, Method(argument-matchers)) -// .With(multi-argument-matchers) -// .Times(cardinality) -// .InSequence(sequences) -// .After(expectations) -// .WillOnce(action) -// .WillRepeatedly(action) -// .RetiresOnSaturation(); -// -// where all clauses are optional, and .InSequence()/.After()/ -// .WillOnce() can appear any number of times. - -// GOOGLETEST_CM0002 DO NOT DELETE - -#ifndef GOOGLEMOCK_INCLUDE_GMOCK_GMOCK_SPEC_BUILDERS_H_ -#define GOOGLEMOCK_INCLUDE_GMOCK_GMOCK_SPEC_BUILDERS_H_ - -#include <cstdint> -#include <functional> -#include <map> -#include <memory> -#include <set> -#include <sstream> -#include <string> -#include <type_traits> -#include <utility> -#include <vector> -// Copyright 2007, 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. - - -// Google Mock - a framework for writing C++ mock classes. -// -// The MATCHER* family of macros can be used in a namespace scope to -// define custom matchers easily. -// -// Basic Usage -// =========== -// -// The syntax -// -// MATCHER(name, description_string) { statements; } -// -// defines a matcher with the given name that executes the statements, -// which must return a bool to indicate if the match succeeds. Inside -// the statements, you can refer to the value being matched by 'arg', -// and refer to its type by 'arg_type'. -// -// The description string documents what the matcher does, and is used -// to generate the failure message when the match fails. Since a -// MATCHER() is usually defined in a header file shared by multiple -// C++ source files, we require the description to be a C-string -// literal to avoid possible side effects. It can be empty, in which -// case we'll use the sequence of words in the matcher name as the -// description. -// -// For example: -// -// MATCHER(IsEven, "") { return (arg % 2) == 0; } -// -// allows you to write -// -// // Expects mock_foo.Bar(n) to be called where n is even. -// EXPECT_CALL(mock_foo, Bar(IsEven())); -// -// or, -// -// // Verifies that the value of some_expression is even. -// EXPECT_THAT(some_expression, IsEven()); -// -// If the above assertion fails, it will print something like: -// -// Value of: some_expression -// Expected: is even -// Actual: 7 -// -// where the description "is even" is automatically calculated from the -// matcher name IsEven. -// -// Argument Type -// ============= -// -// Note that the type of the value being matched (arg_type) is -// determined by the context in which you use the matcher and is -// supplied to you by the compiler, so you don't need to worry about -// declaring it (nor can you). This allows the matcher to be -// polymorphic. For example, IsEven() can be used to match any type -// where the value of "(arg % 2) == 0" can be implicitly converted to -// a bool. In the "Bar(IsEven())" example above, if method Bar() -// takes an int, 'arg_type' will be int; if it takes an unsigned long, -// 'arg_type' will be unsigned long; and so on. -// -// Parameterizing Matchers -// ======================= -// -// Sometimes you'll want to parameterize the matcher. For that you -// can use another macro: -// -// MATCHER_P(name, param_name, description_string) { statements; } -// -// For example: -// -// MATCHER_P(HasAbsoluteValue, value, "") { return abs(arg) == value; } -// -// will allow you to write: -// -// EXPECT_THAT(Blah("a"), HasAbsoluteValue(n)); -// -// which may lead to this message (assuming n is 10): -// -// Value of: Blah("a") -// Expected: has absolute value 10 -// Actual: -9 -// -// Note that both the matcher description and its parameter are -// printed, making the message human-friendly. -// -// In the matcher definition body, you can write 'foo_type' to -// reference the type of a parameter named 'foo'. For example, in the -// body of MATCHER_P(HasAbsoluteValue, value) above, you can write -// 'value_type' to refer to the type of 'value'. -// -// We also provide MATCHER_P2, MATCHER_P3, ..., up to MATCHER_P$n to -// support multi-parameter matchers. -// -// Describing Parameterized Matchers -// ================================= -// -// The last argument to MATCHER*() is a string-typed expression. The -// expression can reference all of the matcher's parameters and a -// special bool-typed variable named 'negation'. When 'negation' is -// false, the expression should evaluate to the matcher's description; -// otherwise it should evaluate to the description of the negation of -// the matcher. For example, -// -// using testing::PrintToString; -// -// MATCHER_P2(InClosedRange, low, hi, -// std::string(negation ? "is not" : "is") + " in range [" + -// PrintToString(low) + ", " + PrintToString(hi) + "]") { -// return low <= arg && arg <= hi; -// } -// ... -// EXPECT_THAT(3, InClosedRange(4, 6)); -// EXPECT_THAT(3, Not(InClosedRange(2, 4))); -// -// would generate two failures that contain the text: -// -// Expected: is in range [4, 6] -// ... -// Expected: is not in range [2, 4] -// -// If you specify "" as the description, the failure message will -// contain the sequence of words in the matcher name followed by the -// parameter values printed as a tuple. For example, -// -// MATCHER_P2(InClosedRange, low, hi, "") { ... } -// ... -// EXPECT_THAT(3, InClosedRange(4, 6)); -// EXPECT_THAT(3, Not(InClosedRange(2, 4))); -// -// would generate two failures that contain the text: -// -// Expected: in closed range (4, 6) -// ... -// Expected: not (in closed range (2, 4)) -// -// Types of Matcher Parameters -// =========================== -// -// For the purpose of typing, you can view -// -// MATCHER_Pk(Foo, p1, ..., pk, description_string) { ... } -// -// as shorthand for -// -// template <typename p1_type, ..., typename pk_type> -// FooMatcherPk<p1_type, ..., pk_type> -// Foo(p1_type p1, ..., pk_type pk) { ... } -// -// When you write Foo(v1, ..., vk), the compiler infers the types of -// the parameters v1, ..., and vk for you. If you are not happy with -// the result of the type inference, you can specify the types by -// explicitly instantiating the template, as in Foo<long, bool>(5, -// false). As said earlier, you don't get to (or need to) specify -// 'arg_type' as that's determined by the context in which the matcher -// is used. You can assign the result of expression Foo(p1, ..., pk) -// to a variable of type FooMatcherPk<p1_type, ..., pk_type>. This -// can be useful when composing matchers. -// -// While you can instantiate a matcher template with reference types, -// passing the parameters by pointer usually makes your code more -// readable. If, however, you still want to pass a parameter by -// reference, be aware that in the failure message generated by the -// matcher you will see the value of the referenced object but not its -// address. -// -// Explaining Match Results -// ======================== -// -// Sometimes the matcher description alone isn't enough to explain why -// the match has failed or succeeded. For example, when expecting a -// long string, it can be very helpful to also print the diff between -// the expected string and the actual one. To achieve that, you can -// optionally stream additional information to a special variable -// named result_listener, whose type is a pointer to class -// MatchResultListener: -// -// MATCHER_P(EqualsLongString, str, "") { -// if (arg == str) return true; -// -// *result_listener << "the difference: " -/// << DiffStrings(str, arg); -// return false; -// } -// -// Overloading Matchers -// ==================== -// -// You can overload matchers with different numbers of parameters: -// -// MATCHER_P(Blah, a, description_string1) { ... } -// MATCHER_P2(Blah, a, b, description_string2) { ... } -// -// Caveats -// ======= -// -// When defining a new matcher, you should also consider implementing -// MatcherInterface or using MakePolymorphicMatcher(). These -// approaches require more work than the MATCHER* macros, but also -// give you more control on the types of the value being matched and -// the matcher parameters, which may leads to better compiler error -// messages when the matcher is used wrong. They also allow -// overloading matchers based on parameter types (as opposed to just -// based on the number of parameters). -// -// MATCHER*() can only be used in a namespace scope as templates cannot be -// declared inside of a local class. -// -// More Information -// ================ -// -// To learn more about using these macros, please search for 'MATCHER' -// on -// https://github.com/google/googletest/blob/master/docs/gmock_cook_book.md -// -// This file also implements some commonly used argument matchers. More -// matchers can be defined by the user implementing the -// MatcherInterface<T> interface if necessary. -// -// See googletest/include/gtest/gtest-matchers.h for the definition of class -// Matcher, class MatcherInterface, and others. - -// GOOGLETEST_CM0002 DO NOT DELETE - -#ifndef GOOGLEMOCK_INCLUDE_GMOCK_GMOCK_MATCHERS_H_ -#define GOOGLEMOCK_INCLUDE_GMOCK_GMOCK_MATCHERS_H_ - -#include <algorithm> -#include <cmath> -#include <initializer_list> -#include <iterator> -#include <limits> -#include <memory> -#include <ostream> // NOLINT -#include <sstream> -#include <string> -#include <type_traits> -#include <utility> -#include <vector> - - -// MSVC warning C5046 is new as of VS2017 version 15.8. -#if defined(_MSC_VER) && _MSC_VER >= 1915 -#define GMOCK_MAYBE_5046_ 5046 -#else -#define GMOCK_MAYBE_5046_ -#endif - -GTEST_DISABLE_MSC_WARNINGS_PUSH_( - 4251 GMOCK_MAYBE_5046_ /* class A needs to have dll-interface to be used by - clients of class B */ - /* Symbol involving type with internal linkage not defined */) - -namespace testing { - -// To implement a matcher Foo for type T, define: -// 1. a class FooMatcherImpl that implements the -// MatcherInterface<T> interface, and -// 2. a factory function that creates a Matcher<T> object from a -// FooMatcherImpl*. -// -// The two-level delegation design makes it possible to allow a user -// to write "v" instead of "Eq(v)" where a Matcher is expected, which -// is impossible if we pass matchers by pointers. It also eases -// ownership management as Matcher objects can now be copied like -// plain values. - -// A match result listener that stores the explanation in a string. -class StringMatchResultListener : public MatchResultListener { - public: - StringMatchResultListener() : MatchResultListener(&ss_) {} - - // Returns the explanation accumulated so far. - std::string str() const { return ss_.str(); } - - // Clears the explanation accumulated so far. - void Clear() { ss_.str(""); } - - private: - ::std::stringstream ss_; - - GTEST_DISALLOW_COPY_AND_ASSIGN_(StringMatchResultListener); -}; - -// Anything inside the 'internal' namespace IS INTERNAL IMPLEMENTATION -// and MUST NOT BE USED IN USER CODE!!! -namespace internal { - -// The MatcherCastImpl class template is a helper for implementing -// MatcherCast(). We need this helper in order to partially -// specialize the implementation of MatcherCast() (C++ allows -// class/struct templates to be partially specialized, but not -// function templates.). - -// This general version is used when MatcherCast()'s argument is a -// polymorphic matcher (i.e. something that can be converted to a -// Matcher but is not one yet; for example, Eq(value)) or a value (for -// example, "hello"). -template <typename T, typename M> -class MatcherCastImpl { - public: - static Matcher<T> Cast(const M& polymorphic_matcher_or_value) { - // M can be a polymorphic matcher, in which case we want to use - // its conversion operator to create Matcher<T>. Or it can be a value - // that should be passed to the Matcher<T>'s constructor. - // - // We can't call Matcher<T>(polymorphic_matcher_or_value) when M is a - // polymorphic matcher because it'll be ambiguous if T has an implicit - // constructor from M (this usually happens when T has an implicit - // constructor from any type). - // - // It won't work to unconditionally implicit_cast - // polymorphic_matcher_or_value to Matcher<T> because it won't trigger - // a user-defined conversion from M to T if one exists (assuming M is - // a value). - return CastImpl(polymorphic_matcher_or_value, - std::is_convertible<M, Matcher<T>>{}, - std::is_convertible<M, T>{}); - } - - private: - template <bool Ignore> - static Matcher<T> CastImpl(const M& polymorphic_matcher_or_value, - std::true_type /* convertible_to_matcher */, - std::integral_constant<bool, Ignore>) { - // M is implicitly convertible to Matcher<T>, which means that either - // M is a polymorphic matcher or Matcher<T> has an implicit constructor - // from M. In both cases using the implicit conversion will produce a - // matcher. - // - // Even if T has an implicit constructor from M, it won't be called because - // creating Matcher<T> would require a chain of two user-defined conversions - // (first to create T from M and then to create Matcher<T> from T). - return polymorphic_matcher_or_value; - } - - // M can't be implicitly converted to Matcher<T>, so M isn't a polymorphic - // matcher. It's a value of a type implicitly convertible to T. Use direct - // initialization to create a matcher. - static Matcher<T> CastImpl(const M& value, - std::false_type /* convertible_to_matcher */, - std::true_type /* convertible_to_T */) { - return Matcher<T>(ImplicitCast_<T>(value)); - } - - // M can't be implicitly converted to either Matcher<T> or T. Attempt to use - // polymorphic matcher Eq(value) in this case. - // - // Note that we first attempt to perform an implicit cast on the value and - // only fall back to the polymorphic Eq() matcher afterwards because the - // latter calls bool operator==(const Lhs& lhs, const Rhs& rhs) in the end - // which might be undefined even when Rhs is implicitly convertible to Lhs - // (e.g. std::pair<const int, int> vs. std::pair<int, int>). - // - // We don't define this method inline as we need the declaration of Eq(). - static Matcher<T> CastImpl(const M& value, - std::false_type /* convertible_to_matcher */, - std::false_type /* convertible_to_T */); -}; - -// This more specialized version is used when MatcherCast()'s argument -// is already a Matcher. This only compiles when type T can be -// statically converted to type U. -template <typename T, typename U> -class MatcherCastImpl<T, Matcher<U> > { - public: - static Matcher<T> Cast(const Matcher<U>& source_matcher) { - return Matcher<T>(new Impl(source_matcher)); - } - - private: - class Impl : public MatcherInterface<T> { - public: - explicit Impl(const Matcher<U>& source_matcher) - : source_matcher_(source_matcher) {} - - // We delegate the matching logic to the source matcher. - bool MatchAndExplain(T x, MatchResultListener* listener) const override { - using FromType = typename std::remove_cv<typename std::remove_pointer< - typename std::remove_reference<T>::type>::type>::type; - using ToType = typename std::remove_cv<typename std::remove_pointer< - typename std::remove_reference<U>::type>::type>::type; - // Do not allow implicitly converting base*/& to derived*/&. - static_assert( - // Do not trigger if only one of them is a pointer. That implies a - // regular conversion and not a down_cast. - (std::is_pointer<typename std::remove_reference<T>::type>::value != - std::is_pointer<typename std::remove_reference<U>::type>::value) || - std::is_same<FromType, ToType>::value || - !std::is_base_of<FromType, ToType>::value, - "Can't implicitly convert from <base> to <derived>"); - - // Do the cast to `U` explicitly if necessary. - // Otherwise, let implicit conversions do the trick. - using CastType = - typename std::conditional<std::is_convertible<T&, const U&>::value, - T&, U>::type; - - return source_matcher_.MatchAndExplain(static_cast<CastType>(x), - listener); - } - - void DescribeTo(::std::ostream* os) const override { - source_matcher_.DescribeTo(os); - } - - void DescribeNegationTo(::std::ostream* os) const override { - source_matcher_.DescribeNegationTo(os); - } - - private: - const Matcher<U> source_matcher_; - }; -}; - -// This even more specialized version is used for efficiently casting -// a matcher to its own type. -template <typename T> -class MatcherCastImpl<T, Matcher<T> > { - public: - static Matcher<T> Cast(const Matcher<T>& matcher) { return matcher; } -}; - -// Template specialization for parameterless Matcher. -template <typename Derived> -class MatcherBaseImpl { - public: - MatcherBaseImpl() = default; - - template <typename T> - operator ::testing::Matcher<T>() const { // NOLINT(runtime/explicit) - return ::testing::Matcher<T>(new - typename Derived::template gmock_Impl<T>()); - } -}; - -// Template specialization for Matcher with parameters. -template <template <typename...> class Derived, typename... Ts> -class MatcherBaseImpl<Derived<Ts...>> { - public: - // Mark the constructor explicit for single argument T to avoid implicit - // conversions. - template <typename E = std::enable_if<sizeof...(Ts) == 1>, - typename E::type* = nullptr> - explicit MatcherBaseImpl(Ts... params) - : params_(std::forward<Ts>(params)...) {} - template <typename E = std::enable_if<sizeof...(Ts) != 1>, - typename = typename E::type> - MatcherBaseImpl(Ts... params) // NOLINT - : params_(std::forward<Ts>(params)...) {} - - template <typename F> - operator ::testing::Matcher<F>() const { // NOLINT(runtime/explicit) - return Apply<F>(MakeIndexSequence<sizeof...(Ts)>{}); - } - - private: - template <typename F, std::size_t... tuple_ids> - ::testing::Matcher<F> Apply(IndexSequence<tuple_ids...>) const { - return ::testing::Matcher<F>( - new typename Derived<Ts...>::template gmock_Impl<F>( - std::get<tuple_ids>(params_)...)); - } - - const std::tuple<Ts...> params_; -}; - -} // namespace internal - -// In order to be safe and clear, casting between different matcher -// types is done explicitly via MatcherCast<T>(m), which takes a -// matcher m and returns a Matcher<T>. It compiles only when T can be -// statically converted to the argument type of m. -template <typename T, typename M> -inline Matcher<T> MatcherCast(const M& matcher) { - return internal::MatcherCastImpl<T, M>::Cast(matcher); -} - -// This overload handles polymorphic matchers and values only since -// monomorphic matchers are handled by the next one. -template <typename T, typename M> -inline Matcher<T> SafeMatcherCast(const M& polymorphic_matcher_or_value) { - return MatcherCast<T>(polymorphic_matcher_or_value); -} - -// This overload handles monomorphic matchers. -// -// In general, if type T can be implicitly converted to type U, we can -// safely convert a Matcher<U> to a Matcher<T> (i.e. Matcher is -// contravariant): just keep a copy of the original Matcher<U>, convert the -// argument from type T to U, and then pass it to the underlying Matcher<U>. -// The only exception is when U is a reference and T is not, as the -// underlying Matcher<U> may be interested in the argument's address, which -// is not preserved in the conversion from T to U. -template <typename T, typename U> -inline Matcher<T> SafeMatcherCast(const Matcher<U>& matcher) { - // Enforce that T can be implicitly converted to U. - static_assert(std::is_convertible<const T&, const U&>::value, - "T must be implicitly convertible to U"); - // Enforce that we are not converting a non-reference type T to a reference - // type U. - GTEST_COMPILE_ASSERT_( - std::is_reference<T>::value || !std::is_reference<U>::value, - cannot_convert_non_reference_arg_to_reference); - // In case both T and U are arithmetic types, enforce that the - // conversion is not lossy. - typedef GTEST_REMOVE_REFERENCE_AND_CONST_(T) RawT; - typedef GTEST_REMOVE_REFERENCE_AND_CONST_(U) RawU; - constexpr bool kTIsOther = GMOCK_KIND_OF_(RawT) == internal::kOther; - constexpr bool kUIsOther = GMOCK_KIND_OF_(RawU) == internal::kOther; - GTEST_COMPILE_ASSERT_( - kTIsOther || kUIsOther || - (internal::LosslessArithmeticConvertible<RawT, RawU>::value), - conversion_of_arithmetic_types_must_be_lossless); - return MatcherCast<T>(matcher); -} - -// A<T>() returns a matcher that matches any value of type T. -template <typename T> -Matcher<T> A(); - -// Anything inside the 'internal' namespace IS INTERNAL IMPLEMENTATION -// and MUST NOT BE USED IN USER CODE!!! -namespace internal { - -// If the explanation is not empty, prints it to the ostream. -inline void PrintIfNotEmpty(const std::string& explanation, - ::std::ostream* os) { - if (explanation != "" && os != nullptr) { - *os << ", " << explanation; - } -} - -// Returns true if the given type name is easy to read by a human. -// This is used to decide whether printing the type of a value might -// be helpful. -inline bool IsReadableTypeName(const std::string& type_name) { - // We consider a type name readable if it's short or doesn't contain - // a template or function type. - return (type_name.length() <= 20 || - type_name.find_first_of("<(") == std::string::npos); -} - -// Matches the value against the given matcher, prints the value and explains -// the match result to the listener. Returns the match result. -// 'listener' must not be NULL. -// Value cannot be passed by const reference, because some matchers take a -// non-const argument. -template <typename Value, typename T> -bool MatchPrintAndExplain(Value& value, const Matcher<T>& matcher, - MatchResultListener* listener) { - if (!listener->IsInterested()) { - // If the listener is not interested, we do not need to construct the - // inner explanation. - return matcher.Matches(value); - } - - StringMatchResultListener inner_listener; - const bool match = matcher.MatchAndExplain(value, &inner_listener); - - UniversalPrint(value, listener->stream()); -#if GTEST_HAS_RTTI - const std::string& type_name = GetTypeName<Value>(); - if (IsReadableTypeName(type_name)) - *listener->stream() << " (of type " << type_name << ")"; -#endif - PrintIfNotEmpty(inner_listener.str(), listener->stream()); - - return match; -} - -// An internal helper class for doing compile-time loop on a tuple's -// fields. -template <size_t N> -class TuplePrefix { - public: - // TuplePrefix<N>::Matches(matcher_tuple, value_tuple) returns true - // if and only if the first N fields of matcher_tuple matches - // the first N fields of value_tuple, respectively. - template <typename MatcherTuple, typename ValueTuple> - static bool Matches(const MatcherTuple& matcher_tuple, - const ValueTuple& value_tuple) { - return TuplePrefix<N - 1>::Matches(matcher_tuple, value_tuple) && - std::get<N - 1>(matcher_tuple).Matches(std::get<N - 1>(value_tuple)); - } - - // TuplePrefix<N>::ExplainMatchFailuresTo(matchers, values, os) - // describes failures in matching the first N fields of matchers - // against the first N fields of values. If there is no failure, - // nothing will be streamed to os. - template <typename MatcherTuple, typename ValueTuple> - static void ExplainMatchFailuresTo(const MatcherTuple& matchers, - const ValueTuple& values, - ::std::ostream* os) { - // First, describes failures in the first N - 1 fields. - TuplePrefix<N - 1>::ExplainMatchFailuresTo(matchers, values, os); - - // Then describes the failure (if any) in the (N - 1)-th (0-based) - // field. - typename std::tuple_element<N - 1, MatcherTuple>::type matcher = - std::get<N - 1>(matchers); - typedef typename std::tuple_element<N - 1, ValueTuple>::type Value; - const Value& value = std::get<N - 1>(values); - StringMatchResultListener listener; - if (!matcher.MatchAndExplain(value, &listener)) { - *os << " Expected arg #" << N - 1 << ": "; - std::get<N - 1>(matchers).DescribeTo(os); - *os << "\n Actual: "; - // We remove the reference in type Value to prevent the - // universal printer from printing the address of value, which - // isn't interesting to the user most of the time. The - // matcher's MatchAndExplain() method handles the case when - // the address is interesting. - internal::UniversalPrint(value, os); - PrintIfNotEmpty(listener.str(), os); - *os << "\n"; - } - } -}; - -// The base case. -template <> -class TuplePrefix<0> { - public: - template <typename MatcherTuple, typename ValueTuple> - static bool Matches(const MatcherTuple& /* matcher_tuple */, - const ValueTuple& /* value_tuple */) { - return true; - } - - template <typename MatcherTuple, typename ValueTuple> - static void ExplainMatchFailuresTo(const MatcherTuple& /* matchers */, - const ValueTuple& /* values */, - ::std::ostream* /* os */) {} -}; - -// TupleMatches(matcher_tuple, value_tuple) returns true if and only if -// all matchers in matcher_tuple match the corresponding fields in -// value_tuple. It is a compiler error if matcher_tuple and -// value_tuple have different number of fields or incompatible field -// types. -template <typename MatcherTuple, typename ValueTuple> -bool TupleMatches(const MatcherTuple& matcher_tuple, - const ValueTuple& value_tuple) { - // Makes sure that matcher_tuple and value_tuple have the same - // number of fields. - GTEST_COMPILE_ASSERT_(std::tuple_size<MatcherTuple>::value == - std::tuple_size<ValueTuple>::value, - matcher_and_value_have_different_numbers_of_fields); - return TuplePrefix<std::tuple_size<ValueTuple>::value>::Matches(matcher_tuple, - value_tuple); -} - -// Describes failures in matching matchers against values. If there -// is no failure, nothing will be streamed to os. -template <typename MatcherTuple, typename ValueTuple> -void ExplainMatchFailureTupleTo(const MatcherTuple& matchers, - const ValueTuple& values, - ::std::ostream* os) { - TuplePrefix<std::tuple_size<MatcherTuple>::value>::ExplainMatchFailuresTo( - matchers, values, os); -} - -// TransformTupleValues and its helper. -// -// TransformTupleValuesHelper hides the internal machinery that -// TransformTupleValues uses to implement a tuple traversal. -template <typename Tuple, typename Func, typename OutIter> -class TransformTupleValuesHelper { - private: - typedef ::std::tuple_size<Tuple> TupleSize; - - public: - // For each member of tuple 't', taken in order, evaluates '*out++ = f(t)'. - // Returns the final value of 'out' in case the caller needs it. - static OutIter Run(Func f, const Tuple& t, OutIter out) { - return IterateOverTuple<Tuple, TupleSize::value>()(f, t, out); - } - - private: - template <typename Tup, size_t kRemainingSize> - struct IterateOverTuple { - OutIter operator() (Func f, const Tup& t, OutIter out) const { - *out++ = f(::std::get<TupleSize::value - kRemainingSize>(t)); - return IterateOverTuple<Tup, kRemainingSize - 1>()(f, t, out); - } - }; - template <typename Tup> - struct IterateOverTuple<Tup, 0> { - OutIter operator() (Func /* f */, const Tup& /* t */, OutIter out) const { - return out; - } - }; -}; - -// Successively invokes 'f(element)' on each element of the tuple 't', -// appending each result to the 'out' iterator. Returns the final value -// of 'out'. -template <typename Tuple, typename Func, typename OutIter> -OutIter TransformTupleValues(Func f, const Tuple& t, OutIter out) { - return TransformTupleValuesHelper<Tuple, Func, OutIter>::Run(f, t, out); -} - -// Implements _, a matcher that matches any value of any -// type. This is a polymorphic matcher, so we need a template type -// conversion operator to make it appearing as a Matcher<T> for any -// type T. -class AnythingMatcher { - public: - using is_gtest_matcher = void; - - template <typename T> - bool MatchAndExplain(const T& /* x */, std::ostream* /* listener */) const { - return true; - } - void DescribeTo(std::ostream* os) const { *os << "is anything"; } - void DescribeNegationTo(::std::ostream* os) const { - // This is mostly for completeness' sake, as it's not very useful - // to write Not(A<bool>()). However we cannot completely rule out - // such a possibility, and it doesn't hurt to be prepared. - *os << "never matches"; - } -}; - -// Implements the polymorphic IsNull() matcher, which matches any raw or smart -// pointer that is NULL. -class IsNullMatcher { - public: - template <typename Pointer> - bool MatchAndExplain(const Pointer& p, - MatchResultListener* /* listener */) const { - return p == nullptr; - } - - void DescribeTo(::std::ostream* os) const { *os << "is NULL"; } - void DescribeNegationTo(::std::ostream* os) const { - *os << "isn't NULL"; - } -}; - -// Implements the polymorphic NotNull() matcher, which matches any raw or smart -// pointer that is not NULL. -class NotNullMatcher { - public: - template <typename Pointer> - bool MatchAndExplain(const Pointer& p, - MatchResultListener* /* listener */) const { - return p != nullptr; - } - - void DescribeTo(::std::ostream* os) const { *os << "isn't NULL"; } - void DescribeNegationTo(::std::ostream* os) const { - *os << "is NULL"; - } -}; - -// Ref(variable) matches any argument that is a reference to -// 'variable'. This matcher is polymorphic as it can match any -// super type of the type of 'variable'. -// -// The RefMatcher template class implements Ref(variable). It can -// only be instantiated with a reference type. This prevents a user -// from mistakenly using Ref(x) to match a non-reference function -// argument. For example, the following will righteously cause a -// compiler error: -// -// int n; -// Matcher<int> m1 = Ref(n); // This won't compile. -// Matcher<int&> m2 = Ref(n); // This will compile. -template <typename T> -class RefMatcher; - -template <typename T> -class RefMatcher<T&> { - // Google Mock is a generic framework and thus needs to support - // mocking any function types, including those that take non-const - // reference arguments. Therefore the template parameter T (and - // Super below) can be instantiated to either a const type or a - // non-const type. - public: - // RefMatcher() takes a T& instead of const T&, as we want the - // compiler to catch using Ref(const_value) as a matcher for a - // non-const reference. - explicit RefMatcher(T& x) : object_(x) {} // NOLINT - - template <typename Super> - operator Matcher<Super&>() const { - // By passing object_ (type T&) to Impl(), which expects a Super&, - // we make sure that Super is a super type of T. In particular, - // this catches using Ref(const_value) as a matcher for a - // non-const reference, as you cannot implicitly convert a const - // reference to a non-const reference. - return MakeMatcher(new Impl<Super>(object_)); - } - - private: - template <typename Super> - class Impl : public MatcherInterface<Super&> { - public: - explicit Impl(Super& x) : object_(x) {} // NOLINT - - // MatchAndExplain() takes a Super& (as opposed to const Super&) - // in order to match the interface MatcherInterface<Super&>. - bool MatchAndExplain(Super& x, - MatchResultListener* listener) const override { - *listener << "which is located @" << static_cast<const void*>(&x); - return &x == &object_; - } - - void DescribeTo(::std::ostream* os) const override { - *os << "references the variable "; - UniversalPrinter<Super&>::Print(object_, os); - } - - void DescribeNegationTo(::std::ostream* os) const override { - *os << "does not reference the variable "; - UniversalPrinter<Super&>::Print(object_, os); - } - - private: - const Super& object_; - }; - - T& object_; -}; - -// Polymorphic helper functions for narrow and wide string matchers. -inline bool CaseInsensitiveCStringEquals(const char* lhs, const char* rhs) { - return String::CaseInsensitiveCStringEquals(lhs, rhs); -} - -inline bool CaseInsensitiveCStringEquals(const wchar_t* lhs, - const wchar_t* rhs) { - return String::CaseInsensitiveWideCStringEquals(lhs, rhs); -} - -// String comparison for narrow or wide strings that can have embedded NUL -// characters. -template <typename StringType> -bool CaseInsensitiveStringEquals(const StringType& s1, - const StringType& s2) { - // Are the heads equal? - if (!CaseInsensitiveCStringEquals(s1.c_str(), s2.c_str())) { - return false; - } - - // Skip the equal heads. - const typename StringType::value_type nul = 0; - const size_t i1 = s1.find(nul), i2 = s2.find(nul); - - // Are we at the end of either s1 or s2? - if (i1 == StringType::npos || i2 == StringType::npos) { - return i1 == i2; - } - - // Are the tails equal? - return CaseInsensitiveStringEquals(s1.substr(i1 + 1), s2.substr(i2 + 1)); -} - -// String matchers. - -// Implements equality-based string matchers like StrEq, StrCaseNe, and etc. -template <typename StringType> -class StrEqualityMatcher { - public: - StrEqualityMatcher(StringType str, bool expect_eq, bool case_sensitive) - : string_(std::move(str)), - expect_eq_(expect_eq), - case_sensitive_(case_sensitive) {} - -#if GTEST_INTERNAL_HAS_STRING_VIEW - bool MatchAndExplain(const internal::StringView& s, - MatchResultListener* listener) const { - // This should fail to compile if StringView is used with wide - // strings. - const StringType& str = std::string(s); - return MatchAndExplain(str, listener); - } -#endif // GTEST_INTERNAL_HAS_STRING_VIEW - - // Accepts pointer types, particularly: - // const char* - // char* - // const wchar_t* - // wchar_t* - template <typename CharType> - bool MatchAndExplain(CharType* s, MatchResultListener* listener) const { - if (s == nullptr) { - return !expect_eq_; - } - return MatchAndExplain(StringType(s), listener); - } - - // Matches anything that can convert to StringType. - // - // This is a template, not just a plain function with const StringType&, - // because StringView has some interfering non-explicit constructors. - template <typename MatcheeStringType> - bool MatchAndExplain(const MatcheeStringType& s, - MatchResultListener* /* listener */) const { - const StringType s2(s); - const bool eq = case_sensitive_ ? s2 == string_ : - CaseInsensitiveStringEquals(s2, string_); - return expect_eq_ == eq; - } - - void DescribeTo(::std::ostream* os) const { - DescribeToHelper(expect_eq_, os); - } - - void DescribeNegationTo(::std::ostream* os) const { - DescribeToHelper(!expect_eq_, os); - } - - private: - void DescribeToHelper(bool expect_eq, ::std::ostream* os) const { - *os << (expect_eq ? "is " : "isn't "); - *os << "equal to "; - if (!case_sensitive_) { - *os << "(ignoring case) "; - } - UniversalPrint(string_, os); - } - - const StringType string_; - const bool expect_eq_; - const bool case_sensitive_; -}; - -// Implements the polymorphic HasSubstr(substring) matcher, which -// can be used as a Matcher<T> as long as T can be converted to a -// string. -template <typename StringType> -class HasSubstrMatcher { - public: - explicit HasSubstrMatcher(const StringType& substring) - : substring_(substring) {} - -#if GTEST_INTERNAL_HAS_STRING_VIEW - bool MatchAndExplain(const internal::StringView& s, - MatchResultListener* listener) const { - // This should fail to compile if StringView is used with wide - // strings. - const StringType& str = std::string(s); - return MatchAndExplain(str, listener); - } -#endif // GTEST_INTERNAL_HAS_STRING_VIEW - - // Accepts pointer types, particularly: - // const char* - // char* - // const wchar_t* - // wchar_t* - template <typename CharType> - bool MatchAndExplain(CharType* s, MatchResultListener* listener) const { - return s != nullptr && MatchAndExplain(StringType(s), listener); - } - - // Matches anything that can convert to StringType. - // - // This is a template, not just a plain function with const StringType&, - // because StringView has some interfering non-explicit constructors. - template <typename MatcheeStringType> - bool MatchAndExplain(const MatcheeStringType& s, - MatchResultListener* /* listener */) const { - return StringType(s).find(substring_) != StringType::npos; - } - - // Describes what this matcher matches. - void DescribeTo(::std::ostream* os) const { - *os << "has substring "; - UniversalPrint(substring_, os); - } - - void DescribeNegationTo(::std::ostream* os) const { - *os << "has no substring "; - UniversalPrint(substring_, os); - } - - private: - const StringType substring_; -}; - -// Implements the polymorphic StartsWith(substring) matcher, which -// can be used as a Matcher<T> as long as T can be converted to a -// string. -template <typename StringType> -class StartsWithMatcher { - public: - explicit StartsWithMatcher(const StringType& prefix) : prefix_(prefix) { - } - -#if GTEST_INTERNAL_HAS_STRING_VIEW - bool MatchAndExplain(const internal::StringView& s, - MatchResultListener* listener) const { - // This should fail to compile if StringView is used with wide - // strings. - const StringType& str = std::string(s); - return MatchAndExplain(str, listener); - } -#endif // GTEST_INTERNAL_HAS_STRING_VIEW - - // Accepts pointer types, particularly: - // const char* - // char* - // const wchar_t* - // wchar_t* - template <typename CharType> - bool MatchAndExplain(CharType* s, MatchResultListener* listener) const { - return s != nullptr && MatchAndExplain(StringType(s), listener); - } - - // Matches anything that can convert to StringType. - // - // This is a template, not just a plain function with const StringType&, - // because StringView has some interfering non-explicit constructors. - template <typename MatcheeStringType> - bool MatchAndExplain(const MatcheeStringType& s, - MatchResultListener* /* listener */) const { - const StringType& s2(s); - return s2.length() >= prefix_.length() && - s2.substr(0, prefix_.length()) == prefix_; - } - - void DescribeTo(::std::ostream* os) const { - *os << "starts with "; - UniversalPrint(prefix_, os); - } - - void DescribeNegationTo(::std::ostream* os) const { - *os << "doesn't start with "; - UniversalPrint(prefix_, os); - } - - private: - const StringType prefix_; -}; - -// Implements the polymorphic EndsWith(substring) matcher, which -// can be used as a Matcher<T> as long as T can be converted to a -// string. -template <typename StringType> -class EndsWithMatcher { - public: - explicit EndsWithMatcher(const StringType& suffix) : suffix_(suffix) {} - -#if GTEST_INTERNAL_HAS_STRING_VIEW - bool MatchAndExplain(const internal::StringView& s, - MatchResultListener* listener) const { - // This should fail to compile if StringView is used with wide - // strings. - const StringType& str = std::string(s); - return MatchAndExplain(str, listener); - } -#endif // GTEST_INTERNAL_HAS_STRING_VIEW - - // Accepts pointer types, particularly: - // const char* - // char* - // const wchar_t* - // wchar_t* - template <typename CharType> - bool MatchAndExplain(CharType* s, MatchResultListener* listener) const { - return s != nullptr && MatchAndExplain(StringType(s), listener); - } - - // Matches anything that can convert to StringType. - // - // This is a template, not just a plain function with const StringType&, - // because StringView has some interfering non-explicit constructors. - template <typename MatcheeStringType> - bool MatchAndExplain(const MatcheeStringType& s, - MatchResultListener* /* listener */) const { - const StringType& s2(s); - return s2.length() >= suffix_.length() && - s2.substr(s2.length() - suffix_.length()) == suffix_; - } - - void DescribeTo(::std::ostream* os) const { - *os << "ends with "; - UniversalPrint(suffix_, os); - } - - void DescribeNegationTo(::std::ostream* os) const { - *os << "doesn't end with "; - UniversalPrint(suffix_, os); - } - - private: - const StringType suffix_; -}; - -// Implements a matcher that compares the two fields of a 2-tuple -// using one of the ==, <=, <, etc, operators. The two fields being -// compared don't have to have the same type. -// -// The matcher defined here is polymorphic (for example, Eq() can be -// used to match a std::tuple<int, short>, a std::tuple<const long&, double>, -// etc). Therefore we use a template type conversion operator in the -// implementation. -template <typename D, typename Op> -class PairMatchBase { - public: - template <typename T1, typename T2> - operator Matcher<::std::tuple<T1, T2>>() const { - return Matcher<::std::tuple<T1, T2>>(new Impl<const ::std::tuple<T1, T2>&>); - } - template <typename T1, typename T2> - operator Matcher<const ::std::tuple<T1, T2>&>() const { - return MakeMatcher(new Impl<const ::std::tuple<T1, T2>&>); - } - - private: - static ::std::ostream& GetDesc(::std::ostream& os) { // NOLINT - return os << D::Desc(); - } - - template <typename Tuple> - class Impl : public MatcherInterface<Tuple> { - public: - bool MatchAndExplain(Tuple args, - MatchResultListener* /* listener */) const override { - return Op()(::std::get<0>(args), ::std::get<1>(args)); - } - void DescribeTo(::std::ostream* os) const override { - *os << "are " << GetDesc; - } - void DescribeNegationTo(::std::ostream* os) const override { - *os << "aren't " << GetDesc; - } - }; -}; - -class Eq2Matcher : public PairMatchBase<Eq2Matcher, AnyEq> { - public: - static const char* Desc() { return "an equal pair"; } -}; -class Ne2Matcher : public PairMatchBase<Ne2Matcher, AnyNe> { - public: - static const char* Desc() { return "an unequal pair"; } -}; -class Lt2Matcher : public PairMatchBase<Lt2Matcher, AnyLt> { - public: - static const char* Desc() { return "a pair where the first < the second"; } -}; -class Gt2Matcher : public PairMatchBase<Gt2Matcher, AnyGt> { - public: - static const char* Desc() { return "a pair where the first > the second"; } -}; -class Le2Matcher : public PairMatchBase<Le2Matcher, AnyLe> { - public: - static const char* Desc() { return "a pair where the first <= the second"; } -}; -class Ge2Matcher : public PairMatchBase<Ge2Matcher, AnyGe> { - public: - static const char* Desc() { return "a pair where the first >= the second"; } -}; - -// Implements the Not(...) matcher for a particular argument type T. -// We do not nest it inside the NotMatcher class template, as that -// will prevent different instantiations of NotMatcher from sharing -// the same NotMatcherImpl<T> class. -template <typename T> -class NotMatcherImpl : public MatcherInterface<const T&> { - public: - explicit NotMatcherImpl(const Matcher<T>& matcher) - : matcher_(matcher) {} - - bool MatchAndExplain(const T& x, - MatchResultListener* listener) const override { - return !matcher_.MatchAndExplain(x, listener); - } - - void DescribeTo(::std::ostream* os) const override { - matcher_.DescribeNegationTo(os); - } - - void DescribeNegationTo(::std::ostream* os) const override { - matcher_.DescribeTo(os); - } - - private: - const Matcher<T> matcher_; -}; - -// Implements the Not(m) matcher, which matches a value that doesn't -// match matcher m. -template <typename InnerMatcher> -class NotMatcher { - public: - explicit NotMatcher(InnerMatcher matcher) : matcher_(matcher) {} - - // This template type conversion operator allows Not(m) to be used - // to match any type m can match. - template <typename T> - operator Matcher<T>() const { - return Matcher<T>(new NotMatcherImpl<T>(SafeMatcherCast<T>(matcher_))); - } - - private: - InnerMatcher matcher_; -}; - -// Implements the AllOf(m1, m2) matcher for a particular argument type -// T. We do not nest it inside the BothOfMatcher class template, as -// that will prevent different instantiations of BothOfMatcher from -// sharing the same BothOfMatcherImpl<T> class. -template <typename T> -class AllOfMatcherImpl : public MatcherInterface<const T&> { - public: - explicit AllOfMatcherImpl(std::vector<Matcher<T> > matchers) - : matchers_(std::move(matchers)) {} - - void DescribeTo(::std::ostream* os) const override { - *os << "("; - for (size_t i = 0; i < matchers_.size(); ++i) { - if (i != 0) *os << ") and ("; - matchers_[i].DescribeTo(os); - } - *os << ")"; - } - - void DescribeNegationTo(::std::ostream* os) const override { - *os << "("; - for (size_t i = 0; i < matchers_.size(); ++i) { - if (i != 0) *os << ") or ("; - matchers_[i].DescribeNegationTo(os); - } - *os << ")"; - } - - bool MatchAndExplain(const T& x, - MatchResultListener* listener) const override { - // If either matcher1_ or matcher2_ doesn't match x, we only need - // to explain why one of them fails. - std::string all_match_result; - - for (size_t i = 0; i < matchers_.size(); ++i) { - StringMatchResultListener slistener; - if (matchers_[i].MatchAndExplain(x, &slistener)) { - if (all_match_result.empty()) { - all_match_result = slistener.str(); - } else { - std::string result = slistener.str(); - if (!result.empty()) { - all_match_result += ", and "; - all_match_result += result; - } - } - } else { - *listener << slistener.str(); - return false; - } - } - - // Otherwise we need to explain why *both* of them match. - *listener << all_match_result; - return true; - } - - private: - const std::vector<Matcher<T> > matchers_; -}; - -// VariadicMatcher is used for the variadic implementation of -// AllOf(m_1, m_2, ...) and AnyOf(m_1, m_2, ...). -// CombiningMatcher<T> is used to recursively combine the provided matchers -// (of type Args...). -template <template <typename T> class CombiningMatcher, typename... Args> -class VariadicMatcher { - public: - VariadicMatcher(const Args&... matchers) // NOLINT - : matchers_(matchers...) { - static_assert(sizeof...(Args) > 0, "Must have at least one matcher."); - } - - VariadicMatcher(const VariadicMatcher&) = default; - VariadicMatcher& operator=(const VariadicMatcher&) = delete; - - // This template type conversion operator allows an - // VariadicMatcher<Matcher1, Matcher2...> object to match any type that - // all of the provided matchers (Matcher1, Matcher2, ...) can match. - template <typename T> - operator Matcher<T>() const { - std::vector<Matcher<T> > values; - CreateVariadicMatcher<T>(&values, std::integral_constant<size_t, 0>()); - return Matcher<T>(new CombiningMatcher<T>(std::move(values))); - } - - private: - template <typename T, size_t I> - void CreateVariadicMatcher(std::vector<Matcher<T> >* values, - std::integral_constant<size_t, I>) const { - values->push_back(SafeMatcherCast<T>(std::get<I>(matchers_))); - CreateVariadicMatcher<T>(values, std::integral_constant<size_t, I + 1>()); - } - - template <typename T> - void CreateVariadicMatcher( - std::vector<Matcher<T> >*, - std::integral_constant<size_t, sizeof...(Args)>) const {} - - std::tuple<Args...> matchers_; -}; - -template <typename... Args> -using AllOfMatcher = VariadicMatcher<AllOfMatcherImpl, Args...>; - -// Implements the AnyOf(m1, m2) matcher for a particular argument type -// T. We do not nest it inside the AnyOfMatcher class template, as -// that will prevent different instantiations of AnyOfMatcher from -// sharing the same EitherOfMatcherImpl<T> class. -template <typename T> -class AnyOfMatcherImpl : public MatcherInterface<const T&> { - public: - explicit AnyOfMatcherImpl(std::vector<Matcher<T> > matchers) - : matchers_(std::move(matchers)) {} - - void DescribeTo(::std::ostream* os) const override { - *os << "("; - for (size_t i = 0; i < matchers_.size(); ++i) { - if (i != 0) *os << ") or ("; - matchers_[i].DescribeTo(os); - } - *os << ")"; - } - - void DescribeNegationTo(::std::ostream* os) const override { - *os << "("; - for (size_t i = 0; i < matchers_.size(); ++i) { - if (i != 0) *os << ") and ("; - matchers_[i].DescribeNegationTo(os); - } - *os << ")"; - } - - bool MatchAndExplain(const T& x, - MatchResultListener* listener) const override { - std::string no_match_result; - - // If either matcher1_ or matcher2_ matches x, we just need to - // explain why *one* of them matches. - for (size_t i = 0; i < matchers_.size(); ++i) { - StringMatchResultListener slistener; - if (matchers_[i].MatchAndExplain(x, &slistener)) { - *listener << slistener.str(); - return true; - } else { - if (no_match_result.empty()) { - no_match_result = slistener.str(); - } else { - std::string result = slistener.str(); - if (!result.empty()) { - no_match_result += ", and "; - no_match_result += result; - } - } - } - } - - // Otherwise we need to explain why *both* of them fail. - *listener << no_match_result; - return false; - } - - private: - const std::vector<Matcher<T> > matchers_; -}; - -// AnyOfMatcher is used for the variadic implementation of AnyOf(m_1, m_2, ...). -template <typename... Args> -using AnyOfMatcher = VariadicMatcher<AnyOfMatcherImpl, Args...>; - -// Wrapper for implementation of Any/AllOfArray(). -template <template <class> class MatcherImpl, typename T> -class SomeOfArrayMatcher { - public: - // Constructs the matcher from a sequence of element values or - // element matchers. - template <typename Iter> - SomeOfArrayMatcher(Iter first, Iter last) : matchers_(first, last) {} - - template <typename U> - operator Matcher<U>() const { // NOLINT - using RawU = typename std::decay<U>::type; - std::vector<Matcher<RawU>> matchers; - for (const auto& matcher : matchers_) { - matchers.push_back(MatcherCast<RawU>(matcher)); - } - return Matcher<U>(new MatcherImpl<RawU>(std::move(matchers))); - } - - private: - const ::std::vector<T> matchers_; -}; - -template <typename T> -using AllOfArrayMatcher = SomeOfArrayMatcher<AllOfMatcherImpl, T>; - -template <typename T> -using AnyOfArrayMatcher = SomeOfArrayMatcher<AnyOfMatcherImpl, T>; - -// Used for implementing Truly(pred), which turns a predicate into a -// matcher. -template <typename Predicate> -class TrulyMatcher { - public: - explicit TrulyMatcher(Predicate pred) : predicate_(pred) {} - - // This method template allows Truly(pred) to be used as a matcher - // for type T where T is the argument type of predicate 'pred'. The - // argument is passed by reference as the predicate may be - // interested in the address of the argument. - template <typename T> - bool MatchAndExplain(T& x, // NOLINT - MatchResultListener* listener) const { - // Without the if-statement, MSVC sometimes warns about converting - // a value to bool (warning 4800). - // - // We cannot write 'return !!predicate_(x);' as that doesn't work - // when predicate_(x) returns a class convertible to bool but - // having no operator!(). - if (predicate_(x)) - return true; - *listener << "didn't satisfy the given predicate"; - return false; - } - - void DescribeTo(::std::ostream* os) const { - *os << "satisfies the given predicate"; - } - - void DescribeNegationTo(::std::ostream* os) const { - *os << "doesn't satisfy the given predicate"; - } - - private: - Predicate predicate_; -}; - -// Used for implementing Matches(matcher), which turns a matcher into -// a predicate. -template <typename M> -class MatcherAsPredicate { - public: - explicit MatcherAsPredicate(M matcher) : matcher_(matcher) {} - - // This template operator() allows Matches(m) to be used as a - // predicate on type T where m is a matcher on type T. - // - // The argument x is passed by reference instead of by value, as - // some matcher may be interested in its address (e.g. as in - // Matches(Ref(n))(x)). - template <typename T> - bool operator()(const T& x) const { - // We let matcher_ commit to a particular type here instead of - // when the MatcherAsPredicate object was constructed. This - // allows us to write Matches(m) where m is a polymorphic matcher - // (e.g. Eq(5)). - // - // If we write Matcher<T>(matcher_).Matches(x) here, it won't - // compile when matcher_ has type Matcher<const T&>; if we write - // Matcher<const T&>(matcher_).Matches(x) here, it won't compile - // when matcher_ has type Matcher<T>; if we just write - // matcher_.Matches(x), it won't compile when matcher_ is - // polymorphic, e.g. Eq(5). - // - // MatcherCast<const T&>() is necessary for making the code work - // in all of the above situations. - return MatcherCast<const T&>(matcher_).Matches(x); - } - - private: - M matcher_; -}; - -// For implementing ASSERT_THAT() and EXPECT_THAT(). The template -// argument M must be a type that can be converted to a matcher. -template <typename M> -class PredicateFormatterFromMatcher { - public: - explicit PredicateFormatterFromMatcher(M m) : matcher_(std::move(m)) {} - - // This template () operator allows a PredicateFormatterFromMatcher - // object to act as a predicate-formatter suitable for using with - // Google Test's EXPECT_PRED_FORMAT1() macro. - template <typename T> - AssertionResult operator()(const char* value_text, const T& x) const { - // We convert matcher_ to a Matcher<const T&> *now* instead of - // when the PredicateFormatterFromMatcher object was constructed, - // as matcher_ may be polymorphic (e.g. NotNull()) and we won't - // know which type to instantiate it to until we actually see the - // type of x here. - // - // We write SafeMatcherCast<const T&>(matcher_) instead of - // Matcher<const T&>(matcher_), as the latter won't compile when - // matcher_ has type Matcher<T> (e.g. An<int>()). - // We don't write MatcherCast<const T&> either, as that allows - // potentially unsafe downcasting of the matcher argument. - const Matcher<const T&> matcher = SafeMatcherCast<const T&>(matcher_); - - // The expected path here is that the matcher should match (i.e. that most - // tests pass) so optimize for this case. - if (matcher.Matches(x)) { - return AssertionSuccess(); - } - - ::std::stringstream ss; - ss << "Value of: " << value_text << "\n" - << "Expected: "; - matcher.DescribeTo(&ss); - - // Rerun the matcher to "PrintAndExplain" the failure. - StringMatchResultListener listener; - if (MatchPrintAndExplain(x, matcher, &listener)) { - ss << "\n The matcher failed on the initial attempt; but passed when " - "rerun to generate the explanation."; - } - ss << "\n Actual: " << listener.str(); - return AssertionFailure() << ss.str(); - } - - private: - const M matcher_; -}; - -// A helper function for converting a matcher to a predicate-formatter -// without the user needing to explicitly write the type. This is -// used for implementing ASSERT_THAT() and EXPECT_THAT(). -// Implementation detail: 'matcher' is received by-value to force decaying. -template <typename M> -inline PredicateFormatterFromMatcher<M> -MakePredicateFormatterFromMatcher(M matcher) { - return PredicateFormatterFromMatcher<M>(std::move(matcher)); -} - -// Implements the polymorphic IsNan() matcher, which matches any floating type -// value that is Nan. -class IsNanMatcher { - public: - template <typename FloatType> - bool MatchAndExplain(const FloatType& f, - MatchResultListener* /* listener */) const { - return (::std::isnan)(f); - } - - void DescribeTo(::std::ostream* os) const { *os << "is NaN"; } - void DescribeNegationTo(::std::ostream* os) const { - *os << "isn't NaN"; - } -}; - -// Implements the polymorphic floating point equality matcher, which matches -// two float values using ULP-based approximation or, optionally, a -// user-specified epsilon. The template is meant to be instantiated with -// FloatType being either float or double. -template <typename FloatType> -class FloatingEqMatcher { - public: - // Constructor for FloatingEqMatcher. - // The matcher's input will be compared with expected. The matcher treats two - // NANs as equal if nan_eq_nan is true. Otherwise, under IEEE standards, - // equality comparisons between NANs will always return false. We specify a - // negative max_abs_error_ term to indicate that ULP-based approximation will - // be used for comparison. - FloatingEqMatcher(FloatType expected, bool nan_eq_nan) : - expected_(expected), nan_eq_nan_(nan_eq_nan), max_abs_error_(-1) { - } - - // Constructor that supports a user-specified max_abs_error that will be used - // for comparison instead of ULP-based approximation. The max absolute - // should be non-negative. - FloatingEqMatcher(FloatType expected, bool nan_eq_nan, - FloatType max_abs_error) - : expected_(expected), - nan_eq_nan_(nan_eq_nan), - max_abs_error_(max_abs_error) { - GTEST_CHECK_(max_abs_error >= 0) - << ", where max_abs_error is" << max_abs_error; - } - - // Implements floating point equality matcher as a Matcher<T>. - template <typename T> - class Impl : public MatcherInterface<T> { - public: - Impl(FloatType expected, bool nan_eq_nan, FloatType max_abs_error) - : expected_(expected), - nan_eq_nan_(nan_eq_nan), - max_abs_error_(max_abs_error) {} - - bool MatchAndExplain(T value, - MatchResultListener* listener) const override { - const FloatingPoint<FloatType> actual(value), expected(expected_); - - // Compares NaNs first, if nan_eq_nan_ is true. - if (actual.is_nan() || expected.is_nan()) { - if (actual.is_nan() && expected.is_nan()) { - return nan_eq_nan_; - } - // One is nan; the other is not nan. - return false; - } - if (HasMaxAbsError()) { - // We perform an equality check so that inf will match inf, regardless - // of error bounds. If the result of value - expected_ would result in - // overflow or if either value is inf, the default result is infinity, - // which should only match if max_abs_error_ is also infinity. - if (value == expected_) { - return true; - } - - const FloatType diff = value - expected_; - if (::std::fabs(diff) <= max_abs_error_) { - return true; - } - - if (listener->IsInterested()) { - *listener << "which is " << diff << " from " << expected_; - } - return false; - } else { - return actual.AlmostEquals(expected); - } - } - - void DescribeTo(::std::ostream* os) const override { - // os->precision() returns the previously set precision, which we - // store to restore the ostream to its original configuration - // after outputting. - const ::std::streamsize old_precision = os->precision( - ::std::numeric_limits<FloatType>::digits10 + 2); - if (FloatingPoint<FloatType>(expected_).is_nan()) { - if (nan_eq_nan_) { - *os << "is NaN"; - } else { - *os << "never matches"; - } - } else { - *os << "is approximately " << expected_; - if (HasMaxAbsError()) { - *os << " (absolute error <= " << max_abs_error_ << ")"; - } - } - os->precision(old_precision); - } - - void DescribeNegationTo(::std::ostream* os) const override { - // As before, get original precision. - const ::std::streamsize old_precision = os->precision( - ::std::numeric_limits<FloatType>::digits10 + 2); - if (FloatingPoint<FloatType>(expected_).is_nan()) { - if (nan_eq_nan_) { - *os << "isn't NaN"; - } else { - *os << "is anything"; - } - } else { - *os << "isn't approximately " << expected_; - if (HasMaxAbsError()) { - *os << " (absolute error > " << max_abs_error_ << ")"; - } - } - // Restore original precision. - os->precision(old_precision); - } - - private: - bool HasMaxAbsError() const { - return max_abs_error_ >= 0; - } - - const FloatType expected_; - const bool nan_eq_nan_; - // max_abs_error will be used for value comparison when >= 0. - const FloatType max_abs_error_; - }; - - // The following 3 type conversion operators allow FloatEq(expected) and - // NanSensitiveFloatEq(expected) to be used as a Matcher<float>, a - // Matcher<const float&>, or a Matcher<float&>, but nothing else. - operator Matcher<FloatType>() const { - return MakeMatcher( - new Impl<FloatType>(expected_, nan_eq_nan_, max_abs_error_)); - } - - operator Matcher<const FloatType&>() const { - return MakeMatcher( - new Impl<const FloatType&>(expected_, nan_eq_nan_, max_abs_error_)); - } - - operator Matcher<FloatType&>() const { - return MakeMatcher( - new Impl<FloatType&>(expected_, nan_eq_nan_, max_abs_error_)); - } - - private: - const FloatType expected_; - const bool nan_eq_nan_; - // max_abs_error will be used for value comparison when >= 0. - const FloatType max_abs_error_; -}; - -// A 2-tuple ("binary") wrapper around FloatingEqMatcher: -// FloatingEq2Matcher() matches (x, y) by matching FloatingEqMatcher(x, false) -// against y, and FloatingEq2Matcher(e) matches FloatingEqMatcher(x, false, e) -// against y. The former implements "Eq", the latter "Near". At present, there -// is no version that compares NaNs as equal. -template <typename FloatType> -class FloatingEq2Matcher { - public: - FloatingEq2Matcher() { Init(-1, false); } - - explicit FloatingEq2Matcher(bool nan_eq_nan) { Init(-1, nan_eq_nan); } - - explicit FloatingEq2Matcher(FloatType max_abs_error) { - Init(max_abs_error, false); - } - - FloatingEq2Matcher(FloatType max_abs_error, bool nan_eq_nan) { - Init(max_abs_error, nan_eq_nan); - } - - template <typename T1, typename T2> - operator Matcher<::std::tuple<T1, T2>>() const { - return MakeMatcher( - new Impl<::std::tuple<T1, T2>>(max_abs_error_, nan_eq_nan_)); - } - template <typename T1, typename T2> - operator Matcher<const ::std::tuple<T1, T2>&>() const { - return MakeMatcher( - new Impl<const ::std::tuple<T1, T2>&>(max_abs_error_, nan_eq_nan_)); - } - - private: - static ::std::ostream& GetDesc(::std::ostream& os) { // NOLINT - return os << "an almost-equal pair"; - } - - template <typename Tuple> - class Impl : public MatcherInterface<Tuple> { - public: - Impl(FloatType max_abs_error, bool nan_eq_nan) : - max_abs_error_(max_abs_error), - nan_eq_nan_(nan_eq_nan) {} - - bool MatchAndExplain(Tuple args, - MatchResultListener* listener) const override { - if (max_abs_error_ == -1) { - FloatingEqMatcher<FloatType> fm(::std::get<0>(args), nan_eq_nan_); - return static_cast<Matcher<FloatType>>(fm).MatchAndExplain( - ::std::get<1>(args), listener); - } else { - FloatingEqMatcher<FloatType> fm(::std::get<0>(args), nan_eq_nan_, - max_abs_error_); - return static_cast<Matcher<FloatType>>(fm).MatchAndExplain( - ::std::get<1>(args), listener); - } - } - void DescribeTo(::std::ostream* os) const override { - *os << "are " << GetDesc; - } - void DescribeNegationTo(::std::ostream* os) const override { - *os << "aren't " << GetDesc; - } - - private: - FloatType max_abs_error_; - const bool nan_eq_nan_; - }; - - void Init(FloatType max_abs_error_val, bool nan_eq_nan_val) { - max_abs_error_ = max_abs_error_val; - nan_eq_nan_ = nan_eq_nan_val; - } - FloatType max_abs_error_; - bool nan_eq_nan_; -}; - -// Implements the Pointee(m) matcher for matching a pointer whose -// pointee matches matcher m. The pointer can be either raw or smart. -template <typename InnerMatcher> -class PointeeMatcher { - public: - explicit PointeeMatcher(const InnerMatcher& matcher) : matcher_(matcher) {} - - // This type conversion operator template allows Pointee(m) to be - // used as a matcher for any pointer type whose pointee type is - // compatible with the inner matcher, where type Pointer can be - // either a raw pointer or a smart pointer. - // - // The reason we do this instead of relying on - // MakePolymorphicMatcher() is that the latter is not flexible - // enough for implementing the DescribeTo() method of Pointee(). - template <typename Pointer> - operator Matcher<Pointer>() const { - return Matcher<Pointer>(new Impl<const Pointer&>(matcher_)); - } - - private: - // The monomorphic implementation that works for a particular pointer type. - template <typename Pointer> - class Impl : public MatcherInterface<Pointer> { - public: - using Pointee = - typename std::pointer_traits<GTEST_REMOVE_REFERENCE_AND_CONST_( - Pointer)>::element_type; - - explicit Impl(const InnerMatcher& matcher) - : matcher_(MatcherCast<const Pointee&>(matcher)) {} - - void DescribeTo(::std::ostream* os) const override { - *os << "points to a value that "; - matcher_.DescribeTo(os); - } - - void DescribeNegationTo(::std::ostream* os) const override { - *os << "does not point to a value that "; - matcher_.DescribeTo(os); - } - - bool MatchAndExplain(Pointer pointer, - MatchResultListener* listener) const override { - if (GetRawPointer(pointer) == nullptr) return false; - - *listener << "which points to "; - return MatchPrintAndExplain(*pointer, matcher_, listener); - } - - private: - const Matcher<const Pointee&> matcher_; - }; - - const InnerMatcher matcher_; -}; - -// Implements the Pointer(m) matcher -// Implements the Pointer(m) matcher for matching a pointer that matches matcher -// m. The pointer can be either raw or smart, and will match `m` against the -// raw pointer. -template <typename InnerMatcher> -class PointerMatcher { - public: - explicit PointerMatcher(const InnerMatcher& matcher) : matcher_(matcher) {} - - // This type conversion operator template allows Pointer(m) to be - // used as a matcher for any pointer type whose pointer type is - // compatible with the inner matcher, where type PointerType can be - // either a raw pointer or a smart pointer. - // - // The reason we do this instead of relying on - // MakePolymorphicMatcher() is that the latter is not flexible - // enough for implementing the DescribeTo() method of Pointer(). - template <typename PointerType> - operator Matcher<PointerType>() const { // NOLINT - return Matcher<PointerType>(new Impl<const PointerType&>(matcher_)); - } - - private: - // The monomorphic implementation that works for a particular pointer type. - template <typename PointerType> - class Impl : public MatcherInterface<PointerType> { - public: - using Pointer = - const typename std::pointer_traits<GTEST_REMOVE_REFERENCE_AND_CONST_( - PointerType)>::element_type*; - - explicit Impl(const InnerMatcher& matcher) - : matcher_(MatcherCast<Pointer>(matcher)) {} - - void DescribeTo(::std::ostream* os) const override { - *os << "is a pointer that "; - matcher_.DescribeTo(os); - } - - void DescribeNegationTo(::std::ostream* os) const override { - *os << "is not a pointer that "; - matcher_.DescribeTo(os); - } - - bool MatchAndExplain(PointerType pointer, - MatchResultListener* listener) const override { - *listener << "which is a pointer that "; - Pointer p = GetRawPointer(pointer); - return MatchPrintAndExplain(p, matcher_, listener); - } - - private: - Matcher<Pointer> matcher_; - }; - - const InnerMatcher matcher_; -}; - -#if GTEST_HAS_RTTI -// Implements the WhenDynamicCastTo<T>(m) matcher that matches a pointer or -// reference that matches inner_matcher when dynamic_cast<T> is applied. -// The result of dynamic_cast<To> is forwarded to the inner matcher. -// If To is a pointer and the cast fails, the inner matcher will receive NULL. -// If To is a reference and the cast fails, this matcher returns false -// immediately. -template <typename To> -class WhenDynamicCastToMatcherBase { - public: - explicit WhenDynamicCastToMatcherBase(const Matcher<To>& matcher) - : matcher_(matcher) {} - - void DescribeTo(::std::ostream* os) const { - GetCastTypeDescription(os); - matcher_.DescribeTo(os); - } - - void DescribeNegationTo(::std::ostream* os) const { - GetCastTypeDescription(os); - matcher_.DescribeNegationTo(os); - } - - protected: - const Matcher<To> matcher_; - - static std::string GetToName() { - return GetTypeName<To>(); - } - - private: - static void GetCastTypeDescription(::std::ostream* os) { - *os << "when dynamic_cast to " << GetToName() << ", "; - } -}; - -// Primary template. -// To is a pointer. Cast and forward the result. -template <typename To> -class WhenDynamicCastToMatcher : public WhenDynamicCastToMatcherBase<To> { - public: - explicit WhenDynamicCastToMatcher(const Matcher<To>& matcher) - : WhenDynamicCastToMatcherBase<To>(matcher) {} - - template <typename From> - bool MatchAndExplain(From from, MatchResultListener* listener) const { - To to = dynamic_cast<To>(from); - return MatchPrintAndExplain(to, this->matcher_, listener); - } -}; - -// Specialize for references. -// In this case we return false if the dynamic_cast fails. -template <typename To> -class WhenDynamicCastToMatcher<To&> : public WhenDynamicCastToMatcherBase<To&> { - public: - explicit WhenDynamicCastToMatcher(const Matcher<To&>& matcher) - : WhenDynamicCastToMatcherBase<To&>(matcher) {} - - template <typename From> - bool MatchAndExplain(From& from, MatchResultListener* listener) const { - // We don't want an std::bad_cast here, so do the cast with pointers. - To* to = dynamic_cast<To*>(&from); - if (to == nullptr) { - *listener << "which cannot be dynamic_cast to " << this->GetToName(); - return false; - } - return MatchPrintAndExplain(*to, this->matcher_, listener); - } -}; -#endif // GTEST_HAS_RTTI - -// Implements the Field() matcher for matching a field (i.e. member -// variable) of an object. -template <typename Class, typename FieldType> -class FieldMatcher { - public: - FieldMatcher(FieldType Class::*field, - const Matcher<const FieldType&>& matcher) - : field_(field), matcher_(matcher), whose_field_("whose given field ") {} - - FieldMatcher(const std::string& field_name, FieldType Class::*field, - const Matcher<const FieldType&>& matcher) - : field_(field), - matcher_(matcher), - whose_field_("whose field `" + field_name + "` ") {} - - void DescribeTo(::std::ostream* os) const { - *os << "is an object " << whose_field_; - matcher_.DescribeTo(os); - } - - void DescribeNegationTo(::std::ostream* os) const { - *os << "is an object " << whose_field_; - matcher_.DescribeNegationTo(os); - } - - template <typename T> - bool MatchAndExplain(const T& value, MatchResultListener* listener) const { - // FIXME: The dispatch on std::is_pointer was introduced as a workaround for - // a compiler bug, and can now be removed. - return MatchAndExplainImpl( - typename std::is_pointer<typename std::remove_const<T>::type>::type(), - value, listener); - } - - private: - bool MatchAndExplainImpl(std::false_type /* is_not_pointer */, - const Class& obj, - MatchResultListener* listener) const { - *listener << whose_field_ << "is "; - return MatchPrintAndExplain(obj.*field_, matcher_, listener); - } - - bool MatchAndExplainImpl(std::true_type /* is_pointer */, const Class* p, - MatchResultListener* listener) const { - if (p == nullptr) return false; - - *listener << "which points to an object "; - // Since *p has a field, it must be a class/struct/union type and - // thus cannot be a pointer. Therefore we pass false_type() as - // the first argument. - return MatchAndExplainImpl(std::false_type(), *p, listener); - } - - const FieldType Class::*field_; - const Matcher<const FieldType&> matcher_; - - // Contains either "whose given field " if the name of the field is unknown - // or "whose field `name_of_field` " if the name is known. - const std::string whose_field_; -}; - -// Implements the Property() matcher for matching a property -// (i.e. return value of a getter method) of an object. -// -// Property is a const-qualified member function of Class returning -// PropertyType. -template <typename Class, typename PropertyType, typename Property> -class PropertyMatcher { - public: - typedef const PropertyType& RefToConstProperty; - - PropertyMatcher(Property property, const Matcher<RefToConstProperty>& matcher) - : property_(property), - matcher_(matcher), - whose_property_("whose given property ") {} - - PropertyMatcher(const std::string& property_name, Property property, - const Matcher<RefToConstProperty>& matcher) - : property_(property), - matcher_(matcher), - whose_property_("whose property `" + property_name + "` ") {} - - void DescribeTo(::std::ostream* os) const { - *os << "is an object " << whose_property_; - matcher_.DescribeTo(os); - } - - void DescribeNegationTo(::std::ostream* os) const { - *os << "is an object " << whose_property_; - matcher_.DescribeNegationTo(os); - } - - template <typename T> - bool MatchAndExplain(const T&value, MatchResultListener* listener) const { - return MatchAndExplainImpl( - typename std::is_pointer<typename std::remove_const<T>::type>::type(), - value, listener); - } - - private: - bool MatchAndExplainImpl(std::false_type /* is_not_pointer */, - const Class& obj, - MatchResultListener* listener) const { - *listener << whose_property_ << "is "; - // Cannot pass the return value (for example, int) to MatchPrintAndExplain, - // which takes a non-const reference as argument. - RefToConstProperty result = (obj.*property_)(); - return MatchPrintAndExplain(result, matcher_, listener); - } - - bool MatchAndExplainImpl(std::true_type /* is_pointer */, const Class* p, - MatchResultListener* listener) const { - if (p == nullptr) return false; - - *listener << "which points to an object "; - // Since *p has a property method, it must be a class/struct/union - // type and thus cannot be a pointer. Therefore we pass - // false_type() as the first argument. - return MatchAndExplainImpl(std::false_type(), *p, listener); - } - - Property property_; - const Matcher<RefToConstProperty> matcher_; - - // Contains either "whose given property " if the name of the property is - // unknown or "whose property `name_of_property` " if the name is known. - const std::string whose_property_; -}; - -// Type traits specifying various features of different functors for ResultOf. -// The default template specifies features for functor objects. -template <typename Functor> -struct CallableTraits { - typedef Functor StorageType; - - static void CheckIsValid(Functor /* functor */) {} - - template <typename T> - static auto Invoke(Functor f, const T& arg) -> decltype(f(arg)) { - return f(arg); - } -}; - -// Specialization for function pointers. -template <typename ArgType, typename ResType> -struct CallableTraits<ResType(*)(ArgType)> { - typedef ResType ResultType; - typedef ResType(*StorageType)(ArgType); - - static void CheckIsValid(ResType(*f)(ArgType)) { - GTEST_CHECK_(f != nullptr) - << "NULL function pointer is passed into ResultOf()."; - } - template <typename T> - static ResType Invoke(ResType(*f)(ArgType), T arg) { - return (*f)(arg); - } -}; - -// Implements the ResultOf() matcher for matching a return value of a -// unary function of an object. -template <typename Callable, typename InnerMatcher> -class ResultOfMatcher { - public: - ResultOfMatcher(Callable callable, InnerMatcher matcher) - : callable_(std::move(callable)), matcher_(std::move(matcher)) { - CallableTraits<Callable>::CheckIsValid(callable_); - } - - template <typename T> - operator Matcher<T>() const { - return Matcher<T>(new Impl<const T&>(callable_, matcher_)); - } - - private: - typedef typename CallableTraits<Callable>::StorageType CallableStorageType; - - template <typename T> - class Impl : public MatcherInterface<T> { - using ResultType = decltype(CallableTraits<Callable>::template Invoke<T>( - std::declval<CallableStorageType>(), std::declval<T>())); - - public: - template <typename M> - Impl(const CallableStorageType& callable, const M& matcher) - : callable_(callable), matcher_(MatcherCast<ResultType>(matcher)) {} - - void DescribeTo(::std::ostream* os) const override { - *os << "is mapped by the given callable to a value that "; - matcher_.DescribeTo(os); - } - - void DescribeNegationTo(::std::ostream* os) const override { - *os << "is mapped by the given callable to a value that "; - matcher_.DescribeNegationTo(os); - } - - bool MatchAndExplain(T obj, MatchResultListener* listener) const override { - *listener << "which is mapped by the given callable to "; - // Cannot pass the return value directly to MatchPrintAndExplain, which - // takes a non-const reference as argument. - // Also, specifying template argument explicitly is needed because T could - // be a non-const reference (e.g. Matcher<Uncopyable&>). - ResultType result = - CallableTraits<Callable>::template Invoke<T>(callable_, obj); - return MatchPrintAndExplain(result, matcher_, listener); - } - - private: - // Functors often define operator() as non-const method even though - // they are actually stateless. But we need to use them even when - // 'this' is a const pointer. It's the user's responsibility not to - // use stateful callables with ResultOf(), which doesn't guarantee - // how many times the callable will be invoked. - mutable CallableStorageType callable_; - const Matcher<ResultType> matcher_; - }; // class Impl - - const CallableStorageType callable_; - const InnerMatcher matcher_; -}; - -// Implements a matcher that checks the size of an STL-style container. -template <typename SizeMatcher> -class SizeIsMatcher { - public: - explicit SizeIsMatcher(const SizeMatcher& size_matcher) - : size_matcher_(size_matcher) { - } - - template <typename Container> - operator Matcher<Container>() const { - return Matcher<Container>(new Impl<const Container&>(size_matcher_)); - } - - template <typename Container> - class Impl : public MatcherInterface<Container> { - public: - using SizeType = decltype(std::declval<Container>().size()); - explicit Impl(const SizeMatcher& size_matcher) - : size_matcher_(MatcherCast<SizeType>(size_matcher)) {} - - void DescribeTo(::std::ostream* os) const override { - *os << "size "; - size_matcher_.DescribeTo(os); - } - void DescribeNegationTo(::std::ostream* os) const override { - *os << "size "; - size_matcher_.DescribeNegationTo(os); - } - - bool MatchAndExplain(Container container, - MatchResultListener* listener) const override { - SizeType size = container.size(); - StringMatchResultListener size_listener; - const bool result = size_matcher_.MatchAndExplain(size, &size_listener); - *listener - << "whose size " << size << (result ? " matches" : " doesn't match"); - PrintIfNotEmpty(size_listener.str(), listener->stream()); - return result; - } - - private: - const Matcher<SizeType> size_matcher_; - }; - - private: - const SizeMatcher size_matcher_; -}; - -// Implements a matcher that checks the begin()..end() distance of an STL-style -// container. -template <typename DistanceMatcher> -class BeginEndDistanceIsMatcher { - public: - explicit BeginEndDistanceIsMatcher(const DistanceMatcher& distance_matcher) - : distance_matcher_(distance_matcher) {} - - template <typename Container> - operator Matcher<Container>() const { - return Matcher<Container>(new Impl<const Container&>(distance_matcher_)); - } - - template <typename Container> - class Impl : public MatcherInterface<Container> { - public: - typedef internal::StlContainerView< - GTEST_REMOVE_REFERENCE_AND_CONST_(Container)> ContainerView; - typedef typename std::iterator_traits< - typename ContainerView::type::const_iterator>::difference_type - DistanceType; - explicit Impl(const DistanceMatcher& distance_matcher) - : distance_matcher_(MatcherCast<DistanceType>(distance_matcher)) {} - - void DescribeTo(::std::ostream* os) const override { - *os << "distance between begin() and end() "; - distance_matcher_.DescribeTo(os); - } - void DescribeNegationTo(::std::ostream* os) const override { - *os << "distance between begin() and end() "; - distance_matcher_.DescribeNegationTo(os); - } - - bool MatchAndExplain(Container container, - MatchResultListener* listener) const override { - using std::begin; - using std::end; - DistanceType distance = std::distance(begin(container), end(container)); - StringMatchResultListener distance_listener; - const bool result = - distance_matcher_.MatchAndExplain(distance, &distance_listener); - *listener << "whose distance between begin() and end() " << distance - << (result ? " matches" : " doesn't match"); - PrintIfNotEmpty(distance_listener.str(), listener->stream()); - return result; - } - - private: - const Matcher<DistanceType> distance_matcher_; - }; - - private: - const DistanceMatcher distance_matcher_; -}; - -// Implements an equality matcher for any STL-style container whose elements -// support ==. This matcher is like Eq(), but its failure explanations provide -// more detailed information that is useful when the container is used as a set. -// The failure message reports elements that are in one of the operands but not -// the other. The failure messages do not report duplicate or out-of-order -// elements in the containers (which don't properly matter to sets, but can -// occur if the containers are vectors or lists, for example). -// -// Uses the container's const_iterator, value_type, operator ==, -// begin(), and end(). -template <typename Container> -class ContainerEqMatcher { - public: - typedef internal::StlContainerView<Container> View; - typedef typename View::type StlContainer; - typedef typename View::const_reference StlContainerReference; - - static_assert(!std::is_const<Container>::value, - "Container type must not be const"); - static_assert(!std::is_reference<Container>::value, - "Container type must not be a reference"); - - // We make a copy of expected in case the elements in it are modified - // after this matcher is created. - explicit ContainerEqMatcher(const Container& expected) - : expected_(View::Copy(expected)) {} - - void DescribeTo(::std::ostream* os) const { - *os << "equals "; - UniversalPrint(expected_, os); - } - void DescribeNegationTo(::std::ostream* os) const { - *os << "does not equal "; - UniversalPrint(expected_, os); - } - - template <typename LhsContainer> - bool MatchAndExplain(const LhsContainer& lhs, - MatchResultListener* listener) const { - typedef internal::StlContainerView< - typename std::remove_const<LhsContainer>::type> - LhsView; - typedef typename LhsView::type LhsStlContainer; - StlContainerReference lhs_stl_container = LhsView::ConstReference(lhs); - if (lhs_stl_container == expected_) - return true; - - ::std::ostream* const os = listener->stream(); - if (os != nullptr) { - // Something is different. Check for extra values first. - bool printed_header = false; - for (typename LhsStlContainer::const_iterator it = - lhs_stl_container.begin(); - it != lhs_stl_container.end(); ++it) { - if (internal::ArrayAwareFind(expected_.begin(), expected_.end(), *it) == - expected_.end()) { - if (printed_header) { - *os << ", "; - } else { - *os << "which has these unexpected elements: "; - printed_header = true; - } - UniversalPrint(*it, os); - } - } - - // Now check for missing values. - bool printed_header2 = false; - for (typename StlContainer::const_iterator it = expected_.begin(); - it != expected_.end(); ++it) { - if (internal::ArrayAwareFind( - lhs_stl_container.begin(), lhs_stl_container.end(), *it) == - lhs_stl_container.end()) { - if (printed_header2) { - *os << ", "; - } else { - *os << (printed_header ? ",\nand" : "which") - << " doesn't have these expected elements: "; - printed_header2 = true; - } - UniversalPrint(*it, os); - } - } - } - - return false; - } - - private: - const StlContainer expected_; -}; - -// A comparator functor that uses the < operator to compare two values. -struct LessComparator { - template <typename T, typename U> - bool operator()(const T& lhs, const U& rhs) const { return lhs < rhs; } -}; - -// Implements WhenSortedBy(comparator, container_matcher). -template <typename Comparator, typename ContainerMatcher> -class WhenSortedByMatcher { - public: - WhenSortedByMatcher(const Comparator& comparator, - const ContainerMatcher& matcher) - : comparator_(comparator), matcher_(matcher) {} - - template <typename LhsContainer> - operator Matcher<LhsContainer>() const { - return MakeMatcher(new Impl<LhsContainer>(comparator_, matcher_)); - } - - template <typename LhsContainer> - class Impl : public MatcherInterface<LhsContainer> { - public: - typedef internal::StlContainerView< - GTEST_REMOVE_REFERENCE_AND_CONST_(LhsContainer)> LhsView; - typedef typename LhsView::type LhsStlContainer; - typedef typename LhsView::const_reference LhsStlContainerReference; - // Transforms std::pair<const Key, Value> into std::pair<Key, Value> - // so that we can match associative containers. - typedef typename RemoveConstFromKey< - typename LhsStlContainer::value_type>::type LhsValue; - - Impl(const Comparator& comparator, const ContainerMatcher& matcher) - : comparator_(comparator), matcher_(matcher) {} - - void DescribeTo(::std::ostream* os) const override { - *os << "(when sorted) "; - matcher_.DescribeTo(os); - } - - void DescribeNegationTo(::std::ostream* os) const override { - *os << "(when sorted) "; - matcher_.DescribeNegationTo(os); - } - - bool MatchAndExplain(LhsContainer lhs, - MatchResultListener* listener) const override { - LhsStlContainerReference lhs_stl_container = LhsView::ConstReference(lhs); - ::std::vector<LhsValue> sorted_container(lhs_stl_container.begin(), - lhs_stl_container.end()); - ::std::sort( - sorted_container.begin(), sorted_container.end(), comparator_); - - if (!listener->IsInterested()) { - // If the listener is not interested, we do not need to - // construct the inner explanation. - return matcher_.Matches(sorted_container); - } - - *listener << "which is "; - UniversalPrint(sorted_container, listener->stream()); - *listener << " when sorted"; - - StringMatchResultListener inner_listener; - const bool match = matcher_.MatchAndExplain(sorted_container, - &inner_listener); - PrintIfNotEmpty(inner_listener.str(), listener->stream()); - return match; - } - - private: - const Comparator comparator_; - const Matcher<const ::std::vector<LhsValue>&> matcher_; - - GTEST_DISALLOW_COPY_AND_ASSIGN_(Impl); - }; - - private: - const Comparator comparator_; - const ContainerMatcher matcher_; -}; - -// Implements Pointwise(tuple_matcher, rhs_container). tuple_matcher -// must be able to be safely cast to Matcher<std::tuple<const T1&, const -// T2&> >, where T1 and T2 are the types of elements in the LHS -// container and the RHS container respectively. -template <typename TupleMatcher, typename RhsContainer> -class PointwiseMatcher { - GTEST_COMPILE_ASSERT_( - !IsHashTable<GTEST_REMOVE_REFERENCE_AND_CONST_(RhsContainer)>::value, - use_UnorderedPointwise_with_hash_tables); - - public: - typedef internal::StlContainerView<RhsContainer> RhsView; - typedef typename RhsView::type RhsStlContainer; - typedef typename RhsStlContainer::value_type RhsValue; - - static_assert(!std::is_const<RhsContainer>::value, - "RhsContainer type must not be const"); - static_assert(!std::is_reference<RhsContainer>::value, - "RhsContainer type must not be a reference"); - - // Like ContainerEq, we make a copy of rhs in case the elements in - // it are modified after this matcher is created. - PointwiseMatcher(const TupleMatcher& tuple_matcher, const RhsContainer& rhs) - : tuple_matcher_(tuple_matcher), rhs_(RhsView::Copy(rhs)) {} - - template <typename LhsContainer> - operator Matcher<LhsContainer>() const { - GTEST_COMPILE_ASSERT_( - !IsHashTable<GTEST_REMOVE_REFERENCE_AND_CONST_(LhsContainer)>::value, - use_UnorderedPointwise_with_hash_tables); - - return Matcher<LhsContainer>( - new Impl<const LhsContainer&>(tuple_matcher_, rhs_)); - } - - template <typename LhsContainer> - class Impl : public MatcherInterface<LhsContainer> { - public: - typedef internal::StlContainerView< - GTEST_REMOVE_REFERENCE_AND_CONST_(LhsContainer)> LhsView; - typedef typename LhsView::type LhsStlContainer; - typedef typename LhsView::const_reference LhsStlContainerReference; - typedef typename LhsStlContainer::value_type LhsValue; - // We pass the LHS value and the RHS value to the inner matcher by - // reference, as they may be expensive to copy. We must use tuple - // instead of pair here, as a pair cannot hold references (C++ 98, - // 20.2.2 [lib.pairs]). - typedef ::std::tuple<const LhsValue&, const RhsValue&> InnerMatcherArg; - - Impl(const TupleMatcher& tuple_matcher, const RhsStlContainer& rhs) - // mono_tuple_matcher_ holds a monomorphic version of the tuple matcher. - : mono_tuple_matcher_(SafeMatcherCast<InnerMatcherArg>(tuple_matcher)), - rhs_(rhs) {} - - void DescribeTo(::std::ostream* os) const override { - *os << "contains " << rhs_.size() - << " values, where each value and its corresponding value in "; - UniversalPrinter<RhsStlContainer>::Print(rhs_, os); - *os << " "; - mono_tuple_matcher_.DescribeTo(os); - } - void DescribeNegationTo(::std::ostream* os) const override { - *os << "doesn't contain exactly " << rhs_.size() - << " values, or contains a value x at some index i" - << " where x and the i-th value of "; - UniversalPrint(rhs_, os); - *os << " "; - mono_tuple_matcher_.DescribeNegationTo(os); - } - - bool MatchAndExplain(LhsContainer lhs, - MatchResultListener* listener) const override { - LhsStlContainerReference lhs_stl_container = LhsView::ConstReference(lhs); - const size_t actual_size = lhs_stl_container.size(); - if (actual_size != rhs_.size()) { - *listener << "which contains " << actual_size << " values"; - return false; - } - - typename LhsStlContainer::const_iterator left = lhs_stl_container.begin(); - typename RhsStlContainer::const_iterator right = rhs_.begin(); - for (size_t i = 0; i != actual_size; ++i, ++left, ++right) { - if (listener->IsInterested()) { - StringMatchResultListener inner_listener; - // Create InnerMatcherArg as a temporarily object to avoid it outlives - // *left and *right. Dereference or the conversion to `const T&` may - // return temp objects, e.g for vector<bool>. - if (!mono_tuple_matcher_.MatchAndExplain( - InnerMatcherArg(ImplicitCast_<const LhsValue&>(*left), - ImplicitCast_<const RhsValue&>(*right)), - &inner_listener)) { - *listener << "where the value pair ("; - UniversalPrint(*left, listener->stream()); - *listener << ", "; - UniversalPrint(*right, listener->stream()); - *listener << ") at index #" << i << " don't match"; - PrintIfNotEmpty(inner_listener.str(), listener->stream()); - return false; - } - } else { - if (!mono_tuple_matcher_.Matches( - InnerMatcherArg(ImplicitCast_<const LhsValue&>(*left), - ImplicitCast_<const RhsValue&>(*right)))) - return false; - } - } - - return true; - } - - private: - const Matcher<InnerMatcherArg> mono_tuple_matcher_; - const RhsStlContainer rhs_; - }; - - private: - const TupleMatcher tuple_matcher_; - const RhsStlContainer rhs_; -}; - -// Holds the logic common to ContainsMatcherImpl and EachMatcherImpl. -template <typename Container> -class QuantifierMatcherImpl : public MatcherInterface<Container> { - public: - typedef GTEST_REMOVE_REFERENCE_AND_CONST_(Container) RawContainer; - typedef StlContainerView<RawContainer> View; - typedef typename View::type StlContainer; - typedef typename View::const_reference StlContainerReference; - typedef typename StlContainer::value_type Element; - - template <typename InnerMatcher> - explicit QuantifierMatcherImpl(InnerMatcher inner_matcher) - : inner_matcher_( - testing::SafeMatcherCast<const Element&>(inner_matcher)) {} - - // Checks whether: - // * All elements in the container match, if all_elements_should_match. - // * Any element in the container matches, if !all_elements_should_match. - bool MatchAndExplainImpl(bool all_elements_should_match, - Container container, - MatchResultListener* listener) const { - StlContainerReference stl_container = View::ConstReference(container); - size_t i = 0; - for (typename StlContainer::const_iterator it = stl_container.begin(); - it != stl_container.end(); ++it, ++i) { - StringMatchResultListener inner_listener; - const bool matches = inner_matcher_.MatchAndExplain(*it, &inner_listener); - - if (matches != all_elements_should_match) { - *listener << "whose element #" << i - << (matches ? " matches" : " doesn't match"); - PrintIfNotEmpty(inner_listener.str(), listener->stream()); - return !all_elements_should_match; - } - } - return all_elements_should_match; - } - - protected: - const Matcher<const Element&> inner_matcher_; -}; - -// Implements Contains(element_matcher) for the given argument type Container. -// Symmetric to EachMatcherImpl. -template <typename Container> -class ContainsMatcherImpl : public QuantifierMatcherImpl<Container> { - public: - template <typename InnerMatcher> - explicit ContainsMatcherImpl(InnerMatcher inner_matcher) - : QuantifierMatcherImpl<Container>(inner_matcher) {} - - // Describes what this matcher does. - void DescribeTo(::std::ostream* os) const override { - *os << "contains at least one element that "; - this->inner_matcher_.DescribeTo(os); - } - - void DescribeNegationTo(::std::ostream* os) const override { - *os << "doesn't contain any element that "; - this->inner_matcher_.DescribeTo(os); - } - - bool MatchAndExplain(Container container, - MatchResultListener* listener) const override { - return this->MatchAndExplainImpl(false, container, listener); - } -}; - -// Implements Each(element_matcher) for the given argument type Container. -// Symmetric to ContainsMatcherImpl. -template <typename Container> -class EachMatcherImpl : public QuantifierMatcherImpl<Container> { - public: - template <typename InnerMatcher> - explicit EachMatcherImpl(InnerMatcher inner_matcher) - : QuantifierMatcherImpl<Container>(inner_matcher) {} - - // Describes what this matcher does. - void DescribeTo(::std::ostream* os) const override { - *os << "only contains elements that "; - this->inner_matcher_.DescribeTo(os); - } - - void DescribeNegationTo(::std::ostream* os) const override { - *os << "contains some element that "; - this->inner_matcher_.DescribeNegationTo(os); - } - - bool MatchAndExplain(Container container, - MatchResultListener* listener) const override { - return this->MatchAndExplainImpl(true, container, listener); - } -}; - -// Implements polymorphic Contains(element_matcher). -template <typename M> -class ContainsMatcher { - public: - explicit ContainsMatcher(M m) : inner_matcher_(m) {} - - template <typename Container> - operator Matcher<Container>() const { - return Matcher<Container>( - new ContainsMatcherImpl<const Container&>(inner_matcher_)); - } - - private: - const M inner_matcher_; -}; - -// Implements polymorphic Each(element_matcher). -template <typename M> -class EachMatcher { - public: - explicit EachMatcher(M m) : inner_matcher_(m) {} - - template <typename Container> - operator Matcher<Container>() const { - return Matcher<Container>( - new EachMatcherImpl<const Container&>(inner_matcher_)); - } - - private: - const M inner_matcher_; -}; - -struct Rank1 {}; -struct Rank0 : Rank1 {}; - -namespace pair_getters { -using std::get; -template <typename T> -auto First(T& x, Rank1) -> decltype(get<0>(x)) { // NOLINT - return get<0>(x); -} -template <typename T> -auto First(T& x, Rank0) -> decltype((x.first)) { // NOLINT - return x.first; -} - -template <typename T> -auto Second(T& x, Rank1) -> decltype(get<1>(x)) { // NOLINT - return get<1>(x); -} -template <typename T> -auto Second(T& x, Rank0) -> decltype((x.second)) { // NOLINT - return x.second; -} -} // namespace pair_getters - -// Implements Key(inner_matcher) for the given argument pair type. -// Key(inner_matcher) matches an std::pair whose 'first' field matches -// inner_matcher. For example, Contains(Key(Ge(5))) can be used to match an -// std::map that contains at least one element whose key is >= 5. -template <typename PairType> -class KeyMatcherImpl : public MatcherInterface<PairType> { - public: - typedef GTEST_REMOVE_REFERENCE_AND_CONST_(PairType) RawPairType; - typedef typename RawPairType::first_type KeyType; - - template <typename InnerMatcher> - explicit KeyMatcherImpl(InnerMatcher inner_matcher) - : inner_matcher_( - testing::SafeMatcherCast<const KeyType&>(inner_matcher)) { - } - - // Returns true if and only if 'key_value.first' (the key) matches the inner - // matcher. - bool MatchAndExplain(PairType key_value, - MatchResultListener* listener) const override { - StringMatchResultListener inner_listener; - const bool match = inner_matcher_.MatchAndExplain( - pair_getters::First(key_value, Rank0()), &inner_listener); - const std::string explanation = inner_listener.str(); - if (explanation != "") { - *listener << "whose first field is a value " << explanation; - } - return match; - } - - // Describes what this matcher does. - void DescribeTo(::std::ostream* os) const override { - *os << "has a key that "; - inner_matcher_.DescribeTo(os); - } - - // Describes what the negation of this matcher does. - void DescribeNegationTo(::std::ostream* os) const override { - *os << "doesn't have a key that "; - inner_matcher_.DescribeTo(os); - } - - private: - const Matcher<const KeyType&> inner_matcher_; -}; - -// Implements polymorphic Key(matcher_for_key). -template <typename M> -class KeyMatcher { - public: - explicit KeyMatcher(M m) : matcher_for_key_(m) {} - - template <typename PairType> - operator Matcher<PairType>() const { - return Matcher<PairType>( - new KeyMatcherImpl<const PairType&>(matcher_for_key_)); - } - - private: - const M matcher_for_key_; -}; - -// Implements polymorphic Address(matcher_for_address). -template <typename InnerMatcher> -class AddressMatcher { - public: - explicit AddressMatcher(InnerMatcher m) : matcher_(m) {} - - template <typename Type> - operator Matcher<Type>() const { // NOLINT - return Matcher<Type>(new Impl<const Type&>(matcher_)); - } - - private: - // The monomorphic implementation that works for a particular object type. - template <typename Type> - class Impl : public MatcherInterface<Type> { - public: - using Address = const GTEST_REMOVE_REFERENCE_AND_CONST_(Type) *; - explicit Impl(const InnerMatcher& matcher) - : matcher_(MatcherCast<Address>(matcher)) {} - - void DescribeTo(::std::ostream* os) const override { - *os << "has address that "; - matcher_.DescribeTo(os); - } - - void DescribeNegationTo(::std::ostream* os) const override { - *os << "does not have address that "; - matcher_.DescribeTo(os); - } - - bool MatchAndExplain(Type object, - MatchResultListener* listener) const override { - *listener << "which has address "; - Address address = std::addressof(object); - return MatchPrintAndExplain(address, matcher_, listener); - } - - private: - const Matcher<Address> matcher_; - }; - const InnerMatcher matcher_; -}; - -// Implements Pair(first_matcher, second_matcher) for the given argument pair -// type with its two matchers. See Pair() function below. -template <typename PairType> -class PairMatcherImpl : public MatcherInterface<PairType> { - public: - typedef GTEST_REMOVE_REFERENCE_AND_CONST_(PairType) RawPairType; - typedef typename RawPairType::first_type FirstType; - typedef typename RawPairType::second_type SecondType; - - template <typename FirstMatcher, typename SecondMatcher> - PairMatcherImpl(FirstMatcher first_matcher, SecondMatcher second_matcher) - : first_matcher_( - testing::SafeMatcherCast<const FirstType&>(first_matcher)), - second_matcher_( - testing::SafeMatcherCast<const SecondType&>(second_matcher)) { - } - - // Describes what this matcher does. - void DescribeTo(::std::ostream* os) const override { - *os << "has a first field that "; - first_matcher_.DescribeTo(os); - *os << ", and has a second field that "; - second_matcher_.DescribeTo(os); - } - - // Describes what the negation of this matcher does. - void DescribeNegationTo(::std::ostream* os) const override { - *os << "has a first field that "; - first_matcher_.DescribeNegationTo(os); - *os << ", or has a second field that "; - second_matcher_.DescribeNegationTo(os); - } - - // Returns true if and only if 'a_pair.first' matches first_matcher and - // 'a_pair.second' matches second_matcher. - bool MatchAndExplain(PairType a_pair, - MatchResultListener* listener) const override { - if (!listener->IsInterested()) { - // If the listener is not interested, we don't need to construct the - // explanation. - return first_matcher_.Matches(pair_getters::First(a_pair, Rank0())) && - second_matcher_.Matches(pair_getters::Second(a_pair, Rank0())); - } - StringMatchResultListener first_inner_listener; - if (!first_matcher_.MatchAndExplain(pair_getters::First(a_pair, Rank0()), - &first_inner_listener)) { - *listener << "whose first field does not match"; - PrintIfNotEmpty(first_inner_listener.str(), listener->stream()); - return false; - } - StringMatchResultListener second_inner_listener; - if (!second_matcher_.MatchAndExplain(pair_getters::Second(a_pair, Rank0()), - &second_inner_listener)) { - *listener << "whose second field does not match"; - PrintIfNotEmpty(second_inner_listener.str(), listener->stream()); - return false; - } - ExplainSuccess(first_inner_listener.str(), second_inner_listener.str(), - listener); - return true; - } - - private: - void ExplainSuccess(const std::string& first_explanation, - const std::string& second_explanation, - MatchResultListener* listener) const { - *listener << "whose both fields match"; - if (first_explanation != "") { - *listener << ", where the first field is a value " << first_explanation; - } - if (second_explanation != "") { - *listener << ", "; - if (first_explanation != "") { - *listener << "and "; - } else { - *listener << "where "; - } - *listener << "the second field is a value " << second_explanation; - } - } - - const Matcher<const FirstType&> first_matcher_; - const Matcher<const SecondType&> second_matcher_; -}; - -// Implements polymorphic Pair(first_matcher, second_matcher). -template <typename FirstMatcher, typename SecondMatcher> -class PairMatcher { - public: - PairMatcher(FirstMatcher first_matcher, SecondMatcher second_matcher) - : first_matcher_(first_matcher), second_matcher_(second_matcher) {} - - template <typename PairType> - operator Matcher<PairType> () const { - return Matcher<PairType>( - new PairMatcherImpl<const PairType&>(first_matcher_, second_matcher_)); - } - - private: - const FirstMatcher first_matcher_; - const SecondMatcher second_matcher_; -}; - -template <typename T, size_t... I> -auto UnpackStructImpl(const T& t, IndexSequence<I...>, int) - -> decltype(std::tie(get<I>(t)...)) { - static_assert(std::tuple_size<T>::value == sizeof...(I), - "Number of arguments doesn't match the number of fields."); - return std::tie(get<I>(t)...); -} - -#if defined(__cpp_structured_bindings) && __cpp_structured_bindings >= 201606 -template <typename T> -auto UnpackStructImpl(const T& t, MakeIndexSequence<1>, char) { - const auto& [a] = t; - return std::tie(a); -} -template <typename T> -auto UnpackStructImpl(const T& t, MakeIndexSequence<2>, char) { - const auto& [a, b] = t; - return std::tie(a, b); -} -template <typename T> -auto UnpackStructImpl(const T& t, MakeIndexSequence<3>, char) { - const auto& [a, b, c] = t; - return std::tie(a, b, c); -} -template <typename T> -auto UnpackStructImpl(const T& t, MakeIndexSequence<4>, char) { - const auto& [a, b, c, d] = t; - return std::tie(a, b, c, d); -} -template <typename T> -auto UnpackStructImpl(const T& t, MakeIndexSequence<5>, char) { - const auto& [a, b, c, d, e] = t; - return std::tie(a, b, c, d, e); -} -template <typename T> -auto UnpackStructImpl(const T& t, MakeIndexSequence<6>, char) { - const auto& [a, b, c, d, e, f] = t; - return std::tie(a, b, c, d, e, f); -} -template <typename T> -auto UnpackStructImpl(const T& t, MakeIndexSequence<7>, char) { - const auto& [a, b, c, d, e, f, g] = t; - return std::tie(a, b, c, d, e, f, g); -} -template <typename T> -auto UnpackStructImpl(const T& t, MakeIndexSequence<8>, char) { - const auto& [a, b, c, d, e, f, g, h] = t; - return std::tie(a, b, c, d, e, f, g, h); -} -template <typename T> -auto UnpackStructImpl(const T& t, MakeIndexSequence<9>, char) { - const auto& [a, b, c, d, e, f, g, h, i] = t; - return std::tie(a, b, c, d, e, f, g, h, i); -} -template <typename T> -auto UnpackStructImpl(const T& t, MakeIndexSequence<10>, char) { - const auto& [a, b, c, d, e, f, g, h, i, j] = t; - return std::tie(a, b, c, d, e, f, g, h, i, j); -} -template <typename T> -auto UnpackStructImpl(const T& t, MakeIndexSequence<11>, char) { - const auto& [a, b, c, d, e, f, g, h, i, j, k] = t; - return std::tie(a, b, c, d, e, f, g, h, i, j, k); -} -template <typename T> -auto UnpackStructImpl(const T& t, MakeIndexSequence<12>, char) { - const auto& [a, b, c, d, e, f, g, h, i, j, k, l] = t; - return std::tie(a, b, c, d, e, f, g, h, i, j, k, l); -} -template <typename T> -auto UnpackStructImpl(const T& t, MakeIndexSequence<13>, char) { - const auto& [a, b, c, d, e, f, g, h, i, j, k, l, m] = t; - return std::tie(a, b, c, d, e, f, g, h, i, j, k, l, m); -} -template <typename T> -auto UnpackStructImpl(const T& t, MakeIndexSequence<14>, char) { - const auto& [a, b, c, d, e, f, g, h, i, j, k, l, m, n] = t; - return std::tie(a, b, c, d, e, f, g, h, i, j, k, l, m, n); -} -template <typename T> -auto UnpackStructImpl(const T& t, MakeIndexSequence<15>, char) { - const auto& [a, b, c, d, e, f, g, h, i, j, k, l, m, n, o] = t; - return std::tie(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o); -} -template <typename T> -auto UnpackStructImpl(const T& t, MakeIndexSequence<16>, char) { - const auto& [a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p] = t; - return std::tie(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p); -} -#endif // defined(__cpp_structured_bindings) - -template <size_t I, typename T> -auto UnpackStruct(const T& t) - -> decltype((UnpackStructImpl)(t, MakeIndexSequence<I>{}, 0)) { - return (UnpackStructImpl)(t, MakeIndexSequence<I>{}, 0); -} - -// Helper function to do comma folding in C++11. -// The array ensures left-to-right order of evaluation. -// Usage: VariadicExpand({expr...}); -template <typename T, size_t N> -void VariadicExpand(const T (&)[N]) {} - -template <typename Struct, typename StructSize> -class FieldsAreMatcherImpl; - -template <typename Struct, size_t... I> -class FieldsAreMatcherImpl<Struct, IndexSequence<I...>> - : public MatcherInterface<Struct> { - using UnpackedType = - decltype(UnpackStruct<sizeof...(I)>(std::declval<const Struct&>())); - using MatchersType = std::tuple< - Matcher<const typename std::tuple_element<I, UnpackedType>::type&>...>; - - public: - template <typename Inner> - explicit FieldsAreMatcherImpl(const Inner& matchers) - : matchers_(testing::SafeMatcherCast< - const typename std::tuple_element<I, UnpackedType>::type&>( - std::get<I>(matchers))...) {} - - void DescribeTo(::std::ostream* os) const override { - const char* separator = ""; - VariadicExpand( - {(*os << separator << "has field #" << I << " that ", - std::get<I>(matchers_).DescribeTo(os), separator = ", and ")...}); - } - - void DescribeNegationTo(::std::ostream* os) const override { - const char* separator = ""; - VariadicExpand({(*os << separator << "has field #" << I << " that ", - std::get<I>(matchers_).DescribeNegationTo(os), - separator = ", or ")...}); - } - - bool MatchAndExplain(Struct t, MatchResultListener* listener) const override { - return MatchInternal((UnpackStruct<sizeof...(I)>)(t), listener); - } - - private: - bool MatchInternal(UnpackedType tuple, MatchResultListener* listener) const { - if (!listener->IsInterested()) { - // If the listener is not interested, we don't need to construct the - // explanation. - bool good = true; - VariadicExpand({good = good && std::get<I>(matchers_).Matches( - std::get<I>(tuple))...}); - return good; - } - - size_t failed_pos = ~size_t{}; - - std::vector<StringMatchResultListener> inner_listener(sizeof...(I)); - - VariadicExpand( - {failed_pos == ~size_t{} && !std::get<I>(matchers_).MatchAndExplain( - std::get<I>(tuple), &inner_listener[I]) - ? failed_pos = I - : 0 ...}); - if (failed_pos != ~size_t{}) { - *listener << "whose field #" << failed_pos << " does not match"; - PrintIfNotEmpty(inner_listener[failed_pos].str(), listener->stream()); - return false; - } - - *listener << "whose all elements match"; - const char* separator = ", where"; - for (size_t index = 0; index < sizeof...(I); ++index) { - const std::string str = inner_listener[index].str(); - if (!str.empty()) { - *listener << separator << " field #" << index << " is a value " << str; - separator = ", and"; - } - } - - return true; - } - - MatchersType matchers_; -}; - -template <typename... Inner> -class FieldsAreMatcher { - public: - explicit FieldsAreMatcher(Inner... inner) : matchers_(std::move(inner)...) {} - - template <typename Struct> - operator Matcher<Struct>() const { // NOLINT - return Matcher<Struct>( - new FieldsAreMatcherImpl<const Struct&, IndexSequenceFor<Inner...>>( - matchers_)); - } - - private: - std::tuple<Inner...> matchers_; -}; - -// Implements ElementsAre() and ElementsAreArray(). -template <typename Container> -class ElementsAreMatcherImpl : public MatcherInterface<Container> { - public: - typedef GTEST_REMOVE_REFERENCE_AND_CONST_(Container) RawContainer; - typedef internal::StlContainerView<RawContainer> View; - typedef typename View::type StlContainer; - typedef typename View::const_reference StlContainerReference; - typedef typename StlContainer::value_type Element; - - // Constructs the matcher from a sequence of element values or - // element matchers. - template <typename InputIter> - ElementsAreMatcherImpl(InputIter first, InputIter last) { - while (first != last) { - matchers_.push_back(MatcherCast<const Element&>(*first++)); - } - } - - // Describes what this matcher does. - void DescribeTo(::std::ostream* os) const override { - if (count() == 0) { - *os << "is empty"; - } else if (count() == 1) { - *os << "has 1 element that "; - matchers_[0].DescribeTo(os); - } else { - *os << "has " << Elements(count()) << " where\n"; - for (size_t i = 0; i != count(); ++i) { - *os << "element #" << i << " "; - matchers_[i].DescribeTo(os); - if (i + 1 < count()) { - *os << ",\n"; - } - } - } - } - - // Describes what the negation of this matcher does. - void DescribeNegationTo(::std::ostream* os) const override { - if (count() == 0) { - *os << "isn't empty"; - return; - } - - *os << "doesn't have " << Elements(count()) << ", or\n"; - for (size_t i = 0; i != count(); ++i) { - *os << "element #" << i << " "; - matchers_[i].DescribeNegationTo(os); - if (i + 1 < count()) { - *os << ", or\n"; - } - } - } - - bool MatchAndExplain(Container container, - MatchResultListener* listener) const override { - // To work with stream-like "containers", we must only walk - // through the elements in one pass. - - const bool listener_interested = listener->IsInterested(); - - // explanations[i] is the explanation of the element at index i. - ::std::vector<std::string> explanations(count()); - StlContainerReference stl_container = View::ConstReference(container); - typename StlContainer::const_iterator it = stl_container.begin(); - size_t exam_pos = 0; - bool mismatch_found = false; // Have we found a mismatched element yet? - - // Go through the elements and matchers in pairs, until we reach - // the end of either the elements or the matchers, or until we find a - // mismatch. - for (; it != stl_container.end() && exam_pos != count(); ++it, ++exam_pos) { - bool match; // Does the current element match the current matcher? - if (listener_interested) { - StringMatchResultListener s; - match = matchers_[exam_pos].MatchAndExplain(*it, &s); - explanations[exam_pos] = s.str(); - } else { - match = matchers_[exam_pos].Matches(*it); - } - - if (!match) { - mismatch_found = true; - break; - } - } - // If mismatch_found is true, 'exam_pos' is the index of the mismatch. - - // Find how many elements the actual container has. We avoid - // calling size() s.t. this code works for stream-like "containers" - // that don't define size(). - size_t actual_count = exam_pos; - for (; it != stl_container.end(); ++it) { - ++actual_count; - } - - if (actual_count != count()) { - // The element count doesn't match. If the container is empty, - // there's no need to explain anything as Google Mock already - // prints the empty container. Otherwise we just need to show - // how many elements there actually are. - if (listener_interested && (actual_count != 0)) { - *listener << "which has " << Elements(actual_count); - } - return false; - } - - if (mismatch_found) { - // The element count matches, but the exam_pos-th element doesn't match. - if (listener_interested) { - *listener << "whose element #" << exam_pos << " doesn't match"; - PrintIfNotEmpty(explanations[exam_pos], listener->stream()); - } - return false; - } - - // Every element matches its expectation. We need to explain why - // (the obvious ones can be skipped). - if (listener_interested) { - bool reason_printed = false; - for (size_t i = 0; i != count(); ++i) { - const std::string& s = explanations[i]; - if (!s.empty()) { - if (reason_printed) { - *listener << ",\nand "; - } - *listener << "whose element #" << i << " matches, " << s; - reason_printed = true; - } - } - } - return true; - } - - private: - static Message Elements(size_t count) { - return Message() << count << (count == 1 ? " element" : " elements"); - } - - size_t count() const { return matchers_.size(); } - - ::std::vector<Matcher<const Element&> > matchers_; -}; - -// Connectivity matrix of (elements X matchers), in element-major order. -// Initially, there are no edges. -// Use NextGraph() to iterate over all possible edge configurations. -// Use Randomize() to generate a random edge configuration. -class GTEST_API_ MatchMatrix { - public: - MatchMatrix(size_t num_elements, size_t num_matchers) - : num_elements_(num_elements), - num_matchers_(num_matchers), - matched_(num_elements_* num_matchers_, 0) { - } - - size_t LhsSize() const { return num_elements_; } - size_t RhsSize() const { return num_matchers_; } - bool HasEdge(size_t ilhs, size_t irhs) const { - return matched_[SpaceIndex(ilhs, irhs)] == 1; - } - void SetEdge(size_t ilhs, size_t irhs, bool b) { - matched_[SpaceIndex(ilhs, irhs)] = b ? 1 : 0; - } - - // Treating the connectivity matrix as a (LhsSize()*RhsSize())-bit number, - // adds 1 to that number; returns false if incrementing the graph left it - // empty. - bool NextGraph(); - - void Randomize(); - - std::string DebugString() const; - - private: - size_t SpaceIndex(size_t ilhs, size_t irhs) const { - return ilhs * num_matchers_ + irhs; - } - - size_t num_elements_; - size_t num_matchers_; - - // Each element is a char interpreted as bool. They are stored as a - // flattened array in lhs-major order, use 'SpaceIndex()' to translate - // a (ilhs, irhs) matrix coordinate into an offset. - ::std::vector<char> matched_; -}; - -typedef ::std::pair<size_t, size_t> ElementMatcherPair; -typedef ::std::vector<ElementMatcherPair> ElementMatcherPairs; - -// Returns a maximum bipartite matching for the specified graph 'g'. -// The matching is represented as a vector of {element, matcher} pairs. -GTEST_API_ ElementMatcherPairs -FindMaxBipartiteMatching(const MatchMatrix& g); - -struct UnorderedMatcherRequire { - enum Flags { - Superset = 1 << 0, - Subset = 1 << 1, - ExactMatch = Superset | Subset, - }; -}; - -// Untyped base class for implementing UnorderedElementsAre. By -// putting logic that's not specific to the element type here, we -// reduce binary bloat and increase compilation speed. -class GTEST_API_ UnorderedElementsAreMatcherImplBase { - protected: - explicit UnorderedElementsAreMatcherImplBase( - UnorderedMatcherRequire::Flags matcher_flags) - : match_flags_(matcher_flags) {} - - // A vector of matcher describers, one for each element matcher. - // Does not own the describers (and thus can be used only when the - // element matchers are alive). - typedef ::std::vector<const MatcherDescriberInterface*> MatcherDescriberVec; - - // Describes this UnorderedElementsAre matcher. - void DescribeToImpl(::std::ostream* os) const; - - // Describes the negation of this UnorderedElementsAre matcher. - void DescribeNegationToImpl(::std::ostream* os) const; - - bool VerifyMatchMatrix(const ::std::vector<std::string>& element_printouts, - const MatchMatrix& matrix, - MatchResultListener* listener) const; - - bool FindPairing(const MatchMatrix& matrix, - MatchResultListener* listener) const; - - MatcherDescriberVec& matcher_describers() { - return matcher_describers_; - } - - static Message Elements(size_t n) { - return Message() << n << " element" << (n == 1 ? "" : "s"); - } - - UnorderedMatcherRequire::Flags match_flags() const { return match_flags_; } - - private: - UnorderedMatcherRequire::Flags match_flags_; - MatcherDescriberVec matcher_describers_; -}; - -// Implements UnorderedElementsAre, UnorderedElementsAreArray, IsSubsetOf, and -// IsSupersetOf. -template <typename Container> -class UnorderedElementsAreMatcherImpl - : public MatcherInterface<Container>, - public UnorderedElementsAreMatcherImplBase { - public: - typedef GTEST_REMOVE_REFERENCE_AND_CONST_(Container) RawContainer; - typedef internal::StlContainerView<RawContainer> View; - typedef typename View::type StlContainer; - typedef typename View::const_reference StlContainerReference; - typedef typename StlContainer::const_iterator StlContainerConstIterator; - typedef typename StlContainer::value_type Element; - - template <typename InputIter> - UnorderedElementsAreMatcherImpl(UnorderedMatcherRequire::Flags matcher_flags, - InputIter first, InputIter last) - : UnorderedElementsAreMatcherImplBase(matcher_flags) { - for (; first != last; ++first) { - matchers_.push_back(MatcherCast<const Element&>(*first)); - } - for (const auto& m : matchers_) { - matcher_describers().push_back(m.GetDescriber()); - } - } - - // Describes what this matcher does. - void DescribeTo(::std::ostream* os) const override { - return UnorderedElementsAreMatcherImplBase::DescribeToImpl(os); - } - - // Describes what the negation of this matcher does. - void DescribeNegationTo(::std::ostream* os) const override { - return UnorderedElementsAreMatcherImplBase::DescribeNegationToImpl(os); - } - - bool MatchAndExplain(Container container, - MatchResultListener* listener) const override { - StlContainerReference stl_container = View::ConstReference(container); - ::std::vector<std::string> element_printouts; - MatchMatrix matrix = - AnalyzeElements(stl_container.begin(), stl_container.end(), - &element_printouts, listener); - - if (matrix.LhsSize() == 0 && matrix.RhsSize() == 0) { - return true; - } - - if (match_flags() == UnorderedMatcherRequire::ExactMatch) { - if (matrix.LhsSize() != matrix.RhsSize()) { - // The element count doesn't match. If the container is empty, - // there's no need to explain anything as Google Mock already - // prints the empty container. Otherwise we just need to show - // how many elements there actually are. - if (matrix.LhsSize() != 0 && listener->IsInterested()) { - *listener << "which has " << Elements(matrix.LhsSize()); - } - return false; - } - } - - return VerifyMatchMatrix(element_printouts, matrix, listener) && - FindPairing(matrix, listener); - } - - private: - template <typename ElementIter> - MatchMatrix AnalyzeElements(ElementIter elem_first, ElementIter elem_last, - ::std::vector<std::string>* element_printouts, - MatchResultListener* listener) const { - element_printouts->clear(); - ::std::vector<char> did_match; - size_t num_elements = 0; - DummyMatchResultListener dummy; - for (; elem_first != elem_last; ++num_elements, ++elem_first) { - if (listener->IsInterested()) { - element_printouts->push_back(PrintToString(*elem_first)); - } - for (size_t irhs = 0; irhs != matchers_.size(); ++irhs) { - did_match.push_back( - matchers_[irhs].MatchAndExplain(*elem_first, &dummy)); - } - } - - MatchMatrix matrix(num_elements, matchers_.size()); - ::std::vector<char>::const_iterator did_match_iter = did_match.begin(); - for (size_t ilhs = 0; ilhs != num_elements; ++ilhs) { - for (size_t irhs = 0; irhs != matchers_.size(); ++irhs) { - matrix.SetEdge(ilhs, irhs, *did_match_iter++ != 0); - } - } - return matrix; - } - - ::std::vector<Matcher<const Element&> > matchers_; -}; - -// Functor for use in TransformTuple. -// Performs MatcherCast<Target> on an input argument of any type. -template <typename Target> -struct CastAndAppendTransform { - template <typename Arg> - Matcher<Target> operator()(const Arg& a) const { - return MatcherCast<Target>(a); - } -}; - -// Implements UnorderedElementsAre. -template <typename MatcherTuple> -class UnorderedElementsAreMatcher { - public: - explicit UnorderedElementsAreMatcher(const MatcherTuple& args) - : matchers_(args) {} - - template <typename Container> - operator Matcher<Container>() const { - typedef GTEST_REMOVE_REFERENCE_AND_CONST_(Container) RawContainer; - typedef typename internal::StlContainerView<RawContainer>::type View; - typedef typename View::value_type Element; - typedef ::std::vector<Matcher<const Element&> > MatcherVec; - MatcherVec matchers; - matchers.reserve(::std::tuple_size<MatcherTuple>::value); - TransformTupleValues(CastAndAppendTransform<const Element&>(), matchers_, - ::std::back_inserter(matchers)); - return Matcher<Container>( - new UnorderedElementsAreMatcherImpl<const Container&>( - UnorderedMatcherRequire::ExactMatch, matchers.begin(), - matchers.end())); - } - - private: - const MatcherTuple matchers_; -}; - -// Implements ElementsAre. -template <typename MatcherTuple> -class ElementsAreMatcher { - public: - explicit ElementsAreMatcher(const MatcherTuple& args) : matchers_(args) {} - - template <typename Container> - operator Matcher<Container>() const { - GTEST_COMPILE_ASSERT_( - !IsHashTable<GTEST_REMOVE_REFERENCE_AND_CONST_(Container)>::value || - ::std::tuple_size<MatcherTuple>::value < 2, - use_UnorderedElementsAre_with_hash_tables); - - typedef GTEST_REMOVE_REFERENCE_AND_CONST_(Container) RawContainer; - typedef typename internal::StlContainerView<RawContainer>::type View; - typedef typename View::value_type Element; - typedef ::std::vector<Matcher<const Element&> > MatcherVec; - MatcherVec matchers; - matchers.reserve(::std::tuple_size<MatcherTuple>::value); - TransformTupleValues(CastAndAppendTransform<const Element&>(), matchers_, - ::std::back_inserter(matchers)); - return Matcher<Container>(new ElementsAreMatcherImpl<const Container&>( - matchers.begin(), matchers.end())); - } - - private: - const MatcherTuple matchers_; -}; - -// Implements UnorderedElementsAreArray(), IsSubsetOf(), and IsSupersetOf(). -template <typename T> -class UnorderedElementsAreArrayMatcher { - public: - template <typename Iter> - UnorderedElementsAreArrayMatcher(UnorderedMatcherRequire::Flags match_flags, - Iter first, Iter last) - : match_flags_(match_flags), matchers_(first, last) {} - - template <typename Container> - operator Matcher<Container>() const { - return Matcher<Container>( - new UnorderedElementsAreMatcherImpl<const Container&>( - match_flags_, matchers_.begin(), matchers_.end())); - } - - private: - UnorderedMatcherRequire::Flags match_flags_; - ::std::vector<T> matchers_; -}; - -// Implements ElementsAreArray(). -template <typename T> -class ElementsAreArrayMatcher { - public: - template <typename Iter> - ElementsAreArrayMatcher(Iter first, Iter last) : matchers_(first, last) {} - - template <typename Container> - operator Matcher<Container>() const { - GTEST_COMPILE_ASSERT_( - !IsHashTable<GTEST_REMOVE_REFERENCE_AND_CONST_(Container)>::value, - use_UnorderedElementsAreArray_with_hash_tables); - - return Matcher<Container>(new ElementsAreMatcherImpl<const Container&>( - matchers_.begin(), matchers_.end())); - } - - private: - const ::std::vector<T> matchers_; -}; - -// Given a 2-tuple matcher tm of type Tuple2Matcher and a value second -// of type Second, BoundSecondMatcher<Tuple2Matcher, Second>(tm, -// second) is a polymorphic matcher that matches a value x if and only if -// tm matches tuple (x, second). Useful for implementing -// UnorderedPointwise() in terms of UnorderedElementsAreArray(). -// -// BoundSecondMatcher is copyable and assignable, as we need to put -// instances of this class in a vector when implementing -// UnorderedPointwise(). -template <typename Tuple2Matcher, typename Second> -class BoundSecondMatcher { - public: - BoundSecondMatcher(const Tuple2Matcher& tm, const Second& second) - : tuple2_matcher_(tm), second_value_(second) {} - - BoundSecondMatcher(const BoundSecondMatcher& other) = default; - - template <typename T> - operator Matcher<T>() const { - return MakeMatcher(new Impl<T>(tuple2_matcher_, second_value_)); - } - - // We have to define this for UnorderedPointwise() to compile in - // C++98 mode, as it puts BoundSecondMatcher instances in a vector, - // which requires the elements to be assignable in C++98. The - // compiler cannot generate the operator= for us, as Tuple2Matcher - // and Second may not be assignable. - // - // However, this should never be called, so the implementation just - // need to assert. - void operator=(const BoundSecondMatcher& /*rhs*/) { - GTEST_LOG_(FATAL) << "BoundSecondMatcher should never be assigned."; - } - - private: - template <typename T> - class Impl : public MatcherInterface<T> { - public: - typedef ::std::tuple<T, Second> ArgTuple; - - Impl(const Tuple2Matcher& tm, const Second& second) - : mono_tuple2_matcher_(SafeMatcherCast<const ArgTuple&>(tm)), - second_value_(second) {} - - void DescribeTo(::std::ostream* os) const override { - *os << "and "; - UniversalPrint(second_value_, os); - *os << " "; - mono_tuple2_matcher_.DescribeTo(os); - } - - bool MatchAndExplain(T x, MatchResultListener* listener) const override { - return mono_tuple2_matcher_.MatchAndExplain(ArgTuple(x, second_value_), - listener); - } - - private: - const Matcher<const ArgTuple&> mono_tuple2_matcher_; - const Second second_value_; - }; - - const Tuple2Matcher tuple2_matcher_; - const Second second_value_; -}; - -// Given a 2-tuple matcher tm and a value second, -// MatcherBindSecond(tm, second) returns a matcher that matches a -// value x if and only if tm matches tuple (x, second). Useful for -// implementing UnorderedPointwise() in terms of UnorderedElementsAreArray(). -template <typename Tuple2Matcher, typename Second> -BoundSecondMatcher<Tuple2Matcher, Second> MatcherBindSecond( - const Tuple2Matcher& tm, const Second& second) { - return BoundSecondMatcher<Tuple2Matcher, Second>(tm, second); -} - -// Returns the description for a matcher defined using the MATCHER*() -// macro where the user-supplied description string is "", if -// 'negation' is false; otherwise returns the description of the -// negation of the matcher. 'param_values' contains a list of strings -// that are the print-out of the matcher's parameters. -GTEST_API_ std::string FormatMatcherDescription(bool negation, - const char* matcher_name, - const Strings& param_values); - -// Implements a matcher that checks the value of a optional<> type variable. -template <typename ValueMatcher> -class OptionalMatcher { - public: - explicit OptionalMatcher(const ValueMatcher& value_matcher) - : value_matcher_(value_matcher) {} - - template <typename Optional> - operator Matcher<Optional>() const { - return Matcher<Optional>(new Impl<const Optional&>(value_matcher_)); - } - - template <typename Optional> - class Impl : public MatcherInterface<Optional> { - public: - typedef GTEST_REMOVE_REFERENCE_AND_CONST_(Optional) OptionalView; - typedef typename OptionalView::value_type ValueType; - explicit Impl(const ValueMatcher& value_matcher) - : value_matcher_(MatcherCast<ValueType>(value_matcher)) {} - - void DescribeTo(::std::ostream* os) const override { - *os << "value "; - value_matcher_.DescribeTo(os); - } - - void DescribeNegationTo(::std::ostream* os) const override { - *os << "value "; - value_matcher_.DescribeNegationTo(os); - } - - bool MatchAndExplain(Optional optional, - MatchResultListener* listener) const override { - if (!optional) { - *listener << "which is not engaged"; - return false; - } - const ValueType& value = *optional; - StringMatchResultListener value_listener; - const bool match = value_matcher_.MatchAndExplain(value, &value_listener); - *listener << "whose value " << PrintToString(value) - << (match ? " matches" : " doesn't match"); - PrintIfNotEmpty(value_listener.str(), listener->stream()); - return match; - } - - private: - const Matcher<ValueType> value_matcher_; - }; - - private: - const ValueMatcher value_matcher_; -}; - -namespace variant_matcher { -// Overloads to allow VariantMatcher to do proper ADL lookup. -template <typename T> -void holds_alternative() {} -template <typename T> -void get() {} - -// Implements a matcher that checks the value of a variant<> type variable. -template <typename T> -class VariantMatcher { - public: - explicit VariantMatcher(::testing::Matcher<const T&> matcher) - : matcher_(std::move(matcher)) {} - - template <typename Variant> - bool MatchAndExplain(const Variant& value, - ::testing::MatchResultListener* listener) const { - using std::get; - if (!listener->IsInterested()) { - return holds_alternative<T>(value) && matcher_.Matches(get<T>(value)); - } - - if (!holds_alternative<T>(value)) { - *listener << "whose value is not of type '" << GetTypeName() << "'"; - return false; - } - - const T& elem = get<T>(value); - StringMatchResultListener elem_listener; - const bool match = matcher_.MatchAndExplain(elem, &elem_listener); - *listener << "whose value " << PrintToString(elem) - << (match ? " matches" : " doesn't match"); - PrintIfNotEmpty(elem_listener.str(), listener->stream()); - return match; - } - - void DescribeTo(std::ostream* os) const { - *os << "is a variant<> with value of type '" << GetTypeName() - << "' and the value "; - matcher_.DescribeTo(os); - } - - void DescribeNegationTo(std::ostream* os) const { - *os << "is a variant<> with value of type other than '" << GetTypeName() - << "' or the value "; - matcher_.DescribeNegationTo(os); - } - - private: - static std::string GetTypeName() { -#if GTEST_HAS_RTTI - GTEST_SUPPRESS_UNREACHABLE_CODE_WARNING_BELOW_( - return internal::GetTypeName<T>()); -#endif - return "the element type"; - } - - const ::testing::Matcher<const T&> matcher_; -}; - -} // namespace variant_matcher - -namespace any_cast_matcher { - -// Overloads to allow AnyCastMatcher to do proper ADL lookup. -template <typename T> -void any_cast() {} - -// Implements a matcher that any_casts the value. -template <typename T> -class AnyCastMatcher { - public: - explicit AnyCastMatcher(const ::testing::Matcher<const T&>& matcher) - : matcher_(matcher) {} - - template <typename AnyType> - bool MatchAndExplain(const AnyType& value, - ::testing::MatchResultListener* listener) const { - if (!listener->IsInterested()) { - const T* ptr = any_cast<T>(&value); - return ptr != nullptr && matcher_.Matches(*ptr); - } - - const T* elem = any_cast<T>(&value); - if (elem == nullptr) { - *listener << "whose value is not of type '" << GetTypeName() << "'"; - return false; - } - - StringMatchResultListener elem_listener; - const bool match = matcher_.MatchAndExplain(*elem, &elem_listener); - *listener << "whose value " << PrintToString(*elem) - << (match ? " matches" : " doesn't match"); - PrintIfNotEmpty(elem_listener.str(), listener->stream()); - return match; - } - - void DescribeTo(std::ostream* os) const { - *os << "is an 'any' type with value of type '" << GetTypeName() - << "' and the value "; - matcher_.DescribeTo(os); - } - - void DescribeNegationTo(std::ostream* os) const { - *os << "is an 'any' type with value of type other than '" << GetTypeName() - << "' or the value "; - matcher_.DescribeNegationTo(os); - } - - private: - static std::string GetTypeName() { -#if GTEST_HAS_RTTI - GTEST_SUPPRESS_UNREACHABLE_CODE_WARNING_BELOW_( - return internal::GetTypeName<T>()); -#endif - return "the element type"; - } - - const ::testing::Matcher<const T&> matcher_; -}; - -} // namespace any_cast_matcher - -// Implements the Args() matcher. -template <class ArgsTuple, size_t... k> -class ArgsMatcherImpl : public MatcherInterface<ArgsTuple> { - public: - using RawArgsTuple = typename std::decay<ArgsTuple>::type; - using SelectedArgs = - std::tuple<typename std::tuple_element<k, RawArgsTuple>::type...>; - using MonomorphicInnerMatcher = Matcher<const SelectedArgs&>; - - template <typename InnerMatcher> - explicit ArgsMatcherImpl(const InnerMatcher& inner_matcher) - : inner_matcher_(SafeMatcherCast<const SelectedArgs&>(inner_matcher)) {} - - bool MatchAndExplain(ArgsTuple args, - MatchResultListener* listener) const override { - // Workaround spurious C4100 on MSVC<=15.7 when k is empty. - (void)args; - const SelectedArgs& selected_args = - std::forward_as_tuple(std::get<k>(args)...); - if (!listener->IsInterested()) return inner_matcher_.Matches(selected_args); - - PrintIndices(listener->stream()); - *listener << "are " << PrintToString(selected_args); - - StringMatchResultListener inner_listener; - const bool match = - inner_matcher_.MatchAndExplain(selected_args, &inner_listener); - PrintIfNotEmpty(inner_listener.str(), listener->stream()); - return match; - } - - void DescribeTo(::std::ostream* os) const override { - *os << "are a tuple "; - PrintIndices(os); - inner_matcher_.DescribeTo(os); - } - - void DescribeNegationTo(::std::ostream* os) const override { - *os << "are a tuple "; - PrintIndices(os); - inner_matcher_.DescribeNegationTo(os); - } - - private: - // Prints the indices of the selected fields. - static void PrintIndices(::std::ostream* os) { - *os << "whose fields ("; - const char* sep = ""; - // Workaround spurious C4189 on MSVC<=15.7 when k is empty. - (void)sep; - const char* dummy[] = {"", (*os << sep << "#" << k, sep = ", ")...}; - (void)dummy; - *os << ") "; - } - - MonomorphicInnerMatcher inner_matcher_; -}; - -template <class InnerMatcher, size_t... k> -class ArgsMatcher { - public: - explicit ArgsMatcher(InnerMatcher inner_matcher) - : inner_matcher_(std::move(inner_matcher)) {} - - template <typename ArgsTuple> - operator Matcher<ArgsTuple>() const { // NOLINT - return MakeMatcher(new ArgsMatcherImpl<ArgsTuple, k...>(inner_matcher_)); - } - - private: - InnerMatcher inner_matcher_; -}; - -} // namespace internal - -// ElementsAreArray(iterator_first, iterator_last) -// ElementsAreArray(pointer, count) -// ElementsAreArray(array) -// ElementsAreArray(container) -// ElementsAreArray({ e1, e2, ..., en }) -// -// The ElementsAreArray() functions are like ElementsAre(...), except -// that they are given a homogeneous sequence rather than taking each -// element as a function argument. The sequence can be specified as an -// array, a pointer and count, a vector, an initializer list, or an -// STL iterator range. In each of these cases, the underlying sequence -// can be either a sequence of values or a sequence of matchers. -// -// All forms of ElementsAreArray() make a copy of the input matcher sequence. - -template <typename Iter> -inline internal::ElementsAreArrayMatcher< - typename ::std::iterator_traits<Iter>::value_type> -ElementsAreArray(Iter first, Iter last) { - typedef typename ::std::iterator_traits<Iter>::value_type T; - return internal::ElementsAreArrayMatcher<T>(first, last); -} - -template <typename T> -inline internal::ElementsAreArrayMatcher<T> ElementsAreArray( - const T* pointer, size_t count) { - return ElementsAreArray(pointer, pointer + count); -} - -template <typename T, size_t N> -inline internal::ElementsAreArrayMatcher<T> ElementsAreArray( - const T (&array)[N]) { - return ElementsAreArray(array, N); -} - -template <typename Container> -inline internal::ElementsAreArrayMatcher<typename Container::value_type> -ElementsAreArray(const Container& container) { - return ElementsAreArray(container.begin(), container.end()); -} - -template <typename T> -inline internal::ElementsAreArrayMatcher<T> -ElementsAreArray(::std::initializer_list<T> xs) { - return ElementsAreArray(xs.begin(), xs.end()); -} - -// UnorderedElementsAreArray(iterator_first, iterator_last) -// UnorderedElementsAreArray(pointer, count) -// UnorderedElementsAreArray(array) -// UnorderedElementsAreArray(container) -// UnorderedElementsAreArray({ e1, e2, ..., en }) -// -// UnorderedElementsAreArray() verifies that a bijective mapping onto a -// collection of matchers exists. -// -// The matchers can be specified as an array, a pointer and count, a container, -// an initializer list, or an STL iterator range. In each of these cases, the -// underlying matchers can be either values or matchers. - -template <typename Iter> -inline internal::UnorderedElementsAreArrayMatcher< - typename ::std::iterator_traits<Iter>::value_type> -UnorderedElementsAreArray(Iter first, Iter last) { - typedef typename ::std::iterator_traits<Iter>::value_type T; - return internal::UnorderedElementsAreArrayMatcher<T>( - internal::UnorderedMatcherRequire::ExactMatch, first, last); -} - -template <typename T> -inline internal::UnorderedElementsAreArrayMatcher<T> -UnorderedElementsAreArray(const T* pointer, size_t count) { - return UnorderedElementsAreArray(pointer, pointer + count); -} - -template <typename T, size_t N> -inline internal::UnorderedElementsAreArrayMatcher<T> -UnorderedElementsAreArray(const T (&array)[N]) { - return UnorderedElementsAreArray(array, N); -} - -template <typename Container> -inline internal::UnorderedElementsAreArrayMatcher< - typename Container::value_type> -UnorderedElementsAreArray(const Container& container) { - return UnorderedElementsAreArray(container.begin(), container.end()); -} - -template <typename T> -inline internal::UnorderedElementsAreArrayMatcher<T> -UnorderedElementsAreArray(::std::initializer_list<T> xs) { - return UnorderedElementsAreArray(xs.begin(), xs.end()); -} - -// _ is a matcher that matches anything of any type. -// -// This definition is fine as: -// -// 1. The C++ standard permits using the name _ in a namespace that -// is not the global namespace or ::std. -// 2. The AnythingMatcher class has no data member or constructor, -// so it's OK to create global variables of this type. -// 3. c-style has approved of using _ in this case. -const internal::AnythingMatcher _ = {}; -// Creates a matcher that matches any value of the given type T. -template <typename T> -inline Matcher<T> A() { - return _; -} - -// Creates a matcher that matches any value of the given type T. -template <typename T> -inline Matcher<T> An() { - return _; -} - -template <typename T, typename M> -Matcher<T> internal::MatcherCastImpl<T, M>::CastImpl( - const M& value, std::false_type /* convertible_to_matcher */, - std::false_type /* convertible_to_T */) { - return Eq(value); -} - -// Creates a polymorphic matcher that matches any NULL pointer. -inline PolymorphicMatcher<internal::IsNullMatcher > IsNull() { - return MakePolymorphicMatcher(internal::IsNullMatcher()); -} - -// Creates a polymorphic matcher that matches any non-NULL pointer. -// This is convenient as Not(NULL) doesn't compile (the compiler -// thinks that that expression is comparing a pointer with an integer). -inline PolymorphicMatcher<internal::NotNullMatcher > NotNull() { - return MakePolymorphicMatcher(internal::NotNullMatcher()); -} - -// Creates a polymorphic matcher that matches any argument that -// references variable x. -template <typename T> -inline internal::RefMatcher<T&> Ref(T& x) { // NOLINT - return internal::RefMatcher<T&>(x); -} - -// Creates a polymorphic matcher that matches any NaN floating point. -inline PolymorphicMatcher<internal::IsNanMatcher> IsNan() { - return MakePolymorphicMatcher(internal::IsNanMatcher()); -} - -// Creates a matcher that matches any double argument approximately -// equal to rhs, where two NANs are considered unequal. -inline internal::FloatingEqMatcher<double> DoubleEq(double rhs) { - return internal::FloatingEqMatcher<double>(rhs, false); -} - -// Creates a matcher that matches any double argument approximately -// equal to rhs, including NaN values when rhs is NaN. -inline internal::FloatingEqMatcher<double> NanSensitiveDoubleEq(double rhs) { - return internal::FloatingEqMatcher<double>(rhs, true); -} - -// Creates a matcher that matches any double argument approximately equal to -// rhs, up to the specified max absolute error bound, where two NANs are -// considered unequal. The max absolute error bound must be non-negative. -inline internal::FloatingEqMatcher<double> DoubleNear( - double rhs, double max_abs_error) { - return internal::FloatingEqMatcher<double>(rhs, false, max_abs_error); -} - -// Creates a matcher that matches any double argument approximately equal to -// rhs, up to the specified max absolute error bound, including NaN values when -// rhs is NaN. The max absolute error bound must be non-negative. -inline internal::FloatingEqMatcher<double> NanSensitiveDoubleNear( - double rhs, double max_abs_error) { - return internal::FloatingEqMatcher<double>(rhs, true, max_abs_error); -} - -// Creates a matcher that matches any float argument approximately -// equal to rhs, where two NANs are considered unequal. -inline internal::FloatingEqMatcher<float> FloatEq(float rhs) { - return internal::FloatingEqMatcher<float>(rhs, false); -} - -// Creates a matcher that matches any float argument approximately -// equal to rhs, including NaN values when rhs is NaN. -inline internal::FloatingEqMatcher<float> NanSensitiveFloatEq(float rhs) { - return internal::FloatingEqMatcher<float>(rhs, true); -} - -// Creates a matcher that matches any float argument approximately equal to -// rhs, up to the specified max absolute error bound, where two NANs are -// considered unequal. The max absolute error bound must be non-negative. -inline internal::FloatingEqMatcher<float> FloatNear( - float rhs, float max_abs_error) { - return internal::FloatingEqMatcher<float>(rhs, false, max_abs_error); -} - -// Creates a matcher that matches any float argument approximately equal to -// rhs, up to the specified max absolute error bound, including NaN values when -// rhs is NaN. The max absolute error bound must be non-negative. -inline internal::FloatingEqMatcher<float> NanSensitiveFloatNear( - float rhs, float max_abs_error) { - return internal::FloatingEqMatcher<float>(rhs, true, max_abs_error); -} - -// Creates a matcher that matches a pointer (raw or smart) that points -// to a value that matches inner_matcher. -template <typename InnerMatcher> -inline internal::PointeeMatcher<InnerMatcher> Pointee( - const InnerMatcher& inner_matcher) { - return internal::PointeeMatcher<InnerMatcher>(inner_matcher); -} - -#if GTEST_HAS_RTTI -// Creates a matcher that matches a pointer or reference that matches -// inner_matcher when dynamic_cast<To> is applied. -// The result of dynamic_cast<To> is forwarded to the inner matcher. -// If To is a pointer and the cast fails, the inner matcher will receive NULL. -// If To is a reference and the cast fails, this matcher returns false -// immediately. -template <typename To> -inline PolymorphicMatcher<internal::WhenDynamicCastToMatcher<To> > -WhenDynamicCastTo(const Matcher<To>& inner_matcher) { - return MakePolymorphicMatcher( - internal::WhenDynamicCastToMatcher<To>(inner_matcher)); -} -#endif // GTEST_HAS_RTTI - -// Creates a matcher that matches an object whose given field matches -// 'matcher'. For example, -// Field(&Foo::number, Ge(5)) -// matches a Foo object x if and only if x.number >= 5. -template <typename Class, typename FieldType, typename FieldMatcher> -inline PolymorphicMatcher< - internal::FieldMatcher<Class, FieldType> > Field( - FieldType Class::*field, const FieldMatcher& matcher) { - return MakePolymorphicMatcher( - internal::FieldMatcher<Class, FieldType>( - field, MatcherCast<const FieldType&>(matcher))); - // The call to MatcherCast() is required for supporting inner - // matchers of compatible types. For example, it allows - // Field(&Foo::bar, m) - // to compile where bar is an int32 and m is a matcher for int64. -} - -// Same as Field() but also takes the name of the field to provide better error -// messages. -template <typename Class, typename FieldType, typename FieldMatcher> -inline PolymorphicMatcher<internal::FieldMatcher<Class, FieldType> > Field( - const std::string& field_name, FieldType Class::*field, - const FieldMatcher& matcher) { - return MakePolymorphicMatcher(internal::FieldMatcher<Class, FieldType>( - field_name, field, MatcherCast<const FieldType&>(matcher))); -} - -// Creates a matcher that matches an object whose given property -// matches 'matcher'. For example, -// Property(&Foo::str, StartsWith("hi")) -// matches a Foo object x if and only if x.str() starts with "hi". -template <typename Class, typename PropertyType, typename PropertyMatcher> -inline PolymorphicMatcher<internal::PropertyMatcher< - Class, PropertyType, PropertyType (Class::*)() const> > -Property(PropertyType (Class::*property)() const, - const PropertyMatcher& matcher) { - return MakePolymorphicMatcher( - internal::PropertyMatcher<Class, PropertyType, - PropertyType (Class::*)() const>( - property, MatcherCast<const PropertyType&>(matcher))); - // The call to MatcherCast() is required for supporting inner - // matchers of compatible types. For example, it allows - // Property(&Foo::bar, m) - // to compile where bar() returns an int32 and m is a matcher for int64. -} - -// Same as Property() above, but also takes the name of the property to provide -// better error messages. -template <typename Class, typename PropertyType, typename PropertyMatcher> -inline PolymorphicMatcher<internal::PropertyMatcher< - Class, PropertyType, PropertyType (Class::*)() const> > -Property(const std::string& property_name, - PropertyType (Class::*property)() const, - const PropertyMatcher& matcher) { - return MakePolymorphicMatcher( - internal::PropertyMatcher<Class, PropertyType, - PropertyType (Class::*)() const>( - property_name, property, MatcherCast<const PropertyType&>(matcher))); -} - -// The same as above but for reference-qualified member functions. -template <typename Class, typename PropertyType, typename PropertyMatcher> -inline PolymorphicMatcher<internal::PropertyMatcher< - Class, PropertyType, PropertyType (Class::*)() const &> > -Property(PropertyType (Class::*property)() const &, - const PropertyMatcher& matcher) { - return MakePolymorphicMatcher( - internal::PropertyMatcher<Class, PropertyType, - PropertyType (Class::*)() const&>( - property, MatcherCast<const PropertyType&>(matcher))); -} - -// Three-argument form for reference-qualified member functions. -template <typename Class, typename PropertyType, typename PropertyMatcher> -inline PolymorphicMatcher<internal::PropertyMatcher< - Class, PropertyType, PropertyType (Class::*)() const &> > -Property(const std::string& property_name, - PropertyType (Class::*property)() const &, - const PropertyMatcher& matcher) { - return MakePolymorphicMatcher( - internal::PropertyMatcher<Class, PropertyType, - PropertyType (Class::*)() const&>( - property_name, property, MatcherCast<const PropertyType&>(matcher))); -} - -// Creates a matcher that matches an object if and only if the result of -// applying a callable to x matches 'matcher'. For example, -// ResultOf(f, StartsWith("hi")) -// matches a Foo object x if and only if f(x) starts with "hi". -// `callable` parameter can be a function, function pointer, or a functor. It is -// required to keep no state affecting the results of the calls on it and make -// no assumptions about how many calls will be made. Any state it keeps must be -// protected from the concurrent access. -template <typename Callable, typename InnerMatcher> -internal::ResultOfMatcher<Callable, InnerMatcher> ResultOf( - Callable callable, InnerMatcher matcher) { - return internal::ResultOfMatcher<Callable, InnerMatcher>( - std::move(callable), std::move(matcher)); -} - -// String matchers. - -// Matches a string equal to str. -template <typename T = std::string> -PolymorphicMatcher<internal::StrEqualityMatcher<std::string> > StrEq( - const internal::StringLike<T>& str) { - return MakePolymorphicMatcher( - internal::StrEqualityMatcher<std::string>(std::string(str), true, true)); -} - -// Matches a string not equal to str. -template <typename T = std::string> -PolymorphicMatcher<internal::StrEqualityMatcher<std::string> > StrNe( - const internal::StringLike<T>& str) { - return MakePolymorphicMatcher( - internal::StrEqualityMatcher<std::string>(std::string(str), false, true)); -} - -// Matches a string equal to str, ignoring case. -template <typename T = std::string> -PolymorphicMatcher<internal::StrEqualityMatcher<std::string> > StrCaseEq( - const internal::StringLike<T>& str) { - return MakePolymorphicMatcher( - internal::StrEqualityMatcher<std::string>(std::string(str), true, false)); -} - -// Matches a string not equal to str, ignoring case. -template <typename T = std::string> -PolymorphicMatcher<internal::StrEqualityMatcher<std::string> > StrCaseNe( - const internal::StringLike<T>& str) { - return MakePolymorphicMatcher(internal::StrEqualityMatcher<std::string>( - std::string(str), false, false)); -} - -// Creates a matcher that matches any string, std::string, or C string -// that contains the given substring. -template <typename T = std::string> -PolymorphicMatcher<internal::HasSubstrMatcher<std::string> > HasSubstr( - const internal::StringLike<T>& substring) { - return MakePolymorphicMatcher( - internal::HasSubstrMatcher<std::string>(std::string(substring))); -} - -// Matches a string that starts with 'prefix' (case-sensitive). -template <typename T = std::string> -PolymorphicMatcher<internal::StartsWithMatcher<std::string> > StartsWith( - const internal::StringLike<T>& prefix) { - return MakePolymorphicMatcher( - internal::StartsWithMatcher<std::string>(std::string(prefix))); -} - -// Matches a string that ends with 'suffix' (case-sensitive). -template <typename T = std::string> -PolymorphicMatcher<internal::EndsWithMatcher<std::string> > EndsWith( - const internal::StringLike<T>& suffix) { - return MakePolymorphicMatcher( - internal::EndsWithMatcher<std::string>(std::string(suffix))); -} - -#if GTEST_HAS_STD_WSTRING -// Wide string matchers. - -// Matches a string equal to str. -inline PolymorphicMatcher<internal::StrEqualityMatcher<std::wstring> > StrEq( - const std::wstring& str) { - return MakePolymorphicMatcher( - internal::StrEqualityMatcher<std::wstring>(str, true, true)); -} - -// Matches a string not equal to str. -inline PolymorphicMatcher<internal::StrEqualityMatcher<std::wstring> > StrNe( - const std::wstring& str) { - return MakePolymorphicMatcher( - internal::StrEqualityMatcher<std::wstring>(str, false, true)); -} - -// Matches a string equal to str, ignoring case. -inline PolymorphicMatcher<internal::StrEqualityMatcher<std::wstring> > -StrCaseEq(const std::wstring& str) { - return MakePolymorphicMatcher( - internal::StrEqualityMatcher<std::wstring>(str, true, false)); -} - -// Matches a string not equal to str, ignoring case. -inline PolymorphicMatcher<internal::StrEqualityMatcher<std::wstring> > -StrCaseNe(const std::wstring& str) { - return MakePolymorphicMatcher( - internal::StrEqualityMatcher<std::wstring>(str, false, false)); -} - -// Creates a matcher that matches any ::wstring, std::wstring, or C wide string -// that contains the given substring. -inline PolymorphicMatcher<internal::HasSubstrMatcher<std::wstring> > HasSubstr( - const std::wstring& substring) { - return MakePolymorphicMatcher( - internal::HasSubstrMatcher<std::wstring>(substring)); -} - -// Matches a string that starts with 'prefix' (case-sensitive). -inline PolymorphicMatcher<internal::StartsWithMatcher<std::wstring> > -StartsWith(const std::wstring& prefix) { - return MakePolymorphicMatcher( - internal::StartsWithMatcher<std::wstring>(prefix)); -} - -// Matches a string that ends with 'suffix' (case-sensitive). -inline PolymorphicMatcher<internal::EndsWithMatcher<std::wstring> > EndsWith( - const std::wstring& suffix) { - return MakePolymorphicMatcher( - internal::EndsWithMatcher<std::wstring>(suffix)); -} - -#endif // GTEST_HAS_STD_WSTRING - -// Creates a polymorphic matcher that matches a 2-tuple where the -// first field == the second field. -inline internal::Eq2Matcher Eq() { return internal::Eq2Matcher(); } - -// Creates a polymorphic matcher that matches a 2-tuple where the -// first field >= the second field. -inline internal::Ge2Matcher Ge() { return internal::Ge2Matcher(); } - -// Creates a polymorphic matcher that matches a 2-tuple where the -// first field > the second field. -inline internal::Gt2Matcher Gt() { return internal::Gt2Matcher(); } - -// Creates a polymorphic matcher that matches a 2-tuple where the -// first field <= the second field. -inline internal::Le2Matcher Le() { return internal::Le2Matcher(); } - -// Creates a polymorphic matcher that matches a 2-tuple where the -// first field < the second field. -inline internal::Lt2Matcher Lt() { return internal::Lt2Matcher(); } - -// Creates a polymorphic matcher that matches a 2-tuple where the -// first field != the second field. -inline internal::Ne2Matcher Ne() { return internal::Ne2Matcher(); } - -// Creates a polymorphic matcher that matches a 2-tuple where -// FloatEq(first field) matches the second field. -inline internal::FloatingEq2Matcher<float> FloatEq() { - return internal::FloatingEq2Matcher<float>(); -} - -// Creates a polymorphic matcher that matches a 2-tuple where -// DoubleEq(first field) matches the second field. -inline internal::FloatingEq2Matcher<double> DoubleEq() { - return internal::FloatingEq2Matcher<double>(); -} - -// Creates a polymorphic matcher that matches a 2-tuple where -// FloatEq(first field) matches the second field with NaN equality. -inline internal::FloatingEq2Matcher<float> NanSensitiveFloatEq() { - return internal::FloatingEq2Matcher<float>(true); -} - -// Creates a polymorphic matcher that matches a 2-tuple where -// DoubleEq(first field) matches the second field with NaN equality. -inline internal::FloatingEq2Matcher<double> NanSensitiveDoubleEq() { - return internal::FloatingEq2Matcher<double>(true); -} - -// Creates a polymorphic matcher that matches a 2-tuple where -// FloatNear(first field, max_abs_error) matches the second field. -inline internal::FloatingEq2Matcher<float> FloatNear(float max_abs_error) { - return internal::FloatingEq2Matcher<float>(max_abs_error); -} - -// Creates a polymorphic matcher that matches a 2-tuple where -// DoubleNear(first field, max_abs_error) matches the second field. -inline internal::FloatingEq2Matcher<double> DoubleNear(double max_abs_error) { - return internal::FloatingEq2Matcher<double>(max_abs_error); -} - -// Creates a polymorphic matcher that matches a 2-tuple where -// FloatNear(first field, max_abs_error) matches the second field with NaN -// equality. -inline internal::FloatingEq2Matcher<float> NanSensitiveFloatNear( - float max_abs_error) { - return internal::FloatingEq2Matcher<float>(max_abs_error, true); -} - -// Creates a polymorphic matcher that matches a 2-tuple where -// DoubleNear(first field, max_abs_error) matches the second field with NaN -// equality. -inline internal::FloatingEq2Matcher<double> NanSensitiveDoubleNear( - double max_abs_error) { - return internal::FloatingEq2Matcher<double>(max_abs_error, true); -} - -// Creates a matcher that matches any value of type T that m doesn't -// match. -template <typename InnerMatcher> -inline internal::NotMatcher<InnerMatcher> Not(InnerMatcher m) { - return internal::NotMatcher<InnerMatcher>(m); -} - -// Returns a matcher that matches anything that satisfies the given -// predicate. The predicate can be any unary function or functor -// whose return type can be implicitly converted to bool. -template <typename Predicate> -inline PolymorphicMatcher<internal::TrulyMatcher<Predicate> > -Truly(Predicate pred) { - return MakePolymorphicMatcher(internal::TrulyMatcher<Predicate>(pred)); -} - -// Returns a matcher that matches the container size. The container must -// support both size() and size_type which all STL-like containers provide. -// Note that the parameter 'size' can be a value of type size_type as well as -// matcher. For instance: -// EXPECT_THAT(container, SizeIs(2)); // Checks container has 2 elements. -// EXPECT_THAT(container, SizeIs(Le(2)); // Checks container has at most 2. -template <typename SizeMatcher> -inline internal::SizeIsMatcher<SizeMatcher> -SizeIs(const SizeMatcher& size_matcher) { - return internal::SizeIsMatcher<SizeMatcher>(size_matcher); -} - -// Returns a matcher that matches the distance between the container's begin() -// iterator and its end() iterator, i.e. the size of the container. This matcher -// can be used instead of SizeIs with containers such as std::forward_list which -// do not implement size(). The container must provide const_iterator (with -// valid iterator_traits), begin() and end(). -template <typename DistanceMatcher> -inline internal::BeginEndDistanceIsMatcher<DistanceMatcher> -BeginEndDistanceIs(const DistanceMatcher& distance_matcher) { - return internal::BeginEndDistanceIsMatcher<DistanceMatcher>(distance_matcher); -} - -// Returns a matcher that matches an equal container. -// This matcher behaves like Eq(), but in the event of mismatch lists the -// values that are included in one container but not the other. (Duplicate -// values and order differences are not explained.) -template <typename Container> -inline PolymorphicMatcher<internal::ContainerEqMatcher< - typename std::remove_const<Container>::type>> -ContainerEq(const Container& rhs) { - return MakePolymorphicMatcher(internal::ContainerEqMatcher<Container>(rhs)); -} - -// Returns a matcher that matches a container that, when sorted using -// the given comparator, matches container_matcher. -template <typename Comparator, typename ContainerMatcher> -inline internal::WhenSortedByMatcher<Comparator, ContainerMatcher> -WhenSortedBy(const Comparator& comparator, - const ContainerMatcher& container_matcher) { - return internal::WhenSortedByMatcher<Comparator, ContainerMatcher>( - comparator, container_matcher); -} - -// Returns a matcher that matches a container that, when sorted using -// the < operator, matches container_matcher. -template <typename ContainerMatcher> -inline internal::WhenSortedByMatcher<internal::LessComparator, ContainerMatcher> -WhenSorted(const ContainerMatcher& container_matcher) { - return - internal::WhenSortedByMatcher<internal::LessComparator, ContainerMatcher>( - internal::LessComparator(), container_matcher); -} - -// Matches an STL-style container or a native array that contains the -// same number of elements as in rhs, where its i-th element and rhs's -// i-th element (as a pair) satisfy the given pair matcher, for all i. -// TupleMatcher must be able to be safely cast to Matcher<std::tuple<const -// T1&, const T2&> >, where T1 and T2 are the types of elements in the -// LHS container and the RHS container respectively. -template <typename TupleMatcher, typename Container> -inline internal::PointwiseMatcher<TupleMatcher, - typename std::remove_const<Container>::type> -Pointwise(const TupleMatcher& tuple_matcher, const Container& rhs) { - return internal::PointwiseMatcher<TupleMatcher, Container>(tuple_matcher, - rhs); -} - - -// Supports the Pointwise(m, {a, b, c}) syntax. -template <typename TupleMatcher, typename T> -inline internal::PointwiseMatcher<TupleMatcher, std::vector<T> > Pointwise( - const TupleMatcher& tuple_matcher, std::initializer_list<T> rhs) { - return Pointwise(tuple_matcher, std::vector<T>(rhs)); -} - - -// UnorderedPointwise(pair_matcher, rhs) matches an STL-style -// container or a native array that contains the same number of -// elements as in rhs, where in some permutation of the container, its -// i-th element and rhs's i-th element (as a pair) satisfy the given -// pair matcher, for all i. Tuple2Matcher must be able to be safely -// cast to Matcher<std::tuple<const T1&, const T2&> >, where T1 and T2 are -// the types of elements in the LHS container and the RHS container -// respectively. -// -// This is like Pointwise(pair_matcher, rhs), except that the element -// order doesn't matter. -template <typename Tuple2Matcher, typename RhsContainer> -inline internal::UnorderedElementsAreArrayMatcher< - typename internal::BoundSecondMatcher< - Tuple2Matcher, - typename internal::StlContainerView< - typename std::remove_const<RhsContainer>::type>::type::value_type>> -UnorderedPointwise(const Tuple2Matcher& tuple2_matcher, - const RhsContainer& rhs_container) { - // RhsView allows the same code to handle RhsContainer being a - // STL-style container and it being a native C-style array. - typedef typename internal::StlContainerView<RhsContainer> RhsView; - typedef typename RhsView::type RhsStlContainer; - typedef typename RhsStlContainer::value_type Second; - const RhsStlContainer& rhs_stl_container = - RhsView::ConstReference(rhs_container); - - // Create a matcher for each element in rhs_container. - ::std::vector<internal::BoundSecondMatcher<Tuple2Matcher, Second> > matchers; - for (typename RhsStlContainer::const_iterator it = rhs_stl_container.begin(); - it != rhs_stl_container.end(); ++it) { - matchers.push_back( - internal::MatcherBindSecond(tuple2_matcher, *it)); - } - - // Delegate the work to UnorderedElementsAreArray(). - return UnorderedElementsAreArray(matchers); -} - - -// Supports the UnorderedPointwise(m, {a, b, c}) syntax. -template <typename Tuple2Matcher, typename T> -inline internal::UnorderedElementsAreArrayMatcher< - typename internal::BoundSecondMatcher<Tuple2Matcher, T> > -UnorderedPointwise(const Tuple2Matcher& tuple2_matcher, - std::initializer_list<T> rhs) { - return UnorderedPointwise(tuple2_matcher, std::vector<T>(rhs)); -} - - -// Matches an STL-style container or a native array that contains at -// least one element matching the given value or matcher. -// -// Examples: -// ::std::set<int> page_ids; -// page_ids.insert(3); -// page_ids.insert(1); -// EXPECT_THAT(page_ids, Contains(1)); -// EXPECT_THAT(page_ids, Contains(Gt(2))); -// EXPECT_THAT(page_ids, Not(Contains(4))); -// -// ::std::map<int, size_t> page_lengths; -// page_lengths[1] = 100; -// EXPECT_THAT(page_lengths, -// Contains(::std::pair<const int, size_t>(1, 100))); -// -// const char* user_ids[] = { "joe", "mike", "tom" }; -// EXPECT_THAT(user_ids, Contains(Eq(::std::string("tom")))); -template <typename M> -inline internal::ContainsMatcher<M> Contains(M matcher) { - return internal::ContainsMatcher<M>(matcher); -} - -// IsSupersetOf(iterator_first, iterator_last) -// IsSupersetOf(pointer, count) -// IsSupersetOf(array) -// IsSupersetOf(container) -// IsSupersetOf({e1, e2, ..., en}) -// -// IsSupersetOf() verifies that a surjective partial mapping onto a collection -// of matchers exists. In other words, a container matches -// IsSupersetOf({e1, ..., en}) if and only if there is a permutation -// {y1, ..., yn} of some of the container's elements where y1 matches e1, -// ..., and yn matches en. Obviously, the size of the container must be >= n -// in order to have a match. Examples: -// -// - {1, 2, 3} matches IsSupersetOf({Ge(3), Ne(0)}), as 3 matches Ge(3) and -// 1 matches Ne(0). -// - {1, 2} doesn't match IsSupersetOf({Eq(1), Lt(2)}), even though 1 matches -// both Eq(1) and Lt(2). The reason is that different matchers must be used -// for elements in different slots of the container. -// - {1, 1, 2} matches IsSupersetOf({Eq(1), Lt(2)}), as (the first) 1 matches -// Eq(1) and (the second) 1 matches Lt(2). -// - {1, 2, 3} matches IsSupersetOf(Gt(1), Gt(1)), as 2 matches (the first) -// Gt(1) and 3 matches (the second) Gt(1). -// -// The matchers can be specified as an array, a pointer and count, a container, -// an initializer list, or an STL iterator range. In each of these cases, the -// underlying matchers can be either values or matchers. - -template <typename Iter> -inline internal::UnorderedElementsAreArrayMatcher< - typename ::std::iterator_traits<Iter>::value_type> -IsSupersetOf(Iter first, Iter last) { - typedef typename ::std::iterator_traits<Iter>::value_type T; - return internal::UnorderedElementsAreArrayMatcher<T>( - internal::UnorderedMatcherRequire::Superset, first, last); -} - -template <typename T> -inline internal::UnorderedElementsAreArrayMatcher<T> IsSupersetOf( - const T* pointer, size_t count) { - return IsSupersetOf(pointer, pointer + count); -} - -template <typename T, size_t N> -inline internal::UnorderedElementsAreArrayMatcher<T> IsSupersetOf( - const T (&array)[N]) { - return IsSupersetOf(array, N); -} - -template <typename Container> -inline internal::UnorderedElementsAreArrayMatcher< - typename Container::value_type> -IsSupersetOf(const Container& container) { - return IsSupersetOf(container.begin(), container.end()); -} - -template <typename T> -inline internal::UnorderedElementsAreArrayMatcher<T> IsSupersetOf( - ::std::initializer_list<T> xs) { - return IsSupersetOf(xs.begin(), xs.end()); -} - -// IsSubsetOf(iterator_first, iterator_last) -// IsSubsetOf(pointer, count) -// IsSubsetOf(array) -// IsSubsetOf(container) -// IsSubsetOf({e1, e2, ..., en}) -// -// IsSubsetOf() verifies that an injective mapping onto a collection of matchers -// exists. In other words, a container matches IsSubsetOf({e1, ..., en}) if and -// only if there is a subset of matchers {m1, ..., mk} which would match the -// container using UnorderedElementsAre. Obviously, the size of the container -// must be <= n in order to have a match. Examples: -// -// - {1} matches IsSubsetOf({Gt(0), Lt(0)}), as 1 matches Gt(0). -// - {1, -1} matches IsSubsetOf({Lt(0), Gt(0)}), as 1 matches Gt(0) and -1 -// matches Lt(0). -// - {1, 2} doesn't matches IsSubsetOf({Gt(0), Lt(0)}), even though 1 and 2 both -// match Gt(0). The reason is that different matchers must be used for -// elements in different slots of the container. -// -// The matchers can be specified as an array, a pointer and count, a container, -// an initializer list, or an STL iterator range. In each of these cases, the -// underlying matchers can be either values or matchers. - -template <typename Iter> -inline internal::UnorderedElementsAreArrayMatcher< - typename ::std::iterator_traits<Iter>::value_type> -IsSubsetOf(Iter first, Iter last) { - typedef typename ::std::iterator_traits<Iter>::value_type T; - return internal::UnorderedElementsAreArrayMatcher<T>( - internal::UnorderedMatcherRequire::Subset, first, last); -} - -template <typename T> -inline internal::UnorderedElementsAreArrayMatcher<T> IsSubsetOf( - const T* pointer, size_t count) { - return IsSubsetOf(pointer, pointer + count); -} - -template <typename T, size_t N> -inline internal::UnorderedElementsAreArrayMatcher<T> IsSubsetOf( - const T (&array)[N]) { - return IsSubsetOf(array, N); -} - -template <typename Container> -inline internal::UnorderedElementsAreArrayMatcher< - typename Container::value_type> -IsSubsetOf(const Container& container) { - return IsSubsetOf(container.begin(), container.end()); -} - -template <typename T> -inline internal::UnorderedElementsAreArrayMatcher<T> IsSubsetOf( - ::std::initializer_list<T> xs) { - return IsSubsetOf(xs.begin(), xs.end()); -} - -// Matches an STL-style container or a native array that contains only -// elements matching the given value or matcher. -// -// Each(m) is semantically equivalent to Not(Contains(Not(m))). Only -// the messages are different. -// -// Examples: -// ::std::set<int> page_ids; -// // Each(m) matches an empty container, regardless of what m is. -// EXPECT_THAT(page_ids, Each(Eq(1))); -// EXPECT_THAT(page_ids, Each(Eq(77))); -// -// page_ids.insert(3); -// EXPECT_THAT(page_ids, Each(Gt(0))); -// EXPECT_THAT(page_ids, Not(Each(Gt(4)))); -// page_ids.insert(1); -// EXPECT_THAT(page_ids, Not(Each(Lt(2)))); -// -// ::std::map<int, size_t> page_lengths; -// page_lengths[1] = 100; -// page_lengths[2] = 200; -// page_lengths[3] = 300; -// EXPECT_THAT(page_lengths, Not(Each(Pair(1, 100)))); -// EXPECT_THAT(page_lengths, Each(Key(Le(3)))); -// -// const char* user_ids[] = { "joe", "mike", "tom" }; -// EXPECT_THAT(user_ids, Not(Each(Eq(::std::string("tom"))))); -template <typename M> -inline internal::EachMatcher<M> Each(M matcher) { - return internal::EachMatcher<M>(matcher); -} - -// Key(inner_matcher) matches an std::pair whose 'first' field matches -// inner_matcher. For example, Contains(Key(Ge(5))) can be used to match an -// std::map that contains at least one element whose key is >= 5. -template <typename M> -inline internal::KeyMatcher<M> Key(M inner_matcher) { - return internal::KeyMatcher<M>(inner_matcher); -} - -// Pair(first_matcher, second_matcher) matches a std::pair whose 'first' field -// matches first_matcher and whose 'second' field matches second_matcher. For -// example, EXPECT_THAT(map_type, ElementsAre(Pair(Ge(5), "foo"))) can be used -// to match a std::map<int, string> that contains exactly one element whose key -// is >= 5 and whose value equals "foo". -template <typename FirstMatcher, typename SecondMatcher> -inline internal::PairMatcher<FirstMatcher, SecondMatcher> -Pair(FirstMatcher first_matcher, SecondMatcher second_matcher) { - return internal::PairMatcher<FirstMatcher, SecondMatcher>( - first_matcher, second_matcher); -} - -namespace no_adl { -// FieldsAre(matchers...) matches piecewise the fields of compatible structs. -// These include those that support `get<I>(obj)`, and when structured bindings -// are enabled any class that supports them. -// In particular, `std::tuple`, `std::pair`, `std::array` and aggregate types. -template <typename... M> -internal::FieldsAreMatcher<typename std::decay<M>::type...> FieldsAre( - M&&... matchers) { - return internal::FieldsAreMatcher<typename std::decay<M>::type...>( - std::forward<M>(matchers)...); -} - -// Creates a matcher that matches a pointer (raw or smart) that matches -// inner_matcher. -template <typename InnerMatcher> -inline internal::PointerMatcher<InnerMatcher> Pointer( - const InnerMatcher& inner_matcher) { - return internal::PointerMatcher<InnerMatcher>(inner_matcher); -} - -// Creates a matcher that matches an object that has an address that matches -// inner_matcher. -template <typename InnerMatcher> -inline internal::AddressMatcher<InnerMatcher> Address( - const InnerMatcher& inner_matcher) { - return internal::AddressMatcher<InnerMatcher>(inner_matcher); -} -} // namespace no_adl - -// Returns a predicate that is satisfied by anything that matches the -// given matcher. -template <typename M> -inline internal::MatcherAsPredicate<M> Matches(M matcher) { - return internal::MatcherAsPredicate<M>(matcher); -} - -// Returns true if and only if the value matches the matcher. -template <typename T, typename M> -inline bool Value(const T& value, M matcher) { - return testing::Matches(matcher)(value); -} - -// Matches the value against the given matcher and explains the match -// result to listener. -template <typename T, typename M> -inline bool ExplainMatchResult( - M matcher, const T& value, MatchResultListener* listener) { - return SafeMatcherCast<const T&>(matcher).MatchAndExplain(value, listener); -} - -// Returns a string representation of the given matcher. Useful for description -// strings of matchers defined using MATCHER_P* macros that accept matchers as -// their arguments. For example: -// -// MATCHER_P(XAndYThat, matcher, -// "X that " + DescribeMatcher<int>(matcher, negation) + -// " and Y that " + DescribeMatcher<double>(matcher, negation)) { -// return ExplainMatchResult(matcher, arg.x(), result_listener) && -// ExplainMatchResult(matcher, arg.y(), result_listener); -// } -template <typename T, typename M> -std::string DescribeMatcher(const M& matcher, bool negation = false) { - ::std::stringstream ss; - Matcher<T> monomorphic_matcher = SafeMatcherCast<T>(matcher); - if (negation) { - monomorphic_matcher.DescribeNegationTo(&ss); - } else { - monomorphic_matcher.DescribeTo(&ss); - } - return ss.str(); -} - -template <typename... Args> -internal::ElementsAreMatcher< - std::tuple<typename std::decay<const Args&>::type...>> -ElementsAre(const Args&... matchers) { - return internal::ElementsAreMatcher< - std::tuple<typename std::decay<const Args&>::type...>>( - std::make_tuple(matchers...)); -} - -template <typename... Args> -internal::UnorderedElementsAreMatcher< - std::tuple<typename std::decay<const Args&>::type...>> -UnorderedElementsAre(const Args&... matchers) { - return internal::UnorderedElementsAreMatcher< - std::tuple<typename std::decay<const Args&>::type...>>( - std::make_tuple(matchers...)); -} - -// Define variadic matcher versions. -template <typename... Args> -internal::AllOfMatcher<typename std::decay<const Args&>::type...> AllOf( - const Args&... matchers) { - return internal::AllOfMatcher<typename std::decay<const Args&>::type...>( - matchers...); -} - -template <typename... Args> -internal::AnyOfMatcher<typename std::decay<const Args&>::type...> AnyOf( - const Args&... matchers) { - return internal::AnyOfMatcher<typename std::decay<const Args&>::type...>( - matchers...); -} - -// AnyOfArray(array) -// AnyOfArray(pointer, count) -// AnyOfArray(container) -// AnyOfArray({ e1, e2, ..., en }) -// AnyOfArray(iterator_first, iterator_last) -// -// AnyOfArray() verifies whether a given value matches any member of a -// collection of matchers. -// -// AllOfArray(array) -// AllOfArray(pointer, count) -// AllOfArray(container) -// AllOfArray({ e1, e2, ..., en }) -// AllOfArray(iterator_first, iterator_last) -// -// AllOfArray() verifies whether a given value matches all members of a -// collection of matchers. -// -// The matchers can be specified as an array, a pointer and count, a container, -// an initializer list, or an STL iterator range. In each of these cases, the -// underlying matchers can be either values or matchers. - -template <typename Iter> -inline internal::AnyOfArrayMatcher< - typename ::std::iterator_traits<Iter>::value_type> -AnyOfArray(Iter first, Iter last) { - return internal::AnyOfArrayMatcher< - typename ::std::iterator_traits<Iter>::value_type>(first, last); -} - -template <typename Iter> -inline internal::AllOfArrayMatcher< - typename ::std::iterator_traits<Iter>::value_type> -AllOfArray(Iter first, Iter last) { - return internal::AllOfArrayMatcher< - typename ::std::iterator_traits<Iter>::value_type>(first, last); -} - -template <typename T> -inline internal::AnyOfArrayMatcher<T> AnyOfArray(const T* ptr, size_t count) { - return AnyOfArray(ptr, ptr + count); -} - -template <typename T> -inline internal::AllOfArrayMatcher<T> AllOfArray(const T* ptr, size_t count) { - return AllOfArray(ptr, ptr + count); -} - -template <typename T, size_t N> -inline internal::AnyOfArrayMatcher<T> AnyOfArray(const T (&array)[N]) { - return AnyOfArray(array, N); -} - -template <typename T, size_t N> -inline internal::AllOfArrayMatcher<T> AllOfArray(const T (&array)[N]) { - return AllOfArray(array, N); -} - -template <typename Container> -inline internal::AnyOfArrayMatcher<typename Container::value_type> AnyOfArray( - const Container& container) { - return AnyOfArray(container.begin(), container.end()); -} - -template <typename Container> -inline internal::AllOfArrayMatcher<typename Container::value_type> AllOfArray( - const Container& container) { - return AllOfArray(container.begin(), container.end()); -} - -template <typename T> -inline internal::AnyOfArrayMatcher<T> AnyOfArray( - ::std::initializer_list<T> xs) { - return AnyOfArray(xs.begin(), xs.end()); -} - -template <typename T> -inline internal::AllOfArrayMatcher<T> AllOfArray( - ::std::initializer_list<T> xs) { - return AllOfArray(xs.begin(), xs.end()); -} - -// Args<N1, N2, ..., Nk>(a_matcher) matches a tuple if the selected -// fields of it matches a_matcher. C++ doesn't support default -// arguments for function templates, so we have to overload it. -template <size_t... k, typename InnerMatcher> -internal::ArgsMatcher<typename std::decay<InnerMatcher>::type, k...> Args( - InnerMatcher&& matcher) { - return internal::ArgsMatcher<typename std::decay<InnerMatcher>::type, k...>( - std::forward<InnerMatcher>(matcher)); -} - -// AllArgs(m) is a synonym of m. This is useful in -// -// EXPECT_CALL(foo, Bar(_, _)).With(AllArgs(Eq())); -// -// which is easier to read than -// -// EXPECT_CALL(foo, Bar(_, _)).With(Eq()); -template <typename InnerMatcher> -inline InnerMatcher AllArgs(const InnerMatcher& matcher) { return matcher; } - -// Returns a matcher that matches the value of an optional<> type variable. -// The matcher implementation only uses '!arg' and requires that the optional<> -// type has a 'value_type' member type and that '*arg' is of type 'value_type' -// and is printable using 'PrintToString'. It is compatible with -// std::optional/std::experimental::optional. -// Note that to compare an optional type variable against nullopt you should -// use Eq(nullopt) and not Eq(Optional(nullopt)). The latter implies that the -// optional value contains an optional itself. -template <typename ValueMatcher> -inline internal::OptionalMatcher<ValueMatcher> Optional( - const ValueMatcher& value_matcher) { - return internal::OptionalMatcher<ValueMatcher>(value_matcher); -} - -// Returns a matcher that matches the value of a absl::any type variable. -template <typename T> -PolymorphicMatcher<internal::any_cast_matcher::AnyCastMatcher<T> > AnyWith( - const Matcher<const T&>& matcher) { - return MakePolymorphicMatcher( - internal::any_cast_matcher::AnyCastMatcher<T>(matcher)); -} - -// Returns a matcher that matches the value of a variant<> type variable. -// The matcher implementation uses ADL to find the holds_alternative and get -// functions. -// It is compatible with std::variant. -template <typename T> -PolymorphicMatcher<internal::variant_matcher::VariantMatcher<T> > VariantWith( - const Matcher<const T&>& matcher) { - return MakePolymorphicMatcher( - internal::variant_matcher::VariantMatcher<T>(matcher)); -} - -#if GTEST_HAS_EXCEPTIONS - -// Anything inside the `internal` namespace is internal to the implementation -// and must not be used in user code! -namespace internal { - -class WithWhatMatcherImpl { - public: - WithWhatMatcherImpl(Matcher<std::string> matcher) - : matcher_(std::move(matcher)) {} - - void DescribeTo(std::ostream* os) const { - *os << "contains .what() that "; - matcher_.DescribeTo(os); - } - - void DescribeNegationTo(std::ostream* os) const { - *os << "contains .what() that does not "; - matcher_.DescribeTo(os); - } - - template <typename Err> - bool MatchAndExplain(const Err& err, MatchResultListener* listener) const { - *listener << "which contains .what() that "; - return matcher_.MatchAndExplain(err.what(), listener); - } - - private: - const Matcher<std::string> matcher_; -}; - -inline PolymorphicMatcher<WithWhatMatcherImpl> WithWhat( - Matcher<std::string> m) { - return MakePolymorphicMatcher(WithWhatMatcherImpl(std::move(m))); -} - -template <typename Err> -class ExceptionMatcherImpl { - class NeverThrown { - public: - const char* what() const noexcept { - return "this exception should never be thrown"; - } - }; - - // If the matchee raises an exception of a wrong type, we'd like to - // catch it and print its message and type. To do that, we add an additional - // catch clause: - // - // try { ... } - // catch (const Err&) { /* an expected exception */ } - // catch (const std::exception&) { /* exception of a wrong type */ } - // - // However, if the `Err` itself is `std::exception`, we'd end up with two - // identical `catch` clauses: - // - // try { ... } - // catch (const std::exception&) { /* an expected exception */ } - // catch (const std::exception&) { /* exception of a wrong type */ } - // - // This can cause a warning or an error in some compilers. To resolve - // the issue, we use a fake error type whenever `Err` is `std::exception`: - // - // try { ... } - // catch (const std::exception&) { /* an expected exception */ } - // catch (const NeverThrown&) { /* exception of a wrong type */ } - using DefaultExceptionType = typename std::conditional< - std::is_same<typename std::remove_cv< - typename std::remove_reference<Err>::type>::type, - std::exception>::value, - const NeverThrown&, const std::exception&>::type; - - public: - ExceptionMatcherImpl(Matcher<const Err&> matcher) - : matcher_(std::move(matcher)) {} - - void DescribeTo(std::ostream* os) const { - *os << "throws an exception which is a " << GetTypeName<Err>(); - *os << " which "; - matcher_.DescribeTo(os); - } - - void DescribeNegationTo(std::ostream* os) const { - *os << "throws an exception which is not a " << GetTypeName<Err>(); - *os << " which "; - matcher_.DescribeNegationTo(os); - } - - template <typename T> - bool MatchAndExplain(T&& x, MatchResultListener* listener) const { - try { - (void)(std::forward<T>(x)()); - } catch (const Err& err) { - *listener << "throws an exception which is a " << GetTypeName<Err>(); - *listener << " "; - return matcher_.MatchAndExplain(err, listener); - } catch (DefaultExceptionType err) { -#if GTEST_HAS_RTTI - *listener << "throws an exception of type " << GetTypeName(typeid(err)); - *listener << " "; -#else - *listener << "throws an std::exception-derived type "; -#endif - *listener << "with description \"" << err.what() << "\""; - return false; - } catch (...) { - *listener << "throws an exception of an unknown type"; - return false; - } - - *listener << "does not throw any exception"; - return false; - } - - private: - const Matcher<const Err&> matcher_; -}; - -} // namespace internal - -// Throws() -// Throws(exceptionMatcher) -// ThrowsMessage(messageMatcher) -// -// This matcher accepts a callable and verifies that when invoked, it throws -// an exception with the given type and properties. -// -// Examples: -// -// EXPECT_THAT( -// []() { throw std::runtime_error("message"); }, -// Throws<std::runtime_error>()); -// -// EXPECT_THAT( -// []() { throw std::runtime_error("message"); }, -// ThrowsMessage<std::runtime_error>(HasSubstr("message"))); -// -// EXPECT_THAT( -// []() { throw std::runtime_error("message"); }, -// Throws<std::runtime_error>( -// Property(&std::runtime_error::what, HasSubstr("message")))); - -template <typename Err> -PolymorphicMatcher<internal::ExceptionMatcherImpl<Err>> Throws() { - return MakePolymorphicMatcher( - internal::ExceptionMatcherImpl<Err>(A<const Err&>())); -} - -template <typename Err, typename ExceptionMatcher> -PolymorphicMatcher<internal::ExceptionMatcherImpl<Err>> Throws( - const ExceptionMatcher& exception_matcher) { - // Using matcher cast allows users to pass a matcher of a more broad type. - // For example user may want to pass Matcher<std::exception> - // to Throws<std::runtime_error>, or Matcher<int64> to Throws<int32>. - return MakePolymorphicMatcher(internal::ExceptionMatcherImpl<Err>( - SafeMatcherCast<const Err&>(exception_matcher))); -} - -template <typename Err, typename MessageMatcher> -PolymorphicMatcher<internal::ExceptionMatcherImpl<Err>> ThrowsMessage( - MessageMatcher&& message_matcher) { - static_assert(std::is_base_of<std::exception, Err>::value, - "expected an std::exception-derived type"); - return Throws<Err>(internal::WithWhat( - MatcherCast<std::string>(std::forward<MessageMatcher>(message_matcher)))); -} - -#endif // GTEST_HAS_EXCEPTIONS - -// These macros allow using matchers to check values in Google Test -// tests. ASSERT_THAT(value, matcher) and EXPECT_THAT(value, matcher) -// succeed if and only if the value matches the matcher. If the assertion -// fails, the value and the description of the matcher will be printed. -#define ASSERT_THAT(value, matcher) ASSERT_PRED_FORMAT1(\ - ::testing::internal::MakePredicateFormatterFromMatcher(matcher), value) -#define EXPECT_THAT(value, matcher) EXPECT_PRED_FORMAT1(\ - ::testing::internal::MakePredicateFormatterFromMatcher(matcher), value) - -// MATCHER* macroses itself are listed below. -#define MATCHER(name, description) \ - class name##Matcher \ - : public ::testing::internal::MatcherBaseImpl<name##Matcher> { \ - public: \ - template <typename arg_type> \ - class gmock_Impl : public ::testing::MatcherInterface<const arg_type&> { \ - public: \ - gmock_Impl() {} \ - bool MatchAndExplain( \ - const arg_type& arg, \ - ::testing::MatchResultListener* result_listener) const override; \ - void DescribeTo(::std::ostream* gmock_os) const override { \ - *gmock_os << FormatDescription(false); \ - } \ - void DescribeNegationTo(::std::ostream* gmock_os) const override { \ - *gmock_os << FormatDescription(true); \ - } \ - \ - private: \ - ::std::string FormatDescription(bool negation) const { \ - ::std::string gmock_description = (description); \ - if (!gmock_description.empty()) { \ - return gmock_description; \ - } \ - return ::testing::internal::FormatMatcherDescription(negation, #name, \ - {}); \ - } \ - }; \ - }; \ - GTEST_ATTRIBUTE_UNUSED_ inline name##Matcher name() { return {}; } \ - template <typename arg_type> \ - bool name##Matcher::gmock_Impl<arg_type>::MatchAndExplain( \ - const arg_type& arg, \ - ::testing::MatchResultListener* result_listener GTEST_ATTRIBUTE_UNUSED_) \ - const - -#define MATCHER_P(name, p0, description) \ - GMOCK_INTERNAL_MATCHER(name, name##MatcherP, description, (p0)) -#define MATCHER_P2(name, p0, p1, description) \ - GMOCK_INTERNAL_MATCHER(name, name##MatcherP2, description, (p0, p1)) -#define MATCHER_P3(name, p0, p1, p2, description) \ - GMOCK_INTERNAL_MATCHER(name, name##MatcherP3, description, (p0, p1, p2)) -#define MATCHER_P4(name, p0, p1, p2, p3, description) \ - GMOCK_INTERNAL_MATCHER(name, name##MatcherP4, description, (p0, p1, p2, p3)) -#define MATCHER_P5(name, p0, p1, p2, p3, p4, description) \ - GMOCK_INTERNAL_MATCHER(name, name##MatcherP5, description, \ - (p0, p1, p2, p3, p4)) -#define MATCHER_P6(name, p0, p1, p2, p3, p4, p5, description) \ - GMOCK_INTERNAL_MATCHER(name, name##MatcherP6, description, \ - (p0, p1, p2, p3, p4, p5)) -#define MATCHER_P7(name, p0, p1, p2, p3, p4, p5, p6, description) \ - GMOCK_INTERNAL_MATCHER(name, name##MatcherP7, description, \ - (p0, p1, p2, p3, p4, p5, p6)) -#define MATCHER_P8(name, p0, p1, p2, p3, p4, p5, p6, p7, description) \ - GMOCK_INTERNAL_MATCHER(name, name##MatcherP8, description, \ - (p0, p1, p2, p3, p4, p5, p6, p7)) -#define MATCHER_P9(name, p0, p1, p2, p3, p4, p5, p6, p7, p8, description) \ - GMOCK_INTERNAL_MATCHER(name, name##MatcherP9, description, \ - (p0, p1, p2, p3, p4, p5, p6, p7, p8)) -#define MATCHER_P10(name, p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, description) \ - GMOCK_INTERNAL_MATCHER(name, name##MatcherP10, description, \ - (p0, p1, p2, p3, p4, p5, p6, p7, p8, p9)) - -#define GMOCK_INTERNAL_MATCHER(name, full_name, description, args) \ - template <GMOCK_INTERNAL_MATCHER_TEMPLATE_PARAMS(args)> \ - class full_name : public ::testing::internal::MatcherBaseImpl< \ - full_name<GMOCK_INTERNAL_MATCHER_TYPE_PARAMS(args)>> { \ - public: \ - using full_name::MatcherBaseImpl::MatcherBaseImpl; \ - template <typename arg_type> \ - class gmock_Impl : public ::testing::MatcherInterface<const arg_type&> { \ - public: \ - explicit gmock_Impl(GMOCK_INTERNAL_MATCHER_FUNCTION_ARGS(args)) \ - : GMOCK_INTERNAL_MATCHER_FORWARD_ARGS(args) {} \ - bool MatchAndExplain( \ - const arg_type& arg, \ - ::testing::MatchResultListener* result_listener) const override; \ - void DescribeTo(::std::ostream* gmock_os) const override { \ - *gmock_os << FormatDescription(false); \ - } \ - void DescribeNegationTo(::std::ostream* gmock_os) const override { \ - *gmock_os << FormatDescription(true); \ - } \ - GMOCK_INTERNAL_MATCHER_MEMBERS(args) \ - \ - private: \ - ::std::string FormatDescription(bool negation) const { \ - ::std::string gmock_description = (description); \ - if (!gmock_description.empty()) { \ - return gmock_description; \ - } \ - return ::testing::internal::FormatMatcherDescription( \ - negation, #name, \ - ::testing::internal::UniversalTersePrintTupleFieldsToStrings( \ - ::std::tuple<GMOCK_INTERNAL_MATCHER_TYPE_PARAMS(args)>( \ - GMOCK_INTERNAL_MATCHER_MEMBERS_USAGE(args)))); \ - } \ - }; \ - }; \ - template <GMOCK_INTERNAL_MATCHER_TEMPLATE_PARAMS(args)> \ - inline full_name<GMOCK_INTERNAL_MATCHER_TYPE_PARAMS(args)> name( \ - GMOCK_INTERNAL_MATCHER_FUNCTION_ARGS(args)) { \ - return full_name<GMOCK_INTERNAL_MATCHER_TYPE_PARAMS(args)>( \ - GMOCK_INTERNAL_MATCHER_ARGS_USAGE(args)); \ - } \ - template <GMOCK_INTERNAL_MATCHER_TEMPLATE_PARAMS(args)> \ - template <typename arg_type> \ - bool full_name<GMOCK_INTERNAL_MATCHER_TYPE_PARAMS(args)>::gmock_Impl< \ - arg_type>::MatchAndExplain(const arg_type& arg, \ - ::testing::MatchResultListener* \ - result_listener GTEST_ATTRIBUTE_UNUSED_) \ - const - -#define GMOCK_INTERNAL_MATCHER_TEMPLATE_PARAMS(args) \ - GMOCK_PP_TAIL( \ - GMOCK_PP_FOR_EACH(GMOCK_INTERNAL_MATCHER_TEMPLATE_PARAM, , args)) -#define GMOCK_INTERNAL_MATCHER_TEMPLATE_PARAM(i_unused, data_unused, arg) \ - , typename arg##_type - -#define GMOCK_INTERNAL_MATCHER_TYPE_PARAMS(args) \ - GMOCK_PP_TAIL(GMOCK_PP_FOR_EACH(GMOCK_INTERNAL_MATCHER_TYPE_PARAM, , args)) -#define GMOCK_INTERNAL_MATCHER_TYPE_PARAM(i_unused, data_unused, arg) \ - , arg##_type - -#define GMOCK_INTERNAL_MATCHER_FUNCTION_ARGS(args) \ - GMOCK_PP_TAIL(dummy_first GMOCK_PP_FOR_EACH( \ - GMOCK_INTERNAL_MATCHER_FUNCTION_ARG, , args)) -#define GMOCK_INTERNAL_MATCHER_FUNCTION_ARG(i, data_unused, arg) \ - , arg##_type gmock_p##i - -#define GMOCK_INTERNAL_MATCHER_FORWARD_ARGS(args) \ - GMOCK_PP_TAIL(GMOCK_PP_FOR_EACH(GMOCK_INTERNAL_MATCHER_FORWARD_ARG, , args)) -#define GMOCK_INTERNAL_MATCHER_FORWARD_ARG(i, data_unused, arg) \ - , arg(::std::forward<arg##_type>(gmock_p##i)) - -#define GMOCK_INTERNAL_MATCHER_MEMBERS(args) \ - GMOCK_PP_FOR_EACH(GMOCK_INTERNAL_MATCHER_MEMBER, , args) -#define GMOCK_INTERNAL_MATCHER_MEMBER(i_unused, data_unused, arg) \ - const arg##_type arg; - -#define GMOCK_INTERNAL_MATCHER_MEMBERS_USAGE(args) \ - GMOCK_PP_TAIL(GMOCK_PP_FOR_EACH(GMOCK_INTERNAL_MATCHER_MEMBER_USAGE, , args)) -#define GMOCK_INTERNAL_MATCHER_MEMBER_USAGE(i_unused, data_unused, arg) , arg - -#define GMOCK_INTERNAL_MATCHER_ARGS_USAGE(args) \ - GMOCK_PP_TAIL(GMOCK_PP_FOR_EACH(GMOCK_INTERNAL_MATCHER_ARG_USAGE, , args)) -#define GMOCK_INTERNAL_MATCHER_ARG_USAGE(i, data_unused, arg_unused) \ - , gmock_p##i - -// To prevent ADL on certain functions we put them on a separate namespace. -using namespace no_adl; // NOLINT - -} // namespace testing - -GTEST_DISABLE_MSC_WARNINGS_POP_() // 4251 5046 - -// Include any custom callback matchers added by the local installation. -// We must include this header at the end to make sure it can use the -// declarations from this file. -// Copyright 2015, 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. -// -// Injection point for custom user configurations. See README for details -// -// GOOGLETEST_CM0002 DO NOT DELETE - -#ifndef GOOGLEMOCK_INCLUDE_GMOCK_INTERNAL_CUSTOM_GMOCK_MATCHERS_H_ -#define GOOGLEMOCK_INCLUDE_GMOCK_INTERNAL_CUSTOM_GMOCK_MATCHERS_H_ -#endif // GOOGLEMOCK_INCLUDE_GMOCK_INTERNAL_CUSTOM_GMOCK_MATCHERS_H_ - -#endif // GOOGLEMOCK_INCLUDE_GMOCK_GMOCK_MATCHERS_H_ - -#if GTEST_HAS_EXCEPTIONS -# include <stdexcept> // NOLINT -#endif - -GTEST_DISABLE_MSC_WARNINGS_PUSH_(4251 \ -/* class A needs to have dll-interface to be used by clients of class B */) - -namespace testing { - -// An abstract handle of an expectation. -class Expectation; - -// A set of expectation handles. -class ExpectationSet; - -// Anything inside the 'internal' namespace IS INTERNAL IMPLEMENTATION -// and MUST NOT BE USED IN USER CODE!!! -namespace internal { - -// Implements a mock function. -template <typename F> class FunctionMocker; - -// Base class for expectations. -class ExpectationBase; - -// Implements an expectation. -template <typename F> class TypedExpectation; - -// Helper class for testing the Expectation class template. -class ExpectationTester; - -// Helper classes for implementing NiceMock, StrictMock, and NaggyMock. -template <typename MockClass> -class NiceMockImpl; -template <typename MockClass> -class StrictMockImpl; -template <typename MockClass> -class NaggyMockImpl; - -// Protects the mock object registry (in class Mock), all function -// mockers, and all expectations. -// -// The reason we don't use more fine-grained protection is: when a -// mock function Foo() is called, it needs to consult its expectations -// to see which one should be picked. If another thread is allowed to -// call a mock function (either Foo() or a different one) at the same -// time, it could affect the "retired" attributes of Foo()'s -// expectations when InSequence() is used, and thus affect which -// expectation gets picked. Therefore, we sequence all mock function -// calls to ensure the integrity of the mock objects' states. -GTEST_API_ GTEST_DECLARE_STATIC_MUTEX_(g_gmock_mutex); - -// Untyped base class for ActionResultHolder<R>. -class UntypedActionResultHolderBase; - -// Abstract base class of FunctionMocker. This is the -// type-agnostic part of the function mocker interface. Its pure -// virtual methods are implemented by FunctionMocker. -class GTEST_API_ UntypedFunctionMockerBase { - public: - UntypedFunctionMockerBase(); - virtual ~UntypedFunctionMockerBase(); - - // Verifies that all expectations on this mock function have been - // satisfied. Reports one or more Google Test non-fatal failures - // and returns false if not. - bool VerifyAndClearExpectationsLocked() - GTEST_EXCLUSIVE_LOCK_REQUIRED_(g_gmock_mutex); - - // Clears the ON_CALL()s set on this mock function. - virtual void ClearDefaultActionsLocked() - GTEST_EXCLUSIVE_LOCK_REQUIRED_(g_gmock_mutex) = 0; - - // In all of the following Untyped* functions, it's the caller's - // responsibility to guarantee the correctness of the arguments' - // types. - - // Performs the default action with the given arguments and returns - // the action's result. The call description string will be used in - // the error message to describe the call in the case the default - // action fails. - // L = * - virtual UntypedActionResultHolderBase* UntypedPerformDefaultAction( - void* untyped_args, const std::string& call_description) const = 0; - - // Performs the given action with the given arguments and returns - // the action's result. - // L = * - virtual UntypedActionResultHolderBase* UntypedPerformAction( - const void* untyped_action, void* untyped_args) const = 0; - - // Writes a message that the call is uninteresting (i.e. neither - // explicitly expected nor explicitly unexpected) to the given - // ostream. - virtual void UntypedDescribeUninterestingCall( - const void* untyped_args, - ::std::ostream* os) const - GTEST_LOCK_EXCLUDED_(g_gmock_mutex) = 0; - - // Returns the expectation that matches the given function arguments - // (or NULL is there's no match); when a match is found, - // untyped_action is set to point to the action that should be - // performed (or NULL if the action is "do default"), and - // is_excessive is modified to indicate whether the call exceeds the - // expected number. - virtual const ExpectationBase* UntypedFindMatchingExpectation( - const void* untyped_args, - const void** untyped_action, bool* is_excessive, - ::std::ostream* what, ::std::ostream* why) - GTEST_LOCK_EXCLUDED_(g_gmock_mutex) = 0; - - // Prints the given function arguments to the ostream. - virtual void UntypedPrintArgs(const void* untyped_args, - ::std::ostream* os) const = 0; - - // Sets the mock object this mock method belongs to, and registers - // this information in the global mock registry. Will be called - // whenever an EXPECT_CALL() or ON_CALL() is executed on this mock - // method. - void RegisterOwner(const void* mock_obj) - GTEST_LOCK_EXCLUDED_(g_gmock_mutex); - - // Sets the mock object this mock method belongs to, and sets the - // name of the mock function. Will be called upon each invocation - // of this mock function. - void SetOwnerAndName(const void* mock_obj, const char* name) - GTEST_LOCK_EXCLUDED_(g_gmock_mutex); - - // Returns the mock object this mock method belongs to. Must be - // called after RegisterOwner() or SetOwnerAndName() has been - // called. - const void* MockObject() const - GTEST_LOCK_EXCLUDED_(g_gmock_mutex); - - // Returns the name of this mock method. Must be called after - // SetOwnerAndName() has been called. - const char* Name() const - GTEST_LOCK_EXCLUDED_(g_gmock_mutex); - - // Returns the result of invoking this mock function with the given - // arguments. This function can be safely called from multiple - // threads concurrently. The caller is responsible for deleting the - // result. - UntypedActionResultHolderBase* UntypedInvokeWith(void* untyped_args) - GTEST_LOCK_EXCLUDED_(g_gmock_mutex); - - protected: - typedef std::vector<const void*> UntypedOnCallSpecs; - - using UntypedExpectations = std::vector<std::shared_ptr<ExpectationBase>>; - - // Returns an Expectation object that references and co-owns exp, - // which must be an expectation on this mock function. - Expectation GetHandleOf(ExpectationBase* exp); - - // Address of the mock object this mock method belongs to. Only - // valid after this mock method has been called or - // ON_CALL/EXPECT_CALL has been invoked on it. - const void* mock_obj_; // Protected by g_gmock_mutex. - - // Name of the function being mocked. Only valid after this mock - // method has been called. - const char* name_; // Protected by g_gmock_mutex. - - // All default action specs for this function mocker. - UntypedOnCallSpecs untyped_on_call_specs_; - - // All expectations for this function mocker. - // - // It's undefined behavior to interleave expectations (EXPECT_CALLs - // or ON_CALLs) and mock function calls. Also, the order of - // expectations is important. Therefore it's a logic race condition - // to read/write untyped_expectations_ concurrently. In order for - // tools like tsan to catch concurrent read/write accesses to - // untyped_expectations, we deliberately leave accesses to it - // unprotected. - UntypedExpectations untyped_expectations_; -}; // class UntypedFunctionMockerBase - -// Untyped base class for OnCallSpec<F>. -class UntypedOnCallSpecBase { - public: - // The arguments are the location of the ON_CALL() statement. - UntypedOnCallSpecBase(const char* a_file, int a_line) - : file_(a_file), line_(a_line), last_clause_(kNone) {} - - // Where in the source file was the default action spec defined? - const char* file() const { return file_; } - int line() const { return line_; } - - protected: - // Gives each clause in the ON_CALL() statement a name. - enum Clause { - // Do not change the order of the enum members! The run-time - // syntax checking relies on it. - kNone, - kWith, - kWillByDefault - }; - - // Asserts that the ON_CALL() statement has a certain property. - void AssertSpecProperty(bool property, - const std::string& failure_message) const { - Assert(property, file_, line_, failure_message); - } - - // Expects that the ON_CALL() statement has a certain property. - void ExpectSpecProperty(bool property, - const std::string& failure_message) const { - Expect(property, file_, line_, failure_message); - } - - const char* file_; - int line_; - - // The last clause in the ON_CALL() statement as seen so far. - // Initially kNone and changes as the statement is parsed. - Clause last_clause_; -}; // class UntypedOnCallSpecBase - -// This template class implements an ON_CALL spec. -template <typename F> -class OnCallSpec : public UntypedOnCallSpecBase { - public: - typedef typename Function<F>::ArgumentTuple ArgumentTuple; - typedef typename Function<F>::ArgumentMatcherTuple ArgumentMatcherTuple; - - // Constructs an OnCallSpec object from the information inside - // the parenthesis of an ON_CALL() statement. - OnCallSpec(const char* a_file, int a_line, - const ArgumentMatcherTuple& matchers) - : UntypedOnCallSpecBase(a_file, a_line), - matchers_(matchers), - // By default, extra_matcher_ should match anything. However, - // we cannot initialize it with _ as that causes ambiguity between - // Matcher's copy and move constructor for some argument types. - extra_matcher_(A<const ArgumentTuple&>()) {} - - // Implements the .With() clause. - OnCallSpec& With(const Matcher<const ArgumentTuple&>& m) { - // Makes sure this is called at most once. - ExpectSpecProperty(last_clause_ < kWith, - ".With() cannot appear " - "more than once in an ON_CALL()."); - last_clause_ = kWith; - - extra_matcher_ = m; - return *this; - } - - // Implements the .WillByDefault() clause. - OnCallSpec& WillByDefault(const Action<F>& action) { - ExpectSpecProperty(last_clause_ < kWillByDefault, - ".WillByDefault() must appear " - "exactly once in an ON_CALL()."); - last_clause_ = kWillByDefault; - - ExpectSpecProperty(!action.IsDoDefault(), - "DoDefault() cannot be used in ON_CALL()."); - action_ = action; - return *this; - } - - // Returns true if and only if the given arguments match the matchers. - bool Matches(const ArgumentTuple& args) const { - return TupleMatches(matchers_, args) && extra_matcher_.Matches(args); - } - - // Returns the action specified by the user. - const Action<F>& GetAction() const { - AssertSpecProperty(last_clause_ == kWillByDefault, - ".WillByDefault() must appear exactly " - "once in an ON_CALL()."); - return action_; - } - - private: - // The information in statement - // - // ON_CALL(mock_object, Method(matchers)) - // .With(multi-argument-matcher) - // .WillByDefault(action); - // - // is recorded in the data members like this: - // - // source file that contains the statement => file_ - // line number of the statement => line_ - // matchers => matchers_ - // multi-argument-matcher => extra_matcher_ - // action => action_ - ArgumentMatcherTuple matchers_; - Matcher<const ArgumentTuple&> extra_matcher_; - Action<F> action_; -}; // class OnCallSpec - -// Possible reactions on uninteresting calls. -enum CallReaction { - kAllow, - kWarn, - kFail, -}; - -} // namespace internal - -// Utilities for manipulating mock objects. -class GTEST_API_ Mock { - public: - // The following public methods can be called concurrently. - - // Tells Google Mock to ignore mock_obj when checking for leaked - // mock objects. - static void AllowLeak(const void* mock_obj) - GTEST_LOCK_EXCLUDED_(internal::g_gmock_mutex); - - // Verifies and clears all expectations on the given mock object. - // If the expectations aren't satisfied, generates one or more - // Google Test non-fatal failures and returns false. - static bool VerifyAndClearExpectations(void* mock_obj) - GTEST_LOCK_EXCLUDED_(internal::g_gmock_mutex); - - // Verifies all expectations on the given mock object and clears its - // default actions and expectations. Returns true if and only if the - // verification was successful. - static bool VerifyAndClear(void* mock_obj) - GTEST_LOCK_EXCLUDED_(internal::g_gmock_mutex); - - // Returns whether the mock was created as a naggy mock (default) - static bool IsNaggy(void* mock_obj) - GTEST_LOCK_EXCLUDED_(internal::g_gmock_mutex); - // Returns whether the mock was created as a nice mock - static bool IsNice(void* mock_obj) - GTEST_LOCK_EXCLUDED_(internal::g_gmock_mutex); - // Returns whether the mock was created as a strict mock - static bool IsStrict(void* mock_obj) - GTEST_LOCK_EXCLUDED_(internal::g_gmock_mutex); - - private: - friend class internal::UntypedFunctionMockerBase; - - // Needed for a function mocker to register itself (so that we know - // how to clear a mock object). - template <typename F> - friend class internal::FunctionMocker; - - template <typename MockClass> - friend class internal::NiceMockImpl; - template <typename MockClass> - friend class internal::NaggyMockImpl; - template <typename MockClass> - friend class internal::StrictMockImpl; - - // Tells Google Mock to allow uninteresting calls on the given mock - // object. - static void AllowUninterestingCalls(uintptr_t mock_obj) - GTEST_LOCK_EXCLUDED_(internal::g_gmock_mutex); - - // Tells Google Mock to warn the user about uninteresting calls on - // the given mock object. - static void WarnUninterestingCalls(uintptr_t mock_obj) - GTEST_LOCK_EXCLUDED_(internal::g_gmock_mutex); - - // Tells Google Mock to fail uninteresting calls on the given mock - // object. - static void FailUninterestingCalls(uintptr_t mock_obj) - GTEST_LOCK_EXCLUDED_(internal::g_gmock_mutex); - - // Tells Google Mock the given mock object is being destroyed and - // its entry in the call-reaction table should be removed. - static void UnregisterCallReaction(uintptr_t mock_obj) - GTEST_LOCK_EXCLUDED_(internal::g_gmock_mutex); - - // Returns the reaction Google Mock will have on uninteresting calls - // made on the given mock object. - static internal::CallReaction GetReactionOnUninterestingCalls( - const void* mock_obj) - GTEST_LOCK_EXCLUDED_(internal::g_gmock_mutex); - - // Verifies that all expectations on the given mock object have been - // satisfied. Reports one or more Google Test non-fatal failures - // and returns false if not. - static bool VerifyAndClearExpectationsLocked(void* mock_obj) - GTEST_EXCLUSIVE_LOCK_REQUIRED_(internal::g_gmock_mutex); - - // Clears all ON_CALL()s set on the given mock object. - static void ClearDefaultActionsLocked(void* mock_obj) - GTEST_EXCLUSIVE_LOCK_REQUIRED_(internal::g_gmock_mutex); - - // Registers a mock object and a mock method it owns. - static void Register( - const void* mock_obj, - internal::UntypedFunctionMockerBase* mocker) - GTEST_LOCK_EXCLUDED_(internal::g_gmock_mutex); - - // Tells Google Mock where in the source code mock_obj is used in an - // ON_CALL or EXPECT_CALL. In case mock_obj is leaked, this - // information helps the user identify which object it is. - static void RegisterUseByOnCallOrExpectCall( - const void* mock_obj, const char* file, int line) - GTEST_LOCK_EXCLUDED_(internal::g_gmock_mutex); - - // Unregisters a mock method; removes the owning mock object from - // the registry when the last mock method associated with it has - // been unregistered. This is called only in the destructor of - // FunctionMocker. - static void UnregisterLocked(internal::UntypedFunctionMockerBase* mocker) - GTEST_EXCLUSIVE_LOCK_REQUIRED_(internal::g_gmock_mutex); -}; // class Mock - -// An abstract handle of an expectation. Useful in the .After() -// clause of EXPECT_CALL() for setting the (partial) order of -// expectations. The syntax: -// -// Expectation e1 = EXPECT_CALL(...)...; -// EXPECT_CALL(...).After(e1)...; -// -// sets two expectations where the latter can only be matched after -// the former has been satisfied. -// -// Notes: -// - This class is copyable and has value semantics. -// - Constness is shallow: a const Expectation object itself cannot -// be modified, but the mutable methods of the ExpectationBase -// object it references can be called via expectation_base(). - -class GTEST_API_ Expectation { - public: - // Constructs a null object that doesn't reference any expectation. - Expectation(); - Expectation(Expectation&&) = default; - Expectation(const Expectation&) = default; - Expectation& operator=(Expectation&&) = default; - Expectation& operator=(const Expectation&) = default; - ~Expectation(); - - // This single-argument ctor must not be explicit, in order to support the - // Expectation e = EXPECT_CALL(...); - // syntax. - // - // A TypedExpectation object stores its pre-requisites as - // Expectation objects, and needs to call the non-const Retire() - // method on the ExpectationBase objects they reference. Therefore - // Expectation must receive a *non-const* reference to the - // ExpectationBase object. - Expectation(internal::ExpectationBase& exp); // NOLINT - - // The compiler-generated copy ctor and operator= work exactly as - // intended, so we don't need to define our own. - - // Returns true if and only if rhs references the same expectation as this - // object does. - bool operator==(const Expectation& rhs) const { - return expectation_base_ == rhs.expectation_base_; - } - - bool operator!=(const Expectation& rhs) const { return !(*this == rhs); } - - private: - friend class ExpectationSet; - friend class Sequence; - friend class ::testing::internal::ExpectationBase; - friend class ::testing::internal::UntypedFunctionMockerBase; - - template <typename F> - friend class ::testing::internal::FunctionMocker; - - template <typename F> - friend class ::testing::internal::TypedExpectation; - - // This comparator is needed for putting Expectation objects into a set. - class Less { - public: - bool operator()(const Expectation& lhs, const Expectation& rhs) const { - return lhs.expectation_base_.get() < rhs.expectation_base_.get(); - } - }; - - typedef ::std::set<Expectation, Less> Set; - - Expectation( - const std::shared_ptr<internal::ExpectationBase>& expectation_base); - - // Returns the expectation this object references. - const std::shared_ptr<internal::ExpectationBase>& expectation_base() const { - return expectation_base_; - } - - // A shared_ptr that co-owns the expectation this handle references. - std::shared_ptr<internal::ExpectationBase> expectation_base_; -}; - -// A set of expectation handles. Useful in the .After() clause of -// EXPECT_CALL() for setting the (partial) order of expectations. The -// syntax: -// -// ExpectationSet es; -// es += EXPECT_CALL(...)...; -// es += EXPECT_CALL(...)...; -// EXPECT_CALL(...).After(es)...; -// -// sets three expectations where the last one can only be matched -// after the first two have both been satisfied. -// -// This class is copyable and has value semantics. -class ExpectationSet { - public: - // A bidirectional iterator that can read a const element in the set. - typedef Expectation::Set::const_iterator const_iterator; - - // An object stored in the set. This is an alias of Expectation. - typedef Expectation::Set::value_type value_type; - - // Constructs an empty set. - ExpectationSet() {} - - // This single-argument ctor must not be explicit, in order to support the - // ExpectationSet es = EXPECT_CALL(...); - // syntax. - ExpectationSet(internal::ExpectationBase& exp) { // NOLINT - *this += Expectation(exp); - } - - // This single-argument ctor implements implicit conversion from - // Expectation and thus must not be explicit. This allows either an - // Expectation or an ExpectationSet to be used in .After(). - ExpectationSet(const Expectation& e) { // NOLINT - *this += e; - } - - // The compiler-generator ctor and operator= works exactly as - // intended, so we don't need to define our own. - - // Returns true if and only if rhs contains the same set of Expectation - // objects as this does. - bool operator==(const ExpectationSet& rhs) const { - return expectations_ == rhs.expectations_; - } - - bool operator!=(const ExpectationSet& rhs) const { return !(*this == rhs); } - - // Implements the syntax - // expectation_set += EXPECT_CALL(...); - ExpectationSet& operator+=(const Expectation& e) { - expectations_.insert(e); - return *this; - } - - int size() const { return static_cast<int>(expectations_.size()); } - - const_iterator begin() const { return expectations_.begin(); } - const_iterator end() const { return expectations_.end(); } - - private: - Expectation::Set expectations_; -}; - - -// Sequence objects are used by a user to specify the relative order -// in which the expectations should match. They are copyable (we rely -// on the compiler-defined copy constructor and assignment operator). -class GTEST_API_ Sequence { - public: - // Constructs an empty sequence. - Sequence() : last_expectation_(new Expectation) {} - - // Adds an expectation to this sequence. The caller must ensure - // that no other thread is accessing this Sequence object. - void AddExpectation(const Expectation& expectation) const; - - private: - // The last expectation in this sequence. - std::shared_ptr<Expectation> last_expectation_; -}; // class Sequence - -// An object of this type causes all EXPECT_CALL() statements -// encountered in its scope to be put in an anonymous sequence. The -// work is done in the constructor and destructor. You should only -// create an InSequence object on the stack. -// -// The sole purpose for this class is to support easy definition of -// sequential expectations, e.g. -// -// { -// InSequence dummy; // The name of the object doesn't matter. -// -// // The following expectations must match in the order they appear. -// EXPECT_CALL(a, Bar())...; -// EXPECT_CALL(a, Baz())...; -// ... -// EXPECT_CALL(b, Xyz())...; -// } -// -// You can create InSequence objects in multiple threads, as long as -// they are used to affect different mock objects. The idea is that -// each thread can create and set up its own mocks as if it's the only -// thread. However, for clarity of your tests we recommend you to set -// up mocks in the main thread unless you have a good reason not to do -// so. -class GTEST_API_ InSequence { - public: - InSequence(); - ~InSequence(); - private: - bool sequence_created_; - - GTEST_DISALLOW_COPY_AND_ASSIGN_(InSequence); // NOLINT -} GTEST_ATTRIBUTE_UNUSED_; - -namespace internal { - -// Points to the implicit sequence introduced by a living InSequence -// object (if any) in the current thread or NULL. -GTEST_API_ extern ThreadLocal<Sequence*> g_gmock_implicit_sequence; - -// Base class for implementing expectations. -// -// There are two reasons for having a type-agnostic base class for -// Expectation: -// -// 1. We need to store collections of expectations of different -// types (e.g. all pre-requisites of a particular expectation, all -// expectations in a sequence). Therefore these expectation objects -// must share a common base class. -// -// 2. We can avoid binary code bloat by moving methods not depending -// on the template argument of Expectation to the base class. -// -// This class is internal and mustn't be used by user code directly. -class GTEST_API_ ExpectationBase { - public: - // source_text is the EXPECT_CALL(...) source that created this Expectation. - ExpectationBase(const char* file, int line, const std::string& source_text); - - virtual ~ExpectationBase(); - - // Where in the source file was the expectation spec defined? - const char* file() const { return file_; } - int line() const { return line_; } - const char* source_text() const { return source_text_.c_str(); } - // Returns the cardinality specified in the expectation spec. - const Cardinality& cardinality() const { return cardinality_; } - - // Describes the source file location of this expectation. - void DescribeLocationTo(::std::ostream* os) const { - *os << FormatFileLocation(file(), line()) << " "; - } - - // Describes how many times a function call matching this - // expectation has occurred. - void DescribeCallCountTo(::std::ostream* os) const - GTEST_EXCLUSIVE_LOCK_REQUIRED_(g_gmock_mutex); - - // If this mock method has an extra matcher (i.e. .With(matcher)), - // describes it to the ostream. - virtual void MaybeDescribeExtraMatcherTo(::std::ostream* os) = 0; - - protected: - friend class ::testing::Expectation; - friend class UntypedFunctionMockerBase; - - enum Clause { - // Don't change the order of the enum members! - kNone, - kWith, - kTimes, - kInSequence, - kAfter, - kWillOnce, - kWillRepeatedly, - kRetiresOnSaturation - }; - - typedef std::vector<const void*> UntypedActions; - - // Returns an Expectation object that references and co-owns this - // expectation. - virtual Expectation GetHandle() = 0; - - // Asserts that the EXPECT_CALL() statement has the given property. - void AssertSpecProperty(bool property, - const std::string& failure_message) const { - Assert(property, file_, line_, failure_message); - } - - // Expects that the EXPECT_CALL() statement has the given property. - void ExpectSpecProperty(bool property, - const std::string& failure_message) const { - Expect(property, file_, line_, failure_message); - } - - // Explicitly specifies the cardinality of this expectation. Used - // by the subclasses to implement the .Times() clause. - void SpecifyCardinality(const Cardinality& cardinality); - - // Returns true if and only if the user specified the cardinality - // explicitly using a .Times(). - bool cardinality_specified() const { return cardinality_specified_; } - - // Sets the cardinality of this expectation spec. - void set_cardinality(const Cardinality& a_cardinality) { - cardinality_ = a_cardinality; - } - - // The following group of methods should only be called after the - // EXPECT_CALL() statement, and only when g_gmock_mutex is held by - // the current thread. - - // Retires all pre-requisites of this expectation. - void RetireAllPreRequisites() - GTEST_EXCLUSIVE_LOCK_REQUIRED_(g_gmock_mutex); - - // Returns true if and only if this expectation is retired. - bool is_retired() const - GTEST_EXCLUSIVE_LOCK_REQUIRED_(g_gmock_mutex) { - g_gmock_mutex.AssertHeld(); - return retired_; - } - - // Retires this expectation. - void Retire() - GTEST_EXCLUSIVE_LOCK_REQUIRED_(g_gmock_mutex) { - g_gmock_mutex.AssertHeld(); - retired_ = true; - } - - // Returns true if and only if this expectation is satisfied. - bool IsSatisfied() const - GTEST_EXCLUSIVE_LOCK_REQUIRED_(g_gmock_mutex) { - g_gmock_mutex.AssertHeld(); - return cardinality().IsSatisfiedByCallCount(call_count_); - } - - // Returns true if and only if this expectation is saturated. - bool IsSaturated() const - GTEST_EXCLUSIVE_LOCK_REQUIRED_(g_gmock_mutex) { - g_gmock_mutex.AssertHeld(); - return cardinality().IsSaturatedByCallCount(call_count_); - } - - // Returns true if and only if this expectation is over-saturated. - bool IsOverSaturated() const - GTEST_EXCLUSIVE_LOCK_REQUIRED_(g_gmock_mutex) { - g_gmock_mutex.AssertHeld(); - return cardinality().IsOverSaturatedByCallCount(call_count_); - } - - // Returns true if and only if all pre-requisites of this expectation are - // satisfied. - bool AllPrerequisitesAreSatisfied() const - GTEST_EXCLUSIVE_LOCK_REQUIRED_(g_gmock_mutex); - - // Adds unsatisfied pre-requisites of this expectation to 'result'. - void FindUnsatisfiedPrerequisites(ExpectationSet* result) const - GTEST_EXCLUSIVE_LOCK_REQUIRED_(g_gmock_mutex); - - // Returns the number this expectation has been invoked. - int call_count() const - GTEST_EXCLUSIVE_LOCK_REQUIRED_(g_gmock_mutex) { - g_gmock_mutex.AssertHeld(); - return call_count_; - } - - // Increments the number this expectation has been invoked. - void IncrementCallCount() - GTEST_EXCLUSIVE_LOCK_REQUIRED_(g_gmock_mutex) { - g_gmock_mutex.AssertHeld(); - call_count_++; - } - - // Checks the action count (i.e. the number of WillOnce() and - // WillRepeatedly() clauses) against the cardinality if this hasn't - // been done before. Prints a warning if there are too many or too - // few actions. - void CheckActionCountIfNotDone() const - GTEST_LOCK_EXCLUDED_(mutex_); - - friend class ::testing::Sequence; - friend class ::testing::internal::ExpectationTester; - - template <typename Function> - friend class TypedExpectation; - - // Implements the .Times() clause. - void UntypedTimes(const Cardinality& a_cardinality); - - // This group of fields are part of the spec and won't change after - // an EXPECT_CALL() statement finishes. - const char* file_; // The file that contains the expectation. - int line_; // The line number of the expectation. - const std::string source_text_; // The EXPECT_CALL(...) source text. - // True if and only if the cardinality is specified explicitly. - bool cardinality_specified_; - Cardinality cardinality_; // The cardinality of the expectation. - // The immediate pre-requisites (i.e. expectations that must be - // satisfied before this expectation can be matched) of this - // expectation. We use std::shared_ptr in the set because we want an - // Expectation object to be co-owned by its FunctionMocker and its - // successors. This allows multiple mock objects to be deleted at - // different times. - ExpectationSet immediate_prerequisites_; - - // This group of fields are the current state of the expectation, - // and can change as the mock function is called. - int call_count_; // How many times this expectation has been invoked. - bool retired_; // True if and only if this expectation has retired. - UntypedActions untyped_actions_; - bool extra_matcher_specified_; - bool repeated_action_specified_; // True if a WillRepeatedly() was specified. - bool retires_on_saturation_; - Clause last_clause_; - mutable bool action_count_checked_; // Under mutex_. - mutable Mutex mutex_; // Protects action_count_checked_. -}; // class ExpectationBase - -// Impements an expectation for the given function type. -template <typename F> -class TypedExpectation : public ExpectationBase { - public: - typedef typename Function<F>::ArgumentTuple ArgumentTuple; - typedef typename Function<F>::ArgumentMatcherTuple ArgumentMatcherTuple; - typedef typename Function<F>::Result Result; - - TypedExpectation(FunctionMocker<F>* owner, const char* a_file, int a_line, - const std::string& a_source_text, - const ArgumentMatcherTuple& m) - : ExpectationBase(a_file, a_line, a_source_text), - owner_(owner), - matchers_(m), - // By default, extra_matcher_ should match anything. However, - // we cannot initialize it with _ as that causes ambiguity between - // Matcher's copy and move constructor for some argument types. - extra_matcher_(A<const ArgumentTuple&>()), - repeated_action_(DoDefault()) {} - - ~TypedExpectation() override { - // Check the validity of the action count if it hasn't been done - // yet (for example, if the expectation was never used). - CheckActionCountIfNotDone(); - for (UntypedActions::const_iterator it = untyped_actions_.begin(); - it != untyped_actions_.end(); ++it) { - delete static_cast<const Action<F>*>(*it); - } - } - - // Implements the .With() clause. - TypedExpectation& With(const Matcher<const ArgumentTuple&>& m) { - if (last_clause_ == kWith) { - ExpectSpecProperty(false, - ".With() cannot appear " - "more than once in an EXPECT_CALL()."); - } else { - ExpectSpecProperty(last_clause_ < kWith, - ".With() must be the first " - "clause in an EXPECT_CALL()."); - } - last_clause_ = kWith; - - extra_matcher_ = m; - extra_matcher_specified_ = true; - return *this; - } - - // Implements the .Times() clause. - TypedExpectation& Times(const Cardinality& a_cardinality) { - ExpectationBase::UntypedTimes(a_cardinality); - return *this; - } - - // Implements the .Times() clause. - TypedExpectation& Times(int n) { - return Times(Exactly(n)); - } - - // Implements the .InSequence() clause. - TypedExpectation& InSequence(const Sequence& s) { - ExpectSpecProperty(last_clause_ <= kInSequence, - ".InSequence() cannot appear after .After()," - " .WillOnce(), .WillRepeatedly(), or " - ".RetiresOnSaturation()."); - last_clause_ = kInSequence; - - s.AddExpectation(GetHandle()); - return *this; - } - TypedExpectation& InSequence(const Sequence& s1, const Sequence& s2) { - return InSequence(s1).InSequence(s2); - } - TypedExpectation& InSequence(const Sequence& s1, const Sequence& s2, - const Sequence& s3) { - return InSequence(s1, s2).InSequence(s3); - } - TypedExpectation& InSequence(const Sequence& s1, const Sequence& s2, - const Sequence& s3, const Sequence& s4) { - return InSequence(s1, s2, s3).InSequence(s4); - } - TypedExpectation& InSequence(const Sequence& s1, const Sequence& s2, - const Sequence& s3, const Sequence& s4, - const Sequence& s5) { - return InSequence(s1, s2, s3, s4).InSequence(s5); - } - - // Implements that .After() clause. - TypedExpectation& After(const ExpectationSet& s) { - ExpectSpecProperty(last_clause_ <= kAfter, - ".After() cannot appear after .WillOnce()," - " .WillRepeatedly(), or " - ".RetiresOnSaturation()."); - last_clause_ = kAfter; - - for (ExpectationSet::const_iterator it = s.begin(); it != s.end(); ++it) { - immediate_prerequisites_ += *it; - } - return *this; - } - TypedExpectation& After(const ExpectationSet& s1, const ExpectationSet& s2) { - return After(s1).After(s2); - } - TypedExpectation& After(const ExpectationSet& s1, const ExpectationSet& s2, - const ExpectationSet& s3) { - return After(s1, s2).After(s3); - } - TypedExpectation& After(const ExpectationSet& s1, const ExpectationSet& s2, - const ExpectationSet& s3, const ExpectationSet& s4) { - return After(s1, s2, s3).After(s4); - } - TypedExpectation& After(const ExpectationSet& s1, const ExpectationSet& s2, - const ExpectationSet& s3, const ExpectationSet& s4, - const ExpectationSet& s5) { - return After(s1, s2, s3, s4).After(s5); - } - - // Implements the .WillOnce() clause. - TypedExpectation& WillOnce(const Action<F>& action) { - ExpectSpecProperty(last_clause_ <= kWillOnce, - ".WillOnce() cannot appear after " - ".WillRepeatedly() or .RetiresOnSaturation()."); - last_clause_ = kWillOnce; - - untyped_actions_.push_back(new Action<F>(action)); - if (!cardinality_specified()) { - set_cardinality(Exactly(static_cast<int>(untyped_actions_.size()))); - } - return *this; - } - - // Implements the .WillRepeatedly() clause. - TypedExpectation& WillRepeatedly(const Action<F>& action) { - if (last_clause_ == kWillRepeatedly) { - ExpectSpecProperty(false, - ".WillRepeatedly() cannot appear " - "more than once in an EXPECT_CALL()."); - } else { - ExpectSpecProperty(last_clause_ < kWillRepeatedly, - ".WillRepeatedly() cannot appear " - "after .RetiresOnSaturation()."); - } - last_clause_ = kWillRepeatedly; - repeated_action_specified_ = true; - - repeated_action_ = action; - if (!cardinality_specified()) { - set_cardinality(AtLeast(static_cast<int>(untyped_actions_.size()))); - } - - // Now that no more action clauses can be specified, we check - // whether their count makes sense. - CheckActionCountIfNotDone(); - return *this; - } - - // Implements the .RetiresOnSaturation() clause. - TypedExpectation& RetiresOnSaturation() { - ExpectSpecProperty(last_clause_ < kRetiresOnSaturation, - ".RetiresOnSaturation() cannot appear " - "more than once."); - last_clause_ = kRetiresOnSaturation; - retires_on_saturation_ = true; - - // Now that no more action clauses can be specified, we check - // whether their count makes sense. - CheckActionCountIfNotDone(); - return *this; - } - - // Returns the matchers for the arguments as specified inside the - // EXPECT_CALL() macro. - const ArgumentMatcherTuple& matchers() const { - return matchers_; - } - - // Returns the matcher specified by the .With() clause. - const Matcher<const ArgumentTuple&>& extra_matcher() const { - return extra_matcher_; - } - - // Returns the action specified by the .WillRepeatedly() clause. - const Action<F>& repeated_action() const { return repeated_action_; } - - // If this mock method has an extra matcher (i.e. .With(matcher)), - // describes it to the ostream. - void MaybeDescribeExtraMatcherTo(::std::ostream* os) override { - if (extra_matcher_specified_) { - *os << " Expected args: "; - extra_matcher_.DescribeTo(os); - *os << "\n"; - } - } - - private: - template <typename Function> - friend class FunctionMocker; - - // Returns an Expectation object that references and co-owns this - // expectation. - Expectation GetHandle() override { return owner_->GetHandleOf(this); } - - // The following methods will be called only after the EXPECT_CALL() - // statement finishes and when the current thread holds - // g_gmock_mutex. - - // Returns true if and only if this expectation matches the given arguments. - bool Matches(const ArgumentTuple& args) const - GTEST_EXCLUSIVE_LOCK_REQUIRED_(g_gmock_mutex) { - g_gmock_mutex.AssertHeld(); - return TupleMatches(matchers_, args) && extra_matcher_.Matches(args); - } - - // Returns true if and only if this expectation should handle the given - // arguments. - bool ShouldHandleArguments(const ArgumentTuple& args) const - GTEST_EXCLUSIVE_LOCK_REQUIRED_(g_gmock_mutex) { - g_gmock_mutex.AssertHeld(); - - // In case the action count wasn't checked when the expectation - // was defined (e.g. if this expectation has no WillRepeatedly() - // or RetiresOnSaturation() clause), we check it when the - // expectation is used for the first time. - CheckActionCountIfNotDone(); - return !is_retired() && AllPrerequisitesAreSatisfied() && Matches(args); - } - - // Describes the result of matching the arguments against this - // expectation to the given ostream. - void ExplainMatchResultTo( - const ArgumentTuple& args, - ::std::ostream* os) const - GTEST_EXCLUSIVE_LOCK_REQUIRED_(g_gmock_mutex) { - g_gmock_mutex.AssertHeld(); - - if (is_retired()) { - *os << " Expected: the expectation is active\n" - << " Actual: it is retired\n"; - } else if (!Matches(args)) { - if (!TupleMatches(matchers_, args)) { - ExplainMatchFailureTupleTo(matchers_, args, os); - } - StringMatchResultListener listener; - if (!extra_matcher_.MatchAndExplain(args, &listener)) { - *os << " Expected args: "; - extra_matcher_.DescribeTo(os); - *os << "\n Actual: don't match"; - - internal::PrintIfNotEmpty(listener.str(), os); - *os << "\n"; - } - } else if (!AllPrerequisitesAreSatisfied()) { - *os << " Expected: all pre-requisites are satisfied\n" - << " Actual: the following immediate pre-requisites " - << "are not satisfied:\n"; - ExpectationSet unsatisfied_prereqs; - FindUnsatisfiedPrerequisites(&unsatisfied_prereqs); - int i = 0; - for (ExpectationSet::const_iterator it = unsatisfied_prereqs.begin(); - it != unsatisfied_prereqs.end(); ++it) { - it->expectation_base()->DescribeLocationTo(os); - *os << "pre-requisite #" << i++ << "\n"; - } - *os << " (end of pre-requisites)\n"; - } else { - // This line is here just for completeness' sake. It will never - // be executed as currently the ExplainMatchResultTo() function - // is called only when the mock function call does NOT match the - // expectation. - *os << "The call matches the expectation.\n"; - } - } - - // Returns the action that should be taken for the current invocation. - const Action<F>& GetCurrentAction(const FunctionMocker<F>* mocker, - const ArgumentTuple& args) const - GTEST_EXCLUSIVE_LOCK_REQUIRED_(g_gmock_mutex) { - g_gmock_mutex.AssertHeld(); - const int count = call_count(); - Assert(count >= 1, __FILE__, __LINE__, - "call_count() is <= 0 when GetCurrentAction() is " - "called - this should never happen."); - - const int action_count = static_cast<int>(untyped_actions_.size()); - if (action_count > 0 && !repeated_action_specified_ && - count > action_count) { - // If there is at least one WillOnce() and no WillRepeatedly(), - // we warn the user when the WillOnce() clauses ran out. - ::std::stringstream ss; - DescribeLocationTo(&ss); - ss << "Actions ran out in " << source_text() << "...\n" - << "Called " << count << " times, but only " - << action_count << " WillOnce()" - << (action_count == 1 ? " is" : "s are") << " specified - "; - mocker->DescribeDefaultActionTo(args, &ss); - Log(kWarning, ss.str(), 1); - } - - return count <= action_count - ? *static_cast<const Action<F>*>( - untyped_actions_[static_cast<size_t>(count - 1)]) - : repeated_action(); - } - - // Given the arguments of a mock function call, if the call will - // over-saturate this expectation, returns the default action; - // otherwise, returns the next action in this expectation. Also - // describes *what* happened to 'what', and explains *why* Google - // Mock does it to 'why'. This method is not const as it calls - // IncrementCallCount(). A return value of NULL means the default - // action. - const Action<F>* GetActionForArguments(const FunctionMocker<F>* mocker, - const ArgumentTuple& args, - ::std::ostream* what, - ::std::ostream* why) - GTEST_EXCLUSIVE_LOCK_REQUIRED_(g_gmock_mutex) { - g_gmock_mutex.AssertHeld(); - if (IsSaturated()) { - // We have an excessive call. - IncrementCallCount(); - *what << "Mock function called more times than expected - "; - mocker->DescribeDefaultActionTo(args, what); - DescribeCallCountTo(why); - - return nullptr; - } - - IncrementCallCount(); - RetireAllPreRequisites(); - - if (retires_on_saturation_ && IsSaturated()) { - Retire(); - } - - // Must be done after IncrementCount()! - *what << "Mock function call matches " << source_text() <<"...\n"; - return &(GetCurrentAction(mocker, args)); - } - - // All the fields below won't change once the EXPECT_CALL() - // statement finishes. - FunctionMocker<F>* const owner_; - ArgumentMatcherTuple matchers_; - Matcher<const ArgumentTuple&> extra_matcher_; - Action<F> repeated_action_; - - GTEST_DISALLOW_COPY_AND_ASSIGN_(TypedExpectation); -}; // class TypedExpectation - -// A MockSpec object is used by ON_CALL() or EXPECT_CALL() for -// specifying the default behavior of, or expectation on, a mock -// function. - -// Note: class MockSpec really belongs to the ::testing namespace. -// However if we define it in ::testing, MSVC will complain when -// classes in ::testing::internal declare it as a friend class -// template. To workaround this compiler bug, we define MockSpec in -// ::testing::internal and import it into ::testing. - -// Logs a message including file and line number information. -GTEST_API_ void LogWithLocation(testing::internal::LogSeverity severity, - const char* file, int line, - const std::string& message); - -template <typename F> -class MockSpec { - public: - typedef typename internal::Function<F>::ArgumentTuple ArgumentTuple; - typedef typename internal::Function<F>::ArgumentMatcherTuple - ArgumentMatcherTuple; - - // Constructs a MockSpec object, given the function mocker object - // that the spec is associated with. - MockSpec(internal::FunctionMocker<F>* function_mocker, - const ArgumentMatcherTuple& matchers) - : function_mocker_(function_mocker), matchers_(matchers) {} - - // Adds a new default action spec to the function mocker and returns - // the newly created spec. - internal::OnCallSpec<F>& InternalDefaultActionSetAt( - const char* file, int line, const char* obj, const char* call) { - LogWithLocation(internal::kInfo, file, line, - std::string("ON_CALL(") + obj + ", " + call + ") invoked"); - return function_mocker_->AddNewOnCallSpec(file, line, matchers_); - } - - // Adds a new expectation spec to the function mocker and returns - // the newly created spec. - internal::TypedExpectation<F>& InternalExpectedAt( - const char* file, int line, const char* obj, const char* call) { - const std::string source_text(std::string("EXPECT_CALL(") + obj + ", " + - call + ")"); - LogWithLocation(internal::kInfo, file, line, source_text + " invoked"); - return function_mocker_->AddNewExpectation( - file, line, source_text, matchers_); - } - - // This operator overload is used to swallow the superfluous parameter list - // introduced by the ON/EXPECT_CALL macros. See the macro comments for more - // explanation. - MockSpec<F>& operator()(const internal::WithoutMatchers&, void* const) { - return *this; - } - - private: - template <typename Function> - friend class internal::FunctionMocker; - - // The function mocker that owns this spec. - internal::FunctionMocker<F>* const function_mocker_; - // The argument matchers specified in the spec. - ArgumentMatcherTuple matchers_; -}; // class MockSpec - -// Wrapper type for generically holding an ordinary value or lvalue reference. -// If T is not a reference type, it must be copyable or movable. -// ReferenceOrValueWrapper<T> is movable, and will also be copyable unless -// T is a move-only value type (which means that it will always be copyable -// if the current platform does not support move semantics). -// -// The primary template defines handling for values, but function header -// comments describe the contract for the whole template (including -// specializations). -template <typename T> -class ReferenceOrValueWrapper { - public: - // Constructs a wrapper from the given value/reference. - explicit ReferenceOrValueWrapper(T value) - : value_(std::move(value)) { - } - - // Unwraps and returns the underlying value/reference, exactly as - // originally passed. The behavior of calling this more than once on - // the same object is unspecified. - T Unwrap() { return std::move(value_); } - - // Provides nondestructive access to the underlying value/reference. - // Always returns a const reference (more precisely, - // const std::add_lvalue_reference<T>::type). The behavior of calling this - // after calling Unwrap on the same object is unspecified. - const T& Peek() const { - return value_; - } - - private: - T value_; -}; - -// Specialization for lvalue reference types. See primary template -// for documentation. -template <typename T> -class ReferenceOrValueWrapper<T&> { - public: - // Workaround for debatable pass-by-reference lint warning (c-library-team - // policy precludes NOLINT in this context) - typedef T& reference; - explicit ReferenceOrValueWrapper(reference ref) - : value_ptr_(&ref) {} - T& Unwrap() { return *value_ptr_; } - const T& Peek() const { return *value_ptr_; } - - private: - T* value_ptr_; -}; - -// C++ treats the void type specially. For example, you cannot define -// a void-typed variable or pass a void value to a function. -// ActionResultHolder<T> holds a value of type T, where T must be a -// copyable type or void (T doesn't need to be default-constructable). -// It hides the syntactic difference between void and other types, and -// is used to unify the code for invoking both void-returning and -// non-void-returning mock functions. - -// Untyped base class for ActionResultHolder<T>. -class UntypedActionResultHolderBase { - public: - virtual ~UntypedActionResultHolderBase() {} - - // Prints the held value as an action's result to os. - virtual void PrintAsActionResult(::std::ostream* os) const = 0; -}; - -// This generic definition is used when T is not void. -template <typename T> -class ActionResultHolder : public UntypedActionResultHolderBase { - public: - // Returns the held value. Must not be called more than once. - T Unwrap() { - return result_.Unwrap(); - } - - // Prints the held value as an action's result to os. - void PrintAsActionResult(::std::ostream* os) const override { - *os << "\n Returns: "; - // T may be a reference type, so we don't use UniversalPrint(). - UniversalPrinter<T>::Print(result_.Peek(), os); - } - - // Performs the given mock function's default action and returns the - // result in a new-ed ActionResultHolder. - template <typename F> - static ActionResultHolder* PerformDefaultAction( - const FunctionMocker<F>* func_mocker, - typename Function<F>::ArgumentTuple&& args, - const std::string& call_description) { - return new ActionResultHolder(Wrapper(func_mocker->PerformDefaultAction( - std::move(args), call_description))); - } - - // Performs the given action and returns the result in a new-ed - // ActionResultHolder. - template <typename F> - static ActionResultHolder* PerformAction( - const Action<F>& action, typename Function<F>::ArgumentTuple&& args) { - return new ActionResultHolder( - Wrapper(action.Perform(std::move(args)))); - } - - private: - typedef ReferenceOrValueWrapper<T> Wrapper; - - explicit ActionResultHolder(Wrapper result) - : result_(std::move(result)) { - } - - Wrapper result_; - - GTEST_DISALLOW_COPY_AND_ASSIGN_(ActionResultHolder); -}; - -// Specialization for T = void. -template <> -class ActionResultHolder<void> : public UntypedActionResultHolderBase { - public: - void Unwrap() { } - - void PrintAsActionResult(::std::ostream* /* os */) const override {} - - // Performs the given mock function's default action and returns ownership - // of an empty ActionResultHolder*. - template <typename F> - static ActionResultHolder* PerformDefaultAction( - const FunctionMocker<F>* func_mocker, - typename Function<F>::ArgumentTuple&& args, - const std::string& call_description) { - func_mocker->PerformDefaultAction(std::move(args), call_description); - return new ActionResultHolder; - } - - // Performs the given action and returns ownership of an empty - // ActionResultHolder*. - template <typename F> - static ActionResultHolder* PerformAction( - const Action<F>& action, typename Function<F>::ArgumentTuple&& args) { - action.Perform(std::move(args)); - return new ActionResultHolder; - } - - private: - ActionResultHolder() {} - GTEST_DISALLOW_COPY_AND_ASSIGN_(ActionResultHolder); -}; - -template <typename F> -class FunctionMocker; - -template <typename R, typename... Args> -class FunctionMocker<R(Args...)> final : public UntypedFunctionMockerBase { - using F = R(Args...); - - public: - using Result = R; - using ArgumentTuple = std::tuple<Args...>; - using ArgumentMatcherTuple = std::tuple<Matcher<Args>...>; - - FunctionMocker() {} - - // There is no generally useful and implementable semantics of - // copying a mock object, so copying a mock is usually a user error. - // Thus we disallow copying function mockers. If the user really - // wants to copy a mock object, they should implement their own copy - // operation, for example: - // - // class MockFoo : public Foo { - // public: - // // Defines a copy constructor explicitly. - // MockFoo(const MockFoo& src) {} - // ... - // }; - FunctionMocker(const FunctionMocker&) = delete; - FunctionMocker& operator=(const FunctionMocker&) = delete; - - // The destructor verifies that all expectations on this mock - // function have been satisfied. If not, it will report Google Test - // non-fatal failures for the violations. - ~FunctionMocker() override GTEST_LOCK_EXCLUDED_(g_gmock_mutex) { - MutexLock l(&g_gmock_mutex); - VerifyAndClearExpectationsLocked(); - Mock::UnregisterLocked(this); - ClearDefaultActionsLocked(); - } - - // Returns the ON_CALL spec that matches this mock function with the - // given arguments; returns NULL if no matching ON_CALL is found. - // L = * - const OnCallSpec<F>* FindOnCallSpec( - const ArgumentTuple& args) const { - for (UntypedOnCallSpecs::const_reverse_iterator it - = untyped_on_call_specs_.rbegin(); - it != untyped_on_call_specs_.rend(); ++it) { - const OnCallSpec<F>* spec = static_cast<const OnCallSpec<F>*>(*it); - if (spec->Matches(args)) - return spec; - } - - return nullptr; - } - - // Performs the default action of this mock function on the given - // arguments and returns the result. Asserts (or throws if - // exceptions are enabled) with a helpful call descrption if there - // is no valid return value. This method doesn't depend on the - // mutable state of this object, and thus can be called concurrently - // without locking. - // L = * - Result PerformDefaultAction(ArgumentTuple&& args, - const std::string& call_description) const { - const OnCallSpec<F>* const spec = - this->FindOnCallSpec(args); - if (spec != nullptr) { - return spec->GetAction().Perform(std::move(args)); - } - const std::string message = - call_description + - "\n The mock function has no default action " - "set, and its return type has no default value set."; -#if GTEST_HAS_EXCEPTIONS - if (!DefaultValue<Result>::Exists()) { - throw std::runtime_error(message); - } -#else - Assert(DefaultValue<Result>::Exists(), "", -1, message); -#endif - return DefaultValue<Result>::Get(); - } - - // Performs the default action with the given arguments and returns - // the action's result. The call description string will be used in - // the error message to describe the call in the case the default - // action fails. The caller is responsible for deleting the result. - // L = * - UntypedActionResultHolderBase* UntypedPerformDefaultAction( - void* untyped_args, // must point to an ArgumentTuple - const std::string& call_description) const override { - ArgumentTuple* args = static_cast<ArgumentTuple*>(untyped_args); - return ResultHolder::PerformDefaultAction(this, std::move(*args), - call_description); - } - - // Performs the given action with the given arguments and returns - // the action's result. The caller is responsible for deleting the - // result. - // L = * - UntypedActionResultHolderBase* UntypedPerformAction( - const void* untyped_action, void* untyped_args) const override { - // Make a copy of the action before performing it, in case the - // action deletes the mock object (and thus deletes itself). - const Action<F> action = *static_cast<const Action<F>*>(untyped_action); - ArgumentTuple* args = static_cast<ArgumentTuple*>(untyped_args); - return ResultHolder::PerformAction(action, std::move(*args)); - } - - // Implements UntypedFunctionMockerBase::ClearDefaultActionsLocked(): - // clears the ON_CALL()s set on this mock function. - void ClearDefaultActionsLocked() override - GTEST_EXCLUSIVE_LOCK_REQUIRED_(g_gmock_mutex) { - g_gmock_mutex.AssertHeld(); - - // Deleting our default actions may trigger other mock objects to be - // deleted, for example if an action contains a reference counted smart - // pointer to that mock object, and that is the last reference. So if we - // delete our actions within the context of the global mutex we may deadlock - // when this method is called again. Instead, make a copy of the set of - // actions to delete, clear our set within the mutex, and then delete the - // actions outside of the mutex. - UntypedOnCallSpecs specs_to_delete; - untyped_on_call_specs_.swap(specs_to_delete); - - g_gmock_mutex.Unlock(); - for (UntypedOnCallSpecs::const_iterator it = - specs_to_delete.begin(); - it != specs_to_delete.end(); ++it) { - delete static_cast<const OnCallSpec<F>*>(*it); - } - - // Lock the mutex again, since the caller expects it to be locked when we - // return. - g_gmock_mutex.Lock(); - } - - // Returns the result of invoking this mock function with the given - // arguments. This function can be safely called from multiple - // threads concurrently. - Result Invoke(Args... args) GTEST_LOCK_EXCLUDED_(g_gmock_mutex) { - ArgumentTuple tuple(std::forward<Args>(args)...); - std::unique_ptr<ResultHolder> holder(DownCast_<ResultHolder*>( - this->UntypedInvokeWith(static_cast<void*>(&tuple)))); - return holder->Unwrap(); - } - - MockSpec<F> With(Matcher<Args>... m) { - return MockSpec<F>(this, ::std::make_tuple(std::move(m)...)); - } - - protected: - template <typename Function> - friend class MockSpec; - - typedef ActionResultHolder<Result> ResultHolder; - - // Adds and returns a default action spec for this mock function. - OnCallSpec<F>& AddNewOnCallSpec( - const char* file, int line, - const ArgumentMatcherTuple& m) - GTEST_LOCK_EXCLUDED_(g_gmock_mutex) { - Mock::RegisterUseByOnCallOrExpectCall(MockObject(), file, line); - OnCallSpec<F>* const on_call_spec = new OnCallSpec<F>(file, line, m); - untyped_on_call_specs_.push_back(on_call_spec); - return *on_call_spec; - } - - // Adds and returns an expectation spec for this mock function. - TypedExpectation<F>& AddNewExpectation(const char* file, int line, - const std::string& source_text, - const ArgumentMatcherTuple& m) - GTEST_LOCK_EXCLUDED_(g_gmock_mutex) { - Mock::RegisterUseByOnCallOrExpectCall(MockObject(), file, line); - TypedExpectation<F>* const expectation = - new TypedExpectation<F>(this, file, line, source_text, m); - const std::shared_ptr<ExpectationBase> untyped_expectation(expectation); - // See the definition of untyped_expectations_ for why access to - // it is unprotected here. - untyped_expectations_.push_back(untyped_expectation); - - // Adds this expectation into the implicit sequence if there is one. - Sequence* const implicit_sequence = g_gmock_implicit_sequence.get(); - if (implicit_sequence != nullptr) { - implicit_sequence->AddExpectation(Expectation(untyped_expectation)); - } - - return *expectation; - } - - private: - template <typename Func> friend class TypedExpectation; - - // Some utilities needed for implementing UntypedInvokeWith(). - - // Describes what default action will be performed for the given - // arguments. - // L = * - void DescribeDefaultActionTo(const ArgumentTuple& args, - ::std::ostream* os) const { - const OnCallSpec<F>* const spec = FindOnCallSpec(args); - - if (spec == nullptr) { - *os << (std::is_void<Result>::value ? "returning directly.\n" - : "returning default value.\n"); - } else { - *os << "taking default action specified at:\n" - << FormatFileLocation(spec->file(), spec->line()) << "\n"; - } - } - - // Writes a message that the call is uninteresting (i.e. neither - // explicitly expected nor explicitly unexpected) to the given - // ostream. - void UntypedDescribeUninterestingCall(const void* untyped_args, - ::std::ostream* os) const override - GTEST_LOCK_EXCLUDED_(g_gmock_mutex) { - const ArgumentTuple& args = - *static_cast<const ArgumentTuple*>(untyped_args); - *os << "Uninteresting mock function call - "; - DescribeDefaultActionTo(args, os); - *os << " Function call: " << Name(); - UniversalPrint(args, os); - } - - // Returns the expectation that matches the given function arguments - // (or NULL is there's no match); when a match is found, - // untyped_action is set to point to the action that should be - // performed (or NULL if the action is "do default"), and - // is_excessive is modified to indicate whether the call exceeds the - // expected number. - // - // Critical section: We must find the matching expectation and the - // corresponding action that needs to be taken in an ATOMIC - // transaction. Otherwise another thread may call this mock - // method in the middle and mess up the state. - // - // However, performing the action has to be left out of the critical - // section. The reason is that we have no control on what the - // action does (it can invoke an arbitrary user function or even a - // mock function) and excessive locking could cause a dead lock. - const ExpectationBase* UntypedFindMatchingExpectation( - const void* untyped_args, const void** untyped_action, bool* is_excessive, - ::std::ostream* what, ::std::ostream* why) override - GTEST_LOCK_EXCLUDED_(g_gmock_mutex) { - const ArgumentTuple& args = - *static_cast<const ArgumentTuple*>(untyped_args); - MutexLock l(&g_gmock_mutex); - TypedExpectation<F>* exp = this->FindMatchingExpectationLocked(args); - if (exp == nullptr) { // A match wasn't found. - this->FormatUnexpectedCallMessageLocked(args, what, why); - return nullptr; - } - - // This line must be done before calling GetActionForArguments(), - // which will increment the call count for *exp and thus affect - // its saturation status. - *is_excessive = exp->IsSaturated(); - const Action<F>* action = exp->GetActionForArguments(this, args, what, why); - if (action != nullptr && action->IsDoDefault()) - action = nullptr; // Normalize "do default" to NULL. - *untyped_action = action; - return exp; - } - - // Prints the given function arguments to the ostream. - void UntypedPrintArgs(const void* untyped_args, - ::std::ostream* os) const override { - const ArgumentTuple& args = - *static_cast<const ArgumentTuple*>(untyped_args); - UniversalPrint(args, os); - } - - // Returns the expectation that matches the arguments, or NULL if no - // expectation matches them. - TypedExpectation<F>* FindMatchingExpectationLocked( - const ArgumentTuple& args) const - GTEST_EXCLUSIVE_LOCK_REQUIRED_(g_gmock_mutex) { - g_gmock_mutex.AssertHeld(); - // See the definition of untyped_expectations_ for why access to - // it is unprotected here. - for (typename UntypedExpectations::const_reverse_iterator it = - untyped_expectations_.rbegin(); - it != untyped_expectations_.rend(); ++it) { - TypedExpectation<F>* const exp = - static_cast<TypedExpectation<F>*>(it->get()); - if (exp->ShouldHandleArguments(args)) { - return exp; - } - } - return nullptr; - } - - // Returns a message that the arguments don't match any expectation. - void FormatUnexpectedCallMessageLocked( - const ArgumentTuple& args, - ::std::ostream* os, - ::std::ostream* why) const - GTEST_EXCLUSIVE_LOCK_REQUIRED_(g_gmock_mutex) { - g_gmock_mutex.AssertHeld(); - *os << "\nUnexpected mock function call - "; - DescribeDefaultActionTo(args, os); - PrintTriedExpectationsLocked(args, why); - } - - // Prints a list of expectations that have been tried against the - // current mock function call. - void PrintTriedExpectationsLocked( - const ArgumentTuple& args, - ::std::ostream* why) const - GTEST_EXCLUSIVE_LOCK_REQUIRED_(g_gmock_mutex) { - g_gmock_mutex.AssertHeld(); - const size_t count = untyped_expectations_.size(); - *why << "Google Mock tried the following " << count << " " - << (count == 1 ? "expectation, but it didn't match" : - "expectations, but none matched") - << ":\n"; - for (size_t i = 0; i < count; i++) { - TypedExpectation<F>* const expectation = - static_cast<TypedExpectation<F>*>(untyped_expectations_[i].get()); - *why << "\n"; - expectation->DescribeLocationTo(why); - if (count > 1) { - *why << "tried expectation #" << i << ": "; - } - *why << expectation->source_text() << "...\n"; - expectation->ExplainMatchResultTo(args, why); - expectation->DescribeCallCountTo(why); - } - } -}; // class FunctionMocker - -// Reports an uninteresting call (whose description is in msg) in the -// manner specified by 'reaction'. -void ReportUninterestingCall(CallReaction reaction, const std::string& msg); - -} // namespace internal - -namespace internal { - -template <typename F> -class MockFunction; - -template <typename R, typename... Args> -class MockFunction<R(Args...)> { - public: - MockFunction(const MockFunction&) = delete; - MockFunction& operator=(const MockFunction&) = delete; - - std::function<R(Args...)> AsStdFunction() { - return [this](Args... args) -> R { - return this->Call(std::forward<Args>(args)...); - }; - } - - // Implementation detail: the expansion of the MOCK_METHOD macro. - R Call(Args... args) { - mock_.SetOwnerAndName(this, "Call"); - return mock_.Invoke(std::forward<Args>(args)...); - } - - MockSpec<R(Args...)> gmock_Call(Matcher<Args>... m) { - mock_.RegisterOwner(this); - return mock_.With(std::move(m)...); - } - - MockSpec<R(Args...)> gmock_Call(const WithoutMatchers&, R (*)(Args...)) { - return this->gmock_Call(::testing::A<Args>()...); - } - - protected: - MockFunction() = default; - ~MockFunction() = default; - - private: - FunctionMocker<R(Args...)> mock_; -}; - -/* -The SignatureOf<F> struct is a meta-function returning function signature -corresponding to the provided F argument. - -It makes use of MockFunction easier by allowing it to accept more F arguments -than just function signatures. - -Specializations provided here cover only a signature type itself and -std::function. However, if need be it can be easily extended to cover also other -types (like for example boost::function). -*/ - -template <typename F> -struct SignatureOf; - -template <typename R, typename... Args> -struct SignatureOf<R(Args...)> { - using type = R(Args...); -}; - -template <typename F> -struct SignatureOf<std::function<F>> : SignatureOf<F> {}; - -template <typename F> -using SignatureOfT = typename SignatureOf<F>::type; - -} // namespace internal - -// A MockFunction<F> type has one mock method whose type is -// internal::SignatureOfT<F>. It is useful when you just want your -// test code to emit some messages and have Google Mock verify the -// right messages are sent (and perhaps at the right times). For -// example, if you are exercising code: -// -// Foo(1); -// Foo(2); -// Foo(3); -// -// and want to verify that Foo(1) and Foo(3) both invoke -// mock.Bar("a"), but Foo(2) doesn't invoke anything, you can write: -// -// TEST(FooTest, InvokesBarCorrectly) { -// MyMock mock; -// MockFunction<void(string check_point_name)> check; -// { -// InSequence s; -// -// EXPECT_CALL(mock, Bar("a")); -// EXPECT_CALL(check, Call("1")); -// EXPECT_CALL(check, Call("2")); -// EXPECT_CALL(mock, Bar("a")); -// } -// Foo(1); -// check.Call("1"); -// Foo(2); -// check.Call("2"); -// Foo(3); -// } -// -// The expectation spec says that the first Bar("a") must happen -// before check point "1", the second Bar("a") must happen after check -// point "2", and nothing should happen between the two check -// points. The explicit check points make it easy to tell which -// Bar("a") is called by which call to Foo(). -// -// MockFunction<F> can also be used to exercise code that accepts -// std::function<internal::SignatureOfT<F>> callbacks. To do so, use -// AsStdFunction() method to create std::function proxy forwarding to -// original object's Call. Example: -// -// TEST(FooTest, RunsCallbackWithBarArgument) { -// MockFunction<int(string)> callback; -// EXPECT_CALL(callback, Call("bar")).WillOnce(Return(1)); -// Foo(callback.AsStdFunction()); -// } -// -// The internal::SignatureOfT<F> indirection allows to use other types -// than just function signature type. This is typically useful when -// providing a mock for a predefined std::function type. Example: -// -// using FilterPredicate = std::function<bool(string)>; -// void MyFilterAlgorithm(FilterPredicate predicate); -// -// TEST(FooTest, FilterPredicateAlwaysAccepts) { -// MockFunction<FilterPredicate> predicateMock; -// EXPECT_CALL(predicateMock, Call(_)).WillRepeatedly(Return(true)); -// MyFilterAlgorithm(predicateMock.AsStdFunction()); -// } -template <typename F> -class MockFunction : public internal::MockFunction<internal::SignatureOfT<F>> { - using Base = internal::MockFunction<internal::SignatureOfT<F>>; - - public: - using Base::Base; -}; - -// The style guide prohibits "using" statements in a namespace scope -// inside a header file. However, the MockSpec class template is -// meant to be defined in the ::testing namespace. The following line -// is just a trick for working around a bug in MSVC 8.0, which cannot -// handle it if we define MockSpec in ::testing. -using internal::MockSpec; - -// Const(x) is a convenient function for obtaining a const reference -// to x. This is useful for setting expectations on an overloaded -// const mock method, e.g. -// -// class MockFoo : public FooInterface { -// public: -// MOCK_METHOD0(Bar, int()); -// MOCK_CONST_METHOD0(Bar, int&()); -// }; -// -// MockFoo foo; -// // Expects a call to non-const MockFoo::Bar(). -// EXPECT_CALL(foo, Bar()); -// // Expects a call to const MockFoo::Bar(). -// EXPECT_CALL(Const(foo), Bar()); -template <typename T> -inline const T& Const(const T& x) { return x; } - -// Constructs an Expectation object that references and co-owns exp. -inline Expectation::Expectation(internal::ExpectationBase& exp) // NOLINT - : expectation_base_(exp.GetHandle().expectation_base()) {} - -} // namespace testing - -GTEST_DISABLE_MSC_WARNINGS_POP_() // 4251 - -// Implementation for ON_CALL and EXPECT_CALL macros. A separate macro is -// required to avoid compile errors when the name of the method used in call is -// a result of macro expansion. See CompilesWithMethodNameExpandedFromMacro -// tests in internal/gmock-spec-builders_test.cc for more details. -// -// This macro supports statements both with and without parameter matchers. If -// the parameter list is omitted, gMock will accept any parameters, which allows -// tests to be written that don't need to encode the number of method -// parameter. This technique may only be used for non-overloaded methods. -// -// // These are the same: -// ON_CALL(mock, NoArgsMethod()).WillByDefault(...); -// ON_CALL(mock, NoArgsMethod).WillByDefault(...); -// -// // As are these: -// ON_CALL(mock, TwoArgsMethod(_, _)).WillByDefault(...); -// ON_CALL(mock, TwoArgsMethod).WillByDefault(...); -// -// // Can also specify args if you want, of course: -// ON_CALL(mock, TwoArgsMethod(_, 45)).WillByDefault(...); -// -// // Overloads work as long as you specify parameters: -// ON_CALL(mock, OverloadedMethod(_)).WillByDefault(...); -// ON_CALL(mock, OverloadedMethod(_, _)).WillByDefault(...); -// -// // Oops! Which overload did you want? -// ON_CALL(mock, OverloadedMethod).WillByDefault(...); -// => ERROR: call to member function 'gmock_OverloadedMethod' is ambiguous -// -// How this works: The mock class uses two overloads of the gmock_Method -// expectation setter method plus an operator() overload on the MockSpec object. -// In the matcher list form, the macro expands to: -// -// // This statement: -// ON_CALL(mock, TwoArgsMethod(_, 45))... -// -// // ...expands to: -// mock.gmock_TwoArgsMethod(_, 45)(WithoutMatchers(), nullptr)... -// |-------------v---------------||------------v-------------| -// invokes first overload swallowed by operator() -// -// // ...which is essentially: -// mock.gmock_TwoArgsMethod(_, 45)... -// -// Whereas the form without a matcher list: -// -// // This statement: -// ON_CALL(mock, TwoArgsMethod)... -// -// // ...expands to: -// mock.gmock_TwoArgsMethod(WithoutMatchers(), nullptr)... -// |-----------------------v--------------------------| -// invokes second overload -// -// // ...which is essentially: -// mock.gmock_TwoArgsMethod(_, _)... -// -// The WithoutMatchers() argument is used to disambiguate overloads and to -// block the caller from accidentally invoking the second overload directly. The -// second argument is an internal type derived from the method signature. The -// failure to disambiguate two overloads of this method in the ON_CALL statement -// is how we block callers from setting expectations on overloaded methods. -#define GMOCK_ON_CALL_IMPL_(mock_expr, Setter, call) \ - ((mock_expr).gmock_##call)(::testing::internal::GetWithoutMatchers(), \ - nullptr) \ - .Setter(__FILE__, __LINE__, #mock_expr, #call) - -#define ON_CALL(obj, call) \ - GMOCK_ON_CALL_IMPL_(obj, InternalDefaultActionSetAt, call) - -#define EXPECT_CALL(obj, call) \ - GMOCK_ON_CALL_IMPL_(obj, InternalExpectedAt, call) - -#endif // GOOGLEMOCK_INCLUDE_GMOCK_GMOCK_SPEC_BUILDERS_H_ - -namespace testing { -namespace internal { -template <typename T> -using identity_t = T; - -template <typename Pattern> -struct ThisRefAdjuster { - template <typename T> - using AdjustT = typename std::conditional< - std::is_const<typename std::remove_reference<Pattern>::type>::value, - typename std::conditional<std::is_lvalue_reference<Pattern>::value, - const T&, const T&&>::type, - typename std::conditional<std::is_lvalue_reference<Pattern>::value, T&, - T&&>::type>::type; - - template <typename MockType> - static AdjustT<MockType> Adjust(const MockType& mock) { - return static_cast<AdjustT<MockType>>(const_cast<MockType&>(mock)); - } -}; - -} // namespace internal - -// The style guide prohibits "using" statements in a namespace scope -// inside a header file. However, the FunctionMocker class template -// is meant to be defined in the ::testing namespace. The following -// line is just a trick for working around a bug in MSVC 8.0, which -// cannot handle it if we define FunctionMocker in ::testing. -using internal::FunctionMocker; -} // namespace testing - -#define MOCK_METHOD(...) \ - GMOCK_PP_VARIADIC_CALL(GMOCK_INTERNAL_MOCK_METHOD_ARG_, __VA_ARGS__) - -#define GMOCK_INTERNAL_MOCK_METHOD_ARG_1(...) \ - GMOCK_INTERNAL_WRONG_ARITY(__VA_ARGS__) - -#define GMOCK_INTERNAL_MOCK_METHOD_ARG_2(...) \ - GMOCK_INTERNAL_WRONG_ARITY(__VA_ARGS__) - -#define GMOCK_INTERNAL_MOCK_METHOD_ARG_3(_Ret, _MethodName, _Args) \ - GMOCK_INTERNAL_MOCK_METHOD_ARG_4(_Ret, _MethodName, _Args, ()) - -#define GMOCK_INTERNAL_MOCK_METHOD_ARG_4(_Ret, _MethodName, _Args, _Spec) \ - GMOCK_INTERNAL_ASSERT_PARENTHESIS(_Args); \ - GMOCK_INTERNAL_ASSERT_PARENTHESIS(_Spec); \ - GMOCK_INTERNAL_ASSERT_VALID_SIGNATURE( \ - GMOCK_PP_NARG0 _Args, GMOCK_INTERNAL_SIGNATURE(_Ret, _Args)); \ - GMOCK_INTERNAL_ASSERT_VALID_SPEC(_Spec) \ - GMOCK_INTERNAL_MOCK_METHOD_IMPL( \ - GMOCK_PP_NARG0 _Args, _MethodName, GMOCK_INTERNAL_HAS_CONST(_Spec), \ - GMOCK_INTERNAL_HAS_OVERRIDE(_Spec), GMOCK_INTERNAL_HAS_FINAL(_Spec), \ - GMOCK_INTERNAL_GET_NOEXCEPT_SPEC(_Spec), \ - GMOCK_INTERNAL_GET_CALLTYPE(_Spec), GMOCK_INTERNAL_GET_REF_SPEC(_Spec), \ - (GMOCK_INTERNAL_SIGNATURE(_Ret, _Args))) - -#define GMOCK_INTERNAL_MOCK_METHOD_ARG_5(...) \ - GMOCK_INTERNAL_WRONG_ARITY(__VA_ARGS__) - -#define GMOCK_INTERNAL_MOCK_METHOD_ARG_6(...) \ - GMOCK_INTERNAL_WRONG_ARITY(__VA_ARGS__) - -#define GMOCK_INTERNAL_MOCK_METHOD_ARG_7(...) \ - GMOCK_INTERNAL_WRONG_ARITY(__VA_ARGS__) - -#define GMOCK_INTERNAL_WRONG_ARITY(...) \ - static_assert( \ - false, \ - "MOCK_METHOD must be called with 3 or 4 arguments. _Ret, " \ - "_MethodName, _Args and optionally _Spec. _Args and _Spec must be " \ - "enclosed in parentheses. If _Ret is a type with unprotected commas, " \ - "it must also be enclosed in parentheses.") - -#define GMOCK_INTERNAL_ASSERT_PARENTHESIS(_Tuple) \ - static_assert( \ - GMOCK_PP_IS_ENCLOSED_PARENS(_Tuple), \ - GMOCK_PP_STRINGIZE(_Tuple) " should be enclosed in parentheses.") - -#define GMOCK_INTERNAL_ASSERT_VALID_SIGNATURE(_N, ...) \ - static_assert( \ - std::is_function<__VA_ARGS__>::value, \ - "Signature must be a function type, maybe return type contains " \ - "unprotected comma."); \ - static_assert( \ - ::testing::tuple_size<typename ::testing::internal::Function< \ - __VA_ARGS__>::ArgumentTuple>::value == _N, \ - "This method does not take " GMOCK_PP_STRINGIZE( \ - _N) " arguments. Parenthesize all types with unprotected commas.") - -#define GMOCK_INTERNAL_ASSERT_VALID_SPEC(_Spec) \ - GMOCK_PP_FOR_EACH(GMOCK_INTERNAL_ASSERT_VALID_SPEC_ELEMENT, ~, _Spec) - -#define GMOCK_INTERNAL_MOCK_METHOD_IMPL(_N, _MethodName, _Constness, \ - _Override, _Final, _NoexceptSpec, \ - _CallType, _RefSpec, _Signature) \ - typename ::testing::internal::Function<GMOCK_PP_REMOVE_PARENS( \ - _Signature)>::Result \ - GMOCK_INTERNAL_EXPAND(_CallType) \ - _MethodName(GMOCK_PP_REPEAT(GMOCK_INTERNAL_PARAMETER, _Signature, _N)) \ - GMOCK_PP_IF(_Constness, const, ) _RefSpec _NoexceptSpec \ - GMOCK_PP_IF(_Override, override, ) GMOCK_PP_IF(_Final, final, ) { \ - GMOCK_MOCKER_(_N, _Constness, _MethodName) \ - .SetOwnerAndName(this, #_MethodName); \ - return GMOCK_MOCKER_(_N, _Constness, _MethodName) \ - .Invoke(GMOCK_PP_REPEAT(GMOCK_INTERNAL_FORWARD_ARG, _Signature, _N)); \ - } \ - ::testing::MockSpec<GMOCK_PP_REMOVE_PARENS(_Signature)> gmock_##_MethodName( \ - GMOCK_PP_REPEAT(GMOCK_INTERNAL_MATCHER_PARAMETER, _Signature, _N)) \ - GMOCK_PP_IF(_Constness, const, ) _RefSpec { \ - GMOCK_MOCKER_(_N, _Constness, _MethodName).RegisterOwner(this); \ - return GMOCK_MOCKER_(_N, _Constness, _MethodName) \ - .With(GMOCK_PP_REPEAT(GMOCK_INTERNAL_MATCHER_ARGUMENT, , _N)); \ - } \ - ::testing::MockSpec<GMOCK_PP_REMOVE_PARENS(_Signature)> gmock_##_MethodName( \ - const ::testing::internal::WithoutMatchers&, \ - GMOCK_PP_IF(_Constness, const, )::testing::internal::Function< \ - GMOCK_PP_REMOVE_PARENS(_Signature)>*) const _RefSpec _NoexceptSpec { \ - return ::testing::internal::ThisRefAdjuster<GMOCK_PP_IF( \ - _Constness, const, ) int _RefSpec>::Adjust(*this) \ - .gmock_##_MethodName(GMOCK_PP_REPEAT( \ - GMOCK_INTERNAL_A_MATCHER_ARGUMENT, _Signature, _N)); \ - } \ - mutable ::testing::FunctionMocker<GMOCK_PP_REMOVE_PARENS(_Signature)> \ - GMOCK_MOCKER_(_N, _Constness, _MethodName) - -#define GMOCK_INTERNAL_EXPAND(...) __VA_ARGS__ - -// Five Valid modifiers. -#define GMOCK_INTERNAL_HAS_CONST(_Tuple) \ - GMOCK_PP_HAS_COMMA(GMOCK_PP_FOR_EACH(GMOCK_INTERNAL_DETECT_CONST, ~, _Tuple)) - -#define GMOCK_INTERNAL_HAS_OVERRIDE(_Tuple) \ - GMOCK_PP_HAS_COMMA( \ - GMOCK_PP_FOR_EACH(GMOCK_INTERNAL_DETECT_OVERRIDE, ~, _Tuple)) - -#define GMOCK_INTERNAL_HAS_FINAL(_Tuple) \ - GMOCK_PP_HAS_COMMA(GMOCK_PP_FOR_EACH(GMOCK_INTERNAL_DETECT_FINAL, ~, _Tuple)) - -#define GMOCK_INTERNAL_GET_NOEXCEPT_SPEC(_Tuple) \ - GMOCK_PP_FOR_EACH(GMOCK_INTERNAL_NOEXCEPT_SPEC_IF_NOEXCEPT, ~, _Tuple) - -#define GMOCK_INTERNAL_NOEXCEPT_SPEC_IF_NOEXCEPT(_i, _, _elem) \ - GMOCK_PP_IF( \ - GMOCK_PP_HAS_COMMA(GMOCK_INTERNAL_DETECT_NOEXCEPT(_i, _, _elem)), \ - _elem, ) - -#define GMOCK_INTERNAL_GET_REF_SPEC(_Tuple) \ - GMOCK_PP_FOR_EACH(GMOCK_INTERNAL_REF_SPEC_IF_REF, ~, _Tuple) - -#define GMOCK_INTERNAL_REF_SPEC_IF_REF(_i, _, _elem) \ - GMOCK_PP_IF(GMOCK_PP_HAS_COMMA(GMOCK_INTERNAL_DETECT_REF(_i, _, _elem)), \ - GMOCK_PP_CAT(GMOCK_INTERNAL_UNPACK_, _elem), ) - -#define GMOCK_INTERNAL_GET_CALLTYPE(_Tuple) \ - GMOCK_PP_FOR_EACH(GMOCK_INTERNAL_GET_CALLTYPE_IMPL, ~, _Tuple) - -#define GMOCK_INTERNAL_ASSERT_VALID_SPEC_ELEMENT(_i, _, _elem) \ - static_assert( \ - (GMOCK_PP_HAS_COMMA(GMOCK_INTERNAL_DETECT_CONST(_i, _, _elem)) + \ - GMOCK_PP_HAS_COMMA(GMOCK_INTERNAL_DETECT_OVERRIDE(_i, _, _elem)) + \ - GMOCK_PP_HAS_COMMA(GMOCK_INTERNAL_DETECT_FINAL(_i, _, _elem)) + \ - GMOCK_PP_HAS_COMMA(GMOCK_INTERNAL_DETECT_NOEXCEPT(_i, _, _elem)) + \ - GMOCK_PP_HAS_COMMA(GMOCK_INTERNAL_DETECT_REF(_i, _, _elem)) + \ - GMOCK_INTERNAL_IS_CALLTYPE(_elem)) == 1, \ - GMOCK_PP_STRINGIZE( \ - _elem) " cannot be recognized as a valid specification modifier."); - -// Modifiers implementation. -#define GMOCK_INTERNAL_DETECT_CONST(_i, _, _elem) \ - GMOCK_PP_CAT(GMOCK_INTERNAL_DETECT_CONST_I_, _elem) - -#define GMOCK_INTERNAL_DETECT_CONST_I_const , - -#define GMOCK_INTERNAL_DETECT_OVERRIDE(_i, _, _elem) \ - GMOCK_PP_CAT(GMOCK_INTERNAL_DETECT_OVERRIDE_I_, _elem) - -#define GMOCK_INTERNAL_DETECT_OVERRIDE_I_override , - -#define GMOCK_INTERNAL_DETECT_FINAL(_i, _, _elem) \ - GMOCK_PP_CAT(GMOCK_INTERNAL_DETECT_FINAL_I_, _elem) - -#define GMOCK_INTERNAL_DETECT_FINAL_I_final , - -#define GMOCK_INTERNAL_DETECT_NOEXCEPT(_i, _, _elem) \ - GMOCK_PP_CAT(GMOCK_INTERNAL_DETECT_NOEXCEPT_I_, _elem) - -#define GMOCK_INTERNAL_DETECT_NOEXCEPT_I_noexcept , - -#define GMOCK_INTERNAL_DETECT_REF(_i, _, _elem) \ - GMOCK_PP_CAT(GMOCK_INTERNAL_DETECT_REF_I_, _elem) - -#define GMOCK_INTERNAL_DETECT_REF_I_ref , - -#define GMOCK_INTERNAL_UNPACK_ref(x) x - -#define GMOCK_INTERNAL_GET_CALLTYPE_IMPL(_i, _, _elem) \ - GMOCK_PP_IF(GMOCK_INTERNAL_IS_CALLTYPE(_elem), \ - GMOCK_INTERNAL_GET_VALUE_CALLTYPE, GMOCK_PP_EMPTY) \ - (_elem) - -// TODO(iserna): GMOCK_INTERNAL_IS_CALLTYPE and -// GMOCK_INTERNAL_GET_VALUE_CALLTYPE needed more expansions to work on windows -// maybe they can be simplified somehow. -#define GMOCK_INTERNAL_IS_CALLTYPE(_arg) \ - GMOCK_INTERNAL_IS_CALLTYPE_I( \ - GMOCK_PP_CAT(GMOCK_INTERNAL_IS_CALLTYPE_HELPER_, _arg)) -#define GMOCK_INTERNAL_IS_CALLTYPE_I(_arg) GMOCK_PP_IS_ENCLOSED_PARENS(_arg) - -#define GMOCK_INTERNAL_GET_VALUE_CALLTYPE(_arg) \ - GMOCK_INTERNAL_GET_VALUE_CALLTYPE_I( \ - GMOCK_PP_CAT(GMOCK_INTERNAL_IS_CALLTYPE_HELPER_, _arg)) -#define GMOCK_INTERNAL_GET_VALUE_CALLTYPE_I(_arg) \ - GMOCK_PP_IDENTITY _arg - -#define GMOCK_INTERNAL_IS_CALLTYPE_HELPER_Calltype - -// Note: The use of `identity_t` here allows _Ret to represent return types that -// would normally need to be specified in a different way. For example, a method -// returning a function pointer must be written as -// -// fn_ptr_return_t (*method(method_args_t...))(fn_ptr_args_t...) -// -// But we only support placing the return type at the beginning. To handle this, -// we wrap all calls in identity_t, so that a declaration will be expanded to -// -// identity_t<fn_ptr_return_t (*)(fn_ptr_args_t...)> method(method_args_t...) -// -// This allows us to work around the syntactic oddities of function/method -// types. -#define GMOCK_INTERNAL_SIGNATURE(_Ret, _Args) \ - ::testing::internal::identity_t<GMOCK_PP_IF(GMOCK_PP_IS_BEGIN_PARENS(_Ret), \ - GMOCK_PP_REMOVE_PARENS, \ - GMOCK_PP_IDENTITY)(_Ret)>( \ - GMOCK_PP_FOR_EACH(GMOCK_INTERNAL_GET_TYPE, _, _Args)) - -#define GMOCK_INTERNAL_GET_TYPE(_i, _, _elem) \ - GMOCK_PP_COMMA_IF(_i) \ - GMOCK_PP_IF(GMOCK_PP_IS_BEGIN_PARENS(_elem), GMOCK_PP_REMOVE_PARENS, \ - GMOCK_PP_IDENTITY) \ - (_elem) - -#define GMOCK_INTERNAL_PARAMETER(_i, _Signature, _) \ - GMOCK_PP_COMMA_IF(_i) \ - GMOCK_INTERNAL_ARG_O(_i, GMOCK_PP_REMOVE_PARENS(_Signature)) \ - gmock_a##_i - -#define GMOCK_INTERNAL_FORWARD_ARG(_i, _Signature, _) \ - GMOCK_PP_COMMA_IF(_i) \ - ::std::forward<GMOCK_INTERNAL_ARG_O( \ - _i, GMOCK_PP_REMOVE_PARENS(_Signature))>(gmock_a##_i) - -#define GMOCK_INTERNAL_MATCHER_PARAMETER(_i, _Signature, _) \ - GMOCK_PP_COMMA_IF(_i) \ - GMOCK_INTERNAL_MATCHER_O(_i, GMOCK_PP_REMOVE_PARENS(_Signature)) \ - gmock_a##_i - -#define GMOCK_INTERNAL_MATCHER_ARGUMENT(_i, _1, _2) \ - GMOCK_PP_COMMA_IF(_i) \ - gmock_a##_i - -#define GMOCK_INTERNAL_A_MATCHER_ARGUMENT(_i, _Signature, _) \ - GMOCK_PP_COMMA_IF(_i) \ - ::testing::A<GMOCK_INTERNAL_ARG_O(_i, GMOCK_PP_REMOVE_PARENS(_Signature))>() - -#define GMOCK_INTERNAL_ARG_O(_i, ...) \ - typename ::testing::internal::Function<__VA_ARGS__>::template Arg<_i>::type - -#define GMOCK_INTERNAL_MATCHER_O(_i, ...) \ - const ::testing::Matcher<typename ::testing::internal::Function< \ - __VA_ARGS__>::template Arg<_i>::type>& - -#define MOCK_METHOD0(m, ...) GMOCK_INTERNAL_MOCK_METHODN(, , m, 0, __VA_ARGS__) -#define MOCK_METHOD1(m, ...) GMOCK_INTERNAL_MOCK_METHODN(, , m, 1, __VA_ARGS__) -#define MOCK_METHOD2(m, ...) GMOCK_INTERNAL_MOCK_METHODN(, , m, 2, __VA_ARGS__) -#define MOCK_METHOD3(m, ...) GMOCK_INTERNAL_MOCK_METHODN(, , m, 3, __VA_ARGS__) -#define MOCK_METHOD4(m, ...) GMOCK_INTERNAL_MOCK_METHODN(, , m, 4, __VA_ARGS__) -#define MOCK_METHOD5(m, ...) GMOCK_INTERNAL_MOCK_METHODN(, , m, 5, __VA_ARGS__) -#define MOCK_METHOD6(m, ...) GMOCK_INTERNAL_MOCK_METHODN(, , m, 6, __VA_ARGS__) -#define MOCK_METHOD7(m, ...) GMOCK_INTERNAL_MOCK_METHODN(, , m, 7, __VA_ARGS__) -#define MOCK_METHOD8(m, ...) GMOCK_INTERNAL_MOCK_METHODN(, , m, 8, __VA_ARGS__) -#define MOCK_METHOD9(m, ...) GMOCK_INTERNAL_MOCK_METHODN(, , m, 9, __VA_ARGS__) -#define MOCK_METHOD10(m, ...) \ - GMOCK_INTERNAL_MOCK_METHODN(, , m, 10, __VA_ARGS__) - -#define MOCK_CONST_METHOD0(m, ...) \ - GMOCK_INTERNAL_MOCK_METHODN(const, , m, 0, __VA_ARGS__) -#define MOCK_CONST_METHOD1(m, ...) \ - GMOCK_INTERNAL_MOCK_METHODN(const, , m, 1, __VA_ARGS__) -#define MOCK_CONST_METHOD2(m, ...) \ - GMOCK_INTERNAL_MOCK_METHODN(const, , m, 2, __VA_ARGS__) -#define MOCK_CONST_METHOD3(m, ...) \ - GMOCK_INTERNAL_MOCK_METHODN(const, , m, 3, __VA_ARGS__) -#define MOCK_CONST_METHOD4(m, ...) \ - GMOCK_INTERNAL_MOCK_METHODN(const, , m, 4, __VA_ARGS__) -#define MOCK_CONST_METHOD5(m, ...) \ - GMOCK_INTERNAL_MOCK_METHODN(const, , m, 5, __VA_ARGS__) -#define MOCK_CONST_METHOD6(m, ...) \ - GMOCK_INTERNAL_MOCK_METHODN(const, , m, 6, __VA_ARGS__) -#define MOCK_CONST_METHOD7(m, ...) \ - GMOCK_INTERNAL_MOCK_METHODN(const, , m, 7, __VA_ARGS__) -#define MOCK_CONST_METHOD8(m, ...) \ - GMOCK_INTERNAL_MOCK_METHODN(const, , m, 8, __VA_ARGS__) -#define MOCK_CONST_METHOD9(m, ...) \ - GMOCK_INTERNAL_MOCK_METHODN(const, , m, 9, __VA_ARGS__) -#define MOCK_CONST_METHOD10(m, ...) \ - GMOCK_INTERNAL_MOCK_METHODN(const, , m, 10, __VA_ARGS__) - -#define MOCK_METHOD0_T(m, ...) MOCK_METHOD0(m, __VA_ARGS__) -#define MOCK_METHOD1_T(m, ...) MOCK_METHOD1(m, __VA_ARGS__) -#define MOCK_METHOD2_T(m, ...) MOCK_METHOD2(m, __VA_ARGS__) -#define MOCK_METHOD3_T(m, ...) MOCK_METHOD3(m, __VA_ARGS__) -#define MOCK_METHOD4_T(m, ...) MOCK_METHOD4(m, __VA_ARGS__) -#define MOCK_METHOD5_T(m, ...) MOCK_METHOD5(m, __VA_ARGS__) -#define MOCK_METHOD6_T(m, ...) MOCK_METHOD6(m, __VA_ARGS__) -#define MOCK_METHOD7_T(m, ...) MOCK_METHOD7(m, __VA_ARGS__) -#define MOCK_METHOD8_T(m, ...) MOCK_METHOD8(m, __VA_ARGS__) -#define MOCK_METHOD9_T(m, ...) MOCK_METHOD9(m, __VA_ARGS__) -#define MOCK_METHOD10_T(m, ...) MOCK_METHOD10(m, __VA_ARGS__) - -#define MOCK_CONST_METHOD0_T(m, ...) MOCK_CONST_METHOD0(m, __VA_ARGS__) -#define MOCK_CONST_METHOD1_T(m, ...) MOCK_CONST_METHOD1(m, __VA_ARGS__) -#define MOCK_CONST_METHOD2_T(m, ...) MOCK_CONST_METHOD2(m, __VA_ARGS__) -#define MOCK_CONST_METHOD3_T(m, ...) MOCK_CONST_METHOD3(m, __VA_ARGS__) -#define MOCK_CONST_METHOD4_T(m, ...) MOCK_CONST_METHOD4(m, __VA_ARGS__) -#define MOCK_CONST_METHOD5_T(m, ...) MOCK_CONST_METHOD5(m, __VA_ARGS__) -#define MOCK_CONST_METHOD6_T(m, ...) MOCK_CONST_METHOD6(m, __VA_ARGS__) -#define MOCK_CONST_METHOD7_T(m, ...) MOCK_CONST_METHOD7(m, __VA_ARGS__) -#define MOCK_CONST_METHOD8_T(m, ...) MOCK_CONST_METHOD8(m, __VA_ARGS__) -#define MOCK_CONST_METHOD9_T(m, ...) MOCK_CONST_METHOD9(m, __VA_ARGS__) -#define MOCK_CONST_METHOD10_T(m, ...) MOCK_CONST_METHOD10(m, __VA_ARGS__) - -#define MOCK_METHOD0_WITH_CALLTYPE(ct, m, ...) \ - GMOCK_INTERNAL_MOCK_METHODN(, ct, m, 0, __VA_ARGS__) -#define MOCK_METHOD1_WITH_CALLTYPE(ct, m, ...) \ - GMOCK_INTERNAL_MOCK_METHODN(, ct, m, 1, __VA_ARGS__) -#define MOCK_METHOD2_WITH_CALLTYPE(ct, m, ...) \ - GMOCK_INTERNAL_MOCK_METHODN(, ct, m, 2, __VA_ARGS__) -#define MOCK_METHOD3_WITH_CALLTYPE(ct, m, ...) \ - GMOCK_INTERNAL_MOCK_METHODN(, ct, m, 3, __VA_ARGS__) -#define MOCK_METHOD4_WITH_CALLTYPE(ct, m, ...) \ - GMOCK_INTERNAL_MOCK_METHODN(, ct, m, 4, __VA_ARGS__) -#define MOCK_METHOD5_WITH_CALLTYPE(ct, m, ...) \ - GMOCK_INTERNAL_MOCK_METHODN(, ct, m, 5, __VA_ARGS__) -#define MOCK_METHOD6_WITH_CALLTYPE(ct, m, ...) \ - GMOCK_INTERNAL_MOCK_METHODN(, ct, m, 6, __VA_ARGS__) -#define MOCK_METHOD7_WITH_CALLTYPE(ct, m, ...) \ - GMOCK_INTERNAL_MOCK_METHODN(, ct, m, 7, __VA_ARGS__) -#define MOCK_METHOD8_WITH_CALLTYPE(ct, m, ...) \ - GMOCK_INTERNAL_MOCK_METHODN(, ct, m, 8, __VA_ARGS__) -#define MOCK_METHOD9_WITH_CALLTYPE(ct, m, ...) \ - GMOCK_INTERNAL_MOCK_METHODN(, ct, m, 9, __VA_ARGS__) -#define MOCK_METHOD10_WITH_CALLTYPE(ct, m, ...) \ - GMOCK_INTERNAL_MOCK_METHODN(, ct, m, 10, __VA_ARGS__) - -#define MOCK_CONST_METHOD0_WITH_CALLTYPE(ct, m, ...) \ - GMOCK_INTERNAL_MOCK_METHODN(const, ct, m, 0, __VA_ARGS__) -#define MOCK_CONST_METHOD1_WITH_CALLTYPE(ct, m, ...) \ - GMOCK_INTERNAL_MOCK_METHODN(const, ct, m, 1, __VA_ARGS__) -#define MOCK_CONST_METHOD2_WITH_CALLTYPE(ct, m, ...) \ - GMOCK_INTERNAL_MOCK_METHODN(const, ct, m, 2, __VA_ARGS__) -#define MOCK_CONST_METHOD3_WITH_CALLTYPE(ct, m, ...) \ - GMOCK_INTERNAL_MOCK_METHODN(const, ct, m, 3, __VA_ARGS__) -#define MOCK_CONST_METHOD4_WITH_CALLTYPE(ct, m, ...) \ - GMOCK_INTERNAL_MOCK_METHODN(const, ct, m, 4, __VA_ARGS__) -#define MOCK_CONST_METHOD5_WITH_CALLTYPE(ct, m, ...) \ - GMOCK_INTERNAL_MOCK_METHODN(const, ct, m, 5, __VA_ARGS__) -#define MOCK_CONST_METHOD6_WITH_CALLTYPE(ct, m, ...) \ - GMOCK_INTERNAL_MOCK_METHODN(const, ct, m, 6, __VA_ARGS__) -#define MOCK_CONST_METHOD7_WITH_CALLTYPE(ct, m, ...) \ - GMOCK_INTERNAL_MOCK_METHODN(const, ct, m, 7, __VA_ARGS__) -#define MOCK_CONST_METHOD8_WITH_CALLTYPE(ct, m, ...) \ - GMOCK_INTERNAL_MOCK_METHODN(const, ct, m, 8, __VA_ARGS__) -#define MOCK_CONST_METHOD9_WITH_CALLTYPE(ct, m, ...) \ - GMOCK_INTERNAL_MOCK_METHODN(const, ct, m, 9, __VA_ARGS__) -#define MOCK_CONST_METHOD10_WITH_CALLTYPE(ct, m, ...) \ - GMOCK_INTERNAL_MOCK_METHODN(const, ct, m, 10, __VA_ARGS__) - -#define MOCK_METHOD0_T_WITH_CALLTYPE(ct, m, ...) \ - MOCK_METHOD0_WITH_CALLTYPE(ct, m, __VA_ARGS__) -#define MOCK_METHOD1_T_WITH_CALLTYPE(ct, m, ...) \ - MOCK_METHOD1_WITH_CALLTYPE(ct, m, __VA_ARGS__) -#define MOCK_METHOD2_T_WITH_CALLTYPE(ct, m, ...) \ - MOCK_METHOD2_WITH_CALLTYPE(ct, m, __VA_ARGS__) -#define MOCK_METHOD3_T_WITH_CALLTYPE(ct, m, ...) \ - MOCK_METHOD3_WITH_CALLTYPE(ct, m, __VA_ARGS__) -#define MOCK_METHOD4_T_WITH_CALLTYPE(ct, m, ...) \ - MOCK_METHOD4_WITH_CALLTYPE(ct, m, __VA_ARGS__) -#define MOCK_METHOD5_T_WITH_CALLTYPE(ct, m, ...) \ - MOCK_METHOD5_WITH_CALLTYPE(ct, m, __VA_ARGS__) -#define MOCK_METHOD6_T_WITH_CALLTYPE(ct, m, ...) \ - MOCK_METHOD6_WITH_CALLTYPE(ct, m, __VA_ARGS__) -#define MOCK_METHOD7_T_WITH_CALLTYPE(ct, m, ...) \ - MOCK_METHOD7_WITH_CALLTYPE(ct, m, __VA_ARGS__) -#define MOCK_METHOD8_T_WITH_CALLTYPE(ct, m, ...) \ - MOCK_METHOD8_WITH_CALLTYPE(ct, m, __VA_ARGS__) -#define MOCK_METHOD9_T_WITH_CALLTYPE(ct, m, ...) \ - MOCK_METHOD9_WITH_CALLTYPE(ct, m, __VA_ARGS__) -#define MOCK_METHOD10_T_WITH_CALLTYPE(ct, m, ...) \ - MOCK_METHOD10_WITH_CALLTYPE(ct, m, __VA_ARGS__) - -#define MOCK_CONST_METHOD0_T_WITH_CALLTYPE(ct, m, ...) \ - MOCK_CONST_METHOD0_WITH_CALLTYPE(ct, m, __VA_ARGS__) -#define MOCK_CONST_METHOD1_T_WITH_CALLTYPE(ct, m, ...) \ - MOCK_CONST_METHOD1_WITH_CALLTYPE(ct, m, __VA_ARGS__) -#define MOCK_CONST_METHOD2_T_WITH_CALLTYPE(ct, m, ...) \ - MOCK_CONST_METHOD2_WITH_CALLTYPE(ct, m, __VA_ARGS__) -#define MOCK_CONST_METHOD3_T_WITH_CALLTYPE(ct, m, ...) \ - MOCK_CONST_METHOD3_WITH_CALLTYPE(ct, m, __VA_ARGS__) -#define MOCK_CONST_METHOD4_T_WITH_CALLTYPE(ct, m, ...) \ - MOCK_CONST_METHOD4_WITH_CALLTYPE(ct, m, __VA_ARGS__) -#define MOCK_CONST_METHOD5_T_WITH_CALLTYPE(ct, m, ...) \ - MOCK_CONST_METHOD5_WITH_CALLTYPE(ct, m, __VA_ARGS__) -#define MOCK_CONST_METHOD6_T_WITH_CALLTYPE(ct, m, ...) \ - MOCK_CONST_METHOD6_WITH_CALLTYPE(ct, m, __VA_ARGS__) -#define MOCK_CONST_METHOD7_T_WITH_CALLTYPE(ct, m, ...) \ - MOCK_CONST_METHOD7_WITH_CALLTYPE(ct, m, __VA_ARGS__) -#define MOCK_CONST_METHOD8_T_WITH_CALLTYPE(ct, m, ...) \ - MOCK_CONST_METHOD8_WITH_CALLTYPE(ct, m, __VA_ARGS__) -#define MOCK_CONST_METHOD9_T_WITH_CALLTYPE(ct, m, ...) \ - MOCK_CONST_METHOD9_WITH_CALLTYPE(ct, m, __VA_ARGS__) -#define MOCK_CONST_METHOD10_T_WITH_CALLTYPE(ct, m, ...) \ - MOCK_CONST_METHOD10_WITH_CALLTYPE(ct, m, __VA_ARGS__) - -#define GMOCK_INTERNAL_MOCK_METHODN(constness, ct, Method, args_num, ...) \ - GMOCK_INTERNAL_ASSERT_VALID_SIGNATURE( \ - args_num, ::testing::internal::identity_t<__VA_ARGS__>); \ - GMOCK_INTERNAL_MOCK_METHOD_IMPL( \ - args_num, Method, GMOCK_PP_NARG0(constness), 0, 0, , ct, , \ - (::testing::internal::identity_t<__VA_ARGS__>)) - -#define GMOCK_MOCKER_(arity, constness, Method) \ - GTEST_CONCAT_TOKEN_(gmock##constness##arity##_##Method##_, __LINE__) - -#endif // GOOGLEMOCK_INCLUDE_GMOCK_INTERNAL_GMOCK_FUNCTION_MOCKER_H_ -// Copyright 2007, 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. - - -// Google Mock - a framework for writing C++ mock classes. -// -// This file implements some commonly used variadic actions. - -// GOOGLETEST_CM0002 DO NOT DELETE - -#ifndef GOOGLEMOCK_INCLUDE_GMOCK_GMOCK_MORE_ACTIONS_H_ -#define GOOGLEMOCK_INCLUDE_GMOCK_GMOCK_MORE_ACTIONS_H_ - -#include <memory> -#include <utility> - - -// Include any custom callback actions added by the local installation. -// GOOGLETEST_CM0002 DO NOT DELETE - -#ifndef GOOGLEMOCK_INCLUDE_GMOCK_INTERNAL_CUSTOM_GMOCK_GENERATED_ACTIONS_H_ -#define GOOGLEMOCK_INCLUDE_GMOCK_INTERNAL_CUSTOM_GMOCK_GENERATED_ACTIONS_H_ - -#endif // GOOGLEMOCK_INCLUDE_GMOCK_INTERNAL_CUSTOM_GMOCK_GENERATED_ACTIONS_H_ - -// Sometimes you want to give an action explicit template parameters -// that cannot be inferred from its value parameters. ACTION() and -// ACTION_P*() don't support that. ACTION_TEMPLATE() remedies that -// and can be viewed as an extension to ACTION() and ACTION_P*(). -// -// The syntax: -// -// ACTION_TEMPLATE(ActionName, -// HAS_m_TEMPLATE_PARAMS(kind1, name1, ..., kind_m, name_m), -// AND_n_VALUE_PARAMS(p1, ..., p_n)) { statements; } -// -// defines an action template that takes m explicit template -// parameters and n value parameters. name_i is the name of the i-th -// template parameter, and kind_i specifies whether it's a typename, -// an integral constant, or a template. p_i is the name of the i-th -// value parameter. -// -// Example: -// -// // DuplicateArg<k, T>(output) converts the k-th argument of the mock -// // function to type T and copies it to *output. -// ACTION_TEMPLATE(DuplicateArg, -// HAS_2_TEMPLATE_PARAMS(int, k, typename, T), -// AND_1_VALUE_PARAMS(output)) { -// *output = T(::std::get<k>(args)); -// } -// ... -// int n; -// EXPECT_CALL(mock, Foo(_, _)) -// .WillOnce(DuplicateArg<1, unsigned char>(&n)); -// -// To create an instance of an action template, write: -// -// ActionName<t1, ..., t_m>(v1, ..., v_n) -// -// where the ts are the template arguments and the vs are the value -// arguments. The value argument types are inferred by the compiler. -// If you want to explicitly specify the value argument types, you can -// provide additional template arguments: -// -// ActionName<t1, ..., t_m, u1, ..., u_k>(v1, ..., v_n) -// -// where u_i is the desired type of v_i. -// -// ACTION_TEMPLATE and ACTION/ACTION_P* can be overloaded on the -// number of value parameters, but not on the number of template -// parameters. Without the restriction, the meaning of the following -// is unclear: -// -// OverloadedAction<int, bool>(x); -// -// Are we using a single-template-parameter action where 'bool' refers -// to the type of x, or are we using a two-template-parameter action -// where the compiler is asked to infer the type of x? -// -// Implementation notes: -// -// GMOCK_INTERNAL_*_HAS_m_TEMPLATE_PARAMS and -// GMOCK_INTERNAL_*_AND_n_VALUE_PARAMS are internal macros for -// implementing ACTION_TEMPLATE. The main trick we use is to create -// new macro invocations when expanding a macro. For example, we have -// -// #define ACTION_TEMPLATE(name, template_params, value_params) -// ... GMOCK_INTERNAL_DECL_##template_params ... -// -// which causes ACTION_TEMPLATE(..., HAS_1_TEMPLATE_PARAMS(typename, T), ...) -// to expand to -// -// ... GMOCK_INTERNAL_DECL_HAS_1_TEMPLATE_PARAMS(typename, T) ... -// -// Since GMOCK_INTERNAL_DECL_HAS_1_TEMPLATE_PARAMS is a macro, the -// preprocessor will continue to expand it to -// -// ... typename T ... -// -// This technique conforms to the C++ standard and is portable. It -// allows us to implement action templates using O(N) code, where N is -// the maximum number of template/value parameters supported. Without -// using it, we'd have to devote O(N^2) amount of code to implement all -// combinations of m and n. - -// Declares the template parameters. -#define GMOCK_INTERNAL_DECL_HAS_1_TEMPLATE_PARAMS(kind0, name0) kind0 name0 -#define GMOCK_INTERNAL_DECL_HAS_2_TEMPLATE_PARAMS(kind0, name0, kind1, \ - name1) kind0 name0, kind1 name1 -#define GMOCK_INTERNAL_DECL_HAS_3_TEMPLATE_PARAMS(kind0, name0, kind1, name1, \ - kind2, name2) kind0 name0, kind1 name1, kind2 name2 -#define GMOCK_INTERNAL_DECL_HAS_4_TEMPLATE_PARAMS(kind0, name0, kind1, name1, \ - kind2, name2, kind3, name3) kind0 name0, kind1 name1, kind2 name2, \ - kind3 name3 -#define GMOCK_INTERNAL_DECL_HAS_5_TEMPLATE_PARAMS(kind0, name0, kind1, name1, \ - kind2, name2, kind3, name3, kind4, name4) kind0 name0, kind1 name1, \ - kind2 name2, kind3 name3, kind4 name4 -#define GMOCK_INTERNAL_DECL_HAS_6_TEMPLATE_PARAMS(kind0, name0, kind1, name1, \ - kind2, name2, kind3, name3, kind4, name4, kind5, name5) kind0 name0, \ - kind1 name1, kind2 name2, kind3 name3, kind4 name4, kind5 name5 -#define GMOCK_INTERNAL_DECL_HAS_7_TEMPLATE_PARAMS(kind0, name0, kind1, name1, \ - kind2, name2, kind3, name3, kind4, name4, kind5, name5, kind6, \ - name6) kind0 name0, kind1 name1, kind2 name2, kind3 name3, kind4 name4, \ - kind5 name5, kind6 name6 -#define GMOCK_INTERNAL_DECL_HAS_8_TEMPLATE_PARAMS(kind0, name0, kind1, name1, \ - kind2, name2, kind3, name3, kind4, name4, kind5, name5, kind6, name6, \ - kind7, name7) kind0 name0, kind1 name1, kind2 name2, kind3 name3, \ - kind4 name4, kind5 name5, kind6 name6, kind7 name7 -#define GMOCK_INTERNAL_DECL_HAS_9_TEMPLATE_PARAMS(kind0, name0, kind1, name1, \ - kind2, name2, kind3, name3, kind4, name4, kind5, name5, kind6, name6, \ - kind7, name7, kind8, name8) kind0 name0, kind1 name1, kind2 name2, \ - kind3 name3, kind4 name4, kind5 name5, kind6 name6, kind7 name7, \ - kind8 name8 -#define GMOCK_INTERNAL_DECL_HAS_10_TEMPLATE_PARAMS(kind0, name0, kind1, \ - name1, kind2, name2, kind3, name3, kind4, name4, kind5, name5, kind6, \ - name6, kind7, name7, kind8, name8, kind9, name9) kind0 name0, \ - kind1 name1, kind2 name2, kind3 name3, kind4 name4, kind5 name5, \ - kind6 name6, kind7 name7, kind8 name8, kind9 name9 - -// Lists the template parameters. -#define GMOCK_INTERNAL_LIST_HAS_1_TEMPLATE_PARAMS(kind0, name0) name0 -#define GMOCK_INTERNAL_LIST_HAS_2_TEMPLATE_PARAMS(kind0, name0, kind1, \ - name1) name0, name1 -#define GMOCK_INTERNAL_LIST_HAS_3_TEMPLATE_PARAMS(kind0, name0, kind1, name1, \ - kind2, name2) name0, name1, name2 -#define GMOCK_INTERNAL_LIST_HAS_4_TEMPLATE_PARAMS(kind0, name0, kind1, name1, \ - kind2, name2, kind3, name3) name0, name1, name2, name3 -#define GMOCK_INTERNAL_LIST_HAS_5_TEMPLATE_PARAMS(kind0, name0, kind1, name1, \ - kind2, name2, kind3, name3, kind4, name4) name0, name1, name2, name3, \ - name4 -#define GMOCK_INTERNAL_LIST_HAS_6_TEMPLATE_PARAMS(kind0, name0, kind1, name1, \ - kind2, name2, kind3, name3, kind4, name4, kind5, name5) name0, name1, \ - name2, name3, name4, name5 -#define GMOCK_INTERNAL_LIST_HAS_7_TEMPLATE_PARAMS(kind0, name0, kind1, name1, \ - kind2, name2, kind3, name3, kind4, name4, kind5, name5, kind6, \ - name6) name0, name1, name2, name3, name4, name5, name6 -#define GMOCK_INTERNAL_LIST_HAS_8_TEMPLATE_PARAMS(kind0, name0, kind1, name1, \ - kind2, name2, kind3, name3, kind4, name4, kind5, name5, kind6, name6, \ - kind7, name7) name0, name1, name2, name3, name4, name5, name6, name7 -#define GMOCK_INTERNAL_LIST_HAS_9_TEMPLATE_PARAMS(kind0, name0, kind1, name1, \ - kind2, name2, kind3, name3, kind4, name4, kind5, name5, kind6, name6, \ - kind7, name7, kind8, name8) name0, name1, name2, name3, name4, name5, \ - name6, name7, name8 -#define GMOCK_INTERNAL_LIST_HAS_10_TEMPLATE_PARAMS(kind0, name0, kind1, \ - name1, kind2, name2, kind3, name3, kind4, name4, kind5, name5, kind6, \ - name6, kind7, name7, kind8, name8, kind9, name9) name0, name1, name2, \ - name3, name4, name5, name6, name7, name8, name9 - -// Declares the types of value parameters. -#define GMOCK_INTERNAL_DECL_TYPE_AND_0_VALUE_PARAMS() -#define GMOCK_INTERNAL_DECL_TYPE_AND_1_VALUE_PARAMS(p0) , typename p0##_type -#define GMOCK_INTERNAL_DECL_TYPE_AND_2_VALUE_PARAMS(p0, p1) , \ - typename p0##_type, typename p1##_type -#define GMOCK_INTERNAL_DECL_TYPE_AND_3_VALUE_PARAMS(p0, p1, p2) , \ - typename p0##_type, typename p1##_type, typename p2##_type -#define GMOCK_INTERNAL_DECL_TYPE_AND_4_VALUE_PARAMS(p0, p1, p2, p3) , \ - typename p0##_type, typename p1##_type, typename p2##_type, \ - typename p3##_type -#define GMOCK_INTERNAL_DECL_TYPE_AND_5_VALUE_PARAMS(p0, p1, p2, p3, p4) , \ - typename p0##_type, typename p1##_type, typename p2##_type, \ - typename p3##_type, typename p4##_type -#define GMOCK_INTERNAL_DECL_TYPE_AND_6_VALUE_PARAMS(p0, p1, p2, p3, p4, p5) , \ - typename p0##_type, typename p1##_type, typename p2##_type, \ - typename p3##_type, typename p4##_type, typename p5##_type -#define GMOCK_INTERNAL_DECL_TYPE_AND_7_VALUE_PARAMS(p0, p1, p2, p3, p4, p5, \ - p6) , typename p0##_type, typename p1##_type, typename p2##_type, \ - typename p3##_type, typename p4##_type, typename p5##_type, \ - typename p6##_type -#define GMOCK_INTERNAL_DECL_TYPE_AND_8_VALUE_PARAMS(p0, p1, p2, p3, p4, p5, \ - p6, p7) , typename p0##_type, typename p1##_type, typename p2##_type, \ - typename p3##_type, typename p4##_type, typename p5##_type, \ - typename p6##_type, typename p7##_type -#define GMOCK_INTERNAL_DECL_TYPE_AND_9_VALUE_PARAMS(p0, p1, p2, p3, p4, p5, \ - p6, p7, p8) , typename p0##_type, typename p1##_type, typename p2##_type, \ - typename p3##_type, typename p4##_type, typename p5##_type, \ - typename p6##_type, typename p7##_type, typename p8##_type -#define GMOCK_INTERNAL_DECL_TYPE_AND_10_VALUE_PARAMS(p0, p1, p2, p3, p4, p5, \ - p6, p7, p8, p9) , typename p0##_type, typename p1##_type, \ - typename p2##_type, typename p3##_type, typename p4##_type, \ - typename p5##_type, typename p6##_type, typename p7##_type, \ - typename p8##_type, typename p9##_type - -// Initializes the value parameters. -#define GMOCK_INTERNAL_INIT_AND_0_VALUE_PARAMS()\ - () -#define GMOCK_INTERNAL_INIT_AND_1_VALUE_PARAMS(p0)\ - (p0##_type gmock_p0) : p0(::std::move(gmock_p0)) -#define GMOCK_INTERNAL_INIT_AND_2_VALUE_PARAMS(p0, p1)\ - (p0##_type gmock_p0, p1##_type gmock_p1) : p0(::std::move(gmock_p0)), \ - p1(::std::move(gmock_p1)) -#define GMOCK_INTERNAL_INIT_AND_3_VALUE_PARAMS(p0, p1, p2)\ - (p0##_type gmock_p0, p1##_type gmock_p1, \ - p2##_type gmock_p2) : p0(::std::move(gmock_p0)), \ - p1(::std::move(gmock_p1)), p2(::std::move(gmock_p2)) -#define GMOCK_INTERNAL_INIT_AND_4_VALUE_PARAMS(p0, p1, p2, p3)\ - (p0##_type gmock_p0, p1##_type gmock_p1, p2##_type gmock_p2, \ - p3##_type gmock_p3) : p0(::std::move(gmock_p0)), \ - p1(::std::move(gmock_p1)), p2(::std::move(gmock_p2)), \ - p3(::std::move(gmock_p3)) -#define GMOCK_INTERNAL_INIT_AND_5_VALUE_PARAMS(p0, p1, p2, p3, p4)\ - (p0##_type gmock_p0, p1##_type gmock_p1, p2##_type gmock_p2, \ - p3##_type gmock_p3, p4##_type gmock_p4) : p0(::std::move(gmock_p0)), \ - p1(::std::move(gmock_p1)), p2(::std::move(gmock_p2)), \ - p3(::std::move(gmock_p3)), p4(::std::move(gmock_p4)) -#define GMOCK_INTERNAL_INIT_AND_6_VALUE_PARAMS(p0, p1, p2, p3, p4, p5)\ - (p0##_type gmock_p0, p1##_type gmock_p1, p2##_type gmock_p2, \ - p3##_type gmock_p3, p4##_type gmock_p4, \ - p5##_type gmock_p5) : p0(::std::move(gmock_p0)), \ - p1(::std::move(gmock_p1)), p2(::std::move(gmock_p2)), \ - p3(::std::move(gmock_p3)), p4(::std::move(gmock_p4)), \ - p5(::std::move(gmock_p5)) -#define GMOCK_INTERNAL_INIT_AND_7_VALUE_PARAMS(p0, p1, p2, p3, p4, p5, p6)\ - (p0##_type gmock_p0, p1##_type gmock_p1, p2##_type gmock_p2, \ - p3##_type gmock_p3, p4##_type gmock_p4, p5##_type gmock_p5, \ - p6##_type gmock_p6) : p0(::std::move(gmock_p0)), \ - p1(::std::move(gmock_p1)), p2(::std::move(gmock_p2)), \ - p3(::std::move(gmock_p3)), p4(::std::move(gmock_p4)), \ - p5(::std::move(gmock_p5)), p6(::std::move(gmock_p6)) -#define GMOCK_INTERNAL_INIT_AND_8_VALUE_PARAMS(p0, p1, p2, p3, p4, p5, p6, p7)\ - (p0##_type gmock_p0, p1##_type gmock_p1, p2##_type gmock_p2, \ - p3##_type gmock_p3, p4##_type gmock_p4, p5##_type gmock_p5, \ - p6##_type gmock_p6, p7##_type gmock_p7) : p0(::std::move(gmock_p0)), \ - p1(::std::move(gmock_p1)), p2(::std::move(gmock_p2)), \ - p3(::std::move(gmock_p3)), p4(::std::move(gmock_p4)), \ - p5(::std::move(gmock_p5)), p6(::std::move(gmock_p6)), \ - p7(::std::move(gmock_p7)) -#define GMOCK_INTERNAL_INIT_AND_9_VALUE_PARAMS(p0, p1, p2, p3, p4, p5, p6, \ - p7, p8)\ - (p0##_type gmock_p0, p1##_type gmock_p1, p2##_type gmock_p2, \ - p3##_type gmock_p3, p4##_type gmock_p4, p5##_type gmock_p5, \ - p6##_type gmock_p6, p7##_type gmock_p7, \ - p8##_type gmock_p8) : p0(::std::move(gmock_p0)), \ - p1(::std::move(gmock_p1)), p2(::std::move(gmock_p2)), \ - p3(::std::move(gmock_p3)), p4(::std::move(gmock_p4)), \ - p5(::std::move(gmock_p5)), p6(::std::move(gmock_p6)), \ - p7(::std::move(gmock_p7)), p8(::std::move(gmock_p8)) -#define GMOCK_INTERNAL_INIT_AND_10_VALUE_PARAMS(p0, p1, p2, p3, p4, p5, p6, \ - p7, p8, p9)\ - (p0##_type gmock_p0, p1##_type gmock_p1, p2##_type gmock_p2, \ - p3##_type gmock_p3, p4##_type gmock_p4, p5##_type gmock_p5, \ - p6##_type gmock_p6, p7##_type gmock_p7, p8##_type gmock_p8, \ - p9##_type gmock_p9) : p0(::std::move(gmock_p0)), \ - p1(::std::move(gmock_p1)), p2(::std::move(gmock_p2)), \ - p3(::std::move(gmock_p3)), p4(::std::move(gmock_p4)), \ - p5(::std::move(gmock_p5)), p6(::std::move(gmock_p6)), \ - p7(::std::move(gmock_p7)), p8(::std::move(gmock_p8)), \ - p9(::std::move(gmock_p9)) - -// Defines the copy constructor -#define GMOCK_INTERNAL_DEFN_COPY_AND_0_VALUE_PARAMS() \ - {} // Avoid https://gcc.gnu.org/bugzilla/show_bug.cgi?id=82134 -#define GMOCK_INTERNAL_DEFN_COPY_AND_1_VALUE_PARAMS(...) = default; -#define GMOCK_INTERNAL_DEFN_COPY_AND_2_VALUE_PARAMS(...) = default; -#define GMOCK_INTERNAL_DEFN_COPY_AND_3_VALUE_PARAMS(...) = default; -#define GMOCK_INTERNAL_DEFN_COPY_AND_4_VALUE_PARAMS(...) = default; -#define GMOCK_INTERNAL_DEFN_COPY_AND_5_VALUE_PARAMS(...) = default; -#define GMOCK_INTERNAL_DEFN_COPY_AND_6_VALUE_PARAMS(...) = default; -#define GMOCK_INTERNAL_DEFN_COPY_AND_7_VALUE_PARAMS(...) = default; -#define GMOCK_INTERNAL_DEFN_COPY_AND_8_VALUE_PARAMS(...) = default; -#define GMOCK_INTERNAL_DEFN_COPY_AND_9_VALUE_PARAMS(...) = default; -#define GMOCK_INTERNAL_DEFN_COPY_AND_10_VALUE_PARAMS(...) = default; - -// Declares the fields for storing the value parameters. -#define GMOCK_INTERNAL_DEFN_AND_0_VALUE_PARAMS() -#define GMOCK_INTERNAL_DEFN_AND_1_VALUE_PARAMS(p0) p0##_type p0; -#define GMOCK_INTERNAL_DEFN_AND_2_VALUE_PARAMS(p0, p1) p0##_type p0; \ - p1##_type p1; -#define GMOCK_INTERNAL_DEFN_AND_3_VALUE_PARAMS(p0, p1, p2) p0##_type p0; \ - p1##_type p1; p2##_type p2; -#define GMOCK_INTERNAL_DEFN_AND_4_VALUE_PARAMS(p0, p1, p2, p3) p0##_type p0; \ - p1##_type p1; p2##_type p2; p3##_type p3; -#define GMOCK_INTERNAL_DEFN_AND_5_VALUE_PARAMS(p0, p1, p2, p3, \ - p4) p0##_type p0; p1##_type p1; p2##_type p2; p3##_type p3; p4##_type p4; -#define GMOCK_INTERNAL_DEFN_AND_6_VALUE_PARAMS(p0, p1, p2, p3, p4, \ - p5) p0##_type p0; p1##_type p1; p2##_type p2; p3##_type p3; p4##_type p4; \ - p5##_type p5; -#define GMOCK_INTERNAL_DEFN_AND_7_VALUE_PARAMS(p0, p1, p2, p3, p4, p5, \ - p6) p0##_type p0; p1##_type p1; p2##_type p2; p3##_type p3; p4##_type p4; \ - p5##_type p5; p6##_type p6; -#define GMOCK_INTERNAL_DEFN_AND_8_VALUE_PARAMS(p0, p1, p2, p3, p4, p5, p6, \ - p7) p0##_type p0; p1##_type p1; p2##_type p2; p3##_type p3; p4##_type p4; \ - p5##_type p5; p6##_type p6; p7##_type p7; -#define GMOCK_INTERNAL_DEFN_AND_9_VALUE_PARAMS(p0, p1, p2, p3, p4, p5, p6, \ - p7, p8) p0##_type p0; p1##_type p1; p2##_type p2; p3##_type p3; \ - p4##_type p4; p5##_type p5; p6##_type p6; p7##_type p7; p8##_type p8; -#define GMOCK_INTERNAL_DEFN_AND_10_VALUE_PARAMS(p0, p1, p2, p3, p4, p5, p6, \ - p7, p8, p9) p0##_type p0; p1##_type p1; p2##_type p2; p3##_type p3; \ - p4##_type p4; p5##_type p5; p6##_type p6; p7##_type p7; p8##_type p8; \ - p9##_type p9; - -// Lists the value parameters. -#define GMOCK_INTERNAL_LIST_AND_0_VALUE_PARAMS() -#define GMOCK_INTERNAL_LIST_AND_1_VALUE_PARAMS(p0) p0 -#define GMOCK_INTERNAL_LIST_AND_2_VALUE_PARAMS(p0, p1) p0, p1 -#define GMOCK_INTERNAL_LIST_AND_3_VALUE_PARAMS(p0, p1, p2) p0, p1, p2 -#define GMOCK_INTERNAL_LIST_AND_4_VALUE_PARAMS(p0, p1, p2, p3) p0, p1, p2, p3 -#define GMOCK_INTERNAL_LIST_AND_5_VALUE_PARAMS(p0, p1, p2, p3, p4) p0, p1, \ - p2, p3, p4 -#define GMOCK_INTERNAL_LIST_AND_6_VALUE_PARAMS(p0, p1, p2, p3, p4, p5) p0, \ - p1, p2, p3, p4, p5 -#define GMOCK_INTERNAL_LIST_AND_7_VALUE_PARAMS(p0, p1, p2, p3, p4, p5, \ - p6) p0, p1, p2, p3, p4, p5, p6 -#define GMOCK_INTERNAL_LIST_AND_8_VALUE_PARAMS(p0, p1, p2, p3, p4, p5, p6, \ - p7) p0, p1, p2, p3, p4, p5, p6, p7 -#define GMOCK_INTERNAL_LIST_AND_9_VALUE_PARAMS(p0, p1, p2, p3, p4, p5, p6, \ - p7, p8) p0, p1, p2, p3, p4, p5, p6, p7, p8 -#define GMOCK_INTERNAL_LIST_AND_10_VALUE_PARAMS(p0, p1, p2, p3, p4, p5, p6, \ - p7, p8, p9) p0, p1, p2, p3, p4, p5, p6, p7, p8, p9 - -// Lists the value parameter types. -#define GMOCK_INTERNAL_LIST_TYPE_AND_0_VALUE_PARAMS() -#define GMOCK_INTERNAL_LIST_TYPE_AND_1_VALUE_PARAMS(p0) , p0##_type -#define GMOCK_INTERNAL_LIST_TYPE_AND_2_VALUE_PARAMS(p0, p1) , p0##_type, \ - p1##_type -#define GMOCK_INTERNAL_LIST_TYPE_AND_3_VALUE_PARAMS(p0, p1, p2) , p0##_type, \ - p1##_type, p2##_type -#define GMOCK_INTERNAL_LIST_TYPE_AND_4_VALUE_PARAMS(p0, p1, p2, p3) , \ - p0##_type, p1##_type, p2##_type, p3##_type -#define GMOCK_INTERNAL_LIST_TYPE_AND_5_VALUE_PARAMS(p0, p1, p2, p3, p4) , \ - p0##_type, p1##_type, p2##_type, p3##_type, p4##_type -#define GMOCK_INTERNAL_LIST_TYPE_AND_6_VALUE_PARAMS(p0, p1, p2, p3, p4, p5) , \ - p0##_type, p1##_type, p2##_type, p3##_type, p4##_type, p5##_type -#define GMOCK_INTERNAL_LIST_TYPE_AND_7_VALUE_PARAMS(p0, p1, p2, p3, p4, p5, \ - p6) , p0##_type, p1##_type, p2##_type, p3##_type, p4##_type, p5##_type, \ - p6##_type -#define GMOCK_INTERNAL_LIST_TYPE_AND_8_VALUE_PARAMS(p0, p1, p2, p3, p4, p5, \ - p6, p7) , p0##_type, p1##_type, p2##_type, p3##_type, p4##_type, \ - p5##_type, p6##_type, p7##_type -#define GMOCK_INTERNAL_LIST_TYPE_AND_9_VALUE_PARAMS(p0, p1, p2, p3, p4, p5, \ - p6, p7, p8) , p0##_type, p1##_type, p2##_type, p3##_type, p4##_type, \ - p5##_type, p6##_type, p7##_type, p8##_type -#define GMOCK_INTERNAL_LIST_TYPE_AND_10_VALUE_PARAMS(p0, p1, p2, p3, p4, p5, \ - p6, p7, p8, p9) , p0##_type, p1##_type, p2##_type, p3##_type, p4##_type, \ - p5##_type, p6##_type, p7##_type, p8##_type, p9##_type - -// Declares the value parameters. -#define GMOCK_INTERNAL_DECL_AND_0_VALUE_PARAMS() -#define GMOCK_INTERNAL_DECL_AND_1_VALUE_PARAMS(p0) p0##_type p0 -#define GMOCK_INTERNAL_DECL_AND_2_VALUE_PARAMS(p0, p1) p0##_type p0, \ - p1##_type p1 -#define GMOCK_INTERNAL_DECL_AND_3_VALUE_PARAMS(p0, p1, p2) p0##_type p0, \ - p1##_type p1, p2##_type p2 -#define GMOCK_INTERNAL_DECL_AND_4_VALUE_PARAMS(p0, p1, p2, p3) p0##_type p0, \ - p1##_type p1, p2##_type p2, p3##_type p3 -#define GMOCK_INTERNAL_DECL_AND_5_VALUE_PARAMS(p0, p1, p2, p3, \ - p4) p0##_type p0, p1##_type p1, p2##_type p2, p3##_type p3, p4##_type p4 -#define GMOCK_INTERNAL_DECL_AND_6_VALUE_PARAMS(p0, p1, p2, p3, p4, \ - p5) p0##_type p0, p1##_type p1, p2##_type p2, p3##_type p3, p4##_type p4, \ - p5##_type p5 -#define GMOCK_INTERNAL_DECL_AND_7_VALUE_PARAMS(p0, p1, p2, p3, p4, p5, \ - p6) p0##_type p0, p1##_type p1, p2##_type p2, p3##_type p3, p4##_type p4, \ - p5##_type p5, p6##_type p6 -#define GMOCK_INTERNAL_DECL_AND_8_VALUE_PARAMS(p0, p1, p2, p3, p4, p5, p6, \ - p7) p0##_type p0, p1##_type p1, p2##_type p2, p3##_type p3, p4##_type p4, \ - p5##_type p5, p6##_type p6, p7##_type p7 -#define GMOCK_INTERNAL_DECL_AND_9_VALUE_PARAMS(p0, p1, p2, p3, p4, p5, p6, \ - p7, p8) p0##_type p0, p1##_type p1, p2##_type p2, p3##_type p3, \ - p4##_type p4, p5##_type p5, p6##_type p6, p7##_type p7, p8##_type p8 -#define GMOCK_INTERNAL_DECL_AND_10_VALUE_PARAMS(p0, p1, p2, p3, p4, p5, p6, \ - p7, p8, p9) p0##_type p0, p1##_type p1, p2##_type p2, p3##_type p3, \ - p4##_type p4, p5##_type p5, p6##_type p6, p7##_type p7, p8##_type p8, \ - p9##_type p9 - -// The suffix of the class template implementing the action template. -#define GMOCK_INTERNAL_COUNT_AND_0_VALUE_PARAMS() -#define GMOCK_INTERNAL_COUNT_AND_1_VALUE_PARAMS(p0) P -#define GMOCK_INTERNAL_COUNT_AND_2_VALUE_PARAMS(p0, p1) P2 -#define GMOCK_INTERNAL_COUNT_AND_3_VALUE_PARAMS(p0, p1, p2) P3 -#define GMOCK_INTERNAL_COUNT_AND_4_VALUE_PARAMS(p0, p1, p2, p3) P4 -#define GMOCK_INTERNAL_COUNT_AND_5_VALUE_PARAMS(p0, p1, p2, p3, p4) P5 -#define GMOCK_INTERNAL_COUNT_AND_6_VALUE_PARAMS(p0, p1, p2, p3, p4, p5) P6 -#define GMOCK_INTERNAL_COUNT_AND_7_VALUE_PARAMS(p0, p1, p2, p3, p4, p5, p6) P7 -#define GMOCK_INTERNAL_COUNT_AND_8_VALUE_PARAMS(p0, p1, p2, p3, p4, p5, p6, \ - p7) P8 -#define GMOCK_INTERNAL_COUNT_AND_9_VALUE_PARAMS(p0, p1, p2, p3, p4, p5, p6, \ - p7, p8) P9 -#define GMOCK_INTERNAL_COUNT_AND_10_VALUE_PARAMS(p0, p1, p2, p3, p4, p5, p6, \ - p7, p8, p9) P10 - -// The name of the class template implementing the action template. -#define GMOCK_ACTION_CLASS_(name, value_params)\ - GTEST_CONCAT_TOKEN_(name##Action, GMOCK_INTERNAL_COUNT_##value_params) - -#define ACTION_TEMPLATE(name, template_params, value_params) \ - template <GMOCK_INTERNAL_DECL_##template_params \ - GMOCK_INTERNAL_DECL_TYPE_##value_params> \ - class GMOCK_ACTION_CLASS_(name, value_params) { \ - public: \ - explicit GMOCK_ACTION_CLASS_(name, value_params)( \ - GMOCK_INTERNAL_DECL_##value_params) \ - GMOCK_PP_IF(GMOCK_PP_IS_EMPTY(GMOCK_INTERNAL_COUNT_##value_params), \ - = default; , \ - : impl_(std::make_shared<gmock_Impl>( \ - GMOCK_INTERNAL_LIST_##value_params)) { }) \ - GMOCK_ACTION_CLASS_(name, value_params)( \ - const GMOCK_ACTION_CLASS_(name, value_params)&) noexcept \ - GMOCK_INTERNAL_DEFN_COPY_##value_params \ - GMOCK_ACTION_CLASS_(name, value_params)( \ - GMOCK_ACTION_CLASS_(name, value_params)&&) noexcept \ - GMOCK_INTERNAL_DEFN_COPY_##value_params \ - template <typename F> \ - operator ::testing::Action<F>() const { \ - return GMOCK_PP_IF( \ - GMOCK_PP_IS_EMPTY(GMOCK_INTERNAL_COUNT_##value_params), \ - (::testing::internal::MakeAction<F, gmock_Impl>()), \ - (::testing::internal::MakeAction<F>(impl_))); \ - } \ - private: \ - class gmock_Impl { \ - public: \ - explicit gmock_Impl GMOCK_INTERNAL_INIT_##value_params {} \ - template <typename function_type, typename return_type, \ - typename args_type, GMOCK_ACTION_TEMPLATE_ARGS_NAMES_> \ - return_type gmock_PerformImpl(GMOCK_ACTION_ARG_TYPES_AND_NAMES_) const; \ - GMOCK_INTERNAL_DEFN_##value_params \ - }; \ - GMOCK_PP_IF(GMOCK_PP_IS_EMPTY(GMOCK_INTERNAL_COUNT_##value_params), \ - , std::shared_ptr<const gmock_Impl> impl_;) \ - }; \ - template <GMOCK_INTERNAL_DECL_##template_params \ - GMOCK_INTERNAL_DECL_TYPE_##value_params> \ - GMOCK_ACTION_CLASS_(name, value_params)< \ - GMOCK_INTERNAL_LIST_##template_params \ - GMOCK_INTERNAL_LIST_TYPE_##value_params> name( \ - GMOCK_INTERNAL_DECL_##value_params) GTEST_MUST_USE_RESULT_; \ - template <GMOCK_INTERNAL_DECL_##template_params \ - GMOCK_INTERNAL_DECL_TYPE_##value_params> \ - inline GMOCK_ACTION_CLASS_(name, value_params)< \ - GMOCK_INTERNAL_LIST_##template_params \ - GMOCK_INTERNAL_LIST_TYPE_##value_params> name( \ - GMOCK_INTERNAL_DECL_##value_params) { \ - return GMOCK_ACTION_CLASS_(name, value_params)< \ - GMOCK_INTERNAL_LIST_##template_params \ - GMOCK_INTERNAL_LIST_TYPE_##value_params>( \ - GMOCK_INTERNAL_LIST_##value_params); \ - } \ - template <GMOCK_INTERNAL_DECL_##template_params \ - GMOCK_INTERNAL_DECL_TYPE_##value_params> \ - template <typename function_type, typename return_type, typename args_type, \ - GMOCK_ACTION_TEMPLATE_ARGS_NAMES_> \ - return_type GMOCK_ACTION_CLASS_(name, value_params)< \ - GMOCK_INTERNAL_LIST_##template_params \ - GMOCK_INTERNAL_LIST_TYPE_##value_params>::gmock_Impl::gmock_PerformImpl( \ - GMOCK_ACTION_ARG_TYPES_AND_NAMES_UNUSED_) const - -namespace testing { - -// The ACTION*() macros trigger warning C4100 (unreferenced formal -// parameter) in MSVC with -W4. Unfortunately they cannot be fixed in -// the macro definition, as the warnings are generated when the macro -// is expanded and macro expansion cannot contain #pragma. Therefore -// we suppress them here. -#ifdef _MSC_VER -# pragma warning(push) -# pragma warning(disable:4100) -#endif - -namespace internal { - -// internal::InvokeArgument - a helper for InvokeArgument action. -// The basic overloads are provided here for generic functors. -// Overloads for other custom-callables are provided in the -// internal/custom/gmock-generated-actions.h header. -template <typename F, typename... Args> -auto InvokeArgument(F f, Args... args) -> decltype(f(args...)) { - return f(args...); -} - -template <std::size_t index, typename... Params> -struct InvokeArgumentAction { - template <typename... Args> - auto operator()(Args&&... args) const -> decltype(internal::InvokeArgument( - std::get<index>(std::forward_as_tuple(std::forward<Args>(args)...)), - std::declval<const Params&>()...)) { - internal::FlatTuple<Args&&...> args_tuple(FlatTupleConstructTag{}, - std::forward<Args>(args)...); - return params.Apply([&](const Params&... unpacked_params) { - auto&& callable = args_tuple.template Get<index>(); - return internal::InvokeArgument( - std::forward<decltype(callable)>(callable), unpacked_params...); - }); - } - - internal::FlatTuple<Params...> params; -}; - -} // namespace internal - -// The InvokeArgument<N>(a1, a2, ..., a_k) action invokes the N-th -// (0-based) argument, which must be a k-ary callable, of the mock -// function, with arguments a1, a2, ..., a_k. -// -// Notes: -// -// 1. The arguments are passed by value by default. If you need to -// pass an argument by reference, wrap it inside std::ref(). For -// example, -// -// InvokeArgument<1>(5, string("Hello"), std::ref(foo)) -// -// passes 5 and string("Hello") by value, and passes foo by -// reference. -// -// 2. If the callable takes an argument by reference but std::ref() is -// not used, it will receive the reference to a copy of the value, -// instead of the original value. For example, when the 0-th -// argument of the mock function takes a const string&, the action -// -// InvokeArgument<0>(string("Hello")) -// -// makes a copy of the temporary string("Hello") object and passes a -// reference of the copy, instead of the original temporary object, -// to the callable. This makes it easy for a user to define an -// InvokeArgument action from temporary values and have it performed -// later. -template <std::size_t index, typename... Params> -internal::InvokeArgumentAction<index, typename std::decay<Params>::type...> -InvokeArgument(Params&&... params) { - return {internal::FlatTuple<typename std::decay<Params>::type...>( - internal::FlatTupleConstructTag{}, std::forward<Params>(params)...)}; -} - -#ifdef _MSC_VER -# pragma warning(pop) -#endif - -} // namespace testing - -#endif // GOOGLEMOCK_INCLUDE_GMOCK_GMOCK_MORE_ACTIONS_H_ -// Copyright 2013, 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. - - -// Google Mock - a framework for writing C++ mock classes. -// -// This file implements some matchers that depend on gmock-matchers.h. -// -// Note that tests are implemented in gmock-matchers_test.cc rather than -// gmock-more-matchers-test.cc. - -// GOOGLETEST_CM0002 DO NOT DELETE - -#ifndef GOOGLEMOCK_INCLUDE_GMOCK_GMOCK_MORE_MATCHERS_H_ -#define GOOGLEMOCK_INCLUDE_GMOCK_GMOCK_MORE_MATCHERS_H_ - - -namespace testing { - -// Silence C4100 (unreferenced formal -// parameter) for MSVC -#ifdef _MSC_VER -# pragma warning(push) -# pragma warning(disable:4100) -#if (_MSC_VER == 1900) -// and silence C4800 (C4800: 'int *const ': forcing value -// to bool 'true' or 'false') for MSVC 14 -# pragma warning(disable:4800) - #endif -#endif - -// Defines a matcher that matches an empty container. The container must -// support both size() and empty(), which all STL-like containers provide. -MATCHER(IsEmpty, negation ? "isn't empty" : "is empty") { - if (arg.empty()) { - return true; - } - *result_listener << "whose size is " << arg.size(); - return false; -} - -// Define a matcher that matches a value that evaluates in boolean -// context to true. Useful for types that define "explicit operator -// bool" operators and so can't be compared for equality with true -// and false. -MATCHER(IsTrue, negation ? "is false" : "is true") { - return static_cast<bool>(arg); -} - -// Define a matcher that matches a value that evaluates in boolean -// context to false. Useful for types that define "explicit operator -// bool" operators and so can't be compared for equality with true -// and false. -MATCHER(IsFalse, negation ? "is true" : "is false") { - return !static_cast<bool>(arg); -} - -#ifdef _MSC_VER -# pragma warning(pop) -#endif - - -} // namespace testing - -#endif // GOOGLEMOCK_INCLUDE_GMOCK_GMOCK_MORE_MATCHERS_H_ -// Copyright 2008, 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. - - -// Implements class templates NiceMock, NaggyMock, and StrictMock. -// -// Given a mock class MockFoo that is created using Google Mock, -// NiceMock<MockFoo> is a subclass of MockFoo that allows -// uninteresting calls (i.e. calls to mock methods that have no -// EXPECT_CALL specs), NaggyMock<MockFoo> is a subclass of MockFoo -// that prints a warning when an uninteresting call occurs, and -// StrictMock<MockFoo> is a subclass of MockFoo that treats all -// uninteresting calls as errors. -// -// Currently a mock is naggy by default, so MockFoo and -// NaggyMock<MockFoo> behave like the same. However, we will soon -// switch the default behavior of mocks to be nice, as that in general -// leads to more maintainable tests. When that happens, MockFoo will -// stop behaving like NaggyMock<MockFoo> and start behaving like -// NiceMock<MockFoo>. -// -// NiceMock, NaggyMock, and StrictMock "inherit" the constructors of -// their respective base class. Therefore you can write -// NiceMock<MockFoo>(5, "a") to construct a nice mock where MockFoo -// has a constructor that accepts (int, const char*), for example. -// -// A known limitation is that NiceMock<MockFoo>, NaggyMock<MockFoo>, -// and StrictMock<MockFoo> only works for mock methods defined using -// the MOCK_METHOD* family of macros DIRECTLY in the MockFoo class. -// If a mock method is defined in a base class of MockFoo, the "nice" -// or "strict" modifier may not affect it, depending on the compiler. -// In particular, nesting NiceMock, NaggyMock, and StrictMock is NOT -// supported. - -// GOOGLETEST_CM0002 DO NOT DELETE - -#ifndef GOOGLEMOCK_INCLUDE_GMOCK_GMOCK_NICE_STRICT_H_ -#define GOOGLEMOCK_INCLUDE_GMOCK_GMOCK_NICE_STRICT_H_ - -#include <cstdint> -#include <type_traits> - - -namespace testing { -template <class MockClass> -class NiceMock; -template <class MockClass> -class NaggyMock; -template <class MockClass> -class StrictMock; - -namespace internal { -template <typename T> -std::true_type StrictnessModifierProbe(const NiceMock<T>&); -template <typename T> -std::true_type StrictnessModifierProbe(const NaggyMock<T>&); -template <typename T> -std::true_type StrictnessModifierProbe(const StrictMock<T>&); -std::false_type StrictnessModifierProbe(...); - -template <typename T> -constexpr bool HasStrictnessModifier() { - return decltype(StrictnessModifierProbe(std::declval<const T&>()))::value; -} - -// Base classes that register and deregister with testing::Mock to alter the -// default behavior around uninteresting calls. Inheriting from one of these -// classes first and then MockClass ensures the MockClass constructor is run -// after registration, and that the MockClass destructor runs before -// deregistration. This guarantees that MockClass's constructor and destructor -// run with the same level of strictness as its instance methods. - -#if GTEST_OS_WINDOWS && !GTEST_OS_WINDOWS_MINGW && \ - (defined(_MSC_VER) || defined(__clang__)) -// We need to mark these classes with this declspec to ensure that -// the empty base class optimization is performed. -#define GTEST_INTERNAL_EMPTY_BASE_CLASS __declspec(empty_bases) -#else -#define GTEST_INTERNAL_EMPTY_BASE_CLASS -#endif - -template <typename Base> -class NiceMockImpl { - public: - NiceMockImpl() { - ::testing::Mock::AllowUninterestingCalls(reinterpret_cast<uintptr_t>(this)); - } - - ~NiceMockImpl() { - ::testing::Mock::UnregisterCallReaction(reinterpret_cast<uintptr_t>(this)); - } -}; - -template <typename Base> -class NaggyMockImpl { - public: - NaggyMockImpl() { - ::testing::Mock::WarnUninterestingCalls(reinterpret_cast<uintptr_t>(this)); - } - - ~NaggyMockImpl() { - ::testing::Mock::UnregisterCallReaction(reinterpret_cast<uintptr_t>(this)); - } -}; - -template <typename Base> -class StrictMockImpl { - public: - StrictMockImpl() { - ::testing::Mock::FailUninterestingCalls(reinterpret_cast<uintptr_t>(this)); - } - - ~StrictMockImpl() { - ::testing::Mock::UnregisterCallReaction(reinterpret_cast<uintptr_t>(this)); - } -}; - -} // namespace internal - -template <class MockClass> -class GTEST_INTERNAL_EMPTY_BASE_CLASS NiceMock - : private internal::NiceMockImpl<MockClass>, - public MockClass { - public: - static_assert(!internal::HasStrictnessModifier<MockClass>(), - "Can't apply NiceMock to a class hierarchy that already has a " - "strictness modifier. See " - "https://google.github.io/googletest/" - "gmock_cook_book.html#NiceStrictNaggy"); - NiceMock() : MockClass() { - static_assert(sizeof(*this) == sizeof(MockClass), - "The impl subclass shouldn't introduce any padding"); - } - - // Ideally, we would inherit base class's constructors through a using - // declaration, which would preserve their visibility. However, many existing - // tests rely on the fact that current implementation reexports protected - // constructors as public. These tests would need to be cleaned up first. - - // Single argument constructor is special-cased so that it can be - // made explicit. - template <typename A> - explicit NiceMock(A&& arg) : MockClass(std::forward<A>(arg)) { - static_assert(sizeof(*this) == sizeof(MockClass), - "The impl subclass shouldn't introduce any padding"); - } - - template <typename TArg1, typename TArg2, typename... An> - NiceMock(TArg1&& arg1, TArg2&& arg2, An&&... args) - : MockClass(std::forward<TArg1>(arg1), std::forward<TArg2>(arg2), - std::forward<An>(args)...) { - static_assert(sizeof(*this) == sizeof(MockClass), - "The impl subclass shouldn't introduce any padding"); - } - - private: - GTEST_DISALLOW_COPY_AND_ASSIGN_(NiceMock); -}; - -template <class MockClass> -class GTEST_INTERNAL_EMPTY_BASE_CLASS NaggyMock - : private internal::NaggyMockImpl<MockClass>, - public MockClass { - static_assert(!internal::HasStrictnessModifier<MockClass>(), - "Can't apply NaggyMock to a class hierarchy that already has a " - "strictness modifier. See " - "https://google.github.io/googletest/" - "gmock_cook_book.html#NiceStrictNaggy"); - - public: - NaggyMock() : MockClass() { - static_assert(sizeof(*this) == sizeof(MockClass), - "The impl subclass shouldn't introduce any padding"); - } - - // Ideally, we would inherit base class's constructors through a using - // declaration, which would preserve their visibility. However, many existing - // tests rely on the fact that current implementation reexports protected - // constructors as public. These tests would need to be cleaned up first. - - // Single argument constructor is special-cased so that it can be - // made explicit. - template <typename A> - explicit NaggyMock(A&& arg) : MockClass(std::forward<A>(arg)) { - static_assert(sizeof(*this) == sizeof(MockClass), - "The impl subclass shouldn't introduce any padding"); - } - - template <typename TArg1, typename TArg2, typename... An> - NaggyMock(TArg1&& arg1, TArg2&& arg2, An&&... args) - : MockClass(std::forward<TArg1>(arg1), std::forward<TArg2>(arg2), - std::forward<An>(args)...) { - static_assert(sizeof(*this) == sizeof(MockClass), - "The impl subclass shouldn't introduce any padding"); - } - - private: - GTEST_DISALLOW_COPY_AND_ASSIGN_(NaggyMock); -}; - -template <class MockClass> -class GTEST_INTERNAL_EMPTY_BASE_CLASS StrictMock - : private internal::StrictMockImpl<MockClass>, - public MockClass { - public: - static_assert( - !internal::HasStrictnessModifier<MockClass>(), - "Can't apply StrictMock to a class hierarchy that already has a " - "strictness modifier. See " - "https://google.github.io/googletest/" - "gmock_cook_book.html#NiceStrictNaggy"); - StrictMock() : MockClass() { - static_assert(sizeof(*this) == sizeof(MockClass), - "The impl subclass shouldn't introduce any padding"); - } - - // Ideally, we would inherit base class's constructors through a using - // declaration, which would preserve their visibility. However, many existing - // tests rely on the fact that current implementation reexports protected - // constructors as public. These tests would need to be cleaned up first. - - // Single argument constructor is special-cased so that it can be - // made explicit. - template <typename A> - explicit StrictMock(A&& arg) : MockClass(std::forward<A>(arg)) { - static_assert(sizeof(*this) == sizeof(MockClass), - "The impl subclass shouldn't introduce any padding"); - } - - template <typename TArg1, typename TArg2, typename... An> - StrictMock(TArg1&& arg1, TArg2&& arg2, An&&... args) - : MockClass(std::forward<TArg1>(arg1), std::forward<TArg2>(arg2), - std::forward<An>(args)...) { - static_assert(sizeof(*this) == sizeof(MockClass), - "The impl subclass shouldn't introduce any padding"); - } - - private: - GTEST_DISALLOW_COPY_AND_ASSIGN_(StrictMock); -}; - -#undef GTEST_INTERNAL_EMPTY_BASE_CLASS - -} // namespace testing - -#endif // GOOGLEMOCK_INCLUDE_GMOCK_GMOCK_NICE_STRICT_H_ - -namespace testing { - -// Declares Google Mock flags that we want a user to use programmatically. -GMOCK_DECLARE_bool_(catch_leaked_mocks); -GMOCK_DECLARE_string_(verbose); -GMOCK_DECLARE_int32_(default_mock_behavior); - -// Initializes Google Mock. This must be called before running the -// tests. In particular, it parses the command line for the flags -// that Google Mock recognizes. Whenever a Google Mock flag is seen, -// it is removed from argv, and *argc is decremented. -// -// No value is returned. Instead, the Google Mock flag variables are -// updated. -// -// Since Google Test is needed for Google Mock to work, this function -// also initializes Google Test and parses its flags, if that hasn't -// been done. -GTEST_API_ void InitGoogleMock(int* argc, char** argv); - -// This overloaded version can be used in Windows programs compiled in -// UNICODE mode. -GTEST_API_ void InitGoogleMock(int* argc, wchar_t** argv); - -// This overloaded version can be used on Arduino/embedded platforms where -// there is no argc/argv. -GTEST_API_ void InitGoogleMock(); - -} // namespace testing - -#endif // GOOGLEMOCK_INCLUDE_GMOCK_GMOCK_H_ diff --git a/thirdparty/fmt/test/gtest/gtest/gtest-spi.h b/thirdparty/fmt/test/gtest/gtest/gtest-spi.h deleted file mode 100644 index eacef4466..000000000 --- a/thirdparty/fmt/test/gtest/gtest/gtest-spi.h +++ /dev/null @@ -1,238 +0,0 @@ -// Copyright 2007, 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. - -// -// Utilities for testing Google Test itself and code that uses Google Test -// (e.g. frameworks built on top of Google Test). - -// GOOGLETEST_CM0004 DO NOT DELETE - -#ifndef GOOGLETEST_INCLUDE_GTEST_GTEST_SPI_H_ -#define GOOGLETEST_INCLUDE_GTEST_GTEST_SPI_H_ - -#include "gtest/gtest.h" - -GTEST_DISABLE_MSC_WARNINGS_PUSH_(4251 \ -/* class A needs to have dll-interface to be used by clients of class B */) - -namespace testing { - -// This helper class can be used to mock out Google Test failure reporting -// so that we can test Google Test or code that builds on Google Test. -// -// An object of this class appends a TestPartResult object to the -// TestPartResultArray object given in the constructor whenever a Google Test -// failure is reported. It can either intercept only failures that are -// generated in the same thread that created this object or it can intercept -// all generated failures. The scope of this mock object can be controlled with -// the second argument to the two arguments constructor. -class GTEST_API_ ScopedFakeTestPartResultReporter - : public TestPartResultReporterInterface { - public: - // The two possible mocking modes of this object. - enum InterceptMode { - INTERCEPT_ONLY_CURRENT_THREAD, // Intercepts only thread local failures. - INTERCEPT_ALL_THREADS // Intercepts all failures. - }; - - // The c'tor sets this object as the test part result reporter used - // by Google Test. The 'result' parameter specifies where to report the - // results. This reporter will only catch failures generated in the current - // thread. DEPRECATED - explicit ScopedFakeTestPartResultReporter(TestPartResultArray* result); - - // Same as above, but you can choose the interception scope of this object. - ScopedFakeTestPartResultReporter(InterceptMode intercept_mode, - TestPartResultArray* result); - - // The d'tor restores the previous test part result reporter. - ~ScopedFakeTestPartResultReporter() override; - - // Appends the TestPartResult object to the TestPartResultArray - // received in the constructor. - // - // This method is from the TestPartResultReporterInterface - // interface. - void ReportTestPartResult(const TestPartResult& result) override; - - private: - void Init(); - - const InterceptMode intercept_mode_; - TestPartResultReporterInterface* old_reporter_; - TestPartResultArray* const result_; - - GTEST_DISALLOW_COPY_AND_ASSIGN_(ScopedFakeTestPartResultReporter); -}; - -namespace internal { - -// A helper class for implementing EXPECT_FATAL_FAILURE() and -// EXPECT_NONFATAL_FAILURE(). Its destructor verifies that the given -// TestPartResultArray contains exactly one failure that has the given -// type and contains the given substring. If that's not the case, a -// non-fatal failure will be generated. -class GTEST_API_ SingleFailureChecker { - public: - // The constructor remembers the arguments. - SingleFailureChecker(const TestPartResultArray* results, - TestPartResult::Type type, const std::string& substr); - ~SingleFailureChecker(); - private: - const TestPartResultArray* const results_; - const TestPartResult::Type type_; - const std::string substr_; - - GTEST_DISALLOW_COPY_AND_ASSIGN_(SingleFailureChecker); -}; - -} // namespace internal - -} // namespace testing - -GTEST_DISABLE_MSC_WARNINGS_POP_() // 4251 - -// A set of macros for testing Google Test assertions or code that's expected -// to generate Google Test fatal failures. It verifies that the given -// statement will cause exactly one fatal Google Test failure with 'substr' -// being part of the failure message. -// -// There are two different versions of this macro. EXPECT_FATAL_FAILURE only -// affects and considers failures generated in the current thread and -// EXPECT_FATAL_FAILURE_ON_ALL_THREADS does the same but for all threads. -// -// The verification of the assertion is done correctly even when the statement -// throws an exception or aborts the current function. -// -// Known restrictions: -// - 'statement' cannot reference local non-static variables or -// non-static members of the current object. -// - 'statement' cannot return a value. -// - You cannot stream a failure message to this macro. -// -// Note that even though the implementations of the following two -// macros are much alike, we cannot refactor them to use a common -// helper macro, due to some peculiarity in how the preprocessor -// works. The AcceptsMacroThatExpandsToUnprotectedComma test in -// gtest_unittest.cc will fail to compile if we do that. -#define EXPECT_FATAL_FAILURE(statement, substr) \ - do { \ - class GTestExpectFatalFailureHelper {\ - public:\ - static void Execute() { statement; }\ - };\ - ::testing::TestPartResultArray gtest_failures;\ - ::testing::internal::SingleFailureChecker gtest_checker(\ - >est_failures, ::testing::TestPartResult::kFatalFailure, (substr));\ - {\ - ::testing::ScopedFakeTestPartResultReporter gtest_reporter(\ - ::testing::ScopedFakeTestPartResultReporter:: \ - INTERCEPT_ONLY_CURRENT_THREAD, >est_failures);\ - GTestExpectFatalFailureHelper::Execute();\ - }\ - } while (::testing::internal::AlwaysFalse()) - -#define EXPECT_FATAL_FAILURE_ON_ALL_THREADS(statement, substr) \ - do { \ - class GTestExpectFatalFailureHelper {\ - public:\ - static void Execute() { statement; }\ - };\ - ::testing::TestPartResultArray gtest_failures;\ - ::testing::internal::SingleFailureChecker gtest_checker(\ - >est_failures, ::testing::TestPartResult::kFatalFailure, (substr));\ - {\ - ::testing::ScopedFakeTestPartResultReporter gtest_reporter(\ - ::testing::ScopedFakeTestPartResultReporter:: \ - INTERCEPT_ALL_THREADS, >est_failures);\ - GTestExpectFatalFailureHelper::Execute();\ - }\ - } while (::testing::internal::AlwaysFalse()) - -// A macro for testing Google Test assertions or code that's expected to -// generate Google Test non-fatal failures. It asserts that the given -// statement will cause exactly one non-fatal Google Test failure with 'substr' -// being part of the failure message. -// -// There are two different versions of this macro. EXPECT_NONFATAL_FAILURE only -// affects and considers failures generated in the current thread and -// EXPECT_NONFATAL_FAILURE_ON_ALL_THREADS does the same but for all threads. -// -// 'statement' is allowed to reference local variables and members of -// the current object. -// -// The verification of the assertion is done correctly even when the statement -// throws an exception or aborts the current function. -// -// Known restrictions: -// - You cannot stream a failure message to this macro. -// -// Note that even though the implementations of the following two -// macros are much alike, we cannot refactor them to use a common -// helper macro, due to some peculiarity in how the preprocessor -// works. If we do that, the code won't compile when the user gives -// EXPECT_NONFATAL_FAILURE() a statement that contains a macro that -// expands to code containing an unprotected comma. The -// AcceptsMacroThatExpandsToUnprotectedComma test in gtest_unittest.cc -// catches that. -// -// For the same reason, we have to write -// if (::testing::internal::AlwaysTrue()) { statement; } -// instead of -// GTEST_SUPPRESS_UNREACHABLE_CODE_WARNING_BELOW_(statement) -// to avoid an MSVC warning on unreachable code. -#define EXPECT_NONFATAL_FAILURE(statement, substr) \ - do {\ - ::testing::TestPartResultArray gtest_failures;\ - ::testing::internal::SingleFailureChecker gtest_checker(\ - >est_failures, ::testing::TestPartResult::kNonFatalFailure, \ - (substr));\ - {\ - ::testing::ScopedFakeTestPartResultReporter gtest_reporter(\ - ::testing::ScopedFakeTestPartResultReporter:: \ - INTERCEPT_ONLY_CURRENT_THREAD, >est_failures);\ - if (::testing::internal::AlwaysTrue()) { statement; }\ - }\ - } while (::testing::internal::AlwaysFalse()) - -#define EXPECT_NONFATAL_FAILURE_ON_ALL_THREADS(statement, substr) \ - do {\ - ::testing::TestPartResultArray gtest_failures;\ - ::testing::internal::SingleFailureChecker gtest_checker(\ - >est_failures, ::testing::TestPartResult::kNonFatalFailure, \ - (substr));\ - {\ - ::testing::ScopedFakeTestPartResultReporter gtest_reporter(\ - ::testing::ScopedFakeTestPartResultReporter::INTERCEPT_ALL_THREADS, \ - >est_failures);\ - if (::testing::internal::AlwaysTrue()) { statement; }\ - }\ - } while (::testing::internal::AlwaysFalse()) - -#endif // GOOGLETEST_INCLUDE_GTEST_GTEST_SPI_H_ diff --git a/thirdparty/fmt/test/gtest/gtest/gtest.h b/thirdparty/fmt/test/gtest/gtest/gtest.h deleted file mode 100644 index cb994607a..000000000 --- a/thirdparty/fmt/test/gtest/gtest/gtest.h +++ /dev/null @@ -1,12399 +0,0 @@ -// 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. - -// -// The Google C++ Testing and Mocking Framework (Google Test) -// -// This header file defines the public API for Google Test. It should be -// included by any test program that uses Google Test. -// -// 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! -// -// Acknowledgment: Google Test borrowed the idea of automatic test -// registration from Barthelemy Dagenais' ([email protected]) -// easyUnit framework. - -// GOOGLETEST_CM0001 DO NOT DELETE - -#ifndef GOOGLETEST_INCLUDE_GTEST_GTEST_H_ -#define GOOGLETEST_INCLUDE_GTEST_GTEST_H_ - -#include <cstddef> -#include <limits> -#include <memory> -#include <ostream> -#include <type_traits> -#include <vector> - -// 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. -// -// The Google C++ Testing and Mocking Framework (Google Test) -// -// This header file declares functions and macros used internally by -// Google Test. They are subject to change without notice. - -// GOOGLETEST_CM0001 DO NOT DELETE - -#ifndef GOOGLETEST_INCLUDE_GTEST_INTERNAL_GTEST_INTERNAL_H_ -#define GOOGLETEST_INCLUDE_GTEST_INTERNAL_GTEST_INTERNAL_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. -// -// Low-level types and utilities for porting Google Test to various -// platforms. All macros ending with _ and symbols defined in an -// internal namespace are subject to change without notice. Code -// outside Google Test MUST NOT USE THEM DIRECTLY. Macros that don't -// end with _ are part of Google Test's public API and can be used by -// code outside Google Test. -// -// This file is fundamental to Google Test. All other Google Test source -// files are expected to #include this. Therefore, it cannot #include -// any other Google Test header. - -// GOOGLETEST_CM0001 DO NOT DELETE - -#ifndef GOOGLETEST_INCLUDE_GTEST_INTERNAL_GTEST_PORT_H_ -#define GOOGLETEST_INCLUDE_GTEST_INTERNAL_GTEST_PORT_H_ - -// Environment-describing macros -// ----------------------------- -// -// Google Test can be used in many different environments. Macros in -// this section tell Google Test what kind of environment it is being -// used in, such that Google Test can provide environment-specific -// features and implementations. -// -// Google Test tries to automatically detect the properties of its -// environment, so users usually don't need to worry about these -// macros. However, the automatic detection is not perfect. -// Sometimes it's necessary for a user to define some of the following -// macros in the build script to override Google Test's decisions. -// -// If the user doesn't define a macro in the list, Google Test will -// provide a default definition. After this header is #included, all -// macros in this list will be defined to either 1 or 0. -// -// Notes to maintainers: -// - Each macro here is a user-tweakable knob; do not grow the list -// lightly. -// - Use #if to key off these macros. Don't use #ifdef or "#if -// defined(...)", which will not work as these macros are ALWAYS -// defined. -// -// GTEST_HAS_CLONE - Define it to 1/0 to indicate that clone(2) -// is/isn't available. -// GTEST_HAS_EXCEPTIONS - Define it to 1/0 to indicate that exceptions -// are enabled. -// GTEST_HAS_POSIX_RE - Define it to 1/0 to indicate that POSIX regular -// expressions are/aren't available. -// GTEST_HAS_PTHREAD - Define it to 1/0 to indicate that <pthread.h> -// is/isn't available. -// GTEST_HAS_RTTI - Define it to 1/0 to indicate that RTTI is/isn't -// enabled. -// GTEST_HAS_STD_WSTRING - Define it to 1/0 to indicate that -// std::wstring does/doesn't work (Google Test can -// be used where std::wstring is unavailable). -// GTEST_HAS_SEH - Define it to 1/0 to indicate whether the -// compiler supports Microsoft's "Structured -// Exception Handling". -// GTEST_HAS_STREAM_REDIRECTION -// - Define it to 1/0 to indicate whether the -// platform supports I/O stream redirection using -// dup() and dup2(). -// GTEST_LINKED_AS_SHARED_LIBRARY -// - Define to 1 when compiling tests that use -// Google Test as a shared library (known as -// DLL on Windows). -// GTEST_CREATE_SHARED_LIBRARY -// - Define to 1 when compiling Google Test itself -// as a shared library. -// GTEST_DEFAULT_DEATH_TEST_STYLE -// - The default value of --gtest_death_test_style. -// The legacy default has been "fast" in the open -// source version since 2008. The recommended value -// is "threadsafe", and can be set in -// custom/gtest-port.h. - -// Platform-indicating macros -// -------------------------- -// -// Macros indicating the platform on which Google Test is being used -// (a macro is defined to 1 if compiled on the given platform; -// otherwise UNDEFINED -- it's never defined to 0.). Google Test -// defines these macros automatically. Code outside Google Test MUST -// NOT define them. -// -// GTEST_OS_AIX - IBM AIX -// GTEST_OS_CYGWIN - Cygwin -// GTEST_OS_DRAGONFLY - DragonFlyBSD -// GTEST_OS_FREEBSD - FreeBSD -// GTEST_OS_FUCHSIA - Fuchsia -// GTEST_OS_GNU_KFREEBSD - GNU/kFreeBSD -// GTEST_OS_HAIKU - Haiku -// GTEST_OS_HPUX - HP-UX -// GTEST_OS_LINUX - Linux -// GTEST_OS_LINUX_ANDROID - Google Android -// GTEST_OS_MAC - Mac OS X -// GTEST_OS_IOS - iOS -// GTEST_OS_NACL - Google Native Client (NaCl) -// GTEST_OS_NETBSD - NetBSD -// GTEST_OS_OPENBSD - OpenBSD -// GTEST_OS_OS2 - OS/2 -// GTEST_OS_QNX - QNX -// GTEST_OS_SOLARIS - Sun Solaris -// GTEST_OS_WINDOWS - Windows (Desktop, MinGW, or Mobile) -// GTEST_OS_WINDOWS_DESKTOP - Windows Desktop -// GTEST_OS_WINDOWS_MINGW - MinGW -// GTEST_OS_WINDOWS_MOBILE - Windows Mobile -// GTEST_OS_WINDOWS_PHONE - Windows Phone -// GTEST_OS_WINDOWS_RT - Windows Store App/WinRT -// GTEST_OS_ZOS - z/OS -// -// Among the platforms, Cygwin, Linux, Mac OS X, and Windows have the -// most stable support. Since core members of the Google Test project -// don't have access to other platforms, support for them may be less -// stable. If you notice any problems on your platform, please notify -// [email protected] (patches for fixing them are -// even more welcome!). -// -// It is possible that none of the GTEST_OS_* macros are defined. - -// Feature-indicating macros -// ------------------------- -// -// Macros indicating which Google Test features are available (a macro -// is defined to 1 if the corresponding feature is supported; -// otherwise UNDEFINED -- it's never defined to 0.). Google Test -// defines these macros automatically. Code outside Google Test MUST -// NOT define them. -// -// These macros are public so that portable tests can be written. -// Such tests typically surround code using a feature with an #if -// which controls that code. For example: -// -// #if GTEST_HAS_DEATH_TEST -// EXPECT_DEATH(DoSomethingDeadly()); -// #endif -// -// GTEST_HAS_DEATH_TEST - death tests -// GTEST_HAS_TYPED_TEST - typed tests -// GTEST_HAS_TYPED_TEST_P - type-parameterized tests -// GTEST_IS_THREADSAFE - Google Test is thread-safe. -// GOOGLETEST_CM0007 DO NOT DELETE -// GTEST_USES_POSIX_RE - enhanced POSIX regex is used. Do not confuse with -// GTEST_HAS_POSIX_RE (see above) which users can -// define themselves. -// GTEST_USES_SIMPLE_RE - our own simple regex is used; -// the above RE\b(s) are mutually exclusive. - -// Misc public macros -// ------------------ -// -// GTEST_FLAG(flag_name) - references the variable corresponding to -// the given Google Test flag. - -// Internal utilities -// ------------------ -// -// The following macros and utilities are for Google Test's INTERNAL -// use only. Code outside Google Test MUST NOT USE THEM DIRECTLY. -// -// Macros for basic C++ coding: -// GTEST_AMBIGUOUS_ELSE_BLOCKER_ - for disabling a gcc warning. -// GTEST_ATTRIBUTE_UNUSED_ - declares that a class' instances or a -// variable don't have to be used. -// GTEST_DISALLOW_ASSIGN_ - disables copy operator=. -// GTEST_DISALLOW_COPY_AND_ASSIGN_ - disables copy ctor and operator=. -// GTEST_DISALLOW_MOVE_ASSIGN_ - disables move operator=. -// GTEST_DISALLOW_MOVE_AND_ASSIGN_ - disables move ctor and operator=. -// GTEST_MUST_USE_RESULT_ - declares that a function's result must be used. -// GTEST_INTENTIONAL_CONST_COND_PUSH_ - start code section where MSVC C4127 is -// suppressed (constant conditional). -// GTEST_INTENTIONAL_CONST_COND_POP_ - finish code section where MSVC C4127 -// is suppressed. -// GTEST_INTERNAL_HAS_ANY - for enabling UniversalPrinter<std::any> or -// UniversalPrinter<absl::any> specializations. -// GTEST_INTERNAL_HAS_OPTIONAL - for enabling UniversalPrinter<std::optional> -// or -// UniversalPrinter<absl::optional> -// specializations. -// GTEST_INTERNAL_HAS_STRING_VIEW - for enabling Matcher<std::string_view> or -// Matcher<absl::string_view> -// specializations. -// GTEST_INTERNAL_HAS_VARIANT - for enabling UniversalPrinter<std::variant> or -// UniversalPrinter<absl::variant> -// specializations. -// -// Synchronization: -// Mutex, MutexLock, ThreadLocal, GetThreadCount() -// - synchronization primitives. -// -// Regular expressions: -// RE - a simple regular expression class using the POSIX -// Extended Regular Expression syntax on UNIX-like platforms -// GOOGLETEST_CM0008 DO NOT DELETE -// or a reduced regular exception syntax on other -// platforms, including Windows. -// Logging: -// GTEST_LOG_() - logs messages at the specified severity level. -// LogToStderr() - directs all log messages to stderr. -// FlushInfoLog() - flushes informational log messages. -// -// Stdout and stderr capturing: -// CaptureStdout() - starts capturing stdout. -// GetCapturedStdout() - stops capturing stdout and returns the captured -// string. -// CaptureStderr() - starts capturing stderr. -// GetCapturedStderr() - stops capturing stderr and returns the captured -// string. -// -// Integer types: -// TypeWithSize - maps an integer to a int type. -// TimeInMillis - integers of known sizes. -// BiggestInt - the biggest signed integer type. -// -// Command-line utilities: -// GTEST_DECLARE_*() - declares a flag. -// GTEST_DEFINE_*() - defines a flag. -// GetInjectableArgvs() - returns the command line as a vector of strings. -// -// Environment variable utilities: -// GetEnv() - gets the value of an environment variable. -// BoolFromGTestEnv() - parses a bool environment variable. -// Int32FromGTestEnv() - parses an int32_t environment variable. -// StringFromGTestEnv() - parses a string environment variable. -// -// Deprecation warnings: -// GTEST_INTERNAL_DEPRECATED(message) - attribute marking a function as -// deprecated; calling a marked function -// should generate a compiler warning - -#include <ctype.h> // for isspace, etc -#include <stddef.h> // for ptrdiff_t -#include <stdio.h> -#include <stdlib.h> -#include <string.h> - -#include <cerrno> -#include <cstdint> -#include <limits> -#include <type_traits> - -#ifndef _WIN32_WCE -# include <sys/types.h> -# include <sys/stat.h> -#endif // !_WIN32_WCE - -#if defined __APPLE__ -# include <AvailabilityMacros.h> -# include <TargetConditionals.h> -#endif - -#include <iostream> // NOLINT -#include <locale> -#include <memory> -#include <string> // NOLINT -#include <tuple> -#include <vector> // NOLINT - -// Copyright 2015, 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. -// -// Injection point for custom user configurations. See README for details -// -// ** Custom implementation starts here ** - -#ifndef GOOGLETEST_INCLUDE_GTEST_INTERNAL_CUSTOM_GTEST_PORT_H_ -#define GOOGLETEST_INCLUDE_GTEST_INTERNAL_CUSTOM_GTEST_PORT_H_ - -#endif // GOOGLETEST_INCLUDE_GTEST_INTERNAL_CUSTOM_GTEST_PORT_H_ -// Copyright 2015, 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. -// -// The Google C++ Testing and Mocking Framework (Google Test) -// -// This header file defines the GTEST_OS_* macro. -// It is separate from gtest-port.h so that custom/gtest-port.h can include it. - -#ifndef GOOGLETEST_INCLUDE_GTEST_INTERNAL_GTEST_PORT_ARCH_H_ -#define GOOGLETEST_INCLUDE_GTEST_INTERNAL_GTEST_PORT_ARCH_H_ - -// Determines the platform on which Google Test is compiled. -#ifdef __CYGWIN__ -# define GTEST_OS_CYGWIN 1 -# elif defined(__MINGW__) || defined(__MINGW32__) || defined(__MINGW64__) -# define GTEST_OS_WINDOWS_MINGW 1 -# define GTEST_OS_WINDOWS 1 -#elif defined _WIN32 -# define GTEST_OS_WINDOWS 1 -# ifdef _WIN32_WCE -# define GTEST_OS_WINDOWS_MOBILE 1 -# elif defined(WINAPI_FAMILY) -# include <winapifamily.h> -# if WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_DESKTOP) -# define GTEST_OS_WINDOWS_DESKTOP 1 -# elif WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_PHONE_APP) -# define GTEST_OS_WINDOWS_PHONE 1 -# elif WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_APP) -# define GTEST_OS_WINDOWS_RT 1 -# elif WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_TV_TITLE) -# define GTEST_OS_WINDOWS_PHONE 1 -# define GTEST_OS_WINDOWS_TV_TITLE 1 -# else - // WINAPI_FAMILY defined but no known partition matched. - // Default to desktop. -# define GTEST_OS_WINDOWS_DESKTOP 1 -# endif -# else -# define GTEST_OS_WINDOWS_DESKTOP 1 -# endif // _WIN32_WCE -#elif defined __OS2__ -# define GTEST_OS_OS2 1 -#elif defined __APPLE__ -# define GTEST_OS_MAC 1 -# include <TargetConditionals.h> -# if TARGET_OS_IPHONE -# define GTEST_OS_IOS 1 -# endif -#elif defined __DragonFly__ -# define GTEST_OS_DRAGONFLY 1 -#elif defined __FreeBSD__ -# define GTEST_OS_FREEBSD 1 -#elif defined __Fuchsia__ -# define GTEST_OS_FUCHSIA 1 -#elif defined(__GLIBC__) && defined(__FreeBSD_kernel__) -# define GTEST_OS_GNU_KFREEBSD 1 -#elif defined __linux__ -# define GTEST_OS_LINUX 1 -# if defined __ANDROID__ -# define GTEST_OS_LINUX_ANDROID 1 -# endif -#elif defined __MVS__ -# define GTEST_OS_ZOS 1 -#elif defined(__sun) && defined(__SVR4) -# define GTEST_OS_SOLARIS 1 -#elif defined(_AIX) -# define GTEST_OS_AIX 1 -#elif defined(__hpux) -# define GTEST_OS_HPUX 1 -#elif defined __native_client__ -# define GTEST_OS_NACL 1 -#elif defined __NetBSD__ -# define GTEST_OS_NETBSD 1 -#elif defined __OpenBSD__ -# define GTEST_OS_OPENBSD 1 -#elif defined __QNX__ -# define GTEST_OS_QNX 1 -#elif defined(__HAIKU__) -#define GTEST_OS_HAIKU 1 -#elif defined ESP8266 -#define GTEST_OS_ESP8266 1 -#elif defined ESP32 -#define GTEST_OS_ESP32 1 -#elif defined(__XTENSA__) -#define GTEST_OS_XTENSA 1 -#endif // __CYGWIN__ - -#endif // GOOGLETEST_INCLUDE_GTEST_INTERNAL_GTEST_PORT_ARCH_H_ - -#if !defined(GTEST_DEV_EMAIL_) -# define GTEST_DEV_EMAIL_ "googletestframework@@googlegroups.com" -# define GTEST_FLAG_PREFIX_ "gtest_" -# define GTEST_FLAG_PREFIX_DASH_ "gtest-" -# define GTEST_FLAG_PREFIX_UPPER_ "GTEST_" -# define GTEST_NAME_ "Google Test" -# define GTEST_PROJECT_URL_ "https://github.com/google/googletest/" -#endif // !defined(GTEST_DEV_EMAIL_) - -#if !defined(GTEST_INIT_GOOGLE_TEST_NAME_) -# define GTEST_INIT_GOOGLE_TEST_NAME_ "testing::InitGoogleTest" -#endif // !defined(GTEST_INIT_GOOGLE_TEST_NAME_) - -// Determines the version of gcc that is used to compile this. -#ifdef __GNUC__ -// 40302 means version 4.3.2. -# define GTEST_GCC_VER_ \ - (__GNUC__*10000 + __GNUC_MINOR__*100 + __GNUC_PATCHLEVEL__) -#endif // __GNUC__ - -// Macros for disabling Microsoft Visual C++ warnings. -// -// GTEST_DISABLE_MSC_WARNINGS_PUSH_(4800 4385) -// /* code that triggers warnings C4800 and C4385 */ -// GTEST_DISABLE_MSC_WARNINGS_POP_() -#if defined(_MSC_VER) -# define GTEST_DISABLE_MSC_WARNINGS_PUSH_(warnings) \ - __pragma(warning(push)) \ - __pragma(warning(disable: warnings)) -# define GTEST_DISABLE_MSC_WARNINGS_POP_() \ - __pragma(warning(pop)) -#else -// Not all compilers are MSVC -# define GTEST_DISABLE_MSC_WARNINGS_PUSH_(warnings) -# define GTEST_DISABLE_MSC_WARNINGS_POP_() -#endif - -// Clang on Windows does not understand MSVC's pragma warning. -// We need clang-specific way to disable function deprecation warning. -#ifdef __clang__ -# define GTEST_DISABLE_MSC_DEPRECATED_PUSH_() \ - _Pragma("clang diagnostic push") \ - _Pragma("clang diagnostic ignored \"-Wdeprecated-declarations\"") \ - _Pragma("clang diagnostic ignored \"-Wdeprecated-implementations\"") -#define GTEST_DISABLE_MSC_DEPRECATED_POP_() \ - _Pragma("clang diagnostic pop") -#else -# define GTEST_DISABLE_MSC_DEPRECATED_PUSH_() \ - GTEST_DISABLE_MSC_WARNINGS_PUSH_(4996) -# define GTEST_DISABLE_MSC_DEPRECATED_POP_() \ - GTEST_DISABLE_MSC_WARNINGS_POP_() -#endif - -// Brings in definitions for functions used in the testing::internal::posix -// namespace (read, write, close, chdir, isatty, stat). We do not currently -// use them on Windows Mobile. -#if GTEST_OS_WINDOWS -# if !GTEST_OS_WINDOWS_MOBILE -# include <direct.h> -# include <io.h> -# endif -// In order to avoid having to include <windows.h>, use forward declaration -#if GTEST_OS_WINDOWS_MINGW && !defined(__MINGW64_VERSION_MAJOR) -// MinGW defined _CRITICAL_SECTION and _RTL_CRITICAL_SECTION as two -// separate (equivalent) structs, instead of using typedef -typedef struct _CRITICAL_SECTION GTEST_CRITICAL_SECTION; -#else -// Assume CRITICAL_SECTION is a typedef of _RTL_CRITICAL_SECTION. -// This assumption is verified by -// WindowsTypesTest.CRITICAL_SECTIONIs_RTL_CRITICAL_SECTION. -typedef struct _RTL_CRITICAL_SECTION GTEST_CRITICAL_SECTION; -#endif -#elif GTEST_OS_XTENSA -#include <unistd.h> -// Xtensa toolchains define strcasecmp in the string.h header instead of -// strings.h. string.h is already included. -#else -// This assumes that non-Windows OSes provide unistd.h. For OSes where this -// is not the case, we need to include headers that provide the functions -// mentioned above. -# include <unistd.h> -# include <strings.h> -#endif // GTEST_OS_WINDOWS - -#if GTEST_OS_LINUX_ANDROID -// Used to define __ANDROID_API__ matching the target NDK API level. -# include <android/api-level.h> // NOLINT -#endif - -// Defines this to true if and only if Google Test can use POSIX regular -// expressions. -#ifndef GTEST_HAS_POSIX_RE -# if GTEST_OS_LINUX_ANDROID -// On Android, <regex.h> is only available starting with Gingerbread. -# define GTEST_HAS_POSIX_RE (__ANDROID_API__ >= 9) -# else -#define GTEST_HAS_POSIX_RE (!GTEST_OS_WINDOWS && !GTEST_OS_XTENSA) -# endif -#endif - -#if GTEST_USES_PCRE -// The appropriate headers have already been included. - -#elif GTEST_HAS_POSIX_RE - -// On some platforms, <regex.h> needs someone to define size_t, and -// won't compile otherwise. We can #include it here as we already -// included <stdlib.h>, which is guaranteed to define size_t through -// <stddef.h>. -# include <regex.h> // NOLINT - -# define GTEST_USES_POSIX_RE 1 - -#elif GTEST_OS_WINDOWS - -// <regex.h> is not available on Windows. Use our own simple regex -// implementation instead. -# define GTEST_USES_SIMPLE_RE 1 - -#else - -// <regex.h> may not be available on this platform. Use our own -// simple regex implementation instead. -# define GTEST_USES_SIMPLE_RE 1 - -#endif // GTEST_USES_PCRE - -#ifndef GTEST_HAS_EXCEPTIONS -// The user didn't tell us whether exceptions are enabled, so we need -// to figure it out. -# if defined(_MSC_VER) && defined(_CPPUNWIND) -// MSVC defines _CPPUNWIND to 1 if and only if exceptions are enabled. -# define GTEST_HAS_EXCEPTIONS 1 -# elif defined(__BORLANDC__) -// C++Builder's implementation of the STL uses the _HAS_EXCEPTIONS -// macro to enable exceptions, so we'll do the same. -// Assumes that exceptions are enabled by default. -# ifndef _HAS_EXCEPTIONS -# define _HAS_EXCEPTIONS 1 -# endif // _HAS_EXCEPTIONS -# define GTEST_HAS_EXCEPTIONS _HAS_EXCEPTIONS -# elif defined(__clang__) -// clang defines __EXCEPTIONS if and only if exceptions are enabled before clang -// 220714, but if and only if cleanups are enabled after that. In Obj-C++ files, -// there can be cleanups for ObjC exceptions which also need cleanups, even if -// C++ exceptions are disabled. clang has __has_feature(cxx_exceptions) which -// checks for C++ exceptions starting at clang r206352, but which checked for -// cleanups prior to that. To reliably check for C++ exception availability with -// clang, check for -// __EXCEPTIONS && __has_feature(cxx_exceptions). -# define GTEST_HAS_EXCEPTIONS (__EXCEPTIONS && __has_feature(cxx_exceptions)) -# elif defined(__GNUC__) && __EXCEPTIONS -// gcc defines __EXCEPTIONS to 1 if and only if exceptions are enabled. -# define GTEST_HAS_EXCEPTIONS 1 -# elif defined(__SUNPRO_CC) -// Sun Pro CC supports exceptions. However, there is no compile-time way of -// detecting whether they are enabled or not. Therefore, we assume that -// they are enabled unless the user tells us otherwise. -# define GTEST_HAS_EXCEPTIONS 1 -# elif defined(__IBMCPP__) && __EXCEPTIONS -// xlC defines __EXCEPTIONS to 1 if and only if exceptions are enabled. -# define GTEST_HAS_EXCEPTIONS 1 -# elif defined(__HP_aCC) -// Exception handling is in effect by default in HP aCC compiler. It has to -// be turned of by +noeh compiler option if desired. -# define GTEST_HAS_EXCEPTIONS 1 -# else -// For other compilers, we assume exceptions are disabled to be -// conservative. -# define GTEST_HAS_EXCEPTIONS 0 -# endif // defined(_MSC_VER) || defined(__BORLANDC__) -#endif // GTEST_HAS_EXCEPTIONS - -#ifndef GTEST_HAS_STD_WSTRING -// The user didn't tell us whether ::std::wstring is available, so we need -// to figure it out. -// Cygwin 1.7 and below doesn't support ::std::wstring. -// Solaris' libc++ doesn't support it either. Android has -// no support for it at least as recent as Froyo (2.2). -#define GTEST_HAS_STD_WSTRING \ - (!(GTEST_OS_LINUX_ANDROID || GTEST_OS_CYGWIN || GTEST_OS_SOLARIS || \ - GTEST_OS_HAIKU || GTEST_OS_ESP32 || GTEST_OS_ESP8266 || GTEST_OS_XTENSA)) - -#endif // GTEST_HAS_STD_WSTRING - -// Determines whether RTTI is available. -#ifndef GTEST_HAS_RTTI -// The user didn't tell us whether RTTI is enabled, so we need to -// figure it out. - -# ifdef _MSC_VER - -#ifdef _CPPRTTI // MSVC defines this macro if and only if RTTI is enabled. -# define GTEST_HAS_RTTI 1 -# else -# define GTEST_HAS_RTTI 0 -# endif - -// Starting with version 4.3.2, gcc defines __GXX_RTTI if and only if RTTI is -// enabled. -# elif defined(__GNUC__) - -# ifdef __GXX_RTTI -// When building against STLport with the Android NDK and with -// -frtti -fno-exceptions, the build fails at link time with undefined -// references to __cxa_bad_typeid. Note sure if STL or toolchain bug, -// so disable RTTI when detected. -# if GTEST_OS_LINUX_ANDROID && defined(_STLPORT_MAJOR) && \ - !defined(__EXCEPTIONS) -# define GTEST_HAS_RTTI 0 -# else -# define GTEST_HAS_RTTI 1 -# endif // GTEST_OS_LINUX_ANDROID && __STLPORT_MAJOR && !__EXCEPTIONS -# else -# define GTEST_HAS_RTTI 0 -# endif // __GXX_RTTI - -// Clang defines __GXX_RTTI starting with version 3.0, but its manual recommends -// using has_feature instead. has_feature(cxx_rtti) is supported since 2.7, the -// first version with C++ support. -# elif defined(__clang__) - -# define GTEST_HAS_RTTI __has_feature(cxx_rtti) - -// Starting with version 9.0 IBM Visual Age defines __RTTI_ALL__ to 1 if -// both the typeid and dynamic_cast features are present. -# elif defined(__IBMCPP__) && (__IBMCPP__ >= 900) - -# ifdef __RTTI_ALL__ -# define GTEST_HAS_RTTI 1 -# else -# define GTEST_HAS_RTTI 0 -# endif - -# else - -// For all other compilers, we assume RTTI is enabled. -# define GTEST_HAS_RTTI 1 - -# endif // _MSC_VER - -#endif // GTEST_HAS_RTTI - -// It's this header's responsibility to #include <typeinfo> when RTTI -// is enabled. -#if GTEST_HAS_RTTI -# include <typeinfo> -#endif - -// Determines whether Google Test can use the pthreads library. -#ifndef GTEST_HAS_PTHREAD -// The user didn't tell us explicitly, so we make reasonable assumptions about -// which platforms have pthreads support. -// -// To disable threading support in Google Test, add -DGTEST_HAS_PTHREAD=0 -// to your compiler flags. -#define GTEST_HAS_PTHREAD \ - (GTEST_OS_LINUX || GTEST_OS_MAC || GTEST_OS_HPUX || GTEST_OS_QNX || \ - GTEST_OS_FREEBSD || GTEST_OS_NACL || GTEST_OS_NETBSD || GTEST_OS_FUCHSIA || \ - GTEST_OS_DRAGONFLY || GTEST_OS_GNU_KFREEBSD || GTEST_OS_OPENBSD || \ - GTEST_OS_HAIKU) -#endif // GTEST_HAS_PTHREAD - -#if GTEST_HAS_PTHREAD -// gtest-port.h guarantees to #include <pthread.h> when GTEST_HAS_PTHREAD is -// true. -# include <pthread.h> // NOLINT - -// For timespec and nanosleep, used below. -# include <time.h> // NOLINT -#endif - -// Determines whether clone(2) is supported. -// Usually it will only be available on Linux, excluding -// Linux on the Itanium architecture. -// Also see http://linux.die.net/man/2/clone. -#ifndef GTEST_HAS_CLONE -// The user didn't tell us, so we need to figure it out. - -# if GTEST_OS_LINUX && !defined(__ia64__) -# if GTEST_OS_LINUX_ANDROID -// On Android, clone() became available at different API levels for each 32-bit -// architecture. -# if defined(__LP64__) || \ - (defined(__arm__) && __ANDROID_API__ >= 9) || \ - (defined(__mips__) && __ANDROID_API__ >= 12) || \ - (defined(__i386__) && __ANDROID_API__ >= 17) -# define GTEST_HAS_CLONE 1 -# else -# define GTEST_HAS_CLONE 0 -# endif -# else -# define GTEST_HAS_CLONE 1 -# endif -# else -# define GTEST_HAS_CLONE 0 -# endif // GTEST_OS_LINUX && !defined(__ia64__) - -#endif // GTEST_HAS_CLONE - -// Determines whether to support stream redirection. This is used to test -// output correctness and to implement death tests. -#ifndef GTEST_HAS_STREAM_REDIRECTION -// By default, we assume that stream redirection is supported on all -// platforms except known mobile ones. -#if GTEST_OS_WINDOWS_MOBILE || GTEST_OS_WINDOWS_PHONE || \ - GTEST_OS_WINDOWS_RT || GTEST_OS_ESP8266 || GTEST_OS_XTENSA -# define GTEST_HAS_STREAM_REDIRECTION 0 -# else -# define GTEST_HAS_STREAM_REDIRECTION 1 -# endif // !GTEST_OS_WINDOWS_MOBILE -#endif // GTEST_HAS_STREAM_REDIRECTION - -// Determines whether to support death tests. -// pops up a dialog window that cannot be suppressed programmatically. -#if (GTEST_OS_LINUX || GTEST_OS_CYGWIN || GTEST_OS_SOLARIS || \ - (GTEST_OS_MAC && !GTEST_OS_IOS) || \ - (GTEST_OS_WINDOWS_DESKTOP && _MSC_VER) || GTEST_OS_WINDOWS_MINGW || \ - GTEST_OS_AIX || GTEST_OS_HPUX || GTEST_OS_OPENBSD || GTEST_OS_QNX || \ - GTEST_OS_FREEBSD || GTEST_OS_NETBSD || GTEST_OS_FUCHSIA || \ - GTEST_OS_DRAGONFLY || GTEST_OS_GNU_KFREEBSD || GTEST_OS_HAIKU) -# define GTEST_HAS_DEATH_TEST 1 -#endif - -// Determines whether to support type-driven tests. - -// Typed tests need <typeinfo> and variadic macros, which GCC, VC++ 8.0, -// Sun Pro CC, IBM Visual Age, and HP aCC support. -#if defined(__GNUC__) || defined(_MSC_VER) || defined(__SUNPRO_CC) || \ - defined(__IBMCPP__) || defined(__HP_aCC) -# define GTEST_HAS_TYPED_TEST 1 -# define GTEST_HAS_TYPED_TEST_P 1 -#endif - -// Determines whether the system compiler uses UTF-16 for encoding wide strings. -#define GTEST_WIDE_STRING_USES_UTF16_ \ - (GTEST_OS_WINDOWS || GTEST_OS_CYGWIN || GTEST_OS_AIX || GTEST_OS_OS2) - -// Determines whether test results can be streamed to a socket. -#if GTEST_OS_LINUX || GTEST_OS_GNU_KFREEBSD || GTEST_OS_DRAGONFLY || \ - GTEST_OS_FREEBSD || GTEST_OS_NETBSD || GTEST_OS_OPENBSD -# define GTEST_CAN_STREAM_RESULTS_ 1 -#endif - -// Defines some utility macros. - -// The GNU compiler emits a warning if nested "if" statements are followed by -// an "else" statement and braces are not used to explicitly disambiguate the -// "else" binding. This leads to problems with code like: -// -// if (gate) -// ASSERT_*(condition) << "Some message"; -// -// The "switch (0) case 0:" idiom is used to suppress this. -#ifdef __INTEL_COMPILER -# define GTEST_AMBIGUOUS_ELSE_BLOCKER_ -#else -# define GTEST_AMBIGUOUS_ELSE_BLOCKER_ switch (0) case 0: default: // NOLINT -#endif - -// Use this annotation at the end of a struct/class definition to -// prevent the compiler from optimizing away instances that are never -// used. This is useful when all interesting logic happens inside the -// c'tor and / or d'tor. Example: -// -// struct Foo { -// Foo() { ... } -// } GTEST_ATTRIBUTE_UNUSED_; -// -// Also use it after a variable or parameter declaration to tell the -// compiler the variable/parameter does not have to be used. -#if defined(__GNUC__) && !defined(COMPILER_ICC) -# define GTEST_ATTRIBUTE_UNUSED_ __attribute__ ((unused)) -#elif defined(__clang__) -# if __has_attribute(unused) -# define GTEST_ATTRIBUTE_UNUSED_ __attribute__ ((unused)) -# endif -#endif -#ifndef GTEST_ATTRIBUTE_UNUSED_ -# define GTEST_ATTRIBUTE_UNUSED_ -#endif - -// Use this annotation before a function that takes a printf format string. -#if (defined(__GNUC__) || defined(__clang__)) && !defined(COMPILER_ICC) -# if defined(__MINGW_PRINTF_FORMAT) -// MinGW has two different printf implementations. Ensure the format macro -// matches the selected implementation. See -// https://sourceforge.net/p/mingw-w64/wiki2/gnu%20printf/. -# define GTEST_ATTRIBUTE_PRINTF_(string_index, first_to_check) \ - __attribute__((__format__(__MINGW_PRINTF_FORMAT, string_index, \ - first_to_check))) -# else -# define GTEST_ATTRIBUTE_PRINTF_(string_index, first_to_check) \ - __attribute__((__format__(__printf__, string_index, first_to_check))) -# endif -#else -# define GTEST_ATTRIBUTE_PRINTF_(string_index, first_to_check) -#endif - - -// A macro to disallow copy operator= -// This should be used in the private: declarations for a class. -#define GTEST_DISALLOW_ASSIGN_(type) \ - type& operator=(type const &) = delete - -// A macro to disallow copy constructor and operator= -// This should be used in the private: declarations for a class. -#define GTEST_DISALLOW_COPY_AND_ASSIGN_(type) \ - type(type const&) = delete; \ - type& operator=(type const&) = delete - -// A macro to disallow move operator= -// This should be used in the private: declarations for a class. -#define GTEST_DISALLOW_MOVE_ASSIGN_(type) \ - type& operator=(type &&) noexcept = delete - -// A macro to disallow move constructor and operator= -// This should be used in the private: declarations for a class. -#define GTEST_DISALLOW_MOVE_AND_ASSIGN_(type) \ - type(type&&) noexcept = delete; \ - type& operator=(type&&) noexcept = delete - -// Tell the compiler to warn about unused return values for functions declared -// with this macro. The macro should be used on function declarations -// following the argument list: -// -// Sprocket* AllocateSprocket() GTEST_MUST_USE_RESULT_; -#if defined(__GNUC__) && !defined(COMPILER_ICC) -# define GTEST_MUST_USE_RESULT_ __attribute__ ((warn_unused_result)) -#else -# define GTEST_MUST_USE_RESULT_ -#endif // __GNUC__ && !COMPILER_ICC - -// MS C++ compiler emits warning when a conditional expression is compile time -// constant. In some contexts this warning is false positive and needs to be -// suppressed. Use the following two macros in such cases: -// -// GTEST_INTENTIONAL_CONST_COND_PUSH_() -// while (true) { -// GTEST_INTENTIONAL_CONST_COND_POP_() -// } -# define GTEST_INTENTIONAL_CONST_COND_PUSH_() \ - GTEST_DISABLE_MSC_WARNINGS_PUSH_(4127) -# define GTEST_INTENTIONAL_CONST_COND_POP_() \ - GTEST_DISABLE_MSC_WARNINGS_POP_() - -// Determine whether the compiler supports Microsoft's Structured Exception -// Handling. This is supported by several Windows compilers but generally -// does not exist on any other system. -#ifndef GTEST_HAS_SEH -// The user didn't tell us, so we need to figure it out. - -# if defined(_MSC_VER) || defined(__BORLANDC__) -// These two compilers are known to support SEH. -# define GTEST_HAS_SEH 1 -# else -// Assume no SEH. -# define GTEST_HAS_SEH 0 -# endif - -#endif // GTEST_HAS_SEH - -#ifndef GTEST_IS_THREADSAFE - -#define GTEST_IS_THREADSAFE \ - (GTEST_HAS_MUTEX_AND_THREAD_LOCAL_ || \ - (GTEST_OS_WINDOWS && !GTEST_OS_WINDOWS_PHONE && !GTEST_OS_WINDOWS_RT) || \ - GTEST_HAS_PTHREAD) - -#endif // GTEST_IS_THREADSAFE - -// GTEST_API_ qualifies all symbols that must be exported. The definitions below -// are guarded by #ifndef to give embedders a chance to define GTEST_API_ in -// gtest/internal/custom/gtest-port.h -#ifndef GTEST_API_ - -#ifdef _MSC_VER -# if GTEST_LINKED_AS_SHARED_LIBRARY -# define GTEST_API_ __declspec(dllimport) -# elif GTEST_CREATE_SHARED_LIBRARY -# define GTEST_API_ __declspec(dllexport) -# endif -#elif __GNUC__ >= 4 || defined(__clang__) -# define GTEST_API_ __attribute__((visibility ("default"))) -#endif // _MSC_VER - -#endif // GTEST_API_ - -#ifndef GTEST_API_ -# define GTEST_API_ -#endif // GTEST_API_ - -#ifndef GTEST_DEFAULT_DEATH_TEST_STYLE -# define GTEST_DEFAULT_DEATH_TEST_STYLE "fast" -#endif // GTEST_DEFAULT_DEATH_TEST_STYLE - -#ifdef __GNUC__ -// Ask the compiler to never inline a given function. -# define GTEST_NO_INLINE_ __attribute__((noinline)) -#else -# define GTEST_NO_INLINE_ -#endif - -// _LIBCPP_VERSION is defined by the libc++ library from the LLVM project. -#if !defined(GTEST_HAS_CXXABI_H_) -# if defined(__GLIBCXX__) || (defined(_LIBCPP_VERSION) && !defined(_MSC_VER)) -# define GTEST_HAS_CXXABI_H_ 1 -# else -# define GTEST_HAS_CXXABI_H_ 0 -# endif -#endif - -// A function level attribute to disable checking for use of uninitialized -// memory when built with MemorySanitizer. -#if defined(__clang__) -# if __has_feature(memory_sanitizer) -# define GTEST_ATTRIBUTE_NO_SANITIZE_MEMORY_ \ - __attribute__((no_sanitize_memory)) -# else -# define GTEST_ATTRIBUTE_NO_SANITIZE_MEMORY_ -# endif // __has_feature(memory_sanitizer) -#else -# define GTEST_ATTRIBUTE_NO_SANITIZE_MEMORY_ -#endif // __clang__ - -// A function level attribute to disable AddressSanitizer instrumentation. -#if defined(__clang__) -# if __has_feature(address_sanitizer) -# define GTEST_ATTRIBUTE_NO_SANITIZE_ADDRESS_ \ - __attribute__((no_sanitize_address)) -# else -# define GTEST_ATTRIBUTE_NO_SANITIZE_ADDRESS_ -# endif // __has_feature(address_sanitizer) -#else -# define GTEST_ATTRIBUTE_NO_SANITIZE_ADDRESS_ -#endif // __clang__ - -// A function level attribute to disable HWAddressSanitizer instrumentation. -#if defined(__clang__) -# if __has_feature(hwaddress_sanitizer) -# define GTEST_ATTRIBUTE_NO_SANITIZE_HWADDRESS_ \ - __attribute__((no_sanitize("hwaddress"))) -# else -# define GTEST_ATTRIBUTE_NO_SANITIZE_HWADDRESS_ -# endif // __has_feature(hwaddress_sanitizer) -#else -# define GTEST_ATTRIBUTE_NO_SANITIZE_HWADDRESS_ -#endif // __clang__ - -// A function level attribute to disable ThreadSanitizer instrumentation. -#if defined(__clang__) -# if __has_feature(thread_sanitizer) -# define GTEST_ATTRIBUTE_NO_SANITIZE_THREAD_ \ - __attribute__((no_sanitize_thread)) -# else -# define GTEST_ATTRIBUTE_NO_SANITIZE_THREAD_ -# endif // __has_feature(thread_sanitizer) -#else -# define GTEST_ATTRIBUTE_NO_SANITIZE_THREAD_ -#endif // __clang__ - -namespace testing { - -class Message; - -// Legacy imports for backwards compatibility. -// New code should use std:: names directly. -using std::get; -using std::make_tuple; -using std::tuple; -using std::tuple_element; -using std::tuple_size; - -namespace internal { - -// A secret type that Google Test users don't know about. It has no -// definition on purpose. Therefore it's impossible to create a -// Secret object, which is what we want. -class Secret; - -// The GTEST_COMPILE_ASSERT_ is a legacy macro used to verify that a compile -// time expression is true (in new code, use static_assert instead). For -// example, you could use it to verify the size of a static array: -// -// GTEST_COMPILE_ASSERT_(GTEST_ARRAY_SIZE_(names) == NUM_NAMES, -// names_incorrect_size); -// -// The second argument to the macro must be a valid C++ identifier. If the -// expression is false, compiler will issue an error containing this identifier. -#define GTEST_COMPILE_ASSERT_(expr, msg) static_assert(expr, #msg) - -// A helper for suppressing warnings on constant condition. It just -// returns 'condition'. -GTEST_API_ bool IsTrue(bool condition); - -// Defines RE. - -#if GTEST_USES_PCRE -// if used, PCRE is injected by custom/gtest-port.h -#elif GTEST_USES_POSIX_RE || GTEST_USES_SIMPLE_RE - -// A simple C++ wrapper for <regex.h>. It uses the POSIX Extended -// Regular Expression syntax. -class GTEST_API_ RE { - public: - // A copy constructor is required by the Standard to initialize object - // references from r-values. - RE(const RE& other) { Init(other.pattern()); } - - // Constructs an RE from a string. - RE(const ::std::string& regex) { Init(regex.c_str()); } // NOLINT - - RE(const char* regex) { Init(regex); } // NOLINT - ~RE(); - - // Returns the string representation of the regex. - const char* pattern() const { return pattern_; } - - // FullMatch(str, re) returns true if and only if regular expression re - // matches the entire str. - // PartialMatch(str, re) returns true if and only if regular expression re - // matches a substring of str (including str itself). - static bool FullMatch(const ::std::string& str, const RE& re) { - return FullMatch(str.c_str(), re); - } - static bool PartialMatch(const ::std::string& str, const RE& re) { - return PartialMatch(str.c_str(), re); - } - - static bool FullMatch(const char* str, const RE& re); - static bool PartialMatch(const char* str, const RE& re); - - private: - void Init(const char* regex); - const char* pattern_; - bool is_valid_; - -# if GTEST_USES_POSIX_RE - - regex_t full_regex_; // For FullMatch(). - regex_t partial_regex_; // For PartialMatch(). - -# else // GTEST_USES_SIMPLE_RE - - const char* full_pattern_; // For FullMatch(); - -# endif -}; - -#endif // GTEST_USES_PCRE - -// Formats a source file path and a line number as they would appear -// in an error message from the compiler used to compile this code. -GTEST_API_ ::std::string FormatFileLocation(const char* file, int line); - -// Formats a file location for compiler-independent XML output. -// Although this function is not platform dependent, we put it next to -// FormatFileLocation in order to contrast the two functions. -GTEST_API_ ::std::string FormatCompilerIndependentFileLocation(const char* file, - int line); - -// Defines logging utilities: -// GTEST_LOG_(severity) - logs messages at the specified severity level. The -// message itself is streamed into the macro. -// LogToStderr() - directs all log messages to stderr. -// FlushInfoLog() - flushes informational log messages. - -enum GTestLogSeverity { - GTEST_INFO, - GTEST_WARNING, - GTEST_ERROR, - GTEST_FATAL -}; - -// Formats log entry severity, provides a stream object for streaming the -// log message, and terminates the message with a newline when going out of -// scope. -class GTEST_API_ GTestLog { - public: - GTestLog(GTestLogSeverity severity, const char* file, int line); - - // Flushes the buffers and, if severity is GTEST_FATAL, aborts the program. - ~GTestLog(); - - ::std::ostream& GetStream() { return ::std::cerr; } - - private: - const GTestLogSeverity severity_; - - GTEST_DISALLOW_COPY_AND_ASSIGN_(GTestLog); -}; - -#if !defined(GTEST_LOG_) - -# define GTEST_LOG_(severity) \ - ::testing::internal::GTestLog(::testing::internal::GTEST_##severity, \ - __FILE__, __LINE__).GetStream() - -inline void LogToStderr() {} -inline void FlushInfoLog() { fflush(nullptr); } - -#endif // !defined(GTEST_LOG_) - -#if !defined(GTEST_CHECK_) -// INTERNAL IMPLEMENTATION - DO NOT USE. -// -// GTEST_CHECK_ is an all-mode assert. It aborts the program if the condition -// is not satisfied. -// Synopsys: -// GTEST_CHECK_(boolean_condition); -// or -// GTEST_CHECK_(boolean_condition) << "Additional message"; -// -// This checks the condition and if the condition is not satisfied -// it prints message about the condition violation, including the -// condition itself, plus additional message streamed into it, if any, -// and then it aborts the program. It aborts the program irrespective of -// whether it is built in the debug mode or not. -# define GTEST_CHECK_(condition) \ - GTEST_AMBIGUOUS_ELSE_BLOCKER_ \ - if (::testing::internal::IsTrue(condition)) \ - ; \ - else \ - GTEST_LOG_(FATAL) << "Condition " #condition " failed. " -#endif // !defined(GTEST_CHECK_) - -// An all-mode assert to verify that the given POSIX-style function -// call returns 0 (indicating success). Known limitation: this -// doesn't expand to a balanced 'if' statement, so enclose the macro -// in {} if you need to use it as the only statement in an 'if' -// branch. -#define GTEST_CHECK_POSIX_SUCCESS_(posix_call) \ - if (const int gtest_error = (posix_call)) \ - GTEST_LOG_(FATAL) << #posix_call << "failed with error " \ - << gtest_error - -// Transforms "T" into "const T&" according to standard reference collapsing -// rules (this is only needed as a backport for C++98 compilers that do not -// support reference collapsing). Specifically, it transforms: -// -// char ==> const char& -// const char ==> const char& -// char& ==> char& -// const char& ==> const char& -// -// Note that the non-const reference will not have "const" added. This is -// standard, and necessary so that "T" can always bind to "const T&". -template <typename T> -struct ConstRef { typedef const T& type; }; -template <typename T> -struct ConstRef<T&> { typedef T& type; }; - -// The argument T must depend on some template parameters. -#define GTEST_REFERENCE_TO_CONST_(T) \ - typename ::testing::internal::ConstRef<T>::type - -// INTERNAL IMPLEMENTATION - DO NOT USE IN USER CODE. -// -// Use ImplicitCast_ as a safe version of static_cast for upcasting in -// the type hierarchy (e.g. casting a Foo* to a SuperclassOfFoo* or a -// const Foo*). When you use ImplicitCast_, the compiler checks that -// the cast is safe. Such explicit ImplicitCast_s are necessary in -// surprisingly many situations where C++ demands an exact type match -// instead of an argument type convertable to a target type. -// -// The syntax for using ImplicitCast_ is the same as for static_cast: -// -// ImplicitCast_<ToType>(expr) -// -// ImplicitCast_ would have been part of the C++ standard library, -// but the proposal was submitted too late. It will probably make -// its way into the language in the future. -// -// This relatively ugly name is intentional. It prevents clashes with -// similar functions users may have (e.g., implicit_cast). The internal -// namespace alone is not enough because the function can be found by ADL. -template<typename To> -inline To ImplicitCast_(To x) { return x; } - -// When you upcast (that is, cast a pointer from type Foo to type -// SuperclassOfFoo), it's fine to use ImplicitCast_<>, since upcasts -// always succeed. When you downcast (that is, cast a pointer from -// type Foo to type SubclassOfFoo), static_cast<> isn't safe, because -// how do you know the pointer is really of type SubclassOfFoo? It -// could be a bare Foo, or of type DifferentSubclassOfFoo. Thus, -// when you downcast, you should use this macro. In debug mode, we -// use dynamic_cast<> to double-check the downcast is legal (we die -// if it's not). In normal mode, we do the efficient static_cast<> -// instead. Thus, it's important to test in debug mode to make sure -// the cast is legal! -// This is the only place in the code we should use dynamic_cast<>. -// In particular, you SHOULDN'T be using dynamic_cast<> in order to -// do RTTI (eg code like this: -// if (dynamic_cast<Subclass1>(foo)) HandleASubclass1Object(foo); -// if (dynamic_cast<Subclass2>(foo)) HandleASubclass2Object(foo); -// You should design the code some other way not to need this. -// -// This relatively ugly name is intentional. It prevents clashes with -// similar functions users may have (e.g., down_cast). The internal -// namespace alone is not enough because the function can be found by ADL. -template<typename To, typename From> // use like this: DownCast_<T*>(foo); -inline To DownCast_(From* f) { // so we only accept pointers - // Ensures that To is a sub-type of From *. This test is here only - // for compile-time type checking, and has no overhead in an - // optimized build at run-time, as it will be optimized away - // completely. - GTEST_INTENTIONAL_CONST_COND_PUSH_() - if (false) { - GTEST_INTENTIONAL_CONST_COND_POP_() - const To to = nullptr; - ::testing::internal::ImplicitCast_<From*>(to); - } - -#if GTEST_HAS_RTTI - // RTTI: debug mode only! - GTEST_CHECK_(f == nullptr || dynamic_cast<To>(f) != nullptr); -#endif - return static_cast<To>(f); -} - -// Downcasts the pointer of type Base to Derived. -// Derived must be a subclass of Base. The parameter MUST -// point to a class of type Derived, not any subclass of it. -// When RTTI is available, the function performs a runtime -// check to enforce this. -template <class Derived, class Base> -Derived* CheckedDowncastToActualType(Base* base) { -#if GTEST_HAS_RTTI - GTEST_CHECK_(typeid(*base) == typeid(Derived)); -#endif - -#if GTEST_HAS_DOWNCAST_ - return ::down_cast<Derived*>(base); -#elif GTEST_HAS_RTTI - return dynamic_cast<Derived*>(base); // NOLINT -#else - return static_cast<Derived*>(base); // Poor man's downcast. -#endif -} - -#if GTEST_HAS_STREAM_REDIRECTION - -// Defines the stderr capturer: -// CaptureStdout - starts capturing stdout. -// GetCapturedStdout - stops capturing stdout and returns the captured string. -// CaptureStderr - starts capturing stderr. -// GetCapturedStderr - stops capturing stderr and returns the captured string. -// -GTEST_API_ void CaptureStdout(); -GTEST_API_ std::string GetCapturedStdout(); -GTEST_API_ void CaptureStderr(); -GTEST_API_ std::string GetCapturedStderr(); - -#endif // GTEST_HAS_STREAM_REDIRECTION -// Returns the size (in bytes) of a file. -GTEST_API_ size_t GetFileSize(FILE* file); - -// Reads the entire content of a file as a string. -GTEST_API_ std::string ReadEntireFile(FILE* file); - -// All command line arguments. -GTEST_API_ std::vector<std::string> GetArgvs(); - -#if GTEST_HAS_DEATH_TEST - -std::vector<std::string> GetInjectableArgvs(); -// Deprecated: pass the args vector by value instead. -void SetInjectableArgvs(const std::vector<std::string>* new_argvs); -void SetInjectableArgvs(const std::vector<std::string>& new_argvs); -void ClearInjectableArgvs(); - -#endif // GTEST_HAS_DEATH_TEST - -// Defines synchronization primitives. -#if GTEST_IS_THREADSAFE -# if GTEST_HAS_PTHREAD -// Sleeps for (roughly) n milliseconds. This function is only for testing -// Google Test's own constructs. Don't use it in user tests, either -// directly or indirectly. -inline void SleepMilliseconds(int n) { - const timespec time = { - 0, // 0 seconds. - n * 1000L * 1000L, // And n ms. - }; - nanosleep(&time, nullptr); -} -# endif // GTEST_HAS_PTHREAD - -# if GTEST_HAS_NOTIFICATION_ -// Notification has already been imported into the namespace. -// Nothing to do here. - -# elif GTEST_HAS_PTHREAD -// Allows a controller thread to pause execution of newly created -// threads until notified. Instances of this class must be created -// and destroyed in the controller thread. -// -// This class is only for testing Google Test's own constructs. Do not -// use it in user tests, either directly or indirectly. -class Notification { - public: - Notification() : notified_(false) { - GTEST_CHECK_POSIX_SUCCESS_(pthread_mutex_init(&mutex_, nullptr)); - } - ~Notification() { - pthread_mutex_destroy(&mutex_); - } - - // Notifies all threads created with this notification to start. Must - // be called from the controller thread. - void Notify() { - pthread_mutex_lock(&mutex_); - notified_ = true; - pthread_mutex_unlock(&mutex_); - } - - // Blocks until the controller thread notifies. Must be called from a test - // thread. - void WaitForNotification() { - for (;;) { - pthread_mutex_lock(&mutex_); - const bool notified = notified_; - pthread_mutex_unlock(&mutex_); - if (notified) - break; - SleepMilliseconds(10); - } - } - - private: - pthread_mutex_t mutex_; - bool notified_; - - GTEST_DISALLOW_COPY_AND_ASSIGN_(Notification); -}; - -# elif GTEST_OS_WINDOWS && !GTEST_OS_WINDOWS_PHONE && !GTEST_OS_WINDOWS_RT - -GTEST_API_ void SleepMilliseconds(int n); - -// Provides leak-safe Windows kernel handle ownership. -// Used in death tests and in threading support. -class GTEST_API_ AutoHandle { - public: - // Assume that Win32 HANDLE type is equivalent to void*. Doing so allows us to - // avoid including <windows.h> in this header file. Including <windows.h> is - // undesirable because it defines a lot of symbols and macros that tend to - // conflict with client code. This assumption is verified by - // WindowsTypesTest.HANDLEIsVoidStar. - typedef void* Handle; - AutoHandle(); - explicit AutoHandle(Handle handle); - - ~AutoHandle(); - - Handle Get() const; - void Reset(); - void Reset(Handle handle); - - private: - // Returns true if and only if the handle is a valid handle object that can be - // closed. - bool IsCloseable() const; - - Handle handle_; - - GTEST_DISALLOW_COPY_AND_ASSIGN_(AutoHandle); -}; - -// Allows a controller thread to pause execution of newly created -// threads until notified. Instances of this class must be created -// and destroyed in the controller thread. -// -// This class is only for testing Google Test's own constructs. Do not -// use it in user tests, either directly or indirectly. -class GTEST_API_ Notification { - public: - Notification(); - void Notify(); - void WaitForNotification(); - - private: - AutoHandle event_; - - GTEST_DISALLOW_COPY_AND_ASSIGN_(Notification); -}; -# endif // GTEST_HAS_NOTIFICATION_ - -// On MinGW, we can have both GTEST_OS_WINDOWS and GTEST_HAS_PTHREAD -// defined, but we don't want to use MinGW's pthreads implementation, which -// has conformance problems with some versions of the POSIX standard. -# if GTEST_HAS_PTHREAD && !GTEST_OS_WINDOWS_MINGW - -// As a C-function, ThreadFuncWithCLinkage cannot be templated itself. -// Consequently, it cannot select a correct instantiation of ThreadWithParam -// in order to call its Run(). Introducing ThreadWithParamBase as a -// non-templated base class for ThreadWithParam allows us to bypass this -// problem. -class ThreadWithParamBase { - public: - virtual ~ThreadWithParamBase() {} - virtual void Run() = 0; -}; - -// pthread_create() accepts a pointer to a function type with the C linkage. -// According to the Standard (7.5/1), function types with different linkages -// are different even if they are otherwise identical. Some compilers (for -// example, SunStudio) treat them as different types. Since class methods -// cannot be defined with C-linkage we need to define a free C-function to -// pass into pthread_create(). -extern "C" inline void* ThreadFuncWithCLinkage(void* thread) { - static_cast<ThreadWithParamBase*>(thread)->Run(); - return nullptr; -} - -// Helper class for testing Google Test's multi-threading constructs. -// To use it, write: -// -// void ThreadFunc(int param) { /* Do things with param */ } -// Notification thread_can_start; -// ... -// // The thread_can_start parameter is optional; you can supply NULL. -// ThreadWithParam<int> thread(&ThreadFunc, 5, &thread_can_start); -// thread_can_start.Notify(); -// -// These classes are only for testing Google Test's own constructs. Do -// not use them in user tests, either directly or indirectly. -template <typename T> -class ThreadWithParam : public ThreadWithParamBase { - public: - typedef void UserThreadFunc(T); - - ThreadWithParam(UserThreadFunc* func, T param, Notification* thread_can_start) - : func_(func), - param_(param), - thread_can_start_(thread_can_start), - finished_(false) { - ThreadWithParamBase* const base = this; - // The thread can be created only after all fields except thread_ - // have been initialized. - GTEST_CHECK_POSIX_SUCCESS_( - pthread_create(&thread_, nullptr, &ThreadFuncWithCLinkage, base)); - } - ~ThreadWithParam() override { Join(); } - - void Join() { - if (!finished_) { - GTEST_CHECK_POSIX_SUCCESS_(pthread_join(thread_, nullptr)); - finished_ = true; - } - } - - void Run() override { - if (thread_can_start_ != nullptr) thread_can_start_->WaitForNotification(); - func_(param_); - } - - private: - UserThreadFunc* const func_; // User-supplied thread function. - const T param_; // User-supplied parameter to the thread function. - // When non-NULL, used to block execution until the controller thread - // notifies. - Notification* const thread_can_start_; - bool finished_; // true if and only if we know that the thread function has - // finished. - pthread_t thread_; // The native thread object. - - GTEST_DISALLOW_COPY_AND_ASSIGN_(ThreadWithParam); -}; -# endif // !GTEST_OS_WINDOWS && GTEST_HAS_PTHREAD || - // GTEST_HAS_MUTEX_AND_THREAD_LOCAL_ - -# if GTEST_HAS_MUTEX_AND_THREAD_LOCAL_ -// Mutex and ThreadLocal have already been imported into the namespace. -// Nothing to do here. - -# elif GTEST_OS_WINDOWS && !GTEST_OS_WINDOWS_PHONE && !GTEST_OS_WINDOWS_RT - -// Mutex implements mutex on Windows platforms. It is used in conjunction -// with class MutexLock: -// -// Mutex mutex; -// ... -// MutexLock lock(&mutex); // Acquires the mutex and releases it at the -// // end of the current scope. -// -// A static Mutex *must* be defined or declared using one of the following -// macros: -// GTEST_DEFINE_STATIC_MUTEX_(g_some_mutex); -// GTEST_DECLARE_STATIC_MUTEX_(g_some_mutex); -// -// (A non-static Mutex is defined/declared in the usual way). -class GTEST_API_ Mutex { - public: - enum MutexType { kStatic = 0, kDynamic = 1 }; - // We rely on kStaticMutex being 0 as it is to what the linker initializes - // type_ in static mutexes. critical_section_ will be initialized lazily - // in ThreadSafeLazyInit(). - enum StaticConstructorSelector { kStaticMutex = 0 }; - - // This constructor intentionally does nothing. It relies on type_ being - // statically initialized to 0 (effectively setting it to kStatic) and on - // ThreadSafeLazyInit() to lazily initialize the rest of the members. - explicit Mutex(StaticConstructorSelector /*dummy*/) {} - - Mutex(); - ~Mutex(); - - void Lock(); - - void Unlock(); - - // Does nothing if the current thread holds the mutex. Otherwise, crashes - // with high probability. - void AssertHeld(); - - private: - // Initializes owner_thread_id_ and critical_section_ in static mutexes. - void ThreadSafeLazyInit(); - - // Per https://blogs.msdn.microsoft.com/oldnewthing/20040223-00/?p=40503, - // we assume that 0 is an invalid value for thread IDs. - unsigned int owner_thread_id_; - - // For static mutexes, we rely on these members being initialized to zeros - // by the linker. - MutexType type_; - long critical_section_init_phase_; // NOLINT - GTEST_CRITICAL_SECTION* critical_section_; - - GTEST_DISALLOW_COPY_AND_ASSIGN_(Mutex); -}; - -# define GTEST_DECLARE_STATIC_MUTEX_(mutex) \ - extern ::testing::internal::Mutex mutex - -# define GTEST_DEFINE_STATIC_MUTEX_(mutex) \ - ::testing::internal::Mutex mutex(::testing::internal::Mutex::kStaticMutex) - -// We cannot name this class MutexLock because the ctor declaration would -// conflict with a macro named MutexLock, which is defined on some -// platforms. That macro is used as a defensive measure to prevent against -// inadvertent misuses of MutexLock like "MutexLock(&mu)" rather than -// "MutexLock l(&mu)". Hence the typedef trick below. -class GTestMutexLock { - public: - explicit GTestMutexLock(Mutex* mutex) - : mutex_(mutex) { mutex_->Lock(); } - - ~GTestMutexLock() { mutex_->Unlock(); } - - private: - Mutex* const mutex_; - - GTEST_DISALLOW_COPY_AND_ASSIGN_(GTestMutexLock); -}; - -typedef GTestMutexLock MutexLock; - -// Base class for ValueHolder<T>. Allows a caller to hold and delete a value -// without knowing its type. -class ThreadLocalValueHolderBase { - public: - virtual ~ThreadLocalValueHolderBase() {} -}; - -// Provides a way for a thread to send notifications to a ThreadLocal -// regardless of its parameter type. -class ThreadLocalBase { - public: - // Creates a new ValueHolder<T> object holding a default value passed to - // this ThreadLocal<T>'s constructor and returns it. It is the caller's - // responsibility not to call this when the ThreadLocal<T> instance already - // has a value on the current thread. - virtual ThreadLocalValueHolderBase* NewValueForCurrentThread() const = 0; - - protected: - ThreadLocalBase() {} - virtual ~ThreadLocalBase() {} - - private: - GTEST_DISALLOW_COPY_AND_ASSIGN_(ThreadLocalBase); -}; - -// Maps a thread to a set of ThreadLocals that have values instantiated on that -// thread and notifies them when the thread exits. A ThreadLocal instance is -// expected to persist until all threads it has values on have terminated. -class GTEST_API_ ThreadLocalRegistry { - public: - // Registers thread_local_instance as having value on the current thread. - // Returns a value that can be used to identify the thread from other threads. - static ThreadLocalValueHolderBase* GetValueOnCurrentThread( - const ThreadLocalBase* thread_local_instance); - - // Invoked when a ThreadLocal instance is destroyed. - static void OnThreadLocalDestroyed( - const ThreadLocalBase* thread_local_instance); -}; - -class GTEST_API_ ThreadWithParamBase { - public: - void Join(); - - protected: - class Runnable { - public: - virtual ~Runnable() {} - virtual void Run() = 0; - }; - - ThreadWithParamBase(Runnable *runnable, Notification* thread_can_start); - virtual ~ThreadWithParamBase(); - - private: - AutoHandle thread_; -}; - -// Helper class for testing Google Test's multi-threading constructs. -template <typename T> -class ThreadWithParam : public ThreadWithParamBase { - public: - typedef void UserThreadFunc(T); - - ThreadWithParam(UserThreadFunc* func, T param, Notification* thread_can_start) - : ThreadWithParamBase(new RunnableImpl(func, param), thread_can_start) { - } - virtual ~ThreadWithParam() {} - - private: - class RunnableImpl : public Runnable { - public: - RunnableImpl(UserThreadFunc* func, T param) - : func_(func), - param_(param) { - } - virtual ~RunnableImpl() {} - virtual void Run() { - func_(param_); - } - - private: - UserThreadFunc* const func_; - const T param_; - - GTEST_DISALLOW_COPY_AND_ASSIGN_(RunnableImpl); - }; - - GTEST_DISALLOW_COPY_AND_ASSIGN_(ThreadWithParam); -}; - -// Implements thread-local storage on Windows systems. -// -// // Thread 1 -// ThreadLocal<int> tl(100); // 100 is the default value for each thread. -// -// // Thread 2 -// tl.set(150); // Changes the value for thread 2 only. -// EXPECT_EQ(150, tl.get()); -// -// // Thread 1 -// EXPECT_EQ(100, tl.get()); // In thread 1, tl has the original value. -// tl.set(200); -// EXPECT_EQ(200, tl.get()); -// -// The template type argument T must have a public copy constructor. -// In addition, the default ThreadLocal constructor requires T to have -// a public default constructor. -// -// The users of a TheadLocal instance have to make sure that all but one -// threads (including the main one) using that instance have exited before -// destroying it. Otherwise, the per-thread objects managed for them by the -// ThreadLocal instance are not guaranteed to be destroyed on all platforms. -// -// Google Test only uses global ThreadLocal objects. That means they -// will die after main() has returned. Therefore, no per-thread -// object managed by Google Test will be leaked as long as all threads -// using Google Test have exited when main() returns. -template <typename T> -class ThreadLocal : public ThreadLocalBase { - public: - ThreadLocal() : default_factory_(new DefaultValueHolderFactory()) {} - explicit ThreadLocal(const T& value) - : default_factory_(new InstanceValueHolderFactory(value)) {} - - ~ThreadLocal() { ThreadLocalRegistry::OnThreadLocalDestroyed(this); } - - T* pointer() { return GetOrCreateValue(); } - const T* pointer() const { return GetOrCreateValue(); } - const T& get() const { return *pointer(); } - void set(const T& value) { *pointer() = value; } - - private: - // Holds a value of T. Can be deleted via its base class without the caller - // knowing the type of T. - class ValueHolder : public ThreadLocalValueHolderBase { - public: - ValueHolder() : value_() {} - explicit ValueHolder(const T& value) : value_(value) {} - - T* pointer() { return &value_; } - - private: - T value_; - GTEST_DISALLOW_COPY_AND_ASSIGN_(ValueHolder); - }; - - - T* GetOrCreateValue() const { - return static_cast<ValueHolder*>( - ThreadLocalRegistry::GetValueOnCurrentThread(this))->pointer(); - } - - virtual ThreadLocalValueHolderBase* NewValueForCurrentThread() const { - return default_factory_->MakeNewHolder(); - } - - class ValueHolderFactory { - public: - ValueHolderFactory() {} - virtual ~ValueHolderFactory() {} - virtual ValueHolder* MakeNewHolder() const = 0; - - private: - GTEST_DISALLOW_COPY_AND_ASSIGN_(ValueHolderFactory); - }; - - class DefaultValueHolderFactory : public ValueHolderFactory { - public: - DefaultValueHolderFactory() {} - ValueHolder* MakeNewHolder() const override { return new ValueHolder(); } - - private: - GTEST_DISALLOW_COPY_AND_ASSIGN_(DefaultValueHolderFactory); - }; - - class InstanceValueHolderFactory : public ValueHolderFactory { - public: - explicit InstanceValueHolderFactory(const T& value) : value_(value) {} - ValueHolder* MakeNewHolder() const override { - return new ValueHolder(value_); - } - - private: - const T value_; // The value for each thread. - - GTEST_DISALLOW_COPY_AND_ASSIGN_(InstanceValueHolderFactory); - }; - - std::unique_ptr<ValueHolderFactory> default_factory_; - - GTEST_DISALLOW_COPY_AND_ASSIGN_(ThreadLocal); -}; - -# elif GTEST_HAS_PTHREAD - -// MutexBase and Mutex implement mutex on pthreads-based platforms. -class MutexBase { - public: - // Acquires this mutex. - void Lock() { - GTEST_CHECK_POSIX_SUCCESS_(pthread_mutex_lock(&mutex_)); - owner_ = pthread_self(); - has_owner_ = true; - } - - // Releases this mutex. - void Unlock() { - // Since the lock is being released the owner_ field should no longer be - // considered valid. We don't protect writing to has_owner_ here, as it's - // the caller's responsibility to ensure that the current thread holds the - // mutex when this is called. - has_owner_ = false; - GTEST_CHECK_POSIX_SUCCESS_(pthread_mutex_unlock(&mutex_)); - } - - // Does nothing if the current thread holds the mutex. Otherwise, crashes - // with high probability. - void AssertHeld() const { - GTEST_CHECK_(has_owner_ && pthread_equal(owner_, pthread_self())) - << "The current thread is not holding the mutex @" << this; - } - - // A static mutex may be used before main() is entered. It may even - // be used before the dynamic initialization stage. Therefore we - // must be able to initialize a static mutex object at link time. - // This means MutexBase has to be a POD and its member variables - // have to be public. - public: - pthread_mutex_t mutex_; // The underlying pthread mutex. - // has_owner_ indicates whether the owner_ field below contains a valid thread - // ID and is therefore safe to inspect (e.g., to use in pthread_equal()). All - // accesses to the owner_ field should be protected by a check of this field. - // An alternative might be to memset() owner_ to all zeros, but there's no - // guarantee that a zero'd pthread_t is necessarily invalid or even different - // from pthread_self(). - bool has_owner_; - pthread_t owner_; // The thread holding the mutex. -}; - -// Forward-declares a static mutex. -# define GTEST_DECLARE_STATIC_MUTEX_(mutex) \ - extern ::testing::internal::MutexBase mutex - -// Defines and statically (i.e. at link time) initializes a static mutex. -// The initialization list here does not explicitly initialize each field, -// instead relying on default initialization for the unspecified fields. In -// particular, the owner_ field (a pthread_t) is not explicitly initialized. -// This allows initialization to work whether pthread_t is a scalar or struct. -// The flag -Wmissing-field-initializers must not be specified for this to work. -#define GTEST_DEFINE_STATIC_MUTEX_(mutex) \ - ::testing::internal::MutexBase mutex = {PTHREAD_MUTEX_INITIALIZER, false, 0} - -// The Mutex class can only be used for mutexes created at runtime. It -// shares its API with MutexBase otherwise. -class Mutex : public MutexBase { - public: - Mutex() { - GTEST_CHECK_POSIX_SUCCESS_(pthread_mutex_init(&mutex_, nullptr)); - has_owner_ = false; - } - ~Mutex() { - GTEST_CHECK_POSIX_SUCCESS_(pthread_mutex_destroy(&mutex_)); - } - - private: - GTEST_DISALLOW_COPY_AND_ASSIGN_(Mutex); -}; - -// We cannot name this class MutexLock because the ctor declaration would -// conflict with a macro named MutexLock, which is defined on some -// platforms. That macro is used as a defensive measure to prevent against -// inadvertent misuses of MutexLock like "MutexLock(&mu)" rather than -// "MutexLock l(&mu)". Hence the typedef trick below. -class GTestMutexLock { - public: - explicit GTestMutexLock(MutexBase* mutex) - : mutex_(mutex) { mutex_->Lock(); } - - ~GTestMutexLock() { mutex_->Unlock(); } - - private: - MutexBase* const mutex_; - - GTEST_DISALLOW_COPY_AND_ASSIGN_(GTestMutexLock); -}; - -typedef GTestMutexLock MutexLock; - -// Helpers for ThreadLocal. - -// pthread_key_create() requires DeleteThreadLocalValue() to have -// C-linkage. Therefore it cannot be templatized to access -// ThreadLocal<T>. Hence the need for class -// ThreadLocalValueHolderBase. -class ThreadLocalValueHolderBase { - public: - virtual ~ThreadLocalValueHolderBase() {} -}; - -// Called by pthread to delete thread-local data stored by -// pthread_setspecific(). -extern "C" inline void DeleteThreadLocalValue(void* value_holder) { - delete static_cast<ThreadLocalValueHolderBase*>(value_holder); -} - -// Implements thread-local storage on pthreads-based systems. -template <typename T> -class GTEST_API_ ThreadLocal { - public: - ThreadLocal() - : key_(CreateKey()), default_factory_(new DefaultValueHolderFactory()) {} - explicit ThreadLocal(const T& value) - : key_(CreateKey()), - default_factory_(new InstanceValueHolderFactory(value)) {} - - ~ThreadLocal() { - // Destroys the managed object for the current thread, if any. - DeleteThreadLocalValue(pthread_getspecific(key_)); - - // Releases resources associated with the key. This will *not* - // delete managed objects for other threads. - GTEST_CHECK_POSIX_SUCCESS_(pthread_key_delete(key_)); - } - - T* pointer() { return GetOrCreateValue(); } - const T* pointer() const { return GetOrCreateValue(); } - const T& get() const { return *pointer(); } - void set(const T& value) { *pointer() = value; } - - private: - // Holds a value of type T. - class ValueHolder : public ThreadLocalValueHolderBase { - public: - ValueHolder() : value_() {} - explicit ValueHolder(const T& value) : value_(value) {} - - T* pointer() { return &value_; } - - private: - T value_; - GTEST_DISALLOW_COPY_AND_ASSIGN_(ValueHolder); - }; - - static pthread_key_t CreateKey() { - pthread_key_t key; - // When a thread exits, DeleteThreadLocalValue() will be called on - // the object managed for that thread. - GTEST_CHECK_POSIX_SUCCESS_( - pthread_key_create(&key, &DeleteThreadLocalValue)); - return key; - } - - T* GetOrCreateValue() const { - ThreadLocalValueHolderBase* const holder = - static_cast<ThreadLocalValueHolderBase*>(pthread_getspecific(key_)); - if (holder != nullptr) { - return CheckedDowncastToActualType<ValueHolder>(holder)->pointer(); - } - - ValueHolder* const new_holder = default_factory_->MakeNewHolder(); - ThreadLocalValueHolderBase* const holder_base = new_holder; - GTEST_CHECK_POSIX_SUCCESS_(pthread_setspecific(key_, holder_base)); - return new_holder->pointer(); - } - - class ValueHolderFactory { - public: - ValueHolderFactory() {} - virtual ~ValueHolderFactory() {} - virtual ValueHolder* MakeNewHolder() const = 0; - - private: - GTEST_DISALLOW_COPY_AND_ASSIGN_(ValueHolderFactory); - }; - - class DefaultValueHolderFactory : public ValueHolderFactory { - public: - DefaultValueHolderFactory() {} - ValueHolder* MakeNewHolder() const override { return new ValueHolder(); } - - private: - GTEST_DISALLOW_COPY_AND_ASSIGN_(DefaultValueHolderFactory); - }; - - class InstanceValueHolderFactory : public ValueHolderFactory { - public: - explicit InstanceValueHolderFactory(const T& value) : value_(value) {} - ValueHolder* MakeNewHolder() const override { - return new ValueHolder(value_); - } - - private: - const T value_; // The value for each thread. - - GTEST_DISALLOW_COPY_AND_ASSIGN_(InstanceValueHolderFactory); - }; - - // A key pthreads uses for looking up per-thread values. - const pthread_key_t key_; - std::unique_ptr<ValueHolderFactory> default_factory_; - - GTEST_DISALLOW_COPY_AND_ASSIGN_(ThreadLocal); -}; - -# endif // GTEST_HAS_MUTEX_AND_THREAD_LOCAL_ - -#else // GTEST_IS_THREADSAFE - -// A dummy implementation of synchronization primitives (mutex, lock, -// and thread-local variable). Necessary for compiling Google Test where -// mutex is not supported - using Google Test in multiple threads is not -// supported on such platforms. - -class Mutex { - public: - Mutex() {} - void Lock() {} - void Unlock() {} - void AssertHeld() const {} -}; - -# define GTEST_DECLARE_STATIC_MUTEX_(mutex) \ - extern ::testing::internal::Mutex mutex - -# define GTEST_DEFINE_STATIC_MUTEX_(mutex) ::testing::internal::Mutex mutex - -// We cannot name this class MutexLock because the ctor declaration would -// conflict with a macro named MutexLock, which is defined on some -// platforms. That macro is used as a defensive measure to prevent against -// inadvertent misuses of MutexLock like "MutexLock(&mu)" rather than -// "MutexLock l(&mu)". Hence the typedef trick below. -class GTestMutexLock { - public: - explicit GTestMutexLock(Mutex*) {} // NOLINT -}; - -typedef GTestMutexLock MutexLock; - -template <typename T> -class GTEST_API_ ThreadLocal { - public: - ThreadLocal() : value_() {} - explicit ThreadLocal(const T& value) : value_(value) {} - T* pointer() { return &value_; } - const T* pointer() const { return &value_; } - const T& get() const { return value_; } - void set(const T& value) { value_ = value; } - private: - T value_; -}; - -#endif // GTEST_IS_THREADSAFE - -// Returns the number of threads running in the process, or 0 to indicate that -// we cannot detect it. -GTEST_API_ size_t GetThreadCount(); - -#if GTEST_OS_WINDOWS -# define GTEST_PATH_SEP_ "\\" -# define GTEST_HAS_ALT_PATH_SEP_ 1 -#else -# define GTEST_PATH_SEP_ "/" -# define GTEST_HAS_ALT_PATH_SEP_ 0 -#endif // GTEST_OS_WINDOWS - -// Utilities for char. - -// isspace(int ch) and friends accept an unsigned char or EOF. char -// may be signed, depending on the compiler (or compiler flags). -// Therefore we need to cast a char to unsigned char before calling -// isspace(), etc. - -inline bool IsAlpha(char ch) { - return isalpha(static_cast<unsigned char>(ch)) != 0; -} -inline bool IsAlNum(char ch) { - return isalnum(static_cast<unsigned char>(ch)) != 0; -} -inline bool IsDigit(char ch) { - return isdigit(static_cast<unsigned char>(ch)) != 0; -} -inline bool IsLower(char ch) { - return islower(static_cast<unsigned char>(ch)) != 0; -} -inline bool IsSpace(char ch) { - return isspace(static_cast<unsigned char>(ch)) != 0; -} -inline bool IsUpper(char ch) { - return isupper(static_cast<unsigned char>(ch)) != 0; -} -inline bool IsXDigit(char ch) { - return isxdigit(static_cast<unsigned char>(ch)) != 0; -} -#ifdef __cpp_char8_t -inline bool IsXDigit(char8_t ch) { - return isxdigit(static_cast<unsigned char>(ch)) != 0; -} -#endif -inline bool IsXDigit(char16_t ch) { - const unsigned char low_byte = static_cast<unsigned char>(ch); - return ch == low_byte && isxdigit(low_byte) != 0; -} -inline bool IsXDigit(char32_t ch) { - const unsigned char low_byte = static_cast<unsigned char>(ch); - return ch == low_byte && isxdigit(low_byte) != 0; -} -inline bool IsXDigit(wchar_t ch) { - const unsigned char low_byte = static_cast<unsigned char>(ch); - return ch == low_byte && isxdigit(low_byte) != 0; -} - -inline char ToLower(char ch) { - return static_cast<char>(tolower(static_cast<unsigned char>(ch))); -} -inline char ToUpper(char ch) { - return static_cast<char>(toupper(static_cast<unsigned char>(ch))); -} - -inline std::string StripTrailingSpaces(std::string str) { - std::string::iterator it = str.end(); - while (it != str.begin() && IsSpace(*--it)) - it = str.erase(it); - return str; -} - -// The testing::internal::posix namespace holds wrappers for common -// POSIX functions. These wrappers hide the differences between -// Windows/MSVC and POSIX systems. Since some compilers define these -// standard functions as macros, the wrapper cannot have the same name -// as the wrapped function. - -namespace posix { - -// Functions with a different name on Windows. - -#if GTEST_OS_WINDOWS - -typedef struct _stat StatStruct; - -# ifdef __BORLANDC__ -inline int DoIsATTY(int fd) { return isatty(fd); } -inline int StrCaseCmp(const char* s1, const char* s2) { - return stricmp(s1, s2); -} -inline char* StrDup(const char* src) { return strdup(src); } -# else // !__BORLANDC__ -# if GTEST_OS_WINDOWS_MOBILE -inline int DoIsATTY(int /* fd */) { return 0; } -# else -inline int DoIsATTY(int fd) { return _isatty(fd); } -# endif // GTEST_OS_WINDOWS_MOBILE -inline int StrCaseCmp(const char* s1, const char* s2) { - return _stricmp(s1, s2); -} -inline char* StrDup(const char* src) { return _strdup(src); } -# endif // __BORLANDC__ - -# if GTEST_OS_WINDOWS_MOBILE -inline int FileNo(FILE* file) { return reinterpret_cast<int>(_fileno(file)); } -// Stat(), RmDir(), and IsDir() are not needed on Windows CE at this -// time and thus not defined there. -# else -inline int FileNo(FILE* file) { return _fileno(file); } -inline int Stat(const char* path, StatStruct* buf) { return _stat(path, buf); } -inline int RmDir(const char* dir) { return _rmdir(dir); } -inline bool IsDir(const StatStruct& st) { - return (_S_IFDIR & st.st_mode) != 0; -} -# endif // GTEST_OS_WINDOWS_MOBILE - -#elif GTEST_OS_ESP8266 -typedef struct stat StatStruct; - -inline int FileNo(FILE* file) { return fileno(file); } -inline int DoIsATTY(int fd) { return isatty(fd); } -inline int Stat(const char* path, StatStruct* buf) { - // stat function not implemented on ESP8266 - return 0; -} -inline int StrCaseCmp(const char* s1, const char* s2) { - return strcasecmp(s1, s2); -} -inline char* StrDup(const char* src) { return strdup(src); } -inline int RmDir(const char* dir) { return rmdir(dir); } -inline bool IsDir(const StatStruct& st) { return S_ISDIR(st.st_mode); } - -#else - -typedef struct stat StatStruct; - -inline int FileNo(FILE* file) { return fileno(file); } -inline int DoIsATTY(int fd) { return isatty(fd); } -inline int Stat(const char* path, StatStruct* buf) { return stat(path, buf); } -inline int StrCaseCmp(const char* s1, const char* s2) { - return strcasecmp(s1, s2); -} -inline char* StrDup(const char* src) { return strdup(src); } -inline int RmDir(const char* dir) { return rmdir(dir); } -inline bool IsDir(const StatStruct& st) { return S_ISDIR(st.st_mode); } - -#endif // GTEST_OS_WINDOWS - -inline int IsATTY(int fd) { - // DoIsATTY might change errno (for example ENOTTY in case you redirect stdout - // to a file on Linux), which is unexpected, so save the previous value, and - // restore it after the call. - int savedErrno = errno; - int isAttyValue = DoIsATTY(fd); - errno = savedErrno; - - return isAttyValue; -} - -// Functions deprecated by MSVC 8.0. - -GTEST_DISABLE_MSC_DEPRECATED_PUSH_() - -// ChDir(), FReopen(), FDOpen(), Read(), Write(), Close(), and -// StrError() aren't needed on Windows CE at this time and thus not -// defined there. - -#if !GTEST_OS_WINDOWS_MOBILE && !GTEST_OS_WINDOWS_PHONE && \ - !GTEST_OS_WINDOWS_RT && !GTEST_OS_ESP8266 && !GTEST_OS_XTENSA -inline int ChDir(const char* dir) { return chdir(dir); } -#endif -inline FILE* FOpen(const char* path, const char* mode) { -#if GTEST_OS_WINDOWS && !GTEST_OS_WINDOWS_MINGW - struct wchar_codecvt : public std::codecvt<wchar_t, char, std::mbstate_t> {}; - std::wstring_convert<wchar_codecvt> converter; - std::wstring wide_path = converter.from_bytes(path); - std::wstring wide_mode = converter.from_bytes(mode); - return _wfopen(wide_path.c_str(), wide_mode.c_str()); -#else // GTEST_OS_WINDOWS && !GTEST_OS_WINDOWS_MINGW - return fopen(path, mode); -#endif // GTEST_OS_WINDOWS && !GTEST_OS_WINDOWS_MINGW -} -#if !GTEST_OS_WINDOWS_MOBILE -inline FILE *FReopen(const char* path, const char* mode, FILE* stream) { - return freopen(path, mode, stream); -} -inline FILE* FDOpen(int fd, const char* mode) { return fdopen(fd, mode); } -#endif -inline int FClose(FILE* fp) { return fclose(fp); } -#if !GTEST_OS_WINDOWS_MOBILE -inline int Read(int fd, void* buf, unsigned int count) { - return static_cast<int>(read(fd, buf, count)); -} -inline int Write(int fd, const void* buf, unsigned int count) { - return static_cast<int>(write(fd, buf, count)); -} -inline int Close(int fd) { return close(fd); } -inline const char* StrError(int errnum) { return strerror(errnum); } -#endif -inline const char* GetEnv(const char* name) { -#if GTEST_OS_WINDOWS_MOBILE || GTEST_OS_WINDOWS_PHONE || \ - GTEST_OS_WINDOWS_RT || GTEST_OS_ESP8266 || GTEST_OS_XTENSA - // We are on an embedded platform, which has no environment variables. - static_cast<void>(name); // To prevent 'unused argument' warning. - return nullptr; -#elif defined(__BORLANDC__) || defined(__SunOS_5_8) || defined(__SunOS_5_9) - // Environment variables which we programmatically clear will be set to the - // empty string rather than unset (NULL). Handle that case. - const char* const env = getenv(name); - return (env != nullptr && env[0] != '\0') ? env : nullptr; -#else - return getenv(name); -#endif -} - -GTEST_DISABLE_MSC_DEPRECATED_POP_() - -#if GTEST_OS_WINDOWS_MOBILE -// Windows CE has no C library. The abort() function is used in -// several places in Google Test. This implementation provides a reasonable -// imitation of standard behaviour. -[[noreturn]] void Abort(); -#else -[[noreturn]] inline void Abort() { abort(); } -#endif // GTEST_OS_WINDOWS_MOBILE - -} // namespace posix - -// MSVC "deprecates" snprintf and issues warnings wherever it is used. In -// order to avoid these warnings, we need to use _snprintf or _snprintf_s on -// MSVC-based platforms. We map the GTEST_SNPRINTF_ macro to the appropriate -// function in order to achieve that. We use macro definition here because -// snprintf is a variadic function. -#if _MSC_VER && !GTEST_OS_WINDOWS_MOBILE -// MSVC 2005 and above support variadic macros. -# define GTEST_SNPRINTF_(buffer, size, format, ...) \ - _snprintf_s(buffer, size, size, format, __VA_ARGS__) -#elif defined(_MSC_VER) -// Windows CE does not define _snprintf_s -# define GTEST_SNPRINTF_ _snprintf -#else -# define GTEST_SNPRINTF_ snprintf -#endif - -// The biggest signed integer type the compiler supports. -// -// long long is guaranteed to be at least 64-bits in C++11. -using BiggestInt = long long; // NOLINT - -// The maximum number a BiggestInt can represent. -constexpr BiggestInt kMaxBiggestInt = (std::numeric_limits<BiggestInt>::max)(); - -// This template class serves as a compile-time function from size to -// type. It maps a size in bytes to a primitive type with that -// size. e.g. -// -// TypeWithSize<4>::UInt -// -// is typedef-ed to be unsigned int (unsigned integer made up of 4 -// bytes). -// -// Such functionality should belong to STL, but I cannot find it -// there. -// -// Google Test uses this class in the implementation of floating-point -// comparison. -// -// For now it only handles UInt (unsigned int) as that's all Google Test -// needs. Other types can be easily added in the future if need -// arises. -template <size_t size> -class TypeWithSize { - public: - // This prevents the user from using TypeWithSize<N> with incorrect - // values of N. - using UInt = void; -}; - -// The specialization for size 4. -template <> -class TypeWithSize<4> { - public: - using Int = std::int32_t; - using UInt = std::uint32_t; -}; - -// The specialization for size 8. -template <> -class TypeWithSize<8> { - public: - using Int = std::int64_t; - using UInt = std::uint64_t; -}; - -// Integer types of known sizes. -using TimeInMillis = int64_t; // Represents time in milliseconds. - -// Utilities for command line flags and environment variables. - -// Macro for referencing flags. -#if !defined(GTEST_FLAG) -# define GTEST_FLAG(name) FLAGS_gtest_##name -#endif // !defined(GTEST_FLAG) - -#if !defined(GTEST_USE_OWN_FLAGFILE_FLAG_) -# define GTEST_USE_OWN_FLAGFILE_FLAG_ 1 -#endif // !defined(GTEST_USE_OWN_FLAGFILE_FLAG_) - -#if !defined(GTEST_DECLARE_bool_) -# define GTEST_FLAG_SAVER_ ::testing::internal::GTestFlagSaver - -// Macros for declaring flags. -# define GTEST_DECLARE_bool_(name) GTEST_API_ extern bool GTEST_FLAG(name) -# define GTEST_DECLARE_int32_(name) \ - GTEST_API_ extern std::int32_t GTEST_FLAG(name) -# define GTEST_DECLARE_string_(name) \ - GTEST_API_ extern ::std::string GTEST_FLAG(name) - -// Macros for defining flags. -# define GTEST_DEFINE_bool_(name, default_val, doc) \ - GTEST_API_ bool GTEST_FLAG(name) = (default_val) -# define GTEST_DEFINE_int32_(name, default_val, doc) \ - GTEST_API_ std::int32_t GTEST_FLAG(name) = (default_val) -# define GTEST_DEFINE_string_(name, default_val, doc) \ - GTEST_API_ ::std::string GTEST_FLAG(name) = (default_val) - -#endif // !defined(GTEST_DECLARE_bool_) - -// Thread annotations -#if !defined(GTEST_EXCLUSIVE_LOCK_REQUIRED_) -# define GTEST_EXCLUSIVE_LOCK_REQUIRED_(locks) -# define GTEST_LOCK_EXCLUDED_(locks) -#endif // !defined(GTEST_EXCLUSIVE_LOCK_REQUIRED_) - -// Parses 'str' for a 32-bit signed integer. If successful, writes the result -// to *value and returns true; otherwise leaves *value unchanged and returns -// false. -GTEST_API_ bool ParseInt32(const Message& src_text, const char* str, - int32_t* value); - -// Parses a bool/int32_t/string from the environment variable -// corresponding to the given Google Test flag. -bool BoolFromGTestEnv(const char* flag, bool default_val); -GTEST_API_ int32_t Int32FromGTestEnv(const char* flag, int32_t default_val); -std::string OutputFlagAlsoCheckEnvVar(); -const char* StringFromGTestEnv(const char* flag, const char* default_val); - -} // namespace internal -} // namespace testing - -#if !defined(GTEST_INTERNAL_DEPRECATED) - -// Internal Macro to mark an API deprecated, for googletest usage only -// Usage: class GTEST_INTERNAL_DEPRECATED(message) MyClass or -// GTEST_INTERNAL_DEPRECATED(message) <return_type> myFunction(); Every usage of -// a deprecated entity will trigger a warning when compiled with -// `-Wdeprecated-declarations` option (clang, gcc, any __GNUC__ compiler). -// For msvc /W3 option will need to be used -// Note that for 'other' compilers this macro evaluates to nothing to prevent -// compilations errors. -#if defined(_MSC_VER) -#define GTEST_INTERNAL_DEPRECATED(message) __declspec(deprecated(message)) -#elif defined(__GNUC__) -#define GTEST_INTERNAL_DEPRECATED(message) __attribute__((deprecated(message))) -#else -#define GTEST_INTERNAL_DEPRECATED(message) -#endif - -#endif // !defined(GTEST_INTERNAL_DEPRECATED) - -#if GTEST_HAS_ABSL -// Always use absl::any for UniversalPrinter<> specializations if googletest -// is built with absl support. -#define GTEST_INTERNAL_HAS_ANY 1 -#include "absl/types/any.h" -namespace testing { -namespace internal { -using Any = ::absl::any; -} // namespace internal -} // namespace testing -#else -#ifdef __has_include -#if __has_include(<any>) && __cplusplus >= 201703L -// Otherwise for C++17 and higher use std::any for UniversalPrinter<> -// specializations. -#define GTEST_INTERNAL_HAS_ANY 1 -#include <any> -namespace testing { -namespace internal { -using Any = ::std::any; -} // namespace internal -} // namespace testing -// The case where absl is configured NOT to alias std::any is not -// supported. -#endif // __has_include(<any>) && __cplusplus >= 201703L -#endif // __has_include -#endif // GTEST_HAS_ABSL - -#if GTEST_HAS_ABSL -// Always use absl::optional for UniversalPrinter<> specializations if -// googletest is built with absl support. -#define GTEST_INTERNAL_HAS_OPTIONAL 1 -#include "absl/types/optional.h" -namespace testing { -namespace internal { -template <typename T> -using Optional = ::absl::optional<T>; -} // namespace internal -} // namespace testing -#else -#ifdef __has_include -#if __has_include(<optional>) && __cplusplus >= 201703L -// Otherwise for C++17 and higher use std::optional for UniversalPrinter<> -// specializations. -#define GTEST_INTERNAL_HAS_OPTIONAL 1 -#include <optional> -namespace testing { -namespace internal { -template <typename T> -using Optional = ::std::optional<T>; -} // namespace internal -} // namespace testing -// The case where absl is configured NOT to alias std::optional is not -// supported. -#endif // __has_include(<optional>) && __cplusplus >= 201703L -#endif // __has_include -#endif // GTEST_HAS_ABSL - -#if GTEST_HAS_ABSL -// Always use absl::string_view for Matcher<> specializations if googletest -// is built with absl support. -# define GTEST_INTERNAL_HAS_STRING_VIEW 1 -#include "absl/strings/string_view.h" -namespace testing { -namespace internal { -using StringView = ::absl::string_view; -} // namespace internal -} // namespace testing -#else -# ifdef __has_include -# if __has_include(<string_view>) && __cplusplus >= 201703L -// Otherwise for C++17 and higher use std::string_view for Matcher<> -// specializations. -# define GTEST_INTERNAL_HAS_STRING_VIEW 1 -#include <string_view> -namespace testing { -namespace internal { -using StringView = ::std::string_view; -} // namespace internal -} // namespace testing -// The case where absl is configured NOT to alias std::string_view is not -// supported. -# endif // __has_include(<string_view>) && __cplusplus >= 201703L -# endif // __has_include -#endif // GTEST_HAS_ABSL - -#if GTEST_HAS_ABSL -// Always use absl::variant for UniversalPrinter<> specializations if googletest -// is built with absl support. -#define GTEST_INTERNAL_HAS_VARIANT 1 -#include "absl/types/variant.h" -namespace testing { -namespace internal { -template <typename... T> -using Variant = ::absl::variant<T...>; -} // namespace internal -} // namespace testing -#else -#ifdef __has_include -#if __has_include(<variant>) && __cplusplus >= 201703L -// Otherwise for C++17 and higher use std::variant for UniversalPrinter<> -// specializations. -#define GTEST_INTERNAL_HAS_VARIANT 1 -#include <variant> -namespace testing { -namespace internal { -template <typename... T> -using Variant = ::std::variant<T...>; -} // namespace internal -} // namespace testing -// The case where absl is configured NOT to alias std::variant is not supported. -#endif // __has_include(<variant>) && __cplusplus >= 201703L -#endif // __has_include -#endif // GTEST_HAS_ABSL - -#endif // GOOGLETEST_INCLUDE_GTEST_INTERNAL_GTEST_PORT_H_ - -#if GTEST_OS_LINUX -# include <stdlib.h> -# include <sys/types.h> -# include <sys/wait.h> -# include <unistd.h> -#endif // GTEST_OS_LINUX - -#if GTEST_HAS_EXCEPTIONS -# include <stdexcept> -#endif - -#include <ctype.h> -#include <float.h> -#include <string.h> -#include <cstdint> -#include <iomanip> -#include <limits> -#include <map> -#include <set> -#include <string> -#include <type_traits> -#include <vector> - -// 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. - -// -// The Google C++ Testing and Mocking 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! - -// GOOGLETEST_CM0001 DO NOT DELETE - -#ifndef GOOGLETEST_INCLUDE_GTEST_GTEST_MESSAGE_H_ -#define GOOGLETEST_INCLUDE_GTEST_GTEST_MESSAGE_H_ - -#include <limits> -#include <memory> -#include <sstream> - - -GTEST_DISABLE_MSC_WARNINGS_PUSH_(4251 \ -/* class A needs to have dll-interface to be used by clients of class B */) - -// Ensures that there is at least one operator<< in the global namespace. -// See Message& operator<<(...) below for why. -void operator<<(const testing::internal::Secret&, int); - -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. - Message(); - - // 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; - } - - // Streams a non-pointer value to this object. - template <typename T> - inline Message& operator <<(const T& val) { - // Some libraries overload << for STL containers. These - // overloads are defined in the global namespace instead of ::std. - // - // C++'s symbol lookup rule (i.e. Koenig lookup) says that these - // overloads are visible in either the std namespace or the global - // namespace, but not other namespaces, including the testing - // namespace which Google Test's Message class is in. - // - // To allow STL containers (and other types that has a << operator - // defined in the global namespace) to be used in Google Test - // assertions, testing::Message must access the custom << operator - // from the global namespace. With this using declaration, - // overloads of << defined in the global namespace and those - // visible via Koenig lookup are both exposed in this function. - using ::operator <<; - *ss_ << 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 == nullptr) { - *ss_ << "(null)"; - } else { - *ss_ << pointer; - } - return *this; - } - - // 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); - Message& operator <<(wchar_t* 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 - - // Gets the text streamed to this object so far as an std::string. - // Each '\0' character in the buffer is replaced with "\\0". - // - // INTERNAL IMPLEMENTATION - DO NOT USE IN A USER PROGRAM. - std::string GetString() const; - - private: - // We'll hold the text streamed to this object here. - const std::unique_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 internal { - -// Converts a streamable value to an std::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". -template <typename T> -std::string StreamableToString(const T& streamable) { - return (Message() << streamable).GetString(); -} - -} // namespace internal -} // namespace testing - -GTEST_DISABLE_MSC_WARNINGS_POP_() // 4251 - -#endif // GOOGLETEST_INCLUDE_GTEST_GTEST_MESSAGE_H_ -// Copyright 2008, 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. -// -// Google Test filepath utilities -// -// This header file declares classes and functions used internally by -// Google Test. They are subject to change without notice. -// -// This file is #included in gtest/internal/gtest-internal.h. -// Do not include this header file separately! - -// GOOGLETEST_CM0001 DO NOT DELETE - -#ifndef GOOGLETEST_INCLUDE_GTEST_INTERNAL_GTEST_FILEPATH_H_ -#define GOOGLETEST_INCLUDE_GTEST_INTERNAL_GTEST_FILEPATH_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. -// -// The Google C++ Testing and Mocking 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.h. -// It should not be #included by other files. - -// GOOGLETEST_CM0001 DO NOT DELETE - -#ifndef GOOGLETEST_INCLUDE_GTEST_INTERNAL_GTEST_STRING_H_ -#define GOOGLETEST_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 <cstdint> -#include <string> - - -namespace testing { -namespace internal { - -// String - an abstract class holding static string utilities. -class GTEST_API_ String { - public: - // Static utility methods - - // 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 if and only if 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 std::string ShowWideCString(const wchar_t* wide_c_str); - - // Compares two wide C strings. Returns true if and only if 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 if and only if - // 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 if and only if - // 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); - - // Returns true if and only if the given string ends with the given suffix, - // ignoring case. Any string is considered to end with an empty suffix. - static bool EndsWithCaseInsensitive( - const std::string& str, const std::string& suffix); - - // Formats an int value as "%02d". - static std::string FormatIntWidth2(int value); // "%02d" for width == 2 - - // Formats an int value to given width with leading zeros. - static std::string FormatIntWidthN(int value, int width); - - // Formats an int value as "%X". - static std::string FormatHexInt(int value); - - // Formats an int value as "%X". - static std::string FormatHexUInt32(uint32_t value); - - // Formats a byte as "%02X". - static std::string FormatByte(unsigned char value); - - private: - String(); // Not meant to be instantiated. -}; // class String - -// Gets the content of the stringstream's buffer as an std::string. Each '\0' -// character in the buffer is replaced with "\\0". -GTEST_API_ std::string StringStreamToString(::std::stringstream* stream); - -} // namespace internal -} // namespace testing - -#endif // GOOGLETEST_INCLUDE_GTEST_INTERNAL_GTEST_STRING_H_ - -GTEST_DISABLE_MSC_WARNINGS_PUSH_(4251 \ -/* class A needs to have dll-interface to be used by clients of class B */) - -namespace testing { -namespace internal { - -// FilePath - a class for file and directory pathname manipulation which -// handles platform-specific conventions (like the pathname separator). -// Used for helper functions for naming files in a directory for xml output. -// Except for Set methods, all methods are const or static, which provides an -// "immutable value object" -- useful for peace of mind. -// A FilePath with a value ending in a path separator ("like/this/") represents -// a directory, otherwise it is assumed to represent a file. In either case, -// it may or may not represent an actual file or directory in the file system. -// Names are NOT checked for syntax correctness -- no checking for illegal -// characters, malformed paths, etc. - -class GTEST_API_ FilePath { - public: - FilePath() : pathname_("") { } - FilePath(const FilePath& rhs) : pathname_(rhs.pathname_) { } - - explicit FilePath(const std::string& pathname) : pathname_(pathname) { - Normalize(); - } - - FilePath& operator=(const FilePath& rhs) { - Set(rhs); - return *this; - } - - void Set(const FilePath& rhs) { - pathname_ = rhs.pathname_; - } - - const std::string& string() const { return pathname_; } - const char* c_str() const { return pathname_.c_str(); } - - // Returns the current working directory, or "" if unsuccessful. - static FilePath GetCurrentDir(); - - // Given directory = "dir", base_name = "test", number = 0, - // extension = "xml", returns "dir/test.xml". If number is greater - // than zero (e.g., 12), returns "dir/test_12.xml". - // On Windows platform, uses \ as the separator rather than /. - static FilePath MakeFileName(const FilePath& directory, - const FilePath& base_name, - int number, - const char* extension); - - // Given directory = "dir", relative_path = "test.xml", - // returns "dir/test.xml". - // On Windows, uses \ as the separator rather than /. - static FilePath ConcatPaths(const FilePath& directory, - const FilePath& relative_path); - - // Returns a pathname for a file that does not currently exist. The pathname - // will be directory/base_name.extension or - // directory/base_name_<number>.extension if directory/base_name.extension - // already exists. The number will be incremented until a pathname is found - // that does not already exist. - // Examples: 'dir/foo_test.xml' or 'dir/foo_test_1.xml'. - // There could be a race condition if two or more processes are calling this - // function at the same time -- they could both pick the same filename. - static FilePath GenerateUniqueFileName(const FilePath& directory, - const FilePath& base_name, - const char* extension); - - // Returns true if and only if the path is "". - bool IsEmpty() const { return pathname_.empty(); } - - // If input name has a trailing separator character, removes it and returns - // the name, otherwise return the name string unmodified. - // On Windows platform, uses \ as the separator, other platforms use /. - FilePath RemoveTrailingPathSeparator() const; - - // Returns a copy of the FilePath with the directory part removed. - // Example: FilePath("path/to/file").RemoveDirectoryName() returns - // FilePath("file"). If there is no directory part ("just_a_file"), it returns - // the FilePath unmodified. If there is no file part ("just_a_dir/") it - // returns an empty FilePath (""). - // On Windows platform, '\' is the path separator, otherwise it is '/'. - FilePath RemoveDirectoryName() const; - - // RemoveFileName returns the directory path with the filename removed. - // Example: FilePath("path/to/file").RemoveFileName() returns "path/to/". - // If the FilePath is "a_file" or "/a_file", RemoveFileName returns - // FilePath("./") or, on Windows, FilePath(".\\"). If the filepath does - // not have a file, like "just/a/dir/", it returns the FilePath unmodified. - // On Windows platform, '\' is the path separator, otherwise it is '/'. - FilePath RemoveFileName() const; - - // Returns a copy of the FilePath with the case-insensitive extension removed. - // Example: FilePath("dir/file.exe").RemoveExtension("EXE") returns - // FilePath("dir/file"). If a case-insensitive extension is not - // found, returns a copy of the original FilePath. - FilePath RemoveExtension(const char* extension) const; - - // Creates directories so that path exists. Returns true if successful or if - // the directories already exist; returns false if unable to create - // directories for any reason. Will also return false if the FilePath does - // not represent a directory (that is, it doesn't end with a path separator). - bool CreateDirectoriesRecursively() const; - - // Create the directory so that path exists. Returns true if successful or - // if the directory already exists; returns false if unable to create the - // directory for any reason, including if the parent directory does not - // exist. Not named "CreateDirectory" because that's a macro on Windows. - bool CreateFolder() const; - - // Returns true if FilePath describes something in the file-system, - // either a file, directory, or whatever, and that something exists. - bool FileOrDirectoryExists() const; - - // Returns true if pathname describes a directory in the file-system - // that exists. - bool DirectoryExists() const; - - // Returns true if FilePath ends with a path separator, which indicates that - // it is intended to represent a directory. Returns false otherwise. - // This does NOT check that a directory (or file) actually exists. - bool IsDirectory() const; - - // Returns true if pathname describes a root directory. (Windows has one - // root directory per disk drive.) - bool IsRootDirectory() const; - - // Returns true if pathname describes an absolute path. - bool IsAbsolutePath() const; - - private: - // Replaces multiple consecutive separators with a single separator. - // For example, "bar///foo" becomes "bar/foo". Does not eliminate other - // redundancies that might be in a pathname involving "." or "..". - // - // A pathname with multiple consecutive separators may occur either through - // user error or as a result of some scripts or APIs that generate a pathname - // with a trailing separator. On other platforms the same API or script - // may NOT generate a pathname with a trailing "/". Then elsewhere that - // pathname may have another "/" and pathname components added to it, - // without checking for the separator already being there. - // The script language and operating system may allow paths like "foo//bar" - // but some of the functions in FilePath will not handle that correctly. In - // particular, RemoveTrailingPathSeparator() only removes one separator, and - // it is called in CreateDirectoriesRecursively() assuming that it will change - // a pathname from directory syntax (trailing separator) to filename syntax. - // - // On Windows this method also replaces the alternate path separator '/' with - // the primary path separator '\\', so that for example "bar\\/\\foo" becomes - // "bar\\foo". - - void Normalize(); - - // Returns a pointer to the last occurrence of a valid path separator in - // the FilePath. On Windows, for example, both '/' and '\' are valid path - // separators. Returns NULL if no path separator was found. - const char* FindLastPathSeparator() const; - - std::string pathname_; -}; // class FilePath - -} // namespace internal -} // namespace testing - -GTEST_DISABLE_MSC_WARNINGS_POP_() // 4251 - -#endif // GOOGLETEST_INCLUDE_GTEST_INTERNAL_GTEST_FILEPATH_H_ -// Copyright 2008 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. - -// Type utilities needed for implementing typed and type-parameterized -// tests. - -// GOOGLETEST_CM0001 DO NOT DELETE - -#ifndef GOOGLETEST_INCLUDE_GTEST_INTERNAL_GTEST_TYPE_UTIL_H_ -#define GOOGLETEST_INCLUDE_GTEST_INTERNAL_GTEST_TYPE_UTIL_H_ - - -// #ifdef __GNUC__ is too general here. It is possible to use gcc without using -// libstdc++ (which is where cxxabi.h comes from). -# if GTEST_HAS_CXXABI_H_ -# include <cxxabi.h> -# elif defined(__HP_aCC) -# include <acxx_demangle.h> -# endif // GTEST_HASH_CXXABI_H_ - -namespace testing { -namespace internal { - -// Canonicalizes a given name with respect to the Standard C++ Library. -// This handles removing the inline namespace within `std` that is -// used by various standard libraries (e.g., `std::__1`). Names outside -// of namespace std are returned unmodified. -inline std::string CanonicalizeForStdLibVersioning(std::string s) { - static const char prefix[] = "std::__"; - if (s.compare(0, strlen(prefix), prefix) == 0) { - std::string::size_type end = s.find("::", strlen(prefix)); - if (end != s.npos) { - // Erase everything between the initial `std` and the second `::`. - s.erase(strlen("std"), end - strlen("std")); - } - } - return s; -} - -#if GTEST_HAS_RTTI -// GetTypeName(const std::type_info&) returns a human-readable name of type T. -inline std::string GetTypeName(const std::type_info& type) { - const char* const name = type.name(); -#if GTEST_HAS_CXXABI_H_ || defined(__HP_aCC) - int status = 0; - // gcc's implementation of typeid(T).name() mangles the type name, - // so we have to demangle it. -#if GTEST_HAS_CXXABI_H_ - using abi::__cxa_demangle; -#endif // GTEST_HAS_CXXABI_H_ - char* const readable_name = __cxa_demangle(name, nullptr, nullptr, &status); - const std::string name_str(status == 0 ? readable_name : name); - free(readable_name); - return CanonicalizeForStdLibVersioning(name_str); -#else - return name; -#endif // GTEST_HAS_CXXABI_H_ || __HP_aCC -} -#endif // GTEST_HAS_RTTI - -// GetTypeName<T>() returns a human-readable name of type T if and only if -// RTTI is enabled, otherwise it returns a dummy type name. -// NB: This function is also used in Google Mock, so don't move it inside of -// the typed-test-only section below. -template <typename T> -std::string GetTypeName() { -#if GTEST_HAS_RTTI - return GetTypeName(typeid(T)); -#else - return "<type>"; -#endif // GTEST_HAS_RTTI -} - -// A unique type indicating an empty node -struct None {}; - -# define GTEST_TEMPLATE_ template <typename T> class - -// The template "selector" struct TemplateSel<Tmpl> is used to -// represent Tmpl, which must be a class template with one type -// parameter, as a type. TemplateSel<Tmpl>::Bind<T>::type is defined -// as the type Tmpl<T>. This allows us to actually instantiate the -// template "selected" by TemplateSel<Tmpl>. -// -// This trick is necessary for simulating typedef for class templates, -// which C++ doesn't support directly. -template <GTEST_TEMPLATE_ Tmpl> -struct TemplateSel { - template <typename T> - struct Bind { - typedef Tmpl<T> type; - }; -}; - -# define GTEST_BIND_(TmplSel, T) \ - TmplSel::template Bind<T>::type - -template <GTEST_TEMPLATE_ Head_, GTEST_TEMPLATE_... Tail_> -struct Templates { - using Head = TemplateSel<Head_>; - using Tail = Templates<Tail_...>; -}; - -template <GTEST_TEMPLATE_ Head_> -struct Templates<Head_> { - using Head = TemplateSel<Head_>; - using Tail = None; -}; - -// Tuple-like type lists -template <typename Head_, typename... Tail_> -struct Types { - using Head = Head_; - using Tail = Types<Tail_...>; -}; - -template <typename Head_> -struct Types<Head_> { - using Head = Head_; - using Tail = None; -}; - -// Helper metafunctions to tell apart a single type from types -// generated by ::testing::Types -template <typename... Ts> -struct ProxyTypeList { - using type = Types<Ts...>; -}; - -template <typename> -struct is_proxy_type_list : std::false_type {}; - -template <typename... Ts> -struct is_proxy_type_list<ProxyTypeList<Ts...>> : std::true_type {}; - -// Generator which conditionally creates type lists. -// It recognizes if a requested type list should be created -// and prevents creating a new type list nested within another one. -template <typename T> -struct GenerateTypeList { - private: - using proxy = typename std::conditional<is_proxy_type_list<T>::value, T, - ProxyTypeList<T>>::type; - - public: - using type = typename proxy::type; -}; - -} // namespace internal - -template <typename... Ts> -using Types = internal::ProxyTypeList<Ts...>; - -} // namespace testing - -#endif // GOOGLETEST_INCLUDE_GTEST_INTERNAL_GTEST_TYPE_UTIL_H_ - -// Due to C++ preprocessor weirdness, we need double indirection to -// concatenate two tokens when one of them is __LINE__. Writing -// -// foo ## __LINE__ -// -// will result in the token foo__LINE__, instead of foo followed by -// the current line number. For more details, see -// http://www.parashift.com/c++-faq-lite/misc-technical-issues.html#faq-39.6 -#define GTEST_CONCAT_TOKEN_(foo, bar) GTEST_CONCAT_TOKEN_IMPL_(foo, bar) -#define GTEST_CONCAT_TOKEN_IMPL_(foo, bar) foo ## bar - -// Stringifies its argument. -// Work around a bug in visual studio which doesn't accept code like this: -// -// #define GTEST_STRINGIFY_(name) #name -// #define MACRO(a, b, c) ... GTEST_STRINGIFY_(a) ... -// MACRO(, x, y) -// -// Complaining about the argument to GTEST_STRINGIFY_ being empty. -// This is allowed by the spec. -#define GTEST_STRINGIFY_HELPER_(name, ...) #name -#define GTEST_STRINGIFY_(...) GTEST_STRINGIFY_HELPER_(__VA_ARGS__, ) - -namespace proto2 { -class MessageLite; -} - -namespace testing { - -// Forward declarations. - -class AssertionResult; // Result of an assertion. -class Message; // Represents a failure message. -class Test; // Represents a test. -class TestInfo; // Information about a test. -class TestPartResult; // Result of a test part. -class UnitTest; // A collection of test suites. - -template <typename T> -::std::string PrintToString(const T& value); - -namespace internal { - -struct TraceInfo; // Information about a trace point. -class TestInfoImpl; // Opaque implementation of TestInfo -class UnitTestImpl; // Opaque implementation of UnitTest - -// The text used in failure messages to indicate the start of the -// stack trace. -GTEST_API_ extern const char kStackTraceMarker[]; - -// An IgnoredValue object can be implicitly constructed from ANY value. -class IgnoredValue { - struct Sink {}; - public: - // This constructor template allows any value to be implicitly - // converted to IgnoredValue. The object has no data member and - // doesn't try to remember anything about the argument. We - // deliberately omit the 'explicit' keyword in order to allow the - // conversion to be implicit. - // Disable the conversion if T already has a magical conversion operator. - // Otherwise we get ambiguity. - template <typename T, - typename std::enable_if<!std::is_convertible<T, Sink>::value, - int>::type = 0> - IgnoredValue(const T& /* ignored */) {} // NOLINT(runtime/explicit) -}; - -// Appends the user-supplied message to the Google-Test-generated message. -GTEST_API_ std::string AppendUserMessage( - const std::string& gtest_msg, const Message& user_msg); - -#if GTEST_HAS_EXCEPTIONS - -GTEST_DISABLE_MSC_WARNINGS_PUSH_(4275 \ -/* an exported class was derived from a class that was not exported */) - -// This exception is thrown by (and only by) a failed Google Test -// assertion when GTEST_FLAG(throw_on_failure) is true (if exceptions -// are enabled). We derive it from std::runtime_error, which is for -// errors presumably detectable only at run time. Since -// std::runtime_error inherits from std::exception, many testing -// frameworks know how to extract and print the message inside it. -class GTEST_API_ GoogleTestFailureException : public ::std::runtime_error { - public: - explicit GoogleTestFailureException(const TestPartResult& failure); -}; - -GTEST_DISABLE_MSC_WARNINGS_POP_() // 4275 - -#endif // GTEST_HAS_EXCEPTIONS - -namespace edit_distance { -// Returns the optimal edits to go from 'left' to 'right'. -// All edits cost the same, with replace having lower priority than -// add/remove. -// Simple implementation of the Wagner-Fischer algorithm. -// See http://en.wikipedia.org/wiki/Wagner-Fischer_algorithm -enum EditType { kMatch, kAdd, kRemove, kReplace }; -GTEST_API_ std::vector<EditType> CalculateOptimalEdits( - const std::vector<size_t>& left, const std::vector<size_t>& right); - -// Same as above, but the input is represented as strings. -GTEST_API_ std::vector<EditType> CalculateOptimalEdits( - const std::vector<std::string>& left, - const std::vector<std::string>& right); - -// Create a diff of the input strings in Unified diff format. -GTEST_API_ std::string CreateUnifiedDiff(const std::vector<std::string>& left, - const std::vector<std::string>& right, - size_t context = 2); - -} // namespace edit_distance - -// Calculate the diff between 'left' and 'right' and return it in unified diff -// format. -// If not null, stores in 'total_line_count' the total number of lines found -// in left + right. -GTEST_API_ std::string DiffStrings(const std::string& left, - const std::string& right, - size_t* total_line_count); - -// Constructs and returns the message for an equality assertion -// (e.g. ASSERT_EQ, EXPECT_STREQ, etc) failure. -// -// The first four parameters are the expressions used in the assertion -// and their values, as strings. For example, for ASSERT_EQ(foo, bar) -// where foo is 5 and bar is 6, we have: -// -// expected_expression: "foo" -// actual_expression: "bar" -// expected_value: "5" -// actual_value: "6" -// -// The ignoring_case parameter is true if and only if the assertion is a -// *_STRCASEEQ*. When it's true, the string " (ignoring case)" will -// be inserted into the message. -GTEST_API_ AssertionResult EqFailure(const char* expected_expression, - const char* actual_expression, - const std::string& expected_value, - const std::string& actual_value, - bool ignoring_case); - -// Constructs a failure message for Boolean assertions such as EXPECT_TRUE. -GTEST_API_ std::string GetBoolAssertionFailureMessage( - const AssertionResult& assertion_result, - const char* expression_text, - const char* actual_predicate_value, - const char* expected_predicate_value); - -// This template class represents an IEEE floating-point number -// (either single-precision or double-precision, depending on the -// template parameters). -// -// The purpose of this class is to do more sophisticated number -// comparison. (Due to round-off error, etc, it's very unlikely that -// two floating-points will be equal exactly. Hence a naive -// comparison by the == operation often doesn't work.) -// -// Format of IEEE floating-point: -// -// The most-significant bit being the leftmost, an IEEE -// floating-point looks like -// -// sign_bit exponent_bits fraction_bits -// -// Here, sign_bit is a single bit that designates the sign of the -// number. -// -// For float, there are 8 exponent bits and 23 fraction bits. -// -// For double, there are 11 exponent bits and 52 fraction bits. -// -// More details can be found at -// http://en.wikipedia.org/wiki/IEEE_floating-point_standard. -// -// Template parameter: -// -// RawType: the raw floating-point type (either float or double) -template <typename RawType> -class FloatingPoint { - public: - // Defines the unsigned integer type that has the same size as the - // floating point number. - typedef typename TypeWithSize<sizeof(RawType)>::UInt Bits; - - // Constants. - - // # of bits in a number. - static const size_t kBitCount = 8*sizeof(RawType); - - // # of fraction bits in a number. - static const size_t kFractionBitCount = - std::numeric_limits<RawType>::digits - 1; - - // # of exponent bits in a number. - static const size_t kExponentBitCount = kBitCount - 1 - kFractionBitCount; - - // The mask for the sign bit. - static const Bits kSignBitMask = static_cast<Bits>(1) << (kBitCount - 1); - - // The mask for the fraction bits. - static const Bits kFractionBitMask = - ~static_cast<Bits>(0) >> (kExponentBitCount + 1); - - // The mask for the exponent bits. - static const Bits kExponentBitMask = ~(kSignBitMask | kFractionBitMask); - - // How many ULP's (Units in the Last Place) we want to tolerate when - // comparing two numbers. The larger the value, the more error we - // allow. A 0 value means that two numbers must be exactly the same - // to be considered equal. - // - // The maximum error of a single floating-point operation is 0.5 - // units in the last place. On Intel CPU's, all floating-point - // calculations are done with 80-bit precision, while double has 64 - // bits. Therefore, 4 should be enough for ordinary use. - // - // See the following article for more details on ULP: - // http://randomascii.wordpress.com/2012/02/25/comparing-floating-point-numbers-2012-edition/ - static const uint32_t kMaxUlps = 4; - - // Constructs a FloatingPoint from a raw floating-point number. - // - // On an Intel CPU, passing a non-normalized NAN (Not a Number) - // around may change its bits, although the new value is guaranteed - // to be also a NAN. Therefore, don't expect this constructor to - // preserve the bits in x when x is a NAN. - explicit FloatingPoint(const RawType& x) { u_.value_ = x; } - - // Static methods - - // Reinterprets a bit pattern as a floating-point number. - // - // This function is needed to test the AlmostEquals() method. - static RawType ReinterpretBits(const Bits bits) { - FloatingPoint fp(0); - fp.u_.bits_ = bits; - return fp.u_.value_; - } - - // Returns the floating-point number that represent positive infinity. - static RawType Infinity() { - return ReinterpretBits(kExponentBitMask); - } - - // Returns the maximum representable finite floating-point number. - static RawType Max(); - - // Non-static methods - - // Returns the bits that represents this number. - const Bits &bits() const { return u_.bits_; } - - // Returns the exponent bits of this number. - Bits exponent_bits() const { return kExponentBitMask & u_.bits_; } - - // Returns the fraction bits of this number. - Bits fraction_bits() const { return kFractionBitMask & u_.bits_; } - - // Returns the sign bit of this number. - Bits sign_bit() const { return kSignBitMask & u_.bits_; } - - // Returns true if and only if this is NAN (not a number). - bool is_nan() const { - // It's a NAN if the exponent bits are all ones and the fraction - // bits are not entirely zeros. - return (exponent_bits() == kExponentBitMask) && (fraction_bits() != 0); - } - - // Returns true if and only if this number is at most kMaxUlps ULP's away - // from rhs. In particular, this function: - // - // - returns false if either number is (or both are) NAN. - // - treats really large numbers as almost equal to infinity. - // - thinks +0.0 and -0.0 are 0 DLP's apart. - bool AlmostEquals(const FloatingPoint& rhs) const { - // The IEEE standard says that any comparison operation involving - // a NAN must return false. - if (is_nan() || rhs.is_nan()) return false; - - return DistanceBetweenSignAndMagnitudeNumbers(u_.bits_, rhs.u_.bits_) - <= kMaxUlps; - } - - private: - // The data type used to store the actual floating-point number. - union FloatingPointUnion { - RawType value_; // The raw floating-point number. - Bits bits_; // The bits that represent the number. - }; - - // Converts an integer from the sign-and-magnitude representation to - // the biased representation. More precisely, let N be 2 to the - // power of (kBitCount - 1), an integer x is represented by the - // unsigned number x + N. - // - // For instance, - // - // -N + 1 (the most negative number representable using - // sign-and-magnitude) is represented by 1; - // 0 is represented by N; and - // N - 1 (the biggest number representable using - // sign-and-magnitude) is represented by 2N - 1. - // - // Read http://en.wikipedia.org/wiki/Signed_number_representations - // for more details on signed number representations. - static Bits SignAndMagnitudeToBiased(const Bits &sam) { - if (kSignBitMask & sam) { - // sam represents a negative number. - return ~sam + 1; - } else { - // sam represents a positive number. - return kSignBitMask | sam; - } - } - - // Given two numbers in the sign-and-magnitude representation, - // returns the distance between them as an unsigned number. - static Bits DistanceBetweenSignAndMagnitudeNumbers(const Bits &sam1, - const Bits &sam2) { - const Bits biased1 = SignAndMagnitudeToBiased(sam1); - const Bits biased2 = SignAndMagnitudeToBiased(sam2); - return (biased1 >= biased2) ? (biased1 - biased2) : (biased2 - biased1); - } - - FloatingPointUnion u_; -}; - -// We cannot use std::numeric_limits<T>::max() as it clashes with the max() -// macro defined by <windows.h>. -template <> -inline float FloatingPoint<float>::Max() { return FLT_MAX; } -template <> -inline double FloatingPoint<double>::Max() { return DBL_MAX; } - -// Typedefs the instances of the FloatingPoint template class that we -// care to use. -typedef FloatingPoint<float> Float; -typedef FloatingPoint<double> Double; - -// In order to catch the mistake of putting tests that use different -// test fixture classes in the same test suite, we need to assign -// unique IDs to fixture classes and compare them. The TypeId type is -// used to hold such IDs. The user should treat TypeId as an opaque -// type: the only operation allowed on TypeId values is to compare -// them for equality using the == operator. -typedef const void* TypeId; - -template <typename T> -class TypeIdHelper { - public: - // dummy_ must not have a const type. Otherwise an overly eager - // compiler (e.g. MSVC 7.1 & 8.0) may try to merge - // TypeIdHelper<T>::dummy_ for different Ts as an "optimization". - static bool dummy_; -}; - -template <typename T> -bool TypeIdHelper<T>::dummy_ = false; - -// GetTypeId<T>() returns the ID of type T. Different values will be -// returned for different types. Calling the function twice with the -// same type argument is guaranteed to return the same ID. -template <typename T> -TypeId GetTypeId() { - // The compiler is required to allocate a different - // TypeIdHelper<T>::dummy_ variable for each T used to instantiate - // the template. Therefore, the address of dummy_ is guaranteed to - // be unique. - return &(TypeIdHelper<T>::dummy_); -} - -// Returns the type ID of ::testing::Test. Always call this instead -// of GetTypeId< ::testing::Test>() to get the type ID of -// ::testing::Test, as the latter may give the wrong result due to a -// suspected linker bug when compiling Google Test as a Mac OS X -// framework. -GTEST_API_ TypeId GetTestTypeId(); - -// Defines the abstract factory interface that creates instances -// of a Test object. -class TestFactoryBase { - public: - virtual ~TestFactoryBase() {} - - // Creates a test instance to run. The instance is both created and destroyed - // within TestInfoImpl::Run() - virtual Test* CreateTest() = 0; - - protected: - TestFactoryBase() {} - - private: - GTEST_DISALLOW_COPY_AND_ASSIGN_(TestFactoryBase); -}; - -// This class provides implementation of TeastFactoryBase interface. -// It is used in TEST and TEST_F macros. -template <class TestClass> -class TestFactoryImpl : public TestFactoryBase { - public: - Test* CreateTest() override { return new TestClass; } -}; - -#if GTEST_OS_WINDOWS - -// Predicate-formatters for implementing the HRESULT checking macros -// {ASSERT|EXPECT}_HRESULT_{SUCCEEDED|FAILED} -// We pass a long instead of HRESULT to avoid causing an -// include dependency for the HRESULT type. -GTEST_API_ AssertionResult IsHRESULTSuccess(const char* expr, - long hr); // NOLINT -GTEST_API_ AssertionResult IsHRESULTFailure(const char* expr, - long hr); // NOLINT - -#endif // GTEST_OS_WINDOWS - -// Types of SetUpTestSuite() and TearDownTestSuite() functions. -using SetUpTestSuiteFunc = void (*)(); -using TearDownTestSuiteFunc = void (*)(); - -struct CodeLocation { - CodeLocation(const std::string& a_file, int a_line) - : file(a_file), line(a_line) {} - - std::string file; - int line; -}; - -// Helper to identify which setup function for TestCase / TestSuite to call. -// Only one function is allowed, either TestCase or TestSute but not both. - -// Utility functions to help SuiteApiResolver -using SetUpTearDownSuiteFuncType = void (*)(); - -inline SetUpTearDownSuiteFuncType GetNotDefaultOrNull( - SetUpTearDownSuiteFuncType a, SetUpTearDownSuiteFuncType def) { - return a == def ? nullptr : a; -} - -template <typename T> -// Note that SuiteApiResolver inherits from T because -// SetUpTestSuite()/TearDownTestSuite() could be protected. Ths way -// SuiteApiResolver can access them. -struct SuiteApiResolver : T { - // testing::Test is only forward declared at this point. So we make it a - // dependend class for the compiler to be OK with it. - using Test = - typename std::conditional<sizeof(T) != 0, ::testing::Test, void>::type; - - static SetUpTearDownSuiteFuncType GetSetUpCaseOrSuite(const char* filename, - int line_num) { -#ifndef GTEST_REMOVE_LEGACY_TEST_CASEAPI_ - SetUpTearDownSuiteFuncType test_case_fp = - GetNotDefaultOrNull(&T::SetUpTestCase, &Test::SetUpTestCase); - SetUpTearDownSuiteFuncType test_suite_fp = - GetNotDefaultOrNull(&T::SetUpTestSuite, &Test::SetUpTestSuite); - - GTEST_CHECK_(!test_case_fp || !test_suite_fp) - << "Test can not provide both SetUpTestSuite and SetUpTestCase, please " - "make sure there is only one present at " - << filename << ":" << line_num; - - return test_case_fp != nullptr ? test_case_fp : test_suite_fp; -#else - (void)(filename); - (void)(line_num); - return &T::SetUpTestSuite; -#endif - } - - static SetUpTearDownSuiteFuncType GetTearDownCaseOrSuite(const char* filename, - int line_num) { -#ifndef GTEST_REMOVE_LEGACY_TEST_CASEAPI_ - SetUpTearDownSuiteFuncType test_case_fp = - GetNotDefaultOrNull(&T::TearDownTestCase, &Test::TearDownTestCase); - SetUpTearDownSuiteFuncType test_suite_fp = - GetNotDefaultOrNull(&T::TearDownTestSuite, &Test::TearDownTestSuite); - - GTEST_CHECK_(!test_case_fp || !test_suite_fp) - << "Test can not provide both TearDownTestSuite and TearDownTestCase," - " please make sure there is only one present at" - << filename << ":" << line_num; - - return test_case_fp != nullptr ? test_case_fp : test_suite_fp; -#else - (void)(filename); - (void)(line_num); - return &T::TearDownTestSuite; -#endif - } -}; - -// Creates a new TestInfo object and registers it with Google Test; -// returns the created object. -// -// Arguments: -// -// test_suite_name: name of the test suite -// name: name of the test -// type_param: the name of the test's type parameter, or NULL if -// this is not a typed or a type-parameterized test. -// value_param: text representation of the test's value parameter, -// or NULL if this is not a type-parameterized test. -// code_location: code location where the test is defined -// fixture_class_id: ID of the test fixture class -// set_up_tc: pointer to the function that sets up the test suite -// tear_down_tc: pointer to the function that tears down the test suite -// factory: pointer to the factory that creates a test object. -// The newly created TestInfo instance will assume -// ownership of the factory object. -GTEST_API_ TestInfo* MakeAndRegisterTestInfo( - const char* test_suite_name, const char* name, const char* type_param, - const char* value_param, CodeLocation code_location, - TypeId fixture_class_id, SetUpTestSuiteFunc set_up_tc, - TearDownTestSuiteFunc tear_down_tc, TestFactoryBase* factory); - -// If *pstr starts with the given prefix, modifies *pstr to be right -// past the prefix and returns true; otherwise leaves *pstr unchanged -// and returns false. None of pstr, *pstr, and prefix can be NULL. -GTEST_API_ bool SkipPrefix(const char* prefix, const char** pstr); - -GTEST_DISABLE_MSC_WARNINGS_PUSH_(4251 \ -/* class A needs to have dll-interface to be used by clients of class B */) - -// State of the definition of a type-parameterized test suite. -class GTEST_API_ TypedTestSuitePState { - public: - TypedTestSuitePState() : registered_(false) {} - - // Adds the given test name to defined_test_names_ and return true - // if the test suite hasn't been registered; otherwise aborts the - // program. - bool AddTestName(const char* file, int line, const char* case_name, - const char* test_name) { - if (registered_) { - fprintf(stderr, - "%s Test %s must be defined before " - "REGISTER_TYPED_TEST_SUITE_P(%s, ...).\n", - FormatFileLocation(file, line).c_str(), test_name, case_name); - fflush(stderr); - posix::Abort(); - } - registered_tests_.insert( - ::std::make_pair(test_name, CodeLocation(file, line))); - return true; - } - - bool TestExists(const std::string& test_name) const { - return registered_tests_.count(test_name) > 0; - } - - const CodeLocation& GetCodeLocation(const std::string& test_name) const { - RegisteredTestsMap::const_iterator it = registered_tests_.find(test_name); - GTEST_CHECK_(it != registered_tests_.end()); - return it->second; - } - - // Verifies that registered_tests match the test names in - // defined_test_names_; returns registered_tests if successful, or - // aborts the program otherwise. - const char* VerifyRegisteredTestNames(const char* test_suite_name, - const char* file, int line, - const char* registered_tests); - - private: - typedef ::std::map<std::string, CodeLocation> RegisteredTestsMap; - - bool registered_; - RegisteredTestsMap registered_tests_; -}; - -// Legacy API is deprecated but still available -#ifndef GTEST_REMOVE_LEGACY_TEST_CASEAPI_ -using TypedTestCasePState = TypedTestSuitePState; -#endif // GTEST_REMOVE_LEGACY_TEST_CASEAPI_ - -GTEST_DISABLE_MSC_WARNINGS_POP_() // 4251 - -// Skips to the first non-space char after the first comma in 'str'; -// returns NULL if no comma is found in 'str'. -inline const char* SkipComma(const char* str) { - const char* comma = strchr(str, ','); - if (comma == nullptr) { - return nullptr; - } - while (IsSpace(*(++comma))) {} - return comma; -} - -// Returns the prefix of 'str' before the first comma in it; returns -// the entire string if it contains no comma. -inline std::string GetPrefixUntilComma(const char* str) { - const char* comma = strchr(str, ','); - return comma == nullptr ? str : std::string(str, comma); -} - -// Splits a given string on a given delimiter, populating a given -// vector with the fields. -void SplitString(const ::std::string& str, char delimiter, - ::std::vector< ::std::string>* dest); - -// The default argument to the template below for the case when the user does -// not provide a name generator. -struct DefaultNameGenerator { - template <typename T> - static std::string GetName(int i) { - return StreamableToString(i); - } -}; - -template <typename Provided = DefaultNameGenerator> -struct NameGeneratorSelector { - typedef Provided type; -}; - -template <typename NameGenerator> -void GenerateNamesRecursively(internal::None, std::vector<std::string>*, int) {} - -template <typename NameGenerator, typename Types> -void GenerateNamesRecursively(Types, std::vector<std::string>* result, int i) { - result->push_back(NameGenerator::template GetName<typename Types::Head>(i)); - GenerateNamesRecursively<NameGenerator>(typename Types::Tail(), result, - i + 1); -} - -template <typename NameGenerator, typename Types> -std::vector<std::string> GenerateNames() { - std::vector<std::string> result; - GenerateNamesRecursively<NameGenerator>(Types(), &result, 0); - return result; -} - -// TypeParameterizedTest<Fixture, TestSel, Types>::Register() -// registers a list of type-parameterized tests with Google Test. The -// return value is insignificant - we just need to return something -// such that we can call this function in a namespace scope. -// -// Implementation note: The GTEST_TEMPLATE_ macro declares a template -// template parameter. It's defined in gtest-type-util.h. -template <GTEST_TEMPLATE_ Fixture, class TestSel, typename Types> -class TypeParameterizedTest { - public: - // 'index' is the index of the test in the type list 'Types' - // specified in INSTANTIATE_TYPED_TEST_SUITE_P(Prefix, TestSuite, - // Types). Valid values for 'index' are [0, N - 1] where N is the - // length of Types. - static bool Register(const char* prefix, const CodeLocation& code_location, - const char* case_name, const char* test_names, int index, - const std::vector<std::string>& type_names = - GenerateNames<DefaultNameGenerator, Types>()) { - typedef typename Types::Head Type; - typedef Fixture<Type> FixtureClass; - typedef typename GTEST_BIND_(TestSel, Type) TestClass; - - // First, registers the first type-parameterized test in the type - // list. - MakeAndRegisterTestInfo( - (std::string(prefix) + (prefix[0] == '\0' ? "" : "/") + case_name + - "/" + type_names[static_cast<size_t>(index)]) - .c_str(), - StripTrailingSpaces(GetPrefixUntilComma(test_names)).c_str(), - GetTypeName<Type>().c_str(), - nullptr, // No value parameter. - code_location, GetTypeId<FixtureClass>(), - SuiteApiResolver<TestClass>::GetSetUpCaseOrSuite( - code_location.file.c_str(), code_location.line), - SuiteApiResolver<TestClass>::GetTearDownCaseOrSuite( - code_location.file.c_str(), code_location.line), - new TestFactoryImpl<TestClass>); - - // Next, recurses (at compile time) with the tail of the type list. - return TypeParameterizedTest<Fixture, TestSel, - typename Types::Tail>::Register(prefix, - code_location, - case_name, - test_names, - index + 1, - type_names); - } -}; - -// The base case for the compile time recursion. -template <GTEST_TEMPLATE_ Fixture, class TestSel> -class TypeParameterizedTest<Fixture, TestSel, internal::None> { - public: - static bool Register(const char* /*prefix*/, const CodeLocation&, - const char* /*case_name*/, const char* /*test_names*/, - int /*index*/, - const std::vector<std::string>& = - std::vector<std::string>() /*type_names*/) { - return true; - } -}; - -GTEST_API_ void RegisterTypeParameterizedTestSuite(const char* test_suite_name, - CodeLocation code_location); -GTEST_API_ void RegisterTypeParameterizedTestSuiteInstantiation( - const char* case_name); - -// TypeParameterizedTestSuite<Fixture, Tests, Types>::Register() -// registers *all combinations* of 'Tests' and 'Types' with Google -// Test. The return value is insignificant - we just need to return -// something such that we can call this function in a namespace scope. -template <GTEST_TEMPLATE_ Fixture, typename Tests, typename Types> -class TypeParameterizedTestSuite { - public: - static bool Register(const char* prefix, CodeLocation code_location, - const TypedTestSuitePState* state, const char* case_name, - const char* test_names, - const std::vector<std::string>& type_names = - GenerateNames<DefaultNameGenerator, Types>()) { - RegisterTypeParameterizedTestSuiteInstantiation(case_name); - std::string test_name = StripTrailingSpaces( - GetPrefixUntilComma(test_names)); - if (!state->TestExists(test_name)) { - fprintf(stderr, "Failed to get code location for test %s.%s at %s.", - case_name, test_name.c_str(), - FormatFileLocation(code_location.file.c_str(), - code_location.line).c_str()); - fflush(stderr); - posix::Abort(); - } - const CodeLocation& test_location = state->GetCodeLocation(test_name); - - typedef typename Tests::Head Head; - - // First, register the first test in 'Test' for each type in 'Types'. - TypeParameterizedTest<Fixture, Head, Types>::Register( - prefix, test_location, case_name, test_names, 0, type_names); - - // Next, recurses (at compile time) with the tail of the test list. - return TypeParameterizedTestSuite<Fixture, typename Tests::Tail, - Types>::Register(prefix, code_location, - state, case_name, - SkipComma(test_names), - type_names); - } -}; - -// The base case for the compile time recursion. -template <GTEST_TEMPLATE_ Fixture, typename Types> -class TypeParameterizedTestSuite<Fixture, internal::None, Types> { - public: - static bool Register(const char* /*prefix*/, const CodeLocation&, - const TypedTestSuitePState* /*state*/, - const char* /*case_name*/, const char* /*test_names*/, - const std::vector<std::string>& = - std::vector<std::string>() /*type_names*/) { - return true; - } -}; - -// Returns the current OS stack trace as an std::string. -// -// The maximum number of stack frames to be included is specified by -// the gtest_stack_trace_depth flag. The skip_count parameter -// specifies the number of top frames to be skipped, which doesn't -// count against the number of frames to be included. -// -// For example, if Foo() calls Bar(), which in turn calls -// GetCurrentOsStackTraceExceptTop(..., 1), Foo() will be included in -// the trace but Bar() and GetCurrentOsStackTraceExceptTop() won't. -GTEST_API_ std::string GetCurrentOsStackTraceExceptTop( - UnitTest* unit_test, int skip_count); - -// Helpers for suppressing warnings on unreachable code or constant -// condition. - -// Always returns true. -GTEST_API_ bool AlwaysTrue(); - -// Always returns false. -inline bool AlwaysFalse() { return !AlwaysTrue(); } - -// Helper for suppressing false warning from Clang on a const char* -// variable declared in a conditional expression always being NULL in -// the else branch. -struct GTEST_API_ ConstCharPtr { - ConstCharPtr(const char* str) : value(str) {} - operator bool() const { return true; } - const char* value; -}; - -// Helper for declaring std::string within 'if' statement -// in pre C++17 build environment. -struct TrueWithString { - TrueWithString() = default; - explicit TrueWithString(const char* str) : value(str) {} - explicit TrueWithString(const std::string& str) : value(str) {} - explicit operator bool() const { return true; } - std::string value; -}; - -// A simple Linear Congruential Generator for generating random -// numbers with a uniform distribution. Unlike rand() and srand(), it -// doesn't use global state (and therefore can't interfere with user -// code). Unlike rand_r(), it's portable. An LCG isn't very random, -// but it's good enough for our purposes. -class GTEST_API_ Random { - public: - static const uint32_t kMaxRange = 1u << 31; - - explicit Random(uint32_t seed) : state_(seed) {} - - void Reseed(uint32_t seed) { state_ = seed; } - - // Generates a random number from [0, range). Crashes if 'range' is - // 0 or greater than kMaxRange. - uint32_t Generate(uint32_t range); - - private: - uint32_t state_; - GTEST_DISALLOW_COPY_AND_ASSIGN_(Random); -}; - -// Turns const U&, U&, const U, and U all into U. -#define GTEST_REMOVE_REFERENCE_AND_CONST_(T) \ - typename std::remove_const<typename std::remove_reference<T>::type>::type - -// HasDebugStringAndShortDebugString<T>::value is a compile-time bool constant -// that's true if and only if T has methods DebugString() and ShortDebugString() -// that return std::string. -template <typename T> -class HasDebugStringAndShortDebugString { - private: - template <typename C> - static auto CheckDebugString(C*) -> typename std::is_same< - std::string, decltype(std::declval<const C>().DebugString())>::type; - template <typename> - static std::false_type CheckDebugString(...); - - template <typename C> - static auto CheckShortDebugString(C*) -> typename std::is_same< - std::string, decltype(std::declval<const C>().ShortDebugString())>::type; - template <typename> - static std::false_type CheckShortDebugString(...); - - using HasDebugStringType = decltype(CheckDebugString<T>(nullptr)); - using HasShortDebugStringType = decltype(CheckShortDebugString<T>(nullptr)); - - public: - static constexpr bool value = - HasDebugStringType::value && HasShortDebugStringType::value; -}; - -template <typename T> -constexpr bool HasDebugStringAndShortDebugString<T>::value; - -// When the compiler sees expression IsContainerTest<C>(0), if C is an -// STL-style container class, the first overload of IsContainerTest -// will be viable (since both C::iterator* and C::const_iterator* are -// valid types and NULL can be implicitly converted to them). It will -// be picked over the second overload as 'int' is a perfect match for -// the type of argument 0. If C::iterator or C::const_iterator is not -// a valid type, the first overload is not viable, and the second -// overload will be picked. Therefore, we can determine whether C is -// a container class by checking the type of IsContainerTest<C>(0). -// The value of the expression is insignificant. -// -// In C++11 mode we check the existence of a const_iterator and that an -// iterator is properly implemented for the container. -// -// For pre-C++11 that we look for both C::iterator and C::const_iterator. -// The reason is that C++ injects the name of a class as a member of the -// class itself (e.g. you can refer to class iterator as either -// 'iterator' or 'iterator::iterator'). If we look for C::iterator -// only, for example, we would mistakenly think that a class named -// iterator is an STL container. -// -// Also note that the simpler approach of overloading -// IsContainerTest(typename C::const_iterator*) and -// IsContainerTest(...) doesn't work with Visual Age C++ and Sun C++. -typedef int IsContainer; -template <class C, - class Iterator = decltype(::std::declval<const C&>().begin()), - class = decltype(::std::declval<const C&>().end()), - class = decltype(++::std::declval<Iterator&>()), - class = decltype(*::std::declval<Iterator>()), - class = typename C::const_iterator> -IsContainer IsContainerTest(int /* dummy */) { - return 0; -} - -typedef char IsNotContainer; -template <class C> -IsNotContainer IsContainerTest(long /* dummy */) { return '\0'; } - -// Trait to detect whether a type T is a hash table. -// The heuristic used is that the type contains an inner type `hasher` and does -// not contain an inner type `reverse_iterator`. -// If the container is iterable in reverse, then order might actually matter. -template <typename T> -struct IsHashTable { - private: - template <typename U> - static char test(typename U::hasher*, typename U::reverse_iterator*); - template <typename U> - static int test(typename U::hasher*, ...); - template <typename U> - static char test(...); - - public: - static const bool value = sizeof(test<T>(nullptr, nullptr)) == sizeof(int); -}; - -template <typename T> -const bool IsHashTable<T>::value; - -template <typename C, - bool = sizeof(IsContainerTest<C>(0)) == sizeof(IsContainer)> -struct IsRecursiveContainerImpl; - -template <typename C> -struct IsRecursiveContainerImpl<C, false> : public std::false_type {}; - -// Since the IsRecursiveContainerImpl depends on the IsContainerTest we need to -// obey the same inconsistencies as the IsContainerTest, namely check if -// something is a container is relying on only const_iterator in C++11 and -// is relying on both const_iterator and iterator otherwise -template <typename C> -struct IsRecursiveContainerImpl<C, true> { - using value_type = decltype(*std::declval<typename C::const_iterator>()); - using type = - std::is_same<typename std::remove_const< - typename std::remove_reference<value_type>::type>::type, - C>; -}; - -// IsRecursiveContainer<Type> is a unary compile-time predicate that -// evaluates whether C is a recursive container type. A recursive container -// type is a container type whose value_type is equal to the container type -// itself. An example for a recursive container type is -// boost::filesystem::path, whose iterator has a value_type that is equal to -// boost::filesystem::path. -template <typename C> -struct IsRecursiveContainer : public IsRecursiveContainerImpl<C>::type {}; - -// Utilities for native arrays. - -// ArrayEq() compares two k-dimensional native arrays using the -// elements' operator==, where k can be any integer >= 0. When k is -// 0, ArrayEq() degenerates into comparing a single pair of values. - -template <typename T, typename U> -bool ArrayEq(const T* lhs, size_t size, const U* rhs); - -// This generic version is used when k is 0. -template <typename T, typename U> -inline bool ArrayEq(const T& lhs, const U& rhs) { return lhs == rhs; } - -// This overload is used when k >= 1. -template <typename T, typename U, size_t N> -inline bool ArrayEq(const T(&lhs)[N], const U(&rhs)[N]) { - return internal::ArrayEq(lhs, N, rhs); -} - -// This helper reduces code bloat. If we instead put its logic inside -// the previous ArrayEq() function, arrays with different sizes would -// lead to different copies of the template code. -template <typename T, typename U> -bool ArrayEq(const T* lhs, size_t size, const U* rhs) { - for (size_t i = 0; i != size; i++) { - if (!internal::ArrayEq(lhs[i], rhs[i])) - return false; - } - return true; -} - -// Finds the first element in the iterator range [begin, end) that -// equals elem. Element may be a native array type itself. -template <typename Iter, typename Element> -Iter ArrayAwareFind(Iter begin, Iter end, const Element& elem) { - for (Iter it = begin; it != end; ++it) { - if (internal::ArrayEq(*it, elem)) - return it; - } - return end; -} - -// CopyArray() copies a k-dimensional native array using the elements' -// operator=, where k can be any integer >= 0. When k is 0, -// CopyArray() degenerates into copying a single value. - -template <typename T, typename U> -void CopyArray(const T* from, size_t size, U* to); - -// This generic version is used when k is 0. -template <typename T, typename U> -inline void CopyArray(const T& from, U* to) { *to = from; } - -// This overload is used when k >= 1. -template <typename T, typename U, size_t N> -inline void CopyArray(const T(&from)[N], U(*to)[N]) { - internal::CopyArray(from, N, *to); -} - -// This helper reduces code bloat. If we instead put its logic inside -// the previous CopyArray() function, arrays with different sizes -// would lead to different copies of the template code. -template <typename T, typename U> -void CopyArray(const T* from, size_t size, U* to) { - for (size_t i = 0; i != size; i++) { - internal::CopyArray(from[i], to + i); - } -} - -// The relation between an NativeArray object (see below) and the -// native array it represents. -// We use 2 different structs to allow non-copyable types to be used, as long -// as RelationToSourceReference() is passed. -struct RelationToSourceReference {}; -struct RelationToSourceCopy {}; - -// Adapts a native array to a read-only STL-style container. Instead -// of the complete STL container concept, this adaptor only implements -// members useful for Google Mock's container matchers. New members -// should be added as needed. To simplify the implementation, we only -// support Element being a raw type (i.e. having no top-level const or -// reference modifier). It's the client's responsibility to satisfy -// this requirement. Element can be an array type itself (hence -// multi-dimensional arrays are supported). -template <typename Element> -class NativeArray { - public: - // STL-style container typedefs. - typedef Element value_type; - typedef Element* iterator; - typedef const Element* const_iterator; - - // Constructs from a native array. References the source. - NativeArray(const Element* array, size_t count, RelationToSourceReference) { - InitRef(array, count); - } - - // Constructs from a native array. Copies the source. - NativeArray(const Element* array, size_t count, RelationToSourceCopy) { - InitCopy(array, count); - } - - // Copy constructor. - NativeArray(const NativeArray& rhs) { - (this->*rhs.clone_)(rhs.array_, rhs.size_); - } - - ~NativeArray() { - if (clone_ != &NativeArray::InitRef) - delete[] array_; - } - - // STL-style container methods. - size_t size() const { return size_; } - const_iterator begin() const { return array_; } - const_iterator end() const { return array_ + size_; } - bool operator==(const NativeArray& rhs) const { - return size() == rhs.size() && - ArrayEq(begin(), size(), rhs.begin()); - } - - private: - static_assert(!std::is_const<Element>::value, "Type must not be const"); - static_assert(!std::is_reference<Element>::value, - "Type must not be a reference"); - - // Initializes this object with a copy of the input. - void InitCopy(const Element* array, size_t a_size) { - Element* const copy = new Element[a_size]; - CopyArray(array, a_size, copy); - array_ = copy; - size_ = a_size; - clone_ = &NativeArray::InitCopy; - } - - // Initializes this object with a reference of the input. - void InitRef(const Element* array, size_t a_size) { - array_ = array; - size_ = a_size; - clone_ = &NativeArray::InitRef; - } - - const Element* array_; - size_t size_; - void (NativeArray::*clone_)(const Element*, size_t); -}; - -// Backport of std::index_sequence. -template <size_t... Is> -struct IndexSequence { - using type = IndexSequence; -}; - -// Double the IndexSequence, and one if plus_one is true. -template <bool plus_one, typename T, size_t sizeofT> -struct DoubleSequence; -template <size_t... I, size_t sizeofT> -struct DoubleSequence<true, IndexSequence<I...>, sizeofT> { - using type = IndexSequence<I..., (sizeofT + I)..., 2 * sizeofT>; -}; -template <size_t... I, size_t sizeofT> -struct DoubleSequence<false, IndexSequence<I...>, sizeofT> { - using type = IndexSequence<I..., (sizeofT + I)...>; -}; - -// Backport of std::make_index_sequence. -// It uses O(ln(N)) instantiation depth. -template <size_t N> -struct MakeIndexSequenceImpl - : DoubleSequence<N % 2 == 1, typename MakeIndexSequenceImpl<N / 2>::type, - N / 2>::type {}; - -template <> -struct MakeIndexSequenceImpl<0> : IndexSequence<> {}; - -template <size_t N> -using MakeIndexSequence = typename MakeIndexSequenceImpl<N>::type; - -template <typename... T> -using IndexSequenceFor = typename MakeIndexSequence<sizeof...(T)>::type; - -template <size_t> -struct Ignore { - Ignore(...); // NOLINT -}; - -template <typename> -struct ElemFromListImpl; -template <size_t... I> -struct ElemFromListImpl<IndexSequence<I...>> { - // We make Ignore a template to solve a problem with MSVC. - // A non-template Ignore would work fine with `decltype(Ignore(I))...`, but - // MSVC doesn't understand how to deal with that pack expansion. - // Use `0 * I` to have a single instantiation of Ignore. - template <typename R> - static R Apply(Ignore<0 * I>..., R (*)(), ...); -}; - -template <size_t N, typename... T> -struct ElemFromList { - using type = - decltype(ElemFromListImpl<typename MakeIndexSequence<N>::type>::Apply( - static_cast<T (*)()>(nullptr)...)); -}; - -struct FlatTupleConstructTag {}; - -template <typename... T> -class FlatTuple; - -template <typename Derived, size_t I> -struct FlatTupleElemBase; - -template <typename... T, size_t I> -struct FlatTupleElemBase<FlatTuple<T...>, I> { - using value_type = typename ElemFromList<I, T...>::type; - FlatTupleElemBase() = default; - template <typename Arg> - explicit FlatTupleElemBase(FlatTupleConstructTag, Arg&& t) - : value(std::forward<Arg>(t)) {} - value_type value; -}; - -template <typename Derived, typename Idx> -struct FlatTupleBase; - -template <size_t... Idx, typename... T> -struct FlatTupleBase<FlatTuple<T...>, IndexSequence<Idx...>> - : FlatTupleElemBase<FlatTuple<T...>, Idx>... { - using Indices = IndexSequence<Idx...>; - FlatTupleBase() = default; - template <typename... Args> - explicit FlatTupleBase(FlatTupleConstructTag, Args&&... args) - : FlatTupleElemBase<FlatTuple<T...>, Idx>(FlatTupleConstructTag{}, - std::forward<Args>(args))... {} - - template <size_t I> - const typename ElemFromList<I, T...>::type& Get() const { - return FlatTupleElemBase<FlatTuple<T...>, I>::value; - } - - template <size_t I> - typename ElemFromList<I, T...>::type& Get() { - return FlatTupleElemBase<FlatTuple<T...>, I>::value; - } - - template <typename F> - auto Apply(F&& f) -> decltype(std::forward<F>(f)(this->Get<Idx>()...)) { - return std::forward<F>(f)(Get<Idx>()...); - } - - template <typename F> - auto Apply(F&& f) const -> decltype(std::forward<F>(f)(this->Get<Idx>()...)) { - return std::forward<F>(f)(Get<Idx>()...); - } -}; - -// Analog to std::tuple but with different tradeoffs. -// This class minimizes the template instantiation depth, thus allowing more -// elements than std::tuple would. std::tuple has been seen to require an -// instantiation depth of more than 10x the number of elements in some -// implementations. -// FlatTuple and ElemFromList are not recursive and have a fixed depth -// regardless of T... -// MakeIndexSequence, on the other hand, it is recursive but with an -// instantiation depth of O(ln(N)). -template <typename... T> -class FlatTuple - : private FlatTupleBase<FlatTuple<T...>, - typename MakeIndexSequence<sizeof...(T)>::type> { - using Indices = typename FlatTupleBase< - FlatTuple<T...>, typename MakeIndexSequence<sizeof...(T)>::type>::Indices; - - public: - FlatTuple() = default; - template <typename... Args> - explicit FlatTuple(FlatTupleConstructTag tag, Args&&... args) - : FlatTuple::FlatTupleBase(tag, std::forward<Args>(args)...) {} - - using FlatTuple::FlatTupleBase::Apply; - using FlatTuple::FlatTupleBase::Get; -}; - -// Utility functions to be called with static_assert to induce deprecation -// warnings. -GTEST_INTERNAL_DEPRECATED( - "INSTANTIATE_TEST_CASE_P is deprecated, please use " - "INSTANTIATE_TEST_SUITE_P") -constexpr bool InstantiateTestCase_P_IsDeprecated() { return true; } - -GTEST_INTERNAL_DEPRECATED( - "TYPED_TEST_CASE_P is deprecated, please use " - "TYPED_TEST_SUITE_P") -constexpr bool TypedTestCase_P_IsDeprecated() { return true; } - -GTEST_INTERNAL_DEPRECATED( - "TYPED_TEST_CASE is deprecated, please use " - "TYPED_TEST_SUITE") -constexpr bool TypedTestCaseIsDeprecated() { return true; } - -GTEST_INTERNAL_DEPRECATED( - "REGISTER_TYPED_TEST_CASE_P is deprecated, please use " - "REGISTER_TYPED_TEST_SUITE_P") -constexpr bool RegisterTypedTestCase_P_IsDeprecated() { return true; } - -GTEST_INTERNAL_DEPRECATED( - "INSTANTIATE_TYPED_TEST_CASE_P is deprecated, please use " - "INSTANTIATE_TYPED_TEST_SUITE_P") -constexpr bool InstantiateTypedTestCase_P_IsDeprecated() { return true; } - -} // namespace internal -} // namespace testing - -namespace std { -// Some standard library implementations use `struct tuple_size` and some use -// `class tuple_size`. Clang warns about the mismatch. -// https://reviews.llvm.org/D55466 -#ifdef __clang__ -#pragma clang diagnostic push -#pragma clang diagnostic ignored "-Wmismatched-tags" -#endif -template <typename... Ts> -struct tuple_size<testing::internal::FlatTuple<Ts...>> - : std::integral_constant<size_t, sizeof...(Ts)> {}; -#ifdef __clang__ -#pragma clang diagnostic pop -#endif -} // namespace std - -#define GTEST_MESSAGE_AT_(file, line, message, result_type) \ - ::testing::internal::AssertHelper(result_type, file, line, message) \ - = ::testing::Message() - -#define GTEST_MESSAGE_(message, result_type) \ - GTEST_MESSAGE_AT_(__FILE__, __LINE__, message, result_type) - -#define GTEST_FATAL_FAILURE_(message) \ - return GTEST_MESSAGE_(message, ::testing::TestPartResult::kFatalFailure) - -#define GTEST_NONFATAL_FAILURE_(message) \ - GTEST_MESSAGE_(message, ::testing::TestPartResult::kNonFatalFailure) - -#define GTEST_SUCCESS_(message) \ - GTEST_MESSAGE_(message, ::testing::TestPartResult::kSuccess) - -#define GTEST_SKIP_(message) \ - return GTEST_MESSAGE_(message, ::testing::TestPartResult::kSkip) - -// Suppress MSVC warning 4072 (unreachable code) for the code following -// statement if it returns or throws (or doesn't return or throw in some -// situations). -// NOTE: The "else" is important to keep this expansion to prevent a top-level -// "else" from attaching to our "if". -#define GTEST_SUPPRESS_UNREACHABLE_CODE_WARNING_BELOW_(statement) \ - if (::testing::internal::AlwaysTrue()) { \ - statement; \ - } else /* NOLINT */ \ - static_assert(true, "") // User must have a semicolon after expansion. - -#if GTEST_HAS_EXCEPTIONS - -namespace testing { -namespace internal { - -class NeverThrown { - public: - const char* what() const noexcept { - return "this exception should never be thrown"; - } -}; - -} // namespace internal -} // namespace testing - -#if GTEST_HAS_RTTI - -#define GTEST_EXCEPTION_TYPE_(e) ::testing::internal::GetTypeName(typeid(e)) - -#else // GTEST_HAS_RTTI - -#define GTEST_EXCEPTION_TYPE_(e) \ - std::string { "an std::exception-derived error" } - -#endif // GTEST_HAS_RTTI - -#define GTEST_TEST_THROW_CATCH_STD_EXCEPTION_(statement, expected_exception) \ - catch (typename std::conditional< \ - std::is_same<typename std::remove_cv<typename std::remove_reference< \ - expected_exception>::type>::type, \ - std::exception>::value, \ - const ::testing::internal::NeverThrown&, const std::exception&>::type \ - e) { \ - gtest_msg.value = "Expected: " #statement \ - " throws an exception of type " #expected_exception \ - ".\n Actual: it throws "; \ - gtest_msg.value += GTEST_EXCEPTION_TYPE_(e); \ - gtest_msg.value += " with description \""; \ - gtest_msg.value += e.what(); \ - gtest_msg.value += "\"."; \ - goto GTEST_CONCAT_TOKEN_(gtest_label_testthrow_, __LINE__); \ - } - -#else // GTEST_HAS_EXCEPTIONS - -#define GTEST_TEST_THROW_CATCH_STD_EXCEPTION_(statement, expected_exception) - -#endif // GTEST_HAS_EXCEPTIONS - -#define GTEST_TEST_THROW_(statement, expected_exception, fail) \ - GTEST_AMBIGUOUS_ELSE_BLOCKER_ \ - if (::testing::internal::TrueWithString gtest_msg{}) { \ - bool gtest_caught_expected = false; \ - try { \ - GTEST_SUPPRESS_UNREACHABLE_CODE_WARNING_BELOW_(statement); \ - } catch (expected_exception const&) { \ - gtest_caught_expected = true; \ - } \ - GTEST_TEST_THROW_CATCH_STD_EXCEPTION_(statement, expected_exception) \ - catch (...) { \ - gtest_msg.value = "Expected: " #statement \ - " throws an exception of type " #expected_exception \ - ".\n Actual: it throws a different type."; \ - goto GTEST_CONCAT_TOKEN_(gtest_label_testthrow_, __LINE__); \ - } \ - if (!gtest_caught_expected) { \ - gtest_msg.value = "Expected: " #statement \ - " throws an exception of type " #expected_exception \ - ".\n Actual: it throws nothing."; \ - goto GTEST_CONCAT_TOKEN_(gtest_label_testthrow_, __LINE__); \ - } \ - } else /*NOLINT*/ \ - GTEST_CONCAT_TOKEN_(gtest_label_testthrow_, __LINE__) \ - : fail(gtest_msg.value.c_str()) - -#if GTEST_HAS_EXCEPTIONS - -#define GTEST_TEST_NO_THROW_CATCH_STD_EXCEPTION_() \ - catch (std::exception const& e) { \ - gtest_msg.value = "it throws "; \ - gtest_msg.value += GTEST_EXCEPTION_TYPE_(e); \ - gtest_msg.value += " with description \""; \ - gtest_msg.value += e.what(); \ - gtest_msg.value += "\"."; \ - goto GTEST_CONCAT_TOKEN_(gtest_label_testnothrow_, __LINE__); \ - } - -#else // GTEST_HAS_EXCEPTIONS - -#define GTEST_TEST_NO_THROW_CATCH_STD_EXCEPTION_() - -#endif // GTEST_HAS_EXCEPTIONS - -#define GTEST_TEST_NO_THROW_(statement, fail) \ - GTEST_AMBIGUOUS_ELSE_BLOCKER_ \ - if (::testing::internal::TrueWithString gtest_msg{}) { \ - try { \ - GTEST_SUPPRESS_UNREACHABLE_CODE_WARNING_BELOW_(statement); \ - } \ - GTEST_TEST_NO_THROW_CATCH_STD_EXCEPTION_() \ - catch (...) { \ - gtest_msg.value = "it throws."; \ - goto GTEST_CONCAT_TOKEN_(gtest_label_testnothrow_, __LINE__); \ - } \ - } else \ - GTEST_CONCAT_TOKEN_(gtest_label_testnothrow_, __LINE__): \ - fail(("Expected: " #statement " doesn't throw an exception.\n" \ - " Actual: " + gtest_msg.value).c_str()) - -#define GTEST_TEST_ANY_THROW_(statement, fail) \ - GTEST_AMBIGUOUS_ELSE_BLOCKER_ \ - if (::testing::internal::AlwaysTrue()) { \ - bool gtest_caught_any = false; \ - try { \ - GTEST_SUPPRESS_UNREACHABLE_CODE_WARNING_BELOW_(statement); \ - } \ - catch (...) { \ - gtest_caught_any = true; \ - } \ - if (!gtest_caught_any) { \ - goto GTEST_CONCAT_TOKEN_(gtest_label_testanythrow_, __LINE__); \ - } \ - } else \ - GTEST_CONCAT_TOKEN_(gtest_label_testanythrow_, __LINE__): \ - fail("Expected: " #statement " throws an exception.\n" \ - " Actual: it doesn't.") - - -// Implements Boolean test assertions such as EXPECT_TRUE. expression can be -// either a boolean expression or an AssertionResult. text is a textual -// representation of expression as it was passed into the EXPECT_TRUE. -#define GTEST_TEST_BOOLEAN_(expression, text, actual, expected, fail) \ - GTEST_AMBIGUOUS_ELSE_BLOCKER_ \ - if (const ::testing::AssertionResult gtest_ar_ = \ - ::testing::AssertionResult(expression)) \ - ; \ - else \ - fail(::testing::internal::GetBoolAssertionFailureMessage(\ - gtest_ar_, text, #actual, #expected).c_str()) - -#define GTEST_TEST_NO_FATAL_FAILURE_(statement, fail) \ - GTEST_AMBIGUOUS_ELSE_BLOCKER_ \ - if (::testing::internal::AlwaysTrue()) { \ - ::testing::internal::HasNewFatalFailureHelper gtest_fatal_failure_checker; \ - GTEST_SUPPRESS_UNREACHABLE_CODE_WARNING_BELOW_(statement); \ - if (gtest_fatal_failure_checker.has_new_fatal_failure()) { \ - goto GTEST_CONCAT_TOKEN_(gtest_label_testnofatal_, __LINE__); \ - } \ - } else \ - GTEST_CONCAT_TOKEN_(gtest_label_testnofatal_, __LINE__): \ - fail("Expected: " #statement " doesn't generate new fatal " \ - "failures in the current thread.\n" \ - " Actual: it does.") - -// Expands to the name of the class that implements the given test. -#define GTEST_TEST_CLASS_NAME_(test_suite_name, test_name) \ - test_suite_name##_##test_name##_Test - -// Helper macro for defining tests. -#define GTEST_TEST_(test_suite_name, test_name, parent_class, parent_id) \ - static_assert(sizeof(GTEST_STRINGIFY_(test_suite_name)) > 1, \ - "test_suite_name must not be empty"); \ - static_assert(sizeof(GTEST_STRINGIFY_(test_name)) > 1, \ - "test_name must not be empty"); \ - class GTEST_TEST_CLASS_NAME_(test_suite_name, test_name) \ - : public parent_class { \ - public: \ - GTEST_TEST_CLASS_NAME_(test_suite_name, test_name)() = default; \ - ~GTEST_TEST_CLASS_NAME_(test_suite_name, test_name)() override = default; \ - GTEST_DISALLOW_COPY_AND_ASSIGN_(GTEST_TEST_CLASS_NAME_(test_suite_name, \ - test_name)); \ - GTEST_DISALLOW_MOVE_AND_ASSIGN_(GTEST_TEST_CLASS_NAME_(test_suite_name, \ - test_name)); \ - \ - private: \ - void TestBody() override; \ - static ::testing::TestInfo* const test_info_ GTEST_ATTRIBUTE_UNUSED_; \ - }; \ - \ - ::testing::TestInfo* const GTEST_TEST_CLASS_NAME_(test_suite_name, \ - test_name)::test_info_ = \ - ::testing::internal::MakeAndRegisterTestInfo( \ - #test_suite_name, #test_name, nullptr, nullptr, \ - ::testing::internal::CodeLocation(__FILE__, __LINE__), (parent_id), \ - ::testing::internal::SuiteApiResolver< \ - parent_class>::GetSetUpCaseOrSuite(__FILE__, __LINE__), \ - ::testing::internal::SuiteApiResolver< \ - parent_class>::GetTearDownCaseOrSuite(__FILE__, __LINE__), \ - new ::testing::internal::TestFactoryImpl<GTEST_TEST_CLASS_NAME_( \ - test_suite_name, test_name)>); \ - void GTEST_TEST_CLASS_NAME_(test_suite_name, test_name)::TestBody() - -#endif // GOOGLETEST_INCLUDE_GTEST_INTERNAL_GTEST_INTERNAL_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. - -// -// The Google C++ Testing and Mocking Framework (Google Test) -// -// This header file defines the public API for death tests. It is -// #included by gtest.h so a user doesn't need to include this -// directly. -// GOOGLETEST_CM0001 DO NOT DELETE - -#ifndef GOOGLETEST_INCLUDE_GTEST_GTEST_DEATH_TEST_H_ -#define GOOGLETEST_INCLUDE_GTEST_GTEST_DEATH_TEST_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. -// -// The Google C++ Testing and Mocking Framework (Google Test) -// -// This header file defines internal utilities needed for implementing -// death tests. They are subject to change without notice. -// GOOGLETEST_CM0001 DO NOT DELETE - -#ifndef GOOGLETEST_INCLUDE_GTEST_INTERNAL_GTEST_DEATH_TEST_INTERNAL_H_ -#define GOOGLETEST_INCLUDE_GTEST_INTERNAL_GTEST_DEATH_TEST_INTERNAL_H_ - -// Copyright 2007, 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. - -// The Google C++ Testing and Mocking Framework (Google Test) -// -// This file implements just enough of the matcher interface to allow -// EXPECT_DEATH and friends to accept a matcher argument. - -#ifndef GOOGLETEST_INCLUDE_GTEST_GTEST_MATCHERS_H_ -#define GOOGLETEST_INCLUDE_GTEST_GTEST_MATCHERS_H_ - -#include <atomic> -#include <memory> -#include <ostream> -#include <string> -#include <type_traits> - -// Copyright 2007, 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. - - -// Google Test - The Google C++ Testing and Mocking Framework -// -// This file implements a universal value printer that can print a -// value of any type T: -// -// void ::testing::internal::UniversalPrinter<T>::Print(value, ostream_ptr); -// -// A user can teach this function how to print a class type T by -// defining either operator<<() or PrintTo() in the namespace that -// defines T. More specifically, the FIRST defined function in the -// following list will be used (assuming T is defined in namespace -// foo): -// -// 1. foo::PrintTo(const T&, ostream*) -// 2. operator<<(ostream&, const T&) defined in either foo or the -// global namespace. -// -// However if T is an STL-style container then it is printed element-wise -// unless foo::PrintTo(const T&, ostream*) is defined. Note that -// operator<<() is ignored for container types. -// -// If none of the above is defined, it will print the debug string of -// the value if it is a protocol buffer, or print the raw bytes in the -// value otherwise. -// -// To aid debugging: when T is a reference type, the address of the -// value is also printed; when T is a (const) char pointer, both the -// pointer value and the NUL-terminated string it points to are -// printed. -// -// We also provide some convenient wrappers: -// -// // Prints a value to a string. For a (const or not) char -// // pointer, the NUL-terminated string (but not the pointer) is -// // printed. -// std::string ::testing::PrintToString(const T& value); -// -// // Prints a value tersely: for a reference type, the referenced -// // value (but not the address) is printed; for a (const or not) char -// // pointer, the NUL-terminated string (but not the pointer) is -// // printed. -// void ::testing::internal::UniversalTersePrint(const T& value, ostream*); -// -// // Prints value using the type inferred by the compiler. The difference -// // from UniversalTersePrint() is that this function prints both the -// // pointer and the NUL-terminated string for a (const or not) char pointer. -// void ::testing::internal::UniversalPrint(const T& value, ostream*); -// -// // Prints the fields of a tuple tersely to a string vector, one -// // element for each field. Tuple support must be enabled in -// // gtest-port.h. -// std::vector<string> UniversalTersePrintTupleFieldsToStrings( -// const Tuple& value); -// -// Known limitation: -// -// The print primitives print the elements of an STL-style container -// using the compiler-inferred type of *iter where iter is a -// const_iterator of the container. When const_iterator is an input -// iterator but not a forward iterator, this inferred type may not -// match value_type, and the print output may be incorrect. In -// practice, this is rarely a problem as for most containers -// const_iterator is a forward iterator. We'll fix this if there's an -// actual need for it. Note that this fix cannot rely on value_type -// being defined as many user-defined container types don't have -// value_type. - -// GOOGLETEST_CM0001 DO NOT DELETE - -#ifndef GOOGLETEST_INCLUDE_GTEST_GTEST_PRINTERS_H_ -#define GOOGLETEST_INCLUDE_GTEST_GTEST_PRINTERS_H_ - -#include <functional> -#include <memory> -#include <ostream> // NOLINT -#include <sstream> -#include <string> -#include <tuple> -#include <type_traits> -#include <utility> -#include <vector> - - -#if GTEST_HAS_RTTI -#include <typeindex> -#include <typeinfo> -#endif // GTEST_HAS_RTTI - -namespace testing { - -// Definitions in the internal* namespaces are subject to change without notice. -// DO NOT USE THEM IN USER CODE! -namespace internal { - -template <typename T> -void UniversalPrint(const T& value, ::std::ostream* os); - -// Used to print an STL-style container when the user doesn't define -// a PrintTo() for it. -struct ContainerPrinter { - template <typename T, - typename = typename std::enable_if< - (sizeof(IsContainerTest<T>(0)) == sizeof(IsContainer)) && - !IsRecursiveContainer<T>::value>::type> - static void PrintValue(const T& container, std::ostream* os) { - const size_t kMaxCount = 32; // The maximum number of elements to print. - *os << '{'; - size_t count = 0; - for (auto&& elem : container) { - if (count > 0) { - *os << ','; - if (count == kMaxCount) { // Enough has been printed. - *os << " ..."; - break; - } - } - *os << ' '; - // We cannot call PrintTo(elem, os) here as PrintTo() doesn't - // handle `elem` being a native array. - internal::UniversalPrint(elem, os); - ++count; - } - - if (count > 0) { - *os << ' '; - } - *os << '}'; - } -}; - -// Used to print a pointer that is neither a char pointer nor a member -// pointer, when the user doesn't define PrintTo() for it. (A member -// variable pointer or member function pointer doesn't really point to -// a location in the address space. Their representation is -// implementation-defined. Therefore they will be printed as raw -// bytes.) -struct FunctionPointerPrinter { - template <typename T, typename = typename std::enable_if< - std::is_function<T>::value>::type> - static void PrintValue(T* p, ::std::ostream* os) { - if (p == nullptr) { - *os << "NULL"; - } else { - // T is a function type, so '*os << p' doesn't do what we want - // (it just prints p as bool). We want to print p as a const - // void*. - *os << reinterpret_cast<const void*>(p); - } - } -}; - -struct PointerPrinter { - template <typename T> - static void PrintValue(T* p, ::std::ostream* os) { - if (p == nullptr) { - *os << "NULL"; - } else { - // T is not a function type. We just call << to print p, - // relying on ADL to pick up user-defined << for their pointer - // types, if any. - *os << p; - } - } -}; - -namespace internal_stream_operator_without_lexical_name_lookup { - -// The presence of an operator<< here will terminate lexical scope lookup -// straight away (even though it cannot be a match because of its argument -// types). Thus, the two operator<< calls in StreamPrinter will find only ADL -// candidates. -struct LookupBlocker {}; -void operator<<(LookupBlocker, LookupBlocker); - -struct StreamPrinter { - template <typename T, - // Don't accept member pointers here. We'd print them via implicit - // conversion to bool, which isn't useful. - typename = typename std::enable_if< - !std::is_member_pointer<T>::value>::type, - // Only accept types for which we can find a streaming operator via - // ADL (possibly involving implicit conversions). - typename = decltype(std::declval<std::ostream&>() - << std::declval<const T&>())> - static void PrintValue(const T& value, ::std::ostream* os) { - // Call streaming operator found by ADL, possibly with implicit conversions - // of the arguments. - *os << value; - } -}; - -} // namespace internal_stream_operator_without_lexical_name_lookup - -struct ProtobufPrinter { - // We print a protobuf using its ShortDebugString() when the string - // doesn't exceed this many characters; otherwise we print it using - // DebugString() for better readability. - static const size_t kProtobufOneLinerMaxLength = 50; - - template <typename T, - typename = typename std::enable_if< - internal::HasDebugStringAndShortDebugString<T>::value>::type> - static void PrintValue(const T& value, ::std::ostream* os) { - std::string pretty_str = value.ShortDebugString(); - if (pretty_str.length() > kProtobufOneLinerMaxLength) { - pretty_str = "\n" + value.DebugString(); - } - *os << ("<" + pretty_str + ">"); - } -}; - -struct ConvertibleToIntegerPrinter { - // Since T has no << operator or PrintTo() but can be implicitly - // converted to BiggestInt, we print it as a BiggestInt. - // - // Most likely T is an enum type (either named or unnamed), in which - // case printing it as an integer is the desired behavior. In case - // T is not an enum, printing it as an integer is the best we can do - // given that it has no user-defined printer. - static void PrintValue(internal::BiggestInt value, ::std::ostream* os) { - *os << value; - } -}; - -struct ConvertibleToStringViewPrinter { -#if GTEST_INTERNAL_HAS_STRING_VIEW - static void PrintValue(internal::StringView value, ::std::ostream* os) { - internal::UniversalPrint(value, os); - } -#endif -}; - - -// Prints the given number of bytes in the given object to the given -// ostream. -GTEST_API_ void PrintBytesInObjectTo(const unsigned char* obj_bytes, - size_t count, - ::std::ostream* os); -struct RawBytesPrinter { - // SFINAE on `sizeof` to make sure we have a complete type. - template <typename T, size_t = sizeof(T)> - static void PrintValue(const T& value, ::std::ostream* os) { - PrintBytesInObjectTo( - static_cast<const unsigned char*>( - // Load bearing cast to void* to support iOS - reinterpret_cast<const void*>(std::addressof(value))), - sizeof(value), os); - } -}; - -struct FallbackPrinter { - template <typename T> - static void PrintValue(const T&, ::std::ostream* os) { - *os << "(incomplete type)"; - } -}; - -// Try every printer in order and return the first one that works. -template <typename T, typename E, typename Printer, typename... Printers> -struct FindFirstPrinter : FindFirstPrinter<T, E, Printers...> {}; - -template <typename T, typename Printer, typename... Printers> -struct FindFirstPrinter< - T, decltype(Printer::PrintValue(std::declval<const T&>(), nullptr)), - Printer, Printers...> { - using type = Printer; -}; - -// Select the best printer in the following order: -// - Print containers (they have begin/end/etc). -// - Print function pointers. -// - Print object pointers. -// - Use the stream operator, if available. -// - Print protocol buffers. -// - Print types convertible to BiggestInt. -// - Print types convertible to StringView, if available. -// - Fallback to printing the raw bytes of the object. -template <typename T> -void PrintWithFallback(const T& value, ::std::ostream* os) { - using Printer = typename FindFirstPrinter< - T, void, ContainerPrinter, FunctionPointerPrinter, PointerPrinter, - internal_stream_operator_without_lexical_name_lookup::StreamPrinter, - ProtobufPrinter, ConvertibleToIntegerPrinter, - ConvertibleToStringViewPrinter, RawBytesPrinter, FallbackPrinter>::type; - Printer::PrintValue(value, os); -} - -// FormatForComparison<ToPrint, OtherOperand>::Format(value) formats a -// value of type ToPrint that is an operand of a comparison assertion -// (e.g. ASSERT_EQ). OtherOperand is the type of the other operand in -// the comparison, and is used to help determine the best way to -// format the value. In particular, when the value is a C string -// (char pointer) and the other operand is an STL string object, we -// want to format the C string as a string, since we know it is -// compared by value with the string object. If the value is a char -// pointer but the other operand is not an STL string object, we don't -// know whether the pointer is supposed to point to a NUL-terminated -// string, and thus want to print it as a pointer to be safe. -// -// INTERNAL IMPLEMENTATION - DO NOT USE IN A USER PROGRAM. - -// The default case. -template <typename ToPrint, typename OtherOperand> -class FormatForComparison { - public: - static ::std::string Format(const ToPrint& value) { - return ::testing::PrintToString(value); - } -}; - -// Array. -template <typename ToPrint, size_t N, typename OtherOperand> -class FormatForComparison<ToPrint[N], OtherOperand> { - public: - static ::std::string Format(const ToPrint* value) { - return FormatForComparison<const ToPrint*, OtherOperand>::Format(value); - } -}; - -// By default, print C string as pointers to be safe, as we don't know -// whether they actually point to a NUL-terminated string. - -#define GTEST_IMPL_FORMAT_C_STRING_AS_POINTER_(CharType) \ - template <typename OtherOperand> \ - class FormatForComparison<CharType*, OtherOperand> { \ - public: \ - static ::std::string Format(CharType* value) { \ - return ::testing::PrintToString(static_cast<const void*>(value)); \ - } \ - } - -GTEST_IMPL_FORMAT_C_STRING_AS_POINTER_(char); -GTEST_IMPL_FORMAT_C_STRING_AS_POINTER_(const char); -GTEST_IMPL_FORMAT_C_STRING_AS_POINTER_(wchar_t); -GTEST_IMPL_FORMAT_C_STRING_AS_POINTER_(const wchar_t); -#ifdef __cpp_char8_t -GTEST_IMPL_FORMAT_C_STRING_AS_POINTER_(char8_t); -GTEST_IMPL_FORMAT_C_STRING_AS_POINTER_(const char8_t); -#endif -GTEST_IMPL_FORMAT_C_STRING_AS_POINTER_(char16_t); -GTEST_IMPL_FORMAT_C_STRING_AS_POINTER_(const char16_t); -GTEST_IMPL_FORMAT_C_STRING_AS_POINTER_(char32_t); -GTEST_IMPL_FORMAT_C_STRING_AS_POINTER_(const char32_t); - -#undef GTEST_IMPL_FORMAT_C_STRING_AS_POINTER_ - -// If a C string is compared with an STL string object, we know it's meant -// to point to a NUL-terminated string, and thus can print it as a string. - -#define GTEST_IMPL_FORMAT_C_STRING_AS_STRING_(CharType, OtherStringType) \ - template <> \ - class FormatForComparison<CharType*, OtherStringType> { \ - public: \ - static ::std::string Format(CharType* value) { \ - return ::testing::PrintToString(value); \ - } \ - } - -GTEST_IMPL_FORMAT_C_STRING_AS_STRING_(char, ::std::string); -GTEST_IMPL_FORMAT_C_STRING_AS_STRING_(const char, ::std::string); -#ifdef __cpp_char8_t -GTEST_IMPL_FORMAT_C_STRING_AS_STRING_(char8_t, ::std::u8string); -GTEST_IMPL_FORMAT_C_STRING_AS_STRING_(const char8_t, ::std::u8string); -#endif -GTEST_IMPL_FORMAT_C_STRING_AS_STRING_(char16_t, ::std::u16string); -GTEST_IMPL_FORMAT_C_STRING_AS_STRING_(const char16_t, ::std::u16string); -GTEST_IMPL_FORMAT_C_STRING_AS_STRING_(char32_t, ::std::u32string); -GTEST_IMPL_FORMAT_C_STRING_AS_STRING_(const char32_t, ::std::u32string); - -#if GTEST_HAS_STD_WSTRING -GTEST_IMPL_FORMAT_C_STRING_AS_STRING_(wchar_t, ::std::wstring); -GTEST_IMPL_FORMAT_C_STRING_AS_STRING_(const wchar_t, ::std::wstring); -#endif - -#undef GTEST_IMPL_FORMAT_C_STRING_AS_STRING_ - -// Formats a comparison assertion (e.g. ASSERT_EQ, EXPECT_LT, and etc) -// operand to be used in a failure message. The type (but not value) -// of the other operand may affect the format. This allows us to -// print a char* as a raw pointer when it is compared against another -// char* or void*, and print it as a C string when it is compared -// against an std::string object, for example. -// -// INTERNAL IMPLEMENTATION - DO NOT USE IN A USER PROGRAM. -template <typename T1, typename T2> -std::string FormatForComparisonFailureMessage( - const T1& value, const T2& /* other_operand */) { - return FormatForComparison<T1, T2>::Format(value); -} - -// UniversalPrinter<T>::Print(value, ostream_ptr) prints the given -// value to the given ostream. The caller must ensure that -// 'ostream_ptr' is not NULL, or the behavior is undefined. -// -// We define UniversalPrinter as a class template (as opposed to a -// function template), as we need to partially specialize it for -// reference types, which cannot be done with function templates. -template <typename T> -class UniversalPrinter; - -// Prints the given value using the << operator if it has one; -// otherwise prints the bytes in it. This is what -// UniversalPrinter<T>::Print() does when PrintTo() is not specialized -// or overloaded for type T. -// -// A user can override this behavior for a class type Foo by defining -// an overload of PrintTo() in the namespace where Foo is defined. We -// give the user this option as sometimes defining a << operator for -// Foo is not desirable (e.g. the coding style may prevent doing it, -// or there is already a << operator but it doesn't do what the user -// wants). -template <typename T> -void PrintTo(const T& value, ::std::ostream* os) { - internal::PrintWithFallback(value, os); -} - -// The following list of PrintTo() overloads tells -// UniversalPrinter<T>::Print() how to print standard types (built-in -// types, strings, plain arrays, and pointers). - -// Overloads for various char types. -GTEST_API_ void PrintTo(unsigned char c, ::std::ostream* os); -GTEST_API_ void PrintTo(signed char c, ::std::ostream* os); -inline void PrintTo(char c, ::std::ostream* os) { - // When printing a plain char, we always treat it as unsigned. This - // way, the output won't be affected by whether the compiler thinks - // char is signed or not. - PrintTo(static_cast<unsigned char>(c), os); -} - -// Overloads for other simple built-in types. -inline void PrintTo(bool x, ::std::ostream* os) { - *os << (x ? "true" : "false"); -} - -// Overload for wchar_t type. -// Prints a wchar_t as a symbol if it is printable or as its internal -// code otherwise and also as its decimal code (except for L'\0'). -// The L'\0' char is printed as "L'\\0'". The decimal code is printed -// as signed integer when wchar_t is implemented by the compiler -// as a signed type and is printed as an unsigned integer when wchar_t -// is implemented as an unsigned type. -GTEST_API_ void PrintTo(wchar_t wc, ::std::ostream* os); - -GTEST_API_ void PrintTo(char32_t c, ::std::ostream* os); -inline void PrintTo(char16_t c, ::std::ostream* os) { - PrintTo(ImplicitCast_<char32_t>(c), os); -} -#ifdef __cpp_char8_t -inline void PrintTo(char8_t c, ::std::ostream* os) { - PrintTo(ImplicitCast_<char32_t>(c), os); -} -#endif - -// Overloads for C strings. -GTEST_API_ void PrintTo(const char* s, ::std::ostream* os); -inline void PrintTo(char* s, ::std::ostream* os) { - PrintTo(ImplicitCast_<const char*>(s), os); -} - -// signed/unsigned char is often used for representing binary data, so -// we print pointers to it as void* to be safe. -inline void PrintTo(const signed char* s, ::std::ostream* os) { - PrintTo(ImplicitCast_<const void*>(s), os); -} -inline void PrintTo(signed char* s, ::std::ostream* os) { - PrintTo(ImplicitCast_<const void*>(s), os); -} -inline void PrintTo(const unsigned char* s, ::std::ostream* os) { - PrintTo(ImplicitCast_<const void*>(s), os); -} -inline void PrintTo(unsigned char* s, ::std::ostream* os) { - PrintTo(ImplicitCast_<const void*>(s), os); -} -#ifdef __cpp_char8_t -// Overloads for u8 strings. -void PrintTo(const char8_t* s, ::std::ostream* os); -inline void PrintTo(char8_t* s, ::std::ostream* os) { - PrintTo(ImplicitCast_<const char8_t*>(s), os); -} -#endif -// Overloads for u16 strings. -void PrintTo(const char16_t* s, ::std::ostream* os); -inline void PrintTo(char16_t* s, ::std::ostream* os) { - PrintTo(ImplicitCast_<const char16_t*>(s), os); -} -// Overloads for u32 strings. -void PrintTo(const char32_t* s, ::std::ostream* os); -inline void PrintTo(char32_t* s, ::std::ostream* os) { - PrintTo(ImplicitCast_<const char32_t*>(s), os); -} - -// MSVC can be configured to define wchar_t as a typedef of unsigned -// short. It defines _NATIVE_WCHAR_T_DEFINED when wchar_t is a native -// type. When wchar_t is a typedef, defining an overload for const -// wchar_t* would cause unsigned short* be printed as a wide string, -// possibly causing invalid memory accesses. -#if !defined(_MSC_VER) || defined(_NATIVE_WCHAR_T_DEFINED) -// Overloads for wide C strings -GTEST_API_ void PrintTo(const wchar_t* s, ::std::ostream* os); -inline void PrintTo(wchar_t* s, ::std::ostream* os) { - PrintTo(ImplicitCast_<const wchar_t*>(s), os); -} -#endif - -// Overload for C arrays. Multi-dimensional arrays are printed -// properly. - -// Prints the given number of elements in an array, without printing -// the curly braces. -template <typename T> -void PrintRawArrayTo(const T a[], size_t count, ::std::ostream* os) { - UniversalPrint(a[0], os); - for (size_t i = 1; i != count; i++) { - *os << ", "; - UniversalPrint(a[i], os); - } -} - -// Overloads for ::std::string. -GTEST_API_ void PrintStringTo(const ::std::string&s, ::std::ostream* os); -inline void PrintTo(const ::std::string& s, ::std::ostream* os) { - PrintStringTo(s, os); -} - -// Overloads for ::std::u8string -#ifdef __cpp_char8_t -GTEST_API_ void PrintU8StringTo(const ::std::u8string& s, ::std::ostream* os); -inline void PrintTo(const ::std::u8string& s, ::std::ostream* os) { - PrintU8StringTo(s, os); -} -#endif - -// Overloads for ::std::u16string -GTEST_API_ void PrintU16StringTo(const ::std::u16string& s, ::std::ostream* os); -inline void PrintTo(const ::std::u16string& s, ::std::ostream* os) { - PrintU16StringTo(s, os); -} - -// Overloads for ::std::u32string -GTEST_API_ void PrintU32StringTo(const ::std::u32string& s, ::std::ostream* os); -inline void PrintTo(const ::std::u32string& s, ::std::ostream* os) { - PrintU32StringTo(s, os); -} - -// Overloads for ::std::wstring. -#if GTEST_HAS_STD_WSTRING -GTEST_API_ void PrintWideStringTo(const ::std::wstring&s, ::std::ostream* os); -inline void PrintTo(const ::std::wstring& s, ::std::ostream* os) { - PrintWideStringTo(s, os); -} -#endif // GTEST_HAS_STD_WSTRING - -#if GTEST_INTERNAL_HAS_STRING_VIEW -// Overload for internal::StringView. -inline void PrintTo(internal::StringView sp, ::std::ostream* os) { - PrintTo(::std::string(sp), os); -} -#endif // GTEST_INTERNAL_HAS_STRING_VIEW - -inline void PrintTo(std::nullptr_t, ::std::ostream* os) { *os << "(nullptr)"; } - -template <typename T> -void PrintTo(std::reference_wrapper<T> ref, ::std::ostream* os) { - UniversalPrinter<T&>::Print(ref.get(), os); -} - -inline const void* VoidifyPointer(const void* p) { return p; } -inline const void* VoidifyPointer(volatile const void* p) { - return const_cast<const void*>(p); -} - -template <typename T, typename Ptr> -void PrintSmartPointer(const Ptr& ptr, std::ostream* os, char) { - if (ptr == nullptr) { - *os << "(nullptr)"; - } else { - // We can't print the value. Just print the pointer.. - *os << "(" << (VoidifyPointer)(ptr.get()) << ")"; - } -} -template <typename T, typename Ptr, - typename = typename std::enable_if<!std::is_void<T>::value && - !std::is_array<T>::value>::type> -void PrintSmartPointer(const Ptr& ptr, std::ostream* os, int) { - if (ptr == nullptr) { - *os << "(nullptr)"; - } else { - *os << "(ptr = " << (VoidifyPointer)(ptr.get()) << ", value = "; - UniversalPrinter<T>::Print(*ptr, os); - *os << ")"; - } -} - -template <typename T, typename D> -void PrintTo(const std::unique_ptr<T, D>& ptr, std::ostream* os) { - (PrintSmartPointer<T>)(ptr, os, 0); -} - -template <typename T> -void PrintTo(const std::shared_ptr<T>& ptr, std::ostream* os) { - (PrintSmartPointer<T>)(ptr, os, 0); -} - -// Helper function for printing a tuple. T must be instantiated with -// a tuple type. -template <typename T> -void PrintTupleTo(const T&, std::integral_constant<size_t, 0>, - ::std::ostream*) {} - -template <typename T, size_t I> -void PrintTupleTo(const T& t, std::integral_constant<size_t, I>, - ::std::ostream* os) { - PrintTupleTo(t, std::integral_constant<size_t, I - 1>(), os); - GTEST_INTENTIONAL_CONST_COND_PUSH_() - if (I > 1) { - GTEST_INTENTIONAL_CONST_COND_POP_() - *os << ", "; - } - UniversalPrinter<typename std::tuple_element<I - 1, T>::type>::Print( - std::get<I - 1>(t), os); -} - -template <typename... Types> -void PrintTo(const ::std::tuple<Types...>& t, ::std::ostream* os) { - *os << "("; - PrintTupleTo(t, std::integral_constant<size_t, sizeof...(Types)>(), os); - *os << ")"; -} - -// Overload for std::pair. -template <typename T1, typename T2> -void PrintTo(const ::std::pair<T1, T2>& value, ::std::ostream* os) { - *os << '('; - // We cannot use UniversalPrint(value.first, os) here, as T1 may be - // a reference type. The same for printing value.second. - UniversalPrinter<T1>::Print(value.first, os); - *os << ", "; - UniversalPrinter<T2>::Print(value.second, os); - *os << ')'; -} - -#if GTEST_HAS_RTTI -inline void PrintTo(const ::std::type_info& value, ::std::ostream* os) { - internal::PrintTo<::std::type_info>(value, os); - *os << " (\"" << value.name() << "\")"; -} - -inline void PrintTo(const ::std::type_index& value, ::std::ostream* os) { - internal::PrintTo<::std::type_index>(value, os); - *os << " (\"" << value.name() << "\")"; -} -#endif // GTEST_HAS_RTTI - -// Implements printing a non-reference type T by letting the compiler -// pick the right overload of PrintTo() for T. -template <typename T> -class UniversalPrinter { - public: - // MSVC warns about adding const to a function type, so we want to - // disable the warning. - GTEST_DISABLE_MSC_WARNINGS_PUSH_(4180) - - // Note: we deliberately don't call this PrintTo(), as that name - // conflicts with ::testing::internal::PrintTo in the body of the - // function. - static void Print(const T& value, ::std::ostream* os) { - // By default, ::testing::internal::PrintTo() is used for printing - // the value. - // - // Thanks to Koenig look-up, if T is a class and has its own - // PrintTo() function defined in its namespace, that function will - // be visible here. Since it is more specific than the generic ones - // in ::testing::internal, it will be picked by the compiler in the - // following statement - exactly what we want. - PrintTo(value, os); - } - - GTEST_DISABLE_MSC_WARNINGS_POP_() -}; - -// Remove any const-qualifiers before passing a type to UniversalPrinter. -template <typename T> -class UniversalPrinter<const T> : public UniversalPrinter<T> {}; - -#if GTEST_INTERNAL_HAS_ANY - -// Printer for std::any / absl::any - -template <> -class UniversalPrinter<Any> { - public: - static void Print(const Any& value, ::std::ostream* os) { - if (value.has_value()) { - *os << "value of type " << GetTypeName(value); - } else { - *os << "no value"; - } - } - - private: - static std::string GetTypeName(const Any& value) { -#if GTEST_HAS_RTTI - return internal::GetTypeName(value.type()); -#else - static_cast<void>(value); // possibly unused - return "<unknown_type>"; -#endif // GTEST_HAS_RTTI - } -}; - -#endif // GTEST_INTERNAL_HAS_ANY - -#if GTEST_INTERNAL_HAS_OPTIONAL - -// Printer for std::optional / absl::optional - -template <typename T> -class UniversalPrinter<Optional<T>> { - public: - static void Print(const Optional<T>& value, ::std::ostream* os) { - *os << '('; - if (!value) { - *os << "nullopt"; - } else { - UniversalPrint(*value, os); - } - *os << ')'; - } -}; - -#endif // GTEST_INTERNAL_HAS_OPTIONAL - -#if GTEST_INTERNAL_HAS_VARIANT - -// Printer for std::variant / absl::variant - -template <typename... T> -class UniversalPrinter<Variant<T...>> { - public: - static void Print(const Variant<T...>& value, ::std::ostream* os) { - *os << '('; -#if GTEST_HAS_ABSL - absl::visit(Visitor{os, value.index()}, value); -#else - std::visit(Visitor{os, value.index()}, value); -#endif // GTEST_HAS_ABSL - *os << ')'; - } - - private: - struct Visitor { - template <typename U> - void operator()(const U& u) const { - *os << "'" << GetTypeName<U>() << "(index = " << index - << ")' with value "; - UniversalPrint(u, os); - } - ::std::ostream* os; - std::size_t index; - }; -}; - -#endif // GTEST_INTERNAL_HAS_VARIANT - -// UniversalPrintArray(begin, len, os) prints an array of 'len' -// elements, starting at address 'begin'. -template <typename T> -void UniversalPrintArray(const T* begin, size_t len, ::std::ostream* os) { - if (len == 0) { - *os << "{}"; - } else { - *os << "{ "; - const size_t kThreshold = 18; - const size_t kChunkSize = 8; - // If the array has more than kThreshold elements, we'll have to - // omit some details by printing only the first and the last - // kChunkSize elements. - if (len <= kThreshold) { - PrintRawArrayTo(begin, len, os); - } else { - PrintRawArrayTo(begin, kChunkSize, os); - *os << ", ..., "; - PrintRawArrayTo(begin + len - kChunkSize, kChunkSize, os); - } - *os << " }"; - } -} -// This overload prints a (const) char array compactly. -GTEST_API_ void UniversalPrintArray( - const char* begin, size_t len, ::std::ostream* os); - -#ifdef __cpp_char8_t -// This overload prints a (const) char8_t array compactly. -GTEST_API_ void UniversalPrintArray(const char8_t* begin, size_t len, - ::std::ostream* os); -#endif - -// This overload prints a (const) char16_t array compactly. -GTEST_API_ void UniversalPrintArray(const char16_t* begin, size_t len, - ::std::ostream* os); - -// This overload prints a (const) char32_t array compactly. -GTEST_API_ void UniversalPrintArray(const char32_t* begin, size_t len, - ::std::ostream* os); - -// This overload prints a (const) wchar_t array compactly. -GTEST_API_ void UniversalPrintArray( - const wchar_t* begin, size_t len, ::std::ostream* os); - -// Implements printing an array type T[N]. -template <typename T, size_t N> -class UniversalPrinter<T[N]> { - public: - // Prints the given array, omitting some elements when there are too - // many. - static void Print(const T (&a)[N], ::std::ostream* os) { - UniversalPrintArray(a, N, os); - } -}; - -// Implements printing a reference type T&. -template <typename T> -class UniversalPrinter<T&> { - public: - // MSVC warns about adding const to a function type, so we want to - // disable the warning. - GTEST_DISABLE_MSC_WARNINGS_PUSH_(4180) - - static void Print(const T& value, ::std::ostream* os) { - // Prints the address of the value. We use reinterpret_cast here - // as static_cast doesn't compile when T is a function type. - *os << "@" << reinterpret_cast<const void*>(&value) << " "; - - // Then prints the value itself. - UniversalPrint(value, os); - } - - GTEST_DISABLE_MSC_WARNINGS_POP_() -}; - -// Prints a value tersely: for a reference type, the referenced value -// (but not the address) is printed; for a (const) char pointer, the -// NUL-terminated string (but not the pointer) is printed. - -template <typename T> -class UniversalTersePrinter { - public: - static void Print(const T& value, ::std::ostream* os) { - UniversalPrint(value, os); - } -}; -template <typename T> -class UniversalTersePrinter<T&> { - public: - static void Print(const T& value, ::std::ostream* os) { - UniversalPrint(value, os); - } -}; -template <typename T, size_t N> -class UniversalTersePrinter<T[N]> { - public: - static void Print(const T (&value)[N], ::std::ostream* os) { - UniversalPrinter<T[N]>::Print(value, os); - } -}; -template <> -class UniversalTersePrinter<const char*> { - public: - static void Print(const char* str, ::std::ostream* os) { - if (str == nullptr) { - *os << "NULL"; - } else { - UniversalPrint(std::string(str), os); - } - } -}; -template <> -class UniversalTersePrinter<char*> : public UniversalTersePrinter<const char*> { -}; - -#ifdef __cpp_char8_t -template <> -class UniversalTersePrinter<const char8_t*> { - public: - static void Print(const char8_t* str, ::std::ostream* os) { - if (str == nullptr) { - *os << "NULL"; - } else { - UniversalPrint(::std::u8string(str), os); - } - } -}; -template <> -class UniversalTersePrinter<char8_t*> - : public UniversalTersePrinter<const char8_t*> {}; -#endif - -template <> -class UniversalTersePrinter<const char16_t*> { - public: - static void Print(const char16_t* str, ::std::ostream* os) { - if (str == nullptr) { - *os << "NULL"; - } else { - UniversalPrint(::std::u16string(str), os); - } - } -}; -template <> -class UniversalTersePrinter<char16_t*> - : public UniversalTersePrinter<const char16_t*> {}; - -template <> -class UniversalTersePrinter<const char32_t*> { - public: - static void Print(const char32_t* str, ::std::ostream* os) { - if (str == nullptr) { - *os << "NULL"; - } else { - UniversalPrint(::std::u32string(str), os); - } - } -}; -template <> -class UniversalTersePrinter<char32_t*> - : public UniversalTersePrinter<const char32_t*> {}; - -#if GTEST_HAS_STD_WSTRING -template <> -class UniversalTersePrinter<const wchar_t*> { - public: - static void Print(const wchar_t* str, ::std::ostream* os) { - if (str == nullptr) { - *os << "NULL"; - } else { - UniversalPrint(::std::wstring(str), os); - } - } -}; -#endif - -template <> -class UniversalTersePrinter<wchar_t*> { - public: - static void Print(wchar_t* str, ::std::ostream* os) { - UniversalTersePrinter<const wchar_t*>::Print(str, os); - } -}; - -template <typename T> -void UniversalTersePrint(const T& value, ::std::ostream* os) { - UniversalTersePrinter<T>::Print(value, os); -} - -// Prints a value using the type inferred by the compiler. The -// difference between this and UniversalTersePrint() is that for a -// (const) char pointer, this prints both the pointer and the -// NUL-terminated string. -template <typename T> -void UniversalPrint(const T& value, ::std::ostream* os) { - // A workarond for the bug in VC++ 7.1 that prevents us from instantiating - // UniversalPrinter with T directly. - typedef T T1; - UniversalPrinter<T1>::Print(value, os); -} - -typedef ::std::vector< ::std::string> Strings; - - // Tersely prints the first N fields of a tuple to a string vector, - // one element for each field. -template <typename Tuple> -void TersePrintPrefixToStrings(const Tuple&, std::integral_constant<size_t, 0>, - Strings*) {} -template <typename Tuple, size_t I> -void TersePrintPrefixToStrings(const Tuple& t, - std::integral_constant<size_t, I>, - Strings* strings) { - TersePrintPrefixToStrings(t, std::integral_constant<size_t, I - 1>(), - strings); - ::std::stringstream ss; - UniversalTersePrint(std::get<I - 1>(t), &ss); - strings->push_back(ss.str()); -} - -// Prints the fields of a tuple tersely to a string vector, one -// element for each field. See the comment before -// UniversalTersePrint() for how we define "tersely". -template <typename Tuple> -Strings UniversalTersePrintTupleFieldsToStrings(const Tuple& value) { - Strings result; - TersePrintPrefixToStrings( - value, std::integral_constant<size_t, std::tuple_size<Tuple>::value>(), - &result); - return result; -} - -} // namespace internal - -template <typename T> -::std::string PrintToString(const T& value) { - ::std::stringstream ss; - internal::UniversalTersePrinter<T>::Print(value, &ss); - return ss.str(); -} - -} // namespace testing - -// Include any custom printer added by the local installation. -// We must include this header at the end to make sure it can use the -// declarations from this file. -// Copyright 2015, 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. -// -// This file provides an injection point for custom printers in a local -// installation of gTest. -// It will be included from gtest-printers.h and the overrides in this file -// will be visible to everyone. -// -// Injection point for custom user configurations. See README for details -// -// ** Custom implementation starts here ** - -#ifndef GOOGLETEST_INCLUDE_GTEST_INTERNAL_CUSTOM_GTEST_PRINTERS_H_ -#define GOOGLETEST_INCLUDE_GTEST_INTERNAL_CUSTOM_GTEST_PRINTERS_H_ - -#endif // GOOGLETEST_INCLUDE_GTEST_INTERNAL_CUSTOM_GTEST_PRINTERS_H_ - -#endif // GOOGLETEST_INCLUDE_GTEST_GTEST_PRINTERS_H_ - -// MSVC warning C5046 is new as of VS2017 version 15.8. -#if defined(_MSC_VER) && _MSC_VER >= 1915 -#define GTEST_MAYBE_5046_ 5046 -#else -#define GTEST_MAYBE_5046_ -#endif - -GTEST_DISABLE_MSC_WARNINGS_PUSH_( - 4251 GTEST_MAYBE_5046_ /* class A needs to have dll-interface to be used by - clients of class B */ - /* Symbol involving type with internal linkage not defined */) - -namespace testing { - -// To implement a matcher Foo for type T, define: -// 1. a class FooMatcherMatcher that implements the matcher interface: -// using is_gtest_matcher = void; -// bool MatchAndExplain(const T&, std::ostream*); -// (MatchResultListener* can also be used instead of std::ostream*) -// void DescribeTo(std::ostream*); -// void DescribeNegationTo(std::ostream*); -// -// 2. a factory function that creates a Matcher<T> object from a -// FooMatcherMatcher. - -class MatchResultListener { - public: - // Creates a listener object with the given underlying ostream. The - // listener does not own the ostream, and does not dereference it - // in the constructor or destructor. - explicit MatchResultListener(::std::ostream* os) : stream_(os) {} - virtual ~MatchResultListener() = 0; // Makes this class abstract. - - // Streams x to the underlying ostream; does nothing if the ostream - // is NULL. - template <typename T> - MatchResultListener& operator<<(const T& x) { - if (stream_ != nullptr) *stream_ << x; - return *this; - } - - // Returns the underlying ostream. - ::std::ostream* stream() { return stream_; } - - // Returns true if and only if the listener is interested in an explanation - // of the match result. A matcher's MatchAndExplain() method can use - // this information to avoid generating the explanation when no one - // intends to hear it. - bool IsInterested() const { return stream_ != nullptr; } - - private: - ::std::ostream* const stream_; - - GTEST_DISALLOW_COPY_AND_ASSIGN_(MatchResultListener); -}; - -inline MatchResultListener::~MatchResultListener() { -} - -// An instance of a subclass of this knows how to describe itself as a -// matcher. -class MatcherDescriberInterface { - public: - virtual ~MatcherDescriberInterface() {} - - // Describes this matcher to an ostream. The function should print - // a verb phrase that describes the property a value matching this - // matcher should have. The subject of the verb phrase is the value - // being matched. For example, the DescribeTo() method of the Gt(7) - // matcher prints "is greater than 7". - virtual void DescribeTo(::std::ostream* os) const = 0; - - // Describes the negation of this matcher to an ostream. For - // example, if the description of this matcher is "is greater than - // 7", the negated description could be "is not greater than 7". - // You are not required to override this when implementing - // MatcherInterface, but it is highly advised so that your matcher - // can produce good error messages. - virtual void DescribeNegationTo(::std::ostream* os) const { - *os << "not ("; - DescribeTo(os); - *os << ")"; - } -}; - -// The implementation of a matcher. -template <typename T> -class MatcherInterface : public MatcherDescriberInterface { - public: - // Returns true if and only if the matcher matches x; also explains the - // match result to 'listener' if necessary (see the next paragraph), in - // the form of a non-restrictive relative clause ("which ...", - // "whose ...", etc) that describes x. For example, the - // MatchAndExplain() method of the Pointee(...) matcher should - // generate an explanation like "which points to ...". - // - // Implementations of MatchAndExplain() should add an explanation of - // the match result *if and only if* they can provide additional - // information that's not already present (or not obvious) in the - // print-out of x and the matcher's description. Whether the match - // succeeds is not a factor in deciding whether an explanation is - // needed, as sometimes the caller needs to print a failure message - // when the match succeeds (e.g. when the matcher is used inside - // Not()). - // - // For example, a "has at least 10 elements" matcher should explain - // what the actual element count is, regardless of the match result, - // as it is useful information to the reader; on the other hand, an - // "is empty" matcher probably only needs to explain what the actual - // size is when the match fails, as it's redundant to say that the - // size is 0 when the value is already known to be empty. - // - // You should override this method when defining a new matcher. - // - // It's the responsibility of the caller (Google Test) to guarantee - // that 'listener' is not NULL. This helps to simplify a matcher's - // implementation when it doesn't care about the performance, as it - // can talk to 'listener' without checking its validity first. - // However, in order to implement dummy listeners efficiently, - // listener->stream() may be NULL. - virtual bool MatchAndExplain(T x, MatchResultListener* listener) const = 0; - - // Inherits these methods from MatcherDescriberInterface: - // virtual void DescribeTo(::std::ostream* os) const = 0; - // virtual void DescribeNegationTo(::std::ostream* os) const; -}; - -namespace internal { - -struct AnyEq { - template <typename A, typename B> - bool operator()(const A& a, const B& b) const { return a == b; } -}; -struct AnyNe { - template <typename A, typename B> - bool operator()(const A& a, const B& b) const { return a != b; } -}; -struct AnyLt { - template <typename A, typename B> - bool operator()(const A& a, const B& b) const { return a < b; } -}; -struct AnyGt { - template <typename A, typename B> - bool operator()(const A& a, const B& b) const { return a > b; } -}; -struct AnyLe { - template <typename A, typename B> - bool operator()(const A& a, const B& b) const { return a <= b; } -}; -struct AnyGe { - template <typename A, typename B> - bool operator()(const A& a, const B& b) const { return a >= b; } -}; - -// A match result listener that ignores the explanation. -class DummyMatchResultListener : public MatchResultListener { - public: - DummyMatchResultListener() : MatchResultListener(nullptr) {} - - private: - GTEST_DISALLOW_COPY_AND_ASSIGN_(DummyMatchResultListener); -}; - -// A match result listener that forwards the explanation to a given -// ostream. The difference between this and MatchResultListener is -// that the former is concrete. -class StreamMatchResultListener : public MatchResultListener { - public: - explicit StreamMatchResultListener(::std::ostream* os) - : MatchResultListener(os) {} - - private: - GTEST_DISALLOW_COPY_AND_ASSIGN_(StreamMatchResultListener); -}; - -struct SharedPayloadBase { - std::atomic<int> ref{1}; - void Ref() { ref.fetch_add(1, std::memory_order_relaxed); } - bool Unref() { return ref.fetch_sub(1, std::memory_order_acq_rel) == 1; } -}; - -template <typename T> -struct SharedPayload : SharedPayloadBase { - explicit SharedPayload(const T& v) : value(v) {} - explicit SharedPayload(T&& v) : value(std::move(v)) {} - - static void Destroy(SharedPayloadBase* shared) { - delete static_cast<SharedPayload*>(shared); - } - - T value; -}; - -template <typename T> -using is_trivially_copy_constructible = -#if defined(__GNUC__) && !defined(__clang__) && __GNUC__ < 5 - std::has_trivial_copy_constructor<T>; -#else - std::is_trivially_copy_constructible<T>; -#endif - -// An internal class for implementing Matcher<T>, which will derive -// from it. We put functionalities common to all Matcher<T> -// specializations here to avoid code duplication. -template <typename T> -class MatcherBase : private MatcherDescriberInterface { - public: - // Returns true if and only if the matcher matches x; also explains the - // match result to 'listener'. - bool MatchAndExplain(const T& x, MatchResultListener* listener) const { - GTEST_CHECK_(vtable_ != nullptr); - return vtable_->match_and_explain(*this, x, listener); - } - - // Returns true if and only if this matcher matches x. - bool Matches(const T& x) const { - DummyMatchResultListener dummy; - return MatchAndExplain(x, &dummy); - } - - // Describes this matcher to an ostream. - void DescribeTo(::std::ostream* os) const final { - GTEST_CHECK_(vtable_ != nullptr); - vtable_->describe(*this, os, false); - } - - // Describes the negation of this matcher to an ostream. - void DescribeNegationTo(::std::ostream* os) const final { - GTEST_CHECK_(vtable_ != nullptr); - vtable_->describe(*this, os, true); - } - - // Explains why x matches, or doesn't match, the matcher. - void ExplainMatchResultTo(const T& x, ::std::ostream* os) const { - StreamMatchResultListener listener(os); - MatchAndExplain(x, &listener); - } - - // Returns the describer for this matcher object; retains ownership - // of the describer, which is only guaranteed to be alive when - // this matcher object is alive. - const MatcherDescriberInterface* GetDescriber() const { - if (vtable_ == nullptr) return nullptr; - return vtable_->get_describer(*this); - } - - protected: - MatcherBase() : vtable_(nullptr), buffer_() {} - - // Constructs a matcher from its implementation. - template <typename U> - explicit MatcherBase(const MatcherInterface<U>* impl) - : vtable_(nullptr), buffer_() { - Init(impl); - } - - template <typename M, typename = typename std::remove_reference< - M>::type::is_gtest_matcher> - MatcherBase(M&& m) : vtable_(nullptr), buffer_() { // NOLINT - Init(std::forward<M>(m)); - } - - MatcherBase(const MatcherBase& other) - : vtable_(other.vtable_), buffer_(other.buffer_) { - if (IsShared()) buffer_.shared->Ref(); - } - - MatcherBase& operator=(const MatcherBase& other) { - if (this == &other) return *this; - Destroy(); - vtable_ = other.vtable_; - buffer_ = other.buffer_; - if (IsShared()) buffer_.shared->Ref(); - return *this; - } - - MatcherBase(MatcherBase&& other) - : vtable_(other.vtable_), buffer_(other.buffer_) { - other.vtable_ = nullptr; - } - - MatcherBase& operator=(MatcherBase&& other) { - if (this == &other) return *this; - Destroy(); - vtable_ = other.vtable_; - buffer_ = other.buffer_; - other.vtable_ = nullptr; - return *this; - } - - ~MatcherBase() override { Destroy(); } - - private: - struct VTable { - bool (*match_and_explain)(const MatcherBase&, const T&, - MatchResultListener*); - void (*describe)(const MatcherBase&, std::ostream*, bool negation); - // Returns the captured object if it implements the interface, otherwise - // returns the MatcherBase itself. - const MatcherDescriberInterface* (*get_describer)(const MatcherBase&); - // Called on shared instances when the reference count reaches 0. - void (*shared_destroy)(SharedPayloadBase*); - }; - - bool IsShared() const { - return vtable_ != nullptr && vtable_->shared_destroy != nullptr; - } - - // If the implementation uses a listener, call that. - template <typename P> - static auto MatchAndExplainImpl(const MatcherBase& m, const T& value, - MatchResultListener* listener) - -> decltype(P::Get(m).MatchAndExplain(value, listener->stream())) { - return P::Get(m).MatchAndExplain(value, listener->stream()); - } - - template <typename P> - static auto MatchAndExplainImpl(const MatcherBase& m, const T& value, - MatchResultListener* listener) - -> decltype(P::Get(m).MatchAndExplain(value, listener)) { - return P::Get(m).MatchAndExplain(value, listener); - } - - template <typename P> - static void DescribeImpl(const MatcherBase& m, std::ostream* os, - bool negation) { - if (negation) { - P::Get(m).DescribeNegationTo(os); - } else { - P::Get(m).DescribeTo(os); - } - } - - template <typename P> - static const MatcherDescriberInterface* GetDescriberImpl( - const MatcherBase& m) { - // If the impl is a MatcherDescriberInterface, then return it. - // Otherwise use MatcherBase itself. - // This allows us to implement the GetDescriber() function without support - // from the impl, but some users really want to get their impl back when - // they call GetDescriber(). - // We use std::get on a tuple as a workaround of not having `if constexpr`. - return std::get<( - std::is_convertible<decltype(&P::Get(m)), - const MatcherDescriberInterface*>::value - ? 1 - : 0)>(std::make_tuple(&m, &P::Get(m))); - } - - template <typename P> - const VTable* GetVTable() { - static constexpr VTable kVTable = {&MatchAndExplainImpl<P>, - &DescribeImpl<P>, &GetDescriberImpl<P>, - P::shared_destroy}; - return &kVTable; - } - - union Buffer { - // Add some types to give Buffer some common alignment/size use cases. - void* ptr; - double d; - int64_t i; - // And add one for the out-of-line cases. - SharedPayloadBase* shared; - }; - - void Destroy() { - if (IsShared() && buffer_.shared->Unref()) { - vtable_->shared_destroy(buffer_.shared); - } - } - - template <typename M> - static constexpr bool IsInlined() { - return sizeof(M) <= sizeof(Buffer) && alignof(M) <= alignof(Buffer) && - is_trivially_copy_constructible<M>::value && - std::is_trivially_destructible<M>::value; - } - - template <typename M, bool = MatcherBase::IsInlined<M>()> - struct ValuePolicy { - static const M& Get(const MatcherBase& m) { - // When inlined along with Init, need to be explicit to avoid violating - // strict aliasing rules. - const M *ptr = static_cast<const M*>( - static_cast<const void*>(&m.buffer_)); - return *ptr; - } - static void Init(MatcherBase& m, M impl) { - ::new (static_cast<void*>(&m.buffer_)) M(impl); - } - static constexpr auto shared_destroy = nullptr; - }; - - template <typename M> - struct ValuePolicy<M, false> { - using Shared = SharedPayload<M>; - static const M& Get(const MatcherBase& m) { - return static_cast<Shared*>(m.buffer_.shared)->value; - } - template <typename Arg> - static void Init(MatcherBase& m, Arg&& arg) { - m.buffer_.shared = new Shared(std::forward<Arg>(arg)); - } - static constexpr auto shared_destroy = &Shared::Destroy; - }; - - template <typename U, bool B> - struct ValuePolicy<const MatcherInterface<U>*, B> { - using M = const MatcherInterface<U>; - using Shared = SharedPayload<std::unique_ptr<M>>; - static const M& Get(const MatcherBase& m) { - return *static_cast<Shared*>(m.buffer_.shared)->value; - } - static void Init(MatcherBase& m, M* impl) { - m.buffer_.shared = new Shared(std::unique_ptr<M>(impl)); - } - - static constexpr auto shared_destroy = &Shared::Destroy; - }; - - template <typename M> - void Init(M&& m) { - using MM = typename std::decay<M>::type; - using Policy = ValuePolicy<MM>; - vtable_ = GetVTable<Policy>(); - Policy::Init(*this, std::forward<M>(m)); - } - - const VTable* vtable_; - Buffer buffer_; -}; - -} // namespace internal - -// A Matcher<T> is a copyable and IMMUTABLE (except by assignment) -// object that can check whether a value of type T matches. The -// implementation of Matcher<T> is just a std::shared_ptr to const -// MatcherInterface<T>. Don't inherit from Matcher! -template <typename T> -class Matcher : public internal::MatcherBase<T> { - public: - // Constructs a null matcher. Needed for storing Matcher objects in STL - // containers. A default-constructed matcher is not yet initialized. You - // cannot use it until a valid value has been assigned to it. - explicit Matcher() {} // NOLINT - - // Constructs a matcher from its implementation. - explicit Matcher(const MatcherInterface<const T&>* impl) - : internal::MatcherBase<T>(impl) {} - - template <typename U> - explicit Matcher( - const MatcherInterface<U>* impl, - typename std::enable_if<!std::is_same<U, const U&>::value>::type* = - nullptr) - : internal::MatcherBase<T>(impl) {} - - template <typename M, typename = typename std::remove_reference< - M>::type::is_gtest_matcher> - Matcher(M&& m) : internal::MatcherBase<T>(std::forward<M>(m)) {} // NOLINT - - // Implicit constructor here allows people to write - // EXPECT_CALL(foo, Bar(5)) instead of EXPECT_CALL(foo, Bar(Eq(5))) sometimes - Matcher(T value); // NOLINT -}; - -// The following two specializations allow the user to write str -// instead of Eq(str) and "foo" instead of Eq("foo") when a std::string -// matcher is expected. -template <> -class GTEST_API_ Matcher<const std::string&> - : public internal::MatcherBase<const std::string&> { - public: - Matcher() {} - - explicit Matcher(const MatcherInterface<const std::string&>* impl) - : internal::MatcherBase<const std::string&>(impl) {} - - template <typename M, typename = typename std::remove_reference< - M>::type::is_gtest_matcher> - Matcher(M&& m) // NOLINT - : internal::MatcherBase<const std::string&>(std::forward<M>(m)) {} - - // Allows the user to write str instead of Eq(str) sometimes, where - // str is a std::string object. - Matcher(const std::string& s); // NOLINT - - // Allows the user to write "foo" instead of Eq("foo") sometimes. - Matcher(const char* s); // NOLINT -}; - -template <> -class GTEST_API_ Matcher<std::string> - : public internal::MatcherBase<std::string> { - public: - Matcher() {} - - explicit Matcher(const MatcherInterface<const std::string&>* impl) - : internal::MatcherBase<std::string>(impl) {} - explicit Matcher(const MatcherInterface<std::string>* impl) - : internal::MatcherBase<std::string>(impl) {} - - template <typename M, typename = typename std::remove_reference< - M>::type::is_gtest_matcher> - Matcher(M&& m) // NOLINT - : internal::MatcherBase<std::string>(std::forward<M>(m)) {} - - // Allows the user to write str instead of Eq(str) sometimes, where - // str is a string object. - Matcher(const std::string& s); // NOLINT - - // Allows the user to write "foo" instead of Eq("foo") sometimes. - Matcher(const char* s); // NOLINT -}; - -#if GTEST_INTERNAL_HAS_STRING_VIEW -// The following two specializations allow the user to write str -// instead of Eq(str) and "foo" instead of Eq("foo") when a absl::string_view -// matcher is expected. -template <> -class GTEST_API_ Matcher<const internal::StringView&> - : public internal::MatcherBase<const internal::StringView&> { - public: - Matcher() {} - - explicit Matcher(const MatcherInterface<const internal::StringView&>* impl) - : internal::MatcherBase<const internal::StringView&>(impl) {} - - template <typename M, typename = typename std::remove_reference< - M>::type::is_gtest_matcher> - Matcher(M&& m) // NOLINT - : internal::MatcherBase<const internal::StringView&>(std::forward<M>(m)) { - } - - // Allows the user to write str instead of Eq(str) sometimes, where - // str is a std::string object. - Matcher(const std::string& s); // NOLINT - - // Allows the user to write "foo" instead of Eq("foo") sometimes. - Matcher(const char* s); // NOLINT - - // Allows the user to pass absl::string_views or std::string_views directly. - Matcher(internal::StringView s); // NOLINT -}; - -template <> -class GTEST_API_ Matcher<internal::StringView> - : public internal::MatcherBase<internal::StringView> { - public: - Matcher() {} - - explicit Matcher(const MatcherInterface<const internal::StringView&>* impl) - : internal::MatcherBase<internal::StringView>(impl) {} - explicit Matcher(const MatcherInterface<internal::StringView>* impl) - : internal::MatcherBase<internal::StringView>(impl) {} - - template <typename M, typename = typename std::remove_reference< - M>::type::is_gtest_matcher> - Matcher(M&& m) // NOLINT - : internal::MatcherBase<internal::StringView>(std::forward<M>(m)) {} - - // Allows the user to write str instead of Eq(str) sometimes, where - // str is a std::string object. - Matcher(const std::string& s); // NOLINT - - // Allows the user to write "foo" instead of Eq("foo") sometimes. - Matcher(const char* s); // NOLINT - - // Allows the user to pass absl::string_views or std::string_views directly. - Matcher(internal::StringView s); // NOLINT -}; -#endif // GTEST_INTERNAL_HAS_STRING_VIEW - -// Prints a matcher in a human-readable format. -template <typename T> -std::ostream& operator<<(std::ostream& os, const Matcher<T>& matcher) { - matcher.DescribeTo(&os); - return os; -} - -// The PolymorphicMatcher class template makes it easy to implement a -// polymorphic matcher (i.e. a matcher that can match values of more -// than one type, e.g. Eq(n) and NotNull()). -// -// To define a polymorphic matcher, a user should provide an Impl -// class that has a DescribeTo() method and a DescribeNegationTo() -// method, and define a member function (or member function template) -// -// bool MatchAndExplain(const Value& value, -// MatchResultListener* listener) const; -// -// See the definition of NotNull() for a complete example. -template <class Impl> -class PolymorphicMatcher { - public: - explicit PolymorphicMatcher(const Impl& an_impl) : impl_(an_impl) {} - - // Returns a mutable reference to the underlying matcher - // implementation object. - Impl& mutable_impl() { return impl_; } - - // Returns an immutable reference to the underlying matcher - // implementation object. - const Impl& impl() const { return impl_; } - - template <typename T> - operator Matcher<T>() const { - return Matcher<T>(new MonomorphicImpl<const T&>(impl_)); - } - - private: - template <typename T> - class MonomorphicImpl : public MatcherInterface<T> { - public: - explicit MonomorphicImpl(const Impl& impl) : impl_(impl) {} - - void DescribeTo(::std::ostream* os) const override { impl_.DescribeTo(os); } - - void DescribeNegationTo(::std::ostream* os) const override { - impl_.DescribeNegationTo(os); - } - - bool MatchAndExplain(T x, MatchResultListener* listener) const override { - return impl_.MatchAndExplain(x, listener); - } - - private: - const Impl impl_; - }; - - Impl impl_; -}; - -// Creates a matcher from its implementation. -// DEPRECATED: Especially in the generic code, prefer: -// Matcher<T>(new MyMatcherImpl<const T&>(...)); -// -// MakeMatcher may create a Matcher that accepts its argument by value, which -// leads to unnecessary copies & lack of support for non-copyable types. -template <typename T> -inline Matcher<T> MakeMatcher(const MatcherInterface<T>* impl) { - return Matcher<T>(impl); -} - -// Creates a polymorphic matcher from its implementation. This is -// easier to use than the PolymorphicMatcher<Impl> constructor as it -// doesn't require you to explicitly write the template argument, e.g. -// -// MakePolymorphicMatcher(foo); -// vs -// PolymorphicMatcher<TypeOfFoo>(foo); -template <class Impl> -inline PolymorphicMatcher<Impl> MakePolymorphicMatcher(const Impl& impl) { - return PolymorphicMatcher<Impl>(impl); -} - -namespace internal { -// Implements a matcher that compares a given value with a -// pre-supplied value using one of the ==, <=, <, etc, operators. The -// two values being compared don't have to have the same type. -// -// The matcher defined here is polymorphic (for example, Eq(5) can be -// used to match an int, a short, a double, etc). Therefore we use -// a template type conversion operator in the implementation. -// -// The following template definition assumes that the Rhs parameter is -// a "bare" type (i.e. neither 'const T' nor 'T&'). -template <typename D, typename Rhs, typename Op> -class ComparisonBase { - public: - explicit ComparisonBase(const Rhs& rhs) : rhs_(rhs) {} - - using is_gtest_matcher = void; - - template <typename Lhs> - bool MatchAndExplain(const Lhs& lhs, std::ostream*) const { - return Op()(lhs, Unwrap(rhs_)); - } - void DescribeTo(std::ostream* os) const { - *os << D::Desc() << " "; - UniversalPrint(Unwrap(rhs_), os); - } - void DescribeNegationTo(std::ostream* os) const { - *os << D::NegatedDesc() << " "; - UniversalPrint(Unwrap(rhs_), os); - } - - private: - template <typename T> - static const T& Unwrap(const T& v) { - return v; - } - template <typename T> - static const T& Unwrap(std::reference_wrapper<T> v) { - return v; - } - - Rhs rhs_; -}; - -template <typename Rhs> -class EqMatcher : public ComparisonBase<EqMatcher<Rhs>, Rhs, AnyEq> { - public: - explicit EqMatcher(const Rhs& rhs) - : ComparisonBase<EqMatcher<Rhs>, Rhs, AnyEq>(rhs) { } - static const char* Desc() { return "is equal to"; } - static const char* NegatedDesc() { return "isn't equal to"; } -}; -template <typename Rhs> -class NeMatcher : public ComparisonBase<NeMatcher<Rhs>, Rhs, AnyNe> { - public: - explicit NeMatcher(const Rhs& rhs) - : ComparisonBase<NeMatcher<Rhs>, Rhs, AnyNe>(rhs) { } - static const char* Desc() { return "isn't equal to"; } - static const char* NegatedDesc() { return "is equal to"; } -}; -template <typename Rhs> -class LtMatcher : public ComparisonBase<LtMatcher<Rhs>, Rhs, AnyLt> { - public: - explicit LtMatcher(const Rhs& rhs) - : ComparisonBase<LtMatcher<Rhs>, Rhs, AnyLt>(rhs) { } - static const char* Desc() { return "is <"; } - static const char* NegatedDesc() { return "isn't <"; } -}; -template <typename Rhs> -class GtMatcher : public ComparisonBase<GtMatcher<Rhs>, Rhs, AnyGt> { - public: - explicit GtMatcher(const Rhs& rhs) - : ComparisonBase<GtMatcher<Rhs>, Rhs, AnyGt>(rhs) { } - static const char* Desc() { return "is >"; } - static const char* NegatedDesc() { return "isn't >"; } -}; -template <typename Rhs> -class LeMatcher : public ComparisonBase<LeMatcher<Rhs>, Rhs, AnyLe> { - public: - explicit LeMatcher(const Rhs& rhs) - : ComparisonBase<LeMatcher<Rhs>, Rhs, AnyLe>(rhs) { } - static const char* Desc() { return "is <="; } - static const char* NegatedDesc() { return "isn't <="; } -}; -template <typename Rhs> -class GeMatcher : public ComparisonBase<GeMatcher<Rhs>, Rhs, AnyGe> { - public: - explicit GeMatcher(const Rhs& rhs) - : ComparisonBase<GeMatcher<Rhs>, Rhs, AnyGe>(rhs) { } - static const char* Desc() { return "is >="; } - static const char* NegatedDesc() { return "isn't >="; } -}; - -template <typename T, typename = typename std::enable_if< - std::is_constructible<std::string, T>::value>::type> -using StringLike = T; - -// Implements polymorphic matchers MatchesRegex(regex) and -// ContainsRegex(regex), which can be used as a Matcher<T> as long as -// T can be converted to a string. -class MatchesRegexMatcher { - public: - MatchesRegexMatcher(const RE* regex, bool full_match) - : regex_(regex), full_match_(full_match) {} - -#if GTEST_INTERNAL_HAS_STRING_VIEW - bool MatchAndExplain(const internal::StringView& s, - MatchResultListener* listener) const { - return MatchAndExplain(std::string(s), listener); - } -#endif // GTEST_INTERNAL_HAS_STRING_VIEW - - // Accepts pointer types, particularly: - // const char* - // char* - // const wchar_t* - // wchar_t* - template <typename CharType> - bool MatchAndExplain(CharType* s, MatchResultListener* listener) const { - return s != nullptr && MatchAndExplain(std::string(s), listener); - } - - // Matches anything that can convert to std::string. - // - // This is a template, not just a plain function with const std::string&, - // because absl::string_view has some interfering non-explicit constructors. - template <class MatcheeStringType> - bool MatchAndExplain(const MatcheeStringType& s, - MatchResultListener* /* listener */) const { - const std::string& s2(s); - return full_match_ ? RE::FullMatch(s2, *regex_) - : RE::PartialMatch(s2, *regex_); - } - - void DescribeTo(::std::ostream* os) const { - *os << (full_match_ ? "matches" : "contains") << " regular expression "; - UniversalPrinter<std::string>::Print(regex_->pattern(), os); - } - - void DescribeNegationTo(::std::ostream* os) const { - *os << "doesn't " << (full_match_ ? "match" : "contain") - << " regular expression "; - UniversalPrinter<std::string>::Print(regex_->pattern(), os); - } - - private: - const std::shared_ptr<const RE> regex_; - const bool full_match_; -}; -} // namespace internal - -// Matches a string that fully matches regular expression 'regex'. -// The matcher takes ownership of 'regex'. -inline PolymorphicMatcher<internal::MatchesRegexMatcher> MatchesRegex( - const internal::RE* regex) { - return MakePolymorphicMatcher(internal::MatchesRegexMatcher(regex, true)); -} -template <typename T = std::string> -PolymorphicMatcher<internal::MatchesRegexMatcher> MatchesRegex( - const internal::StringLike<T>& regex) { - return MatchesRegex(new internal::RE(std::string(regex))); -} - -// Matches a string that contains regular expression 'regex'. -// The matcher takes ownership of 'regex'. -inline PolymorphicMatcher<internal::MatchesRegexMatcher> ContainsRegex( - const internal::RE* regex) { - return MakePolymorphicMatcher(internal::MatchesRegexMatcher(regex, false)); -} -template <typename T = std::string> -PolymorphicMatcher<internal::MatchesRegexMatcher> ContainsRegex( - const internal::StringLike<T>& regex) { - return ContainsRegex(new internal::RE(std::string(regex))); -} - -// Creates a polymorphic matcher that matches anything equal to x. -// Note: if the parameter of Eq() were declared as const T&, Eq("foo") -// wouldn't compile. -template <typename T> -inline internal::EqMatcher<T> Eq(T x) { return internal::EqMatcher<T>(x); } - -// Constructs a Matcher<T> from a 'value' of type T. The constructed -// matcher matches any value that's equal to 'value'. -template <typename T> -Matcher<T>::Matcher(T value) { *this = Eq(value); } - -// Creates a monomorphic matcher that matches anything with type Lhs -// and equal to rhs. A user may need to use this instead of Eq(...) -// in order to resolve an overloading ambiguity. -// -// TypedEq<T>(x) is just a convenient short-hand for Matcher<T>(Eq(x)) -// or Matcher<T>(x), but more readable than the latter. -// -// We could define similar monomorphic matchers for other comparison -// operations (e.g. TypedLt, TypedGe, and etc), but decided not to do -// it yet as those are used much less than Eq() in practice. A user -// can always write Matcher<T>(Lt(5)) to be explicit about the type, -// for example. -template <typename Lhs, typename Rhs> -inline Matcher<Lhs> TypedEq(const Rhs& rhs) { return Eq(rhs); } - -// Creates a polymorphic matcher that matches anything >= x. -template <typename Rhs> -inline internal::GeMatcher<Rhs> Ge(Rhs x) { - return internal::GeMatcher<Rhs>(x); -} - -// Creates a polymorphic matcher that matches anything > x. -template <typename Rhs> -inline internal::GtMatcher<Rhs> Gt(Rhs x) { - return internal::GtMatcher<Rhs>(x); -} - -// Creates a polymorphic matcher that matches anything <= x. -template <typename Rhs> -inline internal::LeMatcher<Rhs> Le(Rhs x) { - return internal::LeMatcher<Rhs>(x); -} - -// Creates a polymorphic matcher that matches anything < x. -template <typename Rhs> -inline internal::LtMatcher<Rhs> Lt(Rhs x) { - return internal::LtMatcher<Rhs>(x); -} - -// Creates a polymorphic matcher that matches anything != x. -template <typename Rhs> -inline internal::NeMatcher<Rhs> Ne(Rhs x) { - return internal::NeMatcher<Rhs>(x); -} -} // namespace testing - -GTEST_DISABLE_MSC_WARNINGS_POP_() // 4251 5046 - -#endif // GOOGLETEST_INCLUDE_GTEST_GTEST_MATCHERS_H_ - -#include <stdio.h> -#include <memory> - -namespace testing { -namespace internal { - -GTEST_DECLARE_string_(internal_run_death_test); - -// Names of the flags (needed for parsing Google Test flags). -const char kDeathTestStyleFlag[] = "death_test_style"; -const char kDeathTestUseFork[] = "death_test_use_fork"; -const char kInternalRunDeathTestFlag[] = "internal_run_death_test"; - -#if GTEST_HAS_DEATH_TEST - -GTEST_DISABLE_MSC_WARNINGS_PUSH_(4251 \ -/* class A needs to have dll-interface to be used by clients of class B */) - -// DeathTest is a class that hides much of the complexity of the -// GTEST_DEATH_TEST_ macro. It is abstract; its static Create method -// returns a concrete class that depends on the prevailing death test -// style, as defined by the --gtest_death_test_style and/or -// --gtest_internal_run_death_test flags. - -// In describing the results of death tests, these terms are used with -// the corresponding definitions: -// -// exit status: The integer exit information in the format specified -// by wait(2) -// exit code: The integer code passed to exit(3), _exit(2), or -// returned from main() -class GTEST_API_ DeathTest { - public: - // Create returns false if there was an error determining the - // appropriate action to take for the current death test; for example, - // if the gtest_death_test_style flag is set to an invalid value. - // The LastMessage method will return a more detailed message in that - // case. Otherwise, the DeathTest pointer pointed to by the "test" - // argument is set. If the death test should be skipped, the pointer - // is set to NULL; otherwise, it is set to the address of a new concrete - // DeathTest object that controls the execution of the current test. - static bool Create(const char* statement, Matcher<const std::string&> matcher, - const char* file, int line, DeathTest** test); - DeathTest(); - virtual ~DeathTest() { } - - // A helper class that aborts a death test when it's deleted. - class ReturnSentinel { - public: - explicit ReturnSentinel(DeathTest* test) : test_(test) { } - ~ReturnSentinel() { test_->Abort(TEST_ENCOUNTERED_RETURN_STATEMENT); } - private: - DeathTest* const test_; - GTEST_DISALLOW_COPY_AND_ASSIGN_(ReturnSentinel); - } GTEST_ATTRIBUTE_UNUSED_; - - // An enumeration of possible roles that may be taken when a death - // test is encountered. EXECUTE means that the death test logic should - // be executed immediately. OVERSEE means that the program should prepare - // the appropriate environment for a child process to execute the death - // test, then wait for it to complete. - enum TestRole { OVERSEE_TEST, EXECUTE_TEST }; - - // An enumeration of the three reasons that a test might be aborted. - enum AbortReason { - TEST_ENCOUNTERED_RETURN_STATEMENT, - TEST_THREW_EXCEPTION, - TEST_DID_NOT_DIE - }; - - // Assumes one of the above roles. - virtual TestRole AssumeRole() = 0; - - // Waits for the death test to finish and returns its status. - virtual int Wait() = 0; - - // Returns true if the death test passed; that is, the test process - // exited during the test, its exit status matches a user-supplied - // predicate, and its stderr output matches a user-supplied regular - // expression. - // The user-supplied predicate may be a macro expression rather - // than a function pointer or functor, or else Wait and Passed could - // be combined. - virtual bool Passed(bool exit_status_ok) = 0; - - // Signals that the death test did not die as expected. - virtual void Abort(AbortReason reason) = 0; - - // Returns a human-readable outcome message regarding the outcome of - // the last death test. - static const char* LastMessage(); - - static void set_last_death_test_message(const std::string& message); - - private: - // A string containing a description of the outcome of the last death test. - static std::string last_death_test_message_; - - GTEST_DISALLOW_COPY_AND_ASSIGN_(DeathTest); -}; - -GTEST_DISABLE_MSC_WARNINGS_POP_() // 4251 - -// Factory interface for death tests. May be mocked out for testing. -class DeathTestFactory { - public: - virtual ~DeathTestFactory() { } - virtual bool Create(const char* statement, - Matcher<const std::string&> matcher, const char* file, - int line, DeathTest** test) = 0; -}; - -// A concrete DeathTestFactory implementation for normal use. -class DefaultDeathTestFactory : public DeathTestFactory { - public: - bool Create(const char* statement, Matcher<const std::string&> matcher, - const char* file, int line, DeathTest** test) override; -}; - -// Returns true if exit_status describes a process that was terminated -// by a signal, or exited normally with a nonzero exit code. -GTEST_API_ bool ExitedUnsuccessfully(int exit_status); - -// A string passed to EXPECT_DEATH (etc.) is caught by one of these overloads -// and interpreted as a regex (rather than an Eq matcher) for legacy -// compatibility. -inline Matcher<const ::std::string&> MakeDeathTestMatcher( - ::testing::internal::RE regex) { - return ContainsRegex(regex.pattern()); -} -inline Matcher<const ::std::string&> MakeDeathTestMatcher(const char* regex) { - return ContainsRegex(regex); -} -inline Matcher<const ::std::string&> MakeDeathTestMatcher( - const ::std::string& regex) { - return ContainsRegex(regex); -} - -// If a Matcher<const ::std::string&> is passed to EXPECT_DEATH (etc.), it's -// used directly. -inline Matcher<const ::std::string&> MakeDeathTestMatcher( - Matcher<const ::std::string&> matcher) { - return matcher; -} - -// Traps C++ exceptions escaping statement and reports them as test -// failures. Note that trapping SEH exceptions is not implemented here. -# if GTEST_HAS_EXCEPTIONS -# define GTEST_EXECUTE_DEATH_TEST_STATEMENT_(statement, death_test) \ - try { \ - GTEST_SUPPRESS_UNREACHABLE_CODE_WARNING_BELOW_(statement); \ - } catch (const ::std::exception& gtest_exception) { \ - fprintf(\ - stderr, \ - "\n%s: Caught std::exception-derived exception escaping the " \ - "death test statement. Exception message: %s\n", \ - ::testing::internal::FormatFileLocation(__FILE__, __LINE__).c_str(), \ - gtest_exception.what()); \ - fflush(stderr); \ - death_test->Abort(::testing::internal::DeathTest::TEST_THREW_EXCEPTION); \ - } catch (...) { \ - death_test->Abort(::testing::internal::DeathTest::TEST_THREW_EXCEPTION); \ - } - -# else -# define GTEST_EXECUTE_DEATH_TEST_STATEMENT_(statement, death_test) \ - GTEST_SUPPRESS_UNREACHABLE_CODE_WARNING_BELOW_(statement) - -# endif - -// This macro is for implementing ASSERT_DEATH*, EXPECT_DEATH*, -// ASSERT_EXIT*, and EXPECT_EXIT*. -#define GTEST_DEATH_TEST_(statement, predicate, regex_or_matcher, fail) \ - GTEST_AMBIGUOUS_ELSE_BLOCKER_ \ - if (::testing::internal::AlwaysTrue()) { \ - ::testing::internal::DeathTest* gtest_dt; \ - if (!::testing::internal::DeathTest::Create( \ - #statement, \ - ::testing::internal::MakeDeathTestMatcher(regex_or_matcher), \ - __FILE__, __LINE__, >est_dt)) { \ - goto GTEST_CONCAT_TOKEN_(gtest_label_, __LINE__); \ - } \ - if (gtest_dt != nullptr) { \ - std::unique_ptr< ::testing::internal::DeathTest> gtest_dt_ptr(gtest_dt); \ - switch (gtest_dt->AssumeRole()) { \ - case ::testing::internal::DeathTest::OVERSEE_TEST: \ - if (!gtest_dt->Passed(predicate(gtest_dt->Wait()))) { \ - goto GTEST_CONCAT_TOKEN_(gtest_label_, __LINE__); \ - } \ - break; \ - case ::testing::internal::DeathTest::EXECUTE_TEST: { \ - ::testing::internal::DeathTest::ReturnSentinel gtest_sentinel( \ - gtest_dt); \ - GTEST_EXECUTE_DEATH_TEST_STATEMENT_(statement, gtest_dt); \ - gtest_dt->Abort(::testing::internal::DeathTest::TEST_DID_NOT_DIE); \ - break; \ - } \ - default: \ - break; \ - } \ - } \ - } else \ - GTEST_CONCAT_TOKEN_(gtest_label_, __LINE__) \ - : fail(::testing::internal::DeathTest::LastMessage()) -// The symbol "fail" here expands to something into which a message -// can be streamed. - -// This macro is for implementing ASSERT/EXPECT_DEBUG_DEATH when compiled in -// NDEBUG mode. In this case we need the statements to be executed and the macro -// must accept a streamed message even though the message is never printed. -// The regex object is not evaluated, but it is used to prevent "unused" -// warnings and to avoid an expression that doesn't compile in debug mode. -#define GTEST_EXECUTE_STATEMENT_(statement, regex_or_matcher) \ - GTEST_AMBIGUOUS_ELSE_BLOCKER_ \ - if (::testing::internal::AlwaysTrue()) { \ - GTEST_SUPPRESS_UNREACHABLE_CODE_WARNING_BELOW_(statement); \ - } else if (!::testing::internal::AlwaysTrue()) { \ - ::testing::internal::MakeDeathTestMatcher(regex_or_matcher); \ - } else \ - ::testing::Message() - -// A class representing the parsed contents of the -// --gtest_internal_run_death_test flag, as it existed when -// RUN_ALL_TESTS was called. -class InternalRunDeathTestFlag { - public: - InternalRunDeathTestFlag(const std::string& a_file, - int a_line, - int an_index, - int a_write_fd) - : file_(a_file), line_(a_line), index_(an_index), - write_fd_(a_write_fd) {} - - ~InternalRunDeathTestFlag() { - if (write_fd_ >= 0) - posix::Close(write_fd_); - } - - const std::string& file() const { return file_; } - int line() const { return line_; } - int index() const { return index_; } - int write_fd() const { return write_fd_; } - - private: - std::string file_; - int line_; - int index_; - int write_fd_; - - GTEST_DISALLOW_COPY_AND_ASSIGN_(InternalRunDeathTestFlag); -}; - -// Returns a newly created InternalRunDeathTestFlag object with fields -// initialized from the GTEST_FLAG(internal_run_death_test) flag if -// the flag is specified; otherwise returns NULL. -InternalRunDeathTestFlag* ParseInternalRunDeathTestFlag(); - -#endif // GTEST_HAS_DEATH_TEST - -} // namespace internal -} // namespace testing - -#endif // GOOGLETEST_INCLUDE_GTEST_INTERNAL_GTEST_DEATH_TEST_INTERNAL_H_ - -namespace testing { - -// This flag controls the style of death tests. Valid values are "threadsafe", -// meaning that the death test child process will re-execute the test binary -// from the start, running only a single death test, or "fast", -// meaning that the child process will execute the test logic immediately -// after forking. -GTEST_DECLARE_string_(death_test_style); - -#if GTEST_HAS_DEATH_TEST - -namespace internal { - -// Returns a Boolean value indicating whether the caller is currently -// executing in the context of the death test child process. Tools such as -// Valgrind heap checkers may need this to modify their behavior in death -// tests. IMPORTANT: This is an internal utility. Using it may break the -// implementation of death tests. User code MUST NOT use it. -GTEST_API_ bool InDeathTestChild(); - -} // namespace internal - -// The following macros are useful for writing death tests. - -// Here's what happens when an ASSERT_DEATH* or EXPECT_DEATH* is -// executed: -// -// 1. It generates a warning if there is more than one active -// thread. This is because it's safe to fork() or clone() only -// when there is a single thread. -// -// 2. The parent process clone()s a sub-process and runs the death -// test in it; the sub-process exits with code 0 at the end of the -// death test, if it hasn't exited already. -// -// 3. The parent process waits for the sub-process to terminate. -// -// 4. The parent process checks the exit code and error message of -// the sub-process. -// -// Examples: -// -// ASSERT_DEATH(server.SendMessage(56, "Hello"), "Invalid port number"); -// for (int i = 0; i < 5; i++) { -// EXPECT_DEATH(server.ProcessRequest(i), -// "Invalid request .* in ProcessRequest()") -// << "Failed to die on request " << i; -// } -// -// ASSERT_EXIT(server.ExitNow(), ::testing::ExitedWithCode(0), "Exiting"); -// -// bool KilledBySIGHUP(int exit_code) { -// return WIFSIGNALED(exit_code) && WTERMSIG(exit_code) == SIGHUP; -// } -// -// ASSERT_EXIT(client.HangUpServer(), KilledBySIGHUP, "Hanging up!"); -// -// On the regular expressions used in death tests: -// -// GOOGLETEST_CM0005 DO NOT DELETE -// On POSIX-compliant systems (*nix), we use the <regex.h> library, -// which uses the POSIX extended regex syntax. -// -// On other platforms (e.g. Windows or Mac), we only support a simple regex -// syntax implemented as part of Google Test. This limited -// implementation should be enough most of the time when writing -// death tests; though it lacks many features you can find in PCRE -// or POSIX extended regex syntax. For example, we don't support -// union ("x|y"), grouping ("(xy)"), brackets ("[xy]"), and -// repetition count ("x{5,7}"), among others. -// -// Below is the syntax that we do support. We chose it to be a -// subset of both PCRE and POSIX extended regex, so it's easy to -// learn wherever you come from. In the following: 'A' denotes a -// literal character, period (.), or a single \\ escape sequence; -// 'x' and 'y' denote regular expressions; 'm' and 'n' are for -// natural numbers. -// -// c matches any literal character c -// \\d matches any decimal digit -// \\D matches any character that's not a decimal digit -// \\f matches \f -// \\n matches \n -// \\r matches \r -// \\s matches any ASCII whitespace, including \n -// \\S matches any character that's not a whitespace -// \\t matches \t -// \\v matches \v -// \\w matches any letter, _, or decimal digit -// \\W matches any character that \\w doesn't match -// \\c matches any literal character c, which must be a punctuation -// . matches any single character except \n -// A? matches 0 or 1 occurrences of A -// A* matches 0 or many occurrences of A -// A+ matches 1 or many occurrences of A -// ^ matches the beginning of a string (not that of each line) -// $ matches the end of a string (not that of each line) -// xy matches x followed by y -// -// If you accidentally use PCRE or POSIX extended regex features -// not implemented by us, you will get a run-time failure. In that -// case, please try to rewrite your regular expression within the -// above syntax. -// -// This implementation is *not* meant to be as highly tuned or robust -// as a compiled regex library, but should perform well enough for a -// death test, which already incurs significant overhead by launching -// a child process. -// -// Known caveats: -// -// A "threadsafe" style death test obtains the path to the test -// program from argv[0] and re-executes it in the sub-process. For -// simplicity, the current implementation doesn't search the PATH -// when launching the sub-process. This means that the user must -// invoke the test program via a path that contains at least one -// path separator (e.g. path/to/foo_test and -// /absolute/path/to/bar_test are fine, but foo_test is not). This -// is rarely a problem as people usually don't put the test binary -// directory in PATH. -// - -// Asserts that a given statement causes the program to exit, with an -// integer exit status that satisfies predicate, and emitting error output -// that matches regex. -# define ASSERT_EXIT(statement, predicate, regex) \ - GTEST_DEATH_TEST_(statement, predicate, regex, GTEST_FATAL_FAILURE_) - -// Like ASSERT_EXIT, but continues on to successive tests in the -// test suite, if any: -# define EXPECT_EXIT(statement, predicate, regex) \ - GTEST_DEATH_TEST_(statement, predicate, regex, GTEST_NONFATAL_FAILURE_) - -// Asserts that a given statement causes the program to exit, either by -// explicitly exiting with a nonzero exit code or being killed by a -// signal, and emitting error output that matches regex. -# define ASSERT_DEATH(statement, regex) \ - ASSERT_EXIT(statement, ::testing::internal::ExitedUnsuccessfully, regex) - -// Like ASSERT_DEATH, but continues on to successive tests in the -// test suite, if any: -# define EXPECT_DEATH(statement, regex) \ - EXPECT_EXIT(statement, ::testing::internal::ExitedUnsuccessfully, regex) - -// Two predicate classes that can be used in {ASSERT,EXPECT}_EXIT*: - -// Tests that an exit code describes a normal exit with a given exit code. -class GTEST_API_ ExitedWithCode { - public: - explicit ExitedWithCode(int exit_code); - ExitedWithCode(const ExitedWithCode&) = default; - void operator=(const ExitedWithCode& other) = delete; - bool operator()(int exit_status) const; - private: - const int exit_code_; -}; - -# if !GTEST_OS_WINDOWS && !GTEST_OS_FUCHSIA -// Tests that an exit code describes an exit due to termination by a -// given signal. -// GOOGLETEST_CM0006 DO NOT DELETE -class GTEST_API_ KilledBySignal { - public: - explicit KilledBySignal(int signum); - bool operator()(int exit_status) const; - private: - const int signum_; -}; -# endif // !GTEST_OS_WINDOWS - -// EXPECT_DEBUG_DEATH asserts that the given statements die in debug mode. -// The death testing framework causes this to have interesting semantics, -// since the sideeffects of the call are only visible in opt mode, and not -// in debug mode. -// -// In practice, this can be used to test functions that utilize the -// LOG(DFATAL) macro using the following style: -// -// int DieInDebugOr12(int* sideeffect) { -// if (sideeffect) { -// *sideeffect = 12; -// } -// LOG(DFATAL) << "death"; -// return 12; -// } -// -// TEST(TestSuite, TestDieOr12WorksInDgbAndOpt) { -// int sideeffect = 0; -// // Only asserts in dbg. -// EXPECT_DEBUG_DEATH(DieInDebugOr12(&sideeffect), "death"); -// -// #ifdef NDEBUG -// // opt-mode has sideeffect visible. -// EXPECT_EQ(12, sideeffect); -// #else -// // dbg-mode no visible sideeffect. -// EXPECT_EQ(0, sideeffect); -// #endif -// } -// -// This will assert that DieInDebugReturn12InOpt() crashes in debug -// mode, usually due to a DCHECK or LOG(DFATAL), but returns the -// appropriate fallback value (12 in this case) in opt mode. If you -// need to test that a function has appropriate side-effects in opt -// mode, include assertions against the side-effects. A general -// pattern for this is: -// -// EXPECT_DEBUG_DEATH({ -// // Side-effects here will have an effect after this statement in -// // opt mode, but none in debug mode. -// EXPECT_EQ(12, DieInDebugOr12(&sideeffect)); -// }, "death"); -// -# ifdef NDEBUG - -# define EXPECT_DEBUG_DEATH(statement, regex) \ - GTEST_EXECUTE_STATEMENT_(statement, regex) - -# define ASSERT_DEBUG_DEATH(statement, regex) \ - GTEST_EXECUTE_STATEMENT_(statement, regex) - -# else - -# define EXPECT_DEBUG_DEATH(statement, regex) \ - EXPECT_DEATH(statement, regex) - -# define ASSERT_DEBUG_DEATH(statement, regex) \ - ASSERT_DEATH(statement, regex) - -# endif // NDEBUG for EXPECT_DEBUG_DEATH -#endif // GTEST_HAS_DEATH_TEST - -// This macro is used for implementing macros such as -// EXPECT_DEATH_IF_SUPPORTED and ASSERT_DEATH_IF_SUPPORTED on systems where -// death tests are not supported. Those macros must compile on such systems -// if and only if EXPECT_DEATH and ASSERT_DEATH compile with the same parameters -// on systems that support death tests. This allows one to write such a macro on -// a system that does not support death tests and be sure that it will compile -// on a death-test supporting system. It is exposed publicly so that systems -// that have death-tests with stricter requirements than GTEST_HAS_DEATH_TEST -// can write their own equivalent of EXPECT_DEATH_IF_SUPPORTED and -// ASSERT_DEATH_IF_SUPPORTED. -// -// Parameters: -// statement - A statement that a macro such as EXPECT_DEATH would test -// for program termination. This macro has to make sure this -// statement is compiled but not executed, to ensure that -// EXPECT_DEATH_IF_SUPPORTED compiles with a certain -// parameter if and only if EXPECT_DEATH compiles with it. -// regex - A regex that a macro such as EXPECT_DEATH would use to test -// the output of statement. This parameter has to be -// compiled but not evaluated by this macro, to ensure that -// this macro only accepts expressions that a macro such as -// EXPECT_DEATH would accept. -// terminator - Must be an empty statement for EXPECT_DEATH_IF_SUPPORTED -// and a return statement for ASSERT_DEATH_IF_SUPPORTED. -// This ensures that ASSERT_DEATH_IF_SUPPORTED will not -// compile inside functions where ASSERT_DEATH doesn't -// compile. -// -// The branch that has an always false condition is used to ensure that -// statement and regex are compiled (and thus syntactically correct) but -// never executed. The unreachable code macro protects the terminator -// statement from generating an 'unreachable code' warning in case -// statement unconditionally returns or throws. The Message constructor at -// the end allows the syntax of streaming additional messages into the -// macro, for compilational compatibility with EXPECT_DEATH/ASSERT_DEATH. -# define GTEST_UNSUPPORTED_DEATH_TEST(statement, regex, terminator) \ - GTEST_AMBIGUOUS_ELSE_BLOCKER_ \ - if (::testing::internal::AlwaysTrue()) { \ - GTEST_LOG_(WARNING) \ - << "Death tests are not supported on this platform.\n" \ - << "Statement '" #statement "' cannot be verified."; \ - } else if (::testing::internal::AlwaysFalse()) { \ - ::testing::internal::RE::PartialMatch(".*", (regex)); \ - GTEST_SUPPRESS_UNREACHABLE_CODE_WARNING_BELOW_(statement); \ - terminator; \ - } else \ - ::testing::Message() - -// EXPECT_DEATH_IF_SUPPORTED(statement, regex) and -// ASSERT_DEATH_IF_SUPPORTED(statement, regex) expand to real death tests if -// death tests are supported; otherwise they just issue a warning. This is -// useful when you are combining death test assertions with normal test -// assertions in one test. -#if GTEST_HAS_DEATH_TEST -# define EXPECT_DEATH_IF_SUPPORTED(statement, regex) \ - EXPECT_DEATH(statement, regex) -# define ASSERT_DEATH_IF_SUPPORTED(statement, regex) \ - ASSERT_DEATH(statement, regex) -#else -# define EXPECT_DEATH_IF_SUPPORTED(statement, regex) \ - GTEST_UNSUPPORTED_DEATH_TEST(statement, regex, ) -# define ASSERT_DEATH_IF_SUPPORTED(statement, regex) \ - GTEST_UNSUPPORTED_DEATH_TEST(statement, regex, return) -#endif - -} // namespace testing - -#endif // GOOGLETEST_INCLUDE_GTEST_GTEST_DEATH_TEST_H_ -// Copyright 2008, 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. -// -// Macros and functions for implementing parameterized tests -// in Google C++ Testing and Mocking Framework (Google Test) -// -// GOOGLETEST_CM0001 DO NOT DELETE -#ifndef GOOGLETEST_INCLUDE_GTEST_GTEST_PARAM_TEST_H_ -#define GOOGLETEST_INCLUDE_GTEST_GTEST_PARAM_TEST_H_ - -// Value-parameterized tests allow you to test your code with different -// parameters without writing multiple copies of the same test. -// -// Here is how you use value-parameterized tests: - -#if 0 - -// To write value-parameterized tests, first you should define a fixture -// class. It is usually derived from testing::TestWithParam<T> (see below for -// another inheritance scheme that's sometimes useful in more complicated -// class hierarchies), where the type of your parameter values. -// TestWithParam<T> is itself derived from testing::Test. T can be any -// copyable type. If it's a raw pointer, you are responsible for managing the -// lifespan of the pointed values. - -class FooTest : public ::testing::TestWithParam<const char*> { - // You can implement all the usual class fixture members here. -}; - -// Then, use the TEST_P macro to define as many parameterized tests -// for this fixture as you want. The _P suffix is for "parameterized" -// or "pattern", whichever you prefer to think. - -TEST_P(FooTest, DoesBlah) { - // Inside a test, access the test parameter with the GetParam() method - // of the TestWithParam<T> class: - EXPECT_TRUE(foo.Blah(GetParam())); - ... -} - -TEST_P(FooTest, HasBlahBlah) { - ... -} - -// Finally, you can use INSTANTIATE_TEST_SUITE_P to instantiate the test -// case with any set of parameters you want. Google Test defines a number -// of functions for generating test parameters. They return what we call -// (surprise!) parameter generators. Here is a summary of them, which -// are all in the testing namespace: -// -// -// Range(begin, end [, step]) - Yields values {begin, begin+step, -// begin+step+step, ...}. The values do not -// include end. step defaults to 1. -// Values(v1, v2, ..., vN) - Yields values {v1, v2, ..., vN}. -// ValuesIn(container) - Yields values from a C-style array, an STL -// ValuesIn(begin,end) container, or an iterator range [begin, end). -// Bool() - Yields sequence {false, true}. -// Combine(g1, g2, ..., gN) - Yields all combinations (the Cartesian product -// for the math savvy) of the values generated -// by the N generators. -// -// For more details, see comments at the definitions of these functions below -// in this file. -// -// The following statement will instantiate tests from the FooTest test suite -// each with parameter values "meeny", "miny", and "moe". - -INSTANTIATE_TEST_SUITE_P(InstantiationName, - FooTest, - Values("meeny", "miny", "moe")); - -// To distinguish different instances of the pattern, (yes, you -// can instantiate it more than once) the first argument to the -// INSTANTIATE_TEST_SUITE_P macro is a prefix that will be added to the -// actual test suite name. Remember to pick unique prefixes for different -// instantiations. The tests from the instantiation above will have -// these names: -// -// * InstantiationName/FooTest.DoesBlah/0 for "meeny" -// * InstantiationName/FooTest.DoesBlah/1 for "miny" -// * InstantiationName/FooTest.DoesBlah/2 for "moe" -// * InstantiationName/FooTest.HasBlahBlah/0 for "meeny" -// * InstantiationName/FooTest.HasBlahBlah/1 for "miny" -// * InstantiationName/FooTest.HasBlahBlah/2 for "moe" -// -// You can use these names in --gtest_filter. -// -// This statement will instantiate all tests from FooTest again, each -// with parameter values "cat" and "dog": - -const char* pets[] = {"cat", "dog"}; -INSTANTIATE_TEST_SUITE_P(AnotherInstantiationName, FooTest, ValuesIn(pets)); - -// The tests from the instantiation above will have these names: -// -// * AnotherInstantiationName/FooTest.DoesBlah/0 for "cat" -// * AnotherInstantiationName/FooTest.DoesBlah/1 for "dog" -// * AnotherInstantiationName/FooTest.HasBlahBlah/0 for "cat" -// * AnotherInstantiationName/FooTest.HasBlahBlah/1 for "dog" -// -// Please note that INSTANTIATE_TEST_SUITE_P will instantiate all tests -// in the given test suite, whether their definitions come before or -// AFTER the INSTANTIATE_TEST_SUITE_P statement. -// -// Please also note that generator expressions (including parameters to the -// generators) are evaluated in InitGoogleTest(), after main() has started. -// This allows the user on one hand, to adjust generator parameters in order -// to dynamically determine a set of tests to run and on the other hand, -// give the user a chance to inspect the generated tests with Google Test -// reflection API before RUN_ALL_TESTS() is executed. -// -// You can see samples/sample7_unittest.cc and samples/sample8_unittest.cc -// for more examples. -// -// In the future, we plan to publish the API for defining new parameter -// generators. But for now this interface remains part of the internal -// implementation and is subject to change. -// -// -// A parameterized test fixture must be derived from testing::Test and from -// testing::WithParamInterface<T>, where T is the type of the parameter -// values. Inheriting from TestWithParam<T> satisfies that requirement because -// TestWithParam<T> inherits from both Test and WithParamInterface. In more -// complicated hierarchies, however, it is occasionally useful to inherit -// separately from Test and WithParamInterface. For example: - -class BaseTest : public ::testing::Test { - // You can inherit all the usual members for a non-parameterized test - // fixture here. -}; - -class DerivedTest : public BaseTest, public ::testing::WithParamInterface<int> { - // The usual test fixture members go here too. -}; - -TEST_F(BaseTest, HasFoo) { - // This is an ordinary non-parameterized test. -} - -TEST_P(DerivedTest, DoesBlah) { - // GetParam works just the same here as if you inherit from TestWithParam. - EXPECT_TRUE(foo.Blah(GetParam())); -} - -#endif // 0 - -#include <iterator> -#include <utility> - -// Copyright 2008 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. - - -// Type and function utilities for implementing parameterized tests. - -// GOOGLETEST_CM0001 DO NOT DELETE - -#ifndef GOOGLETEST_INCLUDE_GTEST_INTERNAL_GTEST_PARAM_UTIL_H_ -#define GOOGLETEST_INCLUDE_GTEST_INTERNAL_GTEST_PARAM_UTIL_H_ - -#include <ctype.h> - -#include <cassert> -#include <iterator> -#include <memory> -#include <set> -#include <tuple> -#include <type_traits> -#include <utility> -#include <vector> - -// Copyright 2008, 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. -// -// GOOGLETEST_CM0001 DO NOT DELETE - -#ifndef GOOGLETEST_INCLUDE_GTEST_GTEST_TEST_PART_H_ -#define GOOGLETEST_INCLUDE_GTEST_GTEST_TEST_PART_H_ - -#include <iosfwd> -#include <vector> - -GTEST_DISABLE_MSC_WARNINGS_PUSH_(4251 \ -/* class A needs to have dll-interface to be used by clients of class B */) - -namespace testing { - -// A copyable object representing the result of a test part (i.e. an -// assertion or an explicit FAIL(), ADD_FAILURE(), or SUCCESS()). -// -// Don't inherit from TestPartResult as its destructor is not virtual. -class GTEST_API_ TestPartResult { - public: - // The possible outcomes of a test part (i.e. an assertion or an - // explicit SUCCEED(), FAIL(), or ADD_FAILURE()). - enum Type { - kSuccess, // Succeeded. - kNonFatalFailure, // Failed but the test can continue. - kFatalFailure, // Failed and the test should be terminated. - kSkip // Skipped. - }; - - // C'tor. TestPartResult does NOT have a default constructor. - // Always use this constructor (with parameters) to create a - // TestPartResult object. - TestPartResult(Type a_type, const char* a_file_name, int a_line_number, - const char* a_message) - : type_(a_type), - file_name_(a_file_name == nullptr ? "" : a_file_name), - line_number_(a_line_number), - summary_(ExtractSummary(a_message)), - message_(a_message) {} - - // Gets the outcome of the test part. - Type type() const { return type_; } - - // Gets the name of the source file where the test part took place, or - // NULL if it's unknown. - const char* file_name() const { - return file_name_.empty() ? nullptr : file_name_.c_str(); - } - - // Gets the line in the source file where the test part took place, - // or -1 if it's unknown. - int line_number() const { return line_number_; } - - // Gets the summary of the failure message. - const char* summary() const { return summary_.c_str(); } - - // Gets the message associated with the test part. - const char* message() const { return message_.c_str(); } - - // Returns true if and only if the test part was skipped. - bool skipped() const { return type_ == kSkip; } - - // Returns true if and only if the test part passed. - bool passed() const { return type_ == kSuccess; } - - // Returns true if and only if the test part non-fatally failed. - bool nonfatally_failed() const { return type_ == kNonFatalFailure; } - - // Returns true if and only if the test part fatally failed. - bool fatally_failed() const { return type_ == kFatalFailure; } - - // Returns true if and only if the test part failed. - bool failed() const { return fatally_failed() || nonfatally_failed(); } - - private: - Type type_; - - // Gets the summary of the failure message by omitting the stack - // trace in it. - static std::string ExtractSummary(const char* message); - - // The name of the source file where the test part took place, or - // "" if the source file is unknown. - std::string file_name_; - // The line in the source file where the test part took place, or -1 - // if the line number is unknown. - int line_number_; - std::string summary_; // The test failure summary. - std::string message_; // The test failure message. -}; - -// Prints a TestPartResult object. -std::ostream& operator<<(std::ostream& os, const TestPartResult& result); - -// An array of TestPartResult objects. -// -// Don't inherit from TestPartResultArray as its destructor is not -// virtual. -class GTEST_API_ TestPartResultArray { - public: - TestPartResultArray() {} - - // Appends the given TestPartResult to the array. - void Append(const TestPartResult& result); - - // Returns the TestPartResult at the given index (0-based). - const TestPartResult& GetTestPartResult(int index) const; - - // Returns the number of TestPartResult objects in the array. - int size() const; - - private: - std::vector<TestPartResult> array_; - - GTEST_DISALLOW_COPY_AND_ASSIGN_(TestPartResultArray); -}; - -// This interface knows how to report a test part result. -class GTEST_API_ TestPartResultReporterInterface { - public: - virtual ~TestPartResultReporterInterface() {} - - virtual void ReportTestPartResult(const TestPartResult& result) = 0; -}; - -namespace internal { - -// This helper class is used by {ASSERT|EXPECT}_NO_FATAL_FAILURE to check if a -// statement generates new fatal failures. To do so it registers itself as the -// current test part result reporter. Besides checking if fatal failures were -// reported, it only delegates the reporting to the former result reporter. -// The original result reporter is restored in the destructor. -// INTERNAL IMPLEMENTATION - DO NOT USE IN A USER PROGRAM. -class GTEST_API_ HasNewFatalFailureHelper - : public TestPartResultReporterInterface { - public: - HasNewFatalFailureHelper(); - ~HasNewFatalFailureHelper() override; - void ReportTestPartResult(const TestPartResult& result) override; - bool has_new_fatal_failure() const { return has_new_fatal_failure_; } - private: - bool has_new_fatal_failure_; - TestPartResultReporterInterface* original_reporter_; - - GTEST_DISALLOW_COPY_AND_ASSIGN_(HasNewFatalFailureHelper); -}; - -} // namespace internal - -} // namespace testing - -GTEST_DISABLE_MSC_WARNINGS_POP_() // 4251 - -#endif // GOOGLETEST_INCLUDE_GTEST_GTEST_TEST_PART_H_ - -namespace testing { -// Input to a parameterized test name generator, describing a test parameter. -// Consists of the parameter value and the integer parameter index. -template <class ParamType> -struct TestParamInfo { - TestParamInfo(const ParamType& a_param, size_t an_index) : - param(a_param), - index(an_index) {} - ParamType param; - size_t index; -}; - -// A builtin parameterized test name generator which returns the result of -// testing::PrintToString. -struct PrintToStringParamName { - template <class ParamType> - std::string operator()(const TestParamInfo<ParamType>& info) const { - return PrintToString(info.param); - } -}; - -namespace internal { - -// INTERNAL IMPLEMENTATION - DO NOT USE IN USER CODE. -// Utility Functions - -// Outputs a message explaining invalid registration of different -// fixture class for the same test suite. This may happen when -// TEST_P macro is used to define two tests with the same name -// but in different namespaces. -GTEST_API_ void ReportInvalidTestSuiteType(const char* test_suite_name, - CodeLocation code_location); - -template <typename> class ParamGeneratorInterface; -template <typename> class ParamGenerator; - -// Interface for iterating over elements provided by an implementation -// of ParamGeneratorInterface<T>. -template <typename T> -class ParamIteratorInterface { - public: - virtual ~ParamIteratorInterface() {} - // A pointer to the base generator instance. - // Used only for the purposes of iterator comparison - // to make sure that two iterators belong to the same generator. - virtual const ParamGeneratorInterface<T>* BaseGenerator() const = 0; - // Advances iterator to point to the next element - // provided by the generator. The caller is responsible - // for not calling Advance() on an iterator equal to - // BaseGenerator()->End(). - virtual void Advance() = 0; - // Clones the iterator object. Used for implementing copy semantics - // of ParamIterator<T>. - virtual ParamIteratorInterface* Clone() const = 0; - // Dereferences the current iterator and provides (read-only) access - // to the pointed value. It is the caller's responsibility not to call - // Current() on an iterator equal to BaseGenerator()->End(). - // Used for implementing ParamGenerator<T>::operator*(). - virtual const T* Current() const = 0; - // Determines whether the given iterator and other point to the same - // element in the sequence generated by the generator. - // Used for implementing ParamGenerator<T>::operator==(). - virtual bool Equals(const ParamIteratorInterface& other) const = 0; -}; - -// Class iterating over elements provided by an implementation of -// ParamGeneratorInterface<T>. It wraps ParamIteratorInterface<T> -// and implements the const forward iterator concept. -template <typename T> -class ParamIterator { - public: - typedef T value_type; - typedef const T& reference; - typedef ptrdiff_t difference_type; - - // ParamIterator assumes ownership of the impl_ pointer. - ParamIterator(const ParamIterator& other) : impl_(other.impl_->Clone()) {} - ParamIterator& operator=(const ParamIterator& other) { - if (this != &other) - impl_.reset(other.impl_->Clone()); - return *this; - } - - const T& operator*() const { return *impl_->Current(); } - const T* operator->() const { return impl_->Current(); } - // Prefix version of operator++. - ParamIterator& operator++() { - impl_->Advance(); - return *this; - } - // Postfix version of operator++. - ParamIterator operator++(int /*unused*/) { - ParamIteratorInterface<T>* clone = impl_->Clone(); - impl_->Advance(); - return ParamIterator(clone); - } - bool operator==(const ParamIterator& other) const { - return impl_.get() == other.impl_.get() || impl_->Equals(*other.impl_); - } - bool operator!=(const ParamIterator& other) const { - return !(*this == other); - } - - private: - friend class ParamGenerator<T>; - explicit ParamIterator(ParamIteratorInterface<T>* impl) : impl_(impl) {} - std::unique_ptr<ParamIteratorInterface<T> > impl_; -}; - -// ParamGeneratorInterface<T> is the binary interface to access generators -// defined in other translation units. -template <typename T> -class ParamGeneratorInterface { - public: - typedef T ParamType; - - virtual ~ParamGeneratorInterface() {} - - // Generator interface definition - virtual ParamIteratorInterface<T>* Begin() const = 0; - virtual ParamIteratorInterface<T>* End() const = 0; -}; - -// Wraps ParamGeneratorInterface<T> and provides general generator syntax -// compatible with the STL Container concept. -// This class implements copy initialization semantics and the contained -// ParamGeneratorInterface<T> instance is shared among all copies -// of the original object. This is possible because that instance is immutable. -template<typename T> -class ParamGenerator { - public: - typedef ParamIterator<T> iterator; - - explicit ParamGenerator(ParamGeneratorInterface<T>* impl) : impl_(impl) {} - ParamGenerator(const ParamGenerator& other) : impl_(other.impl_) {} - - ParamGenerator& operator=(const ParamGenerator& other) { - impl_ = other.impl_; - return *this; - } - - iterator begin() const { return iterator(impl_->Begin()); } - iterator end() const { return iterator(impl_->End()); } - - private: - std::shared_ptr<const ParamGeneratorInterface<T> > impl_; -}; - -// Generates values from a range of two comparable values. Can be used to -// generate sequences of user-defined types that implement operator+() and -// operator<(). -// This class is used in the Range() function. -template <typename T, typename IncrementT> -class RangeGenerator : public ParamGeneratorInterface<T> { - public: - RangeGenerator(T begin, T end, IncrementT step) - : begin_(begin), end_(end), - step_(step), end_index_(CalculateEndIndex(begin, end, step)) {} - ~RangeGenerator() override {} - - ParamIteratorInterface<T>* Begin() const override { - return new Iterator(this, begin_, 0, step_); - } - ParamIteratorInterface<T>* End() const override { - return new Iterator(this, end_, end_index_, step_); - } - - private: - class Iterator : public ParamIteratorInterface<T> { - public: - Iterator(const ParamGeneratorInterface<T>* base, T value, int index, - IncrementT step) - : base_(base), value_(value), index_(index), step_(step) {} - ~Iterator() override {} - - const ParamGeneratorInterface<T>* BaseGenerator() const override { - return base_; - } - void Advance() override { - value_ = static_cast<T>(value_ + step_); - index_++; - } - ParamIteratorInterface<T>* Clone() const override { - return new Iterator(*this); - } - const T* Current() const override { return &value_; } - bool Equals(const ParamIteratorInterface<T>& other) const override { - // Having the same base generator guarantees that the other - // iterator is of the same type and we can downcast. - GTEST_CHECK_(BaseGenerator() == other.BaseGenerator()) - << "The program attempted to compare iterators " - << "from different generators." << std::endl; - const int other_index = - CheckedDowncastToActualType<const Iterator>(&other)->index_; - return index_ == other_index; - } - - private: - Iterator(const Iterator& other) - : ParamIteratorInterface<T>(), - base_(other.base_), value_(other.value_), index_(other.index_), - step_(other.step_) {} - - // No implementation - assignment is unsupported. - void operator=(const Iterator& other); - - const ParamGeneratorInterface<T>* const base_; - T value_; - int index_; - const IncrementT step_; - }; // class RangeGenerator::Iterator - - static int CalculateEndIndex(const T& begin, - const T& end, - const IncrementT& step) { - int end_index = 0; - for (T i = begin; i < end; i = static_cast<T>(i + step)) - end_index++; - return end_index; - } - - // No implementation - assignment is unsupported. - void operator=(const RangeGenerator& other); - - const T begin_; - const T end_; - const IncrementT step_; - // The index for the end() iterator. All the elements in the generated - // sequence are indexed (0-based) to aid iterator comparison. - const int end_index_; -}; // class RangeGenerator - - -// Generates values from a pair of STL-style iterators. Used in the -// ValuesIn() function. The elements are copied from the source range -// since the source can be located on the stack, and the generator -// is likely to persist beyond that stack frame. -template <typename T> -class ValuesInIteratorRangeGenerator : public ParamGeneratorInterface<T> { - public: - template <typename ForwardIterator> - ValuesInIteratorRangeGenerator(ForwardIterator begin, ForwardIterator end) - : container_(begin, end) {} - ~ValuesInIteratorRangeGenerator() override {} - - ParamIteratorInterface<T>* Begin() const override { - return new Iterator(this, container_.begin()); - } - ParamIteratorInterface<T>* End() const override { - return new Iterator(this, container_.end()); - } - - private: - typedef typename ::std::vector<T> ContainerType; - - class Iterator : public ParamIteratorInterface<T> { - public: - Iterator(const ParamGeneratorInterface<T>* base, - typename ContainerType::const_iterator iterator) - : base_(base), iterator_(iterator) {} - ~Iterator() override {} - - const ParamGeneratorInterface<T>* BaseGenerator() const override { - return base_; - } - void Advance() override { - ++iterator_; - value_.reset(); - } - ParamIteratorInterface<T>* Clone() const override { - return new Iterator(*this); - } - // We need to use cached value referenced by iterator_ because *iterator_ - // can return a temporary object (and of type other then T), so just - // having "return &*iterator_;" doesn't work. - // value_ is updated here and not in Advance() because Advance() - // can advance iterator_ beyond the end of the range, and we cannot - // detect that fact. The client code, on the other hand, is - // responsible for not calling Current() on an out-of-range iterator. - const T* Current() const override { - if (value_.get() == nullptr) value_.reset(new T(*iterator_)); - return value_.get(); - } - bool Equals(const ParamIteratorInterface<T>& other) const override { - // Having the same base generator guarantees that the other - // iterator is of the same type and we can downcast. - GTEST_CHECK_(BaseGenerator() == other.BaseGenerator()) - << "The program attempted to compare iterators " - << "from different generators." << std::endl; - return iterator_ == - CheckedDowncastToActualType<const Iterator>(&other)->iterator_; - } - - private: - Iterator(const Iterator& other) - // The explicit constructor call suppresses a false warning - // emitted by gcc when supplied with the -Wextra option. - : ParamIteratorInterface<T>(), - base_(other.base_), - iterator_(other.iterator_) {} - - const ParamGeneratorInterface<T>* const base_; - typename ContainerType::const_iterator iterator_; - // A cached value of *iterator_. We keep it here to allow access by - // pointer in the wrapping iterator's operator->(). - // value_ needs to be mutable to be accessed in Current(). - // Use of std::unique_ptr helps manage cached value's lifetime, - // which is bound by the lifespan of the iterator itself. - mutable std::unique_ptr<const T> value_; - }; // class ValuesInIteratorRangeGenerator::Iterator - - // No implementation - assignment is unsupported. - void operator=(const ValuesInIteratorRangeGenerator& other); - - const ContainerType container_; -}; // class ValuesInIteratorRangeGenerator - -// INTERNAL IMPLEMENTATION - DO NOT USE IN USER CODE. -// -// Default parameterized test name generator, returns a string containing the -// integer test parameter index. -template <class ParamType> -std::string DefaultParamName(const TestParamInfo<ParamType>& info) { - Message name_stream; - name_stream << info.index; - return name_stream.GetString(); -} - -template <typename T = int> -void TestNotEmpty() { - static_assert(sizeof(T) == 0, "Empty arguments are not allowed."); -} -template <typename T = int> -void TestNotEmpty(const T&) {} - -// INTERNAL IMPLEMENTATION - DO NOT USE IN USER CODE. -// -// Stores a parameter value and later creates tests parameterized with that -// value. -template <class TestClass> -class ParameterizedTestFactory : public TestFactoryBase { - public: - typedef typename TestClass::ParamType ParamType; - explicit ParameterizedTestFactory(ParamType parameter) : - parameter_(parameter) {} - Test* CreateTest() override { - TestClass::SetParam(¶meter_); - return new TestClass(); - } - - private: - const ParamType parameter_; - - GTEST_DISALLOW_COPY_AND_ASSIGN_(ParameterizedTestFactory); -}; - -// INTERNAL IMPLEMENTATION - DO NOT USE IN USER CODE. -// -// TestMetaFactoryBase is a base class for meta-factories that create -// test factories for passing into MakeAndRegisterTestInfo function. -template <class ParamType> -class TestMetaFactoryBase { - public: - virtual ~TestMetaFactoryBase() {} - - virtual TestFactoryBase* CreateTestFactory(ParamType parameter) = 0; -}; - -// INTERNAL IMPLEMENTATION - DO NOT USE IN USER CODE. -// -// TestMetaFactory creates test factories for passing into -// MakeAndRegisterTestInfo function. Since MakeAndRegisterTestInfo receives -// ownership of test factory pointer, same factory object cannot be passed -// into that method twice. But ParameterizedTestSuiteInfo is going to call -// it for each Test/Parameter value combination. Thus it needs meta factory -// creator class. -template <class TestSuite> -class TestMetaFactory - : public TestMetaFactoryBase<typename TestSuite::ParamType> { - public: - using ParamType = typename TestSuite::ParamType; - - TestMetaFactory() {} - - TestFactoryBase* CreateTestFactory(ParamType parameter) override { - return new ParameterizedTestFactory<TestSuite>(parameter); - } - - private: - GTEST_DISALLOW_COPY_AND_ASSIGN_(TestMetaFactory); -}; - -// INTERNAL IMPLEMENTATION - DO NOT USE IN USER CODE. -// -// ParameterizedTestSuiteInfoBase is a generic interface -// to ParameterizedTestSuiteInfo classes. ParameterizedTestSuiteInfoBase -// accumulates test information provided by TEST_P macro invocations -// and generators provided by INSTANTIATE_TEST_SUITE_P macro invocations -// and uses that information to register all resulting test instances -// in RegisterTests method. The ParameterizeTestSuiteRegistry class holds -// a collection of pointers to the ParameterizedTestSuiteInfo objects -// and calls RegisterTests() on each of them when asked. -class ParameterizedTestSuiteInfoBase { - public: - virtual ~ParameterizedTestSuiteInfoBase() {} - - // Base part of test suite name for display purposes. - virtual const std::string& GetTestSuiteName() const = 0; - // Test suite id to verify identity. - virtual TypeId GetTestSuiteTypeId() const = 0; - // UnitTest class invokes this method to register tests in this - // test suite right before running them in RUN_ALL_TESTS macro. - // This method should not be called more than once on any single - // instance of a ParameterizedTestSuiteInfoBase derived class. - virtual void RegisterTests() = 0; - - protected: - ParameterizedTestSuiteInfoBase() {} - - private: - GTEST_DISALLOW_COPY_AND_ASSIGN_(ParameterizedTestSuiteInfoBase); -}; - -// INTERNAL IMPLEMENTATION - DO NOT USE IN USER CODE. -// -// Report a the name of a test_suit as safe to ignore -// as the side effect of construction of this type. -struct MarkAsIgnored { - explicit MarkAsIgnored(const char* test_suite); -}; - -GTEST_API_ void InsertSyntheticTestCase(const std::string& name, - CodeLocation location, bool has_test_p); - -// INTERNAL IMPLEMENTATION - DO NOT USE IN USER CODE. -// -// ParameterizedTestSuiteInfo accumulates tests obtained from TEST_P -// macro invocations for a particular test suite and generators -// obtained from INSTANTIATE_TEST_SUITE_P macro invocations for that -// test suite. It registers tests with all values generated by all -// generators when asked. -template <class TestSuite> -class ParameterizedTestSuiteInfo : public ParameterizedTestSuiteInfoBase { - public: - // ParamType and GeneratorCreationFunc are private types but are required - // for declarations of public methods AddTestPattern() and - // AddTestSuiteInstantiation(). - using ParamType = typename TestSuite::ParamType; - // A function that returns an instance of appropriate generator type. - typedef ParamGenerator<ParamType>(GeneratorCreationFunc)(); - using ParamNameGeneratorFunc = std::string(const TestParamInfo<ParamType>&); - - explicit ParameterizedTestSuiteInfo(const char* name, - CodeLocation code_location) - : test_suite_name_(name), code_location_(code_location) {} - - // Test suite base name for display purposes. - const std::string& GetTestSuiteName() const override { - return test_suite_name_; - } - // Test suite id to verify identity. - TypeId GetTestSuiteTypeId() const override { return GetTypeId<TestSuite>(); } - // TEST_P macro uses AddTestPattern() to record information - // about a single test in a LocalTestInfo structure. - // test_suite_name is the base name of the test suite (without invocation - // prefix). test_base_name is the name of an individual test without - // parameter index. For the test SequenceA/FooTest.DoBar/1 FooTest is - // test suite base name and DoBar is test base name. - void AddTestPattern(const char* test_suite_name, const char* test_base_name, - TestMetaFactoryBase<ParamType>* meta_factory, - CodeLocation code_location) { - tests_.push_back(std::shared_ptr<TestInfo>(new TestInfo( - test_suite_name, test_base_name, meta_factory, code_location))); - } - // INSTANTIATE_TEST_SUITE_P macro uses AddGenerator() to record information - // about a generator. - int AddTestSuiteInstantiation(const std::string& instantiation_name, - GeneratorCreationFunc* func, - ParamNameGeneratorFunc* name_func, - const char* file, int line) { - instantiations_.push_back( - InstantiationInfo(instantiation_name, func, name_func, file, line)); - return 0; // Return value used only to run this method in namespace scope. - } - // UnitTest class invokes this method to register tests in this test suite - // right before running tests in RUN_ALL_TESTS macro. - // This method should not be called more than once on any single - // instance of a ParameterizedTestSuiteInfoBase derived class. - // UnitTest has a guard to prevent from calling this method more than once. - void RegisterTests() override { - bool generated_instantiations = false; - - for (typename TestInfoContainer::iterator test_it = tests_.begin(); - test_it != tests_.end(); ++test_it) { - std::shared_ptr<TestInfo> test_info = *test_it; - for (typename InstantiationContainer::iterator gen_it = - instantiations_.begin(); gen_it != instantiations_.end(); - ++gen_it) { - const std::string& instantiation_name = gen_it->name; - ParamGenerator<ParamType> generator((*gen_it->generator)()); - ParamNameGeneratorFunc* name_func = gen_it->name_func; - const char* file = gen_it->file; - int line = gen_it->line; - - std::string test_suite_name; - if ( !instantiation_name.empty() ) - test_suite_name = instantiation_name + "/"; - test_suite_name += test_info->test_suite_base_name; - - size_t i = 0; - std::set<std::string> test_param_names; - for (typename ParamGenerator<ParamType>::iterator param_it = - generator.begin(); - param_it != generator.end(); ++param_it, ++i) { - generated_instantiations = true; - - Message test_name_stream; - - std::string param_name = name_func( - TestParamInfo<ParamType>(*param_it, i)); - - GTEST_CHECK_(IsValidParamName(param_name)) - << "Parameterized test name '" << param_name - << "' is invalid, in " << file - << " line " << line << std::endl; - - GTEST_CHECK_(test_param_names.count(param_name) == 0) - << "Duplicate parameterized test name '" << param_name - << "', in " << file << " line " << line << std::endl; - - test_param_names.insert(param_name); - - if (!test_info->test_base_name.empty()) { - test_name_stream << test_info->test_base_name << "/"; - } - test_name_stream << param_name; - MakeAndRegisterTestInfo( - test_suite_name.c_str(), test_name_stream.GetString().c_str(), - nullptr, // No type parameter. - PrintToString(*param_it).c_str(), test_info->code_location, - GetTestSuiteTypeId(), - SuiteApiResolver<TestSuite>::GetSetUpCaseOrSuite(file, line), - SuiteApiResolver<TestSuite>::GetTearDownCaseOrSuite(file, line), - test_info->test_meta_factory->CreateTestFactory(*param_it)); - } // for param_it - } // for gen_it - } // for test_it - - if (!generated_instantiations) { - // There are no generaotrs, or they all generate nothing ... - InsertSyntheticTestCase(GetTestSuiteName(), code_location_, - !tests_.empty()); - } - } // RegisterTests - - private: - // LocalTestInfo structure keeps information about a single test registered - // with TEST_P macro. - struct TestInfo { - TestInfo(const char* a_test_suite_base_name, const char* a_test_base_name, - TestMetaFactoryBase<ParamType>* a_test_meta_factory, - CodeLocation a_code_location) - : test_suite_base_name(a_test_suite_base_name), - test_base_name(a_test_base_name), - test_meta_factory(a_test_meta_factory), - code_location(a_code_location) {} - - const std::string test_suite_base_name; - const std::string test_base_name; - const std::unique_ptr<TestMetaFactoryBase<ParamType> > test_meta_factory; - const CodeLocation code_location; - }; - using TestInfoContainer = ::std::vector<std::shared_ptr<TestInfo> >; - // Records data received from INSTANTIATE_TEST_SUITE_P macros: - // <Instantiation name, Sequence generator creation function, - // Name generator function, Source file, Source line> - struct InstantiationInfo { - InstantiationInfo(const std::string &name_in, - GeneratorCreationFunc* generator_in, - ParamNameGeneratorFunc* name_func_in, - const char* file_in, - int line_in) - : name(name_in), - generator(generator_in), - name_func(name_func_in), - file(file_in), - line(line_in) {} - - std::string name; - GeneratorCreationFunc* generator; - ParamNameGeneratorFunc* name_func; - const char* file; - int line; - }; - typedef ::std::vector<InstantiationInfo> InstantiationContainer; - - static bool IsValidParamName(const std::string& name) { - // Check for empty string - if (name.empty()) - return false; - - // Check for invalid characters - for (std::string::size_type index = 0; index < name.size(); ++index) { - if (!isalnum(name[index]) && name[index] != '_') - return false; - } - - return true; - } - - const std::string test_suite_name_; - CodeLocation code_location_; - TestInfoContainer tests_; - InstantiationContainer instantiations_; - - GTEST_DISALLOW_COPY_AND_ASSIGN_(ParameterizedTestSuiteInfo); -}; // class ParameterizedTestSuiteInfo - -// Legacy API is deprecated but still available -#ifndef GTEST_REMOVE_LEGACY_TEST_CASEAPI_ -template <class TestCase> -using ParameterizedTestCaseInfo = ParameterizedTestSuiteInfo<TestCase>; -#endif // GTEST_REMOVE_LEGACY_TEST_CASEAPI_ - -// INTERNAL IMPLEMENTATION - DO NOT USE IN USER CODE. -// -// ParameterizedTestSuiteRegistry contains a map of -// ParameterizedTestSuiteInfoBase classes accessed by test suite names. TEST_P -// and INSTANTIATE_TEST_SUITE_P macros use it to locate their corresponding -// ParameterizedTestSuiteInfo descriptors. -class ParameterizedTestSuiteRegistry { - public: - ParameterizedTestSuiteRegistry() {} - ~ParameterizedTestSuiteRegistry() { - for (auto& test_suite_info : test_suite_infos_) { - delete test_suite_info; - } - } - - // Looks up or creates and returns a structure containing information about - // tests and instantiations of a particular test suite. - template <class TestSuite> - ParameterizedTestSuiteInfo<TestSuite>* GetTestSuitePatternHolder( - const char* test_suite_name, CodeLocation code_location) { - ParameterizedTestSuiteInfo<TestSuite>* typed_test_info = nullptr; - for (auto& test_suite_info : test_suite_infos_) { - if (test_suite_info->GetTestSuiteName() == test_suite_name) { - if (test_suite_info->GetTestSuiteTypeId() != GetTypeId<TestSuite>()) { - // Complain about incorrect usage of Google Test facilities - // and terminate the program since we cannot guaranty correct - // test suite setup and tear-down in this case. - ReportInvalidTestSuiteType(test_suite_name, code_location); - posix::Abort(); - } else { - // At this point we are sure that the object we found is of the same - // type we are looking for, so we downcast it to that type - // without further checks. - typed_test_info = CheckedDowncastToActualType< - ParameterizedTestSuiteInfo<TestSuite> >(test_suite_info); - } - break; - } - } - if (typed_test_info == nullptr) { - typed_test_info = new ParameterizedTestSuiteInfo<TestSuite>( - test_suite_name, code_location); - test_suite_infos_.push_back(typed_test_info); - } - return typed_test_info; - } - void RegisterTests() { - for (auto& test_suite_info : test_suite_infos_) { - test_suite_info->RegisterTests(); - } - } -// Legacy API is deprecated but still available -#ifndef GTEST_REMOVE_LEGACY_TEST_CASEAPI_ - template <class TestCase> - ParameterizedTestCaseInfo<TestCase>* GetTestCasePatternHolder( - const char* test_case_name, CodeLocation code_location) { - return GetTestSuitePatternHolder<TestCase>(test_case_name, code_location); - } - -#endif // GTEST_REMOVE_LEGACY_TEST_CASEAPI_ - - private: - using TestSuiteInfoContainer = ::std::vector<ParameterizedTestSuiteInfoBase*>; - - TestSuiteInfoContainer test_suite_infos_; - - GTEST_DISALLOW_COPY_AND_ASSIGN_(ParameterizedTestSuiteRegistry); -}; - -// Keep track of what type-parameterized test suite are defined and -// where as well as which are intatiated. This allows susequently -// identifying suits that are defined but never used. -class TypeParameterizedTestSuiteRegistry { - public: - // Add a suite definition - void RegisterTestSuite(const char* test_suite_name, - CodeLocation code_location); - - // Add an instantiation of a suit. - void RegisterInstantiation(const char* test_suite_name); - - // For each suit repored as defined but not reported as instantiation, - // emit a test that reports that fact (configurably, as an error). - void CheckForInstantiations(); - - private: - struct TypeParameterizedTestSuiteInfo { - explicit TypeParameterizedTestSuiteInfo(CodeLocation c) - : code_location(c), instantiated(false) {} - - CodeLocation code_location; - bool instantiated; - }; - - std::map<std::string, TypeParameterizedTestSuiteInfo> suites_; -}; - -} // namespace internal - -// Forward declarations of ValuesIn(), which is implemented in -// include/gtest/gtest-param-test.h. -template <class Container> -internal::ParamGenerator<typename Container::value_type> ValuesIn( - const Container& container); - -namespace internal { -// Used in the Values() function to provide polymorphic capabilities. - -#ifdef _MSC_VER -#pragma warning(push) -#pragma warning(disable : 4100) -#endif - -template <typename... Ts> -class ValueArray { - public: - explicit ValueArray(Ts... v) : v_(FlatTupleConstructTag{}, std::move(v)...) {} - - template <typename T> - operator ParamGenerator<T>() const { // NOLINT - return ValuesIn(MakeVector<T>(MakeIndexSequence<sizeof...(Ts)>())); - } - - private: - template <typename T, size_t... I> - std::vector<T> MakeVector(IndexSequence<I...>) const { - return std::vector<T>{static_cast<T>(v_.template Get<I>())...}; - } - - FlatTuple<Ts...> v_; -}; - -#ifdef _MSC_VER -#pragma warning(pop) -#endif - -template <typename... T> -class CartesianProductGenerator - : public ParamGeneratorInterface<::std::tuple<T...>> { - public: - typedef ::std::tuple<T...> ParamType; - - CartesianProductGenerator(const std::tuple<ParamGenerator<T>...>& g) - : generators_(g) {} - ~CartesianProductGenerator() override {} - - ParamIteratorInterface<ParamType>* Begin() const override { - return new Iterator(this, generators_, false); - } - ParamIteratorInterface<ParamType>* End() const override { - return new Iterator(this, generators_, true); - } - - private: - template <class I> - class IteratorImpl; - template <size_t... I> - class IteratorImpl<IndexSequence<I...>> - : public ParamIteratorInterface<ParamType> { - public: - IteratorImpl(const ParamGeneratorInterface<ParamType>* base, - const std::tuple<ParamGenerator<T>...>& generators, bool is_end) - : base_(base), - begin_(std::get<I>(generators).begin()...), - end_(std::get<I>(generators).end()...), - current_(is_end ? end_ : begin_) { - ComputeCurrentValue(); - } - ~IteratorImpl() override {} - - const ParamGeneratorInterface<ParamType>* BaseGenerator() const override { - return base_; - } - // Advance should not be called on beyond-of-range iterators - // so no component iterators must be beyond end of range, either. - void Advance() override { - assert(!AtEnd()); - // Advance the last iterator. - ++std::get<sizeof...(T) - 1>(current_); - // if that reaches end, propagate that up. - AdvanceIfEnd<sizeof...(T) - 1>(); - ComputeCurrentValue(); - } - ParamIteratorInterface<ParamType>* Clone() const override { - return new IteratorImpl(*this); - } - - const ParamType* Current() const override { return current_value_.get(); } - - bool Equals(const ParamIteratorInterface<ParamType>& other) const override { - // Having the same base generator guarantees that the other - // iterator is of the same type and we can downcast. - GTEST_CHECK_(BaseGenerator() == other.BaseGenerator()) - << "The program attempted to compare iterators " - << "from different generators." << std::endl; - const IteratorImpl* typed_other = - CheckedDowncastToActualType<const IteratorImpl>(&other); - - // We must report iterators equal if they both point beyond their - // respective ranges. That can happen in a variety of fashions, - // so we have to consult AtEnd(). - if (AtEnd() && typed_other->AtEnd()) return true; - - bool same = true; - bool dummy[] = { - (same = same && std::get<I>(current_) == - std::get<I>(typed_other->current_))...}; - (void)dummy; - return same; - } - - private: - template <size_t ThisI> - void AdvanceIfEnd() { - if (std::get<ThisI>(current_) != std::get<ThisI>(end_)) return; - - bool last = ThisI == 0; - if (last) { - // We are done. Nothing else to propagate. - return; - } - - constexpr size_t NextI = ThisI - (ThisI != 0); - std::get<ThisI>(current_) = std::get<ThisI>(begin_); - ++std::get<NextI>(current_); - AdvanceIfEnd<NextI>(); - } - - void ComputeCurrentValue() { - if (!AtEnd()) - current_value_ = std::make_shared<ParamType>(*std::get<I>(current_)...); - } - bool AtEnd() const { - bool at_end = false; - bool dummy[] = { - (at_end = at_end || std::get<I>(current_) == std::get<I>(end_))...}; - (void)dummy; - return at_end; - } - - const ParamGeneratorInterface<ParamType>* const base_; - std::tuple<typename ParamGenerator<T>::iterator...> begin_; - std::tuple<typename ParamGenerator<T>::iterator...> end_; - std::tuple<typename ParamGenerator<T>::iterator...> current_; - std::shared_ptr<ParamType> current_value_; - }; - - using Iterator = IteratorImpl<typename MakeIndexSequence<sizeof...(T)>::type>; - - std::tuple<ParamGenerator<T>...> generators_; -}; - -template <class... Gen> -class CartesianProductHolder { - public: - CartesianProductHolder(const Gen&... g) : generators_(g...) {} - template <typename... T> - operator ParamGenerator<::std::tuple<T...>>() const { - return ParamGenerator<::std::tuple<T...>>( - new CartesianProductGenerator<T...>(generators_)); - } - - private: - std::tuple<Gen...> generators_; -}; - -} // namespace internal -} // namespace testing - -#endif // GOOGLETEST_INCLUDE_GTEST_INTERNAL_GTEST_PARAM_UTIL_H_ - -namespace testing { - -// Functions producing parameter generators. -// -// Google Test uses these generators to produce parameters for value- -// parameterized tests. When a parameterized test suite is instantiated -// with a particular generator, Google Test creates and runs tests -// for each element in the sequence produced by the generator. -// -// In the following sample, tests from test suite FooTest are instantiated -// each three times with parameter values 3, 5, and 8: -// -// class FooTest : public TestWithParam<int> { ... }; -// -// TEST_P(FooTest, TestThis) { -// } -// TEST_P(FooTest, TestThat) { -// } -// INSTANTIATE_TEST_SUITE_P(TestSequence, FooTest, Values(3, 5, 8)); -// - -// Range() returns generators providing sequences of values in a range. -// -// Synopsis: -// Range(start, end) -// - returns a generator producing a sequence of values {start, start+1, -// start+2, ..., }. -// Range(start, end, step) -// - returns a generator producing a sequence of values {start, start+step, -// start+step+step, ..., }. -// Notes: -// * The generated sequences never include end. For example, Range(1, 5) -// returns a generator producing a sequence {1, 2, 3, 4}. Range(1, 9, 2) -// returns a generator producing {1, 3, 5, 7}. -// * start and end must have the same type. That type may be any integral or -// floating-point type or a user defined type satisfying these conditions: -// * It must be assignable (have operator=() defined). -// * It must have operator+() (operator+(int-compatible type) for -// two-operand version). -// * It must have operator<() defined. -// Elements in the resulting sequences will also have that type. -// * Condition start < end must be satisfied in order for resulting sequences -// to contain any elements. -// -template <typename T, typename IncrementT> -internal::ParamGenerator<T> Range(T start, T end, IncrementT step) { - return internal::ParamGenerator<T>( - new internal::RangeGenerator<T, IncrementT>(start, end, step)); -} - -template <typename T> -internal::ParamGenerator<T> Range(T start, T end) { - return Range(start, end, 1); -} - -// ValuesIn() function allows generation of tests with parameters coming from -// a container. -// -// Synopsis: -// ValuesIn(const T (&array)[N]) -// - returns a generator producing sequences with elements from -// a C-style array. -// ValuesIn(const Container& container) -// - returns a generator producing sequences with elements from -// an STL-style container. -// ValuesIn(Iterator begin, Iterator end) -// - returns a generator producing sequences with elements from -// a range [begin, end) defined by a pair of STL-style iterators. These -// iterators can also be plain C pointers. -// -// Please note that ValuesIn copies the values from the containers -// passed in and keeps them to generate tests in RUN_ALL_TESTS(). -// -// Examples: -// -// This instantiates tests from test suite StringTest -// each with C-string values of "foo", "bar", and "baz": -// -// const char* strings[] = {"foo", "bar", "baz"}; -// INSTANTIATE_TEST_SUITE_P(StringSequence, StringTest, ValuesIn(strings)); -// -// This instantiates tests from test suite StlStringTest -// each with STL strings with values "a" and "b": -// -// ::std::vector< ::std::string> GetParameterStrings() { -// ::std::vector< ::std::string> v; -// v.push_back("a"); -// v.push_back("b"); -// return v; -// } -// -// INSTANTIATE_TEST_SUITE_P(CharSequence, -// StlStringTest, -// ValuesIn(GetParameterStrings())); -// -// -// This will also instantiate tests from CharTest -// each with parameter values 'a' and 'b': -// -// ::std::list<char> GetParameterChars() { -// ::std::list<char> list; -// list.push_back('a'); -// list.push_back('b'); -// return list; -// } -// ::std::list<char> l = GetParameterChars(); -// INSTANTIATE_TEST_SUITE_P(CharSequence2, -// CharTest, -// ValuesIn(l.begin(), l.end())); -// -template <typename ForwardIterator> -internal::ParamGenerator< - typename std::iterator_traits<ForwardIterator>::value_type> -ValuesIn(ForwardIterator begin, ForwardIterator end) { - typedef typename std::iterator_traits<ForwardIterator>::value_type ParamType; - return internal::ParamGenerator<ParamType>( - new internal::ValuesInIteratorRangeGenerator<ParamType>(begin, end)); -} - -template <typename T, size_t N> -internal::ParamGenerator<T> ValuesIn(const T (&array)[N]) { - return ValuesIn(array, array + N); -} - -template <class Container> -internal::ParamGenerator<typename Container::value_type> ValuesIn( - const Container& container) { - return ValuesIn(container.begin(), container.end()); -} - -// Values() allows generating tests from explicitly specified list of -// parameters. -// -// Synopsis: -// Values(T v1, T v2, ..., T vN) -// - returns a generator producing sequences with elements v1, v2, ..., vN. -// -// For example, this instantiates tests from test suite BarTest each -// with values "one", "two", and "three": -// -// INSTANTIATE_TEST_SUITE_P(NumSequence, -// BarTest, -// Values("one", "two", "three")); -// -// This instantiates tests from test suite BazTest each with values 1, 2, 3.5. -// The exact type of values will depend on the type of parameter in BazTest. -// -// INSTANTIATE_TEST_SUITE_P(FloatingNumbers, BazTest, Values(1, 2, 3.5)); -// -// -template <typename... T> -internal::ValueArray<T...> Values(T... v) { - return internal::ValueArray<T...>(std::move(v)...); -} - -// Bool() allows generating tests with parameters in a set of (false, true). -// -// Synopsis: -// Bool() -// - returns a generator producing sequences with elements {false, true}. -// -// It is useful when testing code that depends on Boolean flags. Combinations -// of multiple flags can be tested when several Bool()'s are combined using -// Combine() function. -// -// In the following example all tests in the test suite FlagDependentTest -// will be instantiated twice with parameters false and true. -// -// class FlagDependentTest : public testing::TestWithParam<bool> { -// virtual void SetUp() { -// external_flag = GetParam(); -// } -// } -// INSTANTIATE_TEST_SUITE_P(BoolSequence, FlagDependentTest, Bool()); -// -inline internal::ParamGenerator<bool> Bool() { - return Values(false, true); -} - -// Combine() allows the user to combine two or more sequences to produce -// values of a Cartesian product of those sequences' elements. -// -// Synopsis: -// Combine(gen1, gen2, ..., genN) -// - returns a generator producing sequences with elements coming from -// the Cartesian product of elements from the sequences generated by -// gen1, gen2, ..., genN. The sequence elements will have a type of -// std::tuple<T1, T2, ..., TN> where T1, T2, ..., TN are the types -// of elements from sequences produces by gen1, gen2, ..., genN. -// -// Example: -// -// This will instantiate tests in test suite AnimalTest each one with -// the parameter values tuple("cat", BLACK), tuple("cat", WHITE), -// tuple("dog", BLACK), and tuple("dog", WHITE): -// -// enum Color { BLACK, GRAY, WHITE }; -// class AnimalTest -// : public testing::TestWithParam<std::tuple<const char*, Color> > {...}; -// -// TEST_P(AnimalTest, AnimalLooksNice) {...} -// -// INSTANTIATE_TEST_SUITE_P(AnimalVariations, AnimalTest, -// Combine(Values("cat", "dog"), -// Values(BLACK, WHITE))); -// -// This will instantiate tests in FlagDependentTest with all variations of two -// Boolean flags: -// -// class FlagDependentTest -// : public testing::TestWithParam<std::tuple<bool, bool> > { -// virtual void SetUp() { -// // Assigns external_flag_1 and external_flag_2 values from the tuple. -// std::tie(external_flag_1, external_flag_2) = GetParam(); -// } -// }; -// -// TEST_P(FlagDependentTest, TestFeature1) { -// // Test your code using external_flag_1 and external_flag_2 here. -// } -// INSTANTIATE_TEST_SUITE_P(TwoBoolSequence, FlagDependentTest, -// Combine(Bool(), Bool())); -// -template <typename... Generator> -internal::CartesianProductHolder<Generator...> Combine(const Generator&... g) { - return internal::CartesianProductHolder<Generator...>(g...); -} - -#define TEST_P(test_suite_name, test_name) \ - class GTEST_TEST_CLASS_NAME_(test_suite_name, test_name) \ - : public test_suite_name { \ - public: \ - GTEST_TEST_CLASS_NAME_(test_suite_name, test_name)() {} \ - void TestBody() override; \ - \ - private: \ - static int AddToRegistry() { \ - ::testing::UnitTest::GetInstance() \ - ->parameterized_test_registry() \ - .GetTestSuitePatternHolder<test_suite_name>( \ - GTEST_STRINGIFY_(test_suite_name), \ - ::testing::internal::CodeLocation(__FILE__, __LINE__)) \ - ->AddTestPattern( \ - GTEST_STRINGIFY_(test_suite_name), GTEST_STRINGIFY_(test_name), \ - new ::testing::internal::TestMetaFactory<GTEST_TEST_CLASS_NAME_( \ - test_suite_name, test_name)>(), \ - ::testing::internal::CodeLocation(__FILE__, __LINE__)); \ - return 0; \ - } \ - static int gtest_registering_dummy_ GTEST_ATTRIBUTE_UNUSED_; \ - GTEST_DISALLOW_COPY_AND_ASSIGN_(GTEST_TEST_CLASS_NAME_(test_suite_name, \ - test_name)); \ - }; \ - int GTEST_TEST_CLASS_NAME_(test_suite_name, \ - test_name)::gtest_registering_dummy_ = \ - GTEST_TEST_CLASS_NAME_(test_suite_name, test_name)::AddToRegistry(); \ - void GTEST_TEST_CLASS_NAME_(test_suite_name, test_name)::TestBody() - -// The last argument to INSTANTIATE_TEST_SUITE_P allows the user to specify -// generator and an optional function or functor that generates custom test name -// suffixes based on the test parameters. Such a function or functor should -// accept one argument of type testing::TestParamInfo<class ParamType>, and -// return std::string. -// -// testing::PrintToStringParamName is a builtin test suffix generator that -// returns the value of testing::PrintToString(GetParam()). -// -// Note: test names must be non-empty, unique, and may only contain ASCII -// alphanumeric characters or underscore. Because PrintToString adds quotes -// to std::string and C strings, it won't work for these types. - -#define GTEST_EXPAND_(arg) arg -#define GTEST_GET_FIRST_(first, ...) first -#define GTEST_GET_SECOND_(first, second, ...) second - -#define INSTANTIATE_TEST_SUITE_P(prefix, test_suite_name, ...) \ - static ::testing::internal::ParamGenerator<test_suite_name::ParamType> \ - gtest_##prefix##test_suite_name##_EvalGenerator_() { \ - return GTEST_EXPAND_(GTEST_GET_FIRST_(__VA_ARGS__, DUMMY_PARAM_)); \ - } \ - static ::std::string gtest_##prefix##test_suite_name##_EvalGenerateName_( \ - const ::testing::TestParamInfo<test_suite_name::ParamType>& info) { \ - if (::testing::internal::AlwaysFalse()) { \ - ::testing::internal::TestNotEmpty(GTEST_EXPAND_(GTEST_GET_SECOND_( \ - __VA_ARGS__, \ - ::testing::internal::DefaultParamName<test_suite_name::ParamType>, \ - DUMMY_PARAM_))); \ - auto t = std::make_tuple(__VA_ARGS__); \ - static_assert(std::tuple_size<decltype(t)>::value <= 2, \ - "Too Many Args!"); \ - } \ - return ((GTEST_EXPAND_(GTEST_GET_SECOND_( \ - __VA_ARGS__, \ - ::testing::internal::DefaultParamName<test_suite_name::ParamType>, \ - DUMMY_PARAM_))))(info); \ - } \ - static int gtest_##prefix##test_suite_name##_dummy_ \ - GTEST_ATTRIBUTE_UNUSED_ = \ - ::testing::UnitTest::GetInstance() \ - ->parameterized_test_registry() \ - .GetTestSuitePatternHolder<test_suite_name>( \ - GTEST_STRINGIFY_(test_suite_name), \ - ::testing::internal::CodeLocation(__FILE__, __LINE__)) \ - ->AddTestSuiteInstantiation( \ - GTEST_STRINGIFY_(prefix), \ - >est_##prefix##test_suite_name##_EvalGenerator_, \ - >est_##prefix##test_suite_name##_EvalGenerateName_, \ - __FILE__, __LINE__) - - -// Allow Marking a Parameterized test class as not needing to be instantiated. -#define GTEST_ALLOW_UNINSTANTIATED_PARAMETERIZED_TEST(T) \ - namespace gtest_do_not_use_outside_namespace_scope {} \ - static const ::testing::internal::MarkAsIgnored gtest_allow_ignore_##T( \ - GTEST_STRINGIFY_(T)) - -// Legacy API is deprecated but still available -#ifndef GTEST_REMOVE_LEGACY_TEST_CASEAPI_ -#define INSTANTIATE_TEST_CASE_P \ - static_assert(::testing::internal::InstantiateTestCase_P_IsDeprecated(), \ - ""); \ - INSTANTIATE_TEST_SUITE_P -#endif // GTEST_REMOVE_LEGACY_TEST_CASEAPI_ - -} // namespace testing - -#endif // GOOGLETEST_INCLUDE_GTEST_GTEST_PARAM_TEST_H_ -// Copyright 2006, 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. - -// -// Google C++ Testing and Mocking Framework definitions useful in production code. -// GOOGLETEST_CM0003 DO NOT DELETE - -#ifndef GOOGLETEST_INCLUDE_GTEST_GTEST_PROD_H_ -#define GOOGLETEST_INCLUDE_GTEST_GTEST_PROD_H_ - -// When you need to test the private or protected members of a class, -// use the FRIEND_TEST macro to declare your tests as friends of the -// class. For example: -// -// class MyClass { -// private: -// void PrivateMethod(); -// FRIEND_TEST(MyClassTest, PrivateMethodWorks); -// }; -// -// class MyClassTest : public testing::Test { -// // ... -// }; -// -// TEST_F(MyClassTest, PrivateMethodWorks) { -// // Can call MyClass::PrivateMethod() here. -// } -// -// Note: The test class must be in the same namespace as the class being tested. -// For example, putting MyClassTest in an anonymous namespace will not work. - -#define FRIEND_TEST(test_case_name, test_name)\ -friend class test_case_name##_##test_name##_Test - -#endif // GOOGLETEST_INCLUDE_GTEST_GTEST_PROD_H_ -// Copyright 2008 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. - -// GOOGLETEST_CM0001 DO NOT DELETE - -#ifndef GOOGLETEST_INCLUDE_GTEST_GTEST_TYPED_TEST_H_ -#define GOOGLETEST_INCLUDE_GTEST_GTEST_TYPED_TEST_H_ - -// This header implements typed tests and type-parameterized tests. - -// Typed (aka type-driven) tests repeat the same test for types in a -// list. You must know which types you want to test with when writing -// typed tests. Here's how you do it: - -#if 0 - -// First, define a fixture class template. It should be parameterized -// by a type. Remember to derive it from testing::Test. -template <typename T> -class FooTest : public testing::Test { - public: - ... - typedef std::list<T> List; - static T shared_; - T value_; -}; - -// Next, associate a list of types with the test suite, which will be -// repeated for each type in the list. The typedef is necessary for -// the macro to parse correctly. -typedef testing::Types<char, int, unsigned int> MyTypes; -TYPED_TEST_SUITE(FooTest, MyTypes); - -// If the type list contains only one type, you can write that type -// directly without Types<...>: -// TYPED_TEST_SUITE(FooTest, int); - -// Then, use TYPED_TEST() instead of TEST_F() to define as many typed -// tests for this test suite as you want. -TYPED_TEST(FooTest, DoesBlah) { - // Inside a test, refer to the special name TypeParam to get the type - // parameter. Since we are inside a derived class template, C++ requires - // us to visit the members of FooTest via 'this'. - TypeParam n = this->value_; - - // To visit static members of the fixture, add the TestFixture:: - // prefix. - n += TestFixture::shared_; - - // To refer to typedefs in the fixture, add the "typename - // TestFixture::" prefix. - typename TestFixture::List values; - values.push_back(n); - ... -} - -TYPED_TEST(FooTest, HasPropertyA) { ... } - -// TYPED_TEST_SUITE takes an optional third argument which allows to specify a -// class that generates custom test name suffixes based on the type. This should -// be a class which has a static template function GetName(int index) returning -// a string for each type. The provided integer index equals the index of the -// type in the provided type list. In many cases the index can be ignored. -// -// For example: -// class MyTypeNames { -// public: -// template <typename T> -// static std::string GetName(int) { -// if (std::is_same<T, char>()) return "char"; -// if (std::is_same<T, int>()) return "int"; -// if (std::is_same<T, unsigned int>()) return "unsignedInt"; -// } -// }; -// TYPED_TEST_SUITE(FooTest, MyTypes, MyTypeNames); - -#endif // 0 - -// Type-parameterized tests are abstract test patterns parameterized -// by a type. Compared with typed tests, type-parameterized tests -// allow you to define the test pattern without knowing what the type -// parameters are. The defined pattern can be instantiated with -// different types any number of times, in any number of translation -// units. -// -// If you are designing an interface or concept, you can define a -// suite of type-parameterized tests to verify properties that any -// valid implementation of the interface/concept should have. Then, -// each implementation can easily instantiate the test suite to verify -// that it conforms to the requirements, without having to write -// similar tests repeatedly. Here's an example: - -#if 0 - -// First, define a fixture class template. It should be parameterized -// by a type. Remember to derive it from testing::Test. -template <typename T> -class FooTest : public testing::Test { - ... -}; - -// Next, declare that you will define a type-parameterized test suite -// (the _P suffix is for "parameterized" or "pattern", whichever you -// prefer): -TYPED_TEST_SUITE_P(FooTest); - -// Then, use TYPED_TEST_P() to define as many type-parameterized tests -// for this type-parameterized test suite as you want. -TYPED_TEST_P(FooTest, DoesBlah) { - // Inside a test, refer to TypeParam to get the type parameter. - TypeParam n = 0; - ... -} - -TYPED_TEST_P(FooTest, HasPropertyA) { ... } - -// Now the tricky part: you need to register all test patterns before -// you can instantiate them. The first argument of the macro is the -// test suite name; the rest are the names of the tests in this test -// case. -REGISTER_TYPED_TEST_SUITE_P(FooTest, - DoesBlah, HasPropertyA); - -// Finally, you are free to instantiate the pattern with the types you -// want. If you put the above code in a header file, you can #include -// it in multiple C++ source files and instantiate it multiple times. -// -// To distinguish different instances of the pattern, the first -// argument to the INSTANTIATE_* macro is a prefix that will be added -// to the actual test suite name. Remember to pick unique prefixes for -// different instances. -typedef testing::Types<char, int, unsigned int> MyTypes; -INSTANTIATE_TYPED_TEST_SUITE_P(My, FooTest, MyTypes); - -// If the type list contains only one type, you can write that type -// directly without Types<...>: -// INSTANTIATE_TYPED_TEST_SUITE_P(My, FooTest, int); -// -// Similar to the optional argument of TYPED_TEST_SUITE above, -// INSTANTIATE_TEST_SUITE_P takes an optional fourth argument which allows to -// generate custom names. -// INSTANTIATE_TYPED_TEST_SUITE_P(My, FooTest, MyTypes, MyTypeNames); - -#endif // 0 - - -// Implements typed tests. - -// INTERNAL IMPLEMENTATION - DO NOT USE IN USER CODE. -// -// Expands to the name of the typedef for the type parameters of the -// given test suite. -#define GTEST_TYPE_PARAMS_(TestSuiteName) gtest_type_params_##TestSuiteName##_ - -// Expands to the name of the typedef for the NameGenerator, responsible for -// creating the suffixes of the name. -#define GTEST_NAME_GENERATOR_(TestSuiteName) \ - gtest_type_params_##TestSuiteName##_NameGenerator - -#define TYPED_TEST_SUITE(CaseName, Types, ...) \ - typedef ::testing::internal::GenerateTypeList<Types>::type \ - GTEST_TYPE_PARAMS_(CaseName); \ - typedef ::testing::internal::NameGeneratorSelector<__VA_ARGS__>::type \ - GTEST_NAME_GENERATOR_(CaseName) - -#define TYPED_TEST(CaseName, TestName) \ - static_assert(sizeof(GTEST_STRINGIFY_(TestName)) > 1, \ - "test-name must not be empty"); \ - template <typename gtest_TypeParam_> \ - class GTEST_TEST_CLASS_NAME_(CaseName, TestName) \ - : public CaseName<gtest_TypeParam_> { \ - private: \ - typedef CaseName<gtest_TypeParam_> TestFixture; \ - typedef gtest_TypeParam_ TypeParam; \ - void TestBody() override; \ - }; \ - static bool gtest_##CaseName##_##TestName##_registered_ \ - GTEST_ATTRIBUTE_UNUSED_ = ::testing::internal::TypeParameterizedTest< \ - CaseName, \ - ::testing::internal::TemplateSel<GTEST_TEST_CLASS_NAME_(CaseName, \ - TestName)>, \ - GTEST_TYPE_PARAMS_( \ - CaseName)>::Register("", \ - ::testing::internal::CodeLocation( \ - __FILE__, __LINE__), \ - GTEST_STRINGIFY_(CaseName), \ - GTEST_STRINGIFY_(TestName), 0, \ - ::testing::internal::GenerateNames< \ - GTEST_NAME_GENERATOR_(CaseName), \ - GTEST_TYPE_PARAMS_(CaseName)>()); \ - template <typename gtest_TypeParam_> \ - void GTEST_TEST_CLASS_NAME_(CaseName, \ - TestName)<gtest_TypeParam_>::TestBody() - -// Legacy API is deprecated but still available -#ifndef GTEST_REMOVE_LEGACY_TEST_CASEAPI_ -#define TYPED_TEST_CASE \ - static_assert(::testing::internal::TypedTestCaseIsDeprecated(), ""); \ - TYPED_TEST_SUITE -#endif // GTEST_REMOVE_LEGACY_TEST_CASEAPI_ - -// Implements type-parameterized tests. - -// INTERNAL IMPLEMENTATION - DO NOT USE IN USER CODE. -// -// Expands to the namespace name that the type-parameterized tests for -// the given type-parameterized test suite are defined in. The exact -// name of the namespace is subject to change without notice. -#define GTEST_SUITE_NAMESPACE_(TestSuiteName) gtest_suite_##TestSuiteName##_ - -// INTERNAL IMPLEMENTATION - DO NOT USE IN USER CODE. -// -// Expands to the name of the variable used to remember the names of -// the defined tests in the given test suite. -#define GTEST_TYPED_TEST_SUITE_P_STATE_(TestSuiteName) \ - gtest_typed_test_suite_p_state_##TestSuiteName##_ - -// INTERNAL IMPLEMENTATION - DO NOT USE IN USER CODE DIRECTLY. -// -// Expands to the name of the variable used to remember the names of -// the registered tests in the given test suite. -#define GTEST_REGISTERED_TEST_NAMES_(TestSuiteName) \ - gtest_registered_test_names_##TestSuiteName##_ - -// The variables defined in the type-parameterized test macros are -// static as typically these macros are used in a .h file that can be -// #included in multiple translation units linked together. -#define TYPED_TEST_SUITE_P(SuiteName) \ - static ::testing::internal::TypedTestSuitePState \ - GTEST_TYPED_TEST_SUITE_P_STATE_(SuiteName) - -// Legacy API is deprecated but still available -#ifndef GTEST_REMOVE_LEGACY_TEST_CASEAPI_ -#define TYPED_TEST_CASE_P \ - static_assert(::testing::internal::TypedTestCase_P_IsDeprecated(), ""); \ - TYPED_TEST_SUITE_P -#endif // GTEST_REMOVE_LEGACY_TEST_CASEAPI_ - -#define TYPED_TEST_P(SuiteName, TestName) \ - namespace GTEST_SUITE_NAMESPACE_(SuiteName) { \ - template <typename gtest_TypeParam_> \ - class TestName : public SuiteName<gtest_TypeParam_> { \ - private: \ - typedef SuiteName<gtest_TypeParam_> TestFixture; \ - typedef gtest_TypeParam_ TypeParam; \ - void TestBody() override; \ - }; \ - static bool gtest_##TestName##_defined_ GTEST_ATTRIBUTE_UNUSED_ = \ - GTEST_TYPED_TEST_SUITE_P_STATE_(SuiteName).AddTestName( \ - __FILE__, __LINE__, GTEST_STRINGIFY_(SuiteName), \ - GTEST_STRINGIFY_(TestName)); \ - } \ - template <typename gtest_TypeParam_> \ - void GTEST_SUITE_NAMESPACE_( \ - SuiteName)::TestName<gtest_TypeParam_>::TestBody() - -// Note: this won't work correctly if the trailing arguments are macros. -#define REGISTER_TYPED_TEST_SUITE_P(SuiteName, ...) \ - namespace GTEST_SUITE_NAMESPACE_(SuiteName) { \ - typedef ::testing::internal::Templates<__VA_ARGS__> gtest_AllTests_; \ - } \ - static const char* const GTEST_REGISTERED_TEST_NAMES_( \ - SuiteName) GTEST_ATTRIBUTE_UNUSED_ = \ - GTEST_TYPED_TEST_SUITE_P_STATE_(SuiteName).VerifyRegisteredTestNames( \ - GTEST_STRINGIFY_(SuiteName), __FILE__, __LINE__, #__VA_ARGS__) - -// Legacy API is deprecated but still available -#ifndef GTEST_REMOVE_LEGACY_TEST_CASEAPI_ -#define REGISTER_TYPED_TEST_CASE_P \ - static_assert(::testing::internal::RegisterTypedTestCase_P_IsDeprecated(), \ - ""); \ - REGISTER_TYPED_TEST_SUITE_P -#endif // GTEST_REMOVE_LEGACY_TEST_CASEAPI_ - -#define INSTANTIATE_TYPED_TEST_SUITE_P(Prefix, SuiteName, Types, ...) \ - static_assert(sizeof(GTEST_STRINGIFY_(Prefix)) > 1, \ - "test-suit-prefix must not be empty"); \ - static bool gtest_##Prefix##_##SuiteName GTEST_ATTRIBUTE_UNUSED_ = \ - ::testing::internal::TypeParameterizedTestSuite< \ - SuiteName, GTEST_SUITE_NAMESPACE_(SuiteName)::gtest_AllTests_, \ - ::testing::internal::GenerateTypeList<Types>::type>:: \ - Register(GTEST_STRINGIFY_(Prefix), \ - ::testing::internal::CodeLocation(__FILE__, __LINE__), \ - >EST_TYPED_TEST_SUITE_P_STATE_(SuiteName), \ - GTEST_STRINGIFY_(SuiteName), \ - GTEST_REGISTERED_TEST_NAMES_(SuiteName), \ - ::testing::internal::GenerateNames< \ - ::testing::internal::NameGeneratorSelector< \ - __VA_ARGS__>::type, \ - ::testing::internal::GenerateTypeList<Types>::type>()) - -// Legacy API is deprecated but still available -#ifndef GTEST_REMOVE_LEGACY_TEST_CASEAPI_ -#define INSTANTIATE_TYPED_TEST_CASE_P \ - static_assert( \ - ::testing::internal::InstantiateTypedTestCase_P_IsDeprecated(), ""); \ - INSTANTIATE_TYPED_TEST_SUITE_P -#endif // GTEST_REMOVE_LEGACY_TEST_CASEAPI_ - -#endif // GOOGLETEST_INCLUDE_GTEST_GTEST_TYPED_TEST_H_ - -GTEST_DISABLE_MSC_WARNINGS_PUSH_(4251 \ -/* class A needs to have dll-interface to be used by clients of class B */) - -namespace testing { - -// Silence C4100 (unreferenced formal parameter) and 4805 -// unsafe mix of type 'const int' and type 'const bool' -#ifdef _MSC_VER -# pragma warning(push) -# pragma warning(disable:4805) -# pragma warning(disable:4100) -#endif - - -// Declares the flags. - -// This flag temporary enables the disabled tests. -GTEST_DECLARE_bool_(also_run_disabled_tests); - -// This flag brings the debugger on an assertion failure. -GTEST_DECLARE_bool_(break_on_failure); - -// This flag controls whether Google Test catches all test-thrown exceptions -// and logs them as failures. -GTEST_DECLARE_bool_(catch_exceptions); - -// This flag enables using colors in terminal output. Available values are -// "yes" to enable colors, "no" (disable colors), or "auto" (the default) -// to let Google Test decide. -GTEST_DECLARE_string_(color); - -// This flag controls whether the test runner should continue execution past -// first failure. -GTEST_DECLARE_bool_(fail_fast); - -// This flag sets up the filter to select by name using a glob pattern -// the tests to run. If the filter is not given all tests are executed. -GTEST_DECLARE_string_(filter); - -// This flag controls whether Google Test installs a signal handler that dumps -// debugging information when fatal signals are raised. -GTEST_DECLARE_bool_(install_failure_signal_handler); - -// This flag causes the Google Test to list tests. None of the tests listed -// are actually run if the flag is provided. -GTEST_DECLARE_bool_(list_tests); - -// This flag controls whether Google Test emits a detailed XML report to a file -// in addition to its normal textual output. -GTEST_DECLARE_string_(output); - -// This flags control whether Google Test prints only test failures. -GTEST_DECLARE_bool_(brief); - -// This flags control whether Google Test prints the elapsed time for each -// test. -GTEST_DECLARE_bool_(print_time); - -// This flags control whether Google Test prints UTF8 characters as text. -GTEST_DECLARE_bool_(print_utf8); - -// This flag specifies the random number seed. -GTEST_DECLARE_int32_(random_seed); - -// This flag sets how many times the tests are repeated. The default value -// is 1. If the value is -1 the tests are repeating forever. -GTEST_DECLARE_int32_(repeat); - -// This flag controls whether Google Test includes Google Test internal -// stack frames in failure stack traces. -GTEST_DECLARE_bool_(show_internal_stack_frames); - -// When this flag is specified, tests' order is randomized on every iteration. -GTEST_DECLARE_bool_(shuffle); - -// This flag specifies the maximum number of stack frames to be -// printed in a failure message. -GTEST_DECLARE_int32_(stack_trace_depth); - -// When this flag is specified, a failed assertion will throw an -// exception if exceptions are enabled, or exit the program with a -// non-zero code otherwise. For use with an external test framework. -GTEST_DECLARE_bool_(throw_on_failure); - -// When this flag is set with a "host:port" string, on supported -// platforms test results are streamed to the specified port on -// the specified host machine. -GTEST_DECLARE_string_(stream_result_to); - -#if GTEST_USE_OWN_FLAGFILE_FLAG_ -GTEST_DECLARE_string_(flagfile); -#endif // GTEST_USE_OWN_FLAGFILE_FLAG_ - -// The upper limit for valid stack trace depths. -const int kMaxStackTraceDepth = 100; - -namespace internal { - -class AssertHelper; -class DefaultGlobalTestPartResultReporter; -class ExecDeathTest; -class NoExecDeathTest; -class FinalSuccessChecker; -class GTestFlagSaver; -class StreamingListenerTest; -class TestResultAccessor; -class TestEventListenersAccessor; -class TestEventRepeater; -class UnitTestRecordPropertyTestHelper; -class WindowsDeathTest; -class FuchsiaDeathTest; -class UnitTestImpl* GetUnitTestImpl(); -void ReportFailureInUnknownLocation(TestPartResult::Type result_type, - const std::string& message); -std::set<std::string>* GetIgnoredParameterizedTestSuites(); - -} // namespace internal - -// The friend relationship of some of these classes is cyclic. -// If we don't forward declare them the compiler might confuse the classes -// in friendship clauses with same named classes on the scope. -class Test; -class TestSuite; - -// Old API is still available but deprecated -#ifndef GTEST_REMOVE_LEGACY_TEST_CASEAPI_ -using TestCase = TestSuite; -#endif -class TestInfo; -class UnitTest; - -// A class for indicating whether an assertion was successful. When -// the assertion wasn't successful, the AssertionResult object -// remembers a non-empty message that describes how it failed. -// -// To create an instance of this class, use one of the factory functions -// (AssertionSuccess() and AssertionFailure()). -// -// This class is useful for two purposes: -// 1. Defining predicate functions to be used with Boolean test assertions -// EXPECT_TRUE/EXPECT_FALSE and their ASSERT_ counterparts -// 2. Defining predicate-format functions to be -// used with predicate assertions (ASSERT_PRED_FORMAT*, etc). -// -// For example, if you define IsEven predicate: -// -// testing::AssertionResult IsEven(int n) { -// if ((n % 2) == 0) -// return testing::AssertionSuccess(); -// else -// return testing::AssertionFailure() << n << " is odd"; -// } -// -// Then the failed expectation EXPECT_TRUE(IsEven(Fib(5))) -// will print the message -// -// Value of: IsEven(Fib(5)) -// Actual: false (5 is odd) -// Expected: true -// -// instead of a more opaque -// -// Value of: IsEven(Fib(5)) -// Actual: false -// Expected: true -// -// in case IsEven is a simple Boolean predicate. -// -// If you expect your predicate to be reused and want to support informative -// messages in EXPECT_FALSE and ASSERT_FALSE (negative assertions show up -// about half as often as positive ones in our tests), supply messages for -// both success and failure cases: -// -// testing::AssertionResult IsEven(int n) { -// if ((n % 2) == 0) -// return testing::AssertionSuccess() << n << " is even"; -// else -// return testing::AssertionFailure() << n << " is odd"; -// } -// -// Then a statement EXPECT_FALSE(IsEven(Fib(6))) will print -// -// Value of: IsEven(Fib(6)) -// Actual: true (8 is even) -// Expected: false -// -// NB: Predicates that support negative Boolean assertions have reduced -// performance in positive ones so be careful not to use them in tests -// that have lots (tens of thousands) of positive Boolean assertions. -// -// To use this class with EXPECT_PRED_FORMAT assertions such as: -// -// // Verifies that Foo() returns an even number. -// EXPECT_PRED_FORMAT1(IsEven, Foo()); -// -// you need to define: -// -// testing::AssertionResult IsEven(const char* expr, int n) { -// if ((n % 2) == 0) -// return testing::AssertionSuccess(); -// else -// return testing::AssertionFailure() -// << "Expected: " << expr << " is even\n Actual: it's " << n; -// } -// -// If Foo() returns 5, you will see the following message: -// -// Expected: Foo() is even -// Actual: it's 5 -// -class GTEST_API_ AssertionResult { - public: - // Copy constructor. - // Used in EXPECT_TRUE/FALSE(assertion_result). - AssertionResult(const AssertionResult& other); - -// C4800 is a level 3 warning in Visual Studio 2015 and earlier. -// This warning is not emitted in Visual Studio 2017. -// This warning is off by default starting in Visual Studio 2019 but can be -// enabled with command-line options. -#if defined(_MSC_VER) && (_MSC_VER < 1910 || _MSC_VER >= 1920) - GTEST_DISABLE_MSC_WARNINGS_PUSH_(4800 /* forcing value to bool */) -#endif - - // Used in the EXPECT_TRUE/FALSE(bool_expression). - // - // T must be contextually convertible to bool. - // - // The second parameter prevents this overload from being considered if - // the argument is implicitly convertible to AssertionResult. In that case - // we want AssertionResult's copy constructor to be used. - template <typename T> - explicit AssertionResult( - const T& success, - typename std::enable_if< - !std::is_convertible<T, AssertionResult>::value>::type* - /*enabler*/ - = nullptr) - : success_(success) {} - -#if defined(_MSC_VER) && (_MSC_VER < 1910 || _MSC_VER >= 1920) - GTEST_DISABLE_MSC_WARNINGS_POP_() -#endif - - // Assignment operator. - AssertionResult& operator=(AssertionResult other) { - swap(other); - return *this; - } - - // Returns true if and only if the assertion succeeded. - operator bool() const { return success_; } // NOLINT - - // Returns the assertion's negation. Used with EXPECT/ASSERT_FALSE. - AssertionResult operator!() const; - - // Returns the text streamed into this AssertionResult. Test assertions - // use it when they fail (i.e., the predicate's outcome doesn't match the - // assertion's expectation). When nothing has been streamed into the - // object, returns an empty string. - const char* message() const { - return message_.get() != nullptr ? message_->c_str() : ""; - } - // Deprecated; please use message() instead. - const char* failure_message() const { return message(); } - - // Streams a custom failure message into this object. - template <typename T> AssertionResult& operator<<(const T& value) { - AppendMessage(Message() << value); - return *this; - } - - // Allows streaming basic output manipulators such as endl or flush into - // this object. - AssertionResult& operator<<( - ::std::ostream& (*basic_manipulator)(::std::ostream& stream)) { - AppendMessage(Message() << basic_manipulator); - return *this; - } - - private: - // Appends the contents of message to message_. - void AppendMessage(const Message& a_message) { - if (message_.get() == nullptr) message_.reset(new ::std::string); - message_->append(a_message.GetString().c_str()); - } - - // Swap the contents of this AssertionResult with other. - void swap(AssertionResult& other); - - // Stores result of the assertion predicate. - bool success_; - // Stores the message describing the condition in case the expectation - // construct is not satisfied with the predicate's outcome. - // Referenced via a pointer to avoid taking too much stack frame space - // with test assertions. - std::unique_ptr< ::std::string> message_; -}; - -// Makes a successful assertion result. -GTEST_API_ AssertionResult AssertionSuccess(); - -// Makes a failed assertion result. -GTEST_API_ AssertionResult AssertionFailure(); - -// Makes a failed assertion result with the given failure message. -// Deprecated; use AssertionFailure() << msg. -GTEST_API_ AssertionResult AssertionFailure(const Message& msg); - -} // namespace testing - -// Includes the auto-generated header that implements a family of generic -// predicate assertion macros. This include comes late because it relies on -// APIs declared above. -// Copyright 2006, 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. - -// This file is AUTOMATICALLY GENERATED on 01/02/2019 by command -// 'gen_gtest_pred_impl.py 5'. DO NOT EDIT BY HAND! -// -// Implements a family of generic predicate assertion macros. -// GOOGLETEST_CM0001 DO NOT DELETE - -#ifndef GOOGLETEST_INCLUDE_GTEST_GTEST_PRED_IMPL_H_ -#define GOOGLETEST_INCLUDE_GTEST_GTEST_PRED_IMPL_H_ - - -namespace testing { - -// This header implements a family of generic predicate assertion -// macros: -// -// ASSERT_PRED_FORMAT1(pred_format, v1) -// ASSERT_PRED_FORMAT2(pred_format, v1, v2) -// ... -// -// where pred_format is a function or functor that takes n (in the -// case of ASSERT_PRED_FORMATn) values and their source expression -// text, and returns a testing::AssertionResult. See the definition -// of ASSERT_EQ in gtest.h for an example. -// -// If you don't care about formatting, you can use the more -// restrictive version: -// -// ASSERT_PRED1(pred, v1) -// ASSERT_PRED2(pred, v1, v2) -// ... -// -// where pred is an n-ary function or functor that returns bool, -// and the values v1, v2, ..., must support the << operator for -// streaming to std::ostream. -// -// We also define the EXPECT_* variations. -// -// For now we only support predicates whose arity is at most 5. -// Please email [email protected] if you need -// support for higher arities. - -// GTEST_ASSERT_ is the basic statement to which all of the assertions -// in this file reduce. Don't use this in your code. - -#define GTEST_ASSERT_(expression, on_failure) \ - GTEST_AMBIGUOUS_ELSE_BLOCKER_ \ - if (const ::testing::AssertionResult gtest_ar = (expression)) \ - ; \ - else \ - on_failure(gtest_ar.failure_message()) - - -// Helper function for implementing {EXPECT|ASSERT}_PRED1. Don't use -// this in your code. -template <typename Pred, - typename T1> -AssertionResult AssertPred1Helper(const char* pred_text, - const char* e1, - Pred pred, - const T1& v1) { - if (pred(v1)) return AssertionSuccess(); - - return AssertionFailure() - << pred_text << "(" << e1 << ") evaluates to false, where" - << "\n" - << e1 << " evaluates to " << ::testing::PrintToString(v1); -} - -// Internal macro for implementing {EXPECT|ASSERT}_PRED_FORMAT1. -// Don't use this in your code. -#define GTEST_PRED_FORMAT1_(pred_format, v1, on_failure)\ - GTEST_ASSERT_(pred_format(#v1, v1), \ - on_failure) - -// Internal macro for implementing {EXPECT|ASSERT}_PRED1. Don't use -// this in your code. -#define GTEST_PRED1_(pred, v1, on_failure)\ - GTEST_ASSERT_(::testing::AssertPred1Helper(#pred, \ - #v1, \ - pred, \ - v1), on_failure) - -// Unary predicate assertion macros. -#define EXPECT_PRED_FORMAT1(pred_format, v1) \ - GTEST_PRED_FORMAT1_(pred_format, v1, GTEST_NONFATAL_FAILURE_) -#define EXPECT_PRED1(pred, v1) \ - GTEST_PRED1_(pred, v1, GTEST_NONFATAL_FAILURE_) -#define ASSERT_PRED_FORMAT1(pred_format, v1) \ - GTEST_PRED_FORMAT1_(pred_format, v1, GTEST_FATAL_FAILURE_) -#define ASSERT_PRED1(pred, v1) \ - GTEST_PRED1_(pred, v1, GTEST_FATAL_FAILURE_) - - - -// Helper function for implementing {EXPECT|ASSERT}_PRED2. Don't use -// this in your code. -template <typename Pred, - typename T1, - typename T2> -AssertionResult AssertPred2Helper(const char* pred_text, - const char* e1, - const char* e2, - Pred pred, - const T1& v1, - const T2& v2) { - if (pred(v1, v2)) return AssertionSuccess(); - - return AssertionFailure() - << pred_text << "(" << e1 << ", " << e2 - << ") evaluates to false, where" - << "\n" - << e1 << " evaluates to " << ::testing::PrintToString(v1) << "\n" - << e2 << " evaluates to " << ::testing::PrintToString(v2); -} - -// Internal macro for implementing {EXPECT|ASSERT}_PRED_FORMAT2. -// Don't use this in your code. -#define GTEST_PRED_FORMAT2_(pred_format, v1, v2, on_failure)\ - GTEST_ASSERT_(pred_format(#v1, #v2, v1, v2), \ - on_failure) - -// Internal macro for implementing {EXPECT|ASSERT}_PRED2. Don't use -// this in your code. -#define GTEST_PRED2_(pred, v1, v2, on_failure)\ - GTEST_ASSERT_(::testing::AssertPred2Helper(#pred, \ - #v1, \ - #v2, \ - pred, \ - v1, \ - v2), on_failure) - -// Binary predicate assertion macros. -#define EXPECT_PRED_FORMAT2(pred_format, v1, v2) \ - GTEST_PRED_FORMAT2_(pred_format, v1, v2, GTEST_NONFATAL_FAILURE_) -#define EXPECT_PRED2(pred, v1, v2) \ - GTEST_PRED2_(pred, v1, v2, GTEST_NONFATAL_FAILURE_) -#define ASSERT_PRED_FORMAT2(pred_format, v1, v2) \ - GTEST_PRED_FORMAT2_(pred_format, v1, v2, GTEST_FATAL_FAILURE_) -#define ASSERT_PRED2(pred, v1, v2) \ - GTEST_PRED2_(pred, v1, v2, GTEST_FATAL_FAILURE_) - - - -// Helper function for implementing {EXPECT|ASSERT}_PRED3. Don't use -// this in your code. -template <typename Pred, - typename T1, - typename T2, - typename T3> -AssertionResult AssertPred3Helper(const char* pred_text, - const char* e1, - const char* e2, - const char* e3, - Pred pred, - const T1& v1, - const T2& v2, - const T3& v3) { - if (pred(v1, v2, v3)) return AssertionSuccess(); - - return AssertionFailure() - << pred_text << "(" << e1 << ", " << e2 << ", " << e3 - << ") evaluates to false, where" - << "\n" - << e1 << " evaluates to " << ::testing::PrintToString(v1) << "\n" - << e2 << " evaluates to " << ::testing::PrintToString(v2) << "\n" - << e3 << " evaluates to " << ::testing::PrintToString(v3); -} - -// Internal macro for implementing {EXPECT|ASSERT}_PRED_FORMAT3. -// Don't use this in your code. -#define GTEST_PRED_FORMAT3_(pred_format, v1, v2, v3, on_failure)\ - GTEST_ASSERT_(pred_format(#v1, #v2, #v3, v1, v2, v3), \ - on_failure) - -// Internal macro for implementing {EXPECT|ASSERT}_PRED3. Don't use -// this in your code. -#define GTEST_PRED3_(pred, v1, v2, v3, on_failure)\ - GTEST_ASSERT_(::testing::AssertPred3Helper(#pred, \ - #v1, \ - #v2, \ - #v3, \ - pred, \ - v1, \ - v2, \ - v3), on_failure) - -// Ternary predicate assertion macros. -#define EXPECT_PRED_FORMAT3(pred_format, v1, v2, v3) \ - GTEST_PRED_FORMAT3_(pred_format, v1, v2, v3, GTEST_NONFATAL_FAILURE_) -#define EXPECT_PRED3(pred, v1, v2, v3) \ - GTEST_PRED3_(pred, v1, v2, v3, GTEST_NONFATAL_FAILURE_) -#define ASSERT_PRED_FORMAT3(pred_format, v1, v2, v3) \ - GTEST_PRED_FORMAT3_(pred_format, v1, v2, v3, GTEST_FATAL_FAILURE_) -#define ASSERT_PRED3(pred, v1, v2, v3) \ - GTEST_PRED3_(pred, v1, v2, v3, GTEST_FATAL_FAILURE_) - - - -// Helper function for implementing {EXPECT|ASSERT}_PRED4. Don't use -// this in your code. -template <typename Pred, - typename T1, - typename T2, - typename T3, - typename T4> -AssertionResult AssertPred4Helper(const char* pred_text, - const char* e1, - const char* e2, - const char* e3, - const char* e4, - Pred pred, - const T1& v1, - const T2& v2, - const T3& v3, - const T4& v4) { - if (pred(v1, v2, v3, v4)) return AssertionSuccess(); - - return AssertionFailure() - << pred_text << "(" << e1 << ", " << e2 << ", " << e3 << ", " << e4 - << ") evaluates to false, where" - << "\n" - << e1 << " evaluates to " << ::testing::PrintToString(v1) << "\n" - << e2 << " evaluates to " << ::testing::PrintToString(v2) << "\n" - << e3 << " evaluates to " << ::testing::PrintToString(v3) << "\n" - << e4 << " evaluates to " << ::testing::PrintToString(v4); -} - -// Internal macro for implementing {EXPECT|ASSERT}_PRED_FORMAT4. -// Don't use this in your code. -#define GTEST_PRED_FORMAT4_(pred_format, v1, v2, v3, v4, on_failure)\ - GTEST_ASSERT_(pred_format(#v1, #v2, #v3, #v4, v1, v2, v3, v4), \ - on_failure) - -// Internal macro for implementing {EXPECT|ASSERT}_PRED4. Don't use -// this in your code. -#define GTEST_PRED4_(pred, v1, v2, v3, v4, on_failure)\ - GTEST_ASSERT_(::testing::AssertPred4Helper(#pred, \ - #v1, \ - #v2, \ - #v3, \ - #v4, \ - pred, \ - v1, \ - v2, \ - v3, \ - v4), on_failure) - -// 4-ary predicate assertion macros. -#define EXPECT_PRED_FORMAT4(pred_format, v1, v2, v3, v4) \ - GTEST_PRED_FORMAT4_(pred_format, v1, v2, v3, v4, GTEST_NONFATAL_FAILURE_) -#define EXPECT_PRED4(pred, v1, v2, v3, v4) \ - GTEST_PRED4_(pred, v1, v2, v3, v4, GTEST_NONFATAL_FAILURE_) -#define ASSERT_PRED_FORMAT4(pred_format, v1, v2, v3, v4) \ - GTEST_PRED_FORMAT4_(pred_format, v1, v2, v3, v4, GTEST_FATAL_FAILURE_) -#define ASSERT_PRED4(pred, v1, v2, v3, v4) \ - GTEST_PRED4_(pred, v1, v2, v3, v4, GTEST_FATAL_FAILURE_) - - - -// Helper function for implementing {EXPECT|ASSERT}_PRED5. Don't use -// this in your code. -template <typename Pred, - typename T1, - typename T2, - typename T3, - typename T4, - typename T5> -AssertionResult AssertPred5Helper(const char* pred_text, - const char* e1, - const char* e2, - const char* e3, - const char* e4, - const char* e5, - Pred pred, - const T1& v1, - const T2& v2, - const T3& v3, - const T4& v4, - const T5& v5) { - if (pred(v1, v2, v3, v4, v5)) return AssertionSuccess(); - - return AssertionFailure() - << pred_text << "(" << e1 << ", " << e2 << ", " << e3 << ", " << e4 - << ", " << e5 << ") evaluates to false, where" - << "\n" - << e1 << " evaluates to " << ::testing::PrintToString(v1) << "\n" - << e2 << " evaluates to " << ::testing::PrintToString(v2) << "\n" - << e3 << " evaluates to " << ::testing::PrintToString(v3) << "\n" - << e4 << " evaluates to " << ::testing::PrintToString(v4) << "\n" - << e5 << " evaluates to " << ::testing::PrintToString(v5); -} - -// Internal macro for implementing {EXPECT|ASSERT}_PRED_FORMAT5. -// Don't use this in your code. -#define GTEST_PRED_FORMAT5_(pred_format, v1, v2, v3, v4, v5, on_failure)\ - GTEST_ASSERT_(pred_format(#v1, #v2, #v3, #v4, #v5, v1, v2, v3, v4, v5), \ - on_failure) - -// Internal macro for implementing {EXPECT|ASSERT}_PRED5. Don't use -// this in your code. -#define GTEST_PRED5_(pred, v1, v2, v3, v4, v5, on_failure)\ - GTEST_ASSERT_(::testing::AssertPred5Helper(#pred, \ - #v1, \ - #v2, \ - #v3, \ - #v4, \ - #v5, \ - pred, \ - v1, \ - v2, \ - v3, \ - v4, \ - v5), on_failure) - -// 5-ary predicate assertion macros. -#define EXPECT_PRED_FORMAT5(pred_format, v1, v2, v3, v4, v5) \ - GTEST_PRED_FORMAT5_(pred_format, v1, v2, v3, v4, v5, GTEST_NONFATAL_FAILURE_) -#define EXPECT_PRED5(pred, v1, v2, v3, v4, v5) \ - GTEST_PRED5_(pred, v1, v2, v3, v4, v5, GTEST_NONFATAL_FAILURE_) -#define ASSERT_PRED_FORMAT5(pred_format, v1, v2, v3, v4, v5) \ - GTEST_PRED_FORMAT5_(pred_format, v1, v2, v3, v4, v5, GTEST_FATAL_FAILURE_) -#define ASSERT_PRED5(pred, v1, v2, v3, v4, v5) \ - GTEST_PRED5_(pred, v1, v2, v3, v4, v5, GTEST_FATAL_FAILURE_) - - - -} // namespace testing - -#endif // GOOGLETEST_INCLUDE_GTEST_GTEST_PRED_IMPL_H_ - -namespace testing { - -// The abstract class that all tests inherit from. -// -// In Google Test, a unit test program contains one or many TestSuites, and -// each TestSuite contains one or many Tests. -// -// When you define a test using the TEST macro, you don't need to -// explicitly derive from Test - the TEST macro automatically does -// this for you. -// -// The only time you derive from Test is when defining a test fixture -// to be used in a TEST_F. For example: -// -// class FooTest : public testing::Test { -// protected: -// void SetUp() override { ... } -// void TearDown() override { ... } -// ... -// }; -// -// TEST_F(FooTest, Bar) { ... } -// TEST_F(FooTest, Baz) { ... } -// -// Test is not copyable. -class GTEST_API_ Test { - public: - friend class TestInfo; - - // The d'tor is virtual as we intend to inherit from Test. - virtual ~Test(); - - // Sets up the stuff shared by all tests in this test suite. - // - // Google Test will call Foo::SetUpTestSuite() before running the first - // test in test suite Foo. Hence a sub-class can define its own - // SetUpTestSuite() method to shadow the one defined in the super - // class. - static void SetUpTestSuite() {} - - // Tears down the stuff shared by all tests in this test suite. - // - // Google Test will call Foo::TearDownTestSuite() after running the last - // test in test suite Foo. Hence a sub-class can define its own - // TearDownTestSuite() method to shadow the one defined in the super - // class. - static void TearDownTestSuite() {} - - // Legacy API is deprecated but still available. Use SetUpTestSuite and - // TearDownTestSuite instead. -#ifndef GTEST_REMOVE_LEGACY_TEST_CASEAPI_ - static void TearDownTestCase() {} - static void SetUpTestCase() {} -#endif // GTEST_REMOVE_LEGACY_TEST_CASEAPI_ - - // Returns true if and only if the current test has a fatal failure. - static bool HasFatalFailure(); - - // Returns true if and only if the current test has a non-fatal failure. - static bool HasNonfatalFailure(); - - // Returns true if and only if the current test was skipped. - static bool IsSkipped(); - - // Returns true if and only if the current test has a (either fatal or - // non-fatal) failure. - static bool HasFailure() { return HasFatalFailure() || HasNonfatalFailure(); } - - // Logs a property for the current test, test suite, or for the entire - // invocation of the test program when used outside of the context of a - // test suite. Only the last value for a given key is remembered. These - // are public static so they can be called from utility functions that are - // not members of the test fixture. Calls to RecordProperty made during - // lifespan of the test (from the moment its constructor starts to the - // moment its destructor finishes) will be output in XML as attributes of - // the <testcase> element. Properties recorded from fixture's - // SetUpTestSuite or TearDownTestSuite are logged as attributes of the - // corresponding <testsuite> element. Calls to RecordProperty made in the - // global context (before or after invocation of RUN_ALL_TESTS and from - // SetUp/TearDown method of Environment objects registered with Google - // Test) will be output as attributes of the <testsuites> element. - static void RecordProperty(const std::string& key, const std::string& value); - static void RecordProperty(const std::string& key, int value); - - protected: - // Creates a Test object. - Test(); - - // Sets up the test fixture. - virtual void SetUp(); - - // Tears down the test fixture. - virtual void TearDown(); - - private: - // Returns true if and only if the current test has the same fixture class - // as the first test in the current test suite. - static bool HasSameFixtureClass(); - - // Runs the test after the test fixture has been set up. - // - // A sub-class must implement this to define the test logic. - // - // DO NOT OVERRIDE THIS FUNCTION DIRECTLY IN A USER PROGRAM. - // Instead, use the TEST or TEST_F macro. - virtual void TestBody() = 0; - - // Sets up, executes, and tears down the test. - void Run(); - - // Deletes self. We deliberately pick an unusual name for this - // internal method to avoid clashing with names used in user TESTs. - void DeleteSelf_() { delete this; } - - const std::unique_ptr<GTEST_FLAG_SAVER_> gtest_flag_saver_; - - // Often a user misspells SetUp() as Setup() and spends a long time - // wondering why it is never called by Google Test. The declaration of - // the following method is solely for catching such an error at - // compile time: - // - // - The return type is deliberately chosen to be not void, so it - // will be a conflict if void Setup() is declared in the user's - // test fixture. - // - // - This method is private, so it will be another compiler error - // if the method is called from the user's test fixture. - // - // DO NOT OVERRIDE THIS FUNCTION. - // - // If you see an error about overriding the following function or - // about it being private, you have mis-spelled SetUp() as Setup(). - struct Setup_should_be_spelled_SetUp {}; - virtual Setup_should_be_spelled_SetUp* Setup() { return nullptr; } - - // We disallow copying Tests. - GTEST_DISALLOW_COPY_AND_ASSIGN_(Test); -}; - -typedef internal::TimeInMillis TimeInMillis; - -// A copyable object representing a user specified test property which can be -// output as a key/value string pair. -// -// Don't inherit from TestProperty as its destructor is not virtual. -class TestProperty { - public: - // C'tor. TestProperty does NOT have a default constructor. - // Always use this constructor (with parameters) to create a - // TestProperty object. - TestProperty(const std::string& a_key, const std::string& a_value) : - key_(a_key), value_(a_value) { - } - - // Gets the user supplied key. - const char* key() const { - return key_.c_str(); - } - - // Gets the user supplied value. - const char* value() const { - return value_.c_str(); - } - - // Sets a new value, overriding the one supplied in the constructor. - void SetValue(const std::string& new_value) { - value_ = new_value; - } - - private: - // The key supplied by the user. - std::string key_; - // The value supplied by the user. - std::string value_; -}; - -// The result of a single Test. This includes a list of -// TestPartResults, a list of TestProperties, a count of how many -// death tests there are in the Test, and how much time it took to run -// the Test. -// -// TestResult is not copyable. -class GTEST_API_ TestResult { - public: - // Creates an empty TestResult. - TestResult(); - - // D'tor. Do not inherit from TestResult. - ~TestResult(); - - // Gets the number of all test parts. This is the sum of the number - // of successful test parts and the number of failed test parts. - int total_part_count() const; - - // Returns the number of the test properties. - int test_property_count() const; - - // Returns true if and only if the test passed (i.e. no test part failed). - bool Passed() const { return !Skipped() && !Failed(); } - - // Returns true if and only if the test was skipped. - bool Skipped() const; - - // Returns true if and only if the test failed. - bool Failed() const; - - // Returns true if and only if the test fatally failed. - bool HasFatalFailure() const; - - // Returns true if and only if the test has a non-fatal failure. - bool HasNonfatalFailure() const; - - // Returns the elapsed time, in milliseconds. - TimeInMillis elapsed_time() const { return elapsed_time_; } - - // Gets the time of the test case start, in ms from the start of the - // UNIX epoch. - TimeInMillis start_timestamp() const { return start_timestamp_; } - - // Returns the i-th test part result among all the results. i can range from 0 - // to total_part_count() - 1. If i is not in that range, aborts the program. - const TestPartResult& GetTestPartResult(int i) const; - - // Returns the i-th test property. i can range from 0 to - // test_property_count() - 1. If i is not in that range, aborts the - // program. - const TestProperty& GetTestProperty(int i) const; - - private: - friend class TestInfo; - friend class TestSuite; - friend class UnitTest; - friend class internal::DefaultGlobalTestPartResultReporter; - friend class internal::ExecDeathTest; - friend class internal::TestResultAccessor; - friend class internal::UnitTestImpl; - friend class internal::WindowsDeathTest; - friend class internal::FuchsiaDeathTest; - - // Gets the vector of TestPartResults. - const std::vector<TestPartResult>& test_part_results() const { - return test_part_results_; - } - - // Gets the vector of TestProperties. - const std::vector<TestProperty>& test_properties() const { - return test_properties_; - } - - // Sets the start time. - void set_start_timestamp(TimeInMillis start) { start_timestamp_ = start; } - - // Sets the elapsed time. - void set_elapsed_time(TimeInMillis elapsed) { elapsed_time_ = elapsed; } - - // Adds a test property to the list. The property is validated and may add - // a non-fatal failure if invalid (e.g., if it conflicts with reserved - // key names). If a property is already recorded for the same key, the - // value will be updated, rather than storing multiple values for the same - // key. xml_element specifies the element for which the property is being - // recorded and is used for validation. - void RecordProperty(const std::string& xml_element, - const TestProperty& test_property); - - // Adds a failure if the key is a reserved attribute of Google Test - // testsuite tags. Returns true if the property is valid. - // FIXME: Validate attribute names are legal and human readable. - static bool ValidateTestProperty(const std::string& xml_element, - const TestProperty& test_property); - - // Adds a test part result to the list. - void AddTestPartResult(const TestPartResult& test_part_result); - - // Returns the death test count. - int death_test_count() const { return death_test_count_; } - - // Increments the death test count, returning the new count. - int increment_death_test_count() { return ++death_test_count_; } - - // Clears the test part results. - void ClearTestPartResults(); - - // Clears the object. - void Clear(); - - // Protects mutable state of the property vector and of owned - // properties, whose values may be updated. - internal::Mutex test_properties_mutex_; - - // The vector of TestPartResults - std::vector<TestPartResult> test_part_results_; - // The vector of TestProperties - std::vector<TestProperty> test_properties_; - // Running count of death tests. - int death_test_count_; - // The start time, in milliseconds since UNIX Epoch. - TimeInMillis start_timestamp_; - // The elapsed time, in milliseconds. - TimeInMillis elapsed_time_; - - // We disallow copying TestResult. - GTEST_DISALLOW_COPY_AND_ASSIGN_(TestResult); -}; // class TestResult - -// A TestInfo object stores the following information about a test: -// -// Test suite name -// Test name -// Whether the test should be run -// A function pointer that creates the test object when invoked -// Test result -// -// The constructor of TestInfo registers itself with the UnitTest -// singleton such that the RUN_ALL_TESTS() macro knows which tests to -// run. -class GTEST_API_ TestInfo { - public: - // Destructs a TestInfo object. This function is not virtual, so - // don't inherit from TestInfo. - ~TestInfo(); - - // Returns the test suite name. - const char* test_suite_name() const { return test_suite_name_.c_str(); } - -// Legacy API is deprecated but still available -#ifndef GTEST_REMOVE_LEGACY_TEST_CASEAPI_ - const char* test_case_name() const { return test_suite_name(); } -#endif // GTEST_REMOVE_LEGACY_TEST_CASEAPI_ - - // Returns the test name. - const char* name() const { return name_.c_str(); } - - // Returns the name of the parameter type, or NULL if this is not a typed - // or a type-parameterized test. - const char* type_param() const { - if (type_param_.get() != nullptr) return type_param_->c_str(); - return nullptr; - } - - // Returns the text representation of the value parameter, or NULL if this - // is not a value-parameterized test. - const char* value_param() const { - if (value_param_.get() != nullptr) return value_param_->c_str(); - return nullptr; - } - - // Returns the file name where this test is defined. - const char* file() const { return location_.file.c_str(); } - - // Returns the line where this test is defined. - int line() const { return location_.line; } - - // Return true if this test should not be run because it's in another shard. - bool is_in_another_shard() const { return is_in_another_shard_; } - - // Returns true if this test should run, that is if the test is not - // disabled (or it is disabled but the also_run_disabled_tests flag has - // been specified) and its full name matches the user-specified filter. - // - // Google Test allows the user to filter the tests by their full names. - // The full name of a test Bar in test suite Foo is defined as - // "Foo.Bar". Only the tests that match the filter will run. - // - // A filter is a colon-separated list of glob (not regex) patterns, - // optionally followed by a '-' and a colon-separated list of - // negative patterns (tests to exclude). A test is run if it - // matches one of the positive patterns and does not match any of - // the negative patterns. - // - // For example, *A*:Foo.* is a filter that matches any string that - // contains the character 'A' or starts with "Foo.". - bool should_run() const { return should_run_; } - - // Returns true if and only if this test will appear in the XML report. - bool is_reportable() const { - // The XML report includes tests matching the filter, excluding those - // run in other shards. - return matches_filter_ && !is_in_another_shard_; - } - - // Returns the result of the test. - const TestResult* result() const { return &result_; } - - private: -#if GTEST_HAS_DEATH_TEST - friend class internal::DefaultDeathTestFactory; -#endif // GTEST_HAS_DEATH_TEST - friend class Test; - friend class TestSuite; - friend class internal::UnitTestImpl; - friend class internal::StreamingListenerTest; - friend TestInfo* internal::MakeAndRegisterTestInfo( - const char* test_suite_name, const char* name, const char* type_param, - const char* value_param, internal::CodeLocation code_location, - internal::TypeId fixture_class_id, internal::SetUpTestSuiteFunc set_up_tc, - internal::TearDownTestSuiteFunc tear_down_tc, - internal::TestFactoryBase* factory); - - // Constructs a TestInfo object. The newly constructed instance assumes - // ownership of the factory object. - TestInfo(const std::string& test_suite_name, const std::string& name, - const char* a_type_param, // NULL if not a type-parameterized test - const char* a_value_param, // NULL if not a value-parameterized test - internal::CodeLocation a_code_location, - internal::TypeId fixture_class_id, - internal::TestFactoryBase* factory); - - // Increments the number of death tests encountered in this test so - // far. - int increment_death_test_count() { - return result_.increment_death_test_count(); - } - - // Creates the test object, runs it, records its result, and then - // deletes it. - void Run(); - - // Skip and records the test result for this object. - void Skip(); - - static void ClearTestResult(TestInfo* test_info) { - test_info->result_.Clear(); - } - - // These fields are immutable properties of the test. - const std::string test_suite_name_; // test suite name - const std::string name_; // Test name - // Name of the parameter type, or NULL if this is not a typed or a - // type-parameterized test. - const std::unique_ptr<const ::std::string> type_param_; - // Text representation of the value parameter, or NULL if this is not a - // value-parameterized test. - const std::unique_ptr<const ::std::string> value_param_; - internal::CodeLocation location_; - const internal::TypeId fixture_class_id_; // ID of the test fixture class - bool should_run_; // True if and only if this test should run - bool is_disabled_; // True if and only if this test is disabled - bool matches_filter_; // True if this test matches the - // user-specified filter. - bool is_in_another_shard_; // Will be run in another shard. - internal::TestFactoryBase* const factory_; // The factory that creates - // the test object - - // This field is mutable and needs to be reset before running the - // test for the second time. - TestResult result_; - - GTEST_DISALLOW_COPY_AND_ASSIGN_(TestInfo); -}; - -// A test suite, which consists of a vector of TestInfos. -// -// TestSuite is not copyable. -class GTEST_API_ TestSuite { - public: - // Creates a TestSuite with the given name. - // - // TestSuite does NOT have a default constructor. Always use this - // constructor to create a TestSuite object. - // - // Arguments: - // - // name: name of the test suite - // a_type_param: the name of the test's type parameter, or NULL if - // this is not a type-parameterized test. - // set_up_tc: pointer to the function that sets up the test suite - // tear_down_tc: pointer to the function that tears down the test suite - TestSuite(const char* name, const char* a_type_param, - internal::SetUpTestSuiteFunc set_up_tc, - internal::TearDownTestSuiteFunc tear_down_tc); - - // Destructor of TestSuite. - virtual ~TestSuite(); - - // Gets the name of the TestSuite. - const char* name() const { return name_.c_str(); } - - // Returns the name of the parameter type, or NULL if this is not a - // type-parameterized test suite. - const char* type_param() const { - if (type_param_.get() != nullptr) return type_param_->c_str(); - return nullptr; - } - - // Returns true if any test in this test suite should run. - bool should_run() const { return should_run_; } - - // Gets the number of successful tests in this test suite. - int successful_test_count() const; - - // Gets the number of skipped tests in this test suite. - int skipped_test_count() const; - - // Gets the number of failed tests in this test suite. - int failed_test_count() const; - - // Gets the number of disabled tests that will be reported in the XML report. - int reportable_disabled_test_count() const; - - // Gets the number of disabled tests in this test suite. - int disabled_test_count() const; - - // Gets the number of tests to be printed in the XML report. - int reportable_test_count() const; - - // Get the number of tests in this test suite that should run. - int test_to_run_count() const; - - // Gets the number of all tests in this test suite. - int total_test_count() const; - - // Returns true if and only if the test suite passed. - bool Passed() const { return !Failed(); } - - // Returns true if and only if the test suite failed. - bool Failed() const { - return failed_test_count() > 0 || ad_hoc_test_result().Failed(); - } - - // Returns the elapsed time, in milliseconds. - TimeInMillis elapsed_time() const { return elapsed_time_; } - - // Gets the time of the test suite start, in ms from the start of the - // UNIX epoch. - TimeInMillis start_timestamp() const { return start_timestamp_; } - - // Returns the i-th test among all the tests. i can range from 0 to - // total_test_count() - 1. If i is not in that range, returns NULL. - const TestInfo* GetTestInfo(int i) const; - - // Returns the TestResult that holds test properties recorded during - // execution of SetUpTestSuite and TearDownTestSuite. - const TestResult& ad_hoc_test_result() const { return ad_hoc_test_result_; } - - private: - friend class Test; - friend class internal::UnitTestImpl; - - // Gets the (mutable) vector of TestInfos in this TestSuite. - std::vector<TestInfo*>& test_info_list() { return test_info_list_; } - - // Gets the (immutable) vector of TestInfos in this TestSuite. - const std::vector<TestInfo*>& test_info_list() const { - return test_info_list_; - } - - // Returns the i-th test among all the tests. i can range from 0 to - // total_test_count() - 1. If i is not in that range, returns NULL. - TestInfo* GetMutableTestInfo(int i); - - // Sets the should_run member. - void set_should_run(bool should) { should_run_ = should; } - - // Adds a TestInfo to this test suite. Will delete the TestInfo upon - // destruction of the TestSuite object. - void AddTestInfo(TestInfo * test_info); - - // Clears the results of all tests in this test suite. - void ClearResult(); - - // Clears the results of all tests in the given test suite. - static void ClearTestSuiteResult(TestSuite* test_suite) { - test_suite->ClearResult(); - } - - // Runs every test in this TestSuite. - void Run(); - - // Skips the execution of tests under this TestSuite - void Skip(); - - // Runs SetUpTestSuite() for this TestSuite. This wrapper is needed - // for catching exceptions thrown from SetUpTestSuite(). - void RunSetUpTestSuite() { - if (set_up_tc_ != nullptr) { - (*set_up_tc_)(); - } - } - - // Runs TearDownTestSuite() for this TestSuite. This wrapper is - // needed for catching exceptions thrown from TearDownTestSuite(). - void RunTearDownTestSuite() { - if (tear_down_tc_ != nullptr) { - (*tear_down_tc_)(); - } - } - - // Returns true if and only if test passed. - static bool TestPassed(const TestInfo* test_info) { - return test_info->should_run() && test_info->result()->Passed(); - } - - // Returns true if and only if test skipped. - static bool TestSkipped(const TestInfo* test_info) { - return test_info->should_run() && test_info->result()->Skipped(); - } - - // Returns true if and only if test failed. - static bool TestFailed(const TestInfo* test_info) { - return test_info->should_run() && test_info->result()->Failed(); - } - - // Returns true if and only if the test is disabled and will be reported in - // the XML report. - static bool TestReportableDisabled(const TestInfo* test_info) { - return test_info->is_reportable() && test_info->is_disabled_; - } - - // Returns true if and only if test is disabled. - static bool TestDisabled(const TestInfo* test_info) { - return test_info->is_disabled_; - } - - // Returns true if and only if this test will appear in the XML report. - static bool TestReportable(const TestInfo* test_info) { - return test_info->is_reportable(); - } - - // Returns true if the given test should run. - static bool ShouldRunTest(const TestInfo* test_info) { - return test_info->should_run(); - } - - // Shuffles the tests in this test suite. - void ShuffleTests(internal::Random* random); - - // Restores the test order to before the first shuffle. - void UnshuffleTests(); - - // Name of the test suite. - std::string name_; - // Name of the parameter type, or NULL if this is not a typed or a - // type-parameterized test. - const std::unique_ptr<const ::std::string> type_param_; - // The vector of TestInfos in their original order. It owns the - // elements in the vector. - std::vector<TestInfo*> test_info_list_; - // Provides a level of indirection for the test list to allow easy - // shuffling and restoring the test order. The i-th element in this - // vector is the index of the i-th test in the shuffled test list. - std::vector<int> test_indices_; - // Pointer to the function that sets up the test suite. - internal::SetUpTestSuiteFunc set_up_tc_; - // Pointer to the function that tears down the test suite. - internal::TearDownTestSuiteFunc tear_down_tc_; - // True if and only if any test in this test suite should run. - bool should_run_; - // The start time, in milliseconds since UNIX Epoch. - TimeInMillis start_timestamp_; - // Elapsed time, in milliseconds. - TimeInMillis elapsed_time_; - // Holds test properties recorded during execution of SetUpTestSuite and - // TearDownTestSuite. - TestResult ad_hoc_test_result_; - - // We disallow copying TestSuites. - GTEST_DISALLOW_COPY_AND_ASSIGN_(TestSuite); -}; - -// An Environment object is capable of setting up and tearing down an -// environment. You should subclass this to define your own -// environment(s). -// -// An Environment object does the set-up and tear-down in virtual -// methods SetUp() and TearDown() instead of the constructor and the -// destructor, as: -// -// 1. You cannot safely throw from a destructor. This is a problem -// as in some cases Google Test is used where exceptions are enabled, and -// we may want to implement ASSERT_* using exceptions where they are -// available. -// 2. You cannot use ASSERT_* directly in a constructor or -// destructor. -class Environment { - public: - // The d'tor is virtual as we need to subclass Environment. - virtual ~Environment() {} - - // Override this to define how to set up the environment. - virtual void SetUp() {} - - // Override this to define how to tear down the environment. - virtual void TearDown() {} - private: - // If you see an error about overriding the following function or - // about it being private, you have mis-spelled SetUp() as Setup(). - struct Setup_should_be_spelled_SetUp {}; - virtual Setup_should_be_spelled_SetUp* Setup() { return nullptr; } -}; - -#if GTEST_HAS_EXCEPTIONS - -// Exception which can be thrown from TestEventListener::OnTestPartResult. -class GTEST_API_ AssertionException - : public internal::GoogleTestFailureException { - public: - explicit AssertionException(const TestPartResult& result) - : GoogleTestFailureException(result) {} -}; - -#endif // GTEST_HAS_EXCEPTIONS - -// The interface for tracing execution of tests. The methods are organized in -// the order the corresponding events are fired. -class TestEventListener { - public: - virtual ~TestEventListener() {} - - // Fired before any test activity starts. - virtual void OnTestProgramStart(const UnitTest& unit_test) = 0; - - // Fired before each iteration of tests starts. There may be more than - // one iteration if GTEST_FLAG(repeat) is set. iteration is the iteration - // index, starting from 0. - virtual void OnTestIterationStart(const UnitTest& unit_test, - int iteration) = 0; - - // Fired before environment set-up for each iteration of tests starts. - virtual void OnEnvironmentsSetUpStart(const UnitTest& unit_test) = 0; - - // Fired after environment set-up for each iteration of tests ends. - virtual void OnEnvironmentsSetUpEnd(const UnitTest& unit_test) = 0; - - // Fired before the test suite starts. - virtual void OnTestSuiteStart(const TestSuite& /*test_suite*/) {} - - // Legacy API is deprecated but still available -#ifndef GTEST_REMOVE_LEGACY_TEST_CASEAPI_ - virtual void OnTestCaseStart(const TestCase& /*test_case*/) {} -#endif // GTEST_REMOVE_LEGACY_TEST_CASEAPI_ - - // Fired before the test starts. - virtual void OnTestStart(const TestInfo& test_info) = 0; - - // Fired after a failed assertion or a SUCCEED() invocation. - // If you want to throw an exception from this function to skip to the next - // TEST, it must be AssertionException defined above, or inherited from it. - virtual void OnTestPartResult(const TestPartResult& test_part_result) = 0; - - // Fired after the test ends. - virtual void OnTestEnd(const TestInfo& test_info) = 0; - - // Fired after the test suite ends. - virtual void OnTestSuiteEnd(const TestSuite& /*test_suite*/) {} - -// Legacy API is deprecated but still available -#ifndef GTEST_REMOVE_LEGACY_TEST_CASEAPI_ - virtual void OnTestCaseEnd(const TestCase& /*test_case*/) {} -#endif // GTEST_REMOVE_LEGACY_TEST_CASEAPI_ - - // Fired before environment tear-down for each iteration of tests starts. - virtual void OnEnvironmentsTearDownStart(const UnitTest& unit_test) = 0; - - // Fired after environment tear-down for each iteration of tests ends. - virtual void OnEnvironmentsTearDownEnd(const UnitTest& unit_test) = 0; - - // Fired after each iteration of tests finishes. - virtual void OnTestIterationEnd(const UnitTest& unit_test, - int iteration) = 0; - - // Fired after all test activities have ended. - virtual void OnTestProgramEnd(const UnitTest& unit_test) = 0; -}; - -// The convenience class for users who need to override just one or two -// methods and are not concerned that a possible change to a signature of -// the methods they override will not be caught during the build. For -// comments about each method please see the definition of TestEventListener -// above. -class EmptyTestEventListener : public TestEventListener { - public: - void OnTestProgramStart(const UnitTest& /*unit_test*/) override {} - void OnTestIterationStart(const UnitTest& /*unit_test*/, - int /*iteration*/) override {} - void OnEnvironmentsSetUpStart(const UnitTest& /*unit_test*/) override {} - void OnEnvironmentsSetUpEnd(const UnitTest& /*unit_test*/) override {} - void OnTestSuiteStart(const TestSuite& /*test_suite*/) override {} -// Legacy API is deprecated but still available -#ifndef GTEST_REMOVE_LEGACY_TEST_CASEAPI_ - void OnTestCaseStart(const TestCase& /*test_case*/) override {} -#endif // GTEST_REMOVE_LEGACY_TEST_CASEAPI_ - - void OnTestStart(const TestInfo& /*test_info*/) override {} - void OnTestPartResult(const TestPartResult& /*test_part_result*/) override {} - void OnTestEnd(const TestInfo& /*test_info*/) override {} - void OnTestSuiteEnd(const TestSuite& /*test_suite*/) override {} -#ifndef GTEST_REMOVE_LEGACY_TEST_CASEAPI_ - void OnTestCaseEnd(const TestCase& /*test_case*/) override {} -#endif // GTEST_REMOVE_LEGACY_TEST_CASEAPI_ - - void OnEnvironmentsTearDownStart(const UnitTest& /*unit_test*/) override {} - void OnEnvironmentsTearDownEnd(const UnitTest& /*unit_test*/) override {} - void OnTestIterationEnd(const UnitTest& /*unit_test*/, - int /*iteration*/) override {} - void OnTestProgramEnd(const UnitTest& /*unit_test*/) override {} -}; - -// TestEventListeners lets users add listeners to track events in Google Test. -class GTEST_API_ TestEventListeners { - public: - TestEventListeners(); - ~TestEventListeners(); - - // Appends an event listener to the end of the list. Google Test assumes - // the ownership of the listener (i.e. it will delete the listener when - // the test program finishes). - void Append(TestEventListener* listener); - - // Removes the given event listener from the list and returns it. It then - // becomes the caller's responsibility to delete the listener. Returns - // NULL if the listener is not found in the list. - TestEventListener* Release(TestEventListener* listener); - - // Returns the standard listener responsible for the default console - // output. Can be removed from the listeners list to shut down default - // console output. Note that removing this object from the listener list - // with Release transfers its ownership to the caller and makes this - // function return NULL the next time. - TestEventListener* default_result_printer() const { - return default_result_printer_; - } - - // Returns the standard listener responsible for the default XML output - // controlled by the --gtest_output=xml flag. Can be removed from the - // listeners list by users who want to shut down the default XML output - // controlled by this flag and substitute it with custom one. Note that - // removing this object from the listener list with Release transfers its - // ownership to the caller and makes this function return NULL the next - // time. - TestEventListener* default_xml_generator() const { - return default_xml_generator_; - } - - private: - friend class TestSuite; - friend class TestInfo; - friend class internal::DefaultGlobalTestPartResultReporter; - friend class internal::NoExecDeathTest; - friend class internal::TestEventListenersAccessor; - friend class internal::UnitTestImpl; - - // Returns repeater that broadcasts the TestEventListener events to all - // subscribers. - TestEventListener* repeater(); - - // Sets the default_result_printer attribute to the provided listener. - // The listener is also added to the listener list and previous - // default_result_printer is removed from it and deleted. The listener can - // also be NULL in which case it will not be added to the list. Does - // nothing if the previous and the current listener objects are the same. - void SetDefaultResultPrinter(TestEventListener* listener); - - // Sets the default_xml_generator attribute to the provided listener. The - // listener is also added to the listener list and previous - // default_xml_generator is removed from it and deleted. The listener can - // also be NULL in which case it will not be added to the list. Does - // nothing if the previous and the current listener objects are the same. - void SetDefaultXmlGenerator(TestEventListener* listener); - - // Controls whether events will be forwarded by the repeater to the - // listeners in the list. - bool EventForwardingEnabled() const; - void SuppressEventForwarding(); - - // The actual list of listeners. - internal::TestEventRepeater* repeater_; - // Listener responsible for the standard result output. - TestEventListener* default_result_printer_; - // Listener responsible for the creation of the XML output file. - TestEventListener* default_xml_generator_; - - // We disallow copying TestEventListeners. - GTEST_DISALLOW_COPY_AND_ASSIGN_(TestEventListeners); -}; - -// A UnitTest consists of a vector of TestSuites. -// -// This is a singleton class. The only instance of UnitTest is -// created when UnitTest::GetInstance() is first called. This -// instance is never deleted. -// -// UnitTest is not copyable. -// -// This class is thread-safe as long as the methods are called -// according to their specification. -class GTEST_API_ UnitTest { - public: - // Gets the singleton UnitTest object. The first time this method - // is called, a UnitTest object is constructed and returned. - // Consecutive calls will return the same object. - static UnitTest* GetInstance(); - - // Runs all tests in this UnitTest object and prints the result. - // Returns 0 if successful, or 1 otherwise. - // - // This method can only be called from the main thread. - // - // INTERNAL IMPLEMENTATION - DO NOT USE IN A USER PROGRAM. - int Run() GTEST_MUST_USE_RESULT_; - - // Returns the working directory when the first TEST() or TEST_F() - // was executed. The UnitTest object owns the string. - const char* original_working_dir() const; - - // Returns the TestSuite object for the test that's currently running, - // or NULL if no test is running. - const TestSuite* current_test_suite() const GTEST_LOCK_EXCLUDED_(mutex_); - -// Legacy API is still available but deprecated -#ifndef GTEST_REMOVE_LEGACY_TEST_CASEAPI_ - const TestCase* current_test_case() const GTEST_LOCK_EXCLUDED_(mutex_); -#endif - - // Returns the TestInfo object for the test that's currently running, - // or NULL if no test is running. - const TestInfo* current_test_info() const - GTEST_LOCK_EXCLUDED_(mutex_); - - // Returns the random seed used at the start of the current test run. - int random_seed() const; - - // Returns the ParameterizedTestSuiteRegistry object used to keep track of - // value-parameterized tests and instantiate and register them. - // - // INTERNAL IMPLEMENTATION - DO NOT USE IN A USER PROGRAM. - internal::ParameterizedTestSuiteRegistry& parameterized_test_registry() - GTEST_LOCK_EXCLUDED_(mutex_); - - // Gets the number of successful test suites. - int successful_test_suite_count() const; - - // Gets the number of failed test suites. - int failed_test_suite_count() const; - - // Gets the number of all test suites. - int total_test_suite_count() const; - - // Gets the number of all test suites that contain at least one test - // that should run. - int test_suite_to_run_count() const; - - // Legacy API is deprecated but still available -#ifndef GTEST_REMOVE_LEGACY_TEST_CASEAPI_ - int successful_test_case_count() const; - int failed_test_case_count() const; - int total_test_case_count() const; - int test_case_to_run_count() const; -#endif // GTEST_REMOVE_LEGACY_TEST_CASEAPI_ - - // Gets the number of successful tests. - int successful_test_count() const; - - // Gets the number of skipped tests. - int skipped_test_count() const; - - // Gets the number of failed tests. - int failed_test_count() const; - - // Gets the number of disabled tests that will be reported in the XML report. - int reportable_disabled_test_count() const; - - // Gets the number of disabled tests. - int disabled_test_count() const; - - // Gets the number of tests to be printed in the XML report. - int reportable_test_count() const; - - // Gets the number of all tests. - int total_test_count() const; - - // Gets the number of tests that should run. - int test_to_run_count() const; - - // Gets the time of the test program start, in ms from the start of the - // UNIX epoch. - TimeInMillis start_timestamp() const; - - // Gets the elapsed time, in milliseconds. - TimeInMillis elapsed_time() const; - - // Returns true if and only if the unit test passed (i.e. all test suites - // passed). - bool Passed() const; - - // Returns true if and only if the unit test failed (i.e. some test suite - // failed or something outside of all tests failed). - bool Failed() const; - - // Gets the i-th test suite among all the test suites. i can range from 0 to - // total_test_suite_count() - 1. If i is not in that range, returns NULL. - const TestSuite* GetTestSuite(int i) const; - -// Legacy API is deprecated but still available -#ifndef GTEST_REMOVE_LEGACY_TEST_CASEAPI_ - const TestCase* GetTestCase(int i) const; -#endif // GTEST_REMOVE_LEGACY_TEST_CASEAPI_ - - // Returns the TestResult containing information on test failures and - // properties logged outside of individual test suites. - const TestResult& ad_hoc_test_result() const; - - // Returns the list of event listeners that can be used to track events - // inside Google Test. - TestEventListeners& listeners(); - - private: - // Registers and returns a global test environment. When a test - // program is run, all global test environments will be set-up in - // the order they were registered. After all tests in the program - // have finished, all global test environments will be torn-down in - // the *reverse* order they were registered. - // - // The UnitTest object takes ownership of the given environment. - // - // This method can only be called from the main thread. - Environment* AddEnvironment(Environment* env); - - // Adds a TestPartResult to the current TestResult object. All - // Google Test assertion macros (e.g. ASSERT_TRUE, EXPECT_EQ, etc) - // eventually call this to report their results. The user code - // should use the assertion macros instead of calling this directly. - void AddTestPartResult(TestPartResult::Type result_type, - const char* file_name, - int line_number, - const std::string& message, - const std::string& os_stack_trace) - GTEST_LOCK_EXCLUDED_(mutex_); - - // Adds a TestProperty to the current TestResult object when invoked from - // inside a test, to current TestSuite's ad_hoc_test_result_ when invoked - // from SetUpTestSuite or TearDownTestSuite, or to the global property set - // when invoked elsewhere. If the result already contains a property with - // the same key, the value will be updated. - void RecordProperty(const std::string& key, const std::string& value); - - // Gets the i-th test suite among all the test suites. i can range from 0 to - // total_test_suite_count() - 1. If i is not in that range, returns NULL. - TestSuite* GetMutableTestSuite(int i); - - // Accessors for the implementation object. - internal::UnitTestImpl* impl() { return impl_; } - const internal::UnitTestImpl* impl() const { return impl_; } - - // These classes and functions are friends as they need to access private - // members of UnitTest. - friend class ScopedTrace; - friend class Test; - friend class internal::AssertHelper; - friend class internal::StreamingListenerTest; - friend class internal::UnitTestRecordPropertyTestHelper; - friend Environment* AddGlobalTestEnvironment(Environment* env); - friend std::set<std::string>* internal::GetIgnoredParameterizedTestSuites(); - friend internal::UnitTestImpl* internal::GetUnitTestImpl(); - friend void internal::ReportFailureInUnknownLocation( - TestPartResult::Type result_type, - const std::string& message); - - // Creates an empty UnitTest. - UnitTest(); - - // D'tor - virtual ~UnitTest(); - - // Pushes a trace defined by SCOPED_TRACE() on to the per-thread - // Google Test trace stack. - void PushGTestTrace(const internal::TraceInfo& trace) - GTEST_LOCK_EXCLUDED_(mutex_); - - // Pops a trace from the per-thread Google Test trace stack. - void PopGTestTrace() - GTEST_LOCK_EXCLUDED_(mutex_); - - // Protects mutable state in *impl_. This is mutable as some const - // methods need to lock it too. - mutable internal::Mutex mutex_; - - // Opaque implementation object. This field is never changed once - // the object is constructed. We don't mark it as const here, as - // doing so will cause a warning in the constructor of UnitTest. - // Mutable state in *impl_ is protected by mutex_. - internal::UnitTestImpl* impl_; - - // We disallow copying UnitTest. - GTEST_DISALLOW_COPY_AND_ASSIGN_(UnitTest); -}; - -// A convenient wrapper for adding an environment for the test -// program. -// -// You should call this before RUN_ALL_TESTS() is called, probably in -// main(). If you use gtest_main, you need to call this before main() -// starts for it to take effect. For example, you can define a global -// variable like this: -// -// testing::Environment* const foo_env = -// testing::AddGlobalTestEnvironment(new FooEnvironment); -// -// However, we strongly recommend you to write your own main() and -// call AddGlobalTestEnvironment() there, as relying on initialization -// of global variables makes the code harder to read and may cause -// problems when you register multiple environments from different -// translation units and the environments have dependencies among them -// (remember that the compiler doesn't guarantee the order in which -// global variables from different translation units are initialized). -inline Environment* AddGlobalTestEnvironment(Environment* env) { - return UnitTest::GetInstance()->AddEnvironment(env); -} - -// Initializes Google Test. This must be called before calling -// RUN_ALL_TESTS(). In particular, it parses a command line for the -// flags that Google Test recognizes. Whenever a Google Test flag is -// seen, it is removed from argv, and *argc is decremented. -// -// No value is returned. Instead, the Google Test flag variables are -// updated. -// -// Calling the function for the second time has no user-visible effect. -GTEST_API_ void InitGoogleTest(int* argc, char** argv); - -// This overloaded version can be used in Windows programs compiled in -// UNICODE mode. -GTEST_API_ void InitGoogleTest(int* argc, wchar_t** argv); - -// This overloaded version can be used on Arduino/embedded platforms where -// there is no argc/argv. -GTEST_API_ void InitGoogleTest(); - -namespace internal { - -// Separate the error generating code from the code path to reduce the stack -// frame size of CmpHelperEQ. This helps reduce the overhead of some sanitizers -// when calling EXPECT_* in a tight loop. -template <typename T1, typename T2> -AssertionResult CmpHelperEQFailure(const char* lhs_expression, - const char* rhs_expression, - const T1& lhs, const T2& rhs) { - return EqFailure(lhs_expression, - rhs_expression, - FormatForComparisonFailureMessage(lhs, rhs), - FormatForComparisonFailureMessage(rhs, lhs), - false); -} - -// This block of code defines operator==/!= -// to block lexical scope lookup. -// It prevents using invalid operator==/!= defined at namespace scope. -struct faketype {}; -inline bool operator==(faketype, faketype) { return true; } -inline bool operator!=(faketype, faketype) { return false; } - -// The helper function for {ASSERT|EXPECT}_EQ. -template <typename T1, typename T2> -AssertionResult CmpHelperEQ(const char* lhs_expression, - const char* rhs_expression, - const T1& lhs, - const T2& rhs) { - if (lhs == rhs) { - return AssertionSuccess(); - } - - return CmpHelperEQFailure(lhs_expression, rhs_expression, lhs, rhs); -} - -class EqHelper { - public: - // This templatized version is for the general case. - template < - typename T1, typename T2, - // Disable this overload for cases where one argument is a pointer - // and the other is the null pointer constant. - typename std::enable_if<!std::is_integral<T1>::value || - !std::is_pointer<T2>::value>::type* = nullptr> - static AssertionResult Compare(const char* lhs_expression, - const char* rhs_expression, const T1& lhs, - const T2& rhs) { - return CmpHelperEQ(lhs_expression, rhs_expression, lhs, rhs); - } - - // With this overloaded version, we allow anonymous enums to be used - // in {ASSERT|EXPECT}_EQ when compiled with gcc 4, as anonymous - // enums can be implicitly cast to BiggestInt. - // - // Even though its body looks the same as the above version, we - // cannot merge the two, as it will make anonymous enums unhappy. - static AssertionResult Compare(const char* lhs_expression, - const char* rhs_expression, - BiggestInt lhs, - BiggestInt rhs) { - return CmpHelperEQ(lhs_expression, rhs_expression, lhs, rhs); - } - - template <typename T> - static AssertionResult Compare( - const char* lhs_expression, const char* rhs_expression, - // Handle cases where '0' is used as a null pointer literal. - std::nullptr_t /* lhs */, T* rhs) { - // We already know that 'lhs' is a null pointer. - return CmpHelperEQ(lhs_expression, rhs_expression, static_cast<T*>(nullptr), - rhs); - } -}; - -// Separate the error generating code from the code path to reduce the stack -// frame size of CmpHelperOP. This helps reduce the overhead of some sanitizers -// when calling EXPECT_OP in a tight loop. -template <typename T1, typename T2> -AssertionResult CmpHelperOpFailure(const char* expr1, const char* expr2, - const T1& val1, const T2& val2, - const char* op) { - return AssertionFailure() - << "Expected: (" << expr1 << ") " << op << " (" << expr2 - << "), actual: " << FormatForComparisonFailureMessage(val1, val2) - << " vs " << FormatForComparisonFailureMessage(val2, val1); -} - -// A macro for implementing the helper functions needed to implement -// ASSERT_?? and EXPECT_??. It is here just to avoid copy-and-paste -// of similar code. -// -// INTERNAL IMPLEMENTATION - DO NOT USE IN A USER PROGRAM. - -#define GTEST_IMPL_CMP_HELPER_(op_name, op)\ -template <typename T1, typename T2>\ -AssertionResult CmpHelper##op_name(const char* expr1, const char* expr2, \ - const T1& val1, const T2& val2) {\ - if (val1 op val2) {\ - return AssertionSuccess();\ - } else {\ - return CmpHelperOpFailure(expr1, expr2, val1, val2, #op);\ - }\ -} - -// INTERNAL IMPLEMENTATION - DO NOT USE IN A USER PROGRAM. - -// Implements the helper function for {ASSERT|EXPECT}_NE -GTEST_IMPL_CMP_HELPER_(NE, !=) -// Implements the helper function for {ASSERT|EXPECT}_LE -GTEST_IMPL_CMP_HELPER_(LE, <=) -// Implements the helper function for {ASSERT|EXPECT}_LT -GTEST_IMPL_CMP_HELPER_(LT, <) -// Implements the helper function for {ASSERT|EXPECT}_GE -GTEST_IMPL_CMP_HELPER_(GE, >=) -// Implements the helper function for {ASSERT|EXPECT}_GT -GTEST_IMPL_CMP_HELPER_(GT, >) - -#undef GTEST_IMPL_CMP_HELPER_ - -// The helper function for {ASSERT|EXPECT}_STREQ. -// -// INTERNAL IMPLEMENTATION - DO NOT USE IN A USER PROGRAM. -GTEST_API_ AssertionResult CmpHelperSTREQ(const char* s1_expression, - const char* s2_expression, - const char* s1, - const char* s2); - -// The helper function for {ASSERT|EXPECT}_STRCASEEQ. -// -// INTERNAL IMPLEMENTATION - DO NOT USE IN A USER PROGRAM. -GTEST_API_ AssertionResult CmpHelperSTRCASEEQ(const char* s1_expression, - const char* s2_expression, - const char* s1, - const char* s2); - -// The helper function for {ASSERT|EXPECT}_STRNE. -// -// INTERNAL IMPLEMENTATION - DO NOT USE IN A USER PROGRAM. -GTEST_API_ AssertionResult CmpHelperSTRNE(const char* s1_expression, - const char* s2_expression, - const char* s1, - const char* s2); - -// The helper function for {ASSERT|EXPECT}_STRCASENE. -// -// INTERNAL IMPLEMENTATION - DO NOT USE IN A USER PROGRAM. -GTEST_API_ AssertionResult CmpHelperSTRCASENE(const char* s1_expression, - const char* s2_expression, - const char* s1, - const char* s2); - - -// Helper function for *_STREQ on wide strings. -// -// INTERNAL IMPLEMENTATION - DO NOT USE IN A USER PROGRAM. -GTEST_API_ AssertionResult CmpHelperSTREQ(const char* s1_expression, - const char* s2_expression, - const wchar_t* s1, - const wchar_t* s2); - -// Helper function for *_STRNE on wide strings. -// -// INTERNAL IMPLEMENTATION - DO NOT USE IN A USER PROGRAM. -GTEST_API_ AssertionResult CmpHelperSTRNE(const char* s1_expression, - const char* s2_expression, - const wchar_t* s1, - const wchar_t* s2); - -} // namespace internal - -// IsSubstring() and IsNotSubstring() are intended to be used as the -// first argument to {EXPECT,ASSERT}_PRED_FORMAT2(), not by -// themselves. They check whether needle is a substring of haystack -// (NULL is considered a substring of itself only), and return an -// appropriate error message when they fail. -// -// The {needle,haystack}_expr arguments are the stringified -// expressions that generated the two real arguments. -GTEST_API_ AssertionResult IsSubstring( - const char* needle_expr, const char* haystack_expr, - const char* needle, const char* haystack); -GTEST_API_ AssertionResult IsSubstring( - const char* needle_expr, const char* haystack_expr, - const wchar_t* needle, const wchar_t* haystack); -GTEST_API_ AssertionResult IsNotSubstring( - const char* needle_expr, const char* haystack_expr, - const char* needle, const char* haystack); -GTEST_API_ AssertionResult IsNotSubstring( - const char* needle_expr, const char* haystack_expr, - const wchar_t* needle, const wchar_t* haystack); -GTEST_API_ AssertionResult IsSubstring( - const char* needle_expr, const char* haystack_expr, - const ::std::string& needle, const ::std::string& haystack); -GTEST_API_ AssertionResult IsNotSubstring( - const char* needle_expr, const char* haystack_expr, - const ::std::string& needle, const ::std::string& haystack); - -#if GTEST_HAS_STD_WSTRING -GTEST_API_ AssertionResult IsSubstring( - const char* needle_expr, const char* haystack_expr, - const ::std::wstring& needle, const ::std::wstring& haystack); -GTEST_API_ AssertionResult IsNotSubstring( - const char* needle_expr, const char* haystack_expr, - const ::std::wstring& needle, const ::std::wstring& haystack); -#endif // GTEST_HAS_STD_WSTRING - -namespace internal { - -// Helper template function for comparing floating-points. -// -// Template parameter: -// -// RawType: the raw floating-point type (either float or double) -// -// INTERNAL IMPLEMENTATION - DO NOT USE IN A USER PROGRAM. -template <typename RawType> -AssertionResult CmpHelperFloatingPointEQ(const char* lhs_expression, - const char* rhs_expression, - RawType lhs_value, - RawType rhs_value) { - const FloatingPoint<RawType> lhs(lhs_value), rhs(rhs_value); - - if (lhs.AlmostEquals(rhs)) { - return AssertionSuccess(); - } - - ::std::stringstream lhs_ss; - lhs_ss << std::setprecision(std::numeric_limits<RawType>::digits10 + 2) - << lhs_value; - - ::std::stringstream rhs_ss; - rhs_ss << std::setprecision(std::numeric_limits<RawType>::digits10 + 2) - << rhs_value; - - return EqFailure(lhs_expression, - rhs_expression, - StringStreamToString(&lhs_ss), - StringStreamToString(&rhs_ss), - false); -} - -// Helper function for implementing ASSERT_NEAR. -// -// INTERNAL IMPLEMENTATION - DO NOT USE IN A USER PROGRAM. -GTEST_API_ AssertionResult DoubleNearPredFormat(const char* expr1, - const char* expr2, - const char* abs_error_expr, - double val1, - double val2, - double abs_error); - -// INTERNAL IMPLEMENTATION - DO NOT USE IN USER CODE. -// A class that enables one to stream messages to assertion macros -class GTEST_API_ AssertHelper { - public: - // Constructor. - AssertHelper(TestPartResult::Type type, - const char* file, - int line, - const char* message); - ~AssertHelper(); - - // Message assignment is a semantic trick to enable assertion - // streaming; see the GTEST_MESSAGE_ macro below. - void operator=(const Message& message) const; - - private: - // We put our data in a struct so that the size of the AssertHelper class can - // be as small as possible. This is important because gcc is incapable of - // re-using stack space even for temporary variables, so every EXPECT_EQ - // reserves stack space for another AssertHelper. - struct AssertHelperData { - AssertHelperData(TestPartResult::Type t, - const char* srcfile, - int line_num, - const char* msg) - : type(t), file(srcfile), line(line_num), message(msg) { } - - TestPartResult::Type const type; - const char* const file; - int const line; - std::string const message; - - private: - GTEST_DISALLOW_COPY_AND_ASSIGN_(AssertHelperData); - }; - - AssertHelperData* const data_; - - GTEST_DISALLOW_COPY_AND_ASSIGN_(AssertHelper); -}; - -} // namespace internal - -// The pure interface class that all value-parameterized tests inherit from. -// A value-parameterized class must inherit from both ::testing::Test and -// ::testing::WithParamInterface. In most cases that just means inheriting -// from ::testing::TestWithParam, but more complicated test hierarchies -// may need to inherit from Test and WithParamInterface at different levels. -// -// This interface has support for accessing the test parameter value via -// the GetParam() method. -// -// Use it with one of the parameter generator defining functions, like Range(), -// Values(), ValuesIn(), Bool(), and Combine(). -// -// class FooTest : public ::testing::TestWithParam<int> { -// protected: -// FooTest() { -// // Can use GetParam() here. -// } -// ~FooTest() override { -// // Can use GetParam() here. -// } -// void SetUp() override { -// // Can use GetParam() here. -// } -// void TearDown override { -// // Can use GetParam() here. -// } -// }; -// TEST_P(FooTest, DoesBar) { -// // Can use GetParam() method here. -// Foo foo; -// ASSERT_TRUE(foo.DoesBar(GetParam())); -// } -// INSTANTIATE_TEST_SUITE_P(OneToTenRange, FooTest, ::testing::Range(1, 10)); - -template <typename T> -class WithParamInterface { - public: - typedef T ParamType; - virtual ~WithParamInterface() {} - - // The current parameter value. Is also available in the test fixture's - // constructor. - static const ParamType& GetParam() { - GTEST_CHECK_(parameter_ != nullptr) - << "GetParam() can only be called inside a value-parameterized test " - << "-- did you intend to write TEST_P instead of TEST_F?"; - return *parameter_; - } - - private: - // Sets parameter value. The caller is responsible for making sure the value - // remains alive and unchanged throughout the current test. - static void SetParam(const ParamType* parameter) { - parameter_ = parameter; - } - - // Static value used for accessing parameter during a test lifetime. - static const ParamType* parameter_; - - // TestClass must be a subclass of WithParamInterface<T> and Test. - template <class TestClass> friend class internal::ParameterizedTestFactory; -}; - -template <typename T> -const T* WithParamInterface<T>::parameter_ = nullptr; - -// Most value-parameterized classes can ignore the existence of -// WithParamInterface, and can just inherit from ::testing::TestWithParam. - -template <typename T> -class TestWithParam : public Test, public WithParamInterface<T> { -}; - -// Macros for indicating success/failure in test code. - -// Skips test in runtime. -// Skipping test aborts current function. -// Skipped tests are neither successful nor failed. -#define GTEST_SKIP() GTEST_SKIP_("") - -// ADD_FAILURE unconditionally adds a failure to the current test. -// SUCCEED generates a success - it doesn't automatically make the -// current test successful, as a test is only successful when it has -// no failure. -// -// EXPECT_* verifies that a certain condition is satisfied. If not, -// it behaves like ADD_FAILURE. In particular: -// -// EXPECT_TRUE verifies that a Boolean condition is true. -// EXPECT_FALSE verifies that a Boolean condition is false. -// -// FAIL and ASSERT_* are similar to ADD_FAILURE and EXPECT_*, except -// that they will also abort the current function on failure. People -// usually want the fail-fast behavior of FAIL and ASSERT_*, but those -// writing data-driven tests often find themselves using ADD_FAILURE -// and EXPECT_* more. - -// Generates a nonfatal failure with a generic message. -#define ADD_FAILURE() GTEST_NONFATAL_FAILURE_("Failed") - -// Generates a nonfatal failure at the given source file location with -// a generic message. -#define ADD_FAILURE_AT(file, line) \ - GTEST_MESSAGE_AT_(file, line, "Failed", \ - ::testing::TestPartResult::kNonFatalFailure) - -// Generates a fatal failure with a generic message. -#define GTEST_FAIL() GTEST_FATAL_FAILURE_("Failed") - -// Like GTEST_FAIL(), but at the given source file location. -#define GTEST_FAIL_AT(file, line) \ - GTEST_MESSAGE_AT_(file, line, "Failed", \ - ::testing::TestPartResult::kFatalFailure) - -// Define this macro to 1 to omit the definition of FAIL(), which is a -// generic name and clashes with some other libraries. -#if !GTEST_DONT_DEFINE_FAIL -# define FAIL() GTEST_FAIL() -#endif - -// Generates a success with a generic message. -#define GTEST_SUCCEED() GTEST_SUCCESS_("Succeeded") - -// Define this macro to 1 to omit the definition of SUCCEED(), which -// is a generic name and clashes with some other libraries. -#if !GTEST_DONT_DEFINE_SUCCEED -# define SUCCEED() GTEST_SUCCEED() -#endif - -// Macros for testing exceptions. -// -// * {ASSERT|EXPECT}_THROW(statement, expected_exception): -// Tests that the statement throws the expected exception. -// * {ASSERT|EXPECT}_NO_THROW(statement): -// Tests that the statement doesn't throw any exception. -// * {ASSERT|EXPECT}_ANY_THROW(statement): -// Tests that the statement throws an exception. - -#define EXPECT_THROW(statement, expected_exception) \ - GTEST_TEST_THROW_(statement, expected_exception, GTEST_NONFATAL_FAILURE_) -#define EXPECT_NO_THROW(statement) \ - GTEST_TEST_NO_THROW_(statement, GTEST_NONFATAL_FAILURE_) -#define EXPECT_ANY_THROW(statement) \ - GTEST_TEST_ANY_THROW_(statement, GTEST_NONFATAL_FAILURE_) -#define ASSERT_THROW(statement, expected_exception) \ - GTEST_TEST_THROW_(statement, expected_exception, GTEST_FATAL_FAILURE_) -#define ASSERT_NO_THROW(statement) \ - GTEST_TEST_NO_THROW_(statement, GTEST_FATAL_FAILURE_) -#define ASSERT_ANY_THROW(statement) \ - GTEST_TEST_ANY_THROW_(statement, GTEST_FATAL_FAILURE_) - -// Boolean assertions. Condition can be either a Boolean expression or an -// AssertionResult. For more information on how to use AssertionResult with -// these macros see comments on that class. -#define GTEST_EXPECT_TRUE(condition) \ - GTEST_TEST_BOOLEAN_(condition, #condition, false, true, \ - GTEST_NONFATAL_FAILURE_) -#define GTEST_EXPECT_FALSE(condition) \ - GTEST_TEST_BOOLEAN_(!(condition), #condition, true, false, \ - GTEST_NONFATAL_FAILURE_) -#define GTEST_ASSERT_TRUE(condition) \ - GTEST_TEST_BOOLEAN_(condition, #condition, false, true, \ - GTEST_FATAL_FAILURE_) -#define GTEST_ASSERT_FALSE(condition) \ - GTEST_TEST_BOOLEAN_(!(condition), #condition, true, false, \ - GTEST_FATAL_FAILURE_) - -// Define these macros to 1 to omit the definition of the corresponding -// EXPECT or ASSERT, which clashes with some users' own code. - -#if !GTEST_DONT_DEFINE_EXPECT_TRUE -#define EXPECT_TRUE(condition) GTEST_EXPECT_TRUE(condition) -#endif - -#if !GTEST_DONT_DEFINE_EXPECT_FALSE -#define EXPECT_FALSE(condition) GTEST_EXPECT_FALSE(condition) -#endif - -#if !GTEST_DONT_DEFINE_ASSERT_TRUE -#define ASSERT_TRUE(condition) GTEST_ASSERT_TRUE(condition) -#endif - -#if !GTEST_DONT_DEFINE_ASSERT_FALSE -#define ASSERT_FALSE(condition) GTEST_ASSERT_FALSE(condition) -#endif - -// Macros for testing equalities and inequalities. -// -// * {ASSERT|EXPECT}_EQ(v1, v2): Tests that v1 == v2 -// * {ASSERT|EXPECT}_NE(v1, v2): Tests that v1 != v2 -// * {ASSERT|EXPECT}_LT(v1, v2): Tests that v1 < v2 -// * {ASSERT|EXPECT}_LE(v1, v2): Tests that v1 <= v2 -// * {ASSERT|EXPECT}_GT(v1, v2): Tests that v1 > v2 -// * {ASSERT|EXPECT}_GE(v1, v2): Tests that v1 >= v2 -// -// When they are not, Google Test prints both the tested expressions and -// their actual values. The values must be compatible built-in types, -// or you will get a compiler error. By "compatible" we mean that the -// values can be compared by the respective operator. -// -// Note: -// -// 1. It is possible to make a user-defined type work with -// {ASSERT|EXPECT}_??(), but that requires overloading the -// comparison operators and is thus discouraged by the Google C++ -// Usage Guide. Therefore, you are advised to use the -// {ASSERT|EXPECT}_TRUE() macro to assert that two objects are -// equal. -// -// 2. The {ASSERT|EXPECT}_??() macros do pointer comparisons on -// pointers (in particular, C strings). Therefore, if you use it -// with two C strings, you are testing how their locations in memory -// are related, not how their content is related. To compare two C -// strings by content, use {ASSERT|EXPECT}_STR*(). -// -// 3. {ASSERT|EXPECT}_EQ(v1, v2) is preferred to -// {ASSERT|EXPECT}_TRUE(v1 == v2), as the former tells you -// what the actual value is when it fails, and similarly for the -// other comparisons. -// -// 4. Do not depend on the order in which {ASSERT|EXPECT}_??() -// evaluate their arguments, which is undefined. -// -// 5. These macros evaluate their arguments exactly once. -// -// Examples: -// -// EXPECT_NE(Foo(), 5); -// EXPECT_EQ(a_pointer, NULL); -// ASSERT_LT(i, array_size); -// ASSERT_GT(records.size(), 0) << "There is no record left."; - -#define EXPECT_EQ(val1, val2) \ - EXPECT_PRED_FORMAT2(::testing::internal::EqHelper::Compare, val1, val2) -#define EXPECT_NE(val1, val2) \ - EXPECT_PRED_FORMAT2(::testing::internal::CmpHelperNE, val1, val2) -#define EXPECT_LE(val1, val2) \ - EXPECT_PRED_FORMAT2(::testing::internal::CmpHelperLE, val1, val2) -#define EXPECT_LT(val1, val2) \ - EXPECT_PRED_FORMAT2(::testing::internal::CmpHelperLT, val1, val2) -#define EXPECT_GE(val1, val2) \ - EXPECT_PRED_FORMAT2(::testing::internal::CmpHelperGE, val1, val2) -#define EXPECT_GT(val1, val2) \ - EXPECT_PRED_FORMAT2(::testing::internal::CmpHelperGT, val1, val2) - -#define GTEST_ASSERT_EQ(val1, val2) \ - ASSERT_PRED_FORMAT2(::testing::internal::EqHelper::Compare, val1, val2) -#define GTEST_ASSERT_NE(val1, val2) \ - ASSERT_PRED_FORMAT2(::testing::internal::CmpHelperNE, val1, val2) -#define GTEST_ASSERT_LE(val1, val2) \ - ASSERT_PRED_FORMAT2(::testing::internal::CmpHelperLE, val1, val2) -#define GTEST_ASSERT_LT(val1, val2) \ - ASSERT_PRED_FORMAT2(::testing::internal::CmpHelperLT, val1, val2) -#define GTEST_ASSERT_GE(val1, val2) \ - ASSERT_PRED_FORMAT2(::testing::internal::CmpHelperGE, val1, val2) -#define GTEST_ASSERT_GT(val1, val2) \ - ASSERT_PRED_FORMAT2(::testing::internal::CmpHelperGT, val1, val2) - -// Define macro GTEST_DONT_DEFINE_ASSERT_XY to 1 to omit the definition of -// ASSERT_XY(), which clashes with some users' own code. - -#if !GTEST_DONT_DEFINE_ASSERT_EQ -# define ASSERT_EQ(val1, val2) GTEST_ASSERT_EQ(val1, val2) -#endif - -#if !GTEST_DONT_DEFINE_ASSERT_NE -# define ASSERT_NE(val1, val2) GTEST_ASSERT_NE(val1, val2) -#endif - -#if !GTEST_DONT_DEFINE_ASSERT_LE -# define ASSERT_LE(val1, val2) GTEST_ASSERT_LE(val1, val2) -#endif - -#if !GTEST_DONT_DEFINE_ASSERT_LT -# define ASSERT_LT(val1, val2) GTEST_ASSERT_LT(val1, val2) -#endif - -#if !GTEST_DONT_DEFINE_ASSERT_GE -# define ASSERT_GE(val1, val2) GTEST_ASSERT_GE(val1, val2) -#endif - -#if !GTEST_DONT_DEFINE_ASSERT_GT -# define ASSERT_GT(val1, val2) GTEST_ASSERT_GT(val1, val2) -#endif - -// C-string Comparisons. All tests treat NULL and any non-NULL string -// as different. Two NULLs are equal. -// -// * {ASSERT|EXPECT}_STREQ(s1, s2): Tests that s1 == s2 -// * {ASSERT|EXPECT}_STRNE(s1, s2): Tests that s1 != s2 -// * {ASSERT|EXPECT}_STRCASEEQ(s1, s2): Tests that s1 == s2, ignoring case -// * {ASSERT|EXPECT}_STRCASENE(s1, s2): Tests that s1 != s2, ignoring case -// -// For wide or narrow string objects, you can use the -// {ASSERT|EXPECT}_??() macros. -// -// Don't depend on the order in which the arguments are evaluated, -// which is undefined. -// -// These macros evaluate their arguments exactly once. - -#define EXPECT_STREQ(s1, s2) \ - EXPECT_PRED_FORMAT2(::testing::internal::CmpHelperSTREQ, s1, s2) -#define EXPECT_STRNE(s1, s2) \ - EXPECT_PRED_FORMAT2(::testing::internal::CmpHelperSTRNE, s1, s2) -#define EXPECT_STRCASEEQ(s1, s2) \ - EXPECT_PRED_FORMAT2(::testing::internal::CmpHelperSTRCASEEQ, s1, s2) -#define EXPECT_STRCASENE(s1, s2)\ - EXPECT_PRED_FORMAT2(::testing::internal::CmpHelperSTRCASENE, s1, s2) - -#define ASSERT_STREQ(s1, s2) \ - ASSERT_PRED_FORMAT2(::testing::internal::CmpHelperSTREQ, s1, s2) -#define ASSERT_STRNE(s1, s2) \ - ASSERT_PRED_FORMAT2(::testing::internal::CmpHelperSTRNE, s1, s2) -#define ASSERT_STRCASEEQ(s1, s2) \ - ASSERT_PRED_FORMAT2(::testing::internal::CmpHelperSTRCASEEQ, s1, s2) -#define ASSERT_STRCASENE(s1, s2)\ - ASSERT_PRED_FORMAT2(::testing::internal::CmpHelperSTRCASENE, s1, s2) - -// Macros for comparing floating-point numbers. -// -// * {ASSERT|EXPECT}_FLOAT_EQ(val1, val2): -// Tests that two float values are almost equal. -// * {ASSERT|EXPECT}_DOUBLE_EQ(val1, val2): -// Tests that two double values are almost equal. -// * {ASSERT|EXPECT}_NEAR(v1, v2, abs_error): -// Tests that v1 and v2 are within the given distance to each other. -// -// Google Test uses ULP-based comparison to automatically pick a default -// error bound that is appropriate for the operands. See the -// FloatingPoint template class in gtest-internal.h if you are -// interested in the implementation details. - -#define EXPECT_FLOAT_EQ(val1, val2)\ - EXPECT_PRED_FORMAT2(::testing::internal::CmpHelperFloatingPointEQ<float>, \ - val1, val2) - -#define EXPECT_DOUBLE_EQ(val1, val2)\ - EXPECT_PRED_FORMAT2(::testing::internal::CmpHelperFloatingPointEQ<double>, \ - val1, val2) - -#define ASSERT_FLOAT_EQ(val1, val2)\ - ASSERT_PRED_FORMAT2(::testing::internal::CmpHelperFloatingPointEQ<float>, \ - val1, val2) - -#define ASSERT_DOUBLE_EQ(val1, val2)\ - ASSERT_PRED_FORMAT2(::testing::internal::CmpHelperFloatingPointEQ<double>, \ - val1, val2) - -#define EXPECT_NEAR(val1, val2, abs_error)\ - EXPECT_PRED_FORMAT3(::testing::internal::DoubleNearPredFormat, \ - val1, val2, abs_error) - -#define ASSERT_NEAR(val1, val2, abs_error)\ - ASSERT_PRED_FORMAT3(::testing::internal::DoubleNearPredFormat, \ - val1, val2, abs_error) - -// These predicate format functions work on floating-point values, and -// can be used in {ASSERT|EXPECT}_PRED_FORMAT2*(), e.g. -// -// EXPECT_PRED_FORMAT2(testing::DoubleLE, Foo(), 5.0); - -// Asserts that val1 is less than, or almost equal to, val2. Fails -// otherwise. In particular, it fails if either val1 or val2 is NaN. -GTEST_API_ AssertionResult FloatLE(const char* expr1, const char* expr2, - float val1, float val2); -GTEST_API_ AssertionResult DoubleLE(const char* expr1, const char* expr2, - double val1, double val2); - - -#if GTEST_OS_WINDOWS - -// Macros that test for HRESULT failure and success, these are only useful -// on Windows, and rely on Windows SDK macros and APIs to compile. -// -// * {ASSERT|EXPECT}_HRESULT_{SUCCEEDED|FAILED}(expr) -// -// When expr unexpectedly fails or succeeds, Google Test prints the -// expected result and the actual result with both a human-readable -// string representation of the error, if available, as well as the -// hex result code. -# define EXPECT_HRESULT_SUCCEEDED(expr) \ - EXPECT_PRED_FORMAT1(::testing::internal::IsHRESULTSuccess, (expr)) - -# define ASSERT_HRESULT_SUCCEEDED(expr) \ - ASSERT_PRED_FORMAT1(::testing::internal::IsHRESULTSuccess, (expr)) - -# define EXPECT_HRESULT_FAILED(expr) \ - EXPECT_PRED_FORMAT1(::testing::internal::IsHRESULTFailure, (expr)) - -# define ASSERT_HRESULT_FAILED(expr) \ - ASSERT_PRED_FORMAT1(::testing::internal::IsHRESULTFailure, (expr)) - -#endif // GTEST_OS_WINDOWS - -// Macros that execute statement and check that it doesn't generate new fatal -// failures in the current thread. -// -// * {ASSERT|EXPECT}_NO_FATAL_FAILURE(statement); -// -// Examples: -// -// EXPECT_NO_FATAL_FAILURE(Process()); -// ASSERT_NO_FATAL_FAILURE(Process()) << "Process() failed"; -// -#define ASSERT_NO_FATAL_FAILURE(statement) \ - GTEST_TEST_NO_FATAL_FAILURE_(statement, GTEST_FATAL_FAILURE_) -#define EXPECT_NO_FATAL_FAILURE(statement) \ - GTEST_TEST_NO_FATAL_FAILURE_(statement, GTEST_NONFATAL_FAILURE_) - -// Causes a trace (including the given source file path and line number, -// and the given message) to be included in every test failure message generated -// by code in the scope of the lifetime of an instance of this class. The effect -// is undone with the destruction of the instance. -// -// The message argument can be anything streamable to std::ostream. -// -// Example: -// testing::ScopedTrace trace("file.cc", 123, "message"); -// -class GTEST_API_ ScopedTrace { - public: - // The c'tor pushes the given source file location and message onto - // a trace stack maintained by Google Test. - - // Template version. Uses Message() to convert the values into strings. - // Slow, but flexible. - template <typename T> - ScopedTrace(const char* file, int line, const T& message) { - PushTrace(file, line, (Message() << message).GetString()); - } - - // Optimize for some known types. - ScopedTrace(const char* file, int line, const char* message) { - PushTrace(file, line, message ? message : "(null)"); - } - - ScopedTrace(const char* file, int line, const std::string& message) { - PushTrace(file, line, message); - } - - // The d'tor pops the info pushed by the c'tor. - // - // Note that the d'tor is not virtual in order to be efficient. - // Don't inherit from ScopedTrace! - ~ScopedTrace(); - - private: - void PushTrace(const char* file, int line, std::string message); - - GTEST_DISALLOW_COPY_AND_ASSIGN_(ScopedTrace); -} GTEST_ATTRIBUTE_UNUSED_; // A ScopedTrace object does its job in its - // c'tor and d'tor. Therefore it doesn't - // need to be used otherwise. - -// Causes a trace (including the source file path, the current line -// number, and the given message) to be included in every test failure -// message generated by code in the current scope. The effect is -// undone when the control leaves the current scope. -// -// The message argument can be anything streamable to std::ostream. -// -// In the implementation, we include the current line number as part -// of the dummy variable name, thus allowing multiple SCOPED_TRACE()s -// to appear in the same block - as long as they are on different -// lines. -// -// Assuming that each thread maintains its own stack of traces. -// Therefore, a SCOPED_TRACE() would (correctly) only affect the -// assertions in its own thread. -#define SCOPED_TRACE(message) \ - ::testing::ScopedTrace GTEST_CONCAT_TOKEN_(gtest_trace_, __LINE__)(\ - __FILE__, __LINE__, (message)) - -// Compile-time assertion for type equality. -// StaticAssertTypeEq<type1, type2>() compiles if and only if type1 and type2 -// are the same type. The value it returns is not interesting. -// -// Instead of making StaticAssertTypeEq a class template, we make it a -// function template that invokes a helper class template. This -// prevents a user from misusing StaticAssertTypeEq<T1, T2> by -// defining objects of that type. -// -// CAVEAT: -// -// When used inside a method of a class template, -// StaticAssertTypeEq<T1, T2>() is effective ONLY IF the method is -// instantiated. For example, given: -// -// template <typename T> class Foo { -// public: -// void Bar() { testing::StaticAssertTypeEq<int, T>(); } -// }; -// -// the code: -// -// void Test1() { Foo<bool> foo; } -// -// will NOT generate a compiler error, as Foo<bool>::Bar() is never -// actually instantiated. Instead, you need: -// -// void Test2() { Foo<bool> foo; foo.Bar(); } -// -// to cause a compiler error. -template <typename T1, typename T2> -constexpr bool StaticAssertTypeEq() noexcept { - static_assert(std::is_same<T1, T2>::value, "T1 and T2 are not the same type"); - return true; -} - -// Defines a test. -// -// The first parameter is the name of the test suite, and the second -// parameter is the name of the test within the test suite. -// -// The convention is to end the test suite name with "Test". For -// example, a test suite for the Foo class can be named FooTest. -// -// Test code should appear between braces after an invocation of -// this macro. Example: -// -// TEST(FooTest, InitializesCorrectly) { -// Foo foo; -// EXPECT_TRUE(foo.StatusIsOK()); -// } - -// Note that we call GetTestTypeId() instead of GetTypeId< -// ::testing::Test>() here to get the type ID of testing::Test. This -// is to work around a suspected linker bug when using Google Test as -// a framework on Mac OS X. The bug causes GetTypeId< -// ::testing::Test>() to return different values depending on whether -// the call is from the Google Test framework itself or from user test -// code. GetTestTypeId() is guaranteed to always return the same -// value, as it always calls GetTypeId<>() from the Google Test -// framework. -#define GTEST_TEST(test_suite_name, test_name) \ - GTEST_TEST_(test_suite_name, test_name, ::testing::Test, \ - ::testing::internal::GetTestTypeId()) - -// Define this macro to 1 to omit the definition of TEST(), which -// is a generic name and clashes with some other libraries. -#if !GTEST_DONT_DEFINE_TEST -#define TEST(test_suite_name, test_name) GTEST_TEST(test_suite_name, test_name) -#endif - -// Defines a test that uses a test fixture. -// -// The first parameter is the name of the test fixture class, which -// also doubles as the test suite name. The second parameter is the -// name of the test within the test suite. -// -// A test fixture class must be declared earlier. The user should put -// the test code between braces after using this macro. Example: -// -// class FooTest : public testing::Test { -// protected: -// void SetUp() override { b_.AddElement(3); } -// -// Foo a_; -// Foo b_; -// }; -// -// TEST_F(FooTest, InitializesCorrectly) { -// EXPECT_TRUE(a_.StatusIsOK()); -// } -// -// TEST_F(FooTest, ReturnsElementCountCorrectly) { -// EXPECT_EQ(a_.size(), 0); -// EXPECT_EQ(b_.size(), 1); -// } -// -// GOOGLETEST_CM0011 DO NOT DELETE -#if !GTEST_DONT_DEFINE_TEST -#define TEST_F(test_fixture, test_name)\ - GTEST_TEST_(test_fixture, test_name, test_fixture, \ - ::testing::internal::GetTypeId<test_fixture>()) -#endif // !GTEST_DONT_DEFINE_TEST - -// Returns a path to temporary directory. -// Tries to determine an appropriate directory for the platform. -GTEST_API_ std::string TempDir(); - -#ifdef _MSC_VER -# pragma warning(pop) -#endif - -// Dynamically registers a test with the framework. -// -// This is an advanced API only to be used when the `TEST` macros are -// insufficient. The macros should be preferred when possible, as they avoid -// most of the complexity of calling this function. -// -// The `factory` argument is a factory callable (move-constructible) object or -// function pointer that creates a new instance of the Test object. It -// handles ownership to the caller. The signature of the callable is -// `Fixture*()`, where `Fixture` is the test fixture class for the test. All -// tests registered with the same `test_suite_name` must return the same -// fixture type. This is checked at runtime. -// -// The framework will infer the fixture class from the factory and will call -// the `SetUpTestSuite` and `TearDownTestSuite` for it. -// -// Must be called before `RUN_ALL_TESTS()` is invoked, otherwise behavior is -// undefined. -// -// Use case example: -// -// class MyFixture : public ::testing::Test { -// public: -// // All of these optional, just like in regular macro usage. -// static void SetUpTestSuite() { ... } -// static void TearDownTestSuite() { ... } -// void SetUp() override { ... } -// void TearDown() override { ... } -// }; -// -// class MyTest : public MyFixture { -// public: -// explicit MyTest(int data) : data_(data) {} -// void TestBody() override { ... } -// -// private: -// int data_; -// }; -// -// void RegisterMyTests(const std::vector<int>& values) { -// for (int v : values) { -// ::testing::RegisterTest( -// "MyFixture", ("Test" + std::to_string(v)).c_str(), nullptr, -// std::to_string(v).c_str(), -// __FILE__, __LINE__, -// // Important to use the fixture type as the return type here. -// [=]() -> MyFixture* { return new MyTest(v); }); -// } -// } -// ... -// int main(int argc, char** argv) { -// std::vector<int> values_to_test = LoadValuesFromConfig(); -// RegisterMyTests(values_to_test); -// ... -// return RUN_ALL_TESTS(); -// } -// -template <int&... ExplicitParameterBarrier, typename Factory> -TestInfo* RegisterTest(const char* test_suite_name, const char* test_name, - const char* type_param, const char* value_param, - const char* file, int line, Factory factory) { - using TestT = typename std::remove_pointer<decltype(factory())>::type; - - class FactoryImpl : public internal::TestFactoryBase { - public: - explicit FactoryImpl(Factory f) : factory_(std::move(f)) {} - Test* CreateTest() override { return factory_(); } - - private: - Factory factory_; - }; - - return internal::MakeAndRegisterTestInfo( - test_suite_name, test_name, type_param, value_param, - internal::CodeLocation(file, line), internal::GetTypeId<TestT>(), - internal::SuiteApiResolver<TestT>::GetSetUpCaseOrSuite(file, line), - internal::SuiteApiResolver<TestT>::GetTearDownCaseOrSuite(file, line), - new FactoryImpl{std::move(factory)}); -} - -} // namespace testing - -// Use this function in main() to run all tests. It returns 0 if all -// tests are successful, or 1 otherwise. -// -// RUN_ALL_TESTS() should be invoked after the command line has been -// parsed by InitGoogleTest(). -// -// This function was formerly a macro; thus, it is in the global -// namespace and has an all-caps name. -int RUN_ALL_TESTS() GTEST_MUST_USE_RESULT_; - -inline int RUN_ALL_TESTS() { - return ::testing::UnitTest::GetInstance()->Run(); -} - -GTEST_DISABLE_MSC_WARNINGS_POP_() // 4251 - -#endif // GOOGLETEST_INCLUDE_GTEST_GTEST_H_ diff --git a/thirdparty/fmt/test/header-only-test.cc b/thirdparty/fmt/test/header-only-test.cc deleted file mode 100644 index 8c99f857b..000000000 --- a/thirdparty/fmt/test/header-only-test.cc +++ /dev/null @@ -1,11 +0,0 @@ -// Header-only configuration test - -#include "fmt/base.h" -#include "fmt/ostream.h" -#include "gtest/gtest.h" - -#ifndef FMT_HEADER_ONLY -# error "Not in the header-only mode." -#endif - -TEST(header_only_test, format) { EXPECT_EQ(fmt::format("foo"), "foo"); } diff --git a/thirdparty/fmt/test/mock-allocator.h b/thirdparty/fmt/test/mock-allocator.h deleted file mode 100644 index 0bf015a42..000000000 --- a/thirdparty/fmt/test/mock-allocator.h +++ /dev/null @@ -1,88 +0,0 @@ -// Formatting library for C++ - mock allocator -// -// Copyright (c) 2012 - present, Victor Zverovich -// All rights reserved. -// -// For the license information refer to format.h. - -#ifndef FMT_MOCK_ALLOCATOR_H_ -#define FMT_MOCK_ALLOCATOR_H_ - -#include <assert.h> // assert -#include <stddef.h> // size_t - -#include <memory> // std::allocator_traits - -#include "gmock/gmock.h" - -template <typename T> class mock_allocator { - public: - using value_type = T; - using size_type = size_t; - - using pointer = T*; - using const_pointer = const T*; - using reference = T&; - using const_reference = const T&; - using difference_type = ptrdiff_t; - - template <typename U> struct rebind { - using other = mock_allocator<U>; - }; - - mock_allocator() {} - mock_allocator(const mock_allocator&) {} - - MOCK_METHOD(T*, allocate, (size_t)); - MOCK_METHOD(void, deallocate, (T*, size_t)); -}; - -template <typename Allocator, bool PropagateOnMove = true> class allocator_ref { - private: - Allocator* alloc_; - - void move(allocator_ref& other) { - alloc_ = other.alloc_; - other.alloc_ = nullptr; - } - - public: - using value_type = typename Allocator::value_type; - using propagate_on_container_move_assignment = - fmt::bool_constant<PropagateOnMove>; - - explicit allocator_ref(Allocator* alloc = nullptr) : alloc_(alloc) {} - - allocator_ref(const allocator_ref& other) : alloc_(other.alloc_) {} - allocator_ref(allocator_ref&& other) { move(other); } - - allocator_ref& operator=(allocator_ref&& other) { - assert(this != &other); - move(other); - return *this; - } - - allocator_ref& operator=(const allocator_ref& other) { - alloc_ = other.alloc_; - return *this; - } - - public: - auto get() const -> Allocator* { return alloc_; } - - auto allocate(size_t n) -> value_type* { - return std::allocator_traits<Allocator>::allocate(*alloc_, n); - } - void deallocate(value_type* p, size_t n) { alloc_->deallocate(p, n); } - - friend auto operator==(allocator_ref a, allocator_ref b) noexcept -> bool { - if (a.alloc_ == b.alloc_) return true; - return a.alloc_ && b.alloc_ && *a.alloc_ == *b.alloc_; - } - - friend auto operator!=(allocator_ref a, allocator_ref b) noexcept -> bool { - return !(a == b); - } -}; - -#endif // FMT_MOCK_ALLOCATOR_H_ diff --git a/thirdparty/fmt/test/module-test.cc b/thirdparty/fmt/test/module-test.cc deleted file mode 100644 index bd9624f9a..000000000 --- a/thirdparty/fmt/test/module-test.cc +++ /dev/null @@ -1,520 +0,0 @@ -// Formatting library for C++ - module tests -// -// Copyright (c) 2012 - present, Victor Zverovich -// All rights reserved. -// -// For the license information refer to format.h. -// -// Copyright (c) 2021 - present, Daniela Engert -// All Rights Reserved -// {fmt} module. - -#ifdef _MSC_FULL_VER -// hide some implementation bugs in msvc -// that are not essential to users of the module. -# define FMT_HIDE_MODULE_BUGS -#endif - -#include <bit> -#include <chrono> -#include <exception> -#include <iterator> -#include <locale> -#include <memory> -#include <ostream> -#include <string> -#include <string_view> -#include <system_error> - -#if (__has_include(<fcntl.h>) || defined(__APPLE__) || \ - defined(__linux__)) && \ - (!defined(WINAPI_FAMILY) || (WINAPI_FAMILY == WINAPI_FAMILY_DESKTOP_APP)) -# include <fcntl.h> -# define FMT_USE_FCNTL 1 -#else -# define FMT_USE_FCNTL 0 -#endif -#if defined(_WIN32) && !defined(__MINGW32__) -# define FMT_POSIX(call) _##call -#else -# define FMT_POSIX(call) call -#endif - -import fmt; - -// check for macros leaking from BMI -static bool macro_leaked = -#if defined(FMT_CORE_H_) || defined(FMT_FORMAT_H_) - true; -#else - false; -#endif - -#define FMT_OS_H_ // don't pull in os.h, neither directly nor indirectly -#include "gtest-extra.h" - -// an implicitly exported namespace must be visible [module.interface]/2.2 -TEST(module_test, namespace) { - using namespace fmt; - using namespace fmt::literals; - ASSERT_TRUE(true); -} - -namespace detail { -bool oops_detail_namespace_is_visible; -} - -namespace fmt { -bool namespace_detail_invisible() { -#if defined(FMT_HIDE_MODULE_BUGS) && defined(_MSC_FULL_VER) && \ - _MSC_FULL_VER <= 193700000 - // bug in msvc up to at least 17.7: - - // the namespace is visible even when it is neither - // implicitly nor explicitly exported - return true; -#else - using namespace detail; - // this fails to compile if fmt::detail is visible - return !oops_detail_namespace_is_visible; -#endif -} -} // namespace fmt - -// the non-exported namespace 'detail' must be invisible [module.interface]/2 -TEST(module_test, detail_namespace) { - EXPECT_TRUE(fmt::namespace_detail_invisible()); -} - -// macros must not be imported from a *named* module [cpp.import]/5.1 -TEST(module_test, macros) { -#if defined(FMT_HIDE_MODULE_BUGS) && defined(_MSC_FULL_VER) && \ - _MSC_FULL_VER <= 192930130 - // bug in msvc up to 16.11-pre2: - // include-guard macros leak from BMI - // and even worse: they cannot be #undef-ined - macro_leaked = false; -#endif - EXPECT_FALSE(macro_leaked); -} - -// The following is less about functional testing (that's done elsewhere) -// but rather visibility of all client-facing overloads, reachability of -// non-exported entities, name lookup and overload resolution within -// template instantitions. -// Exercise all exported entities of the API at least once. -// Instantiate as many code paths as possible. - -TEST(module_test, to_string) { - EXPECT_EQ("42", fmt::to_string(42)); - EXPECT_EQ("42", fmt::to_string(42.0)); - - EXPECT_EQ(L"42", fmt::to_wstring(42)); - EXPECT_EQ(L"42", fmt::to_wstring(42.0)); -} - -TEST(module_test, format) { - EXPECT_EQ("42", fmt::format("{:}", 42)); - EXPECT_EQ("-42", fmt::format("{0}", -42.0)); - - EXPECT_EQ(L"42", fmt::format(L"{:}", 42)); - EXPECT_EQ(L"-42", fmt::format(L"{0}", -42.0)); -} - -TEST(module_test, format_to) { - std::string s; - fmt::format_to(std::back_inserter(s), "{}", 42); - EXPECT_EQ("42", s); - - char buffer[4] = {0}; - fmt::format_to(buffer, "{}", 42); - EXPECT_EQ("42", std::string_view(buffer)); - - fmt::memory_buffer mb; - fmt::format_to(std::back_inserter(mb), "{}", 42); - EXPECT_EQ("42", std::string_view(buffer)); - - std::wstring w; - fmt::format_to(std::back_inserter(w), L"{}", 42); - EXPECT_EQ(L"42", w); - - wchar_t wbuffer[4] = {0}; - fmt::format_to(wbuffer, L"{}", 42); - EXPECT_EQ(L"42", std::wstring_view(wbuffer)); - - fmt::wmemory_buffer wb; - fmt::format_to(std::back_inserter(wb), L"{}", 42); - EXPECT_EQ(L"42", std::wstring_view(wbuffer)); -} - -TEST(module_test, formatted_size) { - EXPECT_EQ(2u, fmt::formatted_size("{}", 42)); - EXPECT_EQ(2u, fmt::formatted_size(L"{}", 42)); -} - -TEST(module_test, format_to_n) { - std::string s; - auto result = fmt::format_to_n(std::back_inserter(s), 1, "{}", 42); - EXPECT_EQ(2u, result.size); - char buffer[4] = {0}; - fmt::format_to_n(buffer, 3, "{}", 12345); - - std::wstring w; - auto wresult = fmt::format_to_n(std::back_inserter(w), 1, L"{}", 42); - EXPECT_EQ(2u, wresult.size); - wchar_t wbuffer[4] = {0}; - fmt::format_to_n(wbuffer, 3, L"{}", 12345); -} - -TEST(module_test, format_args) { - auto no_args = fmt::format_args(); - EXPECT_FALSE(no_args.get(1)); - - fmt::basic_format_args args = fmt::make_format_args(42); - EXPECT_TRUE(args.max_size() > 0); - auto arg0 = args.get(0); - EXPECT_TRUE(arg0); - decltype(arg0) arg_none; - EXPECT_FALSE(arg_none); - EXPECT_TRUE(arg0.type() != arg_none.type()); -} - -TEST(module_test, wformat_args) { - auto no_args = fmt::wformat_args(); - EXPECT_FALSE(no_args.get(1)); - fmt::basic_format_args args = fmt::make_wformat_args(42); - EXPECT_TRUE(args.get(0)); -} - -TEST(module_test, dynamic_format_args) { - fmt::dynamic_format_arg_store<fmt::format_context> dyn_store; - dyn_store.push_back(fmt::arg("a42", 42)); - fmt::basic_format_args args = dyn_store; - EXPECT_FALSE(args.get(3)); - EXPECT_TRUE(args.get(fmt::string_view("a42"))); - - fmt::dynamic_format_arg_store<fmt::wformat_context> wdyn_store; - wdyn_store.push_back(fmt::arg(L"a42", 42)); - fmt::basic_format_args wargs = wdyn_store; - EXPECT_FALSE(wargs.get(3)); - EXPECT_TRUE(wargs.get(fmt::wstring_view(L"a42"))); -} - -TEST(module_test, vformat) { - EXPECT_EQ("42", fmt::vformat("{}", fmt::make_format_args(42))); - EXPECT_EQ(L"42", - fmt::vformat(fmt::wstring_view(L"{}"), fmt::make_wformat_args(42))); -} - -TEST(module_test, vformat_to) { - auto store = fmt::make_format_args(42); - std::string s; - fmt::vformat_to(std::back_inserter(s), "{}", store); - EXPECT_EQ("42", s); - - char buffer[4] = {0}; - fmt::vformat_to(buffer, "{:}", store); - EXPECT_EQ("42", std::string_view(buffer)); - - auto wstore = fmt::make_wformat_args(42); - std::wstring w; - fmt::vformat_to(std::back_inserter(w), L"{}", wstore); - EXPECT_EQ(L"42", w); - - wchar_t wbuffer[4] = {0}; - fmt::vformat_to(wbuffer, L"{:}", wstore); - EXPECT_EQ(L"42", std::wstring_view(wbuffer)); -} - -TEST(module_test, vformat_to_n) { - auto store = fmt::make_format_args(12345); - std::string s; - auto result = fmt::vformat_to_n(std::back_inserter(s), 1, "{}", store); - char buffer[4] = {0}; - fmt::vformat_to_n(buffer, 3, "{:}", store); - - auto wstore = fmt::make_wformat_args(12345); - std::wstring w; - auto wresult = fmt::vformat_to_n(std::back_inserter(w), 1, - fmt::wstring_view(L"{}"), wstore); - wchar_t wbuffer[4] = {0}; - fmt::vformat_to_n(wbuffer, 3, fmt::wstring_view(L"{:}"), wstore); -} - -std::string as_string(std::wstring_view text) { - return {reinterpret_cast<const char*>(text.data()), - text.size() * sizeof(text[0])}; -} - -TEST(module_test, print) { - EXPECT_WRITE(stdout, fmt::print("{}µ", 42), "42µ"); - EXPECT_WRITE(stderr, fmt::print(stderr, "{}µ", 4.2), "4.2µ"); - EXPECT_WRITE(stdout, fmt::print(L"{}µ", 42), as_string(L"42µ")); - EXPECT_WRITE(stderr, fmt::print(stderr, L"{}µ", 4.2), as_string(L"4.2µ")); -} - -TEST(module_test, vprint) { - EXPECT_WRITE(stdout, fmt::vprint("{:}µ", fmt::make_format_args(42)), "42µ"); - EXPECT_WRITE(stderr, fmt::vprint(stderr, "{}", fmt::make_format_args(4.2)), - "4.2"); - EXPECT_WRITE(stdout, fmt::vprint(L"{:}µ", fmt::make_wformat_args(42)), - as_string(L"42µ")); - EXPECT_WRITE(stderr, fmt::vprint(stderr, L"{}", fmt::make_wformat_args(42)), - as_string(L"42")); -} - -TEST(module_test, named_args) { - EXPECT_EQ("42", fmt::format("{answer}", fmt::arg("answer", 42))); - EXPECT_EQ(L"42", fmt::format(L"{answer}", fmt::arg(L"answer", 42))); -} - -TEST(module_test, literals) { - using namespace fmt::literals; - EXPECT_EQ("42", fmt::format("{answer}", "answer"_a = 42)); - EXPECT_EQ(L"42", fmt::format(L"{answer}", L"answer"_a = 42)); -} - -TEST(module_test, locale) { - auto store = fmt::make_format_args(4.2); - const auto classic = std::locale::classic(); - EXPECT_EQ("4.2", fmt::format(classic, "{:L}", 4.2)); - EXPECT_EQ("4.2", fmt::vformat(classic, "{:L}", store)); - std::string s; - fmt::vformat_to(std::back_inserter(s), classic, "{:L}", store); - EXPECT_EQ("4.2", s); - EXPECT_EQ("4.2", fmt::format("{:L}", 4.2)); - - auto wstore = fmt::make_wformat_args(4.2); - EXPECT_EQ(L"4.2", fmt::format(classic, L"{:L}", 4.2)); - EXPECT_EQ(L"4.2", fmt::vformat(classic, L"{:L}", wstore)); - std::wstring w; - fmt::vformat_to(std::back_inserter(w), classic, L"{:L}", wstore); - EXPECT_EQ(L"4.2", w); - EXPECT_EQ(L"4.2", fmt::format(L"{:L}", 4.2)); -} - -TEST(module_test, string_view) { - fmt::string_view nsv("fmt"); - EXPECT_EQ("fmt", nsv); - EXPECT_TRUE(fmt::string_view("fmt") == nsv); - - fmt::wstring_view wsv(L"fmt"); - EXPECT_EQ(L"fmt", wsv); - EXPECT_TRUE(fmt::wstring_view(L"fmt") == wsv); -} - -TEST(module_test, memory_buffer) { - fmt::basic_memory_buffer<char, fmt::inline_buffer_size> buffer; - fmt::format_to(std::back_inserter(buffer), "{}", "42"); - EXPECT_EQ("42", to_string(buffer)); - fmt::memory_buffer nbuffer(std::move(buffer)); - EXPECT_EQ("42", to_string(nbuffer)); - buffer = std::move(nbuffer); - EXPECT_EQ("42", to_string(buffer)); - nbuffer.clear(); - EXPECT_EQ(0u, to_string(nbuffer).size()); - - fmt::wmemory_buffer wbuffer; - EXPECT_EQ(0u, to_string(wbuffer).size()); -} - -TEST(module_test, is_char) { - EXPECT_TRUE(fmt::is_char<char>()); - EXPECT_TRUE(fmt::is_char<wchar_t>()); - EXPECT_TRUE(fmt::is_char<char8_t>()); - EXPECT_TRUE(fmt::is_char<char16_t>()); - EXPECT_TRUE(fmt::is_char<char32_t>()); - EXPECT_FALSE(fmt::is_char<signed char>()); -} - -TEST(module_test, ptr) { - uintptr_t answer = 42; - auto p = std::bit_cast<int*>(answer); - EXPECT_EQ("0x2a", fmt::to_string(fmt::ptr(p))); - std::unique_ptr<int> up(p); - EXPECT_EQ("0x2a", fmt::to_string(fmt::ptr(up))); - up.release(); - auto sp = std::make_shared<int>(0); - p = sp.get(); - EXPECT_EQ(fmt::to_string(fmt::ptr(p)), fmt::to_string(fmt::ptr(sp))); -} - -TEST(module_test, errors) { - auto store = fmt::make_format_args(42); - EXPECT_THROW(throw fmt::format_error("oops"), std::exception); - EXPECT_THROW(throw fmt::vsystem_error(0, "{}", store), std::system_error); - EXPECT_THROW(throw fmt::system_error(0, "{}", 42), std::system_error); - - fmt::memory_buffer buffer; - fmt::format_system_error(buffer, 0, "oops"); - auto oops = to_string(buffer); - EXPECT_TRUE(oops.size() > 0); - EXPECT_WRITE(stderr, fmt::report_system_error(0, "oops"), oops + '\n'); - -#ifdef _WIN32 - EXPECT_THROW(throw fmt::vwindows_error(0, "{}", store), std::system_error); - EXPECT_THROW(throw fmt::windows_error(0, "{}", 42), std::system_error); - output_redirect redirect(stderr); - fmt::report_windows_error(0, "oops"); - EXPECT_TRUE(redirect.restore_and_read().size() > 0); -#endif -} - -TEST(module_test, error_code) { - EXPECT_EQ("generic:42", - fmt::format("{0}", std::error_code(42, std::generic_category()))); - EXPECT_EQ("system:42", - fmt::format("{0}", std::error_code(42, fmt::system_category()))); - EXPECT_EQ(L"generic:42", - fmt::format(L"{0}", std::error_code(42, std::generic_category()))); -} - -TEST(module_test, format_int) { - fmt::format_int sanswer(42); - EXPECT_EQ("42", fmt::string_view(sanswer.data(), sanswer.size())); - fmt::format_int uanswer(42u); - EXPECT_EQ("42", fmt::string_view(uanswer.data(), uanswer.size())); -} - -struct test_formatter : fmt::formatter<char> { - bool check() { return true; } -}; - -TEST(module_test, formatter) { EXPECT_TRUE(test_formatter{}.check()); } - -TEST(module_test, join) { - int arr[3] = {1, 2, 3}; - std::vector<double> vec{1.0, 2.0, 3.0}; - std::initializer_list<int> il{1, 2, 3}; - auto sep = fmt::string_view(", "); - EXPECT_EQ("1, 2, 3", to_string(fmt::join(arr + 0, arr + 3, sep))); - EXPECT_EQ("1, 2, 3", to_string(fmt::join(arr, sep))); - EXPECT_EQ("1, 2, 3", to_string(fmt::join(vec.begin(), vec.end(), sep))); - EXPECT_EQ("1, 2, 3", to_string(fmt::join(vec, sep))); - EXPECT_EQ("1, 2, 3", to_string(fmt::join(il, sep))); - - auto wsep = fmt::wstring_view(L", "); - EXPECT_EQ(L"1, 2, 3", fmt::format(L"{}", fmt::join(arr + 0, arr + 3, wsep))); - EXPECT_EQ(L"1, 2, 3", fmt::format(L"{}", fmt::join(arr, wsep))); - EXPECT_EQ(L"1, 2, 3", fmt::format(L"{}", fmt::join(il, wsep))); -} - -TEST(module_test, time) { - auto time_now = std::time(nullptr); - EXPECT_TRUE(fmt::localtime(time_now).tm_year > 120); - EXPECT_TRUE(fmt::gmtime(time_now).tm_year > 120); - auto chrono_now = std::chrono::system_clock::now(); - EXPECT_TRUE(fmt::gmtime(chrono_now).tm_year > 120); -} - -TEST(module_test, time_point) { - auto now = std::chrono::system_clock::now(); - std::string_view past("2021-05-20 10:30:15"); - EXPECT_TRUE(past < fmt::format("{:%Y-%m-%d %H:%M:%S}", now)); - std::wstring_view wpast(L"2021-05-20 10:30:15"); - EXPECT_TRUE(wpast < fmt::format(L"{:%Y-%m-%d %H:%M:%S}", now)); -} - -TEST(module_test, time_duration) { - using us = std::chrono::duration<double, std::micro>; - EXPECT_EQ("42s", fmt::format("{}", std::chrono::seconds{42})); - EXPECT_EQ("4.2µs", fmt::format("{:3.1}", us{4.234})); - EXPECT_EQ("4.2µs", fmt::format(std::locale::classic(), "{:L}", us{4.2})); - - EXPECT_EQ(L"42s", fmt::format(L"{}", std::chrono::seconds{42})); - EXPECT_EQ(L"4.2µs", fmt::format(L"{:3.1}", us{4.234})); - EXPECT_EQ(L"4.2µs", fmt::format(std::locale::classic(), L"{:L}", us{4.2})); -} - -TEST(module_test, weekday) { - EXPECT_EQ("Mon", fmt::format(std::locale::classic(), "{}", fmt::weekday(1))); -} - -TEST(module_test, printf) { - EXPECT_WRITE(stdout, fmt::printf("%f", 42.123456), "42.123456"); - EXPECT_WRITE(stdout, fmt::printf("%d", 42), "42"); - EXPECT_WRITE(stdout, fmt::printf(L"%f", 42.123456), as_string(L"42.123456")); - EXPECT_WRITE(stdout, fmt::printf(L"%d", 42), as_string(L"42")); -} - -TEST(module_test, fprintf) { - EXPECT_WRITE(stderr, fmt::fprintf(stderr, "%d", 42), "42"); - EXPECT_WRITE(stderr, fmt::fprintf(stderr, L"%d", 42), as_string(L"42")); -} - -TEST(module_test, sprintf) { - EXPECT_EQ("42", fmt::sprintf("%d", 42)); - EXPECT_EQ(L"42", fmt::sprintf(L"%d", 42)); -} - -TEST(module_test, vprintf) { - EXPECT_WRITE(stdout, fmt::vprintf("%d", fmt::make_printf_args(42)), "42"); - EXPECT_WRITE(stdout, fmt::vprintf(L"%d", fmt::make_wprintf_args(42)), - as_string(L"42")); -} - -TEST(module_test, vfprintf) { - auto args = fmt::make_printf_args(42); - EXPECT_WRITE(stderr, fmt::vfprintf(stderr, "%d", args), "42"); - auto wargs = fmt::make_wprintf_args(42); - EXPECT_WRITE(stderr, fmt::vfprintf(stderr, L"%d", wargs), as_string(L"42")); -} - -TEST(module_test, vsprintf) { - EXPECT_EQ("42", fmt::vsprintf("%d", fmt::make_printf_args(42))); - EXPECT_EQ(L"42", fmt::vsprintf(L"%d", fmt::make_wprintf_args(42))); -} - -TEST(module_test, color) { - auto fg_check = fg(fmt::rgb(255, 200, 30)); - auto bg_check = bg(fmt::color::dark_slate_gray) | fmt::emphasis::italic; - auto emphasis_check = fmt::emphasis::underline | fmt::emphasis::bold; - EXPECT_EQ("\x1B[30m42\x1B[0m", - fmt::format(fg(fmt::terminal_color::black), "{}", 42)); - EXPECT_EQ(L"\x1B[30m42\x1B[0m", - fmt::format(fg(fmt::terminal_color::black), L"{}", 42)); -} - -TEST(module_test, cstring_view) { - auto s = "fmt"; - EXPECT_EQ(s, fmt::cstring_view(s).c_str()); - auto w = L"fmt"; - EXPECT_EQ(w, fmt::wcstring_view(w).c_str()); -} - -TEST(module_test, buffered_file) { - EXPECT_TRUE(fmt::buffered_file{}.get() == nullptr); -} - -TEST(module_test, output_file) { -#ifdef __clang__ - fmt::println("\033[0;33m[=disabled=] {}\033[0;0m", - "Clang 16.0 emits multiple copies of vtables"); -#else - fmt::ostream out = fmt::output_file("module-test", fmt::buffer_size = 1); - out.close(); -#endif -} - -struct custom_context { - using char_type = char; - using parse_context_type = fmt::format_parse_context; -}; - -TEST(module_test, custom_context) { - fmt::basic_format_arg<custom_context> custom_arg; - EXPECT_TRUE(!custom_arg); -} - -TEST(module_test, compile_format_string) { - using namespace fmt::literals; -#ifdef __clang__ - fmt::println("\033[0;33m[=disabled=] {}\033[0;0m", - "Clang 16.0 fails to import user-defined literals"); -#else - EXPECT_EQ("42", fmt::format("{0:x}"_cf, 0x42)); - EXPECT_EQ(L"42", fmt::format(L"{:}"_cf, 42)); - EXPECT_EQ("4.2", fmt::format("{arg:3.1f}"_cf, "arg"_a = 4.2)); - EXPECT_EQ(L" 42", fmt::format(L"{arg:>3}"_cf, L"arg"_a = L"42")); -#endif -} diff --git a/thirdparty/fmt/test/no-builtin-types-test.cc b/thirdparty/fmt/test/no-builtin-types-test.cc deleted file mode 100644 index 75c7fd16c..000000000 --- a/thirdparty/fmt/test/no-builtin-types-test.cc +++ /dev/null @@ -1,25 +0,0 @@ -// Formatting library for C++ - formatting library tests -// -// Copyright (c) 2012 - present, Victor Zverovich -// All rights reserved. -// -// For the license information refer to format.h. - -#include "gtest/gtest.h" - -#if !defined(__GNUC__) || __GNUC__ >= 5 -# define FMT_BUILTIN_TYPES 0 -# include "fmt/format.h" - -TEST(no_builtin_types_test, format) { - EXPECT_EQ(fmt::format("{}", 42), "42"); - EXPECT_EQ(fmt::format("{}", 42L), "42"); -} - -TEST(no_builtin_types_test, double_is_custom_type) { - double d = 42; - auto args = fmt::make_format_args(d); - EXPECT_EQ(fmt::format_args(args).get(0).type(), - fmt::detail::type::custom_type); -} -#endif diff --git a/thirdparty/fmt/test/noexception-test.cc b/thirdparty/fmt/test/noexception-test.cc deleted file mode 100644 index 0e44e13bb..000000000 --- a/thirdparty/fmt/test/noexception-test.cc +++ /dev/null @@ -1,18 +0,0 @@ -// Formatting library for C++ - Noexception tests -// -// Copyright (c) 2012 - present, Victor Zverovich -// All rights reserved. -// -// For the license information refer to format.h. - -#include "fmt/args.h" -#include "fmt/base.h" -#include "fmt/chrono.h" -#include "fmt/color.h" -#include "fmt/compile.h" -#include "fmt/format.h" -#include "fmt/os.h" -#include "fmt/ostream.h" -#include "fmt/printf.h" -#include "fmt/ranges.h" -#include "fmt/xchar.h" diff --git a/thirdparty/fmt/test/os-test.cc b/thirdparty/fmt/test/os-test.cc deleted file mode 100644 index e789e87e9..000000000 --- a/thirdparty/fmt/test/os-test.cc +++ /dev/null @@ -1,599 +0,0 @@ -// Formatting library for C++ - tests of the OS-specific functionality -// -// Copyright (c) 2012 - present, Victor Zverovich -// All rights reserved. -// -// For the license information refer to format.h. - -#include "fmt/os.h" - -#include <cstdlib> // std::exit -#include <cstring> -#include <memory> -#include <thread> - -#include "gtest-extra.h" -#include "util.h" - -using fmt::buffered_file; -using testing::HasSubstr; -using wstring_view = fmt::basic_string_view<wchar_t>; - -static auto uniq_file_name(unsigned line_number) -> std::string { - return "test-file" + std::to_string(line_number); -} - -auto safe_fopen(const char* filename, const char* mode) -> FILE* { -#if defined(_WIN32) && !defined(__MINGW32__) - // Fix MSVC warning about "unsafe" fopen. - FILE* f = nullptr; - errno = fopen_s(&f, filename, mode); - return f; -#else - return std::fopen(filename, mode); -#endif -} - -#ifdef _WIN32 - -# include <windows.h> - -TEST(os_test, format_windows_error) { - LPWSTR message = nullptr; - auto result = FormatMessageW( - FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM | - FORMAT_MESSAGE_IGNORE_INSERTS, - nullptr, ERROR_FILE_EXISTS, MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT), - reinterpret_cast<LPWSTR>(&message), 0, nullptr); - auto utf8_message = - fmt::detail::to_utf8<wchar_t>(wstring_view(message, result - 2)); - LocalFree(message); - fmt::memory_buffer actual_message; - fmt::detail::format_windows_error(actual_message, ERROR_FILE_EXISTS, "test"); - EXPECT_EQ(fmt::format("test: {}", utf8_message.str()), - fmt::to_string(actual_message)); - actual_message.resize(0); -} - -TEST(os_test, format_long_windows_error) { - LPWSTR message = nullptr; - // this error code is not available on all Windows platforms and - // Windows SDKs, so do not fail the test if the error string cannot - // be retrieved. - int provisioning_not_allowed = 0x80284013L; // TBS_E_PROVISIONING_NOT_ALLOWED - auto result = FormatMessageW( - FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM | - FORMAT_MESSAGE_IGNORE_INSERTS, - nullptr, static_cast<DWORD>(provisioning_not_allowed), - MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT), - reinterpret_cast<LPWSTR>(&message), 0, nullptr); - if (result == 0) { - LocalFree(message); - return; - } - auto utf8_message = - fmt::detail::to_utf8<wchar_t>(wstring_view(message, result - 2)); - LocalFree(message); - fmt::memory_buffer actual_message; - fmt::detail::format_windows_error(actual_message, provisioning_not_allowed, - "test"); - EXPECT_EQ(fmt::format("test: {}", utf8_message.str()), - fmt::to_string(actual_message)); -} - -TEST(os_test, windows_error) { - auto error = std::system_error(std::error_code()); - try { - throw fmt::windows_error(ERROR_FILE_EXISTS, "test {}", "error"); - } catch (const std::system_error& e) { - error = e; - } - fmt::memory_buffer message; - fmt::detail::format_windows_error(message, ERROR_FILE_EXISTS, "test error"); - EXPECT_THAT(error.what(), HasSubstr(to_string(message))); - EXPECT_EQ(ERROR_FILE_EXISTS, error.code().value()); -} - -TEST(os_test, report_windows_error) { - fmt::memory_buffer out; - fmt::detail::format_windows_error(out, ERROR_FILE_EXISTS, "test error"); - out.push_back('\n'); - EXPECT_WRITE(stderr, - fmt::report_windows_error(ERROR_FILE_EXISTS, "test error"), - fmt::to_string(out)); -} - -# if FMT_USE_FCNTL && !defined(__MINGW32__) -TEST(file_test, open_windows_file) { - using fmt::file; - file out = file::open_windows_file(L"test-file", - file::WRONLY | file::CREATE | file::TRUNC); - out.write("x", 1); - file in = file::open_windows_file(L"test-file", file::RDONLY); - EXPECT_READ(in, "x"); -} -# endif // FMT_USE_FCNTL && !defined(__MINGW32__) - -#endif // _WIN32 - -#if FMT_USE_FCNTL - -using fmt::file; - -auto isclosed(int fd) -> bool { - char buffer; - auto result = std::streamsize(); - SUPPRESS_ASSERT(result = FMT_POSIX(read(fd, &buffer, 1))); - return result == -1 && errno == EBADF; -} - -// Opens a file for reading. -auto open_file() -> file { - auto pipe = fmt::pipe(); - pipe.write_end.write(file_content, std::strlen(file_content)); - pipe.write_end.close(); - return std::move(pipe.read_end); -} - -// Attempts to write a string to a file. -void write(file& f, fmt::string_view s) { - size_t num_chars_left = s.size(); - const char* ptr = s.data(); - do { - size_t count = f.write(ptr, num_chars_left); - ptr += count; - // We can't write more than size_t bytes since num_chars_left - // has type size_t. - num_chars_left -= count; - } while (num_chars_left != 0); -} - -TEST(buffered_file_test, default_ctor) { - auto f = buffered_file(); - EXPECT_TRUE(f.get() == nullptr); -} - -TEST(buffered_file_test, move_ctor) { - buffered_file bf = open_buffered_file(); - FILE* fp = bf.get(); - EXPECT_TRUE(fp != nullptr); - buffered_file bf2(std::move(bf)); - EXPECT_EQ(fp, bf2.get()); - EXPECT_TRUE(bf.get() == nullptr); -} - -TEST(buffered_file_test, move_assignment) { - buffered_file bf = open_buffered_file(); - FILE* fp = bf.get(); - EXPECT_TRUE(fp != nullptr); - buffered_file bf2; - bf2 = std::move(bf); - EXPECT_EQ(fp, bf2.get()); - EXPECT_TRUE(bf.get() == nullptr); -} - -TEST(buffered_file_test, move_assignment_closes_file) { - buffered_file bf = open_buffered_file(); - buffered_file bf2 = open_buffered_file(); - int old_fd = bf2.descriptor(); - bf2 = std::move(bf); - EXPECT_TRUE(isclosed(old_fd)); -} - -TEST(buffered_file_test, move_from_temporary_in_ctor) { - FILE* fp = nullptr; - buffered_file f = open_buffered_file(&fp); - EXPECT_EQ(fp, f.get()); -} - -TEST(buffered_file_test, move_from_temporary_in_assignment) { - FILE* fp = nullptr; - auto f = buffered_file(); - f = open_buffered_file(&fp); - EXPECT_EQ(fp, f.get()); -} - -TEST(buffered_file_test, move_from_temporary_in_assignment_closes_file) { - buffered_file f = open_buffered_file(); - int old_fd = f.descriptor(); - f = open_buffered_file(); - EXPECT_TRUE(isclosed(old_fd)); -} - -TEST(buffered_file_test, close_file_in_dtor) { - int fd = 0; - { - buffered_file f = open_buffered_file(); - fd = f.descriptor(); - } - EXPECT_TRUE(isclosed(fd)); -} - -TEST(buffered_file_test, close_error_in_dtor) { - auto f = - std::unique_ptr<buffered_file>(new buffered_file(open_buffered_file())); - EXPECT_WRITE( - stderr, - { - // The close function must be called inside EXPECT_WRITE, - // otherwise the system may recycle closed file descriptor when - // redirecting the output in EXPECT_STDERR and the second close - // will break output redirection. - FMT_POSIX(close(f->descriptor())); - SUPPRESS_ASSERT(f.reset(nullptr)); - }, - system_error_message(EBADF, "cannot close file") + "\n"); -} - -TEST(buffered_file_test, close) { - buffered_file f = open_buffered_file(); - int fd = f.descriptor(); - f.close(); - EXPECT_TRUE(f.get() == nullptr); - EXPECT_TRUE(isclosed(fd)); -} - -TEST(buffered_file_test, close_error) { - buffered_file f = open_buffered_file(); - FMT_POSIX(close(f.descriptor())); - EXPECT_SYSTEM_ERROR_NOASSERT(f.close(), EBADF, "cannot close file"); - EXPECT_TRUE(f.get() == nullptr); -} - -TEST(buffered_file_test, descriptor) { - auto f = open_buffered_file(); - EXPECT_TRUE(f.descriptor() != -1); - file copy = file::dup(f.descriptor()); - EXPECT_READ(copy, file_content); -} - -TEST(ostream_test, move) { - fmt::ostream out = fmt::output_file(uniq_file_name(__LINE__)); - fmt::ostream moved(std::move(out)); - moved.print("hello"); -} - -TEST(ostream_test, move_while_holding_data) { - auto test_file = uniq_file_name(__LINE__); - { - fmt::ostream out = fmt::output_file(test_file); - out.print("Hello, "); - fmt::ostream moved(std::move(out)); - moved.print("world!\n"); - } - { - file in(test_file, file::RDONLY); - EXPECT_READ(in, "Hello, world!\n"); - } -} - -TEST(ostream_test, print) { - auto test_file = uniq_file_name(__LINE__); - fmt::ostream out = fmt::output_file(test_file); - out.print("The answer is {}.\n", 42); - out.close(); - file in(test_file, file::RDONLY); - EXPECT_READ(in, "The answer is 42.\n"); -} - -TEST(ostream_test, buffer_boundary) { - auto str = std::string(4096, 'x'); - auto test_file = uniq_file_name(__LINE__); - fmt::ostream out = fmt::output_file(test_file); - out.print("{}", str); - out.print("{}", str); - out.close(); - file in(test_file, file::RDONLY); - EXPECT_READ(in, str + str); -} - -TEST(ostream_test, buffer_size) { - auto test_file = uniq_file_name(__LINE__); - fmt::ostream out = fmt::output_file(test_file, fmt::buffer_size = 1); - out.print("{}", "foo"); - out.close(); - file in(test_file, file::RDONLY); - EXPECT_READ(in, "foo"); -} - -TEST(ostream_test, truncate) { - auto test_file = uniq_file_name(__LINE__); - { - fmt::ostream out = fmt::output_file(test_file); - out.print("0123456789"); - } - { - fmt::ostream out = fmt::output_file(test_file); - out.print("foo"); - } - file in(test_file, file::RDONLY); - EXPECT_EQ("foo", read(in, 4)); -} - -TEST(ostream_test, flush) { - auto test_file = uniq_file_name(__LINE__); - auto out = fmt::output_file(test_file); - out.print("x"); - out.flush(); - auto in = fmt::file(test_file, file::RDONLY); - EXPECT_READ(in, "x"); -} - -TEST(file_test, default_ctor) { - file f; - EXPECT_EQ(-1, f.descriptor()); -} - -TEST(file_test, open_buffered_file_in_ctor) { - auto test_file = uniq_file_name(__LINE__); - FILE* fp = safe_fopen(test_file.c_str(), "w"); - std::fputs(file_content, fp); - std::fclose(fp); - file f(test_file.c_str(), file::RDONLY); - // Check if the file is open by reading one character from it. - char buffer; - bool isopen = FMT_POSIX(read(f.descriptor(), &buffer, 1)) == 1; - ASSERT_TRUE(isopen); -} - -TEST(file_test, open_buffered_file_error) { - EXPECT_SYSTEM_ERROR(file("nonexistent", file::RDONLY), ENOENT, - "cannot open file nonexistent"); -} - -TEST(file_test, move_ctor) { - file f = open_file(); - int fd = f.descriptor(); - EXPECT_NE(-1, fd); - file f2(std::move(f)); - EXPECT_EQ(fd, f2.descriptor()); - EXPECT_EQ(-1, f.descriptor()); -} - -TEST(file_test, move_assignment) { - file f = open_file(); - int fd = f.descriptor(); - EXPECT_NE(-1, fd); - file f2; - f2 = std::move(f); - EXPECT_EQ(fd, f2.descriptor()); - EXPECT_EQ(-1, f.descriptor()); -} - -TEST(file_test, move_assignment_closes_file) { - file f = open_file(); - file f2 = open_file(); - int old_fd = f2.descriptor(); - f2 = std::move(f); - EXPECT_TRUE(isclosed(old_fd)); -} - -file open_buffered_file(int& fd) { - file f = open_file(); - fd = f.descriptor(); - return f; -} - -TEST(file_test, move_from_temporary_in_ctor) { - int fd = 0xdead; - file f(open_buffered_file(fd)); - EXPECT_EQ(fd, f.descriptor()); -} - -TEST(file_test, move_from_temporary_in_assignment) { - int fd = 0xdead; - file f; - f = open_buffered_file(fd); - EXPECT_EQ(fd, f.descriptor()); -} - -TEST(file_test, move_from_temporary_in_assignment_closes_file) { - int fd = 0xdead; - file f = open_file(); - int old_fd = f.descriptor(); - f = open_buffered_file(fd); - EXPECT_TRUE(isclosed(old_fd)); -} - -TEST(file_test, close_file_in_dtor) { - int fd = 0; - { - file f = open_file(); - fd = f.descriptor(); - } - EXPECT_TRUE(isclosed(fd)); -} - -TEST(file_test, close_error_in_dtor) { - std::unique_ptr<file> f(new file(open_file())); - EXPECT_WRITE( - stderr, - { - // The close function must be called inside EXPECT_WRITE, - // otherwise the system may recycle closed file descriptor when - // redirecting the output in EXPECT_STDERR and the second close - // will break output redirection. - FMT_POSIX(close(f->descriptor())); - SUPPRESS_ASSERT(f.reset(nullptr)); - }, - system_error_message(EBADF, "cannot close file") + "\n"); -} - -TEST(file_test, close) { - file f = open_file(); - int fd = f.descriptor(); - f.close(); - EXPECT_EQ(-1, f.descriptor()); - EXPECT_TRUE(isclosed(fd)); -} - -TEST(file_test, close_error) { - file f = open_file(); - FMT_POSIX(close(f.descriptor())); - EXPECT_SYSTEM_ERROR_NOASSERT(f.close(), EBADF, "cannot close file"); - EXPECT_EQ(-1, f.descriptor()); -} - -TEST(file_test, read) { - file f = open_file(); - EXPECT_READ(f, file_content); -} - -TEST(file_test, read_error) { - file f(uniq_file_name(__LINE__), file::WRONLY | file::CREATE); - char buf; - // We intentionally read from a file opened in the write-only mode to - // cause error. - EXPECT_SYSTEM_ERROR(f.read(&buf, 1), EBADF, "cannot read from file"); -} - -TEST(file_test, write) { - auto pipe = fmt::pipe(); - write(pipe.write_end, "test"); - pipe.write_end.close(); - EXPECT_READ(pipe.read_end, "test"); -} - -TEST(file_test, write_error) { - file f(uniq_file_name(__LINE__), file::RDONLY | file::CREATE); - // We intentionally write to a file opened in the read-only mode to - // cause error. - EXPECT_SYSTEM_ERROR(f.write(" ", 1), EBADF, "cannot write to file"); -} - -TEST(file_test, dup) { - file f = open_file(); - file copy = file::dup(f.descriptor()); - EXPECT_NE(f.descriptor(), copy.descriptor()); - EXPECT_EQ(file_content, read(copy, std::strlen(file_content))); -} - -# ifndef __COVERITY__ -TEST(file_test, dup_error) { - int value = -1; - EXPECT_SYSTEM_ERROR_NOASSERT(file::dup(value), EBADF, - "cannot duplicate file descriptor -1"); -} -# endif - -TEST(file_test, dup2) { - file f = open_file(); - file copy = open_file(); - f.dup2(copy.descriptor()); - EXPECT_NE(f.descriptor(), copy.descriptor()); - EXPECT_READ(copy, file_content); -} - -TEST(file_test, dup2_error) { - file f = open_file(); - EXPECT_SYSTEM_ERROR_NOASSERT( - f.dup2(-1), EBADF, - fmt::format("cannot duplicate file descriptor {} to -1", f.descriptor())); -} - -TEST(file_test, dup2_noexcept) { - file f = open_file(); - file copy = open_file(); - std::error_code ec; - f.dup2(copy.descriptor(), ec); - EXPECT_EQ(ec.value(), 0); - EXPECT_NE(f.descriptor(), copy.descriptor()); - EXPECT_READ(copy, file_content); -} - -TEST(file_test, dup2_noexcept_error) { - file f = open_file(); - std::error_code ec; - SUPPRESS_ASSERT(f.dup2(-1, ec)); - EXPECT_EQ(EBADF, ec.value()); -} - -TEST(file_test, pipe) { - auto pipe = fmt::pipe(); - EXPECT_NE(-1, pipe.read_end.descriptor()); - EXPECT_NE(-1, pipe.write_end.descriptor()); - write(pipe.write_end, "test"); - EXPECT_READ(pipe.read_end, "test"); -} - -TEST(file_test, fdopen) { - auto pipe = fmt::pipe(); - int read_fd = pipe.read_end.descriptor(); - EXPECT_EQ(read_fd, FMT_POSIX(fileno(pipe.read_end.fdopen("r").get()))); -} - -// Windows CRT implements _IOLBF incorrectly (full buffering). -# ifndef _WIN32 -TEST(file_test, line_buffering) { - auto pipe = fmt::pipe(); - - int write_fd = pipe.write_end.descriptor(); - auto write_end = pipe.write_end.fdopen("w"); - setvbuf(write_end.get(), nullptr, _IOLBF, 4096); - write_end.print("42\n"); - close(write_fd); - try { - write_end.close(); - } catch (const std::system_error&) { - } - - auto read_end = pipe.read_end.fdopen("r"); - std::thread reader([&]() { - int n = 0; - int result = fscanf(read_end.get(), "%d", &n); - (void)result; - EXPECT_EQ(n, 42); - }); - - reader.join(); -} -# endif // _WIN32 - -TEST(file_test, buffer_boundary) { - auto pipe = fmt::pipe(); - - auto write_end = pipe.write_end.fdopen("w"); - setvbuf(write_end.get(), nullptr, _IOFBF, 4096); - for (int i = 3; i < 4094; i++) - write_end.print("{}", (i % 73) != 0 ? 'x' : '\n'); - write_end.print("{} {}", 1234, 567); - write_end.close(); - - auto read_end = pipe.read_end.fdopen("r"); - char buf[4091] = {}; - size_t n = fread(buf, 1, sizeof(buf), read_end.get()); - EXPECT_EQ(n, sizeof(buf)); - EXPECT_STREQ(fgets(buf, sizeof(buf), read_end.get()), "1234 567"); -} - -TEST(file_test, io_putting) { - auto pipe = fmt::pipe(); - auto read_end = pipe.read_end.fdopen("r"); - auto write_end = pipe.write_end.fdopen("w"); - - size_t read_size = 0; - auto reader = std::thread([&]() { - size_t n = 0; - do { - char buf[4096] = {}; - n = fread(buf, 1, sizeof(buf), read_end.get()); - read_size += n; - } while (n != 0); - }); - - // This initialize buffers but doesn't set _IO_CURRENTLY_PUTTING. - fseek(write_end.get(), 0, SEEK_SET); - - size_t write_size = 0; - for (int i = 0; i <= 20000; ++i) { - auto s = fmt::format("{}\n", i); - fmt::print(write_end.get(), "{}", s); - write_size += s.size(); - } - - write_end.close(); - reader.join(); - EXPECT_EQ(read_size, write_size); -} - -#endif // FMT_USE_FCNTL diff --git a/thirdparty/fmt/test/ostream-test.cc b/thirdparty/fmt/test/ostream-test.cc deleted file mode 100644 index cc28885a4..000000000 --- a/thirdparty/fmt/test/ostream-test.cc +++ /dev/null @@ -1,308 +0,0 @@ -// Formatting library for C++ - std::ostream support tests -// -// Copyright (c) 2012 - present, Victor Zverovich -// All rights reserved. -// -// For the license information refer to format.h. - -#include <fstream> - -#include "fmt/format.h" - -using fmt::runtime; - -struct test {}; - -// Test that there is no issues with specializations when fmt/ostream.h is -// included after fmt/format.h. -namespace fmt { -template <> struct formatter<test> : formatter<int> { - auto format(const test&, format_context& ctx) const -> decltype(ctx.out()) { - return formatter<int>::format(42, ctx); - } -}; -} // namespace fmt - -#include <sstream> - -#include "fmt/compile.h" -#include "fmt/ostream.h" -#include "fmt/ranges.h" -#include "gmock/gmock.h" -#include "gtest-extra.h" -#include "util.h" - -auto operator<<(std::ostream& os, const date& d) -> std::ostream& { - os << d.year() << '-' << d.month() << '-' << d.day(); - return os; -} - -auto operator<<(std::wostream& os, const date& d) -> std::wostream& { - os << d.year() << L'-' << d.month() << L'-' << d.day(); - return os; -} - -// Make sure that overloaded comma operators do no harm to is_streamable. -struct type_with_comma_op {}; -template <typename T> void operator,(type_with_comma_op, const T&); -template <typename T> type_with_comma_op operator<<(T&, const date&); - -enum streamable_enum {}; - -auto operator<<(std::ostream& os, streamable_enum) -> std::ostream& { - return os << "streamable_enum"; -} - -enum unstreamable_enum {}; -auto format_as(unstreamable_enum e) -> int { return e; } - -struct empty_test {}; -auto operator<<(std::ostream& os, empty_test) -> std::ostream& { - return os << ""; -} - -namespace fmt { -template <> struct formatter<test_string> : ostream_formatter {}; -template <> struct formatter<date> : ostream_formatter {}; -template <> struct formatter<streamable_enum> : ostream_formatter {}; -template <> struct formatter<empty_test> : ostream_formatter {}; -} // namespace fmt - -TEST(ostream_test, enum) { - EXPECT_EQ("streamable_enum", fmt::format("{}", streamable_enum())); - EXPECT_EQ("0", fmt::format("{}", unstreamable_enum())); -} - -TEST(ostream_test, format) { - EXPECT_EQ("a string", fmt::format("{0}", test_string("a string"))); - EXPECT_EQ("The date is 2012-12-9", - fmt::format("The date is {0}", date(2012, 12, 9))); -} - -TEST(ostream_test, format_specs) { - using fmt::format_error; - EXPECT_EQ("def ", fmt::format("{0:<5}", test_string("def"))); - EXPECT_EQ(" def", fmt::format("{0:>5}", test_string("def"))); - EXPECT_EQ(" def ", fmt::format("{0:^5}", test_string("def"))); - EXPECT_EQ("def**", fmt::format("{0:*<5}", test_string("def"))); - EXPECT_THROW_MSG((void)fmt::format(runtime("{0:+}"), test_string()), - format_error, "invalid format specifier"); - EXPECT_THROW_MSG((void)fmt::format(runtime("{0:-}"), test_string()), - format_error, "invalid format specifier"); - EXPECT_THROW_MSG((void)fmt::format(runtime("{0: }"), test_string()), - format_error, "invalid format specifier"); - EXPECT_THROW_MSG((void)fmt::format(runtime("{0:#}"), test_string()), - format_error, "invalid format specifier"); - EXPECT_THROW_MSG((void)fmt::format(runtime("{0:05}"), test_string()), - format_error, "format specifier requires numeric argument"); - EXPECT_EQ("test ", fmt::format("{0:13}", test_string("test"))); - EXPECT_EQ("test ", fmt::format("{0:{1}}", test_string("test"), 13)); - EXPECT_EQ("te", fmt::format("{0:.2}", test_string("test"))); - EXPECT_EQ("te", fmt::format("{0:.{1}}", test_string("test"), 2)); -} - -TEST(ostream_test, empty_custom_output) { - EXPECT_EQ("", fmt::format("{}", empty_test())); -} - -TEST(ostream_test, print) { - { - std::ostringstream os; - fmt::print(os, "Don't {}!", "panic"); - EXPECT_EQ("Don't panic!", os.str()); - } - - { - std::ostringstream os; - fmt::println(os, "Don't {}!", "panic"); - EXPECT_EQ("Don't panic!\n", os.str()); - } -} - -TEST(ostream_test, write_to_ostream) { - std::ostringstream os; - fmt::memory_buffer buffer; - const char* foo = "foo"; - buffer.append(foo, foo + std::strlen(foo)); - fmt::detail::write_buffer(os, buffer); - EXPECT_EQ("foo", os.str()); -} - -TEST(ostream_test, write_to_ostream_max_size) { - auto max_size = fmt::detail::max_value<size_t>(); - auto max_streamsize = fmt::detail::max_value<std::streamsize>(); - if (max_size <= fmt::detail::to_unsigned(max_streamsize)) return; - - struct test_buffer final : fmt::detail::buffer<char> { - explicit test_buffer(size_t size) - : fmt::detail::buffer<char>([](buffer<char>&, size_t) {}, nullptr, size, - size) {} - } buffer(max_size); - - struct mock_streambuf : std::streambuf { - MOCK_METHOD(std::streamsize, xsputn, (const void*, std::streamsize)); - auto xsputn(const char* s, std::streamsize n) -> std::streamsize override { - const void* v = s; - return xsputn(v, n); - } - } streambuf; - - struct test_ostream : std::ostream { - explicit test_ostream(mock_streambuf& output_buffer) - : std::ostream(&output_buffer) {} - } os(streambuf); - - testing::InSequence sequence; - const char* data = nullptr; - using ustreamsize = std::make_unsigned<std::streamsize>::type; - ustreamsize size = max_size; - do { - auto n = std::min(size, fmt::detail::to_unsigned(max_streamsize)); - EXPECT_CALL(streambuf, xsputn(data, static_cast<std::streamsize>(n))) - .WillOnce(testing::Return(max_streamsize)); - data += n; - size -= n; - } while (size != 0); - fmt::detail::write_buffer(os, buffer); -} - -TEST(ostream_test, join) { - int v[3] = {1, 2, 3}; - EXPECT_EQ("1, 2, 3", fmt::format("{}", fmt::join(v, v + 3, ", "))); -} - -TEST(ostream_test, join_fallback_formatter) { - auto strs = std::vector<test_string>{test_string("foo"), test_string("bar")}; - EXPECT_EQ("foo, bar", fmt::format("{}", fmt::join(strs, ", "))); -} - -#if FMT_USE_CONSTEXPR -TEST(ostream_test, constexpr_string) { - EXPECT_EQ("42", fmt::format(FMT_STRING("{}"), std::string("42"))); - EXPECT_EQ("a string", - fmt::format(FMT_STRING("{0}"), test_string("a string"))); -} -#endif - -namespace fmt_test { -struct abc {}; - -template <typename Output> auto operator<<(Output& out, abc) -> Output& { - return out << "abc"; -} -} // namespace fmt_test - -template <typename T> struct test_template {}; - -template <typename T> -auto operator<<(std::ostream& os, test_template<T>) -> std::ostream& { - return os << 1; -} - -namespace fmt { -template <typename T> struct formatter<test_template<T>> : formatter<int> { - auto format(test_template<T>, format_context& ctx) const - -> decltype(ctx.out()) { - return formatter<int>::format(2, ctx); - } -}; - -template <> struct formatter<fmt_test::abc> : ostream_formatter {}; -} // namespace fmt - -TEST(ostream_test, template) { - EXPECT_EQ("2", fmt::format("{}", test_template<int>())); -} - -TEST(ostream_test, format_to_n) { - char buffer[4]; - buffer[3] = 'x'; - auto result = fmt::format_to_n(buffer, 3, "{}", fmt_test::abc()); - EXPECT_EQ(3u, result.size); - EXPECT_EQ(buffer + 3, result.out); - EXPECT_EQ("abcx", fmt::string_view(buffer, 4)); - result = fmt::format_to_n(buffer, 3, "x{}y", fmt_test::abc()); - EXPECT_EQ(5u, result.size); - EXPECT_EQ(buffer + 3, result.out); - EXPECT_EQ("xabx", fmt::string_view(buffer, 4)); -} - -struct copyfmt_test {}; - -std::ostream& operator<<(std::ostream& os, copyfmt_test) { - std::ios ios(nullptr); - ios.copyfmt(os); - return os << "foo"; -} - -namespace fmt { -template <> struct formatter<copyfmt_test> : ostream_formatter {}; -} // namespace fmt - -TEST(ostream_test, copyfmt) { - EXPECT_EQ("foo", fmt::format("{}", copyfmt_test())); -} - -TEST(ostream_test, to_string) { - EXPECT_EQ("abc", fmt::to_string(fmt_test::abc())); -} - -TEST(ostream_test, range) { - auto strs = std::vector<test_string>{test_string("foo"), test_string("bar")}; - EXPECT_EQ("[foo, bar]", fmt::format("{}", strs)); -} - -struct abstract { - virtual ~abstract() = default; - virtual void f() = 0; - friend auto operator<<(std::ostream& os, const abstract&) -> std::ostream& { - return os; - } -}; - -namespace fmt { -template <> struct formatter<abstract> : ostream_formatter {}; -} // namespace fmt - -void format_abstract_compiles(const abstract& a) { - fmt::format(FMT_COMPILE("{}"), a); -} - -TEST(ostream_test, is_formattable) { - EXPECT_TRUE(fmt::is_formattable<std::string>()); - EXPECT_TRUE(fmt::is_formattable<fmt::detail::std_string_view<char>>()); -} - -struct streamable_and_unformattable {}; - -auto operator<<(std::ostream& os, streamable_and_unformattable) - -> std::ostream& { - return os << "foo"; -} - -TEST(ostream_test, streamed) { - EXPECT_FALSE(fmt::is_formattable<streamable_and_unformattable>()); - EXPECT_EQ(fmt::format("{}", fmt::streamed(streamable_and_unformattable())), - "foo"); -} - -TEST(ostream_test, closed_ofstream) { - std::ofstream ofs; - fmt::print(ofs, "discard"); -} - -struct unlocalized {}; - -auto operator<<(std::ostream& os, unlocalized) -> std::ostream& { - return os << 12345; -} - -namespace fmt { -template <> struct formatter<unlocalized> : ostream_formatter {}; -} // namespace fmt - -TEST(ostream_test, unlocalized) { - auto loc = get_locale("en_US.UTF-8"); - std::locale::global(loc); - EXPECT_EQ(fmt::format(loc, "{}", unlocalized()), "12345"); -} diff --git a/thirdparty/fmt/test/perf-sanity.cc b/thirdparty/fmt/test/perf-sanity.cc deleted file mode 100644 index aa0c0caef..000000000 --- a/thirdparty/fmt/test/perf-sanity.cc +++ /dev/null @@ -1,25 +0,0 @@ -// A quick and dirty performance test. -// For actual benchmarks see https://github.com/fmtlib/format-benchmark. - -#include <atomic> -#include <chrono> -#include <iterator> - -#include "fmt/format.h" - -int main() { - const int n = 10000000; - - auto start = std::chrono::steady_clock::now(); - for (int iteration = 0; iteration < n; ++iteration) { - auto buf = fmt::memory_buffer(); - fmt::format_to(std::back_inserter(buf), - "Hello, {}. The answer is {} and {}.", 1, 2345, 6789); - } - std::atomic_signal_fence(std::memory_order_acq_rel); // Clobber memory. - auto end = std::chrono::steady_clock::now(); - - // Print time in milliseconds. - std::chrono::duration<double> duration = end - start; - fmt::print("{:.1f}\n", duration.count() * 1000); -} diff --git a/thirdparty/fmt/test/posix-mock-test.cc b/thirdparty/fmt/test/posix-mock-test.cc deleted file mode 100644 index bcd330d4a..000000000 --- a/thirdparty/fmt/test/posix-mock-test.cc +++ /dev/null @@ -1,442 +0,0 @@ -// Tests of the C++ interface to POSIX functions that require mocks -// -// Copyright (c) 2012 - present, Victor Zverovich -// All rights reserved. -// -// For the license information refer to format.h. - -// Disable bogus MSVC warnings. -#if !defined(_CRT_SECURE_NO_WARNINGS) && defined(_MSC_VER) -# define _CRT_SECURE_NO_WARNINGS -#endif - -#include "posix-mock.h" - -#include <errno.h> -#include <fcntl.h> - -#include <climits> -#include <memory> - -#include "../src/os.cc" - -#ifdef _WIN32 -# include <io.h> -# undef max -#endif - -#include "gmock/gmock.h" -#include "gtest-extra.h" -#include "util.h" - -using fmt::buffered_file; - -using testing::_; -using testing::Return; -using testing::StrEq; - -template <typename Mock> struct scoped_mock : testing::StrictMock<Mock> { - scoped_mock() { Mock::instance = this; } - ~scoped_mock() { Mock::instance = nullptr; } -}; - -namespace { -int open_count; -int close_count; -int dup_count; -int dup2_count; -int fdopen_count; -int read_count; -int write_count; -int pipe_count; -int fopen_count; -int fclose_count; -int fileno_count; -size_t read_nbyte; -size_t write_nbyte; -bool sysconf_error; - -enum { none, max_size, error } fstat_sim; -} // namespace - -#define EMULATE_EINTR(func, error_result) \ - if (func##_count != 0) { \ - if (func##_count++ != 3) { \ - errno = EINTR; \ - return error_result; \ - } \ - } - -#ifndef _MSC_VER -int test::open(const char* path, int oflag, int mode) { - EMULATE_EINTR(open, -1); - return ::open(path, oflag, mode); -} -#endif - -#ifndef _WIN32 - -long test::sysconf(int name) { - long result = ::sysconf(name); - if (!sysconf_error) return result; - // Simulate an error. - errno = EINVAL; - return -1; -} - -static off_t max_file_size() { return std::numeric_limits<off_t>::max(); } - -int test::fstat(int fd, struct stat* buf) { - int result = ::fstat(fd, buf); - if (fstat_sim == max_size) buf->st_size = max_file_size(); - return result; -} - -#else - -static LONGLONG max_file_size() { return std::numeric_limits<LONGLONG>::max(); } - -DWORD test::GetFileSize(HANDLE hFile, LPDWORD lpFileSizeHigh) { - if (fstat_sim == error) { - SetLastError(ERROR_ACCESS_DENIED); - return INVALID_FILE_SIZE; - } - if (fstat_sim == max_size) { - DWORD max = std::numeric_limits<DWORD>::max(); - *lpFileSizeHigh = max >> 1; - return max; - } - return ::GetFileSize(hFile, lpFileSizeHigh); -} - -#endif - -int test::close(int fildes) { - // Close the file first because close shouldn't be retried. - int result = ::FMT_POSIX(close(fildes)); - EMULATE_EINTR(close, -1); - return result; -} - -int test::dup(int fildes) { - EMULATE_EINTR(dup, -1); - return ::FMT_POSIX(dup(fildes)); -} - -int test::dup2(int fildes, int fildes2) { - EMULATE_EINTR(dup2, -1); - return ::FMT_POSIX(dup2(fildes, fildes2)); -} - -FILE* test::fdopen(int fildes, const char* mode) { - EMULATE_EINTR(fdopen, nullptr); - return ::FMT_POSIX(fdopen(fildes, mode)); -} - -test::ssize_t test::read(int fildes, void* buf, test::size_t nbyte) { - read_nbyte = nbyte; - EMULATE_EINTR(read, -1); - return ::FMT_POSIX(read(fildes, buf, nbyte)); -} - -test::ssize_t test::write(int fildes, const void* buf, test::size_t nbyte) { - write_nbyte = nbyte; - EMULATE_EINTR(write, -1); - return ::FMT_POSIX(write(fildes, buf, nbyte)); -} - -#ifndef _WIN32 -int test::pipe(int fildes[2]) { - EMULATE_EINTR(pipe, -1); - return ::pipe(fildes); -} -#else -int test::pipe(int* pfds, unsigned psize, int textmode) { - EMULATE_EINTR(pipe, -1); - return _pipe(pfds, psize, textmode); -} -#endif - -FILE* test::fopen(const char* filename, const char* mode) { - EMULATE_EINTR(fopen, nullptr); - return ::fopen(filename, mode); -} - -int test::fclose(FILE* stream) { - EMULATE_EINTR(fclose, EOF); - return ::fclose(stream); -} - -int(test::fileno)(FILE* stream) { - EMULATE_EINTR(fileno, -1); -#ifdef fileno - return FMT_POSIX(fileno(stream)); -#else - return ::FMT_POSIX(fileno(stream)); -#endif -} - -#ifndef _WIN32 -# define EXPECT_RETRY(statement, func, message) \ - func##_count = 1; \ - statement; \ - EXPECT_EQ(4, func##_count); \ - func##_count = 0; -# define EXPECT_EQ_POSIX(expected, actual) EXPECT_EQ(expected, actual) -#else -# define EXPECT_RETRY(statement, func, message) \ - func##_count = 1; \ - EXPECT_SYSTEM_ERROR(statement, EINTR, message); \ - func##_count = 0; -# define EXPECT_EQ_POSIX(expected, actual) -#endif - -#if FMT_USE_FCNTL -void write_file(fmt::cstring_view filename, fmt::string_view content) { - fmt::buffered_file f(filename, "w"); - f.print("{}", content); -} - -using fmt::file; - -TEST(os_test, getpagesize) { -# ifdef _WIN32 - SYSTEM_INFO si = {}; - GetSystemInfo(&si); - EXPECT_EQ(si.dwPageSize, fmt::getpagesize()); -# else - EXPECT_EQ(sysconf(_SC_PAGESIZE), fmt::getpagesize()); - sysconf_error = true; - EXPECT_SYSTEM_ERROR(fmt::getpagesize(), EINVAL, - "cannot get memory page size"); - sysconf_error = false; -# endif -} - -TEST(file_test, open_retry) { -# ifndef _WIN32 - write_file("temp", "there must be something here"); - std::unique_ptr<file> f{nullptr}; - EXPECT_RETRY(f.reset(new file("temp", file::RDONLY)), open, - "cannot open file temp"); - char c = 0; - f->read(&c, 1); -# endif -} - -TEST(file_test, close_no_retry_in_dtor) { - auto pipe = fmt::pipe(); - std::unique_ptr<file> f(new file(std::move(pipe.read_end))); - int saved_close_count = 0; - EXPECT_WRITE( - stderr, - { - close_count = 1; - f.reset(nullptr); - saved_close_count = close_count; - close_count = 0; - }, - system_error_message(EINTR, "cannot close file") + "\n"); - EXPECT_EQ(2, saved_close_count); -} - -TEST(file_test, close_no_retry) { - auto pipe = fmt::pipe(); - close_count = 1; - EXPECT_SYSTEM_ERROR(pipe.read_end.close(), EINTR, "cannot close file"); - EXPECT_EQ(2, close_count); - close_count = 0; -} - -TEST(file_test, size) { - std::string content = "top secret, destroy before reading"; - write_file("temp", content); - file f("temp", file::RDONLY); - EXPECT_GE(f.size(), 0); - EXPECT_EQ(content.size(), static_cast<unsigned long long>(f.size())); -# ifdef _WIN32 - auto error_code = std::error_code(); - fstat_sim = error; - try { - f.size(); - } catch (const std::system_error& e) { - error_code = e.code(); - } - fstat_sim = none; - EXPECT_EQ(error_code, - std::error_code(ERROR_ACCESS_DENIED, fmt::system_category())); -# else - f.close(); - EXPECT_SYSTEM_ERROR(f.size(), EBADF, "cannot get file attributes"); -# endif -} - -TEST(file_test, max_size) { - write_file("temp", ""); - file f("temp", file::RDONLY); - fstat_sim = max_size; - EXPECT_GE(f.size(), 0); - EXPECT_EQ(max_file_size(), f.size()); - fstat_sim = none; -} - -TEST(file_test, read_retry) { - auto pipe = fmt::pipe(); - enum { SIZE = 4 }; - pipe.write_end.write("test", SIZE); - pipe.write_end.close(); - char buffer[SIZE]; - size_t count = 0; - EXPECT_RETRY(count = pipe.read_end.read(buffer, SIZE), read, - "cannot read from file"); - EXPECT_EQ_POSIX(static_cast<std::streamsize>(SIZE), count); -} - -TEST(file_test, write_retry) { - auto pipe = fmt::pipe(); - enum { SIZE = 4 }; - size_t count = 0; - EXPECT_RETRY(count = pipe.write_end.write("test", SIZE), write, - "cannot write to file"); - pipe.write_end.close(); -# ifndef _WIN32 - EXPECT_EQ(static_cast<std::streamsize>(SIZE), count); - char buffer[SIZE + 1]; - pipe.read_end.read(buffer, SIZE); - buffer[SIZE] = '\0'; - EXPECT_STREQ("test", buffer); -# endif -} - -# ifdef _WIN32 -TEST(file_test, convert_read_count) { - auto pipe = fmt::pipe(); - char c; - size_t size = UINT_MAX; - if (sizeof(unsigned) != sizeof(size_t)) ++size; - read_count = 1; - read_nbyte = 0; - EXPECT_THROW(pipe.read_end.read(&c, size), std::system_error); - read_count = 0; - EXPECT_EQ(UINT_MAX, read_nbyte); -} - -TEST(file_test, convert_write_count) { - auto pipe = fmt::pipe(); - char c; - size_t size = UINT_MAX; - if (sizeof(unsigned) != sizeof(size_t)) ++size; - write_count = 1; - write_nbyte = 0; - EXPECT_THROW(pipe.write_end.write(&c, size), std::system_error); - write_count = 0; - EXPECT_EQ(UINT_MAX, write_nbyte); -} -# endif - -TEST(file_test, dup_no_retry) { - int stdout_fd = FMT_POSIX(fileno(stdout)); - dup_count = 1; - EXPECT_SYSTEM_ERROR( - file::dup(stdout_fd), EINTR, - fmt::format("cannot duplicate file descriptor {}", stdout_fd)); - dup_count = 0; -} - -TEST(file_test, dup2_retry) { - int stdout_fd = FMT_POSIX(fileno(stdout)); - file f1 = file::dup(stdout_fd), f2 = file::dup(stdout_fd); - EXPECT_RETRY(f1.dup2(f2.descriptor()), dup2, - fmt::format("cannot duplicate file descriptor {} to {}", - f1.descriptor(), f2.descriptor())); -} - -TEST(file_test, dup2_no_except_retry) { - int stdout_fd = FMT_POSIX(fileno(stdout)); - file f1 = file::dup(stdout_fd), f2 = file::dup(stdout_fd); - std::error_code ec; - dup2_count = 1; - f1.dup2(f2.descriptor(), ec); -# ifndef _WIN32 - EXPECT_EQ(4, dup2_count); -# else - EXPECT_EQ(EINTR, ec.value()); -# endif - dup2_count = 0; -} - -TEST(file_test, pipe_no_retry) { - pipe_count = 1; - EXPECT_SYSTEM_ERROR(fmt::pipe(), EINTR, "cannot create pipe"); - pipe_count = 0; -} - -TEST(file_test, fdopen_no_retry) { - auto pipe = fmt::pipe(); - fdopen_count = 1; - EXPECT_SYSTEM_ERROR(pipe.read_end.fdopen("r"), EINTR, - "cannot associate stream with file descriptor"); - fdopen_count = 0; -} - -TEST(buffered_file_test, open_retry) { - write_file("temp", "there must be something here"); - std::unique_ptr<buffered_file> f{nullptr}; - EXPECT_RETRY(f.reset(new buffered_file("temp", "r")), fopen, - "cannot open file temp"); -# ifndef _WIN32 - char c = 0; - if (fread(&c, 1, 1, f->get()) < 1) - throw fmt::system_error(errno, "fread failed"); -# endif -} - -TEST(buffered_file_test, close_no_retry_in_dtor) { - auto pipe = fmt::pipe(); - std::unique_ptr<buffered_file> f( - new buffered_file(pipe.read_end.fdopen("r"))); - int saved_fclose_count = 0; - EXPECT_WRITE( - stderr, - { - fclose_count = 1; - f.reset(nullptr); - saved_fclose_count = fclose_count; - fclose_count = 0; - }, - system_error_message(EINTR, "cannot close file") + "\n"); - EXPECT_EQ(2, saved_fclose_count); -} - -TEST(buffered_file_test, close_no_retry) { - auto pipe = fmt::pipe(); - buffered_file f = pipe.read_end.fdopen("r"); - fclose_count = 1; - EXPECT_SYSTEM_ERROR(f.close(), EINTR, "cannot close file"); - EXPECT_EQ(2, fclose_count); - fclose_count = 0; -} - -TEST(buffered_file_test, fileno_no_retry) { - auto pipe = fmt::pipe(); - buffered_file f = pipe.read_end.fdopen("r"); - fileno_count = 1; - EXPECT_SYSTEM_ERROR((f.descriptor)(), EINTR, "cannot get file descriptor"); - EXPECT_EQ(2, fileno_count); - fileno_count = 0; -} -#endif // FMT_USE_FCNTL - -struct test_mock { - static test_mock* instance; -}* test_mock::instance; - -TEST(scoped_mock, scope) { - { - scoped_mock<test_mock> mock; - EXPECT_EQ(&mock, test_mock::instance); - test_mock& copy = mock; - static_cast<void>(copy); - } - EXPECT_EQ(nullptr, test_mock::instance); -} diff --git a/thirdparty/fmt/test/posix-mock.h b/thirdparty/fmt/test/posix-mock.h deleted file mode 100644 index 545808717..000000000 --- a/thirdparty/fmt/test/posix-mock.h +++ /dev/null @@ -1,75 +0,0 @@ -// Formatting library for C++ - mocks of POSIX functions -// -// Copyright (c) 2012 - present, Victor Zverovich -// All rights reserved. -// -// For the license information refer to format.h. - -#ifndef FMT_POSIX_TEST_H -#define FMT_POSIX_TEST_H - -#include <errno.h> -#include <locale.h> -#include <stdio.h> -#ifdef __APPLE__ -# include <xlocale.h> -#endif - -#ifdef _WIN32 -# include <windows.h> -#else -# include <sys/param.h> // for FreeBSD version -# include <sys/types.h> // for ssize_t -#endif - -#ifndef _MSC_VER -struct stat; -#endif - -namespace test { - -#ifndef _MSC_VER -// Size type for read and write. -using size_t = size_t; -using ssize_t = ssize_t; -int open(const char* path, int oflag, int mode); -int fstat(int fd, struct stat* buf); -#else -using size_t = unsigned; -using ssize_t = int; -#endif - -#ifndef _WIN32 -long sysconf(int name); -#else -DWORD GetFileSize(HANDLE hFile, LPDWORD lpFileSizeHigh); -#endif - -int close(int fildes); - -int dup(int fildes); -int dup2(int fildes, int fildes2); - -FILE* fdopen(int fildes, const char* mode); - -ssize_t read(int fildes, void* buf, size_t nbyte); -ssize_t write(int fildes, const void* buf, size_t nbyte); - -#ifndef _WIN32 -int pipe(int fildes[2]); -#else -int pipe(int* pfds, unsigned psize, int textmode); -#endif - -FILE* fopen(const char* filename, const char* mode); -int fclose(FILE* stream); -int(fileno)(FILE* stream); - -#if defined(FMT_LOCALE) && !defined(_WIN32) -locale_t newlocale(int category_mask, const char* locale, locale_t base); -#endif -} // namespace test - -#define FMT_SYSTEM(call) test::call - -#endif // FMT_POSIX_TEST_H diff --git a/thirdparty/fmt/test/printf-test.cc b/thirdparty/fmt/test/printf-test.cc deleted file mode 100644 index 277a3b670..000000000 --- a/thirdparty/fmt/test/printf-test.cc +++ /dev/null @@ -1,529 +0,0 @@ -// Formatting library for C++ - printf tests -// -// Copyright (c) 2012 - present, Victor Zverovich -// All rights reserved. -// -// For the license information refer to format.h. - -#include "fmt/printf.h" - -#include <cctype> -#include <climits> -#include <cstring> - -#include "fmt/xchar.h" // DEPRECATED! -#include "gtest-extra.h" -#include "util.h" - -using fmt::format; -using fmt::format_error; -using fmt::detail::max_value; - -const unsigned big_num = INT_MAX + 1u; - -// Makes format string argument positional. -static auto make_positional(fmt::string_view format) -> std::string { - std::string s(format.data(), format.size()); - s.replace(s.find('%'), 1, "%1$"); - return s; -} - -// A wrapper around fmt::sprintf to workaround bogus warnings about invalid -// format strings in MSVC. -template <typename... Args> -auto test_sprintf(fmt::string_view format, const Args&... args) -> std::string { - return fmt::sprintf(format, args...); -} -template <typename... Args> -auto test_sprintf(fmt::basic_string_view<wchar_t> format, const Args&... args) - -> std::wstring { - return fmt::sprintf(format, args...); -} - -#define EXPECT_PRINTF(expected_output, format, arg) \ - EXPECT_EQ(expected_output, test_sprintf(format, arg)) \ - << "format: " << format; \ - EXPECT_EQ(expected_output, fmt::sprintf(make_positional(format), arg)) - -TEST(printf_test, no_args) { EXPECT_EQ("test", test_sprintf("test")); } - -TEST(printf_test, escape) { - EXPECT_EQ("%", test_sprintf("%%")); - EXPECT_EQ("before %", test_sprintf("before %%")); - EXPECT_EQ("% after", test_sprintf("%% after")); - EXPECT_EQ("before % after", test_sprintf("before %% after")); - EXPECT_EQ("%s", test_sprintf("%%s")); -} - -TEST(printf_test, positional_args) { - EXPECT_EQ("42", test_sprintf("%1$d", 42)); - EXPECT_EQ("before 42", test_sprintf("before %1$d", 42)); - EXPECT_EQ("42 after", test_sprintf("%1$d after", 42)); - EXPECT_EQ("before 42 after", test_sprintf("before %1$d after", 42)); - EXPECT_EQ("answer = 42", test_sprintf("%1$s = %2$d", "answer", 42)); - EXPECT_EQ("42 is the answer", test_sprintf("%2$d is the %1$s", "answer", 42)); - EXPECT_EQ("abracadabra", test_sprintf("%1$s%2$s%1$s", "abra", "cad")); -} - -TEST(printf_test, automatic_arg_indexing) { - EXPECT_EQ("abc", test_sprintf("%c%c%c", 'a', 'b', 'c')); -} - -TEST(printf_test, number_is_too_big_in_arg_index) { - EXPECT_THROW_MSG(test_sprintf(format("%{}$", big_num)), format_error, - "argument not found"); - EXPECT_THROW_MSG(test_sprintf(format("%{}$d", big_num)), format_error, - "argument not found"); -} - -TEST(printf_test, switch_arg_indexing) { - EXPECT_THROW_MSG(test_sprintf("%1$d%", 1, 2), format_error, - "cannot switch from manual to automatic argument indexing"); - EXPECT_THROW_MSG(test_sprintf(format("%1$d%{}d", big_num), 1, 2), - format_error, "number is too big"); - EXPECT_THROW_MSG(test_sprintf("%1$d%d", 1, 2), format_error, - "cannot switch from manual to automatic argument indexing"); - - EXPECT_THROW_MSG(test_sprintf("%d%1$", 1, 2), format_error, - "cannot switch from automatic to manual argument indexing"); - EXPECT_THROW_MSG(test_sprintf(format("%d%{}$d", big_num), 1, 2), format_error, - "cannot switch from automatic to manual argument indexing"); - EXPECT_THROW_MSG(test_sprintf("%d%1$d", 1, 2), format_error, - "cannot switch from automatic to manual argument indexing"); - - // Indexing errors override width errors. - EXPECT_THROW_MSG(test_sprintf(format("%d%1${}d", big_num), 1, 2), - format_error, "number is too big"); - EXPECT_THROW_MSG(test_sprintf(format("%1$d%{}d", big_num), 1, 2), - format_error, "number is too big"); -} - -TEST(printf_test, invalid_arg_index) { - EXPECT_THROW_MSG(test_sprintf("%0$d", 42), format_error, - "argument not found"); - EXPECT_THROW_MSG(test_sprintf("%2$d", 42), format_error, - "argument not found"); - EXPECT_THROW_MSG(test_sprintf(format("%{}$d", INT_MAX), 42), format_error, - "argument not found"); - - EXPECT_THROW_MSG(test_sprintf("%2$", 42), format_error, "argument not found"); - EXPECT_THROW_MSG(test_sprintf(format("%{}$d", big_num), 42), format_error, - "argument not found"); -} - -TEST(printf_test, default_align_right) { - EXPECT_PRINTF(" 42", "%5d", 42); - EXPECT_PRINTF(" abc", "%5s", "abc"); -} - -TEST(printf_test, zero_flag) { - EXPECT_PRINTF("00042", "%05d", 42); - EXPECT_PRINTF("-0042", "%05d", -42); - - EXPECT_PRINTF("00042", "%05d", 42); - EXPECT_PRINTF("-0042", "%05d", -42); - EXPECT_PRINTF("-004.2", "%06g", -4.2); - - EXPECT_PRINTF("+00042", "%00+6d", 42); - - EXPECT_PRINTF(" 42", "%05.d", 42); - EXPECT_PRINTF(" 0042", "%05.4d", 42); - - // '0' flag is ignored for non-numeric types. - EXPECT_PRINTF(" x", "%05c", 'x'); -} - -TEST(printf_test, plus_flag) { - EXPECT_PRINTF("+42", "%+d", 42); - EXPECT_PRINTF("-42", "%+d", -42); - EXPECT_PRINTF("+0042", "%+05d", 42); - EXPECT_PRINTF("+0042", "%0++5d", 42); - - // '+' flag is ignored for non-numeric types. - EXPECT_PRINTF("x", "%+c", 'x'); - - // '+' flag wins over space flag - EXPECT_PRINTF("+42", "%+ d", 42); - EXPECT_PRINTF("-42", "%+ d", -42); - EXPECT_PRINTF("+42", "% +d", 42); - EXPECT_PRINTF("-42", "% +d", -42); - EXPECT_PRINTF("+0042", "% +05d", 42); - EXPECT_PRINTF("+0042", "%0+ 5d", 42); - - // '+' flag and space flag are both ignored for non-numeric types. - EXPECT_PRINTF("x", "%+ c", 'x'); - EXPECT_PRINTF("x", "% +c", 'x'); -} - -TEST(printf_test, minus_flag) { - EXPECT_PRINTF("abc ", "%-5s", "abc"); - EXPECT_PRINTF("abc ", "%0--5s", "abc"); - - EXPECT_PRINTF("7 ", "%-5d", 7); - EXPECT_PRINTF("97 ", "%-5hhi", 'a'); - EXPECT_PRINTF("a ", "%-5c", 'a'); - - // '0' flag is ignored if '-' flag is given - EXPECT_PRINTF("7 ", "%-05d", 7); - EXPECT_PRINTF("7 ", "%0-5d", 7); - EXPECT_PRINTF("a ", "%-05c", 'a'); - EXPECT_PRINTF("a ", "%0-5c", 'a'); - EXPECT_PRINTF("97 ", "%-05hhi", 'a'); - EXPECT_PRINTF("97 ", "%0-5hhi", 'a'); - - // '-' and space flag don't interfere - EXPECT_PRINTF(" 42", "%- d", 42); -} - -TEST(printf_test, space_flag) { - EXPECT_PRINTF(" 42", "% d", 42); - EXPECT_PRINTF("-42", "% d", -42); - EXPECT_PRINTF(" 0042", "% 05d", 42); - EXPECT_PRINTF(" 0042", "%0 5d", 42); - - // ' ' flag is ignored for non-numeric types. - EXPECT_PRINTF("x", "% c", 'x'); -} - -TEST(printf_test, hash_flag) { - EXPECT_PRINTF("042", "%#o", 042); - EXPECT_PRINTF(fmt::format("0{:o}", static_cast<unsigned>(-042)), "%#o", -042); - EXPECT_PRINTF("0", "%#o", 0); - - EXPECT_PRINTF("0x42", "%#x", 0x42); - EXPECT_PRINTF("0X42", "%#X", 0x42); - EXPECT_PRINTF(fmt::format("0x{:x}", static_cast<unsigned>(-0x42)), "%#x", - -0x42); - EXPECT_PRINTF("0", "%#x", 0); - - EXPECT_PRINTF("0x0042", "%#06x", 0x42); - EXPECT_PRINTF("0x0042", "%0##6x", 0x42); - - EXPECT_PRINTF("-42.000000", "%#f", -42.0); - EXPECT_PRINTF("-42.000000", "%#F", -42.0); - - char buffer[256]; - safe_sprintf(buffer, "%#e", -42.0); - EXPECT_PRINTF(buffer, "%#e", -42.0); - safe_sprintf(buffer, "%#E", -42.0); - EXPECT_PRINTF(buffer, "%#E", -42.0); - - EXPECT_PRINTF("-42.0000", "%#g", -42.0); - EXPECT_PRINTF("-42.0000", "%#G", -42.0); - - EXPECT_PRINTF("0x1.p+4", "%#a", 16.0); - EXPECT_PRINTF("0X1.P+4", "%#A", 16.0); - - // '#' flag is ignored for non-numeric types. - EXPECT_PRINTF("x", "%#c", 'x'); -} - -TEST(printf_test, width) { - EXPECT_PRINTF(" abc", "%5s", "abc"); - - // Width cannot be specified twice. - EXPECT_THROW_MSG(test_sprintf("%5-5d", 42), format_error, - "invalid format specifier"); - - EXPECT_THROW_MSG(test_sprintf(format("%{}d", big_num), 42), format_error, - "number is too big"); - EXPECT_THROW_MSG(test_sprintf(format("%1${}d", big_num), 42), format_error, - "number is too big"); -} - -TEST(printf_test, dynamic_width) { - EXPECT_EQ(" 42", test_sprintf("%*d", 5, 42)); - EXPECT_EQ("42 ", test_sprintf("%*d", -5, 42)); - EXPECT_THROW_MSG(test_sprintf("%*d", 5.0, 42), format_error, - "width is not integer"); - EXPECT_THROW_MSG(test_sprintf("%*d"), format_error, "argument not found"); - EXPECT_THROW_MSG(test_sprintf("%*d", big_num, 42), format_error, - "number is too big"); -} - -TEST(printf_test, int_precision) { - EXPECT_PRINTF("00042", "%.5d", 42); - EXPECT_PRINTF("-00042", "%.5d", -42); - EXPECT_PRINTF("00042", "%.5x", 0x42); - EXPECT_PRINTF("0x00042", "%#.5x", 0x42); - EXPECT_PRINTF("00042", "%.5o", 042); - EXPECT_PRINTF("00042", "%#.5o", 042); - - EXPECT_PRINTF(" 00042", "%7.5d", 42); - EXPECT_PRINTF(" 00042", "%7.5x", 0x42); - EXPECT_PRINTF(" 0x00042", "%#10.5x", 0x42); - EXPECT_PRINTF(" 00042", "%7.5o", 042); - EXPECT_PRINTF(" 00042", "%#10.5o", 042); - - EXPECT_PRINTF("00042 ", "%-7.5d", 42); - EXPECT_PRINTF("00042 ", "%-7.5x", 0x42); - EXPECT_PRINTF("0x00042 ", "%-#10.5x", 0x42); - EXPECT_PRINTF("00042 ", "%-7.5o", 042); - EXPECT_PRINTF("00042 ", "%-#10.5o", 042); -} - -TEST(printf_test, float_precision) { - char buffer[256]; - safe_sprintf(buffer, "%.3e", 1234.5678); - EXPECT_PRINTF(buffer, "%.3e", 1234.5678); - EXPECT_PRINTF("1234.568", "%.3f", 1234.5678); - EXPECT_PRINTF("1.23e+03", "%.3g", 1234.5678); - safe_sprintf(buffer, "%.3a", 1234.5678); - EXPECT_PRINTF(buffer, "%.3a", 1234.5678); -} - -TEST(printf_test, string_precision) { - char test[] = {'H', 'e', 'l', 'l', 'o'}; - EXPECT_EQ(fmt::sprintf("%.4s", test), "Hell"); -} - -TEST(printf_test, ignore_precision_for_non_numeric_arg) { - EXPECT_PRINTF("abc", "%.5s", "abc"); -} - -TEST(printf_test, dynamic_precision) { - EXPECT_EQ("00042", test_sprintf("%.*d", 5, 42)); - EXPECT_EQ("42", test_sprintf("%.*d", -5, 42)); - EXPECT_THROW_MSG(test_sprintf("%.*d", 5.0, 42), format_error, - "precision is not integer"); - EXPECT_THROW_MSG(test_sprintf("%.*d"), format_error, "argument not found"); - EXPECT_THROW_MSG(test_sprintf("%.*d", big_num, 42), format_error, - "number is too big"); - if (sizeof(long long) != sizeof(int)) { - long long prec = static_cast<long long>(INT_MIN) - 1; - EXPECT_THROW_MSG(test_sprintf("%.*d", prec, 42), format_error, - "number is too big"); - } -} - -template <typename T> struct make_signed { - using type = T; -}; - -#define SPECIALIZE_MAKE_SIGNED(T, S) \ - template <> struct make_signed<T> { \ - using type = S; \ - } - -SPECIALIZE_MAKE_SIGNED(char, signed char); -SPECIALIZE_MAKE_SIGNED(unsigned char, signed char); -SPECIALIZE_MAKE_SIGNED(unsigned short, short); -SPECIALIZE_MAKE_SIGNED(unsigned, int); -SPECIALIZE_MAKE_SIGNED(unsigned long, long); -SPECIALIZE_MAKE_SIGNED(unsigned long long, long long); - -// Test length format specifier ``length_spec``. -template <typename T, typename U> -void test_length(const char* length_spec, U value) { - long long signed_value = 0; - unsigned long long unsigned_value = 0; - // Apply integer promotion to the argument. - unsigned long long max = max_value<U>(); - using fmt::detail::const_check; - if (const_check(max <= static_cast<unsigned>(max_value<int>()))) { - signed_value = static_cast<int>(value); - unsigned_value = static_cast<unsigned long long>(value); - } else if (const_check(max <= max_value<unsigned>())) { - signed_value = static_cast<unsigned>(value); - unsigned_value = static_cast<unsigned long long>(value); - } - if (sizeof(U) <= sizeof(int) && sizeof(int) < sizeof(T)) { - signed_value = static_cast<long long>(value); - unsigned_value = static_cast<unsigned long long>( - static_cast<typename std::make_unsigned<unsigned>::type>(value)); - } else { - signed_value = static_cast<typename make_signed<T>::type>(value); - unsigned_value = static_cast<typename std::make_unsigned<T>::type>(value); - } - std::ostringstream os; - os << signed_value; - EXPECT_PRINTF(os.str(), fmt::format("%{}d", length_spec), value); - EXPECT_PRINTF(os.str(), fmt::format("%{}i", length_spec), value); - os.str(""); - os << unsigned_value; - EXPECT_PRINTF(os.str(), fmt::format("%{}u", length_spec), value); - os.str(""); - os << std::oct << unsigned_value; - EXPECT_PRINTF(os.str(), fmt::format("%{}o", length_spec), value); - os.str(""); - os << std::hex << unsigned_value; - EXPECT_PRINTF(os.str(), fmt::format("%{}x", length_spec), value); - os.str(""); - os << std::hex << std::uppercase << unsigned_value; - EXPECT_PRINTF(os.str(), fmt::format("%{}X", length_spec), value); -} - -template <typename T> void test_length(const char* length_spec) { - T min = std::numeric_limits<T>::min(), max = max_value<T>(); - test_length<T>(length_spec, 42); - test_length<T>(length_spec, -42); - test_length<T>(length_spec, min); - test_length<T>(length_spec, max); - long long long_long_min = std::numeric_limits<long long>::min(); - if (static_cast<long long>(min) > long_long_min) - test_length<T>(length_spec, static_cast<long long>(min) - 1); - unsigned long long long_long_max = max_value<long long>(); - if (static_cast<unsigned long long>(max) < long_long_max) - test_length<T>(length_spec, static_cast<long long>(max) + 1); - test_length<T>(length_spec, std::numeric_limits<short>::min()); - test_length<T>(length_spec, max_value<unsigned short>()); - test_length<T>(length_spec, std::numeric_limits<int>::min()); - test_length<T>(length_spec, max_value<int>()); - test_length<T>(length_spec, std::numeric_limits<unsigned>::min()); - test_length<T>(length_spec, max_value<unsigned>()); - test_length<T>(length_spec, std::numeric_limits<long long>::min()); - test_length<T>(length_spec, max_value<long long>()); - test_length<T>(length_spec, std::numeric_limits<unsigned long long>::min()); - test_length<T>(length_spec, max_value<unsigned long long>()); -} - -TEST(printf_test, length) { - test_length<char>("hh"); - test_length<signed char>("hh"); - test_length<unsigned char>("hh"); - test_length<short>("h"); - test_length<unsigned short>("h"); - test_length<long>("l"); - test_length<unsigned long>("l"); - test_length<long long>("ll"); - test_length<unsigned long long>("ll"); - test_length<intmax_t>("j"); - test_length<size_t>("z"); - test_length<std::ptrdiff_t>("t"); - long double max = max_value<long double>(); - EXPECT_PRINTF(fmt::format("{:.6}", max), "%g", max); - EXPECT_PRINTF(fmt::format("{:.6}", max), "%Lg", max); -} - -TEST(printf_test, bool) { EXPECT_PRINTF("1", "%d", true); } - -TEST(printf_test, int) { - EXPECT_PRINTF("-42", "%d", -42); - EXPECT_PRINTF("-42", "%i", -42); - unsigned u = 0 - 42u; - EXPECT_PRINTF(fmt::format("{}", u), "%u", -42); - EXPECT_PRINTF(fmt::format("{:o}", u), "%o", -42); - EXPECT_PRINTF(fmt::format("{:x}", u), "%x", -42); - EXPECT_PRINTF(fmt::format("{:X}", u), "%X", -42); -} - -TEST(printf_test, long_long) { - // fmt::printf allows passing long long arguments to %d without length - // specifiers. - long long max = max_value<long long>(); - EXPECT_PRINTF(fmt::format("{}", max), "%d", max); -} - -TEST(printf_test, float) { - EXPECT_PRINTF("392.650000", "%f", 392.65); - EXPECT_PRINTF("392.65", "%.2f", 392.65); - EXPECT_PRINTF("392.6", "%.1f", 392.65); - EXPECT_PRINTF("393", "%.f", 392.65); - EXPECT_PRINTF("392.650000", "%F", 392.65); - char buffer[256]; - safe_sprintf(buffer, "%e", 392.65); - EXPECT_PRINTF(buffer, "%e", 392.65); - safe_sprintf(buffer, "%E", 392.65); - EXPECT_PRINTF(buffer, "%E", 392.65); - EXPECT_PRINTF("392.65", "%g", 392.65); - EXPECT_PRINTF("392.65", "%G", 392.65); - EXPECT_PRINTF("392", "%g", 392.0); - EXPECT_PRINTF("392", "%G", 392.0); - EXPECT_PRINTF("4.56e-07", "%g", 0.000000456); - safe_sprintf(buffer, "%a", -392.65); - EXPECT_EQ(buffer, format("{:a}", -392.65)); - safe_sprintf(buffer, "%A", -392.65); - EXPECT_EQ(buffer, format("{:A}", -392.65)); -} - -TEST(printf_test, inf) { - double inf = std::numeric_limits<double>::infinity(); - for (const char* type = "fega"; *type; ++type) { - EXPECT_PRINTF("inf", fmt::format("%{}", *type), inf); - char upper = static_cast<char>(std::toupper(*type)); - EXPECT_PRINTF("INF", fmt::format("%{}", upper), inf); - } -} - -TEST(printf_test, char) { - EXPECT_PRINTF("x", "%c", 'x'); - int max = max_value<int>(); - EXPECT_PRINTF(fmt::format("{}", static_cast<char>(max)), "%c", max); -} - -TEST(printf_test, string) { - EXPECT_PRINTF("abc", "%s", "abc"); - const char* null_str = nullptr; - EXPECT_PRINTF("(null)", "%s", null_str); - EXPECT_PRINTF(" (null)", "%10s", null_str); -} - -TEST(printf_test, pointer) { - int n; - void* p = &n; - EXPECT_PRINTF(fmt::format("{}", p), "%p", p); - p = nullptr; - EXPECT_PRINTF("(nil)", "%p", p); - EXPECT_PRINTF(" (nil)", "%10p", p); - const char* s = "test"; - EXPECT_PRINTF(fmt::format("{:p}", s), "%p", s); - const char* null_str = nullptr; - EXPECT_PRINTF("(nil)", "%p", null_str); -} - -enum test_enum { answer = 42 }; -auto format_as(test_enum e) -> int { return e; } - -TEST(printf_test, enum) { - EXPECT_PRINTF("42", "%d", answer); - volatile test_enum volatile_enum = answer; - EXPECT_PRINTF("42", "%d", volatile_enum); -} - -#if FMT_USE_FCNTL -TEST(printf_test, examples) { - const char* weekday = "Thursday"; - const char* month = "August"; - int day = 21; - EXPECT_WRITE(stdout, fmt::printf("%1$s, %3$d %2$s", weekday, month, day), - "Thursday, 21 August"); -} - -TEST(printf_test, printf_error) { - auto pipe = fmt::pipe(); - int result = fmt::fprintf(pipe.read_end.fdopen("r").get(), "test"); - EXPECT_LT(result, 0); -} -#endif - -TEST(printf_test, vprintf) { - int n = 42; - auto store = fmt::make_format_args<fmt::printf_context>(n); - auto args = fmt::basic_format_args<fmt::printf_context>(store); - EXPECT_EQ(fmt::vsprintf(fmt::string_view("%d"), args), "42"); - EXPECT_WRITE(stdout, fmt::vfprintf(stdout, fmt::string_view("%d"), args), - "42"); -} - -template <typename... Args> -void check_format_string_regression(fmt::string_view s, const Args&... args) { - fmt::sprintf(s, args...); -} - -TEST(printf_test, check_format_string_regression) { - check_format_string_regression("%c%s", 'x', ""); -} - -TEST(printf_test, fixed_large_exponent) { - EXPECT_EQ("1000000000000000000000", fmt::sprintf("%.*f", -13, 1e21)); -} - -TEST(printf_test, make_printf_args) { - int n = 42; - EXPECT_EQ("[42] something happened", - fmt::vsprintf(fmt::string_view("[%d] %s happened"), - {fmt::make_printf_args(n, "something")})); - EXPECT_EQ(L"[42] something happened", - fmt::vsprintf(fmt::basic_string_view<wchar_t>(L"[%d] %s happened"), - {fmt::make_printf_args<wchar_t>(n, L"something")})); -} diff --git a/thirdparty/fmt/test/ranges-odr-test.cc b/thirdparty/fmt/test/ranges-odr-test.cc deleted file mode 100644 index 6115dcb74..000000000 --- a/thirdparty/fmt/test/ranges-odr-test.cc +++ /dev/null @@ -1,18 +0,0 @@ -// Formatting library for C++ - the core API -// -// Copyright (c) 2012 - present, Victor Zverovich -// All rights reserved. -// -// For the license information refer to format.h. - -#include <vector> - -#include "fmt/format.h" -#include "fmt/ranges.h" -#include "gtest/gtest.h" - -// call fmt::format from another translation unit to test ODR -TEST(ranges_odr_test, format_vector) { - auto v = std::vector<int>{1, 2, 3, 5, 7, 11}; - EXPECT_EQ(fmt::format("{}", v), "[1, 2, 3, 5, 7, 11]"); -} diff --git a/thirdparty/fmt/test/ranges-test.cc b/thirdparty/fmt/test/ranges-test.cc deleted file mode 100644 index d65037fa8..000000000 --- a/thirdparty/fmt/test/ranges-test.cc +++ /dev/null @@ -1,799 +0,0 @@ -// Formatting library for C++ - ranges tests -// -// Copyright (c) 2012 - present, Victor Zverovich and {fmt} contributors -// All rights reserved. -// -// For the license information refer to format.h. - -#include "fmt/ranges.h" - -#include <array> -#include <list> -#include <map> -#include <numeric> -#include <queue> -#include <stack> -#include <string> -#include <utility> -#include <vector> - -#if FMT_CPLUSPLUS > 201703L && FMT_HAS_INCLUDE(<ranges>) -# include <ranges> -#endif - -#include "fmt/format.h" -#include "gtest/gtest.h" - -#if !FMT_GCC_VERSION || FMT_GCC_VERSION >= 601 -# define FMT_RANGES_TEST_ENABLE_C_STYLE_ARRAY -#endif - -#ifdef FMT_RANGES_TEST_ENABLE_C_STYLE_ARRAY -TEST(ranges_test, format_array) { - int arr[] = {1, 2, 3, 5, 7, 11}; - EXPECT_EQ(fmt::format("{}", arr), "[1, 2, 3, 5, 7, 11]"); -} - -TEST(ranges_test, format_2d_array) { - int arr[][2] = {{1, 2}, {3, 5}, {7, 11}}; - EXPECT_EQ(fmt::format("{}", arr), "[[1, 2], [3, 5], [7, 11]]"); -} - -TEST(ranges_test, format_array_of_literals) { - const char* arr[] = {"1234", "abcd"}; - EXPECT_EQ(fmt::format("{}", arr), "[\"1234\", \"abcd\"]"); - EXPECT_EQ(fmt::format("{:n}", arr), "\"1234\", \"abcd\""); - EXPECT_EQ(fmt::format("{:n:}", arr), "1234, abcd"); -} -#endif // FMT_RANGES_TEST_ENABLE_C_STYLE_ARRAY - -struct unformattable {}; - -TEST(ranges_test, format_vector) { - auto v = std::vector<int>{1, 2, 3, 5, 7, 11}; - EXPECT_EQ(fmt::format("{}", v), "[1, 2, 3, 5, 7, 11]"); - EXPECT_EQ(fmt::format("{::#x}", v), "[0x1, 0x2, 0x3, 0x5, 0x7, 0xb]"); - EXPECT_EQ(fmt::format("{:n:#x}", v), "0x1, 0x2, 0x3, 0x5, 0x7, 0xb"); - - auto vc = std::vector<char>{'a', 'b', 'c'}; - auto vec = std::vector<char>{'a', '\n', '\t'}; - auto vvc = std::vector<std::vector<char>>{vc, vc}; - EXPECT_EQ(fmt::format("{}", vc), "['a', 'b', 'c']"); - EXPECT_EQ(fmt::format("{:s}", vc), "\"abc\""); - EXPECT_EQ(fmt::format("{:?s}", vec), "\"a\\n\\t\""); - EXPECT_EQ(fmt::format("{:s}", vec), "\"a\n\t\""); - EXPECT_EQ(fmt::format("{::s}", vvc), "[\"abc\", \"abc\"]"); - EXPECT_EQ(fmt::format("{}", vvc), "[['a', 'b', 'c'], ['a', 'b', 'c']]"); - EXPECT_EQ(fmt::format("{:n}", vvc), "['a', 'b', 'c'], ['a', 'b', 'c']"); - EXPECT_EQ(fmt::format("{:n:n}", vvc), "'a', 'b', 'c', 'a', 'b', 'c'"); - EXPECT_EQ(fmt::format("{:n:n:}", vvc), "a, b, c, a, b, c"); - - EXPECT_FALSE(fmt::is_formattable<unformattable>::value); - EXPECT_FALSE(fmt::is_formattable<std::vector<unformattable>>::value); -} - -TEST(ranges_test, format_nested_vector) { - auto v = std::vector<std::vector<int>>{{1, 2}, {3, 5}, {7, 11}}; - EXPECT_EQ(fmt::format("{}", v), "[[1, 2], [3, 5], [7, 11]]"); - EXPECT_EQ(fmt::format("{:::#x}", v), "[[0x1, 0x2], [0x3, 0x5], [0x7, 0xb]]"); - EXPECT_EQ(fmt::format("{:n:n:#x}", v), "0x1, 0x2, 0x3, 0x5, 0x7, 0xb"); -} - -TEST(ranges_test, to_string_vector) { - auto v = std::vector<std::string>{"a", "b", "c"}; - EXPECT_EQ(fmt::to_string(v), "[\"a\", \"b\", \"c\"]"); -} - -TEST(ranges_test, format_map) { - auto m = std::map<std::string, int>{{"one", 1}, {"two", 2}}; - EXPECT_EQ(fmt::format("{}", m), "{\"one\": 1, \"two\": 2}"); - EXPECT_EQ(fmt::format("{:n}", m), "\"one\": 1, \"two\": 2"); - - EXPECT_FALSE((fmt::is_formattable<std::map<int, unformattable>>::value)); -} - -struct test_map_value {}; - -FMT_BEGIN_NAMESPACE -template <> struct formatter<test_map_value> : formatter<string_view> { - auto format(test_map_value, format_context& ctx) const - -> format_context::iterator { - return formatter<string_view>::format("foo", ctx); - } -}; - -template <typename K> -struct formatter<std::pair<K, test_map_value>> : formatter<string_view> { - auto format(std::pair<K, test_map_value>, format_context& ctx) const - -> format_context::iterator { - return ctx.out(); - } -}; - -template <typename K> -struct is_tuple_formattable<std::pair<K, test_map_value>, char> - : std::false_type {}; - -FMT_END_NAMESPACE - -TEST(ranges_test, format_map_custom_pair) { - EXPECT_EQ(fmt::format("{}", std::map<int, test_map_value>{{42, {}}}), - "{42: \"foo\"}"); -} - -TEST(ranges_test, format_set) { - EXPECT_EQ(fmt::format("{}", std::set<std::string>{"one", "two"}), - "{\"one\", \"two\"}"); -} - -// Models std::flat_set close enough to test if no ambiguous lookup of a -// formatter happens due to the flat_set type matching is_set and -// is_container_adaptor_like. -template <typename T> class flat_set { - public: - using key_type = T; - using container_type = std::vector<T>; - - using iterator = typename std::vector<T>::iterator; - using const_iterator = typename std::vector<T>::const_iterator; - - template <typename... Ts> - explicit flat_set(Ts&&... args) : c{std::forward<Ts>(args)...} {} - - auto begin() -> iterator { return c.begin(); } - auto end() -> iterator { return c.end(); } - - auto begin() const -> const_iterator { return c.begin(); } - auto end() const -> const_iterator { return c.end(); } - - private: - std::vector<T> c; -}; - -TEST(ranges_test, format_flat_set) { - EXPECT_EQ(fmt::format("{}", flat_set<std::string>{"one", "two"}), - "{\"one\", \"two\"}"); - EXPECT_FALSE(fmt::is_formattable<flat_set<unformattable>>::value); -} - -namespace adl { -struct box { - int value; -}; - -auto begin(const box& b) -> const int* { return &b.value; } -auto end(const box& b) -> const int* { return &b.value + 1; } -} // namespace adl - -TEST(ranges_test, format_adl_begin_end) { - auto b = adl::box{42}; - EXPECT_EQ(fmt::format("{}", b), "[42]"); -} - -TEST(ranges_test, format_pair) { - auto p = std::pair<int, float>(42, 1.5f); - EXPECT_EQ(fmt::format("{}", p), "(42, 1.5)"); - EXPECT_EQ(fmt::format("{:}", p), "(42, 1.5)"); - EXPECT_EQ(fmt::format("{:n}", p), "421.5"); -} - -TEST(ranges_test, format_tuple) { - auto t = - std::tuple<int, float, std::string, char>(42, 1.5f, "this is tuple", 'i'); - EXPECT_EQ(fmt::format("{}", t), "(42, 1.5, \"this is tuple\", 'i')"); - EXPECT_EQ(fmt::format("{:n}", t), "421.5\"this is tuple\"'i'"); - - EXPECT_EQ(fmt::format("{}", std::tuple<>()), "()"); - - EXPECT_TRUE((fmt::is_formattable<std::tuple<>>::value)); - EXPECT_FALSE((fmt::is_formattable<std::tuple<unformattable>>::value)); - EXPECT_FALSE((fmt::is_formattable<std::tuple<unformattable, int>>::value)); - EXPECT_FALSE((fmt::is_formattable<std::tuple<int, unformattable>>::value)); - EXPECT_FALSE( - (fmt::is_formattable<std::tuple<unformattable, unformattable>>::value)); - EXPECT_TRUE((fmt::is_formattable<std::tuple<int, float>>::value)); -} - -struct not_default_formattable {}; -struct bad_format {}; - -FMT_BEGIN_NAMESPACE -template <> struct formatter<not_default_formattable> { - auto parse(format_parse_context&) -> const char* { throw bad_format(); } - auto format(not_default_formattable, format_context& ctx) - -> format_context::iterator { - return ctx.out(); - } -}; -FMT_END_NAMESPACE - -TEST(ranges_test, tuple_parse_calls_element_parse) { - auto f = fmt::formatter<std::tuple<not_default_formattable>>(); - auto ctx = fmt::format_parse_context(""); - EXPECT_THROW(f.parse(ctx), bad_format); -} - -struct tuple_like { - int i; - std::string str; - - template <size_t N> - auto get() const noexcept -> fmt::enable_if_t<N == 0, int> { - return i; - } - template <size_t N> - auto get() const noexcept -> fmt::enable_if_t<N == 1, fmt::string_view> { - return str; - } -}; - -template <size_t N> -auto get(const tuple_like& t) noexcept -> decltype(t.get<N>()) { - return t.get<N>(); -} - -// https://github.com/llvm/llvm-project/issues/39218 -FMT_PRAGMA_CLANG(diagnostic ignored "-Wmismatched-tags") - -namespace std { -template <> -struct tuple_size<tuple_like> : public std::integral_constant<size_t, 2> {}; - -template <size_t N> struct tuple_element<N, tuple_like> { - using type = decltype(std::declval<tuple_like>().get<N>()); -}; -} // namespace std - -TEST(ranges_test, format_struct) { - auto t = tuple_like{42, "foo"}; - EXPECT_EQ(fmt::format("{}", t), "(42, \"foo\")"); -} - -TEST(ranges_test, format_to) { - char buf[10]; - auto end = fmt::format_to(buf, "{}", std::vector<int>{1, 2, 3}); - *end = '\0'; - EXPECT_STREQ(buf, "[1, 2, 3]"); -} - -template <typename Char> struct path_like { - auto begin() const -> const path_like*; - auto end() const -> const path_like*; - - operator std::basic_string<Char>() const; -}; - -TEST(ranges_test, disabled_range_formatting_of_path) { - // Range formatting of path is disabled because of infinite recursion - // (path element is itself a path). - EXPECT_EQ((fmt::range_format_kind<path_like<char>, char>::value), - fmt::range_format::disabled); - EXPECT_EQ((fmt::range_format_kind<path_like<wchar_t>, char>::value), - fmt::range_format::disabled); -} - -struct vector_string : std::vector<char> { - using base = std::vector<char>; - using base::base; -}; -struct vector_debug_string : std::vector<char> { - using base = std::vector<char>; - using base::base; -}; -FMT_BEGIN_NAMESPACE -template <> -struct range_format_kind<vector_string, char> - : std::integral_constant<range_format, range_format::string> {}; -template <> -struct range_format_kind<vector_debug_string, char> - : std::integral_constant<range_format, range_format::debug_string> {}; -FMT_END_NAMESPACE - -TEST(ranges_test, range_format_string) { - const vector_string v{'f', 'o', 'o'}; - EXPECT_EQ(fmt::format("{}", v), "foo"); -} - -TEST(ranges_test, range_format_debug_string) { - const vector_debug_string v{'f', 'o', 'o'}; - EXPECT_EQ(fmt::format("{}", v), "\"foo\""); -} - -// A range that provides non-const only begin()/end() to test fmt::join -// handles that. -// -// Some ranges (e.g. those produced by range-v3's views::filter()) can cache -// information during iteration so they only provide non-const begin()/end(). -template <typename T> class non_const_only_range { - private: - std::vector<T> vec; - - public: - using const_iterator = typename ::std::vector<T>::const_iterator; - - template <typename... Args> - explicit non_const_only_range(Args&&... args) - : vec(std::forward<Args>(args)...) {} - - auto begin() -> const_iterator { return vec.begin(); } - auto end() -> const_iterator { return vec.end(); } -}; - -template <typename T> class noncopyable_range { - private: - std::vector<T> vec; - - public: - using iterator = typename ::std::vector<T>::iterator; - - template <typename... Args> - explicit noncopyable_range(Args&&... args) - : vec(std::forward<Args>(args)...) {} - - noncopyable_range(const noncopyable_range&) = delete; - noncopyable_range(noncopyable_range&) = delete; - - auto begin() -> iterator { return vec.begin(); } - auto end() -> iterator { return vec.end(); } -}; - -TEST(ranges_test, range) { - auto&& w = noncopyable_range<int>(3u, 0); - EXPECT_EQ(fmt::format("{}", w), "[0, 0, 0]"); - EXPECT_EQ(fmt::format("{}", noncopyable_range<int>(3u, 0)), "[0, 0, 0]"); - - auto x = non_const_only_range<int>(3u, 0); - EXPECT_EQ(fmt::format("{}", x), "[0, 0, 0]"); - EXPECT_EQ(fmt::format("{}", non_const_only_range<int>(3u, 0)), "[0, 0, 0]"); - - auto y = std::vector<int>(3u, 0); - EXPECT_EQ(fmt::format("{}", y), "[0, 0, 0]"); - EXPECT_EQ(fmt::format("{}", std::vector<int>(3u, 0)), "[0, 0, 0]"); - - const auto z = std::vector<int>(3u, 0); - EXPECT_EQ(fmt::format("{}", z), "[0, 0, 0]"); -} - -enum test_enum { foo, bar }; -auto format_as(test_enum e) -> int { return e; } - -TEST(ranges_test, enum_range) { - auto v = std::vector<test_enum>{test_enum::foo}; - EXPECT_EQ(fmt::format("{}", v), "[0]"); -} - -#if !FMT_MSC_VERSION -TEST(ranges_test, unformattable_range) { - EXPECT_FALSE((fmt::is_formattable<std::vector<unformattable>, char>::value)); -} -#endif - -TEST(ranges_test, join) { - using fmt::join; - int v1[3] = {1, 2, 3}; - auto v2 = std::vector<float>(); - v2.push_back(1.2f); - v2.push_back(3.4f); - void* v3[2] = {&v1[0], &v1[1]}; - - EXPECT_EQ(fmt::format("({})", join(v1, v1 + 3, ", ")), "(1, 2, 3)"); - EXPECT_EQ(fmt::format("({})", join(v1, v1 + 1, ", ")), "(1)"); - EXPECT_EQ(fmt::format("({})", join(v1, v1, ", ")), "()"); - EXPECT_EQ(fmt::format("({:03})", join(v1, v1 + 3, ", ")), "(001, 002, 003)"); - EXPECT_EQ("(+01.20, +03.40)", - fmt::format("({:+06.2f})", join(v2.begin(), v2.end(), ", "))); - - EXPECT_EQ(fmt::format("{0:{1}}", join(v1, v1 + 3, ", "), 1), "1, 2, 3"); - - EXPECT_EQ(fmt::format("{}, {}", v3[0], v3[1]), - fmt::format("{}", join(v3, v3 + 2, ", "))); - - EXPECT_EQ(fmt::format("({})", join(v1, ", ")), "(1, 2, 3)"); - EXPECT_EQ(fmt::format("({:+06.2f})", join(v2, ", ")), "(+01.20, +03.40)"); - - auto v4 = std::vector<test_enum>{foo, bar, foo}; - EXPECT_EQ(fmt::format("{}", join(v4, " ")), "0 1 0"); -} - -#ifdef __cpp_lib_byte -TEST(ranges_test, join_bytes) { - auto v = std::vector<std::byte>{std::byte(1), std::byte(2), std::byte(3)}; - EXPECT_EQ(fmt::format("{}", fmt::join(v, ", ")), "1, 2, 3"); -} -#endif - -TEST(ranges_test, join_tuple) { - // Value tuple args. - auto t1 = std::tuple<char, int, float>('a', 1, 2.0f); - EXPECT_EQ(fmt::format("({})", fmt::join(t1, ", ")), "(a, 1, 2)"); - - // Testing lvalue tuple args. - int x = 4; - auto t2 = std::tuple<char, int&>('b', x); - EXPECT_EQ(fmt::format("{}", fmt::join(t2, " + ")), "b + 4"); - - // Empty tuple. - auto t3 = std::tuple<>(); - EXPECT_EQ(fmt::format("{}", fmt::join(t3, "|")), ""); - - // Single element tuple. - auto t4 = std::tuple<float>(4.0f); - EXPECT_EQ(fmt::format("{}", fmt::join(t4, "/")), "4"); - - // Tuple-like. - auto t5 = tuple_like{42, "foo"}; - EXPECT_EQ(fmt::format("{}", fmt::join(t5, ", ")), "42, foo"); - -#if FMT_TUPLE_JOIN_SPECIFIERS - // Specs applied to each element. - auto t5 = std::tuple<int, int, long>(-3, 100, 1); - EXPECT_EQ(fmt::format("{:+03}", fmt::join(t5, ", ")), "-03, +100, +01"); - - auto t6 = std::tuple<float, double, long double>(3, 3.14, 3.1415); - EXPECT_EQ(fmt::format("{:5.5f}", fmt::join(t6, ", ")), - "3.00000, 3.14000, 3.14150"); - - // Testing lvalue tuple args. - int y = -1; - auto t7 = std::tuple<int, int&, const int&>(3, y, y); - EXPECT_EQ(fmt::format("{:03}", fmt::join(t7, ", ")), "003, -01, -01"); -#endif -} - -TEST(ranges_test, join_initializer_list) { - EXPECT_EQ(fmt::format("{}", fmt::join({1, 2, 3}, ", ")), "1, 2, 3"); - EXPECT_EQ(fmt::format("{}", fmt::join({"fmt", "rocks", "!"}, " ")), - "fmt rocks !"); -} - -struct zstring_sentinel {}; - -bool operator==(const char* p, zstring_sentinel) { return *p == '\0'; } -bool operator!=(const char* p, zstring_sentinel) { return *p != '\0'; } - -struct zstring { - const char* p; - auto begin() const -> const char* { return p; } - auto end() const -> zstring_sentinel { return {}; } -}; - -#ifdef __cpp_lib_ranges -struct cpp20_only_range { - struct iterator { - int val = 0; - - using value_type = int; - using difference_type = std::ptrdiff_t; - using iterator_concept = std::input_iterator_tag; - - iterator() = default; - iterator(int i) : val(i) {} - auto operator*() const -> int { return val; } - auto operator++() -> iterator& { - ++val; - return *this; - } - void operator++(int) { ++*this; } - auto operator==(const iterator& rhs) const -> bool { - return val == rhs.val; - } - }; - - int lo; - int hi; - - auto begin() const -> iterator { return iterator(lo); } - auto end() const -> iterator { return iterator(hi); } -}; - -static_assert(std::input_iterator<cpp20_only_range::iterator>); -#endif - -TEST(ranges_test, join_sentinel) { - auto hello = zstring{"hello"}; - EXPECT_EQ(fmt::format("{}", hello), "['h', 'e', 'l', 'l', 'o']"); - EXPECT_EQ(fmt::format("{::}", hello), "[h, e, l, l, o]"); - EXPECT_EQ(fmt::format("{}", fmt::join(hello, "_")), "h_e_l_l_o"); -} - -TEST(ranges_test, join_range) { - auto&& w = noncopyable_range<int>(3u, 0); - EXPECT_EQ(fmt::format("{}", fmt::join(w, ",")), "0,0,0"); - EXPECT_EQ(fmt::format("{}", fmt::join(noncopyable_range<int>(3u, 0), ",")), - "0,0,0"); - - auto x = non_const_only_range<int>(3u, 0); - EXPECT_EQ(fmt::format("{}", fmt::join(x, ",")), "0,0,0"); - EXPECT_EQ(fmt::format("{}", fmt::join(non_const_only_range<int>(3u, 0), ",")), - "0,0,0"); - - auto y = std::vector<int>(3u, 0); - EXPECT_EQ(fmt::format("{}", fmt::join(y, ",")), "0,0,0"); - EXPECT_EQ(fmt::format("{}", fmt::join(std::vector<int>(3u, 0), ",")), - "0,0,0"); - - const auto z = std::vector<int>(3u, 0); - EXPECT_EQ(fmt::format("{}", fmt::join(z, ",")), "0,0,0"); - -#ifdef __cpp_lib_ranges - EXPECT_EQ(fmt::format("{}", cpp20_only_range{.lo = 0, .hi = 5}), - "[0, 1, 2, 3, 4]"); - EXPECT_EQ( - fmt::format("{}", fmt::join(cpp20_only_range{.lo = 0, .hi = 5}, ",")), - "0,1,2,3,4"); -#endif -} - -namespace adl { -struct vec { - int n[2] = {42, 43}; -}; - -auto begin(const vec& v) -> const int* { return v.n; } -auto end(const vec& v) -> const int* { return v.n + 2; } -} // namespace adl - -TEST(ranges_test, format_join_adl_begin_end) { - EXPECT_EQ(fmt::format("{}", fmt::join(adl::vec(), "/")), "42/43"); -} - -#if defined(__cpp_lib_ranges) && __cpp_lib_ranges >= 202207L -TEST(ranges_test, nested_ranges) { - auto l = std::list{1, 2, 3}; - auto r = std::views::iota(0, 3) | std::views::transform([&l](auto i) { - return std::views::take(std::ranges::subrange(l), i); - }) | - std::views::transform(std::views::reverse); - EXPECT_EQ(fmt::format("{}", r), "[[], [1], [2, 1]]"); -} -#endif - -TEST(ranges_test, is_printable) { - using fmt::detail::is_printable; - EXPECT_TRUE(is_printable(0x0323)); - EXPECT_FALSE(is_printable(0x0378)); - EXPECT_FALSE(is_printable(0x110000)); -} - -TEST(ranges_test, escape) { - using vec = std::vector<std::string>; - EXPECT_EQ(fmt::format("{}", vec{"\n\r\t\"\\"}), "[\"\\n\\r\\t\\\"\\\\\"]"); - EXPECT_EQ(fmt::format("{}", vec{"\x07"}), "[\"\\x07\"]"); - EXPECT_EQ(fmt::format("{}", vec{"\x7f"}), "[\"\\x7f\"]"); - EXPECT_EQ(fmt::format("{}", vec{"n\xcc\x83"}), "[\"n\xcc\x83\"]"); - - if (fmt::detail::use_utf8) { - EXPECT_EQ(fmt::format("{}", vec{"\xcd\xb8"}), "[\"\\u0378\"]"); - // Unassigned Unicode code points. - EXPECT_EQ(fmt::format("{}", vec{"\xf0\xaa\x9b\x9e"}), "[\"\\U0002a6de\"]"); - // Broken utf-8. - EXPECT_EQ(fmt::format("{}", vec{"\xf4\x8f\xbf\xc0"}), - "[\"\\xf4\\x8f\\xbf\\xc0\"]"); - EXPECT_EQ(fmt::format("{}", vec{"\xf0\x28"}), "[\"\\xf0(\"]"); - EXPECT_EQ(fmt::format("{}", vec{"\xe1\x28"}), "[\"\\xe1(\"]"); - EXPECT_EQ(fmt::format("{}", vec{std::string("\xf0\x28\0\0anything", 12)}), - "[\"\\xf0(\\x00\\x00anything\"]"); - - // Correct utf-8. - EXPECT_EQ(fmt::format("{}", vec{"🦄"}), "[\"🦄\"]"); - } - - EXPECT_EQ(fmt::format("{}", std::vector<std::vector<char>>{{'x'}}), - "[['x']]"); - -// Disabled due to a clang 17 bug: https://github.com/fmtlib/fmt/issues/4144. -#if FMT_CLANG_VERSION >= 1800 - EXPECT_EQ(fmt::format("{}", std::tuple<std::vector<char>>{{'x'}}), "(['x'])"); -#endif -} - -template <typename R> struct fmt_ref_view { - R* r; - - auto begin() const -> decltype(r->begin()) { return r->begin(); } - auto end() const -> decltype(r->end()) { return r->end(); } -}; - -TEST(ranges_test, range_of_range_of_mixed_const) { - auto v = std::vector<std::vector<int>>{{1, 2, 3}, {4, 5}}; - EXPECT_EQ(fmt::format("{}", v), "[[1, 2, 3], [4, 5]]"); - - auto r = fmt_ref_view<decltype(v)>{&v}; - EXPECT_EQ(fmt::format("{}", r), "[[1, 2, 3], [4, 5]]"); -} - -TEST(ranges_test, vector_char) { - EXPECT_EQ(fmt::format("{}", std::vector<char>{'a', 'b'}), "['a', 'b']"); -} - -TEST(ranges_test, container_adaptor) { - { - using fmt::detail::is_container_adaptor_like; - using T = std::nullptr_t; - static_assert(is_container_adaptor_like<std::stack<T>>::value, ""); - static_assert(is_container_adaptor_like<std::queue<T>>::value, ""); - static_assert(is_container_adaptor_like<std::priority_queue<T>>::value, ""); - static_assert(!is_container_adaptor_like<std::vector<T>>::value, ""); - } - - { - auto s = std::stack<int>(); - s.push(1); - s.push(2); - EXPECT_EQ(fmt::format("{}", s), "[1, 2]"); - EXPECT_EQ(fmt::format("{}", const_cast<const decltype(s)&>(s)), "[1, 2]"); - } - - { - auto q = std::queue<int>(); - q.push(1); - q.push(2); - EXPECT_EQ(fmt::format("{}", q), "[1, 2]"); - } - - { - auto q = std::priority_queue<int>(); - q.push(3); - q.push(1); - q.push(2); - q.push(4); - EXPECT_EQ(fmt::format("{}", q), "[4, 3, 2, 1]"); - } - - { - auto s = std::stack<char, std::string>(); - s.push('a'); - s.push('b'); - // See https://cplusplus.github.io/LWG/issue3881. - EXPECT_EQ(fmt::format("{}", s), "['a', 'b']"); - } - - { - struct my_container_adaptor { - using value_type = int; - using container_type = std::vector<value_type>; - void push(const value_type& v) { c.push_back(v); } - - protected: - container_type c; - }; - - auto m = my_container_adaptor(); - m.push(1); - m.push(2); - EXPECT_EQ(fmt::format("{}", m), "[1, 2]"); - } - - EXPECT_FALSE(fmt::is_formattable<std::stack<unformattable>>::value); -} - -struct tieable { - int a = 3; - double b = 0.42; -}; - -auto format_as(const tieable& t) -> std::tuple<int, double> { - return std::tie(t.a, t.b); -} - -TEST(ranges_test, format_as_tie) { - EXPECT_EQ(fmt::format("{}", tieable()), "(3, 0.42)"); -} - -struct lvalue_qualified_begin_end { - int arr[5] = {1, 2, 3, 4, 5}; - - auto begin() & -> const int* { return arr; } - auto end() & -> const int* { return arr + 5; } -}; - -TEST(ranges_test, lvalue_qualified_begin_end) { - EXPECT_EQ(fmt::format("{}", lvalue_qualified_begin_end{}), "[1, 2, 3, 4, 5]"); -} - -#if !defined(__cpp_lib_ranges) || __cpp_lib_ranges <= 202106L -# define ENABLE_STD_VIEWS_TESTS 0 -#elif FMT_CLANG_VERSION -# if FMT_CLANG_VERSION > 1500 -# define ENABLE_STD_VIEWS_TESTS 1 -# else -# define ENABLE_STD_VIEWS_TESTS 0 -# endif -#else -# define ENABLE_STD_VIEWS_TESTS 1 -#endif - -#if ENABLE_STD_VIEWS_TESTS -TEST(ranges_test, input_range_join) { - auto iss = std::istringstream("1 2 3 4 5"); - auto view = std::views::istream<std::string>(iss); - EXPECT_EQ("1, 2, 3, 4, 5", - fmt::format("{}", fmt::join(view.begin(), view.end(), ", "))); -} - -TEST(ranges_test, input_range_join_overload) { - auto iss = std::istringstream("1 2 3 4 5"); - EXPECT_EQ( - "1.2.3.4.5", - fmt::format("{}", fmt::join(std::views::istream<std::string>(iss), "."))); -} - -namespace views_filter_view_test { -struct codec_mask { - static constexpr auto codecs = std::array{0, 1, 2, 3}; - int except = 0; -}; - -auto format_as(codec_mask mask) { - // Careful not to capture param by reference here, it will dangle. - return codec_mask::codecs | - std::views::filter([mask](auto c) { return c != mask.except; }); -} -} // namespace views_filter_view_test - -TEST(ranges_test, format_as_with_ranges_mutable_begin_end) { - using namespace views_filter_view_test; - { - auto make_filter_view = []() { - return codec_mask::codecs | - std::views::filter([](auto c) { return c != 2; }); - }; - auto r = make_filter_view(); - EXPECT_EQ("[0, 1, 3]", fmt::format("{}", r)); - EXPECT_EQ("[0, 1, 3]", fmt::format("{}", make_filter_view())); - } - - { - auto mask = codec_mask{2}; - const auto const_mask = codec_mask{2}; - - EXPECT_EQ("[0, 1, 3]", fmt::format("{}", mask)); - EXPECT_EQ("[0, 1, 3]", fmt::format("{}", const_mask)); - EXPECT_EQ("[0, 1, 3]", fmt::format("{}", codec_mask{2})); - } -} - -#endif - -TEST(ranges_test, std_istream_iterator_join) { - auto&& iss = std::istringstream("1 2 3 4 5"); - auto first = std::istream_iterator<int>(iss); - auto last = std::istream_iterator<int>(); - EXPECT_EQ("1, 2, 3, 4, 5", fmt::format("{}", fmt::join(first, last, ", "))); -} - -// Mirrors C++20 std::ranges::basic_istream_view::iterator. -struct noncopyable_istream_iterator : std::istream_iterator<int> { - using base = std::istream_iterator<int>; - explicit noncopyable_istream_iterator(std::istringstream& iss) : base{iss} {} - noncopyable_istream_iterator(const noncopyable_istream_iterator&) = delete; - noncopyable_istream_iterator(noncopyable_istream_iterator&&) = default; -}; -static_assert(!std::is_copy_constructible<noncopyable_istream_iterator>::value, - ""); - -TEST(ranges_test, movable_only_istream_iter_join) { - auto&& iss = std::istringstream("1 2 3 4 5"); - auto first = noncopyable_istream_iterator(iss); - auto last = std::istream_iterator<int>(); - EXPECT_EQ("1, 2, 3, 4, 5", - fmt::format("{}", fmt::join(std::move(first), last, ", "))); -} - -struct movable_iter_range { - std::istringstream iss{"1 2 3 4 5"}; - noncopyable_istream_iterator begin() { - return noncopyable_istream_iterator{iss}; - } - std::istream_iterator<int> end() { return {}; } -}; - -TEST(ranges_test, movable_only_istream_iter_join2) { - EXPECT_EQ("[1, 2, 3, 4, 5]", fmt::format("{}", movable_iter_range{})); -} - -struct not_range { - void begin() const {} - void end() const {} -}; -static_assert(!fmt::is_formattable<not_range>{}, ""); diff --git a/thirdparty/fmt/test/scan-test.cc b/thirdparty/fmt/test/scan-test.cc deleted file mode 100644 index 03b26e5d8..000000000 --- a/thirdparty/fmt/test/scan-test.cc +++ /dev/null @@ -1,184 +0,0 @@ -// Formatting library for C++ - scanning API test -// -// Copyright (c) 2019 - present, Victor Zverovich -// All rights reserved. -// -// For the license information refer to format.h. - -#include "scan.h" - -#include <time.h> - -#include <climits> -#include <thread> - -#include "fmt/os.h" -#include "gmock/gmock.h" -#include "gtest-extra.h" - -TEST(scan_test, read_text) { - fmt::string_view s = "foo"; - auto end = fmt::scan_to(s, "foo"); - EXPECT_EQ(end, s.end()); - EXPECT_THROW_MSG(fmt::scan<int>("fob", "foo"), fmt::format_error, - "invalid input"); -} - -TEST(scan_test, read_int) { - EXPECT_EQ(fmt::scan<int>("42", "{}")->value(), 42); - EXPECT_EQ(fmt::scan<int>("-42", "{}")->value(), -42); - EXPECT_EQ(fmt::scan<int>("42", "{:}")->value(), 42); - EXPECT_THROW_MSG(fmt::scan<int>(std::to_string(INT_MAX + 1u), "{}"), - fmt::format_error, "number is too big"); -} - -TEST(scan_test, read_long_long) { - EXPECT_EQ(fmt::scan<long long>("42", "{}")->value(), 42); - EXPECT_EQ(fmt::scan<long long>("-42", "{}")->value(), -42); -} - -TEST(scan_test, read_uint) { - EXPECT_EQ(fmt::scan<unsigned>("42", "{}")->value(), 42); - EXPECT_THROW_MSG(fmt::scan<unsigned>("-42", "{}"), fmt::format_error, - "invalid input"); -} - -TEST(scan_test, read_ulong_long) { - EXPECT_EQ(fmt::scan<unsigned long long>("42", "{}")->value(), 42); - EXPECT_THROW_MSG(fmt::scan<unsigned long long>("-42", "{}")->value(), - fmt::format_error, "invalid input"); -} - -TEST(scan_test, read_hex) { - EXPECT_EQ(fmt::scan<unsigned>("2a", "{:x}")->value(), 42); - auto num_digits = std::numeric_limits<unsigned>::digits / 4; - EXPECT_THROW_MSG( - fmt::scan<unsigned>(fmt::format("1{:0{}}", 0, num_digits), "{:x}") - ->value(), - fmt::format_error, "number is too big"); -} - -TEST(scan_test, read_string) { - EXPECT_EQ(fmt::scan<std::string>("foo", "{}")->value(), "foo"); -} - -TEST(scan_test, read_string_view) { - EXPECT_EQ(fmt::scan<fmt::string_view>("foo", "{}")->value(), "foo"); -} - -TEST(scan_test, separator) { - int n1 = 0, n2 = 0; - fmt::scan_to("10 20", "{} {}", n1, n2); - EXPECT_EQ(n1, 10); - EXPECT_EQ(n2, 20); -} - -struct num { - int value; -}; - -namespace fmt { -template <> struct scanner<num> { - bool hex = false; - - auto parse(scan_parse_context& ctx) -> scan_parse_context::iterator { - auto it = ctx.begin(), end = ctx.end(); - if (it != end && *it == 'x') { - hex = true; - ++it; - } - if (it != end && *it != '}') report_error("invalid format"); - return it; - } - - template <class ScanContext> - auto scan(num& n, ScanContext& ctx) const -> typename ScanContext::iterator { - return hex ? scan_to(ctx, "{:x}", n.value) : scan_to(ctx, "{}", n.value); - } -}; -} // namespace fmt - -TEST(scan_test, read_custom) { - EXPECT_EQ(fmt::scan<num>("42", "{}")->value().value, 42); - EXPECT_EQ(fmt::scan<num>("2a", "{:x}")->value().value, 42); -} - -TEST(scan_test, invalid_format) { - EXPECT_THROW_MSG(fmt::scan_to("", "{}"), fmt::format_error, - "argument index out of range"); - EXPECT_THROW_MSG(fmt::scan_to("", "{"), fmt::format_error, - "invalid format string"); -} - -namespace std { -using fmt::scan; -using fmt::scan_error; -} // namespace std - -TEST(scan_test, example) { - // Example from https://wg21.link/p1729r3. - if (auto result = std::scan<std::string, int>("answer = 42", "{} = {}")) { - auto range = result->range(); - EXPECT_EQ(range.begin(), range.end()); - EXPECT_EQ(result->begin(), result->end()); -#ifdef __cpp_structured_bindings - const auto& [key, value] = result->values(); - EXPECT_EQ(key, "answer"); - EXPECT_EQ(value, 42); -#endif - } else { - std::scan_error error = result.error(); - (void)error; - FAIL(); - } -} - -TEST(scan_test, end_of_input) { fmt::scan<int>("", "{}"); } - -#if FMT_USE_FCNTL -TEST(scan_test, file) { - auto pipe = fmt::pipe(); - - fmt::string_view input = "10 20"; - pipe.write_end.write(input.data(), input.size()); - pipe.write_end.close(); - - int n1 = 0, n2 = 0; - fmt::buffered_file f = pipe.read_end.fdopen("r"); - fmt::scan_to(f.get(), "{} {}", n1, n2); - EXPECT_EQ(n1, 10); - EXPECT_EQ(n2, 20); -} - -TEST(scan_test, lock) { - auto pipe = fmt::pipe(); - - std::thread producer([&]() { - fmt::string_view input = "42 "; - for (int i = 0; i < 1000; ++i) - pipe.write_end.write(input.data(), input.size()); - pipe.write_end.close(); - }); - - std::atomic<int> count(0); - fmt::buffered_file f = pipe.read_end.fdopen("r"); - auto fun = [&]() { - int value = 0; - while (fmt::scan_to(f.get(), "{}", value)) { - if (value != 42) { - pipe.read_end.close(); - EXPECT_EQ(value, 42); - break; - } - ++count; - } - }; - std::thread consumer1(fun); - std::thread consumer2(fun); - - producer.join(); - consumer1.join(); - consumer2.join(); - EXPECT_EQ(count, 1000); -} -#endif // FMT_USE_FCNTL diff --git a/thirdparty/fmt/test/scan.h b/thirdparty/fmt/test/scan.h deleted file mode 100644 index 257ac8d79..000000000 --- a/thirdparty/fmt/test/scan.h +++ /dev/null @@ -1,722 +0,0 @@ -// Formatting library for C++ - scanning API proof of concept -// -// Copyright (c) 2019 - present, Victor Zverovich -// All rights reserved. -// -// For the license information refer to format.h. - -#include <array> -#include <cassert> -#include <climits> -#include <tuple> - -#include "fmt/format-inl.h" - -FMT_BEGIN_NAMESPACE -namespace detail { - -inline auto is_whitespace(char c) -> bool { return c == ' ' || c == '\n'; } - -// If c is a hex digit returns its numeric value, otherwise -1. -inline auto to_hex_digit(char c) -> int { - if (c >= '0' && c <= '9') return c - '0'; - if (c >= 'a' && c <= 'f') return c - 'a' + 10; - if (c >= 'A' && c <= 'F') return c - 'A' + 10; - return -1; -} - -struct maybe_contiguous_range { - const char* begin; - const char* end; - - explicit operator bool() const { return begin != nullptr; } -}; - -class scan_buffer { - private: - const char* ptr_; - const char* end_; - bool contiguous_; - - protected: - scan_buffer(const char* ptr, const char* end, bool contiguous) - : ptr_(ptr), end_(end), contiguous_(contiguous) {} - ~scan_buffer() = default; - - void set(span<const char> buf) { - ptr_ = buf.data; - end_ = buf.data + buf.size; - } - - auto ptr() const -> const char* { return ptr_; } - - public: - scan_buffer(const scan_buffer&) = delete; - void operator=(const scan_buffer&) = delete; - - // Fills the buffer with more input if available. - virtual void consume() = 0; - - class sentinel {}; - - class iterator { - private: - const char** ptr_; - scan_buffer* buf_; // This could be merged with ptr_. - char value_; - - static auto get_sentinel() -> const char** { - static const char* ptr = nullptr; - return &ptr; - } - - friend class scan_buffer; - - friend auto operator==(iterator lhs, sentinel) -> bool { - return *lhs.ptr_ == nullptr; - } - friend auto operator!=(iterator lhs, sentinel) -> bool { - return *lhs.ptr_ != nullptr; - } - - iterator(scan_buffer* buf) : buf_(buf) { - if (buf->ptr_ == buf->end_) { - ptr_ = get_sentinel(); - return; - } - ptr_ = &buf->ptr_; - value_ = *buf->ptr_; - } - - friend scan_buffer& get_buffer(iterator it) { return *it.buf_; } - - public: - iterator() : ptr_(get_sentinel()), buf_(nullptr) {} - - auto operator++() -> iterator& { - if (!buf_->try_consume()) ptr_ = get_sentinel(); - value_ = *buf_->ptr_; - return *this; - } - auto operator++(int) -> iterator { - iterator copy = *this; - ++*this; - return copy; - } - auto operator*() const -> char { return value_; } - - auto base() const -> const char* { return buf_->ptr_; } - - friend auto to_contiguous(iterator it) -> maybe_contiguous_range; - friend auto advance(iterator it, size_t n) -> iterator; - }; - - friend auto to_contiguous(iterator it) -> maybe_contiguous_range { - if (it.buf_->is_contiguous()) return {it.buf_->ptr_, it.buf_->end_}; - return {nullptr, nullptr}; - } - friend auto advance(iterator it, size_t n) -> iterator { - FMT_ASSERT(it.buf_->is_contiguous(), ""); - const char*& ptr = it.buf_->ptr_; - ptr += n; - it.value_ = *ptr; - if (ptr == it.buf_->end_) it.ptr_ = iterator::get_sentinel(); - return it; - } - - auto begin() -> iterator { return this; } - auto end() -> sentinel { return {}; } - - auto is_contiguous() const -> bool { return contiguous_; } - - // Tries consuming a single code unit. Returns true iff there is more input. - auto try_consume() -> bool { - FMT_ASSERT(ptr_ != end_, ""); - ++ptr_; - if (ptr_ != end_) return true; - consume(); - return ptr_ != end_; - } -}; - -using scan_iterator = scan_buffer::iterator; -using scan_sentinel = scan_buffer::sentinel; - -class string_scan_buffer final : public scan_buffer { - private: - void consume() override {} - - public: - explicit string_scan_buffer(string_view s) - : scan_buffer(s.begin(), s.end(), true) {} -}; - -class file_scan_buffer final : public scan_buffer { - private: - template <typename F, FMT_ENABLE_IF(sizeof(F::_IO_read_ptr) != 0 && - !FMT_USE_FALLBACK_FILE)> - static auto get_file(F* f, int) -> glibc_file<F> { - return f; - } - template <typename F, - FMT_ENABLE_IF(sizeof(F::_p) != 0 && !FMT_USE_FALLBACK_FILE)> - static auto get_file(F* f, int) -> apple_file<F> { - return f; - } - static auto get_file(FILE* f, ...) -> fallback_file<FILE> { return f; } - - decltype(get_file(static_cast<FILE*>(nullptr), 0)) file_; - - // Fills the buffer if it is empty. - void fill() { - span<const char> buf = file_.get_read_buffer(); - if (buf.size == 0) { - int c = file_.get(); - // Put the character back since we are only filling the buffer. - if (c != EOF) file_.unget(static_cast<char>(c)); - buf = file_.get_read_buffer(); - } - set(buf); - } - - void consume() override { - // Consume the current buffer content. - size_t n = to_unsigned(ptr() - file_.get_read_buffer().data); - for (size_t i = 0; i != n; ++i) file_.get(); - fill(); - } - - public: - explicit file_scan_buffer(FILE* f) - : scan_buffer(nullptr, nullptr, false), file_(f) { - flockfile(f); - fill(); - } - ~file_scan_buffer() { - FILE* f = file_; - funlockfile(f); - } -}; -} // namespace detail - -template <typename T, typename Char = char> struct scanner { - // A deleted default constructor indicates a disabled scanner. - scanner() = delete; -}; - -class scan_parse_context { - private: - string_view format_; - - public: - using iterator = string_view::iterator; - - FMT_CONSTEXPR explicit scan_parse_context(string_view format) - : format_(format) {} - - FMT_CONSTEXPR auto begin() const -> iterator { return format_.begin(); } - FMT_CONSTEXPR auto end() const -> iterator { return format_.end(); } - - void advance_to(iterator it) { - format_.remove_prefix(detail::to_unsigned(it - begin())); - } -}; - -namespace detail { -enum class scan_type { - none_type, - int_type, - uint_type, - long_long_type, - ulong_long_type, - double_type, - float_type, - string_type, - string_view_type, - custom_type -}; - -template <typename Context> struct custom_scan_arg { - void* value; - void (*scan)(void* arg, scan_parse_context& parse_ctx, Context& ctx); -}; -} // namespace detail - -// A scan argument. Context is a template parameter for the compiled API where -// output can be unbuffered. -template <typename Context> class basic_scan_arg { - private: - using scan_type = detail::scan_type; - scan_type type_; - union { - int* int_value_; - unsigned* uint_value_; - long long* long_long_value_; - unsigned long long* ulong_long_value_; - double* double_value_; - float* float_value_; - std::string* string_; - string_view* string_view_; - detail::custom_scan_arg<Context> custom_; - // TODO: more types - }; - - template <typename T> - static void scan_custom_arg(void* arg, scan_parse_context& parse_ctx, - Context& ctx) { - auto s = scanner<T>(); - parse_ctx.advance_to(s.parse(parse_ctx)); - ctx.advance_to(s.scan(*static_cast<T*>(arg), ctx)); - } - - public: - FMT_CONSTEXPR basic_scan_arg() - : type_(scan_type::none_type), int_value_(nullptr) {} - FMT_CONSTEXPR basic_scan_arg(int& value) - : type_(scan_type::int_type), int_value_(&value) {} - FMT_CONSTEXPR basic_scan_arg(unsigned& value) - : type_(scan_type::uint_type), uint_value_(&value) {} - FMT_CONSTEXPR basic_scan_arg(long long& value) - : type_(scan_type::long_long_type), long_long_value_(&value) {} - FMT_CONSTEXPR basic_scan_arg(unsigned long long& value) - : type_(scan_type::ulong_long_type), ulong_long_value_(&value) {} - FMT_CONSTEXPR basic_scan_arg(double& value) - : type_(scan_type::double_type), double_value_(&value) {} - FMT_CONSTEXPR basic_scan_arg(float& value) - : type_(scan_type::float_type), float_value_(&value) {} - FMT_CONSTEXPR basic_scan_arg(std::string& value) - : type_(scan_type::string_type), string_(&value) {} - FMT_CONSTEXPR basic_scan_arg(string_view& value) - : type_(scan_type::string_view_type), string_view_(&value) {} - template <typename T> - FMT_CONSTEXPR basic_scan_arg(T& value) : type_(scan_type::custom_type) { - custom_.value = &value; - custom_.scan = scan_custom_arg<T>; - } - - constexpr explicit operator bool() const noexcept { - return type_ != scan_type::none_type; - } - - auto type() const -> detail::scan_type { return type_; } - - template <typename Visitor> - auto visit(Visitor&& vis) -> decltype(vis(monostate())) { - switch (type_) { - case scan_type::none_type: - break; - case scan_type::int_type: - return vis(*int_value_); - case scan_type::uint_type: - return vis(*uint_value_); - case scan_type::long_long_type: - return vis(*long_long_value_); - case scan_type::ulong_long_type: - return vis(*ulong_long_value_); - case scan_type::double_type: - return vis(*double_value_); - case scan_type::float_type: - return vis(*float_value_); - case scan_type::string_type: - return vis(*string_); - case scan_type::string_view_type: - return vis(*string_view_); - case scan_type::custom_type: - break; - } - return vis(monostate()); - } - - auto scan_custom(const char* parse_begin, scan_parse_context& parse_ctx, - Context& ctx) const -> bool { - if (type_ != scan_type::custom_type) return false; - parse_ctx.advance_to(parse_begin); - custom_.scan(custom_.value, parse_ctx, ctx); - return true; - } -}; - -class scan_context; -using scan_arg = basic_scan_arg<scan_context>; - -struct scan_args { - int size; - const scan_arg* data; - - template <size_t N> - FMT_CONSTEXPR scan_args(const std::array<scan_arg, N>& store) - : size(N), data(store.data()) { - static_assert(N < INT_MAX, "too many arguments"); - } -}; - -class scan_context { - private: - detail::scan_buffer& buf_; - scan_args args_; - - public: - using iterator = detail::scan_iterator; - using sentinel = detail::scan_sentinel; - - FMT_CONSTEXPR explicit scan_context(detail::scan_buffer& buf, scan_args args) - : buf_(buf), args_(args) {} - - FMT_CONSTEXPR auto arg(int id) const -> scan_arg { - return id < args_.size ? args_.data[id] : scan_arg(); - } - - auto begin() const -> iterator { return buf_.begin(); } - auto end() const -> sentinel { return {}; } - - void advance_to(iterator) { buf_.consume(); } -}; - -namespace detail { - -const char* parse_scan_specs(const char* begin, const char* end, - format_specs& specs, scan_type) { - while (begin != end) { - switch (to_ascii(*begin)) { - // TODO: parse more scan format specifiers - case 'x': - specs.set_type(presentation_type::hex); - ++begin; - break; - case '}': - return begin; - } - } - return begin; -} - -template <typename T, FMT_ENABLE_IF(std::is_unsigned<T>::value)> -auto read(scan_iterator it, T& value) -> scan_iterator { - if (it == scan_sentinel()) return it; - char c = *it; - if (c < '0' || c > '9') report_error("invalid input"); - - int num_digits = 0; - T n = 0, prev = 0; - char prev_digit = c; - do { - prev = n; - n = n * 10 + static_cast<unsigned>(c - '0'); - prev_digit = c; - c = *++it; - ++num_digits; - if (c < '0' || c > '9') break; - } while (it != scan_sentinel()); - - // Check overflow. - if (num_digits <= std::numeric_limits<int>::digits10) { - value = n; - return it; - } - unsigned max = to_unsigned((std::numeric_limits<int>::max)()); - if (num_digits == std::numeric_limits<int>::digits10 + 1 && - prev * 10ull + unsigned(prev_digit - '0') <= max) { - value = n; - } else { - report_error("number is too big"); - } - return it; -} - -template <typename T, FMT_ENABLE_IF(std::is_unsigned<T>::value)> -auto read_hex(scan_iterator it, T& value) -> scan_iterator { - if (it == scan_sentinel()) return it; - int digit = to_hex_digit(*it); - if (digit < 0) report_error("invalid input"); - - int num_digits = 0; - T n = 0; - do { - n = (n << 4) + static_cast<unsigned>(digit); - ++num_digits; - digit = to_hex_digit(*++it); - if (digit < 0) break; - } while (it != scan_sentinel()); - - // Check overflow. - if (num_digits <= (std::numeric_limits<T>::digits >> 2)) - value = n; - else - report_error("number is too big"); - return it; -} - -template <typename T, FMT_ENABLE_IF(std::is_unsigned<T>::value)> -auto read(scan_iterator it, T& value, const format_specs& specs) - -> scan_iterator { - if (specs.type() == presentation_type::hex) return read_hex(it, value); - return read(it, value); -} - -template <typename T, FMT_ENABLE_IF(std::is_signed<T>::value)> -auto read(scan_iterator it, T& value, const format_specs& specs = {}) - -> scan_iterator { - bool negative = it != scan_sentinel() && *it == '-'; - if (negative) { - ++it; - if (it == scan_sentinel()) report_error("invalid input"); - } - using unsigned_type = typename std::make_unsigned<T>::type; - unsigned_type abs_value = 0; - it = read(it, abs_value, specs); - auto n = static_cast<T>(abs_value); - value = negative ? -n : n; - return it; -} - -auto read(scan_iterator it, double& value, const format_specs& = {}) - -> scan_iterator { - if (it == scan_sentinel()) return it; - - // Simple floating-point parsing - bool negative = *it == '-'; - if (negative) { - ++it; - if (it == scan_sentinel()) report_error("invalid input"); - } - - double result = 0.0; - // Parse integer part - while (it != scan_sentinel() && *it >= '0' && *it <= '9') { - result = result * 10.0 + (*it - '0'); - ++it; - } - - // Parse decimal part if present - if (it != scan_sentinel() && *it == '.') { - ++it; - double fraction = 0.1; - while (it != scan_sentinel() && *it >= '0' && *it <= '9') { - result += (*it - '0') * fraction; - fraction *= 0.1; - ++it; - } - } - - value = negative ? -result : result; - return it; -} - -auto read(scan_iterator it, float& value, const format_specs& specs = {}) - -> scan_iterator { - double temp; - it = read(it, temp, specs); - value = static_cast<float>(temp); - return it; -} - -auto read(scan_iterator it, std::string& value, const format_specs& = {}) - -> scan_iterator { - while (it != scan_sentinel() && *it != ' ') value.push_back(*it++); - return it; -} - -auto read(scan_iterator it, string_view& value, const format_specs& = {}) - -> scan_iterator { - auto range = to_contiguous(it); - // This could also be checked at compile time in scan. - if (!range) report_error("string_view requires contiguous input"); - auto p = range.begin; - while (p != range.end && *p != ' ') ++p; - size_t size = to_unsigned(p - range.begin); - value = {range.begin, size}; - return advance(it, size); -} - -auto read(scan_iterator it, monostate, const format_specs& = {}) - -> scan_iterator { - return it; -} - -// An argument scanner that uses the default format, e.g. decimal for integers. -struct default_arg_scanner { - scan_iterator it; - - template <typename T> FMT_INLINE auto operator()(T&& value) -> scan_iterator { - return read(it, value); - } -}; - -// An argument scanner with format specifiers. -struct arg_scanner { - scan_iterator it; - const format_specs& specs; - - template <typename T> auto operator()(T&& value) -> scan_iterator { - return read(it, value, specs); - } -}; - -struct scan_handler { - private: - scan_parse_context parse_ctx_; - scan_context scan_ctx_; - int next_arg_id_; - - using sentinel = scan_buffer::sentinel; - - public: - FMT_CONSTEXPR scan_handler(string_view format, scan_buffer& buf, - scan_args args) - : parse_ctx_(format), scan_ctx_(buf, args), next_arg_id_(0) {} - - auto pos() const -> scan_buffer::iterator { return scan_ctx_.begin(); } - - void on_text(const char* begin, const char* end) { - if (begin == end) return; - auto it = scan_ctx_.begin(); - for (; begin != end; ++begin, ++it) { - if (it == sentinel() || *begin != *it) on_error("invalid input"); - } - scan_ctx_.advance_to(it); - } - - FMT_CONSTEXPR auto on_arg_id() -> int { return on_arg_id(next_arg_id_++); } - FMT_CONSTEXPR auto on_arg_id(int id) -> int { - if (!scan_ctx_.arg(id)) on_error("argument index out of range"); - return id; - } - FMT_CONSTEXPR auto on_arg_id(string_view id) -> int { - if (id.data()) on_error("invalid format"); - return 0; - } - - void on_replacement_field(int arg_id, const char* begin) { - scan_arg arg = scan_ctx_.arg(arg_id); - if (arg.scan_custom(begin, parse_ctx_, scan_ctx_)) return; - auto it = scan_ctx_.begin(); - while (it != sentinel() && is_whitespace(*it)) ++it; - scan_ctx_.advance_to(arg.visit(default_arg_scanner{it})); - } - - auto on_format_specs(int arg_id, const char* begin, const char* end) -> const - char* { - scan_arg arg = scan_ctx_.arg(arg_id); - if (arg.scan_custom(begin, parse_ctx_, scan_ctx_)) - return parse_ctx_.begin(); - auto specs = format_specs(); - begin = parse_scan_specs(begin, end, specs, arg.type()); - if (begin == end || *begin != '}') on_error("missing '}' in format string"); - scan_ctx_.advance_to(arg.visit(arg_scanner{scan_ctx_.begin(), specs})); - return begin; - } - - FMT_NORETURN void on_error(const char* message) { report_error(message); } -}; - -void vscan(detail::scan_buffer& buf, string_view fmt, scan_args args) { - auto h = detail::scan_handler(fmt, buf, args); - detail::parse_format_string(fmt, h); -} - -template <size_t I, typename... T, FMT_ENABLE_IF(I == sizeof...(T))> -void make_args(std::array<scan_arg, sizeof...(T)>&, std::tuple<T...>&) {} - -template <size_t I, typename... T, FMT_ENABLE_IF(I < sizeof...(T))> -void make_args(std::array<scan_arg, sizeof...(T)>& args, - std::tuple<T...>& values) { - using element_type = typename std::tuple_element<I, std::tuple<T...>>::type; - static_assert(std::is_same<remove_cvref_t<element_type>, element_type>::value, - ""); - args[I] = std::get<I>(values); - make_args<I + 1>(args, values); -} -} // namespace detail - -template <typename Range, typename... T> class scan_data { - private: - std::tuple<T...> values_; - Range range_; - - public: - scan_data() = default; - scan_data(T... values) : values_(std::move(values)...) {} - - auto value() const -> decltype(std::get<0>(values_)) { - return std::get<0>(values_); - } - - auto values() const -> const std::tuple<T...>& { return values_; } - - auto make_args() -> std::array<scan_arg, sizeof...(T)> { - auto args = std::array<scan_arg, sizeof...(T)>(); - detail::make_args<0>(args, values_); - return args; - } - - auto range() const -> Range { return range_; } - - auto begin() const -> decltype(range_.begin()) { return range_.begin(); } - auto end() const -> decltype(range_.end()) { return range_.end(); } -}; - -template <typename... T> -auto make_scan_args(T&... args) -> std::array<scan_arg, sizeof...(T)> { - return {{args...}}; -} - -class scan_error {}; - -// A rudimentary version of std::expected for testing the API shape. -template <typename T, typename E> class expected { - private: - T value_; - bool has_value_ = true; - - public: - expected(T value) : value_(std::move(value)) {} - - explicit operator bool() const { return has_value_; } - - auto operator->() const -> const T* { return &value_; } - - auto error() -> E const { return E(); } -}; - -template <typename Range, typename... T> -using scan_result = expected<scan_data<Range, T...>, scan_error>; - -auto vscan(string_view input, string_view fmt, scan_args args) - -> string_view::iterator { - auto&& buf = detail::string_scan_buffer(input); - detail::vscan(buf, fmt, args); - return input.begin() + (buf.begin().base() - input.data()); -} - -// Scans the input and stores the results (in)to args. -template <typename... T> -auto scan_to(string_view input, string_view fmt, T&... args) - -> string_view::iterator { - return vscan(input, fmt, make_scan_args(args...)); -} - -template <typename... T> -auto scan(string_view input, string_view fmt) - -> scan_result<string_view, T...> { - auto data = scan_data<string_view, T...>(); - vscan(input, fmt, data.make_args()); - return data; -} - -template <typename Range, typename... T, - FMT_ENABLE_IF(!std::is_convertible<Range, string_view>::value)> -auto scan_to(Range&& input, string_view fmt, T&... args) - -> decltype(std::begin(input)) { - auto it = std::begin(input); - detail::vscan(get_buffer(it), fmt, make_scan_args(args...)); - return it; -} - -template <typename... T> -auto scan_to(FILE* f, string_view fmt, T&... args) -> bool { - auto&& buf = detail::file_scan_buffer(f); - detail::vscan(buf, fmt, make_scan_args(args...)); - return buf.begin() != buf.end(); -} - -FMT_END_NAMESPACE diff --git a/thirdparty/fmt/test/static-export-test/library.cc b/thirdparty/fmt/test/static-export-test/library.cc deleted file mode 100644 index fe4801ba5..000000000 --- a/thirdparty/fmt/test/static-export-test/library.cc +++ /dev/null @@ -1,5 +0,0 @@ -#include <fmt/compile.h> - -__attribute__((visibility("default"))) std::string foo() { - return fmt::format(FMT_COMPILE("foo bar {}"), 4242); -} diff --git a/thirdparty/fmt/test/static-export-test/main.cc b/thirdparty/fmt/test/static-export-test/main.cc deleted file mode 100644 index 38f7999ed..000000000 --- a/thirdparty/fmt/test/static-export-test/main.cc +++ /dev/null @@ -1,6 +0,0 @@ -#include <iostream> -#include <string> - -extern std::string foo(); - -int main() { std::cout << foo() << std::endl; } diff --git a/thirdparty/fmt/test/std-test.cc b/thirdparty/fmt/test/std-test.cc deleted file mode 100644 index f5b4e7e85..000000000 --- a/thirdparty/fmt/test/std-test.cc +++ /dev/null @@ -1,443 +0,0 @@ -// Formatting library for C++ - tests of formatters for standard library types -// -// Copyright (c) 2012 - present, Victor Zverovich -// All rights reserved. -// -// For the license information refer to format.h. - -#include "fmt/std.h" - -#include <bitset> -#include <stdexcept> -#include <string> -#include <vector> - -#include "fmt/os.h" // fmt::system_category -#include "gtest-extra.h" // StartsWith - -#ifdef __cpp_lib_filesystem -TEST(std_test, path) { - using std::filesystem::path; - EXPECT_EQ(fmt::format("{}", path("/usr/bin")), "/usr/bin"); - - // see #4303 - const path p = "/usr/bin"; - EXPECT_EQ(fmt::format("{}", p), "/usr/bin"); - - EXPECT_EQ(fmt::format("{:?}", path("/usr/bin")), "\"/usr/bin\""); - EXPECT_EQ(fmt::format("{:8}", path("foo")), "foo "); - - EXPECT_EQ(fmt::format("{}", path("foo\"bar")), "foo\"bar"); - EXPECT_EQ(fmt::format("{:?}", path("foo\"bar")), "\"foo\\\"bar\""); - - EXPECT_EQ(fmt::format("{:g}", path("/usr/bin")), "/usr/bin"); -# ifdef _WIN32 - EXPECT_EQ(fmt::format("{}", path("C:\\foo")), "C:\\foo"); - EXPECT_EQ(fmt::format("{:g}", path("C:\\foo")), "C:/foo"); - - EXPECT_EQ(fmt::format("{}", path(L"\x0428\x0447\x0443\x0447\x044B\x043D\x0448" - L"\x0447\x044B\x043D\x0430")), - "Шчучыншчына"); - EXPECT_EQ(fmt::format("{}", path(L"\xd800")), "�"); - EXPECT_EQ(fmt::format("{}", path(L"HEAD \xd800 TAIL")), "HEAD � TAIL"); - EXPECT_EQ(fmt::format("{}", path(L"HEAD \xD83D\xDE00 TAIL")), - "HEAD \xF0\x9F\x98\x80 TAIL"); - EXPECT_EQ(fmt::format("{}", path(L"HEAD \xD83D\xD83D\xDE00 TAIL")), - "HEAD �\xF0\x9F\x98\x80 TAIL"); - EXPECT_EQ(fmt::format("{:?}", path(L"\xd800")), "\"\\ud800\""); -# endif -} - -// Intentionally delayed include to test #4303 -# include "fmt/ranges.h" - -// Test ambiguity problem described in #2954. -TEST(ranges_std_test, format_vector_path) { - auto p = std::filesystem::path("foo/bar.txt"); - auto c = std::vector<std::string>{"abc", "def"}; - EXPECT_EQ(fmt::format("path={}, range={}", p, c), - "path=foo/bar.txt, range=[\"abc\", \"def\"]"); -} - -// Test that path is not escaped twice in the debug mode. -TEST(ranges_std_test, format_quote_path) { - auto vec = - std::vector<std::filesystem::path>{"path1/file1.txt", "path2/file2.txt"}; - EXPECT_EQ(fmt::format("{}", vec), - "[\"path1/file1.txt\", \"path2/file2.txt\"]"); -# ifdef __cpp_lib_optional - auto o = std::optional<std::filesystem::path>("path/file.txt"); - EXPECT_EQ(fmt::format("{}", o), "optional(\"path/file.txt\")"); - EXPECT_EQ(fmt::format("{:?}", o), "optional(\"path/file.txt\")"); -# endif -} -#endif - -TEST(std_test, thread_id) { - EXPECT_FALSE(fmt::format("{}", std::this_thread::get_id()).empty()); -} - -TEST(std_test, complex) { - using limits = std::numeric_limits<double>; - EXPECT_EQ(fmt::format("{}", std::complex<double>(1, limits::quiet_NaN())), - "(1+nan i)"); - EXPECT_EQ(fmt::format("{}", std::complex<double>(1, -limits::infinity())), - "(1-inf i)"); - - EXPECT_EQ(fmt::format("{}", std::complex<int>(1, 2)), "(1+2i)"); - - EXPECT_EQ(fmt::format("{}", std::complex<double>(1, 2.2)), "(1+2.2i)"); - EXPECT_EQ(fmt::format("{}", std::complex<double>(1, -2.2)), "(1-2.2i)"); - EXPECT_EQ(fmt::format("{}", std::complex<double>(0, 2.2)), "2.2i"); - EXPECT_EQ(fmt::format("{}", std::complex<double>(0, -2.2)), "-2.2i"); - - EXPECT_EQ(fmt::format("{:+}", std::complex<double>(0, 2.2)), "+2.2i"); - EXPECT_EQ(fmt::format("{:+}", std::complex<double>(0, -2.2)), "-2.2i"); - EXPECT_EQ(fmt::format("{:+}", std::complex<double>(1, -2.2)), "(+1-2.2i)"); - EXPECT_EQ(fmt::format("{:+}", std::complex<double>(1, 2.2)), "(+1+2.2i)"); - EXPECT_EQ(fmt::format("{: }", std::complex<double>(1, 2.2)), "( 1+2.2i)"); - EXPECT_EQ(fmt::format("{: }", std::complex<double>(1, -2.2)), "( 1-2.2i)"); - - EXPECT_EQ(fmt::format("{:8}", std::complex<double>(1, 2)), "(1+2i) "); - EXPECT_EQ(fmt::format("{:-<8}", std::complex<double>(1, 2)), "(1+2i)--"); - - EXPECT_EQ(fmt::format("{:>20.2f}", std::complex<double>(1, 2.2)), - " (1.00+2.20i)"); - EXPECT_EQ(fmt::format("{:<20.2f}", std::complex<double>(1, 2.2)), - "(1.00+2.20i) "); - EXPECT_EQ(fmt::format("{:<20.2f}", std::complex<double>(1, -2.2)), - "(1.00-2.20i) "); - EXPECT_EQ(fmt::format("{:<{}.{}f}", std::complex<double>(1, -2.2), 20, 2), - "(1.00-2.20i) "); -} - -#ifdef __cpp_lib_source_location -TEST(std_test, source_location) { - std::source_location loc = std::source_location::current(); - EXPECT_EQ(fmt::format("{}", loc), - fmt::format("{}:{}:{}: {}", loc.file_name(), loc.line(), - loc.column(), loc.function_name())); -} -#endif - -TEST(std_test, optional) { -#ifdef __cpp_lib_optional - EXPECT_EQ(fmt::format("{}", std::optional<int>{}), "none"); - EXPECT_EQ(fmt::format("{}", std::pair{1, "second"}), "(1, \"second\")"); - EXPECT_EQ(fmt::format("{}", std::vector{std::optional{1}, std::optional{2}, - std::optional{3}}), - "[optional(1), optional(2), optional(3)]"); - EXPECT_EQ( - fmt::format("{}", std::optional<std::optional<const char*>>{{"nested"}}), - "optional(optional(\"nested\"))"); - EXPECT_EQ( - fmt::format("{:<{}}", std::optional{std::string{"left aligned"}}, 30), - "optional(\"left aligned\" )"); - EXPECT_EQ( - fmt::format("{::d}", std::optional{std::vector{'h', 'e', 'l', 'l', 'o'}}), - "optional([104, 101, 108, 108, 111])"); - EXPECT_EQ(fmt::format("{}", std::optional{std::string{"string"}}), - "optional(\"string\")"); - EXPECT_EQ(fmt::format("{}", std::optional{'C'}), "optional(\'C\')"); - EXPECT_EQ(fmt::format("{:.{}f}", std::optional{3.14}, 1), "optional(3.1)"); - - struct unformattable {}; - EXPECT_FALSE((fmt::is_formattable<unformattable>::value)); - EXPECT_FALSE((fmt::is_formattable<std::optional<unformattable>>::value)); - EXPECT_TRUE((fmt::is_formattable<std::optional<int>>::value)); -#endif -} - -TEST(std_test, expected) { -#ifdef __cpp_lib_expected - EXPECT_EQ(fmt::format("{}", std::expected<void, int>{}), "expected()"); - EXPECT_EQ(fmt::format("{}", std::expected<int, int>{1}), "expected(1)"); - EXPECT_EQ(fmt::format("{}", std::expected<int, int>{std::unexpected(1)}), - "unexpected(1)"); - EXPECT_EQ(fmt::format("{}", std::expected<std::string, int>{"test"}), - "expected(\"test\")"); - EXPECT_EQ(fmt::format( - "{}", std::expected<int, std::string>{std::unexpected("test")}), - "unexpected(\"test\")"); - EXPECT_EQ(fmt::format("{}", std::expected<char, int>{'a'}), "expected('a')"); - EXPECT_EQ(fmt::format("{}", std::expected<int, char>{std::unexpected('a')}), - "unexpected('a')"); - - struct unformattable1 {}; - struct unformattable2 {}; - EXPECT_FALSE((fmt::is_formattable<unformattable1>::value)); - EXPECT_FALSE((fmt::is_formattable<unformattable2>::value)); - EXPECT_FALSE((fmt::is_formattable< - std::expected<unformattable1, unformattable2>>::value)); - EXPECT_FALSE( - (fmt::is_formattable<std::expected<unformattable1, int>>::value)); - EXPECT_FALSE( - (fmt::is_formattable<std::expected<int, unformattable2>>::value)); - EXPECT_TRUE((fmt::is_formattable<std::expected<int, int>>::value)); - EXPECT_TRUE((fmt::is_formattable<std::expected<void, int>>::value)); -#endif -} - -namespace my_nso { -enum class my_number { - one, - two, -}; -auto format_as(my_number number) -> fmt::string_view { - return number == my_number::one ? "first" : "second"; -} - -class my_class { - public: - int av; - - private: - friend auto format_as(const my_class& elm) -> std::string { - return fmt::to_string(elm.av); - } -}; -} // namespace my_nso -TEST(std_test, optional_format_as) { -#ifdef __cpp_lib_optional - EXPECT_EQ(fmt::format("{}", std::optional<my_nso::my_number>{}), "none"); - EXPECT_EQ(fmt::format("{}", std::optional{my_nso::my_number::one}), - "optional(\"first\")"); - EXPECT_EQ(fmt::format("{}", std::optional<my_nso::my_class>{}), "none"); - EXPECT_EQ(fmt::format("{}", std::optional{my_nso::my_class{7}}), - "optional(\"7\")"); -#endif -} - -struct throws_on_move { - throws_on_move() = default; - - [[noreturn]] throws_on_move(throws_on_move&&) { - throw std::runtime_error("Thrown by throws_on_move"); - } - - throws_on_move(const throws_on_move&) = default; -}; - -namespace fmt { -template <> struct formatter<throws_on_move> : formatter<string_view> { - auto format(const throws_on_move&, format_context& ctx) const - -> decltype(ctx.out()) { - string_view str("<throws_on_move>"); - return formatter<string_view>::format(str, ctx); - } -}; -} // namespace fmt - -TEST(std_test, variant) { -#ifdef __cpp_lib_variant - EXPECT_EQ(fmt::format("{}", std::monostate{}), "monostate"); - using V0 = std::variant<int, float, std::string, char>; - V0 v0(42); - V0 v1(1.5f); - V0 v2("hello"); - V0 v3('i'); - EXPECT_EQ(fmt::format("{}", v0), "variant(42)"); - EXPECT_EQ(fmt::format("{}", v1), "variant(1.5)"); - EXPECT_EQ(fmt::format("{}", v2), "variant(\"hello\")"); - EXPECT_EQ(fmt::format("{}", v3), "variant('i')"); - - struct unformattable {}; - EXPECT_FALSE((fmt::is_formattable<unformattable>::value)); - EXPECT_FALSE((fmt::is_formattable<std::variant<unformattable>>::value)); - EXPECT_FALSE((fmt::is_formattable<std::variant<unformattable, int>>::value)); - EXPECT_FALSE((fmt::is_formattable<std::variant<int, unformattable>>::value)); - EXPECT_FALSE( - (fmt::is_formattable<std::variant<unformattable, unformattable>>::value)); - EXPECT_TRUE((fmt::is_formattable<std::variant<int, float>>::value)); - - using V1 = std::variant<std::monostate, std::string, std::string>; - V1 v4{}; - V1 v5{std::in_place_index<1>, "yes, this is variant"}; - - EXPECT_EQ(fmt::format("{}", v4), "variant(monostate)"); - EXPECT_EQ(fmt::format("{}", v5), "variant(\"yes, this is variant\")"); - - volatile int i = 42; // Test compile error before GCC 11 described in #3068. - EXPECT_EQ(fmt::format("{}", i), "42"); - - std::variant<std::monostate, throws_on_move> v6; - - try { - throws_on_move thrower; - v6.emplace<throws_on_move>(std::move(thrower)); - } catch (const std::runtime_error&) { - } - // v6 is now valueless by exception - - EXPECT_EQ(fmt::format("{}", v6), "variant(valueless by exception)"); - -#endif -} - -TEST(std_test, error_code) { - auto& generic = std::generic_category(); - EXPECT_EQ(fmt::format("{}", std::error_code(42, generic)), "generic:42"); - EXPECT_EQ(fmt::format("{:>12}", std::error_code(42, generic)), - " generic:42"); - EXPECT_EQ(fmt::format("{:12}", std::error_code(42, generic)), "generic:42 "); - EXPECT_EQ(fmt::format("{}", std::error_code(42, fmt::system_category())), - "system:42"); - EXPECT_EQ(fmt::format("{}", std::error_code(-42, fmt::system_category())), - "system:-42"); - auto ec = std::make_error_code(std::errc::value_too_large); - EXPECT_EQ(fmt::format("{:s}", ec), ec.message()); - EXPECT_EQ(fmt::format("{:?}", std::error_code(42, generic)), - "\"generic:42\""); -} - -template <typename Catch> void exception_test() { - try { - throw std::runtime_error("Test Exception"); - } catch (const Catch& ex) { - EXPECT_EQ("Test Exception", fmt::format("{}", ex)); - EXPECT_EQ("std::runtime_error: Test Exception", fmt::format("{:t}", ex)); - } -} - -namespace my_ns1 { -namespace my_ns2 { -struct my_exception : public std::exception { - private: - std::string msg; - - public: - my_exception(const std::string& s) : msg(s) {} - const char* what() const noexcept override; -}; -const char* my_exception::what() const noexcept { return msg.c_str(); } -} // namespace my_ns2 -} // namespace my_ns1 - -TEST(std_test, exception) { - using testing::StartsWith; - exception_test<std::exception>(); - exception_test<std::runtime_error>(); - - try { - using namespace my_ns1::my_ns2; - throw my_exception("My Exception"); - } catch (const std::exception& ex) { - EXPECT_EQ("my_ns1::my_ns2::my_exception: My Exception", - fmt::format("{:t}", ex)); - EXPECT_EQ("My Exception", fmt::format("{:}", ex)); - } - - try { - throw std::system_error(std::error_code(), "message"); - } catch (const std::system_error& ex) { - EXPECT_THAT(fmt::format("{:t}", ex), StartsWith("std::system_error: ")); - } - -#ifdef __cpp_lib_filesystem - // Tests that the inline namespace is stripped out, e.g. - // std::filesystem::__cxx11::* -> std::filesystem::*. - try { - throw std::filesystem::filesystem_error("message", std::error_code()); - } catch (const std::filesystem::filesystem_error& ex) { - EXPECT_THAT(fmt::format("{:t}", ex), - StartsWith("std::filesystem::filesystem_error: ")); - } -#endif -} - -#if FMT_USE_RTTI -TEST(std_test, type_info) { - EXPECT_EQ(fmt::format("{}", typeid(std::runtime_error)), - "std::runtime_error"); -} -#endif - -TEST(std_test, format_bit_reference) { - std::bitset<2> bs(1); - EXPECT_EQ(fmt::format("{} {}", bs[0], bs[1]), "true false"); - std::vector<bool> v = {true, false}; - EXPECT_EQ(fmt::format("{} {}", v[0], v[1]), "true false"); -} - -TEST(std_test, format_const_bit_reference) { - const std::bitset<2> bs(1); - EXPECT_EQ(fmt::format("{} {}", bs[0], bs[1]), "true false"); - const std::vector<bool> v = {true, false}; - EXPECT_EQ(fmt::format("{} {}", v[0], v[1]), "true false"); -} - -TEST(std_test, format_bitset) { - auto bs = std::bitset<6>(42); - EXPECT_EQ(fmt::format("{}", bs), "101010"); - EXPECT_EQ(fmt::format("{:0>8}", bs), "00101010"); - EXPECT_EQ(fmt::format("{:-^12}", bs), "---101010---"); -} - -TEST(std_test, format_atomic) { - std::atomic<bool> b(false); - EXPECT_EQ(fmt::format("{}", b), "false"); - - const std::atomic<bool> cb(true); - EXPECT_EQ(fmt::format("{}", cb), "true"); -} - -#ifdef __cpp_lib_atomic_flag_test -TEST(std_test, format_atomic_flag) { - std::atomic_flag f; - (void)f.test_and_set(); - EXPECT_EQ(fmt::format("{}", f), "true"); - - f.clear(); - const std::atomic_flag& cf = f; - EXPECT_EQ(fmt::format("{}", cf), "false"); -} -#endif // __cpp_lib_atomic_flag_test - -TEST(std_test, format_unique_ptr) { - std::unique_ptr<int> up(new int(1)); - EXPECT_EQ(fmt::format("{}", fmt::ptr(up.get())), - fmt::format("{}", fmt::ptr(up))); - struct custom_deleter { - void operator()(int* p) const { delete p; } - }; - std::unique_ptr<int, custom_deleter> upcd(new int(1)); - EXPECT_EQ(fmt::format("{}", fmt::ptr(upcd.get())), - fmt::format("{}", fmt::ptr(upcd))); -} - -TEST(std_test, format_shared_ptr) { - std::shared_ptr<int> sp(new int(1)); - EXPECT_EQ(fmt::format("{}", fmt::ptr(sp.get())), - fmt::format("{}", fmt::ptr(sp))); -} - -TEST(std_test, format_reference_wrapper) { - int num = 35; - EXPECT_EQ(fmt::to_string(std::cref(num)), "35"); - EXPECT_EQ(fmt::to_string(std::ref(num)), "35"); - EXPECT_EQ(fmt::format("{}", std::cref(num)), "35"); - EXPECT_EQ(fmt::format("{}", std::ref(num)), "35"); -} - -// Regression test for https://github.com/fmtlib/fmt/issues/4424. -struct type_with_format_as {}; -int format_as(type_with_format_as) { return 20; } - -TEST(std_test, format_reference_wrapper_with_format_as) { - type_with_format_as t; - EXPECT_EQ(fmt::to_string(std::cref(t)), "20"); - EXPECT_EQ(fmt::to_string(std::ref(t)), "20"); - EXPECT_EQ(fmt::format("{}", std::cref(t)), "20"); - EXPECT_EQ(fmt::format("{}", std::ref(t)), "20"); -} - -struct type_with_format_as_string {}; -std::string format_as(type_with_format_as_string) { return "foo"; } - -TEST(std_test, format_reference_wrapper_with_format_as_string) { - type_with_format_as_string t; - EXPECT_EQ(fmt::to_string(std::cref(t)), "foo"); - EXPECT_EQ(fmt::to_string(std::ref(t)), "foo"); - EXPECT_EQ(fmt::format("{}", std::cref(t)), "foo"); - EXPECT_EQ(fmt::format("{}", std::ref(t)), "foo"); -} diff --git a/thirdparty/fmt/test/test-assert.h b/thirdparty/fmt/test/test-assert.h deleted file mode 100644 index bec3dfc3e..000000000 --- a/thirdparty/fmt/test/test-assert.h +++ /dev/null @@ -1,39 +0,0 @@ -// Formatting library for C++ - test version of FMT_ASSERT -// -// Copyright (c) 2012 - present, Victor Zverovich -// All rights reserved. -// -// For the license information refer to format.h. - -#ifndef FMT_TEST_ASSERT_H_ -#define FMT_TEST_ASSERT_H_ - -#include <stdexcept> - -void throw_assertion_failure(const char* message); -#define FMT_ASSERT(condition, message) \ - ((condition) ? (void)0 : throw_assertion_failure(message)) - -#include "gtest/gtest.h" - -class assertion_failure : public std::logic_error { - public: - explicit assertion_failure(const char* message) : std::logic_error(message) {} - - private: - virtual void avoid_weak_vtable(); -}; - -void assertion_failure::avoid_weak_vtable() {} - -// We use a separate function (rather than throw directly from FMT_ASSERT) to -// avoid GCC's -Wterminate warning when FMT_ASSERT is used in a destructor. -inline void throw_assertion_failure(const char* message) { - throw assertion_failure(message); -} - -// Expects an assertion failure. -#define EXPECT_ASSERT(stmt, message) \ - FMT_TEST_THROW_(stmt, assertion_failure, message, GTEST_NONFATAL_FAILURE_) - -#endif // FMT_TEST_ASSERT_H_ diff --git a/thirdparty/fmt/test/test-main.cc b/thirdparty/fmt/test/test-main.cc deleted file mode 100644 index 39d2789d3..000000000 --- a/thirdparty/fmt/test/test-main.cc +++ /dev/null @@ -1,43 +0,0 @@ -// Formatting library for C++ - test main function. -// -// Copyright (c) 2012 - present, Victor Zverovich -// All rights reserved. -// -// For the license information refer to format.h. - -#include <cstdlib> - -#include "gtest/gtest.h" - -#ifdef _WIN32 -# include <windows.h> -#endif - -#ifdef _MSC_VER -# include <crtdbg.h> -#endif - -int main(int argc, char** argv) { -#ifdef _WIN32 - // Don't display any error dialogs. This also suppresses message boxes - // on assertion failures in MinGW where _set_error_mode/CrtSetReportMode - // doesn't help. - SetErrorMode(SEM_FAILCRITICALERRORS | SEM_NOGPFAULTERRORBOX | - SEM_NOOPENFILEERRORBOX); -#endif -#ifdef _MSC_VER - // Disable message boxes on assertion failures. - _CrtSetReportMode(_CRT_ERROR, _CRTDBG_MODE_FILE | _CRTDBG_MODE_DEBUG); - _CrtSetReportFile(_CRT_ERROR, _CRTDBG_FILE_STDERR); - _CrtSetReportMode(_CRT_ASSERT, _CRTDBG_MODE_FILE | _CRTDBG_MODE_DEBUG); - _CrtSetReportFile(_CRT_ASSERT, _CRTDBG_FILE_STDERR); -#endif - try { - testing::InitGoogleTest(&argc, argv); - testing::FLAGS_gtest_death_test_style = "threadsafe"; - return RUN_ALL_TESTS(); - } catch (...) { - // Catch all exceptions to make Coverity happy. - } - return EXIT_FAILURE; -} diff --git a/thirdparty/fmt/test/unicode-test.cc b/thirdparty/fmt/test/unicode-test.cc deleted file mode 100644 index 2b59cff97..000000000 --- a/thirdparty/fmt/test/unicode-test.cc +++ /dev/null @@ -1,48 +0,0 @@ -// Formatting library for C++ - Unicode tests -// -// Copyright (c) 2012 - present, Victor Zverovich -// All rights reserved. -// -// For the license information refer to format.h. - -#include <iomanip> -#include <locale> -#include <vector> - -#include "fmt/chrono.h" -#include "gmock/gmock.h" -#include "util.h" // get_locale - -using testing::Contains; - -TEST(unicode_test, use_utf8) { EXPECT_TRUE(fmt::detail::use_utf8); } - -TEST(unicode_test, legacy_locale) { - auto loc = get_locale("be_BY.CP1251", "Belarusian_Belarus.1251"); - if (loc == std::locale::classic()) return; - - auto s = std::string(); - try { - s = fmt::format(loc, "Дзень тыдня: {:L}", fmt::weekday(1)); - } catch (const fmt::format_error& e) { - // Formatting can fail due to an unsupported encoding. - fmt::print("Format error: {}\n", e.what()); - return; - } - -#if !FMT_GCC_VERSION || FMT_GCC_VERSION >= 500 - auto&& os = std::ostringstream(); - os.imbue(loc); - auto tm = std::tm(); - tm.tm_wday = 1; - os << std::put_time(&tm, "%a"); - auto wd = os.str(); - if (wd == "??") { - EXPECT_EQ(s, "Дзень тыдня: ??"); - fmt::print("std::locale gives ?? as a weekday.\n"); - return; - } -#endif - EXPECT_THAT((std::vector<std::string>{"Дзень тыдня: пн", "Дзень тыдня: Пан"}), - Contains(s)); -} diff --git a/thirdparty/fmt/test/util.cc b/thirdparty/fmt/test/util.cc deleted file mode 100644 index 8ea266108..000000000 --- a/thirdparty/fmt/test/util.cc +++ /dev/null @@ -1,48 +0,0 @@ -// Formatting library for C++ - test utilities -// -// Copyright (c) 2012 - present, Victor Zverovich -// All rights reserved. -// -// For the license information refer to format.h. - -#include "util.h" - -#include <cstring> - -const char* const file_content = "Don't panic!"; - -fmt::buffered_file open_buffered_file(FILE** fp) { -#if FMT_USE_FCNTL - auto pipe = fmt::pipe(); - pipe.write_end.write(file_content, std::strlen(file_content)); - pipe.write_end.close(); - fmt::buffered_file f = pipe.read_end.fdopen("r"); - if (fp) *fp = f.get(); -#else - fmt::buffered_file f("test-file", "w"); - fputs(file_content, f.get()); - if (fp) *fp = f.get(); -#endif - return f; -} - -std::locale do_get_locale(const char* name) { - try { - return std::locale(name); - } catch (const std::runtime_error&) { - } - return std::locale::classic(); -} - -std::locale get_locale(const char* name, const char* alt_name) { - auto loc = do_get_locale(name); - if (loc == std::locale::classic() && alt_name) loc = do_get_locale(alt_name); -#ifdef __OpenBSD__ - // Locales are not working in OpenBSD: - // https://github.com/fmtlib/fmt/issues/3670. - loc = std::locale::classic(); -#endif - if (loc == std::locale::classic()) - fmt::print(stderr, "{} locale is missing.\n", name); - return loc; -} diff --git a/thirdparty/fmt/test/util.h b/thirdparty/fmt/test/util.h deleted file mode 100644 index 1f2916a9d..000000000 --- a/thirdparty/fmt/test/util.h +++ /dev/null @@ -1,72 +0,0 @@ -// Formatting library for C++ - test utilities -// -// Copyright (c) 2012 - present, Victor Zverovich -// All rights reserved. -// -// For the license information refer to format.h. - -#include <cstdarg> -#include <cstdio> -#include <locale> -#include <string> - -#include "fmt/os.h" - -#ifdef _MSC_VER -# define FMT_VSNPRINTF vsprintf_s -#else -# define FMT_VSNPRINTF vsnprintf -#endif - -template <size_t SIZE> -void safe_sprintf(char (&buffer)[SIZE], const char* format, ...) { - std::va_list args; - va_start(args, format); - FMT_VSNPRINTF(buffer, SIZE, format, args); - va_end(args); -} - -extern const char* const file_content; - -// Opens a buffered file for reading. -auto open_buffered_file(FILE** fp = nullptr) -> fmt::buffered_file; - -template <typename Char> class basic_test_string { - private: - std::basic_string<Char> value_; - - static const Char empty[]; - - public: - explicit basic_test_string(const Char* value = empty) : value_(value) {} - - auto value() const -> const std::basic_string<Char>& { return value_; } -}; - -template <typename Char> const Char basic_test_string<Char>::empty[] = {0}; - -using test_string = basic_test_string<char>; -using test_wstring = basic_test_string<wchar_t>; - -template <typename Char> -auto operator<<(std::basic_ostream<Char>& os, const basic_test_string<Char>& s) - -> std::basic_ostream<Char>& { - os << s.value(); - return os; -} - -class date { - int year_, month_, day_; - - public: - date(int year, int month, int day) : year_(year), month_(month), day_(day) {} - - auto year() const -> int { return year_; } - auto month() const -> int { return month_; } - auto day() const -> int { return day_; } -}; - -// Returns a locale with the given name if available or classic locale -// otherwise. -auto get_locale(const char* name, const char* alt_name = nullptr) - -> std::locale; diff --git a/thirdparty/fmt/test/xchar-test.cc b/thirdparty/fmt/test/xchar-test.cc deleted file mode 100644 index b0646da07..000000000 --- a/thirdparty/fmt/test/xchar-test.cc +++ /dev/null @@ -1,429 +0,0 @@ -// Formatting library for C++ - formatting library tests -// -// Copyright (c) 2012 - present, Victor Zverovich -// All rights reserved. -// -// For the license information refer to format.h. - -#include "fmt/xchar.h" - -#include <algorithm> -#include <complex> -#include <cwchar> -#include <vector> - -#include "fmt/chrono.h" -#include "fmt/color.h" -#include "fmt/ostream.h" -#include "fmt/ranges.h" -#include "fmt/std.h" -#include "gtest-extra.h" // Contains -#include "util.h" // get_locale - -using fmt::detail::max_value; -using testing::Contains; - -#if defined(__MINGW32__) && !defined(_UCRT) -// Only C89 conversion specifiers when using MSVCRT instead of UCRT -# define FMT_HAS_C99_STRFTIME 0 -#else -# define FMT_HAS_C99_STRFTIME 1 -#endif - -struct non_string {}; - -template <typename T> class has_to_string_view_test : public testing::Test {}; - -using string_char_types = testing::Types<char, wchar_t, char16_t, char32_t>; -TYPED_TEST_SUITE(has_to_string_view_test, string_char_types); - -template <typename Char> -struct derived_from_string_view : fmt::basic_string_view<Char> {}; - -TYPED_TEST(has_to_string_view_test, has_to_string_view) { - EXPECT_TRUE(fmt::detail::has_to_string_view<TypeParam*>::value); - EXPECT_TRUE(fmt::detail::has_to_string_view<const TypeParam*>::value); - EXPECT_TRUE(fmt::detail::has_to_string_view<TypeParam[2]>::value); - EXPECT_TRUE(fmt::detail::has_to_string_view<const TypeParam[2]>::value); - EXPECT_TRUE( - fmt::detail::has_to_string_view<std::basic_string<TypeParam>>::value); - EXPECT_TRUE(fmt::detail::has_to_string_view< - fmt::basic_string_view<TypeParam>>::value); - EXPECT_TRUE(fmt::detail::has_to_string_view< - derived_from_string_view<TypeParam>>::value); - using fmt_string_view = fmt::detail::std_string_view<TypeParam>; - EXPECT_TRUE(std::is_empty<fmt_string_view>::value != - fmt::detail::has_to_string_view<fmt_string_view>::value); - EXPECT_FALSE(fmt::detail::has_to_string_view<non_string>::value); -} - -// std::is_constructible is broken in MSVC until version 2015. -#if !FMT_MSC_VERSION || FMT_MSC_VERSION >= 1900 -struct explicitly_convertible_to_wstring_view { - explicit operator fmt::wstring_view() const { return L"foo"; } -}; - -TEST(xchar_test, format_explicitly_convertible_to_wstring_view) { - // Types explicitly convertible to wstring_view are not formattable by - // default because it may introduce ODR violations. - static_assert( - !fmt::is_formattable<explicitly_convertible_to_wstring_view>::value, ""); -} -#endif - -TEST(xchar_test, format) { - EXPECT_EQ(fmt::format(L"{}", 42), L"42"); - EXPECT_EQ(fmt::format(L"{}", 4.2), L"4.2"); - EXPECT_EQ(fmt::format(L"{}", 1e100), L"1e+100"); - EXPECT_EQ(fmt::format(L"{}", L"abc"), L"abc"); - EXPECT_EQ(fmt::format(L"{}", L'z'), L"z"); - EXPECT_THROW(fmt::format(fmt::runtime(L"{:*\x343E}"), 42), fmt::format_error); - EXPECT_EQ(fmt::format(L"{}", true), L"true"); - EXPECT_EQ(fmt::format(L"{0}", L'a'), L"a"); - EXPECT_EQ(fmt::format(L"Letter {}", L'\x40e'), L"Letter \x40e"); // Ў - if (sizeof(wchar_t) == 4) - EXPECT_EQ(fmt::format(fmt::runtime(L"{:𓀨>3}"), 42), L"𓀨42"); - EXPECT_EQ(fmt::format(L"{}c{}", L"ab", 1), L"abc1"); -} - -TEST(xchar_test, is_formattable) { - static_assert(!fmt::is_formattable<const wchar_t*>::value, ""); -} - -TEST(xchar_test, compile_time_string) { - EXPECT_EQ(fmt::format(fmt::wformat_string<int>(L"{}"), 42), L"42"); -#if defined(FMT_USE_STRING_VIEW) && FMT_CPLUSPLUS >= 201703L - EXPECT_EQ(fmt::format(FMT_STRING(std::wstring_view(L"{}")), 42), L"42"); -#endif -} - -TEST(xchar_test, format_to) { - auto buf = std::vector<wchar_t>(); - fmt::format_to(std::back_inserter(buf), L"{}{}", 42, L'\0'); - EXPECT_STREQ(buf.data(), L"42"); -} - -TEST(xchar_test, compile_time_string_format_to) { - std::wstring ws; - fmt::format_to(std::back_inserter(ws), FMT_STRING(L"{}"), 42); - EXPECT_EQ(L"42", ws); -} - -TEST(xchar_test, vformat_to) { - int n = 42; - auto args = fmt::make_wformat_args(n); - auto w = std::wstring(); - fmt::vformat_to(std::back_inserter(w), L"{}", args); - EXPECT_EQ(L"42", w); -} - -namespace test { -struct struct_as_wstring_view {}; -auto format_as(struct_as_wstring_view) -> fmt::wstring_view { return L"foo"; } -} // namespace test - -TEST(xchar_test, format_as) { - EXPECT_EQ(fmt::format(L"{}", test::struct_as_wstring_view()), L"foo"); -} - -TEST(format_test, wide_format_to_n) { - wchar_t buffer[4]; - buffer[3] = L'x'; - auto result = fmt::format_to_n(buffer, 3, L"{}", 12345); - EXPECT_EQ(5u, result.size); - EXPECT_EQ(buffer + 3, result.out); - EXPECT_EQ(L"123x", fmt::wstring_view(buffer, 4)); - buffer[0] = L'x'; - buffer[1] = L'x'; - buffer[2] = L'x'; - result = fmt::format_to_n(buffer, 3, L"{}", L'A'); - EXPECT_EQ(1u, result.size); - EXPECT_EQ(buffer + 1, result.out); - EXPECT_EQ(L"Axxx", fmt::wstring_view(buffer, 4)); - result = fmt::format_to_n(buffer, 3, L"{}{} ", L'B', L'C'); - EXPECT_EQ(3u, result.size); - EXPECT_EQ(buffer + 3, result.out); - EXPECT_EQ(L"BC x", fmt::wstring_view(buffer, 4)); -} - -TEST(xchar_test, named_arg_udl) { - using namespace fmt::literals; - auto udl_a = - fmt::format(L"{first}{second}{first}{third}", L"first"_a = L"abra", - L"second"_a = L"cad", L"third"_a = 99); - EXPECT_EQ( - fmt::format(L"{first}{second}{first}{third}", fmt::arg(L"first", L"abra"), - fmt::arg(L"second", L"cad"), fmt::arg(L"third", 99)), - udl_a); -} - -TEST(xchar_test, print) { - // Check that the wide print overload compiles. - if (fmt::detail::const_check(false)) { - fmt::print(L"test"); - fmt::println(L"test"); - } -} - -TEST(xchar_test, join) { - int v[3] = {1, 2, 3}; - EXPECT_EQ(fmt::format(L"({})", fmt::join(v, v + 3, L", ")), L"(1, 2, 3)"); - auto t = std::tuple<wchar_t, int, float>('a', 1, 2.0f); - EXPECT_EQ(fmt::format(L"({})", fmt::join(t, L", ")), L"(a, 1, 2)"); -} - -#ifdef __cpp_lib_byte -TEST(xchar_test, join_bytes) { - auto v = std::vector<std::byte>{std::byte(1), std::byte(2), std::byte(3)}; - EXPECT_EQ(fmt::format(L"{}", fmt::join(v, L", ")), L"1, 2, 3"); -} -#endif - -enum streamable_enum {}; - -std::wostream& operator<<(std::wostream& os, streamable_enum) { - return os << L"streamable_enum"; -} - -namespace fmt { -template <> -struct formatter<streamable_enum, wchar_t> : basic_ostream_formatter<wchar_t> { -}; -} // namespace fmt - -enum unstreamable_enum {}; -auto format_as(unstreamable_enum e) -> int { return e; } - -TEST(xchar_test, enum) { - EXPECT_EQ(L"streamable_enum", fmt::format(L"{}", streamable_enum())); - EXPECT_EQ(L"0", fmt::format(L"{}", unstreamable_enum())); -} - -struct streamable_and_unformattable {}; - -auto operator<<(std::wostream& os, streamable_and_unformattable) - -> std::wostream& { - return os << L"foo"; -} - -TEST(xchar_test, streamed) { - EXPECT_FALSE(fmt::is_formattable<streamable_and_unformattable>()); - EXPECT_EQ(fmt::format(L"{}", fmt::streamed(streamable_and_unformattable())), - L"foo"); -} - -TEST(xchar_test, sign_not_truncated) { - wchar_t format_str[] = { - L'{', L':', - '+' | static_cast<wchar_t>(1 << fmt::detail::num_bits<char>()), L'}', 0}; - EXPECT_THROW(fmt::format(fmt::runtime(format_str), 42), fmt::format_error); -} - -TEST(xchar_test, chrono) { - auto tm = std::tm(); - tm.tm_year = 116; - tm.tm_mon = 3; - tm.tm_mday = 25; - tm.tm_hour = 11; - tm.tm_min = 22; - tm.tm_sec = 33; - EXPECT_EQ(fmt::format("The date is {:%Y-%m-%d %H:%M:%S}.", tm), - "The date is 2016-04-25 11:22:33."); - EXPECT_EQ(L"42s", fmt::format(L"{}", std::chrono::seconds(42))); - EXPECT_EQ(fmt::format(L"{:%F}", tm), L"2016-04-25"); - EXPECT_EQ(fmt::format(L"{:%T}", tm), L"11:22:33"); - - auto t = fmt::sys_time<std::chrono::seconds>(std::chrono::seconds(290088000)); - EXPECT_EQ(fmt::format("{:%Y-%m-%d %H:%M:%S}", t), "1979-03-12 12:00:00"); -} - -TEST(xchar_test, color) { - EXPECT_EQ(fmt::format(fg(fmt::rgb(255, 20, 30)), L"rgb(255,20,30) wide"), - L"\x1b[38;2;255;020;030mrgb(255,20,30) wide\x1b[0m"); -} - -TEST(xchar_test, ostream) { -#if !FMT_GCC_VERSION || FMT_GCC_VERSION >= 409 - { - std::wostringstream wos; - fmt::print(wos, L"Don't {}!", L"panic"); - EXPECT_EQ(wos.str(), L"Don't panic!"); - } - - { - std::wostringstream wos; - fmt::println(wos, L"Don't {}!", L"panic"); - EXPECT_EQ(wos.str(), L"Don't panic!\n"); - } -#endif -} - -TEST(xchar_test, format_map) { - auto m = std::map<std::wstring, int>{{L"one", 1}, {L"t\"wo", 2}}; - EXPECT_EQ(fmt::format(L"{}", m), L"{\"one\": 1, \"t\\\"wo\": 2}"); -} - -TEST(xchar_test, escape_string) { - using vec = std::vector<std::wstring>; - EXPECT_EQ(fmt::format(L"{}", vec{L"\n\r\t\"\\"}), L"[\"\\n\\r\\t\\\"\\\\\"]"); - EXPECT_EQ(fmt::format(L"{}", vec{L"понедельник"}), L"[\"понедельник\"]"); -} - -TEST(xchar_test, to_wstring) { EXPECT_EQ(L"42", fmt::to_wstring(42)); } - -#ifndef FMT_STATIC_THOUSANDS_SEPARATOR - -template <typename Char> struct numpunct : std::numpunct<Char> { - protected: - Char do_decimal_point() const override { return '?'; } - std::string do_grouping() const override { return "\03"; } - Char do_thousands_sep() const override { return '~'; } -}; - -template <typename Char> struct no_grouping : std::numpunct<Char> { - protected: - Char do_decimal_point() const override { return '.'; } - std::string do_grouping() const override { return ""; } - Char do_thousands_sep() const override { return ','; } -}; - -template <typename Char> struct special_grouping : std::numpunct<Char> { - protected: - Char do_decimal_point() const override { return '.'; } - std::string do_grouping() const override { return "\03\02"; } - Char do_thousands_sep() const override { return ','; } -}; - -template <typename Char> struct small_grouping : std::numpunct<Char> { - protected: - Char do_decimal_point() const override { return '.'; } - std::string do_grouping() const override { return "\01"; } - Char do_thousands_sep() const override { return ','; } -}; - -TEST(locale_test, localized_double) { - auto loc = std::locale(std::locale(), new numpunct<char>()); - EXPECT_EQ(fmt::format(loc, "{:L}", 1.23), "1?23"); - EXPECT_EQ(fmt::format(loc, "{:Lf}", 1.23), "1?230000"); - EXPECT_EQ(fmt::format(loc, "{:L}", 1234.5), "1~234?5"); - EXPECT_EQ(fmt::format(loc, "{:L}", 12000.0), "12~000"); - EXPECT_EQ(fmt::format(loc, "{:8L}", 1230.0), " 1~230"); - EXPECT_EQ(fmt::format(loc, "{:15.6Lf}", 0.1), " 0?100000"); - EXPECT_EQ(fmt::format(loc, "{:15.6Lf}", 1.0), " 1?000000"); - EXPECT_EQ(fmt::format(loc, "{:15.6Lf}", 1e3), " 1~000?000000"); -} - -TEST(locale_test, format) { - auto loc = std::locale(std::locale(), new numpunct<char>()); - EXPECT_EQ("1234567", fmt::format(std::locale(), "{:L}", 1234567)); - EXPECT_EQ("1~234~567", fmt::format(loc, "{:L}", 1234567)); - EXPECT_EQ("-1~234~567", fmt::format(loc, "{:L}", -1234567)); - EXPECT_EQ("-256", fmt::format(loc, "{:L}", -256)); - auto n = 1234567; - EXPECT_EQ("1~234~567", fmt::vformat(loc, "{:L}", fmt::make_format_args(n))); - auto s = std::string(); - fmt::format_to(std::back_inserter(s), loc, "{:L}", 1234567); - EXPECT_EQ("1~234~567", s); - - auto no_grouping_loc = std::locale(std::locale(), new no_grouping<char>()); - EXPECT_EQ("1234567", fmt::format(no_grouping_loc, "{:L}", 1234567)); - - auto special_grouping_loc = - std::locale(std::locale(), new special_grouping<char>()); - EXPECT_EQ("1,23,45,678", fmt::format(special_grouping_loc, "{:L}", 12345678)); - EXPECT_EQ("12,345", fmt::format(special_grouping_loc, "{:L}", 12345)); - - auto small_grouping_loc = - std::locale(std::locale(), new small_grouping<char>()); - EXPECT_EQ("4,2,9,4,9,6,7,2,9,5", - fmt::format(small_grouping_loc, "{:L}", max_value<uint32_t>())); -} - -TEST(locale_test, format_default_align) { - auto loc = std::locale({}, new special_grouping<char>()); - EXPECT_EQ(" 12,345", fmt::format(loc, "{:8L}", 12345)); -} - -TEST(locale_test, format_plus) { - auto loc = std::locale({}, new special_grouping<char>()); - EXPECT_EQ("+100", fmt::format(loc, "{:+L}", 100)); -} - -TEST(locale_test, wformat) { - auto loc = std::locale(std::locale(), new numpunct<wchar_t>()); - EXPECT_EQ(L"1234567", fmt::format(std::locale(), L"{:L}", 1234567)); - EXPECT_EQ(L"1~234~567", fmt::format(loc, L"{:L}", 1234567)); - int n = 1234567; - EXPECT_EQ(L"1~234~567", - fmt::vformat(loc, L"{:L}", fmt::make_wformat_args(n))); - EXPECT_EQ(L"1234567", fmt::format(std::locale("C"), L"{:L}", 1234567)); - - auto no_grouping_loc = std::locale(std::locale(), new no_grouping<wchar_t>()); - EXPECT_EQ(L"1234567", fmt::format(no_grouping_loc, L"{:L}", 1234567)); - - auto special_grouping_loc = - std::locale(std::locale(), new special_grouping<wchar_t>()); - EXPECT_EQ(L"1,23,45,678", - fmt::format(special_grouping_loc, L"{:L}", 12345678)); - - auto small_grouping_loc = - std::locale(std::locale(), new small_grouping<wchar_t>()); - EXPECT_EQ(L"4,2,9,4,9,6,7,2,9,5", - fmt::format(small_grouping_loc, L"{:L}", max_value<uint32_t>())); -} - -TEST(locale_test, int_formatter) { - auto loc = std::locale(std::locale(), new special_grouping<char>()); - auto f = fmt::formatter<int>(); - auto parse_ctx = fmt::format_parse_context("L"); - f.parse(parse_ctx); - auto buf = fmt::memory_buffer(); - fmt::basic_format_context<fmt::appender, char> format_ctx( - fmt::appender(buf), {}, fmt::locale_ref(loc)); - f.format(12345, format_ctx); - EXPECT_EQ(fmt::to_string(buf), "12,345"); -} - -TEST(locale_test, chrono_weekday) { - auto loc = get_locale("es_ES.UTF-8", "Spanish_Spain.1252"); - auto loc_old = std::locale::global(loc); - auto sat = fmt::weekday(6); - EXPECT_EQ(fmt::format(L"{}", sat), L"Sat"); - if (loc != std::locale::classic()) { - // L'\341' is 'á'. - auto saturdays = - std::vector<std::wstring>{L"s\341b", L"s\341.", L"s\341b."}; - EXPECT_THAT(saturdays, Contains(fmt::format(loc, L"{:L}", sat))); - } - std::locale::global(loc_old); -} - -TEST(locale_test, sign) { - EXPECT_EQ(fmt::format(std::locale(), L"{:L}", -50), L"-50"); -} - -TEST(std_test_xchar, format_bitset) { - auto bs = std::bitset<6>(42); - EXPECT_EQ(fmt::format(L"{}", bs), L"101010"); - EXPECT_EQ(fmt::format(L"{:0>8}", bs), L"00101010"); - EXPECT_EQ(fmt::format(L"{:-^12}", bs), L"---101010---"); -} - -TEST(std_test_xchar, complex) { - auto s = fmt::format(L"{}", std::complex<double>(1, 2)); - EXPECT_EQ(s, L"(1+2i)"); - EXPECT_EQ(fmt::format(L"{:.2f}", std::complex<double>(1, 2)), - L"(1.00+2.00i)"); - EXPECT_EQ(fmt::format(L"{:8}", std::complex<double>(1, 2)), L"(1+2i) "); - EXPECT_EQ(fmt::format(L"{:-<8}", std::complex<double>(1, 2)), L"(1+2i)--"); -} - -TEST(std_test_xchar, optional) { -# ifdef __cpp_lib_optional - EXPECT_EQ(fmt::format(L"{}", std::optional{L'C'}), L"optional(\'C\')"); - EXPECT_EQ(fmt::format(L"{}", std::optional{std::wstring{L"wide string"}}), - L"optional(\"wide string\")"); -# endif -} - -#endif // FMT_STATIC_THOUSANDS_SEPARATOR |