test/std/algorithms/alg.nonmodifying/mismatch/ranges_mismatch.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
//
//===----------------------------------------------------------------------===//

// UNSUPPORTED: c++03, c++11, c++14, c++17

// template <input_iterator I1, sentinel_for<_I1> S1, input_iterator I2, sentinel_for<_I2> S2,
//           class Pred = ranges::equal_to, class Proj1 = identity, class Proj2 = identity>
//   requires indirectly_comparable<I1, I2, Pred, Proj1, Proj2>
// constexpr mismatch_result<_I1, _I2>
// ranges::mismatch()(I1 first1, S1 last1, I2 first2, S2 last2, Pred pred = {}, Proj1 proj1 = {}, Proj2 proj2 = {})

// template <input_range R1, input_range R2,
//           class Pred = ranges::equal_to, class Proj1 = identity, class Proj2 = identity>
//   requires indirectly_comparable<iterator_t<R1>, iterator_t<R2>, Pred, Proj1, Proj2>
// constexpr mismatch_result<borrowed_iterator_t<R1>, borrowed_iterator_t<R2>>
// ranges::mismatch(R1&& r1, R2&& r2, Pred pred = {}, Proj1 proj1 = {}, Proj2 proj2 = {})

#include <algorithm>
#include <array>
#include <cassert>
#include <functional>
#include <ranges>

#include "test_iterators.h"

template <class Iter1, class Iter2>
constexpr void test_iterators(Iter1 begin1, Iter1 end1, Iter2 begin2, Iter2 end2, int* expected1, int* expected2) {
  using Expected = std::ranges::mismatch_result<Iter1, Iter2>;
  std::same_as<Expected> auto ret = std::ranges::mismatch(std::move(begin1), sentinel_wrapper<Iter1>(std::move(end1)),
                                                          std::move(begin2), sentinel_wrapper<Iter2>(std::move(end2)));
  assert(base(ret.in1) == expected1);
  assert(base(ret.in2) == expected2);
}

template <class Iter1, class Iter2>
constexpr void test_iters() {
  int a[] = {1, 2, 3, 4, 5};
  int b[] = {1, 2, 3, 5, 4};

  test_iterators(Iter1(a), Iter1(a + 5), Iter2(b), Iter2(b + 5), a + 3, b + 3);
}

constexpr bool test() {
  test_iters<cpp17_input_iterator<int*>, cpp17_input_iterator<int*>>();
  test_iters<cpp17_input_iterator<int*>, cpp20_input_iterator<int*>>();
  test_iters<cpp17_input_iterator<int*>, forward_iterator<int*>>();
  test_iters<cpp17_input_iterator<int*>, bidirectional_iterator<int*>>();
  test_iters<cpp17_input_iterator<int*>, random_access_iterator<int*>>();
  test_iters<cpp17_input_iterator<int*>, contiguous_iterator<int*>>();
  test_iters<cpp17_input_iterator<int*>, int*>();

  test_iters<cpp20_input_iterator<int*>, cpp17_input_iterator<int*>>();
  test_iters<cpp20_input_iterator<int*>, cpp20_input_iterator<int*>>();
  test_iters<cpp20_input_iterator<int*>, forward_iterator<int*>>();
  test_iters<cpp20_input_iterator<int*>, bidirectional_iterator<int*>>();
  test_iters<cpp20_input_iterator<int*>, random_access_iterator<int*>>();
  test_iters<cpp20_input_iterator<int*>, contiguous_iterator<int*>>();
  test_iters<cpp20_input_iterator<int*>, int*>();

  test_iters<forward_iterator<int*>, cpp17_input_iterator<int*>>();
  test_iters<forward_iterator<int*>, cpp20_input_iterator<int*>>();
  test_iters<forward_iterator<int*>, forward_iterator<int*>>();
  test_iters<forward_iterator<int*>, bidirectional_iterator<int*>>();
  test_iters<forward_iterator<int*>, random_access_iterator<int*>>();
  test_iters<forward_iterator<int*>, contiguous_iterator<int*>>();
  test_iters<forward_iterator<int*>, int*>();

  test_iters<bidirectional_iterator<int*>, cpp17_input_iterator<int*>>();
  test_iters<bidirectional_iterator<int*>, cpp20_input_iterator<int*>>();
  test_iters<bidirectional_iterator<int*>, forward_iterator<int*>>();
  test_iters<bidirectional_iterator<int*>, bidirectional_iterator<int*>>();
  test_iters<bidirectional_iterator<int*>, random_access_iterator<int*>>();
  test_iters<bidirectional_iterator<int*>, contiguous_iterator<int*>>();
  test_iters<bidirectional_iterator<int*>, int*>();

  test_iters<random_access_iterator<int*>, cpp17_input_iterator<int*>>();
  test_iters<random_access_iterator<int*>, cpp20_input_iterator<int*>>();
  test_iters<random_access_iterator<int*>, forward_iterator<int*>>();
  test_iters<random_access_iterator<int*>, bidirectional_iterator<int*>>();
  test_iters<random_access_iterator<int*>, random_access_iterator<int*>>();
  test_iters<random_access_iterator<int*>, contiguous_iterator<int*>>();
  test_iters<random_access_iterator<int*>, int*>();

  test_iters<contiguous_iterator<int*>, cpp17_input_iterator<int*>>();
  test_iters<contiguous_iterator<int*>, cpp20_input_iterator<int*>>();
  test_iters<contiguous_iterator<int*>, forward_iterator<int*>>();
  test_iters<contiguous_iterator<int*>, bidirectional_iterator<int*>>();
  test_iters<contiguous_iterator<int*>, random_access_iterator<int*>>();
  test_iters<contiguous_iterator<int*>, contiguous_iterator<int*>>();
  test_iters<contiguous_iterator<int*>, int*>();

  test_iters<int*, cpp17_input_iterator<int*>>();
  test_iters<int*, cpp20_input_iterator<int*>>();
  test_iters<int*, forward_iterator<int*>>();
  test_iters<int*, bidirectional_iterator<int*>>();
  test_iters<int*, random_access_iterator<int*>>();
  test_iters<int*, contiguous_iterator<int*>>();
  test_iters<int*, int*>();

  { // test with a range
    std::array<int, 5> a = {1, 2, 3, 4, 5};
    std::array<int, 5> b = {1, 2, 3, 5, 4};
    using Expected = std::ranges::mismatch_result<std::array<int, 5>::iterator, std::array<int, 5>::iterator>;
    std::same_as<Expected> auto ret = std::ranges::mismatch(a, b);
    assert(ret.in1 == a.begin() + 3);
    assert(ret.in2 == b.begin() + 3);
  }

  { // test with non-iterator sentinel
    int a[] = {1, 2, 3, 4, 5};
    int b[] = {1, 2, 3, 5, 4};

    using Iter = int*;
    using Sentinel = sentinel_wrapper<Iter>;
    using Expected = std::ranges::mismatch_result<Iter, Iter>;

    std::same_as<Expected> auto r = std::ranges::mismatch(Iter(a), Sentinel(a + 5), Iter(b), Sentinel(b + 5));
    assert(r.in1 == a + 3);
    assert(r.in2 == b + 3);
  }

  { // test with different array sizes
    {
      int a[] = {1, 2, 3};
      int b[] = {1, 2};
      test_iterators(a, a + 3, b, b + 2, a + 2, b + 2);
      using Expected = std::ranges::mismatch_result<int*, int*>;
      std::same_as<Expected> auto ret = std::ranges::mismatch(a, b);
      assert(ret.in1 == a + 2);
      assert(ret.in2 == b + 2);
    }
    {
      int a[] = {1, 2};
      int b[] = {1, 2, 3};
      test_iterators(a, a + 2, b, b + 3, a + 2, b + 2);
      using Expected = std::ranges::mismatch_result<int*, int*>;
      std::same_as<Expected> auto ret = std::ranges::mismatch(a, b);
      assert(ret.in1 == a + 2);
      assert(ret.in2 == b + 2);
    }
  }

  { // test with borrowed ranges
    int r1[] = {1, 2, 3, 4, 5};
    int r2[] = {1, 2, 3, 5, 4};

    using Expected = std::ranges::mismatch_result<int*, int*>;
    {
      std::same_as<Expected> auto ret = std::ranges::mismatch(r1, std::views::all(r2));
      assert(ret.in1 == r1 + 3);
      assert(ret.in2 == r2 + 3);
    }
    {
      std::same_as<Expected> auto ret = std::ranges::mismatch(std::views::all(r1), r2);
      assert(ret.in1 == r1 + 3);
      assert(ret.in2 == r2 + 3);
    }
    {
      std::same_as<Expected> auto ret = std::ranges::mismatch(std::views::all(r1), std::views::all(r2));
      assert(ret.in1 == r1 + 3);
      assert(ret.in2 == r2 + 3);
    }
  }

  { // test structured bindings
    int a[] = {1, 2, 3, 4};
    int b[] = {1, 2, 4, 8, 16};
    auto [ai, bi] = std::ranges::mismatch(a, b);
    assert(ai == a + 2);
    assert(bi == b + 2);
    auto [aj, bj] = std::ranges::mismatch(a, a+4, b, b+5);
    assert(aj == a + 2);
    assert(bj == b + 2);
  }

  { // test predicate
    {
      int a[] = {7, 6, 9, 3, 5, 1, 2, 4};
      int b[] = {6, 5, 8, 2, 5, 1, 2, 4};
      auto ret = std::ranges::mismatch(a, a + 8, b, b + 8, std::ranges::greater{});
      assert(ret.in1 == a + 4);
      assert(ret.in2 == b + 4);
      assert(*ret.in1 == 5);
      assert(*ret.in2 == 5);
    }

    {
      int a[] = {7, 6, 9, 3, 5, 1, 2, 4};
      int b[] = {6, 5, 8, 2, 5, 1, 2, 4};
      auto ret = std::ranges::mismatch(a, b, std::ranges::greater{});
      assert(ret.in1 == a + 4);
      assert(ret.in2 == b + 4);
      assert(*ret.in1 == 5);
      assert(*ret.in2 == 5);
    }
  }

  { // test projection
    {
      int a[] = {7, 6, 9, 3, 5, 1, 2, 4};
      int b[] = {6, 5, 8, 2, 5, 1, 2, 4};
      auto ret = std::ranges::mismatch(a, b,
                                       std::ranges::greater{},
                                       [](int i) { return i == 5 ? +100 : i; },
                                       [](int i) { return i == 5 ? -100 : i; });
      assert(ret.in1 == a + 5);
      assert(ret.in2 == b + 5);
      assert(*ret.in1 == 1);
      assert(*ret.in2 == 1);
    }
    {
      int a[] = {7, 6, 9, 3, 5, 1, 2, 4};
      auto ret = std::ranges::mismatch(a, a,
                                       std::less<double>{},
                                       [](int i) { return i * 1.01; },
                                       [c = 0](int i) mutable { return c++ < 5 ? i * 1.02 : i; });
      assert(ret.in1 == a + 5);
      assert(ret.in2 == a + 5);
      assert(*ret.in1 == 1);
      assert(*ret.in2 == 1);
    }
    {
      int a[] = {7, 6, 9, 3, 5, 1, 2, 4};
      int b[] = {6, 5, 8, 2, 5, 1, 2, 4};
      auto ret = std::ranges::mismatch(a, a + 8, b, b + 8,
                                       std::ranges::greater{},
                                       [](int i) { return i == 5 ? +100 : i; },
                                       [](int i) { return i == 5 ? -100 : i; });
      assert(ret.in1 == a + 5);
      assert(ret.in2 == b + 5);
      assert(*ret.in1 == 1);
      assert(*ret.in2 == 1);
    }
    {
      int a[] = {7, 6, 9, 3, 5, 1, 2, 4};
      auto ret = std::ranges::mismatch(a, a + 8, a, a + 8,
                                       std::less<double>{},
                                       [](int i) { return i * 1.01; },
                                       [c = 0](int i) mutable { return c++ < 5 ? i * 1.02 : i; });
      assert(ret.in1 == a + 5);
      assert(ret.in2 == a + 5);
      assert(*ret.in1 == 1);
      assert(*ret.in2 == 1);
    }
  }

  { // test predicate and projection call count
    {
      int pred_count = 0;
      int proj1_count = 0;
      int proj2_count = 0;
      int a[] = {7, 6, 9, 3, 5, 1, 2, 4};
      auto ret = std::ranges::mismatch(a, a,
                                       [&](int lhs, int rhs) { ++pred_count; return lhs == rhs; },
                                       [&](int i) { ++proj1_count; return i; },
                                       [&](int i) { ++proj2_count; return i; });
      assert(ret.in1 == a + 8);
      assert(ret.in2 == a + 8);
      assert(pred_count == 8);
      assert(proj1_count == 8);
      assert(proj2_count == 8);
    }
    {
      int pred_count = 0;
      int proj1_count = 0;
      int proj2_count = 0;
      int a[] = {7, 6, 9, 3, 5, 1, 2, 4};
      auto ret = std::ranges::mismatch(a, a + 8, a, a + 8,
                                       [&](int lhs, int rhs) { ++pred_count; return lhs == rhs; },
                                       [&](int i) { ++proj1_count; return i; },
                                       [&](int i) { ++proj2_count; return i; });
      assert(ret.in1 == a + 8);
      assert(ret.in2 == a + 8);
      assert(pred_count == 8);
      assert(proj1_count == 8);
      assert(proj2_count == 8);
    }
  }

  return true;
}

int main(int, char**) {
  test();
  static_assert(test());

  return 0;
}