Minor cleanup

test/format-test.cc

@@ -307,7 +307,7 @@ TEST(memory_buffer_test, ctor) {
   EXPECT_EQ(123u, buffer.capacity());
 }
 
-using std_allocator = allocator_ref<std::allocator<char>, true>;
+using std_allocator = allocator_ref<std::allocator<char>>;
 
 TEST(memory_buffer_test, move_ctor_inline_buffer) {
   auto check_move_buffer =
@@ -351,15 +351,15 @@ TEST(memory_buffer_test, move_ctor_dynamic_buffer) {
   EXPECT_GT(buffer2.capacity(), 4u);
 }
 
-using std_allocator_n = allocator_ref<std::allocator<char>, false>;
+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_n>& buffer) {
+         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_n> buffer2(
+        basic_memory_buffer<char, 5, std_allocator_noprop> buffer2(
             std::move(buffer));
         const char* new_data_ptr = &buffer2[0];
         EXPECT_NE(original_data_ptr, new_data_ptr);
@@ -373,8 +373,8 @@ TEST(memory_buffer_test, move_ctor_inline_buffer_non_propagating) {
         EXPECT_NE(original_alloc_ptr, buffer2.get_allocator().get());
       };
   auto alloc = std::allocator<char>();
-  basic_memory_buffer<char, 5, std_allocator_n> buffer(
-      (std_allocator_n(&alloc)));
+  basic_memory_buffer<char, 5, std_allocator_noprop> buffer(
+      (std_allocator_noprop(&alloc)));
   const char test[] = "test";
   buffer.append(string_view(test, 4));
   check_move_buffer("test", buffer);
@@ -384,15 +384,15 @@ TEST(memory_buffer_test, move_ctor_inline_buffer_non_propagating) {
 
 TEST(memory_buffer_test, move_ctor_dynamic_buffer_non_propagating) {
   auto alloc = std::allocator<char>();
-  basic_memory_buffer<char, 4, std_allocator_n> buffer(
-      (std_allocator_n(&alloc)));
+  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[0], inline_buffer_ptr);
   std::allocator<char>* original_alloc_ptr = buffer.get_allocator().get();
-  basic_memory_buffer<char, 4, std_allocator_n> buffer2;
+  basic_memory_buffer<char, 4, std_allocator_noprop> buffer2;
   buffer2 = std::move(buffer);
   EXPECT_EQ(std::string(&buffer2[0], buffer2.size()), "testa");
   EXPECT_GT(buffer2.capacity(), 4u);

test/mock-allocator.h

@@ -37,8 +37,7 @@ template <typename T> class mock_allocator {
   MOCK_METHOD(void, deallocate, (T*, size_t));
 };
 
-template <typename Allocator, bool PropagateOnMove = false>
-class allocator_ref {
+template <typename Allocator, bool PropagateOnMove = true> class allocator_ref {
  private:
   Allocator* alloc_;
 
@@ -50,8 +49,7 @@ class allocator_ref {
  public:
   using value_type = typename Allocator::value_type;
   using propagate_on_container_move_assignment =
-      typename std::conditional<PropagateOnMove, std::true_type,
-                                std::false_type>::type;
+      fmt::bool_constant<PropagateOnMove>;
 
   explicit allocator_ref(Allocator* alloc = nullptr) : alloc_(alloc) {}
 
@@ -70,23 +68,19 @@ class allocator_ref {
   }
 
  public:
-  Allocator* get() const { return alloc_; }
+  auto get() const -> Allocator* { return alloc_; }
 
-  value_type* allocate(size_t n) {
+  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); }
 
-  FMT_CONSTEXPR20 friend bool operator==(const allocator_ref& a,
-                                         const allocator_ref& b) noexcept {
+  friend auto operator==(allocator_ref a, allocator_ref b) noexcept -> bool {
     if (a.alloc_ == b.alloc_) return true;
-    if (a.alloc_ == nullptr || b.alloc_ == nullptr) return false;
-
-    return *a.alloc_ == *b.alloc_;
+    return a.alloc_ && b.alloc_ && *a.alloc_ == *b.alloc_;
   }
 
-  FMT_CONSTEXPR20 friend bool operator!=(const allocator_ref& a,
-                                         const allocator_ref& b) noexcept {
+  friend auto operator!=(allocator_ref a, allocator_ref b) noexcept -> bool {
     return !(a == b);
   }
 };