[libcxx-commits] [libcxx] 886e92c - [libc++][test] Silence allocator conversion warnings

[Casey Carter via libcxx-commits]

Author: Casey Carter
Date: 2023-01-10T11:21:11-08:00
New Revision: 886e92c1abf17a98abb9fb7f58bc02028a3f9a7e

URL: https://github.com/llvm/llvm-project/commit/886e92c1abf17a98abb9fb7f58bc02028a3f9a7e
DIFF: https://github.com/llvm/llvm-project/commit/886e92c1abf17a98abb9fb7f58bc02028a3f9a7e.diff

LOG: [libc++][test] Silence allocator conversion warnings

... by accepting `std::size_t` instead of `int` in `allocate` and `deallocate` functions.

Drive-by: To conform to the allocator requirements, the `Allocator` types in these tests need to have (1) converting constructors and (2) cross-specialization `==` that returns `true` at least for copies of the same allocator.

Differential Revision: https://reviews.llvm.org/D141334

Added: 
    

Modified: 
    libcxx/test/libcxx/containers/sequences/vector/robust_against_adl.pass.cpp
    libcxx/test/std/containers/sequences/vector.bool/ctor_exceptions.pass.cpp
    libcxx/test/std/containers/sequences/vector/vector.cons/exceptions.pass.cpp

Removed: 
    


################################################################################
diff  --git a/libcxx/test/libcxx/containers/sequences/vector/robust_against_adl.pass.cpp b/libcxx/test/libcxx/containers/sequences/vector/robust_against_adl.pass.cpp
index f8a3e4411cae0..ed991fe2194d8 100644
--- a/libcxx/test/libcxx/containers/sequences/vector/robust_against_adl.pass.cpp
+++ b/libcxx/test/libcxx/containers/sequences/vector/robust_against_adl.pass.cpp
@@ -10,6 +10,7 @@
 
 // <vector>
 
+#include <cstddef>
 #include <vector>
 
 #include "test_macros.h"
@@ -22,8 +23,8 @@ struct MyAlloc {
     using value_type = T;
     MyAlloc() = default;
     template<class U> MyAlloc(const MyAlloc<U>&) {}
-    T *allocate(int n) { return std::allocator<T>().allocate(n); }
-    void deallocate(T *p, int n) { return std::allocator<T>().deallocate(p, n); }
+    T *allocate(std::size_t n) { return std::allocator<T>().allocate(n); }
+    void deallocate(T *p, std::size_t n) { return std::allocator<T>().deallocate(p, n); }
 };
 
 int main(int, char**)

diff  --git a/libcxx/test/std/containers/sequences/vector.bool/ctor_exceptions.pass.cpp b/libcxx/test/std/containers/sequences/vector.bool/ctor_exceptions.pass.cpp
index 592d733de42df..df3fc1422ebee 100644
--- a/libcxx/test/std/containers/sequences/vector.bool/ctor_exceptions.pass.cpp
+++ b/libcxx/test/std/containers/sequences/vector.bool/ctor_exceptions.pass.cpp
@@ -11,6 +11,7 @@
 // (bug report: https://llvm.org/PR58392)
 // Check that vector<bool> constructors don't leak memory when an operation inside the constructor throws an exception
 
+#include <cstddef>
 #include <type_traits>
 #include <vector>
 
@@ -30,10 +31,11 @@ struct Allocator {
       throw 0;
   }
 
-  T* allocate(int n) { return std::allocator<T>().allocate(n); }
-  void deallocate(T* ptr, int n) { std::allocator<T>().deallocate(ptr, n); }
+  T* allocate(std::size_t n) { return std::allocator<T>().allocate(n); }
+  void deallocate(T* ptr, std::size_t n) { std::allocator<T>().deallocate(ptr, n); }
 
-  friend bool operator==(const Allocator&, const Allocator&) { return false; }
+  template <class U>
+  friend bool operator==(const Allocator&, const Allocator<U>&) { return true; }
 };
 
 template <class IterCat>

diff  --git a/libcxx/test/std/containers/sequences/vector/vector.cons/exceptions.pass.cpp b/libcxx/test/std/containers/sequences/vector/vector.cons/exceptions.pass.cpp
index 26ad7b4fd05ae..1b7d62ee1583f 100644
--- a/libcxx/test/std/containers/sequences/vector/vector.cons/exceptions.pass.cpp
+++ b/libcxx/test/std/containers/sequences/vector/vector.cons/exceptions.pass.cpp
@@ -11,6 +11,7 @@
 // (bug report: https://llvm.org/PR58392)
 // Check that vector constructors don't leak memory when an operation inside the constructor throws an exception
 
+#include <cstddef>
 #include <type_traits>
 #include <vector>
 
@@ -22,15 +23,19 @@ struct Allocator {
   using value_type      = T;
   using is_always_equal = std::false_type;
 
+  template <class U>
+  Allocator(const Allocator<U>&) {}
+
   Allocator(bool should_throw = true) {
     if (should_throw)
       throw 0;
   }
 
-  T* allocate(int n) { return std::allocator<T>().allocate(n); }
-  void deallocate(T* ptr, int n) { std::allocator<T>().deallocate(ptr, n); }
+  T* allocate(std::size_t n) { return std::allocator<T>().allocate(n); }
+  void deallocate(T* ptr, std::size_t n) { std::allocator<T>().deallocate(ptr, n); }
 
-  friend bool operator==(const Allocator&, const Allocator&) { return false; }
+  template <class U>
+  friend bool operator==(const Allocator&, const Allocator<U>&) { return true; }
 };
 
 struct ThrowingT {