libcxx/test/std/containers/sequences/insert_range_sequence_containers.h

//===----------------------------------------------------------------------===//
//
// 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
//
//===----------------------------------------------------------------------===//

#ifndef SUPPORT_INSERT_RANGE_SEQUENCE_CONTAINERS_H
#define SUPPORT_INSERT_RANGE_SEQUENCE_CONTAINERS_H

#include <algorithm>
#include <cassert>
#include <concepts>
#include <cstddef>
#include <initializer_list>
#include <ranges>
#include <type_traits>
#include <vector>

#include "../exception_safety_helpers.h"
#include "../from_range_helpers.h"
#include "../insert_range_helpers.h"
#include "MoveOnly.h"
#include "almost_satisfies_types.h"
#include "count_new.h"
#include "min_allocator.h"
#include "test_allocator.h"
#include "test_iterators.h"
#include "test_macros.h"
#include "type_algorithms.h"

template <class Container, class Range>
concept HasInsertRange = requires(Container& c, Range&& range) { c.insert_range(c.end(), range); };

template <template <class...> class Container, class T, class U>
constexpr bool test_constraints_insert_range() {
  // Input range with the same value type.
  static_assert(HasInsertRange<Container<T>, InputRange<T>>);
  // Input range with a convertible value type.
  static_assert(HasInsertRange<Container<T>, InputRange<U>>);
  // Input range with a non-convertible value type.
  static_assert(!HasInsertRange<Container<T>, InputRange<Empty>>);
  // Not an input range.
  static_assert(!HasInsertRange<Container<T>, InputRangeNotDerivedFrom>);
  static_assert(!HasInsertRange<Container<T>, InputRangeNotIndirectlyReadable>);
  static_assert(!HasInsertRange<Container<T>, InputRangeNotInputOrOutputIterator>);

  return true;
}

template <class Container, class Range>
concept HasAppendRange = requires(Container& c, Range&& range) { c.append_range(range); };

template <template <class...> class Container, class T, class U>
constexpr bool test_constraints_append_range() {
  // Input range with the same value type.
  static_assert(HasAppendRange<Container<T>, InputRange<T>>);
  // Input range with a convertible value type.
  static_assert(HasAppendRange<Container<T>, InputRange<U>>);
  // Input range with a non-convertible value type.
  static_assert(!HasAppendRange<Container<T>, InputRange<Empty>>);
  // Not an input range.
  static_assert(!HasAppendRange<Container<T>, InputRangeNotDerivedFrom>);
  static_assert(!HasAppendRange<Container<T>, InputRangeNotIndirectlyReadable>);
  static_assert(!HasAppendRange<Container<T>, InputRangeNotInputOrOutputIterator>);

  return true;
}

template <class Container, class Range>
concept HasPrependRange = requires(Container& c, Range&& range) { c.prepend_range(range); };

template <template <class...> class Container, class T, class U>
constexpr bool test_constraints_prepend_range() {
  // Input range with the same value type.
  static_assert(HasPrependRange<Container<T>, InputRange<T>>);
  // Input range with a convertible value type.
  static_assert(HasPrependRange<Container<T>, InputRange<U>>);
  // Input range with a non-convertible value type.
  static_assert(!HasPrependRange<Container<T>, InputRange<Empty>>);
  // Not an input range.
  static_assert(!HasPrependRange<Container<T>, InputRangeNotDerivedFrom>);
  static_assert(!HasPrependRange<Container<T>, InputRangeNotIndirectlyReadable>);
  static_assert(!HasPrependRange<Container<T>, InputRangeNotInputOrOutputIterator>);

  return true;
}

template <class Container, class Range>
concept HasAssignRange = requires(Container& c, Range&& range) { c.assign_range(range); };

template <template <class...> class Container, class T, class U>
constexpr bool test_constraints_assign_range() {
  // Input range with the same value type.
  static_assert(HasAssignRange<Container<T>, InputRange<T>>);
  // Input range with a convertible value type.
  static_assert(HasAssignRange<Container<T>, InputRange<U>>);
  // Input range with a non-convertible value type.
  static_assert(!HasAssignRange<Container<T>, InputRange<Empty>>);
  // Not an input range.
  static_assert(!HasAssignRange<Container<T>, InputRangeNotDerivedFrom>);
  static_assert(!HasAssignRange<Container<T>, InputRangeNotIndirectlyReadable>);
  static_assert(!HasAssignRange<Container<T>, InputRangeNotInputOrOutputIterator>);

  return true;
}

// Empty container.

template <class T>
TestCase<T> constexpr EmptyContainer_EmptyRange{.initial = {}, .index = 0, .input = {}, .expected = {}};
// Note: specializations for `bool` still use `vector<int>` for inputs. This is to avoid dealing with `vector<bool>` and
// its iterators over proxy types.
template <>
constexpr TestCase<int> EmptyContainer_EmptyRange<bool>{.initial = {}, .index = 0, .input = {}, .expected = {}};

template <class T>
constexpr TestCase<T> EmptyContainer_OneElementRange;
template <>
constexpr TestCase<int> EmptyContainer_OneElementRange<int>{.initial = {}, .index = 0, .input = {5}, .expected = {5}};
template <>
constexpr TestCase<char> EmptyContainer_OneElementRange<char>{.initial = {}, .index = 0, .input = "a", .expected = "a"};
template <>
constexpr TestCase<int> EmptyContainer_OneElementRange<bool>{
    .initial = {}, .index = 0, .input = {true}, .expected = {true}};

template <class T>
constexpr TestCase<T> EmptyContainer_MidRange;
template <>
constexpr TestCase<int> EmptyContainer_MidRange<int>{
    .initial = {}, .index = 0, .input = {5, 3, 1, 7, 9}, .expected = {5, 3, 1, 7, 9}};
template <>
constexpr TestCase<char> EmptyContainer_MidRange<char>{
    .initial = {}, .index = 0, .input = "aeiou", .expected = "aeiou"};
template <>
constexpr TestCase<int> EmptyContainer_MidRange<bool>{
    .initial = {}, .index = 0, .input = {1, 1, 0, 1, 1}, .expected = {1, 1, 0, 1, 1}};

// One-element container.

template <class T>
constexpr TestCase<T> OneElementContainer_Begin_EmptyRange;
template <>
constexpr TestCase<int> OneElementContainer_Begin_EmptyRange<int>{
    .initial = {3}, .index = 0, .input = {}, .expected = {3}};
template <>
constexpr TestCase<char> OneElementContainer_Begin_EmptyRange<char>{
    .initial = "B", .index = 0, .input = {}, .expected = "B"};
template <>
constexpr TestCase<int> OneElementContainer_Begin_EmptyRange<bool>{
    .initial = {0}, .index = 0, .input = {}, .expected = {0}};

template <class T>
constexpr TestCase<T> OneElementContainer_End_EmptyRange;
template <>
constexpr TestCase<int> OneElementContainer_End_EmptyRange<int>{
    .initial = {3}, .index = 1, .input = {}, .expected = {3}};
template <>
constexpr TestCase<char> OneElementContainer_End_EmptyRange<char>{
    .initial = "B", .index = 1, .input = {}, .expected = "B"};
template <>
constexpr TestCase<int> OneElementContainer_End_EmptyRange<bool>{
    .initial = {0}, .index = 1, .input = {}, .expected = {0}};

template <class T>
constexpr TestCase<T> OneElementContainer_Begin_OneElementRange;
template <>
constexpr TestCase<int> OneElementContainer_Begin_OneElementRange<int>{
    .initial = {3}, .index = 0, .input = {-5}, .expected = {-5, 3}};
template <>
constexpr TestCase<char> OneElementContainer_Begin_OneElementRange<char>{
    .initial = "B", .index = 0, .input = "a", .expected = "aB"};
template <>
constexpr TestCase<int> OneElementContainer_Begin_OneElementRange<bool>{
    .initial = {0}, .index = 0, .input = {1}, .expected = {1, 0}};

template <class T>
constexpr TestCase<T> OneElementContainer_End_OneElementRange;
template <>
constexpr TestCase<int> OneElementContainer_End_OneElementRange<int>{
    .initial = {3}, .index = 1, .input = {-5}, .expected = {3, -5}};
template <>
constexpr TestCase<char> OneElementContainer_End_OneElementRange<char>{
    .initial = "B", .index = 1, .input = "a", .expected = "Ba"};
template <>
constexpr TestCase<int> OneElementContainer_End_OneElementRange<bool>{
    .initial = {0}, .index = 1, .input = {1}, .expected = {0, 1}};

template <class T>
constexpr TestCase<T> OneElementContainer_Begin_MidRange;
template <>
constexpr TestCase<int> OneElementContainer_Begin_MidRange<int>{
    .initial = {3}, .index = 0, .input = {-5, -3, -1, -7, -9}, .expected = {-5, -3, -1, -7, -9, 3}};
template <>
constexpr TestCase<char> OneElementContainer_Begin_MidRange<char>{
    .initial = "B", .index = 0, .input = "aeiou", .expected = "aeiouB"};
template <>
constexpr TestCase<int> OneElementContainer_Begin_MidRange<bool>{
    .initial = {0}, .index = 0, .input = {1, 1, 0, 1, 1}, .expected = {1, 1, 0, 1, 1, 0}};

template <class T>
constexpr TestCase<T> OneElementContainer_End_MidRange;
template <>
constexpr TestCase<int> OneElementContainer_End_MidRange<int>{
    .initial = {3}, .index = 1, .input = {-5, -3, -1, -7, -9}, .expected = {3, -5, -3, -1, -7, -9}};
template <>
constexpr TestCase<char> OneElementContainer_End_MidRange<char>{
    .initial = "B", .index = 1, .input = "aeiou", .expected = "Baeiou"};
template <>
constexpr TestCase<int> OneElementContainer_End_MidRange<bool>{
    .initial = {0}, .index = 1, .input = {1, 1, 0, 1, 1}, .expected = {0, 1, 1, 0, 1, 1}};

// Full container / empty range.

template <class T>
constexpr TestCase<T> FullContainer_Begin_EmptyRange;
template <>
constexpr TestCase<int> FullContainer_Begin_EmptyRange<int>{
    .initial = {11, 29, 35, 14, 84}, .index = 0, .input = {}, .expected = {11, 29, 35, 14, 84}};
template <>
constexpr TestCase<char> FullContainer_Begin_EmptyRange<char>{
    .initial = "_BCD_", .index = 0, .input = {}, .expected = "_BCD_"};
template <>
constexpr TestCase<int> FullContainer_Begin_EmptyRange<bool>{
    .initial = {0, 0, 1, 0, 0}, .index = 0, .input = {}, .expected = {0, 0, 1, 0, 0}};

template <class T>
constexpr TestCase<T> FullContainer_Mid_EmptyRange;
template <>
constexpr TestCase<int> FullContainer_Mid_EmptyRange<int>{
    .initial = {11, 29, 35, 14, 84}, .index = 2, .input = {}, .expected = {11, 29, 35, 14, 84}};
template <>
constexpr TestCase<char> FullContainer_Mid_EmptyRange<char>{
    .initial = "_BCD_", .index = 2, .input = {}, .expected = "_BCD_"};
template <>
constexpr TestCase<int> FullContainer_Mid_EmptyRange<bool>{
    .initial = {0, 0, 1, 0, 0}, .index = 2, .input = {}, .expected = {0, 0, 1, 0, 0}};

template <class T>
constexpr TestCase<T> FullContainer_End_EmptyRange;
template <>
constexpr TestCase<int> FullContainer_End_EmptyRange<int>{
    .initial = {11, 29, 35, 14, 84}, .index = 5, .input = {}, .expected = {11, 29, 35, 14, 84}};
template <>
constexpr TestCase<char> FullContainer_End_EmptyRange<char>{
    .initial = "_BCD_", .index = 5, .input = {}, .expected = "_BCD_"};
template <>
constexpr TestCase<int> FullContainer_End_EmptyRange<bool>{
    .initial = {0, 0, 1, 0, 0}, .index = 5, .input = {}, .expected = {0, 0, 1, 0, 0}};

// Full container / one-element range.

template <class T>
constexpr TestCase<T> FullContainer_Begin_OneElementRange;
template <>
constexpr TestCase<int> FullContainer_Begin_OneElementRange<int>{
    .initial = {11, 29, 35, 14, 84}, .index = 0, .input = {-5}, .expected = {-5, 11, 29, 35, 14, 84}};
template <>
constexpr TestCase<char> FullContainer_Begin_OneElementRange<char>{
    .initial = "_BCD_", .index = 0, .input = "a", .expected = "a_BCD_"};
template <>
constexpr TestCase<int> FullContainer_Begin_OneElementRange<bool>{
    .initial = {0, 0, 1, 0, 0}, .index = 0, .input = {1}, .expected = {1, 0, 0, 1, 0, 0}};

template <class T>
constexpr TestCase<T> FullContainer_Mid_OneElementRange;
template <>
constexpr TestCase<int> FullContainer_Mid_OneElementRange<int>{
    .initial = {11, 29, 35, 14, 84}, .index = 2, .input = {-5}, .expected = {11, 29, -5, 35, 14, 84}};
template <>
constexpr TestCase<char> FullContainer_Mid_OneElementRange<char>{
    .initial = "_BCD_", .index = 2, .input = "a", .expected = "_BaCD_"};
template <>
constexpr TestCase<int> FullContainer_Mid_OneElementRange<bool>{
    .initial = {0, 0, 1, 0, 0}, .index = 2, .input = {1}, .expected = {0, 0, 1, 1, 0, 0}};

template <class T>
constexpr TestCase<T> FullContainer_End_OneElementRange;
template <>
constexpr TestCase<int> FullContainer_End_OneElementRange<int>{
    .initial = {11, 29, 35, 14, 84}, .index = 5, .input = {-5}, .expected = {11, 29, 35, 14, 84, -5}};
template <>
constexpr TestCase<char> FullContainer_End_OneElementRange<char>{
    .initial = "_BCD_", .index = 5, .input = "a", .expected = "_BCD_a"};
template <>
constexpr TestCase<int> FullContainer_End_OneElementRange<bool>{
    .initial = {0, 0, 1, 0, 0}, .index = 5, .input = {1}, .expected = {0, 0, 1, 0, 0, 1}};

// Full container / mid-sized range.

template <class T>
constexpr TestCase<T> FullContainer_Begin_MidRange;
template <>
constexpr TestCase<int> FullContainer_Begin_MidRange<int>{
    .initial  = {11, 29, 35, 14, 84},
    .index    = 0,
    .input    = {-5, -3, -1, -7, -9},
    .expected = {-5, -3, -1, -7, -9, 11, 29, 35, 14, 84}};
template <>
constexpr TestCase<char> FullContainer_Begin_MidRange<char>{
    .initial = "_BCD_", .index = 0, .input = "aeiou", .expected = "aeiou_BCD_"};
template <>
constexpr TestCase<int> FullContainer_Begin_MidRange<bool>{
    .initial = {0, 0, 1, 0, 1}, .index = 0, .input = {1, 1, 0, 1, 1}, .expected = {1, 1, 0, 1, 1, 0, 0, 1, 0, 1}};

template <class T>
constexpr TestCase<T> FullContainer_Mid_MidRange;
template <>
constexpr TestCase<int> FullContainer_Mid_MidRange<int>{
    .initial  = {11, 29, 35, 14, 84},
    .index    = 2,
    .input    = {-5, -3, -1, -7, -9},
    .expected = {11, 29, -5, -3, -1, -7, -9, 35, 14, 84}};
template <>
constexpr TestCase<char> FullContainer_Mid_MidRange<char>{
    .initial = "_BCD_", .index = 2, .input = "aeiou", .expected = "_BaeiouCD_"};
template <>
constexpr TestCase<int> FullContainer_Mid_MidRange<bool>{
    .initial = {0, 0, 1, 0, 1}, .index = 2, .input = {1, 1, 0, 1, 1}, .expected = {0, 0, 1, 1, 0, 1, 1, 1, 0, 1}};

template <class T>
constexpr TestCase<T> FullContainer_End_MidRange;
template <>
constexpr TestCase<int> FullContainer_End_MidRange<int>{
    .initial  = {11, 29, 35, 14, 84},
    .index    = 5,
    .input    = {-5, -3, -1, -7, -9},
    .expected = {11, 29, 35, 14, 84, -5, -3, -1, -7, -9}};
template <>
constexpr TestCase<char> FullContainer_End_MidRange<char>{
    .initial = "_BCD_", .index = 5, .input = "aeiou", .expected = "_BCD_aeiou"};
template <>
constexpr TestCase<int> FullContainer_End_MidRange<bool>{
    .initial = {0, 0, 1, 0, 1}, .index = 5, .input = {1, 1, 0, 1, 1}, .expected = {0, 0, 1, 0, 1, 1, 1, 0, 1, 1}};

// Full container / long range.

template <class T>
constexpr TestCase<T> FullContainer_Begin_LongRange;
template <>
constexpr TestCase<int> FullContainer_Begin_LongRange<int>{
    .initial  = {11, 29, 35, 14, 84},
    .index    = 0,
    .input    = {-5, -3, -1, -7, -9, -19, -48, -56, -13, -14, -29, -88, -17, -1, -5, -11, -89, -21, -33, -48},
    .expected = {-5, -3, -1,  -7,  -9,  -19, -48, -56, -13, -14, -29, -88, -17,
                 -1, -5, -11, -89, -21, -33, -48, 11,  29,  35,  14,  84}};
template <>
constexpr TestCase<char> FullContainer_Begin_LongRange<char>{
    .initial = "_BCD_", .index = 0, .input = "aeiouqwxyz5781964203", .expected = "aeiouqwxyz5781964203_BCD_"};
template <>
constexpr TestCase<int> FullContainer_Begin_LongRange<bool>{
    .initial  = {0, 0, 1, 0, 0},
    .index    = 0,
    .input    = {1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0},
    .expected = {1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0}};

template <class T>
constexpr TestCase<T> FullContainer_Mid_LongRange;
template <>
constexpr TestCase<int> FullContainer_Mid_LongRange<int>{
    .initial  = {11, 29, 35, 14, 84},
    .index    = 2,
    .input    = {-5, -3, -1, -7, -9, -19, -48, -56, -13, -14, -29, -88, -17, -1, -5, -11, -89, -21, -33, -48},
    .expected = {11,  29,  -5, -3, -1,  -7,  -9,  -19, -48, -56, -13, -14, -29,
                 -88, -17, -1, -5, -11, -89, -21, -33, -48, 35,  14,  84}};
template <>
constexpr TestCase<char> FullContainer_Mid_LongRange<char>{
    .initial = "_BCD_", .index = 2, .input = "aeiouqwxyz5781964203", .expected = "_Baeiouqwxyz5781964203CD_"};
template <>
constexpr TestCase<int> FullContainer_Mid_LongRange<bool>{
    .initial  = {0, 0, 1, 0, 0},
    .index    = 2,
    .input    = {1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0},
    .expected = {0, 0, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 1, 0, 0}};

template <class T>
constexpr TestCase<T> FullContainer_End_LongRange;
template <>
constexpr TestCase<int> FullContainer_End_LongRange<int>{
    .initial  = {11, 29, 35, 14, 84},
    .index    = 5,
    .input    = {-5, -3, -1, -7, -9, -19, -48, -56, -13, -14, -29, -88, -17, -1, -5, -11, -89, -21, -33, -48},
    .expected = {11,  29,  35,  14,  84,  -5, -3, -1,  -7,  -9,  -19, -48, -56,
                 -13, -14, -29, -88, -17, -1, -5, -11, -89, -21, -33, -48}};
template <>
constexpr TestCase<char> FullContainer_End_LongRange<char>{
    .initial = "_BCD_", .index = 5, .input = "aeiouqwxyz5781964203", .expected = "_BCD_aeiouqwxyz5781964203"};
template <>
constexpr TestCase<int> FullContainer_End_LongRange<bool>{
    .initial  = {0, 0, 1, 0, 1},
    .index    = 5,
    .input    = {1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0},
    .expected = {0, 0, 1, 0, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0}};

// Sequence containers tests.

template <class Container, class Iter, class Sent, class Validate>
constexpr void test_sequence_insert_range(Validate validate) {
  using T      = typename Container::value_type;
  using D      = typename Container::difference_type;
  auto get_pos = [](auto& c, auto& test_case) { return std::ranges::next(c.begin(), static_cast<D>(test_case.index)); };

  auto test = [&](auto& test_case) {
    Container c(test_case.initial.begin(), test_case.initial.end());
    auto in  = wrap_input<Iter, Sent>(test_case.input);
    auto pos = get_pos(c, test_case);

    auto result = c.insert_range(pos, in);
    assert(result == get_pos(c, test_case));
    validate(c);
    return std::ranges::equal(c, test_case.expected);
  };

  { // Empty container.
    // empty_c.insert_range(end, empty_range)
    assert(test(EmptyContainer_EmptyRange<T>));
    // empty_c.insert_range(end, one_element_range)
    assert(test(EmptyContainer_OneElementRange<T>));
    // empty_c.insert_range(end, mid_range)
    assert(test(EmptyContainer_MidRange<T>));
  }

  { // One-element container.
    // one_element_c.insert_range(begin, empty_range)
    assert(test(OneElementContainer_Begin_EmptyRange<T>));
    // one_element_c.insert_range(end, empty_range)
    assert(test(OneElementContainer_End_EmptyRange<T>));
    // one_element_c.insert_range(begin, one_element_range)
    assert(test(OneElementContainer_Begin_OneElementRange<T>));
    // one_element_c.insert_range(end, one_element_range)
    assert(test(OneElementContainer_End_OneElementRange<T>));
    // one_element_c.insert_range(begin, mid_range)
    assert(test(OneElementContainer_Begin_MidRange<T>));
    // one_element_c.insert_range(end, mid_range)
    assert(test(OneElementContainer_End_MidRange<T>));
  }

  { // Full container.
    // full_container.insert_range(begin, empty_range)
    assert(test(FullContainer_Begin_EmptyRange<T>));
    // full_container.insert_range(mid, empty_range)
    assert(test(FullContainer_Mid_EmptyRange<T>));
    // full_container.insert_range(end, empty_range)
    assert(test(FullContainer_End_EmptyRange<T>));
    // full_container.insert_range(begin, one_element_range)
    assert(test(FullContainer_Begin_OneElementRange<T>));
    // full_container.insert_range(end, one_element_range)
    assert(test(FullContainer_Mid_OneElementRange<T>));
    // full_container.insert_range(end, one_element_range)
    assert(test(FullContainer_End_OneElementRange<T>));
    // full_container.insert_range(begin, mid_range)
    assert(test(FullContainer_Begin_MidRange<T>));
    // full_container.insert_range(mid, mid_range)
    assert(test(FullContainer_Mid_MidRange<T>));
    // full_container.insert_range(end, mid_range)
    assert(test(FullContainer_End_MidRange<T>));
    // full_container.insert_range(begin, long_range)
    assert(test(FullContainer_Begin_LongRange<T>));
    // full_container.insert_range(mid, long_range)
    assert(test(FullContainer_Mid_LongRange<T>));
    // full_container.insert_range(end, long_range)
    assert(test(FullContainer_End_LongRange<T>));
  }
}

template <class Container, class Iter, class Sent, class Validate>
constexpr void test_sequence_prepend_range(Validate validate) {
  using T = typename Container::value_type;

  auto test = [&](auto& test_case) {
    Container c(test_case.initial.begin(), test_case.initial.end());
    auto in = wrap_input<Iter, Sent>(test_case.input);

    c.prepend_range(in);
    validate(c);
    return std::ranges::equal(c, test_case.expected);
  };

  { // Empty container.
    // empty_c.prepend_range(empty_range)
    assert(test(EmptyContainer_EmptyRange<T>));
    // empty_c.prepend_range(one_element_range)
    assert(test(EmptyContainer_OneElementRange<T>));
    // empty_c.prepend_range(mid_range)
    assert(test(EmptyContainer_MidRange<T>));
  }

  { // One-element container.
    // one_element_c.prepend_range(empty_range)
    assert(test(OneElementContainer_Begin_EmptyRange<T>));
    // one_element_c.prepend_range(one_element_range)
    assert(test(OneElementContainer_Begin_OneElementRange<T>));
    // one_element_c.prepend_range(mid_range)
    assert(test(OneElementContainer_Begin_MidRange<T>));
  }

  { // Full container.
    // full_container.prepend_range(empty_range)
    assert(test(FullContainer_Begin_EmptyRange<T>));
    // full_container.prepend_range(one_element_range)
    assert(test(FullContainer_Begin_OneElementRange<T>));
    // full_container.prepend_range(mid_range)
    assert(test(FullContainer_Begin_MidRange<T>));
    // full_container.prepend_range(long_range)
    assert(test(FullContainer_Begin_LongRange<T>));
  }
}

template <class Container, class Iter, class Sent, class Validate>
constexpr void test_sequence_append_range(Validate validate) {
  using T = typename Container::value_type;

  auto test = [&](auto& test_case) {
    Container c(test_case.initial.begin(), test_case.initial.end());
    auto in = wrap_input<Iter, Sent>(test_case.input);

    c.append_range(in);
    validate(c);
    return std::ranges::equal(c, test_case.expected);
  };

  { // Empty container.
    // empty_c.append_range(empty_range)
    assert(test(EmptyContainer_EmptyRange<T>));
    // empty_c.append_range(one_element_range)
    assert(test(EmptyContainer_OneElementRange<T>));
    // empty_c.append_range(mid_range)
    assert(test(EmptyContainer_MidRange<T>));
  }

  { // One-element container.
    // one_element_c.append_range(empty_range)
    assert(test(OneElementContainer_End_EmptyRange<T>));
    // one_element_c.append_range(one_element_range)
    assert(test(OneElementContainer_End_OneElementRange<T>));
    // one_element_c.append_range(mid_range)
    assert(test(OneElementContainer_End_MidRange<T>));
  }

  { // Full container.
    // full_container.append_range(empty_range)
    assert(test(FullContainer_End_EmptyRange<T>));
    // full_container.append_range(one_element_range)
    assert(test(FullContainer_End_OneElementRange<T>));
    // full_container.append_range(mid_range)
    assert(test(FullContainer_End_MidRange<T>));
    // full_container.append_range(long_range)
    assert(test(FullContainer_End_LongRange<T>));
  }
}

template <class Container, class Iter, class Sent, class Validate>
constexpr void test_sequence_assign_range(Validate validate) {
  using T = typename Container::value_type;

  auto& initial_empty       = EmptyContainer_EmptyRange<T>.initial;
  auto& initial_one_element = OneElementContainer_Begin_EmptyRange<T>.initial;
  auto& initial_full        = FullContainer_Begin_EmptyRange<T>.initial;
  auto& input_empty         = FullContainer_Begin_EmptyRange<T>.input;
  auto& input_one_element   = FullContainer_Begin_OneElementRange<T>.input;
  auto& input_mid_range     = FullContainer_Begin_MidRange<T>.input;
  auto& input_long_range    = FullContainer_Begin_LongRange<T>.input;

  auto test = [&](auto& initial, auto& input) {
    Container c(initial.begin(), initial.end());
    auto in = wrap_input<Iter, Sent>(input);

    c.assign_range(in);
    validate(c);
    return std::ranges::equal(c, input);
  };

  { // Empty container.
    // empty_container.assign_range(empty_range)
    assert(test(initial_empty, input_empty));
    // empty_container.assign_range(one_element_range)
    assert(test(initial_empty, input_one_element));
    // empty_container.assign_range(mid_range)
    assert(test(initial_empty, input_mid_range));
    // empty_container.assign_range(long_range)
    assert(test(initial_empty, input_long_range));
  }

  { // One-element container.
    // one_element_container.assign_range(empty_range)
    assert(test(initial_one_element, input_empty));
    // one_element_container.assign_range(one_element_range)
    assert(test(initial_one_element, input_one_element));
    // one_element_container.assign_range(mid_range)
    assert(test(initial_one_element, input_mid_range));
    // one_element_container.assign_range(long_range)
    assert(test(initial_one_element, input_long_range));
  }

  { // Full container.
    // full_container.assign_range(empty_range)
    assert(test(initial_full, input_empty));
    // full_container.assign_range(one_element_range)
    assert(test(initial_full, input_one_element));
    // full_container.assign_range(mid_range)
    assert(test(initial_full, input_mid_range));
    // full_container.assign_range(long_range)
    assert(test(initial_full, input_long_range));
  }
}

// Move-only types.

template <template <class...> class Container>
constexpr void test_sequence_insert_range_move_only() {
  MoveOnly input[5];
  std::ranges::subrange in(std::move_iterator{input}, std::move_iterator{input + 5});

  Container<MoveOnly> c;
  c.insert_range(c.end(), in);
}

template <template <class...> class Container>
constexpr void test_sequence_prepend_range_move_only() {
  MoveOnly input[5];
  std::ranges::subrange in(std::move_iterator{input}, std::move_iterator{input + 5});

  Container<MoveOnly> c;
  c.prepend_range(in);
}

template <template <class...> class Container>
constexpr void test_sequence_append_range_move_only() {
  MoveOnly input[5];
  std::ranges::subrange in(std::move_iterator{input}, std::move_iterator{input + 5});

  Container<MoveOnly> c;
  c.append_range(in);
}

template <template <class...> class Container>
constexpr void test_sequence_assign_range_move_only() {
  MoveOnly input[5];
  std::ranges::subrange in(std::move_iterator{input}, std::move_iterator{input + 5});

  Container<MoveOnly> c;
  c.assign_range(in);
}

// Exception safety.

template <template <class...> class Container>
void test_insert_range_exception_safety_throwing_copy() {
#if !defined(TEST_HAS_NO_EXCEPTIONS)
  constexpr int ThrowOn = 3;
  using T               = ThrowingCopy<ThrowOn>;
  test_exception_safety_throwing_copy<ThrowOn, /*Size=*/5>([](T* from, T* to) {
    Container<T> c;
    c.insert_range(c.end(), std::ranges::subrange(from, to));
  });
#endif
}

template <template <class...> class Container, class T>
void test_insert_range_exception_safety_throwing_allocator() {
#if !defined(TEST_HAS_NO_EXCEPTIONS)
  T in[] = {0, 1};

  try {
    ThrowingAllocator<T> alloc;

    globalMemCounter.reset();
    Container<T, ThrowingAllocator<T>> c(alloc);
    c.insert_range(c.end(), in);
    assert(false); // The function call above should throw.

  } catch (int) {
    assert(globalMemCounter.new_called == globalMemCounter.delete_called);
  }
#endif
}

template <template <class...> class Container>
void test_prepend_range_exception_safety_throwing_copy() {
#if !defined(TEST_HAS_NO_EXCEPTIONS)
  constexpr int ThrowOn = 3;
  using T               = ThrowingCopy<ThrowOn>;
  test_exception_safety_throwing_copy<ThrowOn, /*Size=*/5>([](T* from, T* to) {
    Container<T> c;
    c.prepend_range(std::ranges::subrange(from, to));
  });
#endif
}

template <template <class...> class Container, class T>
void test_prepend_range_exception_safety_throwing_allocator() {
#if !defined(TEST_HAS_NO_EXCEPTIONS)
  T in[] = {0, 1};

  try {
    ThrowingAllocator<T> alloc;

    globalMemCounter.reset();
    Container<T, ThrowingAllocator<T>> c(alloc);
    c.prepend_range(in);
    assert(false); // The function call above should throw.

  } catch (int) {
    assert(globalMemCounter.new_called == globalMemCounter.delete_called);
  }
#endif
}

template <template <class...> class Container>
void test_append_range_exception_safety_throwing_copy() {
#if !defined(TEST_HAS_NO_EXCEPTIONS)
  constexpr int ThrowOn = 3;
  using T               = ThrowingCopy<ThrowOn>;
  test_exception_safety_throwing_copy<ThrowOn, /*Size=*/5>([](T* from, T* to) {
    Container<T> c;
    c.append_range(std::ranges::subrange(from, to));
  });
#endif
}

template <template <class...> class Container, class T>
void test_append_range_exception_safety_throwing_allocator() {
#if !defined(TEST_HAS_NO_EXCEPTIONS)
  T in[] = {0, 1};

  try {
    ThrowingAllocator<T> alloc;

    globalMemCounter.reset();
    Container<T, ThrowingAllocator<T>> c(alloc);
    c.append_range(in);
    assert(false); // The function call above should throw.

  } catch (int) {
    assert(globalMemCounter.new_called == globalMemCounter.delete_called);
  }
#endif
}

template <template <class...> class Container>
void test_assign_range_exception_safety_throwing_copy() {
#if !defined(TEST_HAS_NO_EXCEPTIONS)
  constexpr int ThrowOn = 3;
  using T               = ThrowingCopy<ThrowOn>;
  test_exception_safety_throwing_copy<ThrowOn, /*Size=*/5>([](T* from, T* to) {
    Container<T> c;
    c.assign_range(std::ranges::subrange(from, to));
  });
#endif
}

template <template <class...> class Container, class T>
void test_assign_range_exception_safety_throwing_allocator() {
#if !defined(TEST_HAS_NO_EXCEPTIONS)
  T in[] = {0, 1};

  try {
    ThrowingAllocator<T> alloc;

    globalMemCounter.reset();
    Container<T, ThrowingAllocator<T>> c(alloc);
    c.assign_range(in);
    assert(false); // The function call above should throw.

  } catch (int) {
    assert(globalMemCounter.new_called == globalMemCounter.delete_called);
  }
#endif
}

#endif // SUPPORT_INSERT_RANGE_SEQUENCE_CONTAINERS_H