libcxx/test/std/iterators/predef.iterators/iterators.common/eq.pass.cpp

   1 //===----------------------------------------------------------------------===//
   2 //
   3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
   4 // See https://llvm.org/LICENSE.txt for license information.
   5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
   6 //
   7 //===----------------------------------------------------------------------===//
   8
   9 // UNSUPPORTED: c++03, c++11, c++14, c++17
  10
  11 // template<class I2, sentinel_for<I> S2>
  12 //   requires sentinel_for<S, I2>
  13 // friend bool operator==(
  14 //   const common_iterator& x, const common_iterator<I2, S2>& y);
  15 // template<class I2, sentinel_for<I> S2>
  16 //   requires sentinel_for<S, I2> && equality_comparable_with<I, I2>
  17 // friend bool operator==(
  18 //   const common_iterator& x, const common_iterator<I2, S2>& y);
  19
  20 #include <iterator>
  21 #include <cassert>
  22
  23 #include "test_macros.h"
  24 #include "types.h"
  25
  26 void test() {
  27   int buffer[8] = {1, 2, 3, 4, 5, 6, 7, 8};
  28
  29   {
  30     auto iter1 = simple_iterator<int*>(buffer);
  31     auto commonIter1 = std::common_iterator<decltype(iter1), sentinel_type<int*>>(iter1);
  32     auto commonSent1 = std::common_iterator<decltype(iter1), sentinel_type<int*>>(sentinel_type<int*>{buffer + 8});
  33
  34     const auto commonIter2 = std::common_iterator<decltype(iter1), sentinel_type<int*>>(iter1);
  35     const auto commonSent2 = std::common_iterator<decltype(iter1), sentinel_type<int*>>(sentinel_type<int*>{buffer + 8});
  36
  37     assert(commonIter1 != commonSent1);
  38     assert(commonIter2 != commonSent2);
  39     assert(commonSent1 != commonIter1);
  40     assert(commonSent2 != commonIter2);
  41
  42     for (auto i = 1; commonIter1 != commonSent1; ++i) {
  43       assert(*(commonIter1++) == i);
  44     }
  45     assert(commonIter1 == commonSent1);
  46     assert(commonSent1 == commonIter1);
  47   }
  48   {
  49     auto iter1 = value_iterator<int*>(buffer);
  50     auto commonIter1 = std::common_iterator<decltype(iter1), sentinel_type<int*>>(iter1);
  51     auto commonSent1 = std::common_iterator<decltype(iter1), sentinel_type<int*>>(sentinel_type<int*>{buffer + 8});
  52
  53     const auto commonIter2 = std::common_iterator<decltype(iter1), sentinel_type<int*>>(iter1);
  54     const auto commonSent2 = std::common_iterator<decltype(iter1), sentinel_type<int*>>(sentinel_type<int*>{buffer + 8});
  55
  56     assert(commonIter1 != commonSent1);
  57     assert(commonIter2 != commonSent2);
  58     assert(commonSent1 != commonIter1);
  59     assert(commonSent2 != commonIter2);
  60
  61     for (auto i = 1; commonIter1 != commonSent1; ++i) {
  62       assert(*(commonIter1++) == i);
  63     }
  64     assert(commonIter1 == commonSent1);
  65     assert(commonSent1 == commonIter1);
  66   }
  67   {
  68     auto iter1 = simple_iterator<int*>(buffer);
  69     auto iter2 = comparable_iterator<int*>(buffer);
  70     auto commonIter1 = std::common_iterator<decltype(iter1), sentinel_type<int*>>(iter1);
  71     auto commonSent1 = std::common_iterator<decltype(iter1), sentinel_type<int*>>(sentinel_type<int*>{buffer + 8});
  72
  73     const auto commonIter2 = std::common_iterator<decltype(iter2), sentinel_type<int*>>(iter2);
  74     const auto commonSent2 = std::common_iterator<decltype(iter2), sentinel_type<int*>>(sentinel_type<int*>{buffer + 8});
  75
  76     assert(commonIter1 == commonIter2);
  77     assert(commonSent1 != commonIter2);
  78     assert(commonSent1 == commonSent2);
  79     assert(commonSent2 == commonSent1);
  80
  81     assert(commonIter1 != commonSent1);
  82     assert(commonIter2 != commonSent2);
  83     assert(commonSent1 != commonIter1);
  84     assert(commonSent2 != commonIter2);
  85
  86     assert(commonIter1 == commonIter2);
  87     assert(commonIter2 == commonIter1);
  88
  89     for (auto i = 1; commonIter1 != commonSent1; ++i) {
  90       assert(*(commonIter1++) == i);
  91     }
  92     assert(commonIter1 == commonSent1);
  93     assert(commonSent1 == commonIter1);
  94
  95     // This check may *seem* incorrect (our iterators point to two completely different
  96     // elements of buffer). However, this is actually what the Standard wants.
  97     // See https://eel.is/c++draft/iterators.common#common.iter.cmp-2.
  98     assert(commonIter1 == commonIter2);
  99   }
 100   {
 101     auto iter1 = cpp17_input_iterator<int*>(buffer);
 102     auto commonIter1 = std::common_iterator<decltype(iter1), sentinel_type<int*>>(iter1);
 103     auto commonSent1 = std::common_iterator<decltype(iter1), sentinel_type<int*>>(sentinel_type<int*>{buffer + 8});
 104
 105     const auto commonIter2 = std::common_iterator<decltype(iter1), sentinel_type<int*>>(iter1);
 106     const auto commonSent2 = std::common_iterator<decltype(iter1), sentinel_type<int*>>(sentinel_type<int*>{buffer + 8});
 107
 108     assert(commonIter1 != commonSent1);
 109     assert(commonIter2 != commonSent2);
 110     assert(commonSent1 != commonIter1);
 111     assert(commonSent2 != commonIter2);
 112
 113     for (auto i = 1; commonIter1 != commonSent1; ++i) {
 114       assert(*(commonIter1++) == i);
 115     }
 116     assert(commonIter1 == commonSent1);
 117     assert(commonSent1 == commonIter1);
 118   }
 119   {
 120     auto iter1 = forward_iterator<int*>(buffer);
 121     auto commonIter1 = std::common_iterator<decltype(iter1), sentinel_type<int*>>(iter1);
 122     auto commonSent1 = std::common_iterator<decltype(iter1), sentinel_type<int*>>(sentinel_type<int*>{buffer + 8});
 123
 124     const auto commonIter2 = std::common_iterator<decltype(iter1), sentinel_type<int*>>(iter1);
 125     const auto commonSent2 = std::common_iterator<decltype(iter1), sentinel_type<int*>>(sentinel_type<int*>{buffer + 8});
 126
 127     assert(commonIter1 != commonSent1);
 128     assert(commonIter2 != commonSent2);
 129     assert(commonSent1 != commonIter1);
 130     assert(commonSent2 != commonIter2);
 131
 132     for (auto i = 1; commonIter1 != commonSent1; ++i) {
 133       assert(*(commonIter1++) == i);
 134     }
 135     assert(commonIter1 == commonSent1);
 136     assert(commonSent1 == commonIter1);
 137   }
 138   {
 139     auto iter1 = random_access_iterator<int*>(buffer);
 140     auto commonIter1 = std::common_iterator<decltype(iter1), sentinel_type<int*>>(iter1);
 141     auto commonSent1 = std::common_iterator<decltype(iter1), sentinel_type<int*>>(sentinel_type<int*>{buffer + 8});
 142
 143     const auto commonIter2 = std::common_iterator<decltype(iter1), sentinel_type<int*>>(iter1);
 144     const auto commonSent2 = std::common_iterator<decltype(iter1), sentinel_type<int*>>(sentinel_type<int*>{buffer + 8});
 145
 146     assert(commonIter1 != commonSent1);
 147     assert(commonIter2 != commonSent2);
 148     assert(commonSent1 != commonIter1);
 149     assert(commonSent2 != commonIter2);
 150
 151     assert(commonSent1 == commonSent2);
 152     assert(commonSent2 == commonSent1);
 153
 154     for (auto i = 1; commonIter1 != commonSent1; ++i) {
 155       assert(*(commonIter1++) == i);
 156     }
 157     assert(commonIter1 == commonSent1);
 158     assert(commonSent1 == commonIter1);
 159   }
 160 }
 161
 162 int main(int, char**) {
 163   test();
 164
 165   return 0;
 166 }