Unnamed: 0
int64 0
0
| repo_id
stringlengths 5
186
| file_path
stringlengths 15
223
| content
stringlengths 1
32.8M
⌀ |
|---|---|---|---|
0 | repos/range-v3/test | repos/range-v3/test/utility/meta.cpp | /// \file meta.cpp Tests for Meta: a tiny metaprogramming library
// Meta: a tiny metaprogramming library
//
// Copyright Eric Niebler 2013-present
//
// Use, modification and distribution is subject to the
// Boost Software License, Version 1.0. (See accompanying
// file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt)
//
// Acknowledgements: Thanks for Paul Fultz for the suggestions that
// concepts can be ordinary Boolean metafunctions.
//
// Project home: https://github.com/ericniebler/range-v3
//
#include <tuple>
#include <meta/meta.hpp>
#include "../simple_test.hpp"
using namespace meta;
// An implementation of tuple_cat gives Range v3's meta-programming and list
// utilities a good workout. It's a good compiler stress test, too.
namespace tc_detail
{
template<typename Ret, typename... Is, typename... Ks, typename Tuples>
Ret tuple_cat_(list<Is...>, list<Ks...>, Tuples tpls)
{
return Ret{std::get<Ks::value>(std::get<Is::value>(tpls))...};
}
}
template<typename... Tuples,
typename Res = apply<quote<std::tuple>, concat<as_list<Tuples>...>>>
Res tuple_cat(Tuples &&... tpls)
{
static constexpr std::size_t N = sizeof...(Tuples);
// E.g. [0,0,0,2,2,2,3,3]
using inner = join<
transform<list<as_list<Tuples>...>,
transform<as_list<make_index_sequence<N>>, quote<id>>, quote<transform>>>;
// E.g. [0,1,2,0,1,2,0,1]
using outer = join<
transform<list<as_list<Tuples>...>,
compose<quote<as_list>, quote_i<std::size_t, make_index_sequence>, quote<size>>>>;
return tc_detail::tuple_cat_<Res>(inner{}, outer{},
std::forward_as_tuple(std::forward<Tuples>(tpls)...));
}
void test_tuple_cat()
{
std::tuple<int, short, long> t1;
std::tuple<> t2;
std::tuple<float, double, long double> t3;
std::tuple<void *, char *> t4;
auto x = ::tuple_cat(t1, t2, t3, t4);
using expected_type = std::tuple<int, short, long, float, double, long double, void *, char *>;
static_assert(std::is_same<decltype(x), expected_type>::value, "");
}
// Other misc tests
static_assert(std::is_same<reverse<list<int, short, double>>, list<double, short, int>>::value, "");
static_assert(std::is_same<reverse<list<int, short, double, float>>, list<float, double, short, int>>::value, "");
static_assert(std::is_same<reverse<list<int[1], int[2], int[3], int[4], int[5], int[6], int[7], int[8], int[9], int[10], int[11], int[12], int[13], int[14], int[15], int[16], int[17]>>, list<int[17], int[16], int[15], int[14], int[13], int[12], int[11], int[10], int[9], int[8], int[7], int[6], int[5], int[4], int[3], int[2], int[1]>>::value, "");
static_assert(all_of<list<int, short, long>, quote<std::is_integral>>::value, "");
static_assert(none_of<list<int, short, long>, quote<std::is_floating_point>>::value, "");
static_assert(!any_of<list<int, short, long>, quote<std::is_floating_point>>::value, "");
static_assert(any_of<list<int, short, long, float>, quote<std::is_floating_point>>::value, "");
static_assert(std::is_same<invoke<uncurry<curry<quote_trait<id>>>, std::tuple<int, short, double>>,
list<int, short, double>>::value,
"");
template<typename, typename, typename = void>
struct can_invoke_ : std::false_type
{
};
template<typename F, typename... As>
struct can_invoke_<F, meta::list<As...>, meta::void_<meta::invoke<F, As...>>> : std::true_type
{
};
template<typename F, typename... As>
struct can_invoke : can_invoke_<F, meta::list<As...>>
{
};
static_assert(can_invoke<meta::quote<std::pair>, int, int>::value, "");
// I'm guessing this failure is due to GCC #64970
// https://gcc.gnu.org/bugzilla/show_bug.cgi?id=64970
#if !defined(__GNUC__) || defined(__clang__) || __GNUC__ >= 5
static_assert(!can_invoke<meta::quote<std::pair>, int, int, int>::value, "");
#endif
// Sanity-check meta::lambda
using Lambda0 = lambda<_a, _b, std::pair<_a, _b>>;
using Lambda1 = lambda<_a, _b, std::pair<_b, _a>>;
using Lambda2 = lambda<_a, _b, std::pair<_b, std::pair<_a, _a>>>;
using Pair0 = invoke<Lambda0, int, short>;
using Pair1 = invoke<Lambda1, int, short>;
using Pair2 = invoke<Lambda2, int, short>;
static_assert(std::is_same<Pair0, std::pair<int, short>>::value, "");
static_assert(std::is_same<Pair1, std::pair<short, int>>::value, "");
static_assert(std::is_same<Pair2, std::pair<short, std::pair<int, int>>>::value, "");
// Not saying you should do it this way, but it's a good test.
namespace l = meta::lazy;
template<class L>
using cart_prod = reverse_fold<
L, list<list<>>,
lambda<
_a, _b,
l::join<l::transform<
_b, lambda<_c, l::join<l::transform<_a, lambda<_d, list<l::push_front<_d, _c>>>>>>>>>>;
using CartProd = cart_prod<meta::list<meta::list<int, short>, meta::list<float, double>>>;
static_assert(
std::is_same<CartProd, meta::list<meta::list<int, float>, meta::list<int, double>,
meta::list<short, float>, meta::list<short, double>>>::value,
"");
static_assert(can_invoke<lambda<_a, lazy::if_<std::is_integral<_a>, _a>>, int>::value, "");
// I'm guessing this failure is due to GCC #64970
// https://gcc.gnu.org/bugzilla/show_bug.cgi?id=64970
#if !defined(__GNUC__) || defined(__clang__) || __GNUC__ >= 5
static_assert(!can_invoke<lambda<_a, lazy::if_<std::is_integral<_a>, _a>>, float>::value, "");
#endif
template<typename List>
using rev = reverse_fold<List, list<>, lambda<_a, _b, defer<push_back, _a, _b>>>;
static_assert(std::is_same<rev<list<int, short, double>>, list<double, short, int>>::value, "");
using uncvref_fn = lambda<_a, l::_t<std::remove_cv<l::_t<std::remove_reference<_a>>>>>;
static_assert(std::is_same<invoke<uncvref_fn, int const &>, int>::value, "");
using L = list<int, short, int, float>;
static_assert(std::is_same<find<L, int>, list<int, short, int, float>>::value, "");
static_assert(std::is_same<find_if<L, bind_front<quote<std::is_same>, int>>, list<int, short, int, float>>::value, "");
static_assert(std::is_same<find_if<L, bind_front<quote<std::is_same>, double>>, list<>>::value, "");
static_assert(std::is_same<reverse_find<L, int>, list<int, float>>::value, "");
static_assert(std::is_same<reverse_find_if<L, bind_front<quote<std::is_same>, int>>, list<int, float>>::value, "");
static_assert(std::is_same<reverse_find_if<L, bind_front<quote<std::is_same>, double>>, list<>>::value, "");
struct check_integral
{
template<class T>
constexpr T operator()(T &&i) const
{
static_assert(std::is_integral<T>{}, "");
return i;
}
};
// Test for meta::let
template<typename T, typename List>
using find_index_ = let<
var<_a, List>, var<_b, lazy::find<_a, T>>,
lazy::if_<std::is_same<_b, list<>>, meta::npos, lazy::minus<lazy::size<_a>, lazy::size<_b>>>>;
static_assert(find_index_<int, list<short, int, float>>{} == 1, "");
static_assert(find_index_<double, list<short, int, float>>{} == meta::npos{}, "");
// Test that the unselected branch does not get evaluated:
template<typename T>
using test_lazy_if_ = let<lazy::if_<std::is_void<T>, T, defer<std::pair, T>>>;
static_assert(std::is_same<test_lazy_if_<void>, void>::value, "");
// Test that and_ gets short-circuited:
template<typename T>
using test_lazy_and_ = let<lazy::and_<std::is_void<T>, defer<std::is_convertible, T>>>;
static_assert(std::is_same<test_lazy_and_<int>, std::false_type>::value, "");
// Test that and_ gets short-circuited:
template<typename T>
using test_lazy_or_ = let<lazy::or_<std::is_void<T>, defer<std::is_convertible, T>>>;
static_assert(std::is_same<test_lazy_or_<void>, std::true_type>::value, "");
template<typename A, int B = 0>
struct lambda_test
{
};
template<typename N>
struct fact
: let<lazy::if_c<(N::value > 0), lazy::multiplies<N, defer<fact, dec<N>>>, meta::size_t<1>>>
{
};
static_assert(fact<meta::size_t<0>>::value == 1, "");
static_assert(fact<meta::size_t<1>>::value == 1, "");
static_assert(fact<meta::size_t<2>>::value == 2, "");
static_assert(fact<meta::size_t<3>>::value == 6, "");
static_assert(fact<meta::size_t<4>>::value == 24, "");
template<std::size_t N>
struct fact2
: let<lazy::if_c<(N > 0), lazy::multiplies<meta::size_t<N>, defer_i<std::size_t, fact2, N - 1>>,
meta::size_t<1>>>
{
};
static_assert(fact2<0>::value == 1, "");
static_assert(fact2<1>::value == 1, "");
static_assert(fact2<2>::value == 2, "");
static_assert(fact2<3>::value == 6, "");
static_assert(fact2<4>::value == 24, "");
template<typename N>
struct factorial
: let<if_c<N::value == 0, meta::size_t<1>, lazy::multiplies<N, factorial<lazy::dec<N>>>>>
{
};
static_assert(factorial<meta::size_t<0>>::value == 1, "");
static_assert(factorial<meta::size_t<1>>::value == 1, "");
static_assert(factorial<meta::size_t<2>>::value == 2, "");
static_assert(factorial<meta::size_t<3>>::value == 6, "");
static_assert(factorial<meta::size_t<4>>::value == 24, "");
int main()
{
// meta::sizeof_
static_assert(meta::sizeof_<int>{} == sizeof(int), "");
// meta::min
static_assert(meta::min<meta::size_t<0>, meta::size_t<1>>{} == 0, "");
static_assert(meta::min<meta::size_t<0>, meta::size_t<0>>{} == 0, "");
static_assert(meta::min<meta::size_t<1>, meta::size_t<0>>{} == 0, "");
// meta::max
static_assert(meta::max<meta::size_t<0>, meta::size_t<1>>{} == 1, "");
static_assert(meta::max<meta::size_t<1>, meta::size_t<0>>{} == 1, "");
static_assert(meta::max<meta::size_t<1>, meta::size_t<1>>{} == 1, "");
// meta::filter
{
using l = meta::list<int, double, short, float, long, char>;
using il = meta::list<int, short, long, char>;
using fl = meta::list<double, float>;
static_assert(std::is_same<il, meta::filter<l, meta::quote<std::is_integral>>>{}, "");
static_assert(std::is_same<fl, meta::filter<l, meta::quote<std::is_floating_point>>>{}, "");
}
// meta::for_each
{
using l = meta::list<int, long, short>;
constexpr auto r = meta::for_each(l{}, check_integral());
static_assert(std::is_same<meta::_t<std::remove_cv<decltype(r)>>, check_integral>::value,
"");
}
// meta::find_index
{
using l = meta::list<int, long, short, int>;
static_assert(meta::find_index<l, int>{} == 0, "");
static_assert(meta::find_index<l, long>{} == 1, "");
static_assert(meta::find_index<l, short>{} == 2, "");
static_assert(meta::find_index<l, double>{} == meta::npos{}, "");
static_assert(meta::find_index<l, float>{} == meta::npos{}, "");
using l2 = meta::list<>;
static_assert(meta::find_index<l2, double>{} == meta::npos{}, "");
using namespace meta::placeholders;
using lambda = meta::lambda<_a, _b, meta::lazy::find_index<_b, _a>>;
using result = meta::invoke<lambda, long, l>;
static_assert(result{} == 1, "");
}
// meta::reverse_find_index
{
using l = meta::list<int, long, short, int>;
static_assert(meta::reverse_find_index<l, int>{} == 3, "");
static_assert(meta::reverse_find_index<l, long>{} == 1, "");
static_assert(meta::reverse_find_index<l, short>{} == 2, "");
static_assert(meta::reverse_find_index<l, double>{} == meta::npos{}, "");
static_assert(meta::reverse_find_index<l, float>{} == meta::npos{}, "");
using l2 = meta::list<>;
static_assert(meta::reverse_find_index<l2, double>{} == meta::npos{}, "");
using lambda = meta::lambda<_a, _b, meta::lazy::reverse_find_index<_b, _a>>;
using result = meta::invoke<lambda, long, l>;
static_assert(result{} == 1, "");
}
// meta::count
{
using l = meta::list<int, long, short, int>;
static_assert(meta::count<l, int>{} == 2, "");
static_assert(meta::count<l, short>{} == 1, "");
static_assert(meta::count<l, double>{} == 0, "");
}
// meta::count_if
{
using l = meta::list<int, long, short, int>;
static_assert(meta::count_if<l, lambda<_a, std::is_same<_a, int>>>{} == 2, "");
static_assert(meta::count_if<l, lambda<_b, std::is_same<_b, short>>>{} == 1, "");
static_assert(meta::count_if<l, lambda<_c, std::is_same<_c, double>>>{} == 0, "");
}
// pathological lambda test
{
using X = invoke<lambda<_a, lambda_test<_a>>, int>;
static_assert(std::is_same<X, lambda_test<_a>>::value, "");
}
// meta::unique
{
using l = meta::list<int, short, int, double, short, double, double>;
static_assert(std::is_same<meta::unique<l>, list<int, short, double>>::value, "");
}
// meta::in
{
static_assert(in<list<int, int, short, float>, int>::value, "");
static_assert(in<list<int, int, short, float>, short>::value, "");
static_assert(in<list<int, int, short, float>, float>::value, "");
static_assert(!in<list<int, int, short, float>, double>::value, "");
}
// lambda with variadic placeholders
{
using X = invoke<lambda<_args, list<_args>>, int, short, double>;
static_assert(std::is_same<X, list<int, short, double>>::value, "");
using X2 = invoke<lambda<_a, lambda_test<_a>>, int>;
static_assert(std::is_same<X2, lambda_test<_a>>::value, "");
using Y = invoke<lambda<_args, defer<std::pair, _args>>, int, short>;
static_assert(std::is_same<Y, std::pair<int, short>>::value, "");
using Y2 = invoke<lambda<_args, list<_args, list<_args>>>, int, short>;
static_assert(std::is_same<Y2, list<int, short, list<int, short>>>::value, "");
using Z = invoke<lambda<_a, _args, list<int, _args, double, _a>>, short *, short, float>;
static_assert(std::is_same<Z, list<int, short, float, double, short *>>::value, "");
// Nesting variadic lambdas in non-variadic lambdas:
using A = invoke<lambda<_a, lazy::invoke<lambda<_b, _args, list<_args, _b>>, _a,
lazy::_t<std::add_pointer<_a>>,
lazy::_t<std::add_lvalue_reference<_a>>>>,
int>;
static_assert(std::is_same<A, list<int *, int &, int>>::value, "");
// Nesting non-variadic lambdas in variadic lambdas:
using B = invoke<lambda<_a, _args, lazy::invoke<lambda<_b, list<_b, _args, _a>>, _a>>, int,
short, double>;
static_assert(std::is_same<B, list<int, short, double, int>>::value, "");
// Nesting variadic lambdas in variadic lambdas:
using ZZ = invoke<
lambda<_a, _args_a,
lazy::invoke<lambda<_b, _args_b, list<_b, _a, list<_args_b>, list<_args_a>>>,
_args_a>>,
int, short, float, double>;
static_assert(
std::is_same<ZZ,
list<short, int, list<float, double>, list<short, float, double>>>::value,
"");
// I'm guessing this failure is due to GCC #64970
// https://gcc.gnu.org/bugzilla/show_bug.cgi?id=64970
#if !defined(__GNUC__) || defined(__clang__) || __GNUC__ >= 5
static_assert(!can_invoke<lambda<_args, defer<std::pair, _args>>, int>::value, "");
static_assert(!can_invoke<lambda<_args, defer<std::pair, _args>>, int, short, double>::value,
"");
static_assert(!can_invoke<lambda<_a, defer<std::pair, _a, _a>>, int, short>::value, "");
static_assert(!can_invoke<lambda<_a, _b, _c, _args, defer<std::pair, _a, _a>>>::value, "");
#endif
}
// Test for meta::sort
{
using L0 = list<char[5], char[3], char[2], char[6], char[1], char[5], char[10]>;
using L2 = meta::sort<L0, lambda<_a, _b, lazy::less<lazy::sizeof_<_a>, lazy::sizeof_<_b>>>>;
static_assert(
std::is_same<
L2, list<char[1], char[2], char[3], char[5], char[5], char[6], char[10]>>::value,
"");
}
// Check the _z user-defined literal:
static_assert(42_z == 42, "");
// Check integer_range
{
constexpr std::size_t a = meta::fold<meta::as_list<meta::integer_range<std::size_t, 0, 5>>,
meta::size_t<0>, meta::quote<meta::plus>>{};
static_assert(a == 10, "");
constexpr std::size_t b = meta::fold<meta::as_list<meta::integer_range<std::size_t, 5, 10>>,
meta::size_t<0>, meta::quote<meta::plus>>{};
static_assert(b == 35, "");
constexpr std::size_t c = meta::fold<meta::as_list<meta::integer_range<std::size_t, 0, 20>>,
meta::size_t<0>, meta::quote<meta::plus>>{};
static_assert(c == 190, "");
using d = meta::integer_range<std::size_t, 5, 10>;
static_assert(std::is_same<d, meta::integer_sequence<std::size_t, 5, 6, 7, 8, 9>>{}, "");
}
// Check reverse_fold
{
constexpr std::size_t a = meta::reverse_fold<meta::as_list<meta::integer_range<std::size_t, 0, 5>>,
meta::size_t<0>, meta::quote<meta::plus>>{};
static_assert(a == 10, "");
constexpr std::size_t b = meta::reverse_fold<meta::as_list<meta::integer_range<std::size_t, 5, 10>>,
meta::size_t<0>, meta::quote<meta::plus>>{};
static_assert(b == 35, "");
constexpr std::size_t c = meta::reverse_fold<meta::as_list<meta::integer_range<std::size_t, 0, 20>>,
meta::size_t<0>, meta::quote<meta::plus>>{};
static_assert(c == 190, "");
}
test_tuple_cat();
return ::test_result();
}
|
0 | repos/range-v3/test | repos/range-v3/test/utility/swap.cpp | // Range v3 library
//
// Copyright Eric Niebler 2013-present
//
// Use, modification and distribution is subject to the
// Boost Software License, Version 1.0. (See accompanying
// file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt)
//
// Acknowledgements: Thanks for Paul Fultz for the suggestions that
// concepts can be ordinary Boolean metafunctions.
//
// Project home: https://github.com/ericniebler/range-v3
//
#include <iostream>
#include <tuple>
#include <memory>
#include <vector>
#include <complex>
#include <concepts/concepts.hpp>
#include <range/v3/utility/swap.hpp>
#include <range/v3/view/zip.hpp>
#include <range/v3/range/conversion.hpp>
#include "../simple_test.hpp"
#include "../test_utils.hpp"
template<typename T>
struct S
{
T t;
};
int main()
{
int a=0,b=42;
ranges::swap(a,b);
CHECK(a == 42);
CHECK(b == 0);
CPP_assert(!ranges::swappable_with<std::pair<int,int>&&,std::pair<int,int>&&>);
CPP_assert(ranges::swappable_with<std::pair<int&,int&>&&,std::pair<int&,int&>&&>);
int c=24,d=82;
ranges::swap(std::tie(a,b),std::tie(c,d));
CHECK(a == 24);
CHECK(b == 82);
CHECK(c == 42);
CHECK(d == 0);
// Swap pairs of tuple proxies
int e=1,f=2,g=3,h=4;
ranges::swap(std::make_pair(std::tie(a,b), std::tie(c,d)), std::make_pair(std::tie(e,f), std::tie(g,h)));
CHECK(a == 1);
CHECK(b == 2);
CHECK(c == 3);
CHECK(d == 4);
CHECK(e == 24);
CHECK(f == 82);
CHECK(g == 42);
CHECK(h == 0);
#ifndef _LIBCPP_VERSION
// Swap tuples of pair proxies
ranges::swap(std::make_tuple(std::make_pair(std::ref(a),std::ref(b)), std::make_pair(std::ref(c),std::ref(d))),
std::make_tuple(std::make_pair(std::ref(e),std::ref(f)), std::make_pair(std::ref(g),std::ref(h))));
CHECK(a == 24);
CHECK(b == 82);
CHECK(c == 42);
CHECK(d == 0);
CHECK(e == 1);
CHECK(f == 2);
CHECK(g == 3);
CHECK(h == 4);
#endif
int aa=24,bb=82;
ranges::iter_swap(&aa, &bb);
CHECK(aa == 82);
CHECK(bb == 24);
std::unique_ptr<int> u0{new int{1}};
std::unique_ptr<int> u1{new int{2}};
int *p0 = u0.get();
int *p1 = u1.get();
ranges::iter_swap(&u0, &u1);
CHECK(u0.get() == p1);
CHECK(u1.get() == p0);
{
using namespace ranges;
auto v0 = to<std::vector<MoveOnlyString>>({"a","b","c"});
auto v1 = to<std::vector<MoveOnlyString>>({"x","y","z"});
auto rng = views::zip(v0, v1);
ranges::iter_swap(rng.begin(), rng.begin()+2);
::check_equal(v0, {"c","b","a"});
::check_equal(v1, {"z","y","x"});
}
{
using T = std::complex<float>;
T s,t;
ranges::swap(s,t);
}
{
using T = S<std::complex<float>>;
T s,t;
ranges::swap(s,t);
}
return ::test_result();
}
|
0 | repos/range-v3/test | repos/range-v3/test/iterator/diffmax_t.cpp | // Range v3 library
//
// Copyright Eric Niebler 2019-present
//
// Use, modification and distribution is subject to the
// Boost Software License, Version 1.0. (See accompanying
// file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt)
//
// Project home: https://github.com/ericniebler/range-v3
#include <range/v3/iterator/diffmax_t.hpp>
#include "../simple_test.hpp"
#include "../test_utils.hpp"
#include <iomanip>
#include <functional>
using ranges::detail::diffmax_t;
template<template<typename> class Op>
void check_1(std::ptrdiff_t a, std::ptrdiff_t b)
{
// std::cout << std::dec;
// std::cout << a << "&" << b << " == " << (a&b) << std::endl;
// std::cout << std::hex;
// std::cout << a << "&" << b << " == " << (a&b) << std::endl;
CHECK(Op<diffmax_t>{}(a, b) == Op<std::ptrdiff_t>{}(a, b));
}
template<>
void check_1<std::divides>(std::ptrdiff_t a, std::ptrdiff_t b)
{
if(b)
CHECK(std::divides<diffmax_t>{}(a, b) == std::divides<std::ptrdiff_t>{}(a, b));
}
template<>
void check_1<std::modulus>(std::ptrdiff_t a, std::ptrdiff_t b)
{
if(b)
CHECK(std::modulus<diffmax_t>{}(a, b) == std::modulus<std::ptrdiff_t>{}(a, b));
}
template<template<typename> class Op>
void check()
{
check_1<Op>(0, 0);
check_1<Op>(-1, 0);
check_1<Op>(0, -1);
check_1<Op>(1, 0);
check_1<Op>(0, 1);
check_1<Op>(1, 1);
check_1<Op>(-1, -1);
check_1<Op>(-5, -4);
check_1<Op>(-4, -5);
check_1<Op>(5, -4);
check_1<Op>(-4, 5);
check_1<Op>(-5, 4);
check_1<Op>(4, -5);
}
int main()
{
check<std::plus>();
check<std::minus>();
check<std::multiplies>();
check<std::divides>();
check<std::modulus>();
check<std::bit_and>();
check<std::bit_or>();
check<std::bit_xor>();
return test_result();
}
|
0 | repos/range-v3/test | repos/range-v3/test/iterator/counted_iterator.cpp | // Range v3 library
//
// Copyright Eric Niebler 2014-present
//
// Use, modification and distribution is subject to the
// Boost Software License, Version 1.0. (See accompanying
// file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt)
//
// Project home: https://github.com/ericniebler/range-v3
#include <range/v3/iterator/counted_iterator.hpp>
#include "../simple_test.hpp"
// iterator that models input_iterator (has void-returning postfix increment operator)
struct Iterator
{
using value_type = int;
using difference_type = int;
int counter = 0;
int operator*() const { return counter; }
Iterator& operator++() { ++counter; return *this; }
void operator++(int) { ++counter; }
bool operator==(const Iterator& rhs) const { return counter == rhs.counter; }
bool operator!=(const Iterator& rhs) const { return !(*this == rhs); }
};
int main()
{
CPP_assert(ranges::input_iterator<Iterator>);
auto cnt = ranges::counted_iterator<Iterator>(Iterator(), 1);
CHECK(*cnt == 0);
cnt++;
CHECK(cnt == ranges::default_sentinel);
return test_result();
}
|
0 | repos/range-v3/test | repos/range-v3/test/iterator/iterator.cpp | // Range v3 library
//
// Copyright Eric Niebler 2014, 2016
// Copyright Casey Carter 2016
//
// Use, modification and distribution is subject to the
// Boost Software License, Version 1.0. (See accompanying
// file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt)
//
// Project home: https://github.com/ericniebler/range-v3
#include <list>
#include <ostream>
#include <sstream>
#include <string>
#include <vector>
#include <meta/meta.hpp>
#include <range/v3/iterator/operations.hpp>
#include <range/v3/iterator/move_iterators.hpp>
#include <range/v3/iterator/insert_iterators.hpp>
#include <range/v3/iterator/stream_iterators.hpp>
#include <range/v3/algorithm/copy.hpp>
#include "../simple_test.hpp"
#include "../test_utils.hpp"
using namespace ranges;
struct MoveOnlyReadable
{
using value_type = std::unique_ptr<int>;
value_type operator*() const;
};
CPP_assert(indirectly_readable<MoveOnlyReadable>);
void test_insert_iterator()
{
CPP_assert(output_iterator<insert_iterator<std::vector<int>>, int&&>);
CPP_assert(!equality_comparable<insert_iterator<std::vector<int>>>);
std::vector<int> vi{5,6,7,8};
copy(std::initializer_list<int>{1,2,3,4}, inserter(vi, vi.begin()+2));
::check_equal(vi, {5,6,1,2,3,4,7,8});
}
void test_ostream_joiner()
{
std::ostringstream oss;
std::vector<int> vi{};
copy(vi, make_ostream_joiner(oss, ","));
::check_equal(oss.str(), std::string{""});
vi = {1,2,3,4};
copy(vi, make_ostream_joiner(oss, ","));
::check_equal(oss.str(), std::string{"1,2,3,4"});
}
void test_move_iterator()
{
std::vector<MoveOnlyString> in;
in.emplace_back("this");
in.emplace_back("is");
in.emplace_back("his");
in.emplace_back("face");
std::vector<MoveOnlyString> out;
auto first = ranges::make_move_iterator(in.begin());
using I = decltype(first);
CPP_assert(input_iterator<I>);
CPP_assert(!forward_iterator<I>);
CPP_assert(same_as<I, ranges::move_iterator<std::vector<MoveOnlyString>::iterator>>);
auto last = ranges::make_move_sentinel(in.end());
using S = decltype(last);
CPP_assert(sentinel_for<S, I>);
CPP_assert(sized_sentinel_for<I, I>);
CHECK((first - first) == 0);
CPP_assert(sized_sentinel_for<S, I>);
CHECK(static_cast<std::size_t>(last - first) == in.size());
ranges::copy(first, last, ranges::back_inserter(out));
::check_equal(in, {"","","",""});
::check_equal(out, {"this","is","his","face"});
}
template<class I>
using RI = std::reverse_iterator<I>;
void issue_420_regression()
{
// Verify that sized_sentinel_for<std::reverse_iterator<S>, std::reverse_iterator<I>>
// properly requires sized_sentinel_for<I, S>
CPP_assert(sized_sentinel_for<RI<int*>, RI<int*>>);
CPP_assert(!sized_sentinel_for<RI<int*>, RI<float*>>);
using BI = BidirectionalIterator<int*>;
CPP_assert(!sized_sentinel_for<RI<BI>, RI<BI>>);
}
struct value_type_tester_thingy {};
namespace ranges
{
template<>
struct indirectly_readable_traits<::value_type_tester_thingy>
{
using value_type = int;
};
}
template<typename T>
struct with_value_type { using value_type = T; };
template<typename T>
struct with_element_type { using element_type = T; };
// arrays of known bound
CPP_assert(same_as<int, ranges::indirectly_readable_traits<int[4]>::value_type>);
CPP_assert(same_as<int, ranges::indirectly_readable_traits<const int[4]>::value_type>);
CPP_assert(same_as<int*, ranges::indirectly_readable_traits<int*[4]>::value_type>);
CPP_assert(same_as<with_value_type<int>, ranges::indirectly_readable_traits<with_value_type<int>[4]>::value_type>);
#if !defined(__GNUC__) || defined(__clang__)
// arrays of unknown bound
CPP_assert(same_as<int, ranges::indirectly_readable_traits<int[]>::value_type>);
CPP_assert(same_as<int, ranges::indirectly_readable_traits<const int[]>::value_type>);
#endif
template<typename T>
using readable_traits_value_type_t = typename ranges::indirectly_readable_traits<T>::value_type;
template<typename T>
using readable_traits_value_type = meta::defer<readable_traits_value_type_t, T>;
// object pointer types
CPP_assert(same_as<int, ranges::indirectly_readable_traits<int*>::value_type>);
CPP_assert(same_as<int, ranges::indirectly_readable_traits<int*const>::value_type>);
CPP_assert(same_as<int, ranges::indirectly_readable_traits<int const*>::value_type>);
CPP_assert(same_as<int, ranges::indirectly_readable_traits<int const*const>::value_type>);
CPP_assert(same_as<int[4], ranges::indirectly_readable_traits<int(*)[4]>::value_type>);
CPP_assert(same_as<int[4], ranges::indirectly_readable_traits<const int(*)[4]>::value_type>);
struct incomplete;
CPP_assert(same_as<incomplete, ranges::indirectly_readable_traits<incomplete*>::value_type>);
static_assert(!meta::is_trait<readable_traits_value_type<void*>>::value, "");
static_assert(!meta::is_trait<readable_traits_value_type<void const*>>::value, "");
// class types with member value_type
CPP_assert(same_as<int, ranges::indirectly_readable_traits<with_value_type<int>>::value_type>);
CPP_assert(same_as<int, ranges::indirectly_readable_traits<with_value_type<int> const>::value_type>);
CPP_assert(same_as<int, ranges::indirectly_readable_traits<value_type_tester_thingy>::value_type>);
CPP_assert(same_as<int, ranges::indirectly_readable_traits<value_type_tester_thingy const>::value_type>);
CPP_assert(same_as<int[4], ranges::indirectly_readable_traits<with_value_type<int[4]>>::value_type>);
CPP_assert(same_as<int[4], ranges::indirectly_readable_traits<with_value_type<int[4]> const>::value_type>);
static_assert(!meta::is_trait<readable_traits_value_type<with_value_type<void>>>::value, "");
static_assert(!meta::is_trait<readable_traits_value_type<with_value_type<int(int)>>>::value, "");
static_assert(!meta::is_trait<readable_traits_value_type<with_value_type<int&>>>::value, "");
// class types with member element_type
CPP_assert(same_as<int, ranges::indirectly_readable_traits<with_element_type<int>>::value_type>);
CPP_assert(same_as<int, ranges::indirectly_readable_traits<with_element_type<int> const>::value_type>);
CPP_assert(same_as<int, ranges::indirectly_readable_traits<with_element_type<int const>>::value_type>);
CPP_assert(same_as<int[4], ranges::indirectly_readable_traits<with_element_type<int[4]>>::value_type>);
CPP_assert(same_as<int[4], ranges::indirectly_readable_traits<with_element_type<int[4]> const>::value_type>);
CPP_assert(same_as<int[4], ranges::indirectly_readable_traits<with_element_type<int const[4]>>::value_type>);
static_assert(!meta::is_trait<readable_traits_value_type<with_element_type<void>>>::value, "");
static_assert(!meta::is_trait<readable_traits_value_type<with_element_type<void const>>>::value, "");
static_assert(!meta::is_trait<readable_traits_value_type<with_element_type<void> const>>::value, "");
static_assert(!meta::is_trait<readable_traits_value_type<with_element_type<int(int)>>>::value, "");
static_assert(!meta::is_trait<readable_traits_value_type<with_element_type<int&>>>::value, "");
// cv-void
static_assert(!meta::is_trait<readable_traits_value_type<void>>::value, "");
static_assert(!meta::is_trait<readable_traits_value_type<void const>>::value, "");
// reference types
static_assert(!meta::is_trait<readable_traits_value_type<int&>>::value, "");
static_assert(!meta::is_trait<readable_traits_value_type<int&&>>::value, "");
static_assert(!meta::is_trait<readable_traits_value_type<int*&>>::value, "");
static_assert(!meta::is_trait<readable_traits_value_type<int*&&>>::value, "");
static_assert(!meta::is_trait<readable_traits_value_type<int(&)(int)>>::value, "");
static_assert(!meta::is_trait<readable_traits_value_type<std::ostream&>>::value, "");
CPP_assert(indirectly_swappable<int *, int *>);
CPP_assert(indirectly_movable<int const *, int *>);
CPP_assert(!indirectly_swappable<int const *, int const *>);
CPP_assert(!indirectly_movable<int const *, int const *>);
namespace Boost
{
struct S {}; // just to have a type from Boost namespace
template<typename I, typename D>
void advance(I&, D)
{}
}
// Regression test for https://github.com/ericniebler/range-v3/issues/845
void test_845()
{
std::list<std::pair<Boost::S, int>> v = { {Boost::S{}, 0} };
auto itr = v.begin();
ranges::advance(itr, 1); // Should not create ambiguity
}
// Test for https://github.com/ericniebler/range-v3/issues/1110
void test_1110()
{
// this should not trigger assertation error
std::vector<int> v = {1,2,3};
auto e = ranges::end(v);
ranges::advance(e, 0, ranges::begin(v));
}
// Test the deep integration with the STL
#if defined(RANGES_DEEP_STL_INTEGRATION) && RANGES_DEEP_STL_INTEGRATION
struct X
{
int& operator*() const;
X & operator++();
struct proxy { operator int() const; };
proxy operator++(int);
};
namespace std
{
template <>
struct iterator_traits<::X>
{
using value_type = int;
using reference = int&;
using pointer = int*;
using difference_type = ptrdiff_t;
using iterator_category = std::input_iterator_tag;
};
}
static_assert(ranges::input_iterator<X>, "");
struct Y
{
using value_type = int;
using difference_type = std::ptrdiff_t;
using iterator_category = std::bidirectional_iterator_tag;
using reference = int&;
using pointer = int*;
int& operator*() const noexcept;
};
static_assert(std::is_same<std::add_pointer_t<int&>, int*>::value, "");
struct Z
{
using difference_type = std::ptrdiff_t;
using iterator_category = std::bidirectional_iterator_tag;
int& operator*() const noexcept;
Z& operator++();
Z operator++(int);
bool operator==(Z) const;
bool operator!=(Z) const;
};
namespace ranges
{
template <>
struct indirectly_readable_traits<::Z>
{
using value_type = int;
};
}
// Looks like an STL2 forward iterator, but the conformance beyond
// input is "accidental".
struct WouldBeFwd
{
using value_type = struct S{ };
using difference_type = std::ptrdiff_t;
S & operator*() const;
WouldBeFwd& operator++();
WouldBeFwd operator++(int);
//S* operator->() const;
bool operator==(WouldBeFwd) const;
bool operator!=(WouldBeFwd) const;
};
namespace std
{
template <>
struct iterator_traits<::WouldBeFwd>
{
using value_type = ::WouldBeFwd::value_type;
using difference_type = ::WouldBeFwd::difference_type;
using reference = iter_reference_t<::WouldBeFwd>;
using pointer = add_pointer_t<reference>;
// Explicit opt-out of stl2's forward_iterator concept:
using iterator_category = std::input_iterator_tag; // STL1-style iterator category
};
}
// Looks like an STL2 bidirectional iterator, but the conformance beyond
// forward is "accidental".
struct WouldBeBidi
{
using value_type = struct S{ };
using difference_type = std::ptrdiff_t;
// using iterator_category = std::input_iterator_tag;
// using iterator_concept = std::forward_iterator_tag;
S operator*() const; // by value!
WouldBeBidi& operator++();
WouldBeBidi operator++(int);
WouldBeBidi& operator--();
WouldBeBidi operator--(int);
//S* operator->() const;
bool operator==(WouldBeBidi) const;
bool operator!=(WouldBeBidi) const;
};
namespace std
{
template <>
struct iterator_traits<::WouldBeBidi>
{
using value_type = ::WouldBeBidi::value_type;
using difference_type = ::WouldBeBidi::difference_type;
using reference = value_type;
using pointer = value_type*;
using iterator_category = std::input_iterator_tag; // STL1-style iterator category
// Explicit opt-out of stl2's bidirectional_iterator concept:
using iterator_concept = std::forward_iterator_tag; // STL2-style iterator category
};
}
struct OutIter
{
using difference_type = std::ptrdiff_t;
OutIter& operator=(int);
OutIter& operator*();
OutIter& operator++();
OutIter& operator++(int);
};
// proxy iterator
struct bool_iterator
{
using value_type = bool;
struct reference
{
operator bool() const { return true; }
reference();
reference(reference const &);
reference& operator=(reference);
reference& operator=(bool);
};
using difference_type = std::ptrdiff_t;
reference operator*() const;
bool_iterator& operator++();
bool_iterator operator++(int);
bool operator==(bool_iterator) const;
bool operator!=(bool_iterator) const;
friend reference iter_move(bool_iterator i) { return *i; }
friend void iter_swap(bool_iterator, bool_iterator) { }
};
void deep_integration_test()
{
using std::is_same;
using std::iterator_traits;
using ranges::iter_value_t;
using ranges::iter_difference_t;
static_assert(is_same<iter_difference_t<std::int_least16_t>, int>::value, "");
static_assert(is_same<iter_difference_t<std::uint_least16_t>, int>::value, "");
static_assert(is_same<iter_difference_t<std::int_least32_t>, std::int_least32_t>::value, "");
static_assert(is_same<iter_difference_t<std::uint_least32_t>, meta::_t<std::make_signed<std::uint_least32_t>>>::value, "");
static_assert(is_same<iter_difference_t<std::uint_least64_t>, meta::_t<std::make_signed<std::uint_least64_t>>>::value, "");
static_assert(is_same<iter_value_t<const int*>, int>::value, "");
static_assert(is_same<iter_difference_t<const int*>, ptrdiff_t>::value, "");
static_assert(is_same<iter_difference_t<int* const>, ptrdiff_t>::value, "");
static_assert(detail::is_std_iterator_traits_specialized_v<X>, "");
static_assert(is_same<iterator_traits<X>::value_type, int>::value, "");
static_assert(is_same<iter_value_t<X>, int>::value, "");
static_assert(!detail::is_std_iterator_traits_specialized_v<Y>, "");
static_assert(is_same<iterator_traits<Y>::value_type, int>::value, "");
static_assert(is_same<iter_value_t<Y>, int>::value, "");
// libc++ has a broken std::iterator_traits primary template
// https://bugs.llvm.org/show_bug.cgi?id=39619
#ifndef _LIBCPP_VERSION
// iterator_traits uses specializations of ranges::indirectly_readable_traits:
static_assert(!detail::is_std_iterator_traits_specialized_v<Z>, "");
static_assert(is_same<iterator_traits<Z>::value_type, int>::value, "");
static_assert(is_same<iter_value_t<Z>, int>::value, "");
static_assert(is_same<iterator_traits<Z>::iterator_category,
std::bidirectional_iterator_tag>::value, "");
#endif
static_assert(ranges::input_iterator<WouldBeFwd>, "");
static_assert(!ranges::forward_iterator<WouldBeFwd>, "");
static_assert(is_same<iterator_traits<WouldBeFwd>::iterator_category,
std::input_iterator_tag>::value, "");
static_assert(ranges::forward_iterator<WouldBeBidi>, "");
static_assert(!ranges::bidirectional_iterator<WouldBeBidi>, "");
static_assert(is_same<iterator_traits<WouldBeBidi>::iterator_category,
std::input_iterator_tag>::value, "");
static_assert(ranges::input_or_output_iterator<OutIter>, "");
static_assert(!ranges::input_iterator<OutIter>, "");
static_assert(is_same<iterator_traits<OutIter>::difference_type,
std::ptrdiff_t>::value, "");
static_assert(is_same<iterator_traits<OutIter>::iterator_category,
std::output_iterator_tag>::value, "");
static_assert(ranges::contiguous_iterator<int volatile *>, "");
static_assert(ranges::forward_iterator<bool_iterator>, "");
static_assert(is_same<iterator_traits<bool_iterator>::iterator_category,
std::input_iterator_tag>::value, "");
// static_assert(_Cpp98InputIterator<int volatile*>);
// static_assert(_Cpp98InputIterator<bool_iterator>);
// // Test subsumption:
// test(WouldBeFwd{});
// test(WouldBeBidi{});
// test(meta::detail::nullptr_v<int>);
// // Test subsumption:
// test2(OutIter{});
// test2(meta::detail::nullptr_v<int>);
// // Test subsumption:
// test3(WouldBeFwd{}, WouldBeFwd{});
// test3(meta::detail::nullptr_v<int>, meta::detail::nullptr_v<int>);
}
#endif
int main()
{
test_insert_iterator();
test_move_iterator();
test_ostream_joiner();
issue_420_regression();
test_1110();
{
struct S { using value_type = int; };
CPP_assert(same_as<int, ranges::indirectly_readable_traits<S const>::value_type>);
}
return ::test_result();
}
|
0 | repos/range-v3/test | repos/range-v3/test/iterator/unformatted_ostream_iterator.cpp | // Range v3 library
//
// Copyright Eric Niebler 2014-present
// Copyright Google LLC 2020-present
//
// Use, modification and distribution is subject to the
// Boost Software License, Version 1.0. (See accompanying
// file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt)
//
// Project home: https://github.com/ericniebler/range-v3
#include <sstream>
#include <string>
#include <vector>
#include <range/v3/algorithm/copy.hpp>
#include <range/v3/iterator/stream_iterators.hpp>
#include <range/v3/range/conversion.hpp>
#include <range/v3/view/for_each.hpp>
#include <range/v3/view/reverse.hpp>
#include <range/v3/view/sliding.hpp>
#include <range/v3/view/stride.hpp>
#include "../simple_test.hpp"
#include "../test_utils.hpp"
namespace
{
#if defined(__BYTE_ORDER__) && __BYTE_ORDER__ == __ORDER_BIG_ENDIAN__
template<typename>
std::string endian_adjust(std::string const & s)
{
return s;
}
#else
template<typename T>
std::string endian_adjust(std::string const & s)
{
namespace rv = ranges::views;
return rv::sliding(s, static_cast<std::ptrdiff_t>(sizeof(T))) //
| rv::stride(static_cast<std::ptrdiff_t>(sizeof(T))) //
| rv::for_each([](auto x) { return x | rv::reverse; }) //
| ranges::to<std::string>;
}
#endif // endianness
} // namespace
int main()
{
{
constexpr auto expected = "\x21\x22\x23\x24";
{
auto const input = std::vector<char>{0x21, 0x22, 0x23, 0x24};
auto output = std::ostringstream();
ranges::copy(input, ranges::unformatted_ostream_iterator<>(output));
auto const actual = output.str();
CHECK(actual == expected);
}
{
auto const input = std::vector<unsigned short>{0x2122, 0x2324};
auto output = std::ostringstream();
ranges::copy(input, ranges::unformatted_ostream_iterator<>(output));
auto const actual = endian_adjust<unsigned short>(output.str());
CHECK(actual == expected);
}
#if __cplusplus > 201703L
{
// float computed to be *exactly* 0x21222324.
auto const input = std::vector<float>{0x1.4446480000000000179Dp-61f};
auto output = std::ostringstream();
ranges::copy(input, ranges::unformatted_ostream_iterator<>(output));
auto const actual = endian_adjust<float>(output.str());
CHECK(actual == expected);
}
#endif // __cplusplus > 201703L
}
{
constexpr auto expected = "\x21\x22\x23\x24\x25\x26\x27\x28";
{
auto const input = std::vector<unsigned int>{0x21222324, 0x25262728};
auto output = std::ostringstream();
ranges::copy(input, ranges::unformatted_ostream_iterator<>(output));
auto const actual = endian_adjust<unsigned int>(output.str());
CHECK(actual == expected);
}
#if __cplusplus > 201703L
{
// floats computed to be *exactly* 0x21222324 and 0x25262728.
auto const input =
std::vector<float>{0x1.4446480000000000179Dp-61f, 0x1.4C4E5p-53f};
auto output = std::ostringstream();
ranges::copy(input, ranges::unformatted_ostream_iterator<>(output));
auto const actual = endian_adjust<unsigned int>(output.str());
CHECK(actual == expected);
}
{
// double computed to be *exactly* 0x2122232425262728.
auto const input = std::vector<double>{0x1.223242526272800006F2p-493};
auto output = std::ostringstream();
ranges::copy(input, ranges::unformatted_ostream_iterator<>(output));
auto const actual = endian_adjust<double>(output.str());
CHECK(actual == expected);
}
#endif // __cplusplus > 201703L
}
return ::test_result();
}
|
0 | repos/range-v3/test | repos/range-v3/test/iterator/reverse_iterator.cpp | // Range v3 library
//
// Copyright Eric Niebler 2014-present
//
// Use, modification and distribution is subject to the
// Boost Software License, Version 1.0. (See accompanying
// file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt)
//
// Project home: https://github.com/ericniebler/range-v3
//
// These tests of reverse_iterator have been adapted from libc++
// (http://libcxx.llvm.org).
//
//===----------------------------------------------------------------------===//
//
// The LLVM Compiler Infrastructure
//
// This file is dual licensed under the MIT and the University of Illinois Open
// Source Licenses. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
#include <range/v3/range/access.hpp>
#include <range/v3/view/iota.hpp>
#include "../simple_test.hpp"
#include "../test_iterators.hpp"
template<class It> void test() { ranges::reverse_iterator<It>{}; }
template<class It> void test2(It i) {
ranges::reverse_iterator<It> r(i);
CHECK(r.base() == i);
}
template<class It, class U> void test3(U u) {
const ranges::reverse_iterator<U> r2(u);
ranges::reverse_iterator<It> r1 = ranges::reverse_iterator<It>(r2);
CHECK(r1.base() == u);
}
struct Base {};
struct Derived : Base {};
template<class It> void test4(It i) {
const ranges::reverse_iterator<It> r = ranges::make_reverse_iterator(i);
CHECK(r.base() == i);
}
template<class It> void test5(It l, It r, bool x) {
const ranges::reverse_iterator<It> r1(l);
const ranges::reverse_iterator<It> r2(r);
CHECK((r1 != r2) == x);
}
template<class It> void test6(It i, It x) {
ranges::reverse_iterator<It> r(i);
ranges::reverse_iterator<It> rr = r++;
CHECK(r.base() == x);
CHECK(rr.base() == i);
}
template<class It> void test7(It i, It x) {
ranges::reverse_iterator<It> r(i);
ranges::reverse_iterator<It> &rr = ++r;
CHECK(r.base() == x);
CHECK(&rr == &r);
}
template<class It>
void test8(It i, ranges::iter_difference_t<It> n, It x) {
const ranges::reverse_iterator<It> r(i);
ranges::reverse_iterator<It> rr = r + n;
CHECK(rr.base() == x);
}
template<class It>
void test9(It i, ranges::iter_difference_t<It> n, It x) {
ranges::reverse_iterator<It> r(i);
ranges::reverse_iterator<It> &rr = r += n;
CHECK(r.base() == x);
CHECK(&rr == &r);
}
template<class It> void test10(It i, It x) {
ranges::reverse_iterator<It> r(i);
ranges::reverse_iterator<It> rr = r--;
CHECK(r.base() == x);
CHECK(rr.base() == i);
}
template<class It> void test11(It i, It x) {
ranges::reverse_iterator<It> r(i);
ranges::reverse_iterator<It> &rr = --r;
CHECK(r.base() == x);
CHECK(&rr == &r);
}
template<class It>
void test12(It i, ranges::iter_difference_t<It> n, It x) {
const ranges::reverse_iterator<It> r(i);
ranges::reverse_iterator<It> rr = r - n;
CHECK(rr.base() == x);
}
template<class It>
void test13(It i, ranges::iter_difference_t<It> n, It x) {
ranges::reverse_iterator<It> r(i);
ranges::reverse_iterator<It> &rr = r -= n;
CHECK(r.base() == x);
CHECK(&rr == &r);
}
class A {
int data_ = 1;
public:
A() = default;
friend bool operator==(const A &x, const A &y) { return x.data_ == y.data_; }
};
template<class It> void test14(It i, ranges::iter_value_t<It> x) {
ranges::reverse_iterator<It> r(i);
CHECK(*r == x);
}
template<class It, class U> void test15(U u) {
const ranges::reverse_iterator<U> r2(u);
ranges::reverse_iterator<It> r1;
ranges::reverse_iterator<It> &rr = r1 = r2;
CHECK(r1.base() == u);
CHECK(&rr == &r1);
}
template<class It> void test16(It l, It r, bool x) {
const ranges::reverse_iterator<It> r1(l);
const ranges::reverse_iterator<It> r2(r);
CHECK((r1 == r2) == x);
}
template<class It1, class It2> void test17(It1 l, It2 r, std::ptrdiff_t x) {
const ranges::reverse_iterator<It1> r1(l);
const ranges::reverse_iterator<It2> r2(r);
CHECK((r1 - r2) == x);
}
template<class It> void test18(It l, It r, bool x) {
const ranges::reverse_iterator<It> r1(l);
const ranges::reverse_iterator<It> r2(r);
CHECK((r1 > r2) == x);
}
template<class It> void test19(It l, It r, bool x) {
const ranges::reverse_iterator<It> r1(l);
const ranges::reverse_iterator<It> r2(r);
CHECK((r1 >= r2) == x);
}
template<class It>
void test20(It i, ranges::iter_difference_t<It> n,
ranges::iter_value_t<It> x) {
const ranges::reverse_iterator<It> r(i);
ranges::iter_value_t<It> rr = r[n];
CHECK(rr == x);
}
template<class It> void test21(It l, It r, bool x) {
const ranges::reverse_iterator<It> r1(l);
const ranges::reverse_iterator<It> r2(r);
CHECK((r1 < r2) == x);
}
template<class It>
void
test22(It l, It r, bool x)
{
const ranges::reverse_iterator<It> r1(l);
const ranges::reverse_iterator<It> r2(r);
CHECK((r1 < r2) == x);
}
template<class It>
void
test23(It l, It r, bool x)
{
const ranges::reverse_iterator<It> r1(l);
const ranges::reverse_iterator<It> r2(r);
CHECK((r1 <= r2) == x);
}
class B
{
int data_ = 1;
public:
B() = default;
int get() const {return data_;}
friend bool operator==(const B& x, const B& y)
{return x.data_ == y.data_;}
};
template<class It>
void
test24(It i, ranges::iter_value_t<It> x)
{
ranges::reverse_iterator<It> r(i);
CHECK((*r).get() == x.get());
}
class C
{
int data_ = 1;
public:
C(int d) : data_(d) {}
C() = default;
int get() const {return data_;}
friend bool operator==(const C& x, const C& y)
{return x.data_ == y.data_;}
const C *operator&() const { return nullptr; }
C *operator&() { return nullptr; }
};
template<class It>
void
test25(It i, ranges::iter_difference_t<It> n, It x)
{
const ranges::reverse_iterator<It> r(i);
ranges::reverse_iterator<It> rr = n + r;
CHECK(rr.base() == x);
}
int main()
{
{
static_assert(
ranges::detail::bidirectional_cursor<
ranges::detail::reverse_cursor<BidirectionalIterator<const char *>>>,
"");
static_assert(
ranges::detail::bidirectional_cursor<
ranges::detail::reverse_cursor<RandomAccessIterator<const char *>>>,
"");
static_assert(
ranges::detail::random_access_cursor<
ranges::detail::reverse_cursor<RandomAccessIterator<const char *>>>,
"");
static_assert(
ranges::bidirectional_iterator<
ranges::reverse_iterator<BidirectionalIterator<const char *>>>,
"");
static_assert(
ranges::random_access_iterator<
ranges::reverse_iterator<RandomAccessIterator<const char *>>>,
"");
}
{ // test
test<BidirectionalIterator<const char *>>();
test<RandomAccessIterator<char *>>();
test<char *>();
test<const char *>();
}
{ // test 2
const char s[] = "123";
test2(BidirectionalIterator<const char *>(s));
test2(RandomAccessIterator<const char *>(s));
}
{ // test3
Derived d;
test3<BidirectionalIterator<Base *>>(
BidirectionalIterator<Derived *>(&d));
//test3<RandomAccessIterator<const Base *>>(
// RandomAccessIterator<Derived *>(&d));
}
//{ // test4
// const char *s = "1234567890";
// RandomAccessIterator<const char *> b(s);
// RandomAccessIterator<const char *> e(s + 10);
// while (b != e)
// test4(b++);
//}
//{ // test5
// const char *s = "1234567890";
// test5(BidirectionalIterator<const char *>(s),
// BidirectionalIterator<const char *>(s), false);
// test5(BidirectionalIterator<const char *>(s),
// BidirectionalIterator<const char *>(s + 1), true);
// test5(RandomAccessIterator<const char *>(s),
// RandomAccessIterator<const char *>(s), false);
// test5(RandomAccessIterator<const char *>(s),
// RandomAccessIterator<const char *>(s + 1), true);
// test5(s, s, false);
// test5(s, s + 1, true);
//}
//{
// const char *s = "123";
// test6(BidirectionalIterator<const char *>(s + 1),
// BidirectionalIterator<const char *>(s));
// test6(RandomAccessIterator<const char *>(s + 1),
// RandomAccessIterator<const char *>(s));
// test6(s + 1, s);
//}
//{
// const char *s = "123";
// test7(BidirectionalIterator<const char *>(s + 1),
// BidirectionalIterator<const char *>(s));
// test7(RandomAccessIterator<const char *>(s + 1),
// RandomAccessIterator<const char *>(s));
// test7(s + 1, s);
//}
//{
// const char *s = "1234567890";
// test8(RandomAccessIterator<const char *>(s + 5), 5,
// RandomAccessIterator<const char *>(s));
// test8(s + 5, 5, s);
//}
//{
// const char *s = "1234567890";
// test9(RandomAccessIterator<const char *>(s + 5), 5,
// RandomAccessIterator<const char *>(s));
// test9(s + 5, 5, s);
//}
//{
// const char *s = "123";
// test10(BidirectionalIterator<const char *>(s + 1),
// BidirectionalIterator<const char *>(s + 2));
// test10(RandomAccessIterator<const char *>(s + 1),
// RandomAccessIterator<const char *>(s + 2));
// test10(s + 1, s + 2);
//}
//{
// const char *s = "123";
// test11(BidirectionalIterator<const char *>(s + 1),
// BidirectionalIterator<const char *>(s + 2));
// test11(RandomAccessIterator<const char *>(s + 1),
// RandomAccessIterator<const char *>(s + 2));
// test11(s + 1, s + 2);
//}
//{
// const char *s = "1234567890";
// test12(RandomAccessIterator<const char *>(s + 5), 5,
// RandomAccessIterator<const char *>(s + 10));
// test12(s + 5, 5, s + 10);
//}
//{
// const char *s = "1234567890";
// test13(RandomAccessIterator<const char *>(s + 5), 5,
// RandomAccessIterator<const char *>(s + 10));
// test13(s + 5, 5, s + 10);
//}
//{
// A a;
// test14(&a + 1, A());
//}
//{
// Derived d;
// test15<BidirectionalIterator<Base *>>(
// BidirectionalIterator<Derived *>(&d));
// test15<RandomAccessIterator<const Base *>>(
// RandomAccessIterator<Derived *>(&d));
// test15<Base *>(&d);
//}
//{
// const char *s = "1234567890";
// test16(BidirectionalIterator<const char *>(s),
// BidirectionalIterator<const char *>(s), true);
// test16(BidirectionalIterator<const char *>(s),
// BidirectionalIterator<const char *>(s + 1), false);
// test16(RandomAccessIterator<const char *>(s),
// RandomAccessIterator<const char *>(s), true);
// test16(RandomAccessIterator<const char *>(s),
// RandomAccessIterator<const char *>(s + 1), false);
// test16(s, s, true);
// test16(s, s + 1, false);
//}
//{
// char s[3] = {0};
// test17(RandomAccessIterator<const char *>(s),
// RandomAccessIterator<char *>(s), 0);
// RandomAccessIterator<char *> inp1(s);
// test17(RandomAccessIterator<char *>(s),
// RandomAccessIterator<const char *>(s + 1), 1);
// test17(RandomAccessIterator<const char *>(s + 1),
// RandomAccessIterator<char *>(s), -1);
// test17(s, s, 0);
// test17(s, s + 1, 1);
// test17(s + 1, s, -1);
//}
//{
// const char *s = "1234567890";
// test18(RandomAccessIterator<const char *>(s),
// RandomAccessIterator<const char *>(s), false);
// test18(RandomAccessIterator<const char *>(s),
// RandomAccessIterator<const char *>(s + 1), true);
// test18(RandomAccessIterator<const char *>(s + 1),
// RandomAccessIterator<const char *>(s), false);
// test18(s, s, false);
// test18(s, s + 1, true);
// test18(s + 1, s, false);
//}
//{
// const char *s = "1234567890";
// test19(RandomAccessIterator<const char *>(s),
// RandomAccessIterator<const char *>(s), true);
// test19(RandomAccessIterator<const char *>(s),
// RandomAccessIterator<const char *>(s + 1), true);
// test19(RandomAccessIterator<const char *>(s + 1),
// RandomAccessIterator<const char *>(s), false);
// test19(s, s, true);
// test19(s, s + 1, true);
// test19(s + 1, s, false);
//}
//{
// const char *s = "1234567890";
// test20(RandomAccessIterator<const char *>(s + 5), 4, '1');
// test20(s + 5, 4, '1');
//}
//{
// const char *s = "1234567890";
// test21(RandomAccessIterator<const char *>(s),
// RandomAccessIterator<const char *>(s), false);
// test21(RandomAccessIterator<const char *>(s),
// RandomAccessIterator<const char *>(s + 1), false);
// test21(RandomAccessIterator<const char *>(s + 1),
// RandomAccessIterator<const char *>(s), true);
// test21(s, s, false);
// test21(s, s + 1, false);
// test21(s + 1, s, true);
//}
//{
// const char* s = "1234567890";
// test22(RandomAccessIterator<const char*>(s), RandomAccessIterator<const char*>(s), false);
// test22(RandomAccessIterator<const char*>(s), RandomAccessIterator<const char*>(s+1), false);
// test22(RandomAccessIterator<const char*>(s+1), RandomAccessIterator<const char*>(s), true);
// test22(s, s, false);
// test22(s, s+1, false);
// test22(s+1, s, true);
//}
//{
// const char* s = "1234567890";
// test23(RandomAccessIterator<const char*>(s), RandomAccessIterator<const char*>(s), true);
// test23(RandomAccessIterator<const char*>(s), RandomAccessIterator<const char*>(s+1), false);
// test23(RandomAccessIterator<const char*>(s+1), RandomAccessIterator<const char*>(s), true);
// test23(s, s, true);
// test23(s, s+1, false);
// test23(s+1, s, true);
//}
//{
// B a;
// test24(&a+1, B());
//}
//{
// C l[3] = {C(0), C(1), C(2)};
// auto ri = ranges::rbegin(l);
// CHECK ( ri->get() == 2 );
// CHECK ( (*ri).get() == 2 );
// CHECK ( ri.operator->() == ranges::prev(ri.base()) );
// ++ri;
// CHECK ( ri->get() == 1 );
// CHECK ( (*ri).get() == 1 );
// CHECK ( ri.operator->() == ranges::prev(ri.base()) );
// ++ri;
// CHECK ( ri->get() == 0 );
// CHECK ( (*ri).get() == 0 );
// CHECK ( ri.operator->() == ranges::prev(ri.base()) );
// ++ri;
// CHECK ( ri == ranges::rend(l));
//}
//{
// const char* s = "1234567890";
// test25(RandomAccessIterator<const char*>(s+5), 5, RandomAccessIterator<const char*>(s));
// test25(s+5, 5, s);
//}
return test_result();
}
|
0 | repos/range-v3/test | repos/range-v3/test/iterator/common_iterator.cpp | // Range v3 library
//
// Copyright Eric Niebler 2015-present
// Copyright Casey Carter 2016
//
// Use, modification and distribution is subject to the
// Boost Software License, Version 1.0. (See accompanying
// file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt)
//
// Project home: https://github.com/ericniebler/range-v3
//
#include <algorithm>
#include <numeric>
#include <range/v3/iterator/common_iterator.hpp>
#include <range/v3/iterator/unreachable_sentinel.hpp>
#include "../simple_test.hpp"
#include "../test_iterators.hpp"
RANGES_DIAGNOSTIC_IGNORE_UNNEEDED_MEMBER
namespace {
struct silly_arrow_cursor {
int read() const { return 0; }
void next() {}
int arrow() const { return 42; }
};
int forty_two = 42;
struct lvalue_iterator {
using difference_type = int;
using value_type = int;
int& operator*() const { return forty_two; }
lvalue_iterator& operator++() & { return *this; }
lvalue_iterator operator++(int) & { return *this; }
};
struct xvalue_iterator : lvalue_iterator {
int&& operator*() const { return std::move(forty_two); }
xvalue_iterator& operator++() & { return *this; }
xvalue_iterator operator++(int) & { return *this; }
};
struct proxy_cursor {
int read() const { return 42; }
void next() {}
};
void test_operator_arrow() {
// I is a pointer type
{
int i = 42;
auto ci = ranges::common_iterator<int*, ranges::unreachable_sentinel_t>{&i};
CPP_assert(ranges::same_as<int*, decltype(ci.operator->())>);
CHECK(ci.operator->() == &i);
}
// the expression i.operator->() is well-formed
{
using I = ranges::basic_iterator<silly_arrow_cursor>;
auto ci = ranges::common_iterator<I, ranges::unreachable_sentinel_t>{};
CPP_assert(ranges::same_as<I, decltype(ci.operator->())>);
CHECK(ci.operator->().operator->() == 42);
}
// the expression *i is a glvalue [lvalue case]
{
auto ci = ranges::common_iterator<lvalue_iterator, ranges::unreachable_sentinel_t>{};
CPP_assert(ranges::same_as<int*, decltype(ci.operator->())>);
CHECK(ci.operator->() == &forty_two);
}
// the expression *i is a glvalue [xvalue case]
{
auto ci = ranges::common_iterator<xvalue_iterator, ranges::unreachable_sentinel_t>{};
CPP_assert(ranges::same_as<int*, decltype(ci.operator->())>);
CHECK(ci.operator->() == &forty_two);
}
// Otherwise, returns a proxy object
{
using I = ranges::basic_iterator<proxy_cursor>;
auto ci = ranges::common_iterator<I, ranges::unreachable_sentinel_t>{};
using A = decltype(ci.operator->());
CPP_assert(std::is_class<A>::value);
CPP_assert(!std::is_same<I, A>::value);
CHECK(*ci.operator->().operator->() == 42);
}
}
}
int main() {
{
CPP_assert(
ranges::forward_iterator<
ranges::common_iterator<
BidirectionalIterator<const char *>,
Sentinel<const char *>>>);
CPP_assert(
!ranges::bidirectional_iterator<
ranges::common_iterator<
BidirectionalIterator<const char *>,
Sentinel<const char *>>>);
CPP_assert(
std::is_same<
ranges::common_reference<
ranges::common_iterator<
BidirectionalIterator<const char *>,
Sentinel<const char *>
>&,
ranges::common_iterator<
BidirectionalIterator<const char *>,
Sentinel<const char *>
>
>::type,
ranges::common_iterator<
BidirectionalIterator<const char *>,
Sentinel<const char *>
>
>::value);
// Sized iterator range tests
CPP_assert(
!ranges::sized_sentinel_for<
ranges::common_iterator<
ForwardIterator<int*>,
Sentinel<int*, true> >,
ranges::common_iterator<
ForwardIterator<int*>,
Sentinel<int*, true> > >);
CPP_assert(
ranges::sized_sentinel_for<
ranges::common_iterator<
RandomAccessIterator<int*>,
Sentinel<int*, true> >,
ranges::common_iterator<
RandomAccessIterator<int*>,
Sentinel<int*, true> > >);
CPP_assert(
!ranges::sized_sentinel_for<
ranges::common_iterator<
RandomAccessIterator<int*>,
Sentinel<int*, false> >,
ranges::common_iterator<
RandomAccessIterator<int*>,
Sentinel<int*, false> > >);
}
{
int rgi[] {0,1,2,3,4,5,6,7,8,9};
using CI = ranges::common_iterator<
RandomAccessIterator<int*>,
Sentinel<int*>>;
CI first{RandomAccessIterator<int*>{rgi}};
CI last{Sentinel<int*>{rgi+10}};
CHECK(std::accumulate(first, last, 0, std::plus<int>{}) == 45);
}
test_operator_arrow();
return test_result();
}
|
0 | repos/range-v3/test | repos/range-v3/test/iterator/CMakeLists.txt | set(CMAKE_FOLDER "${CMAKE_FOLDER}/iterator")
rv3_add_test(test.iter.basic_iterator iter.basic_iterator basic_iterator.cpp)
rv3_add_test(test.iter.diffmax_t iter.diffmax_t diffmax_t.cpp)
rv3_add_test(test.iter.iterator iter.iterator iterator.cpp)
rv3_add_test(test.iter.common_iterator iter.common_iterator common_iterator.cpp)
rv3_add_test(test.iter.reverse_iterator iter.reverse_iterator reverse_iterator.cpp)
rv3_add_test(test.iter.unformatted_ostream_iterator iter.unformatted_ostream_iterator unformatted_ostream_iterator.cpp)
rv3_add_test(test.iter.counted_iterator iter.counted_iterator counted_iterator.cpp)
|
0 | repos/range-v3/test | repos/range-v3/test/iterator/basic_iterator.cpp | // Range v3 library
//
// Copyright Eric Niebler 2014-present
//
// Use, modification and distribution is subject to the
// Boost Software License, Version 1.0. (See accompanying
// file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt)
//
// Project home: https://github.com/ericniebler/range-v3
#include <cstring>
#include <tuple>
#include <range/v3/iterator/basic_iterator.hpp>
#include <range/v3/utility/common_tuple.hpp>
#include "../simple_test.hpp"
#include "../test_utils.hpp"
template<typename T>
using iter_cat_t = typename T::iterator_category;
template<typename T>
using has_iter_cat = meta::is_trait<meta::defer<iter_cat_t, T>>;
namespace test_weak_input
{
template<typename I>
struct cursor
{
I it_;
struct mixin : ranges::basic_mixin<cursor>
{
mixin() = default;
//using ranges::basic_mixin<cursor>::basic_mixin;
explicit mixin(cursor && cur)
: ranges::basic_mixin<cursor>(static_cast<cursor &&>(cur))
{}
explicit mixin(cursor const & cur)
: ranges::basic_mixin<cursor>(cur)
{}
mixin(I i)
: mixin(cursor{i})
{}
};
cursor() = default;
explicit cursor(I i)
: it_(i)
{}
CPP_template(class J)(
/// \pre
requires ranges::convertible_to<J, I>) //
cursor(cursor<J> that)
: it_(std::move(that.it_))
{}
auto read() const -> decltype(*it_)
{
return *it_;
}
void next()
{
++it_;
}
};
CPP_assert(ranges::detail::input_cursor<cursor<char *>>);
CPP_assert(!ranges::detail::sentinel_for_cursor<cursor<char *>, cursor<char *>>);
template<class I>
using iterator = ranges::basic_iterator<cursor<I>>;
CPP_assert(ranges::indirectly_readable<iterator<char *>>);
CPP_assert(ranges::input_iterator<iterator<char *>>);
static_assert(!has_iter_cat<iterator<char *>>::value, "");
static_assert(!has_iter_cat<std::iterator_traits<iterator<char *>>>::value, "");
static_assert(
std::is_same<iterator<char *>::iterator_concept, std::input_iterator_tag>::value,
"");
static_assert(!ranges::equality_comparable<iterator<char *>>, "");
void test()
{
using namespace ranges;
using I = iterator<char const *>;
CPP_assert(std::is_same<std::iterator_traits<I>::pointer, char const *>{});
static char const sz[] = "hello world";
I i{sz};
CHECK(*i == 'h');
CHECK(&*i == i.operator->());
++i;
CHECK(*i == 'e');
CHECK(&*i == i.operator->());
}
} // namespace test_weak_input
namespace test_random_access
{
template<typename I>
struct cursor
{
I it_;
struct mixin : ranges::basic_mixin<cursor>
{
mixin() = default;
//using ranges::basic_mixin<cursor>::basic_mixin;
explicit mixin(cursor && cur)
: ranges::basic_mixin<cursor>(static_cast<cursor &&>(cur))
{}
explicit mixin(cursor const & cur)
: ranges::basic_mixin<cursor>(cur)
{}
mixin(I i)
: mixin(cursor{i})
{}
};
cursor() = default;
explicit cursor(I i)
: it_(i)
{}
CPP_template(class J)(
/// \pre
requires ranges::convertible_to<J, I>) //
cursor(cursor<J> that)
: it_(std::move(that.it_))
{}
auto read() const -> decltype(*it_)
{
return *it_;
}
CPP_template(class J)(
/// \pre
requires ranges::sentinel_for<J, I>) //
bool equal(cursor<J> const & that) const
{
return that.it_ == it_;
}
void next()
{
++it_;
}
void prev()
{
--it_;
}
void advance(ranges::iter_difference_t<I> n)
{
it_ += n;
}
CPP_template(class J)(
/// \pre
requires ranges::sized_sentinel_for<J, I>) //
ranges::iter_difference_t<I> distance_to(cursor<J> const & that) const
{
return that.it_ - it_;
}
};
CPP_assert(ranges::detail::random_access_cursor<cursor<char *>>);
template<class I>
using iterator = ranges::basic_iterator<cursor<I>>;
static_assert(std::is_same<iterator<char *>::iterator_category,
std::random_access_iterator_tag>::value,
"");
void test()
{
using namespace ranges;
iterator<char *> a(nullptr);
iterator<char const *> b(nullptr);
iterator<char const *> c(a);
CPP_assert(
std::is_same<std::iterator_traits<iterator<char *>>::pointer, char *>{});
b = a;
bool d = a == b;
d = (a != b);
detail::ignore_unused(
d, //
a < b, //
a <= b, //
a > b, //
a >= b, //
(a-b), //
(b-a), //
(a-a), //
(b-b)); //
}
} // namespace test_random_access
namespace test_weak_output
{
template<typename I>
struct cursor
{
struct mixin : ranges::basic_mixin<cursor>
{
mixin() = default;
// using ranges::basic_mixin<cursor>::basic_mixin;
explicit mixin(cursor && cur)
: ranges::basic_mixin<cursor>(static_cast<cursor &&>(cur))
{}
explicit mixin(cursor const & cur)
: ranges::basic_mixin<cursor>(cur)
{}
explicit mixin(I i)
: mixin(cursor{i})
{}
};
cursor() = default;
explicit cursor(I i)
: it_(i)
{}
void write(ranges::iter_value_t<I> v) const
{
*it_ = v;
}
void next()
{
++it_;
}
private:
I it_;
};
CPP_assert(ranges::detail::output_cursor<cursor<char *>, char>);
CPP_assert(!ranges::detail::sentinel_for_cursor<cursor<char *>, cursor<char *>>);
template<class I>
using iterator = ranges::basic_iterator<cursor<I>>;
CPP_assert(ranges::output_iterator<iterator<char *>, char>);
CPP_assert(!ranges::equality_comparable<iterator<char *>>);
void test()
{
char buf[10];
iterator<char *> i(buf);
*i = 'h';
++i;
*i = 'e';
++i;
*i = 'l';
++i;
*i = 'l';
++i;
*i = 'o';
++i;
*i = '\0';
CHECK(0 == std::strcmp(buf, "hello"));
}
} // namespace test_weak_output
namespace test_output
{
template<typename I>
struct cursor
{
I it_;
struct mixin : ranges::basic_mixin<cursor>
{
mixin() = default;
//using ranges::basic_mixin<cursor>::basic_mixin;
explicit mixin(cursor && cur)
: ranges::basic_mixin<cursor>(static_cast<cursor &&>(cur))
{}
explicit mixin(cursor const & cur)
: ranges::basic_mixin<cursor>(cur)
{}
mixin(I i)
: mixin(cursor{i})
{}
};
cursor() = default;
explicit cursor(I i)
: it_(i)
{}
CPP_template(class J)(
/// \pre
requires ranges::convertible_to<J, I>) //
cursor(cursor<J> that)
: it_(std::move(that.it_))
{}
using value_type = ranges::iter_value_t<I>;
value_type read() const
{
return *it_;
}
void write(value_type v) const
{
*it_ = v;
}
I arrow() const
{
return it_;
}
void next()
{
++it_;
}
bool equal(cursor const & that) const
{
return it_ == that.it_;
}
};
CPP_assert(ranges::detail::output_cursor<cursor<char *>, char>);
CPP_assert(ranges::detail::forward_cursor<cursor<char *>>);
template<class I>
using iterator = ranges::basic_iterator<cursor<I>>;
CPP_assert(ranges::output_iterator<iterator<char *>, char>);
CPP_assert(ranges::forward_iterator<iterator<char *>>);
CPP_assert(std::is_same<std::iterator_traits<iterator<char *>>::pointer, char *>());
void test()
{
char buf[10];
iterator<char *> i(buf);
*i = 'h';
CHECK(*i == 'h');
CHECK(*i == *i);
++i;
*i = 'e';
CHECK('e' == *i);
++i;
*i = 'l';
++i;
*i = 'l';
++i;
*i = 'o';
++i;
*i = '\0';
CHECK(0 == std::strcmp(buf, "hello"));
CHECK(i == iterator<char *>{buf + 5});
++i;
CHECK(i != iterator<char *>{buf + 5});
CHECK(i == iterator<char *>{buf + 6});
}
} // namespace test_output
namespace test_move_only
{
struct MoveOnly
{
MoveOnly() = default;
MoveOnly(MoveOnly &&) = default;
MoveOnly(MoveOnly const &) = delete;
MoveOnly & operator=(MoveOnly &&) = default;
MoveOnly & operator=(MoveOnly const &) = delete;
};
template<typename I>
struct zip1_cursor
{
I it_;
struct mixin : ranges::basic_mixin<zip1_cursor>
{
mixin() = default;
// using ranges::basic_mixin<zip1_cursor>::basic_mixin;
explicit mixin(zip1_cursor && cur)
: ranges::basic_mixin<zip1_cursor>(static_cast<zip1_cursor &&>(cur))
{}
explicit mixin(zip1_cursor const & cur)
: ranges::basic_mixin<zip1_cursor>(cur)
{}
mixin(I i)
: mixin(zip1_cursor{i})
{}
};
zip1_cursor() = default;
explicit zip1_cursor(I i)
: it_(i)
{}
CPP_template(class J)(
/// \pre
requires ranges::convertible_to<J, I>) //
zip1_cursor(zip1_cursor<J> that)
: it_(std::move(that.it_))
{}
using value_type = std::tuple<ranges::iter_value_t<I>>;
using reference = ranges::common_tuple<ranges::iter_reference_t<I>>;
using rvalue_reference = ranges::common_tuple<ranges::iter_rvalue_reference_t<I>>;
reference read() const
{
return reference{*it_};
}
rvalue_reference move() const
{
return rvalue_reference{ranges::iter_move(it_)};
}
void write(reference const & v) const
{
reference{ *it_} = v;
}
void write(value_type && v) const
{
reference{ *it_} = std::move(v);
}
void next()
{
++it_;
}
bool equal(zip1_cursor const & that) const
{
return it_ == that.it_;
}
};
CPP_assert(
ranges::detail::output_cursor<zip1_cursor<MoveOnly *>, std::tuple<MoveOnly>
&&>);
CPP_assert(ranges::detail::forward_cursor<zip1_cursor<MoveOnly *>>);
template<class I>
using iterator = ranges::basic_iterator<zip1_cursor<I>>;
CPP_assert(ranges::output_iterator<iterator<MoveOnly *>, std::tuple<MoveOnly> &&>);
CPP_assert(ranges::forward_iterator<iterator<MoveOnly *>>);
void test()
{
MoveOnly buf[10] = {};
iterator<MoveOnly *> i(buf);
*i = std::tuple<MoveOnly>{};
ranges::common_tuple<MoveOnly &> x = *i;
(void)x;
std::tuple<MoveOnly> v = ranges::iter_move(i);
*i = std::move(v);
}
} // namespace test_move_only
namespace test_forward_sized
{
template<typename I>
struct cursor
{
I it_;
struct mixin : ranges::basic_mixin<cursor>
{
mixin() = default;
// using ranges::basic_mixin<cursor>::basic_mixin;
explicit mixin(cursor && cur)
: ranges::basic_mixin<cursor>(static_cast<cursor &&>(cur))
{}
explicit mixin(cursor const & cur)
: ranges::basic_mixin<cursor>(cur)
{}
mixin(I i)
: mixin(cursor{i})
{}
};
cursor() = default;
explicit cursor(I i)
: it_(i)
{}
CPP_template(class J)(
/// \pre
requires ranges::convertible_to<J, I>) //
cursor(cursor<J> that)
: it_(std::move(that.it_))
{}
auto read() const -> decltype(*it_)
{
return *it_;
}
CPP_template(class J)(
/// \pre
requires ranges::sentinel_for<J, I>) //
bool equal(cursor<J> const & that) const
{
return that.it_ == it_;
}
void next()
{
++it_;
}
CPP_template(class J)(
/// \pre
requires ranges::sized_sentinel_for<J, I>) //
ranges::iter_difference_t<I> distance_to(cursor<J> const & that) const
{
return that.it_ - it_;
}
};
CPP_assert(ranges::detail::sized_sentinel_for_cursor<cursor<char *>, cursor<char *>>);
CPP_assert(ranges::detail::forward_cursor<cursor<char *>>);
template<class I>
using iterator = ranges::basic_iterator<cursor<I>>;
static_assert(std::is_same<iterator<char *>::iterator_category,
std::forward_iterator_tag>::value,
"");
void test()
{
using namespace ranges;
iterator<char *> a(nullptr);
iterator<char const *> b(nullptr);
iterator<char const *> c(a);
b = a;
bool d = a == b;
d = (a != b);
detail::ignore_unused(
d, //
a < b, //
a <= b, //
a > b, //
a >= b, //
(a-b), //
(b-a), //
(a-a), //
(b-b)); //
}
} // namespace test_forward_sized
RANGES_DIAGNOSTIC_IGNORE_UNNEEDED_MEMBER
void test_box()
{
struct A : ranges::box<int>
{};
CHECK(sizeof(A) == sizeof(int));
struct empty
{};
struct B : ranges::box<empty>
{
int i;
};
CHECK(sizeof(B) == sizeof(int));
B b1, b2;
if(ranges::detail::box_compression<empty>() == ranges::detail::box_compress::coalesce)
CHECK((&b1.get() == &b2.get()));
struct nontrivial
{
nontrivial()
{}
};
struct C : ranges::box<nontrivial>
{
int i;
};
CHECK(sizeof(C) == sizeof(int));
C c1, c2;
CHECK((&c1.get() != &c2.get()));
{
// empty but not trivial cursor that defines value_type:
struct cursor
{
using value_type = int;
cursor()
{}
int read() const
{
return 42;
}
void next()
{}
};
CPP_assert(ranges::detail::box_compression<cursor>() ==
ranges::detail::box_compress::ebo);
CPP_assert(ranges::same_as<int, ranges::basic_iterator<cursor>::value_type>);
}
}
int main()
{
using namespace ranges;
std::cout << "\nTesting basic_iterator\n";
::test_weak_input::test();
::test_random_access::test();
::test_weak_output::test();
::test_output::test();
::test_move_only::test();
::test_forward_sized::test();
::test_box();
return ::test_result();
}
|
0 | repos/range-v3/test | repos/range-v3/test/view/replace.cpp | // Range v3 library
//
// Copyright Eric Niebler 2014-present
//
// Use, modification and distribution is subject to the
// Boost Software License, Version 1.0. (See accompanying
// file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt)
//
// Project home: https://github.com/ericniebler/range-v3
#include <string>
#include <sstream>
#include <vector>
#include <range/v3/core.hpp>
#include <range/v3/view/istream.hpp>
#include <range/v3/functional/reference_wrapper.hpp>
#include <range/v3/utility/copy.hpp>
#include <range/v3/view/iota.hpp>
#include <range/v3/view/replace.hpp>
#include <range/v3/view/common.hpp>
#include <range/v3/view/take.hpp>
#include "../simple_test.hpp"
#include "../test_utils.hpp"
int main()
{
using namespace ranges;
std::string str{"1 2 3 4 5 6 7 8 9 1 2 3 4 5 6 7 8 9 1 2 3 4 5 6 7 8 9 "};
std::stringstream sin{str};
{
auto rng = istream<int>(sin) | views::replace(1, 42);
CPP_assert(same_as<range_value_t<decltype((rng))>, int>);
has_type<int const &>(*begin(rng));
CPP_assert(view_<decltype(rng)>);
CPP_assert(!sized_range<decltype(rng)>);
CPP_assert(!common_range<decltype(rng)>);
CPP_assert(input_iterator<decltype(begin(rng))>);
CPP_assert(!forward_iterator<decltype(begin(rng))>);
auto tmp = rng | views::common;
CPP_assert(same_as<range_value_t<decltype((tmp))>, int>);
has_type<int const &>(*begin(tmp));
CPP_assert(view_<decltype(tmp)>);
CPP_assert(common_range<decltype(tmp)>);
CPP_assert(!sized_range<decltype(tmp)>);
CPP_assert(input_iterator<decltype(begin(tmp))>);
CPP_assert(!forward_iterator<decltype(begin(tmp))>);
std::vector<int> actual{begin(tmp), end(tmp)};
::check_equal(actual, {42, 2, 3, 4, 5, 6, 7, 8, 9, 42, 2, 3, 4, 5, 6, 7, 8, 9, 42, 2, 3, 4, 5, 6, 7, 8, 9});
}
std::vector<int> rgi{1,2,3,4,5,6,7,8,9};
{
auto rng2 = rgi | views::replace(5, 42);
CPP_assert(same_as<range_value_t<decltype((rng2))>, int>);
has_type<int const &>(*begin(rng2));
has_type<int const &>(iter_move(begin(rng2)));
CPP_assert(view_<decltype(rng2)>);
CPP_assert(sized_range<decltype(rng2)>);
CPP_assert(common_range<decltype(rng2)>);
CPP_assert(random_access_iterator<decltype(begin(rng2))>);
::check_equal(rng2, {1,2,3,4,42,6,7,8,9});
}
{
int forty_two = 42;
auto rng3 = rgi | views::replace(5, ref(forty_two));
CPP_assert(same_as<range_value_t<decltype((rng3))>, int>);
has_type<int &>(*begin(rng3));
has_type<int const &>(iter_move(begin(rng3)));
CPP_assert(view_<decltype(rng3)>);
CPP_assert(sized_range<decltype(rng3)>);
CPP_assert(common_range<decltype(rng3)>);
CPP_assert(random_access_iterator<decltype(begin(rng3))>);
::check_equal(rng3, {1,2,3,4,42,6,7,8,9});
}
{
auto rng4 = views::ints | views::replace(5,42) | views::take(10);
CPP_assert(same_as<range_value_t<decltype((rng4))>, int>);
has_type<int>(*begin(rng4));
has_type<int>(iter_move(begin(rng4)));
CPP_assert(view_<decltype(rng4)>);
CPP_assert(sized_range<decltype(rng4)>);
CPP_assert(!common_range<decltype(rng4)>);
CPP_assert(random_access_iterator<decltype(begin(rng4))>);
::check_equal(rng4, {0,1,2,3,4,42,6,7,8,9});
}
{
int const some_ints[] = {1,2,3,4,5,6,7,8,9,1,2,3,4,5,6,7,8,9,1,2,3,4,5,6,7,8,9};
auto rng = debug_input_view<int const>{some_ints} | views::replace(1, 42);
::check_equal(rng, {42,2,3,4,5,6,7,8,9,42,2,3,4,5,6,7,8,9,42,2,3,4,5,6,7,8,9});
}
return test_result();
}
|
0 | repos/range-v3/test | repos/range-v3/test/view/stride.cpp | // Range v3 library
//
// Copyright Eric Niebler 2014-present
//
// Use, modification and distribution is subject to the
// Boost Software License, Version 1.0. (See accompanying
// file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt)
//
// Project home: https://github.com/ericniebler/range-v3
#include <list>
#include <vector>
#include <sstream>
#include <range/v3/core.hpp>
#include <range/v3/view/istream.hpp>
#include <range/v3/view/move.hpp>
#include <range/v3/view/partial_sum.hpp>
#include <range/v3/view/reverse.hpp>
#include <range/v3/view/stride.hpp>
#include <range/v3/view/iota.hpp>
#include <range/v3/algorithm/copy.hpp>
#include <range/v3/iterator/operations.hpp>
#include <range/v3/iterator/insert_iterators.hpp>
#include <range/v3/iterator/stream_iterators.hpp>
#include <range/v3/numeric.hpp>
#include "../simple_test.hpp"
#include "../test_utils.hpp"
#include "../test_iterators.hpp"
// https://github.com/ericniebler/range-v3/issues/1291
void bug_1291()
{
std::vector<int> vec;
auto tx = vec | ranges::views::stride( 2 ) | ranges::views::partial_sum;
ranges::accumulate( tx, 0 );
}
int main()
{
using namespace ranges;
auto const v = []
{
std::vector<int> vec(50);
iota(vec, 0);
return vec;
}();
{
auto rng = v | views::stride(3);
using R = decltype(rng);
CPP_assert(random_access_range<R> && view_<R>);
CPP_assert(!contiguous_range<R>);
CPP_assert(common_range<R>);
CPP_assert(sized_range<R>);
CPP_assert(range<R const>);
::check_equal(rng | views::reverse,
{48, 45, 42, 39, 36, 33, 30, 27, 24, 21, 18, 15, 12, 9, 6, 3, 0});
}
{
std::stringstream str;
copy(v, ostream_iterator<int>{str, " "});
auto rng = istream<int>(str) | views::stride(3);
using R = decltype(rng);
CPP_assert(input_range<R> && view_<R>);
CPP_assert(!forward_range<R>);
CPP_assert(!common_range<R>);
CPP_assert(!sized_range<R>);
CPP_assert(!range<R const>);
check_equal(rng, {0, 3, 6, 9, 12, 15, 18, 21, 24, 27, 30, 33, 36, 39, 42, 45, 48});
}
{
std::list<int> li;
copy(v, back_inserter(li));
auto rng = li | views::stride(3);
using R = decltype(rng);
CPP_assert(bidirectional_range<R> && view_<R>);
CPP_assert(!random_access_range<R>);
CPP_assert(common_range<R>);
CPP_assert(sized_range<R>);
CPP_assert(range<R const>);
::check_equal(rng,
{0, 3, 6, 9, 12, 15, 18, 21, 24, 27, 30, 33, 36, 39, 42, 45, 48});
::check_equal(rng | views::reverse,
{48, 45, 42, 39, 36, 33, 30, 27, 24, 21, 18, 15, 12, 9, 6, 3, 0});
for(int i : rng | views::reverse)
std::cout << i << ' ';
std::cout << '\n';
}
{
auto x2 = v | views::stride(3);
CHECK(ranges::distance(x2) == 17);
auto it0 = x2.begin();
auto it1 = std::next(it0, 10);
CHECK((it1 - it0) == 10);
CHECK((it0 - it1) == -10);
CHECK((it0 - it0) == 0);
CHECK((it1 - it1) == 0);
}
{
const auto n = 4;
auto rng = v | views::move | views::stride(2);
CHECK((next(begin(rng), n) - begin(rng)) == n);
}
{
// Regression test #368
int n = 42;
(void)ranges::views::stride(n);
}
{
int const some_ints[] = {0,1,2,3,4,5,6,7};
auto rng = debug_input_view<int const>{some_ints} | views::stride(2);
using R = decltype(rng);
CPP_assert(input_range<R> && view_<R>);
CPP_assert(!forward_range<R>);
CPP_assert(!common_range<R>);
CPP_assert(sized_range<R>);
CPP_assert(!range<R const>);
::check_equal(rng, {0,2,4,6});
}
{
std::list<int> li;
copy(v, back_inserter(li));
subrange<std::list<int>::const_iterator> tmp{li.begin(), li.end()};
auto rng = tmp | views::stride(3);
using R = decltype(rng);
CPP_assert(bidirectional_range<R> && view_<R>);
CPP_assert(!random_access_range<R>);
CPP_assert(!common_range<R>);
CPP_assert(!sized_range<R>);
CPP_assert(!range<R const>);
::check_equal(rng,
{0, 3, 6, 9, 12, 15, 18, 21, 24, 27, 30, 33, 36, 39, 42, 45, 48});
::check_equal(rng | views::reverse,
{48, 45, 42, 39, 36, 33, 30, 27, 24, 21, 18, 15, 12, 9, 6, 3, 0});
}
{
std::list<int> li;
copy(v, back_inserter(li));
using CLI = std::list<int>::const_iterator;
subrange<CLI, CLI, subrange_kind::sized> tmp{li};
auto rng = tmp | views::stride(3);
using R = decltype(rng);
CPP_assert(bidirectional_range<R> && view_<R>);
CPP_assert(!random_access_range<R>);
CPP_assert(common_range<R>);
CPP_assert(sized_range<R>);
CPP_assert(range<R const>);
CHECK((*--rng.end()) == 48);
::check_equal(rng,
{0, 3, 6, 9, 12, 15, 18, 21, 24, 27, 30, 33, 36, 39, 42, 45, 48});
::check_equal(rng | views::reverse,
{48, 45, 42, 39, 36, 33, 30, 27, 24, 21, 18, 15, 12, 9, 6, 3, 0});
}
// https://github.com/ericniebler/range-v3/issues/901
{
auto r = views::iota( 0, 12 );
// Evenly divisible stride:
auto strided1 = r | views::stride(3);
::check_equal(strided1, {0, 3, 6, 9});
CHECK(strided1.size() == 4u);
CHECK(strided1.front() == 0);
CHECK(strided1[0] == 0);
CHECK(strided1.back() == 9);
CHECK(strided1[3] == 9);
CHECK(strided1[(int)strided1.size() - 1] == 9);
// Not evenly divisible stride:
auto strided2 = r | views::stride(5);
::check_equal(strided2, {0, 5, 10});
CHECK(strided2.size() == 3u);
CHECK(strided2.front() == 0);
CHECK(strided2[0] == 0);
CHECK(strided2.back() == 10);
CHECK(strided2[2] == 10);
CHECK(strided2[(int)strided2.size() - 1] == 10);
}
return ::test_result();
}
|
0 | repos/range-v3/test | repos/range-v3/test/view/adaptor.cpp | // Range v3 library
//
// Copyright Eric Niebler 2014-present
//
// Use, modification and distribution is subject to the
// Boost Software License, Version 1.0. (See accompanying
// file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt)
//
// Project home: https://github.com/ericniebler/range-v3
#include <list>
#include <vector>
#include <sstream>
#include <range/v3/core.hpp>
#include <range/v3/utility/copy.hpp>
#include <range/v3/view/delimit.hpp>
#include "../simple_test.hpp"
#include "../test_utils.hpp"
template<typename BidiRange>
struct my_reverse_view
: ranges::view_adaptor<my_reverse_view<BidiRange>, BidiRange>
{
private:
CPP_assert(ranges::bidirectional_range<BidiRange>);
CPP_assert(ranges::common_range<BidiRange>);
friend ranges::range_access;
using base_iterator_t = ranges::iterator_t<BidiRange>;
struct adaptor : ranges::adaptor_base
{
template<class base_mixin>
struct mixin : base_mixin
{
mixin() = default;
using base_mixin::base_mixin;
int mixin_int = 120;
int base_plus_adaptor() const
{
int y = this->get().t;
return *this->base() + y;
}
};
int t = 20;
// Cross-wire begin and end.
base_iterator_t begin(my_reverse_view const &rng) const
{
return ranges::end(rng.base());
}
base_iterator_t end(my_reverse_view const &rng) const
{
return ranges::begin(rng.base());
}
void next(base_iterator_t &it) const
{
--it;
}
void prev(base_iterator_t &it) const
{
++it;
}
ranges::range_reference_t<BidiRange> read(base_iterator_t it) const
{
return *ranges::prev(it);
}
CPP_member
auto advance(base_iterator_t &it,
ranges::range_difference_t<BidiRange> n) const ->
CPP_ret(void)(
requires ranges::random_access_range<BidiRange>)
{
it -= n;
}
CPP_member
auto distance_to(base_iterator_t const &here,
base_iterator_t const &there) const ->
CPP_ret(ranges::range_difference_t<BidiRange>)(
requires ranges::sized_sentinel_for<base_iterator_t, base_iterator_t>)
{
return here - there;
}
};
adaptor begin_adaptor() const
{
return {};
}
adaptor end_adaptor() const
{
return {};
}
public:
using my_reverse_view::view_adaptor::view_adaptor;
};
struct my_delimited_range
: ranges::view_adaptor<
my_delimited_range,
ranges::delimit_view<ranges::istream_view<int>, int>>
{
using view_adaptor::view_adaptor;
struct adaptor : ranges::adaptor_base
{
template<class base_mixin>
struct mixin : base_mixin
{
mixin() = default;
using base_mixin::base_mixin;
int mixin_int = 120;
int adaptor_access_test() const
{
int y = this->get().t;
return y;
}
};
int t = 20;
};
adaptor begin_adaptor() const
{
return {};
}
adaptor end_adaptor() const
{
return {};
}
};
int main()
{
using namespace ranges;
std::vector<int> v{1, 2, 3, 4};
my_reverse_view<std::vector<int>&> retro{v};
CPP_assert(common_range<decltype(retro)>);
CPP_assert(view_<decltype(retro)>);
CPP_assert(random_access_iterator<decltype(retro.begin())>);
::check_equal(retro, {4, 3, 2, 1});
// test cursor mixin
CHECK( retro.begin().mixin_int == 120 );
CHECK( *((retro.begin()+1).base()) == 4 );
CHECK( (retro.begin()+1).base_plus_adaptor() == 24 );
std::list<int> l{1, 2, 3, 4};
my_reverse_view<std::list<int>& > retro2{l};
CPP_assert(common_range<decltype(retro2)>);
CPP_assert(view_<decltype(retro2)>);
CPP_assert(bidirectional_iterator<decltype(retro2.begin())>);
CPP_assert(!random_access_iterator<decltype(retro2.begin())>);
::check_equal(retro2, {4, 3, 2, 1});
std::stringstream sinx("1 2 3 4 5 6 7 8 9 1 2 3 4 5 6 7 8 9 1 2 3 4 42 6 7 8 9 ");
my_delimited_range r{views::delimit(istream<int>(sinx), 42)};
CPP_assert(view_<decltype(r)>);
CPP_assert(!common_range<decltype(r)>);
CPP_assert(input_iterator<decltype(r.begin())>);
CPP_assert(!forward_iterator<decltype(r.begin())>);
::check_equal(r, {1, 2, 3, 4, 5, 6, 7, 8, 9, 1, 2, 3, 4, 5, 6, 7, 8, 9, 1, 2, 3, 4});
// test sentinel mixin
CHECK(r.end().mixin_int == 120);
CHECK(r.end().adaptor_access_test() == 20);
return ::test_result();
}
|
0 | repos/range-v3/test | repos/range-v3/test/view/move.cpp | // Range v3 library
//
// Copyright Eric Niebler 2014-present
//
// Use, modification and distribution is subject to the
// Boost Software License, Version 1.0. (See accompanying
// file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt)
//
// Project home: https://github.com/ericniebler/range-v3
#include <cstring>
#include <string>
#include <vector>
#include <range/v3/core.hpp>
#include <range/v3/view/move.hpp>
#include <range/v3/algorithm/copy.hpp>
#include <range/v3/iterator/operations.hpp>
#include <range/v3/utility/copy.hpp>
#include "../simple_test.hpp"
#include "../test_utils.hpp"
int main()
{
using namespace ranges;
static const char * const data[] = {"'allo", "'allo", "???"};
std::vector<MoveOnlyString> vs(begin(data), end(data));
auto x = vs | views::move;
{
CPP_assert(common_range<decltype(x)>);
CPP_assert(sized_range<decltype(x)>);
CPP_assert(view_<decltype(x)>);
CPP_assert(common_range<decltype(x)>);
CPP_assert(sized_range<decltype(x)>);
CPP_assert(random_access_iterator<decltype(x.begin())>);
using I = decltype(x.begin());
CPP_assert(same_as<iterator_tag_of<I>, std::random_access_iterator_tag>);
CPP_assert(same_as<
typename std::iterator_traits<I>::iterator_category,
std::random_access_iterator_tag>);
CHECK(bool(*x.begin() == "'allo"));
}
{
std::vector<MoveOnlyString> vs2(x.begin(), x.end());
static_assert(std::is_same<MoveOnlyString&&, decltype(*x.begin())>::value, "");
::check_equal(vs2, {"'allo", "'allo", "???"});
::check_equal(vs, {"", "", ""});
}
{
MoveOnlyString rgs[] = {"can", "you", "hear", "me", "now?"};
auto rng = debug_input_view<MoveOnlyString>{rgs} | views::move;
MoveOnlyString target[sizeof(rgs) / sizeof(rgs[0])];
copy(rng, target);
::check_equal(rgs, {"", "", "", "", ""});
::check_equal(target, {"can", "you", "hear", "me", "now?"});
}
return test_result();
}
|
0 | repos/range-v3/test | repos/range-v3/test/view/take.cpp | // Range v3 library
//
// Copyright Eric Niebler 2014-present
//
// Use, modification and distribution is subject to the
// Boost Software License, Version 1.0. (See accompanying
// file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt)
//
// Project home: https://github.com/ericniebler/range-v3
#include <list>
#include <vector>
#include <range/v3/core.hpp>
#include <range/v3/view/iota.hpp>
#include <range/v3/view/take.hpp>
#include <range/v3/view/reverse.hpp>
#include <range/v3/view/delimit.hpp>
#include <range/v3/utility/copy.hpp>
#include "../simple_test.hpp"
#include "../test_utils.hpp"
int main()
{
using namespace ranges;
int rgi[] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
auto rng0 = rgi | views::take(6);
has_type<int &>(*begin(rng0));
CPP_assert(view_<decltype(rng0)>);
CPP_assert(common_range<decltype(rng0)>);
CPP_assert(sized_range<decltype(rng0)>);
CPP_assert(random_access_iterator<decltype(begin(rng0))>);
CPP_assert(range<decltype(detail::as_const(rng0))>);
check_equal(rng0, {0, 1, 2, 3, 4, 5});
CHECK(size(rng0) == 6u);
auto rng0b = rgi | views::take(20);
has_type<int &>(*begin(rng0b));
CPP_assert(view_<decltype(rng0b)>);
CPP_assert(common_range<decltype(rng0b)>);
CPP_assert(sized_range<decltype(rng0b)>);
CPP_assert(random_access_iterator<decltype(begin(rng0b))>);
CPP_assert(range<decltype(detail::as_const(rng0b))>);
check_equal(rng0b, {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10});
CHECK(size(rng0b) == 11u);
auto rng1 = rng0 | views::reverse;
has_type<int &>(*begin(rng1));
CPP_assert(view_<decltype(rng1)>);
CPP_assert(common_range<decltype(rng1)>);
CPP_assert(sized_range<decltype(rng1)>);
CPP_assert(random_access_iterator<decltype(begin(rng1))>);
CPP_assert(range<decltype(detail::as_const(rng1))>);
check_equal(rng1, {5, 4, 3, 2, 1, 0});
std::vector<int> v{0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
auto rng2 = v | views::take(6) | views::reverse;
has_type<int &>(*begin(rng2));
CPP_assert(view_<decltype(rng2)>);
CPP_assert(common_range<decltype(rng2)>);
CPP_assert(sized_range<decltype(rng2)>);
CPP_assert(random_access_iterator<decltype(begin(rng2))>);
CPP_assert(range<decltype(detail::as_const(rng2))>);
check_equal(rng2, {5, 4, 3, 2, 1, 0});
std::list<int> l{0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
auto rng3 = l | views::take(6);
has_type<int &>(*begin(rng3));
CPP_assert(view_<decltype(rng3)>);
CPP_assert(!common_range<decltype(rng3)>);
CPP_assert(sized_range<decltype(rng3)>);
CPP_assert(bidirectional_iterator<decltype(begin(rng3))>);
CPP_assert(!random_access_iterator<decltype(begin(rng3))>);
CPP_assert(range<decltype(detail::as_const(rng3))>);
::check_equal(rng3, {0, 1, 2, 3, 4, 5});
CHECK(size(rng3) == 6u);
auto rng3b = l | views::take(20);
has_type<int &>(*begin(rng3b));
CPP_assert(view_<decltype(rng3b)>);
CPP_assert(!common_range<decltype(rng3b)>);
CPP_assert(sized_range<decltype(rng3b)>);
CPP_assert(bidirectional_iterator<decltype(begin(rng3b))>);
CPP_assert(!random_access_iterator<decltype(begin(rng3b))>);
CPP_assert(range<decltype(detail::as_const(rng3b))>);
check_equal(rng3b, {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10});
CHECK(size(rng3b) == 11u);
auto rng4 = views::iota(10) | views::take(10);
CPP_assert(view_<decltype(rng4)>);
CPP_assert(!common_range<decltype(rng4)>);
CPP_assert(sized_range<decltype(rng4)>);
CPP_assert(range<decltype(detail::as_const(rng4))>);
static_assert(!ranges::is_infinite<decltype(rng4)>::value, "");
check_equal(rng4, {10, 11, 12, 13, 14, 15, 16, 17, 18, 19});
CHECK(size(rng4) == 10u);
auto rng5 = views::iota(10) | views::take(10) | views::reverse;
CPP_assert(view_<decltype(rng5)>);
CPP_assert(common_range<decltype(rng5)>);
CPP_assert(sized_range<decltype(rng5)>);
CPP_assert(!range<decltype(detail::as_const(rng5))>);
static_assert(!ranges::is_infinite<decltype(rng5)>::value, "");
check_equal(rng5, {19, 18, 17, 16, 15, 14, 13, 12, 11, 10});
CHECK(size(rng5) == 10u);
auto c_str = views::delimit("hello world", '\0');
CPP_assert(random_access_range<decltype(c_str)>);
CPP_assert(!sized_range<decltype(c_str)>);
auto rng6 = c_str | views::take(5);
CPP_assert(view_<decltype(rng6)>);
CPP_assert(random_access_range<decltype(rng6)>);
CPP_assert(!common_range<decltype(rng6)>);
CPP_assert(!sized_range<decltype(rng6)>);
CPP_assert(range<decltype(detail::as_const(rng6))>);
check_equal(rng6, {'h','e','l','l','o'});
auto rng7 = c_str | views::take(20);
check_equal(rng7, {'h','e','l','l','o',' ','w','o','r','l','d'});
subrange<std::list<int>::iterator> rl{l.begin(), l.end()};
CPP_assert(view_<decltype(rl)>);
CPP_assert(bidirectional_range<decltype(rl)>);
CPP_assert(common_range<decltype(rl)>);
CPP_assert(!sized_range<decltype(rl)>);
CPP_assert(range<decltype(detail::as_const(rl))>);
auto rng8 = rl | views::take(5);
CPP_assert(view_<decltype(rng8)>);
CPP_assert(bidirectional_range<decltype(rng8)>);
CPP_assert(!common_range<decltype(rng8)>);
CPP_assert(!sized_range<decltype(rng8)>);
CPP_assert(range<decltype(detail::as_const(rng8))>);
check_equal(rng8, {0, 1, 2, 3, 4});
auto rng9 = rl | views::take(20);
CPP_assert(view_<decltype(rng9)>);
CPP_assert(bidirectional_range<decltype(rng9)>);
CPP_assert(!common_range<decltype(rng9)>);
CPP_assert(!sized_range<decltype(rng9)>);
CPP_assert(range<decltype(detail::as_const(rng9))>);
check_equal(rng9, {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10});
{
auto rng = debug_input_view<int const>{rgi} | views::take(6);
CPP_assert(!range<decltype(detail::as_const(rng))>);
check_equal(rng, {0, 1, 2, 3, 4, 5});
}
return test_result();
}
|
0 | repos/range-v3/test | repos/range-v3/test/view/any_view.cpp | // Range v3 library
//
// Copyright Eric Niebler 2014-present
//
// Use, modification and distribution is subject to the
// Boost Software License, Version 1.0. (See accompanying
// file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt)
//
// Project home: https://github.com/ericniebler/range-v3
#include <map>
#include <vector>
#include <range/v3/core.hpp>
#include <range/v3/utility/copy.hpp>
#include <range/v3/view/any_view.hpp>
#include <range/v3/view/iota.hpp>
#include <range/v3/view/map.hpp>
#include <range/v3/view/reverse.hpp>
#include <range/v3/view/tail.hpp>
#include <range/v3/view/take.hpp>
#include <range/v3/view/take_exactly.hpp>
#include "../simple_test.hpp"
#include "../test_utils.hpp"
namespace
{
template<typename S, typename T, typename = void>
struct can_convert_to : std::false_type
{};
template<typename S, typename T>
struct can_convert_to<
S, T, meta::void_<decltype(ranges::polymorphic_downcast<T>(std::declval<S>()))>>
: std::true_type
{};
void test_polymorphic_downcast()
{
struct A
{
virtual ~A() = default;
};
struct B : A
{};
struct unrelated
{};
struct incomplete;
CPP_assert(can_convert_to<B *, void *>());
CPP_assert(can_convert_to<A *, void *>());
CPP_assert(can_convert_to<B *, A *>());
CPP_assert(can_convert_to<A *, B *>());
CPP_assert(!can_convert_to<int, int>());
CPP_assert(!can_convert_to<A const *, A *>());
CPP_assert(!can_convert_to<A *, unrelated *>());
CPP_assert(!can_convert_to<unrelated *, A *>());
CPP_assert(!can_convert_to<incomplete *, incomplete *>());
CPP_assert(can_convert_to<B &, A &>());
CPP_assert(can_convert_to<A &, B &>());
CPP_assert(!can_convert_to<A &, unrelated &>());
CPP_assert(!can_convert_to<unrelated &, A &>());
CPP_assert(!can_convert_to<incomplete &, incomplete &>());
#if !defined(__GNUC__) || defined(__clang__) || __GNUC__ > 4
CPP_assert(can_convert_to<B &&, A &&>());
CPP_assert(can_convert_to<B &, A &&>());
#endif // old GCC dynamic_cast bug
CPP_assert(!can_convert_to<B &&, A &>());
CPP_assert(can_convert_to<A &&, B &&>());
CPP_assert(!can_convert_to<A &&, B &>());
CPP_assert(can_convert_to<A &, B &&>());
CPP_assert(!can_convert_to<A &&, unrelated &&>());
CPP_assert(!can_convert_to<A &&, unrelated &>());
CPP_assert(!can_convert_to<A &, unrelated &&>());
CPP_assert(!can_convert_to<unrelated &&, A &&>());
CPP_assert(!can_convert_to<unrelated &&, A &>());
CPP_assert(!can_convert_to<unrelated &, A &&>());
CPP_assert(!can_convert_to<incomplete &&, incomplete &&>());
CPP_assert(!can_convert_to<incomplete &&, incomplete &>());
CPP_assert(!can_convert_to<incomplete &, incomplete &&>());
}
} // unnamed namespace
int main()
{
using namespace ranges;
auto const ten_ints = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9};
{
any_view<int> ints = views::ints;
CPP_assert(input_range<decltype(ints)> && view_<decltype(ints)>);
CPP_assert(!(forward_range<decltype(ints)> && view_<decltype(ints)>));
::check_equal(std::move(ints) | views::take(10), ten_ints);
}
{
any_view<int> ints = views::ints | views::take_exactly(5);
CPP_assert(input_range<decltype(ints)> && view_<decltype(ints)>);
CPP_assert(!(random_access_range<decltype(ints)> && view_<decltype(ints)>));
CPP_assert(!(sized_range<decltype(ints)> && view_<decltype(ints)>));
static_assert((get_categories<decltype(ints)>() & category::random_access) ==
category::input,
"");
static_assert(
(get_categories<decltype(ints)>() & category::sized) == category::none, "");
}
{
#if RANGES_CXX_DEDUCTION_GUIDES >= RANGES_CXX_DEDUCTION_GUIDES_17
#if defined(__clang__) && __clang_major__ < 6
// Workaround https://bugs.llvm.org/show_bug.cgi?id=33314
RANGES_DIAGNOSTIC_PUSH
RANGES_DIAGNOSTIC_IGNORE_UNDEFINED_FUNC_TEMPLATE
#endif
any_view ints = views::ints | views::take_exactly(5);
#if defined(__clang__) && __clang_major__ < 6
RANGES_DIAGNOSTIC_POP
#endif
#else
any_view<int, category::random_access | category::sized> ints =
views::ints | views::take_exactly(5);
#endif
CPP_assert(random_access_range<decltype(ints)> && view_<decltype(ints)>);
CPP_assert(sized_range<decltype(ints)> && view_<decltype(ints)>);
static_assert((get_categories<decltype(ints)>() & category::random_access) ==
category::random_access,
"");
static_assert(
(get_categories<decltype(ints)>() & category::sized) == category::sized, "");
}
{
any_view<int, category::input | category::sized> ints =
views::ints | views::take_exactly(10);
CPP_assert(input_range<decltype(ints)> && view_<decltype(ints)>);
CPP_assert(sized_range<decltype(ints)> && view_<decltype(ints)>);
static_assert(
(get_categories<decltype(ints)>() & category::input) == category::input, "");
static_assert(
(get_categories<decltype(ints)>() & category::sized) == category::sized, "");
}
{
any_view<int, category::bidirectional> ints = views::ints;
CPP_assert(bidirectional_range<decltype(ints)> && view_<decltype(ints)>);
CPP_assert(!(random_access_range<decltype(ints)> && view_<decltype(ints)>));
static_assert((get_categories<decltype(ints)>() & category::random_access) ==
category::bidirectional,
"");
}
{
any_view<int> ints2 = views::ints | views::take(10);
::check_equal(ints2, ten_ints);
::check_equal(ints2, ten_ints);
}
{
any_view<int, category::random_access> ints3 = views::ints | views::take(10);
CPP_assert(view_<decltype(ints3)>);
CPP_assert(random_access_range<decltype(ints3)>);
CPP_assert(!common_range<decltype(ints3)>);
::check_equal(ints3, ten_ints);
::check_equal(ints3, ten_ints);
::check_equal(aux::copy(ints3), ten_ints);
::check_equal(ints3 | views::reverse, {9, 8, 7, 6, 5, 4, 3, 2, 1, 0});
}
{
any_view<int&> e;
CHECK(e.begin() == e.begin());
CHECK(e.begin() == e.end());
}
{
iterator_t<any_view<int&, category::random_access>> i{},j{};
sentinel_t<any_view<int&, category::random_access>> k{};
CHECK(i == j);
CHECK(i == k);
CHECK((i - j) == 0);
}
// Regression test for #446
{
auto vec = std::vector<short>{begin(ten_ints), end(ten_ints)};
::check_equal(any_view<int>{vec}, ten_ints);
::check_equal(any_view<int>{ranges::detail::as_const(vec)}, ten_ints);
struct Int
{
int i_;
Int(int i) : i_{i} {}
operator int() const { return i_; }
};
auto vec2 = std::vector<Int>{begin(ten_ints), end(ten_ints)};
::check_equal(any_view<int>{vec2}, ten_ints);
}
{
auto v = any_view<int>{debug_input_view<int const>{
ten_ints.begin(), std::ptrdiff_t(ten_ints.size())
}};
::check_equal(v, ten_ints);
}
// Regression test for #880
{
using namespace ranges;
std::map<int, int> mm{ {0, 1}, {2, 3} };
any_view<int, category::forward | category::sized> as_any =
mm | views::keys;
(void)as_any;
}
// Regression test for #1101
{
using namespace ranges;
std::vector<int> v = { 1, 2, 3, 4, 5 };
using SizedAnyView =
any_view<int, category::random_access | category::sized>;
SizedAnyView av1 = v;
SizedAnyView av2 = av1 | views::transform( [](auto){ return 0; } ); // fail
SizedAnyView av3 = av1 | views::tail; // fail
}
test_polymorphic_downcast();
return test_result();
}
|
0 | repos/range-v3/test | repos/range-v3/test/view/counted.cpp | // Range v3 library
//
// Copyright Eric Niebler 2014-present
//
// Use, modification and distribution is subject to the
// Boost Software License, Version 1.0. (See accompanying
// file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt)
//
// Project home: https://github.com/ericniebler/range-v3
#include <list>
#include <range/v3/core.hpp>
#include <range/v3/view/counted.hpp>
#include "../simple_test.hpp"
#include "../test_utils.hpp"
#include "../test_iterators.hpp"
struct fortytwo_erator {
using difference_type = int;
using value_type = int;
fortytwo_erator() = default;
int operator*() const { return 42; }
fortytwo_erator& operator++() { return *this; }
void operator++(int) {}
};
int main()
{
using namespace ranges;
std::cout << "\nTesting counted\n";
{
int rgi[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
auto rng = views::counted(ForwardIterator<int*>{rgi}, 10);
rng.size();
CPP_assert(sized_range<decltype(rng)> && view_<decltype(rng)>);
auto i = rng.begin();
auto b = i.base();
auto c = i.count();
decltype(i) j{b, c};
::check_equal(rng, {1, 2, 3, 4, 5, 6, 7, 8, 9, 10});
static_assert(std::is_same<decltype(i), counted_iterator<ForwardIterator<int*>>>::value, "");
}
{
std::list<int> l;
counted_iterator<std::list<int>::iterator> a(l.begin(), 0);
counted_iterator<std::list<int>::const_iterator> b(l.begin(), 0);
detail::ignore_unused(
a-a,
b-b,
a-b,
b-a);
counted_iterator<char*> c(nullptr, 0);
counted_iterator<char const*> d(nullptr, 0);
detail::ignore_unused(
c-c,
d-d,
c-d,
d-c);
}
{
// Regression test: ensure that we can post-increment a counted_iterator<I>
// when decltype(declval<I &>()++) is void.
CPP_assert(ranges::input_iterator<fortytwo_erator>);
ranges::counted_iterator<fortytwo_erator> c{{}, 42};
c++;
}
return ::test_result();
}
|
0 | repos/range-v3/test | repos/range-v3/test/view/repeat.cpp | // Range v3 library
//
// Copyright Eric Niebler 2014-present
//
// Use, modification and distribution is subject to the
// Boost Software License, Version 1.0. (See accompanying
// file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt)
//
// Project home: https://github.com/ericniebler/range-v3
#include <vector>
#include <range/v3/core.hpp>
#include <range/v3/view/take.hpp>
#include <range/v3/view/repeat.hpp>
#include <range/v3/utility/copy.hpp>
#include "../simple_test.hpp"
#include "../test_utils.hpp"
int main()
{
using namespace ranges;
auto rng = views::repeat(9) | views::take(10);
CPP_assert(view_<decltype(rng)>);
CPP_assert(sized_range<decltype(rng)>);
CPP_assert(random_access_iterator<decltype(rng.begin())>);
::check_equal(rng, {9, 9, 9, 9, 9, 9, 9, 9, 9, 9});
return test_result();
}
|
0 | repos/range-v3/test | repos/range-v3/test/view/set_union.cpp | // Range v3 library
//
// Copyright Eric Niebler 2014-present
// Copyright Tomislav Ivek 2015-2016
//
// Use, modification and distribution is subject to the
// Boost Software License, Version 1.0. (See accompanying
// file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt)
//
// Project home: https://github.com/ericniebler/range-v3
#include <vector>
#include <sstream>
#include <range/v3/core.hpp>
#include <range/v3/algorithm/set_algorithm.hpp>
#include <range/v3/algorithm/move.hpp>
#include <range/v3/functional/identity.hpp>
#include <range/v3/iterator/operations.hpp>
#include <range/v3/iterator/insert_iterators.hpp>
#include <range/v3/utility/common_type.hpp>
#include <range/v3/utility/copy.hpp>
#include <range/v3/view/all.hpp>
#include <range/v3/view/const.hpp>
#include <range/v3/view/drop_while.hpp>
#include <range/v3/view/iota.hpp>
#include <range/v3/view/move.hpp>
#include <range/v3/view/reverse.hpp>
#include <range/v3/view/set_algorithm.hpp>
#include <range/v3/view/stride.hpp>
#include <range/v3/view/take.hpp>
#include <range/v3/view/transform.hpp>
#include "../simple_test.hpp"
#include "../test_utils.hpp"
int main()
{
using namespace ranges;
int i1_finite[] = {1, 2, 2, 3, 3, 3, 4, 4, 4, 4};
int i2_finite[] = { -3, 2, 4, 4, 6, 9};
auto i1_infinite = views::ints | views::stride(3);
auto i2_infinite = views::ints | views::transform([](int x)
{
return x * x;
});
// simple identity check
{
::check_equal(views::set_union(i1_infinite, i1_infinite) | views::take(100), i1_infinite | views::take(100));
}
// union of two finite ranges/sets
{
auto res = views::set_union(i1_finite, i2_finite);
CPP_assert(view_<decltype(res)>);
CPP_assert(forward_range<decltype(res)>);
CPP_assert(!random_access_range<decltype(res)>);
CPP_assert(!common_range<decltype(res)>);
using R = decltype(res);
CPP_assert(same_as<range_value_t<R>, int>);
CPP_assert(same_as<range_reference_t<R>, int&>);
CPP_assert(same_as<decltype(iter_move(begin(res))), int&&>);
static_assert(range_cardinality<R>::value == ranges::finite, "Cardinality of union of finite ranges should be finite!");
::check_equal(res, {-3, 1, 2, 2, 3, 3, 3, 4, 4, 4, 4, 6, 9});
// check if the final result agrees with the greedy algorithm
std::vector<int> greedy_union;
set_union(i1_finite, i2_finite, back_inserter(greedy_union));
::check_equal(res, greedy_union);
auto it = begin(res);
CHECK(&*it == &*(begin(i2_finite)));
++it;
CHECK(&*it == &*(begin(i1_finite)));
}
// union of two infinite ranges
{
auto res = views::set_union(i1_infinite, i2_infinite);
CPP_assert(view_<decltype(res)>);
CPP_assert(forward_range<decltype(res)>);
CPP_assert(!random_access_range<decltype(res)>);
CPP_assert(!common_range<decltype(res)>);
using R = decltype(res);
CPP_assert(same_as<range_value_t<R>,
common_type_t<range_value_t<decltype(i1_infinite)>,
range_value_t<decltype(i2_infinite)>>>);
CPP_assert(same_as<range_reference_t<R>,
common_reference_t<range_reference_t<decltype(i1_infinite)>,
range_reference_t<decltype(i2_infinite)>>
>);
CPP_assert(same_as<range_rvalue_reference_t<R>,
common_reference_t<range_rvalue_reference_t<decltype(i1_infinite)>,
range_rvalue_reference_t<decltype(i2_infinite)>>
>);
static_assert(range_cardinality<R>::value == ranges::infinite, "Cardinality of union of infinite ranges should be infinite!");
::check_equal(res | views::take(6), {0, 1, 3, 4, 6, 9});
// check if the final result agrees with the greedy algorithm
std::vector<int> greedy_union;
set_union(i1_infinite | views::take(10), i2_infinite | views::take(10), back_inserter(greedy_union));
::check_equal(res | views::take(6), greedy_union | views::take(6));
}
// union of a finite and an infinite range
{
auto res = views::set_union(i1_finite, i2_infinite);
CPP_assert(view_<decltype(res)>);
CPP_assert(forward_range<decltype(res)>);
CPP_assert(!random_access_range<decltype(res)>);
CPP_assert(!common_range<decltype(res)>);
using R = decltype(res);
CPP_assert(same_as<range_value_t<R>, int>);
CPP_assert(same_as<range_reference_t<R>, int>); // our infinite range does not give out references
CPP_assert(same_as<range_rvalue_reference_t<R>, int>);
static_assert(range_cardinality<R>::value == ranges::infinite, "Cardinality of union with an infinite range should be infinite!");
::check_equal(res | views::take(5), {0, 1, 2, 2, 3});
}
// union of an infinite and a finite range
{
auto res = views::set_union(i1_infinite, i2_finite);
CPP_assert(view_<decltype(res)>);
CPP_assert(forward_range<decltype(res)>);
CPP_assert(!random_access_range<decltype(res)>);
CPP_assert(!common_range<decltype(res)>);
using R = decltype(res);
CPP_assert(same_as<range_value_t<R>, int>);
CPP_assert(same_as<range_reference_t<R>, int>); // our infinite range does not give out references
CPP_assert(same_as<range_rvalue_reference_t<R>, int>);
static_assert(range_cardinality<R>::value == ranges::infinite, "Cardinality of union with an infinite range should be infinite!");
::check_equal(res | views::take(7), {-3, 0, 2, 3, 4, 4, 6});
}
// unions involving unknown cardinalities
{
auto rng0 = views::iota(10) | views::drop_while([](int i)
{
return i < 25;
});
static_assert(range_cardinality<decltype(rng0)>::value == ranges::unknown, "");
auto res1 = views::set_union(i2_finite, rng0);
static_assert(range_cardinality<decltype(res1)>::value == ranges::unknown, "Union of a finite and unknown cardinality set should have unknown cardinality!");
auto res2 = views::set_union(rng0, i2_finite);
static_assert(range_cardinality<decltype(res2)>::value == ranges::unknown, "Union of an unknown and finite cardinality set should have unknown cardinality!");
auto res3 = views::set_union(i1_infinite, rng0);
static_assert(range_cardinality<decltype(res3)>::value == ranges::infinite, "Union of an infinite and unknown cardinality set should have infinite cardinality!");
auto res4 = views::set_union(rng0, i1_infinite);
static_assert(range_cardinality<decltype(res4)>::value == ranges::infinite, "Union of an unknown and infinite cardinality set should have infinite cardinality!");
auto res5 = views::set_union(rng0, rng0);
static_assert(range_cardinality<decltype(res5)>::value == ranges::unknown, "Union of two unknown cardinality sets should have unknown cardinality!");
::check_equal(res5 | views::take(100), rng0 | views::take(100));
}
// test const ranges
{
auto res1 = views::set_union(views::const_(i1_finite), views::const_(i2_finite));
using R1 = decltype(res1);
CPP_assert(same_as<range_value_t<R1>, int>);
CPP_assert(same_as<range_reference_t<R1>, const int&>);
CPP_assert(same_as<range_rvalue_reference_t<R1>, const int&&>);
auto res2 = views::set_union(views::const_(i1_finite), i2_finite);
using R2 = decltype(res2);
CPP_assert(same_as<range_value_t<R2>, int>);
CPP_assert(same_as<range_reference_t<R2>, const int&>);
CPP_assert(same_as<range_rvalue_reference_t<R2>, const int&&>);
}
// test different orderings
{
auto res = views::set_union(views::reverse(i1_finite), views::reverse(i2_finite), [](int a, int b)
{
return a > b;
});
::check_equal(res, {9, 6, 4, 4, 4, 4, 3, 3, 3, 2, 2, 1, -3});
}
struct B
{
int val;
B(int i): val{i} {}
bool operator==(const B& other) const
{
return val == other.val;
}
};
struct D: public B
{
D(int i): B{i} {}
D(B b): B{std::move(b)} {}
};
B b_finite[] = {B{-20}, B{-10}, B{1}, B{3}, B{3}, B{6}, B{8}, B{20}};
D d_finite[] = {D{0}, D{2}, D{4}, D{6}};
// sets with different element types, custom orderings
{
auto res = views::set_union(b_finite, d_finite, [](const B& a, const D& b){ return a.val < b.val; });
using R = decltype(res);
CPP_assert(same_as<range_value_t<R>, B>);
CPP_assert(same_as<range_reference_t<R>, B&>);
CPP_assert(same_as<range_rvalue_reference_t<R>, B&&>);
::check_equal(res, {B{-20}, B{-10}, B{0}, B{1}, B{2}, B{3}, B{3}, B{4}, B{6}, B{8}, B{20}});
auto it = begin(res);
CHECK(&*it == &*begin(b_finite));
advance(it, 2);
CHECK(&*it == &*begin(d_finite));
}
// projections
{
auto res1 = views::set_union(b_finite, d_finite,
less(),
&B::val,
&D::val
);
using R1 = decltype(res1);
CPP_assert(same_as<range_value_t<R1>, B>);
CPP_assert(same_as<range_reference_t<R1>, B&>);
CPP_assert(same_as<range_rvalue_reference_t<R1>, B&&>);
::check_equal(res1, {B{-20}, B{-10}, B{0}, B{1}, B{2}, B{3}, B{3}, B{4}, B{6}, B{8}, B{20}});
auto res2 = views::set_union(views::ints(-2, 10), b_finite,
less(),
identity(),
[](const B& x){ return x.val; }
);
using R2 = decltype(res2);
CPP_assert(same_as<range_value_t<R2>, B>);
CPP_assert(same_as<range_reference_t<R2>, B>);
CPP_assert(same_as<range_rvalue_reference_t<R2>, B>);
::check_equal(res2, {B{-20}, B{-10}, B{-2}, B{-1}, B{0}, B{1}, B{2}, B{3}, B{3}, B{4}, B{5}, B{6}, B{7}, B{8}, B{9}, B{20}});
}
// move
{
auto v0 = to<std::vector<MoveOnlyString>>({"a","b","c","x"});
auto v1 = to<std::vector<MoveOnlyString>>({"b","x","y","z"});
auto res = views::set_union(v0, v1, [](const MoveOnlyString& a, const MoveOnlyString& b){return a<b;});
std::vector<MoveOnlyString> expected;
move(res, back_inserter(expected));
::check_equal(expected, {"a","b","c","x","y","z"});
::check_equal(v0, {"","","",""});
::check_equal(v1, {"b","x","",""});
using R = decltype(res);
CPP_assert(same_as<range_value_t<R>, MoveOnlyString>);
CPP_assert(same_as<range_reference_t<R>, MoveOnlyString &>);
CPP_assert(same_as<range_rvalue_reference_t<R>, MoveOnlyString &&>);
}
// iterator (in)equality
{
int r1[] = {1, 2, 3};
int r2[] = { 2, 3, 4, 5};
auto res = views::set_union(r1, r2); // 1, 2, 3, 4, 5
auto it1 = ranges::next(res.begin(), 3); // *it1 == 4, member iterator into r1 points to r1.end()
auto it2 = ranges::next(it1); // *it2 == 5, member iterator into r1 also points to r1.end()
auto sentinel = res.end();
CHECK(*it1 == 4);
CHECK(*it2 == 5);
CHECK(it1 != it2); // should be different even though member iterators into r1 are the same
CHECK(it1 != sentinel);
CHECK(ranges::next(it1, 2) == sentinel);
CHECK(it2 != sentinel);
CHECK(ranges::next(it2, 1) == sentinel);
}
{
auto rng = views::set_union(
debug_input_view<int const>{i1_finite},
debug_input_view<int const>{i2_finite}
);
::check_equal(rng, {-3, 1, 2, 2, 3, 3, 3, 4, 4, 4, 4, 6, 9});
}
return test_result();
}
|
0 | repos/range-v3/test | repos/range-v3/test/view/exclusive_scan.cpp | // Range v3 library
//
// Copyright Mitsutaka Takeda 2018-present
//
// Use, modification and distribution is subject to the
// Boost Software License, Version 1.0. (See accompanying
// file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt)
//
// Project home: https://github.com/ericniebler/range-v3
//
#include <vector>
#include <range/v3/utility/copy.hpp>
#include <range/v3/view/exclusive_scan.hpp>
#include "../test_utils.hpp"
int main()
{
using namespace ranges;
{// For non empty range.
int rgi[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
{
auto rng = rgi | views::exclusive_scan(0);
has_type<int &>(*begin(rgi));
has_type<int>(*begin(rng));
CPP_assert(view_<decltype(rng)>);
CPP_assert(sized_range<decltype(rng)>);
CPP_assert(forward_range<decltype(rng)>);
CPP_assert(!bidirectional_range<decltype(rng)>);
::check_equal(rng, {0, 1, 3, 6, 10, 15, 21, 28, 36, 45});
}
{// Test exclusive_scan with a mutable lambda
int cnt = 0;
auto mutable_rng = views::exclusive_scan(rgi, 0, [cnt](int i, int j) mutable {return i + j + cnt++;});
::check_equal(mutable_rng, {0, 1, 4, 9, 16, 25, 36, 49, 64, 81});
CPP_assert(view_<decltype(mutable_rng)>);
CPP_assert(!view_<decltype(mutable_rng) const>);
}
}
{// For an empty range.
std::vector<int> rgi;
auto rng = rgi | views::exclusive_scan(0);
has_type<int>(*begin(rng));
CPP_assert(view_<decltype(rng)>);
CPP_assert(sized_range<decltype(rng)>);
CPP_assert(forward_range<decltype(rng)>);
CPP_assert(!bidirectional_range<decltype(rng)>);
CHECK(empty(rng));
}
return test_result();
}
|
0 | repos/range-v3/test | repos/range-v3/test/view/take_while.cpp | // Range v3 library
//
// Copyright Eric Niebler 2014-present
//
// Use, modification and distribution is subject to the
// Boost Software License, Version 1.0. (See accompanying
// file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt)
//
// Project home: https://github.com/ericniebler/range-v3
#include <vector>
#include <range/v3/core.hpp>
#include <range/v3/view/iota.hpp>
#include <range/v3/view/generate.hpp>
#include <range/v3/view/take_while.hpp>
#include <range/v3/utility/copy.hpp>
#include "../simple_test.hpp"
#include "../test_utils.hpp"
struct my_data
{
int i;
};
bool operator==(my_data left, my_data right)
{
return left.i == right.i;
}
int main()
{
using namespace ranges;
auto rng0 = views::iota(10) | views::take_while([](int i) { return i != 25; });
::check_equal(rng0, {10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24});
CPP_assert(view_<decltype(rng0)>);
CPP_assert(!common_range<decltype(rng0)>);
CPP_assert(random_access_iterator<decltype(rng0.begin())>);
std::vector<int> vi{0, 1, 2, 3, 4, 5, 6, 7, 8, 9};
auto rng1 = vi | views::take_while([](int i) { return i != 50; });
CPP_assert(view_<decltype(rng1)>);
CPP_assert(random_access_range<decltype(rng1)>);
::check_equal(rng1, {0, 1, 2, 3, 4, 5, 6, 7, 8, 9});
// Check with a mutable predicate
int rgi[] = {0,1,2,3,4,5,6,7,8,9};
int cnt = 0;
auto mutable_only = views::take_while(rgi, [cnt](int) mutable { return ++cnt <= 5;});
::check_equal(mutable_only, {0,1,2,3,4});
CPP_assert(view_<decltype(mutable_only)>);
CPP_assert(!view_<decltype(mutable_only) const>);
{
auto ns = views::generate([]() mutable {
static int N;
return ++N;
});
auto rng = ns | views::take_while([](int i) { return i < 5; });
::check_equal(rng, {1,2,3,4});
}
{
auto ns = views::generate([]() mutable {
static int N;
return ++N;
});
auto rng = ns | views::take_while([](int i) mutable { return i < 5; });
::check_equal(rng, {1,2,3,4});
}
{
auto rng = debug_input_view<int const>{rgi} | views::take_while([](int i) {
return i != 5;
});
::check_equal(rng, {0,1,2,3,4});
}
{
auto ns = views::generate([]() {
static int N;
return my_data{++N};
});
auto rng = ns | views::take_while([](int i) { return i < 5; },
&my_data::i);
::check_equal(rng, std::vector<my_data>{{1},{2},{3},{4}});
}
return test_result();
}
|
0 | repos/range-v3/test | repos/range-v3/test/view/remove.cpp | /// \file
// Range v3 library
//
// Copyright Andrey Diduh 2019
//
// Use, modification and distribution is subject to the
// Boost Software License, Version 1.0. (See accompanying
// file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt)
//
// Project home: https://github.com/ericniebler/range-v3
//
#include <vector>
#include <range/v3/view/remove.hpp>
#include <range/v3/view/remove_if.hpp>
#include "../simple_test.hpp"
#include "../test_utils.hpp"
using namespace ranges;
void test_straight()
{
std::vector<int> vec = {1,2,3,4,5};
auto out = vec | views::remove(2);
::check_equal(out, {1,3,4,5});
}
struct Int
{
int i;
};
bool operator==(Int left, Int right)
{
return left.i == right.i;
}
void test_proj()
{
const std::vector<Int> vec{ Int{1}, Int{2}, Int{3}, Int{4}, Int{5} };
auto out = vec | views::remove(2, &Int::i);
::check_equal(out, {Int{1}, Int{3}, Int{4}, Int{5}});
}
int main()
{
// simple interface tests.
// All other already tested in remove_if.
test_straight();
test_proj();
return test_result();
}
|
0 | repos/range-v3/test | repos/range-v3/test/view/cycle.cpp | // Range v3 library
//
// Copyright Eric Niebler 2013-present
// Copyright Gonzalo Brito Gadeschi 2015
//
// Use, modification and distribution is subject to the
// Boost Software License, Version 1.0. (See accompanying
// file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt)
//
// Project home: https://github.com/ericniebler/range-v3
#include <list>
#include <array>
#include <vector>
#include <memory>
#include <forward_list>
#include <range/v3/range_for.hpp>
#include <range/v3/algorithm/count_if.hpp>
#include <range/v3/view/cycle.hpp>
#include <range/v3/view/take.hpp>
#include <range/v3/view/take_exactly.hpp>
#include <range/v3/view/iota.hpp>
#include <range/v3/view/reverse.hpp>
#include <range/v3/view/slice.hpp>
#include <range/v3/view/c_str.hpp>
#include "../simple_test.hpp"
#include "../test_utils.hpp"
using namespace ranges;
template<typename Rng>
void test_const_forward_range(Rng const &rng)
{
auto r = rng | views::cycle;
static_assert(is_infinite<decltype(r)>{}, "");
static_assert(!common_range<decltype(r)>, "");
CHECK(distance(r | views::take_exactly(0)) == 0);
CHECK(distance(r | views::take_exactly(1)) == 1);
CHECK(distance(r | views::take_exactly(2)) == 2);
CHECK(distance(r | views::take_exactly(3)) == 3);
CHECK(distance(r | views::take_exactly(4)) == 4);
CHECK(distance(r | views::take_exactly(6)) == 6);
CHECK(distance(r | views::take_exactly(7)) == 7);
CHECK(count_if(r | views::take_exactly(7), [](int) { return true; }) == 7);
::check_equal(r | views::take_exactly(0), std::array<int, 0>{});
::check_equal(r | views::take_exactly(1), {0});
::check_equal(r | views::take_exactly(2), {0, 1});
::check_equal(r | views::take_exactly(3), {0, 1, 2});
::check_equal(r | views::take_exactly(4), {0, 1, 2, 0});
::check_equal(r | views::take_exactly(6), {0, 1, 2, 0, 1, 2});
::check_equal(r | views::take_exactly(7), {0, 1, 2, 0, 1, 2, 0});
CHECK(distance(r | views::take(0)) == 0);
CHECK(distance(r | views::take(1)) == 1);
CHECK(distance(r | views::take(2)) == 2);
CHECK(distance(r | views::take(3)) == 3);
CHECK(distance(r | views::take(4)) == 4);
CHECK(distance(r | views::take(6)) == 6);
CHECK(distance(r | views::take(7)) == 7);
CHECK(count_if(r | views::take(7), [](int) { return true; }) == 7);
::check_equal(r | views::take(0), std::array<int, 0>{});
::check_equal(r | views::take(1), {0});
::check_equal(r | views::take(2), {0, 1});
::check_equal(r | views::take(3), {0, 1, 2});
::check_equal(r | views::take(4), {0, 1, 2, 0});
::check_equal(r | views::take(6), {0, 1, 2, 0, 1, 2});
::check_equal(r | views::take(7), {0, 1, 2, 0, 1, 2, 0});
}
template<typename Rng>
void test_const_forward_reversed_range(Rng const &rng)
{
test_const_forward_range(rng);
auto r = rng | views::reverse | views::cycle;
static_assert(is_infinite<decltype(r)>{}, "");
static_assert(!common_range<decltype(r)>, "");
CHECK(distance(r | views::take_exactly(0)) == 0);
CHECK(distance(r | views::take_exactly(1)) == 1);
CHECK(distance(r | views::take_exactly(2)) == 2);
CHECK(distance(r | views::take_exactly(3)) == 3);
CHECK(distance(r | views::take_exactly(4)) == 4);
CHECK(distance(r | views::take_exactly(6)) == 6);
CHECK(distance(r | views::take_exactly(7)) == 7);
CHECK(count_if(r | views::take_exactly(7), [](int) { return true; }) == 7);
::check_equal(r | views::take_exactly(0), std::array<int, 0>{});
::check_equal(r | views::take_exactly(1), {2});
::check_equal(r | views::take_exactly(2), {2, 1});
::check_equal(r | views::take_exactly(3), {2, 1, 0});
::check_equal(r | views::take_exactly(4), {2, 1, 0, 2});
::check_equal(r | views::take_exactly(6), {2, 1, 0, 2, 1, 0});
::check_equal(r | views::take_exactly(7), {2, 1, 0, 2, 1, 0, 2});
CHECK(distance(r | views::take(0)) == 0);
CHECK(distance(r | views::take(1)) == 1);
CHECK(distance(r | views::take(2)) == 2);
CHECK(distance(r | views::take(3)) == 3);
CHECK(distance(r | views::take(4)) == 4);
CHECK(distance(r | views::take(6)) == 6);
CHECK(distance(r | views::take(7)) == 7);
CHECK(count_if(r | views::take(7), [](int) { return true; }) == 7);
::check_equal(r | views::take(0), std::array<int, 0>{});
::check_equal(r | views::take(1), {2});
::check_equal(r | views::take(2), {2, 1});
::check_equal(r | views::take(3), {2, 1, 0});
::check_equal(r | views::take(4), {2, 1, 0, 2});
::check_equal(r | views::take(6), {2, 1, 0, 2, 1, 0});
::check_equal(r | views::take(7), {2, 1, 0, 2, 1, 0, 2});
}
template<typename Rng>
void test_mutable_forward_range_reversed(Rng &rng)
{
test_const_forward_reversed_range(rng);
int count = 2;
RANGES_FOR(auto &&i, rng | views::cycle | views::take_exactly(6)) { i = ++count; }
::check_equal(rng | views::take_exactly(3), {6, 7, 8});
}
template<typename Rng>
void test_forward_it(Rng const &rng)
{
auto r = rng | views::cycle;
static_assert(forward_range<decltype(r)>, "");
auto f = begin(r);
static_assert(forward_iterator<decltype(f)>, "");
CHECK((*f) == 0);
auto n = next(f, 1);
CHECK((*n) == 1);
}
template<typename Rng>
void test_bidirectional_it(Rng const &rng)
{
test_forward_it(rng);
auto r = rng | views::cycle;
static_assert(bidirectional_range<decltype(r)>, "");
auto f = begin(r);
static_assert(bidirectional_iterator<decltype(f)>, "");
CHECK((*f) == 0);
auto n = next(f, 1);
CHECK((*n) == 1);
CHECK((--n) == f);
}
template<typename Rng>
void test_random_access_it(Rng const &rng)
{
test_bidirectional_it(rng);
auto r = rng | views::cycle;
static_assert(random_access_range<decltype(r)>, "");
auto f = begin(r);
static_assert(random_access_iterator<decltype(f)>, "");
auto m = begin(r) + 1;
auto l = begin(r) + 2;
auto f1 = begin(r) + 3;
auto f2 = begin(r) + 6;
CHECK(r[0] == 0);
CHECK(r[1] == 1);
CHECK(r[2] == 2);
CHECK(r[3] == 0);
CHECK(r[4] == 1);
CHECK(r[5] == 2);
CHECK((f + 3) == f1);
CHECK((f + 6) == f2);
CHECK((f1 + 3) == f2);
CHECK((f2 - 3) == f1);
CHECK((f2 - 6) == f);
auto e = end(r);
CHECK(*f == 0);
CHECK(f[0] == 0);
CHECK(f[1] == 1);
CHECK(f[2] == 2);
CHECK(f[3] == 0);
CHECK(f[4] == 1);
CHECK(f[5] == 2);
CHECK(*m == 1);
CHECK(m[0] == 1);
CHECK(m[1] == 2);
CHECK(m[2] == 0);
CHECK(m[3] == 1);
CHECK(m[4] == 2);
CHECK(m[5] == 0);
CHECK(m[-1] == 0);
CHECK(*l == 2);
CHECK(l[0] == 2);
CHECK(l[1] == 0);
CHECK(l[2] == 1);
CHECK(l[3] == 2);
CHECK(l[4] == 0);
CHECK(l[5] == 1);
CHECK(l[-1] == 1);
CHECK(l[-2] == 0);
CHECK(f != e);
auto cur = f;
for (int i = 0; i < 100; ++i, ++cur)
{
CHECK((next(begin(r), i) - f) == i);
CHECK((cur - f) == i);
if(i > 0)
CHECK((cur - m) == i - 1);
if(i > 1)
CHECK((cur - l) == i - 2);
}
}
int main()
{
// initializer list
{
auto il = {0, 1, 2};
test_random_access_it(il);
test_const_forward_reversed_range(il);
const auto cil = {0, 1, 2};
test_random_access_it(cil);
test_const_forward_reversed_range(cil);
}
// array
{
std::array<int, 3> a = {{0, 1, 2}};
test_random_access_it(a);
test_mutable_forward_range_reversed(a);
const std::array<int, 3> ca = {{0, 1, 2}};
test_random_access_it(ca);
test_const_forward_reversed_range(ca);
}
// list
{
std::list<int> l = {0, 1, 2};
test_bidirectional_it(l);
test_mutable_forward_range_reversed(l);
const std::list<int> cl = {0, 1, 2};
test_bidirectional_it(cl);
test_const_forward_reversed_range(cl);
}
// forward list
{
std::forward_list<int> l = {0, 1, 2};
test_forward_it(l);
test_const_forward_range(l);
const std::forward_list<int> cl = {0, 1, 2};
test_forward_it(cl);
test_const_forward_range(cl);
}
// move-only types
{
std::array<std::unique_ptr<int>, 3> a = {{
std::unique_ptr<int>(new int(0)),
std::unique_ptr<int>(new int(1)),
std::unique_ptr<int>(new int(2))
}};
auto r = a | views::cycle;
auto b = iter_move(r.begin() + 4);
CHECK((*(b)) == 1);
}
// infinite
{
int count = 0;
auto il = {0, 1, 2};
auto v = 10;
RANGES_FOR(auto&& i, il | views::cycle)
{
if (count == 42) { break; }
v = i;
++count;
}
CHECK(count == 42);
CHECK(v == 2);
}
// non-bounded
{
auto sz = views::c_str((char const *)"hi! ");
::check_equal(
sz | views::cycle | views::take(10),
{'h','i','!',' ','h','i','!',' ','h','i'} );
auto rng = sz | views::cycle;
auto it = ranges::begin(rng);
CHECK(*it == 'h');
CHECK(*++it == 'i');
CHECK(*++it == '!');
CHECK(*++it == ' ');
CHECK(*++it == 'h');
CHECK(*--it == ' ');
CHECK(*--it == '!');
CHECK(*--it == 'i');
CHECK(*--it == 'h');
rng = sz | views::cycle;
it = ranges::begin(rng);
it += 4;
CHECK(*it == 'h');
}
// Cycle of an infinite range,
// https://github.com/ericniebler/range-v3/issues/780
{
auto view = ranges::views::iota(0)
| ranges::views::cycle;
CHECK(view[5] == 5);
}
// Composing ranges::views::cycle with ranges::views::slice
// https://github.com/ericniebler/range-v3/issues/778
{
const auto length = 512;
const auto k = 16;
std::vector<int> input(length);
auto output = ranges::views::cycle(input)
| ranges::views::slice(length + k, 2 * length + k);
CHECK(bool(ranges::begin(output) != ranges::end(output)));
CHECK(ranges::size(output) == 512u);
CHECK(ranges::distance(output) == 512);
}
return test_result();
}
|
0 | repos/range-v3/test | repos/range-v3/test/view/take_exactly.cpp | // Range v3 library
//
// Copyright Eric Niebler 2014-present
//
// Use, modification and distribution is subject to the
// Boost Software License, Version 1.0. (See accompanying
// file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt)
//
// Project home: https://github.com/ericniebler/range-v3
#include <list>
#include <vector>
#include <range/v3/core.hpp>
#include <range/v3/view/iota.hpp>
#include <range/v3/view/take_exactly.hpp>
#include <range/v3/view/reverse.hpp>
#include <range/v3/utility/copy.hpp>
#include "../simple_test.hpp"
#include "../test_utils.hpp"
int main()
{
using namespace ranges;
int rgi[] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
auto rng0 = rgi | views::take_exactly(6);
has_type<int &>(*begin(rng0));
CPP_assert(view_<decltype(rng0)>);
CPP_assert(common_range<decltype(rng0)>);
CPP_assert(sized_range<decltype(rng0)>);
CPP_assert(random_access_iterator<decltype(begin(rng0))>);
::check_equal(rng0, {0, 1, 2, 3, 4, 5});
CHECK(size(rng0) == 6u);
auto rng1 = rng0 | views::reverse;
has_type<int &>(*begin(rng1));
CPP_assert(view_<decltype(rng1)>);
CPP_assert(common_range<decltype(rng1)>);
CPP_assert(sized_range<decltype(rng1)>);
CPP_assert(random_access_iterator<decltype(begin(rng1))>);
::check_equal(rng1, {5, 4, 3, 2, 1, 0});
std::vector<int> v{0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
auto rng2 = v | views::take_exactly(6) | views::reverse;
has_type<int &>(*begin(rng2));
CPP_assert(view_<decltype(rng2)>);
CPP_assert(common_range<decltype(rng2)>);
CPP_assert(sized_range<decltype(rng2)>);
CPP_assert(random_access_iterator<decltype(begin(rng2))>);
::check_equal(rng2, {5, 4, 3, 2, 1, 0});
std::list<int> l{0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
auto rng3 = l | views::take_exactly(6);
has_type<int &>(*begin(rng3));
CPP_assert(view_<decltype(rng3)>);
CPP_assert(!common_range<decltype(rng3)>);
CPP_assert(sized_range<decltype(rng3)>);
CPP_assert(bidirectional_iterator<decltype(begin(rng3))>);
CPP_assert(!random_access_iterator<decltype(begin(rng3))>);
::check_equal(rng3, {0, 1, 2, 3, 4, 5});
auto rng4 = views::iota(10) | views::take_exactly(10);
CPP_assert(view_<decltype(rng4)>);
CPP_assert(common_range<decltype(rng4)>);
CPP_assert(sized_range<decltype(rng4)>);
static_assert(!ranges::is_infinite<decltype(rng4)>::value, "");
::check_equal(rng4, {10, 11, 12, 13, 14, 15, 16, 17, 18, 19});
CHECK(size(rng4) == 10u);
auto rng5 = views::iota(10) | views::take_exactly(10) | views::reverse;
CPP_assert(view_<decltype(rng5)>);
CPP_assert(common_range<decltype(rng5)>);
CPP_assert(sized_range<decltype(rng5)>);
static_assert(!ranges::is_infinite<decltype(rng5)>::value, "");
::check_equal(rng5, {19, 18, 17, 16, 15, 14, 13, 12, 11, 10});
CHECK(size(rng5) == 10u);
{
auto rng = debug_input_view<int const>{rgi} | views::take_exactly(6);
::check_equal(rng, {0, 1, 2, 3, 4, 5});
}
return test_result();
}
|
0 | repos/range-v3/test | repos/range-v3/test/view/cartesian_product.cpp | /// \file
// Range v3 library
//
// Copyright Eric Niebler 2013-2014.
// Copyright Casey Carter 2017.
//
// Use, modification and distribution is subject to the
// Boost Software License, Version 1.0. (See accompanying
// file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt)
//
// Project home: https://github.com/ericniebler/range-v3
//
#include <climits>
#include <iostream>
#include <range/v3/range/access.hpp>
#include <range/v3/range/primitives.hpp>
#include <range/v3/range_for.hpp>
#include <range/v3/view/span.hpp>
#include <range/v3/utility/tuple_algorithm.hpp>
#include <range/v3/view/cartesian_product.hpp>
#include <range/v3/view/chunk.hpp>
#include <range/v3/view/empty.hpp>
#include <range/v3/view/filter.hpp>
#include <range/v3/view/indices.hpp>
#include <range/v3/view/iota.hpp>
#include <range/v3/view/reverse.hpp>
#include <range/v3/view/single.hpp>
#include <range/v3/view/take_exactly.hpp>
#include <range/v3/view/transform.hpp>
#include <range/v3/view/filter.hpp>
#include <range/v3/view/enumerate.hpp>
#include "../simple_test.hpp"
#include "../test_utils.hpp"
RANGES_DIAGNOSTIC_IGNORE_RANGE_LOOP_ANALYSIS
using namespace ranges;
struct printer
{
std::ostream &os_;
bool &first_;
template<typename T>
void operator()(T const &t) const
{
if (first_) first_ = false;
else os_ << ',';
os_ << t;
}
};
namespace std
{
template<typename... Ts>
std::ostream &operator<<(std::ostream &os, std::tuple<Ts...> const &t)
{
os << '(';
auto first = true;
::ranges::tuple_for_each(t, ::printer{os, first});
os << ')';
return os;
}
}
void test_empty_set()
{
auto rng = views::cartesian_product();
using Rng = decltype(rng);
CPP_assert(range_cardinality<Rng>::value ==
static_cast<cardinality>(0));
CPP_assert(random_access_range<Rng> && view_<Rng>);
CPP_assert(common_range<Rng>);
CPP_assert(sized_range<Rng>);
CHECK(size(rng) == 0u);
CHECK(empty(rng));
CPP_assert(std::is_same<
range_value_t<Rng>,
std::tuple<>>());
CPP_assert(std::is_same<
range_reference_t<Rng>,
std::tuple<>&>());
std::initializer_list<common_tuple<>> control{};
::check_equal(rng, control);
::check_equal(views::reverse(rng), views::reverse(control));
auto const first = begin(rng);
auto const last = end(rng);
CHECK(decltype(size(rng))(last - first) == size(rng));
for(auto i = 0; i <= distance(rng); ++i)
{
for(auto j = 0; j <= distance(rng); ++j)
{
CHECK((next(first, i) - next(first, j)) == i - j);
}
}
}
void test_empty_range()
{
int some_ints[] = {0,1,2,3};
auto e = views::empty<char>;
auto rng = views::cartesian_product(
span<int, size(some_ints)>{some_ints},
e
);
using Rng = decltype(rng);
CPP_assert(range_cardinality<Rng>::value ==
static_cast<cardinality>(0));
CPP_assert(random_access_range<Rng> && view_<Rng>);
CPP_assert(common_range<Rng>);
CPP_assert(sized_range<Rng>);
CHECK(size(rng) == 0u);
CPP_assert(std::is_same<
range_value_t<Rng>,
std::tuple<int, char>>());
CPP_assert(std::is_same<
range_reference_t<Rng>,
common_tuple<int &, char &>>());
using CT = common_tuple<int, char>;
std::initializer_list<CT> control = {};
::check_equal(rng, control);
::check_equal(views::reverse(rng), views::reverse(control));
auto const first = begin(rng);
auto const last = end(rng);
CHECK((last - first) == (std::intmax_t) size(rng));
for(auto i = 0; i <= distance(rng); ++i)
{
for(auto j = 0; j <= distance(rng); ++j)
{
CHECK((next(first, i) - next(first, j)) == i - j);
}
}
}
void test_bug_820()
{
// https://github.com/ericniebler/range-v3/issues/820
using CT = common_tuple<int, int>;
std::initializer_list<CT> control = {
CT{0, 0}, CT{0, 1}, CT{0, 2},
CT{1, 0}, CT{1, 1}, CT{1, 2},
CT{2, 0}, CT{2, 1}, CT{2, 2}
};
auto x = ranges::views::iota(0) | ranges::views::take_exactly(3);
auto y = ranges::views::cartesian_product(x, x);
::check_equal(y, control);
}
void test_bug_823()
{
// https://github.com/ericniebler/range-v3/issues/823
auto three = ranges::views::iota(0) | ranges::views::take_exactly(3);
CPP_assert(ranges::random_access_range<decltype(three)> && ranges::view_<decltype(three)>);
CPP_assert(!(ranges::random_access_range<const decltype(three)> && ranges::view_<const decltype(three)>));
auto prod = ranges::views::cartesian_product(three, three);
CPP_assert(ranges::random_access_range<decltype(prod)> && ranges::view_<decltype(prod)>);
CPP_assert(!(ranges::random_access_range<const decltype(prod)> && ranges::view_<const decltype(prod)>));
CPP_assert(ranges::sized_range<decltype(prod)>);
CHECK(ranges::size(prod) == 9u);
{
int i = 0;
RANGES_FOR(auto&& x, prod) {
(void)x;
RANGES_ENSURE(i++ < 3 * 3);
}
CHECK(i == 3 * 3);
}
auto twoD = prod | ranges::views::chunk(3);
CPP_assert(ranges::random_access_range<decltype(twoD)> && ranges::view_<decltype(twoD)>);
CPP_assert(!(ranges::random_access_range<const decltype(twoD)> && ranges::view_<const decltype(twoD)>));
{
int i = 0;
RANGES_FOR(auto&& row, twoD) {
(void)row;
RANGES_ENSURE(i++ < 3);
}
CHECK(i == 3);
}
{
int i = 0;
RANGES_FOR(auto&& row, twoD) {
RANGES_ENSURE(i++ < 3);
int j = 0;
RANGES_FOR(auto&& col, row) {
(void)col;
RANGES_ENSURE(j++ < 3);
}
CHECK(j == 3);
}
CHECK(i == 3);
}
}
void test_bug_919()
{
// https://github.com/ericniebler/range-v3/issues/919
int some_ints[] = {0,1,2,3};
char const * some_strings[] = {"John", "Paul", "George", "Ringo"};
auto rng = views::cartesian_product(
span<int, size(some_ints)>{some_ints},
span<char const*, size(some_strings)>{some_strings}
);
constexpr std::intmax_t n = size(rng);
static_assert(n == 16, "");
for (std::intmax_t i = 0; i <= n; ++i) {
auto const x = rng.begin() + i;
CHECK((x == rng.end() - (n - i)));
for (std::intmax_t j = 0; j <= n; ++j)
CHECK((rng.begin() + j == x + (j - i)));
}
}
void test_bug_978()
{
// https://github.com/ericniebler/range-v3/issues/978
int rgi[] = {1};
ranges::views::cartesian_product(
rgi | ranges::views::filter([](int){ return true; }),
rgi
);
}
void test_bug_1269()
{
// https://github.com/ericniebler/range-v3/issues/1269
int data0[2]{}, data1[3]{}, data2[5]{}, data3[7]{};
constexpr std::size_t N = ranges::size(data0) * ranges::size(data1) *
ranges::size(data2) * ranges::size(data3);
CPP_assert(N < INT_MAX);
auto rng = ranges::views::cartesian_product(data0, data1, data2, data3);
CPP_assert(ranges::sized_range<decltype(rng)>);
CHECK(ranges::size(rng) == N);
CPP_assert(ranges::random_access_range<decltype(rng)>);
CPP_assert(ranges::sized_sentinel_for<ranges::sentinel_t<decltype(rng)>, ranges::iterator_t<decltype(rng)>>);
for (int i = 0; i < int{N}; ++i)
{
auto pos = ranges::begin(rng) + i;
CHECK((ranges::end(rng) - pos) == std::intmax_t{N} - i);
}
}
void test_bug_1279()
{
// https://github.com/ericniebler/range-v3/issues/1279
auto const xs = ranges::views::indices(std::size_t{0}, std::size_t{10});
auto const ys = ranges::views::indices(std::size_t{0}, std::size_t{10});
for(auto r : ranges::views::cartesian_product(ys, xs))
{
(void) r;
}
}
void test_bug_1296()
{
// https://github.com/ericniebler/range-v3/issues/1296
auto v = ranges::views::cartesian_product(ranges::views::single(42))
| ranges::views::transform([](std::tuple<int> a) {
return std::get<0>(a);
});
CHECK(ranges::size(v) == 1u);
CHECK(*ranges::begin(v) == 42);
}
// https://github.com/ericniebler/range-v3/issues/1422
void test_1422()
{
int v1[] = {1,2,3};
auto e = v1 | ranges::views::enumerate;
auto cp = ranges::views::cartesian_product(e, e);
using CP = decltype(cp);
CPP_assert(ranges::input_range<CP>);
}
int main()
{
int some_ints[] = {0,1,2,3};
char const * some_strings[] = {"John", "Paul", "George", "Ringo"};
auto rng = views::cartesian_product(
span<int, size(some_ints)>{some_ints},
span<char const*, size(some_strings)>{some_strings}
);
using Rng = decltype(rng);
CPP_assert(range_cardinality<Rng>::value ==
range_cardinality<decltype(some_ints)>::value *
range_cardinality<decltype(some_strings)>::value);
CPP_assert(random_access_range<Rng> && view_<Rng>);
CPP_assert(common_range<Rng>);
CPP_assert(sized_range<Rng>);
CHECK(size(rng) == size(some_ints) * size(some_strings));
CPP_assert(std::is_same<
range_value_t<Rng>,
std::tuple<int, char const *>>());
CPP_assert(std::is_same<
range_reference_t<Rng>,
common_tuple<int &, char const * &>>());
using CT = common_tuple<int, std::string>;
std::initializer_list<CT> control = {
CT{0, "John"}, CT{0, "Paul"}, CT{0, "George"}, CT{0, "Ringo"},
CT{1, "John"}, CT{1, "Paul"}, CT{1, "George"}, CT{1, "Ringo"},
CT{2, "John"}, CT{2, "Paul"}, CT{2, "George"}, CT{2, "Ringo"},
CT{3, "John"}, CT{3, "Paul"}, CT{3, "George"}, CT{3, "Ringo"}
};
::check_equal(rng, control);
::check_equal(views::reverse(rng), views::reverse(control));
auto const first = begin(rng);
auto const last = end(rng);
CHECK((last - first) == (std::intmax_t) size(rng));
for(auto i = 0; i <= distance(rng); ++i)
{
for(auto j = 0; j <= distance(rng); ++j)
{
CHECK((next(first, i) - next(first, j)) == i - j);
}
}
test_empty_set();
test_empty_range();
test_bug_820();
test_bug_823();
test_bug_919();
test_bug_978();
test_bug_1269();
test_bug_1279();
test_bug_1296();
return test_result();
}
|
0 | repos/range-v3/test | repos/range-v3/test/view/conversion.cpp | // Range v3 library
//
// Copyright Eric Niebler 2014-present
//
// Use, modification and distribution is subject to the
// Boost Software License, Version 1.0. (See accompanying
// file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt)
//
// Project home: https://github.com/ericniebler/range-v3
#include <utility> // for std::swap on C++14.
#include <map>
#include <set>
#include <list>
#include <sstream>
#include <string>
#include <vector>
#include <range/v3/core.hpp>
#include <range/v3/view/any_view.hpp>
#include <range/v3/view/concat.hpp>
#include <range/v3/view/drop.hpp>
#include <range/v3/view/take.hpp>
#include <range/v3/view/repeat.hpp>
#include <range/v3/view/reverse.hpp>
#include <range/v3/view/transform.hpp>
#include <range/v3/view/for_each.hpp>
#include <range/v3/view/iota.hpp>
#include <range/v3/view/zip.hpp>
#include "../simple_test.hpp"
#include "../test_utils.hpp"
int main()
{
using namespace ranges;
// 1-d vector
auto v = views::ints | views::take(10) | to<std::vector>();
::check_equal(v, {0,1,2,3,4,5,6,7,8,9});
v = views::iota(10) | views::take(10) | views::reverse | to<std::vector>();
::check_equal(v, {19,18,17,16,15,14,13,12,11,10});
// 1-d list
auto l = views::ints | views::take(10) | to<std::list>();
::check_equal(l, {0,1,2,3,4,5,6,7,8,9});
l = views::iota(10) | views::take(10) | views::reverse | to<std::list>();
::check_equal(l, {19,18,17,16,15,14,13,12,11,10});
// 2-d vector
auto vv = views::repeat_n(views::ints(0, 8), 10) | to<std::vector<std::vector<int>>>();
::check_equal(vv, std::vector<std::vector<int>>(10, {0,1,2,3,4,5,6,7}));
// issue #556
{
std::string s{"abc"};
any_view<any_view<char, category::random_access>, category::random_access> v1 =
views::single(s | views::drop(1));
any_view<any_view<char, category::random_access>, category::random_access> v2 =
views::single(s | views::drop(2));
auto v3 = views::concat(v1, v2);
auto owner1 = v3 | to<std::vector<std::vector<char>>>();
auto owner2 = v3 | to<std::vector<std::string>>();
::check_equal(owner1, std::vector<std::vector<char>>{{'b', 'c'}, {'c'}});
::check_equal(owner2, std::vector<std::string>{{"bc"}, {"c"}});
}
// map
auto to_string = [](int i){ std::stringstream str; str << i; return str.str(); };
auto m = views::zip(views::ints, views::ints | views::transform(to_string)) |
views::take(5) | to<std::map<int, std::string>>();
using P = std::pair<int const, std::string>;
::check_equal(m, {P{0,"0"}, P{1,"1"}, P{2,"2"}, P{3,"3"}, P{4,"4"}});
// Another way to say the same thing, but with a range comprehension:
m = views::for_each(views::ints(0,5), [&](int i) {
return yield(std::make_pair(i, to_string(i)));
}) | to<std::map<int, std::string>>();
::check_equal(m, {P{0,"0"}, P{1,"1"}, P{2,"2"}, P{3,"3"}, P{4,"4"}});
// set
CPP_assert(range<std::set<int>>);
CPP_assert(!view_<std::set<int>>);
auto s = views::ints | views::take(10) | to<std::set<int>>();
::check_equal(s, {0,1,2,3,4,5,6,7,8,9});
static_assert(!view_<std::initializer_list<int>>, "");
return ::test_result();
}
|
0 | repos/range-v3/test | repos/range-v3/test/view/indirect.cpp | // Range v3 library
//
// Copyright Eric Niebler 2014-present
//
// Use, modification and distribution is subject to the
// Boost Software License, Version 1.0. (See accompanying
// file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt)
//
// Project home: https://github.com/ericniebler/range-v3
#include <vector>
#include <memory>
#include <range/v3/core.hpp>
#include <range/v3/view/indirect.hpp>
#include <range/v3/view/transform.hpp>
#include "../simple_test.hpp"
#include "../test_utils.hpp"
int main()
{
using namespace ranges;
{
std::vector<std::shared_ptr<int>> vp;
for(int i = 0; i < 10; ++i)
vp.push_back(std::make_shared<int>(i));
auto && rng = vp | views::indirect;
CHECK(&*begin(rng) == vp[0].get());
::check_equal(rng, {0, 1, 2, 3, 4, 5, 6, 7, 8, 9});
}
{
int const some_ints[] = {0,1,2,3};
int const *some_int_pointers[] = {
some_ints + 0, some_ints + 1, some_ints + 2, some_ints + 3
};
auto make_range = [&]{
return debug_input_view<int const *>{some_int_pointers} | views::indirect;
};
auto rng = make_range();
::check_equal(rng, some_ints);
rng = make_range();
CHECK(&*begin(rng) == some_ints + 0);
}
#if RANGES_CXX_RETURN_TYPE_DEDUCTION >= RANGES_CXX_RETURN_TYPE_DEDUCTION_14
{
// regression test for #946
class Data;
struct Test
{
std::vector<Data*> m_list;
auto list()
{
return m_list | ranges::views::indirect;
}
};
class Data
{};
CHECK(Test{std::vector<Data*>(42)}.list().size() == 42u);
}
#endif // RANGES_CXX_RETURN_TYPE_DEDUCTION
{
// regression test for #952
int some_ints[42]{};
auto a = some_ints | views::transform([](int& i) { return &i; })
| views::indirect;
(void) a.begin();
}
return test_result();
}
|
0 | repos/range-v3/test | repos/range-v3/test/view/slice.cpp | // Range v3 library
//
// Copyright Eric Niebler 2014-present
//
// Use, modification and distribution is subject to the
// Boost Software License, Version 1.0. (See accompanying
// file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt)
//
// Project home: https://github.com/ericniebler/range-v3
#include <list>
#include <vector>
#include <string>
#include <sstream>
#include <range/v3/core.hpp>
#include <range/v3/view/iota.hpp>
#include <range/v3/view/istream.hpp>
#include <range/v3/view/slice.hpp>
#include <range/v3/view/reverse.hpp>
#include <range/v3/utility/copy.hpp>
#include "../simple_test.hpp"
#include "../test_utils.hpp"
int main()
{
using namespace ranges;
int rgi[] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
auto rng0 = rgi | views::slice(3, 9);
has_type<int &>(*begin(rng0));
CPP_assert(view_<decltype(rng0)>);
CPP_assert(common_range<decltype(rng0)>);
CPP_assert(sized_range<decltype(rng0)>);
CPP_assert(random_access_iterator<decltype(begin(rng0))>);
::check_equal(rng0, {3, 4, 5, 6, 7, 8});
auto rng1 = rng0 | views::reverse;
has_type<int &>(*begin(rng1));
CPP_assert(view_<decltype(rng1)>);
CPP_assert(common_range<decltype(rng1)>);
CPP_assert(sized_range<decltype(rng1)>);
CPP_assert(random_access_iterator<decltype(begin(rng1))>);
::check_equal(rng1, {8, 7, 6, 5, 4, 3});
std::vector<int> v{0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
auto rng2 = v | views::slice(3, 9) | views::reverse;
has_type<int &>(*begin(rng2));
CPP_assert(view_<decltype(rng2)>);
CPP_assert(common_range<decltype(rng2)>);
CPP_assert(sized_range<decltype(rng2)>);
CPP_assert(random_access_iterator<decltype(begin(rng2))>);
::check_equal(rng2, {8, 7, 6, 5, 4, 3});
std::list<int> l{0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
auto rng3 = l | views::slice(3, 9);
has_type<int &>(*begin(rng3));
CPP_assert(view_<decltype(rng3)>);
CPP_assert(!common_range<decltype(rng3)>);
CPP_assert(sized_range<decltype(rng3)>);
CPP_assert(bidirectional_iterator<decltype(begin(rng3))>);
CPP_assert(!random_access_iterator<decltype(begin(rng3))>);
::check_equal(rng3, {3, 4, 5, 6, 7, 8});
auto rng4 = views::iota(10) | views::slice(10, 20);
CPP_assert(view_<decltype(rng4)>);
CPP_assert(common_range<decltype(rng4)>);
CPP_assert(sized_range<decltype(rng4)>);
static_assert(!ranges::is_infinite<decltype(rng4)>::value, "");
::check_equal(rng4, {20, 21, 22, 23, 24, 25, 26, 27, 28, 29});
auto rng5 = views::iota(10)[{10, 20}];
CPP_assert(view_<decltype(rng5)>);
CPP_assert(common_range<decltype(rng5)>);
CPP_assert(sized_range<decltype(rng5)>);
static_assert(!ranges::is_infinite<decltype(rng5)>::value, "");
::check_equal(rng5, {20, 21, 22, 23, 24, 25, 26, 27, 28, 29});
auto rng6 = views::all(l)[{3, 9}];
has_type<int &>(*begin(rng6));
CPP_assert(view_<decltype(rng6)>);
CPP_assert(!common_range<decltype(rng6)>);
CPP_assert(sized_range<decltype(rng6)>);
CPP_assert(bidirectional_iterator<decltype(begin(rng6))>);
CPP_assert(!random_access_iterator<decltype(begin(rng6))>);
::check_equal(rng6, {3, 4, 5, 6, 7, 8});
auto rng7 = views::all(l)[{3, end}];
has_type<int &>(*begin(rng7));
CPP_assert(view_<decltype(rng7)>);
CPP_assert(common_range<decltype(rng7)>);
CPP_assert(sized_range<decltype(rng7)>);
CPP_assert(bidirectional_iterator<decltype(begin(rng7))>);
CPP_assert(!random_access_iterator<decltype(begin(rng7))>);
::check_equal(rng7, {3, 4, 5, 6, 7, 8, 9, 10});
auto rng8 = views::all(l)[{end-5,end-2}];
has_type<int &>(*begin(rng8));
CPP_assert(view_<decltype(rng8)>);
CPP_assert(!common_range<decltype(rng8)>);
CPP_assert(sized_range<decltype(rng8)>);
CPP_assert(bidirectional_iterator<decltype(begin(rng8))>);
CPP_assert(!random_access_iterator<decltype(begin(rng8))>);
::check_equal(rng8, {6, 7, 8});
auto rng9 = views::iota(0)[{0,end}];
static_assert(is_infinite<decltype(rng9)>::value, "should be infinite");
{
std::string str{"0 1 2 3 4 5 6 7 8 9"};
std::stringstream sin{str};
auto rng10 = istream<int>(sin)[{3,9}];
::check_equal(rng10, {3, 4, 5, 6, 7, 8});
}
{
std::string str{"0 1 2 3 4 5 6 7 8 9"};
std::stringstream sin{str};
auto rng11 = istream<int>(sin)[{3,end}];
::check_equal(rng11, {3, 4, 5, 6, 7, 8, 9});
}
{
auto letters = views::closed_iota('a','g');
static_assert(random_access_range<decltype(letters)> && view_<decltype(letters)>, "");
static_assert(common_range<decltype(letters)> && view_<decltype(letters)>, "");
::check_equal(letters[{2,end-2}], {'c','d','e'});
}
{
int const some_ints[] = {0,1,2,3,4,5,6,7,8,9};
auto rng = debug_input_view<int const>{some_ints} | views::slice(3,10);
::check_equal(rng, {3, 4, 5, 6, 7, 8, 9});
}
return test_result();
}
|
0 | repos/range-v3/test | repos/range-v3/test/view/intersperse.cpp | // Range v3 library
//
// Copyright Eric Niebler 2014-present
//
// Use, modification and distribution is subject to the
// Boost Software License, Version 1.0. (See accompanying
// file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt)
//
// Project home: https://github.com/ericniebler/range-v3
#include <sstream>
#include <range/v3/core.hpp>
#include <range/v3/view/intersperse.hpp>
#include <range/v3/view/delimit.hpp>
#include <range/v3/view/reverse.hpp>
#include <range/v3/range/conversion.hpp>
#include "../simple_test.hpp"
#include "../test_utils.hpp"
#ifdef RANGES_WORKAROUND_MSVC_790554
template<std::size_t N>
auto c_str(char const (&sz)[N])
{
return ranges::subrange<char const*>{&sz[0], &sz[N-1]};
}
#else // ^^^ workaround / no workaround vvv
template<std::size_t N>
ranges::subrange<char const*> c_str(char const (&sz)[N])
{
return {&sz[0], &sz[N-1]};
}
#endif // RANGES_WORKAROUND_MSVC_790554
ranges::delimit_view<ranges::subrange<char const *, ranges::unreachable_sentinel_t>, char>
c_str_(char const *sz)
{
return ranges::views::delimit(sz, '\0');
}
int main()
{
using namespace ranges;
{
auto r0 = views::intersperse(c_str("abcde"), ',');
CPP_assert(common_range<decltype(r0)>);
CHECK((r0.end() - r0.begin()) == 9);
CHECK(to<std::string>(r0) == "a,b,c,d,e");
CHECK(r0.size() == 9u);
auto r1 = views::intersperse(c_str(""), ',');
CPP_assert(common_range<decltype(r1)>);
CHECK(to<std::string>(r1) == "");
CHECK(r1.size() == 0u);
auto r2 = views::intersperse(c_str("a"), ',');
CPP_assert(common_range<decltype(r2)>);
CHECK(to<std::string>(r2) == "a");
CHECK(r2.size() == 1u);
auto r3 = views::intersperse(c_str("ab"), ',');
CPP_assert(common_range<decltype(r3)>);
CHECK(to<std::string>(r3) == "a,b");
CHECK(r3.size() == 3u);
}
{
auto r0 = views::intersperse(c_str("abcde"), ',') | views::reverse;
CPP_assert(common_range<decltype(r0)>);
CHECK(to<std::string>(r0) == "e,d,c,b,a");
auto r1 = views::intersperse(c_str(""), ',') | views::reverse;
CPP_assert(common_range<decltype(r1)>);
CHECK(to<std::string>(r1) == "");
auto r2 = views::intersperse(c_str("a"), ',') | views::reverse;
CPP_assert(common_range<decltype(r2)>);
CHECK(to<std::string>(r2) == "a");
auto r3 = views::intersperse(c_str("ab"), ',') | views::reverse;
CPP_assert(common_range<decltype(r3)>);
CHECK(to<std::string>(r3) == "b,a");
}
{
auto r0 = views::intersperse(c_str_("abcde"), ',');
CPP_assert(!common_range<decltype(r0)>);
CHECK(to<std::string>(r0) == "a,b,c,d,e");
auto r1 = views::intersperse(c_str_(""), ',');
CPP_assert(!common_range<decltype(r1)>);
CHECK(to<std::string>(r1) == "");
auto r2 = views::intersperse(c_str_("a"), ',');
CPP_assert(!common_range<decltype(r2)>);
CHECK(to<std::string>(r2) == "a");
auto r3 = views::intersperse(c_str_("ab"), ',');
CPP_assert(!common_range<decltype(r3)>);
CHECK(to<std::string>(r3) == "a,b");
}
{
auto r0 = views::intersperse(c_str("abcde"), ',');
auto it = r0.begin();
CHECK(*(it+0) == 'a');
CHECK(*(it+1) == ',');
CHECK(*(it+2) == 'b');
CHECK(*(it+3) == ',');
CHECK(*(it+4) == 'c');
CHECK(*(it+5) == ',');
CHECK(*(it+6) == 'd');
CHECK(*(it+7) == ',');
CHECK(*(it+8) == 'e');
CHECK((it+9) == r0.end());
it = r0.end();
CHECK(*(it-9) == 'a');
CHECK(*(it-8) == ',');
CHECK(*(it-7) == 'b');
CHECK(*(it-6) == ',');
CHECK(*(it-5) == 'c');
CHECK(*(it-4) == ',');
CHECK(*(it-3) == 'd');
CHECK(*(it-2) == ',');
CHECK(*(it-1) == 'e');
it = r0.begin();
CHECK(((it+0)-it) == 0);
CHECK(((it+1)-it) == 1);
CHECK(((it+2)-it) == 2);
CHECK(((it+3)-it) == 3);
CHECK(((it+4)-it) == 4);
CHECK(((it+5)-it) == 5);
CHECK(((it+6)-it) == 6);
CHECK(((it+7)-it) == 7);
CHECK(((it+8)-it) == 8);
CHECK(((it+9)-it) == 9);
CHECK((it-(it+0)) == 0);
CHECK((it-(it+1)) == -1);
CHECK((it-(it+2)) == -2);
CHECK((it-(it+3)) == -3);
CHECK((it-(it+4)) == -4);
CHECK((it-(it+5)) == -5);
CHECK((it-(it+6)) == -6);
CHECK((it-(it+7)) == -7);
CHECK((it-(it+8)) == -8);
CHECK((it-(it+9)) == -9);
}
{
std::stringstream str{"1 2 3 4 5"};
auto r0 = istream<int>(str) | views::intersperse(42);
check_equal(r0, {1,42,2,42,3,42,4,42,5});
}
{
int const some_ints[] = {1,2,3,4,5};
auto rng = debug_input_view<int const>{some_ints} | views::intersperse(42);
check_equal(rng, {1,42,2,42,3,42,4,42,5});
}
return test_result();
}
|
0 | repos/range-v3/test | repos/range-v3/test/view/set_difference.cpp | // Range v3 library
//
// Copyright Eric Niebler 2014-present
// Copyright Tomislav Ivek 2015-2016
//
// Use, modification and distribution is subject to the
// Boost Software License, Version 1.0. (See accompanying
// file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt)
//
// Project home: https://github.com/ericniebler/range-v3
#include <vector>
#include <sstream>
#include <range/v3/core.hpp>
#include <range/v3/range_for.hpp>
#include <range/v3/algorithm/set_algorithm.hpp>
#include <range/v3/algorithm/move.hpp>
#include <range/v3/iterator/operations.hpp>
#include <range/v3/iterator/insert_iterators.hpp>
#include <range/v3/iterator/move_iterators.hpp>
#include <range/v3/functional/identity.hpp>
#include <range/v3/utility/copy.hpp>
#include <range/v3/view/all.hpp>
#include <range/v3/view/const.hpp>
#include <range/v3/view/drop_while.hpp>
#include <range/v3/view/iota.hpp>
#include <range/v3/view/move.hpp>
#include <range/v3/view/reverse.hpp>
#include <range/v3/view/set_algorithm.hpp>
#include <range/v3/view/stride.hpp>
#include <range/v3/view/take.hpp>
#include <range/v3/view/transform.hpp>
#include "../simple_test.hpp"
#include "../test_utils.hpp"
int main()
{
using namespace ranges;
int i1_finite[] = {1, 2, 2, 3, 3, 3, 4, 4, 4, 4};
int i2_finite[] = { -3, 2, 4, 4, 6, 9};
auto i1_infinite = views::ints | views::stride(3);
auto i2_infinite = views::ints | views::transform([](int x)
{
return x * x;
});
// difference between two finite ranges/sets
{
auto res = views::set_difference(i1_finite, i2_finite);
CPP_assert(view_<decltype(res)>);
CPP_assert(forward_range<decltype(res)>);
CPP_assert(!random_access_range<decltype(res)>);
CPP_assert(!common_range<decltype(res)>);
using R = decltype(res);
CPP_assert(same_as<range_value_t<R>, int>);
CPP_assert(same_as<range_reference_t<R>, int&>);
CPP_assert(same_as<decltype(iter_move(begin(res))), int &&>);
static_assert(range_cardinality<R>::value == ranges::finite, "Cardinality of difference between two finite ranges should be finite!");
::check_equal(res, {1, 2, 3, 3, 3, 4, 4});
// check if the final result agrees with the greedy algorithm
std::vector<int> diff;
set_difference(i1_finite, i2_finite, back_inserter(diff));
::check_equal(res, diff);
CHECK(&*begin(res) == &*(begin(i1_finite)));
}
// difference between two infinite ranges
{
auto res = views::set_difference(i1_infinite, i2_infinite);
CPP_assert(view_<decltype(res)>);
CPP_assert(forward_range<decltype(res)>);
CPP_assert(!random_access_range<decltype(res)>);
CPP_assert(!common_range<decltype(res)>);
using R = decltype(res);
CPP_assert(same_as<range_value_t<R>, int>);
CPP_assert(same_as<range_reference_t<R>, range_reference_t<decltype(i1_infinite)>>);
CPP_assert(same_as<decltype(iter_move(begin(res))), range_rvalue_reference_t<decltype(i1_infinite)>>);
static_assert(range_cardinality<R>::value == ranges::unknown, "Cardinality of difference of infinite ranges should be unknown!");
::check_equal(res | views::take(5), {3, 6, 12, 15, 18});
// check if the final result agrees with the greedy algorithm
std::vector<int> diff;
set_difference(i1_infinite | views::take(1000), i2_infinite | views::take(1000), back_inserter(diff));
::check_equal(res | views::take(5), diff | views::take(5));
}
// difference between a finite and an infinite range
{
auto res = views::set_difference(i1_finite, i2_infinite);
CPP_assert(view_<decltype(res)>);
CPP_assert(forward_range<decltype(res)>);
CPP_assert(!random_access_range<decltype(res)>);
CPP_assert(!common_range<decltype(res)>);
using R = decltype(res);
CPP_assert(same_as<range_value_t<R>, int>);
CPP_assert(same_as<range_reference_t<R>, range_reference_t<decltype(i1_finite)>>);
CPP_assert(same_as<decltype(iter_move(begin(res))), range_rvalue_reference_t<decltype(i1_finite)>>);
static_assert(range_cardinality<R>::value == ranges::finite, "Cardinality of difference between a finite range and any other range should be finite!");
::check_equal(res, {2, 2, 3, 3, 3, 4, 4, 4});
}
// difference between an infinite and a finite range
{
auto res = views::set_difference(i1_infinite, i2_finite);
CPP_assert(view_<decltype(res)>);
CPP_assert(forward_range<decltype(res)>);
CPP_assert(!random_access_range<decltype(res)>);
CPP_assert(!common_range<decltype(res)>);
using R = decltype(res);
CPP_assert(same_as<range_value_t<R>, int>);
CPP_assert(same_as<range_reference_t<R>, range_reference_t<decltype(i1_infinite)>>);
CPP_assert(same_as<range_rvalue_reference_t<R>, range_rvalue_reference_t<decltype(i1_infinite)>>);
static_assert(range_cardinality<R>::value == ranges::infinite, "Cardinality of difference between an infinite and finite range should be infinite!");
::check_equal(res | views::take(5), {0, 3, 12, 15, 18});
}
// differences involving unknown cardinalities
{
auto rng0 = views::iota(10) | views::drop_while([](int i)
{
return i < 25;
});
static_assert(range_cardinality<decltype(rng0)>::value == ranges::unknown, "");
auto res1 = views::set_difference(i2_finite, rng0);
static_assert(range_cardinality<decltype(res1)>::value == ranges::finite, "Difference between a finite and unknown cardinality set should have finite cardinality!");
auto res2 = views::set_difference(rng0, i2_finite);
static_assert(range_cardinality<decltype(res2)>::value == ranges::unknown, "Difference between an unknown cardinality and finite set should have unknown cardinality!");
auto res3 = views::set_difference(i1_infinite, rng0);
static_assert(range_cardinality<decltype(res3)>::value == ranges::unknown, "Difference between an unknown cardinality and finite set should have unknown cardinality!");
auto res4 = views::set_difference(rng0, i1_infinite);
static_assert(range_cardinality<decltype(res4)>::value == ranges::unknown, "Difference between an unknown and infinite cardinality set should have unknown cardinality!");
}
// test const ranges
{
auto res1 = views::set_difference(views::const_(i1_finite), views::const_(i2_finite));
using R1 = decltype(res1);
CPP_assert(same_as<range_value_t<R1>, int>);
CPP_assert(same_as<range_reference_t<R1>, const int&>);
CPP_assert(same_as<range_rvalue_reference_t<R1>, const int&&>);
auto res2 = views::set_difference(views::const_(i1_finite), i2_finite);
using R2 = decltype(res2);
CPP_assert(same_as<range_value_t<R2>, int>);
CPP_assert(same_as<range_reference_t<R2>, const int&>);
CPP_assert(same_as<range_rvalue_reference_t<R2>, const int&&>);
}
// test different orderings
{
auto res = views::set_difference(views::reverse(i1_finite), views::reverse(i2_finite), [](int a, int b)
{
return a > b;
});
::check_equal(res, {4, 4, 3, 3, 3, 2, 1});
}
// test projections and sets with different element types
struct S
{
int val;
bool operator==(const S& other) const
{
return val == other.val;
}
};
S s_finite[] = {S{-20}, S{-10}, S{1}, S{3}, S{3}, S{6}, S{8}, S{20}};
{
auto res1 = views::set_difference(s_finite, views::ints(-2, 10),
less(),
&S::val,
identity()
);
using R1 = decltype(res1);
CPP_assert(same_as<range_value_t<R1>, S>);
CPP_assert(same_as<range_reference_t<R1>, S&>);
CPP_assert(same_as<range_rvalue_reference_t<R1>, S&&>);
::check_equal(res1, {S{-20}, S{-10}, S{3}, S{20}});
auto res2 = views::set_difference(views::ints(-2, 10), s_finite,
less(),
identity(),
[](const S& x){ return x.val; }
);
using R2 = decltype(res2);
CPP_assert(same_as<range_value_t<R2>, int>);
CPP_assert(same_as<range_reference_t<R2>, int>);
CPP_assert(same_as<range_rvalue_reference_t<R2>, int>);
::check_equal(res2, {-2, -1, 0, 2, 4, 5, 7, 9});
}
// move
{
auto v0 = to<std::vector<MoveOnlyString>>({"a","b","b","c","x","x"});
auto v1 = to<std::vector<MoveOnlyString>>({"b","x","y","z"});
auto res = views::set_difference(v0, v1, [](const MoveOnlyString& a, const MoveOnlyString& b){return a<b;});
std::vector<MoveOnlyString> expected;
move(res, back_inserter(expected));
::check_equal(expected, {"a","b","c","x"});
::check_equal(v1, {"b","x","y","z"});
::check_equal(v0, {"","b","","","x",""});
auto v0_greedy = to<std::vector<MoveOnlyString>>({"a","b","b","c","x","x"});
auto v1_greedy = to<std::vector<MoveOnlyString>>({"b","x","y","z"});
std::vector<MoveOnlyString> expected_greedy;
set_difference(v0_greedy, v1_greedy,
move_into(back_inserter(expected_greedy)),
[](const MoveOnlyString& a, const MoveOnlyString& b){return a<b;});
::check_equal(expected_greedy, expected);
::check_equal(v0_greedy, v0);
::check_equal(v1_greedy, v1);
using R = decltype(res);
CPP_assert(same_as<range_value_t<R>, MoveOnlyString>);
CPP_assert(same_as<range_reference_t<R>, MoveOnlyString &>);
CPP_assert(same_as<range_rvalue_reference_t<R>, MoveOnlyString &&>);
}
// WARNING: set_difference between two infinite ranges can create infinite loops!
// {
// auto empty_range = views::set_difference(views::ints, views::ints);
// begin(empty_range); // infinite loop!
// }
{
auto rng = views::set_difference(
debug_input_view<int const>{i1_finite},
debug_input_view<int const>{i2_finite}
);
::check_equal(rng, {1, 2, 3, 3, 3, 4, 4});
}
return test_result();
}
|
0 | repos/range-v3/test | repos/range-v3/test/view/drop_while.cpp | // Range v3 library
//
// Copyright Eric Niebler 2014-present
//
// Use, modification and distribution is subject to the
// Boost Software License, Version 1.0. (See accompanying
// file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt)
//
// Project home: https://github.com/ericniebler/range-v3
#include <list>
#include <range/v3/core.hpp>
#include <range/v3/view/iota.hpp>
#include <range/v3/view/take.hpp>
#include <range/v3/view/drop_while.hpp>
#include <range/v3/utility/copy.hpp>
#include "../simple_test.hpp"
#include "../test_utils.hpp"
struct my_data
{
int i;
};
bool operator==(my_data left, my_data right)
{
return left.i == right.i;
}
int main()
{
using namespace ranges;
auto rng0 = views::iota(10) | views::drop_while([](int i) { return i < 25; });
CPP_assert(range_cardinality<decltype(rng0)>::value == unknown);
CPP_assert(view_<decltype(rng0)>);
CPP_assert(random_access_range<decltype(rng0)>);
CPP_assert(!common_range<decltype(rng0)>);
CPP_assert(!sized_range<decltype(rng0)>);
CPP_assert(random_access_iterator<decltype(rng0.begin())>);
auto b = rng0.begin();
CHECK(*b == 25);
CHECK(*(b+1) == 26);
::check_equal(rng0 | views::take(10), {25, 26, 27, 28, 29, 30, 31, 32, 33, 34});
std::list<int> vi{0, 1, 2, 3, 4, 5, 6, 7, 8, 9};
auto rng1 = vi | views::drop_while([](int i) { return i != 50; });
CPP_assert(range_cardinality<decltype(rng1)>::value == ranges::finite);
CPP_assert(view_<decltype(rng1)>);
CPP_assert(bidirectional_range<decltype(rng1)>);
CPP_assert(common_range<decltype(rng1)>);
CPP_assert(!sized_range<decltype(rng1)>);
CPP_assert(bidirectional_iterator<decltype(rng1.begin())>);
CHECK(rng1.begin() == rng1.end());
// Check with a mutable predicate
static int const rgi[] = {0,1,2,3,4,5,6,7,8,9};
int cnt = 0;
auto mutable_only = views::drop_while(rgi, [cnt](int) mutable { return ++cnt <= 5;});
::check_equal(mutable_only, {5,6,7,8,9});
CPP_assert(view_<decltype(mutable_only)>);
CPP_assert(!view_<decltype(mutable_only) const>);
{
auto rng = debug_input_view<const int>{rgi} | views::drop_while([](int i){ return i < 4; });
using R = decltype(rng);
CPP_assert(input_range<R> && view_<R>);
CPP_assert(!forward_range<R>);
CPP_assert(!common_range<R>);
CPP_assert(!sized_range<R>);
CPP_assert(same_as<int const&, range_reference_t<R>>);
::check_equal(rng, {4,5,6,7,8,9});
}
{
// with projection
const std::list<my_data> data_list{{1}, {2}, {3}, {1}};
auto rng = data_list | views::drop_while([](int i){ return i <= 2; }, &my_data::i);
::check_equal(rng, std::list<my_data>{{3}, {1}});
}
auto rng2 = rgi | views::drop_while([](int i) { return i != 50; });
CPP_assert(range_cardinality<decltype(rng2)>::value == ranges::finite);
CPP_assert(view_<decltype(rng2)>);
CPP_assert(contiguous_range<decltype(rng2)>);
CPP_assert(common_range<decltype(rng2)>);
CPP_assert(!sized_range<decltype(rng2)>);
CPP_assert(contiguous_iterator<decltype(rng2.begin())>);
CHECK(ranges::size(rng2) == 0u);
return test_result();
}
|
0 | repos/range-v3/test | repos/range-v3/test/view/iterator_range.cpp | // Range v3 library
//
// Copyright Eric Niebler 2014-present
//
// Use, modification and distribution is subject to the
// Boost Software License, Version 1.0. (See accompanying
// file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt)
//
// Project home: https://github.com/ericniebler/range-v3
#include <list>
#include <vector>
#include <range/v3/core.hpp>
#include <range/v3/utility/copy.hpp>
#include <range/v3/iterator/unreachable_sentinel.hpp>
#include <range/v3/iterator_range.hpp>
#include <range/v3/view/all.hpp>
#include "../simple_test.hpp"
#include "../test_utils.hpp"
struct empty
{};
int main()
{
std::vector<int> vi{1,2,3,4};
using namespace ranges;
iterator_range<std::vector<int>::iterator> r0 {vi.begin(), vi.end()};
CPP_assert(view_<decltype(r0)>);
CPP_assert(sized_range<decltype(r0)>);
CHECK(r0.size() == 4u);
CHECK(r0.begin() == vi.begin());
CHECK(r0.end() == vi.end());
CHECK(ranges::get<0>(r0) == vi.begin());
CHECK(ranges::get<1>(r0) == vi.end());
++r0.begin();
CHECK(r0.size() == 3u);
std::pair<std::vector<int>::iterator, std::vector<int>::iterator> p0 = r0;
CHECK(p0.first == vi.begin()+1);
CHECK(p0.second == vi.end());
iterator_range<std::vector<int>::iterator, unreachable_sentinel_t> r1 { r0.begin(), {} };
CPP_assert(view_<decltype(r1)>);
CPP_assert(!sized_range<decltype(r1)>);
CHECK(r1.begin() == vi.begin()+1);
r1.end() = unreachable;
++r0.begin();
CHECK(r0.begin() == vi.begin()+2);
CHECK(r0.size() == 2u);
--r0.end();
CHECK(r0.end() == vi.end()-1);
CHECK(r0.size() == 1u);
CHECK(r0.front() == 3);
CHECK(r0.back() == 3);
std::pair<std::vector<int>::iterator, unreachable_sentinel_t> p1 = r1;
CHECK(p1.first == vi.begin()+1);
iterator_range<std::vector<int>::iterator, unreachable_sentinel_t> r2 { p1 };
CHECK(r1.begin() == vi.begin()+1);
std::list<int> li{1,2,3,4};
sized_iterator_range<std::list<int>::iterator> l0 {li.begin(), li.end(), li.size()};
CPP_assert(view_<decltype(l0)>);
CPP_assert(sized_range<decltype(l0)>);
CHECK(l0.begin() == li.begin());
CHECK(l0.end() == li.end());
CHECK(l0.size() == li.size());
return ::test_result();
}
|
0 | repos/range-v3/test | repos/range-v3/test/view/unique.cpp | // Range v3 library
//
// Copyright Eric Niebler 2014-present
//
// Use, modification and distribution is subject to the
// Boost Software License, Version 1.0. (See accompanying
// file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt)
//
// Project home: https://github.com/ericniebler/range-v3
#include <cctype>
#include <string>
#include <vector>
#include <range/v3/core.hpp>
#include <range/v3/algorithm/copy.hpp>
#include <range/v3/view/delimit.hpp>
#include <range/v3/view/reverse.hpp>
#include <range/v3/view/transform.hpp>
#include <range/v3/view/unique.hpp>
#include <range/v3/utility/copy.hpp>
#include <range/v3/iterator/operations.hpp>
#include <range/v3/iterator/insert_iterators.hpp>
#include "../simple_test.hpp"
#include "../test_utils.hpp"
using std::toupper;
// from http://stackoverflow.com/a/2886589/195873
struct ci_char_traits : std::char_traits<char>
{
static bool eq(char c1, char c2) { return toupper(c1) == toupper(c2); }
static bool ne(char c1, char c2) { return toupper(c1) != toupper(c2); }
static bool lt(char c1, char c2) { return toupper(c1) < toupper(c2); }
static int compare(const char* s1, const char* s2, std::size_t n)
{
for(; n != 0; ++s1, ++s2, --n)
{
if(toupper(*s1) < toupper(*s2))
return -1;
if(toupper(*s1) > toupper(*s2))
return 1;
}
return 0;
}
static const char* find(const char* s, int n, char a)
{
for(; n-- > 0; ++s)
if(toupper(*s) == toupper(a))
break;
return s;
}
};
using ci_string = std::basic_string<char, ci_char_traits>;
int main()
{
using namespace ranges;
{
int rgi[] = {1, 1, 1, 2, 3, 4, 4};
std::vector<int> out;
auto rng = rgi | views::unique;
has_type<int &>(*begin(rng));
CPP_assert(view_<decltype(rng)>);
CPP_assert(bidirectional_range<decltype(rng)>);
CPP_assert(!random_access_range<decltype(rng)>);
CPP_assert(common_range<decltype(rng)>);
CPP_assert(!sized_range<decltype(rng)>);
CPP_assert(range<decltype(rng) const>);
copy(rng, ranges::back_inserter(out));
::check_equal(out, {1, 2, 3, 4});
::check_equal(views::reverse(out), {4, 3, 2, 1});
}
{
std::vector<ci_string> rgs{"hello", "HELLO", "bye", "Bye", "BYE"};
auto rng = rgs | views::unique;
has_type<ci_string &>(*begin(rng));
CPP_assert(view_<decltype(rng)>);
CPP_assert(bidirectional_range<decltype(rng)>);
CPP_assert(!random_access_range<decltype(rng)>);
CPP_assert(common_range<decltype(rng)>);
CPP_assert(!sized_range<decltype(rng)>);
CPP_assert(range<decltype(rng) const>);
auto fs = rng | views::transform([](ci_string s){return std::string(s.data(), s.size());});
CPP_assert(view_<decltype(fs)>);
CPP_assert(bidirectional_range<decltype(fs)>);
::check_equal(fs, {"hello","bye"});
::check_equal(views::reverse(fs), {"bye","hello"});
}
{
int const rgi[] = {1, 1, 1, 2, 3, 4, 4, 42, 7};
auto rng0 = views::delimit(rgi, 42) | views::reverse;
// rng0 is mutable-only...
CPP_assert(forward_range<decltype(rng0)>);
CPP_assert(!forward_range<decltype(rng0) const>);
// ...and composable
auto rng = rng0 | views::unique(equal_to{});
CPP_assert(view_<decltype(rng)>);
CPP_assert(bidirectional_range<decltype(rng)>);
CPP_assert(!random_access_range<decltype(rng)>);
CPP_assert(common_range<decltype(rng)>);
CPP_assert(!sized_range<decltype(rng)>);
::check_equal(rng, {4, 3, 2, 1});
}
{
auto const caseInsensitiveCompare = [](const std::string& s1, const std::string& s2){
if (s1.size() != s2.size())
return false;
for (unsigned i = 0; i < s1.size(); i++)
if (toupper(s1[i]) != toupper(s2[i]))
return false;
return true;
};
std::vector<std::string> rgs{"hello", "HELLO", "bye", "Bye", "BYE"};
auto rng = rgs | views::unique(caseInsensitiveCompare);
has_type<std::string &>(*begin(rng));
CPP_assert(view_<decltype(rng)>);
CPP_assert(bidirectional_range<decltype(rng)>);
CPP_assert(!random_access_range<decltype(rng)>);
CPP_assert(common_range<decltype(rng)>);
CPP_assert(!sized_range<decltype(rng)>);
CPP_assert(range<decltype(rng) const>);
CPP_assert(view_<decltype(rng)>);
CPP_assert(bidirectional_range<decltype(rng)>);
::check_equal(rng, {"hello","bye"});
::check_equal(views::reverse(rng), {"bye","hello"});
}
{
int const rgi[] = {-1, 1, -1, 2, 3, 4, -4, 42, 7};
auto rng0 = views::delimit(rgi, 42) | views::reverse;
// rng0 is mutable-only...
CPP_assert(forward_range<decltype(rng0)>);
CPP_assert(!forward_range<decltype(rng0) const>);
// ...and composable
auto rng = rng0 | views::unique([](const int& n1, const int& n2){ return n1==n2 || n1==-n2; })
| views::transform([](const int& n){ return n > 0 ? n: -n;});
CPP_assert(view_<decltype(rng)>);
CPP_assert(bidirectional_range<decltype(rng)>);
CPP_assert(!random_access_range<decltype(rng)>);
CPP_assert(common_range<decltype(rng)>);
CPP_assert(!sized_range<decltype(rng)>);
::check_equal(rng, {4, 3, 2, 1});
}
return test_result();
}
|
0 | repos/range-v3/test | repos/range-v3/test/view/drop_exactly.cpp | // Range v3 library
//
// Copyright Eric Niebler 2014-present
//
// Use, modification and distribution is subject to the
// Boost Software License, Version 1.0. (See accompanying
// file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt)
//
// Project home: https://github.com/ericniebler/range-v3
#include <list>
#include <vector>
#include <range/v3/core.hpp>
#include <range/v3/view/chunk.hpp>
#include <range/v3/view/drop_exactly.hpp>
#include <range/v3/view/iota.hpp>
#include <range/v3/view/join.hpp>
#include <range/v3/view/reverse.hpp>
#include <range/v3/view/take.hpp>
#include <range/v3/view/transform.hpp>
#include <range/v3/utility/copy.hpp>
#include "../simple_test.hpp"
#include "../test_utils.hpp"
int main()
{
using namespace ranges;
int rgi[] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
auto rng0 = rgi | views::drop_exactly(6);
has_type<int &>(*begin(rng0));
CPP_assert(view_<decltype(rng0)>);
CPP_assert(common_range<decltype(rng0)>);
CPP_assert(sized_range<decltype(rng0)>);
CPP_assert(random_access_iterator<decltype(begin(rng0))>);
::check_equal(rng0, {6, 7, 8, 9, 10});
CHECK(size(rng0) == 5u);
auto rng1 = rng0 | views::reverse;
has_type<int &>(*begin(rng1));
CPP_assert(view_<decltype(rng1)>);
CPP_assert(common_range<decltype(rng1)>);
CPP_assert(sized_range<decltype(rng1)>);
CPP_assert(random_access_iterator<decltype(begin(rng1))>);
::check_equal(rng1, {10, 9, 8, 7, 6});
std::vector<int> v{0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
auto rng2 = v | views::drop_exactly(6) | views::reverse;
has_type<int &>(*begin(rng2));
CPP_assert(view_<decltype(rng2)>);
CPP_assert(common_range<decltype(rng2)>);
CPP_assert(sized_range<decltype(rng2)>);
CPP_assert(random_access_iterator<decltype(begin(rng2))>);
::check_equal(rng2, {10, 9, 8, 7, 6});
std::list<int> l{0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
auto rng3 = l | views::drop_exactly(6);
has_type<int &>(*begin(rng3));
CPP_assert(view_<decltype(rng3)>);
CPP_assert(common_range<decltype(rng3)>);
CPP_assert(sized_range<decltype(rng3)>);
CPP_assert(bidirectional_iterator<decltype(begin(rng3))>);
CPP_assert(!random_access_iterator<decltype(begin(rng3))>);
::check_equal(rng3, {6, 7, 8, 9, 10});
auto rng4 = views::iota(10) | views::drop_exactly(10);
CPP_assert(view_<decltype(rng4)>);
CPP_assert(!common_range<decltype(rng4)>);
CPP_assert(!sized_range<decltype(rng4)>);
static_assert(ranges::is_infinite<decltype(rng4)>::value, "");
auto b = ranges::begin(rng4);
CHECK(*b == 20);
CHECK(*(b+1) == 21);
auto rng5 = views::iota(10) | views::drop_exactly(10) | views::take(10) | views::reverse;
CPP_assert(view_<decltype(rng5)>);
CPP_assert(common_range<decltype(rng5)>);
CPP_assert(sized_range<decltype(rng5)>);
static_assert(!ranges::is_infinite<decltype(rng5)>::value, "");
::check_equal(rng5, {29, 28, 27, 26, 25, 24, 23, 22, 21, 20});
CHECK(size(rng5) == 10u);
{
// drop_exactly should work with random-access mutable-only Views.
auto odds = views::iota(0) |
views::chunk(2) |
views::transform(views::drop_exactly(1)) |
views::join;
(void)odds;
}
{
auto rng = debug_input_view<int const>{rgi} | views::drop_exactly(5);
using Rng = decltype(rng);
CPP_assert(input_range<Rng> && view_<Rng>);
CPP_assert(sized_range<Rng>);
::check_equal(rng, {5,6,7,8,9,10});
}
return test_result();
}
|
0 | repos/range-v3/test | repos/range-v3/test/view/common.cpp | // Range v3 library
//
// Copyright Eric Niebler 2014-present
//
// Use, modification and distribution is subject to the
// Boost Software License, Version 1.0. (See accompanying
// file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt)
//
// Project home: https://github.com/ericniebler/range-v3
#include <list>
#include <vector>
#include <sstream>
#include <range/v3/core.hpp>
#include <range/v3/view/common.hpp>
#include <range/v3/view/counted.hpp>
#include <range/v3/view/delimit.hpp>
#include <range/v3/view/repeat_n.hpp>
#include <range/v3/utility/copy.hpp>
#include "../simple_test.hpp"
#include "../test_utils.hpp"
int main()
{
using namespace ranges;
{
std::stringstream sinx("1 2 3 4 5 6 7 8 9 1 2 3 4 5 6 7 8 9 1 2 3 4 42 6 7 8 9 ");
auto rng1 = istream<int>(sinx) | views::delimit(42); // | views::common;
CPP_assert(!common_range<decltype(rng1)>);
CPP_assert(input_range<decltype(rng1)>);
CPP_assert(!forward_range<decltype(rng1)>);
auto const& crng1 = rng1;
CPP_assert(!range<decltype(crng1)>);
auto rng2 = rng1 | views::common;
CPP_assert(view_<decltype(rng2)>);
CPP_assert(common_range<decltype(rng2)>);
CPP_assert(input_iterator<decltype(rng2.begin())>);
CPP_assert(same_as<typename std::iterator_traits<decltype(rng2.begin())>::iterator_category,
std::input_iterator_tag>);
CPP_assert(!forward_iterator<decltype(rng2.begin())>);
::check_equal(rng2, {1, 2, 3, 4, 5, 6, 7, 8, 9, 1, 2, 3, 4, 5, 6, 7, 8, 9, 1, 2, 3, 4});
}
std::vector<int> v{1,2,3,4,5,6,7,8,9,0,42,64};
{
auto rng1 = v | views::delimit(42) | views::common;
CPP_assert(view_<decltype(rng1)>);
CPP_assert(common_range<decltype(rng1)>);
CPP_assert(!sized_range<decltype(rng1)>);
CPP_assert(forward_iterator<decltype(rng1.begin())>);
CPP_assert(!bidirectional_iterator<decltype(rng1.begin())>);
auto const & crng1 = rng1;
auto i = rng1.begin(); // non-const
auto j = crng1.begin(); // const
j = i;
::check_equal(rng1, {1, 2, 3, 4, 5, 6, 7, 8, 9, 0});
}
{
std::list<int> l{1,2,3,4,5,6,7,8,9,0,1,2,3,4,5,6,7,8,9,0};
auto rng3 = views::counted(l.begin(), 10) | views::common;
CPP_assert(view_<decltype(rng3)>);
CPP_assert(common_range<decltype(rng3)>);
CPP_assert(sized_range<decltype(rng3)>);
CPP_assert(forward_iterator<decltype(rng3.begin())>);
CPP_assert(!bidirectional_iterator<decltype(rng3.begin())>);
CPP_assert(sized_sentinel_for<decltype(rng3.begin()), decltype(rng3.end())>);
auto b = begin(rng3);
auto e = end(rng3);
CHECK((e-b) == 10);
CHECK((b-e) == -10);
CHECK((e-e) == 0);
CHECK((next(b)-b) == 1);
// Pass-through of already-common ranges is OK:
rng3 = rng3 | views::common;
}
{
auto rng4 = views::counted(begin(v), 8) | views::common;
CPP_assert(view_<decltype(rng4)>);
CPP_assert(common_range<decltype(rng4)>);
CPP_assert(sized_range<decltype(rng4)>);
CPP_assert(random_access_iterator<decltype(begin(rng4))>);
::check_equal(rng4, {1, 2, 3, 4, 5, 6, 7, 8});
}
{
// Regression test for issue#504:
auto rng1 = views::repeat_n( 0, 10 );
CPP_assert(view_<decltype(rng1)>);
CPP_assert(!common_range<decltype(rng1)>);
CPP_assert(random_access_range<decltype(rng1)>);
CPP_assert(sized_range<decltype(rng1)>);
auto const& crng1 = rng1;
CPP_assert(random_access_range<decltype(crng1)>);
CPP_assert(sized_range<decltype(crng1)>);
auto rng2 = rng1 | views::common;
CPP_assert(view_<decltype(rng2)>);
CPP_assert(common_range<decltype(rng2)>);
CPP_assert(random_access_range<decltype(rng2)>);
CPP_assert(sized_range<decltype(rng2)>);
auto const& crng2 = rng2;
CPP_assert(common_range<decltype(crng2)>);
CPP_assert(random_access_range<decltype(crng2)>);
CPP_assert(sized_range<decltype(crng2)>);
::check_equal(rng2, {0, 0, 0, 0, 0, 0, 0, 0, 0, 0});
}
{
int const rgi[] = {1,2,3,4};
auto rng = debug_input_view<int const>{rgi} | views::common;
using Rng = decltype(rng);
CPP_assert(input_range<Rng> && view_<Rng>);
CPP_assert(!forward_range<Rng>);
CPP_assert(common_range<Rng>);
::check_equal(rng, {1,2,3,4});
}
return ::test_result();
}
|
0 | repos/range-v3/test | repos/range-v3/test/view/all.cpp | // Range v3 library
//
// Copyright Eric Niebler 2014-present
//
// Use, modification and distribution is subject to the
// Boost Software License, Version 1.0. (See accompanying
// file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt)
//
// Project home: https://github.com/ericniebler/range-v3
#include <list>
#include <vector>
#include <range/v3/core.hpp>
#include <range/v3/view/all.hpp>
#include "../simple_test.hpp"
#include "../test_utils.hpp"
int main()
{
using namespace ranges;
int rgi[] = {1, 1, 1, 2, 3, 4, 4};
std::vector<int> vi(begin(rgi), end(rgi));
std::list<int> li(begin(rgi), end(rgi));
ref_view<int[7]> x = views::all(rgi);
ref_view<std::vector<int>> y = views::all(vi);
ref_view<std::list<int>> z = views::all(li);
CPP_assert(sized_range<decltype(x)> && view_<decltype(x)>);
CPP_assert(sized_range<decltype(y)> && view_<decltype(y)>);
CPP_assert(sized_range<decltype(z)> && view_<decltype(z)>);
x = views::all(x);
y = views::all(y);
z = views::all(z);
CHECK(x.size() == 7u);
CHECK(y.size() == 7u);
CHECK(z.size() == 7u);
{
auto v = views::all(debug_input_view<int const>{rgi});
CHECK(v.size() == size(rgi));
CHECK(v.data_->first_ == rgi);
auto v2 = views::all(views::all(views::all(std::move(v))));
CPP_assert(same_as<decltype(v), decltype(v2)>);
CHECK(v2.size() == size(rgi));
CHECK(v2.data_->first_ == rgi);
}
return test_result();
}
|
0 | repos/range-v3/test | repos/range-v3/test/view/group_by.cpp | // Range v3 library
//
// Copyright Eric Niebler 2014-present
//
// Use, modification and distribution is subject to the
// Boost Software License, Version 1.0. (See accompanying
// file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt)
//
// Project home: https://github.com/ericniebler/range-v3
#include <list>
#include <vector>
#include <range/v3/core.hpp>
#include <range/v3/view/counted.hpp>
#include <range/v3/view/cycle.hpp>
#include <range/v3/view/group_by.hpp>
#include <range/v3/view/remove_if.hpp>
#include <range/v3/view/take.hpp>
#include "../simple_test.hpp"
#include "../test_utils.hpp"
#include "../test_iterators.hpp"
RANGES_DIAGNOSTIC_IGNORE_SIGN_CONVERSION
RANGES_DIAGNOSTIC_IGNORE_DEPRECATED_DECLARATIONS
int main()
{
using namespace ranges;
using P = std::pair<int,int>;
std::vector<std::pair<int, int>> v =
{
{1,1},
{1,1},
{1,2},
{1,2},
{1,2},
{1,2},
{2,2},
{2,2},
{2,3},
{2,3},
{2,3},
{2,3}
};
{
auto rng0 = v | views::group_by([](P p0, P p1) {return p0.second == p1.second;});
CPP_assert(forward_range<decltype(rng0)>);
CPP_assert(!bidirectional_range<decltype(rng0)>);
CHECK(distance(rng0) == 3);
check_equal(*rng0.begin(), {P{1,1},P{1,1}});
check_equal(*next(rng0.begin()), {P{1,2},P{1,2},P{1,2},P{1,2},P{2,2},P{2,2}});
check_equal(*next(rng0.begin(), 2), {P{2,3},P{2,3},P{2,3},P{2,3}});
auto rng1 = v | views::group_by([](P p0, P p1) {return p0.first == p1.first;});
CPP_assert(forward_range<decltype(rng1)>);
CPP_assert(!bidirectional_range<decltype(rng1)>);
CHECK(distance(rng1) == 2);
check_equal(*rng1.begin(), {P{1,1},P{1,1},P{1,2},P{1,2},P{1,2},P{1,2}});
check_equal(*next(rng1.begin()), {P{2,2},P{2,2},P{2,3},P{2,3},P{2,3},P{2,3}});
}
{
ForwardIterator<std::vector<P>::iterator> b{v.begin()};
auto rng0 = views::counted(b, v.size())
| views::group_by([](P p0, P p1) {return p0.second == p1.second;});
CPP_assert(forward_range<decltype(rng0)>);
CPP_assert(!bidirectional_range<decltype(rng0)>);
CHECK(distance(rng0) == 3);
check_equal(*rng0.begin(), {P{1,1},P{1,1}});
check_equal(*next(rng0.begin()), {P{1,2},P{1,2},P{1,2},P{1,2},P{2,2},P{2,2}});
check_equal(*next(rng0.begin(), 2), {P{2,3},P{2,3},P{2,3},P{2,3}});
auto rng1 = views::counted(b, v.size())
| views::group_by([](P p0, P p1) {return p0.first == p1.first;});
CPP_assert(forward_range<decltype(rng1)>);
CPP_assert(!bidirectional_range<decltype(rng1)>);
CHECK(distance(rng1) == 2);
check_equal(*rng1.begin(), {P{1,1},P{1,1},P{1,2},P{1,2},P{1,2},P{1,2}});
check_equal(*next(rng1.begin()), {P{2,2},P{2,2},P{2,3},P{2,3},P{2,3},P{2,3}});
}
{
int a[] = {0, 1, 2, 3, 4, 5};
auto rng = a | views::remove_if([](int n) { return n % 2 == 0; })
| views::group_by([](int, int) { return true; });
check_equal(*rng.begin(), {1, 3, 5});
}
{
std::vector<int> v2 {0,1,2,3,4,5,6,7,8,9};
auto rng0 = ranges::views::group_by(v2, [](int i, int j){ return j - i < 3; });
check_equal(*rng0.begin(), {0, 1, 2});
check_equal(*next(rng0.begin()), {3, 4, 5});
check_equal(*next(rng0.begin(), 2), {6, 7, 8});
check_equal(*next(rng0.begin(), 3), {9});
CHECK(distance(rng0) == 4);
}
{
std::vector<int> v3{1, 2, 3, 4, 5};
int count_invoc = 0;
auto rng = views::group_by(v3, [&](int, int) {
++count_invoc;
return false;
});
CHECK(distance(rng) == 5);
CHECK(count_invoc == 4);
auto it = rng.begin();
check_equal(*it, {1});
check_equal(*++it, {2});
check_equal(*++it, {3});
check_equal(*++it, {4});
check_equal(*++it, {5});
// 7, not 8, because caching in begin()
CHECK(count_invoc == 7);
}
{
std::vector<int> v4 = {2, 3, 4, 5, 0, 1, 2, 3, 4, 5, 6, 0, 1, 2, 3, 0};
auto rng = v4 | views::group_by(std::less<>{});
CHECK(distance(rng) == 4);
check_equal(*rng.begin(), {2, 3, 4, 5});
check_equal(*next(rng.begin()), {0, 1, 2, 3, 4, 5, 6});
check_equal(*next(rng.begin(), 2), {0, 1, 2, 3});
check_equal(*next(rng.begin(), 3), {0});
}
{
std::vector<int> v5 = { 0, 1, 2 };
auto rng = views::cycle(v5) | views::take(6) | views::group_by(std::less<>{});
CHECK(distance(rng) == 2);
check_equal(*rng.begin(), v5);
check_equal(*next(rng.begin()), v5);
}
{
std::vector<int> e;
auto rng = e | views::group_by(std::less<>{});
CHECK(distance(rng) == 0);
}
{
std::vector<int> single{2};
auto rng = single | views::group_by([](int, int) -> bool {
throw 0;
});
CHECK(distance(rng) == 1);
check_equal(*rng.begin(), {2});
}
return test_result();
}
|
0 | repos/range-v3/test | repos/range-v3/test/view/trim.cpp | // Range v3 library
//
// Copyright Johel Guerrero 2019
//
// Use, modification and distribution is subject to the
// Boost Software License, Version 1.0. (See accompanying
// file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt)
//
// Project home: https://github.com/ericniebler/range-v3
//
#include <concepts/concepts.hpp>
#include <range/v3/iterator/operations.hpp>
#include <range/v3/range/operations.hpp>
#include <range/v3/range/primitives.hpp>
#include <range/v3/range_fwd.hpp>
#include <range/v3/utility/copy.hpp>
#include <range/v3/view/addressof.hpp>
#include <range/v3/view/drop.hpp>
#include <range/v3/view/drop_while.hpp>
#include <range/v3/view/reverse.hpp>
#include <range/v3/view/subrange.hpp>
#include <range/v3/view/tail.hpp>
#include <range/v3/view/trim.hpp>
#include "../test_iterators.hpp"
#include "../test_utils.hpp"
int main()
{
using namespace ranges;
int ia[] = {0, 1, 2, 3, 4, 3, 2, 1, 2, 3, 4, 3, 2, 1, 0};
int ib[] = {4, 3, 2, 1, 2, 3, 4};
constexpr auto bs = distance(ib);
auto p = [](int i) { return i < 4; };
auto rng = views::trim(ia, p);
static_assert(same_as<iterator_t<decltype(rng)>, iterator_t<decltype(ia)>>, "");
CPP_assert(view_<decltype(rng)>);
CPP_assert(contiguous_range<decltype(rng)>);
CPP_assert(common_range<decltype(rng)>);
CPP_assert(!sized_range<decltype(rng)>);
check_equal(rng, ib);
auto && rng2 = views::trim(ib, p);
check_equal(views::addressof(rng2), views::addressof(ib));
auto rng3 = ia | views::drop(4) | views::trim(p);
static_assert(same_as<iterator_t<decltype(rng3)>, iterator_t<decltype(rng3.base())>>, "");
CPP_assert(view_<decltype(rng3)>);
CPP_assert(contiguous_range<decltype(rng3)>);
CPP_assert(common_range<decltype(rng3)>);
CPP_assert(!sized_range<decltype(rng3)>);
check_equal(rng3, ib);
auto rng4 = ia | views::reverse | views::drop(4) | views::trim(p);
static_assert(same_as<iterator_t<decltype(rng4)>, iterator_t<decltype(rng4.base())>>, "");
CPP_assert(view_<decltype(rng4)>);
CPP_assert(random_access_range<decltype(rng4)>);
CPP_assert(common_range<decltype(rng4)>);
CPP_assert(!sized_range<decltype(rng4)>);
check_equal(rng4, ib);
check_equal(views::trim(ia, p), ia | views::drop_while(p) | views::reverse | views::drop_while(p));
auto rng5 = make_subrange(ib + 1, ib + bs - 1) | views::trim(p);
static_assert(same_as<iterator_t<decltype(rng5)>, iterator_t<decltype(rng5.base())>>, "");
CPP_assert(view_<decltype(rng5)>);
CPP_assert(contiguous_range<decltype(rng5)>);
CPP_assert(common_range<decltype(rng5)>);
CPP_assert(!sized_range<decltype(rng5)>);
CHECK(empty(rng5));
auto rng6 = make_subrange(ib, ib + bs - 1) | views::trim(p);
CHECK(distance(rng6) == 1);
check_equal(&front(rng6), ib);
auto rng7 = ib | views::tail | views::trim(p);
static_assert(same_as<iterator_t<decltype(rng7)>, iterator_t<decltype(rng7.base())>>, "");
CPP_assert(view_<decltype(rng7)>);
CPP_assert(contiguous_range<decltype(rng7)>);
CPP_assert(common_range<decltype(rng7)>);
CPP_assert(!sized_range<decltype(rng7)>);
CHECK(distance(rng7) == 1);
check_equal(&front(rng7), ib + bs - 1);
auto rng8 = make_subrange(BidirectionalIterator<const int*>(ia),
BidirectionalIterator<const int*>(ia + distance(ia))) | views::trim(p);
static_assert(same_as<iterator_t<decltype(rng8)>, iterator_t<decltype(rng8.base())>>, "");
CPP_assert(view_<decltype(rng8)>);
CPP_assert(bidirectional_range<decltype(rng8)>);
CPP_assert(common_range<decltype(rng8)>);
CPP_assert(!sized_range<decltype(rng8)>);
return test_result();
}
|
0 | repos/range-v3/test | repos/range-v3/test/view/getlines.cpp | // Range v3 library
//
// Copyright Eric Niebler 2014-present
//
// Use, modification and distribution is subject to the
// Boost Software License, Version 1.0. (See accompanying
// file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt)
//
// Project home: https://github.com/ericniebler/range-v3
#include <sstream>
#include <range/v3/core.hpp>
#include <range/v3/range/traits.hpp>
#include "../simple_test.hpp"
#include "../test_utils.hpp"
using namespace ranges;
int main()
{
const char* text =
R"(Now is
the time
for all
good men
)";
std::stringstream sin{text};
auto rng = getlines(sin);
::check_equal(rng, {"Now is", "the time", "for all", "good men"});
using Rng = decltype(rng);
CPP_assert(input_range<Rng> && view_<Rng>);
CPP_assert(!(forward_range<Rng> && view_<Rng>));
CPP_assert(same_as<range_rvalue_reference_t<Rng>, std::string &&>);
return ::test_result();
}
|
0 | repos/range-v3/test | repos/range-v3/test/view/view.cpp | #include <vector>
#include <range/v3/view/drop.hpp>
#include <range/v3/view/view.hpp>
#include "../simple_test.hpp"
#include "../test_utils.hpp"
using namespace ranges;
struct my_drop_base_fn
{
template<typename Rng>
auto operator()(Rng && rng, range_difference_t<Rng> n) const
{
return drop_view<views::all_t<Rng>>(views::all(static_cast<Rng &&>(rng)), n);
}
};
struct my_drop_fn : my_drop_base_fn
{
using my_drop_base_fn::operator();
template<typename Int>
constexpr auto operator()(Int n) const
{
return make_view_closure([=](auto && rng) {
return my_drop_base_fn{}(std::forward<decltype(rng)>(rng), n); });
}
};
RANGES_INLINE_VARIABLE(my_drop_fn, my_drop)
/// #https://github.com/ericniebler/range-v3/issues/1169
void constexpr_test_1169()
{
#if RANGES_CXX_CONSTEXPR >= RANGES_CXX_CONSTEXPR_LAMBDAS
constexpr auto const drop1 = my_drop(1);
constexpr auto const drop3 = drop1 | my_drop(2);
std::vector<int> vec = {1, 2, 3, 4};
check_equal(vec | drop3, {4});
#endif
(void)my_drop;
}
int main()
{
constexpr_test_1169();
return test_result();
}
|
0 | repos/range-v3/test | repos/range-v3/test/view/chunk_by.cpp | // Range v3 library
//
// Copyright Hui Xie 2021
//
// Use, modification and distribution is subject to the
// Boost Software License, Version 1.0. (See accompanying
// file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt)
//
// Project home: https://github.com/ericniebler/range-v3
#include <list>
#include <vector>
#include <range/v3/core.hpp>
#include <range/v3/view/chunk_by.hpp>
#include <range/v3/view/counted.hpp>
#include <range/v3/view/cycle.hpp>
#include <range/v3/view/remove_if.hpp>
#include <range/v3/view/take.hpp>
#include "../simple_test.hpp"
#include "../test_iterators.hpp"
#include "../test_utils.hpp"
RANGES_DIAGNOSTIC_IGNORE_SIGN_CONVERSION
int main()
{
using namespace ranges;
using P = std::pair<int, int>;
std::vector<std::pair<int, int>> v = {
{1, 1},
{1, 1},
{1, 2},
{1, 2},
{1, 2},
{1, 2},
{2, 2},
{2, 2},
{2, 3},
{2, 3},
{2, 3},
{2, 3},
};
{
auto rng0 =
v | views::chunk_by([](P p0, P p1) { return p0.second == p1.second; });
CPP_assert(forward_range<decltype(rng0)>);
CPP_assert(!bidirectional_range<decltype(rng0)>);
CHECK(distance(rng0) == 3);
check_equal(*rng0.begin(), {P{1, 1}, P{1, 1}});
check_equal(*next(rng0.begin()),
{P{1, 2}, P{1, 2}, P{1, 2}, P{1, 2}, P{2, 2}, P{2, 2}});
check_equal(*next(rng0.begin(), 2), {P{2, 3}, P{2, 3}, P{2, 3}, P{2, 3}});
auto rng1 = v | views::chunk_by([](P p0, P p1) { return p0.first == p1.first; });
CPP_assert(forward_range<decltype(rng1)>);
CPP_assert(!bidirectional_range<decltype(rng1)>);
CHECK(distance(rng1) == 2);
check_equal(*rng1.begin(),
{P{1, 1}, P{1, 1}, P{1, 2}, P{1, 2}, P{1, 2}, P{1, 2}});
check_equal(*next(rng1.begin()),
{P{2, 2}, P{2, 2}, P{2, 3}, P{2, 3}, P{2, 3}, P{2, 3}});
}
{
ForwardIterator<std::vector<P>::iterator> b{v.begin()};
auto rng0 = views::counted(b, v.size()) |
views::chunk_by([](P p0, P p1) { return p0.second == p1.second; });
CPP_assert(forward_range<decltype(rng0)>);
CPP_assert(!bidirectional_range<decltype(rng0)>);
CHECK(distance(rng0) == 3);
check_equal(*rng0.begin(), {P{1, 1}, P{1, 1}});
check_equal(*next(rng0.begin()),
{P{1, 2}, P{1, 2}, P{1, 2}, P{1, 2}, P{2, 2}, P{2, 2}});
check_equal(*next(rng0.begin(), 2), {P{2, 3}, P{2, 3}, P{2, 3}, P{2, 3}});
auto rng1 = views::counted(b, v.size()) |
views::chunk_by([](P p0, P p1) { return p0.first == p1.first; });
CPP_assert(forward_range<decltype(rng1)>);
CPP_assert(!bidirectional_range<decltype(rng1)>);
CHECK(distance(rng1) == 2);
check_equal(*rng1.begin(),
{P{1, 1}, P{1, 1}, P{1, 2}, P{1, 2}, P{1, 2}, P{1, 2}});
check_equal(*next(rng1.begin()),
{P{2, 2}, P{2, 2}, P{2, 3}, P{2, 3}, P{2, 3}, P{2, 3}});
}
{
int a[] = {0, 1, 2, 3, 4, 5};
auto rng = a | views::remove_if([](int n) { return n % 2 == 0; }) |
views::chunk_by([](int, int) { return true; });
check_equal(*rng.begin(), {1, 3, 5});
}
{
std::vector<int> v2{0, 1, 2, 6, 8, 10, 15, 17, 18, 29};
auto rng0 = ranges::views::chunk_by(v2, [](int i, int j) { return j - i < 3; });
check_equal(*rng0.begin(), {0, 1, 2});
check_equal(*next(rng0.begin()), {6, 8, 10});
check_equal(*next(rng0.begin(), 2), {15, 17, 18});
check_equal(*next(rng0.begin(), 3), {29});
CHECK(distance(rng0) == 4);
}
{
std::vector<int> v3{1, 2, 3, 4, 5};
int count_invoc = 0;
auto rng = views::chunk_by(v3, [&](int, int) {
++count_invoc;
return false;
});
CHECK(distance(rng) == 5);
CHECK(count_invoc == 4);
auto it = rng.begin();
check_equal(*it, {1});
check_equal(*++it, {2});
check_equal(*++it, {3});
check_equal(*++it, {4});
check_equal(*++it, {5});
// 7, not 8, because caching in begin()
CHECK(count_invoc == 7);
}
{
std::vector<int> v4 = {2, 3, 4, 5, 0, 1, 2, 3, 4, 5, 6, 0, 1, 2, 3, 0};
auto rng = v4 | views::chunk_by(std::less<>{});
CHECK(distance(rng) == 4);
check_equal(*rng.begin(), {2, 3, 4, 5});
check_equal(*next(rng.begin()), {0, 1, 2, 3, 4, 5, 6});
check_equal(*next(rng.begin(), 2), {0, 1, 2, 3});
check_equal(*next(rng.begin(), 3), {0});
}
{
std::vector<int> v5 = {0, 1, 2};
auto rng = views::cycle(v5) | views::take(6) | views::chunk_by(std::less<>{});
CHECK(distance(rng) == 2);
check_equal(*rng.begin(), v5);
check_equal(*next(rng.begin()), v5);
}
{
std::vector<int> e;
auto rng = e | views::chunk_by(std::less<>{});
CHECK(distance(rng) == 0);
}
{
std::vector<int> single{2};
auto rng = single | views::chunk_by([](int, int) -> bool { throw 0; });
CHECK(distance(rng) == 1);
check_equal(*rng.begin(), {2});
}
{
std::vector<int> v6 = {3, 6, 9, 4, 5, 0, 3, 2};
auto rng = v6 | views::chunk_by(std::less<>{});
check_equal(*rng.begin(), {3, 6, 9});
check_equal(*next(rng.begin()), {4, 5});
check_equal(*next(rng.begin(), 2), {0, 3});
check_equal(*next(rng.begin(), 3), {2});
CHECK(distance(rng) == 4);
}
return test_result();
}
|
0 | repos/range-v3/test | repos/range-v3/test/view/linear_distribute.cpp | // Range v3 library
//
// Gonzalo Brito Gadeschi 2017
//
// Use, modification and distribution is subject to the
// Boost Software License, Version 1.0. (See accompanying
// file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt)
//
// Project home: https://github.com/ericniebler/range-v3
#include <cmath>
#include <range/v3/algorithm/equal.hpp>
#include <range/v3/functional/arithmetic.hpp>
#include <range/v3/view/linear_distribute.hpp>
#include <range/v3/view/transform.hpp>
#include <range/v3/view/iota.hpp>
#include "../simple_test.hpp"
#include "../test_utils.hpp"
int main()
{
using ranges::views::linear_distribute;
auto float_eq = [](double a, double b) {
return (int)std::floor(std::abs(a - b)) == 0;
};
{
auto irng = linear_distribute(0, 1, 2);
CHECK(ranges::size(irng) == std::size_t{2});
CPP_assert(ranges::forward_range<decltype(irng)>);
CPP_assert(ranges::sized_range<decltype(irng)>);
auto il = {0, 1};
check_equal(irng, il);
}
{
auto irng = linear_distribute(1, 3, 3);
auto il = {1, 2, 3};
check_equal(irng, il);
CHECK(ranges::size(irng) == std::size_t{3});
}
{
auto irng = linear_distribute(0, 21, 22);
auto frng = linear_distribute(0., 21., 22);
check_equal(irng, frng | ranges::views::transform(ranges::convert_to<int>{}));
}
{
auto frng = linear_distribute(0.0, 1.0, 11);
CPP_assert(ranges::forward_range<decltype(frng)>);
CPP_assert(ranges::sized_range<decltype(frng)>);
CHECK(ranges::size(frng) == std::size_t{11});
auto il = {0., 0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9, 1.0};
CHECK(ranges::size(il) == std::size_t{11});
CHECK(ranges::equal(frng, il, float_eq));
}
{
using ILD = std::initializer_list<double>;
auto frng = linear_distribute(1.0, 3.0, 21);
CHECK(ranges::equal(frng,
ILD{1.0, 1.1, 1.2, 1.3, 1.4, 1.5, 1.6, 1.7, 1.8, 1.9,
2.0, 2.1, 2.2, 2.3, 2.4, 2.5, 2.6, 2.7, 2.8, 2.9,
3.0},
float_eq));
}
{ // empty interval
auto irng = linear_distribute(0, 0, 1);
CHECK(ranges::size(irng) == std::size_t{1});
check_equal(irng, {0});
auto irng1 = linear_distribute(0, 0, 10);
CHECK(ranges::size(irng1) == std::size_t{10});
check_equal(irng1, {0,0,0,0,0,0,0,0,0,0});
auto irng2 = linear_distribute(1, 1, 3);
CHECK(ranges::size(irng2) == std::size_t{3});
check_equal(irng2, {1,1,1});
auto frng = linear_distribute(0., 0., 3);
CHECK(ranges::size(frng) == std::size_t{3});
CHECK(ranges::equal(frng, std::initializer_list<double>{0.,0.,0.}, float_eq));
}
{ // regression test for #1088
auto ld = linear_distribute(1, 10, 10);
auto const first = ranges::begin(ld);
auto const i = ranges::next(first, 4);
CHECK(ranges::distance(first, i) == 4);
}
{ // integral numbers spacing
auto irng = linear_distribute(0, 10, 22);
auto frng = linear_distribute(0., 10., 22);
check_equal(irng, frng | ranges::views::transform(ranges::convert_to<int>{}));
}
return test_result();
}
|
0 | repos/range-v3/test | repos/range-v3/test/view/const.cpp | // Range v3 library
//
// Copyright Eric Niebler 2014-present
//
// Use, modification and distribution is subject to the
// Boost Software License, Version 1.0. (See accompanying
// file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt)
//
// Project home: https://github.com/ericniebler/range-v3
#include <iterator>
#include <functional>
#include <range/v3/core.hpp>
#include <range/v3/view/const.hpp>
#include <range/v3/view/counted.hpp>
#include <range/v3/view/zip.hpp>
#include <range/v3/view/move.hpp>
#include <range/v3/utility/copy.hpp>
#include "../simple_test.hpp"
#include "../test_utils.hpp"
#include "../test_iterators.hpp"
int main()
{
using namespace ranges;
int rgi[] = {1, 2, 3, 4};
{
auto rng = rgi | views::const_;
has_type<int &>(*begin(rgi));
has_type<int const &>(*begin(rng));
CPP_assert(same_as<range_rvalue_reference_t<decltype(rng)>, int const &&>);
CPP_assert(view_<decltype(rng)>);
CPP_assert(common_range<decltype(rng)>);
CPP_assert(sized_range<decltype(rng)>);
CPP_assert(random_access_range<decltype(rng)>);
::check_equal(rng, {1, 2, 3, 4});
CHECK(&*begin(rng) == &rgi[0]);
CHECK(rng.size() == 4u);
}
{
auto rng2 = views::counted(ForwardIterator<int*>(rgi), 4) | views::const_;
has_type<int const &>(*begin(rng2));
CPP_assert(same_as<range_rvalue_reference_t<decltype(rng2)>, int const &&>);
CPP_assert(view_<decltype(rng2)>);
CPP_assert(forward_range<decltype(rng2)>);
CPP_assert(!bidirectional_range<decltype(rng2)>);
CPP_assert(!common_range<decltype(rng2)>);
CPP_assert(sized_range<decltype(rng2)>);
::check_equal(rng2, {1, 2, 3, 4});
CHECK(&*begin(rng2) == &rgi[0]);
CHECK(rng2.size() == 4u);
}
{
auto zip = views::zip(rgi, rgi);
auto rng3 = zip | views::const_;
has_type<common_pair<int &, int &>>(*begin(zip));
has_type<common_pair<int &&, int &&>>(iter_move(begin(zip)));
has_type<common_pair<int const &, int const &>>(*begin(rng3));
has_type<common_pair<int const &&, int const &&>>(iter_move(begin(rng3)));
CPP_assert(view_<decltype(rng3)>);
CPP_assert(random_access_range<decltype(rng3)>);
CPP_assert(common_range<decltype(rng3)>);
CPP_assert(sized_range<decltype(rng3)>);
using P = std::pair<int,int>;
::check_equal(rng3, {P{1,1}, P{2,2}, P{3,3}, P{4,4}});
CHECK(&(*begin(rng3)).first == &rgi[0]);
CHECK(rng3.size() == 4u);
}
{
auto zip2 = views::zip(rgi, rgi) | views::move;
auto rng4 = zip2 | views::const_;
has_type<common_pair<int &&, int &&>>(*begin(zip2));
has_type<common_pair<int &&, int &&>>(iter_move(begin(zip2)));
has_type<common_pair<int const &&, int const &&>>(*begin(rng4));
has_type<common_pair<int const &&, int const &&>>(iter_move(begin(rng4)));
CPP_assert(view_<decltype(rng4)>);
CPP_assert(random_access_range<decltype(rng4)>);
CPP_assert(common_range<decltype(rng4)>);
CPP_assert(sized_range<decltype(rng4)>);
using P = std::pair<int,int>;
::check_equal(rng4, {P{1,1}, P{2,2}, P{3,3}, P{4,4}});
CHECK(&(*begin(rng4)).first == &rgi[0]);
CHECK(rng4.size() == 4u);
}
{
auto rng = debug_input_view<int>{rgi} | views::const_;
CPP_assert(same_as<int const&, range_reference_t<decltype(rng)>>);
::check_equal(rng, rgi);
}
return test_result();
}
|
0 | repos/range-v3/test | repos/range-v3/test/view/subrange.cpp | // Range v3 library
//
// Copyright Eric Niebler 2017-present
//
// Use, modification and distribution is subject to the
// Boost Software License, Version 1.0. (See accompanying
// file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt)
//
// Project home: https://github.com/ericniebler/range-v3
#include <list>
#include <vector>
#include <range/v3/core.hpp>
#include <range/v3/view/all.hpp>
#include <range/v3/view/ref.hpp>
#include <range/v3/view/subrange.hpp>
#include "../simple_test.hpp"
#include "../test_utils.hpp"
#include "../test_iterators.hpp"
CPP_template(class Rng)(
requires ranges::range<Rng>)
ranges::borrowed_subrange_t<Rng> algorithm(Rng &&rng);
struct Base {};
struct Derived : Base {};
int main()
{
using namespace ranges;
std::vector<int> vi{1,2,3,4};
////////////////////////////////////////////////////////////////////////////
// borrowed_subrange_t tests:
// lvalues are ReferenceableRanges and do not dangle:
CPP_assert(same_as<subrange<int*>,
decltype(::algorithm(std::declval<int(&)[42]>()))>);
CPP_assert(same_as<subrange<std::vector<int>::iterator>,
decltype(::algorithm(vi))>);
// subrange and ref_view are ReferenceableRanges and do not dangle:
CPP_assert(same_as<subrange<int*>,
decltype(::algorithm(std::declval<subrange<int*>>()))>);
CPP_assert(same_as<subrange<int*>,
decltype(::algorithm(std::declval<ref_view<int[42]>>()))>);
// non-ReferenceableRange rvalue ranges dangle:
CPP_assert(same_as<dangling,
decltype(::algorithm(std::declval<std::vector<int>>()))>);
CPP_assert(same_as<dangling,
decltype(::algorithm(std::move(vi)))>);
// Test that slicing conversions are not allowed.
CPP_assert(constructible_from<subrange<Base*, Base*>, Base*, Base*>);
CPP_assert(!constructible_from<subrange<Base*, Base*>, Derived*, Derived*>);
CPP_assert(constructible_from<subrange<const Base*, const Base*>, Base*, Base*>);
CPP_assert(!constructible_from<subrange<const Base*, const Base*>, Derived*, Derived*>);
CPP_assert(!constructible_from<subrange<Base*, Base*>, subrange<Derived*, Derived*>>);
CPP_assert(constructible_from<subrange<Base*, unreachable_sentinel_t>, Base*, unreachable_sentinel_t>);
CPP_assert(!constructible_from<subrange<Base*, unreachable_sentinel_t>, Derived*, unreachable_sentinel_t>);
CPP_assert(constructible_from<subrange<const Base*, unreachable_sentinel_t>, Base*, unreachable_sentinel_t>);
CPP_assert(!constructible_from<subrange<const Base*, unreachable_sentinel_t>, Derived*, unreachable_sentinel_t>);
CPP_assert(!constructible_from<subrange<Base*, unreachable_sentinel_t>, subrange<Derived*, unreachable_sentinel_t>>);
CPP_assert(constructible_from<subrange<Base*, Base*, subrange_kind::sized>, Base*, Base*, std::size_t>);
CPP_assert(!constructible_from<subrange<Base*, Base*, subrange_kind::sized>, Derived*, Base*, std::size_t>);
CPP_assert(constructible_from<subrange<const Base*, const Base*, subrange_kind::sized>, Base*, const Base*, std::size_t>);
CPP_assert(!constructible_from<subrange<const Base*, const Base*, subrange_kind::sized>, Derived*, const Base*, std::size_t>);
CPP_assert(!constructible_from<subrange<Base*, Base*, subrange_kind::sized>, subrange<Derived*, Base*>, std::size_t>);
CPP_assert(convertible_to<subrange<Base*, Base*>, std::pair<const Base*, const Base*>>);
CPP_assert(!convertible_to<subrange<Derived*, Derived*>, std::pair<Base*, Base*>>);
subrange<std::vector<int>::iterator> r0 {vi.begin(), vi.end()};
static_assert(std::tuple_size<decltype(r0)>::value == 2, "");
CPP_assert(same_as<std::vector<int>::iterator,
std::tuple_element<0, decltype(r0)>::type>);
CPP_assert(same_as<std::vector<int>::iterator,
std::tuple_element<1, decltype(r0)>::type>);
CPP_assert(sized_range<decltype(r0)>);
CHECK(r0.size() == 4u);
CHECK(r0.begin() == vi.begin());
CHECK(get<0>(r0) == vi.begin());
CHECK(r0.end() == vi.end());
CHECK(get<1>(r0) == vi.end());
r0 = r0.next();
CHECK(r0.size() == 3u);
{
subrange<std::vector<int>::iterator> rng {vi.begin(), vi.end(), ranges::size(vi)};
CHECK(rng.size() == 4u);
CHECK(rng.begin() == vi.begin());
CHECK(rng.end() == vi.end());
}
std::pair<std::vector<int>::iterator, std::vector<int>::iterator> p0 = r0;
CHECK(p0.first == vi.begin()+1);
CHECK(p0.second == vi.end());
subrange<std::vector<int>::iterator, unreachable_sentinel_t> r1 { r0.begin(), {} };
static_assert(std::tuple_size<decltype(r1)>::value == 2, "");
CPP_assert(same_as<std::vector<int>::iterator,
std::tuple_element<0, decltype(r1)>::type>);
CPP_assert(same_as<unreachable_sentinel_t,
std::tuple_element<1, decltype(r1)>::type>);
CPP_assert(view_<decltype(r1)>);
CPP_assert(!sized_range<decltype(r1)>);
CHECK(r1.begin() == vi.begin()+1);
r1.end() = unreachable;
r0 = r0.next();
++r0.begin();
CHECK(r0.begin() == vi.begin()+2);
CHECK(r0.size() == 2u);
r0 = {r0.begin(), --r0.end()}; // --r0.end();
CHECK(r0.end() == vi.end()-1);
CHECK(r0.size() == 1u);
CHECK(r0.front() == 3);
CHECK(r0.back() == 3);
std::pair<std::vector<int>::iterator, unreachable_sentinel_t> p1 = r1;
CHECK(p1.first == vi.begin()+1);
std::list<int> li{1,2,3,4};
using LI = std::list<int>::iterator;
subrange<LI, LI, subrange_kind::sized> l0 {li.begin(), li.end(), li.size()};
CPP_assert(view_<decltype(l0)> && sized_range<decltype(l0)>);
CHECK(l0.begin() == li.begin());
CHECK(l0.end() == li.end());
CHECK(l0.size() == li.size());
l0 = l0.next();
CHECK(l0.begin() == next(li.begin()));
CHECK(l0.end() == li.end());
CHECK(l0.size() == li.size() - 1u);
l0 = views::all(li);
subrange<std::list<int>::iterator> l1 = l0;
CPP_assert(!sized_range<decltype(l1)>);
CHECK(l1.begin() == li.begin());
CHECK(l1.end() == li.end());
#if RANGES_CXX_DEDUCTION_GUIDES >= RANGES_CXX_DEDUCTION_GUIDES_17
#if defined(__clang__) && __clang_major__ < 6
// Workaround https://bugs.llvm.org/show_bug.cgi?id=33314
RANGES_DIAGNOSTIC_PUSH
RANGES_DIAGNOSTIC_IGNORE_UNDEFINED_FUNC_TEMPLATE
#endif
{
subrange s0{vi.begin(), vi.end()};
subrange s1{li.begin(), li.end()};
CPP_assert(same_as<decltype(r0), decltype(s0)>);
CPP_assert(same_as<decltype(l1), decltype(s1)>);
}
{
subrange s0{vi.begin(), vi.end(), ranges::size(vi)};
subrange s1{li.begin(), li.end(), ranges::size(li)};
CPP_assert(same_as<decltype(r0), decltype(s0)>);
CPP_assert(same_as<decltype(l0), decltype(s1)>);
}
{
subrange s0{vi};
subrange s1{li};
subrange s2{views::all(vi)};
subrange s3{views::all(li)};
CPP_assert(same_as<decltype(r0), decltype(s0)>);
CPP_assert(same_as<decltype(l0), decltype(s1)>);
CPP_assert(same_as<decltype(r0), decltype(s2)>);
CPP_assert(same_as<decltype(l0), decltype(s3)>);
}
{
subrange s0{r0};
subrange s1{l0};
subrange s2{l1};
CPP_assert(same_as<decltype(r0), decltype(s0)>);
CPP_assert(same_as<decltype(l0), decltype(s1)>);
CPP_assert(same_as<decltype(l1), decltype(s2)>);
}
{
subrange s0{vi, ranges::size(vi)};
subrange s1{li, ranges::size(li)};
subrange s2{views::all(vi), ranges::size(vi)};
subrange s3{views::all(li), ranges::size(li)};
CPP_assert(same_as<decltype(r0), decltype(s0)>);
CPP_assert(same_as<decltype(l0), decltype(s1)>);
CPP_assert(same_as<decltype(r0), decltype(s2)>);
CPP_assert(same_as<decltype(l0), decltype(s3)>);
}
{
subrange s0{r0, size(r0)};
subrange s1{l0, size(l0)};
subrange s2{l1, size(l0)};
CPP_assert(same_as<decltype(r0), decltype(s0)>);
CPP_assert(same_as<decltype(l0), decltype(s1)>);
CPP_assert(same_as<decltype(l0), decltype(s2)>);
}
{
subrange s(li.begin(), li.end());
subrange s2 = s.next();
CHECK(s2.begin() == std::next(li.begin()));
CHECK(s2.end() == li.end());
}
#if defined(__clang__) && __clang_major__ < 6
RANGES_DIAGNOSTIC_POP
#endif // clang bug workaround
#endif // use deduction guides
return ::test_result();
}
|
0 | repos/range-v3/test | repos/range-v3/test/view/split.cpp | // Range v3 library
//
// Copyright Eric Niebler 2014-present
//
// Use, modification and distribution is subject to the
// Boost Software License, Version 1.0. (See accompanying
// file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt)
//
// Project home: https://github.com/ericniebler/range-v3
#include <string>
#include <cctype>
#include <sstream>
#include <range/v3/core.hpp>
#include <range/v3/view/counted.hpp>
#include <range/v3/view/c_str.hpp>
#include <range/v3/view/empty.hpp>
#include <range/v3/view/remove_if.hpp>
#include <range/v3/view/split.hpp>
#include <range/v3/view/split_when.hpp>
#include "../simple_test.hpp"
#include "../test_utils.hpp"
#include "../test_iterators.hpp"
RANGES_DIAGNOSTIC_IGNORE_SIGN_CONVERSION
#if defined(__clang__) && __clang_major__ < 6
// Workaround https://bugs.llvm.org/show_bug.cgi?id=33314
RANGES_DIAGNOSTIC_IGNORE_UNDEFINED_FUNC_TEMPLATE
#endif
namespace
{
struct starts_with_g
{
template<typename I, typename S>
std::pair<bool, I> operator()(I b, S) const
{
return {*b == 'g', b};
}
};
#ifdef RANGES_WORKAROUND_MSVC_790554
template<std::size_t N>
auto c_str(char const (&sz)[N])
{
return ranges::subrange<char const*>{&sz[0], &sz[N-1]};
}
#else // ^^^ workaround / no workaround vvv
template<std::size_t N>
ranges::subrange<char const*> c_str(char const (&sz)[N])
{
return {&sz[0], &sz[N-1]};
}
#endif // RANGES_WORKAROUND_MSVC_790554
}
void moar_tests()
{
using namespace ranges;
std::string greeting = "now is the time";
std::string pattern = " ";
{
#if RANGES_CXX_DEDUCTION_GUIDES >= RANGES_CXX_DEDUCTION_GUIDES_17
split_view sv{greeting, pattern};
#else
split_view<views::all_t<std::string&>, views::all_t<std::string&>> sv{greeting, pattern};
#endif
auto i = sv.begin();
check_equal(*i, {'n','o','w'});
++i;
CHECK(i != sv.end());
check_equal(*i, {'i','s'});
++i;
CHECK(i != sv.end());
check_equal(*i, {'t','h','e'});
++i;
CHECK(i != sv.end());
check_equal(*i, {'t','i','m','e'});
++i;
CHECK(i == sv.end());
using R = decltype(sv);
CPP_assert(forward_range<R>);
CPP_assert(forward_range<R const>);
}
{
#if RANGES_CXX_DEDUCTION_GUIDES >= RANGES_CXX_DEDUCTION_GUIDES_17
split_view sv{greeting, ' '};
#else
split_view<views::all_t<std::string&>, single_view<char>> sv{greeting, ' '};
#endif
auto i = sv.begin();
CHECK(i != sv.end());
check_equal(*i, {'n','o','w'});
++i;
CHECK(i != sv.end());
check_equal(*i, {'i','s'});
++i;
CHECK(i != sv.end());
check_equal(*i, {'t','h','e'});
++i;
CHECK(i != sv.end());
check_equal(*i, {'t','i','m','e'});
++i;
CHECK(i == sv.end());
using R = decltype(sv);
CPP_assert(forward_range<R>);
CPP_assert(forward_range<R const>);
}
{
std::stringstream sin{greeting};
#if RANGES_CXX_DEDUCTION_GUIDES >= RANGES_CXX_DEDUCTION_GUIDES_17
auto rng = subrange{
std::istreambuf_iterator<char>{sin},
std::istreambuf_iterator<char>{}};
#else
auto rng = make_subrange(
std::istreambuf_iterator<char>{sin},
std::istreambuf_iterator<char>{});
#endif
auto sv = views::split(rng, ' ');
auto i = sv.begin();
CHECK(i != sv.end());
check_equal(*i, {'n','o','w'});
++i;
CHECK(i != sv.end());
check_equal(*i, {'i','s'});
++i;
CHECK(i != sv.end());
check_equal(*i, {'t','h','e'});
++i;
CHECK(i != sv.end());
check_equal(*i, {'t','i','m','e'});
++i;
CHECK(i == sv.end());
using R = decltype(sv);
CPP_assert(input_range<R>);
CPP_assert(!forward_range<R>);
CPP_assert(!input_range<R const>);
}
{
std::string list{"eggs,milk,,butter"};
auto sv = views::split(list, ',');
auto i = sv.begin();
CHECK(i != sv.end());
check_equal(*i, {'e','g','g','s'});
++i;
CHECK(i != sv.end());
check_equal(*i, {'m','i','l','k'});
++i;
CHECK(i != sv.end());
check_equal(*i, views::empty<char>);
++i;
CHECK(i != sv.end());
check_equal(*i, {'b','u','t','t','e','r'});
++i;
CHECK(i == sv.end());
}
{
std::string list{"eggs,milk,,butter"};
std::stringstream sin{list};
auto rng = make_subrange(
std::istreambuf_iterator<char>{sin},
std::istreambuf_iterator<char>{});
auto sv = rng | views::split(',');
auto i = sv.begin();
CHECK(i != sv.end());
check_equal(*i, {'e','g','g','s'});
++i;
CHECK(i != sv.end());
check_equal(*i, {'m','i','l','k'});
++i;
CHECK(i != sv.end());
check_equal(*i, views::empty<char>);
++i;
CHECK(i != sv.end());
check_equal(*i, {'b','u','t','t','e','r'});
++i;
CHECK(i == sv.end());
}
{
std::string hello("hello");
auto sv = views::split(hello, views::empty<char>);
auto i = sv.begin();
CHECK(i != sv.end());
check_equal(*i, single_view<char>{'h'});
++i;
CHECK(i != sv.end());
check_equal(*i, single_view<char>{'e'});
++i;
CHECK(i != sv.end());
check_equal(*i, single_view<char>{'l'});
++i;
CHECK(i != sv.end());
check_equal(*i, single_view<char>{'l'});
++i;
CHECK(i != sv.end());
check_equal(*i, single_view<char>{'o'});
++i;
CHECK(i == sv.end());
}
{
std::string hello{"hello"};
std::stringstream sin{hello};
auto rng = make_subrange(
std::istreambuf_iterator<char>{sin},
std::istreambuf_iterator<char>{});
auto sv = views::split(rng, views::empty<char>);
auto i = sv.begin();
CHECK(i != sv.end());
check_equal(*i, single_view<char>{'h'});
++i;
CHECK(i != sv.end());
check_equal(*i, single_view<char>{'e'});
++i;
CHECK(i != sv.end());
check_equal(*i, single_view<char>{'l'});
++i;
CHECK(i != sv.end());
check_equal(*i, single_view<char>{'l'});
++i;
CHECK(i != sv.end());
check_equal(*i, single_view<char>{'o'});
++i;
CHECK(i == sv.end());
}
{
std::string hello{"hello"};
auto sv = views::split(hello, views::empty<char>);
auto i = sv.begin();
CHECK(i != sv.end());
++i;
CHECK(i != sv.end());
++i;
CHECK(i != sv.end());
check_equal(*i, single_view<char>{'l'});
++i;
CHECK(i != sv.end());
check_equal(*i, single_view<char>{'l'});
++i;
CHECK(i != sv.end());
++i;
CHECK(i == sv.end());
}
{
std::string hello{"hello"};
std::stringstream sin{hello};
auto rng = make_subrange(
std::istreambuf_iterator<char>{sin},
std::istreambuf_iterator<char>{});
auto sv = views::split(rng, views::empty<char>);
auto i = sv.begin();
CHECK(i != sv.end());
++i;
CHECK(i != sv.end());
++i;
CHECK(i != sv.end());
check_equal(*i, single_view<char>{'l'});
++i;
CHECK(i != sv.end());
check_equal(*i, single_view<char>{'l'});
++i;
CHECK(i != sv.end());
++i;
CHECK(i == sv.end());
}
}
int main()
{
using namespace ranges;
{
std::string str("Now is the time for all good men to come to the aid of their country.");
auto rng = views::split(str, ' ');
CHECK(distance(rng) == 16);
if(distance(rng) == 16)
{
check_equal(*(next(begin(rng),0)), c_str("Now"));
check_equal(*(next(begin(rng),1)), c_str("is"));
check_equal(*(next(begin(rng),2)), c_str("the"));
check_equal(*(next(begin(rng),3)), c_str("time"));
check_equal(*(next(begin(rng),4)), c_str("for"));
check_equal(*(next(begin(rng),5)), c_str("all"));
check_equal(*(next(begin(rng),6)), c_str("good"));
check_equal(*(next(begin(rng),7)), c_str("men"));
check_equal(*(next(begin(rng),8)), c_str("to"));
check_equal(*(next(begin(rng),9)), c_str("come"));
check_equal(*(next(begin(rng),10)), c_str("to"));
check_equal(*(next(begin(rng),11)), c_str("the"));
check_equal(*(next(begin(rng),12)), c_str("aid"));
check_equal(*(next(begin(rng),13)), c_str("of"));
check_equal(*(next(begin(rng),14)), c_str("their"));
check_equal(*(next(begin(rng),15)), c_str("country."));
}
}
{
std::string str("Now is the time for all good men to come to the aid of their country.");
auto rng = views::split(str, c_str(" "));
CHECK(distance(rng) == 16);
if(distance(rng) == 16)
{
check_equal(*(next(begin(rng),0)), c_str("Now"));
check_equal(*(next(begin(rng),1)), c_str("is"));
check_equal(*(next(begin(rng),2)), c_str("the"));
check_equal(*(next(begin(rng),3)), c_str("time"));
check_equal(*(next(begin(rng),4)), c_str("for"));
check_equal(*(next(begin(rng),5)), c_str("all"));
check_equal(*(next(begin(rng),6)), c_str("good"));
check_equal(*(next(begin(rng),7)), c_str("men"));
check_equal(*(next(begin(rng),8)), c_str("to"));
check_equal(*(next(begin(rng),9)), c_str("come"));
check_equal(*(next(begin(rng),10)), c_str("to"));
check_equal(*(next(begin(rng),11)), c_str("the"));
check_equal(*(next(begin(rng),12)), c_str("aid"));
check_equal(*(next(begin(rng),13)), c_str("of"));
check_equal(*(next(begin(rng),14)), c_str("their"));
check_equal(*(next(begin(rng),15)), c_str("country."));
}
}
{
std::string str("Now is the time for all ggood men to come to the aid of their country.");
auto rng = views::split_when(str, starts_with_g{});
CHECK(distance(rng) == 3);
if(distance(rng) == 3)
{
check_equal(*begin(rng), c_str("Now is the time for all "));
check_equal(*next(begin(rng)), c_str("g"));
check_equal(*(next(begin(rng),2)), c_str("good men to come to the aid of their country."));
}
}
{
std::string str("Now is the time for all ggood men to come to the aid of their country.");
ForwardIterator<std::string::iterator> i {str.begin()};
auto rng = views::counted(i, str.size()) | views::split_when(starts_with_g{});
CHECK(distance(rng) == 3);
if(distance(rng) == 3)
{
check_equal(*begin(rng), c_str("Now is the time for all "));
check_equal(*next(begin(rng)), c_str("g"));
check_equal(*(next(begin(rng),2)), c_str("good men to come to the aid of their country."));
}
}
{
std::string str("meow");
auto rng = views::split(str, views::empty<char>);
CHECK(distance(rng) == 4);
if(distance(rng) == 4)
{
check_equal(*(next(begin(rng),0)), c_str("m"));
check_equal(*(next(begin(rng),1)), c_str("e"));
check_equal(*(next(begin(rng),2)), c_str("o"));
check_equal(*(next(begin(rng),3)), c_str("w"));
}
}
{
int a[] = {0, 2, 3, 1, 4, 5, 1, 6, 7};
auto rng = a | views::remove_if([](int i) { return i % 2 == 0; });
auto srng = views::split(rng, 1);
CHECK(distance(srng) == 3);
check_equal(*begin(srng), {3});
check_equal(*next(begin(srng), 1), {5});
check_equal(*next(begin(srng), 2), {7});
}
{
std::string str("now is \t the\ttime");
auto rng = views::split_when(str, (int(*)(int))&std::isspace);
CHECK(distance(rng) == 4);
if(distance(rng) == 4)
{
check_equal(*(next(begin(rng),0)), c_str("now"));
check_equal(*(next(begin(rng),1)), c_str("is"));
check_equal(*(next(begin(rng),2)), c_str("the"));
check_equal(*(next(begin(rng),3)), c_str("time"));
}
}
{ // Regression test for https://stackoverflow.com/questions/49015671
auto const str = "quick brown fox";
auto rng = views::c_str(str) | views::split(' ');
CPP_assert(forward_range<decltype(rng)>);
}
{ // Regression test for #986
std::string s;
s | ranges::views::split_when([](char) { return true; });
}
moar_tests();
{ // Regression test for #1041
auto is_escape = [](auto first, auto last) {
return std::make_pair(next(first) != last, first);
};
auto escapes = views::split_when(views::c_str(R"(\t)"), is_escape);
CPP_assert(forward_range<decltype(escapes)>);
auto const first = begin(escapes);
CHECK(first != end(escapes));
CHECK(first != next(first));
}
return test_result();
}
|
0 | repos/range-v3/test | repos/range-v3/test/view/istream.cpp | // Range v3 library
//
// Copyright Eric Niebler 2014-present
//
// Use, modification and distribution is subject to the
// Boost Software License, Version 1.0. (See accompanying
// file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt)
//
// Project home: https://github.com/ericniebler/range-v3
#include <range/v3/view/istream.hpp>
#include <range/v3/view/subrange.hpp>
#include <sstream>
#include "../simple_test.hpp"
#include "../test_utils.hpp"
int main()
{
static const char test[] = "abcd3210";
std::istringstream ss{test};
::check_equal(ranges::istream<char>(ss),
ranges::make_subrange(test, test + sizeof(test) - 1));
return ::test_result();
}
|
0 | repos/range-v3/test | repos/range-v3/test/view/transform.cpp | // Range v3 library
//
// Copyright Eric Niebler 2014-present
//
// Use, modification and distribution is subject to the
// Boost Software License, Version 1.0. (See accompanying
// file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt)
//
// Project home: https://github.com/ericniebler/range-v3
#include <string>
#include <vector>
#include <iterator>
#include <functional>
#include <range/v3/core.hpp>
#include <range/v3/algorithm/move.hpp>
#include <range/v3/functional/overload.hpp>
#include <range/v3/iterator/insert_iterators.hpp>
#include <range/v3/utility/copy.hpp>
#include <range/v3/view/transform.hpp>
#include <range/v3/view/counted.hpp>
#include <range/v3/view/reverse.hpp>
#include <range/v3/view/span.hpp>
#include <range/v3/view/zip.hpp>
#include "../simple_test.hpp"
#include "../test_utils.hpp"
struct is_odd
{
bool operator()(int i) const
{
return (i % 2) == 1;
}
};
// https://github.com/ericniebler/range-v3/issues/996
void bug_996()
{
std::vector<int> buff(12, -1);
::ranges::span<int> sp(buff.data(), 12);
auto x = ::ranges::views::transform(sp, [](int a) { return a > 3 ? a : 42; });
auto y = ::ranges::views::transform(x, sp, [](int a, int b) { return a + b; });
auto rng = ::ranges::views::transform(y, [](int a) { return a + 1; });
(void)rng;
}
int main()
{
using namespace ranges;
int rgi[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
std::pair<int, int> rgp[] = {{1,1}, {2,2}, {3,3}, {4,4}, {5,5}, {6,6}, {7,7}, {8,8}, {9,9}, {10,10}};
{
auto rng = rgi | views::transform(is_odd());
has_type<int &>(*begin(rgi));
has_type<bool>(*begin(rng));
CPP_assert(view_<decltype(rng)>);
CPP_assert(sized_range<decltype(rng)>);
CPP_assert(random_access_range<decltype(rng)>);
::check_equal(rng, {true, false, true, false, true, false, true, false, true, false});
}
{
auto rng2 = rgp | views::transform(&std::pair<int,int>::first);
has_type<int &>(*begin(rng2));
CPP_assert(same_as<range_value_t<decltype(rng2)>, int>);
CPP_assert(same_as<decltype(iter_move(begin(rng2))), int &&>);
CPP_assert(view_<decltype(rng2)>);
CPP_assert(common_range<decltype(rng2)>);
CPP_assert(sized_range<decltype(rng2)>);
CPP_assert(random_access_range<decltype(rng2)>);
::check_equal(rng2, {1,2,3,4,5,6,7,8,9,10});
::check_equal(rng2 | views::reverse, {10,9,8,7,6,5,4,3,2,1});
CHECK(&*begin(rng2) == &rgp[0].first);
CHECK(rng2.size() == 10u);
}
{
auto rng3 = views::counted(rgp, 10) | views::transform(&std::pair<int,int>::first);
has_type<int &>(*begin(rng3));
CPP_assert(view_<decltype(rng3)>);
CPP_assert(common_range<decltype(rng3)>);
CPP_assert(sized_range<decltype(rng3)>);
CPP_assert(random_access_range<decltype(rng3)>);
::check_equal(rng3, {1,2,3,4,5,6,7,8,9,10});
CHECK(&*begin(rng3) == &rgp[0].first);
CHECK(rng3.size() == 10u);
}
{
auto rng4 = views::counted(ForwardIterator<std::pair<int, int>*>{rgp}, 10)
| views::transform(&std::pair<int,int>::first);
has_type<int &>(*begin(rng4));
CPP_assert(view_<decltype(rng4)>);
CPP_assert(!common_range<decltype(rng4)>);
CPP_assert(sized_range<decltype(rng4)>);
CPP_assert(forward_range<decltype(rng4)>);
CPP_assert(!bidirectional_range<decltype(rng4)>);
::check_equal(rng4, {1,2,3,4,5,6,7,8,9,10});
CHECK(&*begin(rng4) == &rgp[0].first);
CHECK(rng4.size() == 10u);
counted_iterator<ForwardIterator<std::pair<int, int>*>> i = begin(rng4).base();
(void)i;
}
// Test transform with a mutable lambda
{
int cnt = 100;
auto mutable_rng = views::transform(rgi, [cnt](int) mutable { return cnt++;});
::check_equal(mutable_rng, {100,101,102,103,104,105,106,107,108,109});
CHECK(cnt == 100);
CPP_assert(view_<decltype(mutable_rng)>);
CPP_assert(!view_<decltype(mutable_rng) const>);
}
// Test iter_transform by transforming a zip view to select one element.
{
auto v0 = to<std::vector<MoveOnlyString>>({"a","b","c"});
auto v1 = to<std::vector<MoveOnlyString>>({"x","y","z"});
auto rng1 = views::zip(v0, v1);
CPP_assert(random_access_range<decltype(rng1)>);
std::vector<MoveOnlyString> res;
using R1 = decltype(rng1);
using I1 = iterator_t<R1>;
// Needlessly verbose -- a simple transform would do the same, but this
// is an interesting test.
auto proj = overload(
[](I1 i1) -> MoveOnlyString& {return (*i1).first;},
[](copy_tag, I1) -> MoveOnlyString {return {};},
[](move_tag, I1 i1) -> MoveOnlyString&& {return std::move((*i1).first);}
);
auto rng2 = rng1 | views::iter_transform(proj);
move(rng2, ranges::back_inserter(res));
::check_equal(res, {"a","b","c"});
::check_equal(v0, {"","",""});
::check_equal(v1, {"x","y","z"});
using R2 = decltype(rng2);
CPP_assert(same_as<range_value_t<R2>, MoveOnlyString>);
CPP_assert(same_as<range_reference_t<R2>, MoveOnlyString &>);
CPP_assert(same_as<range_rvalue_reference_t<R2>, MoveOnlyString &&>);
}
// two range transform
{
auto v0 = to<std::vector<std::string>>({"a","b","c"});
auto v1 = to<std::vector<std::string>>({"x","y","z"});
auto rng = views::transform(v0, v1, [](std::string& s0, std::string& s1){return std::tie(s0, s1);});
using R = decltype(rng);
CPP_assert(same_as<range_value_t<R>, std::tuple<std::string&, std::string&>>);
CPP_assert(same_as<range_reference_t<R>, std::tuple<std::string&, std::string&>>);
CPP_assert(same_as<range_rvalue_reference_t<R>, std::tuple<std::string&, std::string&>>);
using T = std::tuple<std::string, std::string>;
::check_equal(rng, {T{"a","x"}, T{"b","y"}, T{"c","z"}});
}
// two range indirect transform
{
auto v0 = to<std::vector<std::string>>({"a","b","c"});
auto v1 = to<std::vector<std::string>>({"x","y","z"});
using I = std::vector<std::string>::iterator;
auto fun = overload(
[](I i, I j) { return std::tie(*i, *j); },
[](copy_tag, I, I) { return std::tuple<std::string, std::string>{}; },
[](move_tag, I i, I j) { return common_tuple<std::string&&, std::string&&>{
std::move(*i), std::move(*j)}; } );
auto rng = views::iter_transform(v0, v1, fun);
using R = decltype(rng);
CPP_assert(same_as<range_value_t<R>, std::tuple<std::string, std::string>>);
CPP_assert(same_as<range_reference_t<R>, std::tuple<std::string&, std::string&>>);
CPP_assert(same_as<range_rvalue_reference_t<R>, common_tuple<std::string&&, std::string&&>>);
using T = std::tuple<std::string, std::string>;
::check_equal(rng, {T{"a","x"}, T{"b","y"}, T{"c","z"}});
}
{
auto rng = debug_input_view<int const>{rgi} | views::transform(is_odd{});
::check_equal(rng, {true, false, true, false, true, false, true, false, true, false});
}
{
auto v0 = to<std::vector<std::string>>({"a","b","c"});
auto v1 = to<std::vector<std::string>>({"x","y","z"});
auto r0 = debug_input_view<std::string>{v0.data(), distance(v0)};
auto r1 = debug_input_view<std::string>{v1.data(), distance(v1)};
auto rng = views::transform(std::move(r0), std::move(r1),
[](std::string &s0, std::string &s1){ return std::tie(s0, s1); });
using R = decltype(rng);
CPP_assert(same_as<range_value_t<R>, std::tuple<std::string &, std::string &>>);
CPP_assert(same_as<range_reference_t<R>, std::tuple<std::string &, std::string &>>);
CPP_assert(same_as<range_rvalue_reference_t<R>, std::tuple<std::string &, std::string &>>);
using T = std::tuple<std::string, std::string>;
::check_equal(rng, {T{"a","x"}, T{"b","y"}, T{"c","z"}});
}
{
#if RANGES_CXX_DEDUCTION_GUIDES >= RANGES_CXX_DEDUCTION_GUIDES_17
#if defined(__clang__) && __clang_major__ < 6
// Workaround https://bugs.llvm.org/show_bug.cgi?id=33314
RANGES_DIAGNOSTIC_PUSH
RANGES_DIAGNOSTIC_IGNORE_UNDEFINED_FUNC_TEMPLATE
#endif
std::vector<int> vi = {1, 2, 3};
ranges::transform_view times_ten{vi, [](int i) { return i * 10; }};
::check_equal(times_ten, {10, 20, 30});
#if defined(__clang__) && __clang_major__ < 6
RANGES_DIAGNOSTIC_POP
#endif // clang bug workaround
#endif // use deduction guides
}
return test_result();
}
|
0 | repos/range-v3/test | repos/range-v3/test/view/addressof.cpp | /// \file
// Range v3 library
//
// Copyright Andrey Diduh 2019
//
// Use, modification and distribution is subject to the
// Boost Software License, Version 1.0. (See accompanying
// file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt)
//
// Project home: https://github.com/ericniebler/range-v3
//
#include <sstream>
#include <vector>
#include <range/v3/core.hpp>
#include <range/v3/view/addressof.hpp>
#include <range/v3/view/facade.hpp>
#include <range/v3/view/iota.hpp>
#include <range/v3/view/take.hpp>
#include "../simple_test.hpp"
#include "../test_utils.hpp"
using namespace ranges;
void simple_test()
{
std::vector<int> list = {1,2,3};
auto out = list | views::addressof;
check_equal(out, {&list[0], &list[1], &list[2]});
}
struct test_istream_range
: view_facade<test_istream_range, unknown>
{
private:
friend range_access;
std::vector<int> *list;
struct cursor
{
private:
std::size_t i = 0;
std::vector<int> *list = nullptr;
public:
cursor() = default;
explicit cursor(std::vector<int> &list_)
: list(&list_)
{}
void next()
{
++i;
}
int &read() const noexcept
{
return (*list)[i];
}
bool equal(default_sentinel_t) const
{
return i == list->size();
}
};
cursor begin_cursor()
{
return cursor{*list};
}
public:
test_istream_range() = default;
explicit test_istream_range(std::vector<int> &list_)
: list(&list_)
{}
};
void test_input_range()
{
// It is implementation dependent,
// for how long returned reference remains valid.
// It should be valid at least until next read.
// For test purposes we use custom input range.
std::vector<int> list{1, 2, 3};
auto rng = test_istream_range(list);
CPP_assert(input_range<decltype(rng)>);
auto out = rng | views::addressof;
check_equal(out, {&list[0], &list[1], &list[2]});
}
struct test_xvalue_range
: view_facade<test_xvalue_range, unknown>
{
private:
friend range_access;
struct cursor
{
cursor() = default;
void next();
int &&read() const noexcept;
bool equal(default_sentinel_t) const;
};
cursor begin_cursor();
};
template<typename, typename = void>
constexpr bool can_view = false;
template<typename R>
constexpr bool can_view<R,
meta::void_<decltype(views::addressof(std::declval<R>()))>> = true;
// prvalue ranges cannot be passed to views::addressof
CPP_assert(!can_view<decltype(views::iota(0, 3))>);
// xvalue ranges cannot be passed to views::addressof
CPP_assert(!can_view<test_xvalue_range>);
int main()
{
simple_test();
test_input_range();
return test_result();
}
|
0 | repos/range-v3/test | repos/range-v3/test/view/drop_last.cpp | /// \file
// Range v3 library
//
// Copyright Andrey Diduh 2019
//
// Use, modification and distribution is subject to the
// Boost Software License, Version 1.0. (See accompanying
// file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt)
//
// Project home: https://github.com/ericniebler/range-v3
//
#include "../simple_test.hpp"
#include "../test_utils.hpp"
#include <type_traits>
#include <vector>
#include <list>
#include <forward_list>
#include <range/v3/view/drop_last.hpp>
#include <range/v3/view/take_exactly.hpp>
#include <range/v3/view/transform.hpp>
#include <range/v3/view/generate_n.hpp>
using namespace ranges;
template<class Rng>
struct view_non_const_only
: view_adaptor<view_non_const_only<Rng>, Rng>
{
private:
friend range_access;
adaptor_base begin_adaptor() { return {}; }
adaptor_base end_adaptor() { return {}; }
public:
using view_non_const_only::view_adaptor::view_adaptor;
CPP_auto_member
auto CPP_fun(size)() (
requires sized_range<Rng>)
{
return ranges::size(this->base());
}
};
template<class Rng>
view_non_const_only<views::all_t<Rng>> non_const_only(Rng &&rng)
{
return view_non_const_only<views::all_t<Rng>>{views::all(static_cast<Rng&&>(rng))};
}
template<class Rng>
void test_range(Rng&& src)
{
// additional src copy for InputStream
{
auto src_ = src;
::check_equal(src_, {1,2,3,4});
}
{
auto src_ = src;
auto list = src_ | views::drop_last(2);
::check_equal(list, {1,2});
}
{
auto src_ = src;
auto list = src_ | views::drop_last(0);
::check_equal(list, {1,2,3,4});
}
{
auto src_ = src;
auto list = src_ | views::drop_last(4);
CHECK(list.empty());
}
{
auto src_ = src;
auto list = src_ | views::drop_last(5);
CHECK(list.empty());
}
}
template<class Rng>
void test_size(Rng&& src)
{
CHECK( (src | views::drop_last(0)).size() == std::size_t(4) );
CHECK( (src | views::drop_last(2)).size() == std::size_t(2) );
CHECK( (src | views::drop_last(4)).size() == std::size_t(0) );
CHECK( (src | views::drop_last(5)).size() == std::size_t(0) );
}
template<class Rng>
void test_non_convert_range(Rng&& src)
{
// test non-convertible const<=>non-const range
test_range(src | views::transform([](const int& i) -> const int& {return i;}));
}
void random_acccess_test()
{
using Src = std::vector<int>;
static_assert(
ranges::random_access_range<Src>
, "Must be exactly RA.");
static_assert(
std::is_same<
drop_last_view<views::all_t<Src&>>,
drop_last_view<views::all_t<Src&>, detail::drop_last_view::mode_bidi>
>::value
, "Must have correct view.");
Src src = {1,2,3,4};
test_range(src);
test_range(non_const_only(src));
test_size(src);
test_non_convert_range(src);
}
void bidirectional_test()
{
using Src = std::list<int>;
static_assert(
!ranges::random_access_range<Src> &&
ranges::bidirectional_range<Src>
, "Must be exactly bidirectional.");
static_assert(
std::is_same<
/* mode_sized for max_performance profile.
* mode_bidi for compatible profile.
* See aux::drop_last::get_mode */
drop_last_view<views::all_t<Src&>>,
drop_last_view<views::all_t<Src&>, detail::drop_last_view::mode_bidi>
>::value
, "Must have correct view.");
Src src = {1,2,3,4};
test_range(src);
test_range(non_const_only(src));
test_size(src);
test_non_convert_range(src);
}
void forward_test()
{
using Src = std::forward_list<int>;
static_assert(
!ranges::bidirectional_range<Src> &&
ranges::forward_range<Src>
, "Must be exactly forward.");
static_assert(
std::is_same<
drop_last_view<views::all_t<Src&>>,
drop_last_view<views::all_t<Src&>, detail::drop_last_view::mode_forward>
>::value
, "Must have correct view.");
Src src = {1,2,3,4};
test_range(src);
test_range(non_const_only(src));
test_size(src | views::take_exactly(4));
test_non_convert_range(src);
}
void sized_test()
{
int i = 0;
auto src = views::generate_n([i]() mutable -> int { return ++i;}, 4);
using Src = decltype(src);
static_assert(
!ranges::forward_range<Src> &&
ranges::input_range<Src>
, "Must be exactly input.");
static_assert(
std::is_same<
drop_last_view<views::all_t<Src>>,
drop_last_view<views::all_t<Src>, detail::drop_last_view::mode_sized>
>::value
, "Must have correct view.");
{
// always non-const
auto src_ = src;
test_range(src_);
}
{
auto src_ = src;
test_size(src_);
}
{
auto src_ = src;
test_range(non_const_only(std::move(src_)));
}
{
auto src_ = src;
test_non_convert_range(src_);
}
}
int main()
{
random_acccess_test();
bidirectional_test();
forward_test();
sized_test();
return test_result();
}
|
0 | repos/range-v3/test | repos/range-v3/test/view/replace_if.cpp | // Range v3 library
//
// Copyright Eric Niebler 2014-present
//
// Use, modification and distribution is subject to the
// Boost Software License, Version 1.0. (See accompanying
// file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt)
//
// Project home: https://github.com/ericniebler/range-v3
// HACKHACKHACK silence false positive:
// error: ‘<anonymous>.ranges::istream_view<int>::cursor::rng_’ may be used uninitialized in this function
// triggered on line 39.
#if defined(__GNUC__) && !defined(__clang__) && __GNUC__ >= 7
#include <range/v3/detail/config.hpp>
RANGES_DIAGNOSTIC_IGNORE("-Wmaybe-uninitialized")
#endif
#include <string>
#include <sstream>
#include <vector>
#include <range/v3/core.hpp>
#include <range/v3/view/istream.hpp>
#include <range/v3/functional/reference_wrapper.hpp>
#include <range/v3/utility/copy.hpp>
#include <range/v3/view/iota.hpp>
#include <range/v3/view/take.hpp>
#include <range/v3/view/replace_if.hpp>
#include <range/v3/view/common.hpp>
#include "../simple_test.hpp"
#include "../test_utils.hpp"
int main()
{
using namespace ranges;
std::string str{"1 2 3 4 5 6 7 8 9 1 2 3 4 5 6 7 8 9 1 2 3 4 5 6 7 8 9 "};
std::stringstream sin{str};
{
auto rng = istream<int>(sin) | views::replace_if([](int i){return i == 1; }, 42);
has_type<int const &>(*begin(rng));
CPP_assert(view_<decltype(rng)>);
CPP_assert(!sized_range<decltype(rng)>);
CPP_assert(!common_range<decltype(rng)>);
CPP_assert(input_iterator<decltype(begin(rng))>);
CPP_assert(!forward_iterator<decltype(begin(rng))>);
auto tmp = rng | views::common;
has_type<int const &>(*begin(tmp));
CPP_assert(view_<decltype(tmp)>);
CPP_assert(common_range<decltype(tmp)>);
CPP_assert(!sized_range<decltype(tmp)>);
CPP_assert(input_iterator<decltype(begin(tmp))>);
CPP_assert(!forward_iterator<decltype(begin(tmp))>);
std::vector<int> actual{begin(tmp), end(tmp)};
::check_equal(actual, {42, 2, 3, 4, 5, 6, 7, 8, 9, 42, 2, 3, 4, 5, 6, 7, 8, 9, 42, 2, 3, 4, 5, 6, 7, 8, 9});
}
{
std::vector<int> vi{1,2,3,4,5,6,7,8,9};
auto rng2 = vi | views::replace_if([](int i){return i == 5;}, 42);
CPP_assert(same_as<range_value_t<decltype(rng2)>, int>);
has_type<int const &>(*begin(rng2));
has_type<int const &>(iter_move(begin(rng2)));
CPP_assert(view_<decltype(rng2)>);
CPP_assert(sized_range<decltype(rng2)>);
CPP_assert(common_range<decltype(rng2)>);
CPP_assert(random_access_iterator<decltype(begin(rng2))>);
::check_equal(rng2, {1,2,3,4,42,6,7,8,9});
int forty_two = 42;
auto rng3 = vi | views::replace_if([](int i){return i == 5;}, ref(forty_two));
CPP_assert(same_as<range_value_t<decltype(rng3)>, int>);
has_type<int &>(*begin(rng3));
has_type<int const &>(iter_move(begin(rng3)));
CPP_assert(view_<decltype(rng3)>);
CPP_assert(sized_range<decltype(rng3)>);
CPP_assert(common_range<decltype(rng3)>);
CPP_assert(random_access_iterator<decltype(begin(rng3))>);
::check_equal(rng3, {1,2,3,4,42,6,7,8,9});
}
{
auto rng4 = views::ints | views::replace_if([](int i){return i == 5;},42) | views::take(10);
CPP_assert(same_as<range_value_t<decltype(rng4)>, int>);
has_type<int>(*begin(rng4));
has_type<int>(iter_move(begin(rng4)));
CPP_assert(view_<decltype(rng4)>);
CPP_assert(sized_range<decltype(rng4)>);
CPP_assert(!common_range<decltype(rng4)>);
CPP_assert(random_access_iterator<decltype(begin(rng4))>);
::check_equal(rng4, {0,1,2,3,4,42,6,7,8,9});
}
{
// Check with a mutable predicate
int rgi[] = {0,1,2,3,4,5,6,7,8,9};
bool flag = false;
auto mutable_only = views::replace_if(rgi, [flag](int) mutable { return flag = !flag;}, 42);
::check_equal(mutable_only, {42,1,42,3,42,5,42,7,42,9});
CPP_assert(view_<decltype(mutable_only)>);
CPP_assert(!view_<decltype(mutable_only) const>);
}
{
int const some_ints[] = {1,2,3,4,5,6,7,8,9,1,2,3,4,5,6,7,8,9,1,2,3,4,5,6,7,8,9};
auto rng = debug_input_view<int const>{some_ints} |
views::replace_if([](int i){ return i == 1; }, 42);
::check_equal(rng, {42,2,3,4,5,6,7,8,9,42,2,3,4,5,6,7,8,9,42,2,3,4,5,6,7,8,9});
}
return test_result();
}
|
0 | repos/range-v3/test | repos/range-v3/test/view/CMakeLists.txt | set(CMAKE_FOLDER "${CMAKE_FOLDER}/view")
rv3_add_test(test.view.adaptor view.adaptor adaptor.cpp)
rv3_add_test(test.view.addressof view.addressof addressof.cpp)
rv3_add_test(test.view.adjacent_remove_if view.adjacent_remove_if adjacent_remove_if.cpp)
rv3_add_test(test.view.all view.all all.cpp)
rv3_add_test(test.view.any_view view.any_view any_view.cpp)
rv3_add_test(test.view.common view.common common.cpp)
rv3_add_test(test.view.cache1 view.cache1 cache1.cpp)
rv3_add_test(test.view.cartesian_product view.cartesian_product cartesian_product.cpp)
rv3_add_test(test.view.chunk view.chunk chunk.cpp)
rv3_add_test(test.view.chunk_by view.chunk_by chunk_by.cpp)
rv3_add_test(test.view.concat view.concat concat.cpp)
rv3_add_test(test.view.const view.const const.cpp)
rv3_add_test(test.view.conversion view.conversion conversion.cpp)
rv3_add_test(test.view.counted view.counted counted.cpp)
rv3_add_test(test.view.cycle view.cycle cycle.cpp)
rv3_add_test(test.view.delimit view.delimit delimit.cpp)
rv3_add_test(test.view.drop view.drop drop.cpp)
rv3_add_test(test.view.drop_exactly view.drop_exactly drop_exactly.cpp)
rv3_add_test(test.view.drop_while view.drop_while drop_while.cpp)
rv3_add_test(test.view.drop_last view.drop_last drop_last.cpp)
rv3_add_test(test.view.enumerate view.enumerate enumerate.cpp)
rv3_add_test(test.view.exclusive_scan view.exclusive_scan exclusive_scan.cpp)
rv3_add_test(test.view.facade view.facade facade.cpp)
rv3_add_test(test.view.generate view.generate generate.cpp)
rv3_add_test(test.view.generate_n view.generate_n generate_n.cpp)
rv3_add_test(test.view.getlines view.getlines getlines.cpp)
rv3_add_test(test.view.group_by view.group_by group_by.cpp)
rv3_add_test(test.view.indirect view.indirect indirect.cpp)
rv3_add_test(test.view.intersperse view.intersperse intersperse.cpp)
rv3_add_test(test.view.iota view.iota iota.cpp)
rv3_add_test(test.view.istream view.istream istream.cpp)
rv3_add_test(test.view.iterator_range view.iterator_range iterator_range.cpp)
rv3_add_test(test.view.join view.join join.cpp)
rv3_add_test(test.view.linear_distribute view.linear_distribute linear_distribute.cpp)
rv3_add_test(test.view.map view.map keys_value.cpp)
rv3_add_test(test.view.move view.move move.cpp)
rv3_add_test(test.view.partial_sum view.partial_sum partial_sum.cpp)
# rv3_add_test(test.view.partial_sum_depr view.partial_sum_depr partial_sum_depr.cpp)
rv3_add_test(test.view.repeat view.repeat repeat.cpp)
rv3_add_test(test.view.remove view.remove remove.cpp)
rv3_add_test(test.view.remove_if view.remove_if remove_if.cpp)
rv3_add_test(test.view.replace view.replace replace.cpp)
rv3_add_test(test.view.replace_if view.replace_if replace_if.cpp)
rv3_add_test(test.view.reverse view.reverse reverse.cpp)
rv3_add_test(test.view.sample view.sample sample.cpp)
rv3_add_test(test.view.set_difference view.set_difference set_difference.cpp)
rv3_add_test(test.view.set_intersection view.set_intersection set_intersection.cpp)
rv3_add_test(test.view.set_symmetric_difference view.set_symmetric_difference set_symmetric_difference.cpp)
rv3_add_test(test.view.set_union view.set_union set_union.cpp)
rv3_add_test(test.view.slice view.slice slice.cpp)
rv3_add_test(test.view.sliding view.sliding sliding.cpp)
rv3_add_test(test.view.span view.span span.cpp)
rv3_add_test(test.view.split view.split split.cpp)
rv3_add_test(test.view.stride view.stride stride.cpp)
rv3_add_test(test.view.subrange view.subrange subrange.cpp)
rv3_add_test(test.view.tail view.tail tail.cpp)
rv3_add_test(test.view.take view.take take.cpp)
rv3_add_test(test.view.take_exactly view.take_exactly take_exactly.cpp)
rv3_add_test(test.view.take_last view.take_last take_last.cpp)
rv3_add_test(test.view.take_while view.take_while take_while.cpp)
rv3_add_test(test.view.tokenize view.tokenize tokenize.cpp)
rv3_add_test(test.view.transform view.transform transform.cpp)
rv3_add_test(test.view.trim view.trim trim.cpp)
rv3_add_test(test.view.unique view.unique unique.cpp)
rv3_add_test(test.view.view view.view view.cpp)
rv3_add_test(test.view.zip view.zip zip.cpp)
target_compile_definitions(range.v3.view.iterator_range PRIVATE RANGES_DISABLE_DEPRECATED_WARNINGS)
|
0 | repos/range-v3/test | repos/range-v3/test/view/keys_value.cpp | // Range v3 library
//
// Copyright Eric Niebler 2014-present
//
// Use, modification and distribution is subject to the
// Boost Software License, Version 1.0. (See accompanying
// file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt)
//
// Project home: https://github.com/ericniebler/range-v3
#include <map>
#include <string>
#include <vector>
#include <range/v3/core.hpp>
#include <range/v3/view/iota.hpp>
#include <range/v3/view/map.hpp>
#include <range/v3/view/zip.hpp>
#include <range/v3/utility/copy.hpp>
#include <range/v3/algorithm/find.hpp>
#include "../simple_test.hpp"
#include "../test_utils.hpp"
int main()
{
using namespace ranges;
std::map<std::string, int> m = {
{"this", 0},
{"that", 1},
{"other", 2}};
auto keys = m | views::keys;
has_type<std::string const &>(*begin(keys));
CPP_assert(view_<decltype(keys)>);
CPP_assert(sized_range<decltype(keys)>);
CPP_assert(common_range<decltype(keys)>);
CPP_assert(bidirectional_iterator<decltype(begin(keys))>);
CHECK(&*begin(keys) == &m.begin()->first);
::check_equal(keys, {"other", "that", "this"});
auto values = m | views::values;
has_type<int &>(*begin(values));
CPP_assert(sized_range<decltype(values)>);
CPP_assert(common_range<decltype(values)>);
CPP_assert(bidirectional_iterator<decltype(begin(values))>);
CHECK(&*begin(values) == &m.begin()->second);
::check_equal(values, {2, 1, 0});
{
// regression test for #526
auto f = detail::get_first{};
CPP_assert(same_as<int, decltype(f(std::declval<std::pair<int,int>>()))>);
CPP_assert(same_as<int&, decltype(f(std::declval<std::pair<int,int>&>()))>);
CPP_assert(same_as<int&, decltype(f(std::declval<std::pair<int&,int&>>()))>);
CPP_assert(same_as<int&, decltype(f(std::declval<std::pair<int&,int&>&>()))>);
CPP_assert(same_as<int, decltype(f(std::declval<std::pair<int&&,int&&>>()))>);
CPP_assert(same_as<int&, decltype(f(std::declval<std::pair<int&&,int&&>&>()))>);
std::vector<int> xs = {42, 100, -1234};
auto exs = views::zip(views::ints, xs);
::check_equal(views::keys(exs), {0, 1, 2});
}
{
std::pair<int, int> const rgp[] = {{0, 2}, {1, 1}, {2, 0}};
auto key_range = debug_input_view<std::pair<int, int> const>{rgp} | views::keys;
check_equal(key_range, {0,1,2});
auto value_range = debug_input_view<std::pair<int, int> const>{rgp} | views::values;
check_equal(value_range, {2,1,0});
}
{
auto it = find(m | views::keys, "other");
CHECK(it.base()->second == 2);
auto it2 = find(m | views::values, 1);
CHECK(it2.base()->first == "that");
}
return test_result();
}
|
0 | repos/range-v3/test | repos/range-v3/test/view/cache1.cpp | /// \file
// Range v3 library
//
// Copyright Eric Niebler 2013-2014.
// Copyright Casey Carter 2017.
//
// Use, modification and distribution is subject to the
// Boost Software License, Version 1.0. (See accompanying
// file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt)
//
// Project home: https://github.com/ericniebler/range-v3
//
#include <vector>
#include <range/v3/view/cache1.hpp>
#include <range/v3/view/transform.hpp>
#include <range/v3/view/c_str.hpp>
#include <range/v3/view/move.hpp>
#include "../simple_test.hpp"
#include "../test_utils.hpp"
using namespace ranges;
int main()
{
{
int count = 0;
std::vector<int> v{1,2,3};
auto rng = v | views::transform([&count](int i){ ++count; return i;})
| views::cache1;
using Rng = decltype(rng);
CPP_assert(!range<Rng const>);
CPP_assert(input_range<Rng>);
CPP_assert(!forward_range<Rng>);
CPP_assert(common_range<Rng>);
CPP_assert(view_<Rng>);
CPP_assert(sized_range<Rng>);
CPP_assert(sized_sentinel_for<sentinel_t<Rng>, iterator_t<Rng>>);
CPP_assert(same_as<range_value_t<Rng>, int>);
CPP_assert(same_as<range_reference_t<Rng>, int &&>);
CPP_assert(same_as<range_rvalue_reference_t<Rng>, int &&>);
CHECK(count == 0);
auto it = ranges::begin(rng);
CHECK(count == 0);
auto last = ranges::end(rng);
CHECK(it != last);
CHECK(count == 0);
CHECK(*it == 1);
CHECK(count == 1);
CHECK(*it == 1);
CHECK(count == 1);
++it;
CHECK(it != last);
CHECK(count == 1);
CHECK(*it == 2);
CHECK(count == 2);
CHECK(*it == 2);
CHECK(count == 2);
++it;
CHECK(it != last);
CHECK(count == 2);
CHECK(*it == 3);
CHECK(count == 3);
CHECK(*it == 3);
CHECK(count == 3);
++it;
CHECK(count == 3);
CHECK(it == last);
}
{
int count = 0;
char const * hi = "hi";
auto rng = views::c_str(hi)
| views::transform([&count](char ch){ ++count; return ch;})
| views::cache1;
using Rng = decltype(rng);
CPP_assert(!range<Rng const>);
CPP_assert(input_range<Rng>);
CPP_assert(!forward_range<Rng>);
CPP_assert(!common_range<Rng>);
CPP_assert(view_<Rng>);
CPP_assert(!sized_range<Rng>);
CPP_assert(!sized_sentinel_for<sentinel_t<Rng>, iterator_t<Rng>>);
CPP_assert(same_as<range_value_t<Rng>, char>);
CPP_assert(same_as<range_reference_t<Rng>, char &&>);
CPP_assert(same_as<range_rvalue_reference_t<Rng>, char &&>);
CHECK(count == 0);
auto it = ranges::begin(rng);
CHECK(count == 0);
auto last = ranges::end(rng);
CHECK(it != last);
CHECK(count == 0);
CHECK(*it == 'h');
CHECK(count == 1);
CHECK(*it == 'h');
CHECK(count == 1);
++it;
CHECK(it != last);
CHECK(count == 1);
CHECK(*it == 'i');
CHECK(count == 2);
CHECK(*it == 'i');
CHECK(count == 2);
++it;
CHECK(count == 2);
CHECK(it == last);
}
{
int count = 0;
MoveOnlyString rg[] = {"hello", "world"};
auto rng = rg
| views::move
| views::transform([&count](auto s){ ++count; RANGES_ENSURE(s != ""); return s;})
| views::cache1;
using Rng = decltype(rng);
CPP_assert(!range<Rng const>);
CPP_assert(input_range<Rng>);
CPP_assert(!forward_range<Rng>);
CPP_assert(common_range<Rng>);
CPP_assert(view_<Rng>);
CPP_assert(sized_range<Rng>);
CPP_assert(sized_sentinel_for<sentinel_t<Rng>, iterator_t<Rng>>);
CPP_assert(same_as<range_value_t<Rng>, MoveOnlyString>);
CPP_assert(same_as<range_reference_t<Rng>, MoveOnlyString &&>);
CPP_assert(same_as<range_rvalue_reference_t<Rng>, MoveOnlyString &&>);
CHECK(count == 0);
auto it = ranges::begin(rng);
CHECK(count == 0);
auto last = ranges::end(rng);
CHECK(it != last);
CHECK(count == 0);
CHECK((*it == "hello"));
CHECK(count == 1);
CHECK((*it == "hello"));
CHECK(count == 1);
++it;
CHECK(it != last);
CHECK(count == 1);
CHECK((*it == "world"));
CHECK(count == 2);
CHECK((*it == "world"));
CHECK(count == 2);
++it;
CHECK(count == 2);
CHECK(it == last);
}
return test_result();
}
|
0 | repos/range-v3/test | repos/range-v3/test/view/partial_sum.cpp | // Range v3 library
//
// Copyright Eric Niebler 2014-present
//
// Use, modification and distribution is subject to the
// Boost Software License, Version 1.0. (See accompanying
// file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt)
//
// Project home: https://github.com/ericniebler/range-v3
#include <functional>
#include <iterator>
#include <range/v3/core.hpp>
#include <range/v3/utility/copy.hpp>
#include <range/v3/view/counted.hpp>
#include <range/v3/view/partial_sum.hpp>
#include <range/v3/view/reverse.hpp>
#include "../simple_test.hpp"
#include "../test_utils.hpp"
int main()
{
using namespace ranges;
int rgi[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
{
auto rng = rgi | views::partial_sum;
has_type<int &>(*begin(rgi));
has_type<int>(*begin(rng));
CPP_assert(view_<decltype(rng)>);
CPP_assert(sized_range<decltype(rng)>);
CPP_assert(forward_range<decltype(rng)>);
CPP_assert(!bidirectional_range<decltype(rng)>);
::check_equal(rng, {1, 3, 6, 10, 15, 21, 28, 36, 45, 55});
auto it = begin(rng);
CHECK(*it == 1);
auto it2 = next(it);
CHECK(*it == 1);
CHECK(*it2 == 3);
it2 = it;
CHECK(*it2 == 1);
++it2;
CHECK(*it2 == 3);
}
{
// Test partial_sum with a mutable lambda
int cnt = 0;
auto mutable_rng = views::partial_sum(rgi, [cnt](int i, int j) mutable { return i + j + cnt++;});
::check_equal(mutable_rng, {1, 3, 7, 13, 21, 31, 43, 57, 73, 91});
CHECK(cnt == 0);
CPP_assert(view_<decltype(mutable_rng)>);
CPP_assert(!view_<decltype(mutable_rng) const>);
}
{
auto rng = debug_input_view<int const>{rgi} | views::partial_sum;
::check_equal(rng, {1, 3, 6, 10, 15, 21, 28, 36, 45, 55});
}
{
static int const some_ints[] = {0,1,2,3,4};
auto t1 = ranges::views::partial_sum(some_ints);
auto t2 = some_ints | ranges::views::partial_sum;
::check_equal(t1, t2);
}
return test_result();
}
|
0 | repos/range-v3/test | repos/range-v3/test/view/tail.cpp | // Range v3 library
//
// Copyright Eric Niebler 2017-present
//
// Use, modification and distribution is subject to the
// Boost Software License, Version 1.0. (See accompanying
// file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt)
//
// Project home: https://github.com/ericniebler/range-v3
#include <list>
#include <vector>
#include <sstream>
#include <range/v3/core.hpp>
#include <range/v3/view/tail.hpp>
#include <range/v3/view/empty.hpp>
#include <range/v3/view/single.hpp>
#include "../simple_test.hpp"
#include "../test_utils.hpp"
#include "../test_iterators.hpp"
int main()
{
using namespace ranges;
{
std::vector<int> v{0,1,2,3};
auto rng = views::tail(v);
check_equal(rng, {1,2,3});
CHECK(size(rng) == 3u);
}
{
std::vector<int> v{};
auto rng = views::tail(v);
CHECK(empty(rng));
CHECK(size(rng) == 0u);
}
{
std::stringstream sin{"1 2 3 4"};
istream_view<int> is(sin);
auto rng = views::tail(is);
check_equal(rng, {2,3,4});
}
{
std::stringstream sin{""};
istream_view<int> is(sin);
auto rng = views::tail(is);
CHECK(rng.begin() == rng.end());
}
{
auto rng = views::empty<int> | views::tail;
static_assert(0 == size(rng), "");
CPP_assert(same_as<empty_view<int>, decltype(rng)>);
}
{
tail_view<empty_view<int>> const rng(views::empty<int>);
static_assert(0 == size(rng), "");
}
{
auto const rng = views::single(1) | views::tail;
static_assert(0 == size(rng), "");
}
return ::test_result();
}
|
0 | repos/range-v3/test | repos/range-v3/test/view/generate_n.cpp | // Range v3 library
//
// Copyright Eric Niebler 2014-present
//
// Use, modification and distribution is subject to the
// Boost Software License, Version 1.0. (See accompanying
// file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt)
//
// Project home: https://github.com/ericniebler/range-v3
#include <range/v3/core.hpp>
#include <range/v3/view/drop_exactly.hpp>
#include <range/v3/view/generate_n.hpp>
#include "../simple_test.hpp"
#include "../test_utils.hpp"
namespace views = ranges::views;
int main()
{
// Test for constant generator functions
{
int i = 0, j = 1;
auto fib = views::generate_n([&]()->int{int tmp = i; i += j; std::swap(i, j); return tmp;}, 10);
CPP_assert(ranges::input_range<decltype(fib)> && ranges::view_<decltype(fib)>);
check_equal(fib, {0,1,1,2,3,5,8,13,21,34});
}
// Test for mutable-only generator functions
{
int i = 0, j = 1;
auto fib = views::generate_n([=]()mutable->int{int tmp = i; i += j; std::swap(i, j); return tmp;}, 10);
CPP_assert(ranges::input_range<decltype(fib)> && ranges::view_<decltype(fib)>);
check_equal(fib, {0,1,1,2,3,5,8,13,21,34});
// The generator cannot be called when it's const-qualified, so "fib const"
// does not model View.
CPP_assert(!ranges::view_<decltype(fib) const>);
}
// Test for generator functions that return move-only types
// https://github.com/ericniebler/range-v3/issues/905
{
char str[] = "gi";
auto rng = views::generate_n([&]{str[0]++; return MoveOnlyString{str};}, 2);
CPP_assert(ranges::input_range<decltype(rng)> && ranges::view_<decltype(rng)>);
auto i = rng.begin();
CHECK(bool(*i == MoveOnlyString{"hi"}));
CHECK(bool(*i == MoveOnlyString{"hi"}));
CHECK(bool(*rng.begin() == MoveOnlyString{"hi"}));
CHECK(bool(*rng.begin() == MoveOnlyString{"hi"}));
CPP_assert(ranges::input_range<decltype(rng)> && ranges::view_<decltype(rng)>);
check_equal(rng, {MoveOnlyString{"hi"}, MoveOnlyString{"ii"}});
static_assert(std::is_same<ranges::range_reference_t<decltype(rng)>, MoveOnlyString &&>::value, "");
}
// Test for generator functions that return internal references
// https://github.com/ericniebler/range-v3/issues/807
{
int i = 42;
auto rng = views::generate_n([i]{return &i;}, 2);
auto rng2 = std::move(rng);
auto it = rng2.begin();
auto p = *it;
auto p2 = *++it;
CHECK(p == p2);
}
// Test that we only call the function once for each dereferenceable position
// https://github.com/ericniebler/range-v3/issues/819
{
int i = 0;
auto rng = views::generate_n([&i]{return ++i;}, 2);
auto rng2 = std::move(rng);
auto it = rng2.begin();
CHECK(i == 0);
CHECK(*it == 1);
CHECK(i == 1);
++it;
CHECK(i == 1);
CHECK(*it == 2);
CHECK(i == 2);
}
// Test view_interaface sized()-based empty()
// https://github.com/ericniebler/range-v3/issues/1147
{
int i = 0;
auto rng = views::generate_n([&i]{return ++i;}, 2);
CHECK(!rng.empty());
}
// Test that skipping past positions works correctly
// https://github.com/ericniebler/range-v3/issues/1258
{
auto fib = [p = std::make_pair(0, 1)]() mutable -> int {
auto a = p.first;
p = {p.second, p.first + p.second};
return a;
};
auto rng = ranges::views::generate_n(fib, 8)
| ranges::views::drop_exactly(3);
check_equal(rng, {2,3,5,8,13});
}
return test_result();
}
|
0 | repos/range-v3/test | repos/range-v3/test/view/take_last.cpp | // Range v3 library
//
// Copyright Barry Revzin 2019-present
//
// Use, modification and distribution is subject to the
// Boost Software License, Version 1.0. (See accompanying
// file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt)
//
// Project home: https://github.com/ericniebler/range-v3
#include <range/v3/utility/copy.hpp>
#include <range/v3/view/take_last.hpp>
#include "../simple_test.hpp"
#include "../test_utils.hpp"
int main()
{
using namespace ranges;
int rgi[] = {0, 1, 2, 3, 4, 5};
auto rng0 = rgi | views::take_last(3);
has_type<int &>(*begin(rng0));
CPP_assert(view_<decltype(rng0)>);
CPP_assert(common_range<decltype(rng0)>);
CPP_assert(sized_range<decltype(rng0)>);
CPP_assert(random_access_iterator<decltype(begin(rng0))>);
::check_equal(rng0, {3, 4, 5});
CHECK(size(rng0) == 3u);
auto rng1 = rgi | views::take_last(7);
::check_equal(rng1, {0, 1, 2, 3, 4, 5});
return ::test_result();
}
|
0 | repos/range-v3/test | repos/range-v3/test/view/iota.cpp | // Range v3 library
//
// Copyright Eric Niebler 2014-present
//
// Use, modification and distribution is subject to the
// Boost Software License, Version 1.0. (See accompanying
// file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt)
//
// Project home: https://github.com/ericniebler/range-v3
//
#include <range/v3/core.hpp>
#include <range/v3/utility/copy.hpp>
#include <range/v3/view/c_str.hpp>
#include <range/v3/view/indices.hpp>
#include <range/v3/view/indirect.hpp>
#include <range/v3/view/iota.hpp>
#include <range/v3/view/take.hpp>
#include <range/v3/view/drop_exactly.hpp>
#include "../simple_test.hpp"
#include "../test_utils.hpp"
#include "../test_iterators.hpp"
struct Int
{
using difference_type = int;
int i = 0;
Int() = default;
explicit Int(int j) : i(j) {}
Int & operator++() {++i; CHECK(i <= 10); return *this;}
Int operator++(int) {auto tmp = *this; ++*this; return tmp;}
bool operator==(Int j) const { return i == j.i; }
bool operator!=(Int j) const { return i != j.i; }
};
struct NonDefaultInt
{
using difference_type = int;
int i = 0;
explicit NonDefaultInt(int j) : i(j) {}
NonDefaultInt & operator++() {++i; CHECK(i <= 10); return *this;}
NonDefaultInt operator++(int) {auto tmp = *this; ++*this; return tmp;}
bool operator==(NonDefaultInt j) const { return i == j.i; }
bool operator!=(NonDefaultInt j) const { return i != j.i; }
};
CPP_template(typename I)(
requires ranges::integral<I>)
void test_iota_distance()
{
using namespace ranges;
using D = iter_difference_t<I>;
I max = std::numeric_limits<I>::max();
CHECK(detail::iota_distance_(I(0), I(0)) == D(0));
CHECK(detail::iota_distance_(I(1), I(0)) == D(-1));
CHECK(detail::iota_distance_(I(0), I(1)) == D(1));
CHECK(detail::iota_distance_(I(1), I(1)) == D(0));
CHECK(detail::iota_distance_(I(max - I(1)), I(max - I(1))) == D(0));
CHECK(detail::iota_distance_(I(max), I(max - I(1))) == D(-1));
CHECK(detail::iota_distance_(I(max - I(1)), I(max)) == D(1));
CHECK(detail::iota_distance_(I(max), I(max)) == D(0));
}
int main()
{
using namespace ranges;
{
CPP_assert(random_access_range<decltype(views::iota((unsigned short)0))>);
CPP_assert(random_access_range<decltype(views::iota(0))>);
static_assert(is_infinite<decltype(views::iota(0))>::value, "");
static_assert(is_infinite<decltype(views::drop_exactly(views::iota(0),0))>::value, "");
static_assert(!sized_range<decltype(views::iota(0))>, "");
}
{
char const *sz = "hello world";
::check_equal(views::iota(ForwardIterator<char const*>(sz)) | views::take(10) | views::indirect,
{'h','e','l','l','o',' ','w','o','r','l'});
::check_equal(views::ints | views::take(10), {0,1,2,3,4,5,6,7,8,9});
::check_equal(views::ints(0,unreachable) | views::take(10), {0,1,2,3,4,5,6,7,8,9});
::check_equal(views::ints(0,9), {0,1,2,3,4,5,6,7,8});
::check_equal(views::closed_indices(0,9), {0,1,2,3,4,5,6,7,8,9});
::check_equal(views::ints(1,10), {1,2,3,4,5,6,7,8,9});
::check_equal(views::closed_indices(1,10), {1,2,3,4,5,6,7,8,9,10});
}
{
auto chars = views::ints(std::numeric_limits<signed char>::min(),
std::numeric_limits<signed char>::max());
CPP_assert(random_access_range<decltype(chars)>);
CPP_assert(same_as<int, range_difference_t<decltype(chars)>>);
CPP_assert(view_<decltype(chars)>);
CPP_assert(random_access_range<decltype(chars)>);
CPP_assert(common_range<decltype(chars)>);
CHECK(distance(chars.begin(), chars.end()) == (long) CHAR_MAX - (long) CHAR_MIN);
CHECK(chars.size() == (unsigned)((long) CHAR_MAX - (long) CHAR_MIN));
}
{
auto ushorts = views::ints(std::numeric_limits<unsigned short>::min(),
std::numeric_limits<unsigned short>::max());
CPP_assert(view_<decltype(ushorts)>);
CPP_assert(common_range<decltype(ushorts)>);
CPP_assert(same_as<int, range_difference_t<decltype(ushorts)>>);
CPP_assert(same_as<unsigned int, range_size_t<decltype(ushorts)>>);
CHECK(distance(ushorts.begin(), ushorts.end()) == (int) USHRT_MAX);
CHECK(ushorts.size() == (unsigned) USHRT_MAX);
}
{
auto uints = views::closed_indices(
std::numeric_limits<std::uint_least32_t>::min(),
std::numeric_limits<std::uint_least32_t>::max() - 1);
CPP_assert(view_<decltype(uints)>);
CPP_assert(common_range<decltype(uints)>);
CPP_assert(same_as<std::int_fast64_t, range_difference_t<decltype(uints)>>);
CPP_assert(same_as<std::uint_fast64_t, range_size_t<decltype(uints)>>);
CHECK(uints.size() == std::numeric_limits<std::uint32_t>::max());
}
{
auto is = views::closed_indices(
std::numeric_limits<std::int_least32_t>::min(),
std::numeric_limits<std::int_least32_t>::max() - 1);
CPP_assert(same_as<std::int_fast64_t, range_difference_t<decltype(is)>>);
CPP_assert(same_as<std::uint_fast64_t, range_size_t<decltype(is)>>);
CHECK(is.size() == std::numeric_limits<std::uint32_t>::max());
}
{
auto sints = views::ints(std::numeric_limits<int>::min(),
std::numeric_limits<int>::max());
CPP_assert(random_access_range<decltype(sints)>);
CPP_assert(same_as<std::int_fast64_t, range_difference_t<decltype(sints)>>);
CPP_assert(view_<decltype(sints)>);
CPP_assert(random_access_range<decltype(sints)>);
CPP_assert(common_range<decltype(sints)>);
CHECK(distance(sints.begin(), sints.end()) == (std::int_fast64_t) INT_MAX - (std::int_fast64_t) INT_MIN);
CHECK(sints.size() == (std::uint_fast64_t)((std::int_fast64_t) INT_MAX - (std::int_fast64_t) INT_MIN));
}
{
auto is = views::closed_iota(Int{0}, Int{10});
::check_equal(is, {Int{0},Int{1},Int{2},Int{3},Int{4},Int{5},Int{6},Int{7},Int{8},Int{9},Int{10}});
CPP_assert(view_<decltype(is)>);
CPP_assert(common_range<decltype(is)>);
CPP_assert(!sized_range<decltype(is)>);
CPP_assert(forward_range<decltype(is)>);
CPP_assert(!bidirectional_range<decltype(is)>);
}
{
auto is = views::iota(NonDefaultInt{0});
CPP_assert(input_range<decltype(is)>);
CPP_assert(!forward_range<decltype(is)>);
}
{
auto is = views::closed_iota(0, 10);
::check_equal(is, {0,1,2,3,4,5,6,7,8,9,10});
CPP_assert(view_<decltype(is)>);
CPP_assert(common_range<decltype(is)>);
CPP_assert(sized_range<decltype(is)>);
CPP_assert(random_access_range<decltype(is)>);
CHECK(size(is) == 11u);
auto it = is.begin(), e = is.end(), be = e;
--be;
using D = range_difference_t<decltype(is)>;
// CHECK op++ and op-
for(D i = 0; ; ++i)
{
CHECK((e - it) == (11 - i));
CHECK((it - e) == -(11 - i));
CHECK((be - it) == (10 - i));
CHECK((it - be) == -(10 - i));
if(i == 11) break;
++it;
}
// CHECK op-- and op-
for(D i = 11; ; --i)
{
CHECK((e - it) == (11 - i));
CHECK((it - e) == -(11 - i));
CHECK((be - it) == (10 - i));
CHECK((it - be) == -(10 - i));
if(i == 0) break;
--it;
}
// CHECK op+= and op-
for(D i = 0; ; ++i)
{
it = next(is.begin(), i);
CHECK((e - it) == (11 - i));
CHECK((it - e) == -(11 - i));
CHECK((be - it) == (10 - i));
CHECK((it - be) == -(10 - i));
if(i == 11) break;
}
// CHECK op-
CHECK((e - 0) == e);
CHECK((be - 0) == be);
CHECK((e - 1) == be);
CHECK((be - 1) == is.begin() + 9);
}
{ // iota distance tests
test_iota_distance<int8_t>();
test_iota_distance<int16_t>();
test_iota_distance<int32_t>();
test_iota_distance<int64_t>();
test_iota_distance<uint8_t>();
test_iota_distance<uint16_t>();
test_iota_distance<uint32_t>();
test_iota_distance<uint64_t>();
}
{
// https://github.com/ericniebler/range-v3/issues/506
auto cstr = views::c_str((const char*)"hello world");
auto cstr2 = views::iota(cstr.begin(), cstr.end()) | views::indirect;
::check_equal(cstr2, std::string("hello world"));
auto i = cstr2.begin();
i += 4;
CHECK(*i == 'o');
CHECK((i - cstr2.begin()) == 4);
}
{ // test views::indices/closed_indices
::check_equal(views::indices | views::take(10), std::initializer_list<std::size_t>{0,1,2,3,4,5,6,7,8,9});
::check_equal(views::indices(0, 10), {0,1,2,3,4,5,6,7,8,9});
::check_equal(views::closed_indices(0, 10), {0,1,2,3,4,5,6,7,8,9,10});
::check_equal(views::indices(10), {0,1,2,3,4,5,6,7,8,9});
::check_equal(views::closed_indices(10), {0,1,2,3,4,5,6,7,8,9,10});
}
return ::test_result();
}
|
0 | repos/range-v3/test | repos/range-v3/test/view/zip.cpp | // Range v3 library
//
// Copyright Eric Niebler 2014-present
//
// Use, modification and distribution is subject to the
// Boost Software License, Version 1.0. (See accompanying
// file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt)
//
// Project home: https://github.com/ericniebler/range-v3
#include <algorithm>
#include <memory>
#include <sstream>
#include <string>
#include <vector>
#include <range/v3/core.hpp>
#include <range/v3/algorithm/copy.hpp>
#include <range/v3/algorithm/move.hpp>
#include <range/v3/algorithm/find_if.hpp>
#include <range/v3/utility/copy.hpp>
#include <range/v3/iterator/operations.hpp>
#include <range/v3/iterator/insert_iterators.hpp>
#include <range/v3/view/common.hpp>
#include <range/v3/view/filter.hpp>
#include <range/v3/view/for_each.hpp>
#include <range/v3/view/iota.hpp>
#include <range/v3/view/map.hpp>
#include <range/v3/view/move.hpp>
#include <range/v3/view/stride.hpp>
#include <range/v3/view/take_while.hpp>
#include <range/v3/view/take.hpp>
#include <range/v3/view/zip.hpp>
#include <range/v3/view/zip_with.hpp>
#include "../simple_test.hpp"
#include "../test_utils.hpp"
#if defined(__cpp_lib_ranges) && __cpp_lib_ranges >= 201911
// See https://github.com/ericniebler/range-v3/issues/1480
void test_bug1480()
{
std::vector<char> const first{};
std::vector<char> const second{};
auto zip_view = ::ranges::views::zip(first, second);
auto fn = [&] ([[maybe_unused]] auto && ch)
{
};
std::ranges::for_each(zip_view, fn);
}
#endif
int main()
{
using namespace ranges;
std::vector<int> vi{0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
std::vector<std::string> const vs{"hello", "goodbye", "hello", "goodbye"};
// All common ranges, but one single-pass
{
std::stringstream str{"john paul george ringo"};
using V = std::tuple<int, std::string, std::string>;
auto rng = views::zip(vi, vs, istream<std::string>(str) | views::common);
using Rng = decltype(rng);
CPP_assert(view_<decltype(rng)>);
CPP_assert(!common_range<decltype(rng)>);
CPP_assert(!sized_range<decltype(rng)>);
CPP_assert(same_as<
range_value_t<Rng>,
std::tuple<int, std::string, std::string>>);
CPP_assert(same_as<
range_reference_t<Rng>,
common_tuple<int &, std::string const &, std::string &>>);
CPP_assert(same_as<
range_rvalue_reference_t<Rng>,
common_tuple<int &&, std::string const &&, std::string &&>>);
CPP_assert(convertible_to<range_value_t<Rng> &&,
range_rvalue_reference_t<Rng>>);
CPP_assert(input_iterator<decltype(begin(rng))>);
CPP_assert(!forward_iterator<decltype(begin(rng))>);
has_cardinality<cardinality::finite>(rng);
auto expected = to_vector(rng);
::check_equal(expected, {V{0, "hello", "john"},
V{1, "goodbye", "paul"},
V{2, "hello", "george"},
V{3, "goodbye", "ringo"}});
}
// Mixed ranges and common ranges
{
std::stringstream str{"john paul george ringo"};
using V = std::tuple<int, std::string, std::string>;
auto rng = views::zip(vi, vs, istream<std::string>(str));
CPP_assert(view_<decltype(rng)>);
CPP_assert(!sized_range<decltype(rng)>);
CPP_assert(!common_range<decltype(rng)>);
CPP_assert(input_iterator<decltype(begin(rng))>);
CPP_assert(!forward_iterator<decltype(begin(rng))>);
has_cardinality<cardinality::finite>(rng);
std::vector<V> expected;
copy(rng, ranges::back_inserter(expected));
::check_equal(expected, {V{0, "hello", "john"},
V{1, "goodbye", "paul"},
V{2, "hello", "george"},
V{3, "goodbye", "ringo"}});
}
auto rnd_rng = views::zip(vi, vs);
using Ref = range_reference_t<decltype(rnd_rng)>;
static_assert(std::is_same<Ref, common_pair<int &,std::string const &>>::value, "");
CPP_assert(view_<decltype(rnd_rng)>);
CPP_assert(common_range<decltype(rnd_rng)>);
CPP_assert(sized_range<decltype(rnd_rng)>);
CPP_assert(random_access_iterator<decltype(begin(rnd_rng))>);
has_cardinality<cardinality::finite>(rnd_rng);
auto tmp = cbegin(rnd_rng) + 3;
CHECK(std::get<0>(*tmp) == 3);
CHECK(std::get<1>(*tmp) == "goodbye");
CHECK((rnd_rng.end() - rnd_rng.begin()) == 4);
CHECK((rnd_rng.begin() - rnd_rng.end()) == -4);
CHECK(rnd_rng.size() == 4u);
// zip_with
{
std::vector<std::string> v0{"a","b","c"};
std::vector<std::string> v1{"x","y","z"};
auto rng = views::zip_with(std::plus<std::string>{}, v0, v1);
std::vector<std::string> expected;
copy(rng, ranges::back_inserter(expected));
::check_equal(expected, {"ax","by","cz"});
auto rng2 = views::zip_with([] { return 42; });
static_assert(std::is_same<range_value_t<decltype(rng2)>, int>::value, "");
}
// Move from a zip view
{
auto v0 = to<std::vector<MoveOnlyString>>({"a","b","c"});
auto v1 = to<std::vector<MoveOnlyString>>({"x","y","z"});
auto rng = views::zip(v0, v1);
CPP_assert(random_access_range<decltype(rng)>);
std::vector<std::pair<MoveOnlyString, MoveOnlyString>> expected;
move(rng, ranges::back_inserter(expected));
::check_equal(expected | views::keys, {"a","b","c"});
::check_equal(expected | views::values, {"x","y","z"});
::check_equal(v0, {"","",""});
::check_equal(v1, {"","",""});
move(expected, rng.begin());
::check_equal(expected | views::keys, {"","",""});
::check_equal(expected | views::values, {"","",""});
::check_equal(v0, {"a","b","c"});
::check_equal(v1, {"x","y","z"});
std::vector<MoveOnlyString> res;
using R = decltype(rng);
auto proj =
[](range_reference_t<R> p) -> MoveOnlyString& {return p.first;};
auto rng2 = rng | views::transform(proj);
move(rng2, ranges::back_inserter(res));
::check_equal(res, {"a","b","c"});
::check_equal(v0, {"","",""});
::check_equal(v1, {"x","y","z"});
using R2 = decltype(rng2);
CPP_assert(same_as<range_value_t<R2>, MoveOnlyString>);
CPP_assert(same_as<range_reference_t<R2>, MoveOnlyString &>);
CPP_assert(same_as<range_rvalue_reference_t<R2>, MoveOnlyString &&>);
}
{
auto const v = to<std::vector<MoveOnlyString>>({"a","b","c"});
auto rng = views::zip(v, v);
using Rng = decltype(rng);
using I = iterator_t<Rng>;
CPP_assert(indirectly_readable<I>);
CPP_assert(same_as<
range_value_t<Rng>,
std::pair<MoveOnlyString, MoveOnlyString>>);
CPP_assert(same_as<
range_reference_t<Rng>,
common_pair<MoveOnlyString const &, MoveOnlyString const &>>);
CPP_assert(same_as<
range_rvalue_reference_t<Rng>,
common_pair<MoveOnlyString const &&, MoveOnlyString const &&>>);
CPP_assert(same_as<
range_common_reference_t<Rng>,
common_pair<MoveOnlyString const &, MoveOnlyString const &>>);
}
{
std::vector<int> v{1,2,3,4};
auto moved = v | views::move;
using Moved = decltype(moved);
CPP_assert(same_as<range_reference_t<Moved>, int &&>);
auto zipped = views::zip(moved);
using Zipped = decltype(zipped);
CPP_assert(same_as<range_reference_t<Zipped>, common_tuple<int &&> >);
}
// This is actually a test of the logic of view_adaptor. Since the stride view
// does not redefine the current member function, the base range's iter_move
// function gets picked up automatically.
{
auto rng0 = views::zip(vi, vs);
auto rng1 = views::stride(rng0, 2);
CPP_assert(same_as<range_rvalue_reference_t<decltype(rng1)>, range_rvalue_reference_t<decltype(rng0)>>);
CPP_assert(same_as<range_value_t<decltype(rng1)>, range_value_t<decltype(rng0)>>);
}
// Test for noexcept iter_move
{
static_assert(noexcept(std::declval<std::unique_ptr<int>&>() = std::declval<std::unique_ptr<int>&&>()), "");
std::unique_ptr<int> rg1[10], rg2[10];
auto x = views::zip(rg1, rg2);
std::pair<std::unique_ptr<int>, std::unique_ptr<int>> p = iter_move(x.begin());
auto it = x.begin();
static_assert(noexcept(iter_move(it)), "");
}
// Really a test for common_iterator's iter_move, but this is a good place for it.
{
std::unique_ptr<int> rg1[10], rg2[10];
auto rg3 = rg2 | views::take_while([](std::unique_ptr<int> &){return true;});
auto x = views::zip(rg1, rg3);
CPP_assert(!common_range<decltype(x)>);
auto y = x | views::common;
std::pair<std::unique_ptr<int>, std::unique_ptr<int>> p = iter_move(y.begin());
auto it = x.begin();
static_assert(noexcept(iter_move(it)), "");
}
// Regression test for #439.
{
std::vector<int> vec{0,1,2};
auto rng = vec | views::for_each([](int i) { return ranges::yield(i); });
ranges::distance(views::zip(views::iota(0), rng) | views::common);
}
{
int const i1[] = {0,1,2,3};
int const i2[] = {4,5,6,7};
auto rng = views::zip(
debug_input_view<int const>{i1},
debug_input_view<int const>{i2}
);
using P = std::pair<int, int>;
has_cardinality<cardinality::finite>(rng);
::check_equal(rng, {P{0,4},P{1,5}, P{2,6}, P{3,7}});
}
{
// Test with no ranges
auto rng = views::zip();
using R = decltype(rng);
CPP_assert(same_as<range_value_t<R>, std::tuple<>>);
CPP_assert(contiguous_range<R>);
has_cardinality<cardinality(0)>(rng);
CHECK(ranges::begin(rng) == ranges::end(rng));
CHECK(ranges::size(rng) == 0u);
}
{
// test dangling
auto true_ = [](auto&&){ return true; };
CHECK(!::is_dangling(ranges::find_if(views::zip(vi, vs), true_)));
CHECK(!::is_dangling(ranges::find_if(views::zip(
vi | views::move,
vs | views::common
), true_)));
CHECK(::is_dangling(ranges::find_if(views::zip(
vi | views::filter(true_)), true_)));
}
{
// test zip with infinite range
int const i1[] = {0,1,2,3};
auto rng = views::zip(i1, views::iota(4));
has_cardinality<cardinality(4)>(rng);
using P = std::pair<int, int>;
::check_equal(rng, {P{0,4},P{1,5}, P{2,6}, P{3,7}});
}
{
// test zip with infinite ranges only
auto rng = views::zip(views::iota(0), views::iota(4));
has_cardinality<cardinality::infinite>(rng);
using P = std::pair<int, int>;
::check_equal(rng | views::take(4), {P{0,4},P{1,5}, P{2,6}, P{3,7}});
}
{
// test unknown cardinality
std::stringstream str{};
auto rng = views::zip(istream<std::string>(str));
has_cardinality<cardinality::unknown>(rng);
}
{
std::vector<int> v0{1, 2, 3};
std::vector<int> v1{};
auto rng0 = views::zip(v0, v1);
auto rng1 = views::zip(v1, v0);
CHECK(ranges::distance(ranges::begin(rng0), ranges::end(rng0)) == 0);
CHECK(ranges::distance(ranges::begin(rng1), ranges::end(rng1)) == 0);
CHECK(ranges::distance(ranges::end(rng0), ranges::begin(rng0)) == 0);
CHECK(ranges::distance(ranges::end(rng1), ranges::begin(rng1)) == 0);
}
{
std::vector<int> v0{1, 2, 3};
std::vector<int> v1{1, 2, 3, 4, 5};
auto rng = views::zip(v0, v1);
CHECK(ranges::distance(ranges::begin(rng), ranges::end(rng)) == 3);
CHECK(ranges::distance(ranges::end(rng), ranges::begin(rng)) == -3);
}
return test_result();
}
|
0 | repos/range-v3/test | repos/range-v3/test/view/span.cpp | ///////////////////////////////////////////////////////////////////////////////
//
// Copyright (c) 2015 Microsoft Corporation. All rights reserved.
//
// This code is licensed under the MIT License (MIT).
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
// THE SOFTWARE.
//
///////////////////////////////////////////////////////////////////////////////
#include <range/v3/view/span.hpp>
#include <array>
#include <iostream>
#include <list>
#include <map>
#include <memory>
#include <regex>
#include <string>
#include <vector>
#include "../simple_test.hpp"
using ranges::span;
using ranges::dynamic_extent;
using ranges::make_span;
using ranges::as_bytes;
using ranges::as_writeable_bytes;
using ranges::detail::narrow_cast;
RANGES_DIAGNOSTIC_IGNORE_MISSING_BRACES
namespace {
struct BaseClass {};
struct DerivedClass : BaseClass {};
}
void test_case_default_constructor()
{
{
span<int> s;
CHECK((s.size() == 0 && s.data() == nullptr));
span<const int> cs;
CHECK((cs.size() == 0 && cs.data() == nullptr));
}
{
span<int, 0> s;
CHECK((s.size() == 0 && s.data() == nullptr));
span<const int, 0> cs;
CHECK((cs.size() == 0 && cs.data() == nullptr));
}
{
span<int, 1> s;
CHECK((s.size() == 1 && s.data() == nullptr));
}
{
span<int> s{};
CHECK((s.size() == 0 && s.data() == nullptr));
span<const int> cs{};
CHECK((cs.size() == 0 && cs.data() == nullptr));
}
}
void test_case_size_optimization()
{
{
span<int> s;
CHECK(sizeof(s) == sizeof(int*) + sizeof(std::ptrdiff_t));
}
{
span<int, 0> s;
CHECK(sizeof(s) == sizeof(int*));
}
}
void test_case_from_nullptr_constructor()
{
// This implementation doesn't support the silly nullptr_t constructor.
CPP_assert(!std::is_constructible<span<int>, std::nullptr_t>::value);
CPP_assert(!std::is_constructible<span<const int>, std::nullptr_t>::value);
CPP_assert(!std::is_constructible<span<int, 0>, std::nullptr_t>::value);
CPP_assert(!std::is_constructible<span<const int, 0>, std::nullptr_t>::value);
CPP_assert(!std::is_constructible<span<int, 1>, std::nullptr_t>::value);
CPP_assert(!std::is_constructible<span<const int, 1>, std::nullptr_t>::value);
}
void test_case_from_nullptr_size_constructor()
{
{
span<int> s{nullptr, static_cast<span<int>::index_type>(0)};
CHECK((s.size() == 0 && s.data() == nullptr));
span<const int> cs{nullptr, static_cast<span<int>::index_type>(0)};
CHECK((cs.size() == 0 && cs.data() == nullptr));
}
{
span<int, 0> s{nullptr, static_cast<span<int>::index_type>(0)};
CHECK((s.size() == 0 && s.data() == nullptr));
span<const int, 0> cs{nullptr, static_cast<span<int>::index_type>(0)};
CHECK((cs.size() == 0 && cs.data() == nullptr));
}
{
span<int*> s{nullptr, static_cast<span<int>::index_type>(0)};
CHECK((s.size() == 0 && s.data() == nullptr));
span<const int*> cs{nullptr, static_cast<span<int>::index_type>(0)};
CHECK((cs.size() == 0 && cs.data() == nullptr));
}
}
void test_case_from_pointer_size_constructor()
{
int arr[4] = {1, 2, 3, 4};
{
span<int> s{&arr[0], 2};
CHECK((s.size() == 2 && s.data() == &arr[0]));
CHECK((s[0] == 1 && s[1] == 2));
}
{
span<int, 2> s{&arr[0], 2};
CHECK((s.size() == 2 && s.data() == &arr[0]));
CHECK((s[0] == 1 && s[1] == 2));
}
{
int* p = nullptr;
span<int> s{p, static_cast<span<int>::index_type>(0)};
CHECK((s.size() == 0 && s.data() == nullptr));
}
{
auto s = make_span(&arr[0], 2);
CHECK((s.size() == 2 && s.data() == &arr[0]));
CHECK((s[0] == 1 && s[1] == 2));
}
{
int* p = nullptr;
auto s = make_span(p, static_cast<span<int>::index_type>(0));
CHECK((s.size() == 0 && s.data() == nullptr));
}
{
int i = 42;
span<int> s{&i, 0};
CHECK((s.size() == 0 && s.data() == &i));
span<const int> cs{&i, 0};
CHECK((s.size() == 0 && s.data() == &i));
}
}
void test_case_from_pointer_pointer_constructor()
{
int arr[4] = {1, 2, 3, 4};
{
span<int> s{&arr[0], &arr[2]};
CHECK((s.size() == 2 && s.data() == &arr[0]));
CHECK((s[0] == 1 && s[1] == 2));
}
{
span<int, 2> s{&arr[0], &arr[2]};
CHECK((s.size() == 2 && s.data() == &arr[0]));
CHECK((s[0] == 1 && s[1] == 2));
}
{
span<int> s{&arr[0], &arr[0]};
CHECK((s.size() == 0 && s.data() == &arr[0]));
}
{
span<int, 0> s{&arr[0], &arr[0]};
CHECK((s.size() == 0 && s.data() == &arr[0]));
}
{
int* p = nullptr;
span<int> s{p, p};
CHECK((s.size() == 0 && s.data() == nullptr));
}
{
int* p = nullptr;
span<int, 0> s{p, p};
CHECK((s.size() == 0 && s.data() == nullptr));
}
{
auto s = make_span(&arr[0], &arr[2]);
CHECK((s.size() == 2 && s.data() == &arr[0]));
CHECK((s[0] == 1 && s[1] == 2));
}
{
auto s = make_span(&arr[0], &arr[0]);
CHECK((s.size() == 0 && s.data() == &arr[0]));
}
{
int* p = nullptr;
auto s = make_span(p, p);
CHECK((s.size() == 0 && s.data() == nullptr));
}
}
void test_case_from_array_constructor()
{
int arr[5] = {1, 2, 3, 4, 5};
{
span<int> s{arr};
CHECK((s.size() == 5 && s.data() == &arr[0]));
}
{
span<int, 5> s{arr};
CHECK((s.size() == 5 && s.data() == &arr[0]));
}
int arr2d[2][3] = {1, 2, 3, 4, 5, 6};
CPP_assert(!std::is_constructible<span<int, 6>, int(&)[5]>::value);
CPP_assert(!std::is_constructible<span<int, 0>, int(&)[5]>::value);
CPP_assert(!std::is_constructible<span<int>, decltype((arr2d))>::value);
CPP_assert(!std::is_constructible<span<int, 0>, decltype((arr2d))>::value);
CPP_assert(!std::is_constructible<span<int, 6>, decltype((arr2d))>::value);
{
span<int[3]> s{&(arr2d[0]), 1};
CHECK((s.size() == 1 && s.data() == &arr2d[0]));
}
int arr3d[2][3][2] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12};
CPP_assert(!std::is_constructible<span<int>, decltype((arr3d))>::value);
CPP_assert(!std::is_constructible<span<int, 0>, decltype((arr3d))>::value);
CPP_assert(!std::is_constructible<span<int, 11>, decltype((arr3d))>::value);
CPP_assert(!std::is_constructible<span<int, 12>, decltype((arr3d))>::value);
{
span<int[3][2]> s{&arr3d[0], 1};
CHECK((s.size() == 1 && s.data() == &arr3d[0]));
}
{
auto s = make_span(arr);
CHECK((s.size() == 5 && s.data() == &arr[0]));
}
{
auto s = make_span(&(arr2d[0]), 1);
CHECK((s.size() == 1 && s.data() == &arr2d[0]));
}
{
auto s = make_span(&arr3d[0], 1);
CHECK((s.size() == 1 && s.data() == &arr3d[0]));
}
}
void test_case_from_std_array_constructor()
{
std::array<int, 4> arr = {1, 2, 3, 4};
{
span<int> s{arr};
CHECK((s.size() == narrow_cast<std::ptrdiff_t>(arr.size()) && s.data() == arr.data()));
span<const int> cs{arr};
CHECK((cs.size() == narrow_cast<std::ptrdiff_t>(arr.size()) && cs.data() == arr.data()));
}
{
span<int, 4> s{arr};
CHECK((s.size() == narrow_cast<std::ptrdiff_t>(arr.size()) && s.data() == arr.data()));
span<const int, 4> cs{arr};
CHECK((cs.size() == narrow_cast<std::ptrdiff_t>(arr.size()) && cs.data() == arr.data()));
}
CPP_assert(!std::is_constructible<span<int, 2>, decltype((arr))>::value);
CPP_assert(!std::is_constructible<span<const int, 2>, decltype((arr))>::value);
CPP_assert(!std::is_constructible<span<int, 0>, decltype((arr))>::value);
CPP_assert(!std::is_constructible<span<const int, 0>, decltype((arr))>::value);
CPP_assert(!std::is_constructible<span<int, 5>, decltype((arr))>::value);
{
auto get_an_array = []() -> std::array<int, 4> { return {1, 2, 3, 4}; };
auto take_a_span = [](span<int>) {};
take_a_span(get_an_array());
}
{
auto get_an_array = []() -> std::array<int, 4> { return {1, 2, 3, 4}; };
auto take_a_span = [](span<const int>) {};
take_a_span(get_an_array());
}
{
auto s = make_span(arr);
CHECK((s.size() == narrow_cast<std::ptrdiff_t>(arr.size()) && s.data() == arr.data()));
}
}
void test_case_from_const_std_array_constructor()
{
const std::array<int, 4> arr = {1, 2, 3, 4};
{
span<const int> s{arr};
CHECK((s.size() == narrow_cast<std::ptrdiff_t>(arr.size()) && s.data() == arr.data()));
}
{
span<const int, 4> s{arr};
CHECK((s.size() == narrow_cast<std::ptrdiff_t>(arr.size()) && s.data() == arr.data()));
}
CPP_assert(!std::is_constructible<span<const int, 2>, decltype((arr))>::value);
CPP_assert(!std::is_constructible<span<const int, 0>, decltype((arr))>::value);
CPP_assert(!std::is_constructible<span<const int, 5>, decltype((arr))>::value);
{
auto get_an_array = []() -> const std::array<int, 4> { return {1, 2, 3, 4}; };
auto take_a_span = [](span<const int>) {};
take_a_span(get_an_array());
}
{
auto s = make_span(arr);
CHECK((s.size() == narrow_cast<std::ptrdiff_t>(arr.size()) && s.data() == arr.data()));
}
}
void test_case_from_std_array_const_constructor()
{
std::array<const int, 4> arr = {1, 2, 3, 4};
{
span<const int> s{arr};
CHECK((s.size() == narrow_cast<std::ptrdiff_t>(arr.size()) && s.data() == arr.data()));
}
{
span<const int, 4> s{arr};
CHECK((s.size() == narrow_cast<std::ptrdiff_t>(arr.size()) && s.data() == arr.data()));
}
CPP_assert(!std::is_constructible<span<const int, 2>, decltype((arr))>::value);
CPP_assert(!std::is_constructible<span<const int, 0>, decltype((arr))>::value);
CPP_assert(!std::is_constructible<span<const int, 5>, decltype((arr))>::value);
CPP_assert(!std::is_constructible<span<int, 4>, decltype((arr))>::value);
{
auto s = make_span(arr);
CHECK((s.size() == narrow_cast<std::ptrdiff_t>(arr.size()) && s.data() == arr.data()));
}
}
void test_case_from_container_constructor()
{
std::vector<int> v = {1, 2, 3};
const std::vector<int> cv = v;
{
span<int> s{v};
CHECK((s.size() == narrow_cast<std::ptrdiff_t>(v.size()) && s.data() == v.data()));
span<const int> cs{v};
CHECK((cs.size() == narrow_cast<std::ptrdiff_t>(v.size()) && cs.data() == v.data()));
}
std::string str = "hello";
const std::string cstr = "hello";
{
span<char> s{str};
CHECK((s.size() == narrow_cast<std::ptrdiff_t>(str.size()) && s.data() == str.data()));
}
{
auto get_temp_string = []() -> std::string { return {}; };
auto use_span = [](span<char>) {};
use_span(get_temp_string());
}
{
span<const char> cs{str};
CHECK((cs.size() == narrow_cast<std::ptrdiff_t>(str.size()) && cs.data() == str.data()));
}
{
auto get_temp_string = []() -> std::string { return {}; };
auto use_span = [](span<const char>) {};
use_span(get_temp_string());
}
{
CPP_assert(!std::is_constructible<span<char>, decltype((cstr))>::value);
span<const char> cs{cstr};
CHECK((cs.size() == narrow_cast<std::ptrdiff_t>(cstr.size()) &&
cs.data() == cstr.data()));
}
{
auto get_temp_vector = []() -> std::vector<int> { return {}; };
auto use_span = [](span<int>) {};
use_span(get_temp_vector());
}
{
auto get_temp_vector = []() -> std::vector<int> { return {}; };
auto use_span = [](span<const int>) {};
use_span(get_temp_vector());
}
CPP_assert(!ranges::detail::is_convertible<const std::vector<int>, span<const char>>::value);
{
auto get_temp_string = []() -> const std::string { return {}; };
auto use_span = [](span<const char> s) { static_cast<void>(s); };
use_span(get_temp_string());
}
CPP_assert(!std::is_constructible<span<int>, std::map<int, int>&>::value);
{
auto s = make_span(v);
CHECK((s.size() == narrow_cast<std::ptrdiff_t>(v.size()) && s.data() == v.data()));
auto cs = make_span(cv);
CHECK((cs.size() == narrow_cast<std::ptrdiff_t>(cv.size()) && cs.data() == cv.data()));
}
}
void test_case_from_convertible_span_constructor()
{
{
span<DerivedClass> avd;
span<const DerivedClass> avcd = avd;
static_cast<void>(avcd);
}
CPP_assert(!std::is_constructible<span<BaseClass>, span<DerivedClass>>::value);
CPP_assert(!std::is_constructible<span<DerivedClass>, span<BaseClass>>::value);
CPP_assert(!std::is_constructible<span<unsigned int>, span<int>>::value);
CPP_assert(!std::is_constructible<span<const unsigned int>, span<int>>::value);
CPP_assert(!std::is_constructible<span<short>, span<int>>::value);
}
void test_case_copy_move_and_assignment()
{
span<int> s1;
CHECK(s1.empty());
int arr[] = {3, 4, 5};
span<const int> s2 = arr;
CHECK((s2.size() == 3 && s2.data() == &arr[0]));
s2 = s1;
CHECK(s2.empty());
auto get_temp_span = [&]() -> span<int> { return {&arr[1], 2}; };
auto use_span = [&](span<const int> s) { CHECK((s.size() == 2 && s.data() == &arr[1])); };
use_span(get_temp_span());
s1 = get_temp_span();
CHECK((s1.size() == 2 && s1.data() == &arr[1]));
}
void test_case_class_template_argument_deduction()
{
#if RANGES_CXX_DEDUCTION_GUIDES >= RANGES_CXX_DEDUCTION_GUIDES_17
#if defined(__clang__) && __clang_major__ < 6
// Workaround https://bugs.llvm.org/show_bug.cgi?id=33314
RANGES_DIAGNOSTIC_PUSH
RANGES_DIAGNOSTIC_IGNORE_UNDEFINED_FUNC_TEMPLATE
#endif
{
int arr[] = {1, 2, 3, 4, 5};
{
span s{arr};
CPP_assert(std::is_same<span<int, 5>, decltype(s)>::value);
}
{
span s{ranges::data(arr), ranges::size(arr)};
CPP_assert(std::is_same<span<int>, decltype(s)>::value);
}
{
span s{ranges::begin(arr), ranges::end(arr)};
CPP_assert(std::is_same<span<int>, decltype(s)>::value);
}
}
{
std::array<int, 5> arr = {1, 2, 3, 4, 5};
{
span s{arr};
CPP_assert(std::is_same<span<int, 5>, decltype(s)>::value);
}
}
{
std::vector<int> vec = {1, 2, 3, 4, 5};
{
span s{vec};
CPP_assert(std::is_same<span<int>, decltype(s)>::value);
}
}
#if defined(__clang__) && __clang_major__ < 6
RANGES_DIAGNOSTIC_POP
#endif // clang bug workaround
#endif // use deduction guides
}
void test_case_first()
{
int arr[5] = {1, 2, 3, 4, 5};
{
span<int, 5> av = arr;
CHECK(av.first<2>().size() == 2);
CHECK(av.first(2).size() == 2);
}
{
span<int, 5> av = arr;
CHECK(av.first<0>().size() == 0);
CHECK(av.first(0).size() == 0);
}
{
span<int, 5> av = arr;
CHECK(av.first<5>().size() == 5);
CHECK(av.first(5).size() == 5);
}
{
span<int> av;
CHECK(av.first<0>().size() == 0);
CHECK(av.first(0).size() == 0);
}
}
void test_case_last()
{
int arr[5] = {1, 2, 3, 4, 5};
{
span<int, 5> av = arr;
CHECK(av.last<2>().size() == 2);
CHECK(av.last(2).size() == 2);
}
{
span<int, 5> av = arr;
CHECK(av.last<0>().size() == 0);
CHECK(av.last(0).size() == 0);
}
{
span<int, 5> av = arr;
CHECK(av.last<5>().size() == 5);
CHECK(av.last(5).size() == 5);
}
{
span<int> av;
CHECK(av.last<0>().size() == 0);
CHECK(av.last(0).size() == 0);
}
}
void test_case_subspan()
{
int arr[5] = {1, 2, 3, 4, 5};
{
span<int, 5> av = arr;
CHECK((av.subspan<2, 2>().size() == 2));
CHECK(av.subspan(2, 2).size() == 2);
CHECK(av.subspan(2, 3).size() == 3);
}
{
span<int, 5> av = arr;
CHECK((av.subspan<0, 0>().size() == 0));
CHECK(av.subspan(0, 0).size() == 0);
}
{
span<int, 5> av = arr;
CHECK((av.subspan<0, 5>().size() == 5));
CHECK(av.subspan(0, 5).size() == 5);
}
{
span<int, 5> av = arr;
CHECK((av.subspan<4, 0>().size() == 0));
CHECK(av.subspan(4, 0).size() == 0);
CHECK(av.subspan(5, 0).size() == 0);
}
{
span<int> av;
CHECK((av.subspan<0, 0>().size() == 0));
CHECK(av.subspan(0, 0).size() == 0);
}
{
span<int> av;
CHECK(av.subspan(0).size() == 0);
}
{
span<int> av = arr;
CHECK(av.subspan(0).size() == 5);
CHECK(av.subspan(1).size() == 4);
CHECK(av.subspan(4).size() == 1);
CHECK(av.subspan(5).size() == 0);
const auto av2 = av.subspan(1);
for (int i = 0; i < 4; ++i) CHECK(av2[i] == i + 2);
}
{
span<int, 5> av = arr;
CHECK(av.subspan(0).size() == 5);
CHECK(av.subspan(1).size() == 4);
CHECK(av.subspan(4).size() == 1);
CHECK(av.subspan(5).size() == 0);
const auto av2 = av.subspan(1);
for (int i = 0; i < 4; ++i) CHECK(av2[i] == i + 2);
}
{
span<int, 5> av = arr;
CHECK(decltype(av.subspan<0, dynamic_extent>())::extent == 5);
CHECK((av.subspan<0, dynamic_extent>().size() == 5));
CHECK(decltype(av.subspan<1, dynamic_extent>())::extent == 4);
CHECK((av.subspan<1, dynamic_extent>().size() == 4));
CHECK(decltype(av.subspan<2, dynamic_extent>())::extent == 3);
CHECK((av.subspan<2, dynamic_extent>().size() == 3));
CHECK(decltype(av.subspan<3, dynamic_extent>())::extent == 2);
CHECK((av.subspan<3, dynamic_extent>().size() == 2));
CHECK(decltype(av.subspan<4, dynamic_extent>())::extent == 1);
CHECK((av.subspan<4, dynamic_extent>().size() == 1));
CHECK(decltype(av.subspan<5, dynamic_extent>())::extent == 0);
CHECK((av.subspan<5, dynamic_extent>().size() == 0));
}
{
span<int> av = arr;
CHECK(decltype(av.subspan<0, dynamic_extent>())::extent == dynamic_extent);
CHECK((av.subspan<0, dynamic_extent>().size() == 5));
CHECK(decltype(av.subspan<1, dynamic_extent>())::extent == dynamic_extent);
CHECK((av.subspan<1, dynamic_extent>().size() == 4));
CHECK(decltype(av.subspan<2, dynamic_extent>())::extent == dynamic_extent);
CHECK((av.subspan<2, dynamic_extent>().size() == 3));
CHECK(decltype(av.subspan<3, dynamic_extent>())::extent == dynamic_extent);
CHECK((av.subspan<3, dynamic_extent>().size() == 2));
CHECK(decltype(av.subspan<4, dynamic_extent>())::extent == dynamic_extent);
CHECK((av.subspan<4, dynamic_extent>().size() == 1));
CHECK(decltype(av.subspan<5, dynamic_extent>())::extent == dynamic_extent);
CHECK((av.subspan<5, dynamic_extent>().size() == 0));
}
}
void test_case_iterator_value_init()
{
span<int>::iterator it1{};
span<int>::iterator it2{};
CHECK(it1 == it2);
}
void test_case_iterator_comparisons()
{
int a[] = {1, 2, 3, 4};
{
span<int> s = a;
auto it = s.begin();
CPP_assert(ranges::same_as<decltype(it), span<int>::iterator>);
auto it2 = it + 1;
CHECK(it == it);
CHECK(it != it2);
CHECK(it2 != it);
CHECK(it != s.end());
CHECK(it2 != s.end());
CHECK(s.end() != it);
CHECK(it < it2);
CHECK(it <= it2);
CHECK(it2 <= s.end());
CHECK(it < s.end());
CHECK(it2 > it);
CHECK(it2 >= it);
CHECK(s.end() > it2);
CHECK(s.end() >= it2);
}
}
void test_case_begin_end()
{
{
int a[] = {1, 2, 3, 4};
span<int> s = a;
span<int>::iterator it = s.begin();
span<int>::iterator it2 = ranges::begin(s);
CHECK(it == it2);
it = s.end();
it2 = ranges::end(s);
CHECK(it == it2);
}
{
int a[] = {1, 2, 3, 4};
span<int> s = a;
auto it = s.begin();
auto first = it;
CHECK(it == first);
CHECK(*it == 1);
auto beyond = s.end();
CHECK(it != beyond);
CHECK((beyond - first) == 4);
CHECK((first - first) == 0);
CHECK((beyond - beyond) == 0);
++it;
CHECK((it - first) == 1);
CHECK(*it == 2);
*it = 22;
CHECK(*it == 22);
CHECK((beyond - it) == 3);
it = first;
CHECK(it == first);
while (it != s.end()) {
*it = 5;
++it;
}
CHECK(it == beyond);
CHECK((it - beyond) == 0);
for (const auto& n : s) {
CHECK(n == 5);
}
}
}
void test_case_rbegin_rend()
{
{
int a[] = {1, 2, 3, 4};
span<int> s = a;
auto it = s.rbegin();
auto first = it;
CHECK(it == first);
CHECK(*it == 4);
auto beyond = s.rend();
CHECK(it != beyond);
CHECK((beyond - first) == 4);
CHECK((first - first) == 0);
CHECK((beyond - beyond) == 0);
++it;
CHECK((it - first) == 1);
CHECK(*it == 3);
*it = 22;
CHECK(*it == 22);
CHECK((beyond - it) == 3);
it = first;
CHECK(it == first);
while (it != s.rend()) {
*it = 5;
++it;
}
CHECK(it == beyond);
CHECK((it - beyond) == 0);
for (const auto& n : s) {
CHECK(n == 5);
}
}
}
void test_case_comparison_operators()
{
{
span<int> s1;
span<int> s2;
CHECK(s1 == s2);
CHECK(!(s1 != s2));
CHECK(!(s1 < s2));
CHECK(s1 <= s2);
CHECK(!(s1 > s2));
CHECK(s1 >= s2);
CHECK(s2 == s1);
CHECK(!(s2 != s1));
CHECK(!(s2 < s1));
CHECK(s2 <= s1);
CHECK(!(s2 > s1));
CHECK(s2 >= s1);
}
{
int arr[] = {2, 1};
span<int> s1 = arr;
span<int> s2 = arr;
CHECK(s1 == s2);
CHECK(!(s1 != s2));
CHECK(!(s1 < s2));
CHECK(s1 <= s2);
CHECK(!(s1 > s2));
CHECK(s1 >= s2);
CHECK(s2 == s1);
CHECK(!(s2 != s1));
CHECK(!(s2 < s1));
CHECK(s2 <= s1);
CHECK(!(s2 > s1));
CHECK(s2 >= s1);
}
{
int arr[] = {2, 1}; // bigger
span<int> s1;
span<int> s2 = arr;
CHECK(s1 != s2);
CHECK(s2 != s1);
CHECK(!(s1 == s2));
CHECK(!(s2 == s1));
CHECK(s1 < s2);
CHECK(!(s2 < s1));
CHECK(s1 <= s2);
CHECK(!(s2 <= s1));
CHECK(s2 > s1);
CHECK(!(s1 > s2));
CHECK(s2 >= s1);
CHECK(!(s1 >= s2));
}
{
int arr1[] = {1, 2};
int arr2[] = {1, 2};
span<int> s1 = arr1;
span<int> s2 = arr2;
CHECK(s1 == s2);
CHECK(!(s1 != s2));
CHECK(!(s1 < s2));
CHECK(s1 <= s2);
CHECK(!(s1 > s2));
CHECK(s1 >= s2);
CHECK(s2 == s1);
CHECK(!(s2 != s1));
CHECK(!(s2 < s1));
CHECK(s2 <= s1);
CHECK(!(s2 > s1));
CHECK(s2 >= s1);
}
{
int arr[] = {1, 2, 3};
span<int> s1 = {&arr[0], 2}; // shorter
span<int> s2 = arr; // longer
CHECK(s1 != s2);
CHECK(s2 != s1);
CHECK(!(s1 == s2));
CHECK(!(s2 == s1));
CHECK(s1 < s2);
CHECK(!(s2 < s1));
CHECK(s1 <= s2);
CHECK(!(s2 <= s1));
CHECK(s2 > s1);
CHECK(!(s1 > s2));
CHECK(s2 >= s1);
CHECK(!(s1 >= s2));
}
{
int arr1[] = {1, 2}; // smaller
int arr2[] = {2, 1}; // bigger
span<int> s1 = arr1;
span<int> s2 = arr2;
CHECK(s1 != s2);
CHECK(s2 != s1);
CHECK(!(s1 == s2));
CHECK(!(s2 == s1));
CHECK(s1 < s2);
CHECK(!(s2 < s1));
CHECK(s1 <= s2);
CHECK(!(s2 <= s1));
CHECK(s2 > s1);
CHECK(!(s1 > s2));
CHECK(s2 >= s1);
CHECK(!(s1 >= s2));
}
}
void test_case_as_bytes()
{
int a[] = {1, 2, 3, 4};
{
const span<const int> s = a;
CHECK(s.size() == 4);
const auto bs = as_bytes(s);
CHECK(static_cast<const void*>(bs.data()) == static_cast<const void*>(s.data()));
CHECK(bs.size() == s.size_bytes());
}
{
span<int> s;
const auto bs = as_bytes(s);
CHECK(bs.size() == s.size());
CHECK(bs.size() == 0);
CHECK(bs.size_bytes() == 0);
CHECK(static_cast<const void*>(bs.data()) == static_cast<const void*>(s.data()));
CHECK(bs.data() == nullptr);
}
{
span<int> s = a;
const auto bs = as_bytes(s);
CHECK(static_cast<const void*>(bs.data()) == static_cast<const void*>(s.data()));
CHECK(bs.size() == s.size_bytes());
}
}
void test_case_as_writeable_bytes()
{
int a[] = {1, 2, 3, 4};
{
span<int> s;
const auto bs = as_writeable_bytes(s);
CHECK(bs.size() == s.size());
CHECK(bs.size() == 0);
CHECK(bs.size_bytes() == 0);
CHECK(static_cast<void*>(bs.data()) == static_cast<void*>(s.data()));
CHECK(bs.data() == nullptr);
}
{
span<int> s = a;
const auto bs = as_writeable_bytes(s);
CHECK(static_cast<void*>(bs.data()) == static_cast<void*>(s.data()));
CHECK(bs.size() == s.size_bytes());
}
}
void test_case_fixed_size_conversions()
{
int arr[] = {1, 2, 3, 4};
// converting to an span from an equal size array is ok
span<int, 4> s4 = arr;
CHECK(s4.size() == 4);
// converting to dynamic_range is always ok
{
span<int> s = s4;
CHECK(s.size() == s4.size());
static_cast<void>(s);
}
// initialization or assignment to static span that REDUCES size is NOT ok
CPP_assert(!ranges::detail::is_convertible<decltype((arr)), span<int, 2>>::value);
CPP_assert(!ranges::detail::is_convertible<span<int, 4>, span<int, 2>>::value);
// you can convert statically
{
const span<int, 2> s2 = {arr, 2};
static_cast<void>(s2);
}
{
const span<int, 1> s1 = s4.first<1>();
static_cast<void>(s1);
}
// ...or dynamically
{
// NB: implicit conversion to span<int,1> from span<int>
span<int, 1> s1 = s4.first(1);
static_cast<void>(s1);
}
// initialization or assignment to static span that requires size INCREASE is not ok.
int arr2[2] = {1, 2};
(void)arr2;
CPP_assert(!std::is_constructible<span<int, 4>, decltype((arr2))>::value);
CPP_assert(!std::is_constructible<span<int, 4>, span<int, 2>>::value);
}
void test_case_interop_with_std_regex()
{
char lat[] = {'1', '2', '3', '4', '5', '6', 'E', 'F', 'G'};
span<char> s = lat;
const auto f_it = s.begin() + 7;
std::match_results<span<char>::iterator> match;
std::regex_match(s.begin(), s.end(), match, std::regex(".*"));
CHECK(match.ready());
CHECK(!match.empty());
CHECK(match[0].matched);
CHECK(match[0].first == s.begin());
CHECK(match[0].second == s.end());
std::regex_search(s.begin(), s.end(), match, std::regex("F"));
CHECK(match.ready());
CHECK(!match.empty());
CHECK(match[0].matched);
CHECK(match[0].first == f_it);
CHECK(match[0].second == (f_it + 1));
}
void test_case_default_constructible()
{
CHECK((std::is_default_constructible<span<int>>::value));
CHECK((std::is_default_constructible<span<int, 0>>::value));
CHECK((std::is_default_constructible<span<int, 42>>::value));
}
int main() {
test_case_default_constructor();
test_case_size_optimization();
test_case_from_nullptr_constructor();
test_case_from_nullptr_size_constructor();
test_case_from_pointer_size_constructor();
test_case_from_pointer_pointer_constructor();
test_case_from_array_constructor();
test_case_from_std_array_constructor();
test_case_from_const_std_array_constructor();
test_case_from_std_array_const_constructor();
test_case_from_container_constructor();
test_case_from_convertible_span_constructor();
test_case_copy_move_and_assignment();
test_case_class_template_argument_deduction();
test_case_first();
test_case_last();
test_case_subspan();
test_case_iterator_value_init();
test_case_iterator_comparisons();
test_case_begin_end();
test_case_rbegin_rend();
test_case_comparison_operators();
test_case_as_bytes();
test_case_as_writeable_bytes();
test_case_fixed_size_conversions();
test_case_interop_with_std_regex();
test_case_default_constructible();
CPP_assert(ranges::view_<span<int>>);
CPP_assert(ranges::contiguous_range<span<int>>);
CPP_assert(ranges::view_<span<int, 42>>);
CPP_assert(ranges::contiguous_range<span<int, 42>>);
return ::test_result();
}
|
0 | repos/range-v3/test | repos/range-v3/test/view/reverse.cpp | // Range v3 library
//
// Copyright Eric Niebler 2015-present
//
// Use, modification and distribution is subject to the
// Boost Software License, Version 1.0. (See accompanying
// file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt)
//
// Project home: https://github.com/ericniebler/range-v3
#include <list>
#include <vector>
#include <range/v3/core.hpp>
#include <range/v3/view/take.hpp>
#include <range/v3/view/take_exactly.hpp>
#include <range/v3/view/reverse.hpp>
#include <range/v3/view/counted.hpp>
#include <range/v3/view/delimit.hpp>
#include <range/v3/view/filter.hpp>
#include <range/v3/view/c_str.hpp>
#include <range/v3/view/zip.hpp>
#include <range/v3/utility/copy.hpp>
#include <range/v3/algorithm/find.hpp>
#include "../simple_test.hpp"
#include "../test_utils.hpp"
int main()
{
using namespace ranges;
// Reverse a random-access, common, sized range
std::vector<int> rgv{0,1,2,3,4,5,6,7,8,9};
auto const rng0 = rgv | views::reverse;
CPP_assert(view_<std::remove_const_t<decltype(rng0)>>);
CPP_assert(random_access_range<decltype(rng0)>);
CPP_assert(common_range<decltype(rng0)>);
CPP_assert(sized_range<decltype(rng0)>);
CHECK(rng0.size() == 10u);
::check_equal(rng0, {9,8,7,6,5,4,3,2,1,0});
::check_equal(rng0 | views::reverse, {0,1,2,3,4,5,6,7,8,9});
::check_equal(rng0 | views::reverse | views::reverse, {9,8,7,6,5,4,3,2,1,0});
::check_equal(rng0 | views::reverse | views::reverse | views::reverse, {0,1,2,3,4,5,6,7,8,9});
{
auto z = views::zip(rgv);
auto rz = z | views::reverse;
CPP_assert(same_as<range_value_t<decltype(z)>, range_value_t<decltype(rz)>>);
}
#if RANGES_CXX_DEDUCTION_GUIDES >= RANGES_CXX_DEDUCTION_GUIDES_17
#if defined(__clang__) && __clang_major__ < 6
// Workaround https://bugs.llvm.org/show_bug.cgi?id=33314
RANGES_DIAGNOSTIC_PUSH
RANGES_DIAGNOSTIC_IGNORE_UNDEFINED_FUNC_TEMPLATE
#endif
{
ranges::reverse_view dg0{rgv};
::check_equal(dg0, {9, 8, 7, 6, 5, 4, 3, 2, 1, 0});
ranges::reverse_view dg1{dg0};
#ifdef RANGES_WORKAROUND_MSVC_934330
::check_equal(dg1, {9, 8, 7, 6, 5, 4, 3, 2, 1, 0});
#else // ^^^ "workaround" / no "workaround" vvv
::check_equal(dg1, {0, 1, 2, 3, 4, 5, 6, 7, 8, 9});
#endif // RANGES_WORKAROUND_MSVC_934330
}
#if defined(__clang__) && __clang_major__ < 6
RANGES_DIAGNOSTIC_POP
#endif // clang bug workaround
#endif // use deduction guides
// Reverse another random-access, non-common, sized range
auto cnt = counted_view<std::vector<int>::iterator>(rgv.begin(), 10);
CPP_assert(!common_range<decltype(cnt)>);
auto const rng1 = rgv | views::reverse;
CPP_assert(view_<std::remove_const_t<decltype(rng1)>>);
CPP_assert(random_access_range<decltype(rng1)>);
CPP_assert(common_range<decltype(rng1)>);
CPP_assert(sized_range<decltype(rng1)>);
CHECK(rng1.size() == 10u);
::check_equal(rng1, {9,8,7,6,5,4,3,2,1,0});
::check_equal(rng1 | views::reverse, {0,1,2,3,4,5,6,7,8,9});
// Reverse a random-access, non-common, non-sized range
auto sz = views::c_str((char const*)"hello");
auto rng2 = sz | views::reverse;
CPP_assert(view_<decltype(rng2)>);
CPP_assert(random_access_range<decltype(rng2)>);
CPP_assert(common_range<decltype(rng2)>);
CPP_assert(!sized_range<decltype(detail::as_const(rng2))>);
CPP_assert(sized_range<decltype(rng2)>);
auto const & crng2 = rng2;
CPP_assert(!range<decltype(crng2)>);
::check_equal(rng2, {'o','l','l','e','h'});
::check_equal(rng2 | views::reverse, {'h','e','l','l','o'});
// Reverse a bidirectional, common, sized range
std::list<int> rgl{0,1,2,3,4,5,6,7,8,9};
auto const rng3 = rgl | views::reverse;
CPP_assert(view_<std::remove_const_t<decltype(rng3)>>);
CPP_assert(bidirectional_range<decltype(rng3)>);
CPP_assert(!random_access_range<decltype(rng3)>);
CPP_assert(common_range<decltype(rng3)>);
CPP_assert(sized_range<decltype(rng3)>);
CHECK(rng3.size() == 10u);
::check_equal(rng3, {9,8,7,6,5,4,3,2,1,0});
::check_equal(rng3 | views::reverse, {0,1,2,3,4,5,6,7,8,9});
// Reverse a bidirectional, weak, sized range
auto cnt2 = views::counted(rgl.begin(), 10);
auto rng4 = cnt2 | views::reverse;
CPP_assert(view_<decltype(rng4)>);
CPP_assert(bidirectional_range<decltype(rng4)>);
CPP_assert(!random_access_range<decltype(rng4)>);
CPP_assert(common_range<decltype(rng4)>);
CPP_assert(sized_range<decltype(rng4)>);
CHECK(rng4.size() == 10u);
auto const & crng4 = rng4;
CPP_assert(!range<decltype(crng4)>);
::check_equal(rng4, {9,8,7,6,5,4,3,2,1,0});
::check_equal(rng4 | views::reverse, {0,1,2,3,4,5,6,7,8,9});
// Reverse a bidirectional, weak, non-sized range
auto dlm = views::delimit(rgl.begin(), 9);
CPP_assert(!common_range<decltype(dlm)>);
auto rng5 = dlm | views::reverse;
CPP_assert(view_<decltype(rng5)>);
CPP_assert(bidirectional_range<decltype(rng5)>);
CPP_assert(!random_access_range<decltype(rng5)>);
CPP_assert(common_range<decltype(rng5)>);
CPP_assert(!sized_range<decltype(rng5)>);
auto const & crng5 = rng5;
CPP_assert(!range<decltype(crng5)>);
::check_equal(rng5, {8,7,6,5,4,3,2,1,0});
::check_equal(rng5 | views::reverse, {0,1,2,3,4,5,6,7,8});
// Reverse a bidirectional, weak, non-sized range
auto dlm2 = views::delimit(rgl, 10);
CPP_assert(!common_range<decltype(dlm2)>);
auto rng6 = dlm2 | views::reverse;
CPP_assert(view_<decltype(rng6)>);
CPP_assert(bidirectional_range<decltype(rng6)>);
CPP_assert(!random_access_range<decltype(rng6)>);
CPP_assert(common_range<decltype(rng6)>);
CPP_assert(!sized_range<decltype(rng6)>);
auto const & crng6 = rng6;
CPP_assert(!range<decltype(crng6)>);
::check_equal(rng6, {9,8,7,6,5,4,3,2,1,0});
::check_equal(rng6 | views::reverse, {0,1,2,3,4,5,6,7,8,9});
{
std::vector<int> v = {1, 2, 3, 4, 5};
auto b = find(v, 2);
auto e = find(v | views::reverse, 4).base();
::check_equal(make_subrange(b, e), {2, 3, 4});
auto e2 = find(v | views::filter([](int i){ return i%2 == 0;})
| views::reverse, 4);
CHECK(::is_dangling(e2));
}
return test_result();
}
|
0 | repos/range-v3/test | repos/range-v3/test/view/enumerate.cpp | // Range v3 library
//
// Copyright MikeGitb 2018-present
//
// Use, modification and distribution is subject to the
// Boost Software License, Version 1.0. (See accompanying
// file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt)
//
// Project home: https://github.com/ericniebler/range-v3
#include <range/v3/view/enumerate.hpp>
#include <range/v3/view/iota.hpp>
#include <range/v3/view/indices.hpp>
#include <range/v3/view/transform.hpp>
#include "../simple_test.hpp"
#include "../test_utils.hpp"
#include <list>
#include <vector>
#include <tuple>
#include <iterator>
using std::begin;
template<class RangeT>
void test_enumerate_with(RangeT &&range)
{
auto enumerated_range = ranges::views::enumerate(range);
CPP_assert(ranges::borrowed_range<decltype(enumerated_range)>);
std::size_t idx_ref = 0;
auto it_ref = begin( range );
for(auto it = enumerated_range.begin(); it != enumerated_range.end(); ++it)
{
const auto idx = std::get<0>(*it);
const auto value = std::get<1>(*it);
CHECK(idx == idx_ref++);
CHECK(value == *it_ref++);
}
}
int main()
{
{ // test array
int const es[] = { 9,8,7,6,5,4,3,2,1,0 };
test_enumerate_with(es);
}
{ // test with vector of complex value type
std::vector<std::list<int>> range{ {1, 2, 3}, { 3,5,6,7 }, { 10,5,6,1 }, { 1,2,3,4 } };
const auto rcopy = range;
test_enumerate_with(range);
// check that range hasn't accidentially been modified
CHECK(rcopy == range);
// check with empty range
range.clear();
test_enumerate_with(range);
}
{ // test with list
std::list<int> range{ 9,8,7,6,5,4,3,2,1 };
test_enumerate_with(range);
range.clear();
test_enumerate_with(range);
}
{ // test with initializer_list
test_enumerate_with(std::initializer_list<int>{9, 8, 7, 6, 5, 4, 3, 2, 1});
}
{
auto range = ranges::views::iota(0, 0);
test_enumerate_with(range);
range = ranges::views::iota(-10000, 10000);
test_enumerate_with(range);
}
{
auto range = ranges::views::iota((std::uintmax_t)0, (std::uintmax_t)0);
test_enumerate_with(range);
auto range2 = ranges::views::iota((std::intmax_t) -10000, (std::intmax_t) 10000);
test_enumerate_with(range2);
}
// https://github.com/ericniebler/range-v3/issues/1141
{
using namespace ranges;
auto x = views::indices( std::uintmax_t( 100 ) )
| views::transform([](std::uintmax_t) { return "";})
| views::enumerate;
using X = decltype(x);
CPP_assert(same_as<range_difference_t<X>, detail::diffmax_t>);
CPP_assert(same_as<range_value_t<X>, std::pair<detail::diffmax_t, char const*>>);
}
return ::test_result();
}
|
0 | repos/range-v3/test | repos/range-v3/test/view/sliding.cpp | // Range v3 library
//
// Copyright Tobias Mayer 2016
// Copyright Casey Carter 2016
//
// Use, modification and distribution is subject to the
// Boost Software License, Version 1.0. (See accompanying
// file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt)
//
// Project home: https://github.com/ericniebler/range-v3
#include <forward_list>
#include <list>
#include <vector>
#include <range/v3/core.hpp>
#include <range/v3/view/chunk_by.hpp>
#include <range/v3/view/cycle.hpp>
#include <range/v3/view/iota.hpp>
#include <range/v3/view/repeat.hpp>
#include <range/v3/view/repeat_n.hpp>
#include <range/v3/view/reverse.hpp>
#include <range/v3/view/sliding.hpp>
#include <range/v3/view/zip.hpp>
#include "../simple_test.hpp"
#include "../test_utils.hpp"
using namespace ranges;
namespace
{
namespace ebo_test
{
struct empty1 {};
struct empty2 {};
struct refines : empty1, empty2 {};
}
constexpr bool broken_ebo = sizeof(ebo_test::refines) > sizeof(ebo_test::empty1);
constexpr auto N = 7;
constexpr auto K = 3;
CPP_assert(K < N);
template<typename Adapted>
void test_size(Adapted& a, std::true_type)
{
CPP_assert(sized_range<decltype(a)>);
CHECK(size(a), unsigned(N - K + 1));
}
template<typename Adapted>
void test_size(Adapted&, std::false_type)
{}
template<typename Adapted>
void test_common(Adapted& a, std::true_type)
{
CPP_assert(common_range<decltype(a)>);
}
// template<typename Adapted>
// void test_common(Adapted&, std::false_type)
// {}
template<typename Adapted>
void test_prev(Adapted& a, iterator_t<Adapted> const& it, std::true_type)
{
CPP_assert(bidirectional_range<decltype(a)>);
::check_equal(*ranges::prev(it, 3), views::iota(N - K - 2, N - 2));
}
template<typename Adapted>
void test_prev(Adapted&, iterator_t<Adapted> const&, std::false_type)
{}
template<typename Rng, bool>
struct size_compare_
{
iterator_t<Rng> iter1_;
iterator_t<Rng> iter2_;
range_difference_t<Rng> dist_;
};
template<typename Rng>
struct size_compare_<Rng, true>
{
iterator_t<Rng> iter1_;
range_difference_t<Rng> dist_;
};
template<typename Rng>
using size_compare =
size_compare_<Rng, random_access_range<Rng> || (bidirectional_range<Rng> && common_range<Rng>)>;
template<typename ToBase>
void test_finite(ToBase to_base)
{
auto v = to_base(views::iota(0,N));
using Base = decltype(v);
auto rng = v | views::sliding(K);
using Adapted = decltype(rng);
test_size(rng, meta::bool_<sized_range<Base>>{});
using IterTagOfBase =
meta::if_c<contiguous_iterator<iterator_t<Base>>,
std::random_access_iterator_tag,
iterator_tag_of<iterator_t<Base>>>;
CPP_assert(same_as<
IterTagOfBase,
iterator_tag_of<iterator_t<Adapted>>>);
auto it = ranges::begin(rng);
test_common(rng, meta::bool_<common_range<Base>>{});
for (auto i = 0; i <= N - K; ++i)
{
::check_equal(*it++, views::iota(i, i + K));
}
CHECK(it == ranges::end(rng));
test_prev(rng, it, meta::bool_<bidirectional_range<Base>>{});
if (!broken_ebo)
{
CHECK(sizeof(it) == sizeof(size_compare<Base>));
}
}
}
void bug_975()
{
std::vector<double> v{2.0, 2.0, 3.0, 1.0};
std::vector<int> i{1, 2, 1, 2};
std::vector<int> t{1, 1, 2, 2};
{
using namespace ranges;
auto vals = views::zip(v, i, t);
using T = std::tuple<double, int, int>;
auto g = vals | views::chunk_by(
[](T t1, T t2)
{
return std::get<2>(t1) == std::get<2>(t2);
}
);
auto windows = views::sliding(g, 2);
auto it = std::begin(windows);
(void)it;
}
}
int main()
{
test_finite(to<std::forward_list<int>>());
test_finite(to<std::list<int>>());
test_finite(to<std::vector<int>>());
test_finite(identity{});
{
// An infinite, cyclic range with cycle length == 1
auto rng = views::repeat(5) | views::sliding(K);
CPP_assert(random_access_range<decltype(rng)>);
auto it = rng.begin();
CPP_assert(random_access_iterator<decltype(it)>);
#if defined(__GNUC__) && !defined(__clang__) && \
((__GNUC__ == 6 && __GNUC_MINOR__ < 3) || __GNUC__ < 6)
// Avoid https://gcc.gnu.org/bugzilla/show_bug.cgi?id=78047
{
auto deref = *it;
auto i = deref.begin();
for (auto n = 0; n < K; ++n) {
RANGES_ENSURE(i != deref.end());
CHECK(*i == 5);
++i;
}
CHECK(i == deref.end());
}
auto it2 = next(it, 42);
CHECK(it != it2);
{
auto deref = *it;
auto i = deref.begin();
for (auto n = 0; n < K; ++n) {
RANGES_ENSURE(i != deref.end());
CHECK(*i == 5);
++i;
}
CHECK(i == deref.end());
}
#else
::check_equal(*it, views::repeat_n(5, K));
auto it2 = next(it, 42);
CHECK(it != it2);
::check_equal(*it2, views::repeat_n(5, K));
#endif
}
{
// An infinite, cyclic range with cycle length == K
auto rng = views::iota(0, K) | views::cycle | views::sliding(K);
CPP_assert(random_access_range<decltype(rng)>);
auto it = rng.begin();
CPP_assert(random_access_iterator<decltype(it)>);
for (auto i = 0; i < 42; ++i)
{
::check_equal(*it++, {0,1,2});
::check_equal(*it++, {1,2,0});
::check_equal(*it++, {2,0,1});
}
auto it2 = next(it, 42 * K);
::check_equal(*it2, {0,1,2});
}
{
// An infinite, cyclic range with cycle length > K
auto rng = views::iota(0,7) | views::cycle | views::sliding(K);
//[0,1,2],[1,2,3],[2,3,4],[3,4,5],[4,5,6],[5,6,0],[6,0,1],...
auto it = rng.begin();
CPP_assert(random_access_iterator<decltype(it)>);
::check_equal(*it, {0,1,2});
::check_equal(*next(it, 2), {2,3,4});
::check_equal(*next(it,16), {2,3,4});
::check_equal(*next(it,27), {6,0,1});
}
return ::test_result();
}
|
0 | repos/range-v3/test | repos/range-v3/test/view/adjacent_remove_if.cpp | // Range v3 library
//
// Copyright Eric Niebler 2014-present
//
// Use, modification and distribution is subject to the
// Boost Software License, Version 1.0. (See accompanying
// file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt)
//
// Project home: https://github.com/ericniebler/range-v3
#include <vector>
#include <iterator>
#include <functional>
#include <range/v3/core.hpp>
#include <range/v3/view/adjacent_remove_if.hpp>
#include <range/v3/view/iota.hpp>
#include <range/v3/view/counted.hpp>
#include <range/v3/utility/copy.hpp>
#include <range/v3/algorithm/copy.hpp>
#include <range/v3/iterator/operations.hpp>
#include <range/v3/iterator/insert_iterators.hpp>
#include "../simple_test.hpp"
#include "../test_utils.hpp"
#include "../test_iterators.hpp"
int main()
{
using namespace ranges;
int const rgi[] = {1, 1, 1, 2, 3, 4, 4};
std::vector<int> out;
{
auto rng = rgi | views::adjacent_remove_if(std::equal_to<int>{});
has_type<int const &>(*begin(rng));
CPP_assert(view_<decltype(rng)>);
CPP_assert(common_range<decltype(rng)>);
CPP_assert(!sized_range<decltype(rng)>);
CPP_assert(bidirectional_iterator<decltype(begin(rng))>);
CPP_assert(!random_access_iterator<decltype(begin(rng))>);
CPP_assert(output_iterator<decltype(ranges::back_inserter(out)), int>);
CPP_assert(!equality_comparable<decltype(ranges::back_inserter(out))>);
copy(rng, ranges::back_inserter(out));
::check_equal(out, {1, 2, 3, 4});
}
{
auto rng2 = views::counted(rgi, 7)
| views::adjacent_remove_if([&](int i, int j) { return i == j; });
has_type<int const &>(*begin(rng2));
CPP_assert(view_<decltype(rng2)>);
CPP_assert(forward_range<decltype(rng2)>);
CPP_assert(common_range<decltype(rng2)>);
CPP_assert(!sized_range<decltype(rng2)>);
CPP_assert(bidirectional_iterator<decltype(begin(rng2))>);
CPP_assert(!random_access_iterator<decltype(begin(rng2))>);
::check_equal(rng2, {1, 2, 3, 4});
}
{
auto rng3 = views::counted(ForwardIterator<int const*>(rgi), 7)
| views::adjacent_remove_if(std::equal_to<int>{});
has_type<int const &>(*begin(rng3));
CPP_assert(view_<decltype(rng3)>);
CPP_assert(forward_range<decltype(rng3)>);
CPP_assert(!common_range<decltype(rng3)>);
CPP_assert(!sized_range<decltype(rng3)>);
CPP_assert(forward_iterator<decltype(begin(rng3))>);
CPP_assert(!bidirectional_iterator<decltype(begin(rng3))>);
::check_equal(rng3, {1, 2, 3, 4});
}
{
auto rng4 = views::counted(ForwardIterator<int const*>(rgi), 7)
| views::adjacent_remove_if([](int,int){return true;});
has_type<int const &>(*begin(rng4));
CHECK(*begin(rng4) == 4);
CPP_assert(view_<decltype(rng4)>);
CPP_assert(forward_range<decltype(rng4)>);
CPP_assert(!common_range<decltype(rng4)>);
CPP_assert(!sized_range<decltype(rng4)>);
CPP_assert(forward_iterator<decltype(begin(rng4))>);
CPP_assert(!bidirectional_iterator<decltype(begin(rng4))>);
::check_equal(rng4, {4});
}
{
auto is_odd_then_even = [](int i, int j){return 1==i%2 && 0 == j%2;};
auto rng5 = views::iota(0, 11) | views::adjacent_remove_if(is_odd_then_even);
has_type<int>(*begin(rng5));
CPP_assert(view_<decltype(rng5)>);
CPP_assert(forward_range<decltype(rng5)>);
CPP_assert(common_range<decltype(rng5)>);
CPP_assert(!sized_range<decltype(rng5)>);
CPP_assert(bidirectional_iterator<decltype(begin(rng5))>);
CPP_assert(!random_access_iterator<decltype(begin(rng5))>);
::check_equal(rng5, {0,2,4,6,8,10});
}
{
// Verify that forward and backward traversal both select the same elements.
auto rng = views::adjacent_remove_if(rgi, std::equal_to<int>{});
std::vector<int const*> pointers;
for(auto& i : rng)
pointers.push_back(&i);
auto pos = ranges::end(rng);
for(auto i = pointers.size(); i != 0;)
{
CHECK(pos != ranges::begin(rng));
CHECK(&*--pos == pointers[--i]);
}
CHECK(pos == ranges::begin(rng));
}
return test_result();
}
|
0 | repos/range-v3/test | repos/range-v3/test/view/concat.cpp | // Range v3 library
//
// Copyright Eric Niebler 2014-present
//
// Use, modification and distribution is subject to the
// Boost Software License, Version 1.0. (See accompanying
// file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt)
//
// Project home: https://github.com/ericniebler/range-v3
#include <array>
#include <vector>
#include <range/v3/core.hpp>
#include <range/v3/view/concat.hpp>
#include <range/v3/view/generate.hpp>
#include <range/v3/view/reverse.hpp>
#include <range/v3/view/remove_if.hpp>
#include <range/v3/view/take_while.hpp>
#include <range/v3/algorithm/equal.hpp>
#include <range/v3/utility/copy.hpp>
#include "../simple_test.hpp"
#include "../test_utils.hpp"
int main()
{
using namespace ranges;
std::vector<std::string> his_face{"this", "is", "his", "face"};
std::vector<std::string> another_mess{"another", "fine", "mess"};
auto joined = views::concat(his_face, another_mess);
CPP_assert(view_<decltype(joined)>);
CPP_assert(random_access_range<decltype(joined)>);
static_assert(std::is_same<range_reference_t<decltype(joined)>, std::string &>::value, "");
CHECK(joined.size() == 7u);
CHECK((joined.end() - joined.begin()) == 7);
::check_equal(joined | views::reverse, {"mess", "fine", "another", "face", "his", "is", "this"});
auto revjoin = joined | views::reverse;
CHECK((revjoin.end() - revjoin.begin()) == 7);
auto first = joined.begin();
CHECK(*(first+0) == "this");
CHECK(*(first+1) == "is");
CHECK(*(first+2) == "his");
CHECK(*(first+3) == "face");
CHECK(*(first+4) == "another");
CHECK(*(first+5) == "fine");
CHECK(*(first+6) == "mess");
CHECK(*(first) == "this");
CHECK(*(first+=1) == "is");
CHECK(*(first+=1) == "his");
CHECK(*(first+=1) == "face");
CHECK(*(first+=1) == "another");
CHECK(*(first+=1) == "fine");
CHECK(*(first+=1) == "mess");
auto last = joined.end();
CHECK(*(last-1) == "mess");
CHECK(*(last-2) == "fine");
CHECK(*(last-3) == "another");
CHECK(*(last-4) == "face");
CHECK(*(last-5) == "his");
CHECK(*(last-6) == "is");
CHECK(*(last-7) == "this");
CHECK(*(last-=1) == "mess");
CHECK(*(last-=1) == "fine");
CHECK(*(last-=1) == "another");
CHECK(*(last-=1) == "face");
CHECK(*(last-=1) == "his");
CHECK(*(last-=1) == "is");
CHECK(*(last-=1) == "this");
{
const std::array<int, 3> a{{0, 1, 2}};
const std::array<int, 2> b{{3, 4}};
check_equal(views::concat(a, b), {0, 1, 2, 3, 4});
auto odd = [](int i) { return i % 2 != 0; };
auto even_filter = ranges::views::remove_if(odd);
auto f_rng0 = a | even_filter;
auto f_rng1 = b | even_filter;
check_equal(views::concat(f_rng0, f_rng1), {0, 2, 4});
}
// Regression test for http://github.com/ericniebler/range-v3/issues/395.
{
int i = 0;
auto rng = ranges::views::concat(ranges::views::generate([&]{ return i++; }))
| ranges::views::take_while([](int j){ return j < 30; });
CHECK(ranges::distance(ranges::begin(rng), ranges::end(rng)) == 30);
}
{
int const rgi[] = {0,1,2,3};
auto dv = [&]{ return debug_input_view<int const>{rgi}; };
auto rng = views::concat(dv(), dv(), dv());
::check_equal(rng, {0,1,2,3,0,1,2,3,0,1,2,3});
}
return test_result();
}
|
0 | repos/range-v3/test | repos/range-v3/test/view/remove_if.cpp | // Range v3 library
//
// Copyright Eric Niebler 2014-present
//
// Use, modification and distribution is subject to the
// Boost Software License, Version 1.0. (See accompanying
// file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt)
//
// Project home: https://github.com/ericniebler/range-v3
#include <array>
#include <vector>
#include <iterator>
#include <functional>
#include <range/v3/core.hpp>
#include <range/v3/functional/not_fn.hpp>
#include <range/v3/view/remove_if.hpp>
#include <range/v3/view/filter.hpp>
#include <range/v3/view/counted.hpp>
#include <range/v3/view/concat.hpp>
#include <range/v3/view/reverse.hpp>
#include <range/v3/view/subrange.hpp>
#include <range/v3/utility/copy.hpp>
#include "../simple_test.hpp"
#include "../test_utils.hpp"
#include "../test_iterators.hpp"
struct is_odd
{
constexpr bool operator()(int i) const
{
return (i % 2) == 1;
}
};
struct is_even
{
constexpr bool operator()(int i) const
{
return (i % 2) == 0;
}
};
struct my_data
{
int i;
};
constexpr bool operator==(my_data left, my_data right)
{
return left.i == right.i;
}
int main()
{
using namespace ranges;
int rgi[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
{
auto rng = rgi | views::remove_if(is_even());
has_type<int &>(*begin(rgi));
has_type<int &>(*begin(rng));
CPP_assert(view_<decltype(rng)>);
CPP_assert(common_range<decltype(rng)>);
CPP_assert(!sized_range<decltype(rng)>);
CPP_assert(bidirectional_range<decltype(rng)>);
CPP_assert(!random_access_range<decltype(rng)>);
::check_equal(rng, {1,3,5,7,9});
::check_equal(rng | views::reverse, {9,7,5,3,1});
auto tmp = rng | views::reverse;
CHECK(&*begin(tmp) == &rgi[8]);
}
{
auto rng2 = views::counted(rgi, 10) | views::remove_if(not_fn(is_odd()));
has_type<int &>(*begin(rng2));
CPP_assert(view_<decltype(rng2)>);
CPP_assert(bidirectional_range<decltype(rng2)>);
CPP_assert(!random_access_range<decltype(rng2)>);
CPP_assert(common_range<decltype(rng2)>);
CPP_assert(!sized_range<decltype(rng2)>);
::check_equal(rng2, {1,3,5,7,9});
CHECK(&*begin(rng2) == &rgi[0]);
}
{
auto rng3 = views::counted(BidirectionalIterator<int*>{rgi}, 10) | views::remove_if(is_even());
has_type<int &>(*begin(rng3));
CPP_assert(view_<decltype(rng3)>);
CPP_assert(bidirectional_range<decltype(rng3)>);
CPP_assert(!random_access_range<decltype(rng3)>);
CPP_assert(!common_range<decltype(rng3)>);
CPP_assert(!sized_range<decltype(rng3)>);
::check_equal(rng3, {1,3,5,7,9});
CHECK(&*begin(rng3) == &rgi[0]);
CHECK(&*prev(next(begin(rng3))) == &rgi[0]);
}
{
// Test remove_if with a mutable lambda
bool flag = true;
auto mutable_rng = views::remove_if(rgi, [flag](int) mutable { return flag = !flag;});
::check_equal(mutable_rng, {1,3,5,7,9});
CPP_assert(view_<decltype(mutable_rng)>);
CPP_assert(!view_<decltype(mutable_rng) const>);
}
{
const std::array<int, 3> a{{0, 1, 2}};
const std::vector<int> b{3, 4, 5, 6};
auto r = views::concat(a, b);
auto f = [](int i) { return i != 1 && i != 5; };
auto r2 = r | views::remove_if(f);
::check_equal(r2, {1,5});
}
{
auto rng = debug_input_view<int const>{rgi} | views::remove_if(is_even{});
::check_equal(rng, {1,3,5,7,9});
}
{
// Defend against regression of #793
int const some_ints[] = {1, 2, 3};
auto a = some_ints | ranges::views::remove_if([](int val) { return val > 0; });
CHECK(a.empty());
}
{
// with projection
const std::vector<my_data> some_my_datas{{1}, {2}, {3}, {4}};
{
// views::remove_if without pipe
auto rng = ranges::views::remove_if(some_my_datas, is_even(), &my_data::i);
::check_equal(rng, std::vector<my_data>{{1}, {3}});
}
{
// views::remove_if with pipe
auto rng = some_my_datas | ranges::views::remove_if(is_even(), &my_data::i);
::check_equal(rng, std::vector<my_data>{{1}, {3}});
}
{
// views::filter without pipe
auto rng = ranges::views::filter(some_my_datas, is_even(), &my_data::i);
::check_equal(rng, std::vector<my_data>{{2}, {4}});
}
{
// views::filter with pipe
auto rng = some_my_datas | ranges::views::filter(is_even(), &my_data::i);
::check_equal(rng, std::vector<my_data>{{2}, {4}});
}
}
// test constexpr binding
{
using namespace ranges;
constexpr std::array<int, 4> is = {{1,2,3,4}};
constexpr auto filter = views::remove_if(is_even()) | views::remove_if(is_odd());
auto rng = is | filter;
CHECK(rng.empty());
}
{
const std::vector<my_data> some_my_datas{{1}, {2}, {3}, {4}};
constexpr auto filter = views::remove_if(is_even(), &my_data::i) | views::remove_if(is_odd(), &my_data::i);
auto rng = some_my_datas | filter;
CHECK(rng.empty());
}
// test issue #1424 <https://github.com/ericniebler/range-v3/issues/1424>
{
std::vector<int> v{1, 2, 3, 4};
auto rng = views::filter(v, is_odd());
::check_equal(rng, {1, 3});
}
return test_result();
}
|
0 | repos/range-v3/test | repos/range-v3/test/view/partial_sum_depr.cpp | // Range v3 library
//
// Copyright Eric Niebler 2014-present
//
// Use, modification and distribution is subject to the
// Boost Software License, Version 1.0. (See accompanying
// file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt)
//
// Project home: https://github.com/ericniebler/range-v3
#include <range/v3/core.hpp>
RANGES_DIAGNOSTIC_IGNORE_DEPRECATED_DECLARATIONS
#include <range/v3/view/partial_sum.hpp>
#include "../simple_test.hpp"
#include "../test_utils.hpp"
int main()
{
static int const some_ints[] = {0,1,2,3,4};
auto rng = some_ints | ranges::views::partial_sum();
::check_equal(rng, {0,1,3,6,10});
return ::test_result();
}
|
0 | repos/range-v3/test | repos/range-v3/test/view/drop.cpp | // Range v3 library
//
// Copyright Eric Niebler 2014-present
//
// Use, modification and distribution is subject to the
// Boost Software License, Version 1.0. (See accompanying
// file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt)
//
// Project home: https://github.com/ericniebler/range-v3
#include <list>
#include <vector>
#include <range/v3/core.hpp>
#include <range/v3/view/chunk.hpp>
#include <range/v3/view/drop.hpp>
#include <range/v3/view/iota.hpp>
#include <range/v3/view/join.hpp>
#include <range/v3/view/reverse.hpp>
#include <range/v3/view/take.hpp>
#include <range/v3/view/transform.hpp>
#include <range/v3/utility/copy.hpp>
#include "../simple_test.hpp"
#include "../test_utils.hpp"
int main()
{
using namespace ranges;
int rgi[] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
{
auto rng0 = rgi | views::drop(6);
has_type<int &>(*begin(rng0));
CPP_assert(view_<decltype(rng0)>);
CPP_assert(common_range<decltype(rng0)>);
CPP_assert(sized_range<decltype(rng0)>);
CPP_assert(random_access_iterator<decltype(begin(rng0))>);
::check_equal(rng0, {6, 7, 8, 9, 10});
CHECK(size(rng0) == 5u);
auto rng1 = rng0 | views::reverse;
has_type<int &>(*begin(rng1));
CPP_assert(view_<decltype(rng1)>);
CPP_assert(common_range<decltype(rng1)>);
CPP_assert(sized_range<decltype(rng1)>);
CPP_assert(random_access_iterator<decltype(begin(rng1))>);
::check_equal(rng1, {10, 9, 8, 7, 6});
}
{
std::vector<int> v{0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
auto rng2 = v | views::drop(6) | views::reverse;
has_type<int &>(*begin(rng2));
CPP_assert(view_<decltype(rng2)>);
CPP_assert(common_range<decltype(rng2)>);
CPP_assert(sized_range<decltype(rng2)>);
CPP_assert(random_access_iterator<decltype(begin(rng2))>);
::check_equal(rng2, {10, 9, 8, 7, 6});
}
{
std::list<int> l{0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
auto rng3 = l | views::drop(6);
has_type<int &>(*begin(rng3));
CPP_assert(view_<decltype(rng3)>);
CPP_assert(common_range<decltype(rng3)>);
CPP_assert(sized_range<decltype(rng3)>);
CPP_assert(bidirectional_iterator<decltype(begin(rng3))>);
CPP_assert(!random_access_iterator<decltype(begin(rng3))>);
::check_equal(rng3, {6, 7, 8, 9, 10});
}
{
auto rng4 = views::iota(10) | views::drop(10);
CPP_assert(view_<decltype(rng4)>);
CPP_assert(!common_range<decltype(rng4)>);
CPP_assert(!sized_range<decltype(rng4)>);
static_assert(ranges::is_infinite<decltype(rng4)>::value, "");
auto b = ranges::begin(rng4);
CHECK(*b == 20);
CHECK(*(b+1) == 21);
}
{
auto rng5 = views::iota(10) | views::drop(10) | views::take(10) | views::reverse;
CPP_assert(view_<decltype(rng5)>);
CPP_assert(common_range<decltype(rng5)>);
CPP_assert(sized_range<decltype(rng5)>);
static_assert(!ranges::is_infinite<decltype(rng5)>::value, "");
::check_equal(rng5, {29, 28, 27, 26, 25, 24, 23, 22, 21, 20});
CHECK(size(rng5) == 10u);
}
{
int some_ints[] = {0,1,2};
auto rng = make_subrange(some_ints + 0, some_ints + 1);
auto rng2 = views::drop(rng, 2);
CHECK(begin(rng2) == some_ints + 1);
CHECK(size(rng2) == 0u);
}
{
// Regression test for https://github.com/ericniebler/range-v3/issues/413
auto skips = [](std::vector<int> xs) {
return views::ints(0, (int)xs.size())
| views::transform([&](int n) {
return xs | views::chunk(n + 1)
| views::transform(views::drop(n))
| views::join;
})
| to<std::vector<std::vector<int>>>();
};
auto skipped = skips({1,2,3,4,5,6,7,8});
CHECK(skipped.size() == 8u);
if(skipped.size() >= 8u)
{
::check_equal(skipped[0], {1,2,3,4,5,6,7,8});
::check_equal(skipped[1], {2,4,6,8});
::check_equal(skipped[2], {3,6});
::check_equal(skipped[3], {4,8});
::check_equal(skipped[4], {5});
::check_equal(skipped[5], {6});
::check_equal(skipped[6], {7});
::check_equal(skipped[7], {8});
}
}
{
static int const some_ints[] = {0,1,2,3};
auto rng = debug_input_view<int const>{some_ints} | views::drop(2);
using R = decltype(rng);
CPP_assert(input_range<R> && view_<R>);
CPP_assert(!forward_range<R>);
CPP_assert(same_as<int const&, range_reference_t<R>>);
::check_equal(rng, {2,3});
}
{
// regression test for #728
auto rng1 = views::iota(1) | views::chunk(6) | views::take(3);
int i = 2;
RANGES_FOR(auto o1, rng1)
{
auto rng2 = o1 | views::drop(1);
::check_equal(rng2, {i, i+1, i+2, i+3, i+4});
i += 6;
}
}
{
// regression test for #813
static int const some_ints[] = {0,1,2,3};
auto rng = some_ints | views::drop(10);
CHECK(empty(rng));
}
return test_result();
}
|
0 | repos/range-v3/test | repos/range-v3/test/view/facade.cpp | // Range v3 library
//
// Copyright Eric Niebler 2014-present
//
// Use, modification and distribution is subject to the
// Boost Software License, Version 1.0. (See accompanying
// file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt)
//
// Project home: https://github.com/ericniebler/range-v3
#include <vector>
#include <range/v3/core.hpp>
#include <range/v3/utility/copy.hpp>
#include "../simple_test.hpp"
#include "../test_utils.hpp"
struct MyRange
: ranges::view_facade<MyRange>
{
private:
friend ranges::range_access;
std::vector<int> ints_;
struct cursor
{
private:
std::vector<int>::const_iterator iter;
public:
using contiguous = std::true_type;
cursor() = default;
cursor(std::vector<int>::const_iterator it)
: iter(it)
{}
int const & read() const
{
return *iter;
}
bool equal(cursor const &that) const
{
return iter == that.iter;
}
void next()
{
++iter;
}
void prev()
{
--iter;
}
std::ptrdiff_t distance_to(cursor const &that) const
{
return that.iter - iter;
}
void advance(std::ptrdiff_t n)
{
iter += n;
}
};
cursor begin_cursor() const
{
return {ints_.begin()};
}
cursor end_cursor() const
{
return {ints_.end()};
}
public:
MyRange()
: ints_{1, 2, 3, 4, 5, 6, 7}
{}
};
int main()
{
using namespace ranges;
{
auto r = MyRange{};
CPP_assert(view_<decltype(r)>);
CPP_assert(common_range<decltype(r)>);
CPP_assert(sized_range<decltype(r)>);
CPP_assert(contiguous_range<decltype(r)>);
::check_equal(r, {1, 2, 3, 4, 5, 6, 7});
CHECK(7u == r.size());
CHECK(1 == r.front());
CHECK(7 == r.back());
CHECK(&*r.begin() == r.data());
CHECK(r[1] == 2);
CHECK(r[5] == 6);
}
{
const auto r = MyRange{};
CPP_assert(common_range<decltype(r)>);
CPP_assert(sized_range<decltype(r)>);
CPP_assert(random_access_range<decltype(r)>);
CPP_assert(contiguous_range<decltype(r)>);
::check_equal(r, {1, 2, 3, 4, 5, 6, 7});
CHECK(7u == r.size());
CHECK(1 == r.front());
CHECK(7 == r.back());
CHECK(&*r.begin() == r.data());
CHECK(r[1] == 2);
CHECK(r[5] == 6);
}
return test_result();
}
|
0 | repos/range-v3/test | repos/range-v3/test/view/sample.cpp | #include <range/v3/view/sample.hpp>
#include <range/v3/algorithm/equal.hpp>
#include <numeric>
#include <vector>
#include <random>
#include "../simple_test.hpp"
#include "../test_utils.hpp"
using namespace ranges;
int main ()
{
std::mt19937 engine;
std::vector<int> pop(100);
std::iota(std::begin(pop), std::end(pop), 0);
{
constexpr int N = 32;
std::array<int, N> tmp;
auto rng = pop | views::sample(N, engine);
using Rng = decltype(rng);
CPP_assert(input_range<Rng> && view_<Rng>);
CPP_assert(!forward_range<Rng>);
ranges::copy(rng, tmp.begin());
rng = pop | views::sample(N, engine);
CHECK(!ranges::equal(rng, tmp));
engine = decltype(engine){};
rng = pop | views::sample(N, engine);
CHECK(ranges::equal(rng, tmp));
}
{
int const some_ints[] = {0,1,2,3,4,5,6,7,8};
auto rng = debug_input_view<int const>{some_ints} | views::sample(4, engine);
using Rng = decltype(rng);
CPP_assert(input_range<Rng> && view_<Rng>);
CPP_assert(!forward_range<Rng>);
CHECK(ranges::distance(rng) == 4);
}
return ::test_result();
}
|
0 | repos/range-v3/test | repos/range-v3/test/view/chunk.cpp | // Range v3 library
//
// Copyright Eric Niebler 2014-present
//
// Use, modification and distribution is subject to the
// Boost Software License, Version 1.0. (See accompanying
// file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt)
//
// Project home: https://github.com/ericniebler/range-v3
#include <iostream>
#include <forward_list>
#include <list>
#include <vector>
#include <range/v3/range/conversion.hpp>
#include <range/v3/view/chunk.hpp>
#include <range/v3/view/cycle.hpp>
#include <range/v3/view/filter.hpp>
#include <range/v3/view/iota.hpp>
#include <range/v3/view/join.hpp>
#include <range/v3/view/move.hpp>
#include <range/v3/view/repeat.hpp>
#include <range/v3/view/reverse.hpp>
#include "../simple_test.hpp"
#include "../test_iterators.hpp"
#include "../test_utils.hpp"
using namespace ranges;
namespace
{
void test_input_ranges()
{
int const ints[] = {0,1,2,3,4};
static constexpr auto N = ranges::size(ints);
static constexpr auto K = 2;
auto make_range = [&]{ return debug_input_view<int const>{ints} | views::chunk(K); };
auto rng = make_range();
using Rng = decltype(rng);
CPP_assert(input_range<Rng>);
CPP_assert(view_<Rng>);
CPP_assert(!forward_range<Rng>);
CPP_assert(sized_range<Rng>);
CHECK(ranges::size(rng) == (N + K - 1) / K);
CPP_assert(sized_sentinel_for<sentinel_t<Rng>, iterator_t<Rng>>);
CHECK((ranges::end(rng) - ranges::begin(rng)) == int((N + K - 1) / K));
rng = make_range();
auto i = ranges::begin(rng);
auto e = ranges::end(rng);
CHECK(i != e);
if (i == e) return;
{
auto r = *i;
CHECK(ranges::size(r) == 2u);
auto ii = ranges::begin(r);
auto ee = ranges::end(r);
CHECK(ii != ee);
if (ii == ee) return;
CHECK((ee - ii) == 2);
CHECK(*ii == 0);
CHECK(++ii != ee);
if (ii == ee) return;
CHECK((ee - ii) == 1);
CHECK(*ii == 1);
CHECK(++ii == ee);
CHECK((ee - ii) == 0);
}
CHECK(++i != e);
if (i == e) return;
::check_equal(*i, {2,3});
CHECK(++i != e);
if (i != e)
{
::check_equal(*i, {4});
CHECK(++i == e);
}
}
}
int main()
{
{
auto v = views::iota(0,11) | to<std::vector>();
auto rng1 = v | views::chunk(3);
CPP_assert(random_access_range<decltype(rng1)>);
CPP_assert(sized_range<decltype(rng1)>);
auto it1 = ranges::begin(rng1);
::check_equal(*it1++, {0,1,2});
::check_equal(*it1++, {3,4,5});
::check_equal(*it1++, {6,7,8});
::check_equal(*it1++, {9,10});
CHECK(it1 == ranges::end(rng1));
::check_equal(*ranges::next(it1, -3), {3,4,5});
CHECK(size(rng1), 4u);
CHECK(sizeof(rng1.begin()) == sizeof(v.begin()) * 2 + sizeof(std::ptrdiff_t) * 2);
}
{
auto l = views::iota(0,11) | to<std::forward_list>();
auto rng2 = l | views::chunk(3);
CPP_assert(forward_range<decltype(rng2)>);
CPP_assert(!bidirectional_range<decltype(rng2)>);
CPP_assert(!sized_range<decltype(rng2)>);
auto it2 = ranges::begin(rng2);
::check_equal(*it2++, {0,1,2});
::check_equal(*it2++, {3,4,5});
::check_equal(*it2++, {6,7,8});
::check_equal(*it2++, {9,10});
CHECK(it2 == ranges::end(rng2));
CHECK(sizeof(rng2.begin()) == sizeof(l.begin()) * 2 + sizeof(std::ptrdiff_t));
}
{
// An infinite, cyclic range with cycle length == 1
auto fives = views::repeat(5);
CPP_assert(random_access_range<decltype(fives)>);
auto rng = fives | views::chunk(3);
CPP_assert(random_access_range<decltype(rng)>);
auto it = rng.begin();
auto it2 = next(it,3);
CHECK((it2 - it) == 3);
::check_equal(*it, {5,5,5});
::check_equal(*it2, {5,5,5});
}
{
// An infinite, cyclic range with cycle length == 3
int const ints[] = {0,1,2};
auto cyc = ints | views::cycle;
//[0,1],[2,0],[1,2],[0,1],[2,0],[1,2],
auto rng = cyc | views::chunk(2);
CPP_assert(random_access_range<decltype(rng)>);
auto it = rng.begin();
auto it2 = next(it,2);
::check_equal(*it, {0,1});
::check_equal(*it2, {1,2});
CHECK((it - it) == 0);
CHECK((next(it,1) - it) == 1);
CHECK((next(it,2) - it) == 2);
CHECK((next(it,3) - it) == 3);
CHECK((next(it,4) - it) == 4);
CHECK((next(it,5) - it) == 5);
CHECK((next(it,6) - it) == 6);
CHECK((next(it,7) - it) == 7 );
}
{
// An infinite, cyclic range with cycle length == 3
int const ints[] = {0,1,2};
auto cyc = ints | views::cycle;
//[0,1,2,0],[1,2,0,1],[2,0,1,2],...
auto rng = cyc | views::chunk(4);
CPP_assert(random_access_range<decltype(rng)>);
auto it = rng.begin();
auto it2 = next(it,2);
::check_equal(*it, {0,1,2,0});
::check_equal(*it2, {2,0,1,2});
// Strange, but not wrong necessarily:
CHECK((it - it) == 0);
CHECK((next(it,1) - it) == 1);
CHECK((next(it,2) - it) == 2);
CHECK((next(it,3) - it) == 3);
CHECK((next(it,4) - it) == 4);
CHECK((next(it,5) - it) == 5);
CHECK((next(it,6) - it) == 6);
CHECK((next(it,7) - it) == 7);
}
{
// An infinite, cyclic range with cycle length == 10
int const ints[] = {0,1,2,3,4,5,6,7,8,9};
auto cyc = ints | views::cycle;
auto rng = cyc | views::chunk(3);
CPP_assert(random_access_range<decltype(rng)>);
//[0,1,2],[3,4,5],[6,7,8],[9,0,1],[2,3,4],...
auto it = rng.begin();
auto it2 = next(it,2);
::check_equal(*it, {0,1,2});
::check_equal(*it2, {6,7,8});
// Strange, but not wrong necessarily:
CHECK((it - it) == 0);
CHECK((next(it,1) - it) == 1);
CHECK((next(it,2) - it) == 2);
CHECK((next(it,3) - it) == 3);
CHECK((next(it,4) - it) == 4);
CHECK((next(it,5) - it) == 5);
CHECK((next(it,6) - it) == 6);
CHECK((next(it,7) - it) == 7);
CHECK((next(it,8) - it) == 8);
CHECK((next(it,9) - it) == 9);
CHECK((next(it,10) - it) == 10);
CHECK((next(it,11) - it) == 11);
CHECK((next(it,12) - it) == 12);
CHECK((next(it,13) - it) == 13);
}
test_input_ranges();
{
// Regression test for #567
std::vector<std::vector<int>> vec{{1, 2, 3}, {4, 5, 6}};
auto rng = vec | views::join | views::chunk(2);
CPP_assert(input_range<decltype(rng)>);
CPP_assert(input_range<range_reference_t<decltype(rng)>>);
int const expected[][2] = {{1, 2}, {3, 4}, {5, 6}};
::check_equal(rng, expected);
}
{
// Regression test for not-exactly #567 (https://github.com/ericniebler/range-v3/issues/567#issuecomment-315148392)
int some_ints[] = {0,1,2,3};
int const expected[][2] = {{0, 1}, {2, 3}};
auto rng = views::all(some_ints);
::check_equal(rng | views::chunk(2), expected);
}
{
// Regression test for https://stackoverflow.com/questions/49210190
auto rng = views::closed_iota(1,25)
| views::filter([](int item){ return item % 10 != 0; })
| views::chunk(10);
auto it = ranges::begin(rng);
auto last = ranges::end(rng);
CHECK(it != last);
::check_equal(*it, {1,2,3,4,5,6,7,8,9,11});
CHECK(++it != last);
::check_equal(*it, {12,13,14,15,16,17,18,19,21,22});
CHECK(++it != last);
::check_equal(*it, {23,24,25});
CHECK(++it == last);
}
return ::test_result();
}
|
0 | repos/range-v3/test | repos/range-v3/test/view/delimit.cpp | // Range v3 library
//
// Copyright Eric Niebler 2014-present
//
// Use, modification and distribution is subject to the
// Boost Software License, Version 1.0. (See accompanying
// file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt)
//
// Project home: https://github.com/ericniebler/range-v3
#include <vector>
#include <range/v3/core.hpp>
#include <range/v3/view/iota.hpp>
#include <range/v3/view/delimit.hpp>
#include <range/v3/algorithm/for_each.hpp>
#include <range/v3/utility/copy.hpp>
#include "../simple_test.hpp"
#include "../test_utils.hpp"
int main()
{
using namespace ranges;
auto rng0 = views::iota(10) | views::delimit(25);
::check_equal(rng0, {10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24});
CPP_assert(view_<decltype(rng0)>);
CPP_assert(!common_range<decltype(rng0)>);
CPP_assert(random_access_iterator<decltype(rng0.begin())>);
CPP_assert(view_<delimit_view<views::all_t<std::vector<int> &>, int>>);
CPP_assert(random_access_range<delimit_view<views::all_t<std::vector<int> &>, int>>);
std::vector<int> vi{0, 1, 2, 3, 4, 5, 6, 7, 8, 9};
auto rng1 = vi | views::delimit(50);
::check_equal(rng1, {0, 1, 2, 3, 4, 5, 6, 7, 8, 9});
auto rng2 = views::delimit(vi.begin(), 8);
::check_equal(rng2, {0, 1, 2, 3, 4, 5, 6, 7});
{
int const some_ints[] = {1,2,3,0,4,5,6};
auto rng = debug_input_view<const int>{some_ints} | views::delimit(0);
::check_equal(rng, {1,2,3});
}
{
int const some_ints[] = {1,2,3};
auto rng = views::delimit(some_ints, 0);
::check_equal(rng, {1,2,3});
}
return test_result();
}
|
0 | repos/range-v3/test | repos/range-v3/test/view/set_symmetric_difference.cpp | // Range v3 library
//
// Copyright Eric Niebler 2014-present
// Copyright Tomislav Ivek 2015-2016
//
// Use, modification and distribution is subject to the
// Boost Software License, Version 1.0. (See accompanying
// file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt)
//
// Project home: https://github.com/ericniebler/range-v3
#include <vector>
#include <sstream>
#include <range/v3/core.hpp>
#include <range/v3/range_for.hpp>
#include <range/v3/algorithm/set_algorithm.hpp>
#include <range/v3/algorithm/move.hpp>
#include <range/v3/utility/common_type.hpp>
#include <range/v3/iterator/operations.hpp>
#include <range/v3/iterator/insert_iterators.hpp>
#include <range/v3/iterator/move_iterators.hpp>
#include <range/v3/functional/identity.hpp>
#include <range/v3/view/all.hpp>
#include <range/v3/view/const.hpp>
#include <range/v3/view/drop_while.hpp>
#include <range/v3/view/empty.hpp>
#include <range/v3/view/iota.hpp>
#include <range/v3/view/reverse.hpp>
#include <range/v3/view/set_algorithm.hpp>
#include <range/v3/view/stride.hpp>
#include <range/v3/view/take.hpp>
#include <range/v3/view/transform.hpp>
#include <range/v3/view/zip.hpp>
#include <range/v3/utility/copy.hpp>
#include "../simple_test.hpp"
#include "../test_utils.hpp"
int main()
{
using namespace ranges;
int i1_finite[] = {1, 2, 2, 3, 3, 3, 4, 4, 4, 4};
int i2_finite[] = { -3, 2, 4, 4, 6, 9};
auto i1_infinite = views::ints | views::stride(3);
auto i2_infinite = views::ints | views::transform([](int x)
{
return x * x;
});
// symmetric difference between two finite ranges/sets
{
auto res = views::set_symmetric_difference(i1_finite, i2_finite);
CPP_assert(view_<decltype(res)>);
CPP_assert(forward_range<decltype(res)>);
CPP_assert(!random_access_range<decltype(res)>);
CPP_assert(!common_range<decltype(res)>);
using R = decltype(res);
CPP_assert(same_as<range_value_t<R>, int>);
CPP_assert(same_as<range_reference_t<R>, int&>);
CPP_assert(same_as<decltype(iter_move(begin(res))), int&&>);
static_assert(range_cardinality<R>::value == ranges::finite, "Cardinality of symmetric difference of finite ranges should be finite!");
::check_equal(res, {-3, 1, 2, 3, 3, 3, 4, 4, 6, 9});
// check if the final result agrees with the greedy algorithm
std::vector<int> greedy_sd;
set_symmetric_difference(i1_finite, i2_finite, back_inserter(greedy_sd));
::check_equal(res, greedy_sd);
auto it = begin(res);
CHECK(&*it == &*(begin(i2_finite)));
++it;
CHECK(&*it == &*(begin(i1_finite)));
}
// symmetric difference between two infinite ranges
{
auto res = views::set_symmetric_difference(i1_infinite, i2_infinite);
CPP_assert(view_<decltype(res)>);
CPP_assert(forward_range<decltype(res)>);
CPP_assert(!random_access_range<decltype(res)>);
CPP_assert(!common_range<decltype(res)>);
using R = decltype(res);
CPP_assert(same_as<range_value_t<R>,
common_type_t<range_value_t<decltype(i1_infinite)>,
range_value_t<decltype(i2_infinite)>>>);
CPP_assert(same_as<range_reference_t<R>,
common_reference_t<range_reference_t<decltype(i1_infinite)>,
range_reference_t<decltype(i2_infinite)>>
>);
CPP_assert(same_as<range_rvalue_reference_t<R>,
common_reference_t<range_rvalue_reference_t<decltype(i1_infinite)>,
range_rvalue_reference_t<decltype(i2_infinite)>>
>);
static_assert(range_cardinality<R>::value == ranges::unknown, "Cardinality of symmetric difference between infinite ranges should be unknown!");
::check_equal(res | views::take(6), {1, 3, 4, 6, 12, 15});
// check if the final result agrees with the greedy algorithm
std::vector<int> greedy_sd;
set_symmetric_difference(i1_infinite | views::take(10), i2_infinite | views::take(10), back_inserter(greedy_sd));
::check_equal(res | views::take(6), greedy_sd | views::take(6));
}
// symmetric difference between a finite and an infinite range
{
auto res1 = views::set_symmetric_difference(i1_finite, i2_infinite);
CPP_assert(view_<decltype(res1)>);
CPP_assert(forward_range<decltype(res1)>);
CPP_assert(!random_access_range<decltype(res1)>);
CPP_assert(!common_range<decltype(res1)>);
using R1 = decltype(res1);
CPP_assert(same_as<range_value_t<R1>, int>);
CPP_assert(same_as<range_reference_t<R1>, int>); // our infinite range does not give out references
CPP_assert(same_as<range_rvalue_reference_t<R1>, int>);
static_assert(range_cardinality<R1>::value == ranges::infinite, "Cardinality of symmetric difference between a finite and an infinite range should be infinite!");
::check_equal(res1 | views::take(10), {0, 2, 2, 3, 3, 3, 4, 4, 4, 9});
// now swap the operands:
auto res2 = views::set_symmetric_difference(i2_infinite, i1_finite);
CPP_assert(view_<decltype(res2)>);
CPP_assert(forward_range<decltype(res2)>);
CPP_assert(!random_access_range<decltype(res2)>);
CPP_assert(!common_range<decltype(res2)>);
using R2 = decltype(res2);
CPP_assert(same_as<range_value_t<R2>, int>);
CPP_assert(same_as<range_reference_t<R2>, int>); // our infinite range does not give out references
CPP_assert(same_as<range_rvalue_reference_t<R2>, int>);
static_assert(range_cardinality<R2>::value == ranges::infinite, "Cardinality of symmetric difference between a finite and an infinite range should be infinite!");
::check_equal(res1 | views::take(10), res2 | views::take(10));
}
// symmetric differences involving unknown cardinalities
{
auto rng0 = views::iota(10) | views::drop_while([](int i)
{
return i < 25;
});
static_assert(range_cardinality<decltype(rng0)>::value == ranges::unknown, "");
auto res1 = views::set_symmetric_difference(i2_finite, rng0);
static_assert(range_cardinality<decltype(res1)>::value == ranges::unknown, "Symmetric difference between a finite and unknown cardinality set should have unknown cardinality!");
auto res2 = views::set_symmetric_difference(rng0, i2_finite);
static_assert(range_cardinality<decltype(res2)>::value == ranges::unknown, "Symmetric difference between an unknown and finite cardinality set should have unknown cardinality!");
auto res3 = views::set_symmetric_difference(i1_infinite, rng0);
static_assert(range_cardinality<decltype(res3)>::value == ranges::unknown, "Symmetric difference between an infinite and unknown cardinality set should have unknown cardinality!");
auto res4 = views::set_symmetric_difference(rng0, i1_infinite);
static_assert(range_cardinality<decltype(res4)>::value == ranges::unknown, "Symmetric difference between an unknown and infinite cardinality set should have infinite cardinality!");
auto res5 = views::set_symmetric_difference(rng0, rng0);
static_assert(range_cardinality<decltype(res5)>::value == ranges::unknown, "Symmetric difference between two unknown cardinality sets should have unknown cardinality!");
}
// test const ranges
{
auto res1 = views::set_symmetric_difference(views::const_(i1_finite), views::const_(i2_finite));
using R1 = decltype(res1);
CPP_assert(same_as<range_value_t<R1>, int>);
CPP_assert(same_as<range_reference_t<R1>, const int&>);
CPP_assert(same_as<range_rvalue_reference_t<R1>, const int&&>);
auto res2 = views::set_symmetric_difference(views::const_(i1_finite), i2_finite);
using R2 = decltype(res2);
CPP_assert(same_as<range_value_t<R2>, int>);
CPP_assert(same_as<range_reference_t<R2>, const int&>);
CPP_assert(same_as<range_rvalue_reference_t<R2>, const int&&>);
}
// test different orderings
{
auto res = views::set_symmetric_difference(views::reverse(i1_finite), views::reverse(i2_finite), [](int a, int b)
{
return a > b;
});
::check_equal(res, {9, 6, 4, 4, 3, 3, 3, 2, 1, -3});
CHECK(&*begin(res) == &*(begin(i2_finite) + 5));
}
struct B
{
int val;
B(int i): val{i} {}
bool operator==(const B& other) const
{
return val == other.val;
}
};
struct D: public B
{
D(int i): B{i} {}
D(B b): B{std::move(b)} {}
};
B b_finite[] = {B{-20}, B{-10}, B{1}, B{3}, B{3}, B{6}, B{8}, B{20}};
D d_finite[] = {D{0}, D{2}, D{4}, D{6}};
// sets with different element types, custom orderings
{
auto res = views::set_symmetric_difference(b_finite, d_finite, [](const B& a, const D& b){ return a.val < b.val; });
CPP_assert(same_as<range_value_t<decltype(res)>, B>);
CPP_assert(same_as<range_reference_t<decltype(res)>, B&>);
CPP_assert(same_as<range_rvalue_reference_t<decltype(res)>, B&&>);
::check_equal(res, {B{-20}, B{-10}, B{0}, B{1}, B{2}, B{3}, B{3}, B{4}, B{8}, B{20}});
auto it = begin(res);
CHECK(&*it == &*begin(b_finite));
advance(it, 2);
CHECK(&*it == &*begin(d_finite));
}
// projections
{
auto res1 = views::set_symmetric_difference(b_finite, d_finite,
less(),
&B::val,
&D::val
);
CPP_assert(same_as<range_value_t<decltype(res1)>, B>);
CPP_assert(same_as<range_reference_t<decltype(res1)>, B&>);
CPP_assert(same_as<range_rvalue_reference_t<decltype(res1)>, B&&>);
::check_equal(res1, {B{-20}, B{-10}, B{0}, B{1}, B{2}, B{3}, B{3}, B{4}, B{8}, B{20}});
auto res2 = views::set_symmetric_difference(views::ints(-2, 10), b_finite,
less(),
identity(),
[](const B& x){ return x.val; }
);
CPP_assert(same_as<range_value_t<decltype(res2)>, B>);
CPP_assert(same_as<range_reference_t<decltype(res2)>, B>);
CPP_assert(same_as<range_rvalue_reference_t<decltype(res2)>, B>);
::check_equal(res2, {B{-20}, B{-10}, B{-2}, B{-1}, B{0}, B{2}, B{3}, B{4}, B{5}, B{7}, B{9}, B{20}});
}
// move
{
auto v0 = to<std::vector<MoveOnlyString>>({"a","b","b","c","x","x"});
auto v1 = to<std::vector<MoveOnlyString>>({"b","x","y","z"});
auto res = views::set_symmetric_difference(v0, v1, [](const MoveOnlyString& a, const MoveOnlyString& b){return a<b;});
std::vector<MoveOnlyString> expected;
move(res, back_inserter(expected));
::check_equal(expected, {"a","b","c","x","y","z"});
::check_equal(v1, {"b","x","",""});
::check_equal(v0, {"","b","","","x",""});
auto v0_greedy = to<std::vector<MoveOnlyString>>({"a","b","b","c","x","x"});
auto v1_greedy = to<std::vector<MoveOnlyString>>({"b","x","y","z"});
std::vector<MoveOnlyString> expected_greedy;
set_symmetric_difference(v0_greedy, v1_greedy,
move_into(back_inserter(expected_greedy)),
[](const MoveOnlyString& a, const MoveOnlyString& b){return a<b;});
::check_equal(expected_greedy, expected);
::check_equal(v0_greedy, v0);
::check_equal(v1_greedy, v1);
using R = decltype(res);
CPP_assert(same_as<range_value_t<R>, MoveOnlyString>);
CPP_assert(same_as<range_reference_t<R>, MoveOnlyString &>);
CPP_assert(same_as<range_rvalue_reference_t<R>, MoveOnlyString &&>);
}
// WARNING: set_symmetric_difference between two infinite ranges can create infinite loops!
// {
// auto empty_range = views::set_symmetric_difference(views::ints, views::ints);
// begin(empty_range); // infinite loop!
// }
// iterator (in)equality
{
int r1[] = {1, 2, 3};
int r2[] = { 2, 3, 4, 5};
auto res = views::set_symmetric_difference(r1, r2); // 1, 4, 5
auto it1 = ranges::next(res.begin()); // *it1 == 4, member iterator into r1 points to r1.end()
auto it2 = ranges::next(it1); // *it2 == 5, member iterator into r1 also points to r1.end()
auto sentinel = res.end();
CHECK(*it1 == 4);
CHECK(*it2 == 5);
CHECK(it1 != it2); // should be different even though member iterators into r1 are the same
CHECK(it1 != sentinel);
CHECK(ranges::next(it1, 2) == sentinel);
CHECK(it2 != sentinel);
CHECK(ranges::next(it2, 1) == sentinel);
}
{
auto rng = views::set_symmetric_difference(
debug_input_view<int const>{i1_finite},
debug_input_view<int const>{i2_finite}
);
::check_equal(rng, {-3, 1, 2, 3, 3, 3, 4, 4, 6, 9});
}
return test_result();
}
|
0 | repos/range-v3/test | repos/range-v3/test/view/join.cpp | // Range v3 library
//
// Copyright Eric Niebler 2014-present
//
// Use, modification and distribution is subject to the
// Boost Software License, Version 1.0. (See accompanying
// file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt)
//
// Project home: https://github.com/ericniebler/range-v3
#include <iterator>
#include <forward_list>
#include <functional>
#include <vector>
#include <range/v3/core.hpp>
#include <range/v3/view/join.hpp>
#include <range/v3/view/split.hpp>
#include <range/v3/view/generate_n.hpp>
#include <range/v3/view/repeat_n.hpp>
#include <range/v3/view/chunk.hpp>
#include <range/v3/view/concat.hpp>
#include <range/v3/view/iota.hpp>
#include <range/v3/view/single.hpp>
#include <range/v3/view/transform.hpp>
#include <range/v3/view/filter.hpp>
#include "../simple_test.hpp"
#include "../test_utils.hpp"
#include "../test_iterators.hpp"
RANGES_DIAGNOSTIC_IGNORE_GLOBAL_CONSTRUCTORS
namespace
{
template<typename T, std::size_t N>
struct input_array
{
T elements_[N];
InputIterator<T*> begin() { return InputIterator<T*>{elements_ + 0}; }
InputIterator<T*> end() { return InputIterator<T*>{elements_ + N}; }
constexpr std::size_t size() const { return N; }
};
static int N = 0;
auto make_input_rng()
{
using ranges::views::generate_n;
return generate_n([](){
return generate_n([](){
return N++;
},3);
},3);
}
template<typename T>
constexpr auto twice(T t)
{
return ranges::views::concat(
ranges::views::single(t),
ranges::views::single(t));
}
#ifdef __clang__
RANGES_DIAGNOSTIC_IGNORE_PRAGMAS
RANGES_DIAGNOSTIC_IGNORE("-Wunneeded-member-function")
RANGES_DIAGNOSTIC_IGNORE("-Wunused-member-function")
#endif
// https://github.com/ericniebler/range-v3/issues/283
void test_issue_283()
{
const std::vector<std::vector<int>> nums =
{
{ 1, 2, 3 },
{ 4, 5, 6 }
};
const auto flat_nums = ranges::views::join( nums ) | ranges::to<std::vector>();
::check_equal(flat_nums, {1,2,3,4,5,6});
}
// https://github.com/ericniebler/range-v3/issues/1414
void test_issue_1414()
{
std::forward_list<char> u2; // this can also be a vector
std::vector<char> i2;
auto v2 = u2 | ranges::views::chunk(3) | ranges::views::join(i2);
CPP_assert(ranges::input_range<decltype(v2)>);
}
}
int main()
{
using namespace ranges;
// Test that we can join an input range of input ranges:
{
auto rng0 = make_input_rng() | views::join;
static_assert(range_cardinality<decltype(rng0)>::value == ranges::finite, "");
CPP_assert(input_range<decltype(rng0)>);
CPP_assert(!forward_range<decltype(rng0)>);
CPP_assert(!common_range<decltype(rng0)>);
CPP_assert(!sized_range<decltype(rng0)>);
check_equal(rng0, {0,1,2,3,4,5,6,7,8});
}
// Joining with a value
{
N = 0;
auto rng1 = make_input_rng() | views::join(42);
static_assert(range_cardinality<decltype(rng1)>::value == ranges::finite, "");
CPP_assert(input_range<decltype(rng1)>);
CPP_assert(!forward_range<decltype(rng1)>);
CPP_assert(!common_range<decltype(rng1)>);
CPP_assert(!sized_range<decltype(rng1)>);
check_equal(rng1, {0,1,2,42,3,4,5,42,6,7,8});
}
// Joining with a range
{
N = 0;
int rgi[] = {42,43};
auto rng2 = make_input_rng() | views::join(rgi);
static_assert(range_cardinality<decltype(rng2)>::value == ranges::finite, "");
CPP_assert(input_range<decltype(rng2)>);
CPP_assert(!forward_range<decltype(rng2)>);
CPP_assert(!common_range<decltype(rng2)>);
CPP_assert(!sized_range<decltype(rng2)>);
check_equal(rng2, {0,1,2,42,43,3,4,5,42,43,6,7,8});
}
// Just for fun:
{
std::string str = "Now,is,the,time,for,all,good,men,to,come,to,the,aid,of,their,country";
auto res = str | views::split(',') | views::join(' ') | to<std::string>();
CHECK(res == "Now is the time for all good men to come to the aid of their country");
static_assert(range_cardinality<decltype(res)>::value == ranges::finite, "");
}
{
std::vector<std::string> vs{"This","is","his","face"};
auto rng3 = views::join(vs);
static_assert(range_cardinality<decltype(rng3)>::value == ranges::finite, "");
CPP_assert(!sized_range<decltype(rng3)>);
CPP_assert(!sized_sentinel_for<decltype(end(rng3)), decltype(begin(rng3))>);
CHECK(to<std::string>(rng3) == "Thisishisface");
auto rng4 = views::join(vs, ' ');
static_assert(range_cardinality<decltype(rng3)>::value == ranges::finite, "");
CPP_assert(!sized_range<decltype(rng4)>);
CPP_assert(!sized_sentinel_for<decltype(end(rng4)), decltype(begin(rng4))>);
CHECK(to<std::string>(rng4) == "This is his face");
}
{
auto rng5 = views::join(twice(twice(42)));
static_assert(range_cardinality<decltype(rng5)>::value == 4, "");
CPP_assert(sized_range<decltype(rng5)>);
CHECK(rng5.size() == 4u);
check_equal(rng5, {42,42,42,42});
}
{
auto rng6 = views::join(twice(views::repeat_n(42, 2)));
static_assert(range_cardinality<decltype(rng6)>::value == ranges::finite, "");
CPP_assert(sized_range<decltype(rng6)>);
CHECK(rng6.size() == 4u);
check_equal(rng6, {42,42,42,42});
}
{
input_array<std::string, 4> some_strings = {{"This","is","his","face"}};
CPP_assert(input_range<decltype(some_strings)>);
CPP_assert(sized_range<decltype(some_strings)>);
CPP_assert(!sized_range<decltype(some_strings | views::join)>);
}
{
int const some_int_pairs[3][2] = {{0,1},{2,3},{4,5}};
auto rng = debug_input_view<int const[2]>{some_int_pairs} | views::join;
check_equal(rng, {0,1,2,3,4,5});
}
{
std::vector<std::string> vs{"this","is","his","face"};
join_view<ref_view<std::vector<std::string>>> jv{vs};
check_equal(jv, {'t','h','i','s','i','s','h','i','s','f','a','c','e'});
CPP_assert(bidirectional_range<decltype(jv)>);
CPP_assert(bidirectional_range<const decltype(jv)>);
CPP_assert(common_range<decltype(jv)>);
CPP_assert(common_range<const decltype(jv)>);
}
{
auto rng = views::iota(0,4)
| views::transform([](int i) {return views::iota(0,i);})
| views::join;
check_equal(rng, {0,0,1,0,1,2});
CPP_assert(input_range<decltype(rng)>);
CPP_assert(!range<const decltype(rng)>);
CPP_assert(!forward_range<decltype(rng)>);
CPP_assert(!common_range<decltype(rng)>);
}
{
auto rng = views::iota(0,4)
| views::transform([](int i) {return views::iota(0,i);})
| views::filter([](auto){ return true; })
| views::join;
check_equal(rng, {0,0,1,0,1,2});
CPP_assert(input_range<decltype(rng)>);
CPP_assert(!range<const decltype(rng)>);
CPP_assert(!forward_range<decltype(rng)>);
CPP_assert(!common_range<decltype(rng)>);
}
{
auto rng = views::iota(0,4)
| views::transform([](int i) {return std::string((std::size_t) i, char('a'+i));})
| views::join;
check_equal(rng, {'b','c','c','d','d','d'});
CPP_assert(input_range<decltype(rng)>);
CPP_assert(!range<const decltype(rng)>);
CPP_assert(!forward_range<decltype(rng)>);
CPP_assert(!common_range<decltype(rng)>);
}
{
auto rng = views::iota(0,4)
| views::transform([](int i) {return std::string((std::size_t) i, char('a'+i));})
| views::join('-');
check_equal(rng, {'-','b','-','c','c','-','d','d','d'});
CPP_assert(input_range<decltype(rng)>);
CPP_assert(!range<const decltype(rng)>);
CPP_assert(!forward_range<decltype(rng)>);
CPP_assert(!common_range<decltype(rng)>);
}
// https://github.com/ericniebler/range-v3/issues/1320
{
auto op = [](auto & input, int i, auto & ins)
{
return input | ranges::views::chunk(i)
| ranges::views::join(ins);
};
std::string input{"foobarbaxbat"};
std::string insert{"X"};
auto rng = op(input, 2, insert);
std::cout << rng << '\n';
::check_equal(rng, {'f','o','X','o','b','X','a','r','X','b','a','X','x','b','X',
'a','t'});
}
{
auto op = [](auto & input, int i, auto & ins)
{
return input | ranges::views::chunk(i)
| ranges::views::join(ins);
};
std::vector<std::string> input{"foo","bar","bax","bat"};
std::string insert{"XX"};
auto rng = op(input, 2, insert);
std::cout << rng << '\n';
::check_equal(rng, {"foo","bar","XX","bax","bat"});
}
{
std::vector<int> v = {1, 2, 3};
auto throws = [](auto &&) -> std::vector<std::vector<int>> & { throw 42; };
auto rng = v | ranges::views::transform(throws) | ranges::views::join;
try
{
auto d = ranges::distance(rng);
CHECK(false);
CHECK(d == 3);
}
catch(int)
{}
catch(...)
{
CHECK(false);
}
}
test_issue_283();
test_issue_1414();
return ::test_result();
}
|
0 | repos/range-v3/test | repos/range-v3/test/view/generate.cpp | // Range v3 library
//
// Copyright Eric Niebler 2014-present
//
// Use, modification and distribution is subject to the
// Boost Software License, Version 1.0. (See accompanying
// file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt)
//
// Project home: https://github.com/ericniebler/range-v3
#include <range/v3/core.hpp>
#include <range/v3/view/generate.hpp>
#include <range/v3/view/drop_exactly.hpp>
#include <range/v3/view/take_exactly.hpp>
#include "../simple_test.hpp"
#include "../test_utils.hpp"
namespace views = ranges::views;
int main()
{
// Test for constant generator functions
{
int i = 0, j = 1;
auto fib = views::generate([&]()->int{int tmp = i; i += j; std::swap(i, j); return tmp;});
CPP_assert(ranges::input_range<decltype(fib)> && ranges::view_<decltype(fib)>);
check_equal(fib | views::take_exactly(10), {0,1,1,2,3,5,8,13,21,34});
}
// Test for mutable-only generator functions
{
int i = 0, j = 1;
auto fib = views::generate([=]()mutable->int{int tmp = i; i += j; std::swap(i, j); return tmp;});
CPP_assert(ranges::input_range<decltype(fib)> && ranges::view_<decltype(fib)>);
check_equal(fib | views::take_exactly(10), {0,1,1,2,3,5,8,13,21,34});
// The generator cannot be called when it's const-qualified, so "fib const"
// does not model View.
CPP_assert(!ranges::view_<decltype(fib) const>);
}
// Test for generator functions that return move-only types
// https://github.com/ericniebler/range-v3/issues/905
{
char str[] = "gi";
auto rng = views::generate([&]{str[0]++; return MoveOnlyString{str};}) | views::take_exactly(2);
auto i = rng.begin();
CHECK(bool(*i == MoveOnlyString{"hi"}));
CHECK(bool(*i == MoveOnlyString{"hi"}));
CHECK(bool(*rng.begin() == MoveOnlyString{"hi"}));
CHECK(bool(*rng.begin() == MoveOnlyString{"hi"}));
CPP_assert(ranges::input_range<decltype(rng)> && ranges::view_<decltype(rng)>);
check_equal(rng, {MoveOnlyString{"hi"}, MoveOnlyString{"ii"}});
static_assert(std::is_same<ranges::range_reference_t<decltype(rng)>, MoveOnlyString &&>::value, "");
}
// Test for generator functions that return internal references
// https://github.com/ericniebler/range-v3/issues/807
{
int i = 42;
auto rng = views::generate([i]{return &i;});
auto rng2 = std::move(rng);
auto it = rng2.begin();
auto p = *it;
auto p2 = *++it;
CHECK(p == p2);
}
// Test that we only call the function once for each dereferenceable position
// https://github.com/ericniebler/range-v3/issues/819
{
int i = 0;
auto rng = views::generate([&i]{return ++i;});
auto rng2 = std::move(rng);
auto it = rng2.begin();
CHECK(i == 0);
CHECK(*it == 1);
CHECK(i == 1);
++it;
CHECK(i == 1);
CHECK(*it == 2);
CHECK(i == 2);
}
// Test that skipping past positions works correctly
// https://github.com/ericniebler/range-v3/issues/1258
{
auto fib = [p = std::make_pair(0, 1)]() mutable -> int {
auto a = p.first;
p = {p.second, p.first + p.second};
return a;
};
auto rng = ranges::views::generate(fib)
| ranges::views::drop_exactly(3)
| ranges::views::take_exactly(5);
check_equal(rng, {2,3,5,8,13});
}
return test_result();
}
|
0 | repos/range-v3/test | repos/range-v3/test/view/tokenize.cpp | #include <range/v3/core.hpp>
#include <range/v3/view/tokenize.hpp>
#include <range/v3/utility/copy.hpp>
#include "../simple_test.hpp"
#include "../test_utils.hpp"
int main()
{
using namespace ranges;
// GCC 4.8 doesn't do regex
#if !defined(__GNUC__) || defined(__clang__) || __GNUC__ > 4 || __GNUC_MINOR__ > 8
std::string txt{"abc\ndef\tghi"};
const std::regex rx{R"delim(([\w]+))delim"};
auto rng = txt | views::tokenize(rx,1);
const auto crng = txt | views::tokenize(rx,1);
::check_equal(rng, {"abc","def","ghi"});
::check_equal(crng, {"abc","def","ghi"});
::has_type<const std::sub_match<std::string::iterator>&>(*ranges::begin(rng));
::has_type<const std::sub_match<std::string::iterator>&>(*ranges::begin(crng));
CPP_assert(common_range<decltype(rng)>);
CPP_assert(forward_range<decltype(rng)>);
CPP_assert(!bidirectional_range<decltype(rng)>);
CPP_assert(!sized_range<decltype(rng)>);
CPP_assert(common_range<decltype(crng)>);
CPP_assert(forward_range<decltype(crng)>);
CPP_assert(!bidirectional_range<decltype(crng)>);
CPP_assert(!sized_range<decltype(crng)>);
CPP_assert(view_<decltype(rng)>);
CPP_assert(!view_<decltype(crng)>);
#endif
return test_result();
}
|
0 | repos/range-v3/test | repos/range-v3/test/view/set_intersection.cpp | // Range v3 library
//
// Copyright Eric Niebler 2014-present
// Copyright Tomislav Ivek 2015-2016
//
// Use, modification and distribution is subject to the
// Boost Software License, Version 1.0. (See accompanying
// file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt)
//
// Project home: https://github.com/ericniebler/range-v3
#include <vector>
#include <sstream>
#include <range/v3/core.hpp>
#include <range/v3/range_for.hpp>
#include <range/v3/algorithm/set_algorithm.hpp>
#include <range/v3/algorithm/move.hpp>
#include <range/v3/iterator/operations.hpp>
#include <range/v3/iterator/insert_iterators.hpp>
#include <range/v3/functional/identity.hpp>
#include <range/v3/utility/copy.hpp>
#include <range/v3/view/all.hpp>
#include <range/v3/view/const.hpp>
#include <range/v3/view/drop_while.hpp>
#include <range/v3/view/iota.hpp>
#include <range/v3/view/reverse.hpp>
#include <range/v3/view/set_algorithm.hpp>
#include <range/v3/view/stride.hpp>
#include <range/v3/view/take.hpp>
#include <range/v3/view/transform.hpp>
#include "../simple_test.hpp"
#include "../test_utils.hpp"
int main()
{
using namespace ranges;
int i1_finite[] = {1, 2, 2, 3, 3, 3, 4, 4, 4, 4};
int i2_finite[] = { -3, 2, 4, 4, 6, 9};
auto i1_infinite = views::ints | views::stride(3);
auto i2_infinite = views::ints | views::transform([](int x)
{
return x * x;
});
// intersection of two finite ranges
{
auto res = views::set_intersection(i1_finite, i2_finite);
CPP_assert(view_<decltype(res)>);
CPP_assert(forward_range<decltype(res)>);
CPP_assert(!random_access_range<decltype(res)>);
CPP_assert(!common_range<decltype(res)>);
using R = decltype(res);
CPP_assert(same_as<range_value_t<R>, int>);
CPP_assert(same_as<range_reference_t<R>, int&>);
CPP_assert(same_as<decltype(iter_move(begin(res))), int &&>);
static_assert(range_cardinality<R>::value == ranges::finite, "Cardinality of intersection with a finite range should be finite!");
::check_equal(res, {2, 4, 4});
CHECK(&*begin(res) == &*(begin(i1_finite) + 1));
}
// intersection of two infinite ranges
{
auto res = views::set_intersection(i1_infinite, i2_infinite);
CPP_assert(view_<decltype(res)>);
CPP_assert(forward_range<decltype(res)>);
CPP_assert(!random_access_range<decltype(res)>);
CPP_assert(!common_range<decltype(res)>);
using R = decltype(res);
CPP_assert(same_as<range_value_t<R>, int>);
CPP_assert(same_as<range_reference_t<R>, range_reference_t<decltype(i1_infinite)>>);
CPP_assert(same_as<decltype(iter_move(begin(res))), range_rvalue_reference_t<decltype(i1_infinite)>>);
static_assert(range_cardinality<R>::value == ranges::unknown, "Cardinality of intersection of infinite ranges should be unknown!");
::check_equal(res | views::take(5), {0, 9, 36, 81, 144});
}
// intersection of a finite and infinite range
{
auto res = views::set_intersection(i1_finite, i2_infinite);
CPP_assert(view_<decltype(res)>);
CPP_assert(forward_range<decltype(res)>);
CPP_assert(!random_access_range<decltype(res)>);
CPP_assert(!common_range<decltype(res)>);
using R = decltype(res);
CPP_assert(same_as<range_value_t<R>, int>);
CPP_assert(same_as<range_reference_t<R>, range_reference_t<decltype(i1_finite)>>);
CPP_assert(same_as<decltype(iter_move(begin(res))), range_rvalue_reference_t<decltype(i1_finite)>>);
static_assert(range_cardinality<R>::value == ranges::finite, "Cardinality of intersection with a finite range should be finite!");
::check_equal(res | views::take(500), {1, 4});
auto res2 = views::set_intersection(i1_infinite, i2_finite);
CPP_assert(view_<decltype(res2)>);
CPP_assert(forward_range<decltype(res2)>);
CPP_assert(!random_access_range<decltype(res2)>);
CPP_assert(!common_range<decltype(res2)>);
using R2 = decltype(res2);
CPP_assert(same_as<range_value_t<R2>, int>);
CPP_assert(same_as<range_reference_t<R2>, range_reference_t<decltype(i1_infinite)>>);
CPP_assert(same_as<range_rvalue_reference_t<R2>, range_rvalue_reference_t<decltype(i1_infinite)>>);
static_assert(range_cardinality<decltype(res2)>::value == ranges::finite, "Cardinality of intersection with a finite range should be finite!");
::check_equal(res2 | views::take(500), {6, 9});
}
// intersection of a set of unknown cardinality
{
auto rng0 = views::iota(10) | views::drop_while([](int i)
{
return i < 25;
});
static_assert(range_cardinality<decltype(rng0)>::value == ranges::unknown, "");
auto res = views::set_intersection(i1_finite, rng0);
static_assert(range_cardinality<decltype(res)>::value == ranges::unknown, "Intersection with a set of unknown cardinality should have unknown cardinality!");
}
// test const ranges
{
auto res1 = views::set_intersection(views::const_(i1_finite), views::const_(i2_finite));
using R1 = decltype(res1);
CPP_assert(same_as<range_value_t<R1>, int>);
CPP_assert(same_as<range_reference_t<R1>, const int&>);
CPP_assert(same_as<range_rvalue_reference_t<R1>, const int&&>);
auto res2 = views::set_intersection(views::const_(i1_finite), i2_finite);
using R2 = decltype(res2);
CPP_assert(same_as<range_value_t<R2>, int>);
CPP_assert(same_as<range_reference_t<R2>, const int&>);
CPP_assert(same_as<range_rvalue_reference_t<R2>, const int&&>);
}
// test different orderings
{
auto res = views::set_intersection(views::reverse(i1_finite), views::reverse(i2_finite), [](int a, int b)
{
return a > b;
});
::check_equal(res, {4, 4, 2});
}
// test projections and sets with different element types
struct S
{
int val;
bool operator==(const S& other) const
{
return val == other.val;
}
};
S s_finite[] = {S{-20}, S{-10}, S{1}, S{3}, S{3}, S{6}, S{8}, S{20}};
{
auto res1 = views::set_intersection(s_finite, views::ints(-2, 10),
less(),
&S::val,
identity()
);
using R1 = decltype(res1);
CPP_assert(same_as<range_value_t<R1>, S>);
CPP_assert(same_as<range_reference_t<R1>, S&>);
CPP_assert(same_as<range_rvalue_reference_t<R1>, S&&>);
::check_equal(res1, {S{1}, S{3}, S{6}, S{8}});
auto res2 = views::set_intersection(views::ints(-2, 10), s_finite,
less(),
identity(),
[](const S& x){ return x.val; }
);
using R2 = decltype(res2);
CPP_assert(same_as<range_value_t<R2>, int>);
CPP_assert(same_as<range_reference_t<R2>, int>);
CPP_assert(same_as<range_rvalue_reference_t<R2>, int>);
::check_equal(res2, {1, 3, 6, 8});
}
// move
{
auto v0 = to<std::vector<MoveOnlyString>>({"a","b","b","c","x","x"});
auto v1 = to<std::vector<MoveOnlyString>>({"b","x","y","z"});
auto res = views::set_intersection(v0, v1, [](const MoveOnlyString& a, const MoveOnlyString& b){return a<b;});
std::vector<MoveOnlyString> expected;
move(res, back_inserter(expected));
::check_equal(expected, {"b","x"});
::check_equal(v0, {"a","","b","c","","x"});
::check_equal(v1, {"b","x","y","z"});
using R = decltype(res);
CPP_assert(same_as<range_value_t<R>, MoveOnlyString>);
CPP_assert(same_as<range_reference_t<R>, MoveOnlyString &>);
CPP_assert(same_as<range_rvalue_reference_t<R>, MoveOnlyString &&>);
}
{
auto rng = views::set_intersection(
debug_input_view<int const>{i1_finite},
debug_input_view<int const>{i2_finite}
);
::check_equal(rng, {2, 4, 4});
}
return test_result();
}
|
0 | repos/range-v3/test | repos/range-v3/test/functional/on.cpp | // Range v3 library
//
// Copyright Eric Niebler 2020
//
// Use, modification and distribution is subject to the
// Boost Software License, Version 1.0. (See accompanying
// file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt)
//
// Project home: https://github.com/ericniebler/range-v3
#include <range/v3/functional/on.hpp>
#include <range/v3/functional/concepts.hpp>
#include "../simple_test.hpp"
using namespace ranges;
int square(int i) { return i * i; }
int main()
{
auto fn = on(std::multiplies<>{}, square);
CHECK(fn(2, 4) == 64);
return ::test_result();
}
|
0 | repos/range-v3/test | repos/range-v3/test/functional/CMakeLists.txt | set(CMAKE_FOLDER "${CMAKE_FOLDER}/algorithm")
rv3_add_test(test.fun.bind_back fun.bind_back bind_back.cpp)
rv3_add_test(test.fun.on fun.on on.cpp)
|
0 | repos/range-v3/test | repos/range-v3/test/functional/bind_back.cpp | // Range v3 library
//
// Copyright Eric Niebler 2020
//
// Use, modification and distribution is subject to the
// Boost Software License, Version 1.0. (See accompanying
// file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt)
//
// Project home: https://github.com/ericniebler/range-v3
#include <range/v3/functional/bind_back.hpp>
#include <range/v3/functional/concepts.hpp>
#include "../simple_test.hpp"
using namespace ranges;
int* test(int & i)
{
return &i;
}
int main()
{
int i = 42;
auto fn = bind_back(test, i);
int* pi = fn();
CHECK(pi != &i);
CHECK(*pi == i);
CPP_assert(!invocable<decltype(fn)>);
CPP_assert(invocable<decltype(fn) &>);
CPP_assert(!invocable<decltype(fn) const &>);
return ::test_result();
}
|
0 | repos/range-v3/test | repos/range-v3/test/action/stride.cpp | // Range v3 library
//
// Copyright Eric Niebler 2014-present
//
// Use, modification and distribution is subject to the
// Boost Software License, Version 1.0. (See accompanying
// file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt)
#include <array>
#include <vector>
#include <range/v3/core.hpp>
#include <range/v3/view/iota.hpp>
#include <range/v3/algorithm/copy.hpp>
#include <range/v3/algorithm/move.hpp>
#include <range/v3/algorithm/equal.hpp>
#include <range/v3/action/stride.hpp>
#include "../simple_test.hpp"
#include "../test_utils.hpp"
int main()
{
using namespace ranges;
auto v = views::ints(0,100) | to<std::vector>();
auto v2 = v | copy | actions::stride(10);
CHECK(size(v2) == 10u);
CPP_assert(same_as<decltype(v), decltype(v2)>);
::check_equal(v2, {0,10,20,30,40,50,60,70,80,90});
v2 = v2 | move | actions::stride(4);
::check_equal(v2, {0,40,80});
v2 |= actions::stride(2);
::check_equal(v2, {0,80});
v2 |= actions::stride(1);
::check_equal(v2, {0,80});
v2 |= actions::stride(10);
::check_equal(v2, {0});
auto & v3 = actions::stride(v, 30);
CHECK(&v3 == &v);
::check_equal(v, {0,30,60,90});
return ::test_result();
}
|
0 | repos/range-v3/test | repos/range-v3/test/action/take.cpp | // Range v3 library
//
// Copyright Eric Niebler 2014-present
//
// Use, modification and distribution is subject to the
// Boost Software License, Version 1.0. (See accompanying
// file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt)
#include <vector>
#include <range/v3/core.hpp>
#include <range/v3/view/iota.hpp>
#include <range/v3/algorithm/move.hpp>
#include <range/v3/action/take.hpp>
#include "../simple_test.hpp"
#include "../test_utils.hpp"
int main()
{
using namespace ranges;
auto v = views::ints(1,21) | to<std::vector>();
auto & v2 = actions::take(v, 17);
CHECK(&v2 == &v);
CHECK(v.size() == 17u);
CHECK(v.back() == 17);
v = std::move(v) | actions::take(14);
CHECK(v.size() == 14u);
CHECK(v.back() == 14);
v |= actions::take(11);
CHECK(v.size() == 11u);
CHECK(v.back() == 11);
v |= actions::take(100);
CHECK(v.size() == 11u);
v |= actions::take(0);
CHECK(v.size() == 0u);
return ::test_result();
}
|
0 | repos/range-v3/test | repos/range-v3/test/action/take_while.cpp | // Range v3 library
//
// Copyright Eric Niebler 2014-present
//
// Use, modification and distribution is subject to the
// Boost Software License, Version 1.0. (See accompanying
// file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt)
#include <vector>
#include <range/v3/core.hpp>
#include <range/v3/view/iota.hpp>
#include <range/v3/algorithm/move.hpp>
#include <range/v3/action/take_while.hpp>
#include "../simple_test.hpp"
#include "../test_utils.hpp"
int main()
{
using namespace ranges;
using namespace std::placeholders;
auto v = views::ints(1,21) | to<std::vector>();
auto & v2 = actions::take_while(v, std::bind(std::less<int>(), _1, 18));
CHECK(&v2 == &v);
CHECK(v.size() == 17u);
CHECK(v.back() == 17);
v = std::move(v) | actions::take_while([](int i){return i < 15;});
CHECK(v.size() == 14u);
CHECK(v.back() == 14);
v |= actions::take_while([](int i){return i < 12;});
CHECK(v.size() == 11u);
CHECK(v.back() == 11);
v |= actions::take_while([](int){return true;});
CHECK(v.size() == 11u);
v |= actions::take_while([](int){return false;});
CHECK(v.size() == 0u);
return ::test_result();
}
|
0 | repos/range-v3/test | repos/range-v3/test/action/remove.cpp | // Range v3 library
//
// Copyright Andrey Diduh 2019
//
// Use, modification and distribution is subject to the
// Boost Software License, Version 1.0. (See accompanying
// file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt)
//
// Project home: https://github.com/ericniebler/range-v3
#include <vector>
#include <string>
#include <range/v3/action/remove.hpp>
#include "../simple_test.hpp"
#include "../test_utils.hpp"
using namespace ranges;
struct Data
{
int i;
Data() = default;
explicit Data(int j) : i(j) {}
bool operator==(const Data& other) const {
return other.i == i;
}
bool operator!=(const Data& other) const {
return other.i != i;
}
};
void simple_test()
{
std::vector<Data> list;
list.emplace_back(Data{1});
list.emplace_back(Data{2});
list.emplace_back(Data{3});
list.emplace_back(Data{4});
Data d2{2};
const auto remove_data = actions::remove(d2);
list |= remove_data;
check_equal(list, {Data{1}, Data{3}, Data{4}});
list |= actions::remove(3, &Data::i);
check_equal(list, {Data{1}, Data{4}});
}
void string_test()
{
std::vector<std::string> list = {"aaa", "bbb", "ccc"};
list |= actions::remove("bbb");
check_equal(list, {"aaa", "ccc"});
}
int main()
{
simple_test();
string_test();
return ::test_result();
}
|
0 | repos/range-v3/test | repos/range-v3/test/action/slice.cpp | // Range v3 library
//
// Copyright Eric Niebler 2014-present
//
// Use, modification and distribution is subject to the
// Boost Software License, Version 1.0. (See accompanying
// file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt)
#include <array>
#include <vector>
#include <range/v3/core.hpp>
#include <range/v3/view/iota.hpp>
#include <range/v3/view/stride.hpp>
#include <range/v3/algorithm/copy.hpp>
#include <range/v3/algorithm/move.hpp>
#include <range/v3/algorithm/equal.hpp>
#include <range/v3/action/slice.hpp>
#include "../simple_test.hpp"
#include "../test_utils.hpp"
int main()
{
using namespace ranges;
{
auto v = views::ints(0, 100) | to<std::vector>();
auto v2 = v | copy | actions::slice(10, 20);
CHECK(size(v2) == 10u);
CPP_assert(same_as<decltype(v), decltype(v2)>);
::check_equal(v2, {10, 11, 12, 13, 14, 15, 16, 17, 18, 19});
v2 = v2 | move | actions::slice(2, 8);
::check_equal(v2, {12, 13, 14, 15, 16, 17});
v2 |= actions::slice(0, 0);
CHECK(v2.size() == 0u);
auto &v3 = actions::slice(v, 90, 100);
CHECK(&v3 == &v);
::check_equal(v, {90, 91, 92, 93, 94, 95, 96, 97, 98, 99});
}
{
auto rng = views::ints(0, 100) | to<std::vector>();
rng |= actions::slice(20, end - 70);
CHECK(size(rng) == 10u);
::check_equal(rng, {20, 21, 22, 23, 24, 25, 26, 27, 28, 29});
rng |= actions::slice(end - 10, end - 5);
CHECK(size(rng) == 5u);
::check_equal(rng, {20, 21, 22, 23, 24});
}
{
auto rng = views::ints(0, 100) | to<std::vector>();
auto &rng_copy = actions::slice(rng, 90, end);
CHECK(&rng_copy == &rng);
CHECK(size(rng_copy) == 10u);
::check_equal(rng, {90, 91, 92, 93, 94, 95, 96, 97, 98, 99});
rng |= actions::slice(end - 5, end);
CHECK(&rng_copy == &rng);
CHECK(size(rng_copy) == 5u);
::check_equal(rng, {95, 96, 97, 98, 99});
}
return ::test_result();
}
|
0 | repos/range-v3/test | repos/range-v3/test/action/drop_while.cpp | // Range v3 library
//
// Copyright Eric Niebler 2014-present
//
// Use, modification and distribution is subject to the
// Boost Software License, Version 1.0. (See accompanying
// file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt)
#include <vector>
#include <range/v3/core.hpp>
#include <range/v3/view/iota.hpp>
#include <range/v3/algorithm/move.hpp>
#include <range/v3/action/drop_while.hpp>
#include "../simple_test.hpp"
#include "../test_utils.hpp"
int main()
{
using namespace ranges;
using namespace std::placeholders;
auto v = views::ints(1,21) | to<std::vector>();
auto & v2 = actions::drop_while(v, std::bind(std::less<int>(), _1, 4));
CHECK(&v2 == &v);
CHECK(v.size() == 17u);
CHECK(v[0] == 4);
v = std::move(v) | actions::drop_while([](int i){return i < 7;});
CHECK(v.size() == 14u);
CHECK(v[0] == 7);
v |= actions::drop_while([](int i){return i < 10;});
CHECK(v.size() == 11u);
CHECK(v[0] == 10);
v |= actions::drop_while([](int){return true;});
CHECK(v.size() == 0u);
return ::test_result();
}
|
0 | repos/range-v3/test | repos/range-v3/test/action/unique.cpp | // Range v3 library
//
// Copyright Eric Niebler 2014-present
//
// Use, modification and distribution is subject to the
// Boost Software License, Version 1.0. (See accompanying
// file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt)
#include <random>
#include <vector>
#include <range/v3/core.hpp>
#include <range/v3/view/iota.hpp>
#include <range/v3/view/repeat_n.hpp>
#include <range/v3/view/for_each.hpp>
#include <range/v3/view/take.hpp>
#include <range/v3/algorithm/shuffle.hpp>
#include <range/v3/algorithm/equal.hpp>
#include <range/v3/algorithm/is_sorted.hpp>
#include <range/v3/action/shuffle.hpp>
#include <range/v3/action/sort.hpp>
#include <range/v3/action/unique.hpp>
#include "../simple_test.hpp"
#include "../test_utils.hpp"
int main()
{
using namespace ranges;
std::mt19937 gen;
// [1,2,2,3,3,3,4,4,4,4,5,5,5,5,5,...]
auto v =
views::for_each(views::ints(1,100), [](int i){
return yield_from(views::repeat_n(i,i));
}) | to<std::vector>();
check_equal(views::take(v, 15), {1,2,2,3,3,3,4,4,4,4,5,5,5,5,5});
v |= actions::shuffle(gen);
CHECK(!is_sorted(v));
v |= actions::sort | actions::unique;
CHECK(equal(v, views::ints(1,100)));
return ::test_result();
}
|
0 | repos/range-v3/test | repos/range-v3/test/action/sort.cpp | // Range v3 library
//
// Copyright Eric Niebler 2014-present
//
// Use, modification and distribution is subject to the
// Boost Software License, Version 1.0. (See accompanying
// file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt)
#include <array>
#include <random>
#include <vector>
#include <range/v3/core.hpp>
#include <range/v3/view/iota.hpp>
#include <range/v3/view/stride.hpp>
#include <range/v3/view/take.hpp>
#include <range/v3/algorithm/shuffle.hpp>
#include <range/v3/algorithm/copy.hpp>
#include <range/v3/algorithm/move.hpp>
#include <range/v3/algorithm/is_sorted.hpp>
#include <range/v3/algorithm/equal.hpp>
#include <range/v3/action/shuffle.hpp>
#include <range/v3/action/sort.hpp>
#include "../simple_test.hpp"
#include "../test_utils.hpp"
int main()
{
using namespace ranges;
std::mt19937 gen;
auto v = views::ints(0,100) | to<std::vector>();
v |= actions::shuffle(gen);
CHECK(!is_sorted(v));
auto v2 = v | copy | actions::sort;
CHECK(size(v2) == size(v));
CHECK(is_sorted(v2));
CHECK(!is_sorted(v));
CPP_assert(same_as<decltype(v), decltype(v2)>);
v |= actions::sort;
CHECK(is_sorted(v));
v |= actions::shuffle(gen);
CHECK(!is_sorted(v));
v = v | move | actions::sort(std::less<int>());
CHECK(is_sorted(v));
CHECK(equal(v, v2));
// Container algorithms can also be called directly
// in which case they take and return by reference
shuffle(v, gen);
CHECK(!is_sorted(v));
auto & v3 = actions::sort(v);
CHECK(is_sorted(v));
CHECK(&v3 == &v);
auto r = views::ref(v);
r |= actions::sort;
// Can pipe a view to a "container" algorithm.
actions::sort(v, std::greater<int>());
v | views::stride(2) | actions::sort;
check_equal(views::take(v, 10), {1,98,3,96,5,94,7,92,9,90});
return ::test_result();
}
|
0 | repos/range-v3/test | repos/range-v3/test/action/split.cpp | // Range v3 library
//
// Copyright Eric Niebler 2014-present
//
// Use, modification and distribution is subject to the
// Boost Software License, Version 1.0. (See accompanying
// file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt)
#include <cctype>
#include <string>
#include <vector>
#include <range/v3/action/split.hpp>
#include <range/v3/action/split_when.hpp>
#include <range/v3/algorithm/move.hpp>
#include <range/v3/core.hpp>
#include <range/v3/view/c_str.hpp>
#include <range/v3/view/iota.hpp>
#include "../simple_test.hpp"
#include "../test_utils.hpp"
int main()
{
using namespace ranges;
{
auto v = views::ints(1, 21) | to<std::vector>();
std::vector<std::vector<int>> rgv = actions::split(v, 10);
CHECK(rgv.size() == 2u);
::check_equal(rgv[0], {1,2,3,4,5,6,7,8,9});
::check_equal(rgv[1], {11,12,13,14,15,16,17,18,19,20});
using I = std::vector<int>::iterator;
std::vector<std::vector<int>> rgv2 = actions::split_when(
v, [](I b, I) { return std::make_pair(0 == (*b) % 2, next(b)); });
CHECK(rgv2.size() == 10u);
::check_equal(rgv2[0], {1});
::check_equal(rgv2[1], {3});
::check_equal(rgv2[2], {5});
::check_equal(rgv2[3], {7});
::check_equal(rgv2[4], {9});
::check_equal(rgv2[5], {11});
::check_equal(rgv2[6], {13});
::check_equal(rgv2[7], {15});
::check_equal(rgv2[8], {17});
::check_equal(rgv2[9], {19});
}
{
std::string s{"This is his face"};
std::vector<std::string> rgs = actions::split(s, views::c_str(" "));
CHECK(rgs.size() == 4u);
CHECK(rgs[0] == "This");
CHECK(rgs[1] == "is");
CHECK(rgs[2] == "his");
CHECK(rgs[3] == "face");
}
{
std::string s{"This is his face"};
std::vector<std::string> rgs = std::move(s) | actions::split(views::c_str(" "));
CHECK(rgs.size() == 4u);
CHECK(rgs[0] == "This");
CHECK(rgs[1] == "is");
CHECK(rgs[2] == "his");
CHECK(rgs[3] == "face");
}
{
std::string s{"This is his face"};
char ch[] = {' '};
std::vector<std::string> rgs = actions::split(s, ch);
CHECK(rgs.size() == 4u);
CHECK(rgs[0] == "This");
CHECK(rgs[1] == "is");
CHECK(rgs[2] == "his");
CHECK(rgs[3] == "face");
}
{
std::string s{"This is his face"};
char ch[] = {' '};
std::vector<std::string> rgs = std::move(s) | actions::split(ch);
CHECK(rgs.size() == 4u);
CHECK(rgs[0] == "This");
CHECK(rgs[1] == "is");
CHECK(rgs[2] == "his");
CHECK(rgs[3] == "face");
}
{
auto rgi = views::ints(1,21);
std::vector<std::vector<int>> rgv3 = actions::split(rgi, 10);
CHECK(rgv3.size() == 2u);
::check_equal(rgv3[0], {1,2,3,4,5,6,7,8,9});
::check_equal(rgv3[1], {11,12,13,14,15,16,17,18,19,20});
}
{
auto rgi = views::ints(1,21);
std::vector<std::vector<int>> rgv3 = std::move(rgi) | actions::split(10);
CHECK(rgv3.size() == 2u);
::check_equal(rgv3[0], {1,2,3,4,5,6,7,8,9});
::check_equal(rgv3[1], {11,12,13,14,15,16,17,18,19,20});
}
{
std::string str("now is \t the\ttime");
auto toks = actions::split_when(str, +[](int i) { return std::isspace(i); });
static_assert(std::is_same<decltype(toks), std::vector<std::string>>::value, "");
CHECK(toks.size() == 4u);
if(toks.size() == 4u)
{
CHECK(toks[0] == "now");
CHECK(toks[1] == "is");
CHECK(toks[2] == "the");
CHECK(toks[3] == "time");
}
}
{
std::string str("now is \t the\ttime");
auto toks =
std::move(str) | actions::split_when(+[](int i) { return std::isspace(i); });
static_assert(std::is_same<decltype(toks), std::vector<std::string>>::value, "");
CHECK(toks.size() == 4u);
if(toks.size() == 4u)
{
CHECK(toks[0] == "now");
CHECK(toks[1] == "is");
CHECK(toks[2] == "the");
CHECK(toks[3] == "time");
}
}
return ::test_result();
}
|
0 | repos/range-v3/test | repos/range-v3/test/action/transform.cpp | // Range v3 library
//
// Copyright Eric Niebler 2014-present
//
// Use, modification and distribution is subject to the
// Boost Software License, Version 1.0. (See accompanying
// file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt)
#include <array>
#include <vector>
#include <range/v3/core.hpp>
#include <range/v3/view/iota.hpp>
#include <range/v3/algorithm/copy.hpp>
#include <range/v3/algorithm/move.hpp>
#include <range/v3/algorithm/equal.hpp>
#include <range/v3/action/transform.hpp>
#include "../simple_test.hpp"
#include "../test_utils.hpp"
int main()
{
using namespace ranges;
auto v = views::ints(0,10) | to<std::vector>();
auto v0 = v | copy | actions::transform([](int i){return i*i;});
CPP_assert(same_as<decltype(v), decltype(v0)>);
::check_equal(v0, {0,1,4,9,16,25,36,49,64,81});
actions::transform(v, [](int i){return i*i;});
::check_equal(v, {0,1,4,9,16,25,36,49,64,81});
return ::test_result();
}
|
0 | repos/range-v3/test | repos/range-v3/test/action/unstable_remove_if.cpp | // Range v3 library
//
// Copyright Andrey Diduh 2019
//
// Use, modification and distribution is subject to the
// Boost Software License, Version 1.0. (See accompanying
// file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt)
//
// Project home: https://github.com/ericniebler/range-v3
#include <vector>
#include <cstdlib>
#include <ctime>
#include <random>
#include <range/v3/action/unstable_remove_if.hpp>
#include <range/v3/action/remove_if.hpp>
#include <range/v3/action/sort.hpp>
#include "../array.hpp"
#include "../simple_test.hpp"
#include "../test_utils.hpp"
void logic_test()
{
using namespace ranges;
const auto make_vector = []() -> std::vector<int> {
return {1,2,3,4,5};
};
// empty
{
std::vector<int> vec;
vec |= actions::unstable_remove_if([](int) { return true; });
CHECK(vec.empty());
}
// all stay
{
std::vector<int> vec = make_vector();
vec |= actions::unstable_remove_if([](int) { return false; });
check_equal(vec, {1,2,3,4,5});
}
// all remove
{
std::vector<int> vec = make_vector();
vec |= actions::unstable_remove_if([](int) { return true; });
CHECK(vec.empty());
}
// remove one in the middle
{
std::vector<int> vec = make_vector();
vec |= actions::unstable_remove_if([](int i) { return i == 2; });
check_equal(vec, {1,5,3,4});
}
// remove first
{
std::vector<int> vec = make_vector();
vec |= actions::unstable_remove_if([](int i) { return i == 1; });
check_equal(vec, {5,2,3,4});
}
// remove last
{
std::vector<int> vec = make_vector();
vec |= actions::unstable_remove_if([](int i) { return i == 5; });
check_equal(vec, {1,2,3,4});
}
// remove group in the middle
{
std::vector<int> vec = make_vector();
vec |= actions::unstable_remove_if([](int i) { return i == 2 || i == 3 || i == 4; });
check_equal(vec, {1,5});
}
// remove group in the begin
{
std::vector<int> vec = make_vector();
vec |= actions::unstable_remove_if([](int i) { return i == 1 || i == 2 || i == 3; });
check_equal(vec, {5,4});
}
// remove group in the end
{
std::vector<int> vec = make_vector();
vec |= actions::unstable_remove_if([](int i) { return i == 3 || i == 4 || i == 5; });
check_equal(vec, {1,2});
}
// remains one in the middle
{
std::vector<int> vec = make_vector();
vec |= actions::unstable_remove_if([](int i) { return i != 3; });
check_equal(vec, {3});
}
// remains group in the middle
{
std::vector<int> vec = make_vector();
vec |= actions::unstable_remove_if([](int i) { return (i != 3) && (i != 4); });
check_equal(vec, {4,3});
}
}
void num_pred_calls_test()
{
// std::ranges::remove_if requires:
// "Exactly N applications of the corresponding predicate and any projection, where N = (last - first)"
// https://en.cppreference.com/w/cpp/algorithm/ranges/remove
// so expect the same of unstable_remove_if
using namespace ranges;
int pred_invocation_counter = 0;
auto is_zero_count_invocations = [&pred_invocation_counter](int i) {
++pred_invocation_counter;
return i == 0;
};
{
std::vector<int> vec{0};
pred_invocation_counter = 0;
vec |= actions::unstable_remove_if(is_zero_count_invocations);
check_equal(pred_invocation_counter, 1);
}
{
std::vector<int> vec{1,1,1};
pred_invocation_counter = 0;
vec |= actions::unstable_remove_if(is_zero_count_invocations);
check_equal(pred_invocation_counter, 3);
}
{
std::vector<int> vec{1,0};
pred_invocation_counter = 0;
vec |= actions::unstable_remove_if(is_zero_count_invocations);
check_equal(pred_invocation_counter, 2);
}
{
std::vector<int> vec{1,2,0};
pred_invocation_counter = 0;
vec |= actions::unstable_remove_if(is_zero_count_invocations);
check_equal(pred_invocation_counter, 3);
}
{
std::vector<int> vec{0,0,0,0};
pred_invocation_counter = 0;
vec |= actions::unstable_remove_if(is_zero_count_invocations);
check_equal(pred_invocation_counter, 4);
}
{
std::vector<int> vec{1,2,3,0,0,0,0,4,5};
pred_invocation_counter = 0;
vec |= actions::unstable_remove_if(is_zero_count_invocations);
check_equal(pred_invocation_counter, 9);
}
}
class fuzzy_test_fn
{
int size;
#if defined(__GLIBCXX__) && defined(RANGES_WORKAROUND_VALGRIND_RDRAND)
std::random_device rd{"/dev/urandom"};
#else
std::random_device rd;
#endif
std::mt19937 eng{rd()};
std::uniform_int_distribution<int> distr;
public:
explicit fuzzy_test_fn(int sz)
: size(sz)
, distr{0, sz}
{}
void operator()()
{
struct Int
{
int value;
explicit Int(int v)
: value(v)
{}
Int(Int const &) = default;
Int(Int&& other) noexcept
: value(0)
{
*this = std::move(other);
}
Int &operator=(Int const &) = default;
Int &operator=(Int&& other) noexcept
{
const int sentinel = -1;
CHECK(other.value != sentinel);
value = other.value;
other.value = sentinel;
return *this;
}
RANGES_DIAGNOSTIC_PUSH
RANGES_DIAGNOSTIC_IGNORE_UNNEEDED_MEMBER
bool operator==(Int const &other) const
{
return value == other.value;
}
bool operator!=(Int const &other) const
{
return value != other.value;
}
bool operator<(Int const &other) const
{
return value < other.value;
}
bool operator>(Int const &other) const
{
return value > other.value;
}
bool operator<=(Int const &other) const
{
return value <= other.value;
}
bool operator>=(Int const &other) const
{
return value >= other.value;
}
RANGES_DIAGNOSTIC_POP
};
using namespace ranges;
std::vector<Int> ordered_list;
std::vector<Int> unordered_list;
// fill
for(int i=0; i < size; ++i)
{
ordered_list.emplace_back(i);
unordered_list.emplace_back(i);
}
// erase
const int erase_count = distr(eng);
for(int i=0; i < erase_count; ++i)
{
const int value = distr(eng);
const auto pred = [value](Int j) { return j.value == value; };
unordered_list |= actions::unstable_remove_if(pred);
ordered_list |= actions::remove_if(pred);
}
// compare
unordered_list |= actions::sort;
CHECK(ordered_list == unordered_list);
}
};
int main()
{
logic_test();
num_pred_calls_test();
{
const int size = 100;
const int repeats = 1000;
fuzzy_test_fn fuzzy_test(size);
for(int i=0; i < repeats; ++i)
fuzzy_test();
}
return ::test_result();
}
|
0 | repos/range-v3/test | repos/range-v3/test/action/stable_sort.cpp | // Range v3 library
//
// Copyright Eric Niebler 2014-present
//
// Use, modification and distribution is subject to the
// Boost Software License, Version 1.0. (See accompanying
// file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt)
#include <array>
#include <random>
#include <vector>
#include <range/v3/core.hpp>
#include <range/v3/view/iota.hpp>
#include <range/v3/view/stride.hpp>
#include <range/v3/view/take.hpp>
#include <range/v3/algorithm/shuffle.hpp>
#include <range/v3/algorithm/copy.hpp>
#include <range/v3/algorithm/move.hpp>
#include <range/v3/algorithm/is_sorted.hpp>
#include <range/v3/algorithm/equal.hpp>
#include <range/v3/action/shuffle.hpp>
#include <range/v3/action/stable_sort.hpp>
#include "../simple_test.hpp"
#include "../test_utils.hpp"
#if !defined(__clang__) || !defined(_MSVC_STL_VERSION) // Avoid #890
void test_bug632()
{
const std::vector<double> scores = { 3.0, 1.0, 2.0 };
std::vector<int> indices = { 0, 1, 2 };
indices |= ranges::actions::stable_sort(
ranges::less{},
[&] (const int &x) { return scores[ (std::size_t)x ]; }
);
::check_equal( indices, {1, 2, 0} );
}
int main()
{
using namespace ranges;
std::mt19937 gen;
auto v = views::ints(0,100) | to<std::vector>();
v |= actions::shuffle(gen);
CHECK(!is_sorted(v));
auto v2 = v | copy | actions::stable_sort;
CHECK(size(v2) == size(v));
CHECK(is_sorted(v2));
CHECK(!is_sorted(v));
CPP_assert(same_as<decltype(v), decltype(v2)>);
v |= actions::stable_sort;
CHECK(is_sorted(v));
v |= actions::shuffle(gen);
CHECK(!is_sorted(v));
v = v | move | actions::stable_sort(std::less<int>());
CHECK(is_sorted(v));
CHECK(equal(v, v2));
// Container algorithms can also be called directly
// in which case they take and return by reference
shuffle(v, gen);
CHECK(!is_sorted(v));
auto & v3 = actions::stable_sort(v);
CHECK(is_sorted(v));
CHECK(&v3 == &v);
auto r = views::ref(v);
r |= actions::stable_sort;
// Can pipe a view to a "container" algorithm.
actions::stable_sort(v, std::greater<int>());
v | views::stride(2) | actions::stable_sort;
check_equal(views::take(v, 10), {1,98,3,96,5,94,7,92,9,90});
test_bug632();
return ::test_result();
}
#else // Avoid #890
int main() {}
#endif // Avoid #890
|
0 | repos/range-v3/test | repos/range-v3/test/action/CMakeLists.txt | set(CMAKE_FOLDER "${CMAKE_FOLDER}/action")
rv3_add_test(test.act.concepts act.concepts cont_concepts.cpp)
rv3_add_test(test.act.adjacent_remove_if act.adjacent_remove_if adjacent_remove_if.cpp)
rv3_add_test(test.act.drop act.drop drop.cpp)
rv3_add_test(test.act.drop_while act.drop_while drop_while.cpp)
rv3_add_test(test.act.insert act.insert insert.cpp)
rv3_add_test(test.act.join act.join join.cpp)
rv3_add_test(test.act.push_front act.push_front push_front.cpp)
rv3_add_test(test.act.push_back act.push_back push_back.cpp)
rv3_add_test(test.act.remove_if act.remove_if remove_if.cpp)
rv3_add_test(test.act.remove act.remove remove.cpp)
rv3_add_test(test.act.unstable_remove_if act.unstable_remove_if unstable_remove_if.cpp)
rv3_add_test(test.act.reverse act.reverse reverse.cpp)
rv3_add_test(test.act.shuffle act.shuffle shuffle.cpp)
rv3_add_test(test.act.slice act.slice slice.cpp)
rv3_add_test(test.act.sort act.sort sort.cpp)
rv3_add_test(test.act.split act.split split.cpp)
rv3_add_test(test.act.stable_sort act.stable_sort stable_sort.cpp)
rv3_add_test(test.act.stride act.stride stride.cpp)
rv3_add_test(test.act.take act.take take.cpp)
rv3_add_test(test.act.take_while act.take_while take_while.cpp)
rv3_add_test(test.act.transform act.transform transform.cpp)
rv3_add_test(test.act.unique act.unique unique.cpp)
|
0 | repos/range-v3/test | repos/range-v3/test/action/push_back.cpp | // Range v3 library
//
// Copyright Eric Niebler 2014-present
//
// Use, modification and distribution is subject to the
// Boost Software License, Version 1.0. (See accompanying
// file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt)
#include <list>
#include <vector>
#include <range/v3/core.hpp>
#include <range/v3/view/iota.hpp>
#include <range/v3/view/take.hpp>
#include <range/v3/view/for_each.hpp>
#include <range/v3/action/push_back.hpp>
#include "../simple_test.hpp"
#include "../test_utils.hpp"
int main()
{
using namespace ranges;
{
std::vector<int> v;
push_back(v, {1,2,3});
::check_equal(v, {1,2,3});
push_back(v, views::iota(10) | views::take(3));
::check_equal(v, {1,2,3,10,11,12});
push_back(v, views::iota(10) | views::take(3));
::check_equal(v, {1,2,3,10,11,12,10,11,12});
int rg[] = {9,8,7};
push_back(v, rg);
::check_equal(v, {1,2,3,10,11,12,10,11,12,9,8,7});
push_back(v, rg);
::check_equal(v, {1,2,3,10,11,12,10,11,12,9,8,7,9,8,7});
std::list<int> s;
push_back(s,
views::ints|views::take(10)|views::for_each([](int i){return yield_if(i%2==0,i);}));
::check_equal(s, {0,2,4,6,8});
push_back(s, 10);
::check_equal(s, {0,2,4,6,8,10});
}
{
std::vector<int> v;
v = std::move(v) | push_back({1,2,3});
::check_equal(v, {1,2,3});
v = std::move(v) | push_back(views::iota(10) | views::take(3));
::check_equal(v, {1,2,3,10,11,12});
v = std::move(v) | push_back(views::iota(10) | views::take(3));
::check_equal(v, {1,2,3,10,11,12,10,11,12});
int rg[] = {9,8,7};
v = std::move(v) | push_back(rg);
::check_equal(v, {1,2,3,10,11,12,10,11,12,9,8,7});
v = std::move(v) | push_back(rg);
::check_equal(v, {1,2,3,10,11,12,10,11,12,9,8,7,9,8,7});
std::list<int> s;
s = std::move(s) | push_back(
views::ints|views::take(10)|views::for_each([](int i){return yield_if(i%2==0,i);}));
::check_equal(s, {0,2,4,6,8});
s = std::move(s) | push_back(10);
::check_equal(s, {0,2,4,6,8,10});
}
{
std::vector<int> v;
v |= push_back({1,2,3});
::check_equal(v, {1,2,3});
v |= push_back(views::iota(10) | views::take(3));
::check_equal(v, {1,2,3,10,11,12});
v |= push_back(views::iota(10) | views::take(3));
::check_equal(v, {1,2,3,10,11,12,10,11,12});
int rg[] = {9,8,7};
v |= push_back(rg);
::check_equal(v, {1,2,3,10,11,12,10,11,12,9,8,7});
v |= push_back(rg);
::check_equal(v, {1,2,3,10,11,12,10,11,12,9,8,7,9,8,7});
std::list<int> s;
s |= push_back(
views::ints|views::take(10)|views::for_each([](int i){return yield_if(i%2==0,i);}));
::check_equal(s, {0,2,4,6,8});
s |= push_back(10);
::check_equal(s, {0,2,4,6,8,10});
}
return ::test_result();
}
|
0 | repos/range-v3/test | repos/range-v3/test/action/reverse.cpp | // Range v3 library
//
// Copyright Eric Niebler 2014-present
//
// Use, modification and distribution is subject to the
// Boost Software License, Version 1.0. (See accompanying
// file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt)
#include <vector>
#include <range/v3/core.hpp>
#include <range/v3/view/iota.hpp>
#include <range/v3/view/repeat_n.hpp>
#include <range/v3/view/for_each.hpp>
#include <range/v3/action/reverse.hpp>
#include <range/v3/action/unique.hpp>
#include "../simple_test.hpp"
#include "../test_utils.hpp"
using namespace ranges;
int main()
{
// [1,2,2,3,3,3,4,4,4,4,5,5,5,5,5,...]
auto v =
views::for_each(views::ints(1,6), [](int i){
return yield_from(views::repeat_n(i,i));
}) | to<std::vector>();
check_equal(v, {1,2,2,3,3,3,4,4,4,4,5,5,5,5,5});
v |= actions::unique | actions::reverse;
check_equal(v, {5,4,3,2,1});
return ::test_result();
}
|
0 | repos/range-v3/test | repos/range-v3/test/action/shuffle.cpp | // Range v3 library
//
// Copyright Filip Matzner 2015
//
// Use, modification and distribution is subject to the
// Boost Software License, Version 1.0. (See accompanying
// file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt)
#include <vector>
#include <random>
#include <range/v3/core.hpp>
#include <range/v3/view/iota.hpp>
#include <range/v3/view/stride.hpp>
#include <range/v3/algorithm/copy.hpp>
#include <range/v3/algorithm/move.hpp>
#include <range/v3/algorithm/is_sorted.hpp>
#include <range/v3/algorithm/equal.hpp>
#include <range/v3/algorithm/sort.hpp>
#include <range/v3/action/shuffle.hpp>
#include "../simple_test.hpp"
#include "../test_utils.hpp"
int main()
{
using namespace ranges;
std::mt19937 gen;
// "Ints" view vs. shuffled
auto v = views::ints(0,100) | to<std::vector>();
auto v2 = v | copy | actions::shuffle(gen);
CHECK(is_sorted(v));
CHECK(!is_sorted(v2));
CHECK(size(v2) == size(v));
CPP_assert(same_as<decltype(v), decltype(v2)>);
CHECK(!equal(v, v2));
// "Ints" view vs. shuffled and sorted
sort(v2);
CHECK(is_sorted(v2));
CHECK(equal(v, v2));
// Shuffled vs. shuffled
v |= actions::shuffle(gen);
v2 = v2 | move | actions::shuffle(gen);
CHECK(!is_sorted(v));
CHECK(!is_sorted(v2));
CHECK(size(v2) == size(v));
CHECK(!equal(v, v2));
// Container algorithms can also be called directly
// in which case they take and return by reference
v = views::ints(0,100) | to<std::vector>();
auto & v3 = actions::shuffle(v, gen);
CHECK(!is_sorted(v));
CHECK(&v3 == &v);
// Create and shuffle container reference
v = views::ints(0,100) | to<std::vector>();
auto r = views::ref(v);
r |= actions::shuffle(gen);
CHECK(!is_sorted(v));
// Can pipe a view to a "container" algorithm.
v = views::ints(0,100) | to<std::vector>();
v | views::stride(2) | actions::shuffle(gen);
CHECK(!is_sorted(v));
return ::test_result();
}
|
0 | repos/range-v3/test | repos/range-v3/test/action/cont_concepts.cpp | // Range v3 library
//
// Copyright Eric Niebler 2014-present
//
// Use, modification and distribution is subject to the
// Boost Software License, Version 1.0. (See accompanying
// file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt)
#include <array>
#include <vector>
#include <memory>
#include <range/v3/core.hpp>
#include <range/v3/action/concepts.hpp>
#include <range/v3/view/ref.hpp>
#include "../simple_test.hpp"
#include "../test_utils.hpp"
int main()
{
using namespace ranges;
int rgi[6];
CPP_assert(range<decltype(rgi)>);
CPP_assert(!semi_container<decltype(rgi)>);
std::array<int, 6> a;
CPP_assert(semi_container<decltype(a)>);
CPP_assert(!container<decltype(a)>);
std::vector<int> v;
CPP_assert(container<decltype(v)>);
std::vector<std::unique_ptr<int>> v2;
CPP_assert(container<decltype(v2)>);
CPP_assert(lvalue_container_like<decltype((v2))>);
CPP_assert(!lvalue_container_like<decltype(std::move(v2))>);
CPP_assert(lvalue_container_like<decltype(views::ref(v2))>);
return ::test_result();
}
|
0 | repos/range-v3/test | repos/range-v3/test/action/adjacent_remove_if.cpp | /// \file
// Range v3 library
//
// Copyright Eric Niebler
// Copyright Christopher Di Bella
//
// Use, modification and distribution is subject to the
// Boost Software License, Version 1.0. (See accompanying
// file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt)
//
// Project home: https://github.com/ericniebler/range-v3
//
#include <range/v3/action/adjacent_remove_if.hpp>
#include "../simple_test.hpp"
#include "../test_utils.hpp"
#include <range/v3/core.hpp>
#include <range/v3/view/iota.hpp>
#include <vector>
int main()
{
using namespace ranges;
auto v = views::ints(1,21) | to<std::vector>();
auto & v2 = actions::adjacent_remove_if(v, [](int x, int y){ return (x + y) % 3 == 0; });
CHECK(std::addressof(v) == std::addressof(v2));
check_equal(v, {2, 3, 5, 6, 8, 9, 11, 12, 14, 15, 17, 18, 20});
v |= actions::adjacent_remove_if([](int x, int y){ return (y - x) == 2; });
check_equal(v, {2, 5, 8, 11, 14, 17, 20});
return ::test_result();
}
|
0 | repos/range-v3/test | repos/range-v3/test/action/remove_if.cpp | // Range v3 library
//
// Copyright Eric Niebler 2014-present
//
// Use, modification and distribution is subject to the
// Boost Software License, Version 1.0. (See accompanying
// file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt)
#include <vector>
#include <range/v3/core.hpp>
#include <range/v3/view/iota.hpp>
#include <range/v3/algorithm/move.hpp>
#include <range/v3/action/sort.hpp>
#include <range/v3/action/remove_if.hpp>
#include "../simple_test.hpp"
#include "../test_utils.hpp"
int main()
{
using namespace ranges;
auto v = views::ints(1,21) | to<std::vector>();
auto & v2 = actions::remove_if(v, [](int i){return i % 2 == 0;});
CHECK(&v2 == &v);
check_equal(v, {1,3,5,7,9,11,13,15,17,19});
auto && v3 = v | move | actions::remove_if(std::bind(std::less<int>{}, std::placeholders::_1, 10));
check_equal(v3, {11,13,15,17,19});
return ::test_result();
}
|
0 | repos/range-v3/test | repos/range-v3/test/action/drop.cpp | // Range v3 library
//
// Copyright Eric Niebler 2014-present
//
// Use, modification and distribution is subject to the
// Boost Software License, Version 1.0. (See accompanying
// file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt)
#include <vector>
#include <range/v3/core.hpp>
#include <range/v3/view/iota.hpp>
#include <range/v3/action/drop.hpp>
#include "../simple_test.hpp"
#include "../test_utils.hpp"
int main()
{
using namespace ranges;
auto v = views::ints(1,21) | to<std::vector>();
auto & v2 = actions::drop(v, 3);
CHECK(&v2 == &v);
CHECK(v.size() == 17u);
CHECK(v[0] == 4);
v = std::move(v) | actions::drop(3);
CHECK(v.size() == 14u);
CHECK(v[0] == 7);
v |= actions::drop(3);
CHECK(v.size() == 11u);
CHECK(v[0] == 10);
v |= actions::drop(100);
CHECK(v.size() == 0u);
return ::test_result();
}
|
Subsets and Splits
No saved queries yet
Save your SQL queries to embed, download, and access them later. Queries will appear here once saved.