From 38bcc04a11b6fe88afdff4a3ff522bb27edab94c Mon Sep 17 00:00:00 2001 From: Victor Zverovich Date: Tue, 4 May 2021 20:53:56 -0700 Subject: [PATCH] Drop range limit and cleanup tests --- include/fmt/ranges.h | 13 +-- test/ranges-test.cc | 193 +++++++++++++++++++------------------------ 2 files changed, 88 insertions(+), 118 deletions(-) diff --git a/include/fmt/ranges.h b/include/fmt/ranges.h index 355f076c..8ff1e762 100644 --- a/include/fmt/ranges.h +++ b/include/fmt/ranges.h @@ -17,11 +17,6 @@ #include "format.h" -// output only up to N items from the range. -#ifndef FMT_RANGE_OUTPUT_LENGTH_LIMIT -# define FMT_RANGE_OUTPUT_LENGTH_LIMIT 256 -#endif - FMT_BEGIN_NAMESPACE template struct formatting_base { @@ -33,9 +28,6 @@ template struct formatting_base { template struct formatting_range : formatting_base { - static FMT_CONSTEXPR_DECL const size_t range_length_limit = - FMT_RANGE_OUTPUT_LENGTH_LIMIT; // output only up to N items from the - // range. Char prefix = '{'; Char postfix = '}'; }; @@ -360,10 +352,7 @@ struct formatter< for (; it != end; ++it) { if (i > 0) out = detail::write_delimiter(out); out = detail::write_range_entry(out, *it); - if (++i > formatting.range_length_limit) { - out = format_to(out, FMT_STRING("{}"), " ... "); - break; - } + ++i; } return detail::copy(formatting.postfix, out); } diff --git a/test/ranges-test.cc b/test/ranges-test.cc index d711baa9..f2e04d7a 100644 --- a/test/ranges-test.cc +++ b/test/ranges-test.cc @@ -44,69 +44,65 @@ TEST(ranges_test, format_array_of_literals) { #endif // FMT_RANGES_TEST_ENABLE_C_STYLE_ARRAY TEST(ranges_test, format_vector) { - std::vector iv{1, 2, 3, 5, 7, 11}; - auto ivf = fmt::format("{}", iv); - EXPECT_EQ("{1, 2, 3, 5, 7, 11}", ivf); + auto v = std::vector{1, 2, 3, 5, 7, 11}; + EXPECT_EQ(fmt::format("{}", v), "{1, 2, 3, 5, 7, 11}"); } TEST(ranges_test, format_vector2) { - std::vector> ivv{{1, 2}, {3, 5}, {7, 11}}; - auto ivf = fmt::format("{}", ivv); - EXPECT_EQ("{{1, 2}, {3, 5}, {7, 11}}", ivf); + auto v = std::vector>{{1, 2}, {3, 5}, {7, 11}}; + EXPECT_EQ(fmt::format("{}", v), "{{1, 2}, {3, 5}, {7, 11}}"); } -TEST(ranges_test, FormatMap) { - std::map simap{{"one", 1}, {"two", 2}}; - EXPECT_EQ("{(\"one\", 1), (\"two\", 2)}", fmt::format("{}", simap)); +TEST(ranges_test, format_map) { + auto m = std::map{{"one", 1}, {"two", 2}}; + EXPECT_EQ(fmt::format("{}", m), "{(\"one\", 1), (\"two\", 2)}"); } -TEST(ranges_test, FormatPair) { - std::pair pa1{42, 1.5f}; - EXPECT_EQ("(42, 1.5)", fmt::format("{}", pa1)); +TEST(ranges_test, format_pair) { + auto p = std::pair(42, 1.5f); + EXPECT_EQ(fmt::format("{}", p), "(42, 1.5)"); } -TEST(ranges_test, FormatTuple) { - std::tuple t{42, 1.5f, "this is tuple", - 'i'}; - EXPECT_EQ("(42, 1.5, \"this is tuple\", 'i')", fmt::format("{}", t)); - EXPECT_EQ("()", fmt::format("{}", std::tuple<>())); +TEST(ranges_test, format_tuple) { + auto t = + std::tuple(42, 1.5f, "this is tuple", 'i'); + EXPECT_EQ(fmt::format("{}", t), "(42, 1.5, \"this is tuple\", 'i')"); + EXPECT_EQ(fmt::format("{}", std::tuple<>()), "()"); } #ifdef FMT_RANGES_TEST_ENABLE_FORMAT_STRUCT -struct my_struct { - int32_t i; - std::string str; // can throw - template fmt::enable_if_t get() const noexcept { +struct tuple_like { + int i; + std::string str; + + template fmt::enable_if_t get() const noexcept { return i; } template fmt::enable_if_t get() const noexcept { - return {str}; + return str; } }; template -auto get(const my_struct& s) noexcept -> decltype(s.get()) { - return s.get(); +auto get(const tuple_like& t) noexcept -> decltype(t.get()) { + return t.get(); } -namespace std { +template <> +struct std::tuple_size : std::integral_constant {}; -template <> struct tuple_size : std::integral_constant {}; - -template struct tuple_element { - using type = decltype(std::declval().get()); +template struct std::tuple_element { + using type = decltype(std::declval().get()); }; -} // namespace std - -TEST(ranges_test, FormatStruct) { - my_struct mst{13, "my struct"}; - EXPECT_EQ("(13, \"my struct\")", fmt::format("{}", mst)); +TEST(ranges_test, format_struct) { + auto t = tuple_like{42, "foo"}; + EXPECT_EQ(fmt::format("{}", t), "(42, \"foo\")"); } #endif // FMT_RANGES_TEST_ENABLE_FORMAT_STRUCT -TEST(ranges_test, FormatTo) { +TEST(ranges_test, format_to) { char buf[10]; auto end = fmt::format_to(buf, "{}", std::vector{1, 2, 3}); *end = '\0'; @@ -120,7 +116,7 @@ struct path_like { operator std::string() const; }; -TEST(ranges_test, PathLike) { +TEST(ranges_test, path_like) { EXPECT_FALSE((fmt::is_range::value)); } @@ -132,15 +128,15 @@ struct string_like { explicit operator std::string_view() const { return "foo"; } }; -TEST(ranges_test, FormatStringLike) { - EXPECT_EQ("foo", fmt::format("{}", string_like())); +TEST(ranges_test, format_string_like) { + EXPECT_EQ(fmt::format("{}", string_like()), "foo"); } #endif // FMT_USE_STRING_VIEW // A range that provides non-const only begin()/end() to test fmt::join handles -// that +// that. // -// Some ranges (eg those produced by range-v3's views::filter()) can cache +// 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 class non_const_only_range { private: @@ -151,7 +147,7 @@ template class non_const_only_range { template explicit non_const_only_range(Args&&... args) - : vec(::std::forward(args)...) {} + : vec(std::forward(args)...) {} const_iterator begin() { return vec.begin(); } const_iterator end() { return vec.end(); } @@ -166,7 +162,7 @@ template class noncopyable_range { template explicit noncopyable_range(Args&&... args) - : vec(::std::forward(args)...) {} + : vec(std::forward(args)...) {} noncopyable_range(noncopyable_range const&) = delete; noncopyable_range(noncopyable_range&) = delete; @@ -175,75 +171,61 @@ template class noncopyable_range { const_iterator end() const { return vec.end(); } }; -TEST(ranges_test, Range) { +TEST(ranges_test, range) { noncopyable_range w(3u, 0); - EXPECT_EQ("{0, 0, 0}", fmt::format("{}", w)); - EXPECT_EQ("{0, 0, 0}", fmt::format("{}", noncopyable_range(3u, 0))); + EXPECT_EQ(fmt::format("{}", w), "{0, 0, 0}"); + EXPECT_EQ(fmt::format("{}", noncopyable_range(3u, 0)), "{0, 0, 0}"); non_const_only_range x(3u, 0); - EXPECT_EQ("{0, 0, 0}", fmt::format("{}", x)); - EXPECT_EQ("{0, 0, 0}", fmt::format("{}", non_const_only_range(3u, 0))); + EXPECT_EQ(fmt::format("{}", x), "{0, 0, 0}"); + EXPECT_EQ(fmt::format("{}", non_const_only_range(3u, 0)), "{0, 0, 0}"); - std::vector y(3u, 0); - EXPECT_EQ("{0, 0, 0}", fmt::format("{}", y)); - EXPECT_EQ("{0, 0, 0}", fmt::format("{}", std::vector(3u, 0))); + auto y = std::vector(3u, 0); + EXPECT_EQ(fmt::format("{}", y), "{0, 0, 0}"); + EXPECT_EQ(fmt::format("{}", std::vector(3u, 0)), "{0, 0, 0}"); - const std::vector z(3u, 0); - EXPECT_EQ("{0, 0, 0}", fmt::format("{}", z)); + const auto z = std::vector(3u, 0); + EXPECT_EQ(fmt::format("{}", z), "{0, 0, 0}"); } #if !FMT_MSC_VER || FMT_MSC_VER >= 1927 struct unformattable {}; -TEST(ranges_test, UnformattableRange) { +TEST(ranges_test, unformattable_range) { EXPECT_FALSE((fmt::has_formatter, fmt::format_context>::value)); } #endif #ifdef FMT_RANGES_TEST_ENABLE_JOIN -TEST(ranges_test, JoinTuple) { - // Value tuple args - std::tuple t1 = std::make_tuple('a', 1, 2.0f); - EXPECT_EQ("(a, 1, 2)", fmt::format("({})", fmt::join(t1, ", "))); +TEST(ranges_test, join_tuple) { + // Value tuple args. + auto t1 = std::tuple('a', 1, 2.0f); + EXPECT_EQ(fmt::format("({})", fmt::join(t1, ", ")), "(a, 1, 2)"); - // Testing lvalue tuple args + // Testing lvalue tuple args. int x = 4; - std::tuple t2{'b', x}; - EXPECT_EQ("b + 4", fmt::format("{}", fmt::join(t2, " + "))); + auto t2 = std::tuple('b', x); + EXPECT_EQ(fmt::format("{}", fmt::join(t2, " + ")), "b + 4"); - // Empty tuple - std::tuple<> t3; - EXPECT_EQ("", fmt::format("{}", fmt::join(t3, "|"))); + // Empty tuple. + auto t3 = std::tuple<>(); + EXPECT_EQ(fmt::format("{}", fmt::join(t3, "|")), ""); - // Single element tuple - std::tuple t4{4.0f}; - EXPECT_EQ("4", fmt::format("{}", fmt::join(t4, "/"))); + // Single element tuple. + auto t4 = std::tuple(4.0f); + EXPECT_EQ(fmt::format("{}", fmt::join(t4, "/")), "4"); } -TEST(ranges_test, WideStringJoinTuple) { - // Value tuple args - std::tuple t1 = std::make_tuple('a', 1, 2.0f); - EXPECT_EQ(L"(a, 1, 2)", fmt::format(L"({})", fmt::join(t1, L", "))); - - // Testing lvalue tuple args - int x = 4; - std::tuple t2{'b', x}; - EXPECT_EQ(L"b + 4", fmt::format(L"{}", fmt::join(t2, L" + "))); - - // Empty tuple - std::tuple<> t3; - EXPECT_EQ(L"", fmt::format(L"{}", fmt::join(t3, L"|"))); - - // Single element tuple - std::tuple t4{4.0f}; - EXPECT_EQ(L"4", fmt::format(L"{}", fmt::join(t4, L"/"))); +TEST(ranges_test, wide_string_join_tuple) { + auto t = std::tuple('a', 1, 2.0f); + EXPECT_EQ(fmt::format(L"({})", fmt::join(t, L", ")), L"(a, 1, 2)"); } -TEST(ranges_test, JoinInitializerList) { - EXPECT_EQ("1, 2, 3", fmt::format("{}", fmt::join({1, 2, 3}, ", "))); - EXPECT_EQ("fmt rocks !", - fmt::format("{}", fmt::join({"fmt", "rocks", "!"}, " "))); +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 {}; @@ -257,30 +239,29 @@ struct zstring { zstring_sentinel end() const { return {}; } }; -TEST(ranges_test, JoinSentinel) { - zstring hello{"hello"}; - EXPECT_EQ("{'h', 'e', 'l', 'l', 'o'}", fmt::format("{}", hello)); - EXPECT_EQ("h_e_l_l_o", fmt::format("{}", fmt::join(hello, "_"))); +TEST(ranges_test, join_sentinel) { + auto hello = zstring{"hello"}; + 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, JoinRange) { +TEST(ranges_test, join_range) { noncopyable_range w(3u, 0); - EXPECT_EQ("0,0,0", fmt::format("{}", fmt::join(w, ","))); - EXPECT_EQ("0,0,0", - fmt::format("{}", fmt::join(noncopyable_range(3u, 0), ","))); + EXPECT_EQ(fmt::format("{}", fmt::join(w, ",")), "0,0,0"); + EXPECT_EQ(fmt::format("{}", fmt::join(noncopyable_range(3u, 0), ",")), + "0,0,0"); non_const_only_range x(3u, 0); - EXPECT_EQ("0,0,0", fmt::format("{}", fmt::join(x, ","))); - EXPECT_EQ( - "0,0,0", - fmt::format("{}", fmt::join(non_const_only_range(3u, 0), ","))); + EXPECT_EQ(fmt::format("{}", fmt::join(x, ",")), "0,0,0"); + EXPECT_EQ(fmt::format("{}", fmt::join(non_const_only_range(3u, 0), ",")), + "0,0,0"); - std::vector y(3u, 0); - EXPECT_EQ("0,0,0", fmt::format("{}", fmt::join(y, ","))); - EXPECT_EQ("0,0,0", - fmt::format("{}", fmt::join(std::vector(3u, 0), ","))); + auto y = std::vector(3u, 0); + EXPECT_EQ(fmt::format("{}", fmt::join(y, ",")), "0,0,0"); + EXPECT_EQ(fmt::format("{}", fmt::join(std::vector(3u, 0), ",")), + "0,0,0"); - const std::vector z(3u, 0); - EXPECT_EQ("0,0,0", fmt::format("{}", fmt::join(z, ","))); + const auto z = std::vector(3u, 0); + EXPECT_EQ(fmt::format("{}", fmt::join(z, ",")), "0,0,0"); } -#endif // FMT_RANGES_TEST_ENABLE_JOIN \ No newline at end of file +#endif // FMT_RANGES_TEST_ENABLE_JOIN