//===----------------------------------------------------------------------===//
//
// 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
#include "MoveOnly.h"
#include "test_iterators.h"
#include <cassert>
constexpr void testProxy() {
// constructor value
{
Proxy<int> p{5};
assert(p.data == 5);
}
// constructor reference
{
int i = 5;
Proxy<int&> p{i};
assert(&p.data == &i);
}
// constructor conversion
{
int i = 5;
Proxy<int&> p1{i};
Proxy<int> p2 = p1;
assert(p2.data == 5);
Proxy<int&> p3{p2};
assert(&(p3.data) == &(p2.data));
MoveOnly m1{8};
Proxy<MoveOnly&&> p4 = std::move(m1);
Proxy<MoveOnly> p5 = std::move(p4);
assert(p5.data.get() == 8);
}
// assignment
{
Proxy<int> p1{5};
Proxy<int> p2{6};
p1 = p2;
assert(p1.data == 6);
MoveOnly m1{8};
Proxy<MoveOnly&&> p3 = std::move(m1);
Proxy<MoveOnly> p4{MoveOnly{9}};
p4 = std::move(p3);
assert(p4.data.get() == 8);
// `T` is a reference type.
int i = 5, j = 6, k = 7, x = 8;
Proxy<int&> p5{i};
// `Other` is a prvalue.
p5 = Proxy<int&>{j};
assert(p5.data == 6);
// `Other` is a const lvalue.
const Proxy<int&> p_ref{k};
p5 = p_ref;
assert(p5.data == 7);
// `Other` is an xvalue.
Proxy<int&> px{x};
p5 = std::move(px);
assert(p5.data == 8);
}
// const assignment
{
int i = 5;
int j = 6;
const Proxy<int&> p1{i};
const Proxy<int&> p2{j};
p1 = p2;
assert(i == 6);
MoveOnly m1{8};
MoveOnly m2{9};
Proxy<MoveOnly&&> p3 = std::move(m1);
const Proxy<MoveOnly&&> p4 = std::move(m2);
p4 = std::move(p3);
assert(p4.data.get() == 8);
}
// compare
{
Proxy<int> p1{5};
Proxy<int> p2{6};
assert(p1 != p2);
assert(p1 < p2);
// Comparing `T` and `T&`.
int i = 5, j = 6;
Proxy<int&> p_ref{i};
Proxy<const int&> p_cref{j};
assert(p1 == p_ref);
assert(p2 == p_cref);
assert(p_ref == p1);
assert(p_cref == p2);
assert(p_ref == p_ref);
assert(p_cref == p_cref);
assert(p_ref != p_cref);
}
}
static_assert(std::input_iterator<ProxyIterator<cpp20_input_iterator<int*>>>);
static_assert(!std::forward_iterator<ProxyIterator<cpp20_input_iterator<int*>>>);
static_assert(std::forward_iterator<ProxyIterator<forward_iterator<int*>>>);
static_assert(!std::bidirectional_iterator<ProxyIterator<forward_iterator<int*>>>);
static_assert(std::bidirectional_iterator<ProxyIterator<bidirectional_iterator<int*>>>);
static_assert(!std::random_access_iterator<ProxyIterator<bidirectional_iterator<int*>>>);
static_assert(std::random_access_iterator<ProxyIterator<random_access_iterator<int*>>>);
static_assert(!std::contiguous_iterator<ProxyIterator<random_access_iterator<int*>>>);
static_assert(std::random_access_iterator<ProxyIterator<contiguous_iterator<int*>>>);
static_assert(!std::contiguous_iterator<ProxyIterator<contiguous_iterator<int*>>>);
template <class Iter>
constexpr void testInputIteratorOperation() {
int data[] = {1, 2};
ProxyIterator<Iter> iter{Iter{data}};
sentinel_wrapper<ProxyIterator<Iter>> sent{ProxyIterator<Iter>{Iter{data + 2}}};
std::same_as<Proxy<int&>> decltype(auto) result = *iter;
assert(result.data == 1);
auto& iter2 = ++iter;
static_assert(std::is_same_v<decltype(++iter), ProxyIterator<Iter>&>);
assert(&iter2 == &iter);
assert((*iter).data == 2);
++iter;
assert(iter == sent);
}
template <class Iter>
constexpr void testForwardIteratorOperation() {
int data[] = {1, 2};
ProxyIterator<Iter> iter{Iter{data}};
std::same_as<ProxyIterator<Iter>> decltype(auto) it2 = iter++;
assert((*it2).data == 1);
assert((*iter).data == 2);
}
template <class Iter>
constexpr void testBidirectionalIteratorOperation() {
int data[] = {1, 2};
ProxyIterator<Iter> iter{Iter{data}};
++iter;
assert((*iter).data == 2);
auto& iter2 = --iter;
static_assert(std::is_same_v<decltype(--iter), ProxyIterator<Iter>&>);
assert(&iter2 == &iter);
assert((*iter).data == 1);
++iter;
std::same_as<ProxyIterator<Iter>> decltype(auto) iter3 = iter--;
assert((*iter).data == 1);
assert((*iter3).data == 2);
}
template <class Iter>
constexpr void testRandomAccessIteratorOperation() {
int data[] = {1, 2, 3, 4, 5};
ProxyIterator<Iter> iter{Iter{data}};
auto& iter2 = iter += 2;
static_assert(std::is_same_v<decltype(iter += 2), ProxyIterator<Iter>&>);
assert(&iter2 == &iter);
assert((*iter).data == 3);
auto& iter3 = iter -= 1;
static_assert(std::is_same_v<decltype(iter -= 1), ProxyIterator<Iter>&>);
assert(&iter3 == &iter);
assert((*iter).data == 2);
std::same_as<Proxy<int&>> decltype(auto) r = iter[2];
assert(r.data == 4);
std::same_as<ProxyIterator<Iter>> decltype(auto) iter4 = iter - 1;
assert((*iter4).data == 1);
std::same_as<ProxyIterator<Iter>> decltype(auto) iter5 = iter4 + 2;
assert((*iter5).data == 3);
std::same_as<ProxyIterator<Iter>> decltype(auto) iter6 = 3 + iter4;
assert((*iter6).data == 4);
std::same_as<std::iter_difference_t<Iter>> decltype(auto) n = iter6 - iter5;
assert(n == 1);
assert(iter4 < iter5);
assert(iter3 <= iter5);
assert(iter5 > iter4);
assert(iter6 >= iter4);
}
constexpr void testProxyIterator() {
// input iterator operations
{
testInputIteratorOperation<cpp20_input_iterator<int*>>();
testInputIteratorOperation<forward_iterator<int*>>();
testInputIteratorOperation<bidirectional_iterator<int*>>();
testInputIteratorOperation<random_access_iterator<int*>>();
testInputIteratorOperation<contiguous_iterator<int*>>();
}
// forward iterator operations
{
testForwardIteratorOperation<forward_iterator<int*>>();
testForwardIteratorOperation<bidirectional_iterator<int*>>();
testForwardIteratorOperation<random_access_iterator<int*>>();
testForwardIteratorOperation<contiguous_iterator<int*>>();
}
// bidirectional iterator operations
{
testBidirectionalIteratorOperation<bidirectional_iterator<int*>>();
testBidirectionalIteratorOperation<random_access_iterator<int*>>();
testBidirectionalIteratorOperation<contiguous_iterator<int*>>();
}
// random access iterator operations
{
testRandomAccessIteratorOperation<random_access_iterator<int*>>();
testRandomAccessIteratorOperation<contiguous_iterator<int*>>();
}
}
constexpr void testProxyRange() {
int data[] = {3, 4, 5};
ProxyRange r{data};
std::same_as<ProxyIterator<int*>> decltype(auto) it = std::ranges::begin(r);
assert((*it).data == 3);
it += 3;
assert(it == std::ranges::end(r));
}
template <class Iter>
concept StdMoveWorks = requires(std::iter_value_t<Iter> val, Iter iter) { val = std::move(*iter); };
static_assert(StdMoveWorks<MoveOnly*>);
static_assert(!StdMoveWorks<ProxyIterator<MoveOnly*>>);
// although this "works" but it actually creates a copy instead of move
static_assert(StdMoveWorks<ProxyIterator<int*>>);
using std::swap;
template <class Iter>
concept SwapWorks = requires(Iter iter1, Iter iter2) { swap(*iter1, *iter2); };
static_assert(SwapWorks<int*>);
static_assert(!SwapWorks<ProxyIterator<int*>>);
constexpr bool test() {
testProxy();
testProxyIterator();
testProxyRange();
// iter_move
{
MoveOnly data[] = {5, 6, 7};
ProxyRange r{data};
auto it = r.begin();
std::iter_value_t<decltype(it)> moved = std::ranges::iter_move(it);
assert(moved.data.get() == 5);
}
// iter_swap
{
MoveOnly data[] = {5, 6, 7};
ProxyRange r{data};
auto it1 = r.begin();
auto it2 = it1 + 2;
std::ranges::iter_swap(it1, it2);
assert(data[0].get() == 7);
assert(data[2].get() == 5);
}
return true;
}
int main(int, char**) {
test();
static_assert(test());
return 0;
}
Codebase Browser
llvm