This is an archive of the discontinued LLVM Phabricator instance.

Differential D109121

[libc++][NFC] Replace uses of stdr:: by just std::ranges::
ClosedPublic

Authored by ldionne on Sep 1 2021, 6:51 PM.

Details

Reviewers
• Quuxplusone
Group Reviewers
Restricted Project
Commits
rG9d7c420ad1f3: [libc++][NFC] Replace uses of stdr:: by just std::ranges::

Diff Detail

Event Timeline

ldionne requested review of this revision.Sep 1 2021, 6:51 PM
ldionne created this revision.
Herald added a project: Restricted Project. · View Herald TranscriptSep 1 2021, 6:51 PM
Herald added a reviewer: Restricted Project. · View Herald Transcript
Herald added a subscriber: libcxx-commits. · View Herald Transcript
Harbormaster completed remote builds in B122219: Diff 370133.Sep 1 2021, 6:52 PM
• Quuxplusone accepted this revision.Sep 2 2021, 6:54 AM
• Quuxplusone added a subscriber: • Quuxplusone.
• Quuxplusone added inline comments.
libcxx/test/std/containers/associative/multiset/range_concept_conformance.compile.pass.cpp
49

Absolutely bizarre that Phabricator fails to align these lines properly for the diff.
Maybe removing the blank line on 22 would help.
But anyway, ship it!

This revision is now accepted and ready to land.Sep 2 2021, 6:54 AM
This revision was landed with ongoing or failed builds.Sep 2 2021, 10:02 AM
Closed by commit rG9d7c420ad1f3: [libc++][NFC] Replace uses of stdr:: by just std::ranges:: (authored by ldionne). · Explain Why
This revision was automatically updated to reflect the committed changes.
ldionne added a commit: rG9d7c420ad1f3: [libc++][NFC] Replace uses of stdr:: by just std::ranges::.

Revision Contents

PathSize
libcxx/
test/
std/
containers/
associative/
map/
38 lines
multimap/
38 lines
multiset/
33 lines
set/
42 lines
sequences/
array/
38 lines
deque/
38 lines
forwardlist/
38 lines
list/
38 lines
vector.bool/
38 lines
vector/
38 lines
unord/
unord.map/
38 lines
unord.multimap/
38 lines
unord.multiset/
38 lines
unord.set/
38 lines
views/
38 lines
input.output/
filesystems/
class.directory_iterator/
66 lines
class.path/
38 lines
ranges/
range.req/
range.range/
10 lines
14 lines
12 lines
16 lines
range.refinements/
18 lines
30 lines
18 lines
34 lines
range.sized/
42 lines
re/
re.results/
38 lines
strings/
basic.string/
38 lines
string.view/
38 lines

Diff 370313

libcxx/test/std/containers/associative/map/range_concept_conformance.compile.pass.cpp

Show All 12 Lines
// map // map
#include <map> #include <map>
#include <concepts> #include <concepts>
#include <ranges> #include <ranges>
using range = std::map<int, int>; using range = std::map<int, int>;
namespace stdr = std::ranges;
static_assert(std::same_as<stdr::iterator_t<range>, range::iterator>);
static_assert(stdr::common_range<range>); static_assert(std::same_as<std::ranges::iterator_t<range>, range::iterator>);
static_assert(stdr::bidirectional_range<range>); static_assert(std::ranges::common_range<range>);
static_assert(!stdr::view<range>); static_assert(std::ranges::bidirectional_range<range>);
static_assert(!stdr::random_access_range<range>); static_assert(!std::ranges::view<range>);
static_assert(stdr::sized_range<range>); static_assert(!std::ranges::random_access_range<range>);
static_assert(!stdr::borrowed_range<range>); static_assert(std::ranges::sized_range<range>);
static_assert(!stdr::viewable_range<range>); static_assert(!std::ranges::borrowed_range<range>);
static_assert(!std::ranges::viewable_range<range>);
static_assert(std::same_as<stdr::iterator_t<range const>, range::const_iterator>);
static_assert(stdr::common_range<range const>); static_assert(std::same_as<std::ranges::iterator_t<range const>, range::const_iterator>);
static_assert(stdr::bidirectional_range<range const>); static_assert(std::ranges::common_range<range const>);
static_assert(!stdr::view<range const>); static_assert(std::ranges::bidirectional_range<range const>);
static_assert(!stdr::random_access_range<range const>); static_assert(!std::ranges::view<range const>);
static_assert(stdr::sized_range<range const>); static_assert(!std::ranges::random_access_range<range const>);
static_assert(!stdr::borrowed_range<range const>); static_assert(std::ranges::sized_range<range const>);
static_assert(!stdr::viewable_range<range const>); static_assert(!std::ranges::borrowed_range<range const>);
static_assert(!std::ranges::viewable_range<range const>);

libcxx/test/std/containers/associative/multimap/range_concept_conformance.compile.pass.cpp

Show All 12 Lines
// multimap // multimap
#include <map> #include <map>
#include <concepts> #include <concepts>
#include <ranges> #include <ranges>
using range = std::multimap<int, int>; using range = std::multimap<int, int>;
namespace stdr = std::ranges;
static_assert(std::same_as<stdr::iterator_t<range>, range::iterator>);
static_assert(stdr::common_range<range>); static_assert(std::same_as<std::ranges::iterator_t<range>, range::iterator>);
static_assert(stdr::bidirectional_range<range>); static_assert(std::ranges::common_range<range>);
static_assert(!stdr::view<range>); static_assert(std::ranges::bidirectional_range<range>);
static_assert(!stdr::random_access_range<range>); static_assert(!std::ranges::view<range>);
static_assert(stdr::sized_range<range>); static_assert(!std::ranges::random_access_range<range>);
static_assert(!stdr::borrowed_range<range>); static_assert(std::ranges::sized_range<range>);
static_assert(!stdr::viewable_range<range>); static_assert(!std::ranges::borrowed_range<range>);
static_assert(!std::ranges::viewable_range<range>);
static_assert(std::same_as<stdr::iterator_t<range const>, range::const_iterator>);
static_assert(stdr::common_range<range const>); static_assert(std::same_as<std::ranges::iterator_t<range const>, range::const_iterator>);
static_assert(stdr::bidirectional_range<range const>); static_assert(std::ranges::common_range<range const>);
static_assert(!stdr::view<range const>); static_assert(std::ranges::bidirectional_range<range const>);
static_assert(!stdr::random_access_range<range const>); static_assert(!std::ranges::view<range const>);
static_assert(stdr::sized_range<range const>); static_assert(!std::ranges::random_access_range<range const>);
static_assert(!stdr::borrowed_range<range const>); static_assert(std::ranges::sized_range<range const>);
static_assert(!stdr::viewable_range<range const>); static_assert(!std::ranges::borrowed_range<range const>);
static_assert(!std::ranges::viewable_range<range const>);

libcxx/test/std/containers/associative/multiset/range_concept_conformance.compile.pass.cpp

Show All 12 Lines
// multiset // multiset
#include <set> #include <set>
#include <concepts> #include <concepts>
#include <ranges> #include <ranges>
using range = std::multiset<int>; using range = std::multiset<int>;
namespace stdr = std::ranges;
static_assert(std::same_as<stdr::iterator_t<range>, range::iterator>); static_assert(std::same_as<std::ranges::iterator_t<range>, range::iterator>);
static_assert(stdr::common_range<range>); static_assert(std::ranges::common_range<range>);
static_assert(stdr::bidirectional_range<range>); static_assert(std::ranges::bidirectional_range<range>);
static_assert(!stdr::view<range>); static_assert(!std::ranges::view<range>);
static_assert(!stdr::random_access_range<range>); static_assert(!std::ranges::random_access_range<range>);
static_assert(stdr::sized_range<range>); static_assert(std::ranges::sized_range<range>);
static_assert(!stdr::borrowed_range<range>); static_assert(!std::ranges::borrowed_range<range>);
static_assert(!stdr::viewable_range<range>); static_assert(!std::ranges::viewable_range<range>);
static_assert(std::same_as<stdr::iterator_t<range const>, range::const_iterator>); static_assert(std::same_as<std::ranges::iterator_t<range const>, range::const_iterator>);
static_assert(stdr::common_range<range const>); static_assert(std::ranges::common_range<range const>);
static_assert(stdr::bidirectional_range<range const>); static_assert(std::ranges::bidirectional_range<range const>);
static_assert(!stdr::view<range const>); static_assert(!std::ranges::view<range const>);
static_assert(!stdr::random_access_range<range const>); static_assert(!std::ranges::random_access_range<range const>);
static_assert(stdr::sized_range<range const>); static_assert(std::ranges::sized_range<range const>);
static_assert(!stdr::borrowed_range<range const>); static_assert(!std::ranges::borrowed_range<range const>);
static_assert(!stdr::viewable_range<range const>); static_assert(!std::ranges::viewable_range<range const>);
QuuxplusoneUnsubmitted
Not Done
ReplyInline Actions

Absolutely bizarre that Phabricator fails to align these lines properly for the diff.
Maybe removing the blank line on 22 would help.
But anyway, ship it!

Quuxplusone: Absolutely bizarre that Phabricator fails to align these lines properly for the diff. Maybe…

libcxx/test/std/containers/associative/set/range_concept_conformance.compile.pass.cpp

Show All 12 Lines
// set // set
#include <set> #include <set>
#include <concepts> #include <concepts>
#include <ranges> #include <ranges>
using range = std::set<int>; using range = std::set<int>;
namespace stdr = std::ranges;
static_assert(std::same_as<stdr::iterator_t<range>, range::iterator>);
static_assert(stdr::bidirectional_range<range>); static_assert(std::same_as<std::ranges::iterator_t<range>, range::iterator>);
static_assert(!stdr::random_access_range<range>); static_assert(std::ranges::bidirectional_range<range>);
static_assert(stdr::common_range<range>); static_assert(!std::ranges::random_access_range<range>);
static_assert(stdr::input_range<range>); static_assert(std::ranges::common_range<range>);
static_assert(!stdr::view<range>); static_assert(std::ranges::input_range<range>);
static_assert(stdr::sized_range<range>); static_assert(!std::ranges::view<range>);
static_assert(!stdr::borrowed_range<range>); static_assert(std::ranges::sized_range<range>);
static_assert(!stdr::viewable_range<range>); static_assert(!std::ranges::borrowed_range<range>);
static_assert(!std::ranges::viewable_range<range>);
static_assert(std::same_as<stdr::iterator_t<range const>, range::const_iterator>);
static_assert(stdr::bidirectional_range<range const>); static_assert(std::same_as<std::ranges::iterator_t<range const>, range::const_iterator>);
static_assert(!stdr::random_access_range<range const>); static_assert(std::ranges::bidirectional_range<range const>);
static_assert(stdr::common_range<range const>); static_assert(!std::ranges::random_access_range<range const>);
static_assert(stdr::input_range<range>); static_assert(std::ranges::common_range<range const>);
static_assert(!stdr::view<range const>); static_assert(std::ranges::input_range<range>);
static_assert(stdr::sized_range<range const>); static_assert(!std::ranges::view<range const>);
static_assert(!stdr::borrowed_range<range const>); static_assert(std::ranges::sized_range<range const>);
static_assert(!stdr::viewable_range<range const>); static_assert(!std::ranges::borrowed_range<range const>);
static_assert(!std::ranges::viewable_range<range const>);

libcxx/test/std/containers/sequences/array/range_concept_conformance.compile.pass.cpp

Show All 12 Lines
// array // array
#include <array> #include <array>
#include <concepts> #include <concepts>
#include <ranges> #include <ranges>
using range = std::array<int, 10>; using range = std::array<int, 10>;
namespace stdr = std::ranges;
static_assert(!stdr::view<range>);
static_assert(std::same_as<stdr::iterator_t<range>, range::iterator>); static_assert(!std::ranges::view<range>);
static_assert(stdr::common_range<range>); static_assert(std::same_as<std::ranges::iterator_t<range>, range::iterator>);
static_assert(stdr::random_access_range<range>); static_assert(std::ranges::common_range<range>);
static_assert(stdr::contiguous_range<range>); static_assert(std::ranges::random_access_range<range>);
static_assert(stdr::sized_range<range>); static_assert(std::ranges::contiguous_range<range>);
static_assert(!stdr::borrowed_range<range>); static_assert(std::ranges::sized_range<range>);
static_assert(!stdr::viewable_range<range>); static_assert(!std::ranges::borrowed_range<range>);
static_assert(!std::ranges::viewable_range<range>);
static_assert(!stdr::view<range const>);
static_assert(std::same_as<stdr::iterator_t<range const>, range::const_iterator>); static_assert(!std::ranges::view<range const>);
static_assert(stdr::common_range<range const>); static_assert(std::same_as<std::ranges::iterator_t<range const>, range::const_iterator>);
static_assert(stdr::random_access_range<range const>); static_assert(std::ranges::common_range<range const>);
static_assert(stdr::contiguous_range<range const>); static_assert(std::ranges::random_access_range<range const>);
static_assert(stdr::sized_range<range const>); static_assert(std::ranges::contiguous_range<range const>);
static_assert(!stdr::borrowed_range<range const>); static_assert(std::ranges::sized_range<range const>);
static_assert(!stdr::viewable_range<range const>); static_assert(!std::ranges::borrowed_range<range const>);
static_assert(!std::ranges::viewable_range<range const>);

libcxx/test/std/containers/sequences/deque/range_concept_conformance.compile.pass.cpp

Show All 12 Lines
// deque // deque
#include <deque> #include <deque>
#include <concepts> #include <concepts>
#include <ranges> #include <ranges>
using range = std::deque<int>; using range = std::deque<int>;
namespace stdr = std::ranges;
static_assert(std::same_as<stdr::iterator_t<range>, range::iterator>);
static_assert(stdr::common_range<range>); static_assert(std::same_as<std::ranges::iterator_t<range>, range::iterator>);
static_assert(stdr::random_access_range<range>); static_assert(std::ranges::common_range<range>);
static_assert(!stdr::contiguous_range<range>); static_assert(std::ranges::random_access_range<range>);
static_assert(!stdr::view<range>); static_assert(!std::ranges::contiguous_range<range>);
static_assert(stdr::sized_range<range>); static_assert(!std::ranges::view<range>);
static_assert(!stdr::borrowed_range<range>); static_assert(std::ranges::sized_range<range>);
static_assert(!stdr::viewable_range<range>); static_assert(!std::ranges::borrowed_range<range>);
static_assert(!std::ranges::viewable_range<range>);
static_assert(std::same_as<stdr::iterator_t<range const>, range::const_iterator>);
static_assert(stdr::common_range<range const>); static_assert(std::same_as<std::ranges::iterator_t<range const>, range::const_iterator>);
static_assert(stdr::random_access_range<range const>); static_assert(std::ranges::common_range<range const>);
static_assert(!stdr::contiguous_range<range const>); static_assert(std::ranges::random_access_range<range const>);
static_assert(!stdr::view<range const>); static_assert(!std::ranges::contiguous_range<range const>);
static_assert(stdr::sized_range<range const>); static_assert(!std::ranges::view<range const>);
static_assert(!stdr::borrowed_range<range const>); static_assert(std::ranges::sized_range<range const>);
static_assert(!stdr::viewable_range<range const>); static_assert(!std::ranges::borrowed_range<range const>);
static_assert(!std::ranges::viewable_range<range const>);

libcxx/test/std/containers/sequences/forwardlist/range_concept_conformance.compile.pass.cpp

Show All 12 Lines
// forward_list // forward_list
#include <forward_list> #include <forward_list>
#include <concepts> #include <concepts>
#include <ranges> #include <ranges>
using range = std::forward_list<int>; using range = std::forward_list<int>;
namespace stdr = std::ranges;
static_assert(std::same_as<stdr::iterator_t<range>, range::iterator>);
static_assert(stdr::common_range<range>); static_assert(std::same_as<std::ranges::iterator_t<range>, range::iterator>);
static_assert(stdr::forward_range<range>); static_assert(std::ranges::common_range<range>);
static_assert(!stdr::bidirectional_range<range>); static_assert(std::ranges::forward_range<range>);
static_assert(!stdr::view<range>); static_assert(!std::ranges::bidirectional_range<range>);
static_assert(!stdr::sized_range<range>); static_assert(!std::ranges::view<range>);
static_assert(!stdr::borrowed_range<range>); static_assert(!std::ranges::sized_range<range>);
static_assert(!stdr::viewable_range<range>); static_assert(!std::ranges::borrowed_range<range>);
static_assert(!std::ranges::viewable_range<range>);
static_assert(std::same_as<stdr::iterator_t<range const>, range::const_iterator>);
static_assert(stdr::common_range<range const>); static_assert(std::same_as<std::ranges::iterator_t<range const>, range::const_iterator>);
static_assert(stdr::forward_range<range const>); static_assert(std::ranges::common_range<range const>);
static_assert(!stdr::bidirectional_range<range const>); static_assert(std::ranges::forward_range<range const>);
static_assert(!stdr::view<range const>); static_assert(!std::ranges::bidirectional_range<range const>);
static_assert(!stdr::sized_range<range const>); static_assert(!std::ranges::view<range const>);
static_assert(!stdr::borrowed_range<range const>); static_assert(!std::ranges::sized_range<range const>);
static_assert(!stdr::viewable_range<range const>); static_assert(!std::ranges::borrowed_range<range const>);
static_assert(!std::ranges::viewable_range<range const>);

libcxx/test/std/containers/sequences/list/range_concept_conformance.compile.pass.cpp

Show All 12 Lines
// list // list
#include <list> #include <list>
#include <concepts> #include <concepts>
#include <ranges> #include <ranges>
using range = std::list<int>; using range = std::list<int>;
namespace stdr = std::ranges;
static_assert(std::same_as<stdr::iterator_t<range>, range::iterator>);
static_assert(stdr::common_range<range>); static_assert(std::same_as<std::ranges::iterator_t<range>, range::iterator>);
static_assert(stdr::bidirectional_range<range>); static_assert(std::ranges::common_range<range>);
static_assert(!stdr::view<range>); static_assert(std::ranges::bidirectional_range<range>);
static_assert(!stdr::random_access_range<range>); static_assert(!std::ranges::view<range>);
static_assert(stdr::sized_range<range>); static_assert(!std::ranges::random_access_range<range>);
static_assert(!stdr::borrowed_range<range>); static_assert(std::ranges::sized_range<range>);
static_assert(!stdr::viewable_range<range>); static_assert(!std::ranges::borrowed_range<range>);
static_assert(!std::ranges::viewable_range<range>);
static_assert(std::same_as<stdr::iterator_t<range const>, range::const_iterator>);
static_assert(stdr::common_range<range const>); static_assert(std::same_as<std::ranges::iterator_t<range const>, range::const_iterator>);
static_assert(stdr::bidirectional_range<range const>); static_assert(std::ranges::common_range<range const>);
static_assert(!stdr::view<range const>); static_assert(std::ranges::bidirectional_range<range const>);
static_assert(!stdr::random_access_range<range const>); static_assert(!std::ranges::view<range const>);
static_assert(stdr::sized_range<range const>); static_assert(!std::ranges::random_access_range<range const>);
static_assert(!stdr::borrowed_range<range const>); static_assert(std::ranges::sized_range<range const>);
static_assert(!stdr::viewable_range<range const>); static_assert(!std::ranges::borrowed_range<range const>);
static_assert(!std::ranges::viewable_range<range const>);

libcxx/test/std/containers/sequences/vector.bool/range_concept_conformance.compile.pass.cpp

Show All 12 Lines
// vector // vector
#include <vector> #include <vector>
#include <concepts> #include <concepts>
#include <ranges> #include <ranges>
using range = std::vector<bool>; using range = std::vector<bool>;
namespace stdr = std::ranges;
static_assert(std::same_as<stdr::iterator_t<range>, range::iterator>);
static_assert(stdr::common_range<range>); static_assert(std::same_as<std::ranges::iterator_t<range>, range::iterator>);
static_assert(stdr::random_access_range<range>); static_assert(std::ranges::common_range<range>);
static_assert(!stdr::contiguous_range<range>); static_assert(std::ranges::random_access_range<range>);
static_assert(!stdr::view<range>); static_assert(!std::ranges::contiguous_range<range>);
static_assert(stdr::sized_range<range>); static_assert(!std::ranges::view<range>);
static_assert(!stdr::borrowed_range<range>); static_assert(std::ranges::sized_range<range>);
static_assert(!stdr::viewable_range<range>); static_assert(!std::ranges::borrowed_range<range>);
static_assert(!std::ranges::viewable_range<range>);
static_assert(std::same_as<stdr::iterator_t<range const>, range::const_iterator>);
static_assert(stdr::common_range<range const>); static_assert(std::same_as<std::ranges::iterator_t<range const>, range::const_iterator>);
static_assert(stdr::random_access_range<range const>); static_assert(std::ranges::common_range<range const>);
static_assert(!stdr::contiguous_range<range const>); static_assert(std::ranges::random_access_range<range const>);
static_assert(!stdr::view<range const>); static_assert(!std::ranges::contiguous_range<range const>);
static_assert(stdr::sized_range<range const>); static_assert(!std::ranges::view<range const>);
static_assert(!stdr::borrowed_range<range const>); static_assert(std::ranges::sized_range<range const>);
static_assert(!stdr::viewable_range<range const>); static_assert(!std::ranges::borrowed_range<range const>);
static_assert(!std::ranges::viewable_range<range const>);

libcxx/test/std/containers/sequences/vector/range_concept_conformance.compile.pass.cpp

Show All 12 Lines
// vector // vector
#include <vector> #include <vector>
#include <concepts> #include <concepts>
#include <ranges> #include <ranges>
using range = std::vector<int>; using range = std::vector<int>;
namespace stdr = std::ranges;
static_assert(std::same_as<stdr::iterator_t<range>, range::iterator>);
static_assert(stdr::common_range<range>); static_assert(std::same_as<std::ranges::iterator_t<range>, range::iterator>);
static_assert(stdr::random_access_range<range>); static_assert(std::ranges::common_range<range>);
static_assert(stdr::contiguous_range<range>); static_assert(std::ranges::random_access_range<range>);
static_assert(!stdr::view<range>); static_assert(std::ranges::contiguous_range<range>);
static_assert(stdr::sized_range<range>); static_assert(!std::ranges::view<range>);
static_assert(!stdr::borrowed_range<range>); static_assert(std::ranges::sized_range<range>);
static_assert(!stdr::viewable_range<range>); static_assert(!std::ranges::borrowed_range<range>);
static_assert(!std::ranges::viewable_range<range>);
static_assert(std::same_as<stdr::iterator_t<range const>, range::const_iterator>);
static_assert(stdr::common_range<range const>); static_assert(std::same_as<std::ranges::iterator_t<range const>, range::const_iterator>);
static_assert(stdr::random_access_range<range const>); static_assert(std::ranges::common_range<range const>);
static_assert(stdr::contiguous_range<range const>); static_assert(std::ranges::random_access_range<range const>);
static_assert(!stdr::view<range const>); static_assert(std::ranges::contiguous_range<range const>);
static_assert(stdr::sized_range<range const>); static_assert(!std::ranges::view<range const>);
static_assert(!stdr::borrowed_range<range const>); static_assert(std::ranges::sized_range<range const>);
static_assert(!stdr::viewable_range<range const>); static_assert(!std::ranges::borrowed_range<range const>);
static_assert(!std::ranges::viewable_range<range const>);

libcxx/test/std/containers/unord/unord.map/range_concept_conformance.compile.pass.cpp

Show All 12 Lines
// unordered_map // unordered_map
#include <unordered_map> #include <unordered_map>
#include <concepts> #include <concepts>
#include <ranges> #include <ranges>
using range = std::unordered_map<int, int>; using range = std::unordered_map<int, int>;
namespace stdr = std::ranges;
static_assert(std::same_as<stdr::iterator_t<range>, range::iterator>);
static_assert(stdr::common_range<range>); static_assert(std::same_as<std::ranges::iterator_t<range>, range::iterator>);
static_assert(stdr::forward_range<range>); static_assert(std::ranges::common_range<range>);
static_assert(!stdr::bidirectional_range<range>); static_assert(std::ranges::forward_range<range>);
static_assert(!stdr::view<range>); static_assert(!std::ranges::bidirectional_range<range>);
static_assert(stdr::sized_range<range>); static_assert(!std::ranges::view<range>);
static_assert(!stdr::borrowed_range<range>); static_assert(std::ranges::sized_range<range>);
static_assert(!stdr::viewable_range<range>); static_assert(!std::ranges::borrowed_range<range>);
static_assert(!std::ranges::viewable_range<range>);
static_assert(std::same_as<stdr::iterator_t<range const>, range::const_iterator>);
static_assert(stdr::common_range<range const>); static_assert(std::same_as<std::ranges::iterator_t<range const>, range::const_iterator>);
static_assert(stdr::forward_range<range const>); static_assert(std::ranges::common_range<range const>);
static_assert(!stdr::bidirectional_range<range const>); static_assert(std::ranges::forward_range<range const>);
static_assert(!stdr::view<range const>); static_assert(!std::ranges::bidirectional_range<range const>);
static_assert(stdr::sized_range<range const>); static_assert(!std::ranges::view<range const>);
static_assert(!stdr::borrowed_range<range const>); static_assert(std::ranges::sized_range<range const>);
static_assert(!stdr::viewable_range<range const>); static_assert(!std::ranges::borrowed_range<range const>);
static_assert(!std::ranges::viewable_range<range const>);

libcxx/test/std/containers/unord/unord.multimap/range_concept_conformance.compile.pass.cpp

Show All 12 Lines
// unordered_multimap // unordered_multimap
#include <unordered_map> #include <unordered_map>
#include <concepts> #include <concepts>
#include <ranges> #include <ranges>
using range = std::unordered_multimap<int, int>; using range = std::unordered_multimap<int, int>;
namespace stdr = std::ranges;
static_assert(std::same_as<stdr::iterator_t<range>, range::iterator>);
static_assert(stdr::common_range<range>); static_assert(std::same_as<std::ranges::iterator_t<range>, range::iterator>);
static_assert(stdr::forward_range<range>); static_assert(std::ranges::common_range<range>);
static_assert(!stdr::bidirectional_range<range>); static_assert(std::ranges::forward_range<range>);
static_assert(!stdr::view<range>); static_assert(!std::ranges::bidirectional_range<range>);
static_assert(stdr::sized_range<range>); static_assert(!std::ranges::view<range>);
static_assert(!stdr::borrowed_range<range>); static_assert(std::ranges::sized_range<range>);
static_assert(!stdr::viewable_range<range>); static_assert(!std::ranges::borrowed_range<range>);
static_assert(!std::ranges::viewable_range<range>);
static_assert(std::same_as<stdr::iterator_t<range const>, range::const_iterator>);
static_assert(stdr::common_range<range const>); static_assert(std::same_as<std::ranges::iterator_t<range const>, range::const_iterator>);
static_assert(stdr::forward_range<range const>); static_assert(std::ranges::common_range<range const>);
static_assert(!stdr::bidirectional_range<range const>); static_assert(std::ranges::forward_range<range const>);
static_assert(!stdr::view<range const>); static_assert(!std::ranges::bidirectional_range<range const>);
static_assert(stdr::sized_range<range const>); static_assert(!std::ranges::view<range const>);
static_assert(!stdr::borrowed_range<range const>); static_assert(std::ranges::sized_range<range const>);
static_assert(!stdr::viewable_range<range const>); static_assert(!std::ranges::borrowed_range<range const>);
static_assert(!std::ranges::viewable_range<range const>);

libcxx/test/std/containers/unord/unord.multiset/range_concept_conformance.compile.pass.cpp

Show All 12 Lines
// unordered_multiset // unordered_multiset
#include <unordered_set> #include <unordered_set>
#include <concepts> #include <concepts>
#include <ranges> #include <ranges>
using range = std::unordered_multiset<int>; using range = std::unordered_multiset<int>;
namespace stdr = std::ranges;
static_assert(std::same_as<stdr::iterator_t<range>, range::iterator>);
static_assert(stdr::common_range<range>); static_assert(std::same_as<std::ranges::iterator_t<range>, range::iterator>);
static_assert(stdr::forward_range<range>); static_assert(std::ranges::common_range<range>);
static_assert(!stdr::bidirectional_range<range>); static_assert(std::ranges::forward_range<range>);
static_assert(!stdr::view<range>); static_assert(!std::ranges::bidirectional_range<range>);
static_assert(stdr::sized_range<range>); static_assert(!std::ranges::view<range>);
static_assert(!stdr::borrowed_range<range>); static_assert(std::ranges::sized_range<range>);
static_assert(!stdr::viewable_range<range>); static_assert(!std::ranges::borrowed_range<range>);
static_assert(!std::ranges::viewable_range<range>);
static_assert(std::same_as<stdr::iterator_t<range const>, range::const_iterator>);
static_assert(stdr::common_range<range const>); static_assert(std::same_as<std::ranges::iterator_t<range const>, range::const_iterator>);
static_assert(stdr::forward_range<range const>); static_assert(std::ranges::common_range<range const>);
static_assert(!stdr::bidirectional_range<range const>); static_assert(std::ranges::forward_range<range const>);
static_assert(!stdr::view<range const>); static_assert(!std::ranges::bidirectional_range<range const>);
static_assert(stdr::sized_range<range const>); static_assert(!std::ranges::view<range const>);
static_assert(!stdr::borrowed_range<range const>); static_assert(std::ranges::sized_range<range const>);
static_assert(!stdr::viewable_range<range const>); static_assert(!std::ranges::borrowed_range<range const>);
static_assert(!std::ranges::viewable_range<range const>);

libcxx/test/std/containers/unord/unord.set/range_concept_conformance.compile.pass.cpp

Show All 12 Lines
// unordered_multiset // unordered_multiset
#include <unordered_set> #include <unordered_set>
#include <concepts> #include <concepts>
#include <ranges> #include <ranges>
using range = std::unordered_set<int>; using range = std::unordered_set<int>;
namespace stdr = std::ranges;
static_assert(std::same_as<stdr::iterator_t<range>, range::iterator>);
static_assert(stdr::common_range<range>); static_assert(std::same_as<std::ranges::iterator_t<range>, range::iterator>);
static_assert(stdr::forward_range<range>); static_assert(std::ranges::common_range<range>);
static_assert(!stdr::bidirectional_range<range>); static_assert(std::ranges::forward_range<range>);
static_assert(!stdr::view<range>); static_assert(!std::ranges::bidirectional_range<range>);
static_assert(stdr::sized_range<range>); static_assert(!std::ranges::view<range>);
static_assert(!stdr::borrowed_range<range>); static_assert(std::ranges::sized_range<range>);
static_assert(!stdr::viewable_range<range>); static_assert(!std::ranges::borrowed_range<range>);
static_assert(!std::ranges::viewable_range<range>);
static_assert(std::same_as<stdr::iterator_t<range const>, range::const_iterator>);
static_assert(stdr::common_range<range const>); static_assert(std::same_as<std::ranges::iterator_t<range const>, range::const_iterator>);
static_assert(stdr::forward_range<range const>); static_assert(std::ranges::common_range<range const>);
static_assert(!stdr::bidirectional_range<range const>); static_assert(std::ranges::forward_range<range const>);
static_assert(!stdr::view<range const>); static_assert(!std::ranges::bidirectional_range<range const>);
static_assert(stdr::sized_range<range const>); static_assert(!std::ranges::view<range const>);
static_assert(!stdr::borrowed_range<range const>); static_assert(std::ranges::sized_range<range const>);
static_assert(!stdr::viewable_range<range const>); static_assert(!std::ranges::borrowed_range<range const>);
static_assert(!std::ranges::viewable_range<range const>);

libcxx/test/std/containers/views/range_concept_conformance.compile.pass.cpp

Show All 12 Lines
// span // span
#include <span> #include <span>
#include <concepts> #include <concepts>
#include <ranges> #include <ranges>
using range = std::span<int>; using range = std::span<int>;
namespace stdr = std::ranges;
static_assert(std::same_as<stdr::iterator_t<range>, range::iterator>);
static_assert(stdr::common_range<range>); static_assert(std::same_as<std::ranges::iterator_t<range>, range::iterator>);
static_assert(stdr::random_access_range<range>); static_assert(std::ranges::common_range<range>);
static_assert(stdr::contiguous_range<range>); static_assert(std::ranges::random_access_range<range>);
static_assert(stdr::view<range> && stdr::enable_view<range>); static_assert(std::ranges::contiguous_range<range>);
static_assert(stdr::sized_range<range>); static_assert(std::ranges::view<range> && std::ranges::enable_view<range>);
static_assert(stdr::borrowed_range<range>); static_assert(std::ranges::sized_range<range>);
static_assert(stdr::viewable_range<range>); static_assert(std::ranges::borrowed_range<range>);
static_assert(std::ranges::viewable_range<range>);
static_assert(std::same_as<stdr::iterator_t<range const>, range::iterator>);
static_assert(stdr::common_range<range const>); static_assert(std::same_as<std::ranges::iterator_t<range const>, range::iterator>);
static_assert(stdr::random_access_range<range const>); static_assert(std::ranges::common_range<range const>);
static_assert(stdr::contiguous_range<range const>); static_assert(std::ranges::random_access_range<range const>);
static_assert(!stdr::view<range const> && !stdr::enable_view<range const>); static_assert(std::ranges::contiguous_range<range const>);
static_assert(stdr::sized_range<range const>); static_assert(!std::ranges::view<range const> && !std::ranges::enable_view<range const>);
static_assert(stdr::borrowed_range<range const>); static_assert(std::ranges::sized_range<range const>);
static_assert(stdr::viewable_range<range const>); static_assert(std::ranges::borrowed_range<range const>);
static_assert(std::ranges::viewable_range<range const>);

libcxx/test/std/input.output/filesystems/class.directory_iterator/range_concept_conformance.compile.pass.cpp

Show All 12 Lines
// directory_iterator, recursive_directory_iterator // directory_iterator, recursive_directory_iterator
#include "filesystem_include.h" #include "filesystem_include.h"
#include <concepts> #include <concepts>
#include <ranges> #include <ranges>
namespace stdr = std::ranges;
static_assert(std::same_as<stdr::iterator_t<fs::directory_iterator>, fs::directory_iterator>);
static_assert(stdr::common_range<fs::directory_iterator>); static_assert(std::same_as<std::ranges::iterator_t<fs::directory_iterator>, fs::directory_iterator>);
static_assert(stdr::input_range<fs::directory_iterator>); static_assert(std::ranges::common_range<fs::directory_iterator>);
static_assert(!stdr::view<fs::directory_iterator>); static_assert(std::ranges::input_range<fs::directory_iterator>);
static_assert(!stdr::sized_range<fs::directory_iterator>); static_assert(!std::ranges::view<fs::directory_iterator>);
static_assert(!stdr::borrowed_range<fs::directory_iterator>); static_assert(!std::ranges::sized_range<fs::directory_iterator>);
static_assert(!stdr::viewable_range<fs::directory_iterator>); static_assert(!std::ranges::borrowed_range<fs::directory_iterator>);
static_assert(!std::ranges::viewable_range<fs::directory_iterator>);
static_assert(std::same_as<stdr::iterator_t<fs::directory_iterator const>, fs::directory_iterator>);
static_assert(stdr::common_range<fs::directory_iterator const>); static_assert(std::same_as<std::ranges::iterator_t<fs::directory_iterator const>, fs::directory_iterator>);
static_assert(stdr::input_range<fs::directory_iterator const>); static_assert(std::ranges::common_range<fs::directory_iterator const>);
static_assert(!stdr::view<fs::directory_iterator const>); static_assert(std::ranges::input_range<fs::directory_iterator const>);
static_assert(!stdr::sized_range<fs::directory_iterator const>); static_assert(!std::ranges::view<fs::directory_iterator const>);
static_assert(!stdr::borrowed_range<fs::directory_iterator const>); static_assert(!std::ranges::sized_range<fs::directory_iterator const>);
static_assert(!stdr::viewable_range<fs::directory_iterator const>); static_assert(!std::ranges::borrowed_range<fs::directory_iterator const>);
static_assert(!std::ranges::viewable_range<fs::directory_iterator const>);
static_assert(std::same_as<stdr::iterator_t<fs::recursive_directory_iterator>, fs::recursive_directory_iterator>);
static_assert(stdr::common_range<fs::recursive_directory_iterator>); static_assert(std::same_as<std::ranges::iterator_t<fs::recursive_directory_iterator>, fs::recursive_directory_iterator>);
static_assert(stdr::input_range<fs::recursive_directory_iterator>); static_assert(std::ranges::common_range<fs::recursive_directory_iterator>);
static_assert(!stdr::view<fs::recursive_directory_iterator>); static_assert(std::ranges::input_range<fs::recursive_directory_iterator>);
static_assert(!stdr::sized_range<fs::recursive_directory_iterator>); static_assert(!std::ranges::view<fs::recursive_directory_iterator>);
static_assert(!stdr::borrowed_range<fs::recursive_directory_iterator>); static_assert(!std::ranges::sized_range<fs::recursive_directory_iterator>);
static_assert(!stdr::viewable_range<fs::recursive_directory_iterator>); static_assert(!std::ranges::borrowed_range<fs::recursive_directory_iterator>);
static_assert(!std::ranges::viewable_range<fs::recursive_directory_iterator>);
static_assert(std::same_as<stdr::iterator_t<fs::recursive_directory_iterator const>, fs::recursive_directory_iterator>);
static_assert(stdr::common_range<fs::recursive_directory_iterator const>); static_assert(std::same_as<std::ranges::iterator_t<fs::recursive_directory_iterator const>, fs::recursive_directory_iterator>);
static_assert(stdr::input_range<fs::recursive_directory_iterator const>); static_assert(std::ranges::common_range<fs::recursive_directory_iterator const>);
static_assert(!stdr::view<fs::recursive_directory_iterator const>); static_assert(std::ranges::input_range<fs::recursive_directory_iterator const>);
static_assert(!stdr::sized_range<fs::recursive_directory_iterator const>); static_assert(!std::ranges::view<fs::recursive_directory_iterator const>);
static_assert(!stdr::borrowed_range<fs::recursive_directory_iterator const>); static_assert(!std::ranges::sized_range<fs::recursive_directory_iterator const>);
static_assert(!stdr::viewable_range<fs::recursive_directory_iterator const>); static_assert(!std::ranges::borrowed_range<fs::recursive_directory_iterator const>);
static_assert(!std::ranges::viewable_range<fs::recursive_directory_iterator const>);

libcxx/test/std/input.output/filesystems/class.path/range_concept_conformance.compile.pass.cpp

Show All 11 Lines
// path // path
#include "filesystem_include.h" #include "filesystem_include.h"
#include <concepts> #include <concepts>
#include <ranges> #include <ranges>
namespace stdr = std::ranges;
static_assert(std::same_as<stdr::iterator_t<fs::path>, fs::path::iterator>);
static_assert(stdr::common_range<fs::path>); static_assert(std::same_as<std::ranges::iterator_t<fs::path>, fs::path::iterator>);
static_assert(stdr::bidirectional_range<fs::path>); static_assert(std::ranges::common_range<fs::path>);
static_assert(!stdr::view<fs::path>); static_assert(std::ranges::bidirectional_range<fs::path>);
static_assert(!stdr::random_access_range<fs::path>); static_assert(!std::ranges::view<fs::path>);
static_assert(!stdr::sized_range<fs::path>); static_assert(!std::ranges::random_access_range<fs::path>);
static_assert(!stdr::borrowed_range<fs::path>); static_assert(!std::ranges::sized_range<fs::path>);
static_assert(!stdr::viewable_range<fs::path>); static_assert(!std::ranges::borrowed_range<fs::path>);
static_assert(!std::ranges::viewable_range<fs::path>);
static_assert(std::same_as<stdr::iterator_t<fs::path const>, fs::path::const_iterator>);
static_assert(stdr::common_range<fs::path const>); static_assert(std::same_as<std::ranges::iterator_t<fs::path const>, fs::path::const_iterator>);
static_assert(stdr::bidirectional_range<fs::path const>); static_assert(std::ranges::common_range<fs::path const>);
static_assert(!stdr::view<fs::path const>); static_assert(std::ranges::bidirectional_range<fs::path const>);
static_assert(!stdr::random_access_range<fs::path const>); static_assert(!std::ranges::view<fs::path const>);
static_assert(!stdr::sized_range<fs::path const>); static_assert(!std::ranges::random_access_range<fs::path const>);
static_assert(!stdr::borrowed_range<fs::path const>); static_assert(!std::ranges::sized_range<fs::path const>);
static_assert(!stdr::viewable_range<fs::path const>); static_assert(!std::ranges::borrowed_range<fs::path const>);
static_assert(!std::ranges::viewable_range<fs::path const>);

libcxx/test/std/ranges/range.req/range.range/helper_aliases.compile.pass.cpp

Show All 23 Lines
#include <ranges> #include <ranges>
#include <concepts> #include <concepts>
#include "test_iterators.h" #include "test_iterators.h"
#include "test_range.h" #include "test_range.h"
namespace stdr = std::ranges;
static_assert(std::same_as<stdr::range_difference_t<test_range<cpp20_input_iterator> >, std::iter_difference_t<int*> >);
static_assert(std::same_as<stdr::range_value_t<test_range<cpp20_input_iterator> >, std::iter_value_t<int*> >); static_assert(std::same_as<std::ranges::range_difference_t<test_range<cpp20_input_iterator> >, std::iter_difference_t<int*> >);
static_assert(std::same_as<stdr::range_reference_t<test_range<cpp20_input_iterator> >, std::iter_reference_t<int*> >); static_assert(std::same_as<std::ranges::range_value_t<test_range<cpp20_input_iterator> >, std::iter_value_t<int*> >);
static_assert(std::same_as<stdr::range_rvalue_reference_t<test_range<cpp20_input_iterator> >, std::iter_rvalue_reference_t<int*> >); static_assert(std::same_as<std::ranges::range_reference_t<test_range<cpp20_input_iterator> >, std::iter_reference_t<int*> >);
static_assert(std::same_as<std::ranges::range_rvalue_reference_t<test_range<cpp20_input_iterator> >, std::iter_rvalue_reference_t<int*> >);

libcxx/test/std/ranges/range.req/range.range/iterator_t.compile.pass.cpp

Show All 13 Lines
// using iterator_t = decltype(ranges::begin(declval<T&>())); // using iterator_t = decltype(ranges::begin(declval<T&>()));
#include <ranges> #include <ranges>
#include <concepts> #include <concepts>
#include "test_range.h" #include "test_range.h"
namespace stdr = std::ranges;
static_assert(std::same_as<stdr::iterator_t<test_range<cpp17_input_iterator> >, cpp17_input_iterator<int*> >);
static_assert(std::same_as<stdr::iterator_t<test_range<cpp17_input_iterator> const>, cpp17_input_iterator<int const*> >);
static_assert(std::same_as<stdr::iterator_t<test_non_const_range<cpp17_input_iterator> >, cpp17_input_iterator<int*> >); static_assert(std::same_as<std::ranges::iterator_t<test_range<cpp17_input_iterator> >, cpp17_input_iterator<int*> >);
static_assert(std::same_as<std::ranges::iterator_t<test_range<cpp17_input_iterator> const>, cpp17_input_iterator<int const*> >);
static_assert(std::same_as<stdr::iterator_t<test_common_range<cpp17_input_iterator> >, cpp17_input_iterator<int*> >); static_assert(std::same_as<std::ranges::iterator_t<test_non_const_range<cpp17_input_iterator> >, cpp17_input_iterator<int*> >);
static_assert(std::same_as<stdr::iterator_t<test_common_range<cpp17_input_iterator> const>, cpp17_input_iterator<int const*> >);
static_assert(std::same_as<stdr::iterator_t<test_non_const_common_range<cpp17_input_iterator> >, cpp17_input_iterator<int*> >); static_assert(std::same_as<std::ranges::iterator_t<test_common_range<cpp17_input_iterator> >, cpp17_input_iterator<int*> >);
static_assert(std::same_as<std::ranges::iterator_t<test_common_range<cpp17_input_iterator> const>, cpp17_input_iterator<int const*> >);
static_assert(std::same_as<std::ranges::iterator_t<test_non_const_common_range<cpp17_input_iterator> >, cpp17_input_iterator<int*> >);

libcxx/test/std/ranges/range.req/range.range/range.compile.pass.cpp

Show All 13 Lines
// concept range; // concept range;
#include <ranges> #include <ranges>
#include <vector> #include <vector>
#include "test_range.h" #include "test_range.h"
namespace stdr = std::ranges;
static_assert(stdr::range<test_range<cpp20_input_iterator> >);
static_assert(std::ranges::range<test_range<cpp20_input_iterator> >);
struct incompatible_iterators { struct incompatible_iterators {
int* begin(); int* begin();
long* end(); long* end();
}; };
static_assert(!stdr::range<incompatible_iterators>); static_assert(!std::ranges::range<incompatible_iterators>);
struct int_begin_int_end { struct int_begin_int_end {
int begin(); int begin();
int end(); int end();
}; };
static_assert(!stdr::range<int_begin_int_end>); static_assert(!std::ranges::range<int_begin_int_end>);
struct iterator_begin_int_end { struct iterator_begin_int_end {
int* begin(); int* begin();
int end(); int end();
}; };
static_assert(!stdr::range<iterator_begin_int_end>); static_assert(!std::ranges::range<iterator_begin_int_end>);
struct int_begin_iterator_end { struct int_begin_iterator_end {
int begin(); int begin();
int* end(); int* end();
}; };
static_assert(!stdr::range<int_begin_iterator_end>); static_assert(!std::ranges::range<int_begin_iterator_end>);

libcxx/test/std/ranges/range.req/range.range/sentinel_t.compile.pass.cpp

Show All 14 Lines
#include <ranges> #include <ranges>
#include <concepts> #include <concepts>
#include "test_iterators.h" #include "test_iterators.h"
#include "test_range.h" #include "test_range.h"
namespace stdr = std::ranges;
static_assert(std::same_as<stdr::sentinel_t<test_range<cpp20_input_iterator> >, sentinel>);
static_assert(std::same_as<stdr::sentinel_t<test_range<cpp20_input_iterator> const>, sentinel>); static_assert(std::same_as<std::ranges::sentinel_t<test_range<cpp20_input_iterator> >, sentinel>);
static_assert(std::same_as<stdr::sentinel_t<test_non_const_range<cpp20_input_iterator> >, sentinel>); static_assert(std::same_as<std::ranges::sentinel_t<test_range<cpp20_input_iterator> const>, sentinel>);
static_assert(std::same_as<stdr::sentinel_t<test_common_range<cpp17_input_iterator> >, cpp17_input_iterator<int*> >); static_assert(std::same_as<std::ranges::sentinel_t<test_non_const_range<cpp20_input_iterator> >, sentinel>);
static_assert(std::same_as<stdr::sentinel_t<test_common_range<cpp17_input_iterator> const>, cpp17_input_iterator<int const*> >); static_assert(std::same_as<std::ranges::sentinel_t<test_common_range<cpp17_input_iterator> >, cpp17_input_iterator<int*> >);
static_assert(std::same_as<stdr::sentinel_t<test_non_const_common_range<cpp17_input_iterator> >, cpp17_input_iterator<int*> >); static_assert(std::same_as<std::ranges::sentinel_t<test_common_range<cpp17_input_iterator> const>, cpp17_input_iterator<int const*> >);
static_assert(std::same_as<std::ranges::sentinel_t<test_non_const_common_range<cpp17_input_iterator> >, cpp17_input_iterator<int*> >);

libcxx/test/std/ranges/range.req/range.refinements/bidirectional_range.compile.pass.cpp

Show All 11 Lines
// template<class R> // template<class R>
// concept bidirectional_range; // concept bidirectional_range;
#include <ranges> #include <ranges>
#include "test_range.h" #include "test_range.h"
namespace stdr = std::ranges;
template <template <class...> class I> template <template <class...> class I>
constexpr bool check_bidirectional_range() { constexpr bool check_bidirectional_range() {
constexpr bool result = stdr::bidirectional_range<test_range<I> >; constexpr bool result = std::ranges::bidirectional_range<test_range<I> >;
static_assert(stdr::bidirectional_range<test_range<I> const> == result); static_assert(std::ranges::bidirectional_range<test_range<I> const> == result);
static_assert(stdr::bidirectional_range<test_non_const_common_range<I> > == result); static_assert(std::ranges::bidirectional_range<test_non_const_common_range<I> > == result);
static_assert(stdr::bidirectional_range<test_non_const_range<I> > == result); static_assert(std::ranges::bidirectional_range<test_non_const_range<I> > == result);
static_assert(stdr::bidirectional_range<test_common_range<I> > == result); static_assert(std::ranges::bidirectional_range<test_common_range<I> > == result);
static_assert(stdr::bidirectional_range<test_common_range<I> const> == result); static_assert(std::ranges::bidirectional_range<test_common_range<I> const> == result);
static_assert(!stdr::bidirectional_range<test_non_const_common_range<I> const>); static_assert(!std::ranges::bidirectional_range<test_non_const_common_range<I> const>);
static_assert(!stdr::bidirectional_range<test_non_const_range<I> const>); static_assert(!std::ranges::bidirectional_range<test_non_const_range<I> const>);
return result; return result;
} }
static_assert(!check_bidirectional_range<cpp17_input_iterator>()); static_assert(!check_bidirectional_range<cpp17_input_iterator>());
static_assert(!check_bidirectional_range<cpp20_input_iterator>()); static_assert(!check_bidirectional_range<cpp20_input_iterator>());
static_assert(!check_bidirectional_range<forward_iterator>()); static_assert(!check_bidirectional_range<forward_iterator>());
static_assert(check_bidirectional_range<bidirectional_iterator>()); static_assert(check_bidirectional_range<bidirectional_iterator>());
static_assert(check_bidirectional_range<random_access_iterator>()); static_assert(check_bidirectional_range<random_access_iterator>());
static_assert(check_bidirectional_range<contiguous_iterator>()); static_assert(check_bidirectional_range<contiguous_iterator>());

libcxx/test/std/ranges/range.req/range.refinements/common_range.compile.pass.cpp

Show All 12 Lines
// template<class R> // template<class R>
// concept common_range; // concept common_range;
#include <ranges> #include <ranges>
#include "test_iterators.h" #include "test_iterators.h"
#include "test_range.h" #include "test_range.h"
namespace stdr = std::ranges;
static_assert(!stdr::common_range<test_range<cpp17_input_iterator> >);
static_assert(!stdr::common_range<test_range<cpp17_input_iterator> const>);
static_assert(!stdr::common_range<test_non_const_range<cpp17_input_iterator> >); static_assert(!std::ranges::common_range<test_range<cpp17_input_iterator> >);
static_assert(!stdr::common_range<test_non_const_range<cpp17_input_iterator> const>); static_assert(!std::ranges::common_range<test_range<cpp17_input_iterator> const>);
static_assert(stdr::common_range<test_common_range<cpp17_input_iterator> >); static_assert(!std::ranges::common_range<test_non_const_range<cpp17_input_iterator> >);
static_assert(stdr::common_range<test_common_range<cpp17_input_iterator> const>); static_assert(!std::ranges::common_range<test_non_const_range<cpp17_input_iterator> const>);
static_assert(stdr::common_range<test_non_const_common_range<cpp17_input_iterator> >); static_assert(std::ranges::common_range<test_common_range<cpp17_input_iterator> >);
static_assert(!stdr::common_range<test_non_const_common_range<cpp17_input_iterator> const>); static_assert(std::ranges::common_range<test_common_range<cpp17_input_iterator> const>);
static_assert(std::ranges::common_range<test_non_const_common_range<cpp17_input_iterator> >);
static_assert(!std::ranges::common_range<test_non_const_common_range<cpp17_input_iterator> const>);
struct subtly_not_common { struct subtly_not_common {
int* begin() const; int* begin() const;
int const* end() const; int const* end() const;
}; };
static_assert(stdr::range<subtly_not_common> && !stdr::common_range<subtly_not_common>); static_assert(std::ranges::range<subtly_not_common> && !std::ranges::common_range<subtly_not_common>);
static_assert(stdr::range<subtly_not_common const> && !stdr::common_range<subtly_not_common const>); static_assert(std::ranges::range<subtly_not_common const> && !std::ranges::common_range<subtly_not_common const>);
struct common_range_non_const_only { struct common_range_non_const_only {
int* begin() const; int* begin() const;
int* end(); int* end();
int const* end() const; int const* end() const;
}; };
static_assert(stdr::range<common_range_non_const_only>&& stdr::common_range<common_range_non_const_only>); static_assert(std::ranges::range<common_range_non_const_only>&& std::ranges::common_range<common_range_non_const_only>);
static_assert(stdr::range<common_range_non_const_only const> && !stdr::common_range<common_range_non_const_only const>); static_assert(std::ranges::range<common_range_non_const_only const> && !std::ranges::common_range<common_range_non_const_only const>);
struct common_range_const_only { struct common_range_const_only {
int* begin(); int* begin();
int const* begin() const; int const* begin() const;
int const* end() const; int const* end() const;
}; };
static_assert(stdr::range<common_range_const_only> && !stdr::common_range<common_range_const_only>); static_assert(std::ranges::range<common_range_const_only> && !std::ranges::common_range<common_range_const_only>);
static_assert(stdr::range<common_range_const_only const>&& stdr::common_range<common_range_const_only const>); static_assert(std::ranges::range<common_range_const_only const>&& std::ranges::common_range<common_range_const_only const>);

libcxx/test/std/ranges/range.req/range.refinements/forward_range.compile.pass.cpp

Show All 12 Lines
// template<class R> // template<class R>
// concept forward_range; // concept forward_range;
#include <ranges> #include <ranges>
#include "test_iterators.h" #include "test_iterators.h"
#include "test_range.h" #include "test_range.h"
namespace stdr = std::ranges;
template <template <class...> class I> template <template <class...> class I>
constexpr bool check_forward_range() { constexpr bool check_forward_range() {
constexpr bool result = stdr::forward_range<test_range<I> >; constexpr bool result = std::ranges::forward_range<test_range<I> >;
static_assert(stdr::forward_range<test_range<I> const> == result); static_assert(std::ranges::forward_range<test_range<I> const> == result);
static_assert(stdr::forward_range<test_non_const_common_range<I> > == result); static_assert(std::ranges::forward_range<test_non_const_common_range<I> > == result);
static_assert(stdr::forward_range<test_non_const_range<I> > == result); static_assert(std::ranges::forward_range<test_non_const_range<I> > == result);
static_assert(stdr::forward_range<test_common_range<I> > == result); static_assert(std::ranges::forward_range<test_common_range<I> > == result);
static_assert(stdr::forward_range<test_common_range<I> const> == result); static_assert(std::ranges::forward_range<test_common_range<I> const> == result);
static_assert(!stdr::forward_range<test_non_const_common_range<I> const>); static_assert(!std::ranges::forward_range<test_non_const_common_range<I> const>);
static_assert(!stdr::forward_range<test_non_const_range<I> const>); static_assert(!std::ranges::forward_range<test_non_const_range<I> const>);
return result; return result;
} }
static_assert(!check_forward_range<cpp17_input_iterator>()); static_assert(!check_forward_range<cpp17_input_iterator>());
static_assert(!check_forward_range<cpp20_input_iterator>()); static_assert(!check_forward_range<cpp20_input_iterator>());
static_assert(check_forward_range<forward_iterator>()); static_assert(check_forward_range<forward_iterator>());
static_assert(check_forward_range<bidirectional_iterator>()); static_assert(check_forward_range<bidirectional_iterator>());
static_assert(check_forward_range<random_access_iterator>()); static_assert(check_forward_range<random_access_iterator>());
static_assert(check_forward_range<contiguous_iterator>()); static_assert(check_forward_range<contiguous_iterator>());

libcxx/test/std/ranges/range.req/range.refinements/input_range.compile.pass.cpp

Show All 12 Lines
// template<class R> // template<class R>
// concept input_range; // concept input_range;
#include <ranges> #include <ranges>
#include "test_iterators.h" #include "test_iterators.h"
#include "test_range.h" #include "test_range.h"
namespace stdr = std::ranges;
static_assert(stdr::input_range<test_range<cpp17_input_iterator> >);
static_assert(stdr::input_range<test_range<cpp17_input_iterator> const>);
static_assert(stdr::input_range<test_range<cpp20_input_iterator> >); static_assert(std::ranges::input_range<test_range<cpp17_input_iterator> >);
static_assert(stdr::input_range<test_range<cpp20_input_iterator> const>); static_assert(std::ranges::input_range<test_range<cpp17_input_iterator> const>);
static_assert(stdr::input_range<test_non_const_range<cpp17_input_iterator> >); static_assert(std::ranges::input_range<test_range<cpp20_input_iterator> >);
static_assert(stdr::input_range<test_non_const_range<cpp20_input_iterator> >); static_assert(std::ranges::input_range<test_range<cpp20_input_iterator> const>);
static_assert(!stdr::input_range<test_non_const_range<cpp17_input_iterator> const>); static_assert(std::ranges::input_range<test_non_const_range<cpp17_input_iterator> >);
static_assert(!stdr::input_range<test_non_const_range<cpp20_input_iterator> const>); static_assert(std::ranges::input_range<test_non_const_range<cpp20_input_iterator> >);
static_assert(stdr::input_range<test_common_range<cpp17_input_iterator> >); static_assert(!std::ranges::input_range<test_non_const_range<cpp17_input_iterator> const>);
static_assert(!stdr::input_range<test_common_range<cpp20_input_iterator> >); static_assert(!std::ranges::input_range<test_non_const_range<cpp20_input_iterator> const>);
static_assert(stdr::input_range<test_common_range<cpp17_input_iterator> const>); static_assert(std::ranges::input_range<test_common_range<cpp17_input_iterator> >);
static_assert(!stdr::input_range<test_common_range<cpp20_input_iterator> const>); static_assert(!std::ranges::input_range<test_common_range<cpp20_input_iterator> >);
static_assert(stdr::input_range<test_non_const_common_range<cpp17_input_iterator> >); static_assert(std::ranges::input_range<test_common_range<cpp17_input_iterator> const>);
static_assert(!stdr::input_range<test_non_const_common_range<cpp20_input_iterator> >); static_assert(!std::ranges::input_range<test_common_range<cpp20_input_iterator> const>);
static_assert(!stdr::input_range<test_non_const_common_range<cpp17_input_iterator> const>); static_assert(std::ranges::input_range<test_non_const_common_range<cpp17_input_iterator> >);
static_assert(!stdr::input_range<test_non_const_common_range<cpp20_input_iterator> const>); static_assert(!std::ranges::input_range<test_non_const_common_range<cpp20_input_iterator> >);
static_assert(!std::ranges::input_range<test_non_const_common_range<cpp17_input_iterator> const>);
static_assert(!std::ranges::input_range<test_non_const_common_range<cpp20_input_iterator> const>);

libcxx/test/std/ranges/range.req/range.sized/sized_range.compile.pass.cpp

Show All 11 Lines
// template<class T> // template<class T>
// concept sized_range; // concept sized_range;
#include <ranges> #include <ranges>
#include "test_iterators.h" #include "test_iterators.h"
namespace stdr = std::ranges;
static_assert(stdr::sized_range<int[5]>);
static_assert(stdr::sized_range<int (&)[5]>); static_assert(std::ranges::sized_range<int[5]>);
static_assert(!stdr::sized_range<int (&)[]>); static_assert(std::ranges::sized_range<int (&)[5]>);
static_assert(!stdr::sized_range<int[]>); static_assert(!std::ranges::sized_range<int (&)[]>);
static_assert(!std::ranges::sized_range<int[]>);
struct range_has_size { struct range_has_size {
bidirectional_iterator<int*> begin(); bidirectional_iterator<int*> begin();
bidirectional_iterator<int*> end(); bidirectional_iterator<int*> end();
int size(); int size();
}; };
static_assert(stdr::sized_range<range_has_size>); static_assert(std::ranges::sized_range<range_has_size>);
static_assert(!stdr::sized_range<range_has_size const>); static_assert(!std::ranges::sized_range<range_has_size const>);
struct range_has_const_size { struct range_has_const_size {
bidirectional_iterator<int*> begin(); bidirectional_iterator<int*> begin();
bidirectional_iterator<int*> end(); bidirectional_iterator<int*> end();
int size() const; int size() const;
}; };
static_assert(stdr::sized_range<range_has_const_size>); static_assert(std::ranges::sized_range<range_has_const_size>);
static_assert(!stdr::sized_range<range_has_const_size const>); static_assert(!std::ranges::sized_range<range_has_const_size const>);
struct const_range_has_size { struct const_range_has_size {
bidirectional_iterator<int*> begin() const; bidirectional_iterator<int*> begin() const;
bidirectional_iterator<int*> end() const; bidirectional_iterator<int*> end() const;
int size(); int size();
}; };
static_assert(stdr::sized_range<const_range_has_size>); static_assert(std::ranges::sized_range<const_range_has_size>);
static_assert(stdr::range<const_range_has_size const>); static_assert(std::ranges::range<const_range_has_size const>);
static_assert(!stdr::sized_range<const_range_has_size const>); static_assert(!std::ranges::sized_range<const_range_has_size const>);
struct const_range_has_const_size { struct const_range_has_const_size {
bidirectional_iterator<int*> begin() const; bidirectional_iterator<int*> begin() const;
bidirectional_iterator<int*> end() const; bidirectional_iterator<int*> end() const;
int size() const; int size() const;
}; };
static_assert(stdr::sized_range<const_range_has_const_size>); static_assert(std::ranges::sized_range<const_range_has_const_size>);
static_assert(stdr::sized_range<const_range_has_const_size const>); static_assert(std::ranges::sized_range<const_range_has_const_size const>);
struct sized_sentinel_range_has_size { struct sized_sentinel_range_has_size {
int* begin(); int* begin();
int* end(); int* end();
}; };
static_assert(stdr::sized_range<sized_sentinel_range_has_size>); static_assert(std::ranges::sized_range<sized_sentinel_range_has_size>);
static_assert(!stdr::sized_range<sized_sentinel_range_has_size const>); static_assert(!std::ranges::sized_range<sized_sentinel_range_has_size const>);
struct const_sized_sentinel_range_has_size { struct const_sized_sentinel_range_has_size {
int* begin() const; int* begin() const;
int* end() const; int* end() const;
}; };
static_assert(stdr::sized_range<const_sized_sentinel_range_has_size>); static_assert(std::ranges::sized_range<const_sized_sentinel_range_has_size>);
static_assert(stdr::sized_range<const_sized_sentinel_range_has_size const>); static_assert(std::ranges::sized_range<const_sized_sentinel_range_has_size const>);
struct non_range_has_size { struct non_range_has_size {
int size() const; int size() const;
}; };
static_assert(requires(non_range_has_size const x) { stdr::size(x); }); static_assert(requires(non_range_has_size const x) { std::ranges::size(x); });
static_assert(!stdr::sized_range<non_range_has_size>); static_assert(!std::ranges::sized_range<non_range_has_size>);
static_assert(!stdr::sized_range<non_range_has_size const>); static_assert(!std::ranges::sized_range<non_range_has_size const>);

libcxx/test/std/re/re.results/range_concept_conformance.compile.pass.cpp

Show All 11 Lines
// match_results // match_results
#include <regex> #include <regex>
#include <concepts> #include <concepts>
#include <ranges> #include <ranges>
namespace stdr = std::ranges;
static_assert(std::same_as<stdr::iterator_t<std::cmatch>, std::cmatch::iterator>);
static_assert(stdr::common_range<std::cmatch>); static_assert(std::same_as<std::ranges::iterator_t<std::cmatch>, std::cmatch::iterator>);
static_assert(stdr::random_access_range<std::cmatch>); static_assert(std::ranges::common_range<std::cmatch>);
static_assert(stdr::contiguous_range<std::cmatch>); static_assert(std::ranges::random_access_range<std::cmatch>);
static_assert(!stdr::view<std::cmatch>); static_assert(std::ranges::contiguous_range<std::cmatch>);
static_assert(stdr::sized_range<std::cmatch>); static_assert(!std::ranges::view<std::cmatch>);
static_assert(!stdr::borrowed_range<std::cmatch>); static_assert(std::ranges::sized_range<std::cmatch>);
static_assert(!stdr::viewable_range<std::cmatch>); static_assert(!std::ranges::borrowed_range<std::cmatch>);
static_assert(!std::ranges::viewable_range<std::cmatch>);
static_assert(std::same_as<stdr::iterator_t<std::cmatch const>, std::cmatch::const_iterator>);
static_assert(stdr::common_range<std::cmatch const>); static_assert(std::same_as<std::ranges::iterator_t<std::cmatch const>, std::cmatch::const_iterator>);
static_assert(stdr::random_access_range<std::cmatch const>); static_assert(std::ranges::common_range<std::cmatch const>);
static_assert(stdr::contiguous_range<std::cmatch const>); static_assert(std::ranges::random_access_range<std::cmatch const>);
static_assert(!stdr::view<std::cmatch const>); static_assert(std::ranges::contiguous_range<std::cmatch const>);
static_assert(stdr::sized_range<std::cmatch const>); static_assert(!std::ranges::view<std::cmatch const>);
static_assert(!stdr::borrowed_range<std::cmatch const>); static_assert(std::ranges::sized_range<std::cmatch const>);
static_assert(!stdr::viewable_range<std::cmatch const>); static_assert(!std::ranges::borrowed_range<std::cmatch const>);
static_assert(!std::ranges::viewable_range<std::cmatch const>);

libcxx/test/std/strings/basic.string/range_concept_conformance.compile.pass.cpp

Show All 11 Lines
// string // string
#include <string> #include <string>
#include <concepts> #include <concepts>
#include <ranges> #include <ranges>
namespace stdr = std::ranges;
static_assert(std::same_as<stdr::iterator_t<std::string>, std::string::iterator>);
static_assert(stdr::common_range<std::string>); static_assert(std::same_as<std::ranges::iterator_t<std::string>, std::string::iterator>);
static_assert(stdr::random_access_range<std::string>); static_assert(std::ranges::common_range<std::string>);
static_assert(stdr::contiguous_range<std::string>); static_assert(std::ranges::random_access_range<std::string>);
static_assert(!stdr::view<std::string>); static_assert(std::ranges::contiguous_range<std::string>);
static_assert(stdr::sized_range<std::string>); static_assert(!std::ranges::view<std::string>);
static_assert(!stdr::borrowed_range<std::string>); static_assert(std::ranges::sized_range<std::string>);
static_assert(!stdr::viewable_range<std::string>); static_assert(!std::ranges::borrowed_range<std::string>);
static_assert(!std::ranges::viewable_range<std::string>);
static_assert(std::same_as<stdr::iterator_t<std::string const>, std::string::const_iterator>);
static_assert(stdr::common_range<std::string const>); static_assert(std::same_as<std::ranges::iterator_t<std::string const>, std::string::const_iterator>);
static_assert(stdr::random_access_range<std::string const>); static_assert(std::ranges::common_range<std::string const>);
static_assert(stdr::contiguous_range<std::string const>); static_assert(std::ranges::random_access_range<std::string const>);
static_assert(!stdr::view<std::string const>); static_assert(std::ranges::contiguous_range<std::string const>);
static_assert(stdr::sized_range<std::string const>); static_assert(!std::ranges::view<std::string const>);
static_assert(!stdr::borrowed_range<std::string const>); static_assert(std::ranges::sized_range<std::string const>);
static_assert(!stdr::viewable_range<std::string const>); static_assert(!std::ranges::borrowed_range<std::string const>);
static_assert(!std::ranges::viewable_range<std::string const>);

libcxx/test/std/strings/string.view/range_concept_conformance.compile.pass.cpp

Show All 11 Lines
// string_view // string_view
#include <string_view> #include <string_view>
#include <concepts> #include <concepts>
#include <ranges> #include <ranges>
namespace stdr = std::ranges;
static_assert(std::same_as<stdr::iterator_t<std::string_view>, std::string_view::iterator>);
static_assert(stdr::common_range<std::string_view>); static_assert(std::same_as<std::ranges::iterator_t<std::string_view>, std::string_view::iterator>);
static_assert(stdr::random_access_range<std::string_view>); static_assert(std::ranges::common_range<std::string_view>);
static_assert(stdr::contiguous_range<std::string_view>); static_assert(std::ranges::random_access_range<std::string_view>);
static_assert(stdr::view<std::string_view> && stdr::enable_view<std::string_view>); static_assert(std::ranges::contiguous_range<std::string_view>);
static_assert(stdr::sized_range<std::string_view>); static_assert(std::ranges::view<std::string_view> && std::ranges::enable_view<std::string_view>);
static_assert(stdr::borrowed_range<std::string_view>); static_assert(std::ranges::sized_range<std::string_view>);
static_assert(stdr::viewable_range<std::string_view>); static_assert(std::ranges::borrowed_range<std::string_view>);
static_assert(std::ranges::viewable_range<std::string_view>);
static_assert(std::same_as<stdr::iterator_t<std::string_view const>, std::string_view::const_iterator>);
static_assert(stdr::common_range<std::string_view const>); static_assert(std::same_as<std::ranges::iterator_t<std::string_view const>, std::string_view::const_iterator>);
static_assert(stdr::random_access_range<std::string_view const>); static_assert(std::ranges::common_range<std::string_view const>);
static_assert(stdr::contiguous_range<std::string_view const>); static_assert(std::ranges::random_access_range<std::string_view const>);
static_assert(!stdr::view<std::string_view const> && !stdr::enable_view<std::string_view const>); static_assert(std::ranges::contiguous_range<std::string_view const>);
static_assert(stdr::sized_range<std::string_view const>); static_assert(!std::ranges::view<std::string_view const> && !std::ranges::enable_view<std::string_view const>);
static_assert(stdr::borrowed_range<std::string_view const>); static_assert(std::ranges::sized_range<std::string_view const>);
static_assert(stdr::viewable_range<std::string_view const>); static_assert(std::ranges::borrowed_range<std::string_view const>);
static_assert(std::ranges::viewable_range<std::string_view const>);