[libc++] Adds a test for std::fill_n.

[Mordante]

Summary

The function std::fill requires a ForwardIterator, but std::fill_n
only requires an OutputIterator. Adds a test to validate std::fill_n
works with an OutputIterator.

Noticed this while working on LWG3539
format_to must not copy models of output_iterator<const charT&>

[• Quuxplusone]

LGTM % comments — please definitely fix the base(x) thing, but if you consider the other refactoring too much scope creep, OK.

libcxx/test/std/algorithms/alg.modifying.operations/alg.fill/fill_n.pass.cpp

55

assert(base(it) == ca + n);
and likewise below. All of our test iterators provide an ADL base, and we also provide one for pointers.

79–85

Here and in all cases below, it would be nice to make it just

int a[4] = {};
assert(std::fill_n(a, UDI(4), char(1)) == a + 4);
assert(a[0] == 1); // etc

i.e. there's no reason for all these arrays to have names different from a, or for variable n to exist at all. (There also doesn't seem to be a reason for us to be filling this int array with char(1) instead of just 1, but I didn't look closely. :))

[ldionne]

FWIW I agree with Arthur's comments (but he seems to always beat me to it). Thanks for fixing this.

[Mordante]

libcxx/test/std/algorithms/alg.modifying.operations/alg.fill/fill_n.pass.cpp

55

Thanks for the info I didn't know that.

79–85

I've updated the style, but I keep the char(1). Not sure why this was done so I prefer to keep it that way.

libcxx/test/std/algorithms/alg.modifying.operations/alg.fill/fill_n.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
 //
 //===----------------------------------------------------------------------===//
 
 // <algorithm>
return it == (std::begin(ib) + N)
         && std::all_of(std::begin(ib), it, [](int a) {return a == 5; })
         && *it == 0 // don't overwrite the last value in the output array
         ;
     }
 #endif
 
 typedef UserDefinedIntegral<unsigned> UDI;
 
+template <class Iter, class Ptr>
+typename std::enable_if<!std::is_same<Iter, Ptr>::value, bool>::type equal(Iter& it, Ptr ptr) {
+  return it.base() == ptr;
+}
+
+template <class Ptr>
+bool equal(Ptr it, Ptr ptr) {
+  return it == ptr;
+}
+
 template <class Iter>
 void
 test_char()
 {
     const unsigned n = 4;
     char ca[n] = {0};
-    assert(std::fill_n(Iter(ca), UDI(n), char(1)) == std::next(Iter(ca), n));
+    Iter it = std::fill_n(Iter(ca), UDI(n), char(1));
+    assert(equal(it, ca + n));
     assert(ca[0] == 1);
     assert(ca[1] == 1);
     assert(ca[2] == 1);
     assert(ca[3] == 1);
 }
 
 template <class Iter>
 void
 test_int()
 {
     const unsigned n = 4;
     int ia[n] = {0};
-    assert(std::fill_n(Iter(ia), UDI(n), 1) == std::next(Iter(ia), n));
+    Iter it = std::fill_n(Iter(ia), UDI(n), 1);
+    assert(equal(it, ia + n));
     assert(ia[0] == 1);
     assert(ia[1] == 1);
     assert(ia[2] == 1);
     assert(ia[3] == 1);
 }
 
 void
 test_int_array()
 {
     const unsigned n = 4;
     int ia[n] = {0};
-    assert(std::fill_n(ia, UDI(n), static_cast<char>(1)) == std::next(ia, n));
+    assert(std::fill_n(ia, UDI(n), static_cast<char>(1)) == ia + 4);
     assert(ia[0] == 1);
     assert(ia[1] == 1);
     assert(ia[2] == 1);
     assert(ia[3] == 1);
 }
 
 struct source {
     source() : i(0) { }
 
     operator int() const { return i++; }
     mutable int i;
 };
 
 void
 test_int_array_struct_source()
 {
     const unsigned n = 4;
     int ia[n] = {0};
-    assert(std::fill_n(ia, UDI(n), source()) == std::next(ia, n));
+    assert(std::fill_n(ia, UDI(n), source()) == ia + 4);
     assert(ia[0] == 0);
     assert(ia[1] == 1);
     assert(ia[2] == 2);
     assert(ia[3] == 3);
 }
 
 struct test1 {
     test1() : c(0) { }
     test1(char xc) : c(xc + 1) { }
     char c;
 };
 
 void
 test_struct_array()
 {
     const unsigned n = 4;
     test1 test1a[n] = {0};
-    assert(std::fill_n(test1a, UDI(n), static_cast<char>(10)) == std::next(test1a, n));
+    assert(std::fill_n(test1a, UDI(n), static_cast<char>(10)) == test1a + n);
     assert(test1a[0].c == 11);
     assert(test1a[1].c == 11);
     assert(test1a[2].c == 11);
     assert(test1a[3].c == 11);
 }
 
 class A
 {

 {
   Storage foo[5];
   std::fill_n(&foo[0], UDI(5), Storage());
 }
 
 
 int main(int, char**)
 {
+    test_char<output_iterator<char*> >();
     test_char<forward_iterator<char*> >();
     test_char<bidirectional_iterator<char*> >();
     test_char<random_access_iterator<char*> >();
     test_char<char*>();
 
+    test_int<output_iterator<int*> >();
     test_int<forward_iterator<int*> >();
     test_int<bidirectional_iterator<int*> >();
     test_int<random_access_iterator<int*> >();
     test_int<int*>();
 
     test_int_array();
     test_int_array_struct_source();
     test_struct_array();