File Coverage

/usr/local/lib/perl5/site_perl/5.26.1/x86_64-linux/XS/libcatch.x/i/catch2/catch_tostring.hpp

Criterion	Covered	Total	%
statement	4	4	100.0
branch	1	2	50.0
condition			n/a
subroutine			n/a
pod			n/a
total	5	6	83.3

//              Copyright Catch2 Authors
// Distributed under the Boost Software License, Version 1.0.
//   (See accompanying file LICENSE_1_0.txt or copy at
//        https://www.boost.org/LICENSE_1_0.txt)

// SPDX-License-Identifier: BSL-1.0
#ifndef CATCH_TOSTRING_HPP_INCLUDED
#define CATCH_TOSTRING_HPP_INCLUDED


#include
#include
#include
#include
#include

#include
#include
#include
#include
#include

#ifdef CATCH_CONFIG_CPP17_STRING_VIEW
#include
#endif

#ifdef _MSC_VER
#pragma warning(push)
#pragma warning(disable:4180) // We attempt to stream a function (address) by const&, which MSVC complains about but is harmless
#endif

// We need a dummy global operator<< so we can bring it into Catch namespace later
struct Catch_global_namespace_dummy{};
std::ostream& operator<<(std::ostream&, Catch_global_namespace_dummy);

namespace Catch {
    // Bring in global namespace operator<< for ADL lookup in
    // `IsStreamInsertable` below.
    using ::operator<<;

    namespace Detail {


        constexpr StringRef unprintableString = "{?}"_sr;

        //! Encases `string in quotes, and optionally escapes invisibles
        std::string convertIntoString( StringRef string, bool escapeInvisibles );

        //! Encases `string` in quotes, and escapes invisibles if user requested
        //! it via CLI
        std::string convertIntoString( StringRef string );

        std::string rawMemoryToString( const void *object, std::size_t size );

        template
        std::string rawMemoryToString( const T& object ) {
          return rawMemoryToString( &object, sizeof(object) );
        }

        template
        class IsStreamInsertable {
            template
            static auto test(int)
                -> decltype(std::declval() << std::declval(), std::true_type());

            template
            static auto test(...)->std::false_type;

        public:
            static const bool value = decltype(test(0))::value;
        };

        template
        std::string convertUnknownEnumToString( E e );

        template
        std::enable_if_t<
            !std::is_enum::value && !std::is_base_of::value,
        std::string> convertUnstreamable( T const& ) {
            return std::string(Detail::unprintableString);
        }
        template
        std::enable_if_t<
            !std::is_enum::value && std::is_base_of::value,
         std::string> convertUnstreamable(T const& ex) {
            return ex.what();
        }


        template
        std::enable_if_t<
            std::is_enum::value,
        std::string> convertUnstreamable( T const& value ) {
            return convertUnknownEnumToString( value );
        }

#if defined(_MANAGED)
        //! Convert a CLR string to a utf8 std::string
        template
        std::string clrReferenceToString( T^ ref ) {
            if (ref == nullptr)
                return std::string("null");
            auto bytes = System::Text::Encoding::UTF8->GetBytes(ref->ToString());
            cli::pin_ptr p = &bytes[0];
            return std::string(reinterpret_cast(p), bytes->Length);
        }
#endif

    } // namespace Detail


    // If we decide for C++14, change these to enable_if_ts
    template
    struct StringMaker {
        template
        static
        std::enable_if_t<::Catch::Detail::IsStreamInsertable::value, std::string>
            convert(const Fake& value) {
                ReusableStringStream rss;
                // NB: call using the function-like syntax to avoid ambiguity with
                // user-defined templated operator<< under clang.
                rss.operator<<(value);
                return rss.str();
        }

        template
        static
        std::enable_if_t::value, std::string>
            convert( const Fake& value ) {
#if !defined(CATCH_CONFIG_FALLBACK_STRINGIFIER)
            return Detail::convertUnstreamable(value);
#else
            return CATCH_CONFIG_FALLBACK_STRINGIFIER(value);
#endif
        }
    };

    namespace Detail {

        // This function dispatches all stringification requests inside of Catch.
        // Should be preferably called fully qualified, like ::Catch::Detail::stringify
        template
        std::string stringify(const T& e) {
            return ::Catch::StringMaker>>::convert(e);
        }

        template
        std::string convertUnknownEnumToString( E e ) {
            return ::Catch::Detail::stringify(static_cast>(e));
        }

#if defined(_MANAGED)
        template
        std::string stringify( T^ e ) {
            return ::Catch::StringMaker::convert(e);
        }
#endif

    } // namespace Detail

    // Some predefined specializations

    template<>
    struct StringMaker {
        static std::string convert(const std::string& str);
    };

#ifdef CATCH_CONFIG_CPP17_STRING_VIEW
    template<>
    struct StringMaker {
        static std::string convert(std::string_view str);
    };
#endif

    template<>
    struct StringMaker {
        static std::string convert(char const * str);
    };
    template<>
    struct StringMaker {
        static std::string convert(char * str);
    };

#if defined(CATCH_CONFIG_WCHAR)
    template<>
    struct StringMaker {
        static std::string convert(const std::wstring& wstr);
    };

# ifdef CATCH_CONFIG_CPP17_STRING_VIEW
    template<>
    struct StringMaker {
        static std::string convert(std::wstring_view str);
    };
# endif

    template<>
    struct StringMaker {
        static std::string convert(wchar_t const * str);
    };
    template<>
    struct StringMaker {
        static std::string convert(wchar_t * str);
    };
#endif // CATCH_CONFIG_WCHAR

    template
    struct StringMaker {
        static std::string convert(char const* str) {
            // Note that `strnlen` is not actually part of standard C++,
            // but both POSIX and Windows cstdlib provide it.
            return Detail::convertIntoString(
                StringRef( str, strnlen( str, SZ ) ) );
        }
    };
    template
    struct StringMaker {
        static std::string convert(signed char const* str) {
            // See the plain `char const*` overload
            auto reinterpreted = reinterpret_cast(str);
            return Detail::convertIntoString(
                StringRef(reinterpreted, strnlen(reinterpreted, SZ)));
        }
    };
    template
    struct StringMaker {
        static std::string convert(unsigned char const* str) {
            // See the plain `char const*` overload
            auto reinterpreted = reinterpret_cast(str);
            return Detail::convertIntoString(
                StringRef(reinterpreted, strnlen(reinterpreted, SZ)));
        }
    };

#if defined(CATCH_CONFIG_CPP17_BYTE)
    template<>
    struct StringMaker {
        static std::string convert(std::byte value);
    };
#endif // defined(CATCH_CONFIG_CPP17_BYTE)
    template<>
    struct StringMaker {
        static std::string convert(int value);
    };
    template<>
    struct StringMaker {
        static std::string convert(long value);
    };
    template<>
    struct StringMaker {
        static std::string convert(long long value);
    };
    template<>
    struct StringMaker {
        static std::string convert(unsigned int value);
    };
    template<>
    struct StringMaker {
        static std::string convert(unsigned long value);
    };
    template<>
    struct StringMaker {
        static std::string convert(unsigned long long value);
    };

    template<>
    struct StringMaker {
        static std::string convert(bool b) {
            using namespace std::string_literals;
            return b ? "true"s : "false"s;
        }
    };

    template<>
    struct StringMaker {
        static std::string convert(char c);
    };
    template<>
    struct StringMaker {
        static std::string convert(signed char c);
    };
    template<>
    struct StringMaker {
        static std::string convert(unsigned char c);
    };

    template<>
    struct StringMaker {
        static std::string convert(std::nullptr_t) {
            using namespace std::string_literals;
            return "nullptr"s;
        }
    };

    template<>
    struct StringMaker {
        static std::string convert(float value);
        static int precision;
    };

    template<>
    struct StringMaker {
        static std::string convert(double value);
        static int precision;
    };

    template
    struct StringMaker {
        template
        static std::string convert(U* p) {
            if (p) {
                return ::Catch::Detail::rawMemoryToString(p);
            } else {
                return "nullptr";
            }
        }
    };

    template
    struct StringMaker {
        static std::string convert(R C::* p) {
            if (p) {
                return ::Catch::Detail::rawMemoryToString(p);
            } else {
                return "nullptr";
            }
        }
    };

#if defined(_MANAGED)
    template
    struct StringMaker {
        static std::string convert( T^ ref ) {
            return ::Catch::Detail::clrReferenceToString(ref);
        }
    };
#endif

    namespace Detail {
        template
        std::string rangeToString(InputIterator first, Sentinel last) {
            ReusableStringStream rss;
            rss << "{ ";
            if (first != last) {
                rss << ::Catch::Detail::stringify(*first);
                for (++first; first != last; ++first)
                    rss << ", " << ::Catch::Detail::stringify(*first);
            }
            rss << " }";
            return rss.str();
        }
    }

} // namespace Catch

//////////////////////////////////////////////////////
// Separate std-lib types stringification, so it can be selectively enabled
// This means that we do not bring in their headers

#if defined(CATCH_CONFIG_ENABLE_ALL_STRINGMAKERS)
#  define CATCH_CONFIG_ENABLE_PAIR_STRINGMAKER
#  define CATCH_CONFIG_ENABLE_TUPLE_STRINGMAKER
#  define CATCH_CONFIG_ENABLE_VARIANT_STRINGMAKER
#  define CATCH_CONFIG_ENABLE_OPTIONAL_STRINGMAKER
#endif

// Separate std::pair specialization
#if defined(CATCH_CONFIG_ENABLE_PAIR_STRINGMAKER)
#include
namespace Catch {
    template
    struct StringMaker > {
        static std::string convert(const std::pair& pair) {
            ReusableStringStream rss;
            rss << "{ "
                << ::Catch::Detail::stringify(pair.first)
                << ", "
                << ::Catch::Detail::stringify(pair.second)
                << " }";
            return rss.str();
        }
    };
}
#endif // CATCH_CONFIG_ENABLE_PAIR_STRINGMAKER

#if defined(CATCH_CONFIG_ENABLE_OPTIONAL_STRINGMAKER) && defined(CATCH_CONFIG_CPP17_OPTIONAL)
#include
namespace Catch {
    template
    struct StringMaker > {
        static std::string convert(const std::optional& optional) {
            if (optional.has_value()) {
                return ::Catch::Detail::stringify(*optional);
            } else {
                return "{ }";
            }
        }
    };
}
#endif // CATCH_CONFIG_ENABLE_OPTIONAL_STRINGMAKER

// Separate std::tuple specialization
#if defined(CATCH_CONFIG_ENABLE_TUPLE_STRINGMAKER)
#include
namespace Catch {
    namespace Detail {
        template<
            typename Tuple,
            std::size_t N = 0,
            bool = (N < std::tuple_size::value)
            >
            struct TupleElementPrinter {
            static void print(const Tuple& tuple, std::ostream& os) {
                os << (N ? ", " : " ")
                    << ::Catch::Detail::stringify(std::get(tuple));
                TupleElementPrinter::print(tuple, os);
            }
        };

        template<
            typename Tuple,
            std::size_t N
        >
            struct TupleElementPrinter {
            static void print(const Tuple&, std::ostream&) {}
        };

    }


    template
    struct StringMaker> {
        static std::string convert(const std::tuple& tuple) {
            ReusableStringStream rss;
            rss << '{';
            Detail::TupleElementPrinter>::print(tuple, rss.get());
            rss << " }";
            return rss.str();
        }
    };
}
#endif // CATCH_CONFIG_ENABLE_TUPLE_STRINGMAKER

#if defined(CATCH_CONFIG_ENABLE_VARIANT_STRINGMAKER) && defined(CATCH_CONFIG_CPP17_VARIANT)
#include
namespace Catch {
    template<>
    struct StringMaker {
        static std::string convert(const std::monostate&) {
            return "{ }";
        }
    };

    template
    struct StringMaker> {
        static std::string convert(const std::variant& variant) {
            if (variant.valueless_by_exception()) {
                return "{valueless variant}";
            } else {
                return std::visit(
                    [](const auto& value) {
                        return ::Catch::Detail::stringify(value);
                    },
                    variant
                );
            }
        }
    };
}
#endif // CATCH_CONFIG_ENABLE_VARIANT_STRINGMAKER

namespace Catch {
    // Import begin/ end from std here
    using std::begin;
    using std::end;

    namespace Detail {
        template
        struct is_range_impl : std::false_type {};

        template
        struct is_range_impl()))>> : std::true_type {};
    } // namespace Detail

    template
    struct is_range : Detail::is_range_impl {};

#if defined(_MANAGED) // Managed types are never ranges
    template
    struct is_range {
        static const bool value = false;
    };
#endif

    template
    std::string rangeToString( Range const& range ) {
        return ::Catch::Detail::rangeToString( begin( range ), end( range ) );
    }

    // Handle vector specially
    template
    std::string rangeToString( std::vector const& v ) {
        ReusableStringStream rss;
        rss << "{ ";
        bool first = true;
        for( bool b : v ) {
            if( first )
                first = false;
            else
                rss << ", ";
            rss << ::Catch::Detail::stringify( b );
        }
        rss << " }";
        return rss.str();
    }

    template
    struct StringMaker::value && !::Catch::Detail::IsStreamInsertable::value>> {
        static std::string convert( R const& range ) {
            return rangeToString( range );
        }
    };

    template
    struct StringMaker {
        static std::string convert(T const(&arr)[SZ]) {
            return rangeToString(arr);
        }
    };


} // namespace Catch

// Separate std::chrono::duration specialization
#include
#include
#include


namespace Catch {

template
struct ratio_string {
    static std::string symbol() {
        Catch::ReusableStringStream rss;
        rss << '[' << Ratio::num << '/'
            << Ratio::den << ']';
        return rss.str();
    }
};

template <>
struct ratio_string {
    static char symbol() { return 'a'; }
};
template <>
struct ratio_string {
    static char symbol() { return 'f'; }
};
template <>
struct ratio_string {
    static char symbol() { return 'p'; }
};
template <>
struct ratio_string {
    static char symbol() { return 'n'; }
};
template <>
struct ratio_string {
    static char symbol() { return 'u'; }
};
template <>
struct ratio_string {
    static char symbol() { return 'm'; }
};

    ////////////
    // std::chrono::duration specializations
    template
    struct StringMaker> {
        static std::string convert(std::chrono::duration const& duration) {
            ReusableStringStream rss;
            rss << duration.count() << ' ' << ratio_string::symbol() << 's';
            return rss.str();
        }
    };
    template
    struct StringMaker>> {
        static std::string convert(std::chrono::duration> const& duration) {
            ReusableStringStream rss;
            rss << duration.count() << " s";
            return rss.str();
        }
    };
    template
    struct StringMaker>> {
        static std::string convert(std::chrono::duration> const& duration) {
            ReusableStringStream rss;
            rss << duration.count() << " m";
            return rss.str();
        }
    };
    template
    struct StringMaker>> {
        static std::string convert(std::chrono::duration> const& duration) {
            ReusableStringStream rss;
            rss << duration.count() << " h";
            return rss.str();
        }
    };

    ////////////
    // std::chrono::time_point specialization
    // Generic time_point cannot be specialized, only std::chrono::time_point
    template
    struct StringMaker> {
        static std::string convert(std::chrono::time_point const& time_point) {
            return ::Catch::Detail::stringify(time_point.time_since_epoch()) + " since epoch";
        }
    };
    // std::chrono::time_point specialization
    template
    struct StringMaker> {
        static std::string convert(std::chrono::time_point const& time_point) {
            auto converted = std::chrono::system_clock::to_time_t(time_point);

#ifdef _MSC_VER
            std::tm timeInfo = {};
            gmtime_s(&timeInfo, &converted);
#else
            std::tm* timeInfo = std::gmtime(&converted);
#endif

            auto const timeStampSize = sizeof("2017-01-16T17:06:45Z");
            char timeStamp[timeStampSize];
            const char * const fmt = "%Y-%m-%dT%H:%M:%SZ";

#ifdef _MSC_VER
            std::strftime(timeStamp, timeStampSize, fmt, &timeInfo);
#else
            std::strftime(timeStamp, timeStampSize, fmt, timeInfo);
#endif
            return std::string(timeStamp, timeStampSize - 1);
        }
    };
}

#include

#define INTERNAL_CATCH_REGISTER_ENUM( enumName, ... ) \
namespace Catch { \
    template<> struct StringMaker { \
        static std::string convert( enumName value ) { \
            static const auto& enumInfo = ::Catch::getMutableRegistryHub().getMutableEnumValuesRegistry().registerEnum( #enumName, #__VA_ARGS__, { __VA_ARGS__ } ); \
            return static_cast(enumInfo.lookup( static_cast( value ) )); \
        } \
    }; \
}

#define CATCH_REGISTER_ENUM( enumName, ... ) INTERNAL_CATCH_REGISTER_ENUM( enumName, __VA_ARGS__ )

#ifdef _MSC_VER
#pragma warning(pop)
#endif

#endif // CATCH_TOSTRING_HPP_INCLUDED