[libc++] [test] Constexpr-ify a couple of insert-iterator tests.

[• Quuxplusone]

Summary

This should have been done in D96385; thanks ldionne for the catch!
Also, make the back/front inserter behavior tests a little more thorough,
which incidentally caught a cut-and-paste-bug in `nasty_list`, so fix that.

If buildkite is happy with this (which it should be), imma land it.

[ldionne]

Thanks for being thorough.

libcxx/test/std/iterators/predef.iterators/insert.iterators/back.insert.iter.ops/back.insert.iter.cons/container.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 // <iterator>
 
 // back_insert_iterator
 
-// explicit back_insert_iterator(Cont& x);
+// explicit back_insert_iterator(Cont& x); // constexpr in C++20
 
 #include <iterator>
 #include <vector>
-#include "nasty_containers.h"
 
 #include "test_macros.h"
+#include "nasty_containers.h"
+#include "test_constexpr_container.h"
 
 template <class C>
-void
+TEST_CONSTEXPR_CXX20 bool
 test(C c)
 {
     std::back_insert_iterator<C> i(c);
+    return true;
 }
 
 int main(int, char**)
 {
     test(std::vector<int>());
     test(nasty_vector<int>());
-
+#if TEST_STD_VER >= 20
+    test(ConstexprFixedCapacityDeque<int, 10>());
+    static_assert(test(ConstexprFixedCapacityDeque<int, 10>()));
+#endif
     return 0;
 }

libcxx/test/std/iterators/predef.iterators/insert.iterators/back.insert.iter.ops/back.inserter/test.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 // <iterator>
 
 // template <BackInsertionContainer Cont>
 //   back_insert_iterator<Cont>
-//   back_inserter(Cont& x);
+//   back_inserter(Cont& x); // constexpr in C++20
+
+// template <BackInsertionContainer Cont>
+//   front_insert_iterator<Cont>
+//   front_inserter(Cont& x); // constexpr in C++20
 
-#include <iterator>
-#include <vector>
 #include <cassert>
-#include "nasty_containers.h"
+#include <iterator>
+#include <list>
 
 #include "test_macros.h"
+#include "nasty_containers.h"
+#include "test_constexpr_container.h"
 
 template <class C>
-void
+TEST_CONSTEXPR_CXX20 bool
 test(C c)
 {
     std::back_insert_iterator<C> i = std::back_inserter(c);
-    i = 0;
+    i = 3;
     assert(c.size() == 1);
-    assert(c.back() == 0);
+    assert(c.back() == 3);
+    i = 4;
+    assert(c.size() == 2);
+    assert(c.back() == 4);
+    return true;
 }
 
 int main(int, char**)
 {
     test(std::vector<int>());
     test(nasty_vector<int>());
-
+#if TEST_STD_VER >= 20
+    test(ConstexprFixedCapacityDeque<int, 10>());
+    static_assert(test(ConstexprFixedCapacityDeque<int, 10>()));
+#endif
     return 0;
 }

libcxx/test/std/iterators/predef.iterators/insert.iterators/front.insert.iter.ops/front.insert.iter.cons/container.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 // <iterator>
 
 // front_insert_iterator
 
-// explicit front_insert_iterator(Cont& x);
+// explicit front_insert_iterator(Cont& x); // constexpr in C++20
 
 #include <iterator>
 #include <list>
 
 #include "test_macros.h"
 #include "nasty_containers.h"
 #include "test_constexpr_container.h"
 

libcxx/test/std/iterators/predef.iterators/insert.iterators/front.insert.iter.ops/front.inserter/test.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 // <iterator>
 
-// template <BackInsertionContainer Cont>
+// template <FrontInsertionContainer Cont>
 //   front_insert_iterator<Cont>
-//   front_inserter(Cont& x);
+//   front_inserter(Cont& x); // constexpr in C++20
 
 #include <cassert>
 #include <iterator>
 #include <list>
 
 #include "test_macros.h"
 #include "nasty_containers.h"
 #include "test_constexpr_container.h"
 
 template <class C>
 TEST_CONSTEXPR_CXX20 bool
 test(C c)
 {
     std::front_insert_iterator<C> i = std::front_inserter(c);
-    i = 0;
+    i = 3;
     assert(c.size() == 1);
-    assert(c.front() == 0);
+    assert(c.front() == 3);
+    i = 4;
+    assert(c.size() == 2);
+    assert(c.front() == 4);
     return true;
 }
 
 int main(int, char**)
 {
     test(std::list<int>());
     test(nasty_list<int>());
 #if TEST_STD_VER >= 20
     test(ConstexprFixedCapacityDeque<int, 10>());
     static_assert(test(ConstexprFixedCapacityDeque<int, 10>()));
 #endif
     return 0;
 }

libcxx/test/std/iterators/predef.iterators/insert.iterators/insert.iter.ops/insert.iter.cons/test.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 // <iterator>
 
 // insert_iterator
 
-// insert_iterator(Cont& x, Cont::iterator i);
+// insert_iterator(Cont& x, Cont::iterator i); // constexpr in C++20
 
 #include <iterator>
 #include <vector>
 
 #include "test_macros.h"
 #include "nasty_containers.h"
 #include "test_constexpr_container.h"
 

libcxx/test/support/nasty_containers.h

#endif
     size_type size() const TEST_NOEXCEPT      { return l_.size(); }
     size_type max_size() const TEST_NOEXCEPT  { return l_.max_size(); }
     bool empty() const TEST_NOEXCEPT          { return l_.empty(); }
 
     void push_front(const value_type& x)    { l_.push_front(x); }
     void push_back(const value_type& x)     { l_.push_back(x); }
 #if TEST_STD_VER >= 11
     void push_back(value_type&& x)          { l_.push_back(std::forward<value_type&&>(x)); }
-    void push_front(value_type&& x)         { l_.push_back(std::forward<value_type&&>(x)); }
+    void push_front(value_type&& x)         { l_.push_front(std::forward<value_type&&>(x)); }
     template <class... Args>
         void emplace_back(Args&&... args)   { l_.emplace_back(std::forward<Args>(args)...); }
     template <class... Args>
         void emplace_front(Args&&... args)  { l_.emplace_front(std::forward<Args>(args)...); }
 #endif
     void pop_front()                        { l_.pop_front(); }
     void pop_back()                         { l_.pop_back(); }
 
template <class InputIterator>
         iterator insert(const_iterator pos, InputIterator first, InputIterator last)
     { return l_.insert(pos, first, last); }
 
 #if TEST_STD_VER >= 11
     iterator insert(const_iterator pos, std::initializer_list<value_type> il) { return l_.insert(pos, il); }
 #endif
 
     iterator erase(const_iterator pos)                      { return l_.erase(pos); }
-    iterator erase(const_iterator pos, const_iterator last) { return l_.erase(pos, last); }
+    iterator erase(const_iterator first, const_iterator last) { return l_.erase(first, last); }
 
-    void resize(size_type)                      { l_.resize(); }
-    void resize(size_type, const value_type& c) { l_.resize(c); }
+    void resize(size_type n)                      { l_.resize(n); }
+    void resize(size_type n, const value_type& c) { l_.resize(n, c); }
 
     void swap(nasty_list &nl)
 #if TEST_STD_VER > 14
     noexcept(std::is_nothrow_swappable<nested_container>::value)
 #elif defined(_LIBCPP_VERSION)
     TEST_NOEXCEPT_COND(std::__is_nothrow_swappable<nested_container>::value)
 #endif
     { l_.swap(nl.l_); }