llvm-project/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>

// template<class Iter, IntegralLike Size, class T>
//   requires OutputIterator<Iter, const T&>
//   constexpr OutputIterator      // constexpr after C++17
//   fill_n(Iter first, Size n, const T& value);

#include <algorithm>
#include <cassert>
#include <vector>

#include "sized_allocator.h"
#include "test_macros.h"
#include "test_iterators.h"
#include "user_defined_integral.h"

#if TEST_STD_VER > 17
TEST_CONSTEXPR bool test_constexpr() {
  const std::size_t N = 5;
  int ib[]            = {0, 0, 0, 0, 0, 0}; // one bigger than N

  auto it = std::fill_n(std::begin(ib), N, 5);
  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>
void test_char() {
  char a[4] = {};
  Iter it   = std::fill_n(Iter(a), UDI(4), char(1));
  assert(base(it) == a + 4);
  assert(a[0] == 1);
  assert(a[1] == 1);
  assert(a[2] == 1);
  assert(a[3] == 1);
}

template <class Iter>
void test_int() {
  int a[4] = {};
  Iter it  = std::fill_n(Iter(a), UDI(4), 1);
  assert(base(it) == a + 4);
  assert(a[0] == 1);
  assert(a[1] == 1);
  assert(a[2] == 1);
  assert(a[3] == 1);
}

void test_int_array() {
  int a[4] = {};
  assert(std::fill_n(a, UDI(4), static_cast<char>(1)) == a + 4);
  assert(a[0] == 1);
  assert(a[1] == 1);
  assert(a[2] == 1);
  assert(a[3] == 1);
}

struct source {
  source() : i(0) {}

  operator int() const { return i++; }
  mutable int i;
};

void test_int_array_struct_source() {
  int a[4] = {};
  assert(std::fill_n(a, UDI(4), source()) == a + 4);
  assert(a[0] == 0);
  assert(a[1] == 1);
  assert(a[2] == 2);
  assert(a[3] == 3);
}

struct test1 {
  test1() : c(0) {}
  test1(char xc) : c(xc + 1) {}
  char c;
};

void test_struct_array() {
  test1 test1a[4] = {};
  assert(std::fill_n(test1a, UDI(4), static_cast<char>(10)) == test1a + 4);
  assert(test1a[0].c == 11);
  assert(test1a[1].c == 11);
  assert(test1a[2].c == 11);
  assert(test1a[3].c == 11);
}

class A {
  char a_;

public:
  A() {}
  explicit A(char a) : a_(a) {}
  operator unsigned char() const { return 'b'; }

  friend bool operator==(const A& x, const A& y) { return x.a_ == y.a_; }
};

void test5() {
  A a[3];
  assert(std::fill_n(&a[0], UDI(3), A('a')) == a + 3);
  assert(a[0] == A('a'));
  assert(a[1] == A('a'));
  assert(a[2] == A('a'));
}

struct Storage {
  union {
    unsigned char a;
    unsigned char b;
  };
};

void test6() {
  Storage foo[5];
  std::fill_n(&foo[0], UDI(5), Storage());
}

// Make sure std::fill_n behaves properly with std::vector<bool> iterators with custom size types.
// See https://github.com/llvm/llvm-project/pull/122410.
TEST_CONSTEXPR_CXX20 void test_bititer_with_custom_sized_types() {
  {
    using Alloc = sized_allocator<bool, std::uint8_t, std::int8_t>;
    std::vector<bool, Alloc> in(100, false, Alloc(1));
    std::vector<bool, Alloc> expected(100, true, Alloc(1));
    std::fill_n(in.begin(), in.size(), true);
    assert(in == expected);
  }
  {
    using Alloc = sized_allocator<bool, std::uint16_t, std::int16_t>;
    std::vector<bool, Alloc> in(200, false, Alloc(1));
    std::vector<bool, Alloc> expected(200, true, Alloc(1));
    std::fill_n(in.begin(), in.size(), true);
    assert(in == expected);
  }
  {
    using Alloc = sized_allocator<bool, std::uint32_t, std::int32_t>;
    std::vector<bool, Alloc> in(200, false, Alloc(1));
    std::vector<bool, Alloc> expected(200, true, Alloc(1));
    std::fill_n(in.begin(), in.size(), true);
    assert(in == expected);
  }
  {
    using Alloc = sized_allocator<bool, std::uint64_t, std::int64_t>;
    std::vector<bool, Alloc> in(200, false, Alloc(1));
    std::vector<bool, Alloc> expected(200, true, Alloc(1));
    std::fill_n(in.begin(), in.size(), true);
    assert(in == expected);
  }
}

int main(int, char**) {
  test_char<cpp17_output_iterator<char*> >();
  test_char<forward_iterator<char*> >();
  test_char<bidirectional_iterator<char*> >();
  test_char<random_access_iterator<char*> >();
  test_char<char*>();

  test_int<cpp17_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();

  test5();
  test6();

  test_bititer_with_custom_sized_types();

#if TEST_STD_VER > 17
  static_assert(test_constexpr());
#endif

  return 0;
}