test: test the fmt support for bitset_set & mini_flat_map

Signed-off-by: Ronen Friedman <rfriedma@redhat.com>

diff --git a/src/test/common/test_bitset_set.cc b/src/test/common/test_bitset_set.cc
index f8de103bd46fdfedd17463e767d763d64f22170f..7c4ac61b2fa38039de27fe286b20295c48d5c494 100644 (file)
--- a/src/test/common/test_bitset_set.cc
+++ b/src/test/common/test_bitset_set.cc
@@ -2,7 +2,7 @@
 // vim: ts=8 sw=2 smarttab
 
 #include <gtest/gtest.h>
-#include <common/bitset_set.h>
+#include "common/bitset_set.h"
 
 struct Key {
   int8_t k;
@@ -23,6 +23,18 @@ struct Key {
   friend bool operator==(const Key &lhs, const Key &rhs) = default;
 };
 
+namespace fmt {
+template <>
+struct formatter<Key> : private formatter<int> {
+  using formatter<int>::parse;
+  template <typename FormatContext>
+  auto format(const Key& k, FormatContext& ctx) const {
+    return formatter<int>::format(k.k, ctx);
+  }
+};
+} // namespace fmt
+
+
 TEST(bitset_set, constructors) {
   bitset_set<128, Key> bs;
   ASSERT_TRUE(bs.empty());
@@ -182,3 +194,20 @@ TEST(bitset_set, equality) {
   bitset2.insert(64);
   ASSERT_EQ(bitset, bitset2);
 }
+
+TEST(bitset_set, fmt_formatting) {
+  bitset_set<128, Key> bitset;
+  // when empty:
+  auto using_fmt = fmt::format("{}", bitset);
+  ASSERT_EQ("{}", using_fmt);
+
+  bitset.insert(30);
+  bitset.insert(20);
+  bitset.insert(10);
+  using_fmt = fmt::format("{}", bitset);
+  ASSERT_EQ("{10,20,30}", using_fmt);
+  // compare to operator<<
+  std::ostringstream oss;
+  oss << bitset;
+  EXPECT_EQ(using_fmt, oss.str());
+}

diff --git a/src/test/common/test_mini_flat_map.cc b/src/test/common/test_mini_flat_map.cc
index d415d5b95f35744bc8a716d4c676132657e64e31..ee9bb426226098f414af66e85a8db3c8f9676f5c 100644 (file)
--- a/src/test/common/test_mini_flat_map.cc
+++ b/src/test/common/test_mini_flat_map.cc
@@ -2,7 +2,7 @@
 // vim: ts=8 sw=2 smarttab
 
 #include <gtest/gtest.h>
-#include <common/mini_flat_map.h>
+#include "common/mini_flat_map.h"
 
 struct Value {
   int value;
@@ -21,6 +21,17 @@ struct Value {
   }
 };
 
+namespace fmt {
+template <>
+struct formatter<Value> : private formatter<int> {
+  using formatter<int>::parse;
+  template <typename FormatContext>
+  auto format(const Value& v, FormatContext& ctx) const {
+    return formatter<int>::format(v.value, ctx);
+  }
+};
+} // namespace fmt
+
 struct Key {
   int8_t k;
 
@@ -43,6 +54,18 @@ struct Key {
   }
 };
 
+namespace fmt {
+template <>
+struct formatter<Key> : private formatter<int> {
+  using formatter<int>::parse;
+  template <typename FormatContext>
+  auto format(const Key& k, FormatContext& ctx) const {
+    return formatter<int>::format(k.k, ctx);
+  }
+};
+} // namespace fmt
+
+
 TEST(mini_flat_map, copy_operator_and_element_access) {
   mini_flat_map<Key, Value> m(4);
   m[0] = Value(1);
@@ -57,6 +80,55 @@ TEST(mini_flat_map, copy_operator_and_element_access) {
   ASSERT_TRUE(m.contains(0));
 }
 
+TEST(mini_flat_map, fmt_formatting) {
+  mini_flat_map<Key, Value> m(4);
+  m[0] = Value(100);
+  m[2] = Value(200);
+  EXPECT_EQ("{0:100,2:200}", m.fmt_print());
+  // compare to operator<<
+  std::ostringstream oss;
+  oss << m;
+  EXPECT_EQ(m.fmt_print(), oss.str());
+  // use indirectly in fmt::format
+  EXPECT_EQ("{0:100,2:200}", fmt::format("{}", m));
+}
+
+TEST(mini_flat_map, fmt_formatting_empty) {
+  mini_flat_map<Key, Value> m(10);
+  EXPECT_EQ("{}", m.fmt_print());
+  // compare to operator<<
+  const auto as_fmt = fmt::format("{}", m);
+  EXPECT_EQ("{}", as_fmt);
+  std::ostringstream oss;
+  oss << m;
+  EXPECT_EQ(as_fmt, oss.str());
+}
+
+TEST(mini_flat_map, fmt_formatting_one) {
+  mini_flat_map<Key, Value> m(4);
+  m[2] = Value(100);
+  const auto using_fmt = fmt::format("{}", m);
+  EXPECT_EQ("{2:100}", using_fmt);
+  // compare to operator<<
+  std::ostringstream oss;
+  oss << m;
+  EXPECT_EQ(using_fmt, oss.str());
+}
+
+TEST(mini_flat_map, fmt_formatting_full) {
+  mini_flat_map<Key, Value> m(4);
+  m[3] = Value(300);
+  m[2] = Value(200);
+  m[1] = Value(100);
+  m[0] = Value(1);
+  const auto using_fmt = fmt::format("{}", m);
+  EXPECT_EQ("{0:1,1:100,2:200,3:300}", using_fmt);
+  // compare to operator<<
+  std::ostringstream oss;
+  oss << m;
+  EXPECT_EQ(using_fmt, oss.str());
+}
+
 TEST(mini_flat_map, iterators) {
   mini_flat_map<Key, Value> m(4);
   m[0] = Value(1);