[libcxx] [test] Fix test bugs in string.cons/copy_alloc.pass.cpp.

[BillyONeal]

Summary

Fixed the inability to properly rebind the testing allocator, by making the
inner alloc_impl type a plain struct and making the operations templates. Before
rebind failed to compile complaining that a alloc_impl<T>* was not convertible
to an alloc_impl<U>*.

This enables the test to pass for MSVC++ once we provide the strong guarantee
for the copy assignment operator.

Reviewed as https://reviews.llvm.org/D60023

[BillyONeal]

test/std/strings/basic.string/string.cons/copy_alloc.pass.cpp

123

We still fail this test in debug mode because we need to allocate a new _Container_proxy from imp2 in this assignment. Should this be libcxx_assert?

[BillyONeal]

test/std/strings/basic.string/string.cons/copy_alloc.pass.cpp

123

Hmmm this is copy assignment, not move assignment, so we still have a bug. I should not try writing CR comments at 2 in the morning.

[BillyONeal]

test/std/strings/basic.string/string.cons/copy_alloc.pass.cpp

125

This particular assert tests that the copy assignment operator provides the strong exception safety guarantee, but the standard requires only the basic guarantee. Should this be _LIBCXX_ASSERT?

[ldionne]

test/std/strings/basic.string/string.cons/copy_alloc.pass.cpp

125

Yes, I think it should (ideally with a short comment).

[BillyONeal]

Fix asserts for the strong EH guarantee.

[CaseyCarter]

test/std/strings/basic.string/string.cons/copy_alloc.pass.cpp

128

LIBCPP_ASSERT(s1 == p1) (NB: no leading underscore) in test code.

[BillyONeal]

Fixed misspelled test macro.

[BillyONeal]

Tim Song suggests that http://eel.is/c++draft/string.require#2 indicates that basic_string actually does need to provide the strong guarantee here. While I think that wording is a mess I think I'll fix our basic_string to do that instead of that part of this change.

[BillyONeal]

Committed r357545

test/std/strings/basic.string/string.cons/copy_alloc.pass.cpp

 #include <string>
 #include <cassert>
 
 #include "test_macros.h"
 #include "test_allocator.h"
 #include "min_allocator.h"
 
 #ifndef TEST_HAS_NO_EXCEPTIONS
-template <class T>
 struct alloc_imp {
     bool active;
 
     alloc_imp() : active(true) {}
 
+    template <class T>
     T* allocate(std::size_t n)
     {
         if (active)
             return static_cast<T*>(std::malloc(n * sizeof(T)));
         else
             throw std::bad_alloc();
     }
 
+    template <class T>
     void deallocate(T* p, std::size_t) { std::free(p); }
     void activate  ()                  { active = true; }
     void deactivate()                  { active = false; }
 };
 
 template <class T>
 struct poca_alloc {
     typedef T value_type;
     typedef std::true_type propagate_on_container_copy_assignment;
 
-    alloc_imp<T> *imp;
+    alloc_imp *imp;
 
-    poca_alloc(alloc_imp<T> *imp_) : imp (imp_) {}
+    poca_alloc(alloc_imp *imp_) : imp (imp_) {}
 
     template <class U>
     poca_alloc(const poca_alloc<U>& other) : imp(other.imp) {}
 
-    T*   allocate  (std::size_t n)       { return imp->allocate(n);}
+    T*   allocate  (std::size_t n)       { return imp->allocate<T>(n);}
     void deallocate(T* p, std::size_t n) { imp->deallocate(p, n); }
 };
 
 template <typename T, typename U>
 bool operator==(const poca_alloc<T>& lhs, const poca_alloc<U>& rhs)
 {
     return lhs.imp == rhs.imp;
 }

 
 #ifndef TEST_HAS_NO_EXCEPTIONS
     {
     typedef poca_alloc<char> A;
     typedef std::basic_string<char, std::char_traits<char>, A> S;
     const char * p1 = "This is my first string";
     const char * p2 = "This is my second string";
 
-    alloc_imp<char> imp1;
-    alloc_imp<char> imp2;
+    alloc_imp imp1;
+    alloc_imp imp2;
     S s1(p1, A(&imp1));
     S s2(p2, A(&imp2));
 
     assert(s1 == p1);
     assert(s2 == p2);
 
     imp2.deactivate();
     test_assign(s1, s2);
-    assert(s1 == p1);
+    // libc++ provides the strong exception safety guarantee on the copy assignment operator,
+    // but the standard only requires the basic guarantee:
+    LIBCPP_ASSERT(s1 == p1);
+    s1.clear(); // under the basic guarantee, s1 must still be a valid string object.
+    assert(s1.empty());
     assert(s2 == p2);
     }
 #endif
 #endif
 
   return 0;
 }