diff options
author | Daniel Baumann <daniel.baumann@progress-linux.org> | 2024-04-21 11:54:28 +0000 |
---|---|---|
committer | Daniel Baumann <daniel.baumann@progress-linux.org> | 2024-04-21 11:54:28 +0000 |
commit | e6918187568dbd01842d8d1d2c808ce16a894239 (patch) | |
tree | 64f88b554b444a49f656b6c656111a145cbbaa28 /src/fmt/test/ostream-test.cc | |
parent | Initial commit. (diff) | |
download | ceph-upstream/18.2.2.tar.xz ceph-upstream/18.2.2.zip |
Adding upstream version 18.2.2.upstream/18.2.2
Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>
Diffstat (limited to '')
-rw-r--r-- | src/fmt/test/ostream-test.cc | 322 |
1 files changed, 322 insertions, 0 deletions
diff --git a/src/fmt/test/ostream-test.cc b/src/fmt/test/ostream-test.cc new file mode 100644 index 000000000..a3a51d532 --- /dev/null +++ b/src/fmt/test/ostream-test.cc @@ -0,0 +1,322 @@ +// 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) -> 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, "format specifier requires numeric argument"); + EXPECT_THROW_MSG((void)fmt::format(runtime("{0:-}"), test_string()), + format_error, "format specifier requires numeric argument"); + EXPECT_THROW_MSG((void)fmt::format(runtime("{0: }"), test_string()), + format_error, "format specifier requires numeric argument"); + EXPECT_THROW_MSG((void)fmt::format(runtime("{0:#}"), test_string()), + format_error, "format specifier requires numeric argument"); + 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()); +} + +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>(nullptr, size, size) {} + void grow(size_t) override {} + } buffer(max_size); + + struct mock_streambuf : std::streambuf { + MOCK_METHOD2(xsputn, std::streamsize(const void* s, std::streamsize n)); + 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) -> 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)); +} + +template <typename T> struct convertible { + T value; + explicit convertible(const T& val) : value(val) {} + operator T() const { return value; } +}; + +TEST(ostream_test, disable_builtin_ostream_operators) { + EXPECT_EQ("42", fmt::format("{:d}", convertible<unsigned short>(42))); + EXPECT_EQ("foo", fmt::format("{}", convertible<const char*>("foo"))); +} + +struct streamable_and_convertible_to_bool { + operator bool() const { return true; } +}; + +std::ostream& operator<<(std::ostream& os, streamable_and_convertible_to_bool) { + return os << "foo"; +} + +TEST(ostream_test, format_convertible_to_bool) { + // operator<< is intentionally not used because of potential ODR violations. + EXPECT_EQ(fmt::format("{}", streamable_and_convertible_to_bool()), "true"); +} + +struct streamable_and_convertible_to_string_view { + operator fmt::string_view() const { return "foo"; } +}; + +std::ostream& operator<<(std::ostream& os, + streamable_and_convertible_to_string_view) { + return os << "bar"; +} + +TEST(ostream_test, format_convertible_to_string_vew) { + // operator<< is intentionally not used because of potential ODR violations. + EXPECT_EQ(fmt::format("{}", streamable_and_convertible_to_string_view()), + "foo"); +} + +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"); +} |