Page MenuHomePhabricator
Differential D110774 Diff 376727 libcxx/test/std/ranges/range.factories/range.iota.view/iterator/compare.pass.cpp

Changeset View

Standalone View

View Options

libcxx/test/std/ranges/range.factories/range.iota.view/iterator/compare.pass.cpp

//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// UNSUPPORTED: c++03, c++11, c++14, c++17 // UNSUPPORTED: c++03, c++11, c++14, c++17
// UNSUPPORTED: libcpp-no-concepts // UNSUPPORTED: libcpp-no-concepts
// UNSUPPORTED: libcpp-has-no-incomplete-ranges // UNSUPPORTED: libcpp-has-no-incomplete-ranges
// friend constexpr bool operator<(const iterator& x, const iterator& y) // iota_view::<iterator>::operator{<,>,<=,>=,==,!=,<=>}
// requires totally_ordered<W>;
// friend constexpr bool operator>(const iterator& x, const iterator& y)
// requires totally_ordered<W>;
// friend constexpr bool operator<=(const iterator& x, const iterator& y)
// requires totally_ordered<W>;
// friend constexpr bool operator>=(const iterator& x, const iterator& y)
// requires totally_ordered<W>;
// friend constexpr bool operator==(const iterator& x, const iterator& y)
// requires equality_comparable<W>;
// TODO: test spaceship operator once it's implemented.
#include <ranges> #include <ranges>
#include <cassert> #include <compare>
#include "test_macros.h" #include "test_macros.h"
#include "test_iterators.h"
#include "../types.h" #include "../types.h"
constexpr bool test() { constexpr bool test() {
{ {
const std::ranges::iota_view<int> io(0); // Test `int`, which has operator<=>; the iota iterator should also have operator<=>.
assert( io.begin() == io.begin() ); using R = std::ranges::iota_view<int>;
assert( io.begin() != std::ranges::next(io.begin())); static_assert(std::three_way_comparable<std::ranges::iterator_t<R>>);
assert( io.begin() < std::ranges::next(io.begin()));
assert(std::ranges::next(io.begin()) > io.begin() ); std::same_as<R> auto r = std::views::iota(42);
assert( io.begin() <= std::ranges::next(io.begin())); auto iter1 = r.begin();
assert(std::ranges::next(io.begin()) >= io.begin() ); auto iter2 = iter1 + 1;
assert( io.begin() <= io.begin() );
assert( io.begin() >= io.begin() ); assert(!(iter1 < iter1)); assert(iter1 < iter2); assert(!(iter2 < iter1));
} assert(iter1 <= iter1); assert(iter1 <= iter2); assert(!(iter2 <= iter1));
{ assert(!(iter1 > iter1)); assert(!(iter1 > iter2)); assert(iter2 > iter1);
std::ranges::iota_view<int> io(0); assert(iter1 >= iter1); assert(!(iter1 >= iter2)); assert(iter2 >= iter1);
assert( io.begin() == io.begin() ); assert(iter1 == iter1); assert(!(iter1 == iter2)); assert(iter2 == iter2);
assert( io.begin() != std::ranges::next(io.begin())); assert(!(iter1 != iter1)); assert(iter1 != iter2); assert(!(iter2 != iter2));
assert( io.begin() < std::ranges::next(io.begin()));
assert(std::ranges::next(io.begin()) > io.begin() ); assert((iter1 <=> iter2) == std::strong_ordering::less);
assert( io.begin() <= std::ranges::next(io.begin())); assert((iter1 <=> iter1) == std::strong_ordering::equal);
assert(std::ranges::next(io.begin()) >= io.begin() ); assert((iter2 <=> iter1) == std::strong_ordering::greater);
assert( io.begin() <= io.begin() );
assert( io.begin() >= io.begin() );
} }
{ {
const std::ranges::iota_view<SomeInt> io(SomeInt(0)); // Test a new-school iterator with operator<=>; the iota iterator should also have operator<=>.
assert( io.begin() == io.begin() ); using It = three_way_contiguous_iterator<int*>;
assert( io.begin() != std::ranges::next(io.begin())); static_assert(std::three_way_comparable<It>);
assert( io.begin() < std::ranges::next(io.begin())); using R = std::ranges::iota_view<It>;
assert(std::ranges::next(io.begin()) > io.begin() ); static_assert(std::three_way_comparable<std::ranges::iterator_t<R>>);
assert( io.begin() <= std::ranges::next(io.begin()));
assert(std::ranges::next(io.begin()) >= io.begin() ); int a[] = {1,2,3};
assert( io.begin() <= io.begin() ); std::same_as<R> auto r = std::views::iota(It(a));
assert( io.begin() >= io.begin() ); auto iter1 = r.begin();
auto iter2 = iter1 + 1;
assert(!(iter1 < iter1)); assert(iter1 < iter2); assert(!(iter2 < iter1));
assert(iter1 <= iter1); assert(iter1 <= iter2); assert(!(iter2 <= iter1));
assert(!(iter1 > iter1)); assert(!(iter1 > iter2)); assert(iter2 > iter1);
assert(iter1 >= iter1); assert(!(iter1 >= iter2)); assert(iter2 >= iter1);
assert(iter1 == iter1); assert(!(iter1 == iter2)); assert(iter2 == iter2);
assert(!(iter1 != iter1)); assert(iter1 != iter2); assert(!(iter2 != iter2));
assert((iter1 <=> iter2) == std::strong_ordering::less);
assert((iter1 <=> iter1) == std::strong_ordering::equal);
assert((iter2 <=> iter1) == std::strong_ordering::greater);
} }
{ {
std::ranges::iota_view<SomeInt> io(SomeInt(0)); // Test an old-school iterator with no operator<=>; the iota iterator shouldn't have operator<=> either.
assert( io.begin() == io.begin() ); using It = random_access_iterator<int*>;
assert( io.begin() != std::ranges::next(io.begin())); static_assert(!std::three_way_comparable<It>);
assert( io.begin() < std::ranges::next(io.begin())); using R = std::ranges::iota_view<It>;
assert(std::ranges::next(io.begin()) > io.begin() ); static_assert(!std::three_way_comparable<std::ranges::iterator_t<R>>);
assert( io.begin() <= std::ranges::next(io.begin()));
assert(std::ranges::next(io.begin()) >= io.begin() ); int a[] = {1,2,3};
assert( io.begin() <= io.begin() ); std::same_as<R> auto r = std::views::iota(It(a));
assert( io.begin() >= io.begin() ); auto iter1 = r.begin();
auto iter2 = iter1 + 1;
assert(!(iter1 < iter1)); assert(iter1 < iter2); assert(!(iter2 < iter1));
assert(iter1 <= iter1); assert(iter1 <= iter2); assert(!(iter2 <= iter1));
assert(!(iter1 > iter1)); assert(!(iter1 > iter2)); assert(iter2 > iter1);
assert(iter1 >= iter1); assert(!(iter1 >= iter2)); assert(iter2 >= iter1);
assert(iter1 == iter1); assert(!(iter1 == iter2)); assert(iter2 == iter2);
assert(!(iter1 != iter1)); assert(iter1 != iter2); assert(!(iter2 != iter2));
} }
return true; return true;
} }
int main(int, char**) { int main(int, char**) {
test(); test();
static_assert(test()); static_assert(test());
return 0; return 0;
} }