This is an archive of the discontinued LLVM Phabricator instance.

Differential D101242

[libcxx][nfc] prefixes test type `input_iterator` with `cpp17_`
ClosedPublic

Authored by cjdb on Apr 24 2021, 2:40 PM.

Details

Reviewers
ldionne
zoecarver
Mordante
• Quuxplusone
Group Reviewers
Restricted Project
Commits
rG773ae4412468: [libcxx][nfc] prefixes test type `input_iterator` with `cpp17_`
Summary

C++20 revised the definition of what it means to be an iterator. While
all _Cpp17InputIterators_ satisfy std::input_iterator, the reverse
isn't true. D100271 introduces a new test adaptor to accommodate this
new definition (cpp20_input_iterator).

In order to help readers immediately distinguish which input iterator
adaptor is _Cpp17InputIterator_, the current input_iterator adaptor
has been prefixed with cpp17_.

Diff Detail

Event Timeline

cjdb created this revision.Apr 24 2021, 2:40 PM
Herald added subscribers: wenlei, arphaman. · View Herald TranscriptApr 24 2021, 2:40 PM
cjdb requested review of this revision.Apr 24 2021, 2:40 PM
Herald added a project: Restricted Project. · View Herald TranscriptApr 24 2021, 2:40 PM
Herald added a reviewer: Restricted Project. · View Herald Transcript
Herald added a subscriber: libcxx-commits. · View Herald Transcript
• Quuxplusone resigned from this revision.Apr 24 2021, 3:12 PM
• Quuxplusone added a subscriber: • Quuxplusone.

It seems like literally all this does is make the test iterators' names longer and more tedious, so I personally don't think we should accept this patch.

cjdb updated this revision to Diff 340317.Apr 24 2021, 5:10 PM
cjdb edited the summary of this revision. (Show Details)

benchmark file was not updated (tooling only considered files in libcxx/test/)

Harbormaster completed remote builds in B100779: Diff 340315.Apr 24 2021, 7:26 PM
Harbormaster completed remote builds in B100781: Diff 340317.Apr 24 2021, 10:08 PM
Mordante added a comment.Apr 25 2021, 4:38 AM

I had a short look at the patch. I also wonder whether this is the direction we want to go.
For reviewing, I assume this is all basically a search and replace? Or are there more changes?

libcxx/test/support/test_iterators.h
1

The new C++20 style iterators will they also be put in this file or will they get their own header. If the latter then maybe rename this file to test_legacy_iterator.h.

cjdb mentioned this in D100271: [libcxx][iterator][ranges] adds `input_iterator` and `input_range`.Apr 26 2021, 9:51 AM
cjdb added a comment.Apr 26 2021, 9:59 AM
In D101242#2715229, @Mordante wrote:

I had a short look at the patch. I also wonder whether this is the direction we want to go.

The intention of this patch is to optimise for the reader, not the writer. I don't want any contributors or reviewers to question whether input_iterator means legacy input iterator or C++20 input iterator.

For reviewing, I assume this is all basically a search and replace? Or are there more changes?

Should be a 100% search and replace with one file renamed too (input_iterator.h -> legacy_input_iterator.h).

libcxx/test/support/test_iterators.h
1

My intention was to add them here and guard them with a ranges support macro. C++20 ranges may want to test both in certain circumstances.

ldionne requested changes to this revision.Apr 26 2021, 10:03 AM

I agree this is making names longer and I dislike that. However, I think being able to distinguish between an archetype for a C++20 input_iterator and a pre-concepts InputIterator archetype is useful and necessary in the test suite, since those two concepts are different (see note about equality comparable https://en.cppreference.com/w/cpp/iterator/input_iterator).

One other option would be to call those cpp17_XXXXX_iterator instead. That way, if we introduce new iterator concepts eventually in the future, we can call the current ones cpp20_XXXXX_iterator instead of being stuck with a naming problem. WDYT?

I also agree with @Mordante , if we're going to rename the header in the future, we might just as well rename it now. If there's no plans to rename the header, then this LGTM.

Requesting changes for discussion.

This revision now requires changes to proceed.Apr 26 2021, 10:03 AM
• Quuxplusone added a comment.Apr 26 2021, 10:04 AM

The intention of this patch is to optimise for the reader, not the writer.

As a reader myself, I explicitly state that this patch does not optimize for my preferences when reading code. It makes the code actively harder to read.

cjdb added a subscriber: tcanens.Apr 26 2021, 10:10 AM
In D101242#2717210, @ldionne wrote:

I agree this is making names longer and I dislike that. However, I think being able to distinguish between an archetype for a C++20 input_iterator and a pre-concepts InputIterator archetype is useful and necessary in the test suite, since those two concepts are different (see note about equality comparable https://en.cppreference.com/w/cpp/iterator/input_iterator).

One other option would be to call those cpp17_XXXXX_iterator instead. That way, if we introduce new iterator concepts eventually in the future, we can call the current ones cpp20_XXXXX_iterator instead of being stuck with a naming problem. WDYT?

I have grave objections to cpp17 as a prefix (I even raised that in LWG once). It's weird see a C++11 test to have a cpp17_XXXX_iterator. I'm pretty sure that's why @tcanens pushed so strongly for LegacyXXXXIterator on cppreference too.

I also agree with @Mordante , if we're going to rename the header in the future, we might just as well rename it now. If there's no plans to rename the header, then this LGTM.

No plans to rename the header, but I could be talked into it.

ldionne added a comment.Apr 26 2021, 10:14 AM
In D101242#2717210, @ldionne wrote:

I agree this is making names longer and I dislike that. However, I think being able to distinguish between an archetype for a C++20 input_iterator and a pre-concepts InputIterator archetype is useful and necessary in the test suite, since those two concepts are different (see note about equality comparable https://en.cppreference.com/w/cpp/iterator/input_iterator).

@cjdb Are the other iterator concepts also different between C++20 and C++17? It's true for input iterators, but is it also the case for e.g. forward iterator? I think that should influence what we do here.

cjdb added a comment.Apr 26 2021, 10:23 AM
In D101242#2717230, @ldionne wrote:
In D101242#2717210, @ldionne wrote:

I agree this is making names longer and I dislike that. However, I think being able to distinguish between an archetype for a C++20 input_iterator and a pre-concepts InputIterator archetype is useful and necessary in the test suite, since those two concepts are different (see note about equality comparable https://en.cppreference.com/w/cpp/iterator/input_iterator).

@cjdb Are the other iterator concepts also different between C++20 and C++17? It's true for input iterators, but is it also the case for e.g. forward iterator? I think that should influence what we do here.

Contrast:

tl;dr yes. At minimum, the iterator tags are now mandatory.

Mordante added a comment.Apr 26 2021, 11:34 AM
In D101242#2717221, @cjdb wrote:
In D101242#2717210, @ldionne wrote:

One other option would be to call those cpp17_XXXXX_iterator instead. That way, if we introduce new iterator concepts eventually in the future, we can call the current ones cpp20_XXXXX_iterator instead of being stuck with a naming problem. WDYT?

I have grave objections to cpp17 as a prefix (I even raised that in LWG once). It's weird see a C++11 test to have a cpp17_XXXX_iterator. I'm pretty sure that's why @tcanens pushed so strongly for LegacyXXXXIterator on cppreference too.

I'm not too fond of the name Legacy. Unless I'm mistaken the standard uses Cpp17 for these iterators. So that would be my preference.

I also agree with @Mordante , if we're going to rename the header in the future, we might just as well rename it now. If there's no plans to rename the header, then this LGTM.

No plans to rename the header, but I could be talked into it.

I have a strong opinion about the renaming of the header. Just wanted to make sure there wouldn't be a second update in the near future.

• Quuxplusone requested changes to this revision.Apr 26 2021, 11:36 AM
• Quuxplusone added inline comments.
libcxx/test/support/test_iterators.h
66

@cjdb wrote:

tl;dr yes. At minimum, the iterator tags are now mandatory.

The existing iterators already have tags, though. So that's not a concern for us.

I suggested to Louis in chat but will put here for the record: If the main concern of this patch is to make sure we have a test iterator which is a "non-comparable input iterator" (comparable only to its sentinel type, but not to itself), then I suggest you leave everything the way it is in main but then add the new C++20-only, sentinel-comparison-only test iterator, like this:

#if TEST_STD_VER >= 20
template<class It>
class incomparable_input_iterator {
    // This is an input iterator according to C++>=20, but not according to C++<=17.
    // It is comparable with its sentinel type, but not with its own type.
    [...mostly the same stuff as the regular input iterator test type...]
public:
    struct sentinel {
        constexpr explicit sentinel(It it) : it_(it) {}
    };
    friend constexpr bool operator==(const incomparable_input_iterator& x, const sentinel& y)
        {return x.it_ == y.it_;}
};
#endif

This probably belongs right above contiguous_iterator, circa line 315, because we intend it to be new in C++20.

cjdb added inline comments.Apr 26 2021, 12:06 PM
libcxx/test/support/test_iterators.h
66

If the main concern of this patch is to make sure we have a test iterator which is a "non-comparable input iterator" (comparable only to its sentinel type, but not to itself)

This isn't the only difference between Cpp17InputIterator and std::input_iterator.

I suggest you leave everything the way it is in main but then add the new C++20-only, sentinel-comparison-only test iterator

That leaves ambiguity as to whether or not input_iterator refers to a Cpp17InputIterator or is a strict std::input_iterator. It needs to be renamed to clear up that ambiguity.

• Quuxplusone added inline comments.Apr 26 2021, 12:38 PM
libcxx/test/support/test_iterators.h
66

This isn't the only difference

Obligatory "What are the differences you care about, then?"
No two things in the world are ever exactly the same. That doesn't mean we make libc++ PRs about it. :)

cjdb added inline comments.Apr 26 2021, 1:28 PM
libcxx/test/support/test_iterators.h
66

The most salient difference is that C++20 input iterators need not be copyable. I expected that this would be fresh in your mind, since you've recently reviewed D100271, which is why I didn't mention it.

cjdb updated this revision to Diff 340647.Apr 26 2021, 2:20 PM
cjdb retitled this revision from [libcxx][nfc] renames test iterator types to `legacy_*_iterator` to [libcxx][nfc] prefixes test type `input_iterator` with `cpp17_`.
cjdb edited the summary of this revision. (Show Details)
  • reverts legacy_forward_iterator (and stronger)
  • replaces legacy prefix with cpp17
  • revises commit message to reflect drastic changes
• Quuxplusone added inline comments.Apr 26 2021, 2:40 PM
libcxx/test/support/test_iterators.h
66

So basically the intent of D101242-plus-D100271 is to introduce moveonly_input_iterator (and moveonly_output_iterator) while leaving everything else the same? I would approve of that direction.

But I notice that D100271 doesn't introduce a sentinel with which its new iterator type could be compared. It probably should include a sentinel, in order to make the new iterator type more useful with C++20 algorithms like std::ranges::copy. Still, I'm a little leery of introducing too many knobs. We probably don't want all four of a "copyable, comparable iterator" (i.e. the existing input_iterator/output_iterator) and a "move-only, comparable iterator" and a "copyable, sentineled iterator" and a "move-only, sentineled iterator"; but I'm still not sure what we do want.

(Fortunately, std::forward_iterator and higher all require std::regular, which means "copyable and comparable"; so the above combinatorial explosion applies only to input iterators and output iterators.)

cjdb added inline comments.Apr 26 2021, 4:20 PM
libcxx/test/support/test_iterators.h
66

So basically the intent of D101242-plus-D100271 is to introduce moveonly_input_iterator (and moveonly_output_iterator) while leaving everything else the same? I would approve of that direction.

That + prefixing current input_iterator with cpp17_ (or copyable_, which is more descriptive, but longer).

But I notice that D100271 doesn't introduce a sentinel with which its new iterator type could be compared. It probably should include a sentinel, in order to make the new iterator type more useful with C++20 algorithms like std::ranges::copy.

The patch has no need for a sentinel, so it's not added. I think it'd be a good idea for us to think about what the new sentinel type should do, and add it either with the first algorithm or as a follow-up patch to D100271 (it certainly shouldn't be blocking).

Still, I'm a little leery of introducing too many knobs. We probably don't want all four of a "copyable, comparable iterator" (i.e. the existing input_iterator/output_iterator) and a "move-only, comparable iterator" and a "copyable, sentineled iterator" and a "move-only, sentineled iterator"; but I'm still not sure what we do want.

Yeah, that's a bad idea. My intention is for the new, move-only input iterator is for it to be a completely minimal interface (i.e. move-only, not a self-sentinel).

Harbormaster completed remote builds in B101023: Diff 340647.Apr 26 2021, 11:27 PM
ldionne accepted this revision.Apr 27 2021, 12:21 PM

Reached agreement with @cjdb offline about using cpp17_input_iterator here and cpp20_input_iterator for the new thing introduced by D100271.

LGTM but please add a one-line comment saying This is the InputIterator concept as described prior to C++20 or something along those lines.

Mordante accepted this revision.Apr 28 2021, 10:18 AM
In D101242#2720585, @ldionne wrote:

Reached agreement with @cjdb offline about using cpp17_input_iterator here and cpp20_input_iterator for the new thing introduced by D100271.

Nice!
LGTM.

ldionne added a comment.Apr 30 2021, 2:22 PM

Can we apply the feedback and land this? Sorry to be pushy, but this is a large change (in terms of touched lines) and I'd like to get it in ASAP.

cjdb updated this revision to Diff 342043.Apr 30 2021, 2:31 PM

adds a comment explaining what cpp17_input_iterator represents

Harbormaster completed remote builds in B102022: Diff 342043.Apr 30 2021, 3:41 PM
cjdb updated this revision to Diff 342101.Apr 30 2021, 6:46 PM

rebases to fix CI

Harbormaster completed remote builds in B102068: Diff 342101.Apr 30 2021, 7:01 PM
cjdb updated this revision to Diff 342112.Apr 30 2021, 8:49 PM

tries to get CI working once more

• Quuxplusone added inline comments.Apr 30 2021, 8:55 PM
libcxx/benchmarks/filesystem.bench.cpp
69

This legacy_ should also be cpp17_, right? (I think a git grep would help here.)

cjdb updated this revision to Diff 342115.Apr 30 2021, 9:38 PM

fixes benchmark

libcxx/benchmarks/filesystem.bench.cpp
69

Thanks! TIL about git grep.

Harbormaster completed remote builds in B102074: Diff 342112.Apr 30 2021, 10:22 PM
Harbormaster completed remote builds in B102077: Diff 342115.May 1 2021, 12:37 AM
This revision was not accepted when it landed; it landed in state Needs Review.May 1 2021, 10:03 PM
Closed by commit rG773ae4412468: [libcxx][nfc] prefixes test type `input_iterator` with `cpp17_` (authored by cjdb). · Explain Why
This revision was automatically updated to reflect the committed changes.
cjdb added a commit: rG773ae4412468: [libcxx][nfc] prefixes test type `input_iterator` with `cpp17_`.

Revision Contents

PathSize
libcxx/
benchmarks/
2 lines
test/
libcxx/
containers/
sequences/
list/
list.modifiers/
4 lines
vector/
2 lines
input.output/
filesystems/
class.path/
path.req/
4 lines
iterators/
2 lines
std/
algorithms/
alg.modifying.operations/
alg.copy/
12 lines
20 lines
20 lines
alg.move/
46 lines
alg.partitions/
24 lines
4 lines
alg.random.sample/
2 lines
10 lines
2 lines
alg.remove/
10 lines
10 lines
alg.replace/
10 lines
10 lines
alg.transform/
150 lines
20 lines
alg.unique/
10 lines
10 lines
alg.nonmodifying/
alg.all_of/
16 lines
alg.any_of/
24 lines
alg.count/
12 lines
12 lines
alg.equal/
38 lines
38 lines
alg.find.first.of/
24 lines
24 lines
alg.find/
8 lines
10 lines
10 lines
alg.foreach/
2 lines
4 lines
alg.none_of/
24 lines
mismatch/
4 lines
4 lines
alg.sorting/
alg.lex.comparison/
18 lines
18 lines
alg.merge/
4 lines
4 lines
alg.min.max/
2 lines
alg.set.operations/
includes/
18 lines
18 lines
set.difference/
4 lines
4 lines
set.intersection/
4 lines
4 lines
set.symmetric.difference/
4 lines
4 lines
set.union/
4 lines
4 lines
containers/
associative/
map/
map.modifiers/
4 lines
multimap/
multimap.modifiers/
4 lines
multiset/
8 lines
multiset.cons/
8 lines
4 lines
4 lines
set/
8 lines
set.cons/
8 lines
4 lines
4 lines
sequences/
deque/
deque.cons/
4 lines
4 lines
6 lines
deque.modifiers/
6 lines
deque.special/
2 lines
forwardlist/
forwardlist.cons/
8 lines
4 lines
4 lines
forwardlist.modifiers/
4 lines
list/
list.cons/
28 lines
vector.bool/
4 lines
4 lines
8 lines
vector/
vector.cons/
2 lines
14 lines
10 lines
vector.modifiers/
14 lines
unord/
unord.map/
unord.map.cnstr/
8 lines
4 lines
4 lines
4 lines
6 lines
unord.map.modifiers/
4 lines
unord.multimap/
unord.multimap.cnstr/
8 lines
4 lines
4 lines
4 lines
6 lines
unord.multimap.modifiers/
4 lines
unord.multiset/
4 lines
unord.multiset.cnstr/
8 lines
4 lines
4 lines
4 lines
4 lines
unord.set/
4 lines
unord.set.cnstr/
8 lines
4 lines
4 lines
4 lines
4 lines
experimental/
iterator/
ostream.joiner/
ostream.joiner.ops/
8 lines
input.output/
filesystems/
class.path/
path.member/
8 lines
path.assign/
10 lines
8 lines
path.construct/
8 lines
iterators/
iterator.primitives/
iterator.operations/
4 lines
2 lines
4 lines
iterator.traits/
2 lines
2 lines
iterator.requirements/
iterator.concepts/
iterator.concept.input/
2 lines
iterator.concept.iterator/
8 lines
predef.iterators/
move.iterators/
move.iter.ops/
move.iter.nonmember/
2 lines
move.iter.op.comp/
4 lines
4 lines
move.iter.op.const/
2 lines
2 lines
2 lines
move.iter.op.incr/
4 lines
2 lines
move.iter.op=/
2 lines
move.iterator/
2 lines
localization/
locale.categories/
category.monetary/
locale.money.get/
locale.money.get.members/
116 lines
116 lines
116 lines
116 lines
116 lines
category.numeric/
locale.num.get/
facet.num.get.members/
86 lines
110 lines
86 lines
230 lines
116 lines
32 lines
14 lines
20 lines
20 lines
20 lines
20 lines
38 lines
category.time/
locale.time.get.byname/
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
locale.time.get/
locale.time.get.members/
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
numerics/
numeric.ops/
accumulate/
2 lines
2 lines
adjacent.difference/
10 lines
10 lines
exclusive.scan/
2 lines
2 lines
inclusive.scan/
2 lines
2 lines
2 lines
inner.product/
18 lines
18 lines
partial.sum/
10 lines
10 lines
reduce/
2 lines
2 lines
2 lines
transform.exclusive.scan/
2 lines
transform.inclusive.scan/
2 lines
2 lines
transform.reduce/
2 lines
14 lines
14 lines
ranges/
range.range/
9 lines
12 lines
2 lines
12 lines
range.refinements/
16 lines
17 lines
re/
re.regex/
re.regex.assign/
2 lines
strings/
basic.string/
cpp17_input_iterator.h
input_iterator.h
14 lines
string.cons/
4 lines
34 lines
2 lines
2 lines
2 lines
string.modifiers/
string_append/
66 lines
string_assign/
66 lines
string_insert/
80 lines
string_replace/
2 lines
utilities/
memory/
specialized.algorithms/
uninitialized.move/
2 lines
2 lines
support/
28 lines
8 lines

Diff 342218

libcxx/benchmarks/filesystem.bench.cpp

Show First 20 Lines • Show All 56 Lines • ▼ Show 20 Linesvoid BM_PathConstructIter(benchmark::State &st, GenInputs gen) {
while (st.KeepRunning()) { while (st.KeepRunning()) {
const path P(Start, End); const path P(Start, End);
benchmark::DoNotOptimize(P.native().data()); benchmark::DoNotOptimize(P.native().data());
} }
st.SetComplexityN(st.range(0)); st.SetComplexityN(st.range(0));
} }
template <class GenInputs> template <class GenInputs>
void BM_PathConstructInputIter(benchmark::State &st, GenInputs gen) { void BM_PathConstructInputIter(benchmark::State &st, GenInputs gen) {
BM_PathConstructIter<input_iterator>(st, gen); BM_PathConstructIter<cpp17_input_iterator>(st, gen);
} }
template <class GenInputs> template <class GenInputs>
void BM_PathConstructForwardIter(benchmark::State &st, GenInputs gen) { void BM_PathConstructForwardIter(benchmark::State &st, GenInputs gen) {
BM_PathConstructIter<forward_iterator>(st, gen); BM_PathConstructIter<forward_iterator>(st, gen);
QuuxplusoneUnsubmitted
Not Done
ReplyInline Actions

This legacy_ should also be cpp17_, right? (I think a git grep would help here.)

Quuxplusone: This `legacy_` should also be `cpp17_`, right? (I think a `git grep` would help here.)
cjdbAuthorUnsubmitted
Done
ReplyInline Actions

Thanks! TIL about git grep.

cjdb: Thanks! TIL about `git grep`.
} }
BENCHMARK_CAPTURE(BM_PathConstructInputIter, large_string, BENCHMARK_CAPTURE(BM_PathConstructInputIter, large_string,
getRandomStringInputs)->Range(8, TestNumInputs)->Complexity(); getRandomStringInputs)->Range(8, TestNumInputs)->Complexity();
BENCHMARK_CAPTURE(BM_PathConstructForwardIter, large_string, BENCHMARK_CAPTURE(BM_PathConstructForwardIter, large_string,
getRandomStringInputs)->Range(8, TestNumInputs)->Complexity(); getRandomStringInputs)->Range(8, TestNumInputs)->Complexity();
template <class GenInputs> template <class GenInputs>
▲ Show 20 Lines • Show All 86 Lines • Show Last 20 Lines

libcxx/test/libcxx/containers/sequences/list/list.modifiers/insert_iter_iter_iter_db1.pass.cpp

Show All 24 Lines
int main(int, char**) int main(int, char**)
{ {
{ {
std::list<int> v(100); std::list<int> v(100);
std::list<int> v2(100); std::list<int> v2(100);
int a[] = {1, 2, 3, 4, 5}; int a[] = {1, 2, 3, 4, 5};
const int N = sizeof(a)/sizeof(a[0]); const int N = sizeof(a)/sizeof(a[0]);
std::list<int>::iterator i = v.insert(next(v2.cbegin(), 10), std::list<int>::iterator i = v.insert(next(v2.cbegin(), 10),
input_iterator<const int*>(a), cpp17_input_iterator<const int*>(a),
input_iterator<const int*>(a+N)); cpp17_input_iterator<const int*>(a+N));
assert(false); assert(false);
} }
return 0; return 0;
} }

libcxx/test/libcxx/containers/sequences/vector/asan.pass.cpp

Show All 36 Lines#if TEST_STD_VER >= 11
C c(std::begin(t), std::end(t)); C c(std::begin(t), std::end(t));
c.reserve(2*c.size()); c.reserve(2*c.size());
volatile T foo = c[c.size()]; // bad, but not caught by ASAN volatile T foo = c[c.size()]; // bad, but not caught by ASAN
((void)foo); ((void)foo);
} }
#endif #endif
{ {
typedef input_iterator<int*> MyInputIter; typedef cpp17_input_iterator<int*> MyInputIter;
// Sould not trigger ASan. // Sould not trigger ASan.
std::vector<int> v; std::vector<int> v;
v.reserve(1); v.reserve(1);
int i[] = {42}; int i[] = {42};
v.insert(v.begin(), MyInputIter(i), MyInputIter(i + 1)); v.insert(v.begin(), MyInputIter(i), MyInputIter(i + 1));
assert(v[0] == 42); assert(v[0] == 42);
assert(is_contiguous_container_asan_correct(v)); assert(is_contiguous_container_asan_correct(v));
} }
Show All 15 Lines

libcxx/test/libcxx/input.output/filesystems/class.path/path.req/is_pathable.pass.cpp

Show First 20 Lines • Show All 57 Lines • ▼ Show 20 Linesstruct MakeTestType {
using string_type = std::basic_string<CharT>; using string_type = std::basic_string<CharT>;
using string_type2 = std::basic_string<CharT, std::char_traits<CharT>, min_allocator<CharT>>; using string_type2 = std::basic_string<CharT, std::char_traits<CharT>, min_allocator<CharT>>;
using string_view_type = std::basic_string_view<CharT>; using string_view_type = std::basic_string_view<CharT>;
using string_view_type2 = std::basic_string_view<CharT, constexpr_char_traits<CharT>>; using string_view_type2 = std::basic_string_view<CharT, constexpr_char_traits<CharT>>;
using cstr_type = CharT* const; using cstr_type = CharT* const;
using const_cstr_type = const CharT*; using const_cstr_type = const CharT*;
using array_type = CharT[25]; using array_type = CharT[25];
using const_array_type = const CharT[25]; using const_array_type = const CharT[25];
using iter_type = input_iterator<CharT*>; using iter_type = cpp17_input_iterator<CharT*>;
using bad_iter_type = input_iterator<signed char*>; using bad_iter_type = cpp17_input_iterator<signed char*>;
template <class TestT> template <class TestT>
static void AssertPathable() { static void AssertPathable() {
static_assert(__is_pathable<TestT>::value, ""); static_assert(__is_pathable<TestT>::value, "");
static_assert(CheckPassSource<TestT>::value, "cannot pass as Source const&"); static_assert(CheckPassSource<TestT>::value, "cannot pass as Source const&");
ASSERT_SAME_TYPE(CharT, typename __is_pathable<TestT>::__char_type); ASSERT_SAME_TYPE(CharT, typename __is_pathable<TestT>::__char_type);
} }
Show All 30 Lines

libcxx/test/libcxx/iterators/contiguous_iterators.pass.cpp

Show First 20 Lines • Show All 186 Lines • ▼ Show 20 Lines
#if TEST_STD_VER >= 20 #if TEST_STD_VER >= 20
static_assert(( std::__is_cpp17_contiguous_iterator<std::__wrap_iter<my_contiguous_iterator> >::value), ""); static_assert(( std::__is_cpp17_contiguous_iterator<std::__wrap_iter<my_contiguous_iterator> >::value), "");
static_assert(( std::__is_cpp17_contiguous_iterator<std::__wrap_iter<std::__wrap_iter<my_contiguous_iterator> > >::value), ""); static_assert(( std::__is_cpp17_contiguous_iterator<std::__wrap_iter<std::__wrap_iter<my_contiguous_iterator> > >::value), "");
static_assert((!std::__is_cpp17_contiguous_iterator<std::__wrap_iter<std::reverse_iterator<my_contiguous_iterator> > >::value), ""); static_assert((!std::__is_cpp17_contiguous_iterator<std::__wrap_iter<std::reverse_iterator<my_contiguous_iterator> > >::value), "");
#endif #endif
// iterators in the libc++ test suite // iterators in the libc++ test suite
static_assert((!std::__is_cpp17_contiguous_iterator<output_iterator <char *> >::value), ""); static_assert((!std::__is_cpp17_contiguous_iterator<output_iterator <char *> >::value), "");
static_assert((!std::__is_cpp17_contiguous_iterator<input_iterator <char *> >::value), ""); static_assert((!std::__is_cpp17_contiguous_iterator<cpp17_input_iterator <char *> >::value), "");
static_assert((!std::__is_cpp17_contiguous_iterator<forward_iterator <char *> >::value), ""); static_assert((!std::__is_cpp17_contiguous_iterator<forward_iterator <char *> >::value), "");
static_assert((!std::__is_cpp17_contiguous_iterator<bidirectional_iterator<char *> >::value), ""); static_assert((!std::__is_cpp17_contiguous_iterator<bidirectional_iterator<char *> >::value), "");
static_assert((!std::__is_cpp17_contiguous_iterator<random_access_iterator<char *> >::value), ""); static_assert((!std::__is_cpp17_contiguous_iterator<random_access_iterator<char *> >::value), "");
#if TEST_STD_VER >= 20 #if TEST_STD_VER >= 20
static_assert(( std::__is_cpp17_contiguous_iterator<contiguous_iterator <char *> >::value), ""); static_assert(( std::__is_cpp17_contiguous_iterator<contiguous_iterator <char *> >::value), "");
#endif #endif
static_assert((!std::__is_cpp17_contiguous_iterator<ThrowingIterator <char *> >::value), ""); static_assert((!std::__is_cpp17_contiguous_iterator<ThrowingIterator <char *> >::value), "");
static_assert((!std::__is_cpp17_contiguous_iterator<NonThrowingIterator <char *> >::value), ""); static_assert((!std::__is_cpp17_contiguous_iterator<NonThrowingIterator <char *> >::value), "");
▲ Show 20 Lines • Show All 55 Lines • Show Last 20 Lines

libcxx/test/std/algorithms/alg.modifying.operations/alg.copy/copy.pass.cpp

Show All 33 Linestest_copy()
assert(base(r) == ib+N); assert(base(r) == ib+N);
for (unsigned i = 0; i < N; ++i) for (unsigned i = 0; i < N; ++i)
assert(ia[i] == ib[i]); assert(ia[i] == ib[i]);
} }
TEST_CONSTEXPR_CXX20 bool TEST_CONSTEXPR_CXX20 bool
test() test()
{ {
test_copy<input_iterator<const int*>, output_iterator<int*> >(); test_copy<cpp17_input_iterator<const int*>, output_iterator<int*> >();
test_copy<input_iterator<const int*>, forward_iterator<int*> >(); test_copy<cpp17_input_iterator<const int*>, forward_iterator<int*> >();
test_copy<input_iterator<const int*>, bidirectional_iterator<int*> >(); test_copy<cpp17_input_iterator<const int*>, bidirectional_iterator<int*> >();
test_copy<input_iterator<const int*>, random_access_iterator<int*> >(); test_copy<cpp17_input_iterator<const int*>, random_access_iterator<int*> >();
test_copy<input_iterator<const int*>, int*>(); test_copy<cpp17_input_iterator<const int*>, int*>();
test_copy<forward_iterator<const int*>, output_iterator<int*> >(); test_copy<forward_iterator<const int*>, output_iterator<int*> >();
test_copy<forward_iterator<const int*>, forward_iterator<int*> >(); test_copy<forward_iterator<const int*>, forward_iterator<int*> >();
test_copy<forward_iterator<const int*>, bidirectional_iterator<int*> >(); test_copy<forward_iterator<const int*>, bidirectional_iterator<int*> >();
test_copy<forward_iterator<const int*>, random_access_iterator<int*> >(); test_copy<forward_iterator<const int*>, random_access_iterator<int*> >();
test_copy<forward_iterator<const int*>, int*>(); test_copy<forward_iterator<const int*>, int*>();
test_copy<bidirectional_iterator<const int*>, output_iterator<int*> >(); test_copy<bidirectional_iterator<const int*>, output_iterator<int*> >();
Show All 10 Linestest()
test_copy<const int*, output_iterator<int*> >(); test_copy<const int*, output_iterator<int*> >();
test_copy<const int*, forward_iterator<int*> >(); test_copy<const int*, forward_iterator<int*> >();
test_copy<const int*, bidirectional_iterator<int*> >(); test_copy<const int*, bidirectional_iterator<int*> >();
test_copy<const int*, random_access_iterator<int*> >(); test_copy<const int*, random_access_iterator<int*> >();
test_copy<const int*, int*>(); test_copy<const int*, int*>();
#if TEST_STD_VER > 17 #if TEST_STD_VER > 17
test_copy<input_iterator<const int*>, contiguous_iterator<int*>>(); test_copy<cpp17_input_iterator<const int*>, contiguous_iterator<int*>>();
test_copy<forward_iterator<const int*>, contiguous_iterator<int*>>(); test_copy<forward_iterator<const int*>, contiguous_iterator<int*>>();
test_copy<bidirectional_iterator<const int*>, contiguous_iterator<int*>>(); test_copy<bidirectional_iterator<const int*>, contiguous_iterator<int*>>();
test_copy<random_access_iterator<const int*>, contiguous_iterator<int*>>(); test_copy<random_access_iterator<const int*>, contiguous_iterator<int*>>();
test_copy<const int*, contiguous_iterator<int*>>(); test_copy<const int*, contiguous_iterator<int*>>();
test_copy<contiguous_iterator<const int*>, output_iterator<int*>>(); test_copy<contiguous_iterator<const int*>, output_iterator<int*>>();
test_copy<contiguous_iterator<const int*>, forward_iterator<int*>>(); test_copy<contiguous_iterator<const int*>, forward_iterator<int*>>();
test_copy<contiguous_iterator<const int*>, bidirectional_iterator<int*>>(); test_copy<contiguous_iterator<const int*>, bidirectional_iterator<int*>>();
Show All 17 Lines

libcxx/test/std/algorithms/alg.modifying.operations/alg.copy/copy_if.pass.cpp

Show All 38 Linestest_copy_if()
assert(base(r) == ib+N/3+1); assert(base(r) == ib+N/3+1);
for (unsigned i = 0; i < N/3+1; ++i) for (unsigned i = 0; i < N/3+1; ++i)
assert(ib[i] % 3 == 0); assert(ib[i] % 3 == 0);
} }
TEST_CONSTEXPR_CXX20 bool TEST_CONSTEXPR_CXX20 bool
test() test()
{ {
test_copy_if<input_iterator<const int*>, output_iterator<int*> >(); test_copy_if<cpp17_input_iterator<const int*>, output_iterator<int*> >();
test_copy_if<input_iterator<const int*>, input_iterator<int*> >(); test_copy_if<cpp17_input_iterator<const int*>, cpp17_input_iterator<int*> >();
test_copy_if<input_iterator<const int*>, forward_iterator<int*> >(); test_copy_if<cpp17_input_iterator<const int*>, forward_iterator<int*> >();
test_copy_if<input_iterator<const int*>, bidirectional_iterator<int*> >(); test_copy_if<cpp17_input_iterator<const int*>, bidirectional_iterator<int*> >();
test_copy_if<input_iterator<const int*>, random_access_iterator<int*> >(); test_copy_if<cpp17_input_iterator<const int*>, random_access_iterator<int*> >();
test_copy_if<input_iterator<const int*>, int*>(); test_copy_if<cpp17_input_iterator<const int*>, int*>();
test_copy_if<forward_iterator<const int*>, output_iterator<int*> >(); test_copy_if<forward_iterator<const int*>, output_iterator<int*> >();
test_copy_if<forward_iterator<const int*>, input_iterator<int*> >(); test_copy_if<forward_iterator<const int*>, cpp17_input_iterator<int*> >();
test_copy_if<forward_iterator<const int*>, forward_iterator<int*> >(); test_copy_if<forward_iterator<const int*>, forward_iterator<int*> >();
test_copy_if<forward_iterator<const int*>, bidirectional_iterator<int*> >(); test_copy_if<forward_iterator<const int*>, bidirectional_iterator<int*> >();
test_copy_if<forward_iterator<const int*>, random_access_iterator<int*> >(); test_copy_if<forward_iterator<const int*>, random_access_iterator<int*> >();
test_copy_if<forward_iterator<const int*>, int*>(); test_copy_if<forward_iterator<const int*>, int*>();
test_copy_if<bidirectional_iterator<const int*>, output_iterator<int*> >(); test_copy_if<bidirectional_iterator<const int*>, output_iterator<int*> >();
test_copy_if<bidirectional_iterator<const int*>, input_iterator<int*> >(); test_copy_if<bidirectional_iterator<const int*>, cpp17_input_iterator<int*> >();
test_copy_if<bidirectional_iterator<const int*>, forward_iterator<int*> >(); test_copy_if<bidirectional_iterator<const int*>, forward_iterator<int*> >();
test_copy_if<bidirectional_iterator<const int*>, bidirectional_iterator<int*> >(); test_copy_if<bidirectional_iterator<const int*>, bidirectional_iterator<int*> >();
test_copy_if<bidirectional_iterator<const int*>, random_access_iterator<int*> >(); test_copy_if<bidirectional_iterator<const int*>, random_access_iterator<int*> >();
test_copy_if<bidirectional_iterator<const int*>, int*>(); test_copy_if<bidirectional_iterator<const int*>, int*>();
test_copy_if<random_access_iterator<const int*>, output_iterator<int*> >(); test_copy_if<random_access_iterator<const int*>, output_iterator<int*> >();
test_copy_if<random_access_iterator<const int*>, input_iterator<int*> >(); test_copy_if<random_access_iterator<const int*>, cpp17_input_iterator<int*> >();
test_copy_if<random_access_iterator<const int*>, forward_iterator<int*> >(); test_copy_if<random_access_iterator<const int*>, forward_iterator<int*> >();
test_copy_if<random_access_iterator<const int*>, bidirectional_iterator<int*> >(); test_copy_if<random_access_iterator<const int*>, bidirectional_iterator<int*> >();
test_copy_if<random_access_iterator<const int*>, random_access_iterator<int*> >(); test_copy_if<random_access_iterator<const int*>, random_access_iterator<int*> >();
test_copy_if<random_access_iterator<const int*>, int*>(); test_copy_if<random_access_iterator<const int*>, int*>();
test_copy_if<const int*, output_iterator<int*> >(); test_copy_if<const int*, output_iterator<int*> >();
test_copy_if<const int*, input_iterator<int*> >(); test_copy_if<const int*, cpp17_input_iterator<int*> >();
test_copy_if<const int*, forward_iterator<int*> >(); test_copy_if<const int*, forward_iterator<int*> >();
test_copy_if<const int*, bidirectional_iterator<int*> >(); test_copy_if<const int*, bidirectional_iterator<int*> >();
test_copy_if<const int*, random_access_iterator<int*> >(); test_copy_if<const int*, random_access_iterator<int*> >();
test_copy_if<const int*, int*>(); test_copy_if<const int*, int*>();
return true; return true;
} }
Show All 10 Lines

libcxx/test/std/algorithms/alg.modifying.operations/alg.copy/copy_n.pass.cpp

Show All 36 Linestest_copy_n()
assert(base(r) == ib+N/2); assert(base(r) == ib+N/2);
for (unsigned i = 0; i < N/2; ++i) for (unsigned i = 0; i < N/2; ++i)
assert(ia[i] == ib[i]); assert(ia[i] == ib[i]);
} }
TEST_CONSTEXPR_CXX20 bool TEST_CONSTEXPR_CXX20 bool
test() test()
{ {
test_copy_n<input_iterator<const int*>, output_iterator<int*> >(); test_copy_n<cpp17_input_iterator<const int*>, output_iterator<int*> >();
test_copy_n<input_iterator<const int*>, input_iterator<int*> >(); test_copy_n<cpp17_input_iterator<const int*>, cpp17_input_iterator<int*> >();
test_copy_n<input_iterator<const int*>, forward_iterator<int*> >(); test_copy_n<cpp17_input_iterator<const int*>, forward_iterator<int*> >();
test_copy_n<input_iterator<const int*>, bidirectional_iterator<int*> >(); test_copy_n<cpp17_input_iterator<const int*>, bidirectional_iterator<int*> >();
test_copy_n<input_iterator<const int*>, random_access_iterator<int*> >(); test_copy_n<cpp17_input_iterator<const int*>, random_access_iterator<int*> >();
test_copy_n<input_iterator<const int*>, int*>(); test_copy_n<cpp17_input_iterator<const int*>, int*>();
test_copy_n<forward_iterator<const int*>, output_iterator<int*> >(); test_copy_n<forward_iterator<const int*>, output_iterator<int*> >();
test_copy_n<forward_iterator<const int*>, input_iterator<int*> >(); test_copy_n<forward_iterator<const int*>, cpp17_input_iterator<int*> >();
test_copy_n<forward_iterator<const int*>, forward_iterator<int*> >(); test_copy_n<forward_iterator<const int*>, forward_iterator<int*> >();
test_copy_n<forward_iterator<const int*>, bidirectional_iterator<int*> >(); test_copy_n<forward_iterator<const int*>, bidirectional_iterator<int*> >();
test_copy_n<forward_iterator<const int*>, random_access_iterator<int*> >(); test_copy_n<forward_iterator<const int*>, random_access_iterator<int*> >();
test_copy_n<forward_iterator<const int*>, int*>(); test_copy_n<forward_iterator<const int*>, int*>();
test_copy_n<bidirectional_iterator<const int*>, output_iterator<int*> >(); test_copy_n<bidirectional_iterator<const int*>, output_iterator<int*> >();
test_copy_n<bidirectional_iterator<const int*>, input_iterator<int*> >(); test_copy_n<bidirectional_iterator<const int*>, cpp17_input_iterator<int*> >();
test_copy_n<bidirectional_iterator<const int*>, forward_iterator<int*> >(); test_copy_n<bidirectional_iterator<const int*>, forward_iterator<int*> >();
test_copy_n<bidirectional_iterator<const int*>, bidirectional_iterator<int*> >(); test_copy_n<bidirectional_iterator<const int*>, bidirectional_iterator<int*> >();
test_copy_n<bidirectional_iterator<const int*>, random_access_iterator<int*> >(); test_copy_n<bidirectional_iterator<const int*>, random_access_iterator<int*> >();
test_copy_n<bidirectional_iterator<const int*>, int*>(); test_copy_n<bidirectional_iterator<const int*>, int*>();
test_copy_n<random_access_iterator<const int*>, output_iterator<int*> >(); test_copy_n<random_access_iterator<const int*>, output_iterator<int*> >();
test_copy_n<random_access_iterator<const int*>, input_iterator<int*> >(); test_copy_n<random_access_iterator<const int*>, cpp17_input_iterator<int*> >();
test_copy_n<random_access_iterator<const int*>, forward_iterator<int*> >(); test_copy_n<random_access_iterator<const int*>, forward_iterator<int*> >();
test_copy_n<random_access_iterator<const int*>, bidirectional_iterator<int*> >(); test_copy_n<random_access_iterator<const int*>, bidirectional_iterator<int*> >();
test_copy_n<random_access_iterator<const int*>, random_access_iterator<int*> >(); test_copy_n<random_access_iterator<const int*>, random_access_iterator<int*> >();
test_copy_n<random_access_iterator<const int*>, int*>(); test_copy_n<random_access_iterator<const int*>, int*>();
test_copy_n<const int*, output_iterator<int*> >(); test_copy_n<const int*, output_iterator<int*> >();
test_copy_n<const int*, input_iterator<int*> >(); test_copy_n<const int*, cpp17_input_iterator<int*> >();
test_copy_n<const int*, forward_iterator<int*> >(); test_copy_n<const int*, forward_iterator<int*> >();
test_copy_n<const int*, bidirectional_iterator<int*> >(); test_copy_n<const int*, bidirectional_iterator<int*> >();
test_copy_n<const int*, random_access_iterator<int*> >(); test_copy_n<const int*, random_access_iterator<int*> >();
test_copy_n<const int*, int*>(); test_copy_n<const int*, int*>();
return true; return true;
} }
Show All 10 Lines

libcxx/test/std/algorithms/alg.modifying.operations/alg.move/move.pass.cpp

Show First 20 Lines • Show All 57 Lines • ▼ Show 20 Linestest1()
assert(base(r) == ib+N); assert(base(r) == ib+N);
for (unsigned i = 0; i < N; ++i) for (unsigned i = 0; i < N; ++i)
assert(*ib[i] == static_cast<int>(i)); assert(*ib[i] == static_cast<int>(i));
} }
#endif #endif
int main(int, char**) int main(int, char**)
{ {
test<input_iterator<const int*>, output_iterator<int*> >(); test<cpp17_input_iterator<const int*>, output_iterator<int*> >();
test<input_iterator<const int*>, forward_iterator<int*> >(); test<cpp17_input_iterator<const int*>, forward_iterator<int*> >();
test<input_iterator<const int*>, bidirectional_iterator<int*> >(); test<cpp17_input_iterator<const int*>, bidirectional_iterator<int*> >();
test<input_iterator<const int*>, random_access_iterator<int*> >(); test<cpp17_input_iterator<const int*>, random_access_iterator<int*> >();
test<input_iterator<const int*>, int*>(); test<cpp17_input_iterator<const int*>, int*>();
test<forward_iterator<const int*>, output_iterator<int*> >(); test<forward_iterator<const int*>, output_iterator<int*> >();
test<forward_iterator<const int*>, forward_iterator<int*> >(); test<forward_iterator<const int*>, forward_iterator<int*> >();
test<forward_iterator<const int*>, bidirectional_iterator<int*> >(); test<forward_iterator<const int*>, bidirectional_iterator<int*> >();
test<forward_iterator<const int*>, random_access_iterator<int*> >(); test<forward_iterator<const int*>, random_access_iterator<int*> >();
test<forward_iterator<const int*>, int*>(); test<forward_iterator<const int*>, int*>();
test<bidirectional_iterator<const int*>, output_iterator<int*> >(); test<bidirectional_iterator<const int*>, output_iterator<int*> >();
Show All 10 Linesint main(int, char**)
test<const int*, output_iterator<int*> >(); test<const int*, output_iterator<int*> >();
test<const int*, forward_iterator<int*> >(); test<const int*, forward_iterator<int*> >();
test<const int*, bidirectional_iterator<int*> >(); test<const int*, bidirectional_iterator<int*> >();
test<const int*, random_access_iterator<int*> >(); test<const int*, random_access_iterator<int*> >();
test<const int*, int*>(); test<const int*, int*>();
#if TEST_STD_VER >= 11 #if TEST_STD_VER >= 11
test1<input_iterator<std::unique_ptr<int>*>, output_iterator<std::unique_ptr<int>*> >(); test1<cpp17_input_iterator<std::unique_ptr<int>*>, output_iterator<std::unique_ptr<int>*> >();
test1<input_iterator<std::unique_ptr<int>*>, forward_iterator<std::unique_ptr<int>*> >(); test1<cpp17_input_iterator<std::unique_ptr<int>*>, forward_iterator<std::unique_ptr<int>*> >();
test1<input_iterator<std::unique_ptr<int>*>, bidirectional_iterator<std::unique_ptr<int>*> >(); test1<cpp17_input_iterator<std::unique_ptr<int>*>, bidirectional_iterator<std::unique_ptr<int>*> >();
test1<input_iterator<std::unique_ptr<int>*>, random_access_iterator<std::unique_ptr<int>*> >(); test1<cpp17_input_iterator<std::unique_ptr<int>*>, random_access_iterator<std::unique_ptr<int>*> >();
test1<input_iterator<std::unique_ptr<int>*>, std::unique_ptr<int>*>(); test1<cpp17_input_iterator<std::unique_ptr<int>*>, std::unique_ptr<int>*>();
test1<forward_iterator<std::unique_ptr<int>*>, output_iterator<std::unique_ptr<int>*> >(); test1<forward_iterator<std::unique_ptr<int>*>, output_iterator<std::unique_ptr<int>*> >();
test1<forward_iterator<std::unique_ptr<int>*>, forward_iterator<std::unique_ptr<int>*> >(); test1<forward_iterator<std::unique_ptr<int>*>, forward_iterator<std::unique_ptr<int>*> >();
test1<forward_iterator<std::unique_ptr<int>*>, bidirectional_iterator<std::unique_ptr<int>*> >(); test1<forward_iterator<std::unique_ptr<int>*>, bidirectional_iterator<std::unique_ptr<int>*> >();
test1<forward_iterator<std::unique_ptr<int>*>, random_access_iterator<std::unique_ptr<int>*> >(); test1<forward_iterator<std::unique_ptr<int>*>, random_access_iterator<std::unique_ptr<int>*> >();
test1<forward_iterator<std::unique_ptr<int>*>, std::unique_ptr<int>*>(); test1<forward_iterator<std::unique_ptr<int>*>, std::unique_ptr<int>*>();
test1<bidirectional_iterator<std::unique_ptr<int>*>, output_iterator<std::unique_ptr<int>*> >(); test1<bidirectional_iterator<std::unique_ptr<int>*>, output_iterator<std::unique_ptr<int>*> >();
Show All 11 Lines#if TEST_STD_VER >= 11
test1<std::unique_ptr<int>*, output_iterator<std::unique_ptr<int>*> >(); test1<std::unique_ptr<int>*, output_iterator<std::unique_ptr<int>*> >();
test1<std::unique_ptr<int>*, forward_iterator<std::unique_ptr<int>*> >(); test1<std::unique_ptr<int>*, forward_iterator<std::unique_ptr<int>*> >();
test1<std::unique_ptr<int>*, bidirectional_iterator<std::unique_ptr<int>*> >(); test1<std::unique_ptr<int>*, bidirectional_iterator<std::unique_ptr<int>*> >();
test1<std::unique_ptr<int>*, random_access_iterator<std::unique_ptr<int>*> >(); test1<std::unique_ptr<int>*, random_access_iterator<std::unique_ptr<int>*> >();
test1<std::unique_ptr<int>*, std::unique_ptr<int>*>(); test1<std::unique_ptr<int>*, std::unique_ptr<int>*>();
#endif // TEST_STD_VER >= 11 #endif // TEST_STD_VER >= 11
#if TEST_STD_VER > 17 #if TEST_STD_VER > 17
test<input_iterator<const int*>, contiguous_iterator<int*>>(); test<cpp17_input_iterator<const int*>, contiguous_iterator<int*>>();
test<forward_iterator<const int*>, contiguous_iterator<int*>>(); test<forward_iterator<const int*>, contiguous_iterator<int*>>();
test<bidirectional_iterator<const int*>, contiguous_iterator<int*>>(); test<bidirectional_iterator<const int*>, contiguous_iterator<int*>>();
test<random_access_iterator<const int*>, contiguous_iterator<int*>>(); test<random_access_iterator<const int*>, contiguous_iterator<int*>>();
test<const int*, contiguous_iterator<int*>>(); test<const int*, contiguous_iterator<int*>>();
test<contiguous_iterator<const int*>, output_iterator<int*>>(); test<contiguous_iterator<const int*>, output_iterator<int*>>();
test<contiguous_iterator<const int*>, forward_iterator<int*>>(); test<contiguous_iterator<const int*>, forward_iterator<int*>>();
test<contiguous_iterator<const int*>, bidirectional_iterator<int*>>(); test<contiguous_iterator<const int*>, bidirectional_iterator<int*>>();
test<contiguous_iterator<const int*>, random_access_iterator<int*>>(); test<contiguous_iterator<const int*>, random_access_iterator<int*>>();
test<contiguous_iterator<const int*>, int*>(); test<contiguous_iterator<const int*>, int*>();
test<contiguous_iterator<const int*>, contiguous_iterator<int*>>(); test<contiguous_iterator<const int*>, contiguous_iterator<int*>>();
test1<input_iterator<std::unique_ptr<int>*>, contiguous_iterator<std::unique_ptr<int>*>>(); test1<cpp17_input_iterator<std::unique_ptr<int>*>, contiguous_iterator<std::unique_ptr<int>*>>();
test1<forward_iterator<std::unique_ptr<int>*>, contiguous_iterator<std::unique_ptr<int>*>>(); test1<forward_iterator<std::unique_ptr<int>*>, contiguous_iterator<std::unique_ptr<int>*>>();
test1<bidirectional_iterator<std::unique_ptr<int>*>, contiguous_iterator<std::unique_ptr<int>*>>(); test1<bidirectional_iterator<std::unique_ptr<int>*>, contiguous_iterator<std::unique_ptr<int>*>>();
test1<random_access_iterator<std::unique_ptr<int>*>, contiguous_iterator<std::unique_ptr<int>*>>(); test1<random_access_iterator<std::unique_ptr<int>*>, contiguous_iterator<std::unique_ptr<int>*>>();
test1<std::unique_ptr<int>*, contiguous_iterator<std::unique_ptr<int>*>>(); test1<std::unique_ptr<int>*, contiguous_iterator<std::unique_ptr<int>*>>();
test1<contiguous_iterator<std::unique_ptr<int>*>, output_iterator<std::unique_ptr<int>*>>(); test1<contiguous_iterator<std::unique_ptr<int>*>, output_iterator<std::unique_ptr<int>*>>();
test1<contiguous_iterator<std::unique_ptr<int>*>, forward_iterator<std::unique_ptr<int>*>>(); test1<contiguous_iterator<std::unique_ptr<int>*>, forward_iterator<std::unique_ptr<int>*>>();
test1<contiguous_iterator<std::unique_ptr<int>*>, bidirectional_iterator<std::unique_ptr<int>*>>(); test1<contiguous_iterator<std::unique_ptr<int>*>, bidirectional_iterator<std::unique_ptr<int>*>>();
test1<contiguous_iterator<std::unique_ptr<int>*>, random_access_iterator<std::unique_ptr<int>*>>(); test1<contiguous_iterator<std::unique_ptr<int>*>, random_access_iterator<std::unique_ptr<int>*>>();
test1<contiguous_iterator<std::unique_ptr<int>*>, std::unique_ptr<int>*>(); test1<contiguous_iterator<std::unique_ptr<int>*>, std::unique_ptr<int>*>();
test1<contiguous_iterator<std::unique_ptr<int>*>, contiguous_iterator<std::unique_ptr<int>*>>(); test1<contiguous_iterator<std::unique_ptr<int>*>, contiguous_iterator<std::unique_ptr<int>*>>();
static_assert(test<input_iterator<const int*>, input_iterator<int*> >()); static_assert(test<cpp17_input_iterator<const int*>, cpp17_input_iterator<int*> >());
static_assert(test<input_iterator<const int*>, forward_iterator<int*> >()); static_assert(test<cpp17_input_iterator<const int*>, forward_iterator<int*> >());
static_assert(test<input_iterator<const int*>, bidirectional_iterator<int*> >()); static_assert(test<cpp17_input_iterator<const int*>, bidirectional_iterator<int*> >());
static_assert(test<input_iterator<const int*>, random_access_iterator<int*> >()); static_assert(test<cpp17_input_iterator<const int*>, random_access_iterator<int*> >());
static_assert(test<input_iterator<const int*>, contiguous_iterator<int*> >()); static_assert(test<cpp17_input_iterator<const int*>, contiguous_iterator<int*> >());
static_assert(test<input_iterator<const int*>, int*>()); static_assert(test<cpp17_input_iterator<const int*>, int*>());
static_assert(test<forward_iterator<const int*>, input_iterator<int*> >()); static_assert(test<forward_iterator<const int*>, cpp17_input_iterator<int*> >());
static_assert(test<forward_iterator<const int*>, forward_iterator<int*> >()); static_assert(test<forward_iterator<const int*>, forward_iterator<int*> >());
static_assert(test<forward_iterator<const int*>, bidirectional_iterator<int*> >()); static_assert(test<forward_iterator<const int*>, bidirectional_iterator<int*> >());
static_assert(test<forward_iterator<const int*>, random_access_iterator<int*> >()); static_assert(test<forward_iterator<const int*>, random_access_iterator<int*> >());
static_assert(test<forward_iterator<const int*>, contiguous_iterator<int*> >()); static_assert(test<forward_iterator<const int*>, contiguous_iterator<int*> >());
static_assert(test<forward_iterator<const int*>, int*>()); static_assert(test<forward_iterator<const int*>, int*>());
static_assert(test<bidirectional_iterator<const int*>, input_iterator<int*> >()); static_assert(test<bidirectional_iterator<const int*>, cpp17_input_iterator<int*> >());
static_assert(test<bidirectional_iterator<const int*>, forward_iterator<int*> >()); static_assert(test<bidirectional_iterator<const int*>, forward_iterator<int*> >());
static_assert(test<bidirectional_iterator<const int*>, bidirectional_iterator<int*> >()); static_assert(test<bidirectional_iterator<const int*>, bidirectional_iterator<int*> >());
static_assert(test<bidirectional_iterator<const int*>, random_access_iterator<int*> >()); static_assert(test<bidirectional_iterator<const int*>, random_access_iterator<int*> >());
static_assert(test<bidirectional_iterator<const int*>, contiguous_iterator<int*> >()); static_assert(test<bidirectional_iterator<const int*>, contiguous_iterator<int*> >());
static_assert(test<bidirectional_iterator<const int*>, int*>()); static_assert(test<bidirectional_iterator<const int*>, int*>());
static_assert(test<random_access_iterator<const int*>, input_iterator<int*> >()); static_assert(test<random_access_iterator<const int*>, cpp17_input_iterator<int*> >());
static_assert(test<random_access_iterator<const int*>, forward_iterator<int*> >()); static_assert(test<random_access_iterator<const int*>, forward_iterator<int*> >());
static_assert(test<random_access_iterator<const int*>, bidirectional_iterator<int*> >()); static_assert(test<random_access_iterator<const int*>, bidirectional_iterator<int*> >());
static_assert(test<random_access_iterator<const int*>, random_access_iterator<int*> >()); static_assert(test<random_access_iterator<const int*>, random_access_iterator<int*> >());
static_assert(test<random_access_iterator<const int*>, contiguous_iterator<int*> >()); static_assert(test<random_access_iterator<const int*>, contiguous_iterator<int*> >());
static_assert(test<random_access_iterator<const int*>, int*>()); static_assert(test<random_access_iterator<const int*>, int*>());
static_assert(test<contiguous_iterator<const int*>, input_iterator<int*> >()); static_assert(test<contiguous_iterator<const int*>, cpp17_input_iterator<int*> >());
static_assert(test<contiguous_iterator<const int*>, forward_iterator<int*> >()); static_assert(test<contiguous_iterator<const int*>, forward_iterator<int*> >());
static_assert(test<contiguous_iterator<const int*>, bidirectional_iterator<int*> >()); static_assert(test<contiguous_iterator<const int*>, bidirectional_iterator<int*> >());
static_assert(test<contiguous_iterator<const int*>, random_access_iterator<int*> >()); static_assert(test<contiguous_iterator<const int*>, random_access_iterator<int*> >());
static_assert(test<contiguous_iterator<const int*>, contiguous_iterator<int*> >()); static_assert(test<contiguous_iterator<const int*>, contiguous_iterator<int*> >());
static_assert(test<contiguous_iterator<const int*>, int*>()); static_assert(test<contiguous_iterator<const int*>, int*>());
static_assert(test<const int*, input_iterator<int*> >()); static_assert(test<const int*, cpp17_input_iterator<int*> >());
static_assert(test<const int*, forward_iterator<int*> >()); static_assert(test<const int*, forward_iterator<int*> >());
static_assert(test<const int*, bidirectional_iterator<int*> >()); static_assert(test<const int*, bidirectional_iterator<int*> >());
static_assert(test<const int*, random_access_iterator<int*> >()); static_assert(test<const int*, random_access_iterator<int*> >());
static_assert(test<const int*, contiguous_iterator<int*> >()); static_assert(test<const int*, contiguous_iterator<int*> >());
static_assert(test<const int*, int*>()); static_assert(test<const int*, int*>());
#endif // TEST_STD_VER > 17 #endif // TEST_STD_VER > 17
return 0; return 0;
} }

libcxx/test/std/algorithms/alg.modifying.operations/alg.partitions/is_partitioned.pass.cpp

Show All 33 LinesTEST_CONSTEXPR bool test_constexpr() {
} }
#endif #endif
int main(int, char**) { int main(int, char**) {
{ {
const int ia[] = {1, 2, 3, 4, 5, 6}; const int ia[] = {1, 2, 3, 4, 5, 6};
unary_counting_predicate<is_odd, int> pred((is_odd())); unary_counting_predicate<is_odd, int> pred((is_odd()));
assert(!std::is_partitioned(input_iterator<const int *>(std::begin(ia)), assert(!std::is_partitioned(cpp17_input_iterator<const int *>(std::begin(ia)),
input_iterator<const int *>(std::end(ia)), cpp17_input_iterator<const int *>(std::end(ia)),
std::ref(pred))); std::ref(pred)));
assert(static_cast<std::ptrdiff_t>(pred.count()) <= assert(static_cast<std::ptrdiff_t>(pred.count()) <=
std::distance(std::begin(ia), std::end(ia))); std::distance(std::begin(ia), std::end(ia)));
} }
{ {
const int ia[] = {1, 3, 5, 2, 4, 6}; const int ia[] = {1, 3, 5, 2, 4, 6};
unary_counting_predicate<is_odd, int> pred((is_odd())); unary_counting_predicate<is_odd, int> pred((is_odd()));
assert(std::is_partitioned(input_iterator<const int *>(std::begin(ia)), assert(std::is_partitioned(cpp17_input_iterator<const int *>(std::begin(ia)),
input_iterator<const int *>(std::end(ia)), cpp17_input_iterator<const int *>(std::end(ia)),
std::ref(pred))); std::ref(pred)));
assert(static_cast<std::ptrdiff_t>(pred.count()) <= assert(static_cast<std::ptrdiff_t>(pred.count()) <=
std::distance(std::begin(ia), std::end(ia))); std::distance(std::begin(ia), std::end(ia)));
} }
{ {
const int ia[] = {2, 4, 6, 1, 3, 5}; const int ia[] = {2, 4, 6, 1, 3, 5};
unary_counting_predicate<is_odd, int> pred((is_odd())); unary_counting_predicate<is_odd, int> pred((is_odd()));
assert(!std::is_partitioned(input_iterator<const int *>(std::begin(ia)), assert(!std::is_partitioned(cpp17_input_iterator<const int *>(std::begin(ia)),
input_iterator<const int *>(std::end(ia)), cpp17_input_iterator<const int *>(std::end(ia)),
std::ref(pred))); std::ref(pred)));
assert(static_cast<std::ptrdiff_t>(pred.count()) <= assert(static_cast<std::ptrdiff_t>(pred.count()) <=
std::distance(std::begin(ia), std::end(ia))); std::distance(std::begin(ia), std::end(ia)));
} }
{ {
const int ia[] = {1, 3, 5, 2, 4, 6, 7}; const int ia[] = {1, 3, 5, 2, 4, 6, 7};
unary_counting_predicate<is_odd, int> pred((is_odd())); unary_counting_predicate<is_odd, int> pred((is_odd()));
assert(!std::is_partitioned(input_iterator<const int *>(std::begin(ia)), assert(!std::is_partitioned(cpp17_input_iterator<const int *>(std::begin(ia)),
input_iterator<const int *>(std::end(ia)), cpp17_input_iterator<const int *>(std::end(ia)),
std::ref(pred))); std::ref(pred)));
assert(static_cast<std::ptrdiff_t>(pred.count()) <= assert(static_cast<std::ptrdiff_t>(pred.count()) <=
std::distance(std::begin(ia), std::end(ia))); std::distance(std::begin(ia), std::end(ia)));
} }
{ {
const int ia[] = {1, 3, 5, 2, 4, 6, 7}; const int ia[] = {1, 3, 5, 2, 4, 6, 7};
unary_counting_predicate<is_odd, int> pred((is_odd())); unary_counting_predicate<is_odd, int> pred((is_odd()));
assert(std::is_partitioned(input_iterator<const int *>(std::begin(ia)), assert(std::is_partitioned(cpp17_input_iterator<const int *>(std::begin(ia)),
input_iterator<const int *>(std::begin(ia)), cpp17_input_iterator<const int *>(std::begin(ia)),
std::ref(pred))); std::ref(pred)));
assert(static_cast<std::ptrdiff_t>(pred.count()) <= assert(static_cast<std::ptrdiff_t>(pred.count()) <=
std::distance(std::begin(ia), std::begin(ia))); std::distance(std::begin(ia), std::begin(ia)));
} }
{ {
const int ia[] = {1, 3, 5, 7, 9, 11, 2}; const int ia[] = {1, 3, 5, 7, 9, 11, 2};
unary_counting_predicate<is_odd, int> pred((is_odd())); unary_counting_predicate<is_odd, int> pred((is_odd()));
assert(std::is_partitioned(input_iterator<const int *>(std::begin(ia)), assert(std::is_partitioned(cpp17_input_iterator<const int *>(std::begin(ia)),
input_iterator<const int *>(std::end(ia)), cpp17_input_iterator<const int *>(std::end(ia)),
std::ref(pred))); std::ref(pred)));
assert(static_cast<std::ptrdiff_t>(pred.count()) <= assert(static_cast<std::ptrdiff_t>(pred.count()) <=
std::distance(std::begin(ia), std::end(ia))); std::distance(std::begin(ia), std::end(ia)));
} }
#if TEST_STD_VER > 17 #if TEST_STD_VER > 17
static_assert(test_constexpr()); static_assert(test_constexpr());
#endif #endif
return 0; return 0;
} }

libcxx/test/std/algorithms/alg.modifying.operations/alg.partitions/partition_copy.pass.cpp

Show First 20 Lines • Show All 44 Lines • ▼ Show 20 Lines
int main(int, char**) int main(int, char**)
{ {
{ {
const int ia[] = {1, 2, 3, 4, 6, 8, 5, 7}; const int ia[] = {1, 2, 3, 4, 6, 8, 5, 7};
int r1[10] = {0}; int r1[10] = {0};
int r2[10] = {0}; int r2[10] = {0};
typedef std::pair<output_iterator<int*>, int*> P; typedef std::pair<output_iterator<int*>, int*> P;
P p = std::partition_copy(input_iterator<const int*>(std::begin(ia)), P p = std::partition_copy(cpp17_input_iterator<const int*>(std::begin(ia)),
input_iterator<const int*>(std::end(ia)), cpp17_input_iterator<const int*>(std::end(ia)),
output_iterator<int*>(r1), r2, is_odd()); output_iterator<int*>(r1), r2, is_odd());
assert(p.first.base() == r1 + 4); assert(p.first.base() == r1 + 4);
assert(r1[0] == 1); assert(r1[0] == 1);
assert(r1[1] == 3); assert(r1[1] == 3);
assert(r1[2] == 5); assert(r1[2] == 5);
assert(r1[3] == 7); assert(r1[3] == 7);
assert(p.second == r2 + 4); assert(p.second == r2 + 4);
assert(r2[0] == 2); assert(r2[0] == 2);
Show All 11 Lines

libcxx/test/std/algorithms/alg.modifying.operations/alg.random.sample/sample.fail.cpp

Show All 33 Linestemplate <class PopulationIterator, class SampleIterator> void test() {
std::sample(PopulationIterator(ia), PopulationIterator(ia + is), std::sample(PopulationIterator(ia), PopulationIterator(ia + is),
SampleIterator(oa), os, g); SampleIterator(oa), os, g);
} }
int main(int, char**) { int main(int, char**) {
// expected-error-re@algorithm:* {{static_assert failed{{( due to requirement '.*')?}} "SampleIterator must meet the requirements of RandomAccessIterator"}} // expected-error-re@algorithm:* {{static_assert failed{{( due to requirement '.*')?}} "SampleIterator must meet the requirements of RandomAccessIterator"}}
// expected-error@algorithm:* 2 {{does not provide a subscript operator}} // expected-error@algorithm:* 2 {{does not provide a subscript operator}}
// expected-error@algorithm:* {{invalid operands}} // expected-error@algorithm:* {{invalid operands}}
test<input_iterator<int *>, output_iterator<int *> >(); test<cpp17_input_iterator<int *>, output_iterator<int *> >();
return 0; return 0;
} }

libcxx/test/std/algorithms/alg.modifying.operations/alg.random.sample/sample.pass.cpp

Show First 20 Lines • Show All 131 Lines • ▼ Show 20 Linesvoid test_small_population() {
if (std::is_base_of<std::forward_iterator_tag, PopulationCategory>::value) { if (std::is_base_of<std::forward_iterator_tag, PopulationCategory>::value) {
assert(std::equal(oa, end.base(), oa1)); assert(std::equal(oa, end.base(), oa1));
} else { } else {
assert(std::is_permutation(oa, end.base(), oa1)); assert(std::is_permutation(oa, end.base(), oa1));
} }
} }
int main(int, char**) { int main(int, char**) {
test<input_iterator, int, random_access_iterator, int>(); test<cpp17_input_iterator, int, random_access_iterator, int>();
test<forward_iterator, int, output_iterator, int>(); test<forward_iterator, int, output_iterator, int>();
test<forward_iterator, int, random_access_iterator, int>(); test<forward_iterator, int, random_access_iterator, int>();
test<input_iterator, int, random_access_iterator, double>(); test<cpp17_input_iterator, int, random_access_iterator, double>();
test<forward_iterator, int, output_iterator, double>(); test<forward_iterator, int, output_iterator, double>();
test<forward_iterator, int, random_access_iterator, double>(); test<forward_iterator, int, random_access_iterator, double>();
test_empty_population<input_iterator, int, random_access_iterator, int>(); test_empty_population<cpp17_input_iterator, int, random_access_iterator, int>();
test_empty_population<forward_iterator, int, output_iterator, int>(); test_empty_population<forward_iterator, int, output_iterator, int>();
test_empty_population<forward_iterator, int, random_access_iterator, int>(); test_empty_population<forward_iterator, int, random_access_iterator, int>();
test_empty_sample<input_iterator, int, random_access_iterator, int>(); test_empty_sample<cpp17_input_iterator, int, random_access_iterator, int>();
test_empty_sample<forward_iterator, int, output_iterator, int>(); test_empty_sample<forward_iterator, int, output_iterator, int>();
test_empty_sample<forward_iterator, int, random_access_iterator, int>(); test_empty_sample<forward_iterator, int, random_access_iterator, int>();
test_small_population<input_iterator, int, random_access_iterator, int>(); test_small_population<cpp17_input_iterator, int, random_access_iterator, int>();
test_small_population<forward_iterator, int, output_iterator, int>(); test_small_population<forward_iterator, int, output_iterator, int>();
test_small_population<forward_iterator, int, random_access_iterator, int>(); test_small_population<forward_iterator, int, random_access_iterator, int>();
return 0; return 0;
} }

libcxx/test/std/algorithms/alg.modifying.operations/alg.random.sample/sample.stable.pass.cpp

Show First 20 Lines • Show All 45 Lines • ▼ Show 20 Lines for (int i = 0; i < kIterations; ++i) {
std::sample(first, last, out, kSampleSize, g); std::sample(first, last, out, kSampleSize, g);
unstable |= !std::is_sorted(oa, oa + kSampleSize); unstable |= !std::is_sorted(oa, oa + kSampleSize);
} }
assert(expect_stable == !unstable); assert(expect_stable == !unstable);
} }
int main(int, char**) { int main(int, char**) {
test_stability<forward_iterator<int *>, output_iterator<int *> >(true); test_stability<forward_iterator<int *>, output_iterator<int *> >(true);
test_stability<input_iterator<int *>, random_access_iterator<int *> >(false); test_stability<cpp17_input_iterator<int *>, random_access_iterator<int *> >(false);
return 0; return 0;
} }

libcxx/test/std/algorithms/alg.modifying.operations/alg.remove/remove_copy.pass.cpp

Show First 20 Lines • Show All 46 Lines • ▼ Show 20 Linestest()
assert(ib[2] == 3); assert(ib[2] == 3);
assert(ib[3] == 4); assert(ib[3] == 4);
assert(ib[4] == 3); assert(ib[4] == 3);
assert(ib[5] == 4); assert(ib[5] == 4);
} }
int main(int, char**) int main(int, char**)
{ {
test<input_iterator<const int*>, output_iterator<int*> >(); test<cpp17_input_iterator<const int*>, output_iterator<int*> >();
test<input_iterator<const int*>, forward_iterator<int*> >(); test<cpp17_input_iterator<const int*>, forward_iterator<int*> >();
test<input_iterator<const int*>, bidirectional_iterator<int*> >(); test<cpp17_input_iterator<const int*>, bidirectional_iterator<int*> >();
test<input_iterator<const int*>, random_access_iterator<int*> >(); test<cpp17_input_iterator<const int*>, random_access_iterator<int*> >();
test<input_iterator<const int*>, int*>(); test<cpp17_input_iterator<const int*>, int*>();
test<forward_iterator<const int*>, output_iterator<int*> >(); test<forward_iterator<const int*>, output_iterator<int*> >();
test<forward_iterator<const int*>, forward_iterator<int*> >(); test<forward_iterator<const int*>, forward_iterator<int*> >();
test<forward_iterator<const int*>, bidirectional_iterator<int*> >(); test<forward_iterator<const int*>, bidirectional_iterator<int*> >();
test<forward_iterator<const int*>, random_access_iterator<int*> >(); test<forward_iterator<const int*>, random_access_iterator<int*> >();
test<forward_iterator<const int*>, int*>(); test<forward_iterator<const int*>, int*>();
test<bidirectional_iterator<const int*>, output_iterator<int*> >(); test<bidirectional_iterator<const int*>, output_iterator<int*> >();
Show All 23 Lines

libcxx/test/std/algorithms/alg.modifying.operations/alg.remove/remove_copy_if.pass.cpp

Show First 20 Lines • Show All 51 Lines • ▼ Show 20 Linestest()
assert(ib[2] == 3); assert(ib[2] == 3);
assert(ib[3] == 4); assert(ib[3] == 4);
assert(ib[4] == 3); assert(ib[4] == 3);
assert(ib[5] == 4); assert(ib[5] == 4);
} }
int main(int, char**) int main(int, char**)
{ {
test<input_iterator<const int*>, output_iterator<int*> >(); test<cpp17_input_iterator<const int*>, output_iterator<int*> >();
test<input_iterator<const int*>, forward_iterator<int*> >(); test<cpp17_input_iterator<const int*>, forward_iterator<int*> >();
test<input_iterator<const int*>, bidirectional_iterator<int*> >(); test<cpp17_input_iterator<const int*>, bidirectional_iterator<int*> >();
test<input_iterator<const int*>, random_access_iterator<int*> >(); test<cpp17_input_iterator<const int*>, random_access_iterator<int*> >();
test<input_iterator<const int*>, int*>(); test<cpp17_input_iterator<const int*>, int*>();
test<forward_iterator<const int*>, output_iterator<int*> >(); test<forward_iterator<const int*>, output_iterator<int*> >();
test<forward_iterator<const int*>, forward_iterator<int*> >(); test<forward_iterator<const int*>, forward_iterator<int*> >();
test<forward_iterator<const int*>, bidirectional_iterator<int*> >(); test<forward_iterator<const int*>, bidirectional_iterator<int*> >();
test<forward_iterator<const int*>, random_access_iterator<int*> >(); test<forward_iterator<const int*>, random_access_iterator<int*> >();
test<forward_iterator<const int*>, int*>(); test<forward_iterator<const int*>, int*>();
test<bidirectional_iterator<const int*>, output_iterator<int*> >(); test<bidirectional_iterator<const int*>, output_iterator<int*> >();
Show All 23 Lines

libcxx/test/std/algorithms/alg.modifying.operations/alg.replace/replace_copy.pass.cpp

Show First 20 Lines • Show All 50 Lines • ▼ Show 20 Linestest()
assert(ib[1] == 1); assert(ib[1] == 1);
assert(ib[2] == 5); assert(ib[2] == 5);
assert(ib[3] == 3); assert(ib[3] == 3);
assert(ib[4] == 4); assert(ib[4] == 4);
} }
int main(int, char**) int main(int, char**)
{ {
test<input_iterator<const int*>, output_iterator<int*> >(); test<cpp17_input_iterator<const int*>, output_iterator<int*> >();
test<input_iterator<const int*>, forward_iterator<int*> >(); test<cpp17_input_iterator<const int*>, forward_iterator<int*> >();
test<input_iterator<const int*>, bidirectional_iterator<int*> >(); test<cpp17_input_iterator<const int*>, bidirectional_iterator<int*> >();
test<input_iterator<const int*>, random_access_iterator<int*> >(); test<cpp17_input_iterator<const int*>, random_access_iterator<int*> >();
test<input_iterator<const int*>, int*>(); test<cpp17_input_iterator<const int*>, int*>();
test<forward_iterator<const int*>, output_iterator<int*> >(); test<forward_iterator<const int*>, output_iterator<int*> >();
test<forward_iterator<const int*>, forward_iterator<int*> >(); test<forward_iterator<const int*>, forward_iterator<int*> >();
test<forward_iterator<const int*>, bidirectional_iterator<int*> >(); test<forward_iterator<const int*>, bidirectional_iterator<int*> >();
test<forward_iterator<const int*>, random_access_iterator<int*> >(); test<forward_iterator<const int*>, random_access_iterator<int*> >();
test<forward_iterator<const int*>, int*>(); test<forward_iterator<const int*>, int*>();
test<bidirectional_iterator<const int*>, output_iterator<int*> >(); test<bidirectional_iterator<const int*>, output_iterator<int*> >();
Show All 23 Lines

libcxx/test/std/algorithms/alg.modifying.operations/alg.replace/replace_copy_if.pass.cpp

Show First 20 Lines • Show All 54 Lines • ▼ Show 20 Linestest()
assert(ib[1] == 1); assert(ib[1] == 1);
assert(ib[2] == 5); assert(ib[2] == 5);
assert(ib[3] == 3); assert(ib[3] == 3);
assert(ib[4] == 4); assert(ib[4] == 4);
} }
int main(int, char**) int main(int, char**)
{ {
test<input_iterator<const int*>, output_iterator<int*> >(); test<cpp17_input_iterator<const int*>, output_iterator<int*> >();
test<input_iterator<const int*>, forward_iterator<int*> >(); test<cpp17_input_iterator<const int*>, forward_iterator<int*> >();
test<input_iterator<const int*>, bidirectional_iterator<int*> >(); test<cpp17_input_iterator<const int*>, bidirectional_iterator<int*> >();
test<input_iterator<const int*>, random_access_iterator<int*> >(); test<cpp17_input_iterator<const int*>, random_access_iterator<int*> >();
test<input_iterator<const int*>, int*>(); test<cpp17_input_iterator<const int*>, int*>();
test<forward_iterator<const int*>, output_iterator<int*> >(); test<forward_iterator<const int*>, output_iterator<int*> >();
test<forward_iterator<const int*>, forward_iterator<int*> >(); test<forward_iterator<const int*>, forward_iterator<int*> >();
test<forward_iterator<const int*>, bidirectional_iterator<int*> >(); test<forward_iterator<const int*>, bidirectional_iterator<int*> >();
test<forward_iterator<const int*>, random_access_iterator<int*> >(); test<forward_iterator<const int*>, random_access_iterator<int*> >();
test<forward_iterator<const int*>, int*>(); test<forward_iterator<const int*>, int*>();
test<bidirectional_iterator<const int*>, output_iterator<int*> >(); test<bidirectional_iterator<const int*>, output_iterator<int*> >();
Show All 23 Lines

libcxx/test/std/algorithms/alg.modifying.operations/alg.transform/binary_transform.pass.cpp

Show First 20 Lines • Show All 52 Lines • ▼ Show 20 Linestest()
assert(ib[1] == 1); assert(ib[1] == 1);
assert(ib[2] == 1); assert(ib[2] == 1);
assert(ib[3] == 1); assert(ib[3] == 1);
assert(ib[4] == 1); assert(ib[4] == 1);
} }
int main(int, char**) int main(int, char**)
{ {
test<input_iterator<const int*>, input_iterator<const int*>, output_iterator<int*> >(); test<cpp17_input_iterator<const int*>, cpp17_input_iterator<const int*>, output_iterator<int*> >();
test<input_iterator<const int*>, input_iterator<const int*>, input_iterator<int*> >(); test<cpp17_input_iterator<const int*>, cpp17_input_iterator<const int*>, cpp17_input_iterator<int*> >();
test<input_iterator<const int*>, input_iterator<const int*>, forward_iterator<int*> >(); test<cpp17_input_iterator<const int*>, cpp17_input_iterator<const int*>, forward_iterator<int*> >();
test<input_iterator<const int*>, input_iterator<const int*>, bidirectional_iterator<int*> >(); test<cpp17_input_iterator<const int*>, cpp17_input_iterator<const int*>, bidirectional_iterator<int*> >();
test<input_iterator<const int*>, input_iterator<const int*>, random_access_iterator<int*> >(); test<cpp17_input_iterator<const int*>, cpp17_input_iterator<const int*>, random_access_iterator<int*> >();
test<input_iterator<const int*>, input_iterator<const int*>, int*>(); test<cpp17_input_iterator<const int*>, cpp17_input_iterator<const int*>, int*>();
test<input_iterator<const int*>, forward_iterator<const int*>, output_iterator<int*> >(); test<cpp17_input_iterator<const int*>, forward_iterator<const int*>, output_iterator<int*> >();
test<input_iterator<const int*>, forward_iterator<const int*>, input_iterator<int*> >(); test<cpp17_input_iterator<const int*>, forward_iterator<const int*>, cpp17_input_iterator<int*> >();
test<input_iterator<const int*>, forward_iterator<const int*>, forward_iterator<int*> >(); test<cpp17_input_iterator<const int*>, forward_iterator<const int*>, forward_iterator<int*> >();
test<input_iterator<const int*>, forward_iterator<const int*>, bidirectional_iterator<int*> >(); test<cpp17_input_iterator<const int*>, forward_iterator<const int*>, bidirectional_iterator<int*> >();
test<input_iterator<const int*>, forward_iterator<const int*>, random_access_iterator<int*> >(); test<cpp17_input_iterator<const int*>, forward_iterator<const int*>, random_access_iterator<int*> >();
test<input_iterator<const int*>, forward_iterator<const int*>, int*>(); test<cpp17_input_iterator<const int*>, forward_iterator<const int*>, int*>();
test<input_iterator<const int*>, bidirectional_iterator<const int*>, output_iterator<int*> >(); test<cpp17_input_iterator<const int*>, bidirectional_iterator<const int*>, output_iterator<int*> >();
test<input_iterator<const int*>, bidirectional_iterator<const int*>, input_iterator<int*> >(); test<cpp17_input_iterator<const int*>, bidirectional_iterator<const int*>, cpp17_input_iterator<int*> >();
test<input_iterator<const int*>, bidirectional_iterator<const int*>, forward_iterator<int*> >(); test<cpp17_input_iterator<const int*>, bidirectional_iterator<const int*>, forward_iterator<int*> >();
test<input_iterator<const int*>, bidirectional_iterator<const int*>, bidirectional_iterator<int*> >(); test<cpp17_input_iterator<const int*>, bidirectional_iterator<const int*>, bidirectional_iterator<int*> >();
test<input_iterator<const int*>, bidirectional_iterator<const int*>, random_access_iterator<int*> >(); test<cpp17_input_iterator<const int*>, bidirectional_iterator<const int*>, random_access_iterator<int*> >();
test<input_iterator<const int*>, bidirectional_iterator<const int*>, int*>(); test<cpp17_input_iterator<const int*>, bidirectional_iterator<const int*>, int*>();
test<input_iterator<const int*>, random_access_iterator<const int*>, output_iterator<int*> >(); test<cpp17_input_iterator<const int*>, random_access_iterator<const int*>, output_iterator<int*> >();
test<input_iterator<const int*>, random_access_iterator<const int*>, input_iterator<int*> >(); test<cpp17_input_iterator<const int*>, random_access_iterator<const int*>, cpp17_input_iterator<int*> >();
test<input_iterator<const int*>, random_access_iterator<const int*>, forward_iterator<int*> >(); test<cpp17_input_iterator<const int*>, random_access_iterator<const int*>, forward_iterator<int*> >();
test<input_iterator<const int*>, random_access_iterator<const int*>, bidirectional_iterator<int*> >(); test<cpp17_input_iterator<const int*>, random_access_iterator<const int*>, bidirectional_iterator<int*> >();
test<input_iterator<const int*>, random_access_iterator<const int*>, random_access_iterator<int*> >(); test<cpp17_input_iterator<const int*>, random_access_iterator<const int*>, random_access_iterator<int*> >();
test<input_iterator<const int*>, random_access_iterator<const int*>, int*>(); test<cpp17_input_iterator<const int*>, random_access_iterator<const int*>, int*>();
test<input_iterator<const int*>, const int*, output_iterator<int*> >(); test<cpp17_input_iterator<const int*>, const int*, output_iterator<int*> >();
test<input_iterator<const int*>, const int*, input_iterator<int*> >(); test<cpp17_input_iterator<const int*>, const int*, cpp17_input_iterator<int*> >();
test<input_iterator<const int*>, const int*, forward_iterator<int*> >(); test<cpp17_input_iterator<const int*>, const int*, forward_iterator<int*> >();
test<input_iterator<const int*>, const int*, bidirectional_iterator<int*> >(); test<cpp17_input_iterator<const int*>, const int*, bidirectional_iterator<int*> >();
test<input_iterator<const int*>, const int*, random_access_iterator<int*> >(); test<cpp17_input_iterator<const int*>, const int*, random_access_iterator<int*> >();
test<input_iterator<const int*>, const int*, int*>(); test<cpp17_input_iterator<const int*>, const int*, int*>();
test<forward_iterator<const int*>, input_iterator<const int*>, output_iterator<int*> >(); test<forward_iterator<const int*>, cpp17_input_iterator<const int*>, output_iterator<int*> >();
test<forward_iterator<const int*>, input_iterator<const int*>, input_iterator<int*> >(); test<forward_iterator<const int*>, cpp17_input_iterator<const int*>, cpp17_input_iterator<int*> >();
test<forward_iterator<const int*>, input_iterator<const int*>, forward_iterator<int*> >(); test<forward_iterator<const int*>, cpp17_input_iterator<const int*>, forward_iterator<int*> >();
test<forward_iterator<const int*>, input_iterator<const int*>, bidirectional_iterator<int*> >(); test<forward_iterator<const int*>, cpp17_input_iterator<const int*>, bidirectional_iterator<int*> >();
test<forward_iterator<const int*>, input_iterator<const int*>, random_access_iterator<int*> >(); test<forward_iterator<const int*>, cpp17_input_iterator<const int*>, random_access_iterator<int*> >();
test<forward_iterator<const int*>, input_iterator<const int*>, int*>(); test<forward_iterator<const int*>, cpp17_input_iterator<const int*>, int*>();
test<forward_iterator<const int*>, forward_iterator<const int*>, output_iterator<int*> >(); test<forward_iterator<const int*>, forward_iterator<const int*>, output_iterator<int*> >();
test<forward_iterator<const int*>, forward_iterator<const int*>, input_iterator<int*> >(); test<forward_iterator<const int*>, forward_iterator<const int*>, cpp17_input_iterator<int*> >();
test<forward_iterator<const int*>, forward_iterator<const int*>, forward_iterator<int*> >(); test<forward_iterator<const int*>, forward_iterator<const int*>, forward_iterator<int*> >();
test<forward_iterator<const int*>, forward_iterator<const int*>, bidirectional_iterator<int*> >(); test<forward_iterator<const int*>, forward_iterator<const int*>, bidirectional_iterator<int*> >();
test<forward_iterator<const int*>, forward_iterator<const int*>, random_access_iterator<int*> >(); test<forward_iterator<const int*>, forward_iterator<const int*>, random_access_iterator<int*> >();
test<forward_iterator<const int*>, forward_iterator<const int*>, int*>(); test<forward_iterator<const int*>, forward_iterator<const int*>, int*>();
test<forward_iterator<const int*>, bidirectional_iterator<const int*>, output_iterator<int*> >(); test<forward_iterator<const int*>, bidirectional_iterator<const int*>, output_iterator<int*> >();
test<forward_iterator<const int*>, bidirectional_iterator<const int*>, input_iterator<int*> >(); test<forward_iterator<const int*>, bidirectional_iterator<const int*>, cpp17_input_iterator<int*> >();
test<forward_iterator<const int*>, bidirectional_iterator<const int*>, forward_iterator<int*> >(); test<forward_iterator<const int*>, bidirectional_iterator<const int*>, forward_iterator<int*> >();
test<forward_iterator<const int*>, bidirectional_iterator<const int*>, bidirectional_iterator<int*> >(); test<forward_iterator<const int*>, bidirectional_iterator<const int*>, bidirectional_iterator<int*> >();
test<forward_iterator<const int*>, bidirectional_iterator<const int*>, random_access_iterator<int*> >(); test<forward_iterator<const int*>, bidirectional_iterator<const int*>, random_access_iterator<int*> >();
test<forward_iterator<const int*>, bidirectional_iterator<const int*>, int*>(); test<forward_iterator<const int*>, bidirectional_iterator<const int*>, int*>();
test<forward_iterator<const int*>, random_access_iterator<const int*>, output_iterator<int*> >(); test<forward_iterator<const int*>, random_access_iterator<const int*>, output_iterator<int*> >();
test<forward_iterator<const int*>, random_access_iterator<const int*>, input_iterator<int*> >(); test<forward_iterator<const int*>, random_access_iterator<const int*>, cpp17_input_iterator<int*> >();
test<forward_iterator<const int*>, random_access_iterator<const int*>, forward_iterator<int*> >(); test<forward_iterator<const int*>, random_access_iterator<const int*>, forward_iterator<int*> >();
test<forward_iterator<const int*>, random_access_iterator<const int*>, bidirectional_iterator<int*> >(); test<forward_iterator<const int*>, random_access_iterator<const int*>, bidirectional_iterator<int*> >();
test<forward_iterator<const int*>, random_access_iterator<const int*>, random_access_iterator<int*> >(); test<forward_iterator<const int*>, random_access_iterator<const int*>, random_access_iterator<int*> >();
test<forward_iterator<const int*>, random_access_iterator<const int*>, int*>(); test<forward_iterator<const int*>, random_access_iterator<const int*>, int*>();
test<forward_iterator<const int*>, const int*, output_iterator<int*> >(); test<forward_iterator<const int*>, const int*, output_iterator<int*> >();
test<forward_iterator<const int*>, const int*, input_iterator<int*> >(); test<forward_iterator<const int*>, const int*, cpp17_input_iterator<int*> >();
test<forward_iterator<const int*>, const int*, forward_iterator<int*> >(); test<forward_iterator<const int*>, const int*, forward_iterator<int*> >();
test<forward_iterator<const int*>, const int*, bidirectional_iterator<int*> >(); test<forward_iterator<const int*>, const int*, bidirectional_iterator<int*> >();
test<forward_iterator<const int*>, const int*, random_access_iterator<int*> >(); test<forward_iterator<const int*>, const int*, random_access_iterator<int*> >();
test<forward_iterator<const int*>, const int*, int*>(); test<forward_iterator<const int*>, const int*, int*>();
test<bidirectional_iterator<const int*>, input_iterator<const int*>, output_iterator<int*> >(); test<bidirectional_iterator<const int*>, cpp17_input_iterator<const int*>, output_iterator<int*> >();
test<bidirectional_iterator<const int*>, input_iterator<const int*>, input_iterator<int*> >(); test<bidirectional_iterator<const int*>, cpp17_input_iterator<const int*>, cpp17_input_iterator<int*> >();
test<bidirectional_iterator<const int*>, input_iterator<const int*>, forward_iterator<int*> >(); test<bidirectional_iterator<const int*>, cpp17_input_iterator<const int*>, forward_iterator<int*> >();
test<bidirectional_iterator<const int*>, input_iterator<const int*>, bidirectional_iterator<int*> >(); test<bidirectional_iterator<const int*>, cpp17_input_iterator<const int*>, bidirectional_iterator<int*> >();
test<bidirectional_iterator<const int*>, input_iterator<const int*>, random_access_iterator<int*> >(); test<bidirectional_iterator<const int*>, cpp17_input_iterator<const int*>, random_access_iterator<int*> >();
test<bidirectional_iterator<const int*>, input_iterator<const int*>, int*>(); test<bidirectional_iterator<const int*>, cpp17_input_iterator<const int*>, int*>();
test<bidirectional_iterator<const int*>, forward_iterator<const int*>, output_iterator<int*> >(); test<bidirectional_iterator<const int*>, forward_iterator<const int*>, output_iterator<int*> >();
test<bidirectional_iterator<const int*>, forward_iterator<const int*>, input_iterator<int*> >(); test<bidirectional_iterator<const int*>, forward_iterator<const int*>, cpp17_input_iterator<int*> >();
test<bidirectional_iterator<const int*>, forward_iterator<const int*>, forward_iterator<int*> >(); test<bidirectional_iterator<const int*>, forward_iterator<const int*>, forward_iterator<int*> >();
test<bidirectional_iterator<const int*>, forward_iterator<const int*>, bidirectional_iterator<int*> >(); test<bidirectional_iterator<const int*>, forward_iterator<const int*>, bidirectional_iterator<int*> >();
test<bidirectional_iterator<const int*>, forward_iterator<const int*>, random_access_iterator<int*> >(); test<bidirectional_iterator<const int*>, forward_iterator<const int*>, random_access_iterator<int*> >();
test<bidirectional_iterator<const int*>, forward_iterator<const int*>, int*>(); test<bidirectional_iterator<const int*>, forward_iterator<const int*>, int*>();
test<bidirectional_iterator<const int*>, bidirectional_iterator<const int*>, output_iterator<int*> >(); test<bidirectional_iterator<const int*>, bidirectional_iterator<const int*>, output_iterator<int*> >();
test<bidirectional_iterator<const int*>, bidirectional_iterator<const int*>, input_iterator<int*> >(); test<bidirectional_iterator<const int*>, bidirectional_iterator<const int*>, cpp17_input_iterator<int*> >();
test<bidirectional_iterator<const int*>, bidirectional_iterator<const int*>, forward_iterator<int*> >(); test<bidirectional_iterator<const int*>, bidirectional_iterator<const int*>, forward_iterator<int*> >();
test<bidirectional_iterator<const int*>, bidirectional_iterator<const int*>, bidirectional_iterator<int*> >(); test<bidirectional_iterator<const int*>, bidirectional_iterator<const int*>, bidirectional_iterator<int*> >();
test<bidirectional_iterator<const int*>, bidirectional_iterator<const int*>, random_access_iterator<int*> >(); test<bidirectional_iterator<const int*>, bidirectional_iterator<const int*>, random_access_iterator<int*> >();
test<bidirectional_iterator<const int*>, bidirectional_iterator<const int*>, int*>(); test<bidirectional_iterator<const int*>, bidirectional_iterator<const int*>, int*>();
test<bidirectional_iterator<const int*>, random_access_iterator<const int*>, output_iterator<int*> >(); test<bidirectional_iterator<const int*>, random_access_iterator<const int*>, output_iterator<int*> >();
test<bidirectional_iterator<const int*>, random_access_iterator<const int*>, input_iterator<int*> >(); test<bidirectional_iterator<const int*>, random_access_iterator<const int*>, cpp17_input_iterator<int*> >();
test<bidirectional_iterator<const int*>, random_access_iterator<const int*>, forward_iterator<int*> >(); test<bidirectional_iterator<const int*>, random_access_iterator<const int*>, forward_iterator<int*> >();
test<bidirectional_iterator<const int*>, random_access_iterator<const int*>, bidirectional_iterator<int*> >(); test<bidirectional_iterator<const int*>, random_access_iterator<const int*>, bidirectional_iterator<int*> >();
test<bidirectional_iterator<const int*>, random_access_iterator<const int*>, random_access_iterator<int*> >(); test<bidirectional_iterator<const int*>, random_access_iterator<const int*>, random_access_iterator<int*> >();
test<bidirectional_iterator<const int*>, random_access_iterator<const int*>, int*>(); test<bidirectional_iterator<const int*>, random_access_iterator<const int*>, int*>();
test<bidirectional_iterator<const int*>, const int*, output_iterator<int*> >(); test<bidirectional_iterator<const int*>, const int*, output_iterator<int*> >();
test<bidirectional_iterator<const int*>, const int*, input_iterator<int*> >(); test<bidirectional_iterator<const int*>, const int*, cpp17_input_iterator<int*> >();
test<bidirectional_iterator<const int*>, const int*, forward_iterator<int*> >(); test<bidirectional_iterator<const int*>, const int*, forward_iterator<int*> >();
test<bidirectional_iterator<const int*>, const int*, bidirectional_iterator<int*> >(); test<bidirectional_iterator<const int*>, const int*, bidirectional_iterator<int*> >();
test<bidirectional_iterator<const int*>, const int*, random_access_iterator<int*> >(); test<bidirectional_iterator<const int*>, const int*, random_access_iterator<int*> >();
test<bidirectional_iterator<const int*>, const int*, int*>(); test<bidirectional_iterator<const int*>, const int*, int*>();
test<random_access_iterator<const int*>, input_iterator<const int*>, output_iterator<int*> >(); test<random_access_iterator<const int*>, cpp17_input_iterator<const int*>, output_iterator<int*> >();
test<random_access_iterator<const int*>, input_iterator<const int*>, input_iterator<int*> >(); test<random_access_iterator<const int*>, cpp17_input_iterator<const int*>, cpp17_input_iterator<int*> >();
test<random_access_iterator<const int*>, input_iterator<const int*>, forward_iterator<int*> >(); test<random_access_iterator<const int*>, cpp17_input_iterator<const int*>, forward_iterator<int*> >();
test<random_access_iterator<const int*>, input_iterator<const int*>, bidirectional_iterator<int*> >(); test<random_access_iterator<const int*>, cpp17_input_iterator<const int*>, bidirectional_iterator<int*> >();
test<random_access_iterator<const int*>, input_iterator<const int*>, random_access_iterator<int*> >(); test<random_access_iterator<const int*>, cpp17_input_iterator<const int*>, random_access_iterator<int*> >();
test<random_access_iterator<const int*>, input_iterator<const int*>, int*>(); test<random_access_iterator<const int*>, cpp17_input_iterator<const int*>, int*>();
test<random_access_iterator<const int*>, forward_iterator<const int*>, output_iterator<int*> >(); test<random_access_iterator<const int*>, forward_iterator<const int*>, output_iterator<int*> >();
test<random_access_iterator<const int*>, forward_iterator<const int*>, input_iterator<int*> >(); test<random_access_iterator<const int*>, forward_iterator<const int*>, cpp17_input_iterator<int*> >();
test<random_access_iterator<const int*>, forward_iterator<const int*>, forward_iterator<int*> >(); test<random_access_iterator<const int*>, forward_iterator<const int*>, forward_iterator<int*> >();
test<random_access_iterator<const int*>, forward_iterator<const int*>, bidirectional_iterator<int*> >(); test<random_access_iterator<const int*>, forward_iterator<const int*>, bidirectional_iterator<int*> >();
test<random_access_iterator<const int*>, forward_iterator<const int*>, random_access_iterator<int*> >(); test<random_access_iterator<const int*>, forward_iterator<const int*>, random_access_iterator<int*> >();
test<random_access_iterator<const int*>, forward_iterator<const int*>, int*>(); test<random_access_iterator<const int*>, forward_iterator<const int*>, int*>();
test<random_access_iterator<const int*>, bidirectional_iterator<const int*>, output_iterator<int*> >(); test<random_access_iterator<const int*>, bidirectional_iterator<const int*>, output_iterator<int*> >();
test<random_access_iterator<const int*>, bidirectional_iterator<const int*>, input_iterator<int*> >(); test<random_access_iterator<const int*>, bidirectional_iterator<const int*>, cpp17_input_iterator<int*> >();
test<random_access_iterator<const int*>, bidirectional_iterator<const int*>, forward_iterator<int*> >(); test<random_access_iterator<const int*>, bidirectional_iterator<const int*>, forward_iterator<int*> >();
test<random_access_iterator<const int*>, bidirectional_iterator<const int*>, bidirectional_iterator<int*> >(); test<random_access_iterator<const int*>, bidirectional_iterator<const int*>, bidirectional_iterator<int*> >();
test<random_access_iterator<const int*>, bidirectional_iterator<const int*>, random_access_iterator<int*> >(); test<random_access_iterator<const int*>, bidirectional_iterator<const int*>, random_access_iterator<int*> >();
test<random_access_iterator<const int*>, bidirectional_iterator<const int*>, int*>(); test<random_access_iterator<const int*>, bidirectional_iterator<const int*>, int*>();
test<random_access_iterator<const int*>, random_access_iterator<const int*>, output_iterator<int*> >(); test<random_access_iterator<const int*>, random_access_iterator<const int*>, output_iterator<int*> >();
test<random_access_iterator<const int*>, random_access_iterator<const int*>, input_iterator<int*> >(); test<random_access_iterator<const int*>, random_access_iterator<const int*>, cpp17_input_iterator<int*> >();
test<random_access_iterator<const int*>, random_access_iterator<const int*>, forward_iterator<int*> >(); test<random_access_iterator<const int*>, random_access_iterator<const int*>, forward_iterator<int*> >();
test<random_access_iterator<const int*>, random_access_iterator<const int*>, bidirectional_iterator<int*> >(); test<random_access_iterator<const int*>, random_access_iterator<const int*>, bidirectional_iterator<int*> >();
test<random_access_iterator<const int*>, random_access_iterator<const int*>, random_access_iterator<int*> >(); test<random_access_iterator<const int*>, random_access_iterator<const int*>, random_access_iterator<int*> >();
test<random_access_iterator<const int*>, random_access_iterator<const int*>, int*>(); test<random_access_iterator<const int*>, random_access_iterator<const int*>, int*>();
test<random_access_iterator<const int*>, const int*, output_iterator<int*> >(); test<random_access_iterator<const int*>, const int*, output_iterator<int*> >();
test<random_access_iterator<const int*>, const int*, input_iterator<int*> >(); test<random_access_iterator<const int*>, const int*, cpp17_input_iterator<int*> >();
test<random_access_iterator<const int*>, const int*, forward_iterator<int*> >(); test<random_access_iterator<const int*>, const int*, forward_iterator<int*> >();
test<random_access_iterator<const int*>, const int*, bidirectional_iterator<int*> >(); test<random_access_iterator<const int*>, const int*, bidirectional_iterator<int*> >();
test<random_access_iterator<const int*>, const int*, random_access_iterator<int*> >(); test<random_access_iterator<const int*>, const int*, random_access_iterator<int*> >();
test<random_access_iterator<const int*>, const int*, int*>(); test<random_access_iterator<const int*>, const int*, int*>();
test<const int*, input_iterator<const int*>, output_iterator<int*> >(); test<const int*, cpp17_input_iterator<const int*>, output_iterator<int*> >();
test<const int*, input_iterator<const int*>, input_iterator<int*> >(); test<const int*, cpp17_input_iterator<const int*>, cpp17_input_iterator<int*> >();
test<const int*, input_iterator<const int*>, forward_iterator<int*> >(); test<const int*, cpp17_input_iterator<const int*>, forward_iterator<int*> >();
test<const int*, input_iterator<const int*>, bidirectional_iterator<int*> >(); test<const int*, cpp17_input_iterator<const int*>, bidirectional_iterator<int*> >();
test<const int*, input_iterator<const int*>, random_access_iterator<int*> >(); test<const int*, cpp17_input_iterator<const int*>, random_access_iterator<int*> >();
test<const int*, input_iterator<const int*>, int*>(); test<const int*, cpp17_input_iterator<const int*>, int*>();
test<const int*, forward_iterator<const int*>, output_iterator<int*> >(); test<const int*, forward_iterator<const int*>, output_iterator<int*> >();
test<const int*, forward_iterator<const int*>, input_iterator<int*> >(); test<const int*, forward_iterator<const int*>, cpp17_input_iterator<int*> >();
test<const int*, forward_iterator<const int*>, forward_iterator<int*> >(); test<const int*, forward_iterator<const int*>, forward_iterator<int*> >();
test<const int*, forward_iterator<const int*>, bidirectional_iterator<int*> >(); test<const int*, forward_iterator<const int*>, bidirectional_iterator<int*> >();
test<const int*, forward_iterator<const int*>, random_access_iterator<int*> >(); test<const int*, forward_iterator<const int*>, random_access_iterator<int*> >();
test<const int*, forward_iterator<const int*>, int*>(); test<const int*, forward_iterator<const int*>, int*>();
test<const int*, bidirectional_iterator<const int*>, output_iterator<int*> >(); test<const int*, bidirectional_iterator<const int*>, output_iterator<int*> >();
test<const int*, bidirectional_iterator<const int*>, input_iterator<int*> >(); test<const int*, bidirectional_iterator<const int*>, cpp17_input_iterator<int*> >();
test<const int*, bidirectional_iterator<const int*>, forward_iterator<int*> >(); test<const int*, bidirectional_iterator<const int*>, forward_iterator<int*> >();
test<const int*, bidirectional_iterator<const int*>, bidirectional_iterator<int*> >(); test<const int*, bidirectional_iterator<const int*>, bidirectional_iterator<int*> >();
test<const int*, bidirectional_iterator<const int*>, random_access_iterator<int*> >(); test<const int*, bidirectional_iterator<const int*>, random_access_iterator<int*> >();
test<const int*, bidirectional_iterator<const int*>, int*>(); test<const int*, bidirectional_iterator<const int*>, int*>();
test<const int*, random_access_iterator<const int*>, output_iterator<int*> >(); test<const int*, random_access_iterator<const int*>, output_iterator<int*> >();
test<const int*, random_access_iterator<const int*>, input_iterator<int*> >(); test<const int*, random_access_iterator<const int*>, cpp17_input_iterator<int*> >();
test<const int*, random_access_iterator<const int*>, forward_iterator<int*> >(); test<const int*, random_access_iterator<const int*>, forward_iterator<int*> >();
test<const int*, random_access_iterator<const int*>, bidirectional_iterator<int*> >(); test<const int*, random_access_iterator<const int*>, bidirectional_iterator<int*> >();
test<const int*, random_access_iterator<const int*>, random_access_iterator<int*> >(); test<const int*, random_access_iterator<const int*>, random_access_iterator<int*> >();
test<const int*, random_access_iterator<const int*>, int*>(); test<const int*, random_access_iterator<const int*>, int*>();
test<const int*, const int*, output_iterator<int*> >(); test<const int*, const int*, output_iterator<int*> >();
test<const int*, const int*, input_iterator<int*> >(); test<const int*, const int*, cpp17_input_iterator<int*> >();
test<const int*, const int*, forward_iterator<int*> >(); test<const int*, const int*, forward_iterator<int*> >();
test<const int*, const int*, bidirectional_iterator<int*> >(); test<const int*, const int*, bidirectional_iterator<int*> >();
test<const int*, const int*, random_access_iterator<int*> >(); test<const int*, const int*, random_access_iterator<int*> >();
test<const int*, const int*, int*>(); test<const int*, const int*, int*>();
#if TEST_STD_VER > 17 #if TEST_STD_VER > 17
static_assert(test_constexpr()); static_assert(test_constexpr());
#endif #endif
return 0; return 0;
} }

libcxx/test/std/algorithms/alg.modifying.operations/alg.transform/unary_transform.pass.cpp

Show First 20 Lines • Show All 53 Lines • ▼ Show 20 Linestest()
assert(ib[1] == 2); assert(ib[1] == 2);
assert(ib[2] == 3); assert(ib[2] == 3);
assert(ib[3] == 4); assert(ib[3] == 4);
assert(ib[4] == 5); assert(ib[4] == 5);
} }
int main(int, char**) int main(int, char**)
{ {
test<input_iterator<const int*>, output_iterator<int*> >(); test<cpp17_input_iterator<const int*>, output_iterator<int*> >();
test<input_iterator<const int*>, input_iterator<int*> >(); test<cpp17_input_iterator<const int*>, cpp17_input_iterator<int*> >();
test<input_iterator<const int*>, forward_iterator<int*> >(); test<cpp17_input_iterator<const int*>, forward_iterator<int*> >();
test<input_iterator<const int*>, bidirectional_iterator<int*> >(); test<cpp17_input_iterator<const int*>, bidirectional_iterator<int*> >();
test<input_iterator<const int*>, random_access_iterator<int*> >(); test<cpp17_input_iterator<const int*>, random_access_iterator<int*> >();
test<input_iterator<const int*>, int*>(); test<cpp17_input_iterator<const int*>, int*>();
test<forward_iterator<const int*>, output_iterator<int*> >(); test<forward_iterator<const int*>, output_iterator<int*> >();
test<forward_iterator<const int*>, input_iterator<int*> >(); test<forward_iterator<const int*>, cpp17_input_iterator<int*> >();
test<forward_iterator<const int*>, forward_iterator<int*> >(); test<forward_iterator<const int*>, forward_iterator<int*> >();
test<forward_iterator<const int*>, bidirectional_iterator<int*> >(); test<forward_iterator<const int*>, bidirectional_iterator<int*> >();
test<forward_iterator<const int*>, random_access_iterator<int*> >(); test<forward_iterator<const int*>, random_access_iterator<int*> >();
test<forward_iterator<const int*>, int*>(); test<forward_iterator<const int*>, int*>();
test<bidirectional_iterator<const int*>, output_iterator<int*> >(); test<bidirectional_iterator<const int*>, output_iterator<int*> >();
test<bidirectional_iterator<const int*>, input_iterator<int*> >(); test<bidirectional_iterator<const int*>, cpp17_input_iterator<int*> >();
test<bidirectional_iterator<const int*>, forward_iterator<int*> >(); test<bidirectional_iterator<const int*>, forward_iterator<int*> >();
test<bidirectional_iterator<const int*>, bidirectional_iterator<int*> >(); test<bidirectional_iterator<const int*>, bidirectional_iterator<int*> >();
test<bidirectional_iterator<const int*>, random_access_iterator<int*> >(); test<bidirectional_iterator<const int*>, random_access_iterator<int*> >();
test<bidirectional_iterator<const int*>, int*>(); test<bidirectional_iterator<const int*>, int*>();
test<random_access_iterator<const int*>, output_iterator<int*> >(); test<random_access_iterator<const int*>, output_iterator<int*> >();
test<random_access_iterator<const int*>, input_iterator<int*> >(); test<random_access_iterator<const int*>, cpp17_input_iterator<int*> >();
test<random_access_iterator<const int*>, forward_iterator<int*> >(); test<random_access_iterator<const int*>, forward_iterator<int*> >();
test<random_access_iterator<const int*>, bidirectional_iterator<int*> >(); test<random_access_iterator<const int*>, bidirectional_iterator<int*> >();
test<random_access_iterator<const int*>, random_access_iterator<int*> >(); test<random_access_iterator<const int*>, random_access_iterator<int*> >();
test<random_access_iterator<const int*>, int*>(); test<random_access_iterator<const int*>, int*>();
test<const int*, output_iterator<int*> >(); test<const int*, output_iterator<int*> >();
test<const int*, input_iterator<int*> >(); test<const int*, cpp17_input_iterator<int*> >();
test<const int*, forward_iterator<int*> >(); test<const int*, forward_iterator<int*> >();
test<const int*, bidirectional_iterator<int*> >(); test<const int*, bidirectional_iterator<int*> >();
test<const int*, random_access_iterator<int*> >(); test<const int*, random_access_iterator<int*> >();
test<const int*, int*>(); test<const int*, int*>();
#if TEST_STD_VER > 17 #if TEST_STD_VER > 17
static_assert(test_constexpr()); static_assert(test_constexpr());
#endif #endif
return 0; return 0;
} }

libcxx/test/std/algorithms/alg.modifying.operations/alg.unique/unique_copy.pass.cpp

Show First 20 Lines • Show All 101 Lines • ▼ Show 20 Linestest()
assert(base(r) == ji + 3); assert(base(r) == ji + 3);
assert(ji[0] == 0); assert(ji[0] == 0);
assert(ji[1] == 1); assert(ji[1] == 1);
assert(ji[2] == 2); assert(ji[2] == 2);
} }
int main(int, char**) int main(int, char**)
{ {
test<input_iterator<const int*>, output_iterator<int*> >(); test<cpp17_input_iterator<const int*>, output_iterator<int*> >();
test<input_iterator<const int*>, forward_iterator<int*> >(); test<cpp17_input_iterator<const int*>, forward_iterator<int*> >();
test<input_iterator<const int*>, bidirectional_iterator<int*> >(); test<cpp17_input_iterator<const int*>, bidirectional_iterator<int*> >();
test<input_iterator<const int*>, random_access_iterator<int*> >(); test<cpp17_input_iterator<const int*>, random_access_iterator<int*> >();
test<input_iterator<const int*>, int*>(); test<cpp17_input_iterator<const int*>, int*>();
test<forward_iterator<const int*>, output_iterator<int*> >(); test<forward_iterator<const int*>, output_iterator<int*> >();
test<forward_iterator<const int*>, forward_iterator<int*> >(); test<forward_iterator<const int*>, forward_iterator<int*> >();
test<forward_iterator<const int*>, bidirectional_iterator<int*> >(); test<forward_iterator<const int*>, bidirectional_iterator<int*> >();
test<forward_iterator<const int*>, random_access_iterator<int*> >(); test<forward_iterator<const int*>, random_access_iterator<int*> >();
test<forward_iterator<const int*>, int*>(); test<forward_iterator<const int*>, int*>();
test<bidirectional_iterator<const int*>, output_iterator<int*> >(); test<bidirectional_iterator<const int*>, output_iterator<int*> >();
Show All 23 Lines

libcxx/test/std/algorithms/alg.modifying.operations/alg.unique/unique_copy_pred.pass.cpp

Show First 20 Lines • Show All 129 Lines • ▼ Show 20 Linestest()
assert(ji[0] == 0); assert(ji[0] == 0);
assert(ji[1] == 1); assert(ji[1] == 1);
assert(ji[2] == 2); assert(ji[2] == 2);
assert(count_equal::count == si-1); assert(count_equal::count == si-1);
} }
int main(int, char**) int main(int, char**)
{ {
test<input_iterator<const int*>, output_iterator<int*> >(); test<cpp17_input_iterator<const int*>, output_iterator<int*> >();
test<input_iterator<const int*>, forward_iterator<int*> >(); test<cpp17_input_iterator<const int*>, forward_iterator<int*> >();
test<input_iterator<const int*>, bidirectional_iterator<int*> >(); test<cpp17_input_iterator<const int*>, bidirectional_iterator<int*> >();
test<input_iterator<const int*>, random_access_iterator<int*> >(); test<cpp17_input_iterator<const int*>, random_access_iterator<int*> >();
test<input_iterator<const int*>, int*>(); test<cpp17_input_iterator<const int*>, int*>();
test<forward_iterator<const int*>, output_iterator<int*> >(); test<forward_iterator<const int*>, output_iterator<int*> >();
test<forward_iterator<const int*>, forward_iterator<int*> >(); test<forward_iterator<const int*>, forward_iterator<int*> >();
test<forward_iterator<const int*>, bidirectional_iterator<int*> >(); test<forward_iterator<const int*>, bidirectional_iterator<int*> >();
test<forward_iterator<const int*>, random_access_iterator<int*> >(); test<forward_iterator<const int*>, random_access_iterator<int*> >();
test<forward_iterator<const int*>, int*>(); test<forward_iterator<const int*>, int*>();
test<bidirectional_iterator<const int*>, output_iterator<int*> >(); test<bidirectional_iterator<const int*>, output_iterator<int*> >();
Show All 23 Lines

libcxx/test/std/algorithms/alg.nonmodifying/alg.all_of/all_of.pass.cpp

Show All 35 LinesTEST_CONSTEXPR bool test_constexpr() {
} }
#endif #endif
int main(int, char**) int main(int, char**)
{ {
{ {
int ia[] = {2, 4, 6, 8}; int ia[] = {2, 4, 6, 8};
const unsigned sa = sizeof(ia)/sizeof(ia[0]); const unsigned sa = sizeof(ia)/sizeof(ia[0]);
assert(std::all_of(input_iterator<const int*>(ia), assert(std::all_of(cpp17_input_iterator<const int*>(ia),
input_iterator<const int*>(ia + sa), test1()) == true); cpp17_input_iterator<const int*>(ia + sa), test1()) == true);
assert(std::all_of(input_iterator<const int*>(ia), assert(std::all_of(cpp17_input_iterator<const int*>(ia),
input_iterator<const int*>(ia), test1()) == true); cpp17_input_iterator<const int*>(ia), test1()) == true);
} }
{ {
const int ia[] = {2, 4, 5, 8}; const int ia[] = {2, 4, 5, 8};
const unsigned sa = sizeof(ia)/sizeof(ia[0]); const unsigned sa = sizeof(ia)/sizeof(ia[0]);
assert(std::all_of(input_iterator<const int*>(ia), assert(std::all_of(cpp17_input_iterator<const int*>(ia),
input_iterator<const int*>(ia + sa), test1()) == false); cpp17_input_iterator<const int*>(ia + sa), test1()) == false);
assert(std::all_of(input_iterator<const int*>(ia), assert(std::all_of(cpp17_input_iterator<const int*>(ia),
input_iterator<const int*>(ia), test1()) == true); cpp17_input_iterator<const int*>(ia), test1()) == true);
} }
#if TEST_STD_VER > 17 #if TEST_STD_VER > 17
static_assert(test_constexpr()); static_assert(test_constexpr());
#endif #endif
return 0; return 0;
} }

libcxx/test/std/algorithms/alg.nonmodifying/alg.any_of/any_of.pass.cpp

Show All 35 LinesTEST_CONSTEXPR bool test_constexpr() {
} }
#endif #endif
int main(int, char**) int main(int, char**)
{ {
{ {
int ia[] = {2, 4, 6, 8}; int ia[] = {2, 4, 6, 8};
const unsigned sa = sizeof(ia)/sizeof(ia[0]); const unsigned sa = sizeof(ia)/sizeof(ia[0]);
assert(std::any_of(input_iterator<const int*>(ia), assert(std::any_of(cpp17_input_iterator<const int*>(ia),
input_iterator<const int*>(ia + sa), test1()) == true); cpp17_input_iterator<const int*>(ia + sa), test1()) == true);
assert(std::any_of(input_iterator<const int*>(ia), assert(std::any_of(cpp17_input_iterator<const int*>(ia),
input_iterator<const int*>(ia), test1()) == false); cpp17_input_iterator<const int*>(ia), test1()) == false);
} }
{ {
const int ia[] = {2, 4, 5, 8}; const int ia[] = {2, 4, 5, 8};
const unsigned sa = sizeof(ia)/sizeof(ia[0]); const unsigned sa = sizeof(ia)/sizeof(ia[0]);
assert(std::any_of(input_iterator<const int*>(ia), assert(std::any_of(cpp17_input_iterator<const int*>(ia),
input_iterator<const int*>(ia + sa), test1()) == true); cpp17_input_iterator<const int*>(ia + sa), test1()) == true);
assert(std::any_of(input_iterator<const int*>(ia), assert(std::any_of(cpp17_input_iterator<const int*>(ia),
input_iterator<const int*>(ia), test1()) == false); cpp17_input_iterator<const int*>(ia), test1()) == false);
} }
{ {
const int ia[] = {1, 3, 5, 7}; const int ia[] = {1, 3, 5, 7};
const unsigned sa = sizeof(ia)/sizeof(ia[0]); const unsigned sa = sizeof(ia)/sizeof(ia[0]);
assert(std::any_of(input_iterator<const int*>(ia), assert(std::any_of(cpp17_input_iterator<const int*>(ia),
input_iterator<const int*>(ia + sa), test1()) == false); cpp17_input_iterator<const int*>(ia + sa), test1()) == false);
assert(std::any_of(input_iterator<const int*>(ia), assert(std::any_of(cpp17_input_iterator<const int*>(ia),
input_iterator<const int*>(ia), test1()) == false); cpp17_input_iterator<const int*>(ia), test1()) == false);
} }
#if TEST_STD_VER > 17 #if TEST_STD_VER > 17
static_assert(test_constexpr()); static_assert(test_constexpr());
#endif #endif
return 0; return 0;
} }

libcxx/test/std/algorithms/alg.nonmodifying/alg.count/count.pass.cpp

Show All 27 Lines return (std::count(std::begin(ia), std::end(ia), 2) == 3)
; ;
} }
#endif #endif
int main(int, char**) int main(int, char**)
{ {
int ia[] = {0, 1, 2, 2, 0, 1, 2, 3}; int ia[] = {0, 1, 2, 2, 0, 1, 2, 3};
const unsigned sa = sizeof(ia)/sizeof(ia[0]); const unsigned sa = sizeof(ia)/sizeof(ia[0]);
assert(std::count(input_iterator<const int*>(ia), assert(std::count(cpp17_input_iterator<const int*>(ia),
input_iterator<const int*>(ia + sa), 2) == 3); cpp17_input_iterator<const int*>(ia + sa), 2) == 3);
assert(std::count(input_iterator<const int*>(ia), assert(std::count(cpp17_input_iterator<const int*>(ia),
input_iterator<const int*>(ia + sa), 7) == 0); cpp17_input_iterator<const int*>(ia + sa), 7) == 0);
assert(std::count(input_iterator<const int*>(ia), assert(std::count(cpp17_input_iterator<const int*>(ia),
input_iterator<const int*>(ia), 2) == 0); cpp17_input_iterator<const int*>(ia), 2) == 0);
#if TEST_STD_VER > 17 #if TEST_STD_VER > 17
static_assert(test_constexpr()); static_assert(test_constexpr());
#endif #endif
return 0; return 0;
} }

libcxx/test/std/algorithms/alg.nonmodifying/alg.count/count_if.pass.cpp

Show All 34 Lines return (std::count_if(std::begin(ia), std::end(ia), eq(2)) == 3)
; ;
} }
#endif #endif
int main(int, char**) int main(int, char**)
{ {
int ia[] = {0, 1, 2, 2, 0, 1, 2, 3}; int ia[] = {0, 1, 2, 2, 0, 1, 2, 3};
const unsigned sa = sizeof(ia)/sizeof(ia[0]); const unsigned sa = sizeof(ia)/sizeof(ia[0]);
assert(std::count_if(input_iterator<const int*>(ia), assert(std::count_if(cpp17_input_iterator<const int*>(ia),
input_iterator<const int*>(ia + sa), cpp17_input_iterator<const int*>(ia + sa),
eq(2)) == 3); eq(2)) == 3);
assert(std::count_if(input_iterator<const int*>(ia), assert(std::count_if(cpp17_input_iterator<const int*>(ia),
input_iterator<const int*>(ia + sa), cpp17_input_iterator<const int*>(ia + sa),
eq(7)) == 0); eq(7)) == 0);
assert(std::count_if(input_iterator<const int*>(ia), assert(std::count_if(cpp17_input_iterator<const int*>(ia),
input_iterator<const int*>(ia), cpp17_input_iterator<const int*>(ia),
eq(2)) == 0); eq(2)) == 0);
#if TEST_STD_VER > 17 #if TEST_STD_VER > 17
static_assert(test_constexpr()); static_assert(test_constexpr());
#endif #endif
return 0; return 0;
} }

libcxx/test/std/algorithms/alg.nonmodifying/alg.equal/equal.pass.cpp

Show All 23 Lines
#include "test_macros.h" #include "test_macros.h"
#include "test_iterators.h" #include "test_iterators.h"
#if TEST_STD_VER > 17 #if TEST_STD_VER > 17
TEST_CONSTEXPR bool test_constexpr() { TEST_CONSTEXPR bool test_constexpr() {
int ia[] = {1, 3, 6, 7}; int ia[] = {1, 3, 6, 7};
int ib[] = {1, 3}; int ib[] = {1, 3};
int ic[] = {1, 3, 5, 7}; int ic[] = {1, 3, 5, 7};
typedef input_iterator<int*> II; typedef cpp17_input_iterator<int*> II;
typedef bidirectional_iterator<int*> BI; typedef bidirectional_iterator<int*> BI;
return !std::equal(std::begin(ia), std::end(ia), std::begin(ic)) return !std::equal(std::begin(ia), std::end(ia), std::begin(ic))
&& !std::equal(std::begin(ia), std::end(ia), std::begin(ic), std::end(ic)) && !std::equal(std::begin(ia), std::end(ia), std::begin(ic), std::end(ic))
&& std::equal(std::begin(ib), std::end(ib), std::begin(ic)) && std::equal(std::begin(ib), std::end(ib), std::begin(ic))
&& !std::equal(std::begin(ib), std::end(ib), std::begin(ic), std::end(ic)) && !std::equal(std::begin(ib), std::end(ib), std::begin(ic), std::end(ic))
&& std::equal(II(std::begin(ib)), II(std::end(ib)), II(std::begin(ic))) && std::equal(II(std::begin(ib)), II(std::end(ib)), II(std::begin(ic)))
&& !std::equal(BI(std::begin(ib)), BI(std::end(ib)), BI(std::begin(ic)), BI(std::end(ic))) && !std::equal(BI(std::begin(ib)), BI(std::end(ib)), BI(std::begin(ic)), BI(std::end(ic)))
; ;
} }
#endif #endif
int main(int, char**) int main(int, char**)
{ {
int ia[] = {0, 1, 2, 3, 4, 5}; int ia[] = {0, 1, 2, 3, 4, 5};
const unsigned s = sizeof(ia)/sizeof(ia[0]); const unsigned s = sizeof(ia)/sizeof(ia[0]);
int ib[s] = {0, 1, 2, 5, 4, 5}; int ib[s] = {0, 1, 2, 5, 4, 5};
assert(std::equal(input_iterator<const int*>(ia), assert(std::equal(cpp17_input_iterator<const int*>(ia),
input_iterator<const int*>(ia+s), cpp17_input_iterator<const int*>(ia+s),
input_iterator<const int*>(ia))); cpp17_input_iterator<const int*>(ia)));
#if TEST_STD_VER >= 14 #if TEST_STD_VER >= 14
assert(std::equal(input_iterator<const int*>(ia), assert(std::equal(cpp17_input_iterator<const int*>(ia),
input_iterator<const int*>(ia+s), cpp17_input_iterator<const int*>(ia+s),
input_iterator<const int*>(ia), cpp17_input_iterator<const int*>(ia),
input_iterator<const int*>(ia+s))); cpp17_input_iterator<const int*>(ia+s)));
assert(std::equal(random_access_iterator<const int*>(ia), assert(std::equal(random_access_iterator<const int*>(ia),
random_access_iterator<const int*>(ia+s), random_access_iterator<const int*>(ia+s),
random_access_iterator<const int*>(ia), random_access_iterator<const int*>(ia),
random_access_iterator<const int*>(ia+s))); random_access_iterator<const int*>(ia+s)));
#endif #endif
assert(!std::equal(input_iterator<const int*>(ia), assert(!std::equal(cpp17_input_iterator<const int*>(ia),
input_iterator<const int*>(ia+s), cpp17_input_iterator<const int*>(ia+s),
input_iterator<const int*>(ib))); cpp17_input_iterator<const int*>(ib)));
#if TEST_STD_VER >= 14 #if TEST_STD_VER >= 14
assert(!std::equal(input_iterator<const int*>(ia), assert(!std::equal(cpp17_input_iterator<const int*>(ia),
input_iterator<const int*>(ia+s), cpp17_input_iterator<const int*>(ia+s),
input_iterator<const int*>(ib), cpp17_input_iterator<const int*>(ib),
input_iterator<const int*>(ib+s))); cpp17_input_iterator<const int*>(ib+s)));
assert(!std::equal(random_access_iterator<const int*>(ia), assert(!std::equal(random_access_iterator<const int*>(ia),
random_access_iterator<const int*>(ia+s), random_access_iterator<const int*>(ia+s),
random_access_iterator<const int*>(ib), random_access_iterator<const int*>(ib),
random_access_iterator<const int*>(ib+s))); random_access_iterator<const int*>(ib+s)));
assert(!std::equal(input_iterator<const int*>(ia), assert(!std::equal(cpp17_input_iterator<const int*>(ia),
input_iterator<const int*>(ia+s), cpp17_input_iterator<const int*>(ia+s),
input_iterator<const int*>(ia), cpp17_input_iterator<const int*>(ia),
input_iterator<const int*>(ia+s-1))); cpp17_input_iterator<const int*>(ia+s-1)));
assert(!std::equal(random_access_iterator<const int*>(ia), assert(!std::equal(random_access_iterator<const int*>(ia),
random_access_iterator<const int*>(ia+s), random_access_iterator<const int*>(ia+s),
random_access_iterator<const int*>(ia), random_access_iterator<const int*>(ia),
random_access_iterator<const int*>(ia+s-1))); random_access_iterator<const int*>(ia+s-1)));
#endif #endif
#if TEST_STD_VER > 17 #if TEST_STD_VER > 17
static_assert(test_constexpr()); static_assert(test_constexpr());
#endif #endif
return 0; return 0;
} }

libcxx/test/std/algorithms/alg.nonmodifying/alg.equal/equal_pred.pass.cpp

Show All 30 Lines
#if TEST_STD_VER > 17 #if TEST_STD_VER > 17
TEST_CONSTEXPR bool eq(int a, int b) { return a == b; } TEST_CONSTEXPR bool eq(int a, int b) { return a == b; }
TEST_CONSTEXPR bool test_constexpr() { TEST_CONSTEXPR bool test_constexpr() {
int ia[] = {1, 3, 6, 7}; int ia[] = {1, 3, 6, 7};
int ib[] = {1, 3}; int ib[] = {1, 3};
int ic[] = {1, 3, 5, 7}; int ic[] = {1, 3, 5, 7};
typedef input_iterator<int*> II; typedef cpp17_input_iterator<int*> II;
typedef bidirectional_iterator<int*> BI; typedef bidirectional_iterator<int*> BI;
return !std::equal(std::begin(ia), std::end(ia), std::begin(ic) , eq) return !std::equal(std::begin(ia), std::end(ia), std::begin(ic) , eq)
&& !std::equal(std::begin(ia), std::end(ia), std::begin(ic), std::end(ic), eq) && !std::equal(std::begin(ia), std::end(ia), std::begin(ic), std::end(ic), eq)
&& std::equal(std::begin(ib), std::end(ib), std::begin(ic) , eq) && std::equal(std::begin(ib), std::end(ib), std::begin(ic) , eq)
&& !std::equal(std::begin(ib), std::end(ib), std::begin(ic), std::end(ic), eq) && !std::equal(std::begin(ib), std::end(ib), std::begin(ic), std::end(ic), eq)
&& std::equal(II(std::begin(ib)), II(std::end(ib)), II(std::begin(ic)) , eq) && std::equal(II(std::begin(ib)), II(std::end(ib)), II(std::begin(ic)) , eq)
Show All 10 Linesbool counting_equals ( const T &a, const T &b ) {
return a == b; return a == b;
} }
int main(int, char**) int main(int, char**)
{ {
int ia[] = {0, 1, 2, 3, 4, 5}; int ia[] = {0, 1, 2, 3, 4, 5};
const unsigned s = sizeof(ia)/sizeof(ia[0]); const unsigned s = sizeof(ia)/sizeof(ia[0]);
int ib[s] = {0, 1, 2, 5, 4, 5}; int ib[s] = {0, 1, 2, 5, 4, 5};
assert(std::equal(input_iterator<const int*>(ia), assert(std::equal(cpp17_input_iterator<const int*>(ia),
input_iterator<const int*>(ia+s), cpp17_input_iterator<const int*>(ia+s),
input_iterator<const int*>(ia), cpp17_input_iterator<const int*>(ia),
std::equal_to<int>())); std::equal_to<int>()));
#if TEST_STD_VER >= 14 #if TEST_STD_VER >= 14
assert(std::equal(input_iterator<const int*>(ia), assert(std::equal(cpp17_input_iterator<const int*>(ia),
input_iterator<const int*>(ia+s), cpp17_input_iterator<const int*>(ia+s),
input_iterator<const int*>(ia), cpp17_input_iterator<const int*>(ia),
input_iterator<const int*>(ia+s), cpp17_input_iterator<const int*>(ia+s),
std::equal_to<int>())); std::equal_to<int>()));
assert(std::equal(random_access_iterator<const int*>(ia), assert(std::equal(random_access_iterator<const int*>(ia),
random_access_iterator<const int*>(ia+s), random_access_iterator<const int*>(ia+s),
random_access_iterator<const int*>(ia), random_access_iterator<const int*>(ia),
random_access_iterator<const int*>(ia+s), random_access_iterator<const int*>(ia+s),
std::equal_to<int>())); std::equal_to<int>()));
comparison_count = 0; comparison_count = 0;
assert(!std::equal(input_iterator<const int*>(ia), assert(!std::equal(cpp17_input_iterator<const int*>(ia),
input_iterator<const int*>(ia+s), cpp17_input_iterator<const int*>(ia+s),
input_iterator<const int*>(ia), cpp17_input_iterator<const int*>(ia),
input_iterator<const int*>(ia+s-1), cpp17_input_iterator<const int*>(ia+s-1),
counting_equals<int>)); counting_equals<int>));
assert(comparison_count > 0); assert(comparison_count > 0);
comparison_count = 0; comparison_count = 0;
assert(!std::equal(random_access_iterator<const int*>(ia), assert(!std::equal(random_access_iterator<const int*>(ia),
random_access_iterator<const int*>(ia+s), random_access_iterator<const int*>(ia+s),
random_access_iterator<const int*>(ia), random_access_iterator<const int*>(ia),
random_access_iterator<const int*>(ia+s-1), random_access_iterator<const int*>(ia+s-1),
counting_equals<int>)); counting_equals<int>));
assert(comparison_count == 0); assert(comparison_count == 0);
#endif #endif
assert(!std::equal(input_iterator<const int*>(ia), assert(!std::equal(cpp17_input_iterator<const int*>(ia),
input_iterator<const int*>(ia+s), cpp17_input_iterator<const int*>(ia+s),
input_iterator<const int*>(ib), cpp17_input_iterator<const int*>(ib),
std::equal_to<int>())); std::equal_to<int>()));
#if TEST_STD_VER >= 14 #if TEST_STD_VER >= 14
assert(!std::equal(input_iterator<const int*>(ia), assert(!std::equal(cpp17_input_iterator<const int*>(ia),
input_iterator<const int*>(ia+s), cpp17_input_iterator<const int*>(ia+s),
input_iterator<const int*>(ib), cpp17_input_iterator<const int*>(ib),
input_iterator<const int*>(ib+s), cpp17_input_iterator<const int*>(ib+s),
std::equal_to<int>())); std::equal_to<int>()));
assert(!std::equal(random_access_iterator<const int*>(ia), assert(!std::equal(random_access_iterator<const int*>(ia),
random_access_iterator<const int*>(ia+s), random_access_iterator<const int*>(ia+s),
random_access_iterator<const int*>(ib), random_access_iterator<const int*>(ib),
random_access_iterator<const int*>(ib+s), random_access_iterator<const int*>(ib+s),
std::equal_to<int>())); std::equal_to<int>()));
#endif #endif
#if TEST_STD_VER > 17 #if TEST_STD_VER > 17
static_assert(test_constexpr()); static_assert(test_constexpr());
#endif #endif
return 0; return 0;
} }

libcxx/test/std/algorithms/alg.nonmodifying/alg.find.first.of/find_first_of.pass.cpp

Show All 38 Lines
#endif #endif
int main(int, char**) int main(int, char**)
{ {
int ia[] = {0, 1, 2, 3, 0, 1, 2, 3}; int ia[] = {0, 1, 2, 3, 0, 1, 2, 3};
const unsigned sa = sizeof(ia)/sizeof(ia[0]); const unsigned sa = sizeof(ia)/sizeof(ia[0]);
int ib[] = {1, 3, 5, 7}; int ib[] = {1, 3, 5, 7};
const unsigned sb = sizeof(ib)/sizeof(ib[0]); const unsigned sb = sizeof(ib)/sizeof(ib[0]);
assert(std::find_first_of(input_iterator<const int*>(ia), assert(std::find_first_of(cpp17_input_iterator<const int*>(ia),
input_iterator<const int*>(ia + sa), cpp17_input_iterator<const int*>(ia + sa),
forward_iterator<const int*>(ib), forward_iterator<const int*>(ib),
forward_iterator<const int*>(ib + sb)) == forward_iterator<const int*>(ib + sb)) ==
input_iterator<const int*>(ia+1)); cpp17_input_iterator<const int*>(ia+1));
int ic[] = {7}; int ic[] = {7};
assert(std::find_first_of(input_iterator<const int*>(ia), assert(std::find_first_of(cpp17_input_iterator<const int*>(ia),
input_iterator<const int*>(ia + sa), cpp17_input_iterator<const int*>(ia + sa),
forward_iterator<const int*>(ic), forward_iterator<const int*>(ic),
forward_iterator<const int*>(ic + 1)) == forward_iterator<const int*>(ic + 1)) ==
input_iterator<const int*>(ia+sa)); cpp17_input_iterator<const int*>(ia+sa));
assert(std::find_first_of(input_iterator<const int*>(ia), assert(std::find_first_of(cpp17_input_iterator<const int*>(ia),
input_iterator<const int*>(ia + sa), cpp17_input_iterator<const int*>(ia + sa),
forward_iterator<const int*>(ic), forward_iterator<const int*>(ic),
forward_iterator<const int*>(ic)) == forward_iterator<const int*>(ic)) ==
input_iterator<const int*>(ia+sa)); cpp17_input_iterator<const int*>(ia+sa));
assert(std::find_first_of(input_iterator<const int*>(ia), assert(std::find_first_of(cpp17_input_iterator<const int*>(ia),
input_iterator<const int*>(ia), cpp17_input_iterator<const int*>(ia),
forward_iterator<const int*>(ic), forward_iterator<const int*>(ic),
forward_iterator<const int*>(ic+1)) == forward_iterator<const int*>(ic+1)) ==
input_iterator<const int*>(ia)); cpp17_input_iterator<const int*>(ia));
#if TEST_STD_VER > 17 #if TEST_STD_VER > 17
static_assert(test_constexpr()); static_assert(test_constexpr());
#endif #endif
return 0; return 0;
} }

libcxx/test/std/algorithms/alg.nonmodifying/alg.find.first.of/find_first_of_pred.pass.cpp

Show All 40 Lines
#endif #endif
int main(int, char**) int main(int, char**)
{ {
int ia[] = {0, 1, 2, 3, 0, 1, 2, 3}; int ia[] = {0, 1, 2, 3, 0, 1, 2, 3};
const unsigned sa = sizeof(ia)/sizeof(ia[0]); const unsigned sa = sizeof(ia)/sizeof(ia[0]);
int ib[] = {1, 3, 5, 7}; int ib[] = {1, 3, 5, 7};
const unsigned sb = sizeof(ib)/sizeof(ib[0]); const unsigned sb = sizeof(ib)/sizeof(ib[0]);
assert(std::find_first_of(input_iterator<const int*>(ia), assert(std::find_first_of(cpp17_input_iterator<const int*>(ia),
input_iterator<const int*>(ia + sa), cpp17_input_iterator<const int*>(ia + sa),
forward_iterator<const int*>(ib), forward_iterator<const int*>(ib),
forward_iterator<const int*>(ib + sb), forward_iterator<const int*>(ib + sb),
std::equal_to<int>()) == std::equal_to<int>()) ==
input_iterator<const int*>(ia+1)); cpp17_input_iterator<const int*>(ia+1));
int ic[] = {7}; int ic[] = {7};
assert(std::find_first_of(input_iterator<const int*>(ia), assert(std::find_first_of(cpp17_input_iterator<const int*>(ia),
input_iterator<const int*>(ia + sa), cpp17_input_iterator<const int*>(ia + sa),
forward_iterator<const int*>(ic), forward_iterator<const int*>(ic),
forward_iterator<const int*>(ic + 1), forward_iterator<const int*>(ic + 1),
std::equal_to<int>()) == std::equal_to<int>()) ==
input_iterator<const int*>(ia+sa)); cpp17_input_iterator<const int*>(ia+sa));
assert(std::find_first_of(input_iterator<const int*>(ia), assert(std::find_first_of(cpp17_input_iterator<const int*>(ia),
input_iterator<const int*>(ia + sa), cpp17_input_iterator<const int*>(ia + sa),
forward_iterator<const int*>(ic), forward_iterator<const int*>(ic),
forward_iterator<const int*>(ic), forward_iterator<const int*>(ic),
std::equal_to<int>()) == std::equal_to<int>()) ==
input_iterator<const int*>(ia+sa)); cpp17_input_iterator<const int*>(ia+sa));
assert(std::find_first_of(input_iterator<const int*>(ia), assert(std::find_first_of(cpp17_input_iterator<const int*>(ia),
input_iterator<const int*>(ia), cpp17_input_iterator<const int*>(ia),
forward_iterator<const int*>(ic), forward_iterator<const int*>(ic),
forward_iterator<const int*>(ic+1), forward_iterator<const int*>(ic+1),
std::equal_to<int>()) == std::equal_to<int>()) ==
input_iterator<const int*>(ia)); cpp17_input_iterator<const int*>(ia));
#if TEST_STD_VER > 17 #if TEST_STD_VER > 17
static_assert(test_constexpr()); static_assert(test_constexpr());
#endif #endif
return 0; return 0;
} }

libcxx/test/std/algorithms/alg.nonmodifying/alg.find/find.pass.cpp

Show All 27 Lines return (std::find(std::begin(ia), std::end(ia), 5) == ia+2)
; ;
} }
#endif #endif
int main(int, char**) int main(int, char**)
{ {
int ia[] = {0, 1, 2, 3, 4, 5}; int ia[] = {0, 1, 2, 3, 4, 5};
const unsigned s = sizeof(ia)/sizeof(ia[0]); const unsigned s = sizeof(ia)/sizeof(ia[0]);
input_iterator<const int*> r = std::find(input_iterator<const int*>(ia), cpp17_input_iterator<const int*> r = std::find(cpp17_input_iterator<const int*>(ia),
input_iterator<const int*>(ia+s), 3); cpp17_input_iterator<const int*>(ia+s), 3);
assert(*r == 3); assert(*r == 3);
r = std::find(input_iterator<const int*>(ia), input_iterator<const int*>(ia+s), 10); r = std::find(cpp17_input_iterator<const int*>(ia), cpp17_input_iterator<const int*>(ia+s), 10);
assert(r == input_iterator<const int*>(ia+s)); assert(r == cpp17_input_iterator<const int*>(ia+s));
#if TEST_STD_VER > 17 #if TEST_STD_VER > 17
static_assert(test_constexpr()); static_assert(test_constexpr());
#endif #endif
return 0; return 0;
} }

libcxx/test/std/algorithms/alg.nonmodifying/alg.find/find_if.pass.cpp

Show All 35 Lines return (std::find_if(std::begin(ia), std::end(ia), c) == ia+4)
; ;
} }
#endif #endif
int main(int, char**) int main(int, char**)
{ {
int ia[] = {0, 1, 2, 3, 4, 5}; int ia[] = {0, 1, 2, 3, 4, 5};
const unsigned s = sizeof(ia)/sizeof(ia[0]); const unsigned s = sizeof(ia)/sizeof(ia[0]);
input_iterator<const int*> r = std::find_if(input_iterator<const int*>(ia), cpp17_input_iterator<const int*> r = std::find_if(cpp17_input_iterator<const int*>(ia),
input_iterator<const int*>(ia+s), cpp17_input_iterator<const int*>(ia+s),
eq(3)); eq(3));
assert(*r == 3); assert(*r == 3);
r = std::find_if(input_iterator<const int*>(ia), r = std::find_if(cpp17_input_iterator<const int*>(ia),
input_iterator<const int*>(ia+s), cpp17_input_iterator<const int*>(ia+s),
eq(10)); eq(10));
assert(r == input_iterator<const int*>(ia+s)); assert(r == cpp17_input_iterator<const int*>(ia+s));
#if TEST_STD_VER > 17 #if TEST_STD_VER > 17
static_assert(test_constexpr()); static_assert(test_constexpr());
#endif #endif
return 0; return 0;
} }

libcxx/test/std/algorithms/alg.nonmodifying/alg.find/find_if_not.pass.cpp

Show All 35 Lines return (std::find_if_not(std::begin(ia), std::end(ia), c) == ia+4)
; ;
} }
#endif #endif
int main(int, char**) int main(int, char**)
{ {
int ia[] = {0, 1, 2, 3, 4, 5}; int ia[] = {0, 1, 2, 3, 4, 5};
const unsigned s = sizeof(ia)/sizeof(ia[0]); const unsigned s = sizeof(ia)/sizeof(ia[0]);
input_iterator<const int*> r = std::find_if_not(input_iterator<const int*>(ia), cpp17_input_iterator<const int*> r = std::find_if_not(cpp17_input_iterator<const int*>(ia),
input_iterator<const int*>(ia+s), cpp17_input_iterator<const int*>(ia+s),
ne(3)); ne(3));
assert(*r == 3); assert(*r == 3);
r = std::find_if_not(input_iterator<const int*>(ia), r = std::find_if_not(cpp17_input_iterator<const int*>(ia),
input_iterator<const int*>(ia+s), cpp17_input_iterator<const int*>(ia+s),
ne(10)); ne(10));
assert(r == input_iterator<const int*>(ia+s)); assert(r == cpp17_input_iterator<const int*>(ia+s));
#if TEST_STD_VER > 17 #if TEST_STD_VER > 17
static_assert(test_constexpr()); static_assert(test_constexpr());
#endif #endif
return 0; return 0;
} }

libcxx/test/std/algorithms/alg.nonmodifying/alg.foreach/for_each_n.pass.cpp

Show All 36 Lines
{ {
for_each_test(int c) : count(c) {} for_each_test(int c) : count(c) {}
int count; int count;
void operator()(int& i) {++i; ++count;} void operator()(int& i) {++i; ++count;}
}; };
int main(int, char**) int main(int, char**)
{ {
typedef input_iterator<int*> Iter; typedef cpp17_input_iterator<int*> Iter;
int ia[] = {0, 1, 2, 3, 4, 5}; int ia[] = {0, 1, 2, 3, 4, 5};
const unsigned s = sizeof(ia)/sizeof(ia[0]); const unsigned s = sizeof(ia)/sizeof(ia[0]);
{ {
auto f = for_each_test(0); auto f = for_each_test(0);
Iter it = std::for_each_n(Iter(ia), 0, std::ref(f)); Iter it = std::for_each_n(Iter(ia), 0, std::ref(f));
assert(it == Iter(ia)); assert(it == Iter(ia));
assert(f.count == 0); assert(f.count == 0);
Show All 28 Lines

libcxx/test/std/algorithms/alg.nonmodifying/alg.foreach/test.pass.cpp

Show All 35 Linesstruct for_each_test
int count; int count;
void operator()(int& i) {++i; ++count;} void operator()(int& i) {++i; ++count;}
}; };
int main(int, char**) int main(int, char**)
{ {
int ia[] = {0, 1, 2, 3, 4, 5}; int ia[] = {0, 1, 2, 3, 4, 5};
const unsigned s = sizeof(ia)/sizeof(ia[0]); const unsigned s = sizeof(ia)/sizeof(ia[0]);
for_each_test f = std::for_each(input_iterator<int*>(ia), for_each_test f = std::for_each(cpp17_input_iterator<int*>(ia),
input_iterator<int*>(ia+s), cpp17_input_iterator<int*>(ia+s),
for_each_test(0)); for_each_test(0));
assert(f.count == s); assert(f.count == s);
for (unsigned i = 0; i < s; ++i) for (unsigned i = 0; i < s; ++i)
assert(ia[i] == static_cast<int>(i+1)); assert(ia[i] == static_cast<int>(i+1));
#if TEST_STD_VER > 17 #if TEST_STD_VER > 17
static_assert(test_constexpr()); static_assert(test_constexpr());
#endif #endif
return 0; return 0;
} }

libcxx/test/std/algorithms/alg.nonmodifying/alg.none_of/none_of.pass.cpp

Show All 35 LinesTEST_CONSTEXPR bool test_constexpr() {
} }
#endif #endif
int main(int, char**) int main(int, char**)
{ {
{ {
int ia[] = {2, 4, 6, 8}; int ia[] = {2, 4, 6, 8};
const unsigned sa = sizeof(ia)/sizeof(ia[0]); const unsigned sa = sizeof(ia)/sizeof(ia[0]);
assert(std::none_of(input_iterator<const int*>(ia), assert(std::none_of(cpp17_input_iterator<const int*>(ia),
input_iterator<const int*>(ia + sa), test1()) == false); cpp17_input_iterator<const int*>(ia + sa), test1()) == false);
assert(std::none_of(input_iterator<const int*>(ia), assert(std::none_of(cpp17_input_iterator<const int*>(ia),
input_iterator<const int*>(ia), test1()) == true); cpp17_input_iterator<const int*>(ia), test1()) == true);
} }
{ {
const int ia[] = {2, 4, 5, 8}; const int ia[] = {2, 4, 5, 8};
const unsigned sa = sizeof(ia)/sizeof(ia[0]); const unsigned sa = sizeof(ia)/sizeof(ia[0]);
assert(std::none_of(input_iterator<const int*>(ia), assert(std::none_of(cpp17_input_iterator<const int*>(ia),
input_iterator<const int*>(ia + sa), test1()) == false); cpp17_input_iterator<const int*>(ia + sa), test1()) == false);
assert(std::none_of(input_iterator<const int*>(ia), assert(std::none_of(cpp17_input_iterator<const int*>(ia),
input_iterator<const int*>(ia), test1()) == true); cpp17_input_iterator<const int*>(ia), test1()) == true);
} }
{ {
const int ia[] = {1, 3, 5, 7}; const int ia[] = {1, 3, 5, 7};
const unsigned sa = sizeof(ia)/sizeof(ia[0]); const unsigned sa = sizeof(ia)/sizeof(ia[0]);
assert(std::none_of(input_iterator<const int*>(ia), assert(std::none_of(cpp17_input_iterator<const int*>(ia),
input_iterator<const int*>(ia + sa), test1()) == true); cpp17_input_iterator<const int*>(ia + sa), test1()) == true);
assert(std::none_of(input_iterator<const int*>(ia), assert(std::none_of(cpp17_input_iterator<const int*>(ia),
input_iterator<const int*>(ia), test1()) == true); cpp17_input_iterator<const int*>(ia), test1()) == true);
} }
#if TEST_STD_VER > 17 #if TEST_STD_VER > 17
static_assert(test_constexpr()); static_assert(test_constexpr());
#endif #endif
return 0; return 0;
} }

libcxx/test/std/algorithms/alg.nonmodifying/mismatch/mismatch.pass.cpp

Show All 22 Lines
#include "test_macros.h" #include "test_macros.h"
#include "test_iterators.h" #include "test_iterators.h"
#if TEST_STD_VER > 17 #if TEST_STD_VER > 17
TEST_CONSTEXPR bool test_constexpr() { TEST_CONSTEXPR bool test_constexpr() {
int ia[] = {1, 3, 6, 7}; int ia[] = {1, 3, 6, 7};
int ib[] = {1, 3}; int ib[] = {1, 3};
int ic[] = {1, 3, 5, 7}; int ic[] = {1, 3, 5, 7};
typedef input_iterator<int*> II; typedef cpp17_input_iterator<int*> II;
typedef bidirectional_iterator<int*> BI; typedef bidirectional_iterator<int*> BI;
auto p1 = std::mismatch(std::begin(ia), std::end(ia), std::begin(ic)); auto p1 = std::mismatch(std::begin(ia), std::end(ia), std::begin(ic));
if (p1.first != ia+2 || p1.second != ic+2) if (p1.first != ia+2 || p1.second != ic+2)
return false; return false;
auto p2 = std::mismatch(std::begin(ia), std::end(ia), std::begin(ic), std::end(ic)); auto p2 = std::mismatch(std::begin(ia), std::end(ia), std::begin(ic), std::end(ic));
if (p2.first != ia+2 || p2.second != ic+2) if (p2.first != ia+2 || p2.second != ic+2)
Show All 20 Lines
int main(int, char**) int main(int, char**)
{ {
int ia[] = {0, 1, 2, 2, 0, 1, 2, 3}; int ia[] = {0, 1, 2, 2, 0, 1, 2, 3};
const unsigned sa = sizeof(ia)/sizeof(ia[0]); const unsigned sa = sizeof(ia)/sizeof(ia[0]);
int ib[] = {0, 1, 2, 3, 0, 1, 2, 3}; int ib[] = {0, 1, 2, 3, 0, 1, 2, 3};
const unsigned sb = sizeof(ib)/sizeof(ib[0]); ((void)sb); // unused in C++11 const unsigned sb = sizeof(ib)/sizeof(ib[0]); ((void)sb); // unused in C++11
typedef input_iterator<const int*> II; typedef cpp17_input_iterator<const int*> II;
typedef random_access_iterator<const int*> RAI; typedef random_access_iterator<const int*> RAI;
assert(std::mismatch(II(ia), II(ia + sa), II(ib)) assert(std::mismatch(II(ia), II(ia + sa), II(ib))
== (std::pair<II, II>(II(ia+3), II(ib+3)))); == (std::pair<II, II>(II(ia+3), II(ib+3))));
assert(std::mismatch(RAI(ia), RAI(ia + sa), RAI(ib)) assert(std::mismatch(RAI(ia), RAI(ia + sa), RAI(ib))
== (std::pair<RAI, RAI>(RAI(ia+3), RAI(ib+3)))); == (std::pair<RAI, RAI>(RAI(ia+3), RAI(ib+3))));
Show All 18 Lines

libcxx/test/std/algorithms/alg.nonmodifying/mismatch/mismatch_pred.pass.cpp

Show All 27 Lines
#if TEST_STD_VER > 17 #if TEST_STD_VER > 17
TEST_CONSTEXPR bool eq(int a, int b) { return a == b; } TEST_CONSTEXPR bool eq(int a, int b) { return a == b; }
TEST_CONSTEXPR bool test_constexpr() { TEST_CONSTEXPR bool test_constexpr() {
int ia[] = {1, 3, 6, 7}; int ia[] = {1, 3, 6, 7};
int ib[] = {1, 3}; int ib[] = {1, 3};
int ic[] = {1, 3, 5, 7}; int ic[] = {1, 3, 5, 7};
typedef input_iterator<int*> II; typedef cpp17_input_iterator<int*> II;
typedef bidirectional_iterator<int*> BI; typedef bidirectional_iterator<int*> BI;
auto p1 = std::mismatch(std::begin(ia), std::end(ia), std::begin(ic), eq); auto p1 = std::mismatch(std::begin(ia), std::end(ia), std::begin(ic), eq);
if (p1.first != ia+2 || p1.second != ic+2) if (p1.first != ia+2 || p1.second != ic+2)
return false; return false;
auto p2 = std::mismatch(std::begin(ia), std::end(ia), std::begin(ic), std::end(ic), eq); auto p2 = std::mismatch(std::begin(ia), std::end(ia), std::begin(ic), std::end(ic), eq);
if (p2.first != ia+2 || p2.second != ic+2) if (p2.first != ia+2 || p2.second != ic+2)
Show All 25 Lines
int main(int, char**) int main(int, char**)
{ {
int ia[] = {0, 1, 2, 2, 0, 1, 2, 3}; int ia[] = {0, 1, 2, 2, 0, 1, 2, 3};
const unsigned sa = sizeof(ia)/sizeof(ia[0]); const unsigned sa = sizeof(ia)/sizeof(ia[0]);
int ib[] = {0, 1, 2, 3, 0, 1, 2, 3}; int ib[] = {0, 1, 2, 3, 0, 1, 2, 3};
const unsigned sb = sizeof(ib)/sizeof(ib[0]); ((void)sb); // unused in C++11 const unsigned sb = sizeof(ib)/sizeof(ib[0]); ((void)sb); // unused in C++11
typedef input_iterator<const int*> II; typedef cpp17_input_iterator<const int*> II;
typedef random_access_iterator<const int*> RAI; typedef random_access_iterator<const int*> RAI;
typedef std::equal_to<int> EQ; typedef std::equal_to<int> EQ;
assert(std::mismatch(II(ia), II(ia + sa), II(ib), EQ()) assert(std::mismatch(II(ia), II(ia + sa), II(ib), EQ())
== (std::pair<II, II>(II(ia+3), II(ib+3)))); == (std::pair<II, II>(II(ia+3), II(ib+3))));
assert(std::mismatch(RAI(ia), RAI(ia + sa), RAI(ib), EQ()) assert(std::mismatch(RAI(ia), RAI(ia + sa), RAI(ib), EQ())
== (std::pair<RAI, RAI>(RAI(ia+3), RAI(ib+3)))); == (std::pair<RAI, RAI>(RAI(ia+3), RAI(ib+3))));
Show All 33 Lines

libcxx/test/std/algorithms/alg.sorting/alg.lex.comparison/lexicographical_compare.pass.cpp

Show First 20 Lines • Show All 42 Lines • ▼ Show 20 Linestest()
assert(!std::lexicographical_compare(Iter1(ia), Iter1(ia+sa), Iter2(ib), Iter2(ib+3))); assert(!std::lexicographical_compare(Iter1(ia), Iter1(ia+sa), Iter2(ib), Iter2(ib+3)));
assert( std::lexicographical_compare(Iter1(ib), Iter1(ib+3), Iter2(ia), Iter2(ia+sa))); assert( std::lexicographical_compare(Iter1(ib), Iter1(ib+3), Iter2(ia), Iter2(ia+sa)));
assert( std::lexicographical_compare(Iter1(ia), Iter1(ia+sa), Iter2(ib+1), Iter2(ib+3))); assert( std::lexicographical_compare(Iter1(ia), Iter1(ia+sa), Iter2(ib+1), Iter2(ib+3)));
assert(!std::lexicographical_compare(Iter1(ib+1), Iter1(ib+3), Iter2(ia), Iter2(ia+sa))); assert(!std::lexicographical_compare(Iter1(ib+1), Iter1(ib+3), Iter2(ia), Iter2(ia+sa)));
} }
int main(int, char**) int main(int, char**)
{ {
test<input_iterator<const int*>, input_iterator<const int*> >(); test<cpp17_input_iterator<const int*>, cpp17_input_iterator<const int*> >();
test<input_iterator<const int*>, forward_iterator<const int*> >(); test<cpp17_input_iterator<const int*>, forward_iterator<const int*> >();
test<input_iterator<const int*>, bidirectional_iterator<const int*> >(); test<cpp17_input_iterator<const int*>, bidirectional_iterator<const int*> >();
test<input_iterator<const int*>, random_access_iterator<const int*> >(); test<cpp17_input_iterator<const int*>, random_access_iterator<const int*> >();
test<input_iterator<const int*>, const int*>(); test<cpp17_input_iterator<const int*>, const int*>();
test<forward_iterator<const int*>, input_iterator<const int*> >(); test<forward_iterator<const int*>, cpp17_input_iterator<const int*> >();
test<forward_iterator<const int*>, forward_iterator<const int*> >(); test<forward_iterator<const int*>, forward_iterator<const int*> >();
test<forward_iterator<const int*>, bidirectional_iterator<const int*> >(); test<forward_iterator<const int*>, bidirectional_iterator<const int*> >();
test<forward_iterator<const int*>, random_access_iterator<const int*> >(); test<forward_iterator<const int*>, random_access_iterator<const int*> >();
test<forward_iterator<const int*>, const int*>(); test<forward_iterator<const int*>, const int*>();
test<bidirectional_iterator<const int*>, input_iterator<const int*> >(); test<bidirectional_iterator<const int*>, cpp17_input_iterator<const int*> >();
test<bidirectional_iterator<const int*>, forward_iterator<const int*> >(); test<bidirectional_iterator<const int*>, forward_iterator<const int*> >();
test<bidirectional_iterator<const int*>, bidirectional_iterator<const int*> >(); test<bidirectional_iterator<const int*>, bidirectional_iterator<const int*> >();
test<bidirectional_iterator<const int*>, random_access_iterator<const int*> >(); test<bidirectional_iterator<const int*>, random_access_iterator<const int*> >();
test<bidirectional_iterator<const int*>, const int*>(); test<bidirectional_iterator<const int*>, const int*>();
test<random_access_iterator<const int*>, input_iterator<const int*> >(); test<random_access_iterator<const int*>, cpp17_input_iterator<const int*> >();
test<random_access_iterator<const int*>, forward_iterator<const int*> >(); test<random_access_iterator<const int*>, forward_iterator<const int*> >();
test<random_access_iterator<const int*>, bidirectional_iterator<const int*> >(); test<random_access_iterator<const int*>, bidirectional_iterator<const int*> >();
test<random_access_iterator<const int*>, random_access_iterator<const int*> >(); test<random_access_iterator<const int*>, random_access_iterator<const int*> >();
test<random_access_iterator<const int*>, const int*>(); test<random_access_iterator<const int*>, const int*>();
test<const int*, input_iterator<const int*> >(); test<const int*, cpp17_input_iterator<const int*> >();
test<const int*, forward_iterator<const int*> >(); test<const int*, forward_iterator<const int*> >();
test<const int*, bidirectional_iterator<const int*> >(); test<const int*, bidirectional_iterator<const int*> >();
test<const int*, random_access_iterator<const int*> >(); test<const int*, random_access_iterator<const int*> >();
test<const int*, const int*>(); test<const int*, const int*>();
#if TEST_STD_VER > 17 #if TEST_STD_VER > 17
static_assert(test_constexpr()); static_assert(test_constexpr());
#endif #endif
return 0; return 0;
} }

libcxx/test/std/algorithms/alg.sorting/alg.lex.comparison/lexicographical_compare_comp.pass.cpp

Show First 20 Lines • Show All 47 Lines • ▼ Show 20 Linestest()
assert(!std::lexicographical_compare(Iter1(ia), Iter1(ia+sa), Iter2(ib), Iter2(ib+3), c)); assert(!std::lexicographical_compare(Iter1(ia), Iter1(ia+sa), Iter2(ib), Iter2(ib+3), c));
assert( std::lexicographical_compare(Iter1(ib), Iter1(ib+3), Iter2(ia), Iter2(ia+sa), c)); assert( std::lexicographical_compare(Iter1(ib), Iter1(ib+3), Iter2(ia), Iter2(ia+sa), c));
assert(!std::lexicographical_compare(Iter1(ia), Iter1(ia+sa), Iter2(ib+1), Iter2(ib+3), c)); assert(!std::lexicographical_compare(Iter1(ia), Iter1(ia+sa), Iter2(ib+1), Iter2(ib+3), c));
assert( std::lexicographical_compare(Iter1(ib+1), Iter1(ib+3), Iter2(ia), Iter2(ia+sa), c)); assert( std::lexicographical_compare(Iter1(ib+1), Iter1(ib+3), Iter2(ia), Iter2(ia+sa), c));
} }
int main(int, char**) int main(int, char**)
{ {
test<input_iterator<const int*>, input_iterator<const int*> >(); test<cpp17_input_iterator<const int*>, cpp17_input_iterator<const int*> >();
test<input_iterator<const int*>, forward_iterator<const int*> >(); test<cpp17_input_iterator<const int*>, forward_iterator<const int*> >();
test<input_iterator<const int*>, bidirectional_iterator<const int*> >(); test<cpp17_input_iterator<const int*>, bidirectional_iterator<const int*> >();
test<input_iterator<const int*>, random_access_iterator<const int*> >(); test<cpp17_input_iterator<const int*>, random_access_iterator<const int*> >();
test<input_iterator<const int*>, const int*>(); test<cpp17_input_iterator<const int*>, const int*>();
test<forward_iterator<const int*>, input_iterator<const int*> >(); test<forward_iterator<const int*>, cpp17_input_iterator<const int*> >();
test<forward_iterator<const int*>, forward_iterator<const int*> >(); test<forward_iterator<const int*>, forward_iterator<const int*> >();
test<forward_iterator<const int*>, bidirectional_iterator<const int*> >(); test<forward_iterator<const int*>, bidirectional_iterator<const int*> >();
test<forward_iterator<const int*>, random_access_iterator<const int*> >(); test<forward_iterator<const int*>, random_access_iterator<const int*> >();
test<forward_iterator<const int*>, const int*>(); test<forward_iterator<const int*>, const int*>();
test<bidirectional_iterator<const int*>, input_iterator<const int*> >(); test<bidirectional_iterator<const int*>, cpp17_input_iterator<const int*> >();
test<bidirectional_iterator<const int*>, forward_iterator<const int*> >(); test<bidirectional_iterator<const int*>, forward_iterator<const int*> >();
test<bidirectional_iterator<const int*>, bidirectional_iterator<const int*> >(); test<bidirectional_iterator<const int*>, bidirectional_iterator<const int*> >();
test<bidirectional_iterator<const int*>, random_access_iterator<const int*> >(); test<bidirectional_iterator<const int*>, random_access_iterator<const int*> >();
test<bidirectional_iterator<const int*>, const int*>(); test<bidirectional_iterator<const int*>, const int*>();
test<random_access_iterator<const int*>, input_iterator<const int*> >(); test<random_access_iterator<const int*>, cpp17_input_iterator<const int*> >();
test<random_access_iterator<const int*>, forward_iterator<const int*> >(); test<random_access_iterator<const int*>, forward_iterator<const int*> >();
test<random_access_iterator<const int*>, bidirectional_iterator<const int*> >(); test<random_access_iterator<const int*>, bidirectional_iterator<const int*> >();
test<random_access_iterator<const int*>, random_access_iterator<const int*> >(); test<random_access_iterator<const int*>, random_access_iterator<const int*> >();
test<random_access_iterator<const int*>, const int*>(); test<random_access_iterator<const int*>, const int*>();
test<const int*, input_iterator<const int*> >(); test<const int*, cpp17_input_iterator<const int*> >();
test<const int*, forward_iterator<const int*> >(); test<const int*, forward_iterator<const int*> >();
test<const int*, bidirectional_iterator<const int*> >(); test<const int*, bidirectional_iterator<const int*> >();
test<const int*, random_access_iterator<const int*> >(); test<const int*, random_access_iterator<const int*> >();
test<const int*, const int*>(); test<const int*, const int*>();
#if TEST_STD_VER > 17 #if TEST_STD_VER > 17
static_assert(test_constexpr()); static_assert(test_constexpr());
#endif #endif
return 0; return 0;
} }

libcxx/test/std/algorithms/alg.sorting/alg.merge/merge.pass.cpp

Show First 20 Lines • Show All 58 Lines • ▼ Show 20 LinesTEST_CONSTEXPR_CXX20 void test3()
test4<T, Iter1, Iter2, bidirectional_iterator<T*> >(); test4<T, Iter1, Iter2, bidirectional_iterator<T*> >();
test4<T, Iter1, Iter2, random_access_iterator<T*> >(); test4<T, Iter1, Iter2, random_access_iterator<T*> >();
test4<T, Iter1, Iter2, T*>(); test4<T, Iter1, Iter2, T*>();
} }
template<class T, class Iter1> template<class T, class Iter1>
TEST_CONSTEXPR_CXX20 void test2() TEST_CONSTEXPR_CXX20 void test2()
{ {
test3<T, Iter1, input_iterator<const T*> >(); test3<T, Iter1, cpp17_input_iterator<const T*> >();
test3<T, Iter1, forward_iterator<const T*> >(); test3<T, Iter1, forward_iterator<const T*> >();
test3<T, Iter1, bidirectional_iterator<const T*> >(); test3<T, Iter1, bidirectional_iterator<const T*> >();
test3<T, Iter1, random_access_iterator<const T*> >(); test3<T, Iter1, random_access_iterator<const T*> >();
test3<T, Iter1, const T*>(); test3<T, Iter1, const T*>();
} }
template<class T> template<class T>
TEST_CONSTEXPR_CXX20 void test1() TEST_CONSTEXPR_CXX20 void test1()
{ {
test2<T, input_iterator<const T*> >(); test2<T, cpp17_input_iterator<const T*> >();
test2<T, forward_iterator<const T*> >(); test2<T, forward_iterator<const T*> >();
test2<T, bidirectional_iterator<const T*> >(); test2<T, bidirectional_iterator<const T*> >();
test2<T, random_access_iterator<const T*> >(); test2<T, random_access_iterator<const T*> >();
test2<T, const T*>(); test2<T, const T*>();
} }
TEST_CONSTEXPR_CXX20 bool test() TEST_CONSTEXPR_CXX20 bool test()
{ {
Show All 14 Lines

libcxx/test/std/algorithms/alg.sorting/alg.merge/merge_comp.pass.cpp

Show First 20 Lines • Show All 59 Lines • ▼ Show 20 LinesTEST_CONSTEXPR_CXX20 void test3()
test4<T, Iter1, Iter2, bidirectional_iterator<T*> >(); test4<T, Iter1, Iter2, bidirectional_iterator<T*> >();
test4<T, Iter1, Iter2, random_access_iterator<T*> >(); test4<T, Iter1, Iter2, random_access_iterator<T*> >();
test4<T, Iter1, Iter2, T*>(); test4<T, Iter1, Iter2, T*>();
} }
template<class T, class Iter1> template<class T, class Iter1>
TEST_CONSTEXPR_CXX20 void test2() TEST_CONSTEXPR_CXX20 void test2()
{ {
test3<T, Iter1, input_iterator<const T*> >(); test3<T, Iter1, cpp17_input_iterator<const T*> >();
test3<T, Iter1, forward_iterator<const T*> >(); test3<T, Iter1, forward_iterator<const T*> >();
test3<T, Iter1, bidirectional_iterator<const T*> >(); test3<T, Iter1, bidirectional_iterator<const T*> >();
test3<T, Iter1, random_access_iterator<const T*> >(); test3<T, Iter1, random_access_iterator<const T*> >();
test3<T, Iter1, const T*>(); test3<T, Iter1, const T*>();
} }
template<class T> template<class T>
TEST_CONSTEXPR_CXX20 void test1() TEST_CONSTEXPR_CXX20 void test1()
{ {
test2<T, input_iterator<const T*> >(); test2<T, cpp17_input_iterator<const T*> >();
test2<T, forward_iterator<const T*> >(); test2<T, forward_iterator<const T*> >();
test2<T, bidirectional_iterator<const T*> >(); test2<T, bidirectional_iterator<const T*> >();
test2<T, random_access_iterator<const T*> >(); test2<T, random_access_iterator<const T*> >();
test2<T, const T*>(); test2<T, const T*>();
} }
TEST_CONSTEXPR_CXX20 bool test() TEST_CONSTEXPR_CXX20 bool test()
{ {
Show All 14 Lines

libcxx/test/std/algorithms/alg.sorting/alg.min.max/requires_forward_iterator.fail.cpp

Show All 16 Lines
#include <algorithm> #include <algorithm>
#include <cassert> #include <cassert>
#include "test_iterators.h" #include "test_iterators.h"
int main(int, char**) { int main(int, char**) {
int arr[] = {1, 2, 3}; int arr[] = {1, 2, 3};
const int *b = std::begin(arr), *e = std::end(arr); const int *b = std::begin(arr), *e = std::end(arr);
typedef input_iterator<const int*> Iter; typedef cpp17_input_iterator<const int*> Iter;
{ {
// expected-error@algorithm:* {{"std::min_element requires a ForwardIterator"}} // expected-error@algorithm:* {{"std::min_element requires a ForwardIterator"}}
std::min_element(Iter(b), Iter(e)); std::min_element(Iter(b), Iter(e));
} }
{ {
// expected-error@algorithm:* {{"std::max_element requires a ForwardIterator"}} // expected-error@algorithm:* {{"std::max_element requires a ForwardIterator"}}
std::max_element(Iter(b), Iter(e)); std::max_element(Iter(b), Iter(e));
} }
{ {
// expected-error@algorithm:* {{"std::minmax_element requires a ForwardIterator"}} // expected-error@algorithm:* {{"std::minmax_element requires a ForwardIterator"}}
std::minmax_element(Iter(b), Iter(e)); std::minmax_element(Iter(b), Iter(e));
} }
return 0; return 0;
} }

libcxx/test/std/algorithms/alg.sorting/alg.set.operations/includes/includes.pass.cpp

Show First 20 Lines • Show All 47 Lines • ▼ Show 20 Linesvoid test()
assert(std::includes(Iter1(ia), Iter1(ia+sa), Iter2(id), Iter2(id+2))); assert(std::includes(Iter1(ia), Iter1(ia+sa), Iter2(id), Iter2(id+2)));
assert(std::includes(Iter1(ia), Iter1(ia+sa), Iter2(id), Iter2(id+3))); assert(std::includes(Iter1(ia), Iter1(ia+sa), Iter2(id), Iter2(id+3)));
assert(!std::includes(Iter1(ia), Iter1(ia+sa), Iter2(id), Iter2(id+4))); assert(!std::includes(Iter1(ia), Iter1(ia+sa), Iter2(id), Iter2(id+4)));
} }
TEST_CONSTEXPR_CXX20 TEST_CONSTEXPR_CXX20
bool do_tests() bool do_tests()
{ {
test<input_iterator<const int*>, input_iterator<const int*> >(); test<cpp17_input_iterator<const int*>, cpp17_input_iterator<const int*> >();
test<input_iterator<const int*>, forward_iterator<const int*> >(); test<cpp17_input_iterator<const int*>, forward_iterator<const int*> >();
test<input_iterator<const int*>, bidirectional_iterator<const int*> >(); test<cpp17_input_iterator<const int*>, bidirectional_iterator<const int*> >();
test<input_iterator<const int*>, random_access_iterator<const int*> >(); test<cpp17_input_iterator<const int*>, random_access_iterator<const int*> >();
test<input_iterator<const int*>, const int*>(); test<cpp17_input_iterator<const int*>, const int*>();
test<forward_iterator<const int*>, input_iterator<const int*> >(); test<forward_iterator<const int*>, cpp17_input_iterator<const int*> >();
test<forward_iterator<const int*>, forward_iterator<const int*> >(); test<forward_iterator<const int*>, forward_iterator<const int*> >();
test<forward_iterator<const int*>, bidirectional_iterator<const int*> >(); test<forward_iterator<const int*>, bidirectional_iterator<const int*> >();
test<forward_iterator<const int*>, random_access_iterator<const int*> >(); test<forward_iterator<const int*>, random_access_iterator<const int*> >();
test<forward_iterator<const int*>, const int*>(); test<forward_iterator<const int*>, const int*>();
test<bidirectional_iterator<const int*>, input_iterator<const int*> >(); test<bidirectional_iterator<const int*>, cpp17_input_iterator<const int*> >();
test<bidirectional_iterator<const int*>, forward_iterator<const int*> >(); test<bidirectional_iterator<const int*>, forward_iterator<const int*> >();
test<bidirectional_iterator<const int*>, bidirectional_iterator<const int*> >(); test<bidirectional_iterator<const int*>, bidirectional_iterator<const int*> >();
test<bidirectional_iterator<const int*>, random_access_iterator<const int*> >(); test<bidirectional_iterator<const int*>, random_access_iterator<const int*> >();
test<bidirectional_iterator<const int*>, const int*>(); test<bidirectional_iterator<const int*>, const int*>();
test<random_access_iterator<const int*>, input_iterator<const int*> >(); test<random_access_iterator<const int*>, cpp17_input_iterator<const int*> >();
test<random_access_iterator<const int*>, forward_iterator<const int*> >(); test<random_access_iterator<const int*>, forward_iterator<const int*> >();
test<random_access_iterator<const int*>, bidirectional_iterator<const int*> >(); test<random_access_iterator<const int*>, bidirectional_iterator<const int*> >();
test<random_access_iterator<const int*>, random_access_iterator<const int*> >(); test<random_access_iterator<const int*>, random_access_iterator<const int*> >();
test<random_access_iterator<const int*>, const int*>(); test<random_access_iterator<const int*>, const int*>();
test<const int*, input_iterator<const int*> >(); test<const int*, cpp17_input_iterator<const int*> >();
test<const int*, forward_iterator<const int*> >(); test<const int*, forward_iterator<const int*> >();
test<const int*, bidirectional_iterator<const int*> >(); test<const int*, bidirectional_iterator<const int*> >();
test<const int*, random_access_iterator<const int*> >(); test<const int*, random_access_iterator<const int*> >();
test<const int*, const int*>(); test<const int*, const int*>();
return true; return true;
} }
int main(int, char**) int main(int, char**)
{ {
do_tests(); do_tests();
#if TEST_STD_VER > 17 #if TEST_STD_VER > 17
static_assert(do_tests()); static_assert(do_tests());
#endif #endif
return 0; return 0;
} }

libcxx/test/std/algorithms/alg.sorting/alg.set.operations/includes/includes_comp.pass.cpp

Show First 20 Lines • Show All 48 Lines • ▼ Show 20 Linesvoid test()
assert(std::includes(Iter1(ia), Iter1(ia+sa), Iter2(id), Iter2(id+2), std::greater<int>())); assert(std::includes(Iter1(ia), Iter1(ia+sa), Iter2(id), Iter2(id+2), std::greater<int>()));
assert(std::includes(Iter1(ia), Iter1(ia+sa), Iter2(id), Iter2(id+3), std::greater<int>())); assert(std::includes(Iter1(ia), Iter1(ia+sa), Iter2(id), Iter2(id+3), std::greater<int>()));
assert(!std::includes(Iter1(ia), Iter1(ia+sa), Iter2(id), Iter2(id+4), std::greater<int>())); assert(!std::includes(Iter1(ia), Iter1(ia+sa), Iter2(id), Iter2(id+4), std::greater<int>()));
} }
TEST_CONSTEXPR_CXX20 TEST_CONSTEXPR_CXX20
bool do_tests() bool do_tests()
{ {
test<input_iterator<const int*>, input_iterator<const int*> >(); test<cpp17_input_iterator<const int*>, cpp17_input_iterator<const int*> >();
test<input_iterator<const int*>, forward_iterator<const int*> >(); test<cpp17_input_iterator<const int*>, forward_iterator<const int*> >();
test<input_iterator<const int*>, bidirectional_iterator<const int*> >(); test<cpp17_input_iterator<const int*>, bidirectional_iterator<const int*> >();
test<input_iterator<const int*>, random_access_iterator<const int*> >(); test<cpp17_input_iterator<const int*>, random_access_iterator<const int*> >();
test<input_iterator<const int*>, const int*>(); test<cpp17_input_iterator<const int*>, const int*>();
test<forward_iterator<const int*>, input_iterator<const int*> >(); test<forward_iterator<const int*>, cpp17_input_iterator<const int*> >();
test<forward_iterator<const int*>, forward_iterator<const int*> >(); test<forward_iterator<const int*>, forward_iterator<const int*> >();
test<forward_iterator<const int*>, bidirectional_iterator<const int*> >(); test<forward_iterator<const int*>, bidirectional_iterator<const int*> >();
test<forward_iterator<const int*>, random_access_iterator<const int*> >(); test<forward_iterator<const int*>, random_access_iterator<const int*> >();
test<forward_iterator<const int*>, const int*>(); test<forward_iterator<const int*>, const int*>();
test<bidirectional_iterator<const int*>, input_iterator<const int*> >(); test<bidirectional_iterator<const int*>, cpp17_input_iterator<const int*> >();
test<bidirectional_iterator<const int*>, forward_iterator<const int*> >(); test<bidirectional_iterator<const int*>, forward_iterator<const int*> >();
test<bidirectional_iterator<const int*>, bidirectional_iterator<const int*> >(); test<bidirectional_iterator<const int*>, bidirectional_iterator<const int*> >();
test<bidirectional_iterator<const int*>, random_access_iterator<const int*> >(); test<bidirectional_iterator<const int*>, random_access_iterator<const int*> >();
test<bidirectional_iterator<const int*>, const int*>(); test<bidirectional_iterator<const int*>, const int*>();
test<random_access_iterator<const int*>, input_iterator<const int*> >(); test<random_access_iterator<const int*>, cpp17_input_iterator<const int*> >();
test<random_access_iterator<const int*>, forward_iterator<const int*> >(); test<random_access_iterator<const int*>, forward_iterator<const int*> >();
test<random_access_iterator<const int*>, bidirectional_iterator<const int*> >(); test<random_access_iterator<const int*>, bidirectional_iterator<const int*> >();
test<random_access_iterator<const int*>, random_access_iterator<const int*> >(); test<random_access_iterator<const int*>, random_access_iterator<const int*> >();
test<random_access_iterator<const int*>, const int*>(); test<random_access_iterator<const int*>, const int*>();
test<const int*, input_iterator<const int*> >(); test<const int*, cpp17_input_iterator<const int*> >();
test<const int*, forward_iterator<const int*> >(); test<const int*, forward_iterator<const int*> >();
test<const int*, bidirectional_iterator<const int*> >(); test<const int*, bidirectional_iterator<const int*> >();
test<const int*, random_access_iterator<const int*> >(); test<const int*, random_access_iterator<const int*> >();
test<const int*, const int*>(); test<const int*, const int*>();
return true; return true;
} }
int main(int, char**) int main(int, char**)
{ {
do_tests(); do_tests();
#if TEST_STD_VER > 17 #if TEST_STD_VER > 17
static_assert(do_tests()); static_assert(do_tests());
#endif #endif
return 0; return 0;
} }

libcxx/test/std/algorithms/alg.sorting/alg.set.operations/set.difference/set_difference.pass.cpp

Show First 20 Lines • Show All 58 Lines • ▼ Show 20 LinesTEST_CONSTEXPR_CXX20 void test3()
test4<T, Iter1, Iter2, bidirectional_iterator<T*> >(); test4<T, Iter1, Iter2, bidirectional_iterator<T*> >();
test4<T, Iter1, Iter2, random_access_iterator<T*> >(); test4<T, Iter1, Iter2, random_access_iterator<T*> >();
test4<T, Iter1, Iter2, T*>(); test4<T, Iter1, Iter2, T*>();
} }
template<class T, class Iter1> template<class T, class Iter1>
TEST_CONSTEXPR_CXX20 void test2() TEST_CONSTEXPR_CXX20 void test2()
{ {
test3<T, Iter1, input_iterator<const T*> >(); test3<T, Iter1, cpp17_input_iterator<const T*> >();
test3<T, Iter1, forward_iterator<const T*> >(); test3<T, Iter1, forward_iterator<const T*> >();
test3<T, Iter1, bidirectional_iterator<const T*> >(); test3<T, Iter1, bidirectional_iterator<const T*> >();
test3<T, Iter1, random_access_iterator<const T*> >(); test3<T, Iter1, random_access_iterator<const T*> >();
test3<T, Iter1, const T*>(); test3<T, Iter1, const T*>();
} }
template<class T> template<class T>
TEST_CONSTEXPR_CXX20 void test1() TEST_CONSTEXPR_CXX20 void test1()
{ {
test2<T, input_iterator<const T*> >(); test2<T, cpp17_input_iterator<const T*> >();
test2<T, forward_iterator<const T*> >(); test2<T, forward_iterator<const T*> >();
test2<T, bidirectional_iterator<const T*> >(); test2<T, bidirectional_iterator<const T*> >();
test2<T, random_access_iterator<const T*> >(); test2<T, random_access_iterator<const T*> >();
test2<T, const T*>(); test2<T, const T*>();
} }
TEST_CONSTEXPR_CXX20 bool test() TEST_CONSTEXPR_CXX20 bool test()
{ {
Show All 14 Lines

libcxx/test/std/algorithms/alg.sorting/alg.set.operations/set.difference/set_difference_comp.pass.cpp

Show First 20 Lines • Show All 59 Lines • ▼ Show 20 LinesTEST_CONSTEXPR_CXX20 void test3()
test4<T, Iter1, Iter2, bidirectional_iterator<T*> >(); test4<T, Iter1, Iter2, bidirectional_iterator<T*> >();
test4<T, Iter1, Iter2, random_access_iterator<T*> >(); test4<T, Iter1, Iter2, random_access_iterator<T*> >();
test4<T, Iter1, Iter2, T*>(); test4<T, Iter1, Iter2, T*>();
} }
template<class T, class Iter1> template<class T, class Iter1>
TEST_CONSTEXPR_CXX20 void test2() TEST_CONSTEXPR_CXX20 void test2()
{ {
test3<T, Iter1, input_iterator<const T*> >(); test3<T, Iter1, cpp17_input_iterator<const T*> >();
test3<T, Iter1, forward_iterator<const T*> >(); test3<T, Iter1, forward_iterator<const T*> >();
test3<T, Iter1, bidirectional_iterator<const T*> >(); test3<T, Iter1, bidirectional_iterator<const T*> >();
test3<T, Iter1, random_access_iterator<const T*> >(); test3<T, Iter1, random_access_iterator<const T*> >();
test3<T, Iter1, const T*>(); test3<T, Iter1, const T*>();
} }
template<class T> template<class T>
TEST_CONSTEXPR_CXX20 void test1() TEST_CONSTEXPR_CXX20 void test1()
{ {
test2<T, input_iterator<const T*> >(); test2<T, cpp17_input_iterator<const T*> >();
test2<T, forward_iterator<const T*> >(); test2<T, forward_iterator<const T*> >();
test2<T, bidirectional_iterator<const T*> >(); test2<T, bidirectional_iterator<const T*> >();
test2<T, random_access_iterator<const T*> >(); test2<T, random_access_iterator<const T*> >();
test2<T, const T*>(); test2<T, const T*>();
} }
TEST_CONSTEXPR_CXX20 bool test() TEST_CONSTEXPR_CXX20 bool test()
{ {
Show All 14 Lines

libcxx/test/std/algorithms/alg.sorting/alg.set.operations/set.intersection/set_intersection.pass.cpp

Show First 20 Lines • Show All 56 Lines • ▼ Show 20 LinesTEST_CONSTEXPR_CXX20 void test3()
test4<T, Iter1, Iter2, bidirectional_iterator<T*> >(); test4<T, Iter1, Iter2, bidirectional_iterator<T*> >();
test4<T, Iter1, Iter2, random_access_iterator<T*> >(); test4<T, Iter1, Iter2, random_access_iterator<T*> >();
test4<T, Iter1, Iter2, T*>(); test4<T, Iter1, Iter2, T*>();
} }
template<class T, class Iter1> template<class T, class Iter1>
TEST_CONSTEXPR_CXX20 void test2() TEST_CONSTEXPR_CXX20 void test2()
{ {
test3<T, Iter1, input_iterator<const T*> >(); test3<T, Iter1, cpp17_input_iterator<const T*> >();
test3<T, Iter1, forward_iterator<const T*> >(); test3<T, Iter1, forward_iterator<const T*> >();
test3<T, Iter1, bidirectional_iterator<const T*> >(); test3<T, Iter1, bidirectional_iterator<const T*> >();
test3<T, Iter1, random_access_iterator<const T*> >(); test3<T, Iter1, random_access_iterator<const T*> >();
test3<T, Iter1, const T*>(); test3<T, Iter1, const T*>();
} }
template<class T> template<class T>
TEST_CONSTEXPR_CXX20 void test1() TEST_CONSTEXPR_CXX20 void test1()
{ {
test2<T, input_iterator<const T*> >(); test2<T, cpp17_input_iterator<const T*> >();
test2<T, forward_iterator<const T*> >(); test2<T, forward_iterator<const T*> >();
test2<T, bidirectional_iterator<const T*> >(); test2<T, bidirectional_iterator<const T*> >();
test2<T, random_access_iterator<const T*> >(); test2<T, random_access_iterator<const T*> >();
test2<T, const T*>(); test2<T, const T*>();
} }
TEST_CONSTEXPR_CXX20 bool test() TEST_CONSTEXPR_CXX20 bool test()
{ {
Show All 14 Lines

libcxx/test/std/algorithms/alg.sorting/alg.set.operations/set.intersection/set_intersection_comp.pass.cpp

Show First 20 Lines • Show All 57 Lines • ▼ Show 20 LinesTEST_CONSTEXPR_CXX20 void test3()
test4<T, Iter1, Iter2, bidirectional_iterator<T*> >(); test4<T, Iter1, Iter2, bidirectional_iterator<T*> >();
test4<T, Iter1, Iter2, random_access_iterator<T*> >(); test4<T, Iter1, Iter2, random_access_iterator<T*> >();
test4<T, Iter1, Iter2, T*>(); test4<T, Iter1, Iter2, T*>();
} }
template<class T, class Iter1> template<class T, class Iter1>
TEST_CONSTEXPR_CXX20 void test2() TEST_CONSTEXPR_CXX20 void test2()
{ {
test3<T, Iter1, input_iterator<const T*> >(); test3<T, Iter1, cpp17_input_iterator<const T*> >();
test3<T, Iter1, forward_iterator<const T*> >(); test3<T, Iter1, forward_iterator<const T*> >();
test3<T, Iter1, bidirectional_iterator<const T*> >(); test3<T, Iter1, bidirectional_iterator<const T*> >();
test3<T, Iter1, random_access_iterator<const T*> >(); test3<T, Iter1, random_access_iterator<const T*> >();
test3<T, Iter1, const T*>(); test3<T, Iter1, const T*>();
} }
template<class T> template<class T>
TEST_CONSTEXPR_CXX20 void test1() TEST_CONSTEXPR_CXX20 void test1()
{ {
test2<T, input_iterator<const T*> >(); test2<T, cpp17_input_iterator<const T*> >();
test2<T, forward_iterator<const T*> >(); test2<T, forward_iterator<const T*> >();
test2<T, bidirectional_iterator<const T*> >(); test2<T, bidirectional_iterator<const T*> >();
test2<T, random_access_iterator<const T*> >(); test2<T, random_access_iterator<const T*> >();
test2<T, const T*>(); test2<T, const T*>();
} }
TEST_CONSTEXPR_CXX20 bool test() TEST_CONSTEXPR_CXX20 bool test()
{ {
Show All 14 Lines

libcxx/test/std/algorithms/alg.sorting/alg.set.operations/set.symmetric.difference/set_symmetric_difference.pass.cpp

Show First 20 Lines • Show All 58 Lines • ▼ Show 20 LinesTEST_CONSTEXPR_CXX20 void test3()
test4<T, Iter1, Iter2, bidirectional_iterator<T*> >(); test4<T, Iter1, Iter2, bidirectional_iterator<T*> >();
test4<T, Iter1, Iter2, random_access_iterator<T*> >(); test4<T, Iter1, Iter2, random_access_iterator<T*> >();
test4<T, Iter1, Iter2, T*>(); test4<T, Iter1, Iter2, T*>();
} }
template<class T, class Iter1> template<class T, class Iter1>
TEST_CONSTEXPR_CXX20 void test2() TEST_CONSTEXPR_CXX20 void test2()
{ {
test3<T, Iter1, input_iterator<const T*> >(); test3<T, Iter1, cpp17_input_iterator<const T*> >();
test3<T, Iter1, forward_iterator<const T*> >(); test3<T, Iter1, forward_iterator<const T*> >();
test3<T, Iter1, bidirectional_iterator<const T*> >(); test3<T, Iter1, bidirectional_iterator<const T*> >();
test3<T, Iter1, random_access_iterator<const T*> >(); test3<T, Iter1, random_access_iterator<const T*> >();
test3<T, Iter1, const T*>(); test3<T, Iter1, const T*>();
} }
template<class T> template<class T>
TEST_CONSTEXPR_CXX20 void test1() TEST_CONSTEXPR_CXX20 void test1()
{ {
test2<T, input_iterator<const T*> >(); test2<T, cpp17_input_iterator<const T*> >();
test2<T, forward_iterator<const T*> >(); test2<T, forward_iterator<const T*> >();
test2<T, bidirectional_iterator<const T*> >(); test2<T, bidirectional_iterator<const T*> >();
test2<T, random_access_iterator<const T*> >(); test2<T, random_access_iterator<const T*> >();
test2<T, const T*>(); test2<T, const T*>();
} }
TEST_CONSTEXPR_CXX20 bool test() TEST_CONSTEXPR_CXX20 bool test()
{ {
Show All 14 Lines

libcxx/test/std/algorithms/alg.sorting/alg.set.operations/set.symmetric.difference/set_symmetric_difference_comp.pass.cpp

Show First 20 Lines • Show All 59 Lines • ▼ Show 20 LinesTEST_CONSTEXPR_CXX20 void test3()
test4<T, Iter1, Iter2, bidirectional_iterator<T*> >(); test4<T, Iter1, Iter2, bidirectional_iterator<T*> >();
test4<T, Iter1, Iter2, random_access_iterator<T*> >(); test4<T, Iter1, Iter2, random_access_iterator<T*> >();
test4<T, Iter1, Iter2, T*>(); test4<T, Iter1, Iter2, T*>();
} }
template<class T, class Iter1> template<class T, class Iter1>
TEST_CONSTEXPR_CXX20 void test2() TEST_CONSTEXPR_CXX20 void test2()
{ {
test3<T, Iter1, input_iterator<const T*> >(); test3<T, Iter1, cpp17_input_iterator<const T*> >();
test3<T, Iter1, forward_iterator<const T*> >(); test3<T, Iter1, forward_iterator<const T*> >();
test3<T, Iter1, bidirectional_iterator<const T*> >(); test3<T, Iter1, bidirectional_iterator<const T*> >();
test3<T, Iter1, random_access_iterator<const T*> >(); test3<T, Iter1, random_access_iterator<const T*> >();
test3<T, Iter1, const T*>(); test3<T, Iter1, const T*>();
} }
template<class T> template<class T>
TEST_CONSTEXPR_CXX20 void test1() TEST_CONSTEXPR_CXX20 void test1()
{ {
test2<T, input_iterator<const T*> >(); test2<T, cpp17_input_iterator<const T*> >();
test2<T, forward_iterator<const T*> >(); test2<T, forward_iterator<const T*> >();
test2<T, bidirectional_iterator<const T*> >(); test2<T, bidirectional_iterator<const T*> >();
test2<T, random_access_iterator<const T*> >(); test2<T, random_access_iterator<const T*> >();
test2<T, const T*>(); test2<T, const T*>();
} }
TEST_CONSTEXPR_CXX20 bool test() TEST_CONSTEXPR_CXX20 bool test()
{ {
Show All 14 Lines

libcxx/test/std/algorithms/alg.sorting/alg.set.operations/set.union/set_union.pass.cpp

Show First 20 Lines • Show All 58 Lines • ▼ Show 20 LinesTEST_CONSTEXPR_CXX20 void test3()
test4<T, Iter1, Iter2, bidirectional_iterator<T*> >(); test4<T, Iter1, Iter2, bidirectional_iterator<T*> >();
test4<T, Iter1, Iter2, random_access_iterator<T*> >(); test4<T, Iter1, Iter2, random_access_iterator<T*> >();
test4<T, Iter1, Iter2, T*>(); test4<T, Iter1, Iter2, T*>();
} }
template<class T, class Iter1> template<class T, class Iter1>
TEST_CONSTEXPR_CXX20 void test2() TEST_CONSTEXPR_CXX20 void test2()
{ {
test3<T, Iter1, input_iterator<const T*> >(); test3<T, Iter1, cpp17_input_iterator<const T*> >();
test3<T, Iter1, forward_iterator<const T*> >(); test3<T, Iter1, forward_iterator<const T*> >();
test3<T, Iter1, bidirectional_iterator<const T*> >(); test3<T, Iter1, bidirectional_iterator<const T*> >();
test3<T, Iter1, random_access_iterator<const T*> >(); test3<T, Iter1, random_access_iterator<const T*> >();
test3<T, Iter1, const T*>(); test3<T, Iter1, const T*>();
} }
template<class T> template<class T>
TEST_CONSTEXPR_CXX20 void test1() TEST_CONSTEXPR_CXX20 void test1()
{ {
test2<T, input_iterator<const T*> >(); test2<T, cpp17_input_iterator<const T*> >();
test2<T, forward_iterator<const T*> >(); test2<T, forward_iterator<const T*> >();
test2<T, bidirectional_iterator<const T*> >(); test2<T, bidirectional_iterator<const T*> >();
test2<T, random_access_iterator<const T*> >(); test2<T, random_access_iterator<const T*> >();
test2<T, const T*>(); test2<T, const T*>();
} }
TEST_CONSTEXPR_CXX20 bool test() TEST_CONSTEXPR_CXX20 bool test()
{ {
Show All 14 Lines

libcxx/test/std/algorithms/alg.sorting/alg.set.operations/set.union/set_union_comp.pass.cpp

Show First 20 Lines • Show All 59 Lines • ▼ Show 20 LinesTEST_CONSTEXPR_CXX20 void test3()
test4<T, Iter1, Iter2, bidirectional_iterator<T*> >(); test4<T, Iter1, Iter2, bidirectional_iterator<T*> >();
test4<T, Iter1, Iter2, random_access_iterator<T*> >(); test4<T, Iter1, Iter2, random_access_iterator<T*> >();
test4<T, Iter1, Iter2, T*>(); test4<T, Iter1, Iter2, T*>();
} }
template<class T, class Iter1> template<class T, class Iter1>
TEST_CONSTEXPR_CXX20 void test2() TEST_CONSTEXPR_CXX20 void test2()
{ {
test3<T, Iter1, input_iterator<const T*> >(); test3<T, Iter1, cpp17_input_iterator<const T*> >();
test3<T, Iter1, forward_iterator<const T*> >(); test3<T, Iter1, forward_iterator<const T*> >();
test3<T, Iter1, bidirectional_iterator<const T*> >(); test3<T, Iter1, bidirectional_iterator<const T*> >();
test3<T, Iter1, random_access_iterator<const T*> >(); test3<T, Iter1, random_access_iterator<const T*> >();
test3<T, Iter1, const T*>(); test3<T, Iter1, const T*>();
} }
template<class T> template<class T>
TEST_CONSTEXPR_CXX20 void test1() TEST_CONSTEXPR_CXX20 void test1()
{ {
test2<T, input_iterator<const T*> >(); test2<T, cpp17_input_iterator<const T*> >();
test2<T, forward_iterator<const T*> >(); test2<T, forward_iterator<const T*> >();
test2<T, bidirectional_iterator<const T*> >(); test2<T, bidirectional_iterator<const T*> >();
test2<T, random_access_iterator<const T*> >(); test2<T, random_access_iterator<const T*> >();
test2<T, const T*>(); test2<T, const T*>();
} }
TEST_CONSTEXPR_CXX20 bool test() TEST_CONSTEXPR_CXX20 bool test()
{ {
Show All 14 Lines

libcxx/test/std/containers/associative/map/map.modifiers/insert_iter_iter.pass.cpp

Show All 32 Linesint main(int, char**)
P(2, 1), P(2, 1),
P(2, 1.5), P(2, 1.5),
P(2, 2), P(2, 2),
P(3, 1), P(3, 1),
P(3, 1.5), P(3, 1.5),
P(3, 2), P(3, 2),
}; };
M m; M m;
m.insert(input_iterator<P*>(ar), input_iterator<P*>(ar + sizeof(ar)/sizeof(ar[0]))); m.insert(cpp17_input_iterator<P*>(ar), cpp17_input_iterator<P*>(ar + sizeof(ar)/sizeof(ar[0])));
assert(m.size() == 3); assert(m.size() == 3);
assert(m.begin()->first == 1); assert(m.begin()->first == 1);
assert(m.begin()->second == 1); assert(m.begin()->second == 1);
assert(next(m.begin())->first == 2); assert(next(m.begin())->first == 2);
assert(next(m.begin())->second == 1); assert(next(m.begin())->second == 1);
assert(next(m.begin(), 2)->first == 3); assert(next(m.begin(), 2)->first == 3);
assert(next(m.begin(), 2)->second == 1); assert(next(m.begin(), 2)->second == 1);
} }
Show All 9 Lines#if TEST_STD_VER >= 11
P(2, 1), P(2, 1),
P(2, 1.5), P(2, 1.5),
P(2, 2), P(2, 2),
P(3, 1), P(3, 1),
P(3, 1.5), P(3, 1.5),
P(3, 2), P(3, 2),
}; };
M m; M m;
m.insert(input_iterator<P*>(ar), input_iterator<P*>(ar + sizeof(ar)/sizeof(ar[0]))); m.insert(cpp17_input_iterator<P*>(ar), cpp17_input_iterator<P*>(ar + sizeof(ar)/sizeof(ar[0])));
assert(m.size() == 3); assert(m.size() == 3);
assert(m.begin()->first == 1); assert(m.begin()->first == 1);
assert(m.begin()->second == 1); assert(m.begin()->second == 1);
assert(next(m.begin())->first == 2); assert(next(m.begin())->first == 2);
assert(next(m.begin())->second == 1); assert(next(m.begin())->second == 1);
assert(next(m.begin(), 2)->first == 3); assert(next(m.begin(), 2)->first == 3);
assert(next(m.begin(), 2)->second == 1); assert(next(m.begin(), 2)->second == 1);
} }
#endif #endif
return 0; return 0;
} }

libcxx/test/std/containers/associative/multimap/multimap.modifiers/insert_iter_iter.pass.cpp

Show All 32 Linesint main(int, char**)
P(2, 1), P(2, 1),
P(2, 1.5), P(2, 1.5),
P(2, 2), P(2, 2),
P(3, 1), P(3, 1),
P(3, 1.5), P(3, 1.5),
P(3, 2), P(3, 2),
}; };
M m; M m;
m.insert(input_iterator<P*>(ar), input_iterator<P*>(ar + sizeof(ar)/sizeof(ar[0]))); m.insert(cpp17_input_iterator<P*>(ar), cpp17_input_iterator<P*>(ar + sizeof(ar)/sizeof(ar[0])));
assert(m.size() == 9); assert(m.size() == 9);
assert(m.begin()->first == 1); assert(m.begin()->first == 1);
assert(m.begin()->second == 1); assert(m.begin()->second == 1);
assert(next(m.begin())->first == 1); assert(next(m.begin())->first == 1);
assert(next(m.begin())->second == 1.5); assert(next(m.begin())->second == 1.5);
assert(next(m.begin(), 2)->first == 1); assert(next(m.begin(), 2)->first == 1);
assert(next(m.begin(), 2)->second == 2); assert(next(m.begin(), 2)->second == 2);
assert(next(m.begin(), 3)->first == 2); assert(next(m.begin(), 3)->first == 2);
Show All 21 Lines#if TEST_STD_VER >= 11
P(2, 1), P(2, 1),
P(2, 1.5), P(2, 1.5),
P(2, 2), P(2, 2),
P(3, 1), P(3, 1),
P(3, 1.5), P(3, 1.5),
P(3, 2), P(3, 2),
}; };
M m; M m;
m.insert(input_iterator<P*>(ar), input_iterator<P*>(ar + sizeof(ar)/sizeof(ar[0]))); m.insert(cpp17_input_iterator<P*>(ar), cpp17_input_iterator<P*>(ar + sizeof(ar)/sizeof(ar[0])));
assert(m.size() == 9); assert(m.size() == 9);
assert(m.begin()->first == 1); assert(m.begin()->first == 1);
assert(m.begin()->second == 1); assert(m.begin()->second == 1);
assert(next(m.begin())->first == 1); assert(next(m.begin())->first == 1);
assert(next(m.begin())->second == 1.5); assert(next(m.begin())->second == 1.5);
assert(next(m.begin(), 2)->first == 1); assert(next(m.begin(), 2)->first == 1);
assert(next(m.begin(), 2)->second == 2); assert(next(m.begin(), 2)->second == 2);
assert(next(m.begin(), 3)->first == 2); assert(next(m.begin(), 3)->first == 2);
Show All 16 Lines

libcxx/test/std/containers/associative/multiset/insert_iter_iter.pass.cpp

Show All 32 Linesint main(int, char**)
2, 2,
2, 2,
2, 2,
3, 3,
3, 3,
3 3
}; };
M m; M m;
m.insert(input_iterator<const V*>(ar), m.insert(cpp17_input_iterator<const V*>(ar),
input_iterator<const V*>(ar + sizeof(ar)/sizeof(ar[0]))); cpp17_input_iterator<const V*>(ar + sizeof(ar)/sizeof(ar[0])));
assert(m.size() == 9); assert(m.size() == 9);
assert(*next(m.begin(), 0) == 1); assert(*next(m.begin(), 0) == 1);
assert(*next(m.begin(), 1) == 1); assert(*next(m.begin(), 1) == 1);
assert(*next(m.begin(), 2) == 1); assert(*next(m.begin(), 2) == 1);
assert(*next(m.begin(), 3) == 2); assert(*next(m.begin(), 3) == 2);
assert(*next(m.begin(), 4) == 2); assert(*next(m.begin(), 4) == 2);
assert(*next(m.begin(), 5) == 2); assert(*next(m.begin(), 5) == 2);
assert(*next(m.begin(), 6) == 3); assert(*next(m.begin(), 6) == 3);
Show All 12 Lines#if TEST_STD_VER >= 11
2, 2,
2, 2,
2, 2,
3, 3,
3, 3,
3 3
}; };
M m; M m;
m.insert(input_iterator<const V*>(ar), m.insert(cpp17_input_iterator<const V*>(ar),
input_iterator<const V*>(ar + sizeof(ar)/sizeof(ar[0]))); cpp17_input_iterator<const V*>(ar + sizeof(ar)/sizeof(ar[0])));
assert(m.size() == 9); assert(m.size() == 9);
assert(*next(m.begin(), 0) == 1); assert(*next(m.begin(), 0) == 1);
assert(*next(m.begin(), 1) == 1); assert(*next(m.begin(), 1) == 1);
assert(*next(m.begin(), 2) == 1); assert(*next(m.begin(), 2) == 1);
assert(*next(m.begin(), 3) == 2); assert(*next(m.begin(), 3) == 2);
assert(*next(m.begin(), 4) == 2); assert(*next(m.begin(), 4) == 2);
assert(*next(m.begin(), 5) == 2); assert(*next(m.begin(), 5) == 2);
assert(*next(m.begin(), 6) == 3); assert(*next(m.begin(), 6) == 3);
assert(*next(m.begin(), 7) == 3); assert(*next(m.begin(), 7) == 3);
assert(*next(m.begin(), 8) == 3); assert(*next(m.begin(), 8) == 3);
} }
#endif #endif
return 0; return 0;
} }

libcxx/test/std/containers/associative/multiset/multiset.cons/iter_iter.pass.cpp

Show All 30 Lines V ar[] =
1, 1,
2, 2,
2, 2,
2, 2,
3, 3,
3, 3,
3 3
}; };
std::multiset<V> m(input_iterator<const int*>(ar), std::multiset<V> m(cpp17_input_iterator<const int*>(ar),
input_iterator<const int*>(ar+sizeof(ar)/sizeof(ar[0]))); cpp17_input_iterator<const int*>(ar+sizeof(ar)/sizeof(ar[0])));
assert(m.size() == 9); assert(m.size() == 9);
assert(distance(m.begin(), m.end()) == 9); assert(distance(m.begin(), m.end()) == 9);
assert(*next(m.begin(), 0) == 1); assert(*next(m.begin(), 0) == 1);
assert(*next(m.begin(), 1) == 1); assert(*next(m.begin(), 1) == 1);
assert(*next(m.begin(), 2) == 1); assert(*next(m.begin(), 2) == 1);
assert(*next(m.begin(), 3) == 2); assert(*next(m.begin(), 3) == 2);
assert(*next(m.begin(), 4) == 2); assert(*next(m.begin(), 4) == 2);
assert(*next(m.begin(), 5) == 2); assert(*next(m.begin(), 5) == 2);
Show All 11 Lines V ar[] =
1, 1,
2, 2,
2, 2,
2, 2,
3, 3,
3, 3,
3 3
}; };
std::multiset<V, std::less<V>, min_allocator<V>> m(input_iterator<const int*>(ar), std::multiset<V, std::less<V>, min_allocator<V>> m(cpp17_input_iterator<const int*>(ar),
input_iterator<const int*>(ar+sizeof(ar)/sizeof(ar[0]))); cpp17_input_iterator<const int*>(ar+sizeof(ar)/sizeof(ar[0])));
assert(m.size() == 9); assert(m.size() == 9);
assert(distance(m.begin(), m.end()) == 9); assert(distance(m.begin(), m.end()) == 9);
assert(*next(m.begin(), 0) == 1); assert(*next(m.begin(), 0) == 1);
assert(*next(m.begin(), 1) == 1); assert(*next(m.begin(), 1) == 1);
assert(*next(m.begin(), 2) == 1); assert(*next(m.begin(), 2) == 1);
assert(*next(m.begin(), 3) == 2); assert(*next(m.begin(), 3) == 2);
assert(*next(m.begin(), 4) == 2); assert(*next(m.begin(), 4) == 2);
assert(*next(m.begin(), 5) == 2); assert(*next(m.begin(), 5) == 2);
assert(*next(m.begin(), 6) == 3); assert(*next(m.begin(), 6) == 3);
assert(*next(m.begin(), 7) == 3); assert(*next(m.begin(), 7) == 3);
assert(*next(m.begin(), 8) == 3); assert(*next(m.begin(), 8) == 3);
} }
#endif #endif
return 0; return 0;
} }

libcxx/test/std/containers/associative/multiset/multiset.cons/iter_iter_alloc.pass.cpp

Show All 34 Lines V ar[] =
2, 2,
2, 2,
3, 3,
3, 3,
3 3
}; };
typedef test_compare<std::less<V> > C; typedef test_compare<std::less<V> > C;
typedef test_allocator<V> A; typedef test_allocator<V> A;
std::multiset<V, C, A> m(input_iterator<const V*>(ar), std::multiset<V, C, A> m(cpp17_input_iterator<const V*>(ar),
input_iterator<const V*>(ar+sizeof(ar)/sizeof(ar[0])), cpp17_input_iterator<const V*>(ar+sizeof(ar)/sizeof(ar[0])),
C(5), A(7)); C(5), A(7));
assert(m.value_comp() == C(5)); assert(m.value_comp() == C(5));
assert(m.get_allocator() == A(7)); assert(m.get_allocator() == A(7));
assert(m.size() == 9); assert(m.size() == 9);
assert(distance(m.begin(), m.end()) == 9); assert(distance(m.begin(), m.end()) == 9);
assert(*next(m.begin(), 0) == 1); assert(*next(m.begin(), 0) == 1);
assert(*next(m.begin(), 1) == 1); assert(*next(m.begin(), 1) == 1);
assert(*next(m.begin(), 2) == 1); assert(*next(m.begin(), 2) == 1);
▲ Show 20 Lines • Show All 44 Lines • Show Last 20 Lines

libcxx/test/std/containers/associative/multiset/multiset.cons/iter_iter_comp.pass.cpp

Show All 30 Lines V ar[] =
2, 2,
2, 2,
2, 2,
3, 3,
3, 3,
3 3
}; };
typedef test_compare<std::less<V> > C; typedef test_compare<std::less<V> > C;
std::multiset<V, C> m(input_iterator<const V*>(ar), std::multiset<V, C> m(cpp17_input_iterator<const V*>(ar),
input_iterator<const V*>(ar+sizeof(ar)/sizeof(ar[0])), C(5)); cpp17_input_iterator<const V*>(ar+sizeof(ar)/sizeof(ar[0])), C(5));
assert(m.value_comp() == C(5)); assert(m.value_comp() == C(5));
assert(m.size() == 9); assert(m.size() == 9);
assert(distance(m.begin(), m.end()) == 9); assert(distance(m.begin(), m.end()) == 9);
assert(*next(m.begin(), 0) == 1); assert(*next(m.begin(), 0) == 1);
assert(*next(m.begin(), 1) == 1); assert(*next(m.begin(), 1) == 1);
assert(*next(m.begin(), 2) == 1); assert(*next(m.begin(), 2) == 1);
assert(*next(m.begin(), 3) == 2); assert(*next(m.begin(), 3) == 2);
assert(*next(m.begin(), 4) == 2); assert(*next(m.begin(), 4) == 2);
assert(*next(m.begin(), 5) == 2); assert(*next(m.begin(), 5) == 2);
assert(*next(m.begin(), 6) == 3); assert(*next(m.begin(), 6) == 3);
assert(*next(m.begin(), 7) == 3); assert(*next(m.begin(), 7) == 3);
assert(*next(m.begin(), 8) == 3); assert(*next(m.begin(), 8) == 3);
return 0; return 0;
} }

libcxx/test/std/containers/associative/set/insert_iter_iter.pass.cpp

Show All 32 Linesint main(int, char**)
2, 2,
2, 2,
2, 2,
3, 3,
3, 3,
3 3
}; };
M m; M m;
m.insert(input_iterator<const V*>(ar), m.insert(cpp17_input_iterator<const V*>(ar),
input_iterator<const V*>(ar + sizeof(ar)/sizeof(ar[0]))); cpp17_input_iterator<const V*>(ar + sizeof(ar)/sizeof(ar[0])));
assert(m.size() == 3); assert(m.size() == 3);
assert(*m.begin() == 1); assert(*m.begin() == 1);
assert(*next(m.begin()) == 2); assert(*next(m.begin()) == 2);
assert(*next(m.begin(), 2) == 3); assert(*next(m.begin(), 2) == 3);
} }
#if TEST_STD_VER >= 11 #if TEST_STD_VER >= 11
{ {
typedef std::set<int, std::less<int>, min_allocator<int>> M; typedef std::set<int, std::less<int>, min_allocator<int>> M;
typedef int V; typedef int V;
V ar[] = V ar[] =
{ {
1, 1,
1, 1,
1, 1,
2, 2,
2, 2,
2, 2,
3, 3,
3, 3,
3 3
}; };
M m; M m;
m.insert(input_iterator<const V*>(ar), m.insert(cpp17_input_iterator<const V*>(ar),
input_iterator<const V*>(ar + sizeof(ar)/sizeof(ar[0]))); cpp17_input_iterator<const V*>(ar + sizeof(ar)/sizeof(ar[0])));
assert(m.size() == 3); assert(m.size() == 3);
assert(*m.begin() == 1); assert(*m.begin() == 1);
assert(*next(m.begin()) == 2); assert(*next(m.begin()) == 2);
assert(*next(m.begin(), 2) == 3); assert(*next(m.begin(), 2) == 3);
} }
#endif #endif
return 0; return 0;
} }

libcxx/test/std/containers/associative/set/set.cons/iter_iter.pass.cpp

Show All 30 Lines V ar[] =
1, 1,
2, 2,
2, 2,
2, 2,
3, 3,
3, 3,
3 3
}; };
std::set<V> m(input_iterator<const int*>(ar), std::set<V> m(cpp17_input_iterator<const int*>(ar),
input_iterator<const int*>(ar+sizeof(ar)/sizeof(ar[0]))); cpp17_input_iterator<const int*>(ar+sizeof(ar)/sizeof(ar[0])));
assert(m.size() == 3); assert(m.size() == 3);
assert(distance(m.begin(), m.end()) == 3); assert(distance(m.begin(), m.end()) == 3);
assert(*m.begin() == 1); assert(*m.begin() == 1);
assert(*next(m.begin()) == 2); assert(*next(m.begin()) == 2);
assert(*next(m.begin(), 2) == 3); assert(*next(m.begin(), 2) == 3);
} }
#if TEST_STD_VER >= 11 #if TEST_STD_VER >= 11
{ {
typedef int V; typedef int V;
V ar[] = V ar[] =
{ {
1, 1,
1, 1,
1, 1,
2, 2,
2, 2,
2, 2,
3, 3,
3, 3,
3 3
}; };
std::set<V, std::less<int>, min_allocator<int>> m(input_iterator<const int*>(ar), std::set<V, std::less<int>, min_allocator<int>> m(cpp17_input_iterator<const int*>(ar),
input_iterator<const int*>(ar+sizeof(ar)/sizeof(ar[0]))); cpp17_input_iterator<const int*>(ar+sizeof(ar)/sizeof(ar[0])));
assert(m.size() == 3); assert(m.size() == 3);
assert(distance(m.begin(), m.end()) == 3); assert(distance(m.begin(), m.end()) == 3);
assert(*m.begin() == 1); assert(*m.begin() == 1);
assert(*next(m.begin()) == 2); assert(*next(m.begin()) == 2);
assert(*next(m.begin(), 2) == 3); assert(*next(m.begin(), 2) == 3);
} }
#endif #endif
return 0; return 0;
} }

libcxx/test/std/containers/associative/set/set.cons/iter_iter_alloc.pass.cpp

Show All 38 Lines V ar[] =
2, 2,
2, 2,
3, 3,
3, 3,
3 3
}; };
typedef test_compare<std::less<V> > C; typedef test_compare<std::less<V> > C;
typedef test_allocator<V> A; typedef test_allocator<V> A;
std::set<V, C, A> m(input_iterator<const V*>(ar), std::set<V, C, A> m(cpp17_input_iterator<const V*>(ar),
input_iterator<const V*>(ar+sizeof(ar)/sizeof(ar[0])), cpp17_input_iterator<const V*>(ar+sizeof(ar)/sizeof(ar[0])),
C(5), A(7)); C(5), A(7));
assert(m.value_comp() == C(5)); assert(m.value_comp() == C(5));
assert(m.get_allocator() == A(7)); assert(m.get_allocator() == A(7));
assert(m.size() == 3); assert(m.size() == 3);
assert(distance(m.begin(), m.end()) == 3); assert(distance(m.begin(), m.end()) == 3);
assert(*m.begin() == 1); assert(*m.begin() == 1);
assert(*next(m.begin()) == 2); assert(*next(m.begin()) == 2);
assert(*next(m.begin(), 2) == 3); assert(*next(m.begin(), 2) == 3);
Show All 32 Lines

libcxx/test/std/containers/associative/set/set.cons/iter_iter_comp.pass.cpp

Show All 30 Lines V ar[] =
2, 2,
2, 2,
2, 2,
3, 3,
3, 3,
3 3
}; };
typedef test_compare<std::less<V> > C; typedef test_compare<std::less<V> > C;
std::set<V, C> m(input_iterator<const V*>(ar), std::set<V, C> m(cpp17_input_iterator<const V*>(ar),
input_iterator<const V*>(ar+sizeof(ar)/sizeof(ar[0])), C(5)); cpp17_input_iterator<const V*>(ar+sizeof(ar)/sizeof(ar[0])), C(5));
assert(m.value_comp() == C(5)); assert(m.value_comp() == C(5));
assert(m.size() == 3); assert(m.size() == 3);
assert(distance(m.begin(), m.end()) == 3); assert(distance(m.begin(), m.end()) == 3);
assert(*m.begin() == 1); assert(*m.begin() == 1);
assert(*next(m.begin()) == 2); assert(*next(m.begin()) == 2);
assert(*next(m.begin(), 2) == 3); assert(*next(m.begin(), 2) == 3);
return 0; return 0;
} }

libcxx/test/std/containers/sequences/deque/deque.cons/assign_iter_iter.pass.cpp

Show First 20 Lines • Show All 61 Lines • ▼ Show 20 LinestestN(int start, int N, int M)
test(c1, c2); test(c1, c2);
} }
template <class C> template <class C>
void void
testI(C& c1, const C& c2) testI(C& c1, const C& c2)
{ {
typedef typename C::const_iterator CI; typedef typename C::const_iterator CI;
typedef input_iterator<CI> ICI; typedef cpp17_input_iterator<CI> ICI;
c1.assign(ICI(c2.begin()), ICI(c2.end())); c1.assign(ICI(c2.begin()), ICI(c2.end()));
assert(static_cast<std::size_t>(distance(c1.begin(), c1.end())) == c1.size()); assert(static_cast<std::size_t>(distance(c1.begin(), c1.end())) == c1.size());
assert(c1 == c2); assert(c1 == c2);
} }
template <class C> template <class C>
void void
testNI(int start, int N, int M) testNI(int start, int N, int M)
▲ Show 20 Lines • Show All 44 Lines • ▼ Show 20 Lines using It = random_access_iterator<int*>;
v.assign(It(arr2), It(std::end(arr2))); v.assign(It(arr2), It(std::end(arr2)));
assert(v[0].value == 1); assert(v[0].value == 1);
assert(v[1].value == 101); assert(v[1].value == 101);
assert(v[2].value == 42); assert(v[2].value == 42);
} }
} }
{ {
using T = EmplaceConstructibleMoveableAndAssignable<int>; using T = EmplaceConstructibleMoveableAndAssignable<int>;
using It = input_iterator<int*>; using It = cpp17_input_iterator<int*>;
{ {
std::deque<T> v; std::deque<T> v;
v.assign(It(arr1), It(std::end(arr1))); v.assign(It(arr1), It(std::end(arr1)));
assert(v[0].copied == 0); assert(v[0].copied == 0);
assert(v[0].value == 42); assert(v[0].value == 42);
} }
{ {
std::deque<T> v; std::deque<T> v;
Show All 18 Lines

libcxx/test/std/containers/sequences/deque/deque.cons/iter_iter.pass.cpp

Show First 20 Lines • Show All 49 Lines • ▼ Show 20 Linestest(InputIterator f, InputIterator l)
for (const_iterator i = d.begin(), e = d.end(); i != e; ++i, ++f) for (const_iterator i = d.begin(), e = d.end(); i != e; ++i, ++f)
assert(*i == *f); assert(*i == *f);
} }
void basic_test() void basic_test()
{ {
int ab[] = {3, 4, 2, 8, 0, 1, 44, 34, 45, 96, 80, 1, 13, 31, 45}; int ab[] = {3, 4, 2, 8, 0, 1, 44, 34, 45, 96, 80, 1, 13, 31, 45};
int* an = ab + sizeof(ab)/sizeof(ab[0]); int* an = ab + sizeof(ab)/sizeof(ab[0]);
test(input_iterator<const int*>(ab), input_iterator<const int*>(an)); test(cpp17_input_iterator<const int*>(ab), cpp17_input_iterator<const int*>(an));
test(forward_iterator<const int*>(ab), forward_iterator<const int*>(an)); test(forward_iterator<const int*>(ab), forward_iterator<const int*>(an));
test(bidirectional_iterator<const int*>(ab), bidirectional_iterator<const int*>(an)); test(bidirectional_iterator<const int*>(ab), bidirectional_iterator<const int*>(an));
test(random_access_iterator<const int*>(ab), random_access_iterator<const int*>(an)); test(random_access_iterator<const int*>(ab), random_access_iterator<const int*>(an));
test<limited_allocator<int, 4096> >(ab, an); test<limited_allocator<int, 4096> >(ab, an);
#if TEST_STD_VER >= 11 #if TEST_STD_VER >= 11
test<min_allocator<int> >(ab, an); test<min_allocator<int> >(ab, an);
#endif #endif
} }
Show All 14 Lines using It = random_access_iterator<int*>;
std::deque<T> v(It(arr2), It(std::end(arr2))); std::deque<T> v(It(arr2), It(std::end(arr2)));
assert(v[0].value == 1); assert(v[0].value == 1);
assert(v[1].value == 101); assert(v[1].value == 101);
assert(v[2].value == 42); assert(v[2].value == 42);
} }
} }
{ {
using T = EmplaceConstructibleAndMoveable<int>; using T = EmplaceConstructibleAndMoveable<int>;
using It = input_iterator<int*>; using It = cpp17_input_iterator<int*>;
{ {
std::deque<T> v(It(arr1), It(std::end(arr1))); std::deque<T> v(It(arr1), It(std::end(arr1)));
assert(v[0].copied == 0); assert(v[0].copied == 0);
assert(v[0].value == 42); assert(v[0].value == 42);
} }
{ {
std::deque<T> v(It(arr2), It(std::end(arr2))); std::deque<T> v(It(arr2), It(std::end(arr2)));
//assert(v[0].copied == 0); //assert(v[0].copied == 0);
Show All 16 Lines

libcxx/test/std/containers/sequences/deque/deque.cons/iter_iter_alloc.pass.cpp

Show All 36 Linestest(InputIterator f, InputIterator l, const Allocator& a)
for (const_iterator i = d.begin(), e = d.end(); i != e; ++i, ++f) for (const_iterator i = d.begin(), e = d.end(); i != e; ++i, ++f)
assert(*i == *f); assert(*i == *f);
} }
void basic_test() void basic_test()
{ {
int ab[] = {3, 4, 2, 8, 0, 1, 44, 34, 45, 96, 80, 1, 13, 31, 45}; int ab[] = {3, 4, 2, 8, 0, 1, 44, 34, 45, 96, 80, 1, 13, 31, 45};
int* an = ab + sizeof(ab)/sizeof(ab[0]); int* an = ab + sizeof(ab)/sizeof(ab[0]);
test(input_iterator<const int*>(ab), input_iterator<const int*>(an), test_allocator<int>(3)); test(cpp17_input_iterator<const int*>(ab), cpp17_input_iterator<const int*>(an), test_allocator<int>(3));
test(forward_iterator<const int*>(ab), forward_iterator<const int*>(an), test_allocator<int>(4)); test(forward_iterator<const int*>(ab), forward_iterator<const int*>(an), test_allocator<int>(4));
test(bidirectional_iterator<const int*>(ab), bidirectional_iterator<const int*>(an), test_allocator<int>(5)); test(bidirectional_iterator<const int*>(ab), bidirectional_iterator<const int*>(an), test_allocator<int>(5));
test(random_access_iterator<const int*>(ab), random_access_iterator<const int*>(an), test_allocator<int>(6)); test(random_access_iterator<const int*>(ab), random_access_iterator<const int*>(an), test_allocator<int>(6));
#if TEST_STD_VER >= 11 #if TEST_STD_VER >= 11
test(input_iterator<const int*>(ab), input_iterator<const int*>(an), min_allocator<int>()); test(cpp17_input_iterator<const int*>(ab), cpp17_input_iterator<const int*>(an), min_allocator<int>());
test(forward_iterator<const int*>(ab), forward_iterator<const int*>(an), min_allocator<int>()); test(forward_iterator<const int*>(ab), forward_iterator<const int*>(an), min_allocator<int>());
test(bidirectional_iterator<const int*>(ab), bidirectional_iterator<const int*>(an), min_allocator<int>()); test(bidirectional_iterator<const int*>(ab), bidirectional_iterator<const int*>(an), min_allocator<int>());
test(random_access_iterator<const int*>(ab), random_access_iterator<const int*>(an), min_allocator<int>()); test(random_access_iterator<const int*>(ab), random_access_iterator<const int*>(an), min_allocator<int>());
#endif #endif
} }
void test_emplacable_concept() { void test_emplacable_concept() {
Show All 12 Lines std::allocator<T> a;
std::deque<T> v(It(arr2), It(std::end(arr2)), a); std::deque<T> v(It(arr2), It(std::end(arr2)), a);
assert(v[0].value == 1); assert(v[0].value == 1);
assert(v[1].value == 101); assert(v[1].value == 101);
assert(v[2].value == 42); assert(v[2].value == 42);
} }
} }
{ {
using T = EmplaceConstructibleAndMoveable<int>; using T = EmplaceConstructibleAndMoveable<int>;
using It = input_iterator<int*>; using It = cpp17_input_iterator<int*>;
std::allocator<T> a; std::allocator<T> a;
{ {
std::deque<T> v(It(arr1), It(std::end(arr1)), a); std::deque<T> v(It(arr1), It(std::end(arr1)), a);
assert(v[0].copied == 0); assert(v[0].copied == 0);
assert(v[0].value == 42); assert(v[0].value == 42);
} }
{ {
std::deque<T> v(It(arr2), It(std::end(arr2)), a); std::deque<T> v(It(arr2), It(std::end(arr2)), a);
Show All 17 Lines

libcxx/test/std/containers/sequences/deque/deque.modifiers/insert_iter_iter.pass.cpp

Show First 20 Lines • Show All 45 Lines • ▼ Show 20 Lines
} }
template <class C> template <class C>
void void
test(int P, const C& c0, const C& c2) test(int P, const C& c0, const C& c2)
{ {
{ {
typedef typename C::const_iterator CI; typedef typename C::const_iterator CI;
typedef input_iterator<CI> BCI; typedef cpp17_input_iterator<CI> BCI;
C c1 = c0; C c1 = c0;
std::size_t c1_osize = c1.size(); std::size_t c1_osize = c1.size();
CI i = c1.insert(c1.begin() + P, BCI(c2.begin()), BCI(c2.end())); CI i = c1.insert(c1.begin() + P, BCI(c2.begin()), BCI(c2.end()));
assert(i == c1.begin() + P); assert(i == c1.begin() + P);
assert(c1.size() == c1_osize + c2.size()); assert(c1.size() == c1_osize + c2.size());
assert(static_cast<std::size_t>(distance(c1.begin(), c1.end())) == c1.size()); assert(static_cast<std::size_t>(distance(c1.begin(), c1.end())) == c1.size());
i = c1.begin(); i = c1.begin();
for (int j = 0; j < P; ++j, ++i) for (int j = 0; j < P; ++j, ++i)
▲ Show 20 Lines • Show All 99 Lines • ▼ Show 20 LinestestN(int start, int N, int M)
} }
} }
template <class C> template <class C>
void void
testI(int P, C& c1, const C& c2) testI(int P, C& c1, const C& c2)
{ {
typedef typename C::const_iterator CI; typedef typename C::const_iterator CI;
typedef input_iterator<CI> ICI; typedef cpp17_input_iterator<CI> ICI;
std::size_t c1_osize = c1.size(); std::size_t c1_osize = c1.size();
CI i = c1.insert(c1.begin() + P, ICI(c2.begin()), ICI(c2.end())); CI i = c1.insert(c1.begin() + P, ICI(c2.begin()), ICI(c2.end()));
assert(i == c1.begin() + P); assert(i == c1.begin() + P);
assert(c1.size() == c1_osize + c2.size()); assert(c1.size() == c1_osize + c2.size());
assert(static_cast<std::size_t>(distance(c1.begin(), c1.end())) == c1.size()); assert(static_cast<std::size_t>(distance(c1.begin(), c1.end())) == c1.size());
i = c1.begin(); i = c1.begin();
for (int j = 0; j < P; ++j, ++i) for (int j = 0; j < P; ++j, ++i)
assert(*i == j); assert(*i == j);
▲ Show 20 Lines • Show All 66 Lines • ▼ Show 20 Lines typedef typename C::const_iterator CI;
typedef MoveOnly* I; typedef MoveOnly* I;
c.insert(c.end(), std::move_iterator<I>(&mo), std::move_iterator<I>(&mo+1)); c.insert(c.end(), std::move_iterator<I>(&mo), std::move_iterator<I>(&mo+1));
} }
int j = 0; int j = 0;
for (CI i = c.begin(); i != c.end(); ++i, ++j) for (CI i = c.begin(); i != c.end(); ++i, ++j)
assert(*i == MoveOnly(j)); assert(*i == MoveOnly(j));
{ {
MoveOnly mo(1); MoveOnly mo(1);
typedef input_iterator<MoveOnly*> I; typedef cpp17_input_iterator<MoveOnly*> I;
c.insert(c.end(), std::move_iterator<I>(I(&mo)), std::move_iterator<I>(I(&mo+1))); c.insert(c.end(), std::move_iterator<I>(I(&mo)), std::move_iterator<I>(I(&mo+1)));
} }
j = 0; j = 0;
for (CI i = c.begin(); i != c.end(); ++i, ++j) for (CI i = c.begin(); i != c.end(); ++i, ++j)
assert(*i == MoveOnly(j)); assert(*i == MoveOnly(j));
#endif #endif
} }
Show All 29 Lines

libcxx/test/std/containers/sequences/deque/deque.special/copy.pass.cpp

Show First 20 Lines • Show All 44 Lines • ▼ Show 20 Lines
template <class C> template <class C>
void testN(int start, int N) void testN(int start, int N)
{ {
typedef typename C::iterator I; typedef typename C::iterator I;
typedef typename C::const_iterator CI; typedef typename C::const_iterator CI;
typedef random_access_iterator<I> RAI; typedef random_access_iterator<I> RAI;
typedef random_access_iterator<CI> RACI; typedef random_access_iterator<CI> RACI;
typedef input_iterator<CI> ICI; typedef cpp17_input_iterator<CI> ICI;
C c1 = make<C>(N, start); C c1 = make<C>(N, start);
C c2 = make<C>(N); C c2 = make<C>(N);
assert(std::copy(c1.cbegin(), c1.cend(), c2.begin()) == c2.end()); assert(std::copy(c1.cbegin(), c1.cend(), c2.begin()) == c2.end());
assert(c1 == c2); assert(c1 == c2);
assert(std::copy(c2.cbegin(), c2.cend(), c1.begin()) == c1.end()); assert(std::copy(c2.cbegin(), c2.cend(), c1.begin()) == c1.end());
assert(c1 == c2); assert(c1 == c2);
assert(std::copy(c1.cbegin(), c1.cend(), RAI(c2.begin())) == RAI(c2.end())); assert(std::copy(c1.cbegin(), c1.cend(), RAI(c2.begin())) == RAI(c2.end()));
assert(c1 == c2); assert(c1 == c2);
Show All 29 Lines

libcxx/test/std/containers/sequences/forwardlist/forwardlist.cons/assign_range.pass.cpp

Show All 21 Lines
int main(int, char**) int main(int, char**)
{ {
{ {
typedef int T; typedef int T;
typedef std::forward_list<T> C; typedef std::forward_list<T> C;
const T t0[] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9}; const T t0[] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9};
const T t1[] = {10, 11, 12, 13}; const T t1[] = {10, 11, 12, 13};
C c(std::begin(t1), std::end(t1)); C c(std::begin(t1), std::end(t1));
typedef input_iterator<const T*> I; typedef cpp17_input_iterator<const T*> I;
c.assign(I(std::begin(t0)), I(std::end(t0))); c.assign(I(std::begin(t0)), I(std::end(t0)));
int n = 0; int n = 0;
for (C::const_iterator i = c.cbegin(); i != c.cend(); ++i, ++n) for (C::const_iterator i = c.cbegin(); i != c.cend(); ++i, ++n)
assert(*i == n); assert(*i == n);
assert(n == 10); assert(n == 10);
} }
{ {
typedef int T; typedef int T;
typedef std::forward_list<T> C; typedef std::forward_list<T> C;
const T t0[] = {10, 11, 12, 13}; const T t0[] = {10, 11, 12, 13};
const T t1[] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9}; const T t1[] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9};
C c(std::begin(t1), std::end(t1)); C c(std::begin(t1), std::end(t1));
typedef input_iterator<const T*> I; typedef cpp17_input_iterator<const T*> I;
c.assign(I(std::begin(t0)), I(std::end(t0))); c.assign(I(std::begin(t0)), I(std::end(t0)));
int n = 0; int n = 0;
for (C::const_iterator i = c.cbegin(); i != c.cend(); ++i, ++n) for (C::const_iterator i = c.cbegin(); i != c.cend(); ++i, ++n)
assert(*i == 10+n); assert(*i == 10+n);
assert(n == 4); assert(n == 4);
} }
#if TEST_STD_VER >= 11 #if TEST_STD_VER >= 11
{ {
typedef int T; typedef int T;
typedef std::forward_list<T, min_allocator<T>> C; typedef std::forward_list<T, min_allocator<T>> C;
const T t0[] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9}; const T t0[] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9};
const T t1[] = {10, 11, 12, 13}; const T t1[] = {10, 11, 12, 13};
C c(std::begin(t1), std::end(t1)); C c(std::begin(t1), std::end(t1));
typedef input_iterator<const T*> I; typedef cpp17_input_iterator<const T*> I;
c.assign(I(std::begin(t0)), I(std::end(t0))); c.assign(I(std::begin(t0)), I(std::end(t0)));
int n = 0; int n = 0;
for (C::const_iterator i = c.cbegin(); i != c.cend(); ++i, ++n) for (C::const_iterator i = c.cbegin(); i != c.cend(); ++i, ++n)
assert(*i == n); assert(*i == n);
assert(n == 10); assert(n == 10);
} }
{ {
typedef int T; typedef int T;
typedef std::forward_list<T, min_allocator<T>> C; typedef std::forward_list<T, min_allocator<T>> C;
const T t0[] = {10, 11, 12, 13}; const T t0[] = {10, 11, 12, 13};
const T t1[] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9}; const T t1[] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9};
C c(std::begin(t1), std::end(t1)); C c(std::begin(t1), std::end(t1));
typedef input_iterator<const T*> I; typedef cpp17_input_iterator<const T*> I;
c.assign(I(std::begin(t0)), I(std::end(t0))); c.assign(I(std::begin(t0)), I(std::end(t0)));
int n = 0; int n = 0;
for (C::const_iterator i = c.cbegin(); i != c.cend(); ++i, (void) ++n) for (C::const_iterator i = c.cbegin(); i != c.cend(); ++i, (void) ++n)
assert(*i == 10+n); assert(*i == 10+n);
assert(n == 4); assert(n == 4);
} }
#endif #endif
return 0; return 0;
} }

libcxx/test/std/containers/sequences/forwardlist/forwardlist.cons/range.pass.cpp

Show All 18 Lines
#include "test_iterators.h" #include "test_iterators.h"
#include "min_allocator.h" #include "min_allocator.h"
int main(int, char**) int main(int, char**)
{ {
{ {
typedef int T; typedef int T;
typedef std::forward_list<T> C; typedef std::forward_list<T> C;
typedef input_iterator<const T*> I; typedef cpp17_input_iterator<const T*> I;
const T t[] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9}; const T t[] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9};
C c(I(std::begin(t)), I(std::end(t))); C c(I(std::begin(t)), I(std::end(t)));
int n = 0; int n = 0;
for (C::const_iterator i = c.begin(), e = c.end(); i != e; ++i, ++n) for (C::const_iterator i = c.begin(), e = c.end(); i != e; ++i, ++n)
assert(*i == n); assert(*i == n);
assert(n == std::end(t) - std::begin(t)); assert(n == std::end(t) - std::begin(t));
} }
#if TEST_STD_VER >= 11 #if TEST_STD_VER >= 11
{ {
typedef int T; typedef int T;
typedef std::forward_list<T, min_allocator<T>> C; typedef std::forward_list<T, min_allocator<T>> C;
typedef input_iterator<const T*> I; typedef cpp17_input_iterator<const T*> I;
const T t[] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9}; const T t[] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9};
C c(I(std::begin(t)), I(std::end(t))); C c(I(std::begin(t)), I(std::end(t)));
int n = 0; int n = 0;
for (C::const_iterator i = c.begin(), e = c.end(); i != e; ++i, ++n) for (C::const_iterator i = c.begin(), e = c.end(); i != e; ++i, ++n)
assert(*i == n); assert(*i == n);
assert(n == std::end(t) - std::begin(t)); assert(n == std::end(t) - std::begin(t));
} }
#endif #endif
return 0; return 0;
} }

libcxx/test/std/containers/sequences/forwardlist/forwardlist.cons/range_alloc.pass.cpp

Show All 21 Lines
#include "min_allocator.h" #include "min_allocator.h"
int main(int, char**) int main(int, char**)
{ {
{ {
typedef int T; typedef int T;
typedef test_allocator<T> A; typedef test_allocator<T> A;
typedef std::forward_list<T, A> C; typedef std::forward_list<T, A> C;
typedef input_iterator<const T*> I; typedef cpp17_input_iterator<const T*> I;
const T t[] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9}; const T t[] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9};
C c(I(std::begin(t)), I(std::end(t)), A(13)); C c(I(std::begin(t)), I(std::end(t)), A(13));
int n = 0; int n = 0;
for (C::const_iterator i = c.begin(), e = c.end(); i != e; ++i, ++n) for (C::const_iterator i = c.begin(), e = c.end(); i != e; ++i, ++n)
assert(*i == n); assert(*i == n);
assert(n == std::end(t) - std::begin(t)); assert(n == std::end(t) - std::begin(t));
assert(c.get_allocator() == A(13)); assert(c.get_allocator() == A(13));
} }
#if TEST_STD_VER >= 11 #if TEST_STD_VER >= 11
{ {
typedef int T; typedef int T;
typedef min_allocator<T> A; typedef min_allocator<T> A;
typedef std::forward_list<T, A> C; typedef std::forward_list<T, A> C;
typedef input_iterator<const T*> I; typedef cpp17_input_iterator<const T*> I;
const T t[] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9}; const T t[] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9};
C c(I(std::begin(t)), I(std::end(t)), A()); C c(I(std::begin(t)), I(std::end(t)), A());
int n = 0; int n = 0;
for (C::const_iterator i = c.begin(), e = c.end(); i != e; ++i, ++n) for (C::const_iterator i = c.begin(), e = c.end(); i != e; ++i, ++n)
assert(*i == n); assert(*i == n);
assert(n == std::end(t) - std::begin(t)); assert(n == std::end(t) - std::begin(t));
assert(c.get_allocator() == A()); assert(c.get_allocator() == A());
} }
#endif #endif
return 0; return 0;
} }

libcxx/test/std/containers/sequences/forwardlist/forwardlist.modifiers/insert_after_range.pass.cpp

Show All 19 Lines
#include "min_allocator.h" #include "min_allocator.h"
int main(int, char**) int main(int, char**)
{ {
{ {
typedef int T; typedef int T;
typedef std::forward_list<T> C; typedef std::forward_list<T> C;
typedef C::iterator I; typedef C::iterator I;
typedef input_iterator<const T*> J; typedef cpp17_input_iterator<const T*> J;
C c; C c;
const T t[] = {0, 1, 2, 3, 4}; const T t[] = {0, 1, 2, 3, 4};
I i = c.insert_after(c.cbefore_begin(), J(t), J(t)); I i = c.insert_after(c.cbefore_begin(), J(t), J(t));
assert(i == c.before_begin()); assert(i == c.before_begin());
assert(distance(c.begin(), c.end()) == 0); assert(distance(c.begin(), c.end()) == 0);
i = c.insert_after(c.cbefore_begin(), J(t), J(t+3)); i = c.insert_after(c.cbefore_begin(), J(t), J(t+3));
assert(i == next(c.before_begin(), 3)); assert(i == next(c.before_begin(), 3));
Show All 11 Linesint main(int, char**)
assert(*next(c.begin(), 3) == 1); assert(*next(c.begin(), 3) == 1);
assert(*next(c.begin(), 4) == 2); assert(*next(c.begin(), 4) == 2);
} }
#if TEST_STD_VER >= 11 #if TEST_STD_VER >= 11
{ {
typedef int T; typedef int T;
typedef std::forward_list<T, min_allocator<T>> C; typedef std::forward_list<T, min_allocator<T>> C;
typedef C::iterator I; typedef C::iterator I;
typedef input_iterator<const T*> J; typedef cpp17_input_iterator<const T*> J;
C c; C c;
const T t[] = {0, 1, 2, 3, 4}; const T t[] = {0, 1, 2, 3, 4};
I i = c.insert_after(c.cbefore_begin(), J(t), J(t)); I i = c.insert_after(c.cbefore_begin(), J(t), J(t));
assert(i == c.before_begin()); assert(i == c.before_begin());
assert(distance(c.begin(), c.end()) == 0); assert(distance(c.begin(), c.end()) == 0);
i = c.insert_after(c.cbefore_begin(), J(t), J(t+3)); i = c.insert_after(c.cbefore_begin(), J(t), J(t+3));
assert(i == next(c.before_begin(), 3)); assert(i == next(c.before_begin(), 3));
Show All 18 Lines

libcxx/test/std/containers/sequences/list/list.cons/input_iterator.pass.cpp

Show All 20 Lines
#include "emplace_constructible.h" #include "emplace_constructible.h"
#include "container_test_types.h" #include "container_test_types.h"
#endif #endif
void basic_test() void basic_test()
{ {
{ {
int a[] = {0, 1, 2, 3}; int a[] = {0, 1, 2, 3};
std::list<int> l(input_iterator<const int*>(a), std::list<int> l(cpp17_input_iterator<const int*>(a),
input_iterator<const int*>(a + sizeof(a)/sizeof(a[0]))); cpp17_input_iterator<const int*>(a + sizeof(a)/sizeof(a[0])));
assert(l.size() == sizeof(a)/sizeof(a[0])); assert(l.size() == sizeof(a)/sizeof(a[0]));
assert(std::distance(l.begin(), l.end()) == sizeof(a)/sizeof(a[0])); assert(std::distance(l.begin(), l.end()) == sizeof(a)/sizeof(a[0]));
int j = 0; int j = 0;
for (std::list<int>::const_iterator i = l.begin(), e = l.end(); i != e; ++i, ++j) for (std::list<int>::const_iterator i = l.begin(), e = l.end(); i != e; ++i, ++j)
assert(*i == j); assert(*i == j);
} }
{ {
int a[] = {0, 1, 2, 3}; int a[] = {0, 1, 2, 3};
std::list<int> l(input_iterator<const int*>(a), std::list<int> l(cpp17_input_iterator<const int*>(a),
input_iterator<const int*>(a + sizeof(a)/sizeof(a[0])), cpp17_input_iterator<const int*>(a + sizeof(a)/sizeof(a[0])),
std::allocator<int>()); std::allocator<int>());
assert(l.size() == sizeof(a)/sizeof(a[0])); assert(l.size() == sizeof(a)/sizeof(a[0]));
assert(std::distance(l.begin(), l.end()) == sizeof(a)/sizeof(a[0])); assert(std::distance(l.begin(), l.end()) == sizeof(a)/sizeof(a[0]));
int j = 0; int j = 0;
for (std::list<int>::const_iterator i = l.begin(), e = l.end(); i != e; ++i, ++j) for (std::list<int>::const_iterator i = l.begin(), e = l.end(); i != e; ++i, ++j)
assert(*i == j); assert(*i == j);
} }
{ {
int a[] = {0, 1, 2, 3}; int a[] = {0, 1, 2, 3};
// Add 2 for implementations that dynamically allocate a sentinel node and container proxy. // Add 2 for implementations that dynamically allocate a sentinel node and container proxy.
std::list<int, limited_allocator<int, sizeof(a)/sizeof(a[0]) + 2> > l(input_iterator<const int*>(a), std::list<int, limited_allocator<int, sizeof(a)/sizeof(a[0]) + 2> > l(cpp17_input_iterator<const int*>(a),
input_iterator<const int*>(a + sizeof(a)/sizeof(a[0]))); cpp17_input_iterator<const int*>(a + sizeof(a)/sizeof(a[0])));
assert(l.size() == sizeof(a)/sizeof(a[0])); assert(l.size() == sizeof(a)/sizeof(a[0]));
assert(std::distance(l.begin(), l.end()) == sizeof(a)/sizeof(a[0])); assert(std::distance(l.begin(), l.end()) == sizeof(a)/sizeof(a[0]));
int j = 0; int j = 0;
for (std::list<int>::const_iterator i = l.begin(), e = l.end(); i != e; ++i, ++j) for (std::list<int>::const_iterator i = l.begin(), e = l.end(); i != e; ++i, ++j)
assert(*i == j); assert(*i == j);
} }
#if TEST_STD_VER >= 11 #if TEST_STD_VER >= 11
{ {
int a[] = {0, 1, 2, 3}; int a[] = {0, 1, 2, 3};
std::list<int, min_allocator<int>> l(input_iterator<const int*>(a), std::list<int, min_allocator<int>> l(cpp17_input_iterator<const int*>(a),
input_iterator<const int*>(a + sizeof(a)/sizeof(a[0]))); cpp17_input_iterator<const int*>(a + sizeof(a)/sizeof(a[0])));
assert(l.size() == sizeof(a)/sizeof(a[0])); assert(l.size() == sizeof(a)/sizeof(a[0]));
assert(std::distance(l.begin(), l.end()) == sizeof(a)/sizeof(a[0])); assert(std::distance(l.begin(), l.end()) == sizeof(a)/sizeof(a[0]));
int j = 0; int j = 0;
for (std::list<int, min_allocator<int>>::const_iterator i = l.begin(), e = l.end(); i != e; ++i, ++j) for (std::list<int, min_allocator<int>>::const_iterator i = l.begin(), e = l.end(); i != e; ++i, ++j)
assert(*i == j); assert(*i == j);
} }
{ {
int a[] = {0, 1, 2, 3}; int a[] = {0, 1, 2, 3};
std::list<int, min_allocator<int>> l(input_iterator<const int*>(a), std::list<int, min_allocator<int>> l(cpp17_input_iterator<const int*>(a),
input_iterator<const int*>(a + sizeof(a)/sizeof(a[0])), cpp17_input_iterator<const int*>(a + sizeof(a)/sizeof(a[0])),
min_allocator<int>()); min_allocator<int>());
assert(l.size() == sizeof(a)/sizeof(a[0])); assert(l.size() == sizeof(a)/sizeof(a[0]));
assert(std::distance(l.begin(), l.end()) == sizeof(a)/sizeof(a[0])); assert(std::distance(l.begin(), l.end()) == sizeof(a)/sizeof(a[0]));
int j = 0; int j = 0;
for (std::list<int, min_allocator<int>>::const_iterator i = l.begin(), e = l.end(); i != e; ++i, ++j) for (std::list<int, min_allocator<int>>::const_iterator i = l.begin(), e = l.end(); i != e; ++i, ++j)
assert(*i == j); assert(*i == j);
} }
#endif #endif
Show All 20 Lines using It = random_access_iterator<int*>;
++I; ++I;
assert(I->value == 101); assert(I->value == 101);
++I; ++I;
assert(I->value == 42); assert(I->value == 42);
} }
} }
{ {
using T = EmplaceConstructible<int>; using T = EmplaceConstructible<int>;
using It = input_iterator<int*>; using It = cpp17_input_iterator<int*>;
{ {
std::list<T> v(It(arr1), It(std::end(arr1))); std::list<T> v(It(arr1), It(std::end(arr1)));
auto I = v.begin(); auto I = v.begin();
assert(I->value == 42); assert(I->value == 42);
} }
{ {
std::list<T> v(It(arr2), It(std::end(arr2))); std::list<T> v(It(arr2), It(std::end(arr2)));
auto I = v.begin(); auto I = v.begin();
Show All 31 Lines std::allocator<T> a;
++I; ++I;
assert(I->value == 101); assert(I->value == 101);
++I; ++I;
assert(I->value == 42); assert(I->value == 42);
} }
} }
{ {
using T = EmplaceConstructible<int>; using T = EmplaceConstructible<int>;
using It = input_iterator<int*>; using It = cpp17_input_iterator<int*>;
std::allocator<T> a; std::allocator<T> a;
{ {
std::list<T> v(It(arr1), It(std::end(arr1)), a); std::list<T> v(It(arr1), It(std::end(arr1)), a);
auto I = v.begin(); auto I = v.begin();
assert(I->value == 42); assert(I->value == 42);
} }
{ {
std::list<T> v(It(arr2), It(std::end(arr2)), a); std::list<T> v(It(arr2), It(std::end(arr2)), a);
Show All 23 Lines int arr2[] = {1, 101, 42};
} }
{ {
ExpectConstructGuard<int&> G(3); ExpectConstructGuard<int&> G(3);
C v(It(arr2), It(std::end(arr2))); C v(It(arr2), It(std::end(arr2)));
} }
} }
{ {
using C = TCT::list<>; using C = TCT::list<>;
using It = input_iterator<int*>; using It = cpp17_input_iterator<int*>;
{ {
ExpectConstructGuard<int&> G(1); ExpectConstructGuard<int&> G(1);
C v(It(arr1), It(std::end(arr1))); C v(It(arr1), It(std::end(arr1)));
} }
{ {
ExpectConstructGuard<int&> G(3); ExpectConstructGuard<int&> G(3);
C v(It(arr2), It(std::end(arr2))); C v(It(arr2), It(std::end(arr2)));
} }
Show All 16 Lines int arr2[] = {1, 101, 42};
} }
{ {
ExpectConstructGuard<int&> G(3); ExpectConstructGuard<int&> G(3);
C v(It(arr2), It(std::end(arr2)), a); C v(It(arr2), It(std::end(arr2)), a);
} }
} }
{ {
using C = TCT::list<>; using C = TCT::list<>;
using It = input_iterator<int*>; using It = cpp17_input_iterator<int*>;
using Alloc = typename C::allocator_type; using Alloc = typename C::allocator_type;
Alloc a; Alloc a;
{ {
ExpectConstructGuard<int&> G(1); ExpectConstructGuard<int&> G(1);
C v(It(arr1), It(std::end(arr1)), a); C v(It(arr1), It(std::end(arr1)), a);
} }
{ {
ExpectConstructGuard<int&> G(3); ExpectConstructGuard<int&> G(3);
Show All 17 Lines

libcxx/test/std/containers/sequences/vector.bool/construct_iter_iter.pass.cpp

Show All 28 Linestest(Iterator first, Iterator last)
for (typename C::const_iterator i = c.cbegin(), e = c.cend(); i != e; ++i, ++first) for (typename C::const_iterator i = c.cbegin(), e = c.cend(); i != e; ++i, ++first)
assert(*i == *first); assert(*i == *first);
} }
int main(int, char**) int main(int, char**)
{ {
bool a[] = {0, 1, 0, 0, 1, 1, 1, 0, 0, 1, 0, 0, 0, 1, 1, 0, 1, 0}; bool a[] = {0, 1, 0, 0, 1, 1, 1, 0, 0, 1, 0, 0, 0, 1, 1, 0, 1, 0};
bool* an = a + sizeof(a)/sizeof(a[0]); bool* an = a + sizeof(a)/sizeof(a[0]);
test<std::vector<bool> >(input_iterator<const bool*>(a), input_iterator<const bool*>(an)); test<std::vector<bool> >(cpp17_input_iterator<const bool*>(a), cpp17_input_iterator<const bool*>(an));
test<std::vector<bool> >(forward_iterator<const bool*>(a), forward_iterator<const bool*>(an)); test<std::vector<bool> >(forward_iterator<const bool*>(a), forward_iterator<const bool*>(an));
test<std::vector<bool> >(bidirectional_iterator<const bool*>(a), bidirectional_iterator<const bool*>(an)); test<std::vector<bool> >(bidirectional_iterator<const bool*>(a), bidirectional_iterator<const bool*>(an));
test<std::vector<bool> >(random_access_iterator<const bool*>(a), random_access_iterator<const bool*>(an)); test<std::vector<bool> >(random_access_iterator<const bool*>(a), random_access_iterator<const bool*>(an));
test<std::vector<bool> >(a, an); test<std::vector<bool> >(a, an);
#if TEST_STD_VER >= 11 #if TEST_STD_VER >= 11
test<std::vector<bool, min_allocator<bool>> >(input_iterator<const bool*>(a), input_iterator<const bool*>(an)); test<std::vector<bool, min_allocator<bool>> >(cpp17_input_iterator<const bool*>(a), cpp17_input_iterator<const bool*>(an));
test<std::vector<bool, min_allocator<bool>> >(forward_iterator<const bool*>(a), forward_iterator<const bool*>(an)); test<std::vector<bool, min_allocator<bool>> >(forward_iterator<const bool*>(a), forward_iterator<const bool*>(an));
test<std::vector<bool, min_allocator<bool>> >(bidirectional_iterator<const bool*>(a), bidirectional_iterator<const bool*>(an)); test<std::vector<bool, min_allocator<bool>> >(bidirectional_iterator<const bool*>(a), bidirectional_iterator<const bool*>(an));
test<std::vector<bool, min_allocator<bool>> >(random_access_iterator<const bool*>(a), random_access_iterator<const bool*>(an)); test<std::vector<bool, min_allocator<bool>> >(random_access_iterator<const bool*>(a), random_access_iterator<const bool*>(an));
test<std::vector<bool, min_allocator<bool>> >(a, an); test<std::vector<bool, min_allocator<bool>> >(a, an);
#endif #endif
return 0; return 0;
} }

libcxx/test/std/containers/sequences/vector.bool/construct_iter_iter_alloc.pass.cpp

Show All 31 Lines
} }
int main(int, char**) int main(int, char**)
{ {
bool a[] = {0, 1, 0, 0, 1, 1, 1, 0, 0, 1, 0, 0, 0, 1, 1, 0, 1, 0}; bool a[] = {0, 1, 0, 0, 1, 1, 1, 0, 0, 1, 0, 0, 0, 1, 1, 0, 1, 0};
bool* an = a + sizeof(a)/sizeof(a[0]); bool* an = a + sizeof(a)/sizeof(a[0]);
{ {
std::allocator<bool> alloc; std::allocator<bool> alloc;
test<std::vector<bool> >(input_iterator<const bool*>(a), input_iterator<const bool*>(an), alloc); test<std::vector<bool> >(cpp17_input_iterator<const bool*>(a), cpp17_input_iterator<const bool*>(an), alloc);
test<std::vector<bool> >(forward_iterator<const bool*>(a), forward_iterator<const bool*>(an), alloc); test<std::vector<bool> >(forward_iterator<const bool*>(a), forward_iterator<const bool*>(an), alloc);
test<std::vector<bool> >(bidirectional_iterator<const bool*>(a), bidirectional_iterator<const bool*>(an), alloc); test<std::vector<bool> >(bidirectional_iterator<const bool*>(a), bidirectional_iterator<const bool*>(an), alloc);
test<std::vector<bool> >(random_access_iterator<const bool*>(a), random_access_iterator<const bool*>(an), alloc); test<std::vector<bool> >(random_access_iterator<const bool*>(a), random_access_iterator<const bool*>(an), alloc);
test<std::vector<bool> >(a, an, alloc); test<std::vector<bool> >(a, an, alloc);
} }
#if TEST_STD_VER >= 11 #if TEST_STD_VER >= 11
{ {
min_allocator<bool> alloc; min_allocator<bool> alloc;
test<std::vector<bool, min_allocator<bool>> >(input_iterator<const bool*>(a), input_iterator<const bool*>(an), alloc); test<std::vector<bool, min_allocator<bool>> >(cpp17_input_iterator<const bool*>(a), cpp17_input_iterator<const bool*>(an), alloc);
test<std::vector<bool, min_allocator<bool>> >(forward_iterator<const bool*>(a), forward_iterator<const bool*>(an), alloc); test<std::vector<bool, min_allocator<bool>> >(forward_iterator<const bool*>(a), forward_iterator<const bool*>(an), alloc);
test<std::vector<bool, min_allocator<bool>> >(bidirectional_iterator<const bool*>(a), bidirectional_iterator<const bool*>(an), alloc); test<std::vector<bool, min_allocator<bool>> >(bidirectional_iterator<const bool*>(a), bidirectional_iterator<const bool*>(an), alloc);
test<std::vector<bool, min_allocator<bool>> >(random_access_iterator<const bool*>(a), random_access_iterator<const bool*>(an), alloc); test<std::vector<bool, min_allocator<bool>> >(random_access_iterator<const bool*>(a), random_access_iterator<const bool*>(an), alloc);
test<std::vector<bool, min_allocator<bool>> >(a, an, alloc); test<std::vector<bool, min_allocator<bool>> >(a, an, alloc);
} }
#endif #endif
return 0; return 0;
} }

libcxx/test/std/containers/sequences/vector.bool/insert_iter_iter_iter.pass.cpp

Show All 20 Lines
#include "min_allocator.h" #include "min_allocator.h"
int main(int, char**) int main(int, char**)
{ {
{ {
std::vector<bool> v(100); std::vector<bool> v(100);
bool a[] = {1, 0, 0, 1, 1}; bool a[] = {1, 0, 0, 1, 1};
const unsigned N = sizeof(a)/sizeof(a[0]); const unsigned N = sizeof(a)/sizeof(a[0]);
std::vector<bool>::iterator i = v.insert(v.cbegin() + 10, input_iterator<const bool*>(a), std::vector<bool>::iterator i = v.insert(v.cbegin() + 10, cpp17_input_iterator<const bool*>(a),
input_iterator<const bool*>(a+N)); cpp17_input_iterator<const bool*>(a+N));
assert(v.size() == 100 + N); assert(v.size() == 100 + N);
assert(i == v.begin() + 10); assert(i == v.begin() + 10);
std::size_t j; std::size_t j;
for (j = 0; j < 10; ++j) for (j = 0; j < 10; ++j)
assert(v[j] == 0); assert(v[j] == 0);
for (std::size_t k = 0; k < N; ++j, ++k) for (std::size_t k = 0; k < N; ++j, ++k)
assert(v[j] == a[k]); assert(v[j] == a[k]);
for (; j < v.size(); ++j) for (; j < v.size(); ++j)
▲ Show 20 Lines • Show All 52 Lines • ▼ Show 20 Linesint main(int, char**)
for (; j < v.size(); ++j) for (; j < v.size(); ++j)
assert(v[j] == 0); assert(v[j] == 0);
} }
#if TEST_STD_VER >= 11 #if TEST_STD_VER >= 11
{ {
std::vector<bool, min_allocator<bool>> v(100); std::vector<bool, min_allocator<bool>> v(100);
bool a[] = {1, 0, 0, 1, 1}; bool a[] = {1, 0, 0, 1, 1};
const unsigned N = sizeof(a)/sizeof(a[0]); const unsigned N = sizeof(a)/sizeof(a[0]);
std::vector<bool, min_allocator<bool>>::iterator i = v.insert(v.cbegin() + 10, input_iterator<const bool*>(a), std::vector<bool, min_allocator<bool>>::iterator i = v.insert(v.cbegin() + 10, cpp17_input_iterator<const bool*>(a),
input_iterator<const bool*>(a+N)); cpp17_input_iterator<const bool*>(a+N));
assert(v.size() == 100 + N); assert(v.size() == 100 + N);
assert(i == v.begin() + 10); assert(i == v.begin() + 10);
std::size_t j; std::size_t j;
for (j = 0; j < 10; ++j) for (j = 0; j < 10; ++j)
assert(v[j] == 0); assert(v[j] == 0);
for (std::size_t k = 0; k < N; ++j, ++k) for (std::size_t k = 0; k < N; ++j, ++k)
assert(v[j] == a[k]); assert(v[j] == a[k]);
for (; j < v.size(); ++j) for (; j < v.size(); ++j)
Show All 22 Lines

libcxx/test/std/containers/sequences/vector/vector.cons/assign_iter_iter.pass.cpp

Show All 39 Lines using It = forward_iterator<int*>;
v.assign(It(arr2), It(std::end(arr2))); v.assign(It(arr2), It(std::end(arr2)));
assert(v[0].value == 1); assert(v[0].value == 1);
assert(v[1].value == 101); assert(v[1].value == 101);
assert(v[2].value == 42); assert(v[2].value == 42);
} }
} }
{ {
using T = EmplaceConstructibleMoveableAndAssignable<int>; using T = EmplaceConstructibleMoveableAndAssignable<int>;
using It = input_iterator<int*>; using It = cpp17_input_iterator<int*>;
{ {
std::vector<T> v; std::vector<T> v;
v.assign(It(arr1), It(std::end(arr1))); v.assign(It(arr1), It(std::end(arr1)));
assert(v[0].copied == 0); assert(v[0].copied == 0);
assert(v[0].value == 42); assert(v[0].value == 42);
} }
{ {
std::vector<T> v; std::vector<T> v;
Show All 20 Lines

libcxx/test/std/containers/sequences/vector/vector.cons/construct_iter_iter.pass.cpp

Show All 32 Linesvoid test(Iterator first, Iterator last) {
for (typename C::const_iterator i = c.cbegin(), e = c.cend(); i != e; for (typename C::const_iterator i = c.cbegin(), e = c.cend(); i != e;
++i, ++first) ++i, ++first)
assert(*i == *first); assert(*i == *first);
} }
static void basic_test_cases() { static void basic_test_cases() {
int a[] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 8, 7, 6, 5, 4, 3, 1, 0}; int a[] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 8, 7, 6, 5, 4, 3, 1, 0};
int* an = a + sizeof(a) / sizeof(a[0]); int* an = a + sizeof(a) / sizeof(a[0]);
test<std::vector<int> >(input_iterator<const int*>(a), test<std::vector<int> >(cpp17_input_iterator<const int*>(a),
input_iterator<const int*>(an)); cpp17_input_iterator<const int*>(an));
test<std::vector<int> >(forward_iterator<const int*>(a), test<std::vector<int> >(forward_iterator<const int*>(a),
forward_iterator<const int*>(an)); forward_iterator<const int*>(an));
test<std::vector<int> >(bidirectional_iterator<const int*>(a), test<std::vector<int> >(bidirectional_iterator<const int*>(a),
bidirectional_iterator<const int*>(an)); bidirectional_iterator<const int*>(an));
test<std::vector<int> >(random_access_iterator<const int*>(a), test<std::vector<int> >(random_access_iterator<const int*>(a),
random_access_iterator<const int*>(an)); random_access_iterator<const int*>(an));
test<std::vector<int> >(a, an); test<std::vector<int> >(a, an);
test<std::vector<int, limited_allocator<int, 63> > >( test<std::vector<int, limited_allocator<int, 63> > >(
input_iterator<const int*>(a), input_iterator<const int*>(an)); cpp17_input_iterator<const int*>(a), cpp17_input_iterator<const int*>(an));
// Add 1 for implementations that dynamically allocate a container proxy. // Add 1 for implementations that dynamically allocate a container proxy.
test<std::vector<int, limited_allocator<int, 18 + 1> > >( test<std::vector<int, limited_allocator<int, 18 + 1> > >(
forward_iterator<const int*>(a), forward_iterator<const int*>(an)); forward_iterator<const int*>(a), forward_iterator<const int*>(an));
test<std::vector<int, limited_allocator<int, 18 + 1> > >( test<std::vector<int, limited_allocator<int, 18 + 1> > >(
bidirectional_iterator<const int*>(a), bidirectional_iterator<const int*>(a),
bidirectional_iterator<const int*>(an)); bidirectional_iterator<const int*>(an));
test<std::vector<int, limited_allocator<int, 18 + 1> > >( test<std::vector<int, limited_allocator<int, 18 + 1> > >(
random_access_iterator<const int*>(a), random_access_iterator<const int*>(a),
random_access_iterator<const int*>(an)); random_access_iterator<const int*>(an));
test<std::vector<int, limited_allocator<int, 18 + 1> > >(a, an); test<std::vector<int, limited_allocator<int, 18 + 1> > >(a, an);
#if TEST_STD_VER >= 11 #if TEST_STD_VER >= 11
test<std::vector<int, min_allocator<int> > >(input_iterator<const int*>(a), test<std::vector<int, min_allocator<int> > >(cpp17_input_iterator<const int*>(a),
input_iterator<const int*>(an)); cpp17_input_iterator<const int*>(an));
test<std::vector<int, min_allocator<int> > >( test<std::vector<int, min_allocator<int> > >(
forward_iterator<const int*>(a), forward_iterator<const int*>(an)); forward_iterator<const int*>(a), forward_iterator<const int*>(an));
test<std::vector<int, min_allocator<int> > >( test<std::vector<int, min_allocator<int> > >(
bidirectional_iterator<const int*>(a), bidirectional_iterator<const int*>(a),
bidirectional_iterator<const int*>(an)); bidirectional_iterator<const int*>(an));
test<std::vector<int, min_allocator<int> > >( test<std::vector<int, min_allocator<int> > >(
random_access_iterator<const int*>(a), random_access_iterator<const int*>(a),
random_access_iterator<const int*>(an)); random_access_iterator<const int*>(an));
Show All 16 Lines using It = forward_iterator<int*>;
std::vector<T> v(It(arr2), It(std::end(arr2))); std::vector<T> v(It(arr2), It(std::end(arr2)));
assert(v[0].value == 1); assert(v[0].value == 1);
assert(v[1].value == 101); assert(v[1].value == 101);
assert(v[2].value == 42); assert(v[2].value == 42);
} }
} }
{ {
using T = EmplaceConstructibleAndMoveInsertable<int>; using T = EmplaceConstructibleAndMoveInsertable<int>;
using It = input_iterator<int*>; using It = cpp17_input_iterator<int*>;
{ {
std::vector<T> v(It(arr1), It(std::end(arr1))); std::vector<T> v(It(arr1), It(std::end(arr1)));
assert(v[0].copied == 0); assert(v[0].copied == 0);
assert(v[0].value == 42); assert(v[0].value == 42);
} }
{ {
std::vector<T> v(It(arr2), It(std::end(arr2))); std::vector<T> v(It(arr2), It(std::end(arr2)));
//assert(v[0].copied == 0); //assert(v[0].copied == 0);
Show All 20 Lines int arr2[] = {1, 101, 42};
} }
{ {
ExpectConstructGuard<int&> G(3); ExpectConstructGuard<int&> G(3);
C v(It(arr2), It(std::end(arr2))); C v(It(arr2), It(std::end(arr2)));
} }
} }
{ {
using C = TCT::vector<>; using C = TCT::vector<>;
using It = input_iterator<int*>; using It = cpp17_input_iterator<int*>;
{ {
ExpectConstructGuard<int&> G(1); ExpectConstructGuard<int&> G(1);
C v(It(arr1), It(std::end(arr1))); C v(It(arr1), It(std::end(arr1)));
} }
{ {
//ExpectConstructGuard<int&> G(3); //ExpectConstructGuard<int&> G(3);
//C v(It(arr2), It(std::end(arr2)), a); //C v(It(arr2), It(std::end(arr2)), a);
} }
▲ Show 20 Lines • Show All 52 Lines • Show Last 20 Lines

libcxx/test/std/containers/sequences/vector/vector.cons/construct_iter_iter_alloc.pass.cpp

Show First 20 Lines • Show All 48 Lines • ▼ Show 20 Lines
#endif #endif
void basic_tests() { void basic_tests() {
{ {
int a[] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 8, 7, 6, 5, 4, 3, 1, 0}; int a[] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 8, 7, 6, 5, 4, 3, 1, 0};
int* an = a + sizeof(a) / sizeof(a[0]); int* an = a + sizeof(a) / sizeof(a[0]);
std::allocator<int> alloc; std::allocator<int> alloc;
test<std::vector<int> >(input_iterator<const int*>(a), test<std::vector<int> >(cpp17_input_iterator<const int*>(a),
input_iterator<const int*>(an), alloc); cpp17_input_iterator<const int*>(an), alloc);
test<std::vector<int> >(forward_iterator<const int*>(a), test<std::vector<int> >(forward_iterator<const int*>(a),
forward_iterator<const int*>(an), alloc); forward_iterator<const int*>(an), alloc);
test<std::vector<int> >(bidirectional_iterator<const int*>(a), test<std::vector<int> >(bidirectional_iterator<const int*>(a),
bidirectional_iterator<const int*>(an), alloc); bidirectional_iterator<const int*>(an), alloc);
test<std::vector<int> >(random_access_iterator<const int*>(a), test<std::vector<int> >(random_access_iterator<const int*>(a),
random_access_iterator<const int*>(an), alloc); random_access_iterator<const int*>(an), alloc);
test<std::vector<int> >(a, an, alloc); test<std::vector<int> >(a, an, alloc);
} }
#if TEST_STD_VER >= 11 #if TEST_STD_VER >= 11
{ {
int a[] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 8, 7, 6, 5, 4, 3, 1, 0}; int a[] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 8, 7, 6, 5, 4, 3, 1, 0};
int* an = a + sizeof(a) / sizeof(a[0]); int* an = a + sizeof(a) / sizeof(a[0]);
min_allocator<int> alloc; min_allocator<int> alloc;
test<std::vector<int, min_allocator<int> > >( test<std::vector<int, min_allocator<int> > >(
input_iterator<const int*>(a), input_iterator<const int*>(an), alloc); cpp17_input_iterator<const int*>(a), cpp17_input_iterator<const int*>(an), alloc);
test<std::vector<int, min_allocator<int> > >( test<std::vector<int, min_allocator<int> > >(
forward_iterator<const int*>(a), forward_iterator<const int*>(an), forward_iterator<const int*>(a), forward_iterator<const int*>(an),
alloc); alloc);
test<std::vector<int, min_allocator<int> > >( test<std::vector<int, min_allocator<int> > >(
bidirectional_iterator<const int*>(a), bidirectional_iterator<const int*>(a),
bidirectional_iterator<const int*>(an), alloc); bidirectional_iterator<const int*>(an), alloc);
test<std::vector<int, min_allocator<int> > >( test<std::vector<int, min_allocator<int> > >(
random_access_iterator<const int*>(a), random_access_iterator<const int*>(a),
Show All 21 Lines Alloc a;
std::vector<T> v(It(arr2), It(std::end(arr2)), a); std::vector<T> v(It(arr2), It(std::end(arr2)), a);
assert(v[0].value == 1); assert(v[0].value == 1);
assert(v[1].value == 101); assert(v[1].value == 101);
assert(v[2].value == 42); assert(v[2].value == 42);
} }
} }
{ {
using T = EmplaceConstructibleAndMoveInsertable<int>; using T = EmplaceConstructibleAndMoveInsertable<int>;
using It = input_iterator<int*>; using It = cpp17_input_iterator<int*>;
using Alloc = std::allocator<T>; using Alloc = std::allocator<T>;
Alloc a; Alloc a;
{ {
std::vector<T> v(It(arr1), It(std::end(arr1)), a); std::vector<T> v(It(arr1), It(std::end(arr1)), a);
assert(v[0].copied == 0); assert(v[0].copied == 0);
assert(v[0].value == 42); assert(v[0].value == 42);
} }
{ {
Show All 22 Lines int arr2[] = {1, 101, 42};
} }
{ {
ExpectConstructGuard<int&> G(3); ExpectConstructGuard<int&> G(3);
C v(It(arr2), It(std::end(arr2)), a); C v(It(arr2), It(std::end(arr2)), a);
} }
} }
{ {
using C = TCT::vector<>; using C = TCT::vector<>;
using It = input_iterator<int*>; using It = cpp17_input_iterator<int*>;
using Alloc = typename C::allocator_type; using Alloc = typename C::allocator_type;
Alloc a; Alloc a;
{ {
ExpectConstructGuard<int&> G(1); ExpectConstructGuard<int&> G(1);
C v(It(arr1), It(std::end(arr1)), a); C v(It(arr1), It(std::end(arr1)), a);
} }
{ {
//ExpectConstructGuard<int&> G(3); //ExpectConstructGuard<int&> G(3);
Show All 13 Lines

libcxx/test/std/containers/sequences/vector/vector.modifiers/insert_iter_iter_iter.pass.cpp

Show All 27 Lines
int main(int, char**) int main(int, char**)
{ {
{ {
typedef std::vector<int> V; typedef std::vector<int> V;
V v(100); V v(100);
int a[] = {1, 2, 3, 4, 5}; int a[] = {1, 2, 3, 4, 5};
const int N = sizeof(a)/sizeof(a[0]); const int N = sizeof(a)/sizeof(a[0]);
V::iterator i = v.insert(v.cbegin() + 10, input_iterator<const int*>(a), V::iterator i = v.insert(v.cbegin() + 10, cpp17_input_iterator<const int*>(a),
input_iterator<const int*>(a+N)); cpp17_input_iterator<const int*>(a+N));
assert(v.size() == 100 + N); assert(v.size() == 100 + N);
assert(is_contiguous_container_asan_correct(v)); assert(is_contiguous_container_asan_correct(v));
assert(i == v.begin() + 10); assert(i == v.begin() + 10);
int j; int j;
for (j = 0; j < 10; ++j) for (j = 0; j < 10; ++j)
assert(v[j] == 0); assert(v[j] == 0);
for (std::size_t k = 0; k < N; ++j, ++k) for (std::size_t k = 0; k < N; ++j, ++k)
assert(v[j] == a[k]); assert(v[j] == a[k]);
▲ Show 20 Lines • Show All 56 Lines • ▼ Show 20 Linesint main(int, char**)
for (; j < v.size(); ++j) for (; j < v.size(); ++j)
assert(v[j] == 0); assert(v[j] == 0);
} }
{ {
typedef std::vector<int, limited_allocator<int, 308> > V; typedef std::vector<int, limited_allocator<int, 308> > V;
V v(100); V v(100);
int a[] = {1, 2, 3, 4, 5}; int a[] = {1, 2, 3, 4, 5};
const int N = sizeof(a)/sizeof(a[0]); const int N = sizeof(a)/sizeof(a[0]);
V::iterator i = v.insert(v.cbegin() + 10, input_iterator<const int*>(a), V::iterator i = v.insert(v.cbegin() + 10, cpp17_input_iterator<const int*>(a),
input_iterator<const int*>(a+N)); cpp17_input_iterator<const int*>(a+N));
assert(v.size() == 100 + N); assert(v.size() == 100 + N);
assert(is_contiguous_container_asan_correct(v)); assert(is_contiguous_container_asan_correct(v));
assert(i == v.begin() + 10); assert(i == v.begin() + 10);
int j; int j;
for (j = 0; j < 10; ++j) for (j = 0; j < 10; ++j)
assert(v[j] == 0); assert(v[j] == 0);
for (std::size_t k = 0; k < N; ++j, ++k) for (std::size_t k = 0; k < N; ++j, ++k)
assert(v[j] == a[k]); assert(v[j] == a[k]);
Show All 19 Linesint main(int, char**)
assert(v[j] == 0); assert(v[j] == 0);
} }
#if TEST_STD_VER >= 11 #if TEST_STD_VER >= 11
{ {
typedef std::vector<int, min_allocator<int> > V; typedef std::vector<int, min_allocator<int> > V;
V v(100); V v(100);
int a[] = {1, 2, 3, 4, 5}; int a[] = {1, 2, 3, 4, 5};
const int N = sizeof(a)/sizeof(a[0]); const int N = sizeof(a)/sizeof(a[0]);
V::iterator i = v.insert(v.cbegin() + 10, input_iterator<const int*>(a), V::iterator i = v.insert(v.cbegin() + 10, cpp17_input_iterator<const int*>(a),
input_iterator<const int*>(a+N)); cpp17_input_iterator<const int*>(a+N));
assert(v.size() == 100 + N); assert(v.size() == 100 + N);
assert(is_contiguous_container_asan_correct(v)); assert(is_contiguous_container_asan_correct(v));
assert(i == v.begin() + 10); assert(i == v.begin() + 10);
int j; int j;
for (j = 0; j < 10; ++j) for (j = 0; j < 10; ++j)
assert(v[j] == 0); assert(v[j] == 0);
for (std::size_t k = 0; k < N; ++j, ++k) for (std::size_t k = 0; k < N; ++j, ++k)
assert(v[j] == a[k]); assert(v[j] == a[k]);
Show All 17 Lines#if TEST_STD_VER >= 11
assert(v[j] == a[k]); assert(v[j] == a[k]);
for (; j < 105; ++j) for (; j < 105; ++j)
assert(v[j] == 0); assert(v[j] == 0);
} }
#endif #endif
{ {
std::vector<adl::S> s; std::vector<adl::S> s;
s.insert(s.end(), input_iterator<adl::S*>(), input_iterator<adl::S*>()); s.insert(s.end(), cpp17_input_iterator<adl::S*>(), cpp17_input_iterator<adl::S*>());
} }
return 0; return 0;
} }

libcxx/test/std/containers/unord/unord.map/unord.map.cnstr/range.pass.cpp

Show First 20 Lines • Show All 42 Lines • ▼ Show 20 Linesint main(int, char**)
{ {
P(1, "one"), P(1, "one"),
P(2, "two"), P(2, "two"),
P(3, "three"), P(3, "three"),
P(4, "four"), P(4, "four"),
P(1, "four"), P(1, "four"),
P(2, "four"), P(2, "four"),
}; };
C c(input_iterator<P*>(a), input_iterator<P*>(a + sizeof(a)/sizeof(a[0]))); C c(cpp17_input_iterator<P*>(a), cpp17_input_iterator<P*>(a + sizeof(a)/sizeof(a[0])));
assert(c.bucket_count() >= 5); assert(c.bucket_count() >= 5);
assert(c.size() == 4); assert(c.size() == 4);
assert(c.at(1) == "one"); assert(c.at(1) == "one");
assert(c.at(2) == "two"); assert(c.at(2) == "two");
assert(c.at(3) == "three"); assert(c.at(3) == "three");
assert(c.at(4) == "four"); assert(c.at(4) == "four");
assert(c.hash_function() == test_hash<std::hash<int> >()); assert(c.hash_function() == test_hash<std::hash<int> >());
assert(c.key_eq() == test_compare<std::equal_to<int> >()); assert(c.key_eq() == test_compare<std::equal_to<int> >());
Show All 17 Lines#if TEST_STD_VER >= 11
{ {
P(1, "one"), P(1, "one"),
P(2, "two"), P(2, "two"),
P(3, "three"), P(3, "three"),
P(4, "four"), P(4, "four"),
P(1, "four"), P(1, "four"),
P(2, "four"), P(2, "four"),
}; };
C c(input_iterator<P*>(a), input_iterator<P*>(a + sizeof(a)/sizeof(a[0]))); C c(cpp17_input_iterator<P*>(a), cpp17_input_iterator<P*>(a + sizeof(a)/sizeof(a[0])));
assert(c.bucket_count() >= 5); assert(c.bucket_count() >= 5);
assert(c.size() == 4); assert(c.size() == 4);
assert(c.at(1) == "one"); assert(c.at(1) == "one");
assert(c.at(2) == "two"); assert(c.at(2) == "two");
assert(c.at(3) == "three"); assert(c.at(3) == "three");
assert(c.at(4) == "four"); assert(c.at(4) == "four");
assert(c.hash_function() == test_hash<std::hash<int> >()); assert(c.hash_function() == test_hash<std::hash<int> >());
assert(c.key_eq() == test_compare<std::equal_to<int> >()); assert(c.key_eq() == test_compare<std::equal_to<int> >());
Show All 17 Lines#if TEST_STD_VER > 11
{ {
P(1, "one"), P(1, "one"),
P(2, "two"), P(2, "two"),
P(3, "three"), P(3, "three"),
P(4, "four"), P(4, "four"),
P(1, "four"), P(1, "four"),
P(2, "four"), P(2, "four"),
}; };
C c(input_iterator<P*>(arr), input_iterator<P*>(arr + sizeof(arr)/sizeof(arr[0])), 14); C c(cpp17_input_iterator<P*>(arr), cpp17_input_iterator<P*>(arr + sizeof(arr)/sizeof(arr[0])), 14);
assert(c.bucket_count() >= 14); assert(c.bucket_count() >= 14);
assert(c.size() == 4); assert(c.size() == 4);
assert(c.at(1) == "one"); assert(c.at(1) == "one");
assert(c.at(2) == "two"); assert(c.at(2) == "two");
assert(c.at(3) == "three"); assert(c.at(3) == "three");
assert(c.at(4) == "four"); assert(c.at(4) == "four");
assert(c.hash_function() == HF()); assert(c.hash_function() == HF());
assert(c.key_eq() == Comp()); assert(c.key_eq() == Comp());
Show All 17 Lines#if TEST_STD_VER > 11
P(2, "two"), P(2, "two"),
P(3, "three"), P(3, "three"),
P(4, "four"), P(4, "four"),
P(1, "four"), P(1, "four"),
P(2, "four"), P(2, "four"),
}; };
HF hf(42); HF hf(42);
A a(43); A a(43);
C c(input_iterator<P*>(arr), input_iterator<P*>(arr + sizeof(arr)/sizeof(arr[0])), 14, hf, a); C c(cpp17_input_iterator<P*>(arr), cpp17_input_iterator<P*>(arr + sizeof(arr)/sizeof(arr[0])), 14, hf, a);
assert(c.bucket_count() >= 14); assert(c.bucket_count() >= 14);
assert(c.size() == 4); assert(c.size() == 4);
assert(c.at(1) == "one"); assert(c.at(1) == "one");
assert(c.at(2) == "two"); assert(c.at(2) == "two");
assert(c.at(3) == "three"); assert(c.at(3) == "three");
assert(c.at(4) == "four"); assert(c.at(4) == "four");
assert(c.hash_function() == hf); assert(c.hash_function() == hf);
assert(!(c.hash_function() == HF())); assert(!(c.hash_function() == HF()));
Show All 13 Lines

libcxx/test/std/containers/unord/unord.map/unord.map.cnstr/range_size.pass.cpp

Show First 20 Lines • Show All 42 Lines • ▼ Show 20 Linesint main(int, char**)
{ {
P(1, "one"), P(1, "one"),
P(2, "two"), P(2, "two"),
P(3, "three"), P(3, "three"),
P(4, "four"), P(4, "four"),
P(1, "four"), P(1, "four"),
P(2, "four"), P(2, "four"),
}; };
C c(input_iterator<P*>(a), input_iterator<P*>(a + sizeof(a)/sizeof(a[0])), C c(cpp17_input_iterator<P*>(a), cpp17_input_iterator<P*>(a + sizeof(a)/sizeof(a[0])),
10 10
); );
LIBCPP_ASSERT(c.bucket_count() == 11); LIBCPP_ASSERT(c.bucket_count() == 11);
assert(c.size() == 4); assert(c.size() == 4);
assert(c.at(1) == "one"); assert(c.at(1) == "one");
assert(c.at(2) == "two"); assert(c.at(2) == "two");
assert(c.at(3) == "three"); assert(c.at(3) == "three");
assert(c.at(4) == "four"); assert(c.at(4) == "four");
Show All 19 Lines#if TEST_STD_VER >= 11
{ {
P(1, "one"), P(1, "one"),
P(2, "two"), P(2, "two"),
P(3, "three"), P(3, "three"),
P(4, "four"), P(4, "four"),
P(1, "four"), P(1, "four"),
P(2, "four"), P(2, "four"),
}; };
C c(input_iterator<P*>(a), input_iterator<P*>(a + sizeof(a)/sizeof(a[0])), C c(cpp17_input_iterator<P*>(a), cpp17_input_iterator<P*>(a + sizeof(a)/sizeof(a[0])),
10 10
); );
LIBCPP_ASSERT(c.bucket_count() == 11); LIBCPP_ASSERT(c.bucket_count() == 11);
assert(c.size() == 4); assert(c.size() == 4);
assert(c.at(1) == "one"); assert(c.at(1) == "one");
assert(c.at(2) == "two"); assert(c.at(2) == "two");
assert(c.at(3) == "three"); assert(c.at(3) == "three");
assert(c.at(4) == "four"); assert(c.at(4) == "four");
Show All 14 Lines

libcxx/test/std/containers/unord/unord.map/unord.map.cnstr/range_size_hash.pass.cpp

Show First 20 Lines • Show All 43 Lines • ▼ Show 20 Linesint main(int, char**)
{ {
P(1, "one"), P(1, "one"),
P(2, "two"), P(2, "two"),
P(3, "three"), P(3, "three"),
P(4, "four"), P(4, "four"),
P(1, "four"), P(1, "four"),
P(2, "four"), P(2, "four"),
}; };
C c(input_iterator<P*>(a), input_iterator<P*>(a + sizeof(a)/sizeof(a[0])), C c(cpp17_input_iterator<P*>(a), cpp17_input_iterator<P*>(a + sizeof(a)/sizeof(a[0])),
7, 7,
test_hash<std::hash<int> >(8) test_hash<std::hash<int> >(8)
); );
LIBCPP_ASSERT(c.bucket_count() == 7); LIBCPP_ASSERT(c.bucket_count() == 7);
assert(c.size() == 4); assert(c.size() == 4);
assert(c.at(1) == "one"); assert(c.at(1) == "one");
assert(c.at(2) == "two"); assert(c.at(2) == "two");
assert(c.at(3) == "three"); assert(c.at(3) == "three");
Show All 20 Lines#if TEST_STD_VER >= 11
{ {
P(1, "one"), P(1, "one"),
P(2, "two"), P(2, "two"),
P(3, "three"), P(3, "three"),
P(4, "four"), P(4, "four"),
P(1, "four"), P(1, "four"),
P(2, "four"), P(2, "four"),
}; };
C c(input_iterator<P*>(a), input_iterator<P*>(a + sizeof(a)/sizeof(a[0])), C c(cpp17_input_iterator<P*>(a), cpp17_input_iterator<P*>(a + sizeof(a)/sizeof(a[0])),
7, 7,
test_hash<std::hash<int> >(8) test_hash<std::hash<int> >(8)
); );
LIBCPP_ASSERT(c.bucket_count() == 7); LIBCPP_ASSERT(c.bucket_count() == 7);
assert(c.size() == 4); assert(c.size() == 4);
assert(c.at(1) == "one"); assert(c.at(1) == "one");
assert(c.at(2) == "two"); assert(c.at(2) == "two");
assert(c.at(3) == "three"); assert(c.at(3) == "three");
Show All 15 Lines

libcxx/test/std/containers/unord/unord.map/unord.map.cnstr/range_size_hash_equal.pass.cpp

Show First 20 Lines • Show All 43 Lines • ▼ Show 20 Linesint main(int, char**)
{ {
P(1, "one"), P(1, "one"),
P(2, "two"), P(2, "two"),
P(3, "three"), P(3, "three"),
P(4, "four"), P(4, "four"),
P(1, "four"), P(1, "four"),
P(2, "four"), P(2, "four"),
}; };
C c(input_iterator<P*>(a), input_iterator<P*>(a + sizeof(a)/sizeof(a[0])), C c(cpp17_input_iterator<P*>(a), cpp17_input_iterator<P*>(a + sizeof(a)/sizeof(a[0])),
7, 7,
test_hash<std::hash<int> >(8), test_hash<std::hash<int> >(8),
test_compare<std::equal_to<int> >(9) test_compare<std::equal_to<int> >(9)
); );
LIBCPP_ASSERT(c.bucket_count() == 7); LIBCPP_ASSERT(c.bucket_count() == 7);
assert(c.size() == 4); assert(c.size() == 4);
assert(c.at(1) == "one"); assert(c.at(1) == "one");
assert(c.at(2) == "two"); assert(c.at(2) == "two");
Show All 21 Lines#if TEST_STD_VER >= 11
{ {
P(1, "one"), P(1, "one"),
P(2, "two"), P(2, "two"),
P(3, "three"), P(3, "three"),
P(4, "four"), P(4, "four"),
P(1, "four"), P(1, "four"),
P(2, "four"), P(2, "four"),
}; };
C c(input_iterator<P*>(a), input_iterator<P*>(a + sizeof(a)/sizeof(a[0])), C c(cpp17_input_iterator<P*>(a), cpp17_input_iterator<P*>(a + sizeof(a)/sizeof(a[0])),
7, 7,
test_hash<std::hash<int> >(8), test_hash<std::hash<int> >(8),
test_compare<std::equal_to<int> >(9) test_compare<std::equal_to<int> >(9)
); );
LIBCPP_ASSERT(c.bucket_count() == 7); LIBCPP_ASSERT(c.bucket_count() == 7);
assert(c.size() == 4); assert(c.size() == 4);
assert(c.at(1) == "one"); assert(c.at(1) == "one");
assert(c.at(2) == "two"); assert(c.at(2) == "two");
Show All 16 Lines

libcxx/test/std/containers/unord/unord.map/unord.map.cnstr/range_size_hash_equal_allocator.pass.cpp

Show First 20 Lines • Show All 44 Lines • ▼ Show 20 Linesint main(int, char**)
{ {
P(1, "one"), P(1, "one"),
P(2, "two"), P(2, "two"),
P(3, "three"), P(3, "three"),
P(4, "four"), P(4, "four"),
P(1, "four"), P(1, "four"),
P(2, "four"), P(2, "four"),
}; };
C c(input_iterator<P*>(a), input_iterator<P*>(a + sizeof(a)/sizeof(a[0])), C c(cpp17_input_iterator<P*>(a), cpp17_input_iterator<P*>(a + sizeof(a)/sizeof(a[0])),
7, 7,
test_hash<std::hash<int> >(8), test_hash<std::hash<int> >(8),
test_compare<std::equal_to<int> >(9), test_compare<std::equal_to<int> >(9),
test_allocator<std::pair<const int, std::string> >(10) test_allocator<std::pair<const int, std::string> >(10)
); );
LIBCPP_ASSERT(c.bucket_count() == 7); LIBCPP_ASSERT(c.bucket_count() == 7);
assert(c.size() == 4); assert(c.size() == 4);
assert(c.at(1) == "one"); assert(c.at(1) == "one");
Show All 22 Lines#if TEST_STD_VER >= 11
{ {
P(1, "one"), P(1, "one"),
P(2, "two"), P(2, "two"),
P(3, "three"), P(3, "three"),
P(4, "four"), P(4, "four"),
P(1, "four"), P(1, "four"),
P(2, "four"), P(2, "four"),
}; };
C c(input_iterator<P*>(a), input_iterator<P*>(a + sizeof(a)/sizeof(a[0])), C c(cpp17_input_iterator<P*>(a), cpp17_input_iterator<P*>(a + sizeof(a)/sizeof(a[0])),
7, 7,
test_hash<std::hash<int> >(8), test_hash<std::hash<int> >(8),
test_compare<std::equal_to<int> >(9), test_compare<std::equal_to<int> >(9),
min_allocator<std::pair<const int, std::string> >() min_allocator<std::pair<const int, std::string> >()
); );
LIBCPP_ASSERT(c.bucket_count() == 7); LIBCPP_ASSERT(c.bucket_count() == 7);
assert(c.size() == 4); assert(c.size() == 4);
assert(c.at(1) == "one"); assert(c.at(1) == "one");
Show All 22 Lines#if TEST_STD_VER >= 11
{ {
P(1, "one"), P(1, "one"),
P(2, "two"), P(2, "two"),
P(3, "three"), P(3, "three"),
P(4, "four"), P(4, "four"),
P(1, "four"), P(1, "four"),
P(2, "four"), P(2, "four"),
}; };
C c(input_iterator<P*>(a), input_iterator<P*>(a + sizeof(a)/sizeof(a[0])), C c(cpp17_input_iterator<P*>(a), cpp17_input_iterator<P*>(a + sizeof(a)/sizeof(a[0])),
7, 7,
test_hash<std::hash<int> >(8), test_hash<std::hash<int> >(8),
test_compare<std::equal_to<int> >(9), test_compare<std::equal_to<int> >(9),
A{} A{}
); );
LIBCPP_ASSERT(c.bucket_count() == 7); LIBCPP_ASSERT(c.bucket_count() == 7);
assert(c.size() == 4); assert(c.size() == 4);
assert(c.at(1) == "one"); assert(c.at(1) == "one");
Show All 16 Lines

libcxx/test/std/containers/unord/unord.map/unord.map.modifiers/insert_range.pass.cpp

Show All 32 Linesint main(int, char**)
P(1, "one"), P(1, "one"),
P(2, "two"), P(2, "two"),
P(3, "three"), P(3, "three"),
P(4, "four"), P(4, "four"),
P(1, "four"), P(1, "four"),
P(2, "four"), P(2, "four"),
}; };
C c; C c;
c.insert(input_iterator<P*>(a), input_iterator<P*>(a + sizeof(a)/sizeof(a[0]))); c.insert(cpp17_input_iterator<P*>(a), cpp17_input_iterator<P*>(a + sizeof(a)/sizeof(a[0])));
assert(c.size() == 4); assert(c.size() == 4);
assert(c.at(1) == "one"); assert(c.at(1) == "one");
assert(c.at(2) == "two"); assert(c.at(2) == "two");
assert(c.at(3) == "three"); assert(c.at(3) == "three");
assert(c.at(4) == "four"); assert(c.at(4) == "four");
} }
#if TEST_STD_VER >= 11 #if TEST_STD_VER >= 11
{ {
typedef std::unordered_map<int, std::string, std::hash<int>, std::equal_to<int>, typedef std::unordered_map<int, std::string, std::hash<int>, std::equal_to<int>,
min_allocator<std::pair<const int, std::string>>> C; min_allocator<std::pair<const int, std::string>>> C;
typedef std::pair<int, std::string> P; typedef std::pair<int, std::string> P;
P a[] = P a[] =
{ {
P(1, "one"), P(1, "one"),
P(2, "two"), P(2, "two"),
P(3, "three"), P(3, "three"),
P(4, "four"), P(4, "four"),
P(1, "four"), P(1, "four"),
P(2, "four"), P(2, "four"),
}; };
C c; C c;
c.insert(input_iterator<P*>(a), input_iterator<P*>(a + sizeof(a)/sizeof(a[0]))); c.insert(cpp17_input_iterator<P*>(a), cpp17_input_iterator<P*>(a + sizeof(a)/sizeof(a[0])));
assert(c.size() == 4); assert(c.size() == 4);
assert(c.at(1) == "one"); assert(c.at(1) == "one");
assert(c.at(2) == "two"); assert(c.at(2) == "two");
assert(c.at(3) == "three"); assert(c.at(3) == "three");
assert(c.at(4) == "four"); assert(c.at(4) == "four");
} }
#endif #endif
return 0; return 0;
} }

libcxx/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/range.pass.cpp

Show First 20 Lines • Show All 44 Lines • ▼ Show 20 Linesint main(int, char**)
{ {
P(1, "one"), P(1, "one"),
P(2, "two"), P(2, "two"),
P(3, "three"), P(3, "three"),
P(4, "four"), P(4, "four"),
P(1, "four"), P(1, "four"),
P(2, "four"), P(2, "four"),
}; };
C c(input_iterator<P*>(a), input_iterator<P*>(a + sizeof(a)/sizeof(a[0]))); C c(cpp17_input_iterator<P*>(a), cpp17_input_iterator<P*>(a + sizeof(a)/sizeof(a[0])));
assert(c.bucket_count() >= 7); assert(c.bucket_count() >= 7);
assert(c.size() == 6); assert(c.size() == 6);
typedef std::pair<C::const_iterator, C::const_iterator> Eq; typedef std::pair<C::const_iterator, C::const_iterator> Eq;
Eq eq = c.equal_range(1); Eq eq = c.equal_range(1);
assert(std::distance(eq.first, eq.second) == 2); assert(std::distance(eq.first, eq.second) == 2);
std::multiset<std::string> s; std::multiset<std::string> s;
s.insert("one"); s.insert("one");
s.insert("four"); s.insert("four");
Show All 34 Lines#if TEST_STD_VER >= 11
{ {
P(1, "one"), P(1, "one"),
P(2, "two"), P(2, "two"),
P(3, "three"), P(3, "three"),
P(4, "four"), P(4, "four"),
P(1, "four"), P(1, "four"),
P(2, "four"), P(2, "four"),
}; };
C c(input_iterator<P*>(a), input_iterator<P*>(a + sizeof(a)/sizeof(a[0]))); C c(cpp17_input_iterator<P*>(a), cpp17_input_iterator<P*>(a + sizeof(a)/sizeof(a[0])));
assert(c.bucket_count() >= 7); assert(c.bucket_count() >= 7);
assert(c.size() == 6); assert(c.size() == 6);
typedef std::pair<C::const_iterator, C::const_iterator> Eq; typedef std::pair<C::const_iterator, C::const_iterator> Eq;
Eq eq = c.equal_range(1); Eq eq = c.equal_range(1);
assert(std::distance(eq.first, eq.second) == 2); assert(std::distance(eq.first, eq.second) == 2);
std::multiset<std::string> s; std::multiset<std::string> s;
s.insert("one"); s.insert("one");
s.insert("four"); s.insert("four");
Show All 35 Lines#if TEST_STD_VER > 11
P(1, "one"), P(1, "one"),
P(2, "two"), P(2, "two"),
P(3, "three"), P(3, "three"),
P(4, "four"), P(4, "four"),
P(1, "four"), P(1, "four"),
P(2, "four"), P(2, "four"),
}; };
A a(42); A a(42);
C c(input_iterator<P*>(arr), input_iterator<P*>(arr + sizeof(arr)/sizeof(arr[0])), 14, a); C c(cpp17_input_iterator<P*>(arr), cpp17_input_iterator<P*>(arr + sizeof(arr)/sizeof(arr[0])), 14, a);
assert(c.bucket_count() >= 14); assert(c.bucket_count() >= 14);
assert(c.size() == 6); assert(c.size() == 6);
typedef std::pair<C::const_iterator, C::const_iterator> Eq; typedef std::pair<C::const_iterator, C::const_iterator> Eq;
Eq eq = c.equal_range(1); Eq eq = c.equal_range(1);
assert(std::distance(eq.first, eq.second) == 2); assert(std::distance(eq.first, eq.second) == 2);
std::multiset<std::string> s; std::multiset<std::string> s;
s.insert("one"); s.insert("one");
s.insert("four"); s.insert("four");
Show All 36 Lines#if TEST_STD_VER > 11
P(2, "two"), P(2, "two"),
P(3, "three"), P(3, "three"),
P(4, "four"), P(4, "four"),
P(1, "four"), P(1, "four"),
P(2, "four"), P(2, "four"),
}; };
A a(42); A a(42);
HF hf (43); HF hf (43);
C c(input_iterator<P*>(arr), input_iterator<P*>(arr + sizeof(arr)/sizeof(arr[0])), 12, hf, a ); C c(cpp17_input_iterator<P*>(arr), cpp17_input_iterator<P*>(arr + sizeof(arr)/sizeof(arr[0])), 12, hf, a );
assert(c.bucket_count() >= 12); assert(c.bucket_count() >= 12);
assert(c.size() == 6); assert(c.size() == 6);
typedef std::pair<C::const_iterator, C::const_iterator> Eq; typedef std::pair<C::const_iterator, C::const_iterator> Eq;
Eq eq = c.equal_range(1); Eq eq = c.equal_range(1);
assert(std::distance(eq.first, eq.second) == 2); assert(std::distance(eq.first, eq.second) == 2);
std::multiset<std::string> s; std::multiset<std::string> s;
s.insert("one"); s.insert("one");
s.insert("four"); s.insert("four");
Show All 32 Lines

libcxx/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/range_size.pass.cpp

Show First 20 Lines • Show All 44 Lines • ▼ Show 20 Linesint main(int, char**)
{ {
P(1, "one"), P(1, "one"),
P(2, "two"), P(2, "two"),
P(3, "three"), P(3, "three"),
P(4, "four"), P(4, "four"),
P(1, "four"), P(1, "four"),
P(2, "four"), P(2, "four"),
}; };
C c(input_iterator<P*>(a), input_iterator<P*>(a + sizeof(a)/sizeof(a[0])), C c(cpp17_input_iterator<P*>(a), cpp17_input_iterator<P*>(a + sizeof(a)/sizeof(a[0])),
10 10
); );
LIBCPP_ASSERT(c.bucket_count() == 11); LIBCPP_ASSERT(c.bucket_count() == 11);
assert(c.size() == 6); assert(c.size() == 6);
typedef std::pair<C::const_iterator, C::const_iterator> Eq; typedef std::pair<C::const_iterator, C::const_iterator> Eq;
Eq eq = c.equal_range(1); Eq eq = c.equal_range(1);
assert(std::distance(eq.first, eq.second) == 2); assert(std::distance(eq.first, eq.second) == 2);
std::multiset<std::string> s; std::multiset<std::string> s;
Show All 36 Lines#if TEST_STD_VER >= 11
{ {
P(1, "one"), P(1, "one"),
P(2, "two"), P(2, "two"),
P(3, "three"), P(3, "three"),
P(4, "four"), P(4, "four"),
P(1, "four"), P(1, "four"),
P(2, "four"), P(2, "four"),
}; };
C c(input_iterator<P*>(a), input_iterator<P*>(a + sizeof(a)/sizeof(a[0])), C c(cpp17_input_iterator<P*>(a), cpp17_input_iterator<P*>(a + sizeof(a)/sizeof(a[0])),
10 10
); );
LIBCPP_ASSERT(c.bucket_count() == 11); LIBCPP_ASSERT(c.bucket_count() == 11);
assert(c.size() == 6); assert(c.size() == 6);
typedef std::pair<C::const_iterator, C::const_iterator> Eq; typedef std::pair<C::const_iterator, C::const_iterator> Eq;
Eq eq = c.equal_range(1); Eq eq = c.equal_range(1);
assert(std::distance(eq.first, eq.second) == 2); assert(std::distance(eq.first, eq.second) == 2);
std::multiset<std::string> s; std::multiset<std::string> s;
Show All 31 Lines

libcxx/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/range_size_hash.pass.cpp

Show First 20 Lines • Show All 45 Lines • ▼ Show 20 Linesint main(int, char**)
{ {
P(1, "one"), P(1, "one"),
P(2, "two"), P(2, "two"),
P(3, "three"), P(3, "three"),
P(4, "four"), P(4, "four"),
P(1, "four"), P(1, "four"),
P(2, "four"), P(2, "four"),
}; };
C c(input_iterator<P*>(a), input_iterator<P*>(a + sizeof(a)/sizeof(a[0])), C c(cpp17_input_iterator<P*>(a), cpp17_input_iterator<P*>(a + sizeof(a)/sizeof(a[0])),
7, 7,
test_hash<std::hash<int> >(8) test_hash<std::hash<int> >(8)
); );
LIBCPP_ASSERT(c.bucket_count() == 7); LIBCPP_ASSERT(c.bucket_count() == 7);
assert(c.size() == 6); assert(c.size() == 6);
typedef std::pair<C::const_iterator, C::const_iterator> Eq; typedef std::pair<C::const_iterator, C::const_iterator> Eq;
Eq eq = c.equal_range(1); Eq eq = c.equal_range(1);
assert(std::distance(eq.first, eq.second) == 2); assert(std::distance(eq.first, eq.second) == 2);
Show All 37 Lines#if TEST_STD_VER >= 11
{ {
P(1, "one"), P(1, "one"),
P(2, "two"), P(2, "two"),
P(3, "three"), P(3, "three"),
P(4, "four"), P(4, "four"),
P(1, "four"), P(1, "four"),
P(2, "four"), P(2, "four"),
}; };
C c(input_iterator<P*>(a), input_iterator<P*>(a + sizeof(a)/sizeof(a[0])), C c(cpp17_input_iterator<P*>(a), cpp17_input_iterator<P*>(a + sizeof(a)/sizeof(a[0])),
7, 7,
test_hash<std::hash<int> >(8) test_hash<std::hash<int> >(8)
); );
LIBCPP_ASSERT(c.bucket_count() == 7); LIBCPP_ASSERT(c.bucket_count() == 7);
assert(c.size() == 6); assert(c.size() == 6);
typedef std::pair<C::const_iterator, C::const_iterator> Eq; typedef std::pair<C::const_iterator, C::const_iterator> Eq;
Eq eq = c.equal_range(1); Eq eq = c.equal_range(1);
assert(std::distance(eq.first, eq.second) == 2); assert(std::distance(eq.first, eq.second) == 2);
Show All 32 Lines

libcxx/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/range_size_hash_equal.pass.cpp

Show First 20 Lines • Show All 45 Lines • ▼ Show 20 Linesint main(int, char**)
{ {
P(1, "one"), P(1, "one"),
P(2, "two"), P(2, "two"),
P(3, "three"), P(3, "three"),
P(4, "four"), P(4, "four"),
P(1, "four"), P(1, "four"),
P(2, "four"), P(2, "four"),
}; };
C c(input_iterator<P*>(a), input_iterator<P*>(a + sizeof(a)/sizeof(a[0])), C c(cpp17_input_iterator<P*>(a), cpp17_input_iterator<P*>(a + sizeof(a)/sizeof(a[0])),
7, 7,
test_hash<std::hash<int> >(8), test_hash<std::hash<int> >(8),
test_compare<std::equal_to<int> >(9) test_compare<std::equal_to<int> >(9)
); );
LIBCPP_ASSERT(c.bucket_count() == 7); LIBCPP_ASSERT(c.bucket_count() == 7);
assert(c.size() == 6); assert(c.size() == 6);
typedef std::pair<C::const_iterator, C::const_iterator> Eq; typedef std::pair<C::const_iterator, C::const_iterator> Eq;
Eq eq = c.equal_range(1); Eq eq = c.equal_range(1);
Show All 38 Lines#if TEST_STD_VER >= 11
{ {
P(1, "one"), P(1, "one"),
P(2, "two"), P(2, "two"),
P(3, "three"), P(3, "three"),
P(4, "four"), P(4, "four"),
P(1, "four"), P(1, "four"),
P(2, "four"), P(2, "four"),
}; };
C c(input_iterator<P*>(a), input_iterator<P*>(a + sizeof(a)/sizeof(a[0])), C c(cpp17_input_iterator<P*>(a), cpp17_input_iterator<P*>(a + sizeof(a)/sizeof(a[0])),
7, 7,
test_hash<std::hash<int> >(8), test_hash<std::hash<int> >(8),
test_compare<std::equal_to<int> >(9) test_compare<std::equal_to<int> >(9)
); );
LIBCPP_ASSERT(c.bucket_count() == 7); LIBCPP_ASSERT(c.bucket_count() == 7);
assert(c.size() == 6); assert(c.size() == 6);
typedef std::pair<C::const_iterator, C::const_iterator> Eq; typedef std::pair<C::const_iterator, C::const_iterator> Eq;
Eq eq = c.equal_range(1); Eq eq = c.equal_range(1);
Show All 33 Lines

libcxx/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/range_size_hash_equal_allocator.pass.cpp

Show First 20 Lines • Show All 46 Lines • ▼ Show 20 Linesint main(int, char**)
{ {
P(1, "one"), P(1, "one"),
P(2, "two"), P(2, "two"),
P(3, "three"), P(3, "three"),
P(4, "four"), P(4, "four"),
P(1, "four"), P(1, "four"),
P(2, "four"), P(2, "four"),
}; };
C c(input_iterator<P*>(a), input_iterator<P*>(a + sizeof(a)/sizeof(a[0])), C c(cpp17_input_iterator<P*>(a), cpp17_input_iterator<P*>(a + sizeof(a)/sizeof(a[0])),
7, 7,
test_hash<std::hash<int> >(8), test_hash<std::hash<int> >(8),
test_compare<std::equal_to<int> >(9), test_compare<std::equal_to<int> >(9),
test_allocator<std::pair<const int, std::string> >(10) test_allocator<std::pair<const int, std::string> >(10)
); );
LIBCPP_ASSERT(c.bucket_count() == 7); LIBCPP_ASSERT(c.bucket_count() == 7);
assert(c.size() == 6); assert(c.size() == 6);
typedef std::pair<C::const_iterator, C::const_iterator> Eq; typedef std::pair<C::const_iterator, C::const_iterator> Eq;
Show All 39 Lines#if TEST_STD_VER >= 11
{ {
P(1, "one"), P(1, "one"),
P(2, "two"), P(2, "two"),
P(3, "three"), P(3, "three"),
P(4, "four"), P(4, "four"),
P(1, "four"), P(1, "four"),
P(2, "four"), P(2, "four"),
}; };
C c(input_iterator<P*>(a), input_iterator<P*>(a + sizeof(a)/sizeof(a[0])), C c(cpp17_input_iterator<P*>(a), cpp17_input_iterator<P*>(a + sizeof(a)/sizeof(a[0])),
7, 7,
test_hash<std::hash<int> >(8), test_hash<std::hash<int> >(8),
test_compare<std::equal_to<int> >(9), test_compare<std::equal_to<int> >(9),
min_allocator<std::pair<const int, std::string> >() min_allocator<std::pair<const int, std::string> >()
); );
LIBCPP_ASSERT(c.bucket_count() == 7); LIBCPP_ASSERT(c.bucket_count() == 7);
assert(c.size() == 6); assert(c.size() == 6);
typedef std::pair<C::const_iterator, C::const_iterator> Eq; typedef std::pair<C::const_iterator, C::const_iterator> Eq;
Show All 39 Lines#if TEST_STD_VER >= 11
{ {
P(1, "one"), P(1, "one"),
P(2, "two"), P(2, "two"),
P(3, "three"), P(3, "three"),
P(4, "four"), P(4, "four"),
P(1, "four"), P(1, "four"),
P(2, "four"), P(2, "four"),
}; };
C c(input_iterator<P*>(a), input_iterator<P*>(a + sizeof(a)/sizeof(a[0])), C c(cpp17_input_iterator<P*>(a), cpp17_input_iterator<P*>(a + sizeof(a)/sizeof(a[0])),
7, 7,
test_hash<std::hash<int> >(8), test_hash<std::hash<int> >(8),
test_compare<std::equal_to<int> >(9), test_compare<std::equal_to<int> >(9),
A{} A{}
); );
LIBCPP_ASSERT(c.bucket_count() == 7); LIBCPP_ASSERT(c.bucket_count() == 7);
assert(c.size() == 6); assert(c.size() == 6);
typedef std::pair<C::const_iterator, C::const_iterator> Eq; typedef std::pair<C::const_iterator, C::const_iterator> Eq;
Show All 34 Lines

libcxx/test/std/containers/unord/unord.multimap/unord.multimap.modifiers/insert_range.pass.cpp

Show All 35 Linesint main(int, char**)
P(1, "one"), P(1, "one"),
P(2, "two"), P(2, "two"),
P(3, "three"), P(3, "three"),
P(4, "four"), P(4, "four"),
P(1, "four"), P(1, "four"),
P(2, "four"), P(2, "four"),
}; };
C c; C c;
c.insert(input_iterator<P*>(a), input_iterator<P*>(a + sizeof(a)/sizeof(a[0]))); c.insert(cpp17_input_iterator<P*>(a), cpp17_input_iterator<P*>(a + sizeof(a)/sizeof(a[0])));
assert(c.size() == 6); assert(c.size() == 6);
typedef std::pair<C::iterator, C::iterator> Eq; typedef std::pair<C::iterator, C::iterator> Eq;
Eq eq = c.equal_range(1); Eq eq = c.equal_range(1);
assert(std::distance(eq.first, eq.second) == 2); assert(std::distance(eq.first, eq.second) == 2);
std::multiset<std::string> s; std::multiset<std::string> s;
s.insert("one"); s.insert("one");
s.insert("four"); s.insert("four");
CheckConsecutiveKeys<C::const_iterator>(c.find(1), c.end(), 1, s); CheckConsecutiveKeys<C::const_iterator>(c.find(1), c.end(), 1, s);
Show All 25 Lines#if TEST_STD_VER >= 11
P(1, "one"), P(1, "one"),
P(2, "two"), P(2, "two"),
P(3, "three"), P(3, "three"),
P(4, "four"), P(4, "four"),
P(1, "four"), P(1, "four"),
P(2, "four"), P(2, "four"),
}; };
C c; C c;
c.insert(input_iterator<P*>(a), input_iterator<P*>(a + sizeof(a)/sizeof(a[0]))); c.insert(cpp17_input_iterator<P*>(a), cpp17_input_iterator<P*>(a + sizeof(a)/sizeof(a[0])));
assert(c.size() == 6); assert(c.size() == 6);
typedef std::pair<C::iterator, C::iterator> Eq; typedef std::pair<C::iterator, C::iterator> Eq;
Eq eq = c.equal_range(1); Eq eq = c.equal_range(1);
assert(std::distance(eq.first, eq.second) == 2); assert(std::distance(eq.first, eq.second) == 2);
std::multiset<std::string> s; std::multiset<std::string> s;
s.insert("one"); s.insert("one");
s.insert("four"); s.insert("four");
CheckConsecutiveKeys<C::const_iterator>(c.find(1), c.end(), 1, s); CheckConsecutiveKeys<C::const_iterator>(c.find(1), c.end(), 1, s);
Show All 22 Lines

libcxx/test/std/containers/unord/unord.multiset/insert_range.pass.cpp

Show All 31 Linesint main(int, char**)
P(1), P(1),
P(2), P(2),
P(3), P(3),
P(4), P(4),
P(1), P(1),
P(2) P(2)
}; };
C c; C c;
c.insert(input_iterator<P*>(a), input_iterator<P*>(a + sizeof(a)/sizeof(a[0]))); c.insert(cpp17_input_iterator<P*>(a), cpp17_input_iterator<P*>(a + sizeof(a)/sizeof(a[0])));
assert(c.size() == 6); assert(c.size() == 6);
assert(c.count(1) == 2); assert(c.count(1) == 2);
assert(c.count(2) == 2); assert(c.count(2) == 2);
assert(c.count(3) == 1); assert(c.count(3) == 1);
assert(c.count(4) == 1); assert(c.count(4) == 1);
} }
#if TEST_STD_VER >= 11 #if TEST_STD_VER >= 11
{ {
typedef std::unordered_multiset<int, std::hash<int>, typedef std::unordered_multiset<int, std::hash<int>,
std::equal_to<int>, min_allocator<int>> C; std::equal_to<int>, min_allocator<int>> C;
typedef int P; typedef int P;
P a[] = P a[] =
{ {
P(1), P(1),
P(2), P(2),
P(3), P(3),
P(4), P(4),
P(1), P(1),
P(2) P(2)
}; };
C c; C c;
c.insert(input_iterator<P*>(a), input_iterator<P*>(a + sizeof(a)/sizeof(a[0]))); c.insert(cpp17_input_iterator<P*>(a), cpp17_input_iterator<P*>(a + sizeof(a)/sizeof(a[0])));
assert(c.size() == 6); assert(c.size() == 6);
assert(c.count(1) == 2); assert(c.count(1) == 2);
assert(c.count(2) == 2); assert(c.count(2) == 2);
assert(c.count(3) == 1); assert(c.count(3) == 1);
assert(c.count(4) == 1); assert(c.count(4) == 1);
} }
#endif #endif
return 0; return 0;
} }

libcxx/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/range.pass.cpp

Show All 40 Linesint main(int, char**)
{ {
P(1), P(1),
P(2), P(2),
P(3), P(3),
P(4), P(4),
P(1), P(1),
P(2) P(2)
}; };
C c(input_iterator<P*>(a), input_iterator<P*>(a + sizeof(a)/sizeof(a[0]))); C c(cpp17_input_iterator<P*>(a), cpp17_input_iterator<P*>(a + sizeof(a)/sizeof(a[0])));
assert(c.bucket_count() >= 7); assert(c.bucket_count() >= 7);
assert(c.size() == 6); assert(c.size() == 6);
assert(c.count(1) == 2); assert(c.count(1) == 2);
assert(c.count(2) == 2); assert(c.count(2) == 2);
assert(c.count(3) == 1); assert(c.count(3) == 1);
assert(c.count(4) == 1); assert(c.count(4) == 1);
assert(c.hash_function() == test_hash<std::hash<int> >()); assert(c.hash_function() == test_hash<std::hash<int> >());
assert(c.key_eq() == test_compare<std::equal_to<int> >()); assert(c.key_eq() == test_compare<std::equal_to<int> >());
Show All 16 Lines#if TEST_STD_VER >= 11
{ {
P(1), P(1),
P(2), P(2),
P(3), P(3),
P(4), P(4),
P(1), P(1),
P(2) P(2)
}; };
C c(input_iterator<P*>(a), input_iterator<P*>(a + sizeof(a)/sizeof(a[0]))); C c(cpp17_input_iterator<P*>(a), cpp17_input_iterator<P*>(a + sizeof(a)/sizeof(a[0])));
assert(c.bucket_count() >= 7); assert(c.bucket_count() >= 7);
assert(c.size() == 6); assert(c.size() == 6);
assert(c.count(1) == 2); assert(c.count(1) == 2);
assert(c.count(2) == 2); assert(c.count(2) == 2);
assert(c.count(3) == 1); assert(c.count(3) == 1);
assert(c.count(4) == 1); assert(c.count(4) == 1);
assert(c.hash_function() == test_hash<std::hash<int> >()); assert(c.hash_function() == test_hash<std::hash<int> >());
assert(c.key_eq() == test_compare<std::equal_to<int> >()); assert(c.key_eq() == test_compare<std::equal_to<int> >());
Show All 16 Lines#if TEST_STD_VER > 11
T(1), T(1),
T(2), T(2),
T(3), T(3),
T(4), T(4),
T(1), T(1),
T(2) T(2)
}; };
A a(42); A a(42);
C c(input_iterator<T*>(arr), input_iterator<T*>(arr + sizeof(arr)/sizeof(arr[0])), 12, a); C c(cpp17_input_iterator<T*>(arr), cpp17_input_iterator<T*>(arr + sizeof(arr)/sizeof(arr[0])), 12, a);
assert(c.bucket_count() >= 12); assert(c.bucket_count() >= 12);
assert(c.size() == 6); assert(c.size() == 6);
assert(c.count(1) == 2); assert(c.count(1) == 2);
assert(c.count(2) == 2); assert(c.count(2) == 2);
assert(c.count(3) == 1); assert(c.count(3) == 1);
assert(c.count(4) == 1); assert(c.count(4) == 1);
assert(c.hash_function() == HF()); assert(c.hash_function() == HF());
assert(c.key_eq() == Comp()); assert(c.key_eq() == Comp());
Show All 17 Lines#if TEST_STD_VER > 11
T(2), T(2),
T(3), T(3),
T(4), T(4),
T(1), T(1),
T(2) T(2)
}; };
HF hf(43); HF hf(43);
A a(42); A a(42);
C c(input_iterator<T*>(arr), input_iterator<T*>(arr + sizeof(arr)/sizeof(arr[0])), 16, hf, a); C c(cpp17_input_iterator<T*>(arr), cpp17_input_iterator<T*>(arr + sizeof(arr)/sizeof(arr[0])), 16, hf, a);
assert(c.bucket_count() >= 16); assert(c.bucket_count() >= 16);
assert(c.size() == 6); assert(c.size() == 6);
assert(c.count(1) == 2); assert(c.count(1) == 2);
assert(c.count(2) == 2); assert(c.count(2) == 2);
assert(c.count(3) == 1); assert(c.count(3) == 1);
assert(c.count(4) == 1); assert(c.count(4) == 1);
assert(c.hash_function() == hf); assert(c.hash_function() == hf);
assert(!(c.hash_function() == HF())); assert(!(c.hash_function() == HF()));
Show All 14 Lines

libcxx/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/range_size.pass.cpp

Show All 40 Linesint main(int, char**)
{ {
P(1), P(1),
P(2), P(2),
P(3), P(3),
P(4), P(4),
P(1), P(1),
P(2) P(2)
}; };
C c(input_iterator<P*>(a), input_iterator<P*>(a + sizeof(a)/sizeof(a[0])), C c(cpp17_input_iterator<P*>(a), cpp17_input_iterator<P*>(a + sizeof(a)/sizeof(a[0])),
7 7
); );
LIBCPP_ASSERT(c.bucket_count() == 7); LIBCPP_ASSERT(c.bucket_count() == 7);
assert(c.size() == 6); assert(c.size() == 6);
assert(c.count(1) == 2); assert(c.count(1) == 2);
assert(c.count(2) == 2); assert(c.count(2) == 2);
assert(c.count(3) == 1); assert(c.count(3) == 1);
assert(c.count(4) == 1); assert(c.count(4) == 1);
Show All 18 Lines#if TEST_STD_VER >= 11
{ {
P(1), P(1),
P(2), P(2),
P(3), P(3),
P(4), P(4),
P(1), P(1),
P(2) P(2)
}; };
C c(input_iterator<P*>(a), input_iterator<P*>(a + sizeof(a)/sizeof(a[0])), C c(cpp17_input_iterator<P*>(a), cpp17_input_iterator<P*>(a + sizeof(a)/sizeof(a[0])),
7 7
); );
LIBCPP_ASSERT(c.bucket_count() == 7); LIBCPP_ASSERT(c.bucket_count() == 7);
assert(c.size() == 6); assert(c.size() == 6);
assert(c.count(1) == 2); assert(c.count(1) == 2);
assert(c.count(2) == 2); assert(c.count(2) == 2);
assert(c.count(3) == 1); assert(c.count(3) == 1);
assert(c.count(4) == 1); assert(c.count(4) == 1);
Show All 13 Lines

libcxx/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/range_size_hash.pass.cpp

Show First 20 Lines • Show All 41 Lines • ▼ Show 20 Linesint main(int, char**)
{ {
P(1), P(1),
P(2), P(2),
P(3), P(3),
P(4), P(4),
P(1), P(1),
P(2) P(2)
}; };
C c(input_iterator<P*>(a), input_iterator<P*>(a + sizeof(a)/sizeof(a[0])), C c(cpp17_input_iterator<P*>(a), cpp17_input_iterator<P*>(a + sizeof(a)/sizeof(a[0])),
7, 7,
test_hash<std::hash<int> >(8) test_hash<std::hash<int> >(8)
); );
LIBCPP_ASSERT(c.bucket_count() == 7); LIBCPP_ASSERT(c.bucket_count() == 7);
assert(c.size() == 6); assert(c.size() == 6);
assert(c.count(1) == 2); assert(c.count(1) == 2);
assert(c.count(2) == 2); assert(c.count(2) == 2);
assert(c.count(3) == 1); assert(c.count(3) == 1);
Show All 19 Lines#if TEST_STD_VER >= 11
{ {
P(1), P(1),
P(2), P(2),
P(3), P(3),
P(4), P(4),
P(1), P(1),
P(2) P(2)
}; };
C c(input_iterator<P*>(a), input_iterator<P*>(a + sizeof(a)/sizeof(a[0])), C c(cpp17_input_iterator<P*>(a), cpp17_input_iterator<P*>(a + sizeof(a)/sizeof(a[0])),
7, 7,
test_hash<std::hash<int> >(8) test_hash<std::hash<int> >(8)
); );
LIBCPP_ASSERT(c.bucket_count() == 7); LIBCPP_ASSERT(c.bucket_count() == 7);
assert(c.size() == 6); assert(c.size() == 6);
assert(c.count(1) == 2); assert(c.count(1) == 2);
assert(c.count(2) == 2); assert(c.count(2) == 2);
assert(c.count(3) == 1); assert(c.count(3) == 1);
Show All 14 Lines

libcxx/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/range_size_hash_equal.pass.cpp

Show First 20 Lines • Show All 41 Lines • ▼ Show 20 Linesint main(int, char**)
{ {
P(1), P(1),
P(2), P(2),
P(3), P(3),
P(4), P(4),
P(1), P(1),
P(2) P(2)
}; };
C c(input_iterator<P*>(a), input_iterator<P*>(a + sizeof(a)/sizeof(a[0])), C c(cpp17_input_iterator<P*>(a), cpp17_input_iterator<P*>(a + sizeof(a)/sizeof(a[0])),
7, 7,
test_hash<std::hash<int> >(8), test_hash<std::hash<int> >(8),
test_compare<std::equal_to<int> >(9) test_compare<std::equal_to<int> >(9)
); );
LIBCPP_ASSERT(c.bucket_count() == 7); LIBCPP_ASSERT(c.bucket_count() == 7);
assert(c.size() == 6); assert(c.size() == 6);
assert(c.count(1) == 2); assert(c.count(1) == 2);
assert(c.count(2) == 2); assert(c.count(2) == 2);
Show All 20 Lines#if TEST_STD_VER >= 11
{ {
P(1), P(1),
P(2), P(2),
P(3), P(3),
P(4), P(4),
P(1), P(1),
P(2) P(2)
}; };
C c(input_iterator<P*>(a), input_iterator<P*>(a + sizeof(a)/sizeof(a[0])), C c(cpp17_input_iterator<P*>(a), cpp17_input_iterator<P*>(a + sizeof(a)/sizeof(a[0])),
7, 7,
test_hash<std::hash<int> >(8), test_hash<std::hash<int> >(8),
test_compare<std::equal_to<int> >(9) test_compare<std::equal_to<int> >(9)
); );
LIBCPP_ASSERT(c.bucket_count() == 7); LIBCPP_ASSERT(c.bucket_count() == 7);
assert(c.size() == 6); assert(c.size() == 6);
assert(c.count(1) == 2); assert(c.count(1) == 2);
assert(c.count(2) == 2); assert(c.count(2) == 2);
Show All 15 Lines

libcxx/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/range_size_hash_equal_allocator.pass.cpp

Show First 20 Lines • Show All 42 Lines • ▼ Show 20 Linesint main(int, char**)
{ {
P(1), P(1),
P(2), P(2),
P(3), P(3),
P(4), P(4),
P(1), P(1),
P(2) P(2)
}; };
C c(input_iterator<P*>(a), input_iterator<P*>(a + sizeof(a)/sizeof(a[0])), C c(cpp17_input_iterator<P*>(a), cpp17_input_iterator<P*>(a + sizeof(a)/sizeof(a[0])),
7, 7,
test_hash<std::hash<int> >(8), test_hash<std::hash<int> >(8),
test_compare<std::equal_to<int> >(9), test_compare<std::equal_to<int> >(9),
test_allocator<int>(10) test_allocator<int>(10)
); );
LIBCPP_ASSERT(c.bucket_count() == 7); LIBCPP_ASSERT(c.bucket_count() == 7);
assert(c.size() == 6); assert(c.size() == 6);
assert(c.count(1) == 2); assert(c.count(1) == 2);
Show All 21 Lines#if TEST_STD_VER >= 11
{ {
P(1), P(1),
P(2), P(2),
P(3), P(3),
P(4), P(4),
P(1), P(1),
P(2) P(2)
}; };
C c(input_iterator<P*>(a), input_iterator<P*>(a + sizeof(a)/sizeof(a[0])), C c(cpp17_input_iterator<P*>(a), cpp17_input_iterator<P*>(a + sizeof(a)/sizeof(a[0])),
7, 7,
test_hash<std::hash<int> >(8), test_hash<std::hash<int> >(8),
test_compare<std::equal_to<int> >(9), test_compare<std::equal_to<int> >(9),
min_allocator<int>() min_allocator<int>()
); );
LIBCPP_ASSERT(c.bucket_count() == 7); LIBCPP_ASSERT(c.bucket_count() == 7);
assert(c.size() == 6); assert(c.size() == 6);
assert(c.count(1) == 2); assert(c.count(1) == 2);
Show All 16 Lines

libcxx/test/std/containers/unord/unord.set/insert_range.pass.cpp

Show All 31 Linesint main(int, char**)
P(1), P(1),
P(2), P(2),
P(3), P(3),
P(4), P(4),
P(1), P(1),
P(2) P(2)
}; };
C c; C c;
c.insert(input_iterator<P*>(a), input_iterator<P*>(a + sizeof(a)/sizeof(a[0]))); c.insert(cpp17_input_iterator<P*>(a), cpp17_input_iterator<P*>(a + sizeof(a)/sizeof(a[0])));
assert(c.size() == 4); assert(c.size() == 4);
assert(c.count(1) == 1); assert(c.count(1) == 1);
assert(c.count(2) == 1); assert(c.count(2) == 1);
assert(c.count(3) == 1); assert(c.count(3) == 1);
assert(c.count(4) == 1); assert(c.count(4) == 1);
} }
#if TEST_STD_VER >= 11 #if TEST_STD_VER >= 11
{ {
typedef std::unordered_set<int, std::hash<int>, typedef std::unordered_set<int, std::hash<int>,
std::equal_to<int>, min_allocator<int>> C; std::equal_to<int>, min_allocator<int>> C;
typedef int P; typedef int P;
P a[] = P a[] =
{ {
P(1), P(1),
P(2), P(2),
P(3), P(3),
P(4), P(4),
P(1), P(1),
P(2) P(2)
}; };
C c; C c;
c.insert(input_iterator<P*>(a), input_iterator<P*>(a + sizeof(a)/sizeof(a[0]))); c.insert(cpp17_input_iterator<P*>(a), cpp17_input_iterator<P*>(a + sizeof(a)/sizeof(a[0])));
assert(c.size() == 4); assert(c.size() == 4);
assert(c.count(1) == 1); assert(c.count(1) == 1);
assert(c.count(2) == 1); assert(c.count(2) == 1);
assert(c.count(3) == 1); assert(c.count(3) == 1);
assert(c.count(4) == 1); assert(c.count(4) == 1);
} }
#endif #endif
return 0; return 0;
} }

libcxx/test/std/containers/unord/unord.set/unord.set.cnstr/range.pass.cpp

Show All 40 Linesint main(int, char**)
{ {
P(1), P(1),
P(2), P(2),
P(3), P(3),
P(4), P(4),
P(1), P(1),
P(2) P(2)
}; };
C c(input_iterator<P*>(a), input_iterator<P*>(a + sizeof(a)/sizeof(a[0]))); C c(cpp17_input_iterator<P*>(a), cpp17_input_iterator<P*>(a + sizeof(a)/sizeof(a[0])));
assert(c.bucket_count() >= 5); assert(c.bucket_count() >= 5);
assert(c.size() == 4); assert(c.size() == 4);
assert(c.count(1) == 1); assert(c.count(1) == 1);
assert(c.count(2) == 1); assert(c.count(2) == 1);
assert(c.count(3) == 1); assert(c.count(3) == 1);
assert(c.count(4) == 1); assert(c.count(4) == 1);
assert(c.hash_function() == test_hash<std::hash<int> >()); assert(c.hash_function() == test_hash<std::hash<int> >());
assert(c.key_eq() == test_compare<std::equal_to<int> >()); assert(c.key_eq() == test_compare<std::equal_to<int> >());
Show All 16 Lines#if TEST_STD_VER >= 11
{ {
P(1), P(1),
P(2), P(2),
P(3), P(3),
P(4), P(4),
P(1), P(1),
P(2) P(2)
}; };
C c(input_iterator<P*>(a), input_iterator<P*>(a + sizeof(a)/sizeof(a[0]))); C c(cpp17_input_iterator<P*>(a), cpp17_input_iterator<P*>(a + sizeof(a)/sizeof(a[0])));
assert(c.bucket_count() >= 5); assert(c.bucket_count() >= 5);
assert(c.size() == 4); assert(c.size() == 4);
assert(c.count(1) == 1); assert(c.count(1) == 1);
assert(c.count(2) == 1); assert(c.count(2) == 1);
assert(c.count(3) == 1); assert(c.count(3) == 1);
assert(c.count(4) == 1); assert(c.count(4) == 1);
assert(c.hash_function() == test_hash<std::hash<int> >()); assert(c.hash_function() == test_hash<std::hash<int> >());
assert(c.key_eq() == test_compare<std::equal_to<int> >()); assert(c.key_eq() == test_compare<std::equal_to<int> >());
Show All 16 Lines#if TEST_STD_VER > 11
T(1), T(1),
T(2), T(2),
T(3), T(3),
T(4), T(4),
T(1), T(1),
T(2) T(2)
}; };
A a(42); A a(42);
C c(input_iterator<T*>(arr), input_iterator<T*>(arr + sizeof(arr)/sizeof(arr[0])), 12, a); C c(cpp17_input_iterator<T*>(arr), cpp17_input_iterator<T*>(arr + sizeof(arr)/sizeof(arr[0])), 12, a);
assert(c.bucket_count() >= 12); assert(c.bucket_count() >= 12);
assert(c.size() == 4); assert(c.size() == 4);
assert(c.count(1) == 1); assert(c.count(1) == 1);
assert(c.count(2) == 1); assert(c.count(2) == 1);
assert(c.count(3) == 1); assert(c.count(3) == 1);
assert(c.count(4) == 1); assert(c.count(4) == 1);
assert(c.hash_function() == HF()); assert(c.hash_function() == HF());
assert(c.key_eq() == Comp()); assert(c.key_eq() == Comp());
Show All 17 Lines#if TEST_STD_VER > 11
T(2), T(2),
T(3), T(3),
T(4), T(4),
T(1), T(1),
T(2) T(2)
}; };
HF hf(43); HF hf(43);
A a(42); A a(42);
C c(input_iterator<T*>(arr), input_iterator<T*>(arr + sizeof(arr)/sizeof(arr[0])), 16, hf, a); C c(cpp17_input_iterator<T*>(arr), cpp17_input_iterator<T*>(arr + sizeof(arr)/sizeof(arr[0])), 16, hf, a);
assert(c.bucket_count() >= 16); assert(c.bucket_count() >= 16);
assert(c.size() == 4); assert(c.size() == 4);
assert(c.count(1) == 1); assert(c.count(1) == 1);
assert(c.count(2) == 1); assert(c.count(2) == 1);
assert(c.count(3) == 1); assert(c.count(3) == 1);
assert(c.count(4) == 1); assert(c.count(4) == 1);
assert(c.hash_function() == hf); assert(c.hash_function() == hf);
assert(!(c.hash_function() == HF())); assert(!(c.hash_function() == HF()));
Show All 15 Lines

libcxx/test/std/containers/unord/unord.set/unord.set.cnstr/range_size.pass.cpp

Show All 40 Linesint main(int, char**)
{ {
P(1), P(1),
P(2), P(2),
P(3), P(3),
P(4), P(4),
P(1), P(1),
P(2) P(2)
}; };
C c(input_iterator<P*>(a), input_iterator<P*>(a + sizeof(a)/sizeof(a[0])), C c(cpp17_input_iterator<P*>(a), cpp17_input_iterator<P*>(a + sizeof(a)/sizeof(a[0])),
7 7
); );
LIBCPP_ASSERT(c.bucket_count() == 7); LIBCPP_ASSERT(c.bucket_count() == 7);
assert(c.size() == 4); assert(c.size() == 4);
assert(c.count(1) == 1); assert(c.count(1) == 1);
assert(c.count(2) == 1); assert(c.count(2) == 1);
assert(c.count(3) == 1); assert(c.count(3) == 1);
assert(c.count(4) == 1); assert(c.count(4) == 1);
Show All 18 Lines#if TEST_STD_VER >= 11
{ {
P(1), P(1),
P(2), P(2),
P(3), P(3),
P(4), P(4),
P(1), P(1),
P(2) P(2)
}; };
C c(input_iterator<P*>(a), input_iterator<P*>(a + sizeof(a)/sizeof(a[0])), C c(cpp17_input_iterator<P*>(a), cpp17_input_iterator<P*>(a + sizeof(a)/sizeof(a[0])),
7 7
); );
LIBCPP_ASSERT(c.bucket_count() == 7); LIBCPP_ASSERT(c.bucket_count() == 7);
assert(c.size() == 4); assert(c.size() == 4);
assert(c.count(1) == 1); assert(c.count(1) == 1);
assert(c.count(2) == 1); assert(c.count(2) == 1);
assert(c.count(3) == 1); assert(c.count(3) == 1);
assert(c.count(4) == 1); assert(c.count(4) == 1);
Show All 13 Lines

libcxx/test/std/containers/unord/unord.set/unord.set.cnstr/range_size_hash.pass.cpp

Show First 20 Lines • Show All 41 Lines • ▼ Show 20 Linesint main(int, char**)
{ {
P(1), P(1),
P(2), P(2),
P(3), P(3),
P(4), P(4),
P(1), P(1),
P(2) P(2)
}; };
C c(input_iterator<P*>(a), input_iterator<P*>(a + sizeof(a)/sizeof(a[0])), C c(cpp17_input_iterator<P*>(a), cpp17_input_iterator<P*>(a + sizeof(a)/sizeof(a[0])),
7, 7,
test_hash<std::hash<int> >(8) test_hash<std::hash<int> >(8)
); );
LIBCPP_ASSERT(c.bucket_count() == 7); LIBCPP_ASSERT(c.bucket_count() == 7);
assert(c.size() == 4); assert(c.size() == 4);
assert(c.count(1) == 1); assert(c.count(1) == 1);
assert(c.count(2) == 1); assert(c.count(2) == 1);
assert(c.count(3) == 1); assert(c.count(3) == 1);
Show All 19 Lines#if TEST_STD_VER >= 11
{ {
P(1), P(1),
P(2), P(2),
P(3), P(3),
P(4), P(4),
P(1), P(1),
P(2) P(2)
}; };
C c(input_iterator<P*>(a), input_iterator<P*>(a + sizeof(a)/sizeof(a[0])), C c(cpp17_input_iterator<P*>(a), cpp17_input_iterator<P*>(a + sizeof(a)/sizeof(a[0])),
7, 7,
test_hash<std::hash<int> >(8) test_hash<std::hash<int> >(8)
); );
LIBCPP_ASSERT(c.bucket_count() == 7); LIBCPP_ASSERT(c.bucket_count() == 7);
assert(c.size() == 4); assert(c.size() == 4);
assert(c.count(1) == 1); assert(c.count(1) == 1);
assert(c.count(2) == 1); assert(c.count(2) == 1);
assert(c.count(3) == 1); assert(c.count(3) == 1);
Show All 14 Lines

libcxx/test/std/containers/unord/unord.set/unord.set.cnstr/range_size_hash_equal.pass.cpp

Show First 20 Lines • Show All 41 Lines • ▼ Show 20 Linesint main(int, char**)
{ {
P(1), P(1),
P(2), P(2),
P(3), P(3),
P(4), P(4),
P(1), P(1),
P(2) P(2)
}; };
C c(input_iterator<P*>(a), input_iterator<P*>(a + sizeof(a)/sizeof(a[0])), C c(cpp17_input_iterator<P*>(a), cpp17_input_iterator<P*>(a + sizeof(a)/sizeof(a[0])),
7, 7,
test_hash<std::hash<int> >(8), test_hash<std::hash<int> >(8),
test_compare<std::equal_to<int> >(9) test_compare<std::equal_to<int> >(9)
); );
LIBCPP_ASSERT(c.bucket_count() == 7); LIBCPP_ASSERT(c.bucket_count() == 7);
assert(c.size() == 4); assert(c.size() == 4);
assert(c.count(1) == 1); assert(c.count(1) == 1);
assert(c.count(2) == 1); assert(c.count(2) == 1);
Show All 20 Lines#if TEST_STD_VER >= 11
{ {
P(1), P(1),
P(2), P(2),
P(3), P(3),
P(4), P(4),
P(1), P(1),
P(2) P(2)
}; };
C c(input_iterator<P*>(a), input_iterator<P*>(a + sizeof(a)/sizeof(a[0])), C c(cpp17_input_iterator<P*>(a), cpp17_input_iterator<P*>(a + sizeof(a)/sizeof(a[0])),
7, 7,
test_hash<std::hash<int> >(8), test_hash<std::hash<int> >(8),
test_compare<std::equal_to<int> >(9) test_compare<std::equal_to<int> >(9)
); );
LIBCPP_ASSERT(c.bucket_count() == 7); LIBCPP_ASSERT(c.bucket_count() == 7);
assert(c.size() == 4); assert(c.size() == 4);
assert(c.count(1) == 1); assert(c.count(1) == 1);
assert(c.count(2) == 1); assert(c.count(2) == 1);
Show All 15 Lines

libcxx/test/std/containers/unord/unord.set/unord.set.cnstr/range_size_hash_equal_allocator.pass.cpp

Show First 20 Lines • Show All 42 Lines • ▼ Show 20 Linesint main(int, char**)
{ {
P(1), P(1),
P(2), P(2),
P(3), P(3),
P(4), P(4),
P(1), P(1),
P(2) P(2)
}; };
C c(input_iterator<P*>(a), input_iterator<P*>(a + sizeof(a)/sizeof(a[0])), C c(cpp17_input_iterator<P*>(a), cpp17_input_iterator<P*>(a + sizeof(a)/sizeof(a[0])),
7, 7,
test_hash<std::hash<int> >(8), test_hash<std::hash<int> >(8),
test_compare<std::equal_to<int> >(9), test_compare<std::equal_to<int> >(9),
test_allocator<int>(10) test_allocator<int>(10)
); );
LIBCPP_ASSERT(c.bucket_count() == 7); LIBCPP_ASSERT(c.bucket_count() == 7);
assert(c.size() == 4); assert(c.size() == 4);
assert(c.count(1) == 1); assert(c.count(1) == 1);
Show All 21 Lines#if TEST_STD_VER >= 11
{ {
P(1), P(1),
P(2), P(2),
P(3), P(3),
P(4), P(4),
P(1), P(1),
P(2) P(2)
}; };
C c(input_iterator<P*>(a), input_iterator<P*>(a + sizeof(a)/sizeof(a[0])), C c(cpp17_input_iterator<P*>(a), cpp17_input_iterator<P*>(a + sizeof(a)/sizeof(a[0])),
7, 7,
test_hash<std::hash<int> >(8), test_hash<std::hash<int> >(8),
test_compare<std::equal_to<int> >(9), test_compare<std::equal_to<int> >(9),
min_allocator<int>() min_allocator<int>()
); );
LIBCPP_ASSERT(c.bucket_count() == 7); LIBCPP_ASSERT(c.bucket_count() == 7);
assert(c.size() == 4); assert(c.size() == 4);
assert(c.count(1) == 1); assert(c.count(1) == 1);
Show All 16 Lines

libcxx/test/std/experimental/iterator/ostream.joiner/ostream.joiner.ops/ostream_joiner.op.assign.pass.cpp

Show First 20 Lines • Show All 69 Lines • ▼ Show 20 Lines
int main(int, char**) { int main(int, char**) {
{ {
const char chars[] = "0123456789"; const char chars[] = "0123456789";
const int ints [] = { 10, 11, 12, 13, 14, 15, 16, 17, 18, 19 }; const int ints [] = { 10, 11, 12, 13, 14, 15, 16, 17, 18, 19 };
test('X', chars, chars+10, "0X1X2X3X4X5X6X7X8X9"); test('X', chars, chars+10, "0X1X2X3X4X5X6X7X8X9");
test('x', ints, ints+10, "10x11x12x13x14x15x16x17x18x19"); test('x', ints, ints+10, "10x11x12x13x14x15x16x17x18x19");
test('X', input_iterator<const char*>(chars), input_iterator<const char*>(chars+10), "0X1X2X3X4X5X6X7X8X9"); test('X', cpp17_input_iterator<const char*>(chars), cpp17_input_iterator<const char*>(chars+10), "0X1X2X3X4X5X6X7X8X9");
test('x', input_iterator<const int*>(ints), input_iterator<const int*>(ints+10), "10x11x12x13x14x15x16x17x18x19"); test('x', cpp17_input_iterator<const int*>(ints), cpp17_input_iterator<const int*>(ints+10), "10x11x12x13x14x15x16x17x18x19");
test('X', forward_iterator<const char*>(chars), forward_iterator<const char*>(chars+10), "0X1X2X3X4X5X6X7X8X9"); test('X', forward_iterator<const char*>(chars), forward_iterator<const char*>(chars+10), "0X1X2X3X4X5X6X7X8X9");
test('x', forward_iterator<const int*>(ints), forward_iterator<const int*>(ints+10), "10x11x12x13x14x15x16x17x18x19"); test('x', forward_iterator<const int*>(ints), forward_iterator<const int*>(ints+10), "10x11x12x13x14x15x16x17x18x19");
test('X', random_access_iterator<const char*>(chars), random_access_iterator<const char*>(chars+10), "0X1X2X3X4X5X6X7X8X9"); test('X', random_access_iterator<const char*>(chars), random_access_iterator<const char*>(chars+10), "0X1X2X3X4X5X6X7X8X9");
test('x', random_access_iterator<const int*>(ints), random_access_iterator<const int*>(ints+10), "10x11x12x13x14x15x16x17x18x19"); test('x', random_access_iterator<const int*>(ints), random_access_iterator<const int*>(ints+10), "10x11x12x13x14x15x16x17x18x19");
test("Z", chars, chars+10, "0Z1Z2Z3Z4Z5Z6Z7Z8Z9"); test("Z", chars, chars+10, "0Z1Z2Z3Z4Z5Z6Z7Z8Z9");
test("z", ints, ints+10, "10z11z12z13z14z15z16z17z18z19"); test("z", ints, ints+10, "10z11z12z13z14z15z16z17z18z19");
test<char, const char *, wchar_t> ('X', chars, chars+10, L"0X1X2X3X4X5X6X7X8X9"); test<char, const char *, wchar_t> ('X', chars, chars+10, L"0X1X2X3X4X5X6X7X8X9");
test<char, const int *, wchar_t> ('x', ints, ints+10, L"10x11x12x13x14x15x16x17x18x19"); test<char, const int *, wchar_t> ('x', ints, ints+10, L"10x11x12x13x14x15x16x17x18x19");
// test<char, const char *, char16_t>('X', chars, chars+10, u"0X1X2X3X4X5X6X7X8X9"); // test<char, const char *, char16_t>('X', chars, chars+10, u"0X1X2X3X4X5X6X7X8X9");
// test<char, const int *, char16_t>('x', ints, ints+10, u"10x11x12x13x14x15x16x17x18x19"); // test<char, const int *, char16_t>('x', ints, ints+10, u"10x11x12x13x14x15x16x17x18x19");
// test<char, const char *, char32_t>('X', chars, chars+10, U"0X1X2X3X4X5X6X7X8X9"); // test<char, const char *, char32_t>('X', chars, chars+10, U"0X1X2X3X4X5X6X7X8X9");
// test<char, const int *, char32_t>('x', ints, ints+10, U"10x11x12x13x14x15x16x17x18x19"); // test<char, const int *, char32_t>('x', ints, ints+10, U"10x11x12x13x14x15x16x17x18x19");
test(mutating_delimiter(), chars, chars+10, "0 1!2\"3#4$5%6&7'8(9"); test(mutating_delimiter(), chars, chars+10, "0 1!2\"3#4$5%6&7'8(9");
test(mutating_delimiter2(), chars, chars+10, "0 1!2\"3#4$5%6&7'8(9"); test(mutating_delimiter2(), chars, chars+10, "0 1!2\"3#4$5%6&7'8(9");
} }
{ {
const wchar_t chars[] = L"0123456789"; const wchar_t chars[] = L"0123456789";
const int ints [] = { 10, 11, 12, 13, 14, 15, 16, 17, 18, 19 }; const int ints [] = { 10, 11, 12, 13, 14, 15, 16, 17, 18, 19 };
test(L'X', chars, chars+10, L"0X1X2X3X4X5X6X7X8X9"); test(L'X', chars, chars+10, L"0X1X2X3X4X5X6X7X8X9");
test(L'x', ints, ints+10, L"10x11x12x13x14x15x16x17x18x19"); test(L'x', ints, ints+10, L"10x11x12x13x14x15x16x17x18x19");
test(L'X', input_iterator<const wchar_t*>(chars), input_iterator<const wchar_t*>(chars+10), L"0X1X2X3X4X5X6X7X8X9"); test(L'X', cpp17_input_iterator<const wchar_t*>(chars), cpp17_input_iterator<const wchar_t*>(chars+10), L"0X1X2X3X4X5X6X7X8X9");
test(L'x', input_iterator<const int*>(ints), input_iterator<const int*>(ints+10), L"10x11x12x13x14x15x16x17x18x19"); test(L'x', cpp17_input_iterator<const int*>(ints), cpp17_input_iterator<const int*>(ints+10), L"10x11x12x13x14x15x16x17x18x19");
test(L'X', forward_iterator<const wchar_t*>(chars), forward_iterator<const wchar_t*>(chars+10), L"0X1X2X3X4X5X6X7X8X9"); test(L'X', forward_iterator<const wchar_t*>(chars), forward_iterator<const wchar_t*>(chars+10), L"0X1X2X3X4X5X6X7X8X9");
test(L'x', forward_iterator<const int*>(ints), forward_iterator<const int*>(ints+10), L"10x11x12x13x14x15x16x17x18x19"); test(L'x', forward_iterator<const int*>(ints), forward_iterator<const int*>(ints+10), L"10x11x12x13x14x15x16x17x18x19");
test(L'X', random_access_iterator<const wchar_t*>(chars), random_access_iterator<const wchar_t*>(chars+10), L"0X1X2X3X4X5X6X7X8X9"); test(L'X', random_access_iterator<const wchar_t*>(chars), random_access_iterator<const wchar_t*>(chars+10), L"0X1X2X3X4X5X6X7X8X9");
test(L'x', random_access_iterator<const int*>(ints), random_access_iterator<const int*>(ints+10), L"10x11x12x13x14x15x16x17x18x19"); test(L'x', random_access_iterator<const int*>(ints), random_access_iterator<const int*>(ints+10), L"10x11x12x13x14x15x16x17x18x19");
test(L"Z", chars, chars+10, L"0Z1Z2Z3Z4Z5Z6Z7Z8Z9"); test(L"Z", chars, chars+10, L"0Z1Z2Z3Z4Z5Z6Z7Z8Z9");
test(L"z", ints, ints+10, L"10z11z12z13z14z15z16z17z18z19"); test(L"z", ints, ints+10, L"10z11z12z13z14z15z16z17z18z19");
Show All 9 Lines

libcxx/test/std/input.output/filesystems/class.path/path.member/path.append.pass.cpp

Show First 20 Lines • Show All 122 Lines • ▼ Show 20 Lines
// 3. Append `RHS` to `LHS` and check for the expected allocation behavior. // 3. Append `RHS` to `LHS` and check for the expected allocation behavior.
template <class CharT> template <class CharT>
void doAppendSourceAllocTest(AppendOperatorTestcase const& TC) void doAppendSourceAllocTest(AppendOperatorTestcase const& TC)
{ {
using namespace fs; using namespace fs;
using Ptr = CharT const*; using Ptr = CharT const*;
using Str = std::basic_string<CharT>; using Str = std::basic_string<CharT>;
using StrView = std::basic_string_view<CharT>; using StrView = std::basic_string_view<CharT>;
using InputIter = input_iterator<Ptr>; using InputIter = cpp17_input_iterator<Ptr>;
const Ptr L = TC.lhs; const Ptr L = TC.lhs;
Str RShort = (Ptr)TC.rhs; Str RShort = (Ptr)TC.rhs;
Str EShort = (Ptr)TC.expected_result(); Str EShort = (Ptr)TC.expected_result();
assert(RShort.size() >= 2); assert(RShort.size() >= 2);
CharT c = RShort.back(); CharT c = RShort.back();
RShort.append(100, c); RShort.append(100, c);
EShort.append(100, c); EShort.append(100, c);
▲ Show 20 Lines • Show All 90 Lines • ▼ Show 20 Lines
template <class CharT> template <class CharT>
void doAppendSourceTest(AppendOperatorTestcase const& TC) void doAppendSourceTest(AppendOperatorTestcase const& TC)
{ {
using namespace fs; using namespace fs;
using Ptr = CharT const*; using Ptr = CharT const*;
using Str = std::basic_string<CharT>; using Str = std::basic_string<CharT>;
using StrView = std::basic_string_view<CharT>; using StrView = std::basic_string_view<CharT>;
using InputIter = input_iterator<Ptr>; using InputIter = cpp17_input_iterator<Ptr>;
const Ptr L = TC.lhs; const Ptr L = TC.lhs;
const Ptr R = TC.rhs; const Ptr R = TC.rhs;
const Ptr E = TC.expected_result(); const Ptr E = TC.expected_result();
// basic_string // basic_string
{ {
path Result(L); path Result(L);
Str RHS(R); Str RHS(R);
path& Ref = (Result /= RHS); path& Ref = (Result /= RHS);
▲ Show 20 Lines • Show All 89 Lines • ▼ Show 20 Lines
void test_sfinae() void test_sfinae()
{ {
using namespace fs; using namespace fs;
{ {
using It = const char* const; using It = const char* const;
static_assert(has_append<It>(), ""); static_assert(has_append<It>(), "");
} }
{ {
using It = input_iterator<const char*>; using It = cpp17_input_iterator<const char*>;
static_assert(has_append<It>(), ""); static_assert(has_append<It>(), "");
} }
{ {
struct Traits { struct Traits {
using iterator_category = std::input_iterator_tag; using iterator_category = std::input_iterator_tag;
using value_type = const char; using value_type = const char;
using pointer = const char*; using pointer = const char*;
using reference = const char&; using reference = const char&;
using difference_type = std::ptrdiff_t; using difference_type = std::ptrdiff_t;
}; };
using It = input_iterator<const char*, Traits>; using It = cpp17_input_iterator<const char*, Traits>;
static_assert(has_append<It>(), ""); static_assert(has_append<It>(), "");
} }
{ {
using It = output_iterator<const char*>; using It = output_iterator<const char*>;
static_assert(!has_append<It>(), ""); static_assert(!has_append<It>(), "");
} }
{ {
Show All 35 Lines

libcxx/test/std/input.output/filesystems/class.path/path.member/path.assign/source.pass.cpp

Show First 20 Lines • Show All 131 Lines • ▼ Show 20 Lines path p; PathReserve(p, Size + 1);
assert(&pref == &p); assert(&pref == &p);
} }
assert(p.native() == Expect); assert(p.native() == Expect);
assert(p.string<CharT>() == TestPath); assert(p.string<CharT>() == TestPath);
} }
////////////////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////////////////
// Iterators // Iterators
{ {
using It = input_iterator<const CharT*>; using It = cpp17_input_iterator<const CharT*>;
path p; PathReserve(p, Size + 1); path p; PathReserve(p, Size + 1);
It it(TestPath); It it(TestPath);
{ {
// Iterators cannot be used with code_cvt directly. This assignment // Iterators cannot be used with code_cvt directly. This assignment
// may allocate if it's larger than a "short-string". // may allocate if it's larger than a "short-string".
path& pref = (p = it); path& pref = (p = it);
assert(&pref == &p); assert(&pref == &p);
} }
assert(p.native() == Expect); assert(p.native() == Expect);
assert(p.string<CharT>() == TestPath); assert(p.string<CharT>() == TestPath);
} }
{ {
using It = input_iterator<const CharT*>; using It = cpp17_input_iterator<const CharT*>;
path p; PathReserve(p, Size + 1); path p; PathReserve(p, Size + 1);
It it(TestPath); It it(TestPath);
{ {
path& pref = p.assign(it); path& pref = p.assign(it);
assert(&pref == &p); assert(&pref == &p);
} }
assert(p.native() == Expect); assert(p.native() == Expect);
assert(p.string<CharT>() == TestPath); assert(p.string<CharT>() == TestPath);
} }
{ {
using It = input_iterator<const CharT*>; using It = cpp17_input_iterator<const CharT*>;
path p; PathReserve(p, Size + 1); path p; PathReserve(p, Size + 1);
It it(TestPath); It it(TestPath);
It e(TestPathEnd); It e(TestPathEnd);
{ {
path& pref = p.assign(it, e); path& pref = p.assign(it, e);
assert(&pref == &p); assert(&pref == &p);
} }
assert(p.native() == Expect); assert(p.native() == Expect);
Show All 11 Lines
void test_sfinae() { void test_sfinae() {
using namespace fs; using namespace fs;
{ {
using It = const char* const; using It = const char* const;
static_assert(std::is_assignable<path, It>::value, ""); static_assert(std::is_assignable<path, It>::value, "");
static_assert(has_assign<It>(), ""); static_assert(has_assign<It>(), "");
} }
{ {
using It = input_iterator<const char*>; using It = cpp17_input_iterator<const char*>;
static_assert(std::is_assignable<path, It>::value, ""); static_assert(std::is_assignable<path, It>::value, "");
static_assert(has_assign<It>(), ""); static_assert(has_assign<It>(), "");
} }
{ {
struct Traits { struct Traits {
using iterator_category = std::input_iterator_tag; using iterator_category = std::input_iterator_tag;
using value_type = const char; using value_type = const char;
using pointer = const char*; using pointer = const char*;
using reference = const char&; using reference = const char&;
using difference_type = std::ptrdiff_t; using difference_type = std::ptrdiff_t;
}; };
using It = input_iterator<const char*, Traits>; using It = cpp17_input_iterator<const char*, Traits>;
static_assert(std::is_assignable<path, It>::value, ""); static_assert(std::is_assignable<path, It>::value, "");
static_assert(has_assign<It>(), ""); static_assert(has_assign<It>(), "");
} }
{ {
using It = output_iterator<const char*>; using It = output_iterator<const char*>;
static_assert(!std::is_assignable<path, It>::value, ""); static_assert(!std::is_assignable<path, It>::value, "");
static_assert(!has_assign<It>(), ""); static_assert(!has_assign<It>(), "");
Show All 35 Lines

libcxx/test/std/input.output/filesystems/class.path/path.member/path.concat.pass.cpp

Show First 20 Lines • Show All 84 Lines • ▼ Show 20 Lines
// 3. Concat `RHS` to `LHS` and check for the expected allocation behavior. // 3. Concat `RHS` to `LHS` and check for the expected allocation behavior.
template <class CharT> template <class CharT>
void doConcatSourceAllocTest(ConcatOperatorTestcase const& TC) void doConcatSourceAllocTest(ConcatOperatorTestcase const& TC)
{ {
using namespace fs; using namespace fs;
using Ptr = CharT const*; using Ptr = CharT const*;
using Str = std::basic_string<CharT>; using Str = std::basic_string<CharT>;
using StrView = std::basic_string_view<CharT>; using StrView = std::basic_string_view<CharT>;
using InputIter = input_iterator<Ptr>; using InputIter = cpp17_input_iterator<Ptr>;
const Ptr L = TC.lhs; const Ptr L = TC.lhs;
const Ptr R = TC.rhs; const Ptr R = TC.rhs;
const Ptr E = TC.expect; const Ptr E = TC.expect;
std::size_t ReserveSize = StrLen(E) + 1; std::size_t ReserveSize = StrLen(E) + 1;
// basic_string // basic_string
{ {
path LHS(L); PathReserve(LHS, ReserveSize); path LHS(L); PathReserve(LHS, ReserveSize);
▲ Show 20 Lines • Show All 70 Lines • ▼ Show 20 Lines
template <class CharT> template <class CharT>
void doConcatSourceTest(ConcatOperatorTestcase const& TC) void doConcatSourceTest(ConcatOperatorTestcase const& TC)
{ {
using namespace fs; using namespace fs;
using Ptr = CharT const*; using Ptr = CharT const*;
using Str = std::basic_string<CharT>; using Str = std::basic_string<CharT>;
using StrView = std::basic_string_view<CharT>; using StrView = std::basic_string_view<CharT>;
using InputIter = input_iterator<Ptr>; using InputIter = cpp17_input_iterator<Ptr>;
const Ptr L = TC.lhs; const Ptr L = TC.lhs;
const Ptr R = TC.rhs; const Ptr R = TC.rhs;
const Ptr E = TC.expect; const Ptr E = TC.expect;
// basic_string // basic_string
{ {
path LHS(L); path LHS(L);
Str RHS(R); Str RHS(R);
path& Ref = (LHS += RHS); path& Ref = (LHS += RHS);
▲ Show 20 Lines • Show All 113 Lines • ▼ Show 20 Lines using namespace fs;
static_assert(has_concat_op<char16_t>(), ""); static_assert(has_concat_op<char16_t>(), "");
static_assert(has_concat_op<const char16_t>(), ""); static_assert(has_concat_op<const char16_t>(), "");
} }
{ {
using It = const char* const; using It = const char* const;
static_assert(has_concat<It>(), ""); static_assert(has_concat<It>(), "");
} }
{ {
using It = input_iterator<const char*>; using It = cpp17_input_iterator<const char*>;
static_assert(has_concat<It>(), ""); static_assert(has_concat<It>(), "");
} }
{ {
struct Traits { struct Traits {
using iterator_category = std::input_iterator_tag; using iterator_category = std::input_iterator_tag;
using value_type = const char; using value_type = const char;
using pointer = const char*; using pointer = const char*;
using reference = const char&; using reference = const char&;
using difference_type = std::ptrdiff_t; using difference_type = std::ptrdiff_t;
}; };
using It = input_iterator<const char*, Traits>; using It = cpp17_input_iterator<const char*, Traits>;
static_assert(has_concat<It>(), ""); static_assert(has_concat<It>(), "");
} }
{ {
using It = output_iterator<const char*>; using It = output_iterator<const char*>;
static_assert(!has_concat<It>(), ""); static_assert(!has_concat<It>(), "");
} }
{ {
static_assert(!has_concat<int>(0), ""); static_assert(!has_concat<int>(0), "");
▲ Show 20 Lines • Show All 72 Lines • Show Last 20 Lines

libcxx/test/std/input.output/filesystems/class.path/path.member/path.construct/source.pass.cpp

Show First 20 Lines • Show All 62 Lines • ▼ Show 20 Linesvoid RunTestCaseImpl(MultiStringType const& MS, Args... args) {
} }
{ {
path p(TestPath, TestPathEnd, args...); path p(TestPath, TestPathEnd, args...);
assert(p.native() == Expect); assert(p.native() == Expect);
assert(p.string<CharT>() == TestPath); assert(p.string<CharT>() == TestPath);
} }
// Iterators // Iterators
{ {
using It = input_iterator<const CharT*>; using It = cpp17_input_iterator<const CharT*>;
path p(It{TestPath}, args...); path p(It{TestPath}, args...);
assert(p.native() == Expect); assert(p.native() == Expect);
assert(p.string<CharT>() == TestPath); assert(p.string<CharT>() == TestPath);
} }
{ {
using It = input_iterator<const CharT*>; using It = cpp17_input_iterator<const CharT*>;
path p(It{TestPath}, It{TestPathEnd}, args...); path p(It{TestPath}, It{TestPathEnd}, args...);
assert(p.native() == Expect); assert(p.native() == Expect);
assert(p.string<CharT>() == TestPath); assert(p.string<CharT>() == TestPath);
} }
} }
template <class CharT, class ...Args> template <class CharT, class ...Args>
void RunTestCase(MultiStringType const& MS) { void RunTestCase(MultiStringType const& MS) {
RunTestCaseImpl<CharT>(MS); RunTestCaseImpl<CharT>(MS);
RunTestCaseImpl<CharT>(MS, fs::path::format::auto_format); RunTestCaseImpl<CharT>(MS, fs::path::format::auto_format);
RunTestCaseImpl<CharT>(MS, fs::path::format::native_format); RunTestCaseImpl<CharT>(MS, fs::path::format::native_format);
RunTestCaseImpl<CharT>(MS, fs::path::format::generic_format); RunTestCaseImpl<CharT>(MS, fs::path::format::generic_format);
RunTestCaseImpl<CharT>(MS, fs::path::auto_format); RunTestCaseImpl<CharT>(MS, fs::path::auto_format);
RunTestCaseImpl<CharT>(MS, fs::path::native_format); RunTestCaseImpl<CharT>(MS, fs::path::native_format);
RunTestCaseImpl<CharT>(MS, fs::path::generic_format); RunTestCaseImpl<CharT>(MS, fs::path::generic_format);
} }
void test_sfinae() { void test_sfinae() {
using namespace fs; using namespace fs;
{ {
using It = const char* const; using It = const char* const;
static_assert(std::is_constructible<path, It>::value, ""); static_assert(std::is_constructible<path, It>::value, "");
} }
{ {
using It = input_iterator<const char*>; using It = cpp17_input_iterator<const char*>;
static_assert(std::is_constructible<path, It>::value, ""); static_assert(std::is_constructible<path, It>::value, "");
} }
{ {
struct Traits { struct Traits {
using iterator_category = std::input_iterator_tag; using iterator_category = std::input_iterator_tag;
using value_type = const char; using value_type = const char;
using pointer = const char*; using pointer = const char*;
using reference = const char&; using reference = const char&;
using difference_type = std::ptrdiff_t; using difference_type = std::ptrdiff_t;
}; };
using It = input_iterator<const char*, Traits>; using It = cpp17_input_iterator<const char*, Traits>;
static_assert(std::is_constructible<path, It>::value, ""); static_assert(std::is_constructible<path, It>::value, "");
} }
{ {
using It = output_iterator<const char*>; using It = output_iterator<const char*>;
static_assert(!std::is_constructible<path, It>::value, ""); static_assert(!std::is_constructible<path, It>::value, "");
} }
{ {
Show All 18 Lines

libcxx/test/std/iterators/iterator.primitives/iterator.operations/advance.pass.cpp

Show All 37 Linesvoid check_advance(It it, Distance n, It result)
std::advance(it, n); std::advance(it, n);
assert(it == result); assert(it == result);
} }
TEST_CONSTEXPR_CXX17 bool tests() TEST_CONSTEXPR_CXX17 bool tests()
{ {
const char* s = "1234567890"; const char* s = "1234567890";
typedef std::iterator_traits<const char*>::difference_type Distance; typedef std::iterator_traits<const char*>::difference_type Distance;
check_advance<Distance>(input_iterator<const char*>(s), 10, input_iterator<const char*>(s+10)); check_advance<Distance>(cpp17_input_iterator<const char*>(s), 10, cpp17_input_iterator<const char*>(s+10));
check_advance<Distance>(forward_iterator<const char*>(s), 10, forward_iterator<const char*>(s+10)); check_advance<Distance>(forward_iterator<const char*>(s), 10, forward_iterator<const char*>(s+10));
check_advance<Distance>(bidirectional_iterator<const char*>(s+5), 5, bidirectional_iterator<const char*>(s+10)); check_advance<Distance>(bidirectional_iterator<const char*>(s+5), 5, bidirectional_iterator<const char*>(s+10));
check_advance<Distance>(bidirectional_iterator<const char*>(s+5), -5, bidirectional_iterator<const char*>(s)); check_advance<Distance>(bidirectional_iterator<const char*>(s+5), -5, bidirectional_iterator<const char*>(s));
check_advance<Distance>(random_access_iterator<const char*>(s+5), 5, random_access_iterator<const char*>(s+10)); check_advance<Distance>(random_access_iterator<const char*>(s+5), 5, random_access_iterator<const char*>(s+10));
check_advance<Distance>(random_access_iterator<const char*>(s+5), -5, random_access_iterator<const char*>(s)); check_advance<Distance>(random_access_iterator<const char*>(s+5), -5, random_access_iterator<const char*>(s));
check_advance<Distance>(s+5, 5, s+10); check_advance<Distance>(s+5, 5, s+10);
check_advance<Distance>(s+5, -5, s); check_advance<Distance>(s+5, -5, s);
// Also check with other distance types // Also check with other distance types
check_advance<std::size_t>(input_iterator<const char*>(s), 10u, input_iterator<const char*>(s+10)); check_advance<std::size_t>(cpp17_input_iterator<const char*>(s), 10u, cpp17_input_iterator<const char*>(s+10));
check_advance<std::size_t>(forward_iterator<const char*>(s), 10u, forward_iterator<const char*>(s+10)); check_advance<std::size_t>(forward_iterator<const char*>(s), 10u, forward_iterator<const char*>(s+10));
check_advance<std::size_t>(bidirectional_iterator<const char*>(s), 10u, bidirectional_iterator<const char*>(s+10)); check_advance<std::size_t>(bidirectional_iterator<const char*>(s), 10u, bidirectional_iterator<const char*>(s+10));
check_advance<std::size_t>(random_access_iterator<const char*>(s), 10u, random_access_iterator<const char*>(s+10)); check_advance<std::size_t>(random_access_iterator<const char*>(s), 10u, random_access_iterator<const char*>(s+10));
return true; return true;
} }
int main(int, char**) int main(int, char**)
{ {
tests(); tests();
#if TEST_STD_VER >= 17 #if TEST_STD_VER >= 17
static_assert(tests(), ""); static_assert(tests(), "");
#endif #endif
return 0; return 0;
} }

libcxx/test/std/iterators/iterator.primitives/iterator.operations/distance.pass.cpp

Show All 29 Linesvoid check_distance(It first, It last, typename std::iterator_traits<It>::difference_type dist)
typedef typename std::iterator_traits<It>::difference_type Difference; typedef typename std::iterator_traits<It>::difference_type Difference;
static_assert(std::is_same<decltype(std::distance(first, last)), Difference>::value, ""); static_assert(std::is_same<decltype(std::distance(first, last)), Difference>::value, "");
assert(std::distance(first, last) == dist); assert(std::distance(first, last) == dist);
} }
TEST_CONSTEXPR_CXX17 bool tests() TEST_CONSTEXPR_CXX17 bool tests()
{ {
const char* s = "1234567890"; const char* s = "1234567890";
check_distance(input_iterator<const char*>(s), input_iterator<const char*>(s+10), 10); check_distance(cpp17_input_iterator<const char*>(s), cpp17_input_iterator<const char*>(s+10), 10);
check_distance(forward_iterator<const char*>(s), forward_iterator<const char*>(s+10), 10); check_distance(forward_iterator<const char*>(s), forward_iterator<const char*>(s+10), 10);
check_distance(bidirectional_iterator<const char*>(s), bidirectional_iterator<const char*>(s+10), 10); check_distance(bidirectional_iterator<const char*>(s), bidirectional_iterator<const char*>(s+10), 10);
check_distance(random_access_iterator<const char*>(s), random_access_iterator<const char*>(s+10), 10); check_distance(random_access_iterator<const char*>(s), random_access_iterator<const char*>(s+10), 10);
check_distance(s, s+10, 10); check_distance(s, s+10, 10);
return true; return true;
} }
int main(int, char**) int main(int, char**)
{ {
tests(); tests();
#if TEST_STD_VER >= 17 #if TEST_STD_VER >= 17
static_assert(tests(), ""); static_assert(tests(), "");
#endif #endif
return 0; return 0;
} }

libcxx/test/std/iterators/iterator.primitives/iterator.operations/next.pass.cpp

Show All 36 Lines
{ {
static_assert(std::is_same<decltype(std::next(it)), It>::value, ""); static_assert(std::is_same<decltype(std::next(it)), It>::value, "");
assert(std::next(it) == result); assert(std::next(it) == result);
} }
TEST_CONSTEXPR_CXX17 bool tests() TEST_CONSTEXPR_CXX17 bool tests()
{ {
const char* s = "1234567890"; const char* s = "1234567890";
check_next_n(input_iterator<const char*>(s), 10, input_iterator<const char*>(s+10)); check_next_n(cpp17_input_iterator<const char*>(s), 10, cpp17_input_iterator<const char*>(s+10));
check_next_n(forward_iterator<const char*>(s), 10, forward_iterator<const char*>(s+10)); check_next_n(forward_iterator<const char*>(s), 10, forward_iterator<const char*>(s+10));
check_next_n(bidirectional_iterator<const char*>(s), 10, bidirectional_iterator<const char*>(s+10)); check_next_n(bidirectional_iterator<const char*>(s), 10, bidirectional_iterator<const char*>(s+10));
check_next_n(bidirectional_iterator<const char*>(s+10), -10, bidirectional_iterator<const char*>(s)); check_next_n(bidirectional_iterator<const char*>(s+10), -10, bidirectional_iterator<const char*>(s));
check_next_n(random_access_iterator<const char*>(s), 10, random_access_iterator<const char*>(s+10)); check_next_n(random_access_iterator<const char*>(s), 10, random_access_iterator<const char*>(s+10));
check_next_n(random_access_iterator<const char*>(s+10), -10, random_access_iterator<const char*>(s)); check_next_n(random_access_iterator<const char*>(s+10), -10, random_access_iterator<const char*>(s));
check_next_n(s, 10, s+10); check_next_n(s, 10, s+10);
check_next_1(input_iterator<const char*>(s), input_iterator<const char*>(s+1)); check_next_1(cpp17_input_iterator<const char*>(s), cpp17_input_iterator<const char*>(s+1));
check_next_1(forward_iterator<const char*>(s), forward_iterator<const char*>(s+1)); check_next_1(forward_iterator<const char*>(s), forward_iterator<const char*>(s+1));
check_next_1(bidirectional_iterator<const char*>(s), bidirectional_iterator<const char*>(s+1)); check_next_1(bidirectional_iterator<const char*>(s), bidirectional_iterator<const char*>(s+1));
check_next_1(random_access_iterator<const char*>(s), random_access_iterator<const char*>(s+1)); check_next_1(random_access_iterator<const char*>(s), random_access_iterator<const char*>(s+1));
check_next_1(s, s+1); check_next_1(s, s+1);
return true; return true;
} }
int main(int, char**) int main(int, char**)
{ {
tests(); tests();
#if TEST_STD_VER >= 17 #if TEST_STD_VER >= 17
static_assert(tests(), ""); static_assert(tests(), "");
#endif #endif
return 0; return 0;
} }

libcxx/test/std/iterators/iterator.primitives/iterator.traits/cxx20_iterator_traits.compile.pass.cpp

Show First 20 Lines • Show All 605 Lines • ▼ Show 20 Lines
static_assert( static_assert(
std::same_as<LegacyRandomAccessSpecializedTraits::reference, short&>); std::same_as<LegacyRandomAccessSpecializedTraits::reference, short&>);
static_assert( static_assert(
std::same_as<LegacyRandomAccessSpecializedTraits::pointer, short*>); std::same_as<LegacyRandomAccessSpecializedTraits::pointer, short*>);
static_assert(!has_iterator_concept_v<LegacyRandomAccessSpecializedTraits>); static_assert(!has_iterator_concept_v<LegacyRandomAccessSpecializedTraits>);
// Other test iterators. // Other test iterators.
using InputTestItereatorTraits = std::iterator_traits<input_iterator<int*> >; using InputTestItereatorTraits = std::iterator_traits<cpp17_input_iterator<int*> >;
static_assert(std::same_as<InputTestItereatorTraits::iterator_category, static_assert(std::same_as<InputTestItereatorTraits::iterator_category,
std::input_iterator_tag>); std::input_iterator_tag>);
static_assert(std::same_as<InputTestItereatorTraits::value_type, int>); static_assert(std::same_as<InputTestItereatorTraits::value_type, int>);
static_assert(std::same_as<InputTestItereatorTraits::difference_type, std::ptrdiff_t>); static_assert(std::same_as<InputTestItereatorTraits::difference_type, std::ptrdiff_t>);
static_assert(std::same_as<InputTestItereatorTraits::reference, int&>); static_assert(std::same_as<InputTestItereatorTraits::reference, int&>);
static_assert(std::same_as<InputTestItereatorTraits::pointer, int*>); static_assert(std::same_as<InputTestItereatorTraits::pointer, int*>);
static_assert(!has_iterator_concept_v<InputTestItereatorTraits>); static_assert(!has_iterator_concept_v<InputTestItereatorTraits>);
▲ Show 20 Lines • Show All 74 Lines • Show Last 20 Lines

libcxx/test/std/iterators/iterator.primitives/iterator.traits/iter_reference_t.compile.pass.cpp

Show All 12 Lines
// using iter_reference_t = decltype(*declval<T&>()); // using iter_reference_t = decltype(*declval<T&>());
#include <iterator> #include <iterator>
#include <concepts> #include <concepts>
#include "test_iterators.h" #include "test_iterators.h"
static_assert(std::same_as<std::iter_reference_t<input_iterator<int*> >, int&>); static_assert(std::same_as<std::iter_reference_t<cpp17_input_iterator<int*> >, int&>);
static_assert(std::same_as<std::iter_reference_t<forward_iterator<int*> >, int&>); static_assert(std::same_as<std::iter_reference_t<forward_iterator<int*> >, int&>);
static_assert(std::same_as<std::iter_reference_t<bidirectional_iterator<int*> >, int&>); static_assert(std::same_as<std::iter_reference_t<bidirectional_iterator<int*> >, int&>);
static_assert(std::same_as<std::iter_reference_t<random_access_iterator<int*> >, int&>); static_assert(std::same_as<std::iter_reference_t<random_access_iterator<int*> >, int&>);

libcxx/test/std/iterators/iterator.requirements/iterator.concepts/iterator.concept.input/input_iterator.compile.pass.cpp

Show All 11 Lines
// template<class T> // template<class T>
// concept input_iterator; // concept input_iterator;
#include <iterator> #include <iterator>
#include "test_iterators.h" #include "test_iterators.h"
static_assert(std::input_iterator<input_iterator<int*> >); static_assert(std::input_iterator<cpp17_input_iterator<int*> >);
static_assert(std::input_iterator<cpp20_input_iterator<int*> >); static_assert(std::input_iterator<cpp20_input_iterator<int*> >);
struct no_explicit_iter_concept { struct no_explicit_iter_concept {
using value_type = int; using value_type = int;
using difference_type = std::ptrdiff_t; using difference_type = std::ptrdiff_t;
no_explicit_iter_concept() = default; no_explicit_iter_concept() = default;
▲ Show 20 Lines • Show All 96 Lines • Show Last 20 Lines

libcxx/test/std/iterators/iterator.requirements/iterator.concepts/iterator.concept.iterator/input_or_output_iterator.compile.pass.cpp

Show All 16 Lines
#include "test_iterators.h" #include "test_iterators.h"
static_assert(std::input_or_output_iterator<int*>); static_assert(std::input_or_output_iterator<int*>);
static_assert(std::input_or_output_iterator<int const*>); static_assert(std::input_or_output_iterator<int const*>);
static_assert(std::input_or_output_iterator<int volatile*>); static_assert(std::input_or_output_iterator<int volatile*>);
static_assert(std::input_or_output_iterator<int const volatile*>); static_assert(std::input_or_output_iterator<int const volatile*>);
static_assert(std::input_or_output_iterator<input_iterator<int*> >); static_assert(std::input_or_output_iterator<cpp17_input_iterator<int*> >);
static_assert(std::input_or_output_iterator<input_iterator<int const*> >); static_assert(std::input_or_output_iterator<cpp17_input_iterator<int const*> >);
static_assert(std::input_or_output_iterator<input_iterator<int volatile*> >); static_assert(std::input_or_output_iterator<cpp17_input_iterator<int volatile*> >);
static_assert(std::input_or_output_iterator<input_iterator<int const volatile*> >); static_assert(std::input_or_output_iterator<cpp17_input_iterator<int const volatile*> >);
static_assert(std::input_or_output_iterator<forward_iterator<int*> >); static_assert(std::input_or_output_iterator<forward_iterator<int*> >);
static_assert(std::input_or_output_iterator<forward_iterator<int const*> >); static_assert(std::input_or_output_iterator<forward_iterator<int const*> >);
static_assert(std::input_or_output_iterator<forward_iterator<int volatile*> >); static_assert(std::input_or_output_iterator<forward_iterator<int volatile*> >);
static_assert(std::input_or_output_iterator<forward_iterator<int const volatile*> >); static_assert(std::input_or_output_iterator<forward_iterator<int const volatile*> >);
static_assert(std::input_or_output_iterator<bidirectional_iterator<int*> >); static_assert(std::input_or_output_iterator<bidirectional_iterator<int*> >);
static_assert(std::input_or_output_iterator<bidirectional_iterator<int const*> >); static_assert(std::input_or_output_iterator<bidirectional_iterator<int const*> >);
▲ Show 20 Lines • Show All 41 Lines • Show Last 20 Lines

libcxx/test/std/iterators/predef.iterators/move.iterators/move.iter.ops/move.iter.nonmember/make_move_iterator.pass.cpp

Show All 28 Linestest(It i)
const std::move_iterator<It> r(i); const std::move_iterator<It> r(i);
assert(std::make_move_iterator(i) == r); assert(std::make_move_iterator(i) == r);
} }
int main(int, char**) int main(int, char**)
{ {
{ {
char s[] = "1234567890"; char s[] = "1234567890";
test(input_iterator<char*>(s+5)); test(cpp17_input_iterator<char*>(s+5));
test(forward_iterator<char*>(s+5)); test(forward_iterator<char*>(s+5));
test(bidirectional_iterator<char*>(s+5)); test(bidirectional_iterator<char*>(s+5));
test(random_access_iterator<char*>(s+5)); test(random_access_iterator<char*>(s+5));
test(s+5); test(s+5);
} }
{ {
int a[] = {1,2,3,4}; int a[] = {1,2,3,4};
TEST_IGNORE_NODISCARD std::make_move_iterator(a+4); TEST_IGNORE_NODISCARD std::make_move_iterator(a+4);
Show All 13 Lines

libcxx/test/std/iterators/predef.iterators/move.iterators/move.iter.ops/move.iter.op.comp/op_eq.pass.cpp

Show All 29 Linestest(It l, It r, bool x)
const std::move_iterator<It> r1(l); const std::move_iterator<It> r1(l);
const std::move_iterator<It> r2(r); const std::move_iterator<It> r2(r);
assert((r1 == r2) == x); assert((r1 == r2) == x);
} }
int main(int, char**) int main(int, char**)
{ {
char s[] = "1234567890"; char s[] = "1234567890";
test(input_iterator<char*>(s), input_iterator<char*>(s), true); test(cpp17_input_iterator<char*>(s), cpp17_input_iterator<char*>(s), true);
test(input_iterator<char*>(s), input_iterator<char*>(s+1), false); test(cpp17_input_iterator<char*>(s), cpp17_input_iterator<char*>(s+1), false);
test(forward_iterator<char*>(s), forward_iterator<char*>(s), true); test(forward_iterator<char*>(s), forward_iterator<char*>(s), true);
test(forward_iterator<char*>(s), forward_iterator<char*>(s+1), false); test(forward_iterator<char*>(s), forward_iterator<char*>(s+1), false);
test(bidirectional_iterator<char*>(s), bidirectional_iterator<char*>(s), true); test(bidirectional_iterator<char*>(s), bidirectional_iterator<char*>(s), true);
test(bidirectional_iterator<char*>(s), bidirectional_iterator<char*>(s+1), false); test(bidirectional_iterator<char*>(s), bidirectional_iterator<char*>(s+1), false);
test(random_access_iterator<char*>(s), random_access_iterator<char*>(s), true); test(random_access_iterator<char*>(s), random_access_iterator<char*>(s), true);
test(random_access_iterator<char*>(s), random_access_iterator<char*>(s+1), false); test(random_access_iterator<char*>(s), random_access_iterator<char*>(s+1), false);
test(s, s, true); test(s, s, true);
test(s, s+1, false); test(s, s+1, false);
Show All 16 Lines

libcxx/test/std/iterators/predef.iterators/move.iterators/move.iter.ops/move.iter.op.comp/op_neq.pass.cpp

Show All 29 Linestest(It l, It r, bool x)
const std::move_iterator<It> r1(l); const std::move_iterator<It> r1(l);
const std::move_iterator<It> r2(r); const std::move_iterator<It> r2(r);
assert((r1 != r2) == x); assert((r1 != r2) == x);
} }
int main(int, char**) int main(int, char**)
{ {
char s[] = "1234567890"; char s[] = "1234567890";
test(input_iterator<char*>(s), input_iterator<char*>(s), false); test(cpp17_input_iterator<char*>(s), cpp17_input_iterator<char*>(s), false);
test(input_iterator<char*>(s), input_iterator<char*>(s+1), true); test(cpp17_input_iterator<char*>(s), cpp17_input_iterator<char*>(s+1), true);
test(forward_iterator<char*>(s), forward_iterator<char*>(s), false); test(forward_iterator<char*>(s), forward_iterator<char*>(s), false);
test(forward_iterator<char*>(s), forward_iterator<char*>(s+1), true); test(forward_iterator<char*>(s), forward_iterator<char*>(s+1), true);
test(bidirectional_iterator<char*>(s), bidirectional_iterator<char*>(s), false); test(bidirectional_iterator<char*>(s), bidirectional_iterator<char*>(s), false);
test(bidirectional_iterator<char*>(s), bidirectional_iterator<char*>(s+1), true); test(bidirectional_iterator<char*>(s), bidirectional_iterator<char*>(s+1), true);
test(random_access_iterator<char*>(s), random_access_iterator<char*>(s), false); test(random_access_iterator<char*>(s), random_access_iterator<char*>(s), false);
test(random_access_iterator<char*>(s), random_access_iterator<char*>(s+1), true); test(random_access_iterator<char*>(s), random_access_iterator<char*>(s+1), true);
test(s, s, false); test(s, s, false);
test(s, s+1, true); test(s, s+1, true);
Show All 16 Lines

libcxx/test/std/iterators/predef.iterators/move.iterators/move.iter.ops/move.iter.op.const/convert.pass.cpp

Show All 32 Lines
struct Base {}; struct Base {};
struct Derived : Base {}; struct Derived : Base {};
int main(int, char**) int main(int, char**)
{ {
Derived d; Derived d;
test<input_iterator<Base*> >(input_iterator<Derived*>(&d)); test<cpp17_input_iterator<Base*> >(cpp17_input_iterator<Derived*>(&d));
test<forward_iterator<Base*> >(forward_iterator<Derived*>(&d)); test<forward_iterator<Base*> >(forward_iterator<Derived*>(&d));
test<bidirectional_iterator<Base*> >(bidirectional_iterator<Derived*>(&d)); test<bidirectional_iterator<Base*> >(bidirectional_iterator<Derived*>(&d));
test<random_access_iterator<const Base*> >(random_access_iterator<Derived*>(&d)); test<random_access_iterator<const Base*> >(random_access_iterator<Derived*>(&d));
test<Base*>(&d); test<Base*>(&d);
#if TEST_STD_VER > 14 #if TEST_STD_VER > 14
{ {
constexpr const Derived *p = nullptr; constexpr const Derived *p = nullptr;
constexpr std::move_iterator<const Derived *> it1 = std::make_move_iterator(p); constexpr std::move_iterator<const Derived *> it1 = std::make_move_iterator(p);
constexpr std::move_iterator<const Base *> it2(it1); constexpr std::move_iterator<const Base *> it2(it1);
static_assert(it2.base() == p); static_assert(it2.base() == p);
} }
#endif #endif
return 0; return 0;
} }

libcxx/test/std/iterators/predef.iterators/move.iterators/move.iter.ops/move.iter.op.const/default.pass.cpp

Show All 23 Lines
test() test()
{ {
std::move_iterator<It> r; std::move_iterator<It> r;
(void)r; (void)r;
} }
int main(int, char**) int main(int, char**)
{ {
test<input_iterator<char*> >(); test<cpp17_input_iterator<char*> >();
test<forward_iterator<char*> >(); test<forward_iterator<char*> >();
test<bidirectional_iterator<char*> >(); test<bidirectional_iterator<char*> >();
test<random_access_iterator<char*> >(); test<random_access_iterator<char*> >();
test<char*>(); test<char*>();
#if TEST_STD_VER > 14 #if TEST_STD_VER > 14
{ {
constexpr std::move_iterator<const char *> it; constexpr std::move_iterator<const char *> it;
(void)it; (void)it;
} }
#endif #endif
return 0; return 0;
} }

libcxx/test/std/iterators/predef.iterators/move.iterators/move.iter.ops/move.iter.op.const/iter.pass.cpp

Show All 25 Lines
{ {
std::move_iterator<It> r(i); std::move_iterator<It> r(i);
assert(r.base() == i); assert(r.base() == i);
} }
int main(int, char**) int main(int, char**)
{ {
char s[] = "123"; char s[] = "123";
test(input_iterator<char*>(s)); test(cpp17_input_iterator<char*>(s));
test(forward_iterator<char*>(s)); test(forward_iterator<char*>(s));
test(bidirectional_iterator<char*>(s)); test(bidirectional_iterator<char*>(s));
test(random_access_iterator<char*>(s)); test(random_access_iterator<char*>(s));
test(s); test(s);
#if TEST_STD_VER > 14 #if TEST_STD_VER > 14
{ {
constexpr const char *p = "123456789"; constexpr const char *p = "123456789";
constexpr std::move_iterator<const char *> it(p); constexpr std::move_iterator<const char *> it(p);
static_assert(it.base() == p); static_assert(it.base() == p);
} }
#endif #endif
return 0; return 0;
} }

libcxx/test/std/iterators/predef.iterators/move.iterators/move.iter.ops/move.iter.op.incr/post.pass.cpp

Show All 38 Linestest(It i, It x)
assert(r.base() == x); assert(r.base() == x);
assert(rr.base() == i); assert(rr.base() == i);
} }
int main(int, char**) int main(int, char**)
{ {
char s[] = "123"; char s[] = "123";
#if TEST_STD_VER > 17 #if TEST_STD_VER > 17
test_single_pass(input_iterator<char*>(s), input_iterator<char*>(s + 1)); test_single_pass(cpp17_input_iterator<char*>(s), cpp17_input_iterator<char*>(s + 1));
#else #else
test(input_iterator<char*>(s), input_iterator<char*>(s+1)); test(cpp17_input_iterator<char*>(s), cpp17_input_iterator<char*>(s+1));
#endif #endif
test(forward_iterator<char*>(s), forward_iterator<char*>(s+1)); test(forward_iterator<char*>(s), forward_iterator<char*>(s+1));
test(bidirectional_iterator<char*>(s), bidirectional_iterator<char*>(s+1)); test(bidirectional_iterator<char*>(s), bidirectional_iterator<char*>(s+1));
test(random_access_iterator<char*>(s), random_access_iterator<char*>(s+1)); test(random_access_iterator<char*>(s), random_access_iterator<char*>(s+1));
test(s, s+1); test(s, s+1);
#if TEST_STD_VER > 14 #if TEST_STD_VER > 14
{ {
Show All 13 Lines

libcxx/test/std/iterators/predef.iterators/move.iterators/move.iter.ops/move.iter.op.incr/pre.pass.cpp

Show All 27 Linestest(It i, It x)
std::move_iterator<It>& rr = ++r; std::move_iterator<It>& rr = ++r;
assert(r.base() == x); assert(r.base() == x);
assert(&rr == &r); assert(&rr == &r);
} }
int main(int, char**) int main(int, char**)
{ {
char s[] = "123"; char s[] = "123";
test(input_iterator<char*>(s), input_iterator<char*>(s+1)); test(cpp17_input_iterator<char*>(s), cpp17_input_iterator<char*>(s+1));
test(forward_iterator<char*>(s), forward_iterator<char*>(s+1)); test(forward_iterator<char*>(s), forward_iterator<char*>(s+1));
test(bidirectional_iterator<char*>(s), bidirectional_iterator<char*>(s+1)); test(bidirectional_iterator<char*>(s), bidirectional_iterator<char*>(s+1));
test(random_access_iterator<char*>(s), random_access_iterator<char*>(s+1)); test(random_access_iterator<char*>(s), random_access_iterator<char*>(s+1));
test(s, s+1); test(s, s+1);
#if TEST_STD_VER > 14 #if TEST_STD_VER > 14
{ {
constexpr const char *p = "123456789"; constexpr const char *p = "123456789";
Show All 12 Lines

libcxx/test/std/iterators/predef.iterators/move.iterators/move.iter.ops/move.iter.op=/move_iterator.pass.cpp

Show All 35 Lines
struct Base {}; struct Base {};
struct Derived : Base {}; struct Derived : Base {};
int main(int, char**) int main(int, char**)
{ {
Derived d; Derived d;
test<input_iterator<Base*> >(input_iterator<Derived*>(&d)); test<cpp17_input_iterator<Base*> >(cpp17_input_iterator<Derived*>(&d));
test<forward_iterator<Base*> >(forward_iterator<Derived*>(&d)); test<forward_iterator<Base*> >(forward_iterator<Derived*>(&d));
test<bidirectional_iterator<Base*> >(bidirectional_iterator<Derived*>(&d)); test<bidirectional_iterator<Base*> >(bidirectional_iterator<Derived*>(&d));
test<random_access_iterator<const Base*> >(random_access_iterator<Derived*>(&d)); test<random_access_iterator<const Base*> >(random_access_iterator<Derived*>(&d));
test<Base*>(&d); test<Base*>(&d);
#if TEST_STD_VER > 14 #if TEST_STD_VER > 14
{ {
using BaseIter = std::move_iterator<const Base *>; using BaseIter = std::move_iterator<const Base *>;
using DerivedIter = std::move_iterator<const Derived *>; using DerivedIter = std::move_iterator<const Derived *>;
Show All 9 Lines

libcxx/test/std/iterators/predef.iterators/move.iterators/move.iterator/types.pass.cpp

Show First 20 Lines • Show All 61 Lines • ▼ Show 20 Lines#if TEST_STD_VER > 17
} }
#else #else
static_assert((std::is_same<typename R::iterator_category, typename T::iterator_category>::value), ""); static_assert((std::is_same<typename R::iterator_category, typename T::iterator_category>::value), "");
#endif #endif
} }
int main(int, char**) int main(int, char**)
{ {
test<input_iterator<char*> >(); test<cpp17_input_iterator<char*> >();
test<forward_iterator<char*> >(); test<forward_iterator<char*> >();
test<bidirectional_iterator<char*> >(); test<bidirectional_iterator<char*> >();
test<random_access_iterator<char*> >(); test<random_access_iterator<char*> >();
test<char*>(); test<char*>();
#if TEST_STD_VER >= 11 #if TEST_STD_VER >= 11
{ {
typedef DummyIt<int, int> T; typedef DummyIt<int, int> T;
typedef std::move_iterator<T> It; typedef std::move_iterator<T> It;
Show All 37 Lines

libcxx/test/std/localization/locale.categories/category.monetary/locale.money.get/locale.money.get.members/get_long_double_en_US.pass.cpp

Show All 19 Lines
#include <ios> #include <ios>
#include <streambuf> #include <streambuf>
#include <cassert> #include <cassert>
#include "test_macros.h" #include "test_macros.h"
#include "test_iterators.h" #include "test_iterators.h"
#include "platform_support.h" // locale name macros #include "platform_support.h" // locale name macros
typedef std::money_get<char, input_iterator<const char*> > Fn; typedef std::money_get<char, cpp17_input_iterator<const char*> > Fn;
class my_facet class my_facet
: public Fn : public Fn
{ {
public: public:
explicit my_facet(std::size_t refs = 0) explicit my_facet(std::size_t refs = 0)
: Fn(refs) {} : Fn(refs) {}
}; };
typedef std::money_get<wchar_t, input_iterator<const wchar_t*> > Fw; typedef std::money_get<wchar_t, cpp17_input_iterator<const wchar_t*> > Fw;
class my_facetw class my_facetw
: public Fw : public Fw
{ {
public: public:
explicit my_facetw(std::size_t refs = 0) explicit my_facetw(std::size_t refs = 0)
: Fw(refs) {} : Fw(refs) {}
}; };
Show All 10 Lines ios.imbue(std::locale(ios.getloc(),
new std::moneypunct_byname<wchar_t, false>(loc_name))); new std::moneypunct_byname<wchar_t, false>(loc_name)));
ios.imbue(std::locale(ios.getloc(), ios.imbue(std::locale(ios.getloc(),
new std::moneypunct_byname<wchar_t, true>(loc_name))); new std::moneypunct_byname<wchar_t, true>(loc_name)));
{ {
const my_facet f(1); const my_facet f(1);
// char, national // char, national
{ // zero { // zero
std::string v = "0.00"; std::string v = "0.00";
typedef input_iterator<const char*> I; typedef cpp17_input_iterator<const char*> I;
long double ex; long double ex;
std::ios_base::iostate err = std::ios_base::goodbit; std::ios_base::iostate err = std::ios_base::goodbit;
I iter = f.get(I(v.data()), I(v.data() + v.size()), I iter = f.get(I(v.data()), I(v.data() + v.size()),
false, ios, err, ex); false, ios, err, ex);
assert(iter.base() == v.data() + v.size()); assert(iter.base() == v.data() + v.size());
assert(err == std::ios_base::eofbit); assert(err == std::ios_base::eofbit);
assert(ex == 0); assert(ex == 0);
} }
{ // negative one { // negative one
std::string v = "-0.01"; std::string v = "-0.01";
typedef input_iterator<const char*> I; typedef cpp17_input_iterator<const char*> I;
long double ex; long double ex;
std::ios_base::iostate err = std::ios_base::goodbit; std::ios_base::iostate err = std::ios_base::goodbit;
I iter = f.get(I(v.data()), I(v.data() + v.size()), I iter = f.get(I(v.data()), I(v.data() + v.size()),
false, ios, err, ex); false, ios, err, ex);
assert(iter.base() == v.data() + v.size()); assert(iter.base() == v.data() + v.size());
assert(err == std::ios_base::eofbit); assert(err == std::ios_base::eofbit);
assert(ex == -1); assert(ex == -1);
} }
{ // positive { // positive
std::string v = "1,234,567.89"; std::string v = "1,234,567.89";
typedef input_iterator<const char*> I; typedef cpp17_input_iterator<const char*> I;
long double ex; long double ex;
std::ios_base::iostate err = std::ios_base::goodbit; std::ios_base::iostate err = std::ios_base::goodbit;
I iter = f.get(I(v.data()), I(v.data() + v.size()), I iter = f.get(I(v.data()), I(v.data() + v.size()),
false, ios, err, ex); false, ios, err, ex);
assert(iter.base() == v.data() + v.size()); assert(iter.base() == v.data() + v.size());
assert(err == std::ios_base::eofbit); assert(err == std::ios_base::eofbit);
assert(ex == 123456789); assert(ex == 123456789);
} }
{ // negative { // negative
std::string v = "-1,234,567.89"; std::string v = "-1,234,567.89";
typedef input_iterator<const char*> I; typedef cpp17_input_iterator<const char*> I;
long double ex; long double ex;
std::ios_base::iostate err = std::ios_base::goodbit; std::ios_base::iostate err = std::ios_base::goodbit;
I iter = f.get(I(v.data()), I(v.data() + v.size()), I iter = f.get(I(v.data()), I(v.data() + v.size()),
false, ios, err, ex); false, ios, err, ex);
assert(iter.base() == v.data() + v.size()); assert(iter.base() == v.data() + v.size());
assert(err == std::ios_base::eofbit); assert(err == std::ios_base::eofbit);
assert(ex == -123456789); assert(ex == -123456789);
} }
{ // negative { // negative
std::string v = "-1234567.89"; std::string v = "-1234567.89";
typedef input_iterator<const char*> I; typedef cpp17_input_iterator<const char*> I;
long double ex; long double ex;
std::ios_base::iostate err = std::ios_base::goodbit; std::ios_base::iostate err = std::ios_base::goodbit;
I iter = f.get(I(v.data()), I(v.data() + v.size()), I iter = f.get(I(v.data()), I(v.data() + v.size()),
false, ios, err, ex); false, ios, err, ex);
assert(iter.base() == v.data() + v.size()); assert(iter.base() == v.data() + v.size());
assert(err == std::ios_base::eofbit); assert(err == std::ios_base::eofbit);
assert(ex == -123456789); assert(ex == -123456789);
} }
{ // zero, showbase { // zero, showbase
std::string v = "$0.00"; std::string v = "$0.00";
typedef input_iterator<const char*> I; typedef cpp17_input_iterator<const char*> I;
long double ex; long double ex;
std::ios_base::iostate err = std::ios_base::goodbit; std::ios_base::iostate err = std::ios_base::goodbit;
I iter = f.get(I(v.data()), I(v.data() + v.size()), I iter = f.get(I(v.data()), I(v.data() + v.size()),
false, ios, err, ex); false, ios, err, ex);
assert(iter.base() == v.data() + v.size()); assert(iter.base() == v.data() + v.size());
assert(err == std::ios_base::eofbit); assert(err == std::ios_base::eofbit);
assert(ex == 0); assert(ex == 0);
} }
{ // zero, showbase { // zero, showbase
std::string v = "$0.00"; std::string v = "$0.00";
showbase(ios); showbase(ios);
typedef input_iterator<const char*> I; typedef cpp17_input_iterator<const char*> I;
long double ex; long double ex;
std::ios_base::iostate err = std::ios_base::goodbit; std::ios_base::iostate err = std::ios_base::goodbit;
I iter = f.get(I(v.data()), I(v.data() + v.size()), I iter = f.get(I(v.data()), I(v.data() + v.size()),
false, ios, err, ex); false, ios, err, ex);
assert(iter.base() == v.data() + v.size()); assert(iter.base() == v.data() + v.size());
assert(err == std::ios_base::eofbit); assert(err == std::ios_base::eofbit);
assert(ex == 0); assert(ex == 0);
noshowbase(ios); noshowbase(ios);
} }
{ // negative one, showbase { // negative one, showbase
std::string v = "-$0.01"; std::string v = "-$0.01";
typedef input_iterator<const char*> I; typedef cpp17_input_iterator<const char*> I;
long double ex; long double ex;
std::ios_base::iostate err = std::ios_base::goodbit; std::ios_base::iostate err = std::ios_base::goodbit;
I iter = f.get(I(v.data()), I(v.data() + v.size()), I iter = f.get(I(v.data()), I(v.data() + v.size()),
false, ios, err, ex); false, ios, err, ex);
assert(iter.base() == v.data() + v.size()); assert(iter.base() == v.data() + v.size());
assert(err == std::ios_base::eofbit); assert(err == std::ios_base::eofbit);
assert(ex == -1); assert(ex == -1);
} }
{ // negative one, showbase { // negative one, showbase
std::string v = "-$0.01"; std::string v = "-$0.01";
showbase(ios); showbase(ios);
typedef input_iterator<const char*> I; typedef cpp17_input_iterator<const char*> I;
long double ex; long double ex;
std::ios_base::iostate err = std::ios_base::goodbit; std::ios_base::iostate err = std::ios_base::goodbit;
I iter = f.get(I(v.data()), I(v.data() + v.size()), I iter = f.get(I(v.data()), I(v.data() + v.size()),
false, ios, err, ex); false, ios, err, ex);
assert(iter.base() == v.data() + v.size()); assert(iter.base() == v.data() + v.size());
assert(err == std::ios_base::eofbit); assert(err == std::ios_base::eofbit);
assert(ex == -1); assert(ex == -1);
noshowbase(ios); noshowbase(ios);
} }
{ // positive, showbase { // positive, showbase
std::string v = "$1,234,567.89"; std::string v = "$1,234,567.89";
typedef input_iterator<const char*> I; typedef cpp17_input_iterator<const char*> I;
long double ex; long double ex;
std::ios_base::iostate err = std::ios_base::goodbit; std::ios_base::iostate err = std::ios_base::goodbit;
I iter = f.get(I(v.data()), I(v.data() + v.size()), I iter = f.get(I(v.data()), I(v.data() + v.size()),
false, ios, err, ex); false, ios, err, ex);
assert(iter.base() == v.data() + v.size()); assert(iter.base() == v.data() + v.size());
assert(err == std::ios_base::eofbit); assert(err == std::ios_base::eofbit);
assert(ex == 123456789); assert(ex == 123456789);
} }
{ // positive, showbase { // positive, showbase
std::string v = "$1,234,567.89"; std::string v = "$1,234,567.89";
showbase(ios); showbase(ios);
typedef input_iterator<const char*> I; typedef cpp17_input_iterator<const char*> I;
long double ex; long double ex;
std::ios_base::iostate err = std::ios_base::goodbit; std::ios_base::iostate err = std::ios_base::goodbit;
I iter = f.get(I(v.data()), I(v.data() + v.size()), I iter = f.get(I(v.data()), I(v.data() + v.size()),
false, ios, err, ex); false, ios, err, ex);
assert(iter.base() == v.data() + v.size()); assert(iter.base() == v.data() + v.size());
assert(err == std::ios_base::eofbit); assert(err == std::ios_base::eofbit);
assert(ex == 123456789); assert(ex == 123456789);
noshowbase(ios); noshowbase(ios);
} }
{ // negative, showbase { // negative, showbase
std::string v = "-$1,234,567.89"; std::string v = "-$1,234,567.89";
showbase(ios); showbase(ios);
typedef input_iterator<const char*> I; typedef cpp17_input_iterator<const char*> I;
long double ex; long double ex;
std::ios_base::iostate err = std::ios_base::goodbit; std::ios_base::iostate err = std::ios_base::goodbit;
I iter = f.get(I(v.data()), I(v.data() + v.size()), I iter = f.get(I(v.data()), I(v.data() + v.size()),
false, ios, err, ex); false, ios, err, ex);
assert(iter.base() == v.data() + v.size()); assert(iter.base() == v.data() + v.size());
assert(err == std::ios_base::eofbit); assert(err == std::ios_base::eofbit);
assert(ex == -123456789); assert(ex == -123456789);
noshowbase(ios); noshowbase(ios);
} }
{ // negative, showbase { // negative, showbase
std::string v = "-USD 1,234,567.89"; std::string v = "-USD 1,234,567.89";
showbase(ios); showbase(ios);
typedef input_iterator<const char*> I; typedef cpp17_input_iterator<const char*> I;
long double ex; long double ex;
std::ios_base::iostate err = std::ios_base::goodbit; std::ios_base::iostate err = std::ios_base::goodbit;
I iter = f.get(I(v.data()), I(v.data() + v.size()), I iter = f.get(I(v.data()), I(v.data() + v.size()),
false, ios, err, ex); false, ios, err, ex);
assert(iter.base() == v.data() + 1); assert(iter.base() == v.data() + 1);
assert(err == std::ios_base::failbit); assert(err == std::ios_base::failbit);
noshowbase(ios); noshowbase(ios);
} }
{ // negative, showbase { // negative, showbase
std::string v = "-USD 1,234,567.89"; std::string v = "-USD 1,234,567.89";
typedef input_iterator<const char*> I; typedef cpp17_input_iterator<const char*> I;
long double ex; long double ex;
std::ios_base::iostate err = std::ios_base::goodbit; std::ios_base::iostate err = std::ios_base::goodbit;
I iter = f.get(I(v.data()), I(v.data() + v.size()), I iter = f.get(I(v.data()), I(v.data() + v.size()),
false, ios, err, ex); false, ios, err, ex);
assert(iter.base() == v.data() + 1); assert(iter.base() == v.data() + 1);
assert(err == std::ios_base::failbit); assert(err == std::ios_base::failbit);
} }
} }
{ {
const my_facet f(1); const my_facet f(1);
// char, international // char, international
{ // zero { // zero
std::string v = "0.00"; std::string v = "0.00";
typedef input_iterator<const char*> I; typedef cpp17_input_iterator<const char*> I;
long double ex; long double ex;
std::ios_base::iostate err = std::ios_base::goodbit; std::ios_base::iostate err = std::ios_base::goodbit;
I iter = f.get(I(v.data()), I(v.data() + v.size()), I iter = f.get(I(v.data()), I(v.data() + v.size()),
true, ios, err, ex); true, ios, err, ex);
assert(iter.base() == v.data() + v.size()); assert(iter.base() == v.data() + v.size());
assert(err == std::ios_base::eofbit); assert(err == std::ios_base::eofbit);
assert(ex == 0); assert(ex == 0);
} }
{ // negative one { // negative one
std::string v = "-0.01"; std::string v = "-0.01";
typedef input_iterator<const char*> I; typedef cpp17_input_iterator<const char*> I;
long double ex; long double ex;
std::ios_base::iostate err = std::ios_base::goodbit; std::ios_base::iostate err = std::ios_base::goodbit;
I iter = f.get(I(v.data()), I(v.data() + v.size()), I iter = f.get(I(v.data()), I(v.data() + v.size()),
true, ios, err, ex); true, ios, err, ex);
assert(iter.base() == v.data() + v.size()); assert(iter.base() == v.data() + v.size());
assert(err == std::ios_base::eofbit); assert(err == std::ios_base::eofbit);
assert(ex == -1); assert(ex == -1);
} }
{ // positive { // positive
std::string v = "1,234,567.89"; std::string v = "1,234,567.89";
typedef input_iterator<const char*> I; typedef cpp17_input_iterator<const char*> I;
long double ex; long double ex;
std::ios_base::iostate err = std::ios_base::goodbit; std::ios_base::iostate err = std::ios_base::goodbit;
I iter = f.get(I(v.data()), I(v.data() + v.size()), I iter = f.get(I(v.data()), I(v.data() + v.size()),
true, ios, err, ex); true, ios, err, ex);
assert(iter.base() == v.data() + v.size()); assert(iter.base() == v.data() + v.size());
assert(err == std::ios_base::eofbit); assert(err == std::ios_base::eofbit);
assert(ex == 123456789); assert(ex == 123456789);
} }
{ // negative { // negative
std::string v = "-1,234,567.89"; std::string v = "-1,234,567.89";
typedef input_iterator<const char*> I; typedef cpp17_input_iterator<const char*> I;
long double ex; long double ex;
std::ios_base::iostate err = std::ios_base::goodbit; std::ios_base::iostate err = std::ios_base::goodbit;
I iter = f.get(I(v.data()), I(v.data() + v.size()), I iter = f.get(I(v.data()), I(v.data() + v.size()),
true, ios, err, ex); true, ios, err, ex);
assert(iter.base() == v.data() + v.size()); assert(iter.base() == v.data() + v.size());
assert(err == std::ios_base::eofbit); assert(err == std::ios_base::eofbit);
assert(ex == -123456789); assert(ex == -123456789);
} }
{ // negative { // negative
std::string v = "-1234567.89"; std::string v = "-1234567.89";
typedef input_iterator<const char*> I; typedef cpp17_input_iterator<const char*> I;
long double ex; long double ex;
std::ios_base::iostate err = std::ios_base::goodbit; std::ios_base::iostate err = std::ios_base::goodbit;
I iter = f.get(I(v.data()), I(v.data() + v.size()), I iter = f.get(I(v.data()), I(v.data() + v.size()),
true, ios, err, ex); true, ios, err, ex);
assert(iter.base() == v.data() + v.size()); assert(iter.base() == v.data() + v.size());
assert(err == std::ios_base::eofbit); assert(err == std::ios_base::eofbit);
assert(ex == -123456789); assert(ex == -123456789);
} }
{ // zero, showbase { // zero, showbase
std::string v = "USD 0.00"; std::string v = "USD 0.00";
typedef input_iterator<const char*> I; typedef cpp17_input_iterator<const char*> I;
long double ex; long double ex;
std::ios_base::iostate err = std::ios_base::goodbit; std::ios_base::iostate err = std::ios_base::goodbit;
I iter = f.get(I(v.data()), I(v.data() + v.size()), I iter = f.get(I(v.data()), I(v.data() + v.size()),
true, ios, err, ex); true, ios, err, ex);
assert(iter.base() == v.data() + v.size()); assert(iter.base() == v.data() + v.size());
assert(err == std::ios_base::eofbit); assert(err == std::ios_base::eofbit);
assert(ex == 0); assert(ex == 0);
} }
{ // zero, showbase { // zero, showbase
std::string v = "USD 0.00"; std::string v = "USD 0.00";
showbase(ios); showbase(ios);
typedef input_iterator<const char*> I; typedef cpp17_input_iterator<const char*> I;
long double ex; long double ex;
std::ios_base::iostate err = std::ios_base::goodbit; std::ios_base::iostate err = std::ios_base::goodbit;
I iter = f.get(I(v.data()), I(v.data() + v.size()), I iter = f.get(I(v.data()), I(v.data() + v.size()),
true, ios, err, ex); true, ios, err, ex);
assert(iter.base() == v.data() + v.size()); assert(iter.base() == v.data() + v.size());
assert(err == std::ios_base::eofbit); assert(err == std::ios_base::eofbit);
assert(ex == 0); assert(ex == 0);
noshowbase(ios); noshowbase(ios);
} }
{ // negative one, showbase { // negative one, showbase
std::string v = "-USD 0.01"; std::string v = "-USD 0.01";
typedef input_iterator<const char*> I; typedef cpp17_input_iterator<const char*> I;
long double ex; long double ex;
std::ios_base::iostate err = std::ios_base::goodbit; std::ios_base::iostate err = std::ios_base::goodbit;
I iter = f.get(I(v.data()), I(v.data() + v.size()), I iter = f.get(I(v.data()), I(v.data() + v.size()),
true, ios, err, ex); true, ios, err, ex);
assert(iter.base() == v.data() + v.size()); assert(iter.base() == v.data() + v.size());
assert(err == std::ios_base::eofbit); assert(err == std::ios_base::eofbit);
assert(ex == -1); assert(ex == -1);
} }
{ // negative one, showbase { // negative one, showbase
std::string v = "-USD 0.01"; std::string v = "-USD 0.01";
showbase(ios); showbase(ios);
typedef input_iterator<const char*> I; typedef cpp17_input_iterator<const char*> I;
long double ex; long double ex;
std::ios_base::iostate err = std::ios_base::goodbit; std::ios_base::iostate err = std::ios_base::goodbit;
I iter = f.get(I(v.data()), I(v.data() + v.size()), I iter = f.get(I(v.data()), I(v.data() + v.size()),
true, ios, err, ex); true, ios, err, ex);
assert(iter.base() == v.data() + v.size()); assert(iter.base() == v.data() + v.size());
assert(err == std::ios_base::eofbit); assert(err == std::ios_base::eofbit);
assert(ex == -1); assert(ex == -1);
noshowbase(ios); noshowbase(ios);
} }
{ // positive, showbase { // positive, showbase
std::string v = "USD 1,234,567.89"; std::string v = "USD 1,234,567.89";
typedef input_iterator<const char*> I; typedef cpp17_input_iterator<const char*> I;
long double ex; long double ex;
std::ios_base::iostate err = std::ios_base::goodbit; std::ios_base::iostate err = std::ios_base::goodbit;
I iter = f.get(I(v.data()), I(v.data() + v.size()), I iter = f.get(I(v.data()), I(v.data() + v.size()),
true, ios, err, ex); true, ios, err, ex);
assert(iter.base() == v.data() + v.size()); assert(iter.base() == v.data() + v.size());
assert(err == std::ios_base::eofbit); assert(err == std::ios_base::eofbit);
assert(ex == 123456789); assert(ex == 123456789);
} }
{ // positive, showbase { // positive, showbase
std::string v = "USD 1,234,567.89"; std::string v = "USD 1,234,567.89";
showbase(ios); showbase(ios);
typedef input_iterator<const char*> I; typedef cpp17_input_iterator<const char*> I;
long double ex; long double ex;
std::ios_base::iostate err = std::ios_base::goodbit; std::ios_base::iostate err = std::ios_base::goodbit;
I iter = f.get(I(v.data()), I(v.data() + v.size()), I iter = f.get(I(v.data()), I(v.data() + v.size()),
true, ios, err, ex); true, ios, err, ex);
assert(iter.base() == v.data() + v.size()); assert(iter.base() == v.data() + v.size());
assert(err == std::ios_base::eofbit); assert(err == std::ios_base::eofbit);
assert(ex == 123456789); assert(ex == 123456789);
noshowbase(ios); noshowbase(ios);
} }
{ // negative, showbase { // negative, showbase
std::string v = "-USD 1,234,567.89"; std::string v = "-USD 1,234,567.89";
showbase(ios); showbase(ios);
typedef input_iterator<const char*> I; typedef cpp17_input_iterator<const char*> I;
long double ex; long double ex;
std::ios_base::iostate err = std::ios_base::goodbit; std::ios_base::iostate err = std::ios_base::goodbit;
I iter = f.get(I(v.data()), I(v.data() + v.size()), I iter = f.get(I(v.data()), I(v.data() + v.size()),
true, ios, err, ex); true, ios, err, ex);
assert(iter.base() == v.data() + v.size()); assert(iter.base() == v.data() + v.size());
assert(err == std::ios_base::eofbit); assert(err == std::ios_base::eofbit);
assert(ex == -123456789); assert(ex == -123456789);
noshowbase(ios); noshowbase(ios);
} }
{ // negative, showbase { // negative, showbase
std::string v = "-$1,234,567.89"; std::string v = "-$1,234,567.89";
showbase(ios); showbase(ios);
typedef input_iterator<const char*> I; typedef cpp17_input_iterator<const char*> I;
long double ex; long double ex;
std::ios_base::iostate err = std::ios_base::goodbit; std::ios_base::iostate err = std::ios_base::goodbit;
I iter = f.get(I(v.data()), I(v.data() + v.size()), I iter = f.get(I(v.data()), I(v.data() + v.size()),
true, ios, err, ex); true, ios, err, ex);
assert(iter.base() == v.data() + 1); assert(iter.base() == v.data() + 1);
assert(err == std::ios_base::failbit); assert(err == std::ios_base::failbit);
noshowbase(ios); noshowbase(ios);
} }
{ // negative, showbase { // negative, showbase
std::string v = "-$1,234,567.89"; std::string v = "-$1,234,567.89";
typedef input_iterator<const char*> I; typedef cpp17_input_iterator<const char*> I;
long double ex; long double ex;
std::ios_base::iostate err = std::ios_base::goodbit; std::ios_base::iostate err = std::ios_base::goodbit;
I iter = f.get(I(v.data()), I(v.data() + v.size()), I iter = f.get(I(v.data()), I(v.data() + v.size()),
true, ios, err, ex); true, ios, err, ex);
assert(iter.base() == v.data() + 1); assert(iter.base() == v.data() + 1);
assert(err == std::ios_base::failbit); assert(err == std::ios_base::failbit);
} }
} }
{ {
const my_facetw f(1); const my_facetw f(1);
// wchar_t, national // wchar_t, national
{ // zero { // zero
std::wstring v = L"0.00"; std::wstring v = L"0.00";
typedef input_iterator<const wchar_t*> I; typedef cpp17_input_iterator<const wchar_t*> I;
long double ex; long double ex;
std::ios_base::iostate err = std::ios_base::goodbit; std::ios_base::iostate err = std::ios_base::goodbit;
I iter = f.get(I(v.data()), I(v.data() + v.size()), I iter = f.get(I(v.data()), I(v.data() + v.size()),
false, ios, err, ex); false, ios, err, ex);
assert(iter.base() == v.data() + v.size()); assert(iter.base() == v.data() + v.size());
assert(err == std::ios_base::eofbit); assert(err == std::ios_base::eofbit);
assert(ex == 0); assert(ex == 0);
} }
{ // negative one { // negative one
std::wstring v = L"-0.01"; std::wstring v = L"-0.01";
typedef input_iterator<const wchar_t*> I; typedef cpp17_input_iterator<const wchar_t*> I;
long double ex; long double ex;
std::ios_base::iostate err = std::ios_base::goodbit; std::ios_base::iostate err = std::ios_base::goodbit;
I iter = f.get(I(v.data()), I(v.data() + v.size()), I iter = f.get(I(v.data()), I(v.data() + v.size()),
false, ios, err, ex); false, ios, err, ex);
assert(iter.base() == v.data() + v.size()); assert(iter.base() == v.data() + v.size());
assert(err == std::ios_base::eofbit); assert(err == std::ios_base::eofbit);
assert(ex == -1); assert(ex == -1);
} }
{ // positive { // positive
std::wstring v = L"1,234,567.89"; std::wstring v = L"1,234,567.89";
typedef input_iterator<const wchar_t*> I; typedef cpp17_input_iterator<const wchar_t*> I;
long double ex; long double ex;
std::ios_base::iostate err = std::ios_base::goodbit; std::ios_base::iostate err = std::ios_base::goodbit;
I iter = f.get(I(v.data()), I(v.data() + v.size()), I iter = f.get(I(v.data()), I(v.data() + v.size()),
false, ios, err, ex); false, ios, err, ex);
assert(iter.base() == v.data() + v.size()); assert(iter.base() == v.data() + v.size());
assert(err == std::ios_base::eofbit); assert(err == std::ios_base::eofbit);
assert(ex == 123456789); assert(ex == 123456789);
} }
{ // negative { // negative
std::wstring v = L"-1,234,567.89"; std::wstring v = L"-1,234,567.89";
typedef input_iterator<const wchar_t*> I; typedef cpp17_input_iterator<const wchar_t*> I;
long double ex; long double ex;
std::ios_base::iostate err = std::ios_base::goodbit; std::ios_base::iostate err = std::ios_base::goodbit;
I iter = f.get(I(v.data()), I(v.data() + v.size()), I iter = f.get(I(v.data()), I(v.data() + v.size()),
false, ios, err, ex); false, ios, err, ex);
assert(iter.base() == v.data() + v.size()); assert(iter.base() == v.data() + v.size());
assert(err == std::ios_base::eofbit); assert(err == std::ios_base::eofbit);
assert(ex == -123456789); assert(ex == -123456789);
} }
{ // negative { // negative
std::wstring v = L"-1234567.89"; std::wstring v = L"-1234567.89";
typedef input_iterator<const wchar_t*> I; typedef cpp17_input_iterator<const wchar_t*> I;
long double ex; long double ex;
std::ios_base::iostate err = std::ios_base::goodbit; std::ios_base::iostate err = std::ios_base::goodbit;
I iter = f.get(I(v.data()), I(v.data() + v.size()), I iter = f.get(I(v.data()), I(v.data() + v.size()),
false, ios, err, ex); false, ios, err, ex);
assert(iter.base() == v.data() + v.size()); assert(iter.base() == v.data() + v.size());
assert(err == std::ios_base::eofbit); assert(err == std::ios_base::eofbit);
assert(ex == -123456789); assert(ex == -123456789);
} }
{ // zero, showbase { // zero, showbase
std::wstring v = L"$0.00"; std::wstring v = L"$0.00";
typedef input_iterator<const wchar_t*> I; typedef cpp17_input_iterator<const wchar_t*> I;
long double ex; long double ex;
std::ios_base::iostate err = std::ios_base::goodbit; std::ios_base::iostate err = std::ios_base::goodbit;
I iter = f.get(I(v.data()), I(v.data() + v.size()), I iter = f.get(I(v.data()), I(v.data() + v.size()),
false, ios, err, ex); false, ios, err, ex);
assert(iter.base() == v.data() + v.size()); assert(iter.base() == v.data() + v.size());
assert(err == std::ios_base::eofbit); assert(err == std::ios_base::eofbit);
assert(ex == 0); assert(ex == 0);
} }
{ // zero, showbase { // zero, showbase
std::wstring v = L"$0.00"; std::wstring v = L"$0.00";
showbase(ios); showbase(ios);
typedef input_iterator<const wchar_t*> I; typedef cpp17_input_iterator<const wchar_t*> I;
long double ex; long double ex;
std::ios_base::iostate err = std::ios_base::goodbit; std::ios_base::iostate err = std::ios_base::goodbit;
I iter = f.get(I(v.data()), I(v.data() + v.size()), I iter = f.get(I(v.data()), I(v.data() + v.size()),
false, ios, err, ex); false, ios, err, ex);
assert(iter.base() == v.data() + v.size()); assert(iter.base() == v.data() + v.size());
assert(err == std::ios_base::eofbit); assert(err == std::ios_base::eofbit);
assert(ex == 0); assert(ex == 0);
noshowbase(ios); noshowbase(ios);
} }
{ // negative one, showbase { // negative one, showbase
std::wstring v = L"-$0.01"; std::wstring v = L"-$0.01";
typedef input_iterator<const wchar_t*> I; typedef cpp17_input_iterator<const wchar_t*> I;
long double ex; long double ex;
std::ios_base::iostate err = std::ios_base::goodbit; std::ios_base::iostate err = std::ios_base::goodbit;
I iter = f.get(I(v.data()), I(v.data() + v.size()), I iter = f.get(I(v.data()), I(v.data() + v.size()),
false, ios, err, ex); false, ios, err, ex);
assert(iter.base() == v.data() + v.size()); assert(iter.base() == v.data() + v.size());
assert(err == std::ios_base::eofbit); assert(err == std::ios_base::eofbit);
assert(ex == -1); assert(ex == -1);
} }
{ // negative one, showbase { // negative one, showbase
std::wstring v = L"-$0.01"; std::wstring v = L"-$0.01";
showbase(ios); showbase(ios);
typedef input_iterator<const wchar_t*> I; typedef cpp17_input_iterator<const wchar_t*> I;
long double ex; long double ex;
std::ios_base::iostate err = std::ios_base::goodbit; std::ios_base::iostate err = std::ios_base::goodbit;
I iter = f.get(I(v.data()), I(v.data() + v.size()), I iter = f.get(I(v.data()), I(v.data() + v.size()),
false, ios, err, ex); false, ios, err, ex);
assert(iter.base() == v.data() + v.size()); assert(iter.base() == v.data() + v.size());
assert(err == std::ios_base::eofbit); assert(err == std::ios_base::eofbit);
assert(ex == -1); assert(ex == -1);
noshowbase(ios); noshowbase(ios);
} }
{ // positive, showbase { // positive, showbase
std::wstring v = L"$1,234,567.89"; std::wstring v = L"$1,234,567.89";
typedef input_iterator<const wchar_t*> I; typedef cpp17_input_iterator<const wchar_t*> I;
long double ex; long double ex;
std::ios_base::iostate err = std::ios_base::goodbit; std::ios_base::iostate err = std::ios_base::goodbit;
I iter = f.get(I(v.data()), I(v.data() + v.size()), I iter = f.get(I(v.data()), I(v.data() + v.size()),
false, ios, err, ex); false, ios, err, ex);
assert(iter.base() == v.data() + v.size()); assert(iter.base() == v.data() + v.size());
assert(err == std::ios_base::eofbit); assert(err == std::ios_base::eofbit);
assert(ex == 123456789); assert(ex == 123456789);
} }
{ // positive, showbase { // positive, showbase
std::wstring v = L"$1,234,567.89"; std::wstring v = L"$1,234,567.89";
showbase(ios); showbase(ios);
typedef input_iterator<const wchar_t*> I; typedef cpp17_input_iterator<const wchar_t*> I;
long double ex; long double ex;
std::ios_base::iostate err = std::ios_base::goodbit; std::ios_base::iostate err = std::ios_base::goodbit;
I iter = f.get(I(v.data()), I(v.data() + v.size()), I iter = f.get(I(v.data()), I(v.data() + v.size()),
false, ios, err, ex); false, ios, err, ex);
assert(iter.base() == v.data() + v.size()); assert(iter.base() == v.data() + v.size());
assert(err == std::ios_base::eofbit); assert(err == std::ios_base::eofbit);
assert(ex == 123456789); assert(ex == 123456789);
noshowbase(ios); noshowbase(ios);
} }
{ // negative, showbase { // negative, showbase
std::wstring v = L"-$1,234,567.89"; std::wstring v = L"-$1,234,567.89";
showbase(ios); showbase(ios);
typedef input_iterator<const wchar_t*> I; typedef cpp17_input_iterator<const wchar_t*> I;
long double ex; long double ex;
std::ios_base::iostate err = std::ios_base::goodbit; std::ios_base::iostate err = std::ios_base::goodbit;
I iter = f.get(I(v.data()), I(v.data() + v.size()), I iter = f.get(I(v.data()), I(v.data() + v.size()),
false, ios, err, ex); false, ios, err, ex);
assert(iter.base() == v.data() + v.size()); assert(iter.base() == v.data() + v.size());
assert(err == std::ios_base::eofbit); assert(err == std::ios_base::eofbit);
assert(ex == -123456789); assert(ex == -123456789);
noshowbase(ios); noshowbase(ios);
} }
{ // negative, showbase { // negative, showbase
std::wstring v = L"-USD 1,234,567.89"; std::wstring v = L"-USD 1,234,567.89";
showbase(ios); showbase(ios);
typedef input_iterator<const wchar_t*> I; typedef cpp17_input_iterator<const wchar_t*> I;
long double ex; long double ex;
std::ios_base::iostate err = std::ios_base::goodbit; std::ios_base::iostate err = std::ios_base::goodbit;
I iter = f.get(I(v.data()), I(v.data() + v.size()), I iter = f.get(I(v.data()), I(v.data() + v.size()),
false, ios, err, ex); false, ios, err, ex);
assert(iter.base() == v.data() + 1); assert(iter.base() == v.data() + 1);
assert(err == std::ios_base::failbit); assert(err == std::ios_base::failbit);
noshowbase(ios); noshowbase(ios);
} }
{ // negative, showbase { // negative, showbase
std::wstring v = L"-USD 1,234,567.89"; std::wstring v = L"-USD 1,234,567.89";
typedef input_iterator<const wchar_t*> I; typedef cpp17_input_iterator<const wchar_t*> I;
long double ex; long double ex;
std::ios_base::iostate err = std::ios_base::goodbit; std::ios_base::iostate err = std::ios_base::goodbit;
I iter = f.get(I(v.data()), I(v.data() + v.size()), I iter = f.get(I(v.data()), I(v.data() + v.size()),
false, ios, err, ex); false, ios, err, ex);
assert(iter.base() == v.data() + 1); assert(iter.base() == v.data() + 1);
assert(err == std::ios_base::failbit); assert(err == std::ios_base::failbit);
} }
} }
{ {
const my_facetw f(1); const my_facetw f(1);
// wchar_t, international // wchar_t, international
{ // zero { // zero
std::wstring v = L"0.00"; std::wstring v = L"0.00";
typedef input_iterator<const wchar_t*> I; typedef cpp17_input_iterator<const wchar_t*> I;
long double ex; long double ex;
std::ios_base::iostate err = std::ios_base::goodbit; std::ios_base::iostate err = std::ios_base::goodbit;
I iter = f.get(I(v.data()), I(v.data() + v.size()), I iter = f.get(I(v.data()), I(v.data() + v.size()),
true, ios, err, ex); true, ios, err, ex);
assert(iter.base() == v.data() + v.size()); assert(iter.base() == v.data() + v.size());
assert(err == std::ios_base::eofbit); assert(err == std::ios_base::eofbit);
assert(ex == 0); assert(ex == 0);
} }
{ // negative one { // negative one
std::wstring v = L"-0.01"; std::wstring v = L"-0.01";
typedef input_iterator<const wchar_t*> I; typedef cpp17_input_iterator<const wchar_t*> I;
long double ex; long double ex;
std::ios_base::iostate err = std::ios_base::goodbit; std::ios_base::iostate err = std::ios_base::goodbit;
I iter = f.get(I(v.data()), I(v.data() + v.size()), I iter = f.get(I(v.data()), I(v.data() + v.size()),
true, ios, err, ex); true, ios, err, ex);
assert(iter.base() == v.data() + v.size()); assert(iter.base() == v.data() + v.size());
assert(err == std::ios_base::eofbit); assert(err == std::ios_base::eofbit);
assert(ex == -1); assert(ex == -1);
} }
{ // positive { // positive
std::wstring v = L"1,234,567.89"; std::wstring v = L"1,234,567.89";
typedef input_iterator<const wchar_t*> I; typedef cpp17_input_iterator<const wchar_t*> I;
long double ex; long double ex;
std::ios_base::iostate err = std::ios_base::goodbit; std::ios_base::iostate err = std::ios_base::goodbit;
I iter = f.get(I(v.data()), I(v.data() + v.size()), I iter = f.get(I(v.data()), I(v.data() + v.size()),
true, ios, err, ex); true, ios, err, ex);
assert(iter.base() == v.data() + v.size()); assert(iter.base() == v.data() + v.size());
assert(err == std::ios_base::eofbit); assert(err == std::ios_base::eofbit);
assert(ex == 123456789); assert(ex == 123456789);
} }
{ // negative { // negative
std::wstring v = L"-1,234,567.89"; std::wstring v = L"-1,234,567.89";
typedef input_iterator<const wchar_t*> I; typedef cpp17_input_iterator<const wchar_t*> I;
long double ex; long double ex;
std::ios_base::iostate err = std::ios_base::goodbit; std::ios_base::iostate err = std::ios_base::goodbit;
I iter = f.get(I(v.data()), I(v.data() + v.size()), I iter = f.get(I(v.data()), I(v.data() + v.size()),
true, ios, err, ex); true, ios, err, ex);
assert(iter.base() == v.data() + v.size()); assert(iter.base() == v.data() + v.size());
assert(err == std::ios_base::eofbit); assert(err == std::ios_base::eofbit);
assert(ex == -123456789); assert(ex == -123456789);
} }
{ // negative { // negative
std::wstring v = L"-1234567.89"; std::wstring v = L"-1234567.89";
typedef input_iterator<const wchar_t*> I; typedef cpp17_input_iterator<const wchar_t*> I;
long double ex; long double ex;
std::ios_base::iostate err = std::ios_base::goodbit; std::ios_base::iostate err = std::ios_base::goodbit;
I iter = f.get(I(v.data()), I(v.data() + v.size()), I iter = f.get(I(v.data()), I(v.data() + v.size()),
true, ios, err, ex); true, ios, err, ex);
assert(iter.base() == v.data() + v.size()); assert(iter.base() == v.data() + v.size());
assert(err == std::ios_base::eofbit); assert(err == std::ios_base::eofbit);
assert(ex == -123456789); assert(ex == -123456789);
} }
{ // zero, showbase { // zero, showbase
std::wstring v = L"USD 0.00"; std::wstring v = L"USD 0.00";
typedef input_iterator<const wchar_t*> I; typedef cpp17_input_iterator<const wchar_t*> I;
long double ex; long double ex;
std::ios_base::iostate err = std::ios_base::goodbit; std::ios_base::iostate err = std::ios_base::goodbit;
I iter = f.get(I(v.data()), I(v.data() + v.size()), I iter = f.get(I(v.data()), I(v.data() + v.size()),
true, ios, err, ex); true, ios, err, ex);
assert(iter.base() == v.data() + v.size()); assert(iter.base() == v.data() + v.size());
assert(err == std::ios_base::eofbit); assert(err == std::ios_base::eofbit);
assert(ex == 0); assert(ex == 0);
} }
{ // zero, showbase { // zero, showbase
std::wstring v = L"USD 0.00"; std::wstring v = L"USD 0.00";
showbase(ios); showbase(ios);
typedef input_iterator<const wchar_t*> I; typedef cpp17_input_iterator<const wchar_t*> I;
long double ex; long double ex;
std::ios_base::iostate err = std::ios_base::goodbit; std::ios_base::iostate err = std::ios_base::goodbit;
I iter = f.get(I(v.data()), I(v.data() + v.size()), I iter = f.get(I(v.data()), I(v.data() + v.size()),
true, ios, err, ex); true, ios, err, ex);
assert(iter.base() == v.data() + v.size()); assert(iter.base() == v.data() + v.size());
assert(err == std::ios_base::eofbit); assert(err == std::ios_base::eofbit);
assert(ex == 0); assert(ex == 0);
noshowbase(ios); noshowbase(ios);
} }
{ // negative one, showbase { // negative one, showbase
std::wstring v = L"-USD 0.01"; std::wstring v = L"-USD 0.01";
typedef input_iterator<const wchar_t*> I; typedef cpp17_input_iterator<const wchar_t*> I;
long double ex; long double ex;
std::ios_base::iostate err = std::ios_base::goodbit; std::ios_base::iostate err = std::ios_base::goodbit;
I iter = f.get(I(v.data()), I(v.data() + v.size()), I iter = f.get(I(v.data()), I(v.data() + v.size()),
true, ios, err, ex); true, ios, err, ex);
assert(iter.base() == v.data() + v.size()); assert(iter.base() == v.data() + v.size());
assert(err == std::ios_base::eofbit); assert(err == std::ios_base::eofbit);
assert(ex == -1); assert(ex == -1);
} }
{ // negative one, showbase { // negative one, showbase
std::wstring v = L"-USD 0.01"; std::wstring v = L"-USD 0.01";
showbase(ios); showbase(ios);
typedef input_iterator<const wchar_t*> I; typedef cpp17_input_iterator<const wchar_t*> I;
long double ex; long double ex;
std::ios_base::iostate err = std::ios_base::goodbit; std::ios_base::iostate err = std::ios_base::goodbit;
I iter = f.get(I(v.data()), I(v.data() + v.size()), I iter = f.get(I(v.data()), I(v.data() + v.size()),
true, ios, err, ex); true, ios, err, ex);
assert(iter.base() == v.data() + v.size()); assert(iter.base() == v.data() + v.size());
assert(err == std::ios_base::eofbit); assert(err == std::ios_base::eofbit);
assert(ex == -1); assert(ex == -1);
noshowbase(ios); noshowbase(ios);
} }
{ // positive, showbase { // positive, showbase
std::wstring v = L"USD 1,234,567.89"; std::wstring v = L"USD 1,234,567.89";
typedef input_iterator<const wchar_t*> I; typedef cpp17_input_iterator<const wchar_t*> I;
long double ex; long double ex;
std::ios_base::iostate err = std::ios_base::goodbit; std::ios_base::iostate err = std::ios_base::goodbit;
I iter = f.get(I(v.data()), I(v.data() + v.size()), I iter = f.get(I(v.data()), I(v.data() + v.size()),
true, ios, err, ex); true, ios, err, ex);
assert(iter.base() == v.data() + v.size()); assert(iter.base() == v.data() + v.size());
assert(err == std::ios_base::eofbit); assert(err == std::ios_base::eofbit);
assert(ex == 123456789); assert(ex == 123456789);
} }
{ // positive, showbase { // positive, showbase
std::wstring v = L"USD 1,234,567.89"; std::wstring v = L"USD 1,234,567.89";
showbase(ios); showbase(ios);
typedef input_iterator<const wchar_t*> I; typedef cpp17_input_iterator<const wchar_t*> I;
long double ex; long double ex;
std::ios_base::iostate err = std::ios_base::goodbit; std::ios_base::iostate err = std::ios_base::goodbit;
I iter = f.get(I(v.data()), I(v.data() + v.size()), I iter = f.get(I(v.data()), I(v.data() + v.size()),
true, ios, err, ex); true, ios, err, ex);
assert(iter.base() == v.data() + v.size()); assert(iter.base() == v.data() + v.size());
assert(err == std::ios_base::eofbit); assert(err == std::ios_base::eofbit);
assert(ex == 123456789); assert(ex == 123456789);
noshowbase(ios); noshowbase(ios);
} }
{ // negative, showbase { // negative, showbase
std::wstring v = L"-USD 1,234,567.89"; std::wstring v = L"-USD 1,234,567.89";
showbase(ios); showbase(ios);
typedef input_iterator<const wchar_t*> I; typedef cpp17_input_iterator<const wchar_t*> I;
long double ex; long double ex;
std::ios_base::iostate err = std::ios_base::goodbit; std::ios_base::iostate err = std::ios_base::goodbit;
I iter = f.get(I(v.data()), I(v.data() + v.size()), I iter = f.get(I(v.data()), I(v.data() + v.size()),
true, ios, err, ex); true, ios, err, ex);
assert(iter.base() == v.data() + v.size()); assert(iter.base() == v.data() + v.size());
assert(err == std::ios_base::eofbit); assert(err == std::ios_base::eofbit);
assert(ex == -123456789); assert(ex == -123456789);
noshowbase(ios); noshowbase(ios);
} }
{ // negative, showbase { // negative, showbase
std::wstring v = L"-$1,234,567.89"; std::wstring v = L"-$1,234,567.89";
showbase(ios); showbase(ios);
typedef input_iterator<const wchar_t*> I; typedef cpp17_input_iterator<const wchar_t*> I;
long double ex; long double ex;
std::ios_base::iostate err = std::ios_base::goodbit; std::ios_base::iostate err = std::ios_base::goodbit;
I iter = f.get(I(v.data()), I(v.data() + v.size()), I iter = f.get(I(v.data()), I(v.data() + v.size()),
true, ios, err, ex); true, ios, err, ex);
assert(iter.base() == v.data() + 1); assert(iter.base() == v.data() + 1);
assert(err == std::ios_base::failbit); assert(err == std::ios_base::failbit);
noshowbase(ios); noshowbase(ios);
} }
{ // negative, showbase { // negative, showbase
std::wstring v = L"-$1,234,567.89"; std::wstring v = L"-$1,234,567.89";
typedef input_iterator<const wchar_t*> I; typedef cpp17_input_iterator<const wchar_t*> I;
long double ex; long double ex;
std::ios_base::iostate err = std::ios_base::goodbit; std::ios_base::iostate err = std::ios_base::goodbit;
I iter = f.get(I(v.data()), I(v.data() + v.size()), I iter = f.get(I(v.data()), I(v.data() + v.size()),
true, ios, err, ex); true, ios, err, ex);
assert(iter.base() == v.data() + 1); assert(iter.base() == v.data() + 1);
assert(err == std::ios_base::failbit); assert(err == std::ios_base::failbit);
} }
} }
return 0; return 0;
} }

libcxx/test/std/localization/locale.categories/category.monetary/locale.money.get/locale.money.get.members/get_long_double_fr_FR.pass.cpp

Show All 25 Lines
#include <ios> #include <ios>
#include <streambuf> #include <streambuf>
#include <cassert> #include <cassert>
#include "test_iterators.h" #include "test_iterators.h"
#include "platform_support.h" // locale name macros #include "platform_support.h" // locale name macros
#include "test_macros.h" #include "test_macros.h"
typedef std::money_get<char, input_iterator<const char*> > Fn; typedef std::money_get<char, cpp17_input_iterator<const char*> > Fn;
class my_facet class my_facet
: public Fn : public Fn
{ {
public: public:
explicit my_facet(std::size_t refs = 0) explicit my_facet(std::size_t refs = 0)
: Fn(refs) {} : Fn(refs) {}
}; };
typedef std::money_get<wchar_t, input_iterator<const wchar_t*> > Fw; typedef std::money_get<wchar_t, cpp17_input_iterator<const wchar_t*> > Fw;
class my_facetw class my_facetw
: public Fw : public Fw
{ {
public: public:
explicit my_facetw(std::size_t refs = 0) explicit my_facetw(std::size_t refs = 0)
: Fw(refs) {} : Fw(refs) {}
}; };
Show All 37 Lines ios.imbue(std::locale(ios.getloc(),
new std::moneypunct_byname<wchar_t, false>(loc_name))); new std::moneypunct_byname<wchar_t, false>(loc_name)));
ios.imbue(std::locale(ios.getloc(), ios.imbue(std::locale(ios.getloc(),
new std::moneypunct_byname<wchar_t, true>(loc_name))); new std::moneypunct_byname<wchar_t, true>(loc_name)));
{ {
const my_facet f(1); const my_facet f(1);
// char, national // char, national
{ // zero { // zero
std::string v = "0,00"; std::string v = "0,00";
typedef input_iterator<const char*> I; typedef cpp17_input_iterator<const char*> I;
long double ex; long double ex;
std::ios_base::iostate err = std::ios_base::goodbit; std::ios_base::iostate err = std::ios_base::goodbit;
I iter = f.get(I(v.data()), I(v.data() + v.size()), I iter = f.get(I(v.data()), I(v.data() + v.size()),
false, ios, err, ex); false, ios, err, ex);
assert(iter.base() == v.data() + v.size()); assert(iter.base() == v.data() + v.size());
assert(err == std::ios_base::eofbit); assert(err == std::ios_base::eofbit);
assert(ex == 0); assert(ex == 0);
} }
{ // negative one { // negative one
std::string v = "-0,01"; std::string v = "-0,01";
typedef input_iterator<const char*> I; typedef cpp17_input_iterator<const char*> I;
long double ex; long double ex;
std::ios_base::iostate err = std::ios_base::goodbit; std::ios_base::iostate err = std::ios_base::goodbit;
I iter = f.get(I(v.data()), I(v.data() + v.size()), I iter = f.get(I(v.data()), I(v.data() + v.size()),
false, ios, err, ex); false, ios, err, ex);
assert(iter.base() == v.data() + v.size()); assert(iter.base() == v.data() + v.size());
assert(err == std::ios_base::eofbit); assert(err == std::ios_base::eofbit);
assert(ex == -1); assert(ex == -1);
} }
{ // positive { // positive
std::string v = "1 234 567,89 "; std::string v = "1 234 567,89 ";
typedef input_iterator<const char*> I; typedef cpp17_input_iterator<const char*> I;
long double ex; long double ex;
std::ios_base::iostate err = std::ios_base::goodbit; std::ios_base::iostate err = std::ios_base::goodbit;
I iter = f.get(I(v.data()), I(v.data() + v.size()), I iter = f.get(I(v.data()), I(v.data() + v.size()),
false, ios, err, ex); false, ios, err, ex);
assert(iter.base() == v.data() + v.size()); assert(iter.base() == v.data() + v.size());
assert(err == std::ios_base::eofbit); assert(err == std::ios_base::eofbit);
assert(ex == 123456789); assert(ex == 123456789);
} }
{ // negative { // negative
std::string v = "-1 234 567,89"; std::string v = "-1 234 567,89";
typedef input_iterator<const char*> I; typedef cpp17_input_iterator<const char*> I;
long double ex; long double ex;
std::ios_base::iostate err = std::ios_base::goodbit; std::ios_base::iostate err = std::ios_base::goodbit;
I iter = f.get(I(v.data()), I(v.data() + v.size()), I iter = f.get(I(v.data()), I(v.data() + v.size()),
false, ios, err, ex); false, ios, err, ex);
assert(iter.base() == v.data() + v.size()); assert(iter.base() == v.data() + v.size());
assert(err == std::ios_base::eofbit); assert(err == std::ios_base::eofbit);
assert(ex == -123456789); assert(ex == -123456789);
} }
{ // negative { // negative
std::string v = "-1234567,89"; std::string v = "-1234567,89";
typedef input_iterator<const char*> I; typedef cpp17_input_iterator<const char*> I;
long double ex; long double ex;
std::ios_base::iostate err = std::ios_base::goodbit; std::ios_base::iostate err = std::ios_base::goodbit;
I iter = f.get(I(v.data()), I(v.data() + v.size()), I iter = f.get(I(v.data()), I(v.data() + v.size()),
false, ios, err, ex); false, ios, err, ex);
assert(iter.base() == v.data() + v.size()); assert(iter.base() == v.data() + v.size());
assert(err == std::ios_base::eofbit); assert(err == std::ios_base::eofbit);
assert(ex == -123456789); assert(ex == -123456789);
} }
{ // zero, showbase { // zero, showbase
std::string v = "0,00 \u20ac"; // EURO SIGN std::string v = "0,00 \u20ac"; // EURO SIGN
showbase(ios); showbase(ios);
typedef input_iterator<const char*> I; typedef cpp17_input_iterator<const char*> I;
long double ex; long double ex;
std::ios_base::iostate err = std::ios_base::goodbit; std::ios_base::iostate err = std::ios_base::goodbit;
I iter = f.get(I(v.data()), I(v.data() + v.size()), I iter = f.get(I(v.data()), I(v.data() + v.size()),
false, ios, err, ex); false, ios, err, ex);
assert(iter.base() == v.data() + v.size()); assert(iter.base() == v.data() + v.size());
assert(err == std::ios_base::eofbit); assert(err == std::ios_base::eofbit);
assert(ex == 0); assert(ex == 0);
} }
{ // zero, showbase { // zero, showbase
std::string v = "0,00 \u20ac"; // EURO SIGN std::string v = "0,00 \u20ac"; // EURO SIGN
showbase(ios); showbase(ios);
typedef input_iterator<const char*> I; typedef cpp17_input_iterator<const char*> I;
long double ex; long double ex;
std::ios_base::iostate err = std::ios_base::goodbit; std::ios_base::iostate err = std::ios_base::goodbit;
I iter = f.get(I(v.data()), I(v.data() + v.size()), I iter = f.get(I(v.data()), I(v.data() + v.size()),
false, ios, err, ex); false, ios, err, ex);
assert(iter.base() == v.data() + v.size()); assert(iter.base() == v.data() + v.size());
assert(err == std::ios_base::eofbit); assert(err == std::ios_base::eofbit);
assert(ex == 0); assert(ex == 0);
} }
{ // negative one, showbase { // negative one, showbase
std::string v = "-0,01 \u20ac"; // EURO SIGN std::string v = "-0,01 \u20ac"; // EURO SIGN
typedef input_iterator<const char*> I; typedef cpp17_input_iterator<const char*> I;
long double ex; long double ex;
std::ios_base::iostate err = std::ios_base::goodbit; std::ios_base::iostate err = std::ios_base::goodbit;
I iter = f.get(I(v.data()), I(v.data() + v.size()), I iter = f.get(I(v.data()), I(v.data() + v.size()),
false, ios, err, ex); false, ios, err, ex);
assert(iter.base() == v.data() + v.size()); assert(iter.base() == v.data() + v.size());
assert(err == std::ios_base::eofbit); assert(err == std::ios_base::eofbit);
assert(ex == -1); assert(ex == -1);
} }
{ // negative one, showbase { // negative one, showbase
std::string v = "-0,01 \u20ac"; // EURO SIGN std::string v = "-0,01 \u20ac"; // EURO SIGN
showbase(ios); showbase(ios);
typedef input_iterator<const char*> I; typedef cpp17_input_iterator<const char*> I;
long double ex; long double ex;
std::ios_base::iostate err = std::ios_base::goodbit; std::ios_base::iostate err = std::ios_base::goodbit;
I iter = f.get(I(v.data()), I(v.data() + v.size()), I iter = f.get(I(v.data()), I(v.data() + v.size()),
false, ios, err, ex); false, ios, err, ex);
assert(iter.base() == v.data() + v.size()); assert(iter.base() == v.data() + v.size());
assert(err == std::ios_base::eofbit); assert(err == std::ios_base::eofbit);
assert(ex == -1); assert(ex == -1);
} }
{ // positive, showbase { // positive, showbase
std::string v = "1 234 567,89 \u20ac"; // EURO SIGN std::string v = "1 234 567,89 \u20ac"; // EURO SIGN
typedef input_iterator<const char*> I; typedef cpp17_input_iterator<const char*> I;
long double ex; long double ex;
std::ios_base::iostate err = std::ios_base::goodbit; std::ios_base::iostate err = std::ios_base::goodbit;
I iter = f.get(I(v.data()), I(v.data() + v.size()), I iter = f.get(I(v.data()), I(v.data() + v.size()),
false, ios, err, ex); false, ios, err, ex);
assert(iter.base() == v.data() + v.size()); assert(iter.base() == v.data() + v.size());
assert(err == std::ios_base::eofbit); assert(err == std::ios_base::eofbit);
assert(ex == 123456789); assert(ex == 123456789);
} }
{ // positive, showbase { // positive, showbase
std::string v = "1 234 567,89 \u20ac"; // EURO SIGN std::string v = "1 234 567,89 \u20ac"; // EURO SIGN
showbase(ios); showbase(ios);
typedef input_iterator<const char*> I; typedef cpp17_input_iterator<const char*> I;
long double ex; long double ex;
std::ios_base::iostate err = std::ios_base::goodbit; std::ios_base::iostate err = std::ios_base::goodbit;
I iter = f.get(I(v.data()), I(v.data() + v.size()), I iter = f.get(I(v.data()), I(v.data() + v.size()),
false, ios, err, ex); false, ios, err, ex);
assert(iter.base() == v.data() + v.size()); assert(iter.base() == v.data() + v.size());
assert(err == std::ios_base::eofbit); assert(err == std::ios_base::eofbit);
assert(ex == 123456789); assert(ex == 123456789);
noshowbase(ios); noshowbase(ios);
} }
{ // negative, showbase { // negative, showbase
std::string v = "-1 234 567,89 \u20ac"; // EURO SIGN std::string v = "-1 234 567,89 \u20ac"; // EURO SIGN
showbase(ios); showbase(ios);
typedef input_iterator<const char*> I; typedef cpp17_input_iterator<const char*> I;
long double ex; long double ex;
std::ios_base::iostate err = std::ios_base::goodbit; std::ios_base::iostate err = std::ios_base::goodbit;
I iter = f.get(I(v.data()), I(v.data() + v.size()), I iter = f.get(I(v.data()), I(v.data() + v.size()),
false, ios, err, ex); false, ios, err, ex);
assert(iter.base() == v.data() + v.size()); assert(iter.base() == v.data() + v.size());
assert(err == std::ios_base::eofbit); assert(err == std::ios_base::eofbit);
assert(ex == -123456789); assert(ex == -123456789);
noshowbase(ios); noshowbase(ios);
} }
{ // negative, showbase { // negative, showbase
std::string v = "1 234 567,89 EUR -"; std::string v = "1 234 567,89 EUR -";
showbase(ios); showbase(ios);
typedef input_iterator<const char*> I; typedef cpp17_input_iterator<const char*> I;
long double ex; long double ex;
std::ios_base::iostate err = std::ios_base::goodbit; std::ios_base::iostate err = std::ios_base::goodbit;
I iter = f.get(I(v.data()), I(v.data() + v.size()), I iter = f.get(I(v.data()), I(v.data() + v.size()),
false, ios, err, ex); false, ios, err, ex);
assert(iter.base() == v.data() + 13); assert(iter.base() == v.data() + 13);
assert(err == std::ios_base::failbit); assert(err == std::ios_base::failbit);
noshowbase(ios); noshowbase(ios);
} }
{ // negative, showbase { // negative, showbase
std::string v = "1 234 567,89 EUR -"; std::string v = "1 234 567,89 EUR -";
typedef input_iterator<const char*> I; typedef cpp17_input_iterator<const char*> I;
long double ex; long double ex;
std::ios_base::iostate err = std::ios_base::goodbit; std::ios_base::iostate err = std::ios_base::goodbit;
I iter = f.get(I(v.data()), I(v.data() + v.size()), I iter = f.get(I(v.data()), I(v.data() + v.size()),
false, ios, err, ex); false, ios, err, ex);
assert(iter.base() == v.data() + 13); assert(iter.base() == v.data() + 13);
assert(err == std::ios_base::goodbit); assert(err == std::ios_base::goodbit);
assert(ex == 123456789); assert(ex == 123456789);
} }
noshowbase(ios); noshowbase(ios);
} }
{ {
const my_facet f(1); const my_facet f(1);
// char, international // char, international
{ // zero { // zero
std::string v = "0,00"; std::string v = "0,00";
typedef input_iterator<const char*> I; typedef cpp17_input_iterator<const char*> I;
long double ex; long double ex;
std::ios_base::iostate err = std::ios_base::goodbit; std::ios_base::iostate err = std::ios_base::goodbit;
I iter = f.get(I(v.data()), I(v.data() + v.size()), I iter = f.get(I(v.data()), I(v.data() + v.size()),
true, ios, err, ex); true, ios, err, ex);
assert(iter.base() == v.data() + v.size()); assert(iter.base() == v.data() + v.size());
assert(err == std::ios_base::eofbit); assert(err == std::ios_base::eofbit);
assert(ex == 0); assert(ex == 0);
} }
{ // negative one { // negative one
std::string v = "-0,01"; std::string v = "-0,01";
typedef input_iterator<const char*> I; typedef cpp17_input_iterator<const char*> I;
long double ex; long double ex;
std::ios_base::iostate err = std::ios_base::goodbit; std::ios_base::iostate err = std::ios_base::goodbit;
I iter = f.get(I(v.data()), I(v.data() + v.size()), I iter = f.get(I(v.data()), I(v.data() + v.size()),
true, ios, err, ex); true, ios, err, ex);
assert(iter.base() == v.data() + v.size()); assert(iter.base() == v.data() + v.size());
assert(err == std::ios_base::eofbit); assert(err == std::ios_base::eofbit);
assert(ex == -1); assert(ex == -1);
} }
{ // positive { // positive
std::string v = "1 234 567,89 "; std::string v = "1 234 567,89 ";
typedef input_iterator<const char*> I; typedef cpp17_input_iterator<const char*> I;
long double ex; long double ex;
std::ios_base::iostate err = std::ios_base::goodbit; std::ios_base::iostate err = std::ios_base::goodbit;
I iter = f.get(I(v.data()), I(v.data() + v.size()), I iter = f.get(I(v.data()), I(v.data() + v.size()),
true, ios, err, ex); true, ios, err, ex);
assert(iter.base() == v.data() + v.size()); assert(iter.base() == v.data() + v.size());
assert(err == std::ios_base::eofbit); assert(err == std::ios_base::eofbit);
assert(ex == 123456789); assert(ex == 123456789);
} }
{ // negative { // negative
std::string v = "-1 234 567,89"; std::string v = "-1 234 567,89";
typedef input_iterator<const char*> I; typedef cpp17_input_iterator<const char*> I;
long double ex; long double ex;
std::ios_base::iostate err = std::ios_base::goodbit; std::ios_base::iostate err = std::ios_base::goodbit;
I iter = f.get(I(v.data()), I(v.data() + v.size()), I iter = f.get(I(v.data()), I(v.data() + v.size()),
true, ios, err, ex); true, ios, err, ex);
assert(iter.base() == v.data() + v.size()); assert(iter.base() == v.data() + v.size());
assert(err == std::ios_base::eofbit); assert(err == std::ios_base::eofbit);
assert(ex == -123456789); assert(ex == -123456789);
} }
{ // negative { // negative
std::string v = "-1234567,89"; std::string v = "-1234567,89";
typedef input_iterator<const char*> I; typedef cpp17_input_iterator<const char*> I;
long double ex; long double ex;
std::ios_base::iostate err = std::ios_base::goodbit; std::ios_base::iostate err = std::ios_base::goodbit;
I iter = f.get(I(v.data()), I(v.data() + v.size()), I iter = f.get(I(v.data()), I(v.data() + v.size()),
true, ios, err, ex); true, ios, err, ex);
assert(iter.base() == v.data() + v.size()); assert(iter.base() == v.data() + v.size());
assert(err == std::ios_base::eofbit); assert(err == std::ios_base::eofbit);
assert(ex == -123456789); assert(ex == -123456789);
} }
{ // zero, showbase { // zero, showbase
std::string v = "0,00 EUR"; std::string v = "0,00 EUR";
showbase(ios); showbase(ios);
typedef input_iterator<const char*> I; typedef cpp17_input_iterator<const char*> I;
long double ex; long double ex;
std::ios_base::iostate err = std::ios_base::goodbit; std::ios_base::iostate err = std::ios_base::goodbit;
I iter = f.get(I(v.data()), I(v.data() + v.size()), I iter = f.get(I(v.data()), I(v.data() + v.size()),
true, ios, err, ex); true, ios, err, ex);
assert(iter.base() == v.data() + v.size()); assert(iter.base() == v.data() + v.size());
assert(err == std::ios_base::eofbit); assert(err == std::ios_base::eofbit);
assert(ex == 0); assert(ex == 0);
} }
{ // zero, showbase { // zero, showbase
std::string v = "0,00 EUR"; std::string v = "0,00 EUR";
showbase(ios); showbase(ios);
typedef input_iterator<const char*> I; typedef cpp17_input_iterator<const char*> I;
long double ex; long double ex;
std::ios_base::iostate err = std::ios_base::goodbit; std::ios_base::iostate err = std::ios_base::goodbit;
I iter = f.get(I(v.data()), I(v.data() + v.size()), I iter = f.get(I(v.data()), I(v.data() + v.size()),
true, ios, err, ex); true, ios, err, ex);
assert(iter.base() == v.data() + v.size()); assert(iter.base() == v.data() + v.size());
assert(err == std::ios_base::eofbit); assert(err == std::ios_base::eofbit);
assert(ex == 0); assert(ex == 0);
} }
{ // negative one, showbase { // negative one, showbase
std::string v = "-0,01 EUR"; std::string v = "-0,01 EUR";
typedef input_iterator<const char*> I; typedef cpp17_input_iterator<const char*> I;
long double ex; long double ex;
std::ios_base::iostate err = std::ios_base::goodbit; std::ios_base::iostate err = std::ios_base::goodbit;
I iter = f.get(I(v.data()), I(v.data() + v.size()), I iter = f.get(I(v.data()), I(v.data() + v.size()),
true, ios, err, ex); true, ios, err, ex);
assert(iter.base() == v.data() + v.size()); assert(iter.base() == v.data() + v.size());
assert(err == std::ios_base::eofbit); assert(err == std::ios_base::eofbit);
assert(ex == -1); assert(ex == -1);
} }
{ // negative one, showbase { // negative one, showbase
std::string v = "-0,01 EUR"; std::string v = "-0,01 EUR";
showbase(ios); showbase(ios);
typedef input_iterator<const char*> I; typedef cpp17_input_iterator<const char*> I;
long double ex; long double ex;
std::ios_base::iostate err = std::ios_base::goodbit; std::ios_base::iostate err = std::ios_base::goodbit;
I iter = f.get(I(v.data()), I(v.data() + v.size()), I iter = f.get(I(v.data()), I(v.data() + v.size()),
true, ios, err, ex); true, ios, err, ex);
assert(iter.base() == v.data() + v.size()); assert(iter.base() == v.data() + v.size());
assert(err == std::ios_base::eofbit); assert(err == std::ios_base::eofbit);
assert(ex == -1); assert(ex == -1);
} }
{ // positive, showbase { // positive, showbase
std::string v = "1 234 567,89 EUR"; std::string v = "1 234 567,89 EUR";
typedef input_iterator<const char*> I; typedef cpp17_input_iterator<const char*> I;
long double ex; long double ex;
std::ios_base::iostate err = std::ios_base::goodbit; std::ios_base::iostate err = std::ios_base::goodbit;
I iter = f.get(I(v.data()), I(v.data() + v.size()), I iter = f.get(I(v.data()), I(v.data() + v.size()),
true, ios, err, ex); true, ios, err, ex);
assert(iter.base() == v.data() + v.size()); assert(iter.base() == v.data() + v.size());
assert(err == std::ios_base::eofbit); assert(err == std::ios_base::eofbit);
assert(ex == 123456789); assert(ex == 123456789);
} }
{ // positive, showbase { // positive, showbase
std::string v = "1 234 567,89 EUR"; std::string v = "1 234 567,89 EUR";
showbase(ios); showbase(ios);
typedef input_iterator<const char*> I; typedef cpp17_input_iterator<const char*> I;
long double ex; long double ex;
std::ios_base::iostate err = std::ios_base::goodbit; std::ios_base::iostate err = std::ios_base::goodbit;
I iter = f.get(I(v.data()), I(v.data() + v.size()), I iter = f.get(I(v.data()), I(v.data() + v.size()),
true, ios, err, ex); true, ios, err, ex);
assert(iter.base() == v.data() + v.size()); assert(iter.base() == v.data() + v.size());
assert(err == std::ios_base::eofbit); assert(err == std::ios_base::eofbit);
assert(ex == 123456789); assert(ex == 123456789);
noshowbase(ios); noshowbase(ios);
} }
{ // negative, showbase { // negative, showbase
std::string v = "-1 234 567,89 EUR"; std::string v = "-1 234 567,89 EUR";
showbase(ios); showbase(ios);
typedef input_iterator<const char*> I; typedef cpp17_input_iterator<const char*> I;
long double ex; long double ex;
std::ios_base::iostate err = std::ios_base::goodbit; std::ios_base::iostate err = std::ios_base::goodbit;
I iter = f.get(I(v.data()), I(v.data() + v.size()), I iter = f.get(I(v.data()), I(v.data() + v.size()),
true, ios, err, ex); true, ios, err, ex);
assert(iter.base() == v.data() + v.size()); assert(iter.base() == v.data() + v.size());
assert(err == std::ios_base::eofbit); assert(err == std::ios_base::eofbit);
assert(ex == -123456789); assert(ex == -123456789);
noshowbase(ios); noshowbase(ios);
} }
{ // negative, showbase { // negative, showbase
std::string v = "1 234 567,89 Eu-"; std::string v = "1 234 567,89 Eu-";
showbase(ios); showbase(ios);
typedef input_iterator<const char*> I; typedef cpp17_input_iterator<const char*> I;
long double ex; long double ex;
std::ios_base::iostate err = std::ios_base::goodbit; std::ios_base::iostate err = std::ios_base::goodbit;
I iter = f.get(I(v.data()), I(v.data() + v.size()), I iter = f.get(I(v.data()), I(v.data() + v.size()),
true, ios, err, ex); true, ios, err, ex);
assert(iter.base() == v.data() + 14); assert(iter.base() == v.data() + 14);
assert(err == std::ios_base::failbit); assert(err == std::ios_base::failbit);
noshowbase(ios); noshowbase(ios);
} }
{ // negative, showbase { // negative, showbase
std::string v = "1 234 567,89 Eu-"; std::string v = "1 234 567,89 Eu-";
typedef input_iterator<const char*> I; typedef cpp17_input_iterator<const char*> I;
long double ex; long double ex;
std::ios_base::iostate err = std::ios_base::goodbit; std::ios_base::iostate err = std::ios_base::goodbit;
I iter = f.get(I(v.data()), I(v.data() + v.size()), I iter = f.get(I(v.data()), I(v.data() + v.size()),
true, ios, err, ex); true, ios, err, ex);
assert(iter.base() == v.data() + 13); assert(iter.base() == v.data() + 13);
assert(err == std::ios_base::goodbit); assert(err == std::ios_base::goodbit);
assert(ex == 123456789); assert(ex == 123456789);
} }
} }
{ {
const my_facetw f(1); const my_facetw f(1);
// wchar_t, national // wchar_t, national
{ // zero { // zero
std::wstring v = L"0,00"; std::wstring v = L"0,00";
typedef input_iterator<const wchar_t*> I; typedef cpp17_input_iterator<const wchar_t*> I;
long double ex; long double ex;
std::ios_base::iostate err = std::ios_base::goodbit; std::ios_base::iostate err = std::ios_base::goodbit;
I iter = f.get(I(v.data()), I(v.data() + v.size()), I iter = f.get(I(v.data()), I(v.data() + v.size()),
false, ios, err, ex); false, ios, err, ex);
assert(iter.base() == v.data() + v.size()); assert(iter.base() == v.data() + v.size());
assert(err == std::ios_base::eofbit); assert(err == std::ios_base::eofbit);
assert(ex == 0); assert(ex == 0);
} }
{ // negative one { // negative one
std::wstring v = L"-0,01"; std::wstring v = L"-0,01";
typedef input_iterator<const wchar_t*> I; typedef cpp17_input_iterator<const wchar_t*> I;
long double ex; long double ex;
std::ios_base::iostate err = std::ios_base::goodbit; std::ios_base::iostate err = std::ios_base::goodbit;
I iter = f.get(I(v.data()), I(v.data() + v.size()), I iter = f.get(I(v.data()), I(v.data() + v.size()),
false, ios, err, ex); false, ios, err, ex);
assert(iter.base() == v.data() + v.size()); assert(iter.base() == v.data() + v.size());
assert(err == std::ios_base::eofbit); assert(err == std::ios_base::eofbit);
assert(ex == -1); assert(ex == -1);
} }
{ // positive { // positive
std::wstring v = convert_thousands_sep(L"1 234 567,89 "); std::wstring v = convert_thousands_sep(L"1 234 567,89 ");
typedef input_iterator<const wchar_t*> I; typedef cpp17_input_iterator<const wchar_t*> I;
long double ex; long double ex;
std::ios_base::iostate err = std::ios_base::goodbit; std::ios_base::iostate err = std::ios_base::goodbit;
I iter = f.get(I(v.data()), I(v.data() + v.size()), I iter = f.get(I(v.data()), I(v.data() + v.size()),
false, ios, err, ex); false, ios, err, ex);
assert(iter.base() == v.data() + v.size()); assert(iter.base() == v.data() + v.size());
assert(err == std::ios_base::eofbit); assert(err == std::ios_base::eofbit);
assert(ex == 123456789); assert(ex == 123456789);
} }
{ // negative { // negative
std::wstring v = convert_thousands_sep(L"-1 234 567,89"); std::wstring v = convert_thousands_sep(L"-1 234 567,89");
typedef input_iterator<const wchar_t*> I; typedef cpp17_input_iterator<const wchar_t*> I;
long double ex; long double ex;
std::ios_base::iostate err = std::ios_base::goodbit; std::ios_base::iostate err = std::ios_base::goodbit;
I iter = f.get(I(v.data()), I(v.data() + v.size()), I iter = f.get(I(v.data()), I(v.data() + v.size()),
false, ios, err, ex); false, ios, err, ex);
assert(iter.base() == v.data() + v.size()); assert(iter.base() == v.data() + v.size());
assert(err == std::ios_base::eofbit); assert(err == std::ios_base::eofbit);
assert(ex == -123456789); assert(ex == -123456789);
} }
{ // negative { // negative
std::wstring v = L"-1234567,89"; std::wstring v = L"-1234567,89";
typedef input_iterator<const wchar_t*> I; typedef cpp17_input_iterator<const wchar_t*> I;
long double ex; long double ex;
std::ios_base::iostate err = std::ios_base::goodbit; std::ios_base::iostate err = std::ios_base::goodbit;
I iter = f.get(I(v.data()), I(v.data() + v.size()), I iter = f.get(I(v.data()), I(v.data() + v.size()),
false, ios, err, ex); false, ios, err, ex);
assert(iter.base() == v.data() + v.size()); assert(iter.base() == v.data() + v.size());
assert(err == std::ios_base::eofbit); assert(err == std::ios_base::eofbit);
assert(ex == -123456789); assert(ex == -123456789);
} }
{ // zero, showbase { // zero, showbase
std::wstring v = L"0,00 \u20ac"; // EURO SIGN std::wstring v = L"0,00 \u20ac"; // EURO SIGN
showbase(ios); showbase(ios);
typedef input_iterator<const wchar_t*> I; typedef cpp17_input_iterator<const wchar_t*> I;
long double ex; long double ex;
std::ios_base::iostate err = std::ios_base::goodbit; std::ios_base::iostate err = std::ios_base::goodbit;
I iter = f.get(I(v.data()), I(v.data() + v.size()), I iter = f.get(I(v.data()), I(v.data() + v.size()),
false, ios, err, ex); false, ios, err, ex);
assert(iter.base() == v.data() + v.size()); assert(iter.base() == v.data() + v.size());
assert(err == std::ios_base::eofbit); assert(err == std::ios_base::eofbit);
assert(ex == 0); assert(ex == 0);
} }
{ // zero, showbase { // zero, showbase
std::wstring v = L"0,00 \u20ac"; // EURO SIGN std::wstring v = L"0,00 \u20ac"; // EURO SIGN
showbase(ios); showbase(ios);
typedef input_iterator<const wchar_t*> I; typedef cpp17_input_iterator<const wchar_t*> I;
long double ex; long double ex;
std::ios_base::iostate err = std::ios_base::goodbit; std::ios_base::iostate err = std::ios_base::goodbit;
I iter = f.get(I(v.data()), I(v.data() + v.size()), I iter = f.get(I(v.data()), I(v.data() + v.size()),
false, ios, err, ex); false, ios, err, ex);
assert(iter.base() == v.data() + v.size()); assert(iter.base() == v.data() + v.size());
assert(err == std::ios_base::eofbit); assert(err == std::ios_base::eofbit);
assert(ex == 0); assert(ex == 0);
} }
{ // negative one, showbase { // negative one, showbase
std::wstring v = L"-0,01 \u20ac"; // EURO SIGN std::wstring v = L"-0,01 \u20ac"; // EURO SIGN
typedef input_iterator<const wchar_t*> I; typedef cpp17_input_iterator<const wchar_t*> I;
long double ex; long double ex;
std::ios_base::iostate err = std::ios_base::goodbit; std::ios_base::iostate err = std::ios_base::goodbit;
I iter = f.get(I(v.data()), I(v.data() + v.size()), I iter = f.get(I(v.data()), I(v.data() + v.size()),
false, ios, err, ex); false, ios, err, ex);
assert(iter.base() == v.data() + v.size()); assert(iter.base() == v.data() + v.size());
assert(err == std::ios_base::eofbit); assert(err == std::ios_base::eofbit);
assert(ex == -1); assert(ex == -1);
} }
{ // negative one, showbase { // negative one, showbase
std::wstring v = L"-0,01 \u20ac"; // EURO SIGN std::wstring v = L"-0,01 \u20ac"; // EURO SIGN
showbase(ios); showbase(ios);
typedef input_iterator<const wchar_t*> I; typedef cpp17_input_iterator<const wchar_t*> I;
long double ex; long double ex;
std::ios_base::iostate err = std::ios_base::goodbit; std::ios_base::iostate err = std::ios_base::goodbit;
I iter = f.get(I(v.data()), I(v.data() + v.size()), I iter = f.get(I(v.data()), I(v.data() + v.size()),
false, ios, err, ex); false, ios, err, ex);
assert(iter.base() == v.data() + v.size()); assert(iter.base() == v.data() + v.size());
assert(err == std::ios_base::eofbit); assert(err == std::ios_base::eofbit);
assert(ex == -1); assert(ex == -1);
} }
{ // positive, showbase { // positive, showbase
std::wstring v = convert_thousands_sep(L"1 234 567,89 \u20ac"); // EURO SIGN std::wstring v = convert_thousands_sep(L"1 234 567,89 \u20ac"); // EURO SIGN
typedef input_iterator<const wchar_t*> I; typedef cpp17_input_iterator<const wchar_t*> I;
long double ex; long double ex;
std::ios_base::iostate err = std::ios_base::goodbit; std::ios_base::iostate err = std::ios_base::goodbit;
I iter = f.get(I(v.data()), I(v.data() + v.size()), I iter = f.get(I(v.data()), I(v.data() + v.size()),
false, ios, err, ex); false, ios, err, ex);
assert(iter.base() == v.data() + v.size()); assert(iter.base() == v.data() + v.size());
assert(err == std::ios_base::eofbit); assert(err == std::ios_base::eofbit);
assert(ex == 123456789); assert(ex == 123456789);
} }
{ // positive, showbase { // positive, showbase
std::wstring v = convert_thousands_sep(L"1 234 567,89 \u20ac"); // EURO SIGN std::wstring v = convert_thousands_sep(L"1 234 567,89 \u20ac"); // EURO SIGN
showbase(ios); showbase(ios);
typedef input_iterator<const wchar_t*> I; typedef cpp17_input_iterator<const wchar_t*> I;
long double ex; long double ex;
std::ios_base::iostate err = std::ios_base::goodbit; std::ios_base::iostate err = std::ios_base::goodbit;
I iter = f.get(I(v.data()), I(v.data() + v.size()), I iter = f.get(I(v.data()), I(v.data() + v.size()),
false, ios, err, ex); false, ios, err, ex);
assert(iter.base() == v.data() + v.size()); assert(iter.base() == v.data() + v.size());
assert(err == std::ios_base::eofbit); assert(err == std::ios_base::eofbit);
assert(ex == 123456789); assert(ex == 123456789);
noshowbase(ios); noshowbase(ios);
} }
{ // negative, showbase { // negative, showbase
std::wstring v = convert_thousands_sep(L"-1 234 567,89 \u20ac"); // EURO SIGN std::wstring v = convert_thousands_sep(L"-1 234 567,89 \u20ac"); // EURO SIGN
showbase(ios); showbase(ios);
typedef input_iterator<const wchar_t*> I; typedef cpp17_input_iterator<const wchar_t*> I;
long double ex; long double ex;
std::ios_base::iostate err = std::ios_base::goodbit; std::ios_base::iostate err = std::ios_base::goodbit;
I iter = f.get(I(v.data()), I(v.data() + v.size()), I iter = f.get(I(v.data()), I(v.data() + v.size()),
false, ios, err, ex); false, ios, err, ex);
assert(iter.base() == v.data() + v.size()); assert(iter.base() == v.data() + v.size());
assert(err == std::ios_base::eofbit); assert(err == std::ios_base::eofbit);
assert(ex == -123456789); assert(ex == -123456789);
noshowbase(ios); noshowbase(ios);
} }
{ // negative, showbase { // negative, showbase
std::wstring v = convert_thousands_sep(L"1 234 567,89 EUR -"); std::wstring v = convert_thousands_sep(L"1 234 567,89 EUR -");
showbase(ios); showbase(ios);
typedef input_iterator<const wchar_t*> I; typedef cpp17_input_iterator<const wchar_t*> I;
long double ex; long double ex;
std::ios_base::iostate err = std::ios_base::goodbit; std::ios_base::iostate err = std::ios_base::goodbit;
I iter = f.get(I(v.data()), I(v.data() + v.size()), I iter = f.get(I(v.data()), I(v.data() + v.size()),
false, ios, err, ex); false, ios, err, ex);
assert(iter.base() == v.data() + 13); assert(iter.base() == v.data() + 13);
assert(err == std::ios_base::failbit); assert(err == std::ios_base::failbit);
noshowbase(ios); noshowbase(ios);
} }
{ // negative, showbase { // negative, showbase
std::wstring v = convert_thousands_sep(L"1 234 567,89 EUR -"); std::wstring v = convert_thousands_sep(L"1 234 567,89 EUR -");
typedef input_iterator<const wchar_t*> I; typedef cpp17_input_iterator<const wchar_t*> I;
long double ex; long double ex;
std::ios_base::iostate err = std::ios_base::goodbit; std::ios_base::iostate err = std::ios_base::goodbit;
I iter = f.get(I(v.data()), I(v.data() + v.size()), I iter = f.get(I(v.data()), I(v.data() + v.size()),
false, ios, err, ex); false, ios, err, ex);
assert(iter.base() == v.data() + 13); assert(iter.base() == v.data() + 13);
assert(err == std::ios_base::goodbit); assert(err == std::ios_base::goodbit);
assert(ex == 123456789); assert(ex == 123456789);
} }
} }
{ {
const my_facetw f(1); const my_facetw f(1);
// wchar_t, international // wchar_t, international
{ // zero { // zero
std::wstring v = L"0,00"; std::wstring v = L"0,00";
typedef input_iterator<const wchar_t*> I; typedef cpp17_input_iterator<const wchar_t*> I;
long double ex; long double ex;
std::ios_base::iostate err = std::ios_base::goodbit; std::ios_base::iostate err = std::ios_base::goodbit;
I iter = f.get(I(v.data()), I(v.data() + v.size()), I iter = f.get(I(v.data()), I(v.data() + v.size()),
true, ios, err, ex); true, ios, err, ex);
assert(iter.base() == v.data() + v.size()); assert(iter.base() == v.data() + v.size());
assert(err == std::ios_base::eofbit); assert(err == std::ios_base::eofbit);
assert(ex == 0); assert(ex == 0);
} }
{ // negative one { // negative one
std::wstring v = L"-0,01"; std::wstring v = L"-0,01";
typedef input_iterator<const wchar_t*> I; typedef cpp17_input_iterator<const wchar_t*> I;
long double ex; long double ex;
std::ios_base::iostate err = std::ios_base::goodbit; std::ios_base::iostate err = std::ios_base::goodbit;
I iter = f.get(I(v.data()), I(v.data() + v.size()), I iter = f.get(I(v.data()), I(v.data() + v.size()),
true, ios, err, ex); true, ios, err, ex);
assert(iter.base() == v.data() + v.size()); assert(iter.base() == v.data() + v.size());
assert(err == std::ios_base::eofbit); assert(err == std::ios_base::eofbit);
assert(ex == -1); assert(ex == -1);
} }
{ // positive { // positive
std::wstring v = convert_thousands_sep(L"1 234 567,89 "); std::wstring v = convert_thousands_sep(L"1 234 567,89 ");
typedef input_iterator<const wchar_t*> I; typedef cpp17_input_iterator<const wchar_t*> I;
long double ex; long double ex;
std::ios_base::iostate err = std::ios_base::goodbit; std::ios_base::iostate err = std::ios_base::goodbit;
I iter = f.get(I(v.data()), I(v.data() + v.size()), I iter = f.get(I(v.data()), I(v.data() + v.size()),
true, ios, err, ex); true, ios, err, ex);
assert(iter.base() == v.data() + v.size()); assert(iter.base() == v.data() + v.size());
assert(err == std::ios_base::eofbit); assert(err == std::ios_base::eofbit);
assert(ex == 123456789); assert(ex == 123456789);
} }
{ // negative { // negative
std::wstring v = convert_thousands_sep(L"-1 234 567,89"); std::wstring v = convert_thousands_sep(L"-1 234 567,89");
typedef input_iterator<const wchar_t*> I; typedef cpp17_input_iterator<const wchar_t*> I;
long double ex; long double ex;
std::ios_base::iostate err = std::ios_base::goodbit; std::ios_base::iostate err = std::ios_base::goodbit;
I iter = f.get(I(v.data()), I(v.data() + v.size()), I iter = f.get(I(v.data()), I(v.data() + v.size()),
true, ios, err, ex); true, ios, err, ex);
assert(iter.base() == v.data() + v.size()); assert(iter.base() == v.data() + v.size());
assert(err == std::ios_base::eofbit); assert(err == std::ios_base::eofbit);
assert(ex == -123456789); assert(ex == -123456789);
} }
{ // negative { // negative
std::wstring v = L"-1234567,89"; std::wstring v = L"-1234567,89";
typedef input_iterator<const wchar_t*> I; typedef cpp17_input_iterator<const wchar_t*> I;
long double ex; long double ex;
std::ios_base::iostate err = std::ios_base::goodbit; std::ios_base::iostate err = std::ios_base::goodbit;
I iter = f.get(I(v.data()), I(v.data() + v.size()), I iter = f.get(I(v.data()), I(v.data() + v.size()),
true, ios, err, ex); true, ios, err, ex);
assert(iter.base() == v.data() + v.size()); assert(iter.base() == v.data() + v.size());
assert(err == std::ios_base::eofbit); assert(err == std::ios_base::eofbit);
assert(ex == -123456789); assert(ex == -123456789);
} }
{ // zero, showbase { // zero, showbase
std::wstring v = L"0,00 EUR"; std::wstring v = L"0,00 EUR";
showbase(ios); showbase(ios);
typedef input_iterator<const wchar_t*> I; typedef cpp17_input_iterator<const wchar_t*> I;
long double ex; long double ex;
std::ios_base::iostate err = std::ios_base::goodbit; std::ios_base::iostate err = std::ios_base::goodbit;
I iter = f.get(I(v.data()), I(v.data() + v.size()), I iter = f.get(I(v.data()), I(v.data() + v.size()),
true, ios, err, ex); true, ios, err, ex);
assert(iter.base() == v.data() + v.size()); assert(iter.base() == v.data() + v.size());
assert(err == std::ios_base::eofbit); assert(err == std::ios_base::eofbit);
assert(ex == 0); assert(ex == 0);
} }
{ // zero, showbase { // zero, showbase
std::wstring v = L"0,00 EUR"; std::wstring v = L"0,00 EUR";
showbase(ios); showbase(ios);
typedef input_iterator<const wchar_t*> I; typedef cpp17_input_iterator<const wchar_t*> I;
long double ex; long double ex;
std::ios_base::iostate err = std::ios_base::goodbit; std::ios_base::iostate err = std::ios_base::goodbit;
I iter = f.get(I(v.data()), I(v.data() + v.size()), I iter = f.get(I(v.data()), I(v.data() + v.size()),
true, ios, err, ex); true, ios, err, ex);
assert(iter.base() == v.data() + v.size()); assert(iter.base() == v.data() + v.size());
assert(err == std::ios_base::eofbit); assert(err == std::ios_base::eofbit);
assert(ex == 0); assert(ex == 0);
} }
{ // negative one, showbase { // negative one, showbase
std::wstring v = L"-0,01 EUR"; std::wstring v = L"-0,01 EUR";
typedef input_iterator<const wchar_t*> I; typedef cpp17_input_iterator<const wchar_t*> I;
long double ex; long double ex;
std::ios_base::iostate err = std::ios_base::goodbit; std::ios_base::iostate err = std::ios_base::goodbit;
I iter = f.get(I(v.data()), I(v.data() + v.size()), I iter = f.get(I(v.data()), I(v.data() + v.size()),
true, ios, err, ex); true, ios, err, ex);
assert(iter.base() == v.data() + v.size()); assert(iter.base() == v.data() + v.size());
assert(err == std::ios_base::eofbit); assert(err == std::ios_base::eofbit);
assert(ex == -1); assert(ex == -1);
} }
{ // negative one, showbase { // negative one, showbase
std::wstring v = L"-0,01 EUR"; std::wstring v = L"-0,01 EUR";
showbase(ios); showbase(ios);
typedef input_iterator<const wchar_t*> I; typedef cpp17_input_iterator<const wchar_t*> I;
long double ex; long double ex;
std::ios_base::iostate err = std::ios_base::goodbit; std::ios_base::iostate err = std::ios_base::goodbit;
I iter = f.get(I(v.data()), I(v.data() + v.size()), I iter = f.get(I(v.data()), I(v.data() + v.size()),
true, ios, err, ex); true, ios, err, ex);
assert(iter.base() == v.data() + v.size()); assert(iter.base() == v.data() + v.size());
assert(err == std::ios_base::eofbit); assert(err == std::ios_base::eofbit);
assert(ex == -1); assert(ex == -1);
} }
{ // positive, showbase { // positive, showbase
std::wstring v = convert_thousands_sep(L"1 234 567,89 EUR"); std::wstring v = convert_thousands_sep(L"1 234 567,89 EUR");
typedef input_iterator<const wchar_t*> I; typedef cpp17_input_iterator<const wchar_t*> I;
long double ex; long double ex;
std::ios_base::iostate err = std::ios_base::goodbit; std::ios_base::iostate err = std::ios_base::goodbit;
I iter = f.get(I(v.data()), I(v.data() + v.size()), I iter = f.get(I(v.data()), I(v.data() + v.size()),
true, ios, err, ex); true, ios, err, ex);
assert(iter.base() == v.data() + v.size()); assert(iter.base() == v.data() + v.size());
assert(err == std::ios_base::eofbit); assert(err == std::ios_base::eofbit);
assert(ex == 123456789); assert(ex == 123456789);
} }
{ // positive, showbase { // positive, showbase
std::wstring v = convert_thousands_sep(L"1 234 567,89 EUR"); std::wstring v = convert_thousands_sep(L"1 234 567,89 EUR");
showbase(ios); showbase(ios);
typedef input_iterator<const wchar_t*> I; typedef cpp17_input_iterator<const wchar_t*> I;
long double ex; long double ex;
std::ios_base::iostate err = std::ios_base::goodbit; std::ios_base::iostate err = std::ios_base::goodbit;
I iter = f.get(I(v.data()), I(v.data() + v.size()), I iter = f.get(I(v.data()), I(v.data() + v.size()),
true, ios, err, ex); true, ios, err, ex);
assert(iter.base() == v.data() + v.size()); assert(iter.base() == v.data() + v.size());
assert(err == std::ios_base::eofbit); assert(err == std::ios_base::eofbit);
assert(ex == 123456789); assert(ex == 123456789);
noshowbase(ios); noshowbase(ios);
} }
{ // negative, showbase { // negative, showbase
std::wstring v = convert_thousands_sep(L"-1 234 567,89 EUR"); std::wstring v = convert_thousands_sep(L"-1 234 567,89 EUR");
showbase(ios); showbase(ios);
typedef input_iterator<const wchar_t*> I; typedef cpp17_input_iterator<const wchar_t*> I;
long double ex; long double ex;
std::ios_base::iostate err = std::ios_base::goodbit; std::ios_base::iostate err = std::ios_base::goodbit;
I iter = f.get(I(v.data()), I(v.data() + v.size()), I iter = f.get(I(v.data()), I(v.data() + v.size()),
true, ios, err, ex); true, ios, err, ex);
assert(iter.base() == v.data() + v.size()); assert(iter.base() == v.data() + v.size());
assert(err == std::ios_base::eofbit); assert(err == std::ios_base::eofbit);
assert(ex == -123456789); assert(ex == -123456789);
noshowbase(ios); noshowbase(ios);
} }
{ // negative, showbase { // negative, showbase
std::wstring v = convert_thousands_sep(L"1 234 567,89 Eu-"); std::wstring v = convert_thousands_sep(L"1 234 567,89 Eu-");
showbase(ios); showbase(ios);
typedef input_iterator<const wchar_t*> I; typedef cpp17_input_iterator<const wchar_t*> I;
long double ex; long double ex;
std::ios_base::iostate err = std::ios_base::goodbit; std::ios_base::iostate err = std::ios_base::goodbit;
I iter = f.get(I(v.data()), I(v.data() + v.size()), I iter = f.get(I(v.data()), I(v.data() + v.size()),
true, ios, err, ex); true, ios, err, ex);
assert(iter.base() == v.data() + 14); assert(iter.base() == v.data() + 14);
assert(err == std::ios_base::failbit); assert(err == std::ios_base::failbit);
noshowbase(ios); noshowbase(ios);
} }
{ // negative, showbase { // negative, showbase
std::wstring v = convert_thousands_sep(L"1 234 567,89 Eu-"); std::wstring v = convert_thousands_sep(L"1 234 567,89 Eu-");
typedef input_iterator<const wchar_t*> I; typedef cpp17_input_iterator<const wchar_t*> I;
long double ex; long double ex;
std::ios_base::iostate err = std::ios_base::goodbit; std::ios_base::iostate err = std::ios_base::goodbit;
I iter = f.get(I(v.data()), I(v.data() + v.size()), I iter = f.get(I(v.data()), I(v.data() + v.size()),
true, ios, err, ex); true, ios, err, ex);
assert(iter.base() == v.data() + 13); assert(iter.base() == v.data() + 13);
assert(err == std::ios_base::goodbit); assert(err == std::ios_base::goodbit);
assert(ex == 123456789); assert(ex == 123456789);
} }
} }
return 0; return 0;
} }

libcxx/test/std/localization/locale.categories/category.monetary/locale.money.get/locale.money.get.members/get_long_double_ru_RU.pass.cpp

Show First 20 Lines • Show All 42 Lines • ▼ Show 20 Lines
// we test. To avoid this test becoming entirely stale, we just disable // we test. To avoid this test becoming entirely stale, we just disable
// the parts that fail. // the parts that fail.
// //
// See https://llvm.org/PR45739 for the bug tracking this. // See https://llvm.org/PR45739 for the bug tracking this.
#if defined(__APPLE__) #if defined(__APPLE__)
# define APPLE_FIXME # define APPLE_FIXME
#endif #endif
typedef std::money_get<char, input_iterator<const char*> > Fn; typedef std::money_get<char, cpp17_input_iterator<const char*> > Fn;
class my_facet class my_facet
: public Fn : public Fn
{ {
public: public:
explicit my_facet(std::size_t refs = 0) explicit my_facet(std::size_t refs = 0)
: Fn(refs) {} : Fn(refs) {}
}; };
typedef std::money_get<wchar_t, input_iterator<const wchar_t*> > Fw; typedef std::money_get<wchar_t, cpp17_input_iterator<const wchar_t*> > Fw;
class my_facetw class my_facetw
: public Fw : public Fw
{ {
public: public:
explicit my_facetw(std::size_t refs = 0) explicit my_facetw(std::size_t refs = 0)
: Fw(refs) {} : Fw(refs) {}
}; };
Show All 10 Lines ios.imbue(std::locale(ios.getloc(),
new std::moneypunct_byname<wchar_t, false>(loc_name))); new std::moneypunct_byname<wchar_t, false>(loc_name)));
ios.imbue(std::locale(ios.getloc(), ios.imbue(std::locale(ios.getloc(),
new std::moneypunct_byname<wchar_t, true>(loc_name))); new std::moneypunct_byname<wchar_t, true>(loc_name)));
{ {
const my_facet f(1); const my_facet f(1);
// char, national // char, national
{ // zero { // zero
std::string v = "0,00 "; std::string v = "0,00 ";
typedef input_iterator<const char*> I; typedef cpp17_input_iterator<const char*> I;
long double ex; long double ex;
std::ios_base::iostate err = std::ios_base::goodbit; std::ios_base::iostate err = std::ios_base::goodbit;
I iter = f.get(I(v.data()), I(v.data() + v.size()), I iter = f.get(I(v.data()), I(v.data() + v.size()),
false, ios, err, ex); false, ios, err, ex);
assert(iter.base() == v.data() + v.size()); assert(iter.base() == v.data() + v.size());
assert(err == std::ios_base::eofbit); assert(err == std::ios_base::eofbit);
assert(ex == 0); assert(ex == 0);
} }
{ // negative one { // negative one
std::string v = "-0,01 "; std::string v = "-0,01 ";
typedef input_iterator<const char*> I; typedef cpp17_input_iterator<const char*> I;
long double ex; long double ex;
std::ios_base::iostate err = std::ios_base::goodbit; std::ios_base::iostate err = std::ios_base::goodbit;
I iter = f.get(I(v.data()), I(v.data() + v.size()), I iter = f.get(I(v.data()), I(v.data() + v.size()),
false, ios, err, ex); false, ios, err, ex);
assert(iter.base() == v.data() + v.size()); assert(iter.base() == v.data() + v.size());
assert(err == std::ios_base::eofbit); assert(err == std::ios_base::eofbit);
assert(ex == -1); assert(ex == -1);
} }
{ // positive { // positive
std::string v = "1 234 567,89 "; std::string v = "1 234 567,89 ";
typedef input_iterator<const char*> I; typedef cpp17_input_iterator<const char*> I;
long double ex; long double ex;
std::ios_base::iostate err = std::ios_base::goodbit; std::ios_base::iostate err = std::ios_base::goodbit;
I iter = f.get(I(v.data()), I(v.data() + v.size()), I iter = f.get(I(v.data()), I(v.data() + v.size()),
false, ios, err, ex); false, ios, err, ex);
assert(iter.base() == v.data() + v.size()); assert(iter.base() == v.data() + v.size());
assert(err == std::ios_base::eofbit); assert(err == std::ios_base::eofbit);
assert(ex == 123456789); assert(ex == 123456789);
} }
{ // negative { // negative
std::string v = "-1 234 567,89 "; std::string v = "-1 234 567,89 ";
typedef input_iterator<const char*> I; typedef cpp17_input_iterator<const char*> I;
long double ex; long double ex;
std::ios_base::iostate err = std::ios_base::goodbit; std::ios_base::iostate err = std::ios_base::goodbit;
I iter = f.get(I(v.data()), I(v.data() + v.size()), I iter = f.get(I(v.data()), I(v.data() + v.size()),
false, ios, err, ex); false, ios, err, ex);
assert(iter.base() == v.data() + v.size()); assert(iter.base() == v.data() + v.size());
assert(err == std::ios_base::eofbit); assert(err == std::ios_base::eofbit);
assert(ex == -123456789); assert(ex == -123456789);
} }
{ // negative { // negative
std::string v = "-1234567,89 "; std::string v = "-1234567,89 ";
typedef input_iterator<const char*> I; typedef cpp17_input_iterator<const char*> I;
long double ex; long double ex;
std::ios_base::iostate err = std::ios_base::goodbit; std::ios_base::iostate err = std::ios_base::goodbit;
I iter = f.get(I(v.data()), I(v.data() + v.size()), I iter = f.get(I(v.data()), I(v.data() + v.size()),
false, ios, err, ex); false, ios, err, ex);
assert(iter.base() == v.data() + v.size()); assert(iter.base() == v.data() + v.size());
assert(err == std::ios_base::eofbit); assert(err == std::ios_base::eofbit);
assert(ex == -123456789); assert(ex == -123456789);
} }
{ // zero, showbase { // zero, showbase
std::string v = "0,00 \xD1\x80\xD1\x83\xD0\xB1""."; std::string v = "0,00 \xD1\x80\xD1\x83\xD0\xB1"".";
typedef input_iterator<const char*> I; typedef cpp17_input_iterator<const char*> I;
long double ex; long double ex;
std::ios_base::iostate err = std::ios_base::goodbit; std::ios_base::iostate err = std::ios_base::goodbit;
I iter = f.get(I(v.data()), I(v.data() + v.size()), I iter = f.get(I(v.data()), I(v.data() + v.size()),
false, ios, err, ex); false, ios, err, ex);
assert(iter.base() == v.data() + 5); assert(iter.base() == v.data() + 5);
assert(err == std::ios_base::goodbit); assert(err == std::ios_base::goodbit);
assert(ex == 0); assert(ex == 0);
} }
{ // zero, showbase { // zero, showbase
std::string v = "0,00 \xD1\x80\xD1\x83\xD0\xB1""."; std::string v = "0,00 \xD1\x80\xD1\x83\xD0\xB1"".";
showbase(ios); showbase(ios);
typedef input_iterator<const char*> I; typedef cpp17_input_iterator<const char*> I;
long double ex; long double ex;
std::ios_base::iostate err = std::ios_base::goodbit; std::ios_base::iostate err = std::ios_base::goodbit;
I iter = f.get(I(v.data()), I(v.data() + v.size()), I iter = f.get(I(v.data()), I(v.data() + v.size()),
false, ios, err, ex); false, ios, err, ex);
assert(iter.base() == v.data() + v.size()); assert(iter.base() == v.data() + v.size());
assert(err == std::ios_base::eofbit); assert(err == std::ios_base::eofbit);
assert(ex == 0); assert(ex == 0);
noshowbase(ios); noshowbase(ios);
} }
{ // negative one, showbase { // negative one, showbase
std::string v = "-0,01 \xD1\x80\xD1\x83\xD0\xB1""."; std::string v = "-0,01 \xD1\x80\xD1\x83\xD0\xB1"".";
typedef input_iterator<const char*> I; typedef cpp17_input_iterator<const char*> I;
long double ex; long double ex;
std::ios_base::iostate err = std::ios_base::goodbit; std::ios_base::iostate err = std::ios_base::goodbit;
I iter = f.get(I(v.data()), I(v.data() + v.size()), I iter = f.get(I(v.data()), I(v.data() + v.size()),
false, ios, err, ex); false, ios, err, ex);
assert(iter.base() == v.data() + 6); assert(iter.base() == v.data() + 6);
assert(err == std::ios_base::goodbit); assert(err == std::ios_base::goodbit);
assert(ex == -1); assert(ex == -1);
} }
{ // negative one, showbase { // negative one, showbase
std::string v = "-0,01 \xD1\x80\xD1\x83\xD0\xB1""."; std::string v = "-0,01 \xD1\x80\xD1\x83\xD0\xB1"".";
showbase(ios); showbase(ios);
typedef input_iterator<const char*> I; typedef cpp17_input_iterator<const char*> I;
long double ex; long double ex;
std::ios_base::iostate err = std::ios_base::goodbit; std::ios_base::iostate err = std::ios_base::goodbit;
I iter = f.get(I(v.data()), I(v.data() + v.size()), I iter = f.get(I(v.data()), I(v.data() + v.size()),
false, ios, err, ex); false, ios, err, ex);
assert(iter.base() == v.data() + v.size()); assert(iter.base() == v.data() + v.size());
assert(err == std::ios_base::eofbit); assert(err == std::ios_base::eofbit);
assert(ex == -1); assert(ex == -1);
noshowbase(ios); noshowbase(ios);
} }
{ // positive, showbase { // positive, showbase
std::string v = "1 234 567,89 \xD1\x80\xD1\x83\xD0\xB1""."; std::string v = "1 234 567,89 \xD1\x80\xD1\x83\xD0\xB1"".";
typedef input_iterator<const char*> I; typedef cpp17_input_iterator<const char*> I;
long double ex; long double ex;
std::ios_base::iostate err = std::ios_base::goodbit; std::ios_base::iostate err = std::ios_base::goodbit;
I iter = f.get(I(v.data()), I(v.data() + v.size()), I iter = f.get(I(v.data()), I(v.data() + v.size()),
false, ios, err, ex); false, ios, err, ex);
assert(iter.base() == v.data() + 13); assert(iter.base() == v.data() + 13);
assert(err == std::ios_base::goodbit); assert(err == std::ios_base::goodbit);
assert(ex == 123456789); assert(ex == 123456789);
} }
{ // positive, showbase { // positive, showbase
std::string v = "1 234 567,89 \xD1\x80\xD1\x83\xD0\xB1""."; std::string v = "1 234 567,89 \xD1\x80\xD1\x83\xD0\xB1"".";
showbase(ios); showbase(ios);
typedef input_iterator<const char*> I; typedef cpp17_input_iterator<const char*> I;
long double ex; long double ex;
std::ios_base::iostate err = std::ios_base::goodbit; std::ios_base::iostate err = std::ios_base::goodbit;
I iter = f.get(I(v.data()), I(v.data() + v.size()), I iter = f.get(I(v.data()), I(v.data() + v.size()),
false, ios, err, ex); false, ios, err, ex);
assert(iter.base() == v.data() + v.size()); assert(iter.base() == v.data() + v.size());
assert(err == std::ios_base::eofbit); assert(err == std::ios_base::eofbit);
assert(ex == 123456789); assert(ex == 123456789);
noshowbase(ios); noshowbase(ios);
} }
{ // negative, showbase { // negative, showbase
std::string v = "-1 234 567,89 \xD1\x80\xD1\x83\xD0\xB1""."; std::string v = "-1 234 567,89 \xD1\x80\xD1\x83\xD0\xB1"".";
showbase(ios); showbase(ios);
typedef input_iterator<const char*> I; typedef cpp17_input_iterator<const char*> I;
long double ex; long double ex;
std::ios_base::iostate err = std::ios_base::goodbit; std::ios_base::iostate err = std::ios_base::goodbit;
I iter = f.get(I(v.data()), I(v.data() + v.size()), I iter = f.get(I(v.data()), I(v.data() + v.size()),
false, ios, err, ex); false, ios, err, ex);
assert(iter.base() == v.data() + v.size()); assert(iter.base() == v.data() + v.size());
assert(err == std::ios_base::eofbit); assert(err == std::ios_base::eofbit);
assert(ex == -123456789); assert(ex == -123456789);
noshowbase(ios); noshowbase(ios);
} }
{ // negative, showbase { // negative, showbase
std::string v = "-1 234 567,89 RUB "; std::string v = "-1 234 567,89 RUB ";
showbase(ios); showbase(ios);
typedef input_iterator<const char*> I; typedef cpp17_input_iterator<const char*> I;
long double ex; long double ex;
std::ios_base::iostate err = std::ios_base::goodbit; std::ios_base::iostate err = std::ios_base::goodbit;
I iter = f.get(I(v.data()), I(v.data() + v.size()), I iter = f.get(I(v.data()), I(v.data() + v.size()),
false, ios, err, ex); false, ios, err, ex);
assert(iter.base() == v.data() + 14); assert(iter.base() == v.data() + 14);
assert(err == std::ios_base::failbit); assert(err == std::ios_base::failbit);
noshowbase(ios); noshowbase(ios);
} }
{ // negative, showbase { // negative, showbase
std::string v = "-1 234 567,89 RUB "; std::string v = "-1 234 567,89 RUB ";
typedef input_iterator<const char*> I; typedef cpp17_input_iterator<const char*> I;
long double ex; long double ex;
std::ios_base::iostate err = std::ios_base::goodbit; std::ios_base::iostate err = std::ios_base::goodbit;
I iter = f.get(I(v.data()), I(v.data() + v.size()), I iter = f.get(I(v.data()), I(v.data() + v.size()),
false, ios, err, ex); false, ios, err, ex);
assert(iter.base() == v.data() + 14); assert(iter.base() == v.data() + 14);
assert(err == std::ios_base::goodbit); assert(err == std::ios_base::goodbit);
assert(ex == -123456789); assert(ex == -123456789);
} }
} }
{ {
const my_facet f(1); const my_facet f(1);
// char, international // char, international
{ // zero { // zero
std::string v = "0,00"; std::string v = "0,00";
typedef input_iterator<const char*> I; typedef cpp17_input_iterator<const char*> I;
long double ex; long double ex;
std::ios_base::iostate err = std::ios_base::goodbit; std::ios_base::iostate err = std::ios_base::goodbit;
I iter = f.get(I(v.data()), I(v.data() + v.size()), I iter = f.get(I(v.data()), I(v.data() + v.size()),
true, ios, err, ex); true, ios, err, ex);
assert(iter.base() == v.data() + v.size()); assert(iter.base() == v.data() + v.size());
assert(err == std::ios_base::eofbit); assert(err == std::ios_base::eofbit);
assert(ex == 0); assert(ex == 0);
} }
{ // negative one { // negative one
std::string v = "-0,01 "; std::string v = "-0,01 ";
typedef input_iterator<const char*> I; typedef cpp17_input_iterator<const char*> I;
long double ex; long double ex;
std::ios_base::iostate err = std::ios_base::goodbit; std::ios_base::iostate err = std::ios_base::goodbit;
I iter = f.get(I(v.data()), I(v.data() + v.size()), I iter = f.get(I(v.data()), I(v.data() + v.size()),
true, ios, err, ex); true, ios, err, ex);
assert(iter.base() == v.data() + v.size()); assert(iter.base() == v.data() + v.size());
assert(err == std::ios_base::eofbit); assert(err == std::ios_base::eofbit);
assert(ex == -1); assert(ex == -1);
} }
{ // positive { // positive
std::string v = "1 234 567,89 "; std::string v = "1 234 567,89 ";
typedef input_iterator<const char*> I; typedef cpp17_input_iterator<const char*> I;
long double ex; long double ex;
std::ios_base::iostate err = std::ios_base::goodbit; std::ios_base::iostate err = std::ios_base::goodbit;
I iter = f.get(I(v.data()), I(v.data() + v.size()), I iter = f.get(I(v.data()), I(v.data() + v.size()),
true, ios, err, ex); true, ios, err, ex);
assert(iter.base() == v.data() + v.size()); assert(iter.base() == v.data() + v.size());
assert(err == std::ios_base::eofbit); assert(err == std::ios_base::eofbit);
assert(ex == 123456789); assert(ex == 123456789);
} }
{ // negative { // negative
std::string v = "-1 234 567,89 "; std::string v = "-1 234 567,89 ";
typedef input_iterator<const char*> I; typedef cpp17_input_iterator<const char*> I;
long double ex; long double ex;
std::ios_base::iostate err = std::ios_base::goodbit; std::ios_base::iostate err = std::ios_base::goodbit;
I iter = f.get(I(v.data()), I(v.data() + v.size()), I iter = f.get(I(v.data()), I(v.data() + v.size()),
true, ios, err, ex); true, ios, err, ex);
assert(iter.base() == v.data() + v.size()); assert(iter.base() == v.data() + v.size());
assert(err == std::ios_base::eofbit); assert(err == std::ios_base::eofbit);
assert(ex == -123456789); assert(ex == -123456789);
} }
{ // negative { // negative
std::string v = "-1234567,89 "; std::string v = "-1234567,89 ";
typedef input_iterator<const char*> I; typedef cpp17_input_iterator<const char*> I;
long double ex; long double ex;
std::ios_base::iostate err = std::ios_base::goodbit; std::ios_base::iostate err = std::ios_base::goodbit;
I iter = f.get(I(v.data()), I(v.data() + v.size()), I iter = f.get(I(v.data()), I(v.data() + v.size()),
true, ios, err, ex); true, ios, err, ex);
assert(iter.base() == v.data() + v.size()); assert(iter.base() == v.data() + v.size());
assert(err == std::ios_base::eofbit); assert(err == std::ios_base::eofbit);
assert(ex == -123456789); assert(ex == -123456789);
} }
{ // zero, showbase { // zero, showbase
std::string v = "0,00 RUB "; std::string v = "0,00 RUB ";
typedef input_iterator<const char*> I; typedef cpp17_input_iterator<const char*> I;
long double ex; long double ex;
std::ios_base::iostate err = std::ios_base::goodbit; std::ios_base::iostate err = std::ios_base::goodbit;
I iter = f.get(I(v.data()), I(v.data() + v.size()), I iter = f.get(I(v.data()), I(v.data() + v.size()),
true, ios, err, ex); true, ios, err, ex);
assert(iter.base() == v.data() + 5); assert(iter.base() == v.data() + 5);
assert(err == std::ios_base::goodbit); assert(err == std::ios_base::goodbit);
assert(ex == 0); assert(ex == 0);
} }
#if !defined(APPLE_FIXME) #if !defined(APPLE_FIXME)
{ // zero, showbase { // zero, showbase
std::string v = "0,00 RUB "; std::string v = "0,00 RUB ";
showbase(ios); showbase(ios);
typedef input_iterator<const char*> I; typedef cpp17_input_iterator<const char*> I;
long double ex; long double ex;
std::ios_base::iostate err = std::ios_base::goodbit; std::ios_base::iostate err = std::ios_base::goodbit;
I iter = f.get(I(v.data()), I(v.data() + v.size()), I iter = f.get(I(v.data()), I(v.data() + v.size()),
true, ios, err, ex); true, ios, err, ex);
assert(iter.base() == v.data() + v.size()); assert(iter.base() == v.data() + v.size());
assert(err == std::ios_base::eofbit); assert(err == std::ios_base::eofbit);
assert(ex == 0); assert(ex == 0);
noshowbase(ios); noshowbase(ios);
} }
#endif #endif
{ // negative one, showbase { // negative one, showbase
std::string v = "-0,01 RUB "; std::string v = "-0,01 RUB ";
typedef input_iterator<const char*> I; typedef cpp17_input_iterator<const char*> I;
long double ex; long double ex;
std::ios_base::iostate err = std::ios_base::goodbit; std::ios_base::iostate err = std::ios_base::goodbit;
I iter = f.get(I(v.data()), I(v.data() + v.size()), I iter = f.get(I(v.data()), I(v.data() + v.size()),
true, ios, err, ex); true, ios, err, ex);
assert(iter.base() == v.data() + 6); assert(iter.base() == v.data() + 6);
assert(err == std::ios_base::goodbit); assert(err == std::ios_base::goodbit);
assert(ex == -1); assert(ex == -1);
} }
#if !defined(APPLE_FIXME) #if !defined(APPLE_FIXME)
{ // negative one, showbase { // negative one, showbase
std::string v = "-0,01 RUB "; std::string v = "-0,01 RUB ";
showbase(ios); showbase(ios);
typedef input_iterator<const char*> I; typedef cpp17_input_iterator<const char*> I;
long double ex; long double ex;
std::ios_base::iostate err = std::ios_base::goodbit; std::ios_base::iostate err = std::ios_base::goodbit;
I iter = f.get(I(v.data()), I(v.data() + v.size()), I iter = f.get(I(v.data()), I(v.data() + v.size()),
true, ios, err, ex); true, ios, err, ex);
assert(iter.base() == v.data() + v.size()); assert(iter.base() == v.data() + v.size());
assert(err == std::ios_base::eofbit); assert(err == std::ios_base::eofbit);
assert(ex == -1); assert(ex == -1);
noshowbase(ios); noshowbase(ios);
} }
#endif #endif
{ // positive, showbase { // positive, showbase
std::string v = "1 234 567,89 RUB "; std::string v = "1 234 567,89 RUB ";
typedef input_iterator<const char*> I; typedef cpp17_input_iterator<const char*> I;
long double ex; long double ex;
std::ios_base::iostate err = std::ios_base::goodbit; std::ios_base::iostate err = std::ios_base::goodbit;
I iter = f.get(I(v.data()), I(v.data() + v.size()), I iter = f.get(I(v.data()), I(v.data() + v.size()),
true, ios, err, ex); true, ios, err, ex);
assert(iter.base() == v.data() + 13); assert(iter.base() == v.data() + 13);
assert(err == std::ios_base::goodbit); assert(err == std::ios_base::goodbit);
assert(ex == 123456789); assert(ex == 123456789);
} }
#if !defined(APPLE_FIXME) #if !defined(APPLE_FIXME)
{ // positive, showbase { // positive, showbase
std::string v = "1 234 567,89 RUB "; std::string v = "1 234 567,89 RUB ";
showbase(ios); showbase(ios);
typedef input_iterator<const char*> I; typedef cpp17_input_iterator<const char*> I;
long double ex; long double ex;
std::ios_base::iostate err = std::ios_base::goodbit; std::ios_base::iostate err = std::ios_base::goodbit;
I iter = f.get(I(v.data()), I(v.data() + v.size()), I iter = f.get(I(v.data()), I(v.data() + v.size()),
true, ios, err, ex); true, ios, err, ex);
assert(iter.base() == v.data() + v.size()); assert(iter.base() == v.data() + v.size());
assert(err == std::ios_base::eofbit); assert(err == std::ios_base::eofbit);
assert(ex == 123456789); assert(ex == 123456789);
noshowbase(ios); noshowbase(ios);
} }
#endif #endif
#if !defined(APPLE_FIXME) #if !defined(APPLE_FIXME)
{ // negative, showbase { // negative, showbase
std::string v = "-1 234 567,89 RUB "; std::string v = "-1 234 567,89 RUB ";
showbase(ios); showbase(ios);
typedef input_iterator<const char*> I; typedef cpp17_input_iterator<const char*> I;
long double ex; long double ex;
std::ios_base::iostate err = std::ios_base::goodbit; std::ios_base::iostate err = std::ios_base::goodbit;
I iter = f.get(I(v.data()), I(v.data() + v.size()), I iter = f.get(I(v.data()), I(v.data() + v.size()),
true, ios, err, ex); true, ios, err, ex);
assert(iter.base() == v.data() + v.size()); assert(iter.base() == v.data() + v.size());
assert(err == std::ios_base::eofbit); assert(err == std::ios_base::eofbit);
assert(ex == -123456789); assert(ex == -123456789);
noshowbase(ios); noshowbase(ios);
} }
#endif #endif
{ // negative, showbase { // negative, showbase
std::string v = "-1 234 567,89 \xD1\x80\xD1\x83\xD0\xB1""."; std::string v = "-1 234 567,89 \xD1\x80\xD1\x83\xD0\xB1"".";
showbase(ios); showbase(ios);
typedef input_iterator<const char*> I; typedef cpp17_input_iterator<const char*> I;
long double ex; long double ex;
std::ios_base::iostate err = std::ios_base::goodbit; std::ios_base::iostate err = std::ios_base::goodbit;
I iter = f.get(I(v.data()), I(v.data() + v.size()), I iter = f.get(I(v.data()), I(v.data() + v.size()),
true, ios, err, ex); true, ios, err, ex);
assert(iter.base() == v.data() + 14); assert(iter.base() == v.data() + 14);
assert(err == std::ios_base::failbit); assert(err == std::ios_base::failbit);
noshowbase(ios); noshowbase(ios);
} }
{ // negative, showbase { // negative, showbase
std::string v = "-1 234 567,89 \xD1\x80\xD1\x83\xD0\xB1""."; std::string v = "-1 234 567,89 \xD1\x80\xD1\x83\xD0\xB1"".";
typedef input_iterator<const char*> I; typedef cpp17_input_iterator<const char*> I;
long double ex; long double ex;
std::ios_base::iostate err = std::ios_base::goodbit; std::ios_base::iostate err = std::ios_base::goodbit;
I iter = f.get(I(v.data()), I(v.data() + v.size()), I iter = f.get(I(v.data()), I(v.data() + v.size()),
true, ios, err, ex); true, ios, err, ex);
assert(iter.base() == v.data() + 14); assert(iter.base() == v.data() + 14);
assert(err == std::ios_base::goodbit); assert(err == std::ios_base::goodbit);
assert(ex == -123456789); assert(ex == -123456789);
} }
} }
{ {
const my_facetw f(1); const my_facetw f(1);
// wchar_t, national // wchar_t, national
{ // zero { // zero
std::wstring v = L"0,00"; std::wstring v = L"0,00";
typedef input_iterator<const wchar_t*> I; typedef cpp17_input_iterator<const wchar_t*> I;
long double ex; long double ex;
std::ios_base::iostate err = std::ios_base::goodbit; std::ios_base::iostate err = std::ios_base::goodbit;
I iter = f.get(I(v.data()), I(v.data() + v.size()), I iter = f.get(I(v.data()), I(v.data() + v.size()),
false, ios, err, ex); false, ios, err, ex);
assert(iter.base() == v.data() + v.size()); assert(iter.base() == v.data() + v.size());
assert(err == std::ios_base::eofbit); assert(err == std::ios_base::eofbit);
assert(ex == 0); assert(ex == 0);
} }
{ // negative one { // negative one
std::wstring v = L"-0,01 "; std::wstring v = L"-0,01 ";
typedef input_iterator<const wchar_t*> I; typedef cpp17_input_iterator<const wchar_t*> I;
long double ex; long double ex;
std::ios_base::iostate err = std::ios_base::goodbit; std::ios_base::iostate err = std::ios_base::goodbit;
I iter = f.get(I(v.data()), I(v.data() + v.size()), I iter = f.get(I(v.data()), I(v.data() + v.size()),
false, ios, err, ex); false, ios, err, ex);
assert(iter.base() == v.data() + v.size()); assert(iter.base() == v.data() + v.size());
assert(err == std::ios_base::eofbit); assert(err == std::ios_base::eofbit);
assert(ex == -1); assert(ex == -1);
} }
{ // positive { // positive
std::wstring v = L"1 234 567,89 "; std::wstring v = L"1 234 567,89 ";
typedef input_iterator<const wchar_t*> I; typedef cpp17_input_iterator<const wchar_t*> I;
long double ex; long double ex;
std::ios_base::iostate err = std::ios_base::goodbit; std::ios_base::iostate err = std::ios_base::goodbit;
I iter = f.get(I(v.data()), I(v.data() + v.size()), I iter = f.get(I(v.data()), I(v.data() + v.size()),
false, ios, err, ex); false, ios, err, ex);
assert(iter.base() == v.data() + v.size()); assert(iter.base() == v.data() + v.size());
assert(err == std::ios_base::eofbit); assert(err == std::ios_base::eofbit);
assert(ex == 123456789); assert(ex == 123456789);
} }
{ // negative { // negative
std::wstring v = L"-1 234 567,89 "; std::wstring v = L"-1 234 567,89 ";
typedef input_iterator<const wchar_t*> I; typedef cpp17_input_iterator<const wchar_t*> I;
long double ex; long double ex;
std::ios_base::iostate err = std::ios_base::goodbit; std::ios_base::iostate err = std::ios_base::goodbit;
I iter = f.get(I(v.data()), I(v.data() + v.size()), I iter = f.get(I(v.data()), I(v.data() + v.size()),
false, ios, err, ex); false, ios, err, ex);
assert(iter.base() == v.data() + v.size()); assert(iter.base() == v.data() + v.size());
assert(err == std::ios_base::eofbit); assert(err == std::ios_base::eofbit);
assert(ex == -123456789); assert(ex == -123456789);
} }
{ // negative { // negative
std::wstring v = L"-1234567,89 "; std::wstring v = L"-1234567,89 ";
typedef input_iterator<const wchar_t*> I; typedef cpp17_input_iterator<const wchar_t*> I;
long double ex; long double ex;
std::ios_base::iostate err = std::ios_base::goodbit; std::ios_base::iostate err = std::ios_base::goodbit;
I iter = f.get(I(v.data()), I(v.data() + v.size()), I iter = f.get(I(v.data()), I(v.data() + v.size()),
false, ios, err, ex); false, ios, err, ex);
assert(iter.base() == v.data() + v.size()); assert(iter.base() == v.data() + v.size());
assert(err == std::ios_base::eofbit); assert(err == std::ios_base::eofbit);
assert(ex == -123456789); assert(ex == -123456789);
} }
{ // zero, showbase { // zero, showbase
std::wstring v = L"0,00 \x440\x443\x431""."; std::wstring v = L"0,00 \x440\x443\x431"".";
typedef input_iterator<const wchar_t*> I; typedef cpp17_input_iterator<const wchar_t*> I;
long double ex; long double ex;
std::ios_base::iostate err = std::ios_base::goodbit; std::ios_base::iostate err = std::ios_base::goodbit;
I iter = f.get(I(v.data()), I(v.data() + v.size()), I iter = f.get(I(v.data()), I(v.data() + v.size()),
false, ios, err, ex); false, ios, err, ex);
assert(iter.base() == v.data() + 5); assert(iter.base() == v.data() + 5);
assert(err == std::ios_base::goodbit); assert(err == std::ios_base::goodbit);
assert(ex == 0); assert(ex == 0);
} }
{ // zero, showbase { // zero, showbase
std::wstring v = L"0,00 \x440\x443\x431""."; std::wstring v = L"0,00 \x440\x443\x431"".";
showbase(ios); showbase(ios);
typedef input_iterator<const wchar_t*> I; typedef cpp17_input_iterator<const wchar_t*> I;
long double ex; long double ex;
std::ios_base::iostate err = std::ios_base::goodbit; std::ios_base::iostate err = std::ios_base::goodbit;
I iter = f.get(I(v.data()), I(v.data() + v.size()), I iter = f.get(I(v.data()), I(v.data() + v.size()),
false, ios, err, ex); false, ios, err, ex);
assert(iter.base() == v.data() + v.size()); assert(iter.base() == v.data() + v.size());
assert(err == std::ios_base::eofbit); assert(err == std::ios_base::eofbit);
assert(ex == 0); assert(ex == 0);
noshowbase(ios); noshowbase(ios);
} }
{ // negative one, showbase { // negative one, showbase
std::wstring v = L"-0,01 \x440\x443\x431""."; std::wstring v = L"-0,01 \x440\x443\x431"".";
typedef input_iterator<const wchar_t*> I; typedef cpp17_input_iterator<const wchar_t*> I;
long double ex; long double ex;
std::ios_base::iostate err = std::ios_base::goodbit; std::ios_base::iostate err = std::ios_base::goodbit;
I iter = f.get(I(v.data()), I(v.data() + v.size()), I iter = f.get(I(v.data()), I(v.data() + v.size()),
false, ios, err, ex); false, ios, err, ex);
assert(iter.base() == v.data() + 6); assert(iter.base() == v.data() + 6);
assert(err == std::ios_base::goodbit); assert(err == std::ios_base::goodbit);
assert(ex == -1); assert(ex == -1);
} }
{ // negative one, showbase { // negative one, showbase
std::wstring v = L"-0,01 \x440\x443\x431""."; std::wstring v = L"-0,01 \x440\x443\x431"".";
showbase(ios); showbase(ios);
typedef input_iterator<const wchar_t*> I; typedef cpp17_input_iterator<const wchar_t*> I;
long double ex; long double ex;
std::ios_base::iostate err = std::ios_base::goodbit; std::ios_base::iostate err = std::ios_base::goodbit;
I iter = f.get(I(v.data()), I(v.data() + v.size()), I iter = f.get(I(v.data()), I(v.data() + v.size()),
false, ios, err, ex); false, ios, err, ex);
assert(iter.base() == v.data() + v.size()); assert(iter.base() == v.data() + v.size());
assert(err == std::ios_base::eofbit); assert(err == std::ios_base::eofbit);
assert(ex == -1); assert(ex == -1);
noshowbase(ios); noshowbase(ios);
} }
{ // positive, showbase { // positive, showbase
std::wstring v = L"1 234 567,89 \x440\x443\x431""."; std::wstring v = L"1 234 567,89 \x440\x443\x431"".";
typedef input_iterator<const wchar_t*> I; typedef cpp17_input_iterator<const wchar_t*> I;
long double ex; long double ex;
std::ios_base::iostate err = std::ios_base::goodbit; std::ios_base::iostate err = std::ios_base::goodbit;
I iter = f.get(I(v.data()), I(v.data() + v.size()), I iter = f.get(I(v.data()), I(v.data() + v.size()),
false, ios, err, ex); false, ios, err, ex);
assert(iter.base() == v.data() + 13); assert(iter.base() == v.data() + 13);
assert(err == std::ios_base::goodbit); assert(err == std::ios_base::goodbit);
assert(ex == 123456789); assert(ex == 123456789);
} }
{ // positive, showbase { // positive, showbase
std::wstring v = L"1 234 567,89 \x440\x443\x431""."; std::wstring v = L"1 234 567,89 \x440\x443\x431"".";
showbase(ios); showbase(ios);
typedef input_iterator<const wchar_t*> I; typedef cpp17_input_iterator<const wchar_t*> I;
long double ex; long double ex;
std::ios_base::iostate err = std::ios_base::goodbit; std::ios_base::iostate err = std::ios_base::goodbit;
I iter = f.get(I(v.data()), I(v.data() + v.size()), I iter = f.get(I(v.data()), I(v.data() + v.size()),
false, ios, err, ex); false, ios, err, ex);
assert(iter.base() == v.data() + v.size()); assert(iter.base() == v.data() + v.size());
assert(err == std::ios_base::eofbit); assert(err == std::ios_base::eofbit);
assert(ex == 123456789); assert(ex == 123456789);
noshowbase(ios); noshowbase(ios);
} }
{ // negative, showbase { // negative, showbase
std::wstring v = L"-1 234 567,89 \x440\x443\x431""."; std::wstring v = L"-1 234 567,89 \x440\x443\x431"".";
showbase(ios); showbase(ios);
typedef input_iterator<const wchar_t*> I; typedef cpp17_input_iterator<const wchar_t*> I;
long double ex; long double ex;
std::ios_base::iostate err = std::ios_base::goodbit; std::ios_base::iostate err = std::ios_base::goodbit;
I iter = f.get(I(v.data()), I(v.data() + v.size()), I iter = f.get(I(v.data()), I(v.data() + v.size()),
false, ios, err, ex); false, ios, err, ex);
assert(iter.base() == v.data() + v.size()); assert(iter.base() == v.data() + v.size());
assert(err == std::ios_base::eofbit); assert(err == std::ios_base::eofbit);
assert(ex == -123456789); assert(ex == -123456789);
noshowbase(ios); noshowbase(ios);
} }
{ // negative, showbase { // negative, showbase
std::wstring v = L"-1 234 567,89 RUB "; std::wstring v = L"-1 234 567,89 RUB ";
showbase(ios); showbase(ios);
typedef input_iterator<const wchar_t*> I; typedef cpp17_input_iterator<const wchar_t*> I;
long double ex; long double ex;
std::ios_base::iostate err = std::ios_base::goodbit; std::ios_base::iostate err = std::ios_base::goodbit;
I iter = f.get(I(v.data()), I(v.data() + v.size()), I iter = f.get(I(v.data()), I(v.data() + v.size()),
false, ios, err, ex); false, ios, err, ex);
assert(iter.base() == v.data() + 14); assert(iter.base() == v.data() + 14);
assert(err == std::ios_base::failbit); assert(err == std::ios_base::failbit);
noshowbase(ios); noshowbase(ios);
} }
{ // negative, showbase { // negative, showbase
std::wstring v = L"-1 234 567,89 RUB "; std::wstring v = L"-1 234 567,89 RUB ";
typedef input_iterator<const wchar_t*> I; typedef cpp17_input_iterator<const wchar_t*> I;
long double ex; long double ex;
std::ios_base::iostate err = std::ios_base::goodbit; std::ios_base::iostate err = std::ios_base::goodbit;
I iter = f.get(I(v.data()), I(v.data() + v.size()), I iter = f.get(I(v.data()), I(v.data() + v.size()),
false, ios, err, ex); false, ios, err, ex);
assert(iter.base() == v.data() + 14); assert(iter.base() == v.data() + 14);
assert(err == std::ios_base::goodbit); assert(err == std::ios_base::goodbit);
assert(ex == -123456789); assert(ex == -123456789);
} }
} }
{ {
const my_facetw f(1); const my_facetw f(1);
// wchar_t, international // wchar_t, international
{ // zero { // zero
std::wstring v = L"0,00"; std::wstring v = L"0,00";
typedef input_iterator<const wchar_t*> I; typedef cpp17_input_iterator<const wchar_t*> I;
long double ex; long double ex;
std::ios_base::iostate err = std::ios_base::goodbit; std::ios_base::iostate err = std::ios_base::goodbit;
I iter = f.get(I(v.data()), I(v.data() + v.size()), I iter = f.get(I(v.data()), I(v.data() + v.size()),
true, ios, err, ex); true, ios, err, ex);
assert(iter.base() == v.data() + v.size()); assert(iter.base() == v.data() + v.size());
assert(err == std::ios_base::eofbit); assert(err == std::ios_base::eofbit);
assert(ex == 0); assert(ex == 0);
} }
{ // negative one { // negative one
std::wstring v = L"-0,01 "; std::wstring v = L"-0,01 ";
typedef input_iterator<const wchar_t*> I; typedef cpp17_input_iterator<const wchar_t*> I;
long double ex; long double ex;
std::ios_base::iostate err = std::ios_base::goodbit; std::ios_base::iostate err = std::ios_base::goodbit;
I iter = f.get(I(v.data()), I(v.data() + v.size()), I iter = f.get(I(v.data()), I(v.data() + v.size()),
true, ios, err, ex); true, ios, err, ex);
assert(iter.base() == v.data() + v.size()); assert(iter.base() == v.data() + v.size());
assert(err == std::ios_base::eofbit); assert(err == std::ios_base::eofbit);
assert(ex == -1); assert(ex == -1);
} }
{ // positive { // positive
std::wstring v = L"1 234 567,89 "; std::wstring v = L"1 234 567,89 ";
typedef input_iterator<const wchar_t*> I; typedef cpp17_input_iterator<const wchar_t*> I;
long double ex; long double ex;
std::ios_base::iostate err = std::ios_base::goodbit; std::ios_base::iostate err = std::ios_base::goodbit;
I iter = f.get(I(v.data()), I(v.data() + v.size()), I iter = f.get(I(v.data()), I(v.data() + v.size()),
true, ios, err, ex); true, ios, err, ex);
assert(iter.base() == v.data() + v.size()); assert(iter.base() == v.data() + v.size());
assert(err == std::ios_base::eofbit); assert(err == std::ios_base::eofbit);
assert(ex == 123456789); assert(ex == 123456789);
} }
{ // negative { // negative
std::wstring v = L"-1 234 567,89 "; std::wstring v = L"-1 234 567,89 ";
typedef input_iterator<const wchar_t*> I; typedef cpp17_input_iterator<const wchar_t*> I;
long double ex; long double ex;
std::ios_base::iostate err = std::ios_base::goodbit; std::ios_base::iostate err = std::ios_base::goodbit;
I iter = f.get(I(v.data()), I(v.data() + v.size()), I iter = f.get(I(v.data()), I(v.data() + v.size()),
true, ios, err, ex); true, ios, err, ex);
assert(iter.base() == v.data() + v.size()); assert(iter.base() == v.data() + v.size());
assert(err == std::ios_base::eofbit); assert(err == std::ios_base::eofbit);
assert(ex == -123456789); assert(ex == -123456789);
} }
{ // negative { // negative
std::wstring v = L"-1234567,89 "; std::wstring v = L"-1234567,89 ";
typedef input_iterator<const wchar_t*> I; typedef cpp17_input_iterator<const wchar_t*> I;
long double ex; long double ex;
std::ios_base::iostate err = std::ios_base::goodbit; std::ios_base::iostate err = std::ios_base::goodbit;
I iter = f.get(I(v.data()), I(v.data() + v.size()), I iter = f.get(I(v.data()), I(v.data() + v.size()),
true, ios, err, ex); true, ios, err, ex);
assert(iter.base() == v.data() + v.size()); assert(iter.base() == v.data() + v.size());
assert(err == std::ios_base::eofbit); assert(err == std::ios_base::eofbit);
assert(ex == -123456789); assert(ex == -123456789);
} }
{ // zero, showbase { // zero, showbase
std::wstring v = L"0,00 RUB "; std::wstring v = L"0,00 RUB ";
typedef input_iterator<const wchar_t*> I; typedef cpp17_input_iterator<const wchar_t*> I;
long double ex; long double ex;
std::ios_base::iostate err = std::ios_base::goodbit; std::ios_base::iostate err = std::ios_base::goodbit;
I iter = f.get(I(v.data()), I(v.data() + v.size()), I iter = f.get(I(v.data()), I(v.data() + v.size()),
true, ios, err, ex); true, ios, err, ex);
assert(iter.base() == v.data() + 5); assert(iter.base() == v.data() + 5);
assert(err == std::ios_base::goodbit); assert(err == std::ios_base::goodbit);
assert(ex == 0); assert(ex == 0);
} }
#if !defined(APPLE_FIXME) #if !defined(APPLE_FIXME)
{ // zero, showbase { // zero, showbase
std::wstring v = L"0,00 RUB "; std::wstring v = L"0,00 RUB ";
showbase(ios); showbase(ios);
typedef input_iterator<const wchar_t*> I; typedef cpp17_input_iterator<const wchar_t*> I;
long double ex; long double ex;
std::ios_base::iostate err = std::ios_base::goodbit; std::ios_base::iostate err = std::ios_base::goodbit;
I iter = f.get(I(v.data()), I(v.data() + v.size()), I iter = f.get(I(v.data()), I(v.data() + v.size()),
true, ios, err, ex); true, ios, err, ex);
assert(iter.base() == v.data() + v.size()); assert(iter.base() == v.data() + v.size());
assert(err == std::ios_base::eofbit); assert(err == std::ios_base::eofbit);
assert(ex == 0); assert(ex == 0);
noshowbase(ios); noshowbase(ios);
} }
#endif #endif
{ // negative one, showbase { // negative one, showbase
std::wstring v = L"-0,01 RUB "; std::wstring v = L"-0,01 RUB ";
typedef input_iterator<const wchar_t*> I; typedef cpp17_input_iterator<const wchar_t*> I;
long double ex; long double ex;
std::ios_base::iostate err = std::ios_base::goodbit; std::ios_base::iostate err = std::ios_base::goodbit;
I iter = f.get(I(v.data()), I(v.data() + v.size()), I iter = f.get(I(v.data()), I(v.data() + v.size()),
true, ios, err, ex); true, ios, err, ex);
assert(iter.base() == v.data() + 6); assert(iter.base() == v.data() + 6);
assert(err == std::ios_base::goodbit); assert(err == std::ios_base::goodbit);
assert(ex == -1); assert(ex == -1);
} }
#if !defined(APPLE_FIXME) #if !defined(APPLE_FIXME)
{ // negative one, showbase { // negative one, showbase
std::wstring v = L"-0,01 RUB "; std::wstring v = L"-0,01 RUB ";
showbase(ios); showbase(ios);
typedef input_iterator<const wchar_t*> I; typedef cpp17_input_iterator<const wchar_t*> I;
long double ex; long double ex;
std::ios_base::iostate err = std::ios_base::goodbit; std::ios_base::iostate err = std::ios_base::goodbit;
I iter = f.get(I(v.data()), I(v.data() + v.size()), I iter = f.get(I(v.data()), I(v.data() + v.size()),
true, ios, err, ex); true, ios, err, ex);
assert(iter.base() == v.data() + v.size()); assert(iter.base() == v.data() + v.size());
assert(err == std::ios_base::eofbit); assert(err == std::ios_base::eofbit);
assert(ex == -1); assert(ex == -1);
noshowbase(ios); noshowbase(ios);
} }
#endif #endif
{ // positive, showbase { // positive, showbase
std::wstring v = L"1 234 567,89 RUB "; std::wstring v = L"1 234 567,89 RUB ";
typedef input_iterator<const wchar_t*> I; typedef cpp17_input_iterator<const wchar_t*> I;
long double ex; long double ex;
std::ios_base::iostate err = std::ios_base::goodbit; std::ios_base::iostate err = std::ios_base::goodbit;
I iter = f.get(I(v.data()), I(v.data() + v.size()), I iter = f.get(I(v.data()), I(v.data() + v.size()),
true, ios, err, ex); true, ios, err, ex);
assert(iter.base() == v.data() + 13); assert(iter.base() == v.data() + 13);
assert(err == std::ios_base::goodbit); assert(err == std::ios_base::goodbit);
assert(ex == 123456789); assert(ex == 123456789);
} }
#if !defined(APPLE_FIXME) #if !defined(APPLE_FIXME)
{ // positive, showbase { // positive, showbase
std::wstring v = L"1 234 567,89 RUB "; std::wstring v = L"1 234 567,89 RUB ";
showbase(ios); showbase(ios);
typedef input_iterator<const wchar_t*> I; typedef cpp17_input_iterator<const wchar_t*> I;
long double ex; long double ex;
std::ios_base::iostate err = std::ios_base::goodbit; std::ios_base::iostate err = std::ios_base::goodbit;
I iter = f.get(I(v.data()), I(v.data() + v.size()), I iter = f.get(I(v.data()), I(v.data() + v.size()),
true, ios, err, ex); true, ios, err, ex);
assert(iter.base() == v.data() + v.size()); assert(iter.base() == v.data() + v.size());
assert(err == std::ios_base::eofbit); assert(err == std::ios_base::eofbit);
assert(ex == 123456789); assert(ex == 123456789);
noshowbase(ios); noshowbase(ios);
} }
#endif #endif
#if !defined(APPLE_FIXME) #if !defined(APPLE_FIXME)
{ // negative, showbase { // negative, showbase
std::wstring v = L"-1 234 567,89 RUB "; std::wstring v = L"-1 234 567,89 RUB ";
showbase(ios); showbase(ios);
typedef input_iterator<const wchar_t*> I; typedef cpp17_input_iterator<const wchar_t*> I;
long double ex; long double ex;
std::ios_base::iostate err = std::ios_base::goodbit; std::ios_base::iostate err = std::ios_base::goodbit;
I iter = f.get(I(v.data()), I(v.data() + v.size()), I iter = f.get(I(v.data()), I(v.data() + v.size()),
true, ios, err, ex); true, ios, err, ex);
assert(iter.base() == v.data() + v.size()); assert(iter.base() == v.data() + v.size());
assert(err == std::ios_base::eofbit); assert(err == std::ios_base::eofbit);
assert(ex == -123456789); assert(ex == -123456789);
noshowbase(ios); noshowbase(ios);
} }
#endif #endif
{ // negative, showbase { // negative, showbase
std::wstring v = L"-1 234 567,89 \x440\x443\x431""."; std::wstring v = L"-1 234 567,89 \x440\x443\x431"".";
showbase(ios); showbase(ios);
typedef input_iterator<const wchar_t*> I; typedef cpp17_input_iterator<const wchar_t*> I;
long double ex; long double ex;
std::ios_base::iostate err = std::ios_base::goodbit; std::ios_base::iostate err = std::ios_base::goodbit;
I iter = f.get(I(v.data()), I(v.data() + v.size()), I iter = f.get(I(v.data()), I(v.data() + v.size()),
true, ios, err, ex); true, ios, err, ex);
assert(iter.base() == v.data() + 14); assert(iter.base() == v.data() + 14);
assert(err == std::ios_base::failbit); assert(err == std::ios_base::failbit);
noshowbase(ios); noshowbase(ios);
} }
{ // negative, showbase { // negative, showbase
std::wstring v = L"-1 234 567,89 \x440\x443\x431""."; std::wstring v = L"-1 234 567,89 \x440\x443\x431"".";
typedef input_iterator<const wchar_t*> I; typedef cpp17_input_iterator<const wchar_t*> I;
long double ex; long double ex;
std::ios_base::iostate err = std::ios_base::goodbit; std::ios_base::iostate err = std::ios_base::goodbit;
I iter = f.get(I(v.data()), I(v.data() + v.size()), I iter = f.get(I(v.data()), I(v.data() + v.size()),
true, ios, err, ex); true, ios, err, ex);
assert(iter.base() == v.data() + 14); assert(iter.base() == v.data() + 14);
assert(err == std::ios_base::goodbit); assert(err == std::ios_base::goodbit);
assert(ex == -123456789); assert(ex == -123456789);
} }
} }
return 0; return 0;
} }

libcxx/test/std/localization/locale.categories/category.monetary/locale.money.get/locale.money.get.members/get_long_double_zh_CN.pass.cpp

Show All 26 Lines
#include <ios> #include <ios>
#include <streambuf> #include <streambuf>
#include <cassert> #include <cassert>
#include "test_macros.h" #include "test_macros.h"
#include "test_iterators.h" #include "test_iterators.h"
#include "platform_support.h" // locale name macros #include "platform_support.h" // locale name macros
typedef std::money_get<char, input_iterator<const char*> > Fn; typedef std::money_get<char, cpp17_input_iterator<const char*> > Fn;
class my_facet class my_facet
: public Fn : public Fn
{ {
public: public:
explicit my_facet(std::size_t refs = 0) explicit my_facet(std::size_t refs = 0)
: Fn(refs) {} : Fn(refs) {}
}; };
typedef std::money_get<wchar_t, input_iterator<const wchar_t*> > Fw; typedef std::money_get<wchar_t, cpp17_input_iterator<const wchar_t*> > Fw;
class my_facetw class my_facetw
: public Fw : public Fw
{ {
public: public:
explicit my_facetw(std::size_t refs = 0) explicit my_facetw(std::size_t refs = 0)
: Fw(refs) {} : Fw(refs) {}
}; };
Show All 10 Lines ios.imbue(std::locale(ios.getloc(),
new std::moneypunct_byname<wchar_t, false>(loc_name))); new std::moneypunct_byname<wchar_t, false>(loc_name)));
ios.imbue(std::locale(ios.getloc(), ios.imbue(std::locale(ios.getloc(),
new std::moneypunct_byname<wchar_t, true>(loc_name))); new std::moneypunct_byname<wchar_t, true>(loc_name)));
{ {
const my_facet f(1); const my_facet f(1);
// char, national // char, national
{ // zero { // zero
std::string v = "0.00"; std::string v = "0.00";
typedef input_iterator<const char*> I; typedef cpp17_input_iterator<const char*> I;
long double ex; long double ex;
std::ios_base::iostate err = std::ios_base::goodbit; std::ios_base::iostate err = std::ios_base::goodbit;
I iter = f.get(I(v.data()), I(v.data() + v.size()), I iter = f.get(I(v.data()), I(v.data() + v.size()),
false, ios, err, ex); false, ios, err, ex);
assert(iter.base() == v.data() + v.size()); assert(iter.base() == v.data() + v.size());
assert(err == std::ios_base::eofbit); assert(err == std::ios_base::eofbit);
assert(ex == 0); assert(ex == 0);
} }
{ // negative one { // negative one
std::string v = "-0.01"; std::string v = "-0.01";
typedef input_iterator<const char*> I; typedef cpp17_input_iterator<const char*> I;
long double ex; long double ex;
std::ios_base::iostate err = std::ios_base::goodbit; std::ios_base::iostate err = std::ios_base::goodbit;
I iter = f.get(I(v.data()), I(v.data() + v.size()), I iter = f.get(I(v.data()), I(v.data() + v.size()),
false, ios, err, ex); false, ios, err, ex);
assert(iter.base() == v.data() + v.size()); assert(iter.base() == v.data() + v.size());
assert(err == std::ios_base::eofbit); assert(err == std::ios_base::eofbit);
assert(ex == -1); assert(ex == -1);
} }
{ // positive { // positive
std::string v = "1,234,567.89"; std::string v = "1,234,567.89";
typedef input_iterator<const char*> I; typedef cpp17_input_iterator<const char*> I;
long double ex; long double ex;
std::ios_base::iostate err = std::ios_base::goodbit; std::ios_base::iostate err = std::ios_base::goodbit;
I iter = f.get(I(v.data()), I(v.data() + v.size()), I iter = f.get(I(v.data()), I(v.data() + v.size()),
false, ios, err, ex); false, ios, err, ex);
assert(iter.base() == v.data() + v.size()); assert(iter.base() == v.data() + v.size());
assert(err == std::ios_base::eofbit); assert(err == std::ios_base::eofbit);
assert(ex == 123456789); assert(ex == 123456789);
} }
{ // negative { // negative
std::string v = "-1,234,567.89"; std::string v = "-1,234,567.89";
typedef input_iterator<const char*> I; typedef cpp17_input_iterator<const char*> I;
long double ex; long double ex;
std::ios_base::iostate err = std::ios_base::goodbit; std::ios_base::iostate err = std::ios_base::goodbit;
I iter = f.get(I(v.data()), I(v.data() + v.size()), I iter = f.get(I(v.data()), I(v.data() + v.size()),
false, ios, err, ex); false, ios, err, ex);
assert(iter.base() == v.data() + v.size()); assert(iter.base() == v.data() + v.size());
assert(err == std::ios_base::eofbit); assert(err == std::ios_base::eofbit);
assert(ex == -123456789); assert(ex == -123456789);
} }
{ // negative { // negative
std::string v = "-1234567.89"; std::string v = "-1234567.89";
typedef input_iterator<const char*> I; typedef cpp17_input_iterator<const char*> I;
long double ex; long double ex;
std::ios_base::iostate err = std::ios_base::goodbit; std::ios_base::iostate err = std::ios_base::goodbit;
I iter = f.get(I(v.data()), I(v.data() + v.size()), I iter = f.get(I(v.data()), I(v.data() + v.size()),
false, ios, err, ex); false, ios, err, ex);
assert(iter.base() == v.data() + v.size()); assert(iter.base() == v.data() + v.size());
assert(err == std::ios_base::eofbit); assert(err == std::ios_base::eofbit);
assert(ex == -123456789); assert(ex == -123456789);
} }
{ // zero, showbase { // zero, showbase
std::string v = "\xEF\xBF\xA5""0.00"; std::string v = "\xEF\xBF\xA5""0.00";
typedef input_iterator<const char*> I; typedef cpp17_input_iterator<const char*> I;
long double ex; long double ex;
std::ios_base::iostate err = std::ios_base::goodbit; std::ios_base::iostate err = std::ios_base::goodbit;
I iter = f.get(I(v.data()), I(v.data() + v.size()), I iter = f.get(I(v.data()), I(v.data() + v.size()),
false, ios, err, ex); false, ios, err, ex);
assert(iter.base() == v.data() + v.size()); assert(iter.base() == v.data() + v.size());
assert(err == std::ios_base::eofbit); assert(err == std::ios_base::eofbit);
assert(ex == 0); assert(ex == 0);
} }
{ // zero, showbase { // zero, showbase
std::string v = "\xEF\xBF\xA5""0.00"; std::string v = "\xEF\xBF\xA5""0.00";
showbase(ios); showbase(ios);
typedef input_iterator<const char*> I; typedef cpp17_input_iterator<const char*> I;
long double ex; long double ex;
std::ios_base::iostate err = std::ios_base::goodbit; std::ios_base::iostate err = std::ios_base::goodbit;
I iter = f.get(I(v.data()), I(v.data() + v.size()), I iter = f.get(I(v.data()), I(v.data() + v.size()),
false, ios, err, ex); false, ios, err, ex);
assert(iter.base() == v.data() + v.size()); assert(iter.base() == v.data() + v.size());
assert(err == std::ios_base::eofbit); assert(err == std::ios_base::eofbit);
assert(ex == 0); assert(ex == 0);
noshowbase(ios); noshowbase(ios);
} }
{ // negative one, showbase { // negative one, showbase
std::string v = "\xEF\xBF\xA5""-0.01"; std::string v = "\xEF\xBF\xA5""-0.01";
typedef input_iterator<const char*> I; typedef cpp17_input_iterator<const char*> I;
long double ex; long double ex;
std::ios_base::iostate err = std::ios_base::goodbit; std::ios_base::iostate err = std::ios_base::goodbit;
I iter = f.get(I(v.data()), I(v.data() + v.size()), I iter = f.get(I(v.data()), I(v.data() + v.size()),
false, ios, err, ex); false, ios, err, ex);
assert(iter.base() == v.data() + v.size()); assert(iter.base() == v.data() + v.size());
assert(err == std::ios_base::eofbit); assert(err == std::ios_base::eofbit);
assert(ex == -1); assert(ex == -1);
} }
{ // negative one, showbase { // negative one, showbase
std::string v = "\xEF\xBF\xA5""-0.01"; std::string v = "\xEF\xBF\xA5""-0.01";
showbase(ios); showbase(ios);
typedef input_iterator<const char*> I; typedef cpp17_input_iterator<const char*> I;
long double ex; long double ex;
std::ios_base::iostate err = std::ios_base::goodbit; std::ios_base::iostate err = std::ios_base::goodbit;
I iter = f.get(I(v.data()), I(v.data() + v.size()), I iter = f.get(I(v.data()), I(v.data() + v.size()),
false, ios, err, ex); false, ios, err, ex);
assert(iter.base() == v.data() + v.size()); assert(iter.base() == v.data() + v.size());
assert(err == std::ios_base::eofbit); assert(err == std::ios_base::eofbit);
assert(ex == -1); assert(ex == -1);
noshowbase(ios); noshowbase(ios);
} }
{ // positive, showbase { // positive, showbase
std::string v = "\xEF\xBF\xA5""1,234,567.89"; std::string v = "\xEF\xBF\xA5""1,234,567.89";
typedef input_iterator<const char*> I; typedef cpp17_input_iterator<const char*> I;
long double ex; long double ex;
std::ios_base::iostate err = std::ios_base::goodbit; std::ios_base::iostate err = std::ios_base::goodbit;
I iter = f.get(I(v.data()), I(v.data() + v.size()), I iter = f.get(I(v.data()), I(v.data() + v.size()),
false, ios, err, ex); false, ios, err, ex);
assert(iter.base() == v.data() + v.size()); assert(iter.base() == v.data() + v.size());
assert(err == std::ios_base::eofbit); assert(err == std::ios_base::eofbit);
assert(ex == 123456789); assert(ex == 123456789);
} }
{ // positive, showbase { // positive, showbase
std::string v = "\xEF\xBF\xA5""1,234,567.89"; std::string v = "\xEF\xBF\xA5""1,234,567.89";
showbase(ios); showbase(ios);
typedef input_iterator<const char*> I; typedef cpp17_input_iterator<const char*> I;
long double ex; long double ex;
std::ios_base::iostate err = std::ios_base::goodbit; std::ios_base::iostate err = std::ios_base::goodbit;
I iter = f.get(I(v.data()), I(v.data() + v.size()), I iter = f.get(I(v.data()), I(v.data() + v.size()),
false, ios, err, ex); false, ios, err, ex);
assert(iter.base() == v.data() + v.size()); assert(iter.base() == v.data() + v.size());
assert(err == std::ios_base::eofbit); assert(err == std::ios_base::eofbit);
assert(ex == 123456789); assert(ex == 123456789);
noshowbase(ios); noshowbase(ios);
} }
{ // negative, showbase { // negative, showbase
std::string v = "\xEF\xBF\xA5""-1,234,567.89"; std::string v = "\xEF\xBF\xA5""-1,234,567.89";
showbase(ios); showbase(ios);
typedef input_iterator<const char*> I; typedef cpp17_input_iterator<const char*> I;
long double ex; long double ex;
std::ios_base::iostate err = std::ios_base::goodbit; std::ios_base::iostate err = std::ios_base::goodbit;
I iter = f.get(I(v.data()), I(v.data() + v.size()), I iter = f.get(I(v.data()), I(v.data() + v.size()),
false, ios, err, ex); false, ios, err, ex);
assert(iter.base() == v.data() + v.size()); assert(iter.base() == v.data() + v.size());
assert(err == std::ios_base::eofbit); assert(err == std::ios_base::eofbit);
assert(ex == -123456789); assert(ex == -123456789);
noshowbase(ios); noshowbase(ios);
} }
{ // negative, showbase { // negative, showbase
std::string v = "CNY -1,234,567.89"; std::string v = "CNY -1,234,567.89";
showbase(ios); showbase(ios);
typedef input_iterator<const char*> I; typedef cpp17_input_iterator<const char*> I;
long double ex; long double ex;
std::ios_base::iostate err = std::ios_base::goodbit; std::ios_base::iostate err = std::ios_base::goodbit;
I iter = f.get(I(v.data()), I(v.data() + v.size()), I iter = f.get(I(v.data()), I(v.data() + v.size()),
false, ios, err, ex); false, ios, err, ex);
assert(iter.base() == v.data() + 0); assert(iter.base() == v.data() + 0);
assert(err == std::ios_base::failbit); assert(err == std::ios_base::failbit);
noshowbase(ios); noshowbase(ios);
} }
{ // negative, showbase { // negative, showbase
std::string v = "CNY -1,234,567.89"; std::string v = "CNY -1,234,567.89";
typedef input_iterator<const char*> I; typedef cpp17_input_iterator<const char*> I;
long double ex; long double ex;
std::ios_base::iostate err = std::ios_base::goodbit; std::ios_base::iostate err = std::ios_base::goodbit;
I iter = f.get(I(v.data()), I(v.data() + v.size()), I iter = f.get(I(v.data()), I(v.data() + v.size()),
false, ios, err, ex); false, ios, err, ex);
assert(iter.base() == v.data() + 0); assert(iter.base() == v.data() + 0);
assert(err == std::ios_base::failbit); assert(err == std::ios_base::failbit);
} }
} }
{ {
const my_facet f(1); const my_facet f(1);
// char, international // char, international
{ // zero { // zero
std::string v = "0.00"; std::string v = "0.00";
typedef input_iterator<const char*> I; typedef cpp17_input_iterator<const char*> I;
long double ex; long double ex;
std::ios_base::iostate err = std::ios_base::goodbit; std::ios_base::iostate err = std::ios_base::goodbit;
I iter = f.get(I(v.data()), I(v.data() + v.size()), I iter = f.get(I(v.data()), I(v.data() + v.size()),
true, ios, err, ex); true, ios, err, ex);
assert(iter.base() == v.data() + v.size()); assert(iter.base() == v.data() + v.size());
assert(err == std::ios_base::eofbit); assert(err == std::ios_base::eofbit);
assert(ex == 0); assert(ex == 0);
} }
{ // negative one { // negative one
std::string v = "-0.01"; std::string v = "-0.01";
typedef input_iterator<const char*> I; typedef cpp17_input_iterator<const char*> I;
long double ex; long double ex;
std::ios_base::iostate err = std::ios_base::goodbit; std::ios_base::iostate err = std::ios_base::goodbit;
I iter = f.get(I(v.data()), I(v.data() + v.size()), I iter = f.get(I(v.data()), I(v.data() + v.size()),
true, ios, err, ex); true, ios, err, ex);
assert(iter.base() == v.data() + v.size()); assert(iter.base() == v.data() + v.size());
assert(err == std::ios_base::eofbit); assert(err == std::ios_base::eofbit);
assert(ex == -1); assert(ex == -1);
} }
{ // positive { // positive
std::string v = "1,234,567.89"; std::string v = "1,234,567.89";
typedef input_iterator<const char*> I; typedef cpp17_input_iterator<const char*> I;
long double ex; long double ex;
std::ios_base::iostate err = std::ios_base::goodbit; std::ios_base::iostate err = std::ios_base::goodbit;
I iter = f.get(I(v.data()), I(v.data() + v.size()), I iter = f.get(I(v.data()), I(v.data() + v.size()),
true, ios, err, ex); true, ios, err, ex);
assert(iter.base() == v.data() + v.size()); assert(iter.base() == v.data() + v.size());
assert(err == std::ios_base::eofbit); assert(err == std::ios_base::eofbit);
assert(ex == 123456789); assert(ex == 123456789);
} }
{ // negative { // negative
std::string v = "-1,234,567.89"; std::string v = "-1,234,567.89";
typedef input_iterator<const char*> I; typedef cpp17_input_iterator<const char*> I;
long double ex; long double ex;
std::ios_base::iostate err = std::ios_base::goodbit; std::ios_base::iostate err = std::ios_base::goodbit;
I iter = f.get(I(v.data()), I(v.data() + v.size()), I iter = f.get(I(v.data()), I(v.data() + v.size()),
true, ios, err, ex); true, ios, err, ex);
assert(iter.base() == v.data() + v.size()); assert(iter.base() == v.data() + v.size());
assert(err == std::ios_base::eofbit); assert(err == std::ios_base::eofbit);
assert(ex == -123456789); assert(ex == -123456789);
} }
{ // negative { // negative
std::string v = "-1234567.89"; std::string v = "-1234567.89";
typedef input_iterator<const char*> I; typedef cpp17_input_iterator<const char*> I;
long double ex; long double ex;
std::ios_base::iostate err = std::ios_base::goodbit; std::ios_base::iostate err = std::ios_base::goodbit;
I iter = f.get(I(v.data()), I(v.data() + v.size()), I iter = f.get(I(v.data()), I(v.data() + v.size()),
true, ios, err, ex); true, ios, err, ex);
assert(iter.base() == v.data() + v.size()); assert(iter.base() == v.data() + v.size());
assert(err == std::ios_base::eofbit); assert(err == std::ios_base::eofbit);
assert(ex == -123456789); assert(ex == -123456789);
} }
{ // zero, showbase { // zero, showbase
std::string v = "CNY 0.00"; std::string v = "CNY 0.00";
typedef input_iterator<const char*> I; typedef cpp17_input_iterator<const char*> I;
long double ex; long double ex;
std::ios_base::iostate err = std::ios_base::goodbit; std::ios_base::iostate err = std::ios_base::goodbit;
I iter = f.get(I(v.data()), I(v.data() + v.size()), I iter = f.get(I(v.data()), I(v.data() + v.size()),
true, ios, err, ex); true, ios, err, ex);
assert(iter.base() == v.data() + v.size()); assert(iter.base() == v.data() + v.size());
assert(err == std::ios_base::eofbit); assert(err == std::ios_base::eofbit);
assert(ex == 0); assert(ex == 0);
} }
{ // zero, showbase { // zero, showbase
std::string v = "CNY 0.00"; std::string v = "CNY 0.00";
showbase(ios); showbase(ios);
typedef input_iterator<const char*> I; typedef cpp17_input_iterator<const char*> I;
long double ex; long double ex;
std::ios_base::iostate err = std::ios_base::goodbit; std::ios_base::iostate err = std::ios_base::goodbit;
I iter = f.get(I(v.data()), I(v.data() + v.size()), I iter = f.get(I(v.data()), I(v.data() + v.size()),
true, ios, err, ex); true, ios, err, ex);
assert(iter.base() == v.data() + v.size()); assert(iter.base() == v.data() + v.size());
assert(err == std::ios_base::eofbit); assert(err == std::ios_base::eofbit);
assert(ex == 0); assert(ex == 0);
noshowbase(ios); noshowbase(ios);
} }
{ // negative one, showbase { // negative one, showbase
std::string v = "CNY -0.01"; std::string v = "CNY -0.01";
typedef input_iterator<const char*> I; typedef cpp17_input_iterator<const char*> I;
long double ex; long double ex;
std::ios_base::iostate err = std::ios_base::goodbit; std::ios_base::iostate err = std::ios_base::goodbit;
I iter = f.get(I(v.data()), I(v.data() + v.size()), I iter = f.get(I(v.data()), I(v.data() + v.size()),
true, ios, err, ex); true, ios, err, ex);
assert(iter.base() == v.data() + v.size()); assert(iter.base() == v.data() + v.size());
assert(err == std::ios_base::eofbit); assert(err == std::ios_base::eofbit);
assert(ex == -1); assert(ex == -1);
} }
{ // negative one, showbase { // negative one, showbase
std::string v = "CNY -0.01"; std::string v = "CNY -0.01";
showbase(ios); showbase(ios);
typedef input_iterator<const char*> I; typedef cpp17_input_iterator<const char*> I;
long double ex; long double ex;
std::ios_base::iostate err = std::ios_base::goodbit; std::ios_base::iostate err = std::ios_base::goodbit;
I iter = f.get(I(v.data()), I(v.data() + v.size()), I iter = f.get(I(v.data()), I(v.data() + v.size()),
true, ios, err, ex); true, ios, err, ex);
assert(iter.base() == v.data() + v.size()); assert(iter.base() == v.data() + v.size());
assert(err == std::ios_base::eofbit); assert(err == std::ios_base::eofbit);
assert(ex == -1); assert(ex == -1);
noshowbase(ios); noshowbase(ios);
} }
{ // positive, showbase { // positive, showbase
std::string v = "CNY 1,234,567.89"; std::string v = "CNY 1,234,567.89";
typedef input_iterator<const char*> I; typedef cpp17_input_iterator<const char*> I;
long double ex; long double ex;
std::ios_base::iostate err = std::ios_base::goodbit; std::ios_base::iostate err = std::ios_base::goodbit;
I iter = f.get(I(v.data()), I(v.data() + v.size()), I iter = f.get(I(v.data()), I(v.data() + v.size()),
true, ios, err, ex); true, ios, err, ex);
assert(iter.base() == v.data() + v.size()); assert(iter.base() == v.data() + v.size());
assert(err == std::ios_base::eofbit); assert(err == std::ios_base::eofbit);
assert(ex == 123456789); assert(ex == 123456789);
} }
{ // positive, showbase { // positive, showbase
std::string v = "CNY 1,234,567.89"; std::string v = "CNY 1,234,567.89";
showbase(ios); showbase(ios);
typedef input_iterator<const char*> I; typedef cpp17_input_iterator<const char*> I;
long double ex; long double ex;
std::ios_base::iostate err = std::ios_base::goodbit; std::ios_base::iostate err = std::ios_base::goodbit;
I iter = f.get(I(v.data()), I(v.data() + v.size()), I iter = f.get(I(v.data()), I(v.data() + v.size()),
true, ios, err, ex); true, ios, err, ex);
assert(iter.base() == v.data() + v.size()); assert(iter.base() == v.data() + v.size());
assert(err == std::ios_base::eofbit); assert(err == std::ios_base::eofbit);
assert(ex == 123456789); assert(ex == 123456789);
noshowbase(ios); noshowbase(ios);
} }
{ // negative, showbase { // negative, showbase
std::string v = "CNY -1,234,567.89"; std::string v = "CNY -1,234,567.89";
showbase(ios); showbase(ios);
typedef input_iterator<const char*> I; typedef cpp17_input_iterator<const char*> I;
long double ex; long double ex;
std::ios_base::iostate err = std::ios_base::goodbit; std::ios_base::iostate err = std::ios_base::goodbit;
I iter = f.get(I(v.data()), I(v.data() + v.size()), I iter = f.get(I(v.data()), I(v.data() + v.size()),
true, ios, err, ex); true, ios, err, ex);
assert(iter.base() == v.data() + v.size()); assert(iter.base() == v.data() + v.size());
assert(err == std::ios_base::eofbit); assert(err == std::ios_base::eofbit);
assert(ex == -123456789); assert(ex == -123456789);
noshowbase(ios); noshowbase(ios);
} }
{ // negative, showbase { // negative, showbase
std::string v = "\xEF\xBF\xA5""-1,234,567.89"; std::string v = "\xEF\xBF\xA5""-1,234,567.89";
showbase(ios); showbase(ios);
typedef input_iterator<const char*> I; typedef cpp17_input_iterator<const char*> I;
long double ex; long double ex;
std::ios_base::iostate err = std::ios_base::goodbit; std::ios_base::iostate err = std::ios_base::goodbit;
I iter = f.get(I(v.data()), I(v.data() + v.size()), I iter = f.get(I(v.data()), I(v.data() + v.size()),
true, ios, err, ex); true, ios, err, ex);
assert(iter.base() == v.data() + 0); assert(iter.base() == v.data() + 0);
assert(err == std::ios_base::failbit); assert(err == std::ios_base::failbit);
noshowbase(ios); noshowbase(ios);
} }
{ // negative, showbase { // negative, showbase
std::string v = "\xEF\xBF\xA5""-1,234,567.89"; std::string v = "\xEF\xBF\xA5""-1,234,567.89";
typedef input_iterator<const char*> I; typedef cpp17_input_iterator<const char*> I;
long double ex; long double ex;
std::ios_base::iostate err = std::ios_base::goodbit; std::ios_base::iostate err = std::ios_base::goodbit;
I iter = f.get(I(v.data()), I(v.data() + v.size()), I iter = f.get(I(v.data()), I(v.data() + v.size()),
true, ios, err, ex); true, ios, err, ex);
assert(iter.base() == v.data() + 0); assert(iter.base() == v.data() + 0);
assert(err == std::ios_base::failbit); assert(err == std::ios_base::failbit);
} }
} }
{ {
const my_facetw f(1); const my_facetw f(1);
// wchar_t, national // wchar_t, national
{ // zero { // zero
std::wstring v = L"0.00"; std::wstring v = L"0.00";
typedef input_iterator<const wchar_t*> I; typedef cpp17_input_iterator<const wchar_t*> I;
long double ex; long double ex;
std::ios_base::iostate err = std::ios_base::goodbit; std::ios_base::iostate err = std::ios_base::goodbit;
I iter = f.get(I(v.data()), I(v.data() + v.size()), I iter = f.get(I(v.data()), I(v.data() + v.size()),
false, ios, err, ex); false, ios, err, ex);
assert(iter.base() == v.data() + v.size()); assert(iter.base() == v.data() + v.size());
assert(err == std::ios_base::eofbit); assert(err == std::ios_base::eofbit);
assert(ex == 0); assert(ex == 0);
} }
{ // negative one { // negative one
std::wstring v = L"-0.01"; std::wstring v = L"-0.01";
typedef input_iterator<const wchar_t*> I; typedef cpp17_input_iterator<const wchar_t*> I;
long double ex; long double ex;
std::ios_base::iostate err = std::ios_base::goodbit; std::ios_base::iostate err = std::ios_base::goodbit;
I iter = f.get(I(v.data()), I(v.data() + v.size()), I iter = f.get(I(v.data()), I(v.data() + v.size()),
false, ios, err, ex); false, ios, err, ex);
assert(iter.base() == v.data() + v.size()); assert(iter.base() == v.data() + v.size());
assert(err == std::ios_base::eofbit); assert(err == std::ios_base::eofbit);
assert(ex == -1); assert(ex == -1);
} }
{ // positive { // positive
std::wstring v = L"1,234,567.89"; std::wstring v = L"1,234,567.89";
typedef input_iterator<const wchar_t*> I; typedef cpp17_input_iterator<const wchar_t*> I;
long double ex; long double ex;
std::ios_base::iostate err = std::ios_base::goodbit; std::ios_base::iostate err = std::ios_base::goodbit;
I iter = f.get(I(v.data()), I(v.data() + v.size()), I iter = f.get(I(v.data()), I(v.data() + v.size()),
false, ios, err, ex); false, ios, err, ex);
assert(iter.base() == v.data() + v.size()); assert(iter.base() == v.data() + v.size());
assert(err == std::ios_base::eofbit); assert(err == std::ios_base::eofbit);
assert(ex == 123456789); assert(ex == 123456789);
} }
{ // negative { // negative
std::wstring v = L"-1,234,567.89"; std::wstring v = L"-1,234,567.89";
typedef input_iterator<const wchar_t*> I; typedef cpp17_input_iterator<const wchar_t*> I;
long double ex; long double ex;
std::ios_base::iostate err = std::ios_base::goodbit; std::ios_base::iostate err = std::ios_base::goodbit;
I iter = f.get(I(v.data()), I(v.data() + v.size()), I iter = f.get(I(v.data()), I(v.data() + v.size()),
false, ios, err, ex); false, ios, err, ex);
assert(iter.base() == v.data() + v.size()); assert(iter.base() == v.data() + v.size());
assert(err == std::ios_base::eofbit); assert(err == std::ios_base::eofbit);
assert(ex == -123456789); assert(ex == -123456789);
} }
{ // negative { // negative
std::wstring v = L"-1234567.89"; std::wstring v = L"-1234567.89";
typedef input_iterator<const wchar_t*> I; typedef cpp17_input_iterator<const wchar_t*> I;
long double ex; long double ex;
std::ios_base::iostate err = std::ios_base::goodbit; std::ios_base::iostate err = std::ios_base::goodbit;
I iter = f.get(I(v.data()), I(v.data() + v.size()), I iter = f.get(I(v.data()), I(v.data() + v.size()),
false, ios, err, ex); false, ios, err, ex);
assert(iter.base() == v.data() + v.size()); assert(iter.base() == v.data() + v.size());
assert(err == std::ios_base::eofbit); assert(err == std::ios_base::eofbit);
assert(ex == -123456789); assert(ex == -123456789);
} }
{ // zero, showbase { // zero, showbase
std::wstring v = L"\xFFE5""0.00"; std::wstring v = L"\xFFE5""0.00";
typedef input_iterator<const wchar_t*> I; typedef cpp17_input_iterator<const wchar_t*> I;
long double ex; long double ex;
std::ios_base::iostate err = std::ios_base::goodbit; std::ios_base::iostate err = std::ios_base::goodbit;
I iter = f.get(I(v.data()), I(v.data() + v.size()), I iter = f.get(I(v.data()), I(v.data() + v.size()),
false, ios, err, ex); false, ios, err, ex);
assert(iter.base() == v.data() + v.size()); assert(iter.base() == v.data() + v.size());
assert(err == std::ios_base::eofbit); assert(err == std::ios_base::eofbit);
assert(ex == 0); assert(ex == 0);
} }
{ // zero, showbase { // zero, showbase
std::wstring v = L"\xFFE5""0.00"; std::wstring v = L"\xFFE5""0.00";
showbase(ios); showbase(ios);
typedef input_iterator<const wchar_t*> I; typedef cpp17_input_iterator<const wchar_t*> I;
long double ex; long double ex;
std::ios_base::iostate err = std::ios_base::goodbit; std::ios_base::iostate err = std::ios_base::goodbit;
I iter = f.get(I(v.data()), I(v.data() + v.size()), I iter = f.get(I(v.data()), I(v.data() + v.size()),
false, ios, err, ex); false, ios, err, ex);
assert(iter.base() == v.data() + v.size()); assert(iter.base() == v.data() + v.size());
assert(err == std::ios_base::eofbit); assert(err == std::ios_base::eofbit);
assert(ex == 0); assert(ex == 0);
noshowbase(ios); noshowbase(ios);
} }
{ // negative one, showbase { // negative one, showbase
std::wstring v = L"\xFFE5""-0.01"; std::wstring v = L"\xFFE5""-0.01";
typedef input_iterator<const wchar_t*> I; typedef cpp17_input_iterator<const wchar_t*> I;
long double ex; long double ex;
std::ios_base::iostate err = std::ios_base::goodbit; std::ios_base::iostate err = std::ios_base::goodbit;
I iter = f.get(I(v.data()), I(v.data() + v.size()), I iter = f.get(I(v.data()), I(v.data() + v.size()),
false, ios, err, ex); false, ios, err, ex);
assert(iter.base() == v.data() + v.size()); assert(iter.base() == v.data() + v.size());
assert(err == std::ios_base::eofbit); assert(err == std::ios_base::eofbit);
assert(ex == -1); assert(ex == -1);
} }
{ // negative one, showbase { // negative one, showbase
std::wstring v = L"\xFFE5""-0.01"; std::wstring v = L"\xFFE5""-0.01";
showbase(ios); showbase(ios);
typedef input_iterator<const wchar_t*> I; typedef cpp17_input_iterator<const wchar_t*> I;
long double ex; long double ex;
std::ios_base::iostate err = std::ios_base::goodbit; std::ios_base::iostate err = std::ios_base::goodbit;
I iter = f.get(I(v.data()), I(v.data() + v.size()), I iter = f.get(I(v.data()), I(v.data() + v.size()),
false, ios, err, ex); false, ios, err, ex);
assert(iter.base() == v.data() + v.size()); assert(iter.base() == v.data() + v.size());
assert(err == std::ios_base::eofbit); assert(err == std::ios_base::eofbit);
assert(ex == -1); assert(ex == -1);
noshowbase(ios); noshowbase(ios);
} }
{ // positive, showbase { // positive, showbase
std::wstring v = L"\xFFE5""1,234,567.89"; std::wstring v = L"\xFFE5""1,234,567.89";
typedef input_iterator<const wchar_t*> I; typedef cpp17_input_iterator<const wchar_t*> I;
long double ex; long double ex;
std::ios_base::iostate err = std::ios_base::goodbit; std::ios_base::iostate err = std::ios_base::goodbit;
I iter = f.get(I(v.data()), I(v.data() + v.size()), I iter = f.get(I(v.data()), I(v.data() + v.size()),
false, ios, err, ex); false, ios, err, ex);
assert(iter.base() == v.data() + v.size()); assert(iter.base() == v.data() + v.size());
assert(err == std::ios_base::eofbit); assert(err == std::ios_base::eofbit);
assert(ex == 123456789); assert(ex == 123456789);
} }
{ // positive, showbase { // positive, showbase
std::wstring v = L"\xFFE5""1,234,567.89"; std::wstring v = L"\xFFE5""1,234,567.89";
showbase(ios); showbase(ios);
typedef input_iterator<const wchar_t*> I; typedef cpp17_input_iterator<const wchar_t*> I;
long double ex; long double ex;
std::ios_base::iostate err = std::ios_base::goodbit; std::ios_base::iostate err = std::ios_base::goodbit;
I iter = f.get(I(v.data()), I(v.data() + v.size()), I iter = f.get(I(v.data()), I(v.data() + v.size()),
false, ios, err, ex); false, ios, err, ex);
assert(iter.base() == v.data() + v.size()); assert(iter.base() == v.data() + v.size());
assert(err == std::ios_base::eofbit); assert(err == std::ios_base::eofbit);
assert(ex == 123456789); assert(ex == 123456789);
noshowbase(ios); noshowbase(ios);
} }
{ // negative, showbase { // negative, showbase
std::wstring v = L"\xFFE5""-1,234,567.89"; std::wstring v = L"\xFFE5""-1,234,567.89";
showbase(ios); showbase(ios);
typedef input_iterator<const wchar_t*> I; typedef cpp17_input_iterator<const wchar_t*> I;
long double ex; long double ex;
std::ios_base::iostate err = std::ios_base::goodbit; std::ios_base::iostate err = std::ios_base::goodbit;
I iter = f.get(I(v.data()), I(v.data() + v.size()), I iter = f.get(I(v.data()), I(v.data() + v.size()),
false, ios, err, ex); false, ios, err, ex);
assert(iter.base() == v.data() + v.size()); assert(iter.base() == v.data() + v.size());
assert(err == std::ios_base::eofbit); assert(err == std::ios_base::eofbit);
assert(ex == -123456789); assert(ex == -123456789);
noshowbase(ios); noshowbase(ios);
} }
{ // negative, showbase { // negative, showbase
std::wstring v = L"CNY -1,234,567.89"; std::wstring v = L"CNY -1,234,567.89";
showbase(ios); showbase(ios);
typedef input_iterator<const wchar_t*> I; typedef cpp17_input_iterator<const wchar_t*> I;
long double ex; long double ex;
std::ios_base::iostate err = std::ios_base::goodbit; std::ios_base::iostate err = std::ios_base::goodbit;
I iter = f.get(I(v.data()), I(v.data() + v.size()), I iter = f.get(I(v.data()), I(v.data() + v.size()),
false, ios, err, ex); false, ios, err, ex);
assert(iter.base() == v.data() + 0); assert(iter.base() == v.data() + 0);
assert(err == std::ios_base::failbit); assert(err == std::ios_base::failbit);
noshowbase(ios); noshowbase(ios);
} }
{ // negative, showbase { // negative, showbase
std::wstring v = L"CNY -1,234,567.89"; std::wstring v = L"CNY -1,234,567.89";
typedef input_iterator<const wchar_t*> I; typedef cpp17_input_iterator<const wchar_t*> I;
long double ex; long double ex;
std::ios_base::iostate err = std::ios_base::goodbit; std::ios_base::iostate err = std::ios_base::goodbit;
I iter = f.get(I(v.data()), I(v.data() + v.size()), I iter = f.get(I(v.data()), I(v.data() + v.size()),
false, ios, err, ex); false, ios, err, ex);
assert(iter.base() == v.data() + 0); assert(iter.base() == v.data() + 0);
assert(err == std::ios_base::failbit); assert(err == std::ios_base::failbit);
} }
} }
{ {
const my_facetw f(1); const my_facetw f(1);
// wchar_t, international // wchar_t, international
{ // zero { // zero
std::wstring v = L"0.00"; std::wstring v = L"0.00";
typedef input_iterator<const wchar_t*> I; typedef cpp17_input_iterator<const wchar_t*> I;
long double ex; long double ex;
std::ios_base::iostate err = std::ios_base::goodbit; std::ios_base::iostate err = std::ios_base::goodbit;
I iter = f.get(I(v.data()), I(v.data() + v.size()), I iter = f.get(I(v.data()), I(v.data() + v.size()),
true, ios, err, ex); true, ios, err, ex);
assert(iter.base() == v.data() + v.size()); assert(iter.base() == v.data() + v.size());
assert(err == std::ios_base::eofbit); assert(err == std::ios_base::eofbit);
assert(ex == 0); assert(ex == 0);
} }
{ // negative one { // negative one
std::wstring v = L"-0.01"; std::wstring v = L"-0.01";
typedef input_iterator<const wchar_t*> I; typedef cpp17_input_iterator<const wchar_t*> I;
long double ex; long double ex;
std::ios_base::iostate err = std::ios_base::goodbit; std::ios_base::iostate err = std::ios_base::goodbit;
I iter = f.get(I(v.data()), I(v.data() + v.size()), I iter = f.get(I(v.data()), I(v.data() + v.size()),
true, ios, err, ex); true, ios, err, ex);
assert(iter.base() == v.data() + v.size()); assert(iter.base() == v.data() + v.size());
assert(err == std::ios_base::eofbit); assert(err == std::ios_base::eofbit);
assert(ex == -1); assert(ex == -1);
} }
{ // positive { // positive
std::wstring v = L"1,234,567.89"; std::wstring v = L"1,234,567.89";
typedef input_iterator<const wchar_t*> I; typedef cpp17_input_iterator<const wchar_t*> I;
long double ex; long double ex;
std::ios_base::iostate err = std::ios_base::goodbit; std::ios_base::iostate err = std::ios_base::goodbit;
I iter = f.get(I(v.data()), I(v.data() + v.size()), I iter = f.get(I(v.data()), I(v.data() + v.size()),
true, ios, err, ex); true, ios, err, ex);
assert(iter.base() == v.data() + v.size()); assert(iter.base() == v.data() + v.size());
assert(err == std::ios_base::eofbit); assert(err == std::ios_base::eofbit);
assert(ex == 123456789); assert(ex == 123456789);
} }
{ // negative { // negative
std::wstring v = L"-1,234,567.89"; std::wstring v = L"-1,234,567.89";
typedef input_iterator<const wchar_t*> I; typedef cpp17_input_iterator<const wchar_t*> I;
long double ex; long double ex;
std::ios_base::iostate err = std::ios_base::goodbit; std::ios_base::iostate err = std::ios_base::goodbit;
I iter = f.get(I(v.data()), I(v.data() + v.size()), I iter = f.get(I(v.data()), I(v.data() + v.size()),
true, ios, err, ex); true, ios, err, ex);
assert(iter.base() == v.data() + v.size()); assert(iter.base() == v.data() + v.size());
assert(err == std::ios_base::eofbit); assert(err == std::ios_base::eofbit);
assert(ex == -123456789); assert(ex == -123456789);
} }
{ // negative { // negative
std::wstring v = L"-1234567.89"; std::wstring v = L"-1234567.89";
typedef input_iterator<const wchar_t*> I; typedef cpp17_input_iterator<const wchar_t*> I;
long double ex; long double ex;
std::ios_base::iostate err = std::ios_base::goodbit; std::ios_base::iostate err = std::ios_base::goodbit;
I iter = f.get(I(v.data()), I(v.data() + v.size()), I iter = f.get(I(v.data()), I(v.data() + v.size()),
true, ios, err, ex); true, ios, err, ex);
assert(iter.base() == v.data() + v.size()); assert(iter.base() == v.data() + v.size());
assert(err == std::ios_base::eofbit); assert(err == std::ios_base::eofbit);
assert(ex == -123456789); assert(ex == -123456789);
} }
{ // zero, showbase { // zero, showbase
std::wstring v = L"CNY 0.00"; std::wstring v = L"CNY 0.00";
typedef input_iterator<const wchar_t*> I; typedef cpp17_input_iterator<const wchar_t*> I;
long double ex; long double ex;
std::ios_base::iostate err = std::ios_base::goodbit; std::ios_base::iostate err = std::ios_base::goodbit;
I iter = f.get(I(v.data()), I(v.data() + v.size()), I iter = f.get(I(v.data()), I(v.data() + v.size()),
true, ios, err, ex); true, ios, err, ex);
assert(iter.base() == v.data() + v.size()); assert(iter.base() == v.data() + v.size());
assert(err == std::ios_base::eofbit); assert(err == std::ios_base::eofbit);
assert(ex == 0); assert(ex == 0);
} }
{ // zero, showbase { // zero, showbase
std::wstring v = L"CNY 0.00"; std::wstring v = L"CNY 0.00";
showbase(ios); showbase(ios);
typedef input_iterator<const wchar_t*> I; typedef cpp17_input_iterator<const wchar_t*> I;
long double ex; long double ex;
std::ios_base::iostate err = std::ios_base::goodbit; std::ios_base::iostate err = std::ios_base::goodbit;
I iter = f.get(I(v.data()), I(v.data() + v.size()), I iter = f.get(I(v.data()), I(v.data() + v.size()),
true, ios, err, ex); true, ios, err, ex);
assert(iter.base() == v.data() + v.size()); assert(iter.base() == v.data() + v.size());
assert(err == std::ios_base::eofbit); assert(err == std::ios_base::eofbit);
assert(ex == 0); assert(ex == 0);
noshowbase(ios); noshowbase(ios);
} }
{ // negative one, showbase { // negative one, showbase
std::wstring v = L"CNY -0.01"; std::wstring v = L"CNY -0.01";
typedef input_iterator<const wchar_t*> I; typedef cpp17_input_iterator<const wchar_t*> I;
long double ex; long double ex;
std::ios_base::iostate err = std::ios_base::goodbit; std::ios_base::iostate err = std::ios_base::goodbit;
I iter = f.get(I(v.data()), I(v.data() + v.size()), I iter = f.get(I(v.data()), I(v.data() + v.size()),
true, ios, err, ex); true, ios, err, ex);
assert(iter.base() == v.data() + v.size()); assert(iter.base() == v.data() + v.size());
assert(err == std::ios_base::eofbit); assert(err == std::ios_base::eofbit);
assert(ex == -1); assert(ex == -1);
} }
{ // negative one, showbase { // negative one, showbase
std::wstring v = L"CNY -0.01"; std::wstring v = L"CNY -0.01";
showbase(ios); showbase(ios);
typedef input_iterator<const wchar_t*> I; typedef cpp17_input_iterator<const wchar_t*> I;
long double ex; long double ex;
std::ios_base::iostate err = std::ios_base::goodbit; std::ios_base::iostate err = std::ios_base::goodbit;
I iter = f.get(I(v.data()), I(v.data() + v.size()), I iter = f.get(I(v.data()), I(v.data() + v.size()),
true, ios, err, ex); true, ios, err, ex);
assert(iter.base() == v.data() + v.size()); assert(iter.base() == v.data() + v.size());
assert(err == std::ios_base::eofbit); assert(err == std::ios_base::eofbit);
assert(ex == -1); assert(ex == -1);
noshowbase(ios); noshowbase(ios);
} }
{ // positive, showbase { // positive, showbase
std::wstring v = L"CNY 1,234,567.89"; std::wstring v = L"CNY 1,234,567.89";
typedef input_iterator<const wchar_t*> I; typedef cpp17_input_iterator<const wchar_t*> I;
long double ex; long double ex;
std::ios_base::iostate err = std::ios_base::goodbit; std::ios_base::iostate err = std::ios_base::goodbit;
I iter = f.get(I(v.data()), I(v.data() + v.size()), I iter = f.get(I(v.data()), I(v.data() + v.size()),
true, ios, err, ex); true, ios, err, ex);
assert(iter.base() == v.data() + v.size()); assert(iter.base() == v.data() + v.size());
assert(err == std::ios_base::eofbit); assert(err == std::ios_base::eofbit);
assert(ex == 123456789); assert(ex == 123456789);
} }
{ // positive, showbase { // positive, showbase
std::wstring v = L"CNY 1,234,567.89"; std::wstring v = L"CNY 1,234,567.89";
showbase(ios); showbase(ios);
typedef input_iterator<const wchar_t*> I; typedef cpp17_input_iterator<const wchar_t*> I;
long double ex; long double ex;
std::ios_base::iostate err = std::ios_base::goodbit; std::ios_base::iostate err = std::ios_base::goodbit;
I iter = f.get(I(v.data()), I(v.data() + v.size()), I iter = f.get(I(v.data()), I(v.data() + v.size()),
true, ios, err, ex); true, ios, err, ex);
assert(iter.base() == v.data() + v.size()); assert(iter.base() == v.data() + v.size());
assert(err == std::ios_base::eofbit); assert(err == std::ios_base::eofbit);
assert(ex == 123456789); assert(ex == 123456789);
noshowbase(ios); noshowbase(ios);
} }
{ // negative, showbase { // negative, showbase
std::wstring v = L"CNY -1,234,567.89"; std::wstring v = L"CNY -1,234,567.89";
showbase(ios); showbase(ios);
typedef input_iterator<const wchar_t*> I; typedef cpp17_input_iterator<const wchar_t*> I;
long double ex; long double ex;
std::ios_base::iostate err = std::ios_base::goodbit; std::ios_base::iostate err = std::ios_base::goodbit;
I iter = f.get(I(v.data()), I(v.data() + v.size()), I iter = f.get(I(v.data()), I(v.data() + v.size()),
true, ios, err, ex); true, ios, err, ex);
assert(iter.base() == v.data() + v.size()); assert(iter.base() == v.data() + v.size());
assert(err == std::ios_base::eofbit); assert(err == std::ios_base::eofbit);
assert(ex == -123456789); assert(ex == -123456789);
noshowbase(ios); noshowbase(ios);
} }
{ // negative, showbase { // negative, showbase
std::wstring v = L"\xFFE5""-1,234,567.89"; std::wstring v = L"\xFFE5""-1,234,567.89";
showbase(ios); showbase(ios);
typedef input_iterator<const wchar_t*> I; typedef cpp17_input_iterator<const wchar_t*> I;
long double ex; long double ex;
std::ios_base::iostate err = std::ios_base::goodbit; std::ios_base::iostate err = std::ios_base::goodbit;
I iter = f.get(I(v.data()), I(v.data() + v.size()), I iter = f.get(I(v.data()), I(v.data() + v.size()),
true, ios, err, ex); true, ios, err, ex);
assert(iter.base() == v.data() + 0); assert(iter.base() == v.data() + 0);
assert(err == std::ios_base::failbit); assert(err == std::ios_base::failbit);
noshowbase(ios); noshowbase(ios);
} }
{ // negative, showbase { // negative, showbase
std::wstring v = L"\xFFE5""-1,234,567.89"; std::wstring v = L"\xFFE5""-1,234,567.89";
typedef input_iterator<const wchar_t*> I; typedef cpp17_input_iterator<const wchar_t*> I;
long double ex; long double ex;
std::ios_base::iostate err = std::ios_base::goodbit; std::ios_base::iostate err = std::ios_base::goodbit;
I iter = f.get(I(v.data()), I(v.data() + v.size()), I iter = f.get(I(v.data()), I(v.data() + v.size()),
true, ios, err, ex); true, ios, err, ex);
assert(iter.base() == v.data() + 0); assert(iter.base() == v.data() + 0);
assert(err == std::ios_base::failbit); assert(err == std::ios_base::failbit);
} }
} }
return 0; return 0;
} }

libcxx/test/std/localization/locale.categories/category.monetary/locale.money.get/locale.money.get.members/get_string_en_US.pass.cpp

Show All 19 Lines
#include <ios> #include <ios>
#include <streambuf> #include <streambuf>
#include <cassert> #include <cassert>
#include "test_macros.h" #include "test_macros.h"
#include "test_iterators.h" #include "test_iterators.h"
#include "platform_support.h" // locale name macros #include "platform_support.h" // locale name macros
typedef std::money_get<char, input_iterator<const char*> > Fn; typedef std::money_get<char, cpp17_input_iterator<const char*> > Fn;
class my_facet class my_facet
: public Fn : public Fn
{ {
public: public:
explicit my_facet(std::size_t refs = 0) explicit my_facet(std::size_t refs = 0)
: Fn(refs) {} : Fn(refs) {}
}; };
typedef std::money_get<wchar_t, input_iterator<const wchar_t*> > Fw; typedef std::money_get<wchar_t, cpp17_input_iterator<const wchar_t*> > Fw;
class my_facetw class my_facetw
: public Fw : public Fw
{ {
public: public:
explicit my_facetw(std::size_t refs = 0) explicit my_facetw(std::size_t refs = 0)
: Fw(refs) {} : Fw(refs) {}
}; };
Show All 10 Lines ios.imbue(std::locale(ios.getloc(),
new std::moneypunct_byname<wchar_t, false>(loc_name))); new std::moneypunct_byname<wchar_t, false>(loc_name)));
ios.imbue(std::locale(ios.getloc(), ios.imbue(std::locale(ios.getloc(),
new std::moneypunct_byname<wchar_t, true>(loc_name))); new std::moneypunct_byname<wchar_t, true>(loc_name)));
{ {
const my_facet f(1); const my_facet f(1);
// char, national // char, national
{ // zero { // zero
std::string v = "0.00"; std::string v = "0.00";
typedef input_iterator<const char*> I; typedef cpp17_input_iterator<const char*> I;
std::string ex; std::string ex;
std::ios_base::iostate err = std::ios_base::goodbit; std::ios_base::iostate err = std::ios_base::goodbit;
I iter = f.get(I(v.data()), I(v.data() + v.size()), I iter = f.get(I(v.data()), I(v.data() + v.size()),
false, ios, err, ex); false, ios, err, ex);
assert(iter.base() == v.data() + v.size()); assert(iter.base() == v.data() + v.size());
assert(err == std::ios_base::eofbit); assert(err == std::ios_base::eofbit);
assert(ex == "0"); assert(ex == "0");
} }
{ // negative one { // negative one
std::string v = "-0.01"; std::string v = "-0.01";
typedef input_iterator<const char*> I; typedef cpp17_input_iterator<const char*> I;
std::string ex; std::string ex;
std::ios_base::iostate err = std::ios_base::goodbit; std::ios_base::iostate err = std::ios_base::goodbit;
I iter = f.get(I(v.data()), I(v.data() + v.size()), I iter = f.get(I(v.data()), I(v.data() + v.size()),
false, ios, err, ex); false, ios, err, ex);
assert(iter.base() == v.data() + v.size()); assert(iter.base() == v.data() + v.size());
assert(err == std::ios_base::eofbit); assert(err == std::ios_base::eofbit);
assert(ex == "-1"); assert(ex == "-1");
} }
{ // positive { // positive
std::string v = "1,234,567.89"; std::string v = "1,234,567.89";
typedef input_iterator<const char*> I; typedef cpp17_input_iterator<const char*> I;
std::string ex; std::string ex;
std::ios_base::iostate err = std::ios_base::goodbit; std::ios_base::iostate err = std::ios_base::goodbit;
I iter = f.get(I(v.data()), I(v.data() + v.size()), I iter = f.get(I(v.data()), I(v.data() + v.size()),
false, ios, err, ex); false, ios, err, ex);
assert(iter.base() == v.data() + v.size()); assert(iter.base() == v.data() + v.size());
assert(err == std::ios_base::eofbit); assert(err == std::ios_base::eofbit);
assert(ex == "123456789"); assert(ex == "123456789");
} }
{ // negative { // negative
std::string v = "-1,234,567.89"; std::string v = "-1,234,567.89";
typedef input_iterator<const char*> I; typedef cpp17_input_iterator<const char*> I;
std::string ex; std::string ex;
std::ios_base::iostate err = std::ios_base::goodbit; std::ios_base::iostate err = std::ios_base::goodbit;
I iter = f.get(I(v.data()), I(v.data() + v.size()), I iter = f.get(I(v.data()), I(v.data() + v.size()),
false, ios, err, ex); false, ios, err, ex);
assert(iter.base() == v.data() + v.size()); assert(iter.base() == v.data() + v.size());
assert(err == std::ios_base::eofbit); assert(err == std::ios_base::eofbit);
assert(ex == "-123456789"); assert(ex == "-123456789");
} }
{ // negative { // negative
std::string v = "-1234567.89"; std::string v = "-1234567.89";
typedef input_iterator<const char*> I; typedef cpp17_input_iterator<const char*> I;
std::string ex; std::string ex;
std::ios_base::iostate err = std::ios_base::goodbit; std::ios_base::iostate err = std::ios_base::goodbit;
I iter = f.get(I(v.data()), I(v.data() + v.size()), I iter = f.get(I(v.data()), I(v.data() + v.size()),
false, ios, err, ex); false, ios, err, ex);
assert(iter.base() == v.data() + v.size()); assert(iter.base() == v.data() + v.size());
assert(err == std::ios_base::eofbit); assert(err == std::ios_base::eofbit);
assert(ex == "-123456789"); assert(ex == "-123456789");
} }
{ // zero, showbase { // zero, showbase
std::string v = "$0.00"; std::string v = "$0.00";
typedef input_iterator<const char*> I; typedef cpp17_input_iterator<const char*> I;
std::string ex; std::string ex;
std::ios_base::iostate err = std::ios_base::goodbit; std::ios_base::iostate err = std::ios_base::goodbit;
I iter = f.get(I(v.data()), I(v.data() + v.size()), I iter = f.get(I(v.data()), I(v.data() + v.size()),
false, ios, err, ex); false, ios, err, ex);
assert(iter.base() == v.data() + v.size()); assert(iter.base() == v.data() + v.size());
assert(err == std::ios_base::eofbit); assert(err == std::ios_base::eofbit);
assert(ex == "0"); assert(ex == "0");
} }
{ // zero, showbase { // zero, showbase
std::string v = "$0.00"; std::string v = "$0.00";
showbase(ios); showbase(ios);
typedef input_iterator<const char*> I; typedef cpp17_input_iterator<const char*> I;
std::string ex; std::string ex;
std::ios_base::iostate err = std::ios_base::goodbit; std::ios_base::iostate err = std::ios_base::goodbit;
I iter = f.get(I(v.data()), I(v.data() + v.size()), I iter = f.get(I(v.data()), I(v.data() + v.size()),
false, ios, err, ex); false, ios, err, ex);
assert(iter.base() == v.data() + v.size()); assert(iter.base() == v.data() + v.size());
assert(err == std::ios_base::eofbit); assert(err == std::ios_base::eofbit);
assert(ex == "0"); assert(ex == "0");
noshowbase(ios); noshowbase(ios);
} }
{ // negative one, showbase { // negative one, showbase
std::string v = "-$0.01"; std::string v = "-$0.01";
typedef input_iterator<const char*> I; typedef cpp17_input_iterator<const char*> I;
std::string ex; std::string ex;
std::ios_base::iostate err = std::ios_base::goodbit; std::ios_base::iostate err = std::ios_base::goodbit;
I iter = f.get(I(v.data()), I(v.data() + v.size()), I iter = f.get(I(v.data()), I(v.data() + v.size()),
false, ios, err, ex); false, ios, err, ex);
assert(iter.base() == v.data() + v.size()); assert(iter.base() == v.data() + v.size());
assert(err == std::ios_base::eofbit); assert(err == std::ios_base::eofbit);
assert(ex == "-1"); assert(ex == "-1");
} }
{ // negative one, showbase { // negative one, showbase
std::string v = "-$0.01"; std::string v = "-$0.01";
showbase(ios); showbase(ios);
typedef input_iterator<const char*> I; typedef cpp17_input_iterator<const char*> I;
std::string ex; std::string ex;
std::ios_base::iostate err = std::ios_base::goodbit; std::ios_base::iostate err = std::ios_base::goodbit;
I iter = f.get(I(v.data()), I(v.data() + v.size()), I iter = f.get(I(v.data()), I(v.data() + v.size()),
false, ios, err, ex); false, ios, err, ex);
assert(iter.base() == v.data() + v.size()); assert(iter.base() == v.data() + v.size());
assert(err == std::ios_base::eofbit); assert(err == std::ios_base::eofbit);
assert(ex == "-1"); assert(ex == "-1");
noshowbase(ios); noshowbase(ios);
} }
{ // positive, showbase { // positive, showbase
std::string v = "$1,234,567.89"; std::string v = "$1,234,567.89";
typedef input_iterator<const char*> I; typedef cpp17_input_iterator<const char*> I;
std::string ex; std::string ex;
std::ios_base::iostate err = std::ios_base::goodbit; std::ios_base::iostate err = std::ios_base::goodbit;
I iter = f.get(I(v.data()), I(v.data() + v.size()), I iter = f.get(I(v.data()), I(v.data() + v.size()),
false, ios, err, ex); false, ios, err, ex);
assert(iter.base() == v.data() + v.size()); assert(iter.base() == v.data() + v.size());
assert(err == std::ios_base::eofbit); assert(err == std::ios_base::eofbit);
assert(ex == "123456789"); assert(ex == "123456789");
} }
{ // positive, showbase { // positive, showbase
std::string v = "$1,234,567.89"; std::string v = "$1,234,567.89";
showbase(ios); showbase(ios);
typedef input_iterator<const char*> I; typedef cpp17_input_iterator<const char*> I;
std::string ex; std::string ex;
std::ios_base::iostate err = std::ios_base::goodbit; std::ios_base::iostate err = std::ios_base::goodbit;
I iter = f.get(I(v.data()), I(v.data() + v.size()), I iter = f.get(I(v.data()), I(v.data() + v.size()),
false, ios, err, ex); false, ios, err, ex);
assert(iter.base() == v.data() + v.size()); assert(iter.base() == v.data() + v.size());
assert(err == std::ios_base::eofbit); assert(err == std::ios_base::eofbit);
assert(ex == "123456789"); assert(ex == "123456789");
noshowbase(ios); noshowbase(ios);
} }
{ // negative, showbase { // negative, showbase
std::string v = "-$1,234,567.89"; std::string v = "-$1,234,567.89";
showbase(ios); showbase(ios);
typedef input_iterator<const char*> I; typedef cpp17_input_iterator<const char*> I;
std::string ex; std::string ex;
std::ios_base::iostate err = std::ios_base::goodbit; std::ios_base::iostate err = std::ios_base::goodbit;
I iter = f.get(I(v.data()), I(v.data() + v.size()), I iter = f.get(I(v.data()), I(v.data() + v.size()),
false, ios, err, ex); false, ios, err, ex);
assert(iter.base() == v.data() + v.size()); assert(iter.base() == v.data() + v.size());
assert(err == std::ios_base::eofbit); assert(err == std::ios_base::eofbit);
assert(ex == "-123456789"); assert(ex == "-123456789");
noshowbase(ios); noshowbase(ios);
} }
{ // negative, showbase { // negative, showbase
std::string v = "-USD 1,234,567.89"; std::string v = "-USD 1,234,567.89";
showbase(ios); showbase(ios);
typedef input_iterator<const char*> I; typedef cpp17_input_iterator<const char*> I;
std::string ex; std::string ex;
std::ios_base::iostate err = std::ios_base::goodbit; std::ios_base::iostate err = std::ios_base::goodbit;
I iter = f.get(I(v.data()), I(v.data() + v.size()), I iter = f.get(I(v.data()), I(v.data() + v.size()),
false, ios, err, ex); false, ios, err, ex);
assert(iter.base() == v.data() + 1); assert(iter.base() == v.data() + 1);
assert(err == std::ios_base::failbit); assert(err == std::ios_base::failbit);
assert(ex == ""); assert(ex == "");
noshowbase(ios); noshowbase(ios);
} }
{ // negative, showbase { // negative, showbase
std::string v = "-USD 1,234,567.89"; std::string v = "-USD 1,234,567.89";
typedef input_iterator<const char*> I; typedef cpp17_input_iterator<const char*> I;
std::string ex; std::string ex;
std::ios_base::iostate err = std::ios_base::goodbit; std::ios_base::iostate err = std::ios_base::goodbit;
I iter = f.get(I(v.data()), I(v.data() + v.size()), I iter = f.get(I(v.data()), I(v.data() + v.size()),
false, ios, err, ex); false, ios, err, ex);
assert(iter.base() == v.data() + 1); assert(iter.base() == v.data() + 1);
assert(err == std::ios_base::failbit); assert(err == std::ios_base::failbit);
assert(ex == ""); assert(ex == "");
} }
} }
{ {
const my_facet f(1); const my_facet f(1);
// char, international // char, international
{ // zero { // zero
std::string v = "0.00"; std::string v = "0.00";
typedef input_iterator<const char*> I; typedef cpp17_input_iterator<const char*> I;
std::string ex; std::string ex;
std::ios_base::iostate err = std::ios_base::goodbit; std::ios_base::iostate err = std::ios_base::goodbit;
I iter = f.get(I(v.data()), I(v.data() + v.size()), I iter = f.get(I(v.data()), I(v.data() + v.size()),
true, ios, err, ex); true, ios, err, ex);
assert(iter.base() == v.data() + v.size()); assert(iter.base() == v.data() + v.size());
assert(err == std::ios_base::eofbit); assert(err == std::ios_base::eofbit);
assert(ex == "0"); assert(ex == "0");
} }
{ // negative one { // negative one
std::string v = "-0.01"; std::string v = "-0.01";
typedef input_iterator<const char*> I; typedef cpp17_input_iterator<const char*> I;
std::string ex; std::string ex;
std::ios_base::iostate err = std::ios_base::goodbit; std::ios_base::iostate err = std::ios_base::goodbit;
I iter = f.get(I(v.data()), I(v.data() + v.size()), I iter = f.get(I(v.data()), I(v.data() + v.size()),
true, ios, err, ex); true, ios, err, ex);
assert(iter.base() == v.data() + v.size()); assert(iter.base() == v.data() + v.size());
assert(err == std::ios_base::eofbit); assert(err == std::ios_base::eofbit);
assert(ex == "-1"); assert(ex == "-1");
} }
{ // positive { // positive
std::string v = "1,234,567.89"; std::string v = "1,234,567.89";
typedef input_iterator<const char*> I; typedef cpp17_input_iterator<const char*> I;
std::string ex; std::string ex;
std::ios_base::iostate err = std::ios_base::goodbit; std::ios_base::iostate err = std::ios_base::goodbit;
I iter = f.get(I(v.data()), I(v.data() + v.size()), I iter = f.get(I(v.data()), I(v.data() + v.size()),
true, ios, err, ex); true, ios, err, ex);
assert(iter.base() == v.data() + v.size()); assert(iter.base() == v.data() + v.size());
assert(err == std::ios_base::eofbit); assert(err == std::ios_base::eofbit);
assert(ex == "123456789"); assert(ex == "123456789");
} }
{ // negative { // negative
std::string v = "-1,234,567.89"; std::string v = "-1,234,567.89";
typedef input_iterator<const char*> I; typedef cpp17_input_iterator<const char*> I;
std::string ex; std::string ex;
std::ios_base::iostate err = std::ios_base::goodbit; std::ios_base::iostate err = std::ios_base::goodbit;
I iter = f.get(I(v.data()), I(v.data() + v.size()), I iter = f.get(I(v.data()), I(v.data() + v.size()),
true, ios, err, ex); true, ios, err, ex);
assert(iter.base() == v.data() + v.size()); assert(iter.base() == v.data() + v.size());
assert(err == std::ios_base::eofbit); assert(err == std::ios_base::eofbit);
assert(ex == "-123456789"); assert(ex == "-123456789");
} }
{ // negative { // negative
std::string v = "-1234567.89"; std::string v = "-1234567.89";
typedef input_iterator<const char*> I; typedef cpp17_input_iterator<const char*> I;
std::string ex; std::string ex;
std::ios_base::iostate err = std::ios_base::goodbit; std::ios_base::iostate err = std::ios_base::goodbit;
I iter = f.get(I(v.data()), I(v.data() + v.size()), I iter = f.get(I(v.data()), I(v.data() + v.size()),
true, ios, err, ex); true, ios, err, ex);
assert(iter.base() == v.data() + v.size()); assert(iter.base() == v.data() + v.size());
assert(err == std::ios_base::eofbit); assert(err == std::ios_base::eofbit);
assert(ex == "-123456789"); assert(ex == "-123456789");
} }
{ // zero, showbase { // zero, showbase
std::string v = "USD 0.00"; std::string v = "USD 0.00";
typedef input_iterator<const char*> I; typedef cpp17_input_iterator<const char*> I;
std::string ex; std::string ex;
std::ios_base::iostate err = std::ios_base::goodbit; std::ios_base::iostate err = std::ios_base::goodbit;
I iter = f.get(I(v.data()), I(v.data() + v.size()), I iter = f.get(I(v.data()), I(v.data() + v.size()),
true, ios, err, ex); true, ios, err, ex);
assert(iter.base() == v.data() + v.size()); assert(iter.base() == v.data() + v.size());
assert(err == std::ios_base::eofbit); assert(err == std::ios_base::eofbit);
assert(ex == "0"); assert(ex == "0");
} }
{ // zero, showbase { // zero, showbase
std::string v = "USD 0.00"; std::string v = "USD 0.00";
showbase(ios); showbase(ios);
typedef input_iterator<const char*> I; typedef cpp17_input_iterator<const char*> I;
std::string ex; std::string ex;
std::ios_base::iostate err = std::ios_base::goodbit; std::ios_base::iostate err = std::ios_base::goodbit;
I iter = f.get(I(v.data()), I(v.data() + v.size()), I iter = f.get(I(v.data()), I(v.data() + v.size()),
true, ios, err, ex); true, ios, err, ex);
assert(iter.base() == v.data() + v.size()); assert(iter.base() == v.data() + v.size());
assert(err == std::ios_base::eofbit); assert(err == std::ios_base::eofbit);
assert(ex == "0"); assert(ex == "0");
noshowbase(ios); noshowbase(ios);
} }
{ // negative one, showbase { // negative one, showbase
std::string v = "-USD 0.01"; std::string v = "-USD 0.01";
typedef input_iterator<const char*> I; typedef cpp17_input_iterator<const char*> I;
std::string ex; std::string ex;
std::ios_base::iostate err = std::ios_base::goodbit; std::ios_base::iostate err = std::ios_base::goodbit;
I iter = f.get(I(v.data()), I(v.data() + v.size()), I iter = f.get(I(v.data()), I(v.data() + v.size()),
true, ios, err, ex); true, ios, err, ex);
assert(iter.base() == v.data() + v.size()); assert(iter.base() == v.data() + v.size());
assert(err == std::ios_base::eofbit); assert(err == std::ios_base::eofbit);
assert(ex == "-1"); assert(ex == "-1");
} }
{ // negative one, showbase { // negative one, showbase
std::string v = "-USD 0.01"; std::string v = "-USD 0.01";
showbase(ios); showbase(ios);
typedef input_iterator<const char*> I; typedef cpp17_input_iterator<const char*> I;
std::string ex; std::string ex;
std::ios_base::iostate err = std::ios_base::goodbit; std::ios_base::iostate err = std::ios_base::goodbit;
I iter = f.get(I(v.data()), I(v.data() + v.size()), I iter = f.get(I(v.data()), I(v.data() + v.size()),
true, ios, err, ex); true, ios, err, ex);
assert(iter.base() == v.data() + v.size()); assert(iter.base() == v.data() + v.size());
assert(err == std::ios_base::eofbit); assert(err == std::ios_base::eofbit);
assert(ex == "-1"); assert(ex == "-1");
noshowbase(ios); noshowbase(ios);
} }
{ // positive, showbase { // positive, showbase
std::string v = "USD 1,234,567.89"; std::string v = "USD 1,234,567.89";
typedef input_iterator<const char*> I; typedef cpp17_input_iterator<const char*> I;
std::string ex; std::string ex;
std::ios_base::iostate err = std::ios_base::goodbit; std::ios_base::iostate err = std::ios_base::goodbit;
I iter = f.get(I(v.data()), I(v.data() + v.size()), I iter = f.get(I(v.data()), I(v.data() + v.size()),
true, ios, err, ex); true, ios, err, ex);
assert(iter.base() == v.data() + v.size()); assert(iter.base() == v.data() + v.size());
assert(err == std::ios_base::eofbit); assert(err == std::ios_base::eofbit);
assert(ex == "123456789"); assert(ex == "123456789");
} }
{ // positive, showbase { // positive, showbase
std::string v = "USD 1,234,567.89"; std::string v = "USD 1,234,567.89";
showbase(ios); showbase(ios);
typedef input_iterator<const char*> I; typedef cpp17_input_iterator<const char*> I;
std::string ex; std::string ex;
std::ios_base::iostate err = std::ios_base::goodbit; std::ios_base::iostate err = std::ios_base::goodbit;
I iter = f.get(I(v.data()), I(v.data() + v.size()), I iter = f.get(I(v.data()), I(v.data() + v.size()),
true, ios, err, ex); true, ios, err, ex);
assert(iter.base() == v.data() + v.size()); assert(iter.base() == v.data() + v.size());
assert(err == std::ios_base::eofbit); assert(err == std::ios_base::eofbit);
assert(ex == "123456789"); assert(ex == "123456789");
noshowbase(ios); noshowbase(ios);
} }
{ // negative, showbase { // negative, showbase
std::string v = "-USD 1,234,567.89"; std::string v = "-USD 1,234,567.89";
showbase(ios); showbase(ios);
typedef input_iterator<const char*> I; typedef cpp17_input_iterator<const char*> I;
std::string ex; std::string ex;
std::ios_base::iostate err = std::ios_base::goodbit; std::ios_base::iostate err = std::ios_base::goodbit;
I iter = f.get(I(v.data()), I(v.data() + v.size()), I iter = f.get(I(v.data()), I(v.data() + v.size()),
true, ios, err, ex); true, ios, err, ex);
assert(iter.base() == v.data() + v.size()); assert(iter.base() == v.data() + v.size());
assert(err == std::ios_base::eofbit); assert(err == std::ios_base::eofbit);
assert(ex == "-123456789"); assert(ex == "-123456789");
noshowbase(ios); noshowbase(ios);
} }
{ // negative, showbase { // negative, showbase
std::string v = "-$1,234,567.89"; std::string v = "-$1,234,567.89";
showbase(ios); showbase(ios);
typedef input_iterator<const char*> I; typedef cpp17_input_iterator<const char*> I;
std::string ex; std::string ex;
std::ios_base::iostate err = std::ios_base::goodbit; std::ios_base::iostate err = std::ios_base::goodbit;
I iter = f.get(I(v.data()), I(v.data() + v.size()), I iter = f.get(I(v.data()), I(v.data() + v.size()),
true, ios, err, ex); true, ios, err, ex);
assert(iter.base() == v.data() + 1); assert(iter.base() == v.data() + 1);
assert(err == std::ios_base::failbit); assert(err == std::ios_base::failbit);
assert(ex == ""); assert(ex == "");
noshowbase(ios); noshowbase(ios);
} }
{ // negative, showbase { // negative, showbase
std::string v = "-$1,234,567.89"; std::string v = "-$1,234,567.89";
typedef input_iterator<const char*> I; typedef cpp17_input_iterator<const char*> I;
std::string ex; std::string ex;
std::ios_base::iostate err = std::ios_base::goodbit; std::ios_base::iostate err = std::ios_base::goodbit;
I iter = f.get(I(v.data()), I(v.data() + v.size()), I iter = f.get(I(v.data()), I(v.data() + v.size()),
true, ios, err, ex); true, ios, err, ex);
assert(iter.base() == v.data() + 1); assert(iter.base() == v.data() + 1);
assert(err == std::ios_base::failbit); assert(err == std::ios_base::failbit);
assert(ex == ""); assert(ex == "");
} }
} }
{ {
const my_facetw f(1); const my_facetw f(1);
// wchar_t, national // wchar_t, national
{ // zero { // zero
std::wstring v = L"0.00"; std::wstring v = L"0.00";
typedef input_iterator<const wchar_t*> I; typedef cpp17_input_iterator<const wchar_t*> I;
std::wstring ex; std::wstring ex;
std::ios_base::iostate err = std::ios_base::goodbit; std::ios_base::iostate err = std::ios_base::goodbit;
I iter = f.get(I(v.data()), I(v.data() + v.size()), I iter = f.get(I(v.data()), I(v.data() + v.size()),
false, ios, err, ex); false, ios, err, ex);
assert(iter.base() == v.data() + v.size()); assert(iter.base() == v.data() + v.size());
assert(err == std::ios_base::eofbit); assert(err == std::ios_base::eofbit);
assert(ex == L"0"); assert(ex == L"0");
} }
{ // negative one { // negative one
std::wstring v = L"-0.01"; std::wstring v = L"-0.01";
typedef input_iterator<const wchar_t*> I; typedef cpp17_input_iterator<const wchar_t*> I;
std::wstring ex; std::wstring ex;
std::ios_base::iostate err = std::ios_base::goodbit; std::ios_base::iostate err = std::ios_base::goodbit;
I iter = f.get(I(v.data()), I(v.data() + v.size()), I iter = f.get(I(v.data()), I(v.data() + v.size()),
false, ios, err, ex); false, ios, err, ex);
assert(iter.base() == v.data() + v.size()); assert(iter.base() == v.data() + v.size());
assert(err == std::ios_base::eofbit); assert(err == std::ios_base::eofbit);
assert(ex == L"-1"); assert(ex == L"-1");
} }
{ // positive { // positive
std::wstring v = L"1,234,567.89"; std::wstring v = L"1,234,567.89";
typedef input_iterator<const wchar_t*> I; typedef cpp17_input_iterator<const wchar_t*> I;
std::wstring ex; std::wstring ex;
std::ios_base::iostate err = std::ios_base::goodbit; std::ios_base::iostate err = std::ios_base::goodbit;
I iter = f.get(I(v.data()), I(v.data() + v.size()), I iter = f.get(I(v.data()), I(v.data() + v.size()),
false, ios, err, ex); false, ios, err, ex);
assert(iter.base() == v.data() + v.size()); assert(iter.base() == v.data() + v.size());
assert(err == std::ios_base::eofbit); assert(err == std::ios_base::eofbit);
assert(ex == L"123456789"); assert(ex == L"123456789");
} }
{ // negative { // negative
std::wstring v = L"-1,234,567.89"; std::wstring v = L"-1,234,567.89";
typedef input_iterator<const wchar_t*> I; typedef cpp17_input_iterator<const wchar_t*> I;
std::wstring ex; std::wstring ex;
std::ios_base::iostate err = std::ios_base::goodbit; std::ios_base::iostate err = std::ios_base::goodbit;
I iter = f.get(I(v.data()), I(v.data() + v.size()), I iter = f.get(I(v.data()), I(v.data() + v.size()),
false, ios, err, ex); false, ios, err, ex);
assert(iter.base() == v.data() + v.size()); assert(iter.base() == v.data() + v.size());
assert(err == std::ios_base::eofbit); assert(err == std::ios_base::eofbit);
assert(ex == L"-123456789"); assert(ex == L"-123456789");
} }
{ // negative { // negative
std::wstring v = L"-1234567.89"; std::wstring v = L"-1234567.89";
typedef input_iterator<const wchar_t*> I; typedef cpp17_input_iterator<const wchar_t*> I;
std::wstring ex; std::wstring ex;
std::ios_base::iostate err = std::ios_base::goodbit; std::ios_base::iostate err = std::ios_base::goodbit;
I iter = f.get(I(v.data()), I(v.data() + v.size()), I iter = f.get(I(v.data()), I(v.data() + v.size()),
false, ios, err, ex); false, ios, err, ex);
assert(iter.base() == v.data() + v.size()); assert(iter.base() == v.data() + v.size());
assert(err == std::ios_base::eofbit); assert(err == std::ios_base::eofbit);
assert(ex == L"-123456789"); assert(ex == L"-123456789");
} }
{ // zero, showbase { // zero, showbase
std::wstring v = L"$0.00"; std::wstring v = L"$0.00";
typedef input_iterator<const wchar_t*> I; typedef cpp17_input_iterator<const wchar_t*> I;
std::wstring ex; std::wstring ex;
std::ios_base::iostate err = std::ios_base::goodbit; std::ios_base::iostate err = std::ios_base::goodbit;
I iter = f.get(I(v.data()), I(v.data() + v.size()), I iter = f.get(I(v.data()), I(v.data() + v.size()),
false, ios, err, ex); false, ios, err, ex);
assert(iter.base() == v.data() + v.size()); assert(iter.base() == v.data() + v.size());
assert(err == std::ios_base::eofbit); assert(err == std::ios_base::eofbit);
assert(ex == L"0"); assert(ex == L"0");
} }
{ // zero, showbase { // zero, showbase
std::wstring v = L"$0.00"; std::wstring v = L"$0.00";
showbase(ios); showbase(ios);
typedef input_iterator<const wchar_t*> I; typedef cpp17_input_iterator<const wchar_t*> I;
std::wstring ex; std::wstring ex;
std::ios_base::iostate err = std::ios_base::goodbit; std::ios_base::iostate err = std::ios_base::goodbit;
I iter = f.get(I(v.data()), I(v.data() + v.size()), I iter = f.get(I(v.data()), I(v.data() + v.size()),
false, ios, err, ex); false, ios, err, ex);
assert(iter.base() == v.data() + v.size()); assert(iter.base() == v.data() + v.size());
assert(err == std::ios_base::eofbit); assert(err == std::ios_base::eofbit);
assert(ex == L"0"); assert(ex == L"0");
noshowbase(ios); noshowbase(ios);
} }
{ // negative one, showbase { // negative one, showbase
std::wstring v = L"-$0.01"; std::wstring v = L"-$0.01";
typedef input_iterator<const wchar_t*> I; typedef cpp17_input_iterator<const wchar_t*> I;
std::wstring ex; std::wstring ex;
std::ios_base::iostate err = std::ios_base::goodbit; std::ios_base::iostate err = std::ios_base::goodbit;
I iter = f.get(I(v.data()), I(v.data() + v.size()), I iter = f.get(I(v.data()), I(v.data() + v.size()),
false, ios, err, ex); false, ios, err, ex);
assert(iter.base() == v.data() + v.size()); assert(iter.base() == v.data() + v.size());
assert(err == std::ios_base::eofbit); assert(err == std::ios_base::eofbit);
assert(ex == L"-1"); assert(ex == L"-1");
} }
{ // negative one, showbase { // negative one, showbase
std::wstring v = L"-$0.01"; std::wstring v = L"-$0.01";
showbase(ios); showbase(ios);
typedef input_iterator<const wchar_t*> I; typedef cpp17_input_iterator<const wchar_t*> I;
std::wstring ex; std::wstring ex;
std::ios_base::iostate err = std::ios_base::goodbit; std::ios_base::iostate err = std::ios_base::goodbit;
I iter = f.get(I(v.data()), I(v.data() + v.size()), I iter = f.get(I(v.data()), I(v.data() + v.size()),
false, ios, err, ex); false, ios, err, ex);
assert(iter.base() == v.data() + v.size()); assert(iter.base() == v.data() + v.size());
assert(err == std::ios_base::eofbit); assert(err == std::ios_base::eofbit);
assert(ex == L"-1"); assert(ex == L"-1");
noshowbase(ios); noshowbase(ios);
} }
{ // positive, showbase { // positive, showbase
std::wstring v = L"$1,234,567.89"; std::wstring v = L"$1,234,567.89";
typedef input_iterator<const wchar_t*> I; typedef cpp17_input_iterator<const wchar_t*> I;
std::wstring ex; std::wstring ex;
std::ios_base::iostate err = std::ios_base::goodbit; std::ios_base::iostate err = std::ios_base::goodbit;
I iter = f.get(I(v.data()), I(v.data() + v.size()), I iter = f.get(I(v.data()), I(v.data() + v.size()),
false, ios, err, ex); false, ios, err, ex);
assert(iter.base() == v.data() + v.size()); assert(iter.base() == v.data() + v.size());
assert(err == std::ios_base::eofbit); assert(err == std::ios_base::eofbit);
assert(ex == L"123456789"); assert(ex == L"123456789");
} }
{ // positive, showbase { // positive, showbase
std::wstring v = L"$1,234,567.89"; std::wstring v = L"$1,234,567.89";
showbase(ios); showbase(ios);
typedef input_iterator<const wchar_t*> I; typedef cpp17_input_iterator<const wchar_t*> I;
std::wstring ex; std::wstring ex;
std::ios_base::iostate err = std::ios_base::goodbit; std::ios_base::iostate err = std::ios_base::goodbit;
I iter = f.get(I(v.data()), I(v.data() + v.size()), I iter = f.get(I(v.data()), I(v.data() + v.size()),
false, ios, err, ex); false, ios, err, ex);
assert(iter.base() == v.data() + v.size()); assert(iter.base() == v.data() + v.size());
assert(err == std::ios_base::eofbit); assert(err == std::ios_base::eofbit);
assert(ex == L"123456789"); assert(ex == L"123456789");
noshowbase(ios); noshowbase(ios);
} }
{ // negative, showbase { // negative, showbase
std::wstring v = L"-$1,234,567.89"; std::wstring v = L"-$1,234,567.89";
showbase(ios); showbase(ios);
typedef input_iterator<const wchar_t*> I; typedef cpp17_input_iterator<const wchar_t*> I;
std::wstring ex; std::wstring ex;
std::ios_base::iostate err = std::ios_base::goodbit; std::ios_base::iostate err = std::ios_base::goodbit;
I iter = f.get(I(v.data()), I(v.data() + v.size()), I iter = f.get(I(v.data()), I(v.data() + v.size()),
false, ios, err, ex); false, ios, err, ex);
assert(iter.base() == v.data() + v.size()); assert(iter.base() == v.data() + v.size());
assert(err == std::ios_base::eofbit); assert(err == std::ios_base::eofbit);
assert(ex == L"-123456789"); assert(ex == L"-123456789");
noshowbase(ios); noshowbase(ios);
} }
{ // negative, showbase { // negative, showbase
std::wstring v = L"-USD 1,234,567.89"; std::wstring v = L"-USD 1,234,567.89";
showbase(ios); showbase(ios);
typedef input_iterator<const wchar_t*> I; typedef cpp17_input_iterator<const wchar_t*> I;
std::wstring ex; std::wstring ex;
std::ios_base::iostate err = std::ios_base::goodbit; std::ios_base::iostate err = std::ios_base::goodbit;
I iter = f.get(I(v.data()), I(v.data() + v.size()), I iter = f.get(I(v.data()), I(v.data() + v.size()),
false, ios, err, ex); false, ios, err, ex);
assert(iter.base() == v.data() + 1); assert(iter.base() == v.data() + 1);
assert(err == std::ios_base::failbit); assert(err == std::ios_base::failbit);
assert(ex == L""); assert(ex == L"");
noshowbase(ios); noshowbase(ios);
} }
{ // negative, showbase { // negative, showbase
std::wstring v = L"-USD 1,234,567.89"; std::wstring v = L"-USD 1,234,567.89";
typedef input_iterator<const wchar_t*> I; typedef cpp17_input_iterator<const wchar_t*> I;
std::wstring ex; std::wstring ex;
std::ios_base::iostate err = std::ios_base::goodbit; std::ios_base::iostate err = std::ios_base::goodbit;
I iter = f.get(I(v.data()), I(v.data() + v.size()), I iter = f.get(I(v.data()), I(v.data() + v.size()),
false, ios, err, ex); false, ios, err, ex);
assert(iter.base() == v.data() + 1); assert(iter.base() == v.data() + 1);
assert(err == std::ios_base::failbit); assert(err == std::ios_base::failbit);
assert(ex == L""); assert(ex == L"");
} }
} }
{ {
const my_facetw f(1); const my_facetw f(1);
// wchar_t, international // wchar_t, international
{ // zero { // zero
std::wstring v = L"0.00"; std::wstring v = L"0.00";
typedef input_iterator<const wchar_t*> I; typedef cpp17_input_iterator<const wchar_t*> I;
std::wstring ex; std::wstring ex;
std::ios_base::iostate err = std::ios_base::goodbit; std::ios_base::iostate err = std::ios_base::goodbit;
I iter = f.get(I(v.data()), I(v.data() + v.size()), I iter = f.get(I(v.data()), I(v.data() + v.size()),
true, ios, err, ex); true, ios, err, ex);
assert(iter.base() == v.data() + v.size()); assert(iter.base() == v.data() + v.size());
assert(err == std::ios_base::eofbit); assert(err == std::ios_base::eofbit);
assert(ex == L"0"); assert(ex == L"0");
} }
{ // negative one { // negative one
std::wstring v = L"-0.01"; std::wstring v = L"-0.01";
typedef input_iterator<const wchar_t*> I; typedef cpp17_input_iterator<const wchar_t*> I;
std::wstring ex; std::wstring ex;
std::ios_base::iostate err = std::ios_base::goodbit; std::ios_base::iostate err = std::ios_base::goodbit;
I iter = f.get(I(v.data()), I(v.data() + v.size()), I iter = f.get(I(v.data()), I(v.data() + v.size()),
true, ios, err, ex); true, ios, err, ex);
assert(iter.base() == v.data() + v.size()); assert(iter.base() == v.data() + v.size());
assert(err == std::ios_base::eofbit); assert(err == std::ios_base::eofbit);
assert(ex == L"-1"); assert(ex == L"-1");
} }
{ // positive { // positive
std::wstring v = L"1,234,567.89"; std::wstring v = L"1,234,567.89";
typedef input_iterator<const wchar_t*> I; typedef cpp17_input_iterator<const wchar_t*> I;
std::wstring ex; std::wstring ex;
std::ios_base::iostate err = std::ios_base::goodbit; std::ios_base::iostate err = std::ios_base::goodbit;
I iter = f.get(I(v.data()), I(v.data() + v.size()), I iter = f.get(I(v.data()), I(v.data() + v.size()),
true, ios, err, ex); true, ios, err, ex);
assert(iter.base() == v.data() + v.size()); assert(iter.base() == v.data() + v.size());
assert(err == std::ios_base::eofbit); assert(err == std::ios_base::eofbit);
assert(ex == L"123456789"); assert(ex == L"123456789");
} }
{ // negative { // negative
std::wstring v = L"-1,234,567.89"; std::wstring v = L"-1,234,567.89";
typedef input_iterator<const wchar_t*> I; typedef cpp17_input_iterator<const wchar_t*> I;
std::wstring ex; std::wstring ex;
std::ios_base::iostate err = std::ios_base::goodbit; std::ios_base::iostate err = std::ios_base::goodbit;
I iter = f.get(I(v.data()), I(v.data() + v.size()), I iter = f.get(I(v.data()), I(v.data() + v.size()),
true, ios, err, ex); true, ios, err, ex);
assert(iter.base() == v.data() + v.size()); assert(iter.base() == v.data() + v.size());
assert(err == std::ios_base::eofbit); assert(err == std::ios_base::eofbit);
assert(ex == L"-123456789"); assert(ex == L"-123456789");
} }
{ // negative { // negative
std::wstring v = L"-1234567.89"; std::wstring v = L"-1234567.89";
typedef input_iterator<const wchar_t*> I; typedef cpp17_input_iterator<const wchar_t*> I;
std::wstring ex; std::wstring ex;
std::ios_base::iostate err = std::ios_base::goodbit; std::ios_base::iostate err = std::ios_base::goodbit;
I iter = f.get(I(v.data()), I(v.data() + v.size()), I iter = f.get(I(v.data()), I(v.data() + v.size()),
true, ios, err, ex); true, ios, err, ex);
assert(iter.base() == v.data() + v.size()); assert(iter.base() == v.data() + v.size());
assert(err == std::ios_base::eofbit); assert(err == std::ios_base::eofbit);
assert(ex == L"-123456789"); assert(ex == L"-123456789");
} }
{ // zero, showbase { // zero, showbase
std::wstring v = L"USD 0.00"; std::wstring v = L"USD 0.00";
typedef input_iterator<const wchar_t*> I; typedef cpp17_input_iterator<const wchar_t*> I;
std::wstring ex; std::wstring ex;
std::ios_base::iostate err = std::ios_base::goodbit; std::ios_base::iostate err = std::ios_base::goodbit;
I iter = f.get(I(v.data()), I(v.data() + v.size()), I iter = f.get(I(v.data()), I(v.data() + v.size()),
true, ios, err, ex); true, ios, err, ex);
assert(iter.base() == v.data() + v.size()); assert(iter.base() == v.data() + v.size());
assert(err == std::ios_base::eofbit); assert(err == std::ios_base::eofbit);
assert(ex == L"0"); assert(ex == L"0");
} }
{ // zero, showbase { // zero, showbase
std::wstring v = L"USD 0.00"; std::wstring v = L"USD 0.00";
showbase(ios); showbase(ios);
typedef input_iterator<const wchar_t*> I; typedef cpp17_input_iterator<const wchar_t*> I;
std::wstring ex; std::wstring ex;
std::ios_base::iostate err = std::ios_base::goodbit; std::ios_base::iostate err = std::ios_base::goodbit;
I iter = f.get(I(v.data()), I(v.data() + v.size()), I iter = f.get(I(v.data()), I(v.data() + v.size()),
true, ios, err, ex); true, ios, err, ex);
assert(iter.base() == v.data() + v.size()); assert(iter.base() == v.data() + v.size());
assert(err == std::ios_base::eofbit); assert(err == std::ios_base::eofbit);
assert(ex == L"0"); assert(ex == L"0");
noshowbase(ios); noshowbase(ios);
} }
{ // negative one, showbase { // negative one, showbase
std::wstring v = L"-USD 0.01"; std::wstring v = L"-USD 0.01";
typedef input_iterator<const wchar_t*> I; typedef cpp17_input_iterator<const wchar_t*> I;
std::wstring ex; std::wstring ex;
std::ios_base::iostate err = std::ios_base::goodbit; std::ios_base::iostate err = std::ios_base::goodbit;
I iter = f.get(I(v.data()), I(v.data() + v.size()), I iter = f.get(I(v.data()), I(v.data() + v.size()),
true, ios, err, ex); true, ios, err, ex);
assert(iter.base() == v.data() + v.size()); assert(iter.base() == v.data() + v.size());
assert(err == std::ios_base::eofbit); assert(err == std::ios_base::eofbit);
assert(ex == L"-1"); assert(ex == L"-1");
} }
{ // negative one, showbase { // negative one, showbase
std::wstring v = L"-USD 0.01"; std::wstring v = L"-USD 0.01";
showbase(ios); showbase(ios);
typedef input_iterator<const wchar_t*> I; typedef cpp17_input_iterator<const wchar_t*> I;
std::wstring ex; std::wstring ex;
std::ios_base::iostate err = std::ios_base::goodbit; std::ios_base::iostate err = std::ios_base::goodbit;
I iter = f.get(I(v.data()), I(v.data() + v.size()), I iter = f.get(I(v.data()), I(v.data() + v.size()),
true, ios, err, ex); true, ios, err, ex);
assert(iter.base() == v.data() + v.size()); assert(iter.base() == v.data() + v.size());
assert(err == std::ios_base::eofbit); assert(err == std::ios_base::eofbit);
assert(ex == L"-1"); assert(ex == L"-1");
noshowbase(ios); noshowbase(ios);
} }
{ // positive, showbase { // positive, showbase
std::wstring v = L"USD 1,234,567.89"; std::wstring v = L"USD 1,234,567.89";
typedef input_iterator<const wchar_t*> I; typedef cpp17_input_iterator<const wchar_t*> I;
std::wstring ex; std::wstring ex;
std::ios_base::iostate err = std::ios_base::goodbit; std::ios_base::iostate err = std::ios_base::goodbit;
I iter = f.get(I(v.data()), I(v.data() + v.size()), I iter = f.get(I(v.data()), I(v.data() + v.size()),
true, ios, err, ex); true, ios, err, ex);
assert(iter.base() == v.data() + v.size()); assert(iter.base() == v.data() + v.size());
assert(err == std::ios_base::eofbit); assert(err == std::ios_base::eofbit);
assert(ex == L"123456789"); assert(ex == L"123456789");
} }
{ // positive, showbase { // positive, showbase
std::wstring v = L"USD 1,234,567.89"; std::wstring v = L"USD 1,234,567.89";
showbase(ios); showbase(ios);
typedef input_iterator<const wchar_t*> I; typedef cpp17_input_iterator<const wchar_t*> I;
std::wstring ex; std::wstring ex;
std::ios_base::iostate err = std::ios_base::goodbit; std::ios_base::iostate err = std::ios_base::goodbit;
I iter = f.get(I(v.data()), I(v.data() + v.size()), I iter = f.get(I(v.data()), I(v.data() + v.size()),
true, ios, err, ex); true, ios, err, ex);
assert(iter.base() == v.data() + v.size()); assert(iter.base() == v.data() + v.size());
assert(err == std::ios_base::eofbit); assert(err == std::ios_base::eofbit);
assert(ex == L"123456789"); assert(ex == L"123456789");
noshowbase(ios); noshowbase(ios);
} }
{ // negative, showbase { // negative, showbase
std::wstring v = L"-USD 1,234,567.89"; std::wstring v = L"-USD 1,234,567.89";
showbase(ios); showbase(ios);
typedef input_iterator<const wchar_t*> I; typedef cpp17_input_iterator<const wchar_t*> I;
std::wstring ex; std::wstring ex;
std::ios_base::iostate err = std::ios_base::goodbit; std::ios_base::iostate err = std::ios_base::goodbit;
I iter = f.get(I(v.data()), I(v.data() + v.size()), I iter = f.get(I(v.data()), I(v.data() + v.size()),
true, ios, err, ex); true, ios, err, ex);
assert(iter.base() == v.data() + v.size()); assert(iter.base() == v.data() + v.size());
assert(err == std::ios_base::eofbit); assert(err == std::ios_base::eofbit);
assert(ex == L"-123456789"); assert(ex == L"-123456789");
noshowbase(ios); noshowbase(ios);
} }
{ // negative, showbase { // negative, showbase
std::wstring v = L"-$1,234,567.89"; std::wstring v = L"-$1,234,567.89";
showbase(ios); showbase(ios);
typedef input_iterator<const wchar_t*> I; typedef cpp17_input_iterator<const wchar_t*> I;
std::wstring ex; std::wstring ex;
std::ios_base::iostate err = std::ios_base::goodbit; std::ios_base::iostate err = std::ios_base::goodbit;
I iter = f.get(I(v.data()), I(v.data() + v.size()), I iter = f.get(I(v.data()), I(v.data() + v.size()),
true, ios, err, ex); true, ios, err, ex);
assert(iter.base() == v.data() + 1); assert(iter.base() == v.data() + 1);
assert(err == std::ios_base::failbit); assert(err == std::ios_base::failbit);
assert(ex == L""); assert(ex == L"");
noshowbase(ios); noshowbase(ios);
} }
{ // negative, showbase { // negative, showbase
std::wstring v = L"-$1,234,567.89"; std::wstring v = L"-$1,234,567.89";
typedef input_iterator<const wchar_t*> I; typedef cpp17_input_iterator<const wchar_t*> I;
std::wstring ex; std::wstring ex;
std::ios_base::iostate err = std::ios_base::goodbit; std::ios_base::iostate err = std::ios_base::goodbit;
I iter = f.get(I(v.data()), I(v.data() + v.size()), I iter = f.get(I(v.data()), I(v.data() + v.size()),
true, ios, err, ex); true, ios, err, ex);
assert(iter.base() == v.data() + 1); assert(iter.base() == v.data() + 1);
assert(err == std::ios_base::failbit); assert(err == std::ios_base::failbit);
assert(ex == L""); assert(ex == L"");
} }
} }
return 0; return 0;
} }

libcxx/test/std/localization/locale.categories/category.numeric/locale.num.get/facet.num.get.members/get_bool.pass.cpp

Show All 14 Lines
#include <locale> #include <locale>
#include <ios> #include <ios>
#include <cassert> #include <cassert>
#include <streambuf> #include <streambuf>
#include "test_macros.h" #include "test_macros.h"
#include "test_iterators.h" #include "test_iterators.h"
typedef std::num_get<char, input_iterator<const char*> > F; typedef std::num_get<char, cpp17_input_iterator<const char*> > F;
class my_facet class my_facet
: public F : public F
{ {
public: public:
explicit my_facet(std::size_t refs = 0) explicit my_facet(std::size_t refs = 0)
: F(refs) {} : F(refs) {}
}; };
Show All 23 Lines
int main(int, char**) int main(int, char**)
{ {
const my_facet f(1); const my_facet f(1);
std::ios ios(0); std::ios ios(0);
{ {
const char str[] = "1"; const char str[] = "1";
std::ios_base::iostate err = ios.goodbit; std::ios_base::iostate err = ios.goodbit;
bool b; bool b;
input_iterator<const char*> iter = cpp17_input_iterator<const char*> iter =
f.get(input_iterator<const char*>(str), f.get(cpp17_input_iterator<const char*>(str),
input_iterator<const char*>(str+sizeof(str)), cpp17_input_iterator<const char*>(str+sizeof(str)),
ios, err, b); ios, err, b);
assert(iter.base() == str+sizeof(str)-1); assert(iter.base() == str+sizeof(str)-1);
assert(err == ios.goodbit); assert(err == ios.goodbit);
assert(b == true); assert(b == true);
} }
{ {
const char str[] = "0"; const char str[] = "0";
std::ios_base::iostate err = ios.goodbit; std::ios_base::iostate err = ios.goodbit;
bool b; bool b;
input_iterator<const char*> iter = cpp17_input_iterator<const char*> iter =
f.get(input_iterator<const char*>(str), f.get(cpp17_input_iterator<const char*>(str),
input_iterator<const char*>(str+sizeof(str)), cpp17_input_iterator<const char*>(str+sizeof(str)),
ios, err, b); ios, err, b);
assert(iter.base() == str+sizeof(str)-1); assert(iter.base() == str+sizeof(str)-1);
assert(err == ios.goodbit); assert(err == ios.goodbit);
assert(b == false); assert(b == false);
} }
{ {
const char str[] = "12"; const char str[] = "12";
std::ios_base::iostate err = ios.goodbit; std::ios_base::iostate err = ios.goodbit;
bool b; bool b;
input_iterator<const char*> iter = cpp17_input_iterator<const char*> iter =
f.get(input_iterator<const char*>(str), f.get(cpp17_input_iterator<const char*>(str),
input_iterator<const char*>(str+sizeof(str)), cpp17_input_iterator<const char*>(str+sizeof(str)),
ios, err, b); ios, err, b);
assert(iter.base() == str+sizeof(str)-1); assert(iter.base() == str+sizeof(str)-1);
assert(err == ios.failbit); assert(err == ios.failbit);
assert(b == true); assert(b == true);
} }
{ {
const char str[] = "*12"; const char str[] = "*12";
std::ios_base::iostate err = ios.goodbit; std::ios_base::iostate err = ios.goodbit;
bool b; bool b;
input_iterator<const char*> iter = cpp17_input_iterator<const char*> iter =
f.get(input_iterator<const char*>(str), f.get(cpp17_input_iterator<const char*>(str),
input_iterator<const char*>(str+sizeof(str)), cpp17_input_iterator<const char*>(str+sizeof(str)),
ios, err, b); ios, err, b);
assert(iter.base() == str+0); assert(iter.base() == str+0);
assert(err == ios.failbit); assert(err == ios.failbit);
assert(b == false); assert(b == false);
} }
boolalpha(ios); boolalpha(ios);
{ {
const char str[] = "1"; const char str[] = "1";
std::ios_base::iostate err = ios.goodbit; std::ios_base::iostate err = ios.goodbit;
bool b; bool b;
input_iterator<const char*> iter = cpp17_input_iterator<const char*> iter =
f.get(input_iterator<const char*>(str), f.get(cpp17_input_iterator<const char*>(str),
input_iterator<const char*>(str+sizeof(str)), cpp17_input_iterator<const char*>(str+sizeof(str)),
ios, err, b); ios, err, b);
assert(iter.base() == str+0); assert(iter.base() == str+0);
assert(err == ios.failbit); assert(err == ios.failbit);
assert(b == false); assert(b == false);
} }
{ {
const char str[] = "true"; const char str[] = "true";
std::ios_base::iostate err = ios.goodbit; std::ios_base::iostate err = ios.goodbit;
bool b; bool b;
input_iterator<const char*> iter = cpp17_input_iterator<const char*> iter =
f.get(input_iterator<const char*>(str), f.get(cpp17_input_iterator<const char*>(str),
input_iterator<const char*>(str+sizeof(str)), cpp17_input_iterator<const char*>(str+sizeof(str)),
ios, err, b); ios, err, b);
assert(iter.base() == str+sizeof(str)-1); assert(iter.base() == str+sizeof(str)-1);
assert(err == ios.goodbit); assert(err == ios.goodbit);
assert(b == true); assert(b == true);
} }
{ {
const char str[] = "false"; const char str[] = "false";
std::ios_base::iostate err = ios.goodbit; std::ios_base::iostate err = ios.goodbit;
bool b; bool b;
input_iterator<const char*> iter = cpp17_input_iterator<const char*> iter =
f.get(input_iterator<const char*>(str), f.get(cpp17_input_iterator<const char*>(str),
input_iterator<const char*>(str+sizeof(str)), cpp17_input_iterator<const char*>(str+sizeof(str)),
ios, err, b); ios, err, b);
assert(iter.base() == str+sizeof(str)-1); assert(iter.base() == str+sizeof(str)-1);
assert(err == ios.goodbit); assert(err == ios.goodbit);
assert(b == false); assert(b == false);
} }
ios.imbue(std::locale(ios.getloc(), new p1)); ios.imbue(std::locale(ios.getloc(), new p1));
{ {
const char str[] = "a"; const char str[] = "a";
std::ios_base::iostate err = ios.goodbit; std::ios_base::iostate err = ios.goodbit;
bool b; bool b;
input_iterator<const char*> iter = cpp17_input_iterator<const char*> iter =
f.get(input_iterator<const char*>(str), f.get(cpp17_input_iterator<const char*>(str),
input_iterator<const char*>(str+1), cpp17_input_iterator<const char*>(str+1),
ios, err, b); ios, err, b);
assert(iter.base() == str+1); assert(iter.base() == str+1);
assert(err == ios.eofbit); assert(err == ios.eofbit);
assert(b == true); assert(b == true);
} }
{ {
const char str[] = "abc"; const char str[] = "abc";
std::ios_base::iostate err = ios.goodbit; std::ios_base::iostate err = ios.goodbit;
bool b; bool b;
input_iterator<const char*> iter = cpp17_input_iterator<const char*> iter =
f.get(input_iterator<const char*>(str), f.get(cpp17_input_iterator<const char*>(str),
input_iterator<const char*>(str+3), cpp17_input_iterator<const char*>(str+3),
ios, err, b); ios, err, b);
assert(iter.base() == str+2); assert(iter.base() == str+2);
assert(err == ios.failbit); assert(err == ios.failbit);
assert(b == false); assert(b == false);
} }
{ {
const char str[] = "acc"; const char str[] = "acc";
std::ios_base::iostate err = ios.goodbit; std::ios_base::iostate err = ios.goodbit;
bool b; bool b;
input_iterator<const char*> iter = cpp17_input_iterator<const char*> iter =
f.get(input_iterator<const char*>(str), f.get(cpp17_input_iterator<const char*>(str),
input_iterator<const char*>(str+3), cpp17_input_iterator<const char*>(str+3),
ios, err, b); ios, err, b);
assert(iter.base() == str+1); assert(iter.base() == str+1);
assert(err == ios.goodbit); assert(err == ios.goodbit);
assert(b == true); assert(b == true);
} }
ios.imbue(std::locale(ios.getloc(), new p2)); ios.imbue(std::locale(ios.getloc(), new p2));
{ {
const char str[] = "a"; const char str[] = "a";
std::ios_base::iostate err = ios.goodbit; std::ios_base::iostate err = ios.goodbit;
bool b; bool b;
input_iterator<const char*> iter = cpp17_input_iterator<const char*> iter =
f.get(input_iterator<const char*>(str), f.get(cpp17_input_iterator<const char*>(str),
input_iterator<const char*>(str+1), cpp17_input_iterator<const char*>(str+1),
ios, err, b); ios, err, b);
assert(iter.base() == str+1); assert(iter.base() == str+1);
assert(err == ios.eofbit); assert(err == ios.eofbit);
assert(b == true); assert(b == true);
} }
{ {
const char str[] = "ab"; const char str[] = "ab";
std::ios_base::iostate err = ios.goodbit; std::ios_base::iostate err = ios.goodbit;
bool b; bool b;
input_iterator<const char*> iter = cpp17_input_iterator<const char*> iter =
f.get(input_iterator<const char*>(str), f.get(cpp17_input_iterator<const char*>(str),
input_iterator<const char*>(str+2), cpp17_input_iterator<const char*>(str+2),
ios, err, b); ios, err, b);
assert(iter.base() == str+2); assert(iter.base() == str+2);
assert(err == ios.eofbit); assert(err == ios.eofbit);
assert(b == false); assert(b == false);
} }
{ {
const char str[] = "abc"; const char str[] = "abc";
std::ios_base::iostate err = ios.goodbit; std::ios_base::iostate err = ios.goodbit;
bool b; bool b;
input_iterator<const char*> iter = cpp17_input_iterator<const char*> iter =
f.get(input_iterator<const char*>(str), f.get(cpp17_input_iterator<const char*>(str),
input_iterator<const char*>(str+3), cpp17_input_iterator<const char*>(str+3),
ios, err, b); ios, err, b);
assert(iter.base() == str+2); assert(iter.base() == str+2);
assert(err == ios.goodbit); assert(err == ios.goodbit);
assert(b == false); assert(b == false);
} }
{ {
const char str[] = "ac"; const char str[] = "ac";
std::ios_base::iostate err = ios.goodbit; std::ios_base::iostate err = ios.goodbit;
bool b; bool b;
input_iterator<const char*> iter = cpp17_input_iterator<const char*> iter =
f.get(input_iterator<const char*>(str), f.get(cpp17_input_iterator<const char*>(str),
input_iterator<const char*>(str+2), cpp17_input_iterator<const char*>(str+2),
ios, err, b); ios, err, b);
assert(iter.base() == str+1); assert(iter.base() == str+1);
assert(err == ios.goodbit); assert(err == ios.goodbit);
assert(b == true); assert(b == true);
} }
return 0; return 0;
} }

libcxx/test/std/localization/locale.categories/category.numeric/locale.num.get/facet.num.get.members/get_double.pass.cpp

Show All 16 Lines
#include <ios> #include <ios>
#include <cassert> #include <cassert>
#include <streambuf> #include <streambuf>
#include <cmath> #include <cmath>
#include "test_macros.h" #include "test_macros.h"
#include "test_iterators.h" #include "test_iterators.h"
#include "hexfloat.h" #include "hexfloat.h"
typedef std::num_get<char, input_iterator<const char*> > F; typedef std::num_get<char, cpp17_input_iterator<const char*> > F;
class my_facet class my_facet
: public F : public F
{ {
public: public:
explicit my_facet(std::size_t refs = 0) explicit my_facet(std::size_t refs = 0)
: F(refs) {} : F(refs) {}
}; };
Show All 15 Linesint main(int, char**)
const my_facet f(1); const my_facet f(1);
std::ios ios(0); std::ios ios(0);
double v = -1; double v = -1;
{ {
const char str[] = "123"; const char str[] = "123";
assert((ios.flags() & ios.basefield) == ios.dec); assert((ios.flags() & ios.basefield) == ios.dec);
assert(ios.getloc().name() == "C"); assert(ios.getloc().name() == "C");
std::ios_base::iostate err = ios.goodbit; std::ios_base::iostate err = ios.goodbit;
input_iterator<const char*> iter = cpp17_input_iterator<const char*> iter =
f.get(input_iterator<const char*>(str), f.get(cpp17_input_iterator<const char*>(str),
input_iterator<const char*>(str+sizeof(str)), cpp17_input_iterator<const char*>(str+sizeof(str)),
ios, err, v); ios, err, v);
assert(iter.base() == str+sizeof(str)-1); assert(iter.base() == str+sizeof(str)-1);
assert(err == ios.goodbit); assert(err == ios.goodbit);
assert(v == 123); assert(v == 123);
} }
{ {
const char str[] = "-123"; const char str[] = "-123";
std::ios_base::iostate err = ios.goodbit; std::ios_base::iostate err = ios.goodbit;
input_iterator<const char*> iter = cpp17_input_iterator<const char*> iter =
f.get(input_iterator<const char*>(str), f.get(cpp17_input_iterator<const char*>(str),
input_iterator<const char*>(str+sizeof(str)), cpp17_input_iterator<const char*>(str+sizeof(str)),
ios, err, v); ios, err, v);
assert(iter.base() == str+sizeof(str)-1); assert(iter.base() == str+sizeof(str)-1);
assert(err == ios.goodbit); assert(err == ios.goodbit);
assert(v == -123); assert(v == -123);
} }
{ {
const char str[] = "123.5"; const char str[] = "123.5";
std::ios_base::iostate err = ios.goodbit; std::ios_base::iostate err = ios.goodbit;
input_iterator<const char*> iter = cpp17_input_iterator<const char*> iter =
f.get(input_iterator<const char*>(str), f.get(cpp17_input_iterator<const char*>(str),
input_iterator<const char*>(str+sizeof(str)), cpp17_input_iterator<const char*>(str+sizeof(str)),
ios, err, v); ios, err, v);
assert(iter.base() == str+sizeof(str)-1); assert(iter.base() == str+sizeof(str)-1);
assert(err == ios.goodbit); assert(err == ios.goodbit);
assert(v == 123.5); assert(v == 123.5);
} }
{ {
const char str[] = "125e-1"; const char str[] = "125e-1";
hex(ios); hex(ios);
std::ios_base::iostate err = ios.goodbit; std::ios_base::iostate err = ios.goodbit;
input_iterator<const char*> iter = cpp17_input_iterator<const char*> iter =
f.get(input_iterator<const char*>(str), f.get(cpp17_input_iterator<const char*>(str),
input_iterator<const char*>(str+sizeof(str)), cpp17_input_iterator<const char*>(str+sizeof(str)),
ios, err, v); ios, err, v);
assert(iter.base() == str+sizeof(str)-1); assert(iter.base() == str+sizeof(str)-1);
assert(err == ios.goodbit); assert(err == ios.goodbit);
assert(v == 125e-1); assert(v == 125e-1);
} }
{ {
const char str[] = "0x125p-1"; const char str[] = "0x125p-1";
hex(ios); hex(ios);
std::ios_base::iostate err = ios.goodbit; std::ios_base::iostate err = ios.goodbit;
input_iterator<const char*> iter = cpp17_input_iterator<const char*> iter =
f.get(input_iterator<const char*>(str), f.get(cpp17_input_iterator<const char*>(str),
input_iterator<const char*>(str+sizeof(str)), cpp17_input_iterator<const char*>(str+sizeof(str)),
ios, err, v); ios, err, v);
assert(iter.base() == str+sizeof(str)-1); assert(iter.base() == str+sizeof(str)-1);
assert(err == ios.goodbit); assert(err == ios.goodbit);
assert(v == hexfloat<double>(0x125, 0, -1)); assert(v == hexfloat<double>(0x125, 0, -1));
} }
{ {
const char str[] = "inf"; const char str[] = "inf";
hex(ios); hex(ios);
std::ios_base::iostate err = ios.goodbit; std::ios_base::iostate err = ios.goodbit;
input_iterator<const char*> iter = cpp17_input_iterator<const char*> iter =
f.get(input_iterator<const char*>(str), f.get(cpp17_input_iterator<const char*>(str),
input_iterator<const char*>(str+sizeof(str)), cpp17_input_iterator<const char*>(str+sizeof(str)),
ios, err, v); ios, err, v);
assert(iter.base() == str+sizeof(str)-1); assert(iter.base() == str+sizeof(str)-1);
assert(err == ios.goodbit); assert(err == ios.goodbit);
assert(v == INFINITY); assert(v == INFINITY);
} }
{ {
const char str[] = "INF"; const char str[] = "INF";
hex(ios); hex(ios);
std::ios_base::iostate err = ios.goodbit; std::ios_base::iostate err = ios.goodbit;
input_iterator<const char*> iter = cpp17_input_iterator<const char*> iter =
f.get(input_iterator<const char*>(str), f.get(cpp17_input_iterator<const char*>(str),
input_iterator<const char*>(str+sizeof(str)), cpp17_input_iterator<const char*>(str+sizeof(str)),
ios, err, v); ios, err, v);
assert(iter.base() == str+sizeof(str)-1); assert(iter.base() == str+sizeof(str)-1);
assert(err == ios.goodbit); assert(err == ios.goodbit);
assert(v == INFINITY); assert(v == INFINITY);
} }
{ {
const char str[] = "-inf"; const char str[] = "-inf";
hex(ios); hex(ios);
std::ios_base::iostate err = ios.goodbit; std::ios_base::iostate err = ios.goodbit;
input_iterator<const char*> iter = cpp17_input_iterator<const char*> iter =
f.get(input_iterator<const char*>(str), f.get(cpp17_input_iterator<const char*>(str),
input_iterator<const char*>(str+sizeof(str)), cpp17_input_iterator<const char*>(str+sizeof(str)),
ios, err, v); ios, err, v);
assert(iter.base() == str+sizeof(str)-1); assert(iter.base() == str+sizeof(str)-1);
assert(err == ios.goodbit); assert(err == ios.goodbit);
assert(v == -INFINITY); assert(v == -INFINITY);
} }
{ {
const char str[] = "-INF"; const char str[] = "-INF";
hex(ios); hex(ios);
std::ios_base::iostate err = ios.goodbit; std::ios_base::iostate err = ios.goodbit;
input_iterator<const char*> iter = cpp17_input_iterator<const char*> iter =
f.get(input_iterator<const char*>(str), f.get(cpp17_input_iterator<const char*>(str),
input_iterator<const char*>(str+sizeof(str)), cpp17_input_iterator<const char*>(str+sizeof(str)),
ios, err, v); ios, err, v);
assert(iter.base() == str+sizeof(str)-1); assert(iter.base() == str+sizeof(str)-1);
assert(err == ios.goodbit); assert(err == ios.goodbit);
assert(v == -INFINITY); assert(v == -INFINITY);
} }
{ {
const char str[] = "nan"; const char str[] = "nan";
hex(ios); hex(ios);
std::ios_base::iostate err = ios.goodbit; std::ios_base::iostate err = ios.goodbit;
input_iterator<const char*> iter = cpp17_input_iterator<const char*> iter =
f.get(input_iterator<const char*>(str), f.get(cpp17_input_iterator<const char*>(str),
input_iterator<const char*>(str+sizeof(str)), cpp17_input_iterator<const char*>(str+sizeof(str)),
ios, err, v); ios, err, v);
assert(iter.base() == str+sizeof(str)-1); assert(iter.base() == str+sizeof(str)-1);
assert(err == ios.goodbit); assert(err == ios.goodbit);
assert(std::isnan(v)); assert(std::isnan(v));
} }
{ {
const char str[] = "NAN"; const char str[] = "NAN";
hex(ios); hex(ios);
std::ios_base::iostate err = ios.goodbit; std::ios_base::iostate err = ios.goodbit;
input_iterator<const char*> iter = cpp17_input_iterator<const char*> iter =
f.get(input_iterator<const char*>(str), f.get(cpp17_input_iterator<const char*>(str),
input_iterator<const char*>(str+sizeof(str)), cpp17_input_iterator<const char*>(str+sizeof(str)),
ios, err, v); ios, err, v);
assert(iter.base() == str+sizeof(str)-1); assert(iter.base() == str+sizeof(str)-1);
assert(err == ios.goodbit); assert(err == ios.goodbit);
assert(std::isnan(v)); assert(std::isnan(v));
} }
{ {
v = -1; v = -1;
const char str[] = "123_456_78_9;125"; const char str[] = "123_456_78_9;125";
std::ios_base::iostate err = ios.goodbit; std::ios_base::iostate err = ios.goodbit;
input_iterator<const char*> iter = cpp17_input_iterator<const char*> iter =
f.get(input_iterator<const char*>(str), f.get(cpp17_input_iterator<const char*>(str),
input_iterator<const char*>(str+sizeof(str)), cpp17_input_iterator<const char*>(str+sizeof(str)),
ios, err, v); ios, err, v);
assert(iter.base() == str+3); assert(iter.base() == str+3);
assert(err == ios.goodbit); assert(err == ios.goodbit);
assert(v == 123); assert(v == 123);
} }
{ {
// See PR11871 // See PR11871
v = -1; v = -1;
const char str[] = "2-"; const char str[] = "2-";
std::ios_base::iostate err = ios.goodbit; std::ios_base::iostate err = ios.goodbit;
input_iterator<const char*> iter = cpp17_input_iterator<const char*> iter =
f.get(input_iterator<const char*>(str), f.get(cpp17_input_iterator<const char*>(str),
input_iterator<const char*>(str+sizeof(str)), cpp17_input_iterator<const char*>(str+sizeof(str)),
ios, err, v); ios, err, v);
assert(iter.base() == str+1); assert(iter.base() == str+1);
assert(err == ios.goodbit); assert(err == ios.goodbit);
assert(v == 2); assert(v == 2);
} }
{ {
v = -1; v = -1;
const char str[] = "1.79779e+309"; // unrepresentable const char str[] = "1.79779e+309"; // unrepresentable
std::ios_base::iostate err = ios.goodbit; std::ios_base::iostate err = ios.goodbit;
input_iterator<const char*> iter = cpp17_input_iterator<const char*> iter =
f.get(input_iterator<const char*>(str), f.get(cpp17_input_iterator<const char*>(str),
input_iterator<const char*>(str+sizeof(str)), cpp17_input_iterator<const char*>(str+sizeof(str)),
ios, err, v); ios, err, v);
assert(iter.base() == str+sizeof(str)-1); assert(iter.base() == str+sizeof(str)-1);
assert(err == ios.failbit); assert(err == ios.failbit);
assert(v == HUGE_VAL); assert(v == HUGE_VAL);
} }
{ {
v = -1; v = -1;
const char str[] = "-1.79779e+308"; // unrepresentable const char str[] = "-1.79779e+308"; // unrepresentable
std::ios_base::iostate err = ios.goodbit; std::ios_base::iostate err = ios.goodbit;
input_iterator<const char*> iter = cpp17_input_iterator<const char*> iter =
f.get(input_iterator<const char*>(str), f.get(cpp17_input_iterator<const char*>(str),
input_iterator<const char*>(str+sizeof(str)), cpp17_input_iterator<const char*>(str+sizeof(str)),
ios, err, v); ios, err, v);
assert(iter.base() == str+sizeof(str)-1); assert(iter.base() == str+sizeof(str)-1);
assert(err == ios.failbit); assert(err == ios.failbit);
assert(v == -HUGE_VAL); assert(v == -HUGE_VAL);
} }
ios.imbue(std::locale(std::locale(), new my_numpunct)); ios.imbue(std::locale(std::locale(), new my_numpunct));
{ {
v = -1; v = -1;
const char str[] = "123_456_78_9;125"; const char str[] = "123_456_78_9;125";
std::ios_base::iostate err = ios.goodbit; std::ios_base::iostate err = ios.goodbit;
input_iterator<const char*> iter = cpp17_input_iterator<const char*> iter =
f.get(input_iterator<const char*>(str), f.get(cpp17_input_iterator<const char*>(str),
input_iterator<const char*>(str+sizeof(str)), cpp17_input_iterator<const char*>(str+sizeof(str)),
ios, err, v); ios, err, v);
assert(iter.base() == str+sizeof(str)-1); assert(iter.base() == str+sizeof(str)-1);
assert(err == ios.goodbit); assert(err == ios.goodbit);
assert(v == 123456789.125); assert(v == 123456789.125);
} }
{ {
v = -1; v = -1;
const char str[] = "1_2_3_4_5_6_7_8_9_0_1_2_3_4_5_6_7_8_9_0_1_2_3_4_5_6_7_8_9_0_" const char str[] = "1_2_3_4_5_6_7_8_9_0_1_2_3_4_5_6_7_8_9_0_1_2_3_4_5_6_7_8_9_0_"
"1_2_3_4_5_6_7_8_9_0_1_2_3_4_5_6_7_8_9_0_1_2_3_4_5_6_7_8_9_0_" "1_2_3_4_5_6_7_8_9_0_1_2_3_4_5_6_7_8_9_0_1_2_3_4_5_6_7_8_9_0_"
"1_2_3_4_5_6_7_8_9_0_1_2_3_4_5_6_7_8_9_0_1_2_3_4_5_6_7_8_9_0_" "1_2_3_4_5_6_7_8_9_0_1_2_3_4_5_6_7_8_9_0_1_2_3_4_5_6_7_8_9_0_"
"1_2_3_4_5_6_7_8_9_0_1_2_3_4_5_6_7_8_9_0_1_2_3_4_5_6_7_8_9_0_" "1_2_3_4_5_6_7_8_9_0_1_2_3_4_5_6_7_8_9_0_1_2_3_4_5_6_7_8_9_0_"
"1_2_3_4_5_6_7_8_9_0_1_2_3_4_5_6_7_8_9_0_1_2_3_4_5_6_7_8_9_0_" "1_2_3_4_5_6_7_8_9_0_1_2_3_4_5_6_7_8_9_0_1_2_3_4_5_6_7_8_9_0_"
"1_2_3_4_5_6_7_8_9_0_1_2_3_4_5_6_7_8_9_0_1_2_3_4_5_6_7_8_9_0_" "1_2_3_4_5_6_7_8_9_0_1_2_3_4_5_6_7_8_9_0_1_2_3_4_5_6_7_8_9_0_"
"1_2_3_4_5_6_7_8_9_0_1_2_3_4_5_6_7_8_9_0_1_2_3_4_5_6_7_8_9_0_" "1_2_3_4_5_6_7_8_9_0_1_2_3_4_5_6_7_8_9_0_1_2_3_4_5_6_7_8_9_0_"
"1_2_3_4_5_6_7_8_9_0_1_2_3_4_5_6_7_8_9_0_1_2_3_4_5_6_7_8_9_0_" "1_2_3_4_5_6_7_8_9_0_1_2_3_4_5_6_7_8_9_0_1_2_3_4_5_6_7_8_9_0_"
"1_2_3_4_5_6_7_8_9_0_1_2_3_4_5_6_7_8_9_0_1_2_3_4_5_6_7_8_9_0_" "1_2_3_4_5_6_7_8_9_0_1_2_3_4_5_6_7_8_9_0_1_2_3_4_5_6_7_8_9_0_"
"1_2_3_4_5_6_7_8_9_0_1_2_3_4_5_6_7_8_9_0_1_2_3_4_5_6_7_8_9_0_" "1_2_3_4_5_6_7_8_9_0_1_2_3_4_5_6_7_8_9_0_1_2_3_4_5_6_7_8_9_0_"
"1_2_3_4_5_6_7_8_9_0_1_2_3_4_5_6_7_8_9_0_1_2_3_4_5_6_7_8_9_0_"; "1_2_3_4_5_6_7_8_9_0_1_2_3_4_5_6_7_8_9_0_1_2_3_4_5_6_7_8_9_0_";
std::ios_base::iostate err = ios.goodbit; std::ios_base::iostate err = ios.goodbit;
input_iterator<const char*> iter = cpp17_input_iterator<const char*> iter =
f.get(input_iterator<const char*>(str), f.get(cpp17_input_iterator<const char*>(str),
input_iterator<const char*>(str+sizeof(str)), cpp17_input_iterator<const char*>(str+sizeof(str)),
ios, err, v); ios, err, v);
assert(iter.base() == str+sizeof(str)-1); assert(iter.base() == str+sizeof(str)-1);
assert(err == ios.failbit); assert(err == ios.failbit);
} }
{ {
// See PR15445 // See PR15445
v = -1; v = -1;
const char str[] = "3;14159265358979323846264338327950288419716939937510582097494459230781640628620899862803482534211706798214808651e+10"; const char str[] = "3;14159265358979323846264338327950288419716939937510582097494459230781640628620899862803482534211706798214808651e+10";
std::ios_base::iostate err = ios.goodbit; std::ios_base::iostate err = ios.goodbit;
input_iterator<const char*> iter = cpp17_input_iterator<const char*> iter =
f.get(input_iterator<const char*>(str), f.get(cpp17_input_iterator<const char*>(str),
input_iterator<const char*>(str+sizeof(str)), cpp17_input_iterator<const char*>(str+sizeof(str)),
ios, err, v); ios, err, v);
assert(iter.base() == str+sizeof(str)-1); assert(iter.base() == str+sizeof(str)-1);
assert(err == ios.goodbit); assert(err == ios.goodbit);
assert(std::abs(v - 3.14159265358979e+10)/3.14159265358979e+10 < 1.e-8); assert(std::abs(v - 3.14159265358979e+10)/3.14159265358979e+10 < 1.e-8);
} }
return 0; return 0;
} }

libcxx/test/std/localization/locale.categories/category.numeric/locale.num.get/facet.num.get.members/get_float.pass.cpp

Show All 16 Lines
#include <ios> #include <ios>
#include <cassert> #include <cassert>
#include <streambuf> #include <streambuf>
#include <cmath> #include <cmath>
#include "test_macros.h" #include "test_macros.h"
#include "test_iterators.h" #include "test_iterators.h"
#include "hexfloat.h" #include "hexfloat.h"
typedef std::num_get<char, input_iterator<const char*> > F; typedef std::num_get<char, cpp17_input_iterator<const char*> > F;
class my_facet class my_facet
: public F : public F
{ {
public: public:
explicit my_facet(std::size_t refs = 0) explicit my_facet(std::size_t refs = 0)
: F(refs) {} : F(refs) {}
}; };
int main(int, char**) int main(int, char**)
{ {
const my_facet f(1); const my_facet f(1);
std::ios ios(0); std::ios ios(0);
float v = -1; float v = -1;
{ {
const char str[] = "123"; const char str[] = "123";
assert((ios.flags() & ios.basefield) == ios.dec); assert((ios.flags() & ios.basefield) == ios.dec);
assert(ios.getloc().name() == "C"); assert(ios.getloc().name() == "C");
std::ios_base::iostate err = ios.goodbit; std::ios_base::iostate err = ios.goodbit;
input_iterator<const char*> iter = cpp17_input_iterator<const char*> iter =
f.get(input_iterator<const char*>(str), f.get(cpp17_input_iterator<const char*>(str),
input_iterator<const char*>(str+sizeof(str)), cpp17_input_iterator<const char*>(str+sizeof(str)),
ios, err, v); ios, err, v);
assert(iter.base() == str+sizeof(str)-1); assert(iter.base() == str+sizeof(str)-1);
assert(err == ios.goodbit); assert(err == ios.goodbit);
assert(v == 123); assert(v == 123);
} }
{ {
const char str[] = "-123"; const char str[] = "-123";
std::ios_base::iostate err = ios.goodbit; std::ios_base::iostate err = ios.goodbit;
input_iterator<const char*> iter = cpp17_input_iterator<const char*> iter =
f.get(input_iterator<const char*>(str), f.get(cpp17_input_iterator<const char*>(str),
input_iterator<const char*>(str+sizeof(str)), cpp17_input_iterator<const char*>(str+sizeof(str)),
ios, err, v); ios, err, v);
assert(iter.base() == str+sizeof(str)-1); assert(iter.base() == str+sizeof(str)-1);
assert(err == ios.goodbit); assert(err == ios.goodbit);
assert(v == -123); assert(v == -123);
} }
{ {
const char str[] = "123.5"; const char str[] = "123.5";
std::ios_base::iostate err = ios.goodbit; std::ios_base::iostate err = ios.goodbit;
input_iterator<const char*> iter = cpp17_input_iterator<const char*> iter =
f.get(input_iterator<const char*>(str), f.get(cpp17_input_iterator<const char*>(str),
input_iterator<const char*>(str+sizeof(str)), cpp17_input_iterator<const char*>(str+sizeof(str)),
ios, err, v); ios, err, v);
assert(iter.base() == str+sizeof(str)-1); assert(iter.base() == str+sizeof(str)-1);
assert(err == ios.goodbit); assert(err == ios.goodbit);
assert(v == 123.5); assert(v == 123.5);
} }
{ {
const char str[] = "125e-1"; const char str[] = "125e-1";
hex(ios); hex(ios);
std::ios_base::iostate err = ios.goodbit; std::ios_base::iostate err = ios.goodbit;
input_iterator<const char*> iter = cpp17_input_iterator<const char*> iter =
f.get(input_iterator<const char*>(str), f.get(cpp17_input_iterator<const char*>(str),
input_iterator<const char*>(str+sizeof(str)), cpp17_input_iterator<const char*>(str+sizeof(str)),
ios, err, v); ios, err, v);
assert(iter.base() == str+sizeof(str)-1); assert(iter.base() == str+sizeof(str)-1);
assert(err == ios.goodbit); assert(err == ios.goodbit);
assert(v == 125e-1); assert(v == 125e-1);
} }
{ {
const char str[] = "0x125p-1"; const char str[] = "0x125p-1";
hex(ios); hex(ios);
std::ios_base::iostate err = ios.goodbit; std::ios_base::iostate err = ios.goodbit;
input_iterator<const char*> iter = cpp17_input_iterator<const char*> iter =
f.get(input_iterator<const char*>(str), f.get(cpp17_input_iterator<const char*>(str),
input_iterator<const char*>(str+sizeof(str)), cpp17_input_iterator<const char*>(str+sizeof(str)),
ios, err, v); ios, err, v);
assert(iter.base() == str+sizeof(str)-1); assert(iter.base() == str+sizeof(str)-1);
assert(err == ios.goodbit); assert(err == ios.goodbit);
assert(v == hexfloat<float>(0x125, 0, -1)); assert(v == hexfloat<float>(0x125, 0, -1));
} }
{ {
const char str[] = "inf"; const char str[] = "inf";
hex(ios); hex(ios);
std::ios_base::iostate err = ios.goodbit; std::ios_base::iostate err = ios.goodbit;
input_iterator<const char*> iter = cpp17_input_iterator<const char*> iter =
f.get(input_iterator<const char*>(str), f.get(cpp17_input_iterator<const char*>(str),
input_iterator<const char*>(str+sizeof(str)), cpp17_input_iterator<const char*>(str+sizeof(str)),
ios, err, v); ios, err, v);
assert(iter.base() == str+sizeof(str)-1); assert(iter.base() == str+sizeof(str)-1);
assert(err == ios.goodbit); assert(err == ios.goodbit);
assert(v == INFINITY); assert(v == INFINITY);
} }
{ {
const char str[] = "INF"; const char str[] = "INF";
hex(ios); hex(ios);
std::ios_base::iostate err = ios.goodbit; std::ios_base::iostate err = ios.goodbit;
input_iterator<const char*> iter = cpp17_input_iterator<const char*> iter =
f.get(input_iterator<const char*>(str), f.get(cpp17_input_iterator<const char*>(str),
input_iterator<const char*>(str+sizeof(str)), cpp17_input_iterator<const char*>(str+sizeof(str)),
ios, err, v); ios, err, v);
assert(iter.base() == str+sizeof(str)-1); assert(iter.base() == str+sizeof(str)-1);
assert(err == ios.goodbit); assert(err == ios.goodbit);
assert(v == INFINITY); assert(v == INFINITY);
} }
{ {
const char str[] = "-inf"; const char str[] = "-inf";
hex(ios); hex(ios);
std::ios_base::iostate err = ios.goodbit; std::ios_base::iostate err = ios.goodbit;
input_iterator<const char*> iter = cpp17_input_iterator<const char*> iter =
f.get(input_iterator<const char*>(str), f.get(cpp17_input_iterator<const char*>(str),
input_iterator<const char*>(str+sizeof(str)), cpp17_input_iterator<const char*>(str+sizeof(str)),
ios, err, v); ios, err, v);
assert(iter.base() == str+sizeof(str)-1); assert(iter.base() == str+sizeof(str)-1);
assert(err == ios.goodbit); assert(err == ios.goodbit);
assert(v == -INFINITY); assert(v == -INFINITY);
} }
{ {
const char str[] = "-INF"; const char str[] = "-INF";
hex(ios); hex(ios);
std::ios_base::iostate err = ios.goodbit; std::ios_base::iostate err = ios.goodbit;
input_iterator<const char*> iter = cpp17_input_iterator<const char*> iter =
f.get(input_iterator<const char*>(str), f.get(cpp17_input_iterator<const char*>(str),
input_iterator<const char*>(str+sizeof(str)), cpp17_input_iterator<const char*>(str+sizeof(str)),
ios, err, v); ios, err, v);
assert(iter.base() == str+sizeof(str)-1); assert(iter.base() == str+sizeof(str)-1);
assert(err == ios.goodbit); assert(err == ios.goodbit);
assert(v == -INFINITY); assert(v == -INFINITY);
} }
{ {
const char str[] = "nan"; const char str[] = "nan";
hex(ios); hex(ios);
std::ios_base::iostate err = ios.goodbit; std::ios_base::iostate err = ios.goodbit;
input_iterator<const char*> iter = cpp17_input_iterator<const char*> iter =
f.get(input_iterator<const char*>(str), f.get(cpp17_input_iterator<const char*>(str),
input_iterator<const char*>(str+sizeof(str)), cpp17_input_iterator<const char*>(str+sizeof(str)),
ios, err, v); ios, err, v);
assert(iter.base() == str+sizeof(str)-1); assert(iter.base() == str+sizeof(str)-1);
assert(err == ios.goodbit); assert(err == ios.goodbit);
assert(std::isnan(v)); assert(std::isnan(v));
} }
{ {
const char str[] = "NAN"; const char str[] = "NAN";
hex(ios); hex(ios);
std::ios_base::iostate err = ios.goodbit; std::ios_base::iostate err = ios.goodbit;
input_iterator<const char*> iter = cpp17_input_iterator<const char*> iter =
f.get(input_iterator<const char*>(str), f.get(cpp17_input_iterator<const char*>(str),
input_iterator<const char*>(str+sizeof(str)), cpp17_input_iterator<const char*>(str+sizeof(str)),
ios, err, v); ios, err, v);
assert(iter.base() == str+sizeof(str)-1); assert(iter.base() == str+sizeof(str)-1);
assert(err == ios.goodbit); assert(err == ios.goodbit);
assert(std::isnan(v)); assert(std::isnan(v));
} }
{ {
v = -1; v = -1;
const char str[] = "3.40283e+39"; // unrepresentable const char str[] = "3.40283e+39"; // unrepresentable
std::ios_base::iostate err = ios.goodbit; std::ios_base::iostate err = ios.goodbit;
input_iterator<const char*> iter = cpp17_input_iterator<const char*> iter =
f.get(input_iterator<const char*>(str), f.get(cpp17_input_iterator<const char*>(str),
input_iterator<const char*>(str+sizeof(str)), cpp17_input_iterator<const char*>(str+sizeof(str)),
ios, err, v); ios, err, v);
assert(iter.base() == str+sizeof(str)-1); assert(iter.base() == str+sizeof(str)-1);
assert(err == ios.failbit); assert(err == ios.failbit);
assert(v == HUGE_VALF); assert(v == HUGE_VALF);
} }
{ {
v = -1; v = -1;
const char str[] = "-3.40283e+38"; // unrepresentable const char str[] = "-3.40283e+38"; // unrepresentable
std::ios_base::iostate err = ios.goodbit; std::ios_base::iostate err = ios.goodbit;
input_iterator<const char*> iter = cpp17_input_iterator<const char*> iter =
f.get(input_iterator<const char*>(str), f.get(cpp17_input_iterator<const char*>(str),
input_iterator<const char*>(str+sizeof(str)), cpp17_input_iterator<const char*>(str+sizeof(str)),
ios, err, v); ios, err, v);
assert(iter.base() == str+sizeof(str)-1); assert(iter.base() == str+sizeof(str)-1);
assert(err == ios.failbit); assert(err == ios.failbit);
assert(v == -HUGE_VALF); assert(v == -HUGE_VALF);
} }
{ {
v = -1; v = -1;
const char str[] = "2-"; const char str[] = "2-";
std::ios_base::iostate err = ios.goodbit; std::ios_base::iostate err = ios.goodbit;
input_iterator<const char*> iter = cpp17_input_iterator<const char*> iter =
f.get(input_iterator<const char*>(str), f.get(cpp17_input_iterator<const char*>(str),
input_iterator<const char*>(str+sizeof(str)), cpp17_input_iterator<const char*>(str+sizeof(str)),
ios, err, v); ios, err, v);
assert(iter.base() == str+1); assert(iter.base() == str+1);
assert(err == ios.goodbit); assert(err == ios.goodbit);
assert(v == 2); assert(v == 2);
} }
return 0; return 0;
} }

libcxx/test/std/localization/locale.categories/category.numeric/locale.num.get/facet.num.get.members/get_long.pass.cpp

Show All 24 Lines
#include <locale> #include <locale>
#include <ios> #include <ios>
#include <cassert> #include <cassert>
#include <limits> #include <limits>
#include <streambuf> #include <streambuf>
#include "test_macros.h" #include "test_macros.h"
#include "test_iterators.h" #include "test_iterators.h"
typedef std::num_get<char, input_iterator<const char*> > F; typedef std::num_get<char, cpp17_input_iterator<const char*> > F;
class my_facet class my_facet
: public F : public F
{ {
public: public:
explicit my_facet(std::size_t refs = 0) explicit my_facet(std::size_t refs = 0)
: F(refs) {} : F(refs) {}
}; };
Show All 15 Linesint main(int, char**)
std::ios ios(0); std::ios ios(0);
long v = -1; long v = -1;
const std::ios_base::fmtflags zf = static_cast<std::ios_base::fmtflags>(0); const std::ios_base::fmtflags zf = static_cast<std::ios_base::fmtflags>(0);
{ {
const char str[] = "123"; const char str[] = "123";
assert((ios.flags() & ios.basefield) == ios.dec); assert((ios.flags() & ios.basefield) == ios.dec);
assert(ios.getloc().name() == "C"); assert(ios.getloc().name() == "C");
std::ios_base::iostate err = ios.goodbit; std::ios_base::iostate err = ios.goodbit;
input_iterator<const char*> iter = cpp17_input_iterator<const char*> iter =
f.get(input_iterator<const char*>(str), f.get(cpp17_input_iterator<const char*>(str),
input_iterator<const char*>(str+sizeof(str)), cpp17_input_iterator<const char*>(str+sizeof(str)),
ios, err, v); ios, err, v);
assert(iter.base() == str+3); assert(iter.base() == str+3);
assert(err == ios.goodbit); assert(err == ios.goodbit);
assert(v == 123); assert(v == 123);
} }
{ {
const char str[] = "-123"; const char str[] = "-123";
assert((ios.flags() & ios.basefield) == ios.dec); assert((ios.flags() & ios.basefield) == ios.dec);
assert(ios.getloc().name() == "C"); assert(ios.getloc().name() == "C");
std::ios_base::iostate err = ios.goodbit; std::ios_base::iostate err = ios.goodbit;
input_iterator<const char*> iter = cpp17_input_iterator<const char*> iter =
f.get(input_iterator<const char*>(str), f.get(cpp17_input_iterator<const char*>(str),
input_iterator<const char*>(str+sizeof(str)), cpp17_input_iterator<const char*>(str+sizeof(str)),
ios, err, v); ios, err, v);
assert(iter.base() == str+4); assert(iter.base() == str+4);
assert(err == ios.goodbit); assert(err == ios.goodbit);
assert(v == -123); assert(v == -123);
} }
{ {
const char str[] = "123"; const char str[] = "123";
oct(ios); oct(ios);
std::ios_base::iostate err = ios.goodbit; std::ios_base::iostate err = ios.goodbit;
input_iterator<const char*> iter = cpp17_input_iterator<const char*> iter =
f.get(input_iterator<const char*>(str), f.get(cpp17_input_iterator<const char*>(str),
input_iterator<const char*>(str+sizeof(str)), cpp17_input_iterator<const char*>(str+sizeof(str)),
ios, err, v); ios, err, v);
assert(iter.base() == str+3); assert(iter.base() == str+3);
assert(err == ios.goodbit); assert(err == ios.goodbit);
assert(v == 83); assert(v == 83);
} }
{ {
const char str[] = "123"; const char str[] = "123";
hex(ios); hex(ios);
std::ios_base::iostate err = ios.goodbit; std::ios_base::iostate err = ios.goodbit;
input_iterator<const char*> iter = cpp17_input_iterator<const char*> iter =
f.get(input_iterator<const char*>(str), f.get(cpp17_input_iterator<const char*>(str),
input_iterator<const char*>(str+sizeof(str)), cpp17_input_iterator<const char*>(str+sizeof(str)),
ios, err, v); ios, err, v);
assert(iter.base() == str+3); assert(iter.base() == str+3);
assert(err == ios.goodbit); assert(err == ios.goodbit);
assert(v == 291); assert(v == 291);
} }
{ {
const char str[] = "0x123"; const char str[] = "0x123";
hex(ios); hex(ios);
std::ios_base::iostate err = ios.goodbit; std::ios_base::iostate err = ios.goodbit;
input_iterator<const char*> iter = cpp17_input_iterator<const char*> iter =
f.get(input_iterator<const char*>(str), f.get(cpp17_input_iterator<const char*>(str),
input_iterator<const char*>(str+sizeof(str)), cpp17_input_iterator<const char*>(str+sizeof(str)),
ios, err, v); ios, err, v);
assert(iter.base() == str+sizeof(str)-1); assert(iter.base() == str+sizeof(str)-1);
assert(err == ios.goodbit); assert(err == ios.goodbit);
assert(v == 291); assert(v == 291);
} }
{ {
const char str[] = "123"; const char str[] = "123";
ios.setf(zf, ios.basefield); ios.setf(zf, ios.basefield);
std::ios_base::iostate err = ios.goodbit; std::ios_base::iostate err = ios.goodbit;
input_iterator<const char*> iter = cpp17_input_iterator<const char*> iter =
f.get(input_iterator<const char*>(str), f.get(cpp17_input_iterator<const char*>(str),
input_iterator<const char*>(str+sizeof(str)), cpp17_input_iterator<const char*>(str+sizeof(str)),
ios, err, v); ios, err, v);
assert(iter.base() == str+sizeof(str)-1); assert(iter.base() == str+sizeof(str)-1);
assert(err == ios.goodbit); assert(err == ios.goodbit);
assert(v == 123); assert(v == 123);
} }
{ {
const char str[] = "0x123"; const char str[] = "0x123";
ios.setf(zf, ios.basefield); ios.setf(zf, ios.basefield);
std::ios_base::iostate err = ios.goodbit; std::ios_base::iostate err = ios.goodbit;
input_iterator<const char*> iter = cpp17_input_iterator<const char*> iter =
f.get(input_iterator<const char*>(str), f.get(cpp17_input_iterator<const char*>(str),
input_iterator<const char*>(str+sizeof(str)), cpp17_input_iterator<const char*>(str+sizeof(str)),
ios, err, v); ios, err, v);
assert(iter.base() == str+sizeof(str)-1); assert(iter.base() == str+sizeof(str)-1);
assert(err == ios.goodbit); assert(err == ios.goodbit);
assert(v == 291); assert(v == 291);
} }
{ {
const char str[] = "0123"; const char str[] = "0123";
ios.setf(zf, ios.basefield); ios.setf(zf, ios.basefield);
std::ios_base::iostate err = ios.goodbit; std::ios_base::iostate err = ios.goodbit;
input_iterator<const char*> iter = cpp17_input_iterator<const char*> iter =
f.get(input_iterator<const char*>(str), f.get(cpp17_input_iterator<const char*>(str),
input_iterator<const char*>(str+sizeof(str)), cpp17_input_iterator<const char*>(str+sizeof(str)),
ios, err, v); ios, err, v);
assert(iter.base() == str+sizeof(str)-1); assert(iter.base() == str+sizeof(str)-1);
assert(err == ios.goodbit); assert(err == ios.goodbit);
assert(v == 83); assert(v == 83);
} }
{ {
// See PR11871 // See PR11871
const char str[] = "2-"; const char str[] = "2-";
ios.setf(zf, ios.basefield); ios.setf(zf, ios.basefield);
std::ios_base::iostate err = ios.goodbit; std::ios_base::iostate err = ios.goodbit;
input_iterator<const char*> iter = cpp17_input_iterator<const char*> iter =
f.get(input_iterator<const char*>(str), f.get(cpp17_input_iterator<const char*>(str),
input_iterator<const char*>(str+sizeof(str)), cpp17_input_iterator<const char*>(str+sizeof(str)),
ios, err, v); ios, err, v);
assert(iter.base() == str+1); assert(iter.base() == str+1);
assert(err == ios.goodbit); assert(err == ios.goodbit);
assert(v == 2); assert(v == 2);
} }
dec(ios); dec(ios);
ios.imbue(std::locale(std::locale(), new my_numpunct)); ios.imbue(std::locale(std::locale(), new my_numpunct));
{ {
v = -1; v = -1;
const char str[] = "123"; // no separators at all const char str[] = "123"; // no separators at all
std::ios_base::iostate err = ios.goodbit; std::ios_base::iostate err = ios.goodbit;
input_iterator<const char*> iter = cpp17_input_iterator<const char*> iter =
f.get(input_iterator<const char*>(str), f.get(cpp17_input_iterator<const char*>(str),
input_iterator<const char*>(str+sizeof(str)), cpp17_input_iterator<const char*>(str+sizeof(str)),
ios, err, v); ios, err, v);
assert(iter.base() == str+sizeof(str)-1); assert(iter.base() == str+sizeof(str)-1);
assert(err == ios.goodbit); assert(err == ios.goodbit);
assert(v == 123); assert(v == 123);
} }
{ {
v = -1; v = -1;
const char str[] = "+1"; const char str[] = "+1";
std::ios_base::iostate err = ios.goodbit; std::ios_base::iostate err = ios.goodbit;
input_iterator<const char*> iter = cpp17_input_iterator<const char*> iter =
f.get(input_iterator<const char*>(str), f.get(cpp17_input_iterator<const char*>(str),
input_iterator<const char*>(str+sizeof(str)), cpp17_input_iterator<const char*>(str+sizeof(str)),
ios, err, v); ios, err, v);
assert(iter.base() == str+sizeof(str)-1); assert(iter.base() == str+sizeof(str)-1);
assert(err == ios.goodbit); assert(err == ios.goodbit);
assert(v == 1); assert(v == 1);
} }
{ {
v = -1; v = -1;
const char str[] = "+1_"; const char str[] = "+1_";
std::ios_base::iostate err = ios.goodbit; std::ios_base::iostate err = ios.goodbit;
input_iterator<const char*> iter = cpp17_input_iterator<const char*> iter =
f.get(input_iterator<const char*>(str), f.get(cpp17_input_iterator<const char*>(str),
input_iterator<const char*>(str+sizeof(str)), cpp17_input_iterator<const char*>(str+sizeof(str)),
ios, err, v); ios, err, v);
assert(iter.base() == str+sizeof(str)-1); assert(iter.base() == str+sizeof(str)-1);
assert(err == ios.failbit); assert(err == ios.failbit);
assert(v == 1); assert(v == 1);
} }
{ {
v = -1; v = -1;
const char str[] = "+_1"; const char str[] = "+_1";
std::ios_base::iostate err = ios.goodbit; std::ios_base::iostate err = ios.goodbit;
input_iterator<const char*> iter = cpp17_input_iterator<const char*> iter =
f.get(input_iterator<const char*>(str), f.get(cpp17_input_iterator<const char*>(str),
input_iterator<const char*>(str+sizeof(str)), cpp17_input_iterator<const char*>(str+sizeof(str)),
ios, err, v); ios, err, v);
assert(iter.base() == str+sizeof(str)-1); assert(iter.base() == str+sizeof(str)-1);
assert(err == ios.failbit); assert(err == ios.failbit);
assert(v == 1); assert(v == 1);
} }
{ {
v = -1; v = -1;
const char str[] = "_+1"; const char str[] = "_+1";
std::ios_base::iostate err = ios.goodbit; std::ios_base::iostate err = ios.goodbit;
input_iterator<const char*> iter = cpp17_input_iterator<const char*> iter =
f.get(input_iterator<const char*>(str), f.get(cpp17_input_iterator<const char*>(str),
input_iterator<const char*>(str+sizeof(str)), cpp17_input_iterator<const char*>(str+sizeof(str)),
ios, err, v); ios, err, v);
assert(iter.base() == str+sizeof(str)-1); assert(iter.base() == str+sizeof(str)-1);
assert(err == ios.failbit); assert(err == ios.failbit);
assert(v == 1); assert(v == 1);
} }
{ {
v = -1; v = -1;
const char str[] = "+1__"; const char str[] = "+1__";
std::ios_base::iostate err = ios.goodbit; std::ios_base::iostate err = ios.goodbit;
input_iterator<const char*> iter = cpp17_input_iterator<const char*> iter =
f.get(input_iterator<const char*>(str), f.get(cpp17_input_iterator<const char*>(str),
input_iterator<const char*>(str+sizeof(str)), cpp17_input_iterator<const char*>(str+sizeof(str)),
ios, err, v); ios, err, v);
assert(iter.base() == str+sizeof(str)-1); assert(iter.base() == str+sizeof(str)-1);
assert(err == ios.failbit); assert(err == ios.failbit);
assert(v == 1); assert(v == 1);
} }
{ {
v = -1; v = -1;
const char str[] = "+_1_"; const char str[] = "+_1_";
std::ios_base::iostate err = ios.goodbit; std::ios_base::iostate err = ios.goodbit;
input_iterator<const char*> iter = cpp17_input_iterator<const char*> iter =
f.get(input_iterator<const char*>(str), f.get(cpp17_input_iterator<const char*>(str),
input_iterator<const char*>(str+sizeof(str)), cpp17_input_iterator<const char*>(str+sizeof(str)),
ios, err, v); ios, err, v);
assert(iter.base() == str+sizeof(str)-1); assert(iter.base() == str+sizeof(str)-1);
assert(err == ios.failbit); assert(err == ios.failbit);
assert(v == 1); assert(v == 1);
} }
{ {
v = -1; v = -1;
const char str[] = "_+1_"; const char str[] = "_+1_";
std::ios_base::iostate err = ios.goodbit; std::ios_base::iostate err = ios.goodbit;
input_iterator<const char*> iter = cpp17_input_iterator<const char*> iter =
f.get(input_iterator<const char*>(str), f.get(cpp17_input_iterator<const char*>(str),
input_iterator<const char*>(str+sizeof(str)), cpp17_input_iterator<const char*>(str+sizeof(str)),
ios, err, v); ios, err, v);
assert(iter.base() == str+sizeof(str)-1); assert(iter.base() == str+sizeof(str)-1);
assert(err == ios.failbit); assert(err == ios.failbit);
assert(v == 1); assert(v == 1);
} }
{ {
v = -1; v = -1;
const char str[] = "+__1"; const char str[] = "+__1";
std::ios_base::iostate err = ios.goodbit; std::ios_base::iostate err = ios.goodbit;
input_iterator<const char*> iter = cpp17_input_iterator<const char*> iter =
f.get(input_iterator<const char*>(str), f.get(cpp17_input_iterator<const char*>(str),
input_iterator<const char*>(str+sizeof(str)), cpp17_input_iterator<const char*>(str+sizeof(str)),
ios, err, v); ios, err, v);
assert(iter.base() == str+sizeof(str)-1); assert(iter.base() == str+sizeof(str)-1);
assert(err == ios.failbit); assert(err == ios.failbit);
assert(v == 1); assert(v == 1);
} }
{ {
v = -1; v = -1;
const char str[] = "_+_1"; const char str[] = "_+_1";
std::ios_base::iostate err = ios.goodbit; std::ios_base::iostate err = ios.goodbit;
input_iterator<const char*> iter = cpp17_input_iterator<const char*> iter =
f.get(input_iterator<const char*>(str), f.get(cpp17_input_iterator<const char*>(str),
input_iterator<const char*>(str+sizeof(str)), cpp17_input_iterator<const char*>(str+sizeof(str)),
ios, err, v); ios, err, v);
assert(iter.base() == str+sizeof(str)-1); assert(iter.base() == str+sizeof(str)-1);
assert(err == ios.failbit); assert(err == ios.failbit);
assert(v == 1); assert(v == 1);
} }
{ {
v = -1; v = -1;
const char str[] = "__+1"; const char str[] = "__+1";
std::ios_base::iostate err = ios.goodbit; std::ios_base::iostate err = ios.goodbit;
input_iterator<const char*> iter = cpp17_input_iterator<const char*> iter =
f.get(input_iterator<const char*>(str), f.get(cpp17_input_iterator<const char*>(str),
input_iterator<const char*>(str+sizeof(str)), cpp17_input_iterator<const char*>(str+sizeof(str)),
ios, err, v); ios, err, v);
assert(iter.base() == str+sizeof(str)-1); assert(iter.base() == str+sizeof(str)-1);
assert(err == ios.failbit); assert(err == ios.failbit);
assert(v == 1); assert(v == 1);
} }
{ {
v = -1; v = -1;
const char str[] = "+1_2"; const char str[] = "+1_2";
std::ios_base::iostate err = ios.goodbit; std::ios_base::iostate err = ios.goodbit;
input_iterator<const char*> iter = cpp17_input_iterator<const char*> iter =
f.get(input_iterator<const char*>(str), f.get(cpp17_input_iterator<const char*>(str),
input_iterator<const char*>(str+sizeof(str)), cpp17_input_iterator<const char*>(str+sizeof(str)),
ios, err, v); ios, err, v);
assert(iter.base() == str+sizeof(str)-1); assert(iter.base() == str+sizeof(str)-1);
assert(err == ios.goodbit); assert(err == ios.goodbit);
assert(v == 12); assert(v == 12);
} }
{ {
v = -1; v = -1;
const char str[] = "+12_"; const char str[] = "+12_";
std::ios_base::iostate err = ios.goodbit; std::ios_base::iostate err = ios.goodbit;
input_iterator<const char*> iter = cpp17_input_iterator<const char*> iter =
f.get(input_iterator<const char*>(str), f.get(cpp17_input_iterator<const char*>(str),
input_iterator<const char*>(str+sizeof(str)), cpp17_input_iterator<const char*>(str+sizeof(str)),
ios, err, v); ios, err, v);
assert(iter.base() == str+sizeof(str)-1); assert(iter.base() == str+sizeof(str)-1);
assert(err == ios.failbit); assert(err == ios.failbit);
assert(v == 12); assert(v == 12);
} }
{ {
v = -1; v = -1;
const char str[] = "+_12"; const char str[] = "+_12";
std::ios_base::iostate err = ios.goodbit; std::ios_base::iostate err = ios.goodbit;
input_iterator<const char*> iter = cpp17_input_iterator<const char*> iter =
f.get(input_iterator<const char*>(str), f.get(cpp17_input_iterator<const char*>(str),
input_iterator<const char*>(str+sizeof(str)), cpp17_input_iterator<const char*>(str+sizeof(str)),
ios, err, v); ios, err, v);
assert(iter.base() == str+sizeof(str)-1); assert(iter.base() == str+sizeof(str)-1);
assert(err == ios.failbit); assert(err == ios.failbit);
assert(v == 12); assert(v == 12);
} }
{ {
v = -1; v = -1;
const char str[] = "+1__2"; const char str[] = "+1__2";
std::ios_base::iostate err = ios.goodbit; std::ios_base::iostate err = ios.goodbit;
input_iterator<const char*> iter = cpp17_input_iterator<const char*> iter =
f.get(input_iterator<const char*>(str), f.get(cpp17_input_iterator<const char*>(str),
input_iterator<const char*>(str+sizeof(str)), cpp17_input_iterator<const char*>(str+sizeof(str)),
ios, err, v); ios, err, v);
assert(iter.base() == str+sizeof(str)-1); assert(iter.base() == str+sizeof(str)-1);
assert(err == ios.failbit); assert(err == ios.failbit);
assert(v == 12); assert(v == 12);
} }
{ {
v = -1; v = -1;
const char str[] = "+12_3"; const char str[] = "+12_3";
std::ios_base::iostate err = ios.goodbit; std::ios_base::iostate err = ios.goodbit;
input_iterator<const char*> iter = cpp17_input_iterator<const char*> iter =
f.get(input_iterator<const char*>(str), f.get(cpp17_input_iterator<const char*>(str),
input_iterator<const char*>(str+sizeof(str)), cpp17_input_iterator<const char*>(str+sizeof(str)),
ios, err, v); ios, err, v);
assert(iter.base() == str+sizeof(str)-1); assert(iter.base() == str+sizeof(str)-1);
assert(err == ios.goodbit); assert(err == ios.goodbit);
assert(v == 123); assert(v == 123);
} }
{ {
v = -1; v = -1;
const char str[] = "+1_23"; const char str[] = "+1_23";
std::ios_base::iostate err = ios.goodbit; std::ios_base::iostate err = ios.goodbit;
input_iterator<const char*> iter = cpp17_input_iterator<const char*> iter =
f.get(input_iterator<const char*>(str), f.get(cpp17_input_iterator<const char*>(str),
input_iterator<const char*>(str+sizeof(str)), cpp17_input_iterator<const char*>(str+sizeof(str)),
ios, err, v); ios, err, v);
assert(iter.base() == str+sizeof(str)-1); assert(iter.base() == str+sizeof(str)-1);
assert(err == ios.failbit); assert(err == ios.failbit);
assert(v == 123); assert(v == 123);
} }
{ {
v = -1; v = -1;
const char str[] = "+1_23_4"; const char str[] = "+1_23_4";
std::ios_base::iostate err = ios.goodbit; std::ios_base::iostate err = ios.goodbit;
input_iterator<const char*> iter = cpp17_input_iterator<const char*> iter =
f.get(input_iterator<const char*>(str), f.get(cpp17_input_iterator<const char*>(str),
input_iterator<const char*>(str+sizeof(str)), cpp17_input_iterator<const char*>(str+sizeof(str)),
ios, err, v); ios, err, v);
assert(iter.base() == str+sizeof(str)-1); assert(iter.base() == str+sizeof(str)-1);
assert(err == ios.goodbit); assert(err == ios.goodbit);
assert(v == 1234); assert(v == 1234);
} }
{ {
v = -1; v = -1;
const char str[] = "+123_4"; const char str[] = "+123_4";
std::ios_base::iostate err = ios.goodbit; std::ios_base::iostate err = ios.goodbit;
input_iterator<const char*> iter = cpp17_input_iterator<const char*> iter =
f.get(input_iterator<const char*>(str), f.get(cpp17_input_iterator<const char*>(str),
input_iterator<const char*>(str+sizeof(str)), cpp17_input_iterator<const char*>(str+sizeof(str)),
ios, err, v); ios, err, v);
assert(iter.base() == str+sizeof(str)-1); assert(iter.base() == str+sizeof(str)-1);
assert(err == ios.failbit); assert(err == ios.failbit);
assert(v == 1234); assert(v == 1234);
} }
{ {
v = -1; v = -1;
const char str[] = "+12_34"; const char str[] = "+12_34";
std::ios_base::iostate err = ios.goodbit; std::ios_base::iostate err = ios.goodbit;
input_iterator<const char*> iter = cpp17_input_iterator<const char*> iter =
f.get(input_iterator<const char*>(str), f.get(cpp17_input_iterator<const char*>(str),
input_iterator<const char*>(str+sizeof(str)), cpp17_input_iterator<const char*>(str+sizeof(str)),
ios, err, v); ios, err, v);
assert(iter.base() == str+sizeof(str)-1); assert(iter.base() == str+sizeof(str)-1);
assert(err == ios.failbit); assert(err == ios.failbit);
assert(v == 1234); assert(v == 1234);
} }
{ {
v = -1; v = -1;
const char str[] = "+12_34_5"; const char str[] = "+12_34_5";
std::ios_base::iostate err = ios.goodbit; std::ios_base::iostate err = ios.goodbit;
input_iterator<const char*> iter = cpp17_input_iterator<const char*> iter =
f.get(input_iterator<const char*>(str), f.get(cpp17_input_iterator<const char*>(str),
input_iterator<const char*>(str+sizeof(str)), cpp17_input_iterator<const char*>(str+sizeof(str)),
ios, err, v); ios, err, v);
assert(iter.base() == str+sizeof(str)-1); assert(iter.base() == str+sizeof(str)-1);
assert(err == ios.goodbit); assert(err == ios.goodbit);
assert(v == 12345); assert(v == 12345);
} }
{ {
v = -1; v = -1;
const char str[] = "+123_45_6"; const char str[] = "+123_45_6";
std::ios_base::iostate err = ios.goodbit; std::ios_base::iostate err = ios.goodbit;
input_iterator<const char*> iter = cpp17_input_iterator<const char*> iter =
f.get(input_iterator<const char*>(str), f.get(cpp17_input_iterator<const char*>(str),
input_iterator<const char*>(str+sizeof(str)), cpp17_input_iterator<const char*>(str+sizeof(str)),
ios, err, v); ios, err, v);
assert(iter.base() == str+sizeof(str)-1); assert(iter.base() == str+sizeof(str)-1);
assert(err == ios.goodbit); assert(err == ios.goodbit);
assert(v == 123456); assert(v == 123456);
} }
{ {
v = -1; v = -1;
const char str[] = "+1_23_45_6"; const char str[] = "+1_23_45_6";
std::ios_base::iostate err = ios.goodbit; std::ios_base::iostate err = ios.goodbit;
input_iterator<const char*> iter = cpp17_input_iterator<const char*> iter =
f.get(input_iterator<const char*>(str), f.get(cpp17_input_iterator<const char*>(str),
input_iterator<const char*>(str+sizeof(str)), cpp17_input_iterator<const char*>(str+sizeof(str)),
ios, err, v); ios, err, v);
assert(iter.base() == str+sizeof(str)-1); assert(iter.base() == str+sizeof(str)-1);
assert(err == ios.failbit); assert(err == ios.failbit);
assert(v == 123456); assert(v == 123456);
} }
{ {
v = -1; v = -1;
const char str[] = "+1_234_56_7"; const char str[] = "+1_234_56_7";
std::ios_base::iostate err = ios.goodbit; std::ios_base::iostate err = ios.goodbit;
input_iterator<const char*> iter = cpp17_input_iterator<const char*> iter =
f.get(input_iterator<const char*>(str), f.get(cpp17_input_iterator<const char*>(str),
input_iterator<const char*>(str+sizeof(str)), cpp17_input_iterator<const char*>(str+sizeof(str)),
ios, err, v); ios, err, v);
assert(iter.base() == str+sizeof(str)-1); assert(iter.base() == str+sizeof(str)-1);
assert(err == ios.goodbit); assert(err == ios.goodbit);
assert(v == 1234567); assert(v == 1234567);
} }
{ {
v = -1; v = -1;
const char str[] = "+1_234_567_89_0"; const char str[] = "+1_234_567_89_0";
std::ios_base::iostate err = ios.goodbit; std::ios_base::iostate err = ios.goodbit;
input_iterator<const char*> iter = cpp17_input_iterator<const char*> iter =
f.get(input_iterator<const char*>(str), f.get(cpp17_input_iterator<const char*>(str),
input_iterator<const char*>(str+sizeof(str)), cpp17_input_iterator<const char*>(str+sizeof(str)),
ios, err, v); ios, err, v);
assert(iter.base() == str+sizeof(str)-1); assert(iter.base() == str+sizeof(str)-1);
assert(err == ios.goodbit); assert(err == ios.goodbit);
assert(v == 1234567890); assert(v == 1234567890);
} }
{ {
v = -1; v = -1;
const char str[] = "-1_234_567_89_0"; const char str[] = "-1_234_567_89_0";
std::ios_base::iostate err = ios.goodbit; std::ios_base::iostate err = ios.goodbit;
input_iterator<const char*> iter = cpp17_input_iterator<const char*> iter =
f.get(input_iterator<const char*>(str), f.get(cpp17_input_iterator<const char*>(str),
input_iterator<const char*>(str+sizeof(str)), cpp17_input_iterator<const char*>(str+sizeof(str)),
ios, err, v); ios, err, v);
assert(iter.base() == str+sizeof(str)-1); assert(iter.base() == str+sizeof(str)-1);
assert(err == ios.goodbit); assert(err == ios.goodbit);
assert(v == -1234567890); assert(v == -1234567890);
} }
{ {
v = -1; v = -1;
const char str[] = "1_234_567_89_0"; const char str[] = "1_234_567_89_0";
std::ios_base::iostate err = ios.goodbit; std::ios_base::iostate err = ios.goodbit;
input_iterator<const char*> iter = cpp17_input_iterator<const char*> iter =
f.get(input_iterator<const char*>(str), f.get(cpp17_input_iterator<const char*>(str),
input_iterator<const char*>(str+sizeof(str)), cpp17_input_iterator<const char*>(str+sizeof(str)),
ios, err, v); ios, err, v);
assert(iter.base() == str+sizeof(str)-1); assert(iter.base() == str+sizeof(str)-1);
assert(err == ios.goodbit); assert(err == ios.goodbit);
assert(v == 1234567890); assert(v == 1234567890);
} }
{ {
v = -1; v = -1;
const char str[] = "1234_567_89_0"; const char str[] = "1234_567_89_0";
std::ios_base::iostate err = ios.goodbit; std::ios_base::iostate err = ios.goodbit;
input_iterator<const char*> iter = cpp17_input_iterator<const char*> iter =
f.get(input_iterator<const char*>(str), f.get(cpp17_input_iterator<const char*>(str),
input_iterator<const char*>(str+sizeof(str)), cpp17_input_iterator<const char*>(str+sizeof(str)),
ios, err, v); ios, err, v);
assert(iter.base() == str+sizeof(str)-1); assert(iter.base() == str+sizeof(str)-1);
assert(err == ios.failbit); assert(err == ios.failbit);
assert(v == 1234567890); assert(v == 1234567890);
} }
{ {
v = -1; v = -1;
const char str[] = "1_2_3_4_5_6_7_8_9_0_1_2_3_4_5_6_7_8_9_0_1_2_3_4_5_6_7_8_9_0_" const char str[] = "1_2_3_4_5_6_7_8_9_0_1_2_3_4_5_6_7_8_9_0_1_2_3_4_5_6_7_8_9_0_"
"1_2_3_4_5_6_7_8_9_0_1_2_3_4_5_6_7_8_9_0_1_2_3_4_5_6_7_8_9_0_" "1_2_3_4_5_6_7_8_9_0_1_2_3_4_5_6_7_8_9_0_1_2_3_4_5_6_7_8_9_0_"
"1_2_3_4_5_6_7_8_9_0_1_2_3_4_5_6_7_8_9_0_1_2_3_4_5_6_7_8_9_0_" "1_2_3_4_5_6_7_8_9_0_1_2_3_4_5_6_7_8_9_0_1_2_3_4_5_6_7_8_9_0_"
"1_2_3_4_5_6_7_8_9_0_1_2_3_4_5_6_7_8_9_0_1_2_3_4_5_6_7_8_9_0_" "1_2_3_4_5_6_7_8_9_0_1_2_3_4_5_6_7_8_9_0_1_2_3_4_5_6_7_8_9_0_"
"1_2_3_4_5_6_7_8_9_0_1_2_3_4_5_6_7_8_9_0_1_2_3_4_5_6_7_8_9_0_" "1_2_3_4_5_6_7_8_9_0_1_2_3_4_5_6_7_8_9_0_1_2_3_4_5_6_7_8_9_0_"
"1_2_3_4_5_6_7_8_9_0_1_2_3_4_5_6_7_8_9_0_1_2_3_4_5_6_7_8_9_0_" "1_2_3_4_5_6_7_8_9_0_1_2_3_4_5_6_7_8_9_0_1_2_3_4_5_6_7_8_9_0_"
"1_2_3_4_5_6_7_8_9_0_1_2_3_4_5_6_7_8_9_0_1_2_3_4_5_6_7_8_9_0_" "1_2_3_4_5_6_7_8_9_0_1_2_3_4_5_6_7_8_9_0_1_2_3_4_5_6_7_8_9_0_"
"1_2_3_4_5_6_7_8_9_0_1_2_3_4_5_6_7_8_9_0_1_2_3_4_5_6_7_8_9_0_" "1_2_3_4_5_6_7_8_9_0_1_2_3_4_5_6_7_8_9_0_1_2_3_4_5_6_7_8_9_0_"
"1_2_3_4_5_6_7_8_9_0_1_2_3_4_5_6_7_8_9_0_1_2_3_4_5_6_7_8_9_0_" "1_2_3_4_5_6_7_8_9_0_1_2_3_4_5_6_7_8_9_0_1_2_3_4_5_6_7_8_9_0_"
"1_2_3_4_5_6_7_8_9_0_1_2_3_4_5_6_7_8_9_0_1_2_3_4_5_6_7_8_9_0_" "1_2_3_4_5_6_7_8_9_0_1_2_3_4_5_6_7_8_9_0_1_2_3_4_5_6_7_8_9_0_"
"1_2_3_4_5_6_7_8_9_0_1_2_3_4_5_6_7_8_9_0_1_2_3_4_5_6_7_8_9_0_"; "1_2_3_4_5_6_7_8_9_0_1_2_3_4_5_6_7_8_9_0_1_2_3_4_5_6_7_8_9_0_";
std::ios_base::iostate err = ios.goodbit; std::ios_base::iostate err = ios.goodbit;
input_iterator<const char*> iter = cpp17_input_iterator<const char*> iter =
f.get(input_iterator<const char*>(str), f.get(cpp17_input_iterator<const char*>(str),
input_iterator<const char*>(str+sizeof(str)), cpp17_input_iterator<const char*>(str+sizeof(str)),
ios, err, v); ios, err, v);
assert(iter.base() == str+sizeof(str)-1); assert(iter.base() == str+sizeof(str)-1);
assert(err == ios.failbit); assert(err == ios.failbit);
assert(v == std::numeric_limits<long>::max()); assert(v == std::numeric_limits<long>::max());
} }
return 0; return 0;
} }

libcxx/test/std/localization/locale.categories/category.numeric/locale.num.get/facet.num.get.members/get_long_double.pass.cpp

Show All 16 Lines
#include <ios> #include <ios>
#include <cassert> #include <cassert>
#include <streambuf> #include <streambuf>
#include <cmath> #include <cmath>
#include "test_macros.h" #include "test_macros.h"
#include "test_iterators.h" #include "test_iterators.h"
#include "hexfloat.h" #include "hexfloat.h"
typedef std::num_get<char, input_iterator<const char*> > F; typedef std::num_get<char, cpp17_input_iterator<const char*> > F;
class my_facet class my_facet
: public F : public F
{ {
public: public:
explicit my_facet(std::size_t refs = 0) explicit my_facet(std::size_t refs = 0)
: F(refs) {} : F(refs) {}
}; };
int main(int, char**) int main(int, char**)
{ {
const my_facet f(1); const my_facet f(1);
std::ios ios(0); std::ios ios(0);
long double v = -1; long double v = -1;
{ {
const char str[] = "123"; const char str[] = "123";
assert((ios.flags() & ios.basefield) == ios.dec); assert((ios.flags() & ios.basefield) == ios.dec);
assert(ios.getloc().name() == "C"); assert(ios.getloc().name() == "C");
std::ios_base::iostate err = ios.goodbit; std::ios_base::iostate err = ios.goodbit;
input_iterator<const char*> iter = cpp17_input_iterator<const char*> iter =
f.get(input_iterator<const char*>(str), f.get(cpp17_input_iterator<const char*>(str),
input_iterator<const char*>(str+sizeof(str)), cpp17_input_iterator<const char*>(str+sizeof(str)),
ios, err, v); ios, err, v);
assert(iter.base() == str+sizeof(str)-1); assert(iter.base() == str+sizeof(str)-1);
assert(err == ios.goodbit); assert(err == ios.goodbit);
assert(v == 123); assert(v == 123);
} }
{ {
const char str[] = "-123"; const char str[] = "-123";
std::ios_base::iostate err = ios.goodbit; std::ios_base::iostate err = ios.goodbit;
input_iterator<const char*> iter = cpp17_input_iterator<const char*> iter =
f.get(input_iterator<const char*>(str), f.get(cpp17_input_iterator<const char*>(str),
input_iterator<const char*>(str+sizeof(str)), cpp17_input_iterator<const char*>(str+sizeof(str)),
ios, err, v); ios, err, v);
assert(iter.base() == str+sizeof(str)-1); assert(iter.base() == str+sizeof(str)-1);
assert(err == ios.goodbit); assert(err == ios.goodbit);
assert(v == -123); assert(v == -123);
} }
{ {
const char str[] = "123.5"; const char str[] = "123.5";
std::ios_base::iostate err = ios.goodbit; std::ios_base::iostate err = ios.goodbit;
input_iterator<const char*> iter = cpp17_input_iterator<const char*> iter =
f.get(input_iterator<const char*>(str), f.get(cpp17_input_iterator<const char*>(str),
input_iterator<const char*>(str+sizeof(str)), cpp17_input_iterator<const char*>(str+sizeof(str)),
ios, err, v); ios, err, v);
assert(iter.base() == str+sizeof(str)-1); assert(iter.base() == str+sizeof(str)-1);
assert(err == ios.goodbit); assert(err == ios.goodbit);
assert(v == 123.5); assert(v == 123.5);
} }
{ {
const char str[] = "125e-1"; const char str[] = "125e-1";
hex(ios); hex(ios);
std::ios_base::iostate err = ios.goodbit; std::ios_base::iostate err = ios.goodbit;
input_iterator<const char*> iter = cpp17_input_iterator<const char*> iter =
f.get(input_iterator<const char*>(str), f.get(cpp17_input_iterator<const char*>(str),
input_iterator<const char*>(str+sizeof(str)), cpp17_input_iterator<const char*>(str+sizeof(str)),
ios, err, v); ios, err, v);
assert(iter.base() == str+sizeof(str)-1); assert(iter.base() == str+sizeof(str)-1);
assert(err == ios.goodbit); assert(err == ios.goodbit);
assert(v == 125e-1); assert(v == 125e-1);
} }
{ {
const char str[] = "0x125p-1"; const char str[] = "0x125p-1";
hex(ios); hex(ios);
std::ios_base::iostate err = ios.goodbit; std::ios_base::iostate err = ios.goodbit;
input_iterator<const char*> iter = cpp17_input_iterator<const char*> iter =
f.get(input_iterator<const char*>(str), f.get(cpp17_input_iterator<const char*>(str),
input_iterator<const char*>(str+sizeof(str)), cpp17_input_iterator<const char*>(str+sizeof(str)),
ios, err, v); ios, err, v);
assert(iter.base() == str+sizeof(str)-1); assert(iter.base() == str+sizeof(str)-1);
assert(err == ios.goodbit); assert(err == ios.goodbit);
assert(v == hexfloat<long double>(0x125, 0, -1)); assert(v == hexfloat<long double>(0x125, 0, -1));
} }
{ {
const char str[] = "inf"; const char str[] = "inf";
hex(ios); hex(ios);
std::ios_base::iostate err = ios.goodbit; std::ios_base::iostate err = ios.goodbit;
input_iterator<const char*> iter = cpp17_input_iterator<const char*> iter =
f.get(input_iterator<const char*>(str), f.get(cpp17_input_iterator<const char*>(str),
input_iterator<const char*>(str+sizeof(str)), cpp17_input_iterator<const char*>(str+sizeof(str)),
ios, err, v); ios, err, v);
assert(iter.base() == str+sizeof(str)-1); assert(iter.base() == str+sizeof(str)-1);
assert(err == ios.goodbit); assert(err == ios.goodbit);
assert(v == INFINITY); assert(v == INFINITY);
} }
{ {
const char str[] = "INF"; const char str[] = "INF";
hex(ios); hex(ios);
std::ios_base::iostate err = ios.goodbit; std::ios_base::iostate err = ios.goodbit;
input_iterator<const char*> iter = cpp17_input_iterator<const char*> iter =
f.get(input_iterator<const char*>(str), f.get(cpp17_input_iterator<const char*>(str),
input_iterator<const char*>(str+sizeof(str)), cpp17_input_iterator<const char*>(str+sizeof(str)),
ios, err, v); ios, err, v);
assert(iter.base() == str+sizeof(str)-1); assert(iter.base() == str+sizeof(str)-1);
assert(err == ios.goodbit); assert(err == ios.goodbit);
assert(v == INFINITY); assert(v == INFINITY);
} }
{ {
const char str[] = "-inf"; const char str[] = "-inf";
hex(ios); hex(ios);
std::ios_base::iostate err = ios.goodbit; std::ios_base::iostate err = ios.goodbit;
input_iterator<const char*> iter = cpp17_input_iterator<const char*> iter =
f.get(input_iterator<const char*>(str), f.get(cpp17_input_iterator<const char*>(str),
input_iterator<const char*>(str+sizeof(str)), cpp17_input_iterator<const char*>(str+sizeof(str)),
ios, err, v); ios, err, v);
assert(iter.base() == str+sizeof(str)-1); assert(iter.base() == str+sizeof(str)-1);
assert(err == ios.goodbit); assert(err == ios.goodbit);
assert(v == -INFINITY); assert(v == -INFINITY);
} }
{ {
const char str[] = "-INF"; const char str[] = "-INF";
hex(ios); hex(ios);
std::ios_base::iostate err = ios.goodbit; std::ios_base::iostate err = ios.goodbit;
input_iterator<const char*> iter = cpp17_input_iterator<const char*> iter =
f.get(input_iterator<const char*>(str), f.get(cpp17_input_iterator<const char*>(str),
input_iterator<const char*>(str+sizeof(str)), cpp17_input_iterator<const char*>(str+sizeof(str)),
ios, err, v); ios, err, v);
assert(iter.base() == str+sizeof(str)-1); assert(iter.base() == str+sizeof(str)-1);
assert(err == ios.goodbit); assert(err == ios.goodbit);
assert(v == -INFINITY); assert(v == -INFINITY);
} }
{ {
const char str[] = "nan"; const char str[] = "nan";
hex(ios); hex(ios);
std::ios_base::iostate err = ios.goodbit; std::ios_base::iostate err = ios.goodbit;
input_iterator<const char*> iter = cpp17_input_iterator<const char*> iter =
f.get(input_iterator<const char*>(str), f.get(cpp17_input_iterator<const char*>(str),
input_iterator<const char*>(str+sizeof(str)), cpp17_input_iterator<const char*>(str+sizeof(str)),
ios, err, v); ios, err, v);
assert(iter.base() == str+sizeof(str)-1); assert(iter.base() == str+sizeof(str)-1);
assert(err == ios.goodbit); assert(err == ios.goodbit);
assert(std::isnan(v)); assert(std::isnan(v));
} }
{ {
const char str[] = "NAN"; const char str[] = "NAN";
hex(ios); hex(ios);
std::ios_base::iostate err = ios.goodbit; std::ios_base::iostate err = ios.goodbit;
input_iterator<const char*> iter = cpp17_input_iterator<const char*> iter =
f.get(input_iterator<const char*>(str), f.get(cpp17_input_iterator<const char*>(str),
input_iterator<const char*>(str+sizeof(str)), cpp17_input_iterator<const char*>(str+sizeof(str)),
ios, err, v); ios, err, v);
assert(iter.base() == str+sizeof(str)-1); assert(iter.base() == str+sizeof(str)-1);
assert(err == ios.goodbit); assert(err == ios.goodbit);
assert(std::isnan(v)); assert(std::isnan(v));
} }
{ {
const char str[] = "1.189731495357231765021264e+49321"; const char str[] = "1.189731495357231765021264e+49321";
std::ios_base::iostate err = ios.goodbit; std::ios_base::iostate err = ios.goodbit;
v = 0; v = 0;
input_iterator<const char*> iter = cpp17_input_iterator<const char*> iter =
f.get(input_iterator<const char*>(str), f.get(cpp17_input_iterator<const char*>(str),
input_iterator<const char*>(str+sizeof(str)), cpp17_input_iterator<const char*>(str+sizeof(str)),
ios, err, v); ios, err, v);
assert(iter.base() == str+sizeof(str)-1); assert(iter.base() == str+sizeof(str)-1);
assert(err == ios.failbit); assert(err == ios.failbit);
assert(v == INFINITY); assert(v == INFINITY);
} }
{ {
const char str[] = "1.189731495357231765021264e+49329"; const char str[] = "1.189731495357231765021264e+49329";
std::ios_base::iostate err = ios.goodbit; std::ios_base::iostate err = ios.goodbit;
v = 0; v = 0;
input_iterator<const char*> iter = cpp17_input_iterator<const char*> iter =
f.get(input_iterator<const char*>(str), f.get(cpp17_input_iterator<const char*>(str),
input_iterator<const char*>(str+sizeof(str)), cpp17_input_iterator<const char*>(str+sizeof(str)),
ios, err, v); ios, err, v);
assert(iter.base() == str+sizeof(str)-1); assert(iter.base() == str+sizeof(str)-1);
assert(err == ios.failbit); assert(err == ios.failbit);
assert(v == INFINITY); assert(v == INFINITY);
} }
{ {
const char str[] = "11.189731495357231765021264e+4932"; const char str[] = "11.189731495357231765021264e+4932";
std::ios_base::iostate err = ios.goodbit; std::ios_base::iostate err = ios.goodbit;
v = 0; v = 0;
input_iterator<const char*> iter = cpp17_input_iterator<const char*> iter =
f.get(input_iterator<const char*>(str), f.get(cpp17_input_iterator<const char*>(str),
input_iterator<const char*>(str+sizeof(str)), cpp17_input_iterator<const char*>(str+sizeof(str)),
ios, err, v); ios, err, v);
assert(iter.base() == str+sizeof(str)-1); assert(iter.base() == str+sizeof(str)-1);
assert(err == ios.failbit); assert(err == ios.failbit);
assert(v == INFINITY); assert(v == INFINITY);
} }
{ {
const char str[] = "91.189731495357231765021264e+4932"; const char str[] = "91.189731495357231765021264e+4932";
std::ios_base::iostate err = ios.goodbit; std::ios_base::iostate err = ios.goodbit;
v = 0; v = 0;
input_iterator<const char*> iter = cpp17_input_iterator<const char*> iter =
f.get(input_iterator<const char*>(str), f.get(cpp17_input_iterator<const char*>(str),
input_iterator<const char*>(str+sizeof(str)), cpp17_input_iterator<const char*>(str+sizeof(str)),
ios, err, v); ios, err, v);
assert(iter.base() == str+sizeof(str)-1); assert(iter.base() == str+sizeof(str)-1);
assert(err == ios.failbit); assert(err == ios.failbit);
assert(v == INFINITY); assert(v == INFINITY);
} }
{ {
const char str[] = "304888344611713860501504000000"; const char str[] = "304888344611713860501504000000";
std::ios_base::iostate err = ios.goodbit; std::ios_base::iostate err = ios.goodbit;
v = 0; v = 0;
input_iterator<const char*> iter = cpp17_input_iterator<const char*> iter =
f.get(input_iterator<const char*>(str), f.get(cpp17_input_iterator<const char*>(str),
input_iterator<const char*>(str+sizeof(str)), cpp17_input_iterator<const char*>(str+sizeof(str)),
ios, err, v); ios, err, v);
assert(iter.base() == str+sizeof(str)-1); assert(iter.base() == str+sizeof(str)-1);
assert(err != ios.failbit); assert(err != ios.failbit);
assert(v == 304888344611713860501504000000.0L); assert(v == 304888344611713860501504000000.0L);
} }
{ {
v = -1; v = -1;
const char str[] = "1.19973e+4933"; // unrepresentable const char str[] = "1.19973e+4933"; // unrepresentable
std::ios_base::iostate err = ios.goodbit; std::ios_base::iostate err = ios.goodbit;
input_iterator<const char*> iter = cpp17_input_iterator<const char*> iter =
f.get(input_iterator<const char*>(str), f.get(cpp17_input_iterator<const char*>(str),
input_iterator<const char*>(str+sizeof(str)), cpp17_input_iterator<const char*>(str+sizeof(str)),
ios, err, v); ios, err, v);
assert(iter.base() == str+sizeof(str)-1); assert(iter.base() == str+sizeof(str)-1);
assert(err == ios.failbit); assert(err == ios.failbit);
assert(v == HUGE_VALL); assert(v == HUGE_VALL);
} }
{ {
v = -1; v = -1;
const char str[] = "-1.18974e+4932"; // unrepresentable const char str[] = "-1.18974e+4932"; // unrepresentable
std::ios_base::iostate err = ios.goodbit; std::ios_base::iostate err = ios.goodbit;
input_iterator<const char*> iter = cpp17_input_iterator<const char*> iter =
f.get(input_iterator<const char*>(str), f.get(cpp17_input_iterator<const char*>(str),
input_iterator<const char*>(str+sizeof(str)), cpp17_input_iterator<const char*>(str+sizeof(str)),
ios, err, v); ios, err, v);
assert(iter.base() == str+sizeof(str)-1); assert(iter.base() == str+sizeof(str)-1);
assert(err == ios.failbit); assert(err == ios.failbit);
assert(v == -HUGE_VALL); assert(v == -HUGE_VALL);
} }
{ {
v = -1; v = -1;
const char str[] = "2-"; const char str[] = "2-";
std::ios_base::iostate err = ios.goodbit; std::ios_base::iostate err = ios.goodbit;
input_iterator<const char*> iter = cpp17_input_iterator<const char*> iter =
f.get(input_iterator<const char*>(str), f.get(cpp17_input_iterator<const char*>(str),
input_iterator<const char*>(str+sizeof(str)), cpp17_input_iterator<const char*>(str+sizeof(str)),
ios, err, v); ios, err, v);
assert(iter.base() == str+1); assert(iter.base() == str+1);
assert(err == ios.goodbit); assert(err == ios.goodbit);
assert(v == 2); assert(v == 2);
} }
return 0; return 0;
} }

libcxx/test/std/localization/locale.categories/category.numeric/locale.num.get/facet.num.get.members/get_long_long.pass.cpp

Show All 14 Lines
#include <locale> #include <locale>
#include <ios> #include <ios>
#include <cassert> #include <cassert>
#include <streambuf> #include <streambuf>
#include "test_macros.h" #include "test_macros.h"
#include "test_iterators.h" #include "test_iterators.h"
typedef std::num_get<char, input_iterator<const char*> > F; typedef std::num_get<char, cpp17_input_iterator<const char*> > F;
class my_facet class my_facet
: public F : public F
{ {
public: public:
explicit my_facet(std::size_t refs = 0) explicit my_facet(std::size_t refs = 0)
: F(refs) {} : F(refs) {}
}; };
Show All 12 Lines
int main(int, char**) int main(int, char**)
{ {
const my_facet f(1); const my_facet f(1);
std::ios ios(0); std::ios ios(0);
long long v = -1; long long v = -1;
{ {
const char str[] = "0"; const char str[] = "0";
std::ios_base::iostate err = ios.goodbit; std::ios_base::iostate err = ios.goodbit;
input_iterator<const char*> iter = cpp17_input_iterator<const char*> iter =
f.get(input_iterator<const char*>(str), f.get(cpp17_input_iterator<const char*>(str),
input_iterator<const char*>(str+sizeof(str)), cpp17_input_iterator<const char*>(str+sizeof(str)),
ios, err, v); ios, err, v);
assert(iter.base() == str+sizeof(str)-1); assert(iter.base() == str+sizeof(str)-1);
assert(err == ios.goodbit); assert(err == ios.goodbit);
assert(v == 0); assert(v == 0);
} }
{ {
const char str[] = "1"; const char str[] = "1";
std::ios_base::iostate err = ios.goodbit; std::ios_base::iostate err = ios.goodbit;
input_iterator<const char*> iter = cpp17_input_iterator<const char*> iter =
f.get(input_iterator<const char*>(str), f.get(cpp17_input_iterator<const char*>(str),
input_iterator<const char*>(str+sizeof(str)), cpp17_input_iterator<const char*>(str+sizeof(str)),
ios, err, v); ios, err, v);
assert(iter.base() == str+sizeof(str)-1); assert(iter.base() == str+sizeof(str)-1);
assert(err == ios.goodbit); assert(err == ios.goodbit);
assert(v == 1); assert(v == 1);
} }
{ {
const char str[] = "-1"; const char str[] = "-1";
std::ios_base::iostate err = ios.goodbit; std::ios_base::iostate err = ios.goodbit;
input_iterator<const char*> iter = cpp17_input_iterator<const char*> iter =
f.get(input_iterator<const char*>(str), f.get(cpp17_input_iterator<const char*>(str),
input_iterator<const char*>(str+sizeof(str)), cpp17_input_iterator<const char*>(str+sizeof(str)),
ios, err, v); ios, err, v);
assert(iter.base() == str+sizeof(str)-1); assert(iter.base() == str+sizeof(str)-1);
assert(err == ios.goodbit); assert(err == ios.goodbit);
assert(v == -1); assert(v == -1);
} }
hex(ios); hex(ios);
{ {
const char str[] = "0x7FFFFFFFFFFFFFFF"; const char str[] = "0x7FFFFFFFFFFFFFFF";
std::ios_base::iostate err = ios.goodbit; std::ios_base::iostate err = ios.goodbit;
input_iterator<const char*> iter = cpp17_input_iterator<const char*> iter =
f.get(input_iterator<const char*>(str), f.get(cpp17_input_iterator<const char*>(str),
input_iterator<const char*>(str+sizeof(str)), cpp17_input_iterator<const char*>(str+sizeof(str)),
ios, err, v); ios, err, v);
assert(iter.base() == str+sizeof(str)-1); assert(iter.base() == str+sizeof(str)-1);
assert(err == ios.goodbit); assert(err == ios.goodbit);
assert(v == 0x7FFFFFFFFFFFFFFFLL); assert(v == 0x7FFFFFFFFFFFFFFFLL);
} }
{ {
const char str[] = "-0x8000000000000000"; const char str[] = "-0x8000000000000000";
std::ios_base::iostate err = ios.goodbit; std::ios_base::iostate err = ios.goodbit;
input_iterator<const char*> iter = cpp17_input_iterator<const char*> iter =
f.get(input_iterator<const char*>(str), f.get(cpp17_input_iterator<const char*>(str),
input_iterator<const char*>(str+sizeof(str)), cpp17_input_iterator<const char*>(str+sizeof(str)),
ios, err, v); ios, err, v);
assert(iter.base() == str+sizeof(str)-1); assert(iter.base() == str+sizeof(str)-1);
assert(err == ios.goodbit); assert(err == ios.goodbit);
const long long expect = 0x8000000000000000LL; const long long expect = 0x8000000000000000LL;
assert(v == expect); assert(v == expect);
} }
return 0; return 0;
} }

libcxx/test/std/localization/locale.categories/category.numeric/locale.num.get/facet.num.get.members/get_pointer.pass.cpp

Show All 14 Lines
#include <locale> #include <locale>
#include <ios> #include <ios>
#include <cassert> #include <cassert>
#include <streambuf> #include <streambuf>
#include "test_macros.h" #include "test_macros.h"
#include "test_iterators.h" #include "test_iterators.h"
typedef std::num_get<char, input_iterator<const char*> > F; typedef std::num_get<char, cpp17_input_iterator<const char*> > F;
class my_facet class my_facet
: public F : public F
{ {
public: public:
explicit my_facet(std::size_t refs = 0) explicit my_facet(std::size_t refs = 0)
: F(refs) {} : F(refs) {}
}; };
int main(int, char**) int main(int, char**)
{ {
const my_facet f(1); const my_facet f(1);
std::ios ios(0); std::ios ios(0);
{ {
const char str[] = "0x0"; const char str[] = "0x0";
std::ios_base::iostate err = ios.goodbit; std::ios_base::iostate err = ios.goodbit;
void* p; void* p;
input_iterator<const char*> iter = cpp17_input_iterator<const char*> iter =
f.get(input_iterator<const char*>(str), f.get(cpp17_input_iterator<const char*>(str),
input_iterator<const char*>(str+sizeof(str)), cpp17_input_iterator<const char*>(str+sizeof(str)),
ios, err, p); ios, err, p);
assert(iter.base() == str+sizeof(str)-1); assert(iter.base() == str+sizeof(str)-1);
assert(err == ios.goodbit); assert(err == ios.goodbit);
assert(p == 0); assert(p == 0);
} }
{ {
const char str[] = "0x73"; const char str[] = "0x73";
std::ios_base::iostate err = ios.goodbit; std::ios_base::iostate err = ios.goodbit;
void* p; void* p;
input_iterator<const char*> iter = cpp17_input_iterator<const char*> iter =
f.get(input_iterator<const char*>(str), f.get(cpp17_input_iterator<const char*>(str),
input_iterator<const char*>(str+sizeof(str)), cpp17_input_iterator<const char*>(str+sizeof(str)),
ios, err, p); ios, err, p);
assert(iter.base() == str+sizeof(str)-1); assert(iter.base() == str+sizeof(str)-1);
assert(err == ios.goodbit); assert(err == ios.goodbit);
assert(p == (void*)0x73); assert(p == (void*)0x73);
} }
return 0; return 0;
} }

libcxx/test/std/localization/locale.categories/category.numeric/locale.num.get/facet.num.get.members/get_unsigned_int.pass.cpp

Show All 14 Lines
#include <locale> #include <locale>
#include <ios> #include <ios>
#include <cassert> #include <cassert>
#include <streambuf> #include <streambuf>
#include "test_macros.h" #include "test_macros.h"
#include "test_iterators.h" #include "test_iterators.h"
typedef std::num_get<char, input_iterator<const char*> > F; typedef std::num_get<char, cpp17_input_iterator<const char*> > F;
class my_facet class my_facet
: public F : public F
{ {
public: public:
explicit my_facet(std::size_t refs = 0) explicit my_facet(std::size_t refs = 0)
: F(refs) {} : F(refs) {}
}; };
Show All 12 Lines
int main(int, char**) int main(int, char**)
{ {
const my_facet f(1); const my_facet f(1);
std::ios ios(0); std::ios ios(0);
unsigned int v = static_cast<unsigned int>(-1); unsigned int v = static_cast<unsigned int>(-1);
{ {
const char str[] = "0"; const char str[] = "0";
std::ios_base::iostate err = ios.goodbit; std::ios_base::iostate err = ios.goodbit;
input_iterator<const char*> iter = cpp17_input_iterator<const char*> iter =
f.get(input_iterator<const char*>(str), f.get(cpp17_input_iterator<const char*>(str),
input_iterator<const char*>(str+sizeof(str)), cpp17_input_iterator<const char*>(str+sizeof(str)),
ios, err, v); ios, err, v);
assert(iter.base() == str+sizeof(str)-1); assert(iter.base() == str+sizeof(str)-1);
assert(err == ios.goodbit); assert(err == ios.goodbit);
assert(v == 0); assert(v == 0);
} }
{ {
const char str[] = "1"; const char str[] = "1";
std::ios_base::iostate err = ios.goodbit; std::ios_base::iostate err = ios.goodbit;
input_iterator<const char*> iter = cpp17_input_iterator<const char*> iter =
f.get(input_iterator<const char*>(str), f.get(cpp17_input_iterator<const char*>(str),
input_iterator<const char*>(str+sizeof(str)), cpp17_input_iterator<const char*>(str+sizeof(str)),
ios, err, v); ios, err, v);
assert(iter.base() == str+sizeof(str)-1); assert(iter.base() == str+sizeof(str)-1);
assert(err == ios.goodbit); assert(err == ios.goodbit);
assert(v == 1); assert(v == 1);
} }
hex(ios); hex(ios);
{ {
const char str[] = "0xFFFFFFFF"; const char str[] = "0xFFFFFFFF";
std::ios_base::iostate err = ios.goodbit; std::ios_base::iostate err = ios.goodbit;
input_iterator<const char*> iter = cpp17_input_iterator<const char*> iter =
f.get(input_iterator<const char*>(str), f.get(cpp17_input_iterator<const char*>(str),
input_iterator<const char*>(str+sizeof(str)), cpp17_input_iterator<const char*>(str+sizeof(str)),
ios, err, v); ios, err, v);
assert(iter.base() == str+sizeof(str)-1); assert(iter.base() == str+sizeof(str)-1);
assert(err == ios.goodbit); assert(err == ios.goodbit);
assert(v == 0xFFFFFFFF); assert(v == 0xFFFFFFFF);
} }
return 0; return 0;
} }

libcxx/test/std/localization/locale.categories/category.numeric/locale.num.get/facet.num.get.members/get_unsigned_long.pass.cpp

Show All 14 Lines
#include <locale> #include <locale>
#include <ios> #include <ios>
#include <cassert> #include <cassert>
#include <streambuf> #include <streambuf>
#include "test_macros.h" #include "test_macros.h"
#include "test_iterators.h" #include "test_iterators.h"
typedef std::num_get<char, input_iterator<const char*> > F; typedef std::num_get<char, cpp17_input_iterator<const char*> > F;
class my_facet class my_facet
: public F : public F
{ {
public: public:
explicit my_facet(std::size_t refs = 0) explicit my_facet(std::size_t refs = 0)
: F(refs) {} : F(refs) {}
}; };
Show All 12 Lines
int main(int, char**) int main(int, char**)
{ {
const my_facet f(1); const my_facet f(1);
std::ios ios(0); std::ios ios(0);
unsigned long v = static_cast<unsigned long>(-1); unsigned long v = static_cast<unsigned long>(-1);
{ {
const char str[] = "0"; const char str[] = "0";
std::ios_base::iostate err = ios.goodbit; std::ios_base::iostate err = ios.goodbit;
input_iterator<const char*> iter = cpp17_input_iterator<const char*> iter =
f.get(input_iterator<const char*>(str), f.get(cpp17_input_iterator<const char*>(str),
input_iterator<const char*>(str+sizeof(str)), cpp17_input_iterator<const char*>(str+sizeof(str)),
ios, err, v); ios, err, v);
assert(iter.base() == str+sizeof(str)-1); assert(iter.base() == str+sizeof(str)-1);
assert(err == ios.goodbit); assert(err == ios.goodbit);
assert(v == 0); assert(v == 0);
} }
{ {
const char str[] = "1"; const char str[] = "1";
std::ios_base::iostate err = ios.goodbit; std::ios_base::iostate err = ios.goodbit;
input_iterator<const char*> iter = cpp17_input_iterator<const char*> iter =
f.get(input_iterator<const char*>(str), f.get(cpp17_input_iterator<const char*>(str),
input_iterator<const char*>(str+sizeof(str)), cpp17_input_iterator<const char*>(str+sizeof(str)),
ios, err, v); ios, err, v);
assert(iter.base() == str+sizeof(str)-1); assert(iter.base() == str+sizeof(str)-1);
assert(err == ios.goodbit); assert(err == ios.goodbit);
assert(v == 1); assert(v == 1);
} }
hex(ios); hex(ios);
{ {
const char str[] = "0xFFFFFFFF"; const char str[] = "0xFFFFFFFF";
std::ios_base::iostate err = ios.goodbit; std::ios_base::iostate err = ios.goodbit;
input_iterator<const char*> iter = cpp17_input_iterator<const char*> iter =
f.get(input_iterator<const char*>(str), f.get(cpp17_input_iterator<const char*>(str),
input_iterator<const char*>(str+sizeof(str)), cpp17_input_iterator<const char*>(str+sizeof(str)),
ios, err, v); ios, err, v);
assert(iter.base() == str+sizeof(str)-1); assert(iter.base() == str+sizeof(str)-1);
assert(err == ios.goodbit); assert(err == ios.goodbit);
assert(v == 0xFFFFFFFF); assert(v == 0xFFFFFFFF);
} }
return 0; return 0;
} }

libcxx/test/std/localization/locale.categories/category.numeric/locale.num.get/facet.num.get.members/get_unsigned_long_long.pass.cpp

Show All 14 Lines
#include <locale> #include <locale>
#include <ios> #include <ios>
#include <cassert> #include <cassert>
#include <streambuf> #include <streambuf>
#include "test_macros.h" #include "test_macros.h"
#include "test_iterators.h" #include "test_iterators.h"
typedef std::num_get<char, input_iterator<const char*> > F; typedef std::num_get<char, cpp17_input_iterator<const char*> > F;
class my_facet class my_facet
: public F : public F
{ {
public: public:
explicit my_facet(std::size_t refs = 0) explicit my_facet(std::size_t refs = 0)
: F(refs) {} : F(refs) {}
}; };
Show All 12 Lines
int main(int, char**) int main(int, char**)
{ {
const my_facet f(1); const my_facet f(1);
std::ios ios(0); std::ios ios(0);
unsigned long long v = static_cast<unsigned long long>(-1); unsigned long long v = static_cast<unsigned long long>(-1);
{ {
const char str[] = "0"; const char str[] = "0";
std::ios_base::iostate err = ios.goodbit; std::ios_base::iostate err = ios.goodbit;
input_iterator<const char*> iter = cpp17_input_iterator<const char*> iter =
f.get(input_iterator<const char*>(str), f.get(cpp17_input_iterator<const char*>(str),
input_iterator<const char*>(str+sizeof(str)), cpp17_input_iterator<const char*>(str+sizeof(str)),
ios, err, v); ios, err, v);
assert(iter.base() == str+sizeof(str)-1); assert(iter.base() == str+sizeof(str)-1);
assert(err == ios.goodbit); assert(err == ios.goodbit);
assert(v == 0); assert(v == 0);
} }
{ {
const char str[] = "1"; const char str[] = "1";
std::ios_base::iostate err = ios.goodbit; std::ios_base::iostate err = ios.goodbit;
input_iterator<const char*> iter = cpp17_input_iterator<const char*> iter =
f.get(input_iterator<const char*>(str), f.get(cpp17_input_iterator<const char*>(str),
input_iterator<const char*>(str+sizeof(str)), cpp17_input_iterator<const char*>(str+sizeof(str)),
ios, err, v); ios, err, v);
assert(iter.base() == str+sizeof(str)-1); assert(iter.base() == str+sizeof(str)-1);
assert(err == ios.goodbit); assert(err == ios.goodbit);
assert(v == 1); assert(v == 1);
} }
hex(ios); hex(ios);
{ {
const char str[] = "0xFFFFFFFFFFFFFFFF"; const char str[] = "0xFFFFFFFFFFFFFFFF";
std::ios_base::iostate err = ios.goodbit; std::ios_base::iostate err = ios.goodbit;
input_iterator<const char*> iter = cpp17_input_iterator<const char*> iter =
f.get(input_iterator<const char*>(str), f.get(cpp17_input_iterator<const char*>(str),
input_iterator<const char*>(str+sizeof(str)), cpp17_input_iterator<const char*>(str+sizeof(str)),
ios, err, v); ios, err, v);
assert(iter.base() == str+sizeof(str)-1); assert(iter.base() == str+sizeof(str)-1);
assert(err == ios.goodbit); assert(err == ios.goodbit);
assert(v == 0xFFFFFFFFFFFFFFFFULL); assert(v == 0xFFFFFFFFFFFFFFFFULL);
} }
return 0; return 0;
} }

libcxx/test/std/localization/locale.categories/category.numeric/locale.num.get/facet.num.get.members/get_unsigned_short.pass.cpp

Show All 14 Lines
#include <locale> #include <locale>
#include <ios> #include <ios>
#include <cassert> #include <cassert>
#include <streambuf> #include <streambuf>
#include "test_macros.h" #include "test_macros.h"
#include "test_iterators.h" #include "test_iterators.h"
typedef std::num_get<char, input_iterator<const char*> > F; typedef std::num_get<char, cpp17_input_iterator<const char*> > F;
class my_facet class my_facet
: public F : public F
{ {
public: public:
explicit my_facet(std::size_t refs = 0) explicit my_facet(std::size_t refs = 0)
: F(refs) {} : F(refs) {}
}; };
Show All 12 Lines
int main(int, char**) int main(int, char**)
{ {
const my_facet f(1); const my_facet f(1);
std::ios ios(0); std::ios ios(0);
unsigned short v = static_cast<unsigned short>(-1); unsigned short v = static_cast<unsigned short>(-1);
{ {
const char str[] = "0"; const char str[] = "0";
std::ios_base::iostate err = ios.goodbit; std::ios_base::iostate err = ios.goodbit;
input_iterator<const char*> iter = cpp17_input_iterator<const char*> iter =
f.get(input_iterator<const char*>(str), f.get(cpp17_input_iterator<const char*>(str),
input_iterator<const char*>(str+sizeof(str)), cpp17_input_iterator<const char*>(str+sizeof(str)),
ios, err, v); ios, err, v);
assert(iter.base() == str+sizeof(str)-1); assert(iter.base() == str+sizeof(str)-1);
assert(err == ios.goodbit); assert(err == ios.goodbit);
assert(v == 0); assert(v == 0);
} }
{ {
const char str[] = "1"; const char str[] = "1";
std::ios_base::iostate err = ios.goodbit; std::ios_base::iostate err = ios.goodbit;
input_iterator<const char*> iter = cpp17_input_iterator<const char*> iter =
f.get(input_iterator<const char*>(str), f.get(cpp17_input_iterator<const char*>(str),
input_iterator<const char*>(str+sizeof(str)), cpp17_input_iterator<const char*>(str+sizeof(str)),
ios, err, v); ios, err, v);
assert(iter.base() == str+sizeof(str)-1); assert(iter.base() == str+sizeof(str)-1);
assert(err == ios.goodbit); assert(err == ios.goodbit);
assert(v == 1); assert(v == 1);
} }
hex(ios); hex(ios);
{ {
const char str[] = "0xFFFF"; const char str[] = "0xFFFF";
std::ios_base::iostate err = ios.goodbit; std::ios_base::iostate err = ios.goodbit;
input_iterator<const char*> iter = cpp17_input_iterator<const char*> iter =
f.get(input_iterator<const char*>(str), f.get(cpp17_input_iterator<const char*>(str),
input_iterator<const char*>(str+sizeof(str)), cpp17_input_iterator<const char*>(str+sizeof(str)),
ios, err, v); ios, err, v);
assert(iter.base() == str+sizeof(str)-1); assert(iter.base() == str+sizeof(str)-1);
assert(err == ios.goodbit); assert(err == ios.goodbit);
assert(v == 0xFFFF); assert(v == 0xFFFF);
} }
return 0; return 0;
} }

libcxx/test/std/localization/locale.categories/category.numeric/locale.num.get/facet.num.get.members/test_neg_one.pass.cpp

Show All 20 Lines
#include <sstream> #include <sstream>
#include "test_iterators.h" #include "test_iterators.h"
#include "test_macros.h" #include "test_macros.h"
#ifdef TEST_COMPILER_C1XX #ifdef TEST_COMPILER_C1XX
#pragma warning(disable: 4146) // unary minus operator applied to unsigned type, result still unsigned #pragma warning(disable: 4146) // unary minus operator applied to unsigned type, result still unsigned
#endif #endif
typedef std::num_get<char, input_iterator<const char*> > F; typedef std::num_get<char, cpp17_input_iterator<const char*> > F;
class my_facet class my_facet
: public F : public F
{ {
public: public:
explicit my_facet(std::size_t refs = 0) explicit my_facet(std::size_t refs = 0)
: F(refs) {} : F(refs) {}
}; };
Show All 9 Lines
template <class T> template <class T>
void test_neg_one() { void test_neg_one() {
const my_facet f(1); const my_facet f(1);
std::ios ios(0); std::ios ios(0);
T v = static_cast<T>(42); T v = static_cast<T>(42);
{ {
const char str[] = "-1"; const char str[] = "-1";
std::ios_base::iostate err = ios.goodbit; std::ios_base::iostate err = ios.goodbit;
input_iterator<const char*> iter = cpp17_input_iterator<const char*> iter =
f.get(input_iterator<const char*>(str), f.get(cpp17_input_iterator<const char*>(str),
input_iterator<const char*>(str+sizeof(str)), cpp17_input_iterator<const char*>(str+sizeof(str)),
ios, err, v); ios, err, v);
assert(iter.base() == str+sizeof(str)-1); assert(iter.base() == str+sizeof(str)-1);
assert(err == ios.goodbit); assert(err == ios.goodbit);
assert(v == T(-1)); assert(v == T(-1));
} }
v = 42; v = 42;
{ {
const char str[] = "-"; const char str[] = "-";
std::ios_base::iostate err = ios.goodbit; std::ios_base::iostate err = ios.goodbit;
input_iterator<const char*> iter = cpp17_input_iterator<const char*> iter =
f.get(input_iterator<const char*>(str), f.get(cpp17_input_iterator<const char*>(str),
input_iterator<const char*>(str+sizeof(str)), cpp17_input_iterator<const char*>(str+sizeof(str)),
ios, err, v); ios, err, v);
assert(iter.base() == str+sizeof(str)-1); assert(iter.base() == str+sizeof(str)-1);
assert(err == ios.failbit); assert(err == ios.failbit);
assert(v == 0); assert(v == 0);
} }
} }
template <class T> template <class T>
void test_negate() { void test_negate() {
typedef typename std::make_signed<T>::type SignedT; typedef typename std::make_signed<T>::type SignedT;
const my_facet f(1); const my_facet f(1);
std::ios ios(0); std::ios ios(0);
T v = 42; T v = 42;
{ {
T value = std::numeric_limits<SignedT>::max(); T value = std::numeric_limits<SignedT>::max();
++value; ++value;
std::string std_str = make_neg_string(value); std::string std_str = make_neg_string(value);
const char* str = std_str.data(); const char* str = std_str.data();
size_t size = std_str.size(); size_t size = std_str.size();
std::ios_base::iostate err = ios.goodbit; std::ios_base::iostate err = ios.goodbit;
input_iterator<const char*> iter = cpp17_input_iterator<const char*> iter =
f.get(input_iterator<const char*>(str), f.get(cpp17_input_iterator<const char*>(str),
input_iterator<const char*>(str+size+1), cpp17_input_iterator<const char*>(str+size+1),
ios, err, v); ios, err, v);
assert(iter.base() == str+size); assert(iter.base() == str+size);
assert(err == ios.goodbit); assert(err == ios.goodbit);
T expected = -value; T expected = -value;
assert(v == expected); assert(v == expected);
} }
v = 42; v = 42;
{ {
T value = std::numeric_limits<SignedT>::max(); T value = std::numeric_limits<SignedT>::max();
++value; ++value;
++value; ++value;
std::string std_str = make_neg_string(value); std::string std_str = make_neg_string(value);
const char* str = std_str.data(); const char* str = std_str.data();
size_t size = std_str.size(); size_t size = std_str.size();
std::ios_base::iostate err = ios.goodbit; std::ios_base::iostate err = ios.goodbit;
input_iterator<const char*> iter = cpp17_input_iterator<const char*> iter =
f.get(input_iterator<const char*>(str), f.get(cpp17_input_iterator<const char*>(str),
input_iterator<const char*>(str+size+1), cpp17_input_iterator<const char*>(str+size+1),
ios, err, v); ios, err, v);
assert(iter.base() == str+size); assert(iter.base() == str+size);
assert(err == ios.goodbit); assert(err == ios.goodbit);
T expected = -value; T expected = -value;
assert(v == expected); assert(v == expected);
} }
v = 42; v = 42;
{ {
T value = std::numeric_limits<T>::max(); T value = std::numeric_limits<T>::max();
std::string std_str = make_neg_string(value); std::string std_str = make_neg_string(value);
const char* str = std_str.data(); const char* str = std_str.data();
size_t size = std_str.size(); size_t size = std_str.size();
std::ios_base::iostate err = ios.goodbit; std::ios_base::iostate err = ios.goodbit;
input_iterator<const char*> iter = cpp17_input_iterator<const char*> iter =
f.get(input_iterator<const char*>(str), f.get(cpp17_input_iterator<const char*>(str),
input_iterator<const char*>(str+size+1), cpp17_input_iterator<const char*>(str+size+1),
ios, err, v); ios, err, v);
assert(iter.base() == str+size); assert(iter.base() == str+size);
assert(err == ios.goodbit); assert(err == ios.goodbit);
T expected = -value; T expected = -value;
assert(v == expected); assert(v == expected);
} }
v = 42; v = 42;
{ {
std::string std_str = make_neg_string(std::numeric_limits<T>::max()); std::string std_str = make_neg_string(std::numeric_limits<T>::max());
std_str.back()++; std_str.back()++;
const char* str = std_str.data(); const char* str = std_str.data();
size_t size = std_str.size(); size_t size = std_str.size();
std::ios_base::iostate err = ios.goodbit; std::ios_base::iostate err = ios.goodbit;
input_iterator<const char*> iter = cpp17_input_iterator<const char*> iter =
f.get(input_iterator<const char*>(str), f.get(cpp17_input_iterator<const char*>(str),
input_iterator<const char*>(str+size+1), cpp17_input_iterator<const char*>(str+size+1),
ios, err, v); ios, err, v);
assert(iter.base() == str+size); assert(iter.base() == str+size);
assert(err == ios.failbit); assert(err == ios.failbit);
assert(v == T(-1)); assert(v == T(-1));
} }
} }
int main(int, char**) int main(int, char**)
Show All 15 Lines

libcxx/test/std/localization/locale.categories/category.time/locale.time.get.byname/date_order.pass.cpp

Show All 18 Lines
#include <locale> #include <locale>
#include <cassert> #include <cassert>
#include "test_macros.h" #include "test_macros.h"
#include "test_iterators.h" #include "test_iterators.h"
#include "platform_support.h" // locale name macros #include "platform_support.h" // locale name macros
typedef std::time_get_byname<char, input_iterator<const char*> > F; typedef std::time_get_byname<char, cpp17_input_iterator<const char*> > F;
class my_facet class my_facet
: public F : public F
{ {
public: public:
explicit my_facet(const std::string& nm, std::size_t refs = 0) explicit my_facet(const std::string& nm, std::size_t refs = 0)
: F(nm, refs) {} : F(nm, refs) {}
}; };
Show All 22 Lines

libcxx/test/std/localization/locale.categories/category.time/locale.time.get.byname/date_order_wide.pass.cpp

Show All 18 Lines
#include <locale> #include <locale>
#include <cassert> #include <cassert>
#include "test_macros.h" #include "test_macros.h"
#include "test_iterators.h" #include "test_iterators.h"
#include "platform_support.h" // locale name macros #include "platform_support.h" // locale name macros
typedef std::time_get_byname<wchar_t, input_iterator<const wchar_t*> > F; typedef std::time_get_byname<wchar_t, cpp17_input_iterator<const wchar_t*> > F;
class my_facet class my_facet
: public F : public F
{ {
public: public:
explicit my_facet(const std::string& nm, std::size_t refs = 0) explicit my_facet(const std::string& nm, std::size_t refs = 0)
: F(nm, refs) {} : F(nm, refs) {}
}; };
Show All 22 Lines

libcxx/test/std/localization/locale.categories/category.time/locale.time.get.byname/get_date.pass.cpp

Show All 29 Lines
#include <locale> #include <locale>
#include <cassert> #include <cassert>
#include "test_macros.h" #include "test_macros.h"
#include "test_iterators.h" #include "test_iterators.h"
#include "platform_support.h" // locale name macros #include "platform_support.h" // locale name macros
typedef input_iterator<const char*> I; typedef cpp17_input_iterator<const char*> I;
typedef std::time_get_byname<char, I> F; typedef std::time_get_byname<char, I> F;
class my_facet class my_facet
: public F : public F
{ {
public: public:
explicit my_facet(const std::string& nm, std::size_t refs = 0) explicit my_facet(const std::string& nm, std::size_t refs = 0)
▲ Show 20 Lines • Show All 60 Lines • Show Last 20 Lines

libcxx/test/std/localization/locale.categories/category.time/locale.time.get.byname/get_date_wide.pass.cpp

Show All 29 Lines
#include <locale> #include <locale>
#include <cassert> #include <cassert>
#include "test_macros.h" #include "test_macros.h"
#include "test_iterators.h" #include "test_iterators.h"
#include "platform_support.h" // locale name macros #include "platform_support.h" // locale name macros
typedef input_iterator<const wchar_t*> I; typedef cpp17_input_iterator<const wchar_t*> I;
typedef std::time_get_byname<wchar_t, I> F; typedef std::time_get_byname<wchar_t, I> F;
class my_facet class my_facet
: public F : public F
{ {
public: public:
explicit my_facet(const std::string& nm, std::size_t refs = 0) explicit my_facet(const std::string& nm, std::size_t refs = 0)
▲ Show 20 Lines • Show All 59 Lines • Show Last 20 Lines

libcxx/test/std/localization/locale.categories/category.time/locale.time.get.byname/get_monthname.pass.cpp

Show All 21 Lines
#include <locale> #include <locale>
#include <cassert> #include <cassert>
#include "test_macros.h" #include "test_macros.h"
#include "test_iterators.h" #include "test_iterators.h"
#include "platform_support.h" // locale name macros #include "platform_support.h" // locale name macros
typedef input_iterator<const char*> I; typedef cpp17_input_iterator<const char*> I;
typedef std::time_get_byname<char, I> F; typedef std::time_get_byname<char, I> F;
class my_facet class my_facet
: public F : public F
{ {
public: public:
explicit my_facet(const std::string& nm, std::size_t refs = 0) explicit my_facet(const std::string& nm, std::size_t refs = 0)
▲ Show 20 Lines • Show All 41 Lines • Show Last 20 Lines

libcxx/test/std/localization/locale.categories/category.time/locale.time.get.byname/get_monthname_wide.pass.cpp

Show All 19 Lines
#include <locale> #include <locale>
#include <cassert> #include <cassert>
#include "test_macros.h" #include "test_macros.h"
#include "test_iterators.h" #include "test_iterators.h"
#include "platform_support.h" // locale name macros #include "platform_support.h" // locale name macros
typedef input_iterator<const wchar_t*> I; typedef cpp17_input_iterator<const wchar_t*> I;
typedef std::time_get_byname<wchar_t, I> F; typedef std::time_get_byname<wchar_t, I> F;
class my_facet class my_facet
: public F : public F
{ {
public: public:
explicit my_facet(const std::string& nm, std::size_t refs = 0) explicit my_facet(const std::string& nm, std::size_t refs = 0)
▲ Show 20 Lines • Show All 50 Lines • Show Last 20 Lines

libcxx/test/std/localization/locale.categories/category.time/locale.time.get.byname/get_one.pass.cpp

Show All 27 Lines
#include <locale> #include <locale>
#include <cassert> #include <cassert>
#include "test_macros.h" #include "test_macros.h"
#include "test_iterators.h" #include "test_iterators.h"
#include "platform_support.h" // locale name macros #include "platform_support.h" // locale name macros
typedef input_iterator<const char*> I; typedef cpp17_input_iterator<const char*> I;
typedef std::time_get_byname<char, I> F; typedef std::time_get_byname<char, I> F;
class my_facet class my_facet
: public F : public F
{ {
public: public:
explicit my_facet(const std::string& nm, std::size_t refs = 0) explicit my_facet(const std::string& nm, std::size_t refs = 0)
▲ Show 20 Lines • Show All 131 Lines • Show Last 20 Lines

libcxx/test/std/localization/locale.categories/category.time/locale.time.get.byname/get_one_wide.pass.cpp

Show All 27 Lines
#include <locale> #include <locale>
#include <cassert> #include <cassert>
#include "test_macros.h" #include "test_macros.h"
#include "test_iterators.h" #include "test_iterators.h"
#include "platform_support.h" // locale name macros #include "platform_support.h" // locale name macros
typedef input_iterator<const wchar_t*> I; typedef cpp17_input_iterator<const wchar_t*> I;
typedef std::time_get_byname<wchar_t, I> F; typedef std::time_get_byname<wchar_t, I> F;
class my_facet class my_facet
: public F : public F
{ {
public: public:
explicit my_facet(const std::string& nm, std::size_t refs = 0) explicit my_facet(const std::string& nm, std::size_t refs = 0)
▲ Show 20 Lines • Show All 133 Lines • Show Last 20 Lines

libcxx/test/std/localization/locale.categories/category.time/locale.time.get.byname/get_time.pass.cpp

Show All 21 Lines
#include <locale> #include <locale>
#include <cassert> #include <cassert>
#include <ios> #include <ios>
#include "test_macros.h" #include "test_macros.h"
#include "test_iterators.h" #include "test_iterators.h"
#include "platform_support.h" // locale name macros #include "platform_support.h" // locale name macros
typedef input_iterator<const char*> I; typedef cpp17_input_iterator<const char*> I;
typedef std::time_get_byname<char, I> F; typedef std::time_get_byname<char, I> F;
class my_facet class my_facet
: public F : public F
{ {
public: public:
explicit my_facet(const std::string& nm, std::size_t refs = 0) explicit my_facet(const std::string& nm, std::size_t refs = 0)
▲ Show 20 Lines • Show All 59 Lines • Show Last 20 Lines

libcxx/test/std/localization/locale.categories/category.time/locale.time.get.byname/get_time_wide.pass.cpp

Show All 21 Lines
#include <locale> #include <locale>
#include <cassert> #include <cassert>
#include <ios> #include <ios>
#include "test_macros.h" #include "test_macros.h"
#include "test_iterators.h" #include "test_iterators.h"
#include "platform_support.h" // locale name macros #include "platform_support.h" // locale name macros
typedef input_iterator<const wchar_t*> I; typedef cpp17_input_iterator<const wchar_t*> I;
typedef std::time_get_byname<wchar_t, I> F; typedef std::time_get_byname<wchar_t, I> F;
class my_facet class my_facet
: public F : public F
{ {
public: public:
explicit my_facet(const std::string& nm, std::size_t refs = 0) explicit my_facet(const std::string& nm, std::size_t refs = 0)
▲ Show 20 Lines • Show All 59 Lines • Show Last 20 Lines

libcxx/test/std/localization/locale.categories/category.time/locale.time.get.byname/get_weekday.pass.cpp

Show All 25 Lines
#include <locale> #include <locale>
#include <cassert> #include <cassert>
#include "test_macros.h" #include "test_macros.h"
#include "test_iterators.h" #include "test_iterators.h"
#include "platform_support.h" // locale name macros #include "platform_support.h" // locale name macros
typedef input_iterator<const char*> I; typedef cpp17_input_iterator<const char*> I;
typedef std::time_get_byname<char, I> F; typedef std::time_get_byname<char, I> F;
class my_facet class my_facet
: public F : public F
{ {
public: public:
explicit my_facet(const std::string& nm, std::size_t refs = 0) explicit my_facet(const std::string& nm, std::size_t refs = 0)
▲ Show 20 Lines • Show All 53 Lines • Show Last 20 Lines

libcxx/test/std/localization/locale.categories/category.time/locale.time.get.byname/get_weekday_wide.pass.cpp

Show All 23 Lines
#include <locale> #include <locale>
#include <cassert> #include <cassert>
#include "test_macros.h" #include "test_macros.h"
#include "test_iterators.h" #include "test_iterators.h"
#include "platform_support.h" // locale name macros #include "platform_support.h" // locale name macros
typedef input_iterator<const wchar_t*> I; typedef cpp17_input_iterator<const wchar_t*> I;
typedef std::time_get_byname<wchar_t, I> F; typedef std::time_get_byname<wchar_t, I> F;
class my_facet class my_facet
: public F : public F
{ {
public: public:
explicit my_facet(const std::string& nm, std::size_t refs = 0) explicit my_facet(const std::string& nm, std::size_t refs = 0)
▲ Show 20 Lines • Show All 51 Lines • Show Last 20 Lines

libcxx/test/std/localization/locale.categories/category.time/locale.time.get.byname/get_year.pass.cpp

Show All 20 Lines
#include <locale> #include <locale>
#include <cassert> #include <cassert>
#include <ios> #include <ios>
#include "test_macros.h" #include "test_macros.h"
#include "test_iterators.h" #include "test_iterators.h"
#include "platform_support.h" // locale name macros #include "platform_support.h" // locale name macros
typedef input_iterator<const char*> I; typedef cpp17_input_iterator<const char*> I;
typedef std::time_get_byname<char, I> F; typedef std::time_get_byname<char, I> F;
class my_facet class my_facet
: public F : public F
{ {
public: public:
explicit my_facet(const std::string& nm, std::size_t refs = 0) explicit my_facet(const std::string& nm, std::size_t refs = 0)
▲ Show 20 Lines • Show All 51 Lines • Show Last 20 Lines

libcxx/test/std/localization/locale.categories/category.time/locale.time.get.byname/get_year_wide.pass.cpp

Show All 20 Lines
#include <locale> #include <locale>
#include <cassert> #include <cassert>
#include <ios> #include <ios>
#include "test_macros.h" #include "test_macros.h"
#include "test_iterators.h" #include "test_iterators.h"
#include "platform_support.h" // locale name macros #include "platform_support.h" // locale name macros
typedef input_iterator<const wchar_t*> I; typedef cpp17_input_iterator<const wchar_t*> I;
typedef std::time_get_byname<wchar_t, I> F; typedef std::time_get_byname<wchar_t, I> F;
class my_facet class my_facet
: public F : public F
{ {
public: public:
explicit my_facet(const std::string& nm, std::size_t refs = 0) explicit my_facet(const std::string& nm, std::size_t refs = 0)
▲ Show 20 Lines • Show All 51 Lines • Show Last 20 Lines

libcxx/test/std/localization/locale.categories/category.time/locale.time.get/locale.time.get.members/date_order.pass.cpp

Show All 11 Lines
// dateorder date_order() const; // dateorder date_order() const;
#include <locale> #include <locale>
#include <cassert> #include <cassert>
#include "test_macros.h" #include "test_macros.h"
#include "test_iterators.h" #include "test_iterators.h"
typedef std::time_get<char, input_iterator<const char*> > F; typedef std::time_get<char, cpp17_input_iterator<const char*> > F;
class my_facet class my_facet
: public F : public F
{ {
public: public:
explicit my_facet(std::size_t refs = 0) explicit my_facet(std::size_t refs = 0)
: F(refs) {} : F(refs) {}
}; };
int main(int, char**) int main(int, char**)
{ {
const my_facet f(1); const my_facet f(1);
assert(f.date_order() == std::time_base::mdy); assert(f.date_order() == std::time_base::mdy);
return 0; return 0;
} }

libcxx/test/std/localization/locale.categories/category.time/locale.time.get/locale.time.get.members/get_date.pass.cpp

Show All 14 Lines
// ios_base::iostate& err, tm* t) const; // ios_base::iostate& err, tm* t) const;
#include <locale> #include <locale>
#include <cassert> #include <cassert>
#include <ios> #include <ios>
#include "test_macros.h" #include "test_macros.h"
#include "test_iterators.h" #include "test_iterators.h"
typedef input_iterator<const char*> I; typedef cpp17_input_iterator<const char*> I;
typedef std::time_get<char, I> F; typedef std::time_get<char, I> F;
class my_facet class my_facet
: public F : public F
{ {
public: public:
explicit my_facet(std::size_t refs = 0) explicit my_facet(std::size_t refs = 0)
Show All 23 Lines

libcxx/test/std/localization/locale.categories/category.time/locale.time.get/locale.time.get.members/get_date_wide.pass.cpp

Show All 14 Lines
// ios_base::iostate& err, tm* t) const; // ios_base::iostate& err, tm* t) const;
#include <locale> #include <locale>
#include <cassert> #include <cassert>
#include <ios> #include <ios>
#include "test_macros.h" #include "test_macros.h"
#include "test_iterators.h" #include "test_iterators.h"
typedef input_iterator<const wchar_t*> I; typedef cpp17_input_iterator<const wchar_t*> I;
typedef std::time_get<wchar_t, I> F; typedef std::time_get<wchar_t, I> F;
class my_facet class my_facet
: public F : public F
{ {
public: public:
explicit my_facet(std::size_t refs = 0) explicit my_facet(std::size_t refs = 0)
Show All 23 Lines

libcxx/test/std/localization/locale.categories/category.time/locale.time.get/locale.time.get.members/get_many.pass.cpp

Show All 14 Lines
// const char_type *fmt, const char_type *fmtend) const; // const char_type *fmt, const char_type *fmtend) const;
#include <locale> #include <locale>
#include <cassert> #include <cassert>
#include <ios> #include <ios>
#include "test_macros.h" #include "test_macros.h"
#include "test_iterators.h" #include "test_iterators.h"
typedef input_iterator<const char*> I; typedef cpp17_input_iterator<const char*> I;
typedef std::time_get<char, I> F; typedef std::time_get<char, I> F;
class my_facet class my_facet
: public F : public F
{ {
public: public:
explicit my_facet(std::size_t refs = 0) explicit my_facet(std::size_t refs = 0)
Show All 40 Lines

libcxx/test/std/localization/locale.categories/category.time/locale.time.get/locale.time.get.members/get_monthname.pass.cpp

Show All 13 Lines
// get_monthname(iter_type s, iter_type end, ios_base& str, // get_monthname(iter_type s, iter_type end, ios_base& str,
// ios_base::iostate& err, tm* t) const; // ios_base::iostate& err, tm* t) const;
#include <locale> #include <locale>
#include <cassert> #include <cassert>
#include "test_macros.h" #include "test_macros.h"
#include "test_iterators.h" #include "test_iterators.h"
typedef input_iterator<const char*> I; typedef cpp17_input_iterator<const char*> I;
typedef std::time_get<char, I> F; typedef std::time_get<char, I> F;
class my_facet class my_facet
: public F : public F
{ {
public: public:
explicit my_facet(std::size_t refs = 0) explicit my_facet(std::size_t refs = 0)
▲ Show 20 Lines • Show All 237 Lines • Show Last 20 Lines

libcxx/test/std/localization/locale.categories/category.time/locale.time.get/locale.time.get.members/get_monthname_wide.pass.cpp

Show All 13 Lines
// get_monthname(iter_type s, iter_type end, ios_base& str, // get_monthname(iter_type s, iter_type end, ios_base& str,
// ios_base::iostate& err, tm* t) const; // ios_base::iostate& err, tm* t) const;
#include <locale> #include <locale>
#include <cassert> #include <cassert>
#include "test_macros.h" #include "test_macros.h"
#include "test_iterators.h" #include "test_iterators.h"
typedef input_iterator<const wchar_t*> I; typedef cpp17_input_iterator<const wchar_t*> I;
typedef std::time_get<wchar_t, I> F; typedef std::time_get<wchar_t, I> F;
class my_facet class my_facet
: public F : public F
{ {
public: public:
explicit my_facet(std::size_t refs = 0) explicit my_facet(std::size_t refs = 0)
▲ Show 20 Lines • Show All 237 Lines • Show Last 20 Lines

libcxx/test/std/localization/locale.categories/category.time/locale.time.get/locale.time.get.members/get_one.pass.cpp

Show All 12 Lines
// iter_type get(iter_type s, iter_type end, ios_base& f, // iter_type get(iter_type s, iter_type end, ios_base& f,
// ios_base::iostate& err, tm *t, char format, char modifier = 0) const; // ios_base::iostate& err, tm *t, char format, char modifier = 0) const;
#include <locale> #include <locale>
#include <cassert> #include <cassert>
#include "test_macros.h" #include "test_macros.h"
#include "test_iterators.h" #include "test_iterators.h"
typedef input_iterator<const char*> I; typedef cpp17_input_iterator<const char*> I;
typedef std::time_get<char, I> F; typedef std::time_get<char, I> F;
class my_facet class my_facet
: public F : public F
{ {
public: public:
explicit my_facet(std::size_t refs = 0) explicit my_facet(std::size_t refs = 0)
▲ Show 20 Lines • Show All 278 Lines • Show Last 20 Lines

libcxx/test/std/localization/locale.categories/category.time/locale.time.get/locale.time.get.members/get_time.pass.cpp

Show All 13 Lines
// get_time(iter_type s, iter_type end, ios_base& str, // get_time(iter_type s, iter_type end, ios_base& str,
// ios_base::iostate& err, tm* t) const; // ios_base::iostate& err, tm* t) const;
#include <locale> #include <locale>
#include <cassert> #include <cassert>
#include "test_macros.h" #include "test_macros.h"
#include "test_iterators.h" #include "test_iterators.h"
typedef input_iterator<const char*> I; typedef cpp17_input_iterator<const char*> I;
typedef std::time_get<char, I> F; typedef std::time_get<char, I> F;
class my_facet class my_facet
: public F : public F
{ {
public: public:
explicit my_facet(std::size_t refs = 0) explicit my_facet(std::size_t refs = 0)
▲ Show 20 Lines • Show All 89 Lines • Show Last 20 Lines

libcxx/test/std/localization/locale.categories/category.time/locale.time.get/locale.time.get.members/get_time_wide.pass.cpp

Show All 13 Lines
// get_time(iter_type s, iter_type end, ios_base& str, // get_time(iter_type s, iter_type end, ios_base& str,
// ios_base::iostate& err, tm* t) const; // ios_base::iostate& err, tm* t) const;
#include <locale> #include <locale>
#include <cassert> #include <cassert>
#include "test_macros.h" #include "test_macros.h"
#include "test_iterators.h" #include "test_iterators.h"
typedef input_iterator<const wchar_t*> I; typedef cpp17_input_iterator<const wchar_t*> I;
typedef std::time_get<wchar_t, I> F; typedef std::time_get<wchar_t, I> F;
class my_facet class my_facet
: public F : public F
{ {
public: public:
explicit my_facet(std::size_t refs = 0) explicit my_facet(std::size_t refs = 0)
▲ Show 20 Lines • Show All 89 Lines • Show Last 20 Lines

libcxx/test/std/localization/locale.categories/category.time/locale.time.get/locale.time.get.members/get_weekday.pass.cpp

Show All 13 Lines
// get_weekday(iter_type s, iter_type end, ios_base& str, // get_weekday(iter_type s, iter_type end, ios_base& str,
// ios_base::iostate& err, tm* t) const; // ios_base::iostate& err, tm* t) const;
#include <locale> #include <locale>
#include <cassert> #include <cassert>
#include "test_macros.h" #include "test_macros.h"
#include "test_iterators.h" #include "test_iterators.h"
typedef input_iterator<const char*> I; typedef cpp17_input_iterator<const char*> I;
typedef std::time_get<char, I> F; typedef std::time_get<char, I> F;
class my_facet class my_facet
: public F : public F
{ {
public: public:
explicit my_facet(std::size_t refs = 0) explicit my_facet(std::size_t refs = 0)
▲ Show 20 Lines • Show All 192 Lines • Show Last 20 Lines

libcxx/test/std/localization/locale.categories/category.time/locale.time.get/locale.time.get.members/get_weekday_wide.pass.cpp

Show All 13 Lines
// get_weekday(iter_type s, iter_type end, ios_base& str, // get_weekday(iter_type s, iter_type end, ios_base& str,
// ios_base::iostate& err, tm* t) const; // ios_base::iostate& err, tm* t) const;
#include <locale> #include <locale>
#include <cassert> #include <cassert>
#include "test_macros.h" #include "test_macros.h"
#include "test_iterators.h" #include "test_iterators.h"
typedef input_iterator<const wchar_t*> I; typedef cpp17_input_iterator<const wchar_t*> I;
typedef std::time_get<wchar_t, I> F; typedef std::time_get<wchar_t, I> F;
class my_facet class my_facet
: public F : public F
{ {
public: public:
explicit my_facet(std::size_t refs = 0) explicit my_facet(std::size_t refs = 0)
▲ Show 20 Lines • Show All 192 Lines • Show Last 20 Lines

libcxx/test/std/localization/locale.categories/category.time/locale.time.get/locale.time.get.members/get_year.pass.cpp

Show All 13 Lines
// ios_base::iostate& err, tm* t) const; // ios_base::iostate& err, tm* t) const;
#include <locale> #include <locale>
#include <cassert> #include <cassert>
#include <ios> #include <ios>
#include "test_macros.h" #include "test_macros.h"
#include "test_iterators.h" #include "test_iterators.h"
typedef input_iterator<const char*> I; typedef cpp17_input_iterator<const char*> I;
typedef std::time_get<char, I> F; typedef std::time_get<char, I> F;
class my_facet class my_facet
: public F : public F
{ {
public: public:
explicit my_facet(std::size_t refs = 0) explicit my_facet(std::size_t refs = 0)
▲ Show 20 Lines • Show All 111 Lines • Show Last 20 Lines

libcxx/test/std/numerics/numeric.ops/accumulate/accumulate.pass.cpp

Show First 20 Lines • Show All 43 Lines • ▼ Show 20 Linestest()
test(Iter(ia), Iter(ia+2), 10, 13); test(Iter(ia), Iter(ia+2), 10, 13);
test(Iter(ia), Iter(ia+sa), 0, 21); test(Iter(ia), Iter(ia+sa), 0, 21);
test(Iter(ia), Iter(ia+sa), 10, 31); test(Iter(ia), Iter(ia+sa), 10, 31);
} }
TEST_CONSTEXPR_CXX20 bool TEST_CONSTEXPR_CXX20 bool
test() test()
{ {
test<input_iterator<const int*> >(); test<cpp17_input_iterator<const int*> >();
test<forward_iterator<const int*> >(); test<forward_iterator<const int*> >();
test<bidirectional_iterator<const int*> >(); test<bidirectional_iterator<const int*> >();
test<random_access_iterator<const int*> >(); test<random_access_iterator<const int*> >();
test<const int*>(); test<const int*>();
return true; return true;
} }
int main(int, char**) int main(int, char**)
{ {
test(); test();
#if TEST_STD_VER > 17 #if TEST_STD_VER > 17
static_assert(test()); static_assert(test());
#endif #endif
return 0; return 0;
} }

libcxx/test/std/numerics/numeric.ops/accumulate/accumulate_op.pass.cpp

Show First 20 Lines • Show All 97 Lines • ▼ Show 20 Linestest()
test(Iter(ia), Iter(ia+2), 10, 20); test(Iter(ia), Iter(ia+2), 10, 20);
test(Iter(ia), Iter(ia+sa), 1, 720); test(Iter(ia), Iter(ia+sa), 1, 720);
test(Iter(ia), Iter(ia+sa), 10, 7200); test(Iter(ia), Iter(ia+sa), 10, 7200);
} }
TEST_CONSTEXPR_CXX20 bool TEST_CONSTEXPR_CXX20 bool
test() test()
{ {
test<input_iterator<const int*> >(); test<cpp17_input_iterator<const int*> >();
test<forward_iterator<const int*> >(); test<forward_iterator<const int*> >();
test<bidirectional_iterator<const int*> >(); test<bidirectional_iterator<const int*> >();
test<random_access_iterator<const int*> >(); test<random_access_iterator<const int*> >();
test<const int*>(); test<const int*>();
#if TEST_STD_VER > 17 #if TEST_STD_VER > 17
test_use_move(); test_use_move();
#endif // TEST_STD_VER > 17 #endif // TEST_STD_VER > 17
Show All 20 Lines

libcxx/test/std/numerics/numeric.ops/adjacent.difference/adjacent_difference.pass.cpp

Show First 20 Lines • Show All 75 Lines • ▼ Show 20 Linespublic:
TEST_CONSTEXPR_CXX20 void operator=(const X& x) {i_ = x.i_;} TEST_CONSTEXPR_CXX20 void operator=(const X& x) {i_ = x.i_;}
}; };
#endif #endif
TEST_CONSTEXPR_CXX20 bool TEST_CONSTEXPR_CXX20 bool
test() test()
{ {
test<input_iterator<const int*>, output_iterator<int*> >(); test<cpp17_input_iterator<const int*>, output_iterator<int*> >();
test<input_iterator<const int*>, forward_iterator<int*> >(); test<cpp17_input_iterator<const int*>, forward_iterator<int*> >();
test<input_iterator<const int*>, bidirectional_iterator<int*> >(); test<cpp17_input_iterator<const int*>, bidirectional_iterator<int*> >();
test<input_iterator<const int*>, random_access_iterator<int*> >(); test<cpp17_input_iterator<const int*>, random_access_iterator<int*> >();
test<input_iterator<const int*>, int*>(); test<cpp17_input_iterator<const int*>, int*>();
test<forward_iterator<const int*>, output_iterator<int*> >(); test<forward_iterator<const int*>, output_iterator<int*> >();
test<forward_iterator<const int*>, forward_iterator<int*> >(); test<forward_iterator<const int*>, forward_iterator<int*> >();
test<forward_iterator<const int*>, bidirectional_iterator<int*> >(); test<forward_iterator<const int*>, bidirectional_iterator<int*> >();
test<forward_iterator<const int*>, random_access_iterator<int*> >(); test<forward_iterator<const int*>, random_access_iterator<int*> >();
test<forward_iterator<const int*>, int*>(); test<forward_iterator<const int*>, int*>();
test<bidirectional_iterator<const int*>, output_iterator<int*> >(); test<bidirectional_iterator<const int*>, output_iterator<int*> >();
Show All 34 Lines

libcxx/test/std/numerics/numeric.ops/adjacent.difference/adjacent_difference_op.pass.cpp

Show First 20 Lines • Show All 136 Lines • ▼ Show 20 Lines
}; };
#endif #endif
TEST_CONSTEXPR_CXX20 bool TEST_CONSTEXPR_CXX20 bool
test() test()
{ {
test<input_iterator<const int*>, output_iterator<int*> >(); test<cpp17_input_iterator<const int*>, output_iterator<int*> >();
test<input_iterator<const int*>, forward_iterator<int*> >(); test<cpp17_input_iterator<const int*>, forward_iterator<int*> >();
test<input_iterator<const int*>, bidirectional_iterator<int*> >(); test<cpp17_input_iterator<const int*>, bidirectional_iterator<int*> >();
test<input_iterator<const int*>, random_access_iterator<int*> >(); test<cpp17_input_iterator<const int*>, random_access_iterator<int*> >();
test<input_iterator<const int*>, int*>(); test<cpp17_input_iterator<const int*>, int*>();
test<forward_iterator<const int*>, output_iterator<int*> >(); test<forward_iterator<const int*>, output_iterator<int*> >();
test<forward_iterator<const int*>, forward_iterator<int*> >(); test<forward_iterator<const int*>, forward_iterator<int*> >();
test<forward_iterator<const int*>, bidirectional_iterator<int*> >(); test<forward_iterator<const int*>, bidirectional_iterator<int*> >();
test<forward_iterator<const int*>, random_access_iterator<int*> >(); test<forward_iterator<const int*>, random_access_iterator<int*> >();
test<forward_iterator<const int*>, int*>(); test<forward_iterator<const int*>, int*>();
test<bidirectional_iterator<const int*>, output_iterator<int*> >(); test<bidirectional_iterator<const int*>, output_iterator<int*> >();
▲ Show 20 Lines • Show All 46 Lines • Show Last 20 Lines

libcxx/test/std/numerics/numeric.ops/exclusive.scan/exclusive_scan.pass.cpp

Show First 20 Lines • Show All 91 Lines • ▼ Show 20 Lines
} }
TEST_CONSTEXPR_CXX20 bool TEST_CONSTEXPR_CXX20 bool
test() test()
{ {
basic_tests(); basic_tests();
// All the iterator categories // All the iterator categories
test<input_iterator <const int*> >(); test<cpp17_input_iterator <const int*> >();
test<forward_iterator <const int*> >(); test<forward_iterator <const int*> >();
test<bidirectional_iterator<const int*> >(); test<bidirectional_iterator<const int*> >();
test<random_access_iterator<const int*> >(); test<random_access_iterator<const int*> >();
test<const int*>(); test<const int*>();
test< int*>(); test< int*>();
return true; return true;
} }
Show All 9 Lines

libcxx/test/std/numerics/numeric.ops/exclusive.scan/exclusive_scan_init_op.pass.cpp

Show First 20 Lines • Show All 62 Lines • ▼ Show 20 Lines for (unsigned int i = 0; i < sa; ++i ) {
test(Iter(ia), Iter(ia + i), 1, std::multiplies<>(), mRes, mRes + i); test(Iter(ia), Iter(ia + i), 1, std::multiplies<>(), mRes, mRes + i);
} }
} }
TEST_CONSTEXPR_CXX20 bool TEST_CONSTEXPR_CXX20 bool
test() test()
{ {
// All the iterator categories // All the iterator categories
test<input_iterator <const int*> >(); test<cpp17_input_iterator <const int*> >();
test<forward_iterator <const int*> >(); test<forward_iterator <const int*> >();
test<bidirectional_iterator<const int*> >(); test<bidirectional_iterator<const int*> >();
test<random_access_iterator<const int*> >(); test<random_access_iterator<const int*> >();
test<const int*>(); test<const int*>();
test< int*>(); test< int*>();
// Make sure that the calculations are done using the init typedef // Make sure that the calculations are done using the init typedef
{ {
Show All 26 Lines

libcxx/test/std/numerics/numeric.ops/inclusive.scan/inclusive_scan.pass.cpp

Show First 20 Lines • Show All 97 Lines • ▼ Show 20 Lines
} }
TEST_CONSTEXPR_CXX20 bool TEST_CONSTEXPR_CXX20 bool
test() test()
{ {
basic_tests(); basic_tests();
// All the iterator categories // All the iterator categories
test<input_iterator <const int*> >(); test<cpp17_input_iterator <const int*> >();
test<forward_iterator <const int*> >(); test<forward_iterator <const int*> >();
test<bidirectional_iterator<const int*> >(); test<bidirectional_iterator<const int*> >();
test<random_access_iterator<const int*> >(); test<random_access_iterator<const int*> >();
test<const int*>(); test<const int*>();
test< int*>(); test< int*>();
return true; return true;
} }
Show All 9 Lines

libcxx/test/std/numerics/numeric.ops/inclusive.scan/inclusive_scan_op.pass.cpp

Show First 20 Lines • Show All 101 Lines • ▼ Show 20 Lines
} }
TEST_CONSTEXPR_CXX20 bool TEST_CONSTEXPR_CXX20 bool
test() test()
{ {
basic_tests(); basic_tests();
// All the iterator categories // All the iterator categories
test<input_iterator <const int*> >(); test<cpp17_input_iterator <const int*> >();
test<forward_iterator <const int*> >(); test<forward_iterator <const int*> >();
test<bidirectional_iterator<const int*> >(); test<bidirectional_iterator<const int*> >();
test<random_access_iterator<const int*> >(); test<random_access_iterator<const int*> >();
test<const int*>(); test<const int*>();
test< int*>(); test< int*>();
return true; return true;
} }
Show All 9 Lines

libcxx/test/std/numerics/numeric.ops/inclusive.scan/inclusive_scan_op_init.pass.cpp

Show First 20 Lines • Show All 118 Lines • ▼ Show 20 Lines
} }
TEST_CONSTEXPR_CXX20 bool TEST_CONSTEXPR_CXX20 bool
test() test()
{ {
basic_tests(); basic_tests();
// All the iterator categories // All the iterator categories
test<input_iterator <const int*> >(); test<cpp17_input_iterator <const int*> >();
test<forward_iterator <const int*> >(); test<forward_iterator <const int*> >();
test<bidirectional_iterator<const int*> >(); test<bidirectional_iterator<const int*> >();
test<random_access_iterator<const int*> >(); test<random_access_iterator<const int*> >();
test<const int*>(); test<const int*>();
test< int*>(); test< int*>();
return true; return true;
} }
Show All 9 Lines

libcxx/test/std/numerics/numeric.ops/inner.product/inner_product.pass.cpp

Show First 20 Lines • Show All 48 Lines • ▼ Show 20 Linestest()
test(Iter1(a), Iter1(a+2), Iter2(b), 10, 26); test(Iter1(a), Iter1(a+2), Iter2(b), 10, 26);
test(Iter1(a), Iter1(a+sa), Iter2(b), 0, 56); test(Iter1(a), Iter1(a+sa), Iter2(b), 0, 56);
test(Iter1(a), Iter1(a+sa), Iter2(b), 10, 66); test(Iter1(a), Iter1(a+sa), Iter2(b), 10, 66);
} }
TEST_CONSTEXPR_CXX20 bool TEST_CONSTEXPR_CXX20 bool
test() test()
{ {
test<input_iterator<const int*>, input_iterator<const int*> >(); test<cpp17_input_iterator<const int*>, cpp17_input_iterator<const int*> >();
test<input_iterator<const int*>, forward_iterator<const int*> >(); test<cpp17_input_iterator<const int*>, forward_iterator<const int*> >();
test<input_iterator<const int*>, bidirectional_iterator<const int*> >(); test<cpp17_input_iterator<const int*>, bidirectional_iterator<const int*> >();
test<input_iterator<const int*>, random_access_iterator<const int*> >(); test<cpp17_input_iterator<const int*>, random_access_iterator<const int*> >();
test<input_iterator<const int*>, const int*>(); test<cpp17_input_iterator<const int*>, const int*>();
test<forward_iterator<const int*>, input_iterator<const int*> >(); test<forward_iterator<const int*>, cpp17_input_iterator<const int*> >();
test<forward_iterator<const int*>, forward_iterator<const int*> >(); test<forward_iterator<const int*>, forward_iterator<const int*> >();
test<forward_iterator<const int*>, bidirectional_iterator<const int*> >(); test<forward_iterator<const int*>, bidirectional_iterator<const int*> >();
test<forward_iterator<const int*>, random_access_iterator<const int*> >(); test<forward_iterator<const int*>, random_access_iterator<const int*> >();
test<forward_iterator<const int*>, const int*>(); test<forward_iterator<const int*>, const int*>();
test<bidirectional_iterator<const int*>, input_iterator<const int*> >(); test<bidirectional_iterator<const int*>, cpp17_input_iterator<const int*> >();
test<bidirectional_iterator<const int*>, forward_iterator<const int*> >(); test<bidirectional_iterator<const int*>, forward_iterator<const int*> >();
test<bidirectional_iterator<const int*>, bidirectional_iterator<const int*> >(); test<bidirectional_iterator<const int*>, bidirectional_iterator<const int*> >();
test<bidirectional_iterator<const int*>, random_access_iterator<const int*> >(); test<bidirectional_iterator<const int*>, random_access_iterator<const int*> >();
test<bidirectional_iterator<const int*>, const int*>(); test<bidirectional_iterator<const int*>, const int*>();
test<random_access_iterator<const int*>, input_iterator<const int*> >(); test<random_access_iterator<const int*>, cpp17_input_iterator<const int*> >();
test<random_access_iterator<const int*>, forward_iterator<const int*> >(); test<random_access_iterator<const int*>, forward_iterator<const int*> >();
test<random_access_iterator<const int*>, bidirectional_iterator<const int*> >(); test<random_access_iterator<const int*>, bidirectional_iterator<const int*> >();
test<random_access_iterator<const int*>, random_access_iterator<const int*> >(); test<random_access_iterator<const int*>, random_access_iterator<const int*> >();
test<random_access_iterator<const int*>, const int*>(); test<random_access_iterator<const int*>, const int*>();
test<const int*, input_iterator<const int*> >(); test<const int*, cpp17_input_iterator<const int*> >();
test<const int*, forward_iterator<const int*> >(); test<const int*, forward_iterator<const int*> >();
test<const int*, bidirectional_iterator<const int*> >(); test<const int*, bidirectional_iterator<const int*> >();
test<const int*, random_access_iterator<const int*> >(); test<const int*, random_access_iterator<const int*> >();
test<const int*, const int*>(); test<const int*, const int*>();
return true; return true;
} }
int main(int, char**) int main(int, char**)
{ {
test(); test();
#if TEST_STD_VER > 17 #if TEST_STD_VER > 17
static_assert(test()); static_assert(test());
#endif #endif
return 0; return 0;
} }

libcxx/test/std/numerics/numeric.ops/inner.product/inner_product_comp.pass.cpp

Show First 20 Lines • Show All 113 Lines • ▼ Show 20 Linestest()
test(Iter1(a), Iter1(a+2), Iter2(b), 10, 490); test(Iter1(a), Iter1(a+2), Iter2(b), 10, 490);
test(Iter1(a), Iter1(a+sa), Iter2(b), 1, 117649); test(Iter1(a), Iter1(a+sa), Iter2(b), 1, 117649);
test(Iter1(a), Iter1(a+sa), Iter2(b), 10, 1176490); test(Iter1(a), Iter1(a+sa), Iter2(b), 10, 1176490);
} }
TEST_CONSTEXPR_CXX20 bool TEST_CONSTEXPR_CXX20 bool
test() test()
{ {
test<input_iterator<const int*>, input_iterator<const int*> >(); test<cpp17_input_iterator<const int*>, cpp17_input_iterator<const int*> >();
test<input_iterator<const int*>, forward_iterator<const int*> >(); test<cpp17_input_iterator<const int*>, forward_iterator<const int*> >();
test<input_iterator<const int*>, bidirectional_iterator<const int*> >(); test<cpp17_input_iterator<const int*>, bidirectional_iterator<const int*> >();
test<input_iterator<const int*>, random_access_iterator<const int*> >(); test<cpp17_input_iterator<const int*>, random_access_iterator<const int*> >();
test<input_iterator<const int*>, const int*>(); test<cpp17_input_iterator<const int*>, const int*>();
test<forward_iterator<const int*>, input_iterator<const int*> >(); test<forward_iterator<const int*>, cpp17_input_iterator<const int*> >();
test<forward_iterator<const int*>, forward_iterator<const int*> >(); test<forward_iterator<const int*>, forward_iterator<const int*> >();
test<forward_iterator<const int*>, bidirectional_iterator<const int*> >(); test<forward_iterator<const int*>, bidirectional_iterator<const int*> >();
test<forward_iterator<const int*>, random_access_iterator<const int*> >(); test<forward_iterator<const int*>, random_access_iterator<const int*> >();
test<forward_iterator<const int*>, const int*>(); test<forward_iterator<const int*>, const int*>();
test<bidirectional_iterator<const int*>, input_iterator<const int*> >(); test<bidirectional_iterator<const int*>, cpp17_input_iterator<const int*> >();
test<bidirectional_iterator<const int*>, forward_iterator<const int*> >(); test<bidirectional_iterator<const int*>, forward_iterator<const int*> >();
test<bidirectional_iterator<const int*>, bidirectional_iterator<const int*> >(); test<bidirectional_iterator<const int*>, bidirectional_iterator<const int*> >();
test<bidirectional_iterator<const int*>, random_access_iterator<const int*> >(); test<bidirectional_iterator<const int*>, random_access_iterator<const int*> >();
test<bidirectional_iterator<const int*>, const int*>(); test<bidirectional_iterator<const int*>, const int*>();
test<random_access_iterator<const int*>, input_iterator<const int*> >(); test<random_access_iterator<const int*>, cpp17_input_iterator<const int*> >();
test<random_access_iterator<const int*>, forward_iterator<const int*> >(); test<random_access_iterator<const int*>, forward_iterator<const int*> >();
test<random_access_iterator<const int*>, bidirectional_iterator<const int*> >(); test<random_access_iterator<const int*>, bidirectional_iterator<const int*> >();
test<random_access_iterator<const int*>, random_access_iterator<const int*> >(); test<random_access_iterator<const int*>, random_access_iterator<const int*> >();
test<random_access_iterator<const int*>, const int*>(); test<random_access_iterator<const int*>, const int*>();
test<const int*, input_iterator<const int*> >(); test<const int*, cpp17_input_iterator<const int*> >();
test<const int*, forward_iterator<const int*> >(); test<const int*, forward_iterator<const int*> >();
test<const int*, bidirectional_iterator<const int*> >(); test<const int*, bidirectional_iterator<const int*> >();
test<const int*, random_access_iterator<const int*> >(); test<const int*, random_access_iterator<const int*> >();
test<const int*, const int*>(); test<const int*, const int*>();
#if TEST_STD_VER > 17 #if TEST_STD_VER > 17
test_use_move(); test_use_move();
#endif // TEST_STD_VER > 17 #endif // TEST_STD_VER > 17
Show All 20 Lines

libcxx/test/std/numerics/numeric.ops/partial.sum/partial_sum.pass.cpp

Show All 36 Linestest()
assert(base(r) == ib + s); assert(base(r) == ib + s);
for (unsigned i = 0; i < s; ++i) for (unsigned i = 0; i < s; ++i)
assert(ib[i] == ir[i]); assert(ib[i] == ir[i]);
} }
TEST_CONSTEXPR_CXX20 bool TEST_CONSTEXPR_CXX20 bool
test() test()
{ {
test<input_iterator<const int*>, output_iterator<int*> >(); test<cpp17_input_iterator<const int*>, output_iterator<int*> >();
test<input_iterator<const int*>, forward_iterator<int*> >(); test<cpp17_input_iterator<const int*>, forward_iterator<int*> >();
test<input_iterator<const int*>, bidirectional_iterator<int*> >(); test<cpp17_input_iterator<const int*>, bidirectional_iterator<int*> >();
test<input_iterator<const int*>, random_access_iterator<int*> >(); test<cpp17_input_iterator<const int*>, random_access_iterator<int*> >();
test<input_iterator<const int*>, int*>(); test<cpp17_input_iterator<const int*>, int*>();
test<forward_iterator<const int*>, output_iterator<int*> >(); test<forward_iterator<const int*>, output_iterator<int*> >();
test<forward_iterator<const int*>, forward_iterator<int*> >(); test<forward_iterator<const int*>, forward_iterator<int*> >();
test<forward_iterator<const int*>, bidirectional_iterator<int*> >(); test<forward_iterator<const int*>, bidirectional_iterator<int*> >();
test<forward_iterator<const int*>, random_access_iterator<int*> >(); test<forward_iterator<const int*>, random_access_iterator<int*> >();
test<forward_iterator<const int*>, int*>(); test<forward_iterator<const int*>, int*>();
test<bidirectional_iterator<const int*>, output_iterator<int*> >(); test<bidirectional_iterator<const int*>, output_iterator<int*> >();
Show All 28 Lines

libcxx/test/std/numerics/numeric.ops/partial.sum/partial_sum_op.pass.cpp

Show First 20 Lines • Show All 96 Lines • ▼ Show 20 Linestest()
assert(base(r) == ib + s); assert(base(r) == ib + s);
for (unsigned i = 0; i < s; ++i) for (unsigned i = 0; i < s; ++i)
assert(ib[i] == ir[i]); assert(ib[i] == ir[i]);
} }
TEST_CONSTEXPR_CXX20 bool TEST_CONSTEXPR_CXX20 bool
test() test()
{ {
test<input_iterator<const int*>, output_iterator<int*> >(); test<cpp17_input_iterator<const int*>, output_iterator<int*> >();
test<input_iterator<const int*>, forward_iterator<int*> >(); test<cpp17_input_iterator<const int*>, forward_iterator<int*> >();
test<input_iterator<const int*>, bidirectional_iterator<int*> >(); test<cpp17_input_iterator<const int*>, bidirectional_iterator<int*> >();
test<input_iterator<const int*>, random_access_iterator<int*> >(); test<cpp17_input_iterator<const int*>, random_access_iterator<int*> >();
test<input_iterator<const int*>, int*>(); test<cpp17_input_iterator<const int*>, int*>();
test<forward_iterator<const int*>, output_iterator<int*> >(); test<forward_iterator<const int*>, output_iterator<int*> >();
test<forward_iterator<const int*>, forward_iterator<int*> >(); test<forward_iterator<const int*>, forward_iterator<int*> >();
test<forward_iterator<const int*>, bidirectional_iterator<int*> >(); test<forward_iterator<const int*>, bidirectional_iterator<int*> >();
test<forward_iterator<const int*>, random_access_iterator<int*> >(); test<forward_iterator<const int*>, random_access_iterator<int*> >();
test<forward_iterator<const int*>, int*>(); test<forward_iterator<const int*>, int*>();
test<bidirectional_iterator<const int*>, output_iterator<int*> >(); test<bidirectional_iterator<const int*>, output_iterator<int*> >();
▲ Show 20 Lines • Show All 41 Lines • Show Last 20 Lines

libcxx/test/std/numerics/numeric.ops/reduce/reduce.pass.cpp

Show First 20 Lines • Show All 54 Lines • ▼ Show 20 Lines
test() test()
{ {
test_return_type<char>(); test_return_type<char>();
test_return_type<int>(); test_return_type<int>();
test_return_type<unsigned long>(); test_return_type<unsigned long>();
test_return_type<float>(); test_return_type<float>();
test_return_type<double>(); test_return_type<double>();
test<input_iterator<const int*> >(); test<cpp17_input_iterator<const int*> >();
test<forward_iterator<const int*> >(); test<forward_iterator<const int*> >();
test<bidirectional_iterator<const int*> >(); test<bidirectional_iterator<const int*> >();
test<random_access_iterator<const int*> >(); test<random_access_iterator<const int*> >();
test<const int*>(); test<const int*>();
return true; return true;
} }
int main(int, char**) int main(int, char**)
{ {
test(); test();
#if TEST_STD_VER > 17 #if TEST_STD_VER > 17
static_assert(test()); static_assert(test());
#endif #endif
return 0; return 0;
} }

libcxx/test/std/numerics/numeric.ops/reduce/reduce_init.pass.cpp

Show First 20 Lines • Show All 58 Lines • ▼ Show 20 Linestest()
test_return_type<char, int>(); test_return_type<char, int>();
test_return_type<int, int>(); test_return_type<int, int>();
test_return_type<int, unsigned long>(); test_return_type<int, unsigned long>();
test_return_type<float, int>(); test_return_type<float, int>();
test_return_type<short, float>(); test_return_type<short, float>();
test_return_type<double, char>(); test_return_type<double, char>();
test_return_type<char, double>(); test_return_type<char, double>();
test<input_iterator<const int*> >(); test<cpp17_input_iterator<const int*> >();
test<forward_iterator<const int*> >(); test<forward_iterator<const int*> >();
test<bidirectional_iterator<const int*> >(); test<bidirectional_iterator<const int*> >();
test<random_access_iterator<const int*> >(); test<random_access_iterator<const int*> >();
test<const int*>(); test<const int*>();
return true; return true;
} }
int main(int, char**) int main(int, char**)
{ {
test(); test();
#if TEST_STD_VER > 17 #if TEST_STD_VER > 17
static_assert(test()); static_assert(test());
#endif #endif
return 0; return 0;
} }

libcxx/test/std/numerics/numeric.ops/reduce/reduce_init_op.pass.cpp

Show First 20 Lines • Show All 58 Lines • ▼ Show 20 Linestest()
test_return_type<char, int>(); test_return_type<char, int>();
test_return_type<int, int>(); test_return_type<int, int>();
test_return_type<int, unsigned long>(); test_return_type<int, unsigned long>();
test_return_type<float, int>(); test_return_type<float, int>();
test_return_type<short, float>(); test_return_type<short, float>();
test_return_type<double, char>(); test_return_type<double, char>();
test_return_type<char, double>(); test_return_type<char, double>();
test<input_iterator<const int*> >(); test<cpp17_input_iterator<const int*> >();
test<forward_iterator<const int*> >(); test<forward_iterator<const int*> >();
test<bidirectional_iterator<const int*> >(); test<bidirectional_iterator<const int*> >();
test<random_access_iterator<const int*> >(); test<random_access_iterator<const int*> >();
test<const int*>(); test<const int*>();
// Make sure the math is done using the correct type // Make sure the math is done using the correct type
{ {
auto v = {1, 2, 3, 4, 5, 6, 7, 8}; auto v = {1, 2, 3, 4, 5, 6, 7, 8};
Show All 15 Lines

libcxx/test/std/numerics/numeric.ops/transform.exclusive.scan/transform_exclusive_scan_init_bop_uop.pass.cpp

Show First 20 Lines • Show All 144 Lines • ▼ Show 20 Lines
} }
TEST_CONSTEXPR_CXX20 bool TEST_CONSTEXPR_CXX20 bool
test() test()
{ {
basic_tests(); basic_tests();
// All the iterator categories // All the iterator categories
test<input_iterator <const int*> >(); test<cpp17_input_iterator <const int*> >();
test<forward_iterator <const int*> >(); test<forward_iterator <const int*> >();
test<bidirectional_iterator<const int*> >(); test<bidirectional_iterator<const int*> >();
test<random_access_iterator<const int*> >(); test<random_access_iterator<const int*> >();
test<const int*>(); test<const int*>();
test< int*>(); test< int*>();
return true; return true;
} }
Show All 9 Lines

libcxx/test/std/numerics/numeric.ops/transform.inclusive.scan/transform_inclusive_scan_bop_uop.pass.cpp

Show First 20 Lines • Show All 116 Lines • ▼ Show 20 Lines
} }
TEST_CONSTEXPR_CXX20 bool TEST_CONSTEXPR_CXX20 bool
test() test()
{ {
basic_tests(); basic_tests();
// All the iterator categories // All the iterator categories
test<input_iterator <const int*> >(); test<cpp17_input_iterator <const int*> >();
test<forward_iterator <const int*> >(); test<forward_iterator <const int*> >();
test<bidirectional_iterator<const int*> >(); test<bidirectional_iterator<const int*> >();
test<random_access_iterator<const int*> >(); test<random_access_iterator<const int*> >();
test<const int*>(); test<const int*>();
test< int*>(); test< int*>();
return true; return true;
} }
Show All 9 Lines

libcxx/test/std/numerics/numeric.ops/transform.inclusive.scan/transform_inclusive_scan_bop_uop_init.pass.cpp

Show First 20 Lines • Show All 146 Lines • ▼ Show 20 Lines
} }
TEST_CONSTEXPR_CXX20 bool TEST_CONSTEXPR_CXX20 bool
test() test()
{ {
basic_tests(); basic_tests();
// All the iterator categories // All the iterator categories
test<input_iterator <const int*> >(); test<cpp17_input_iterator <const int*> >();
test<forward_iterator <const int*> >(); test<forward_iterator <const int*> >();
test<bidirectional_iterator<const int*> >(); test<bidirectional_iterator<const int*> >();
test<random_access_iterator<const int*> >(); test<random_access_iterator<const int*> >();
test<const int*>(); test<const int*>();
test< int*>(); test< int*>();
return true; return true;
} }
Show All 9 Lines

libcxx/test/std/numerics/numeric.ops/transform.reduce/transform_reduce_iter_iter_init_bop_uop.pass.cpp

Show First 20 Lines • Show All 103 Lines • ▼ Show 20 Linestest()
test_return_type<int, int>(); test_return_type<int, int>();
test_return_type<int, unsigned long>(); test_return_type<int, unsigned long>();
test_return_type<float, int>(); test_return_type<float, int>();
test_return_type<short, float>(); test_return_type<short, float>();
test_return_type<double, char>(); test_return_type<double, char>();
test_return_type<char, double>(); test_return_type<char, double>();
// All the iterator categories // All the iterator categories
test<input_iterator <const int*> >(); test<cpp17_input_iterator <const int*> >();
test<forward_iterator <const int*> >(); test<forward_iterator <const int*> >();
test<bidirectional_iterator<const int*> >(); test<bidirectional_iterator<const int*> >();
test<random_access_iterator<const int*> >(); test<random_access_iterator<const int*> >();
test<const int*>(); test<const int*>();
test< int*>(); test< int*>();
// Make sure the math is done using the correct type // Make sure the math is done using the correct type
{ {
Show All 18 Lines

libcxx/test/std/numerics/numeric.ops/transform.reduce/transform_reduce_iter_iter_iter_init.pass.cpp

Show First 20 Lines • Show All 77 Lines • ▼ Show 20 Linestest()
test_return_type<int, int>(); test_return_type<int, int>();
test_return_type<int, unsigned long>(); test_return_type<int, unsigned long>();
test_return_type<float, int>(); test_return_type<float, int>();
test_return_type<short, float>(); test_return_type<short, float>();
test_return_type<double, char>(); test_return_type<double, char>();
test_return_type<char, double>(); test_return_type<char, double>();
// All the iterator categories // All the iterator categories
test<input_iterator <const int*>, input_iterator <const unsigned int*> >(); test<cpp17_input_iterator <const int*>, cpp17_input_iterator <const unsigned int*> >();
test<input_iterator <const int*>, forward_iterator <const unsigned int*> >(); test<cpp17_input_iterator <const int*>, forward_iterator <const unsigned int*> >();
test<input_iterator <const int*>, bidirectional_iterator<const unsigned int*> >(); test<cpp17_input_iterator <const int*>, bidirectional_iterator<const unsigned int*> >();
test<input_iterator <const int*>, random_access_iterator<const unsigned int*> >(); test<cpp17_input_iterator <const int*>, random_access_iterator<const unsigned int*> >();
test<forward_iterator <const int*>, input_iterator <const unsigned int*> >(); test<forward_iterator <const int*>, cpp17_input_iterator <const unsigned int*> >();
test<forward_iterator <const int*>, forward_iterator <const unsigned int*> >(); test<forward_iterator <const int*>, forward_iterator <const unsigned int*> >();
test<forward_iterator <const int*>, bidirectional_iterator<const unsigned int*> >(); test<forward_iterator <const int*>, bidirectional_iterator<const unsigned int*> >();
test<forward_iterator <const int*>, random_access_iterator<const unsigned int*> >(); test<forward_iterator <const int*>, random_access_iterator<const unsigned int*> >();
test<bidirectional_iterator<const int*>, input_iterator <const unsigned int*> >(); test<bidirectional_iterator<const int*>, cpp17_input_iterator <const unsigned int*> >();
test<bidirectional_iterator<const int*>, forward_iterator <const unsigned int*> >(); test<bidirectional_iterator<const int*>, forward_iterator <const unsigned int*> >();
test<bidirectional_iterator<const int*>, bidirectional_iterator<const unsigned int*> >(); test<bidirectional_iterator<const int*>, bidirectional_iterator<const unsigned int*> >();
test<bidirectional_iterator<const int*>, random_access_iterator<const unsigned int*> >(); test<bidirectional_iterator<const int*>, random_access_iterator<const unsigned int*> >();
test<random_access_iterator<const int*>, input_iterator <const unsigned int*> >(); test<random_access_iterator<const int*>, cpp17_input_iterator <const unsigned int*> >();
test<random_access_iterator<const int*>, forward_iterator <const unsigned int*> >(); test<random_access_iterator<const int*>, forward_iterator <const unsigned int*> >();
test<random_access_iterator<const int*>, bidirectional_iterator<const unsigned int*> >(); test<random_access_iterator<const int*>, bidirectional_iterator<const unsigned int*> >();
test<random_access_iterator<const int*>, random_access_iterator<const unsigned int*> >(); test<random_access_iterator<const int*>, random_access_iterator<const unsigned int*> >();
// just plain pointers (const vs. non-const, too) // just plain pointers (const vs. non-const, too)
test<const int*, const unsigned int *>(); test<const int*, const unsigned int *>();
test<const int*, unsigned int *>(); test<const int*, unsigned int *>();
test< int*, const unsigned int *>(); test< int*, const unsigned int *>();
Show All 15 Lines

libcxx/test/std/numerics/numeric.ops/transform.reduce/transform_reduce_iter_iter_iter_init_op_op.pass.cpp

Show First 20 Lines • Show All 81 Lines • ▼ Show 20 Linestest()
test_return_type<int, int>(); test_return_type<int, int>();
test_return_type<int, unsigned long>(); test_return_type<int, unsigned long>();
test_return_type<float, int>(); test_return_type<float, int>();
test_return_type<short, float>(); test_return_type<short, float>();
test_return_type<double, char>(); test_return_type<double, char>();
test_return_type<char, double>(); test_return_type<char, double>();
// All the iterator categories // All the iterator categories
test<input_iterator <const int*>, input_iterator <const unsigned int*> >(); test<cpp17_input_iterator <const int*>, cpp17_input_iterator <const unsigned int*> >();
test<input_iterator <const int*>, forward_iterator <const unsigned int*> >(); test<cpp17_input_iterator <const int*>, forward_iterator <const unsigned int*> >();
test<input_iterator <const int*>, bidirectional_iterator<const unsigned int*> >(); test<cpp17_input_iterator <const int*>, bidirectional_iterator<const unsigned int*> >();
test<input_iterator <const int*>, random_access_iterator<const unsigned int*> >(); test<cpp17_input_iterator <const int*>, random_access_iterator<const unsigned int*> >();
test<forward_iterator <const int*>, input_iterator <const unsigned int*> >(); test<forward_iterator <const int*>, cpp17_input_iterator <const unsigned int*> >();
test<forward_iterator <const int*>, forward_iterator <const unsigned int*> >(); test<forward_iterator <const int*>, forward_iterator <const unsigned int*> >();
test<forward_iterator <const int*>, bidirectional_iterator<const unsigned int*> >(); test<forward_iterator <const int*>, bidirectional_iterator<const unsigned int*> >();
test<forward_iterator <const int*>, random_access_iterator<const unsigned int*> >(); test<forward_iterator <const int*>, random_access_iterator<const unsigned int*> >();
test<bidirectional_iterator<const int*>, input_iterator <const unsigned int*> >(); test<bidirectional_iterator<const int*>, cpp17_input_iterator <const unsigned int*> >();
test<bidirectional_iterator<const int*>, forward_iterator <const unsigned int*> >(); test<bidirectional_iterator<const int*>, forward_iterator <const unsigned int*> >();
test<bidirectional_iterator<const int*>, bidirectional_iterator<const unsigned int*> >(); test<bidirectional_iterator<const int*>, bidirectional_iterator<const unsigned int*> >();
test<bidirectional_iterator<const int*>, random_access_iterator<const unsigned int*> >(); test<bidirectional_iterator<const int*>, random_access_iterator<const unsigned int*> >();
test<random_access_iterator<const int*>, input_iterator <const unsigned int*> >(); test<random_access_iterator<const int*>, cpp17_input_iterator <const unsigned int*> >();
test<random_access_iterator<const int*>, forward_iterator <const unsigned int*> >(); test<random_access_iterator<const int*>, forward_iterator <const unsigned int*> >();
test<random_access_iterator<const int*>, bidirectional_iterator<const unsigned int*> >(); test<random_access_iterator<const int*>, bidirectional_iterator<const unsigned int*> >();
test<random_access_iterator<const int*>, random_access_iterator<const unsigned int*> >(); test<random_access_iterator<const int*>, random_access_iterator<const unsigned int*> >();
// just plain pointers (const vs. non-const, too) // just plain pointers (const vs. non-const, too)
test<const int*, const unsigned int *>(); test<const int*, const unsigned int *>();
test<const int*, unsigned int *>(); test<const int*, unsigned int *>();
test< int*, const unsigned int *>(); test< int*, const unsigned int *>();
Show All 15 Lines

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

Show All 20 Lines
// template<range R> // template<range R>
// using range_rvalue_reference_t = iter_rvalue_reference_t<iterator_t<R>>; // using range_rvalue_reference_t = iter_rvalue_reference_t<iterator_t<R>>;
#include <ranges> #include <ranges>
#include <concepts> #include <concepts>
#include "test_iterators.h"
#include "test_range.h" #include "test_range.h"
namespace stdr = std::ranges; namespace stdr = std::ranges;
static_assert(std::same_as<stdr::range_difference_t<test_range<> >, std::iter_difference_t<int*> >); 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<> >, std::iter_value_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<stdr::range_reference_t<test_range<> >, std::iter_reference_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<stdr::range_rvalue_reference_t<test_range<> >, std::iter_rvalue_reference_t<int*> >); static_assert(std::same_as<stdr::range_rvalue_reference_t<test_range<cpp20_input_iterator> >, std::iter_rvalue_reference_t<int*> >);

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

Show All 15 Lines
#include <ranges> #include <ranges>
#include <concepts> #include <concepts>
#include "test_range.h" #include "test_range.h"
namespace stdr = std::ranges; namespace stdr = std::ranges;
static_assert(std::same_as<stdr::iterator_t<test_range<input_iterator> >, input_iterator<int*> >); 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<input_iterator> const>, input_iterator<int const*> >); 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<input_iterator> >, input_iterator<int*> >); static_assert(std::same_as<stdr::iterator_t<test_non_const_range<cpp17_input_iterator> >, cpp17_input_iterator<int*> >);
static_assert(std::same_as<stdr::iterator_t<test_common_range<input_iterator> >, input_iterator<int*> >); static_assert(std::same_as<stdr::iterator_t<test_common_range<cpp17_input_iterator> >, cpp17_input_iterator<int*> >);
static_assert(std::same_as<stdr::iterator_t<test_common_range<input_iterator> const>, input_iterator<int const*> >); 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<input_iterator> >, input_iterator<int*> >); static_assert(std::same_as<stdr::iterator_t<test_non_const_common_range<cpp17_input_iterator> >, cpp17_input_iterator<int*> >);

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

Show All 15 Lines
#include <ranges> #include <ranges>
#include <vector> #include <vector>
#include "test_range.h" #include "test_range.h"
namespace stdr = std::ranges; namespace stdr = std::ranges;
static_assert(stdr::range<test_range<> >); static_assert(stdr::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(!stdr::range<incompatible_iterators>);
struct int_begin_int_end { struct int_begin_int_end {
Show All 16 Lines

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

Show All 16 Lines
#include <concepts> #include <concepts>
#include "test_iterators.h" #include "test_iterators.h"
#include "test_range.h" #include "test_range.h"
namespace stdr = std::ranges; namespace stdr = std::ranges;
static_assert(std::same_as<stdr::sentinel_t<test_range<> >, sentinel>); static_assert(std::same_as<stdr::sentinel_t<test_range<cpp20_input_iterator> >, sentinel>);
static_assert(std::same_as<stdr::sentinel_t<test_range<> const>, sentinel>); static_assert(std::same_as<stdr::sentinel_t<test_range<cpp20_input_iterator> const>, sentinel>);
static_assert(std::same_as<stdr::sentinel_t<test_non_const_range<> >, sentinel>); static_assert(std::same_as<stdr::sentinel_t<test_non_const_range<cpp20_input_iterator> >, sentinel>);
static_assert(std::same_as<stdr::sentinel_t<test_common_range<> >, input_iterator<int*> >); static_assert(std::same_as<stdr::sentinel_t<test_common_range<cpp17_input_iterator> >, cpp17_input_iterator<int*> >);
static_assert(std::same_as<stdr::sentinel_t<test_common_range<> const>, input_iterator<int const*> >); 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<stdr::sentinel_t<test_non_const_common_range<> >, input_iterator<int*> >); static_assert(std::same_as<stdr::sentinel_t<test_non_const_common_range<cpp17_input_iterator> >, cpp17_input_iterator<int*> >);

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

Show All 13 Lines
#include <ranges> #include <ranges>
#include "test_iterators.h" #include "test_iterators.h"
#include "test_range.h" #include "test_range.h"
namespace stdr = std::ranges; namespace stdr = std::ranges;
static_assert(!stdr::common_range<test_range<input_iterator> >); static_assert(!stdr::common_range<test_range<cpp17_input_iterator> >);
static_assert(!stdr::common_range<test_range<input_iterator> const>); static_assert(!stdr::common_range<test_range<cpp17_input_iterator> const>);
static_assert(!stdr::common_range<test_non_const_range<input_iterator> >); static_assert(!stdr::common_range<test_non_const_range<cpp17_input_iterator> >);
static_assert(!stdr::common_range<test_non_const_range<input_iterator> const>); static_assert(!stdr::common_range<test_non_const_range<cpp17_input_iterator> const>);
static_assert(stdr::common_range<test_common_range<input_iterator> >); static_assert(stdr::common_range<test_common_range<cpp17_input_iterator> >);
static_assert(stdr::common_range<test_common_range<input_iterator> const>); static_assert(stdr::common_range<test_common_range<cpp17_input_iterator> const>);
static_assert(stdr::common_range<test_non_const_common_range<input_iterator> >); static_assert(stdr::common_range<test_non_const_common_range<cpp17_input_iterator> >);
static_assert(!stdr::common_range<test_non_const_common_range<input_iterator> const>); static_assert(!stdr::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(stdr::range<subtly_not_common> && !stdr::common_range<subtly_not_common>);
static_assert(stdr::range<subtly_not_common const> && !stdr::common_range<subtly_not_common const>); static_assert(stdr::range<subtly_not_common const> && !stdr::common_range<subtly_not_common const>);
Show All 15 Lines

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

Show All 9 Lines
// UNSUPPORTED: libcpp-no-concepts // UNSUPPORTED: libcpp-no-concepts
// UNSUPPORTED: gcc-10 // UNSUPPORTED: gcc-10
// template<range _Rp> // template<range _Rp>
// concept input_range; // concept input_range;
#include <ranges> #include <ranges>
#include "test_iterators.h"
#include "test_range.h" #include "test_range.h"
namespace stdr = std::ranges; namespace stdr = std::ranges;
static_assert(stdr::input_range<test_range<input_iterator> >); static_assert(stdr::input_range<test_range<cpp17_input_iterator> >);
static_assert(stdr::input_range<test_range<input_iterator> const>); static_assert(stdr::input_range<test_range<cpp17_input_iterator> const>);
static_assert(stdr::input_range<test_range<cpp20_input_iterator> >); static_assert(stdr::input_range<test_range<cpp20_input_iterator> >);
static_assert(stdr::input_range<test_range<cpp20_input_iterator> const>); static_assert(stdr::input_range<test_range<cpp20_input_iterator> const>);
static_assert(stdr::input_range<test_non_const_range<input_iterator> >); static_assert(stdr::input_range<test_non_const_range<cpp17_input_iterator> >);
static_assert(stdr::input_range<test_non_const_range<cpp20_input_iterator> >); static_assert(stdr::input_range<test_non_const_range<cpp20_input_iterator> >);
static_assert(!stdr::input_range<test_non_const_range<input_iterator> const>); static_assert(!stdr::input_range<test_non_const_range<cpp17_input_iterator> const>);
static_assert(!stdr::input_range<test_non_const_range<cpp20_input_iterator> const>); static_assert(!stdr::input_range<test_non_const_range<cpp20_input_iterator> const>);
static_assert(stdr::input_range<test_common_range<input_iterator> >); static_assert(stdr::input_range<test_common_range<cpp17_input_iterator> >);
static_assert(!stdr::input_range<test_common_range<cpp20_input_iterator> >); static_assert(!stdr::input_range<test_common_range<cpp20_input_iterator> >);
static_assert(stdr::input_range<test_common_range<input_iterator> const>); static_assert(stdr::input_range<test_common_range<cpp17_input_iterator> const>);
static_assert(!stdr::input_range<test_common_range<cpp20_input_iterator> const>); static_assert(!stdr::input_range<test_common_range<cpp20_input_iterator> const>);
static_assert(stdr::input_range<test_non_const_common_range<input_iterator> >); static_assert(stdr::input_range<test_non_const_common_range<cpp17_input_iterator> >);
static_assert(!stdr::input_range<test_non_const_common_range<cpp20_input_iterator> >); static_assert(!stdr::input_range<test_non_const_common_range<cpp20_input_iterator> >);
static_assert(!stdr::input_range<test_non_const_common_range<input_iterator> const>); static_assert(!stdr::input_range<test_non_const_common_range<cpp17_input_iterator> const>);
static_assert(!stdr::input_range<test_non_const_common_range<cpp20_input_iterator> const>); static_assert(!stdr::input_range<test_non_const_common_range<cpp20_input_iterator> const>);

libcxx/test/std/re/re.regex/re.regex.assign/assign_iter_iter_flag.pass.cpp

Show All 17 Lines
#include <regex> #include <regex>
#include <cassert> #include <cassert>
#include "test_macros.h" #include "test_macros.h"
#include "test_iterators.h" #include "test_iterators.h"
int main(int, char**) int main(int, char**)
{ {
typedef input_iterator<std::string::const_iterator> I; typedef cpp17_input_iterator<std::string::const_iterator> I;
typedef forward_iterator<std::string::const_iterator> F; typedef forward_iterator<std::string::const_iterator> F;
std::string s4("(a([bc]))"); std::string s4("(a([bc]))");
std::regex r2; std::regex r2;
r2.assign(I(s4.begin()), I(s4.end())); r2.assign(I(s4.begin()), I(s4.end()));
assert(r2.flags() == std::regex::ECMAScript); assert(r2.flags() == std::regex::ECMAScript);
assert(r2.mark_count() == 2); assert(r2.mark_count() == 2);
Show All 14 Lines

libcxx/test/std/strings/basic.string/cpp17_input_iterator.h

  • This file was moved from libcxx/test/std/strings/basic.string/input_iterator.h.
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#ifndef INPUT_ITERATOR_H #ifndef INPUT_ITERATOR_H
#define INPUT_ITERATOR_H #define INPUT_ITERATOR_H
#include <iterator> #include <iterator>
template <class It> template <class It>
class input_iterator class cpp17_input_iterator
{ {
It it_; It it_;
public: public:
typedef typename std::input_iterator_tag iterator_category; typedef typename std::input_iterator_tag iterator_category;
typedef typename std::iterator_traits<It>::value_type value_type; typedef typename std::iterator_traits<It>::value_type value_type;
typedef typename std::iterator_traits<It>::difference_type difference_type; typedef typename std::iterator_traits<It>::difference_type difference_type;
typedef It pointer; typedef It pointer;
typedef typename std::iterator_traits<It>::reference reference; typedef typename std::iterator_traits<It>::reference reference;
input_iterator() : it_() {} cpp17_input_iterator() : it_() {}
explicit input_iterator(It it) : it_(it) {} explicit cpp17_input_iterator(It it) : it_(it) {}
reference operator*() const {return *it_;} reference operator*() const {return *it_;}
pointer operator->() const {return it_;} pointer operator->() const {return it_;}
input_iterator& operator++() {++it_; return *this;} cpp17_input_iterator& operator++() {++it_; return *this;}
input_iterator operator++(int) {input_iterator tmp(*this); ++(*this); return tmp;} cpp17_input_iterator operator++(int) {cpp17_input_iterator tmp(*this); ++(*this); return tmp;}
friend bool operator==(const input_iterator& x, const input_iterator& y) friend bool operator==(const cpp17_input_iterator& x, const cpp17_input_iterator& y)
{return x.it_ == y.it_;} {return x.it_ == y.it_;}
friend bool operator!=(const input_iterator& x, const input_iterator& y) friend bool operator!=(const cpp17_input_iterator& x, const cpp17_input_iterator& y)
{return !(x == y);} {return !(x == y);}
}; };
#endif // INPUT_ITERATOR_H #endif // INPUT_ITERATOR_H

libcxx/test/std/strings/basic.string/input_iterator.h

  • This file was moved to libcxx/test/std/strings/basic.string/cpp17_input_iterator.h.

libcxx/test/std/strings/basic.string/string.cons/implicit_deduction_guides.pass.cpp

Show First 20 Lines • Show All 169 Lines • ▼ Show 20 Lines using TestSizeT = test_allocator<char>::size_type;
using WStr = std::basic_string<wchar_t, using WStr = std::basic_string<wchar_t,
std::char_traits<wchar_t>, std::char_traits<wchar_t>,
test_allocator<wchar_t>>; test_allocator<wchar_t>>;
std::basic_string w(L"abcdef", test_allocator<wchar_t>{}); std::basic_string w(L"abcdef", test_allocator<wchar_t>{});
ASSERT_SAME_TYPE(decltype(w), WStr); ASSERT_SAME_TYPE(decltype(w), WStr);
assert(w == L"abcdef"); assert(w == L"abcdef");
} }
{ // (8) w/o allocator { // (8) w/o allocator
using It = input_iterator<const char*>; using It = cpp17_input_iterator<const char*>;
const char* input = "abcdef"; const char* input = "abcdef";
std::basic_string s(It(input), It(input + 3), std::allocator<char>{}); std::basic_string s(It(input), It(input + 3), std::allocator<char>{});
ASSERT_SAME_TYPE(decltype(s), std::string); ASSERT_SAME_TYPE(decltype(s), std::string);
assert(s == "abc"); assert(s == "abc");
} }
{ // (8) w/ allocator { // (8) w/ allocator
using ExpectW = std::basic_string<wchar_t, std::char_traits<wchar_t>, test_allocator<wchar_t>>; using ExpectW = std::basic_string<wchar_t, std::char_traits<wchar_t>, test_allocator<wchar_t>>;
using It = input_iterator<const wchar_t*>; using It = cpp17_input_iterator<const wchar_t*>;
const wchar_t* input = L"abcdef"; const wchar_t* input = L"abcdef";
std::basic_string s(It(input), It(input + 3), test_allocator<wchar_t>{}); std::basic_string s(It(input), It(input + 3), test_allocator<wchar_t>{});
ASSERT_SAME_TYPE(decltype(s), ExpectW); ASSERT_SAME_TYPE(decltype(s), ExpectW);
assert(s == L"abc"); assert(s == L"abc");
} }
{ // Testing (9) { // Testing (9)
const std::string sin("abc"); const std::string sin("abc");
std::basic_string s(sin); std::basic_string s(sin);
▲ Show 20 Lines • Show All 124 Lines • Show Last 20 Lines

libcxx/test/std/strings/basic.string/string.cons/iter_alloc.pass.cpp

Show All 14 Lines
#include <string> #include <string>
#include <iterator> #include <iterator>
#include <cassert> #include <cassert>
#include <cstddef> #include <cstddef>
#include "test_macros.h" #include "test_macros.h"
#include "test_allocator.h" #include "test_allocator.h"
#include "../input_iterator.h" #include "../cpp17_input_iterator.h"
#include "min_allocator.h" #include "min_allocator.h"
template <class It> template <class It>
void void
test(It first, It last) test(It first, It last)
{ {
typedef typename std::iterator_traits<It>::value_type charT; typedef typename std::iterator_traits<It>::value_type charT;
typedef std::basic_string<charT, std::char_traits<charT>, test_allocator<charT> > S; typedef std::basic_string<charT, std::char_traits<charT>, test_allocator<charT> > S;
Show All 37 Linesint main(int, char**)
test(s, s+1, A(2)); test(s, s+1, A(2));
test(s, s+10); test(s, s+10);
test(s, s+10, A(2)); test(s, s+10, A(2));
test(s, s+50); test(s, s+50);
test(s, s+50, A(2)); test(s, s+50, A(2));
test(input_iterator<const char*>(s), input_iterator<const char*>(s)); test(cpp17_input_iterator<const char*>(s), cpp17_input_iterator<const char*>(s));
test(input_iterator<const char*>(s), input_iterator<const char*>(s), A(2)); test(cpp17_input_iterator<const char*>(s), cpp17_input_iterator<const char*>(s), A(2));
test(input_iterator<const char*>(s), input_iterator<const char*>(s+1)); test(cpp17_input_iterator<const char*>(s), cpp17_input_iterator<const char*>(s+1));
test(input_iterator<const char*>(s), input_iterator<const char*>(s+1), A(2)); test(cpp17_input_iterator<const char*>(s), cpp17_input_iterator<const char*>(s+1), A(2));
test(input_iterator<const char*>(s), input_iterator<const char*>(s+10)); test(cpp17_input_iterator<const char*>(s), cpp17_input_iterator<const char*>(s+10));
test(input_iterator<const char*>(s), input_iterator<const char*>(s+10), A(2)); test(cpp17_input_iterator<const char*>(s), cpp17_input_iterator<const char*>(s+10), A(2));
test(input_iterator<const char*>(s), input_iterator<const char*>(s+50)); test(cpp17_input_iterator<const char*>(s), cpp17_input_iterator<const char*>(s+50));
test(input_iterator<const char*>(s), input_iterator<const char*>(s+50), A(2)); test(cpp17_input_iterator<const char*>(s), cpp17_input_iterator<const char*>(s+50), A(2));
} }
#if TEST_STD_VER >= 11 #if TEST_STD_VER >= 11
{ {
typedef min_allocator<char> A; typedef min_allocator<char> A;
const char* s = "12345678901234567890123456789012345678901234567890"; const char* s = "12345678901234567890123456789012345678901234567890";
test(s, s); test(s, s);
test(s, s, A()); test(s, s, A());
test(s, s+1); test(s, s+1);
test(s, s+1, A()); test(s, s+1, A());
test(s, s+10); test(s, s+10);
test(s, s+10, A()); test(s, s+10, A());
test(s, s+50); test(s, s+50);
test(s, s+50, A()); test(s, s+50, A());
test(input_iterator<const char*>(s), input_iterator<const char*>(s)); test(cpp17_input_iterator<const char*>(s), cpp17_input_iterator<const char*>(s));
test(input_iterator<const char*>(s), input_iterator<const char*>(s), A()); test(cpp17_input_iterator<const char*>(s), cpp17_input_iterator<const char*>(s), A());
test(input_iterator<const char*>(s), input_iterator<const char*>(s+1)); test(cpp17_input_iterator<const char*>(s), cpp17_input_iterator<const char*>(s+1));
test(input_iterator<const char*>(s), input_iterator<const char*>(s+1), A()); test(cpp17_input_iterator<const char*>(s), cpp17_input_iterator<const char*>(s+1), A());
test(input_iterator<const char*>(s), input_iterator<const char*>(s+10)); test(cpp17_input_iterator<const char*>(s), cpp17_input_iterator<const char*>(s+10));
test(input_iterator<const char*>(s), input_iterator<const char*>(s+10), A()); test(cpp17_input_iterator<const char*>(s), cpp17_input_iterator<const char*>(s+10), A());
test(input_iterator<const char*>(s), input_iterator<const char*>(s+50)); test(cpp17_input_iterator<const char*>(s), cpp17_input_iterator<const char*>(s+50));
test(input_iterator<const char*>(s), input_iterator<const char*>(s+50), A()); test(cpp17_input_iterator<const char*>(s), cpp17_input_iterator<const char*>(s+50), A());
} }
#endif #endif
{ {
static_assert((!std::is_constructible<std::string, std::string, static_assert((!std::is_constructible<std::string, std::string,
std::string>::value), std::string>::value),
""); "");
static_assert( static_assert(
(!std::is_constructible<std::string, std::string, std::string, (!std::is_constructible<std::string, std::string, std::string,
std::allocator<char> >::value), std::allocator<char> >::value),
""); "");
} }
return 0; return 0;
} }

libcxx/test/std/strings/basic.string/string.cons/iter_alloc_deduction.pass.cpp

Show All 27 Lines
#include <string> #include <string>
#include <iterator> #include <iterator>
#include <cassert> #include <cassert>
#include <cstddef> #include <cstddef>
#include "test_macros.h" #include "test_macros.h"
#include "test_allocator.h" #include "test_allocator.h"
#include "../input_iterator.h" #include "../cpp17_input_iterator.h"
#include "min_allocator.h" #include "min_allocator.h"
int main(int, char**) int main(int, char**)
{ {
{ {
const char* s = "12345678901234"; const char* s = "12345678901234";
std::basic_string s1(s, s+10); // Can't use {} here std::basic_string s1(s, s+10); // Can't use {} here
using S = decltype(s1); // what type did we get? using S = decltype(s1); // what type did we get?
▲ Show 20 Lines • Show All 50 Lines • Show Last 20 Lines

libcxx/test/std/strings/basic.string/string.cons/string_view_deduction.pass.cpp

Show All 29 Lines
#include <iterator> #include <iterator>
#include <memory> #include <memory>
#include <type_traits> #include <type_traits>
#include <cassert> #include <cassert>
#include <cstddef> #include <cstddef>
#include "test_macros.h" #include "test_macros.h"
#include "test_allocator.h" #include "test_allocator.h"
#include "../input_iterator.h" #include "../cpp17_input_iterator.h"
#include "min_allocator.h" #include "min_allocator.h"
int main(int, char**) int main(int, char**)
{ {
{ {
std::string_view sv = "12345678901234"; std::string_view sv = "12345678901234";
std::basic_string s1(sv); std::basic_string s1(sv);
using S = decltype(s1); // what type did we get? using S = decltype(s1); // what type did we get?
▲ Show 20 Lines • Show All 62 Lines • Show Last 20 Lines

libcxx/test/std/strings/basic.string/string.cons/string_view_size_size_deduction.pass.cpp

Show All 33 Lines
#include <string> #include <string>
#include <string_view> #include <string_view>
#include <iterator> #include <iterator>
#include <cassert> #include <cassert>
#include <cstddef> #include <cstddef>
#include "test_macros.h" #include "test_macros.h"
#include "test_allocator.h" #include "test_allocator.h"
#include "../input_iterator.h" #include "../cpp17_input_iterator.h"
#include "min_allocator.h" #include "min_allocator.h"
int main(int, char**) int main(int, char**)
{ {
{ {
std::string_view sv = "12345678901234"; std::string_view sv = "12345678901234";
std::basic_string s1{sv, 0, 4}; std::basic_string s1{sv, 0, 4};
using S = decltype(s1); // what type did we get? using S = decltype(s1); // what type did we get?
▲ Show 20 Lines • Show All 62 Lines • Show Last 20 Lines

libcxx/test/std/strings/basic.string/string.modifiers/string_append/iterator.pass.cpp

Show First 20 Lines • Show All 72 Lines • ▼ Show 20 Linesint main(int, char**)
test(S("1234567890"), s, s+52, S("1234567890ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz")); test(S("1234567890"), s, s+52, S("1234567890ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz"));
test(S("12345678901234567890"), s, s, S("12345678901234567890")); test(S("12345678901234567890"), s, s, S("12345678901234567890"));
test(S("12345678901234567890"), s, s+1, S("12345678901234567890""A")); test(S("12345678901234567890"), s, s+1, S("12345678901234567890""A"));
test(S("12345678901234567890"), s, s+10, S("12345678901234567890""ABCDEFGHIJ")); test(S("12345678901234567890"), s, s+10, S("12345678901234567890""ABCDEFGHIJ"));
test(S("12345678901234567890"), s, s+52, test(S("12345678901234567890"), s, s+52,
S("12345678901234567890""ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz")); S("12345678901234567890""ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz"));
test(S(), input_iterator<const char*>(s), input_iterator<const char*>(s), S()); test(S(), cpp17_input_iterator<const char*>(s), cpp17_input_iterator<const char*>(s), S());
test(S(), input_iterator<const char*>(s), input_iterator<const char*>(s+1), S("A")); test(S(), cpp17_input_iterator<const char*>(s), cpp17_input_iterator<const char*>(s+1), S("A"));
test(S(), input_iterator<const char*>(s), input_iterator<const char*>(s+10), test(S(), cpp17_input_iterator<const char*>(s), cpp17_input_iterator<const char*>(s+10),
S("ABCDEFGHIJ")); S("ABCDEFGHIJ"));
test(S(), input_iterator<const char*>(s), input_iterator<const char*>(s+52), test(S(), cpp17_input_iterator<const char*>(s), cpp17_input_iterator<const char*>(s+52),
S("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz")); S("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz"));
test(S("12345"), input_iterator<const char*>(s), input_iterator<const char*>(s), test(S("12345"), cpp17_input_iterator<const char*>(s), cpp17_input_iterator<const char*>(s),
S("12345")); S("12345"));
test(S("12345"), input_iterator<const char*>(s), input_iterator<const char*>(s+1), test(S("12345"), cpp17_input_iterator<const char*>(s), cpp17_input_iterator<const char*>(s+1),
S("12345A")); S("12345A"));
test(S("12345"), input_iterator<const char*>(s), input_iterator<const char*>(s+10), test(S("12345"), cpp17_input_iterator<const char*>(s), cpp17_input_iterator<const char*>(s+10),
S("12345ABCDEFGHIJ")); S("12345ABCDEFGHIJ"));
test(S("12345"), input_iterator<const char*>(s), input_iterator<const char*>(s+52), test(S("12345"), cpp17_input_iterator<const char*>(s), cpp17_input_iterator<const char*>(s+52),
S("12345ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz")); S("12345ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz"));
test(S("1234567890"), input_iterator<const char*>(s), input_iterator<const char*>(s), test(S("1234567890"), cpp17_input_iterator<const char*>(s), cpp17_input_iterator<const char*>(s),
S("1234567890")); S("1234567890"));
test(S("1234567890"), input_iterator<const char*>(s), input_iterator<const char*>(s+1), test(S("1234567890"), cpp17_input_iterator<const char*>(s), cpp17_input_iterator<const char*>(s+1),
S("1234567890A")); S("1234567890A"));
test(S("1234567890"), input_iterator<const char*>(s), input_iterator<const char*>(s+10), test(S("1234567890"), cpp17_input_iterator<const char*>(s), cpp17_input_iterator<const char*>(s+10),
S("1234567890ABCDEFGHIJ")); S("1234567890ABCDEFGHIJ"));
test(S("1234567890"), input_iterator<const char*>(s), input_iterator<const char*>(s+52), test(S("1234567890"), cpp17_input_iterator<const char*>(s), cpp17_input_iterator<const char*>(s+52),
S("1234567890ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz")); S("1234567890ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz"));
test(S("12345678901234567890"), input_iterator<const char*>(s), input_iterator<const char*>(s), test(S("12345678901234567890"), cpp17_input_iterator<const char*>(s), cpp17_input_iterator<const char*>(s),
S("12345678901234567890")); S("12345678901234567890"));
test(S("12345678901234567890"), input_iterator<const char*>(s), input_iterator<const char*>(s+1), test(S("12345678901234567890"), cpp17_input_iterator<const char*>(s), cpp17_input_iterator<const char*>(s+1),
S("12345678901234567890""A")); S("12345678901234567890""A"));
test(S("12345678901234567890"), input_iterator<const char*>(s), input_iterator<const char*>(s+10), test(S("12345678901234567890"), cpp17_input_iterator<const char*>(s), cpp17_input_iterator<const char*>(s+10),
S("12345678901234567890""ABCDEFGHIJ")); S("12345678901234567890""ABCDEFGHIJ"));
test(S("12345678901234567890"), input_iterator<const char*>(s), input_iterator<const char*>(s+52), test(S("12345678901234567890"), cpp17_input_iterator<const char*>(s), cpp17_input_iterator<const char*>(s+52),
S("12345678901234567890""ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz")); S("12345678901234567890""ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz"));
} }
#if TEST_STD_VER >= 11 #if TEST_STD_VER >= 11
{ {
typedef std::basic_string<char, std::char_traits<char>, min_allocator<char>> S; typedef std::basic_string<char, std::char_traits<char>, min_allocator<char>> S;
const char* s = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz"; const char* s = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz";
test(S(), s, s, S()); test(S(), s, s, S());
test(S(), s, s+1, S("A")); test(S(), s, s+1, S("A"));
Show All 11 Lines#if TEST_STD_VER >= 11
test(S("1234567890"), s, s+52, S("1234567890ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz")); test(S("1234567890"), s, s+52, S("1234567890ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz"));
test(S("12345678901234567890"), s, s, S("12345678901234567890")); test(S("12345678901234567890"), s, s, S("12345678901234567890"));
test(S("12345678901234567890"), s, s+1, S("12345678901234567890""A")); test(S("12345678901234567890"), s, s+1, S("12345678901234567890""A"));
test(S("12345678901234567890"), s, s+10, S("12345678901234567890""ABCDEFGHIJ")); test(S("12345678901234567890"), s, s+10, S("12345678901234567890""ABCDEFGHIJ"));
test(S("12345678901234567890"), s, s+52, test(S("12345678901234567890"), s, s+52,
S("12345678901234567890""ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz")); S("12345678901234567890""ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz"));
test(S(), input_iterator<const char*>(s), input_iterator<const char*>(s), S()); test(S(), cpp17_input_iterator<const char*>(s), cpp17_input_iterator<const char*>(s), S());
test(S(), input_iterator<const char*>(s), input_iterator<const char*>(s+1), S("A")); test(S(), cpp17_input_iterator<const char*>(s), cpp17_input_iterator<const char*>(s+1), S("A"));
test(S(), input_iterator<const char*>(s), input_iterator<const char*>(s+10), test(S(), cpp17_input_iterator<const char*>(s), cpp17_input_iterator<const char*>(s+10),
S("ABCDEFGHIJ")); S("ABCDEFGHIJ"));
test(S(), input_iterator<const char*>(s), input_iterator<const char*>(s+52), test(S(), cpp17_input_iterator<const char*>(s), cpp17_input_iterator<const char*>(s+52),
S("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz")); S("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz"));
test(S("12345"), input_iterator<const char*>(s), input_iterator<const char*>(s), test(S("12345"), cpp17_input_iterator<const char*>(s), cpp17_input_iterator<const char*>(s),
S("12345")); S("12345"));
test(S("12345"), input_iterator<const char*>(s), input_iterator<const char*>(s+1), test(S("12345"), cpp17_input_iterator<const char*>(s), cpp17_input_iterator<const char*>(s+1),
S("12345A")); S("12345A"));
test(S("12345"), input_iterator<const char*>(s), input_iterator<const char*>(s+10), test(S("12345"), cpp17_input_iterator<const char*>(s), cpp17_input_iterator<const char*>(s+10),
S("12345ABCDEFGHIJ")); S("12345ABCDEFGHIJ"));
test(S("12345"), input_iterator<const char*>(s), input_iterator<const char*>(s+52), test(S("12345"), cpp17_input_iterator<const char*>(s), cpp17_input_iterator<const char*>(s+52),
S("12345ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz")); S("12345ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz"));
test(S("1234567890"), input_iterator<const char*>(s), input_iterator<const char*>(s), test(S("1234567890"), cpp17_input_iterator<const char*>(s), cpp17_input_iterator<const char*>(s),
S("1234567890")); S("1234567890"));
test(S("1234567890"), input_iterator<const char*>(s), input_iterator<const char*>(s+1), test(S("1234567890"), cpp17_input_iterator<const char*>(s), cpp17_input_iterator<const char*>(s+1),
S("1234567890A")); S("1234567890A"));
test(S("1234567890"), input_iterator<const char*>(s), input_iterator<const char*>(s+10), test(S("1234567890"), cpp17_input_iterator<const char*>(s), cpp17_input_iterator<const char*>(s+10),
S("1234567890ABCDEFGHIJ")); S("1234567890ABCDEFGHIJ"));
test(S("1234567890"), input_iterator<const char*>(s), input_iterator<const char*>(s+52), test(S("1234567890"), cpp17_input_iterator<const char*>(s), cpp17_input_iterator<const char*>(s+52),
S("1234567890ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz")); S("1234567890ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz"));
test(S("12345678901234567890"), input_iterator<const char*>(s), input_iterator<const char*>(s), test(S("12345678901234567890"), cpp17_input_iterator<const char*>(s), cpp17_input_iterator<const char*>(s),
S("12345678901234567890")); S("12345678901234567890"));
test(S("12345678901234567890"), input_iterator<const char*>(s), input_iterator<const char*>(s+1), test(S("12345678901234567890"), cpp17_input_iterator<const char*>(s), cpp17_input_iterator<const char*>(s+1),
S("12345678901234567890""A")); S("12345678901234567890""A"));
test(S("12345678901234567890"), input_iterator<const char*>(s), input_iterator<const char*>(s+10), test(S("12345678901234567890"), cpp17_input_iterator<const char*>(s), cpp17_input_iterator<const char*>(s+10),
S("12345678901234567890""ABCDEFGHIJ")); S("12345678901234567890""ABCDEFGHIJ"));
test(S("12345678901234567890"), input_iterator<const char*>(s), input_iterator<const char*>(s+52), test(S("12345678901234567890"), cpp17_input_iterator<const char*>(s), cpp17_input_iterator<const char*>(s+52),
S("12345678901234567890""ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz")); S("12345678901234567890""ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz"));
} }
#endif #endif
#ifndef TEST_HAS_NO_EXCEPTIONS #ifndef TEST_HAS_NO_EXCEPTIONS
{ // test iterator operations that throw { // test iterator operations that throw
typedef std::string S; typedef std::string S;
typedef ThrowingIterator<char> TIter; typedef ThrowingIterator<char> TIter;
typedef input_iterator<TIter> IIter; typedef cpp17_input_iterator<TIter> IIter;
const char* s = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz"; const char* s = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz";
test_exceptions(S(), IIter(TIter(s, s+10, 4, TIter::TAIncrement)), IIter()); test_exceptions(S(), IIter(TIter(s, s+10, 4, TIter::TAIncrement)), IIter());
test_exceptions(S(), IIter(TIter(s, s+10, 5, TIter::TADereference)), IIter()); test_exceptions(S(), IIter(TIter(s, s+10, 5, TIter::TADereference)), IIter());
test_exceptions(S(), IIter(TIter(s, s+10, 6, TIter::TAComparison)), IIter()); test_exceptions(S(), IIter(TIter(s, s+10, 6, TIter::TAComparison)), IIter());
test_exceptions(S(), TIter(s, s+10, 4, TIter::TAIncrement), TIter()); test_exceptions(S(), TIter(s, s+10, 4, TIter::TAIncrement), TIter());
test_exceptions(S(), TIter(s, s+10, 5, TIter::TADereference), TIter()); test_exceptions(S(), TIter(s, s+10, 5, TIter::TADereference), TIter());
test_exceptions(S(), TIter(s, s+10, 6, TIter::TAComparison), TIter()); test_exceptions(S(), TIter(s, s+10, 6, TIter::TAComparison), TIter());
▲ Show 20 Lines • Show All 67 Lines • Show Last 20 Lines

libcxx/test/std/strings/basic.string/string.modifiers/string_assign/iterator.pass.cpp

Show First 20 Lines • Show All 74 Lines • ▼ Show 20 Linesint main(int, char**)
test(S("1234567890"), s, s+52, S("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz")); test(S("1234567890"), s, s+52, S("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz"));
test(S("12345678901234567890"), s, s, S()); test(S("12345678901234567890"), s, s, S());
test(S("12345678901234567890"), s, s+1, S("A")); test(S("12345678901234567890"), s, s+1, S("A"));
test(S("12345678901234567890"), s, s+10, S("ABCDEFGHIJ")); test(S("12345678901234567890"), s, s+10, S("ABCDEFGHIJ"));
test(S("12345678901234567890"), s, s+52, test(S("12345678901234567890"), s, s+52,
S("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz")); S("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz"));
test(S(), input_iterator<const char*>(s), input_iterator<const char*>(s), S()); test(S(), cpp17_input_iterator<const char*>(s), cpp17_input_iterator<const char*>(s), S());
test(S(), input_iterator<const char*>(s), input_iterator<const char*>(s+1), S("A")); test(S(), cpp17_input_iterator<const char*>(s), cpp17_input_iterator<const char*>(s+1), S("A"));
test(S(), input_iterator<const char*>(s), input_iterator<const char*>(s+10), test(S(), cpp17_input_iterator<const char*>(s), cpp17_input_iterator<const char*>(s+10),
S("ABCDEFGHIJ")); S("ABCDEFGHIJ"));
test(S(), input_iterator<const char*>(s), input_iterator<const char*>(s+52), test(S(), cpp17_input_iterator<const char*>(s), cpp17_input_iterator<const char*>(s+52),
S("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz")); S("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz"));
test(S("12345"), input_iterator<const char*>(s), input_iterator<const char*>(s), test(S("12345"), cpp17_input_iterator<const char*>(s), cpp17_input_iterator<const char*>(s),
S()); S());
test(S("12345"), input_iterator<const char*>(s), input_iterator<const char*>(s+1), test(S("12345"), cpp17_input_iterator<const char*>(s), cpp17_input_iterator<const char*>(s+1),
S("A")); S("A"));
test(S("12345"), input_iterator<const char*>(s), input_iterator<const char*>(s+10), test(S("12345"), cpp17_input_iterator<const char*>(s), cpp17_input_iterator<const char*>(s+10),
S("ABCDEFGHIJ")); S("ABCDEFGHIJ"));
test(S("12345"), input_iterator<const char*>(s), input_iterator<const char*>(s+52), test(S("12345"), cpp17_input_iterator<const char*>(s), cpp17_input_iterator<const char*>(s+52),
S("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz")); S("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz"));
test(S("1234567890"), input_iterator<const char*>(s), input_iterator<const char*>(s), test(S("1234567890"), cpp17_input_iterator<const char*>(s), cpp17_input_iterator<const char*>(s),
S()); S());
test(S("1234567890"), input_iterator<const char*>(s), input_iterator<const char*>(s+1), test(S("1234567890"), cpp17_input_iterator<const char*>(s), cpp17_input_iterator<const char*>(s+1),
S("A")); S("A"));
test(S("1234567890"), input_iterator<const char*>(s), input_iterator<const char*>(s+10), test(S("1234567890"), cpp17_input_iterator<const char*>(s), cpp17_input_iterator<const char*>(s+10),
S("ABCDEFGHIJ")); S("ABCDEFGHIJ"));
test(S("1234567890"), input_iterator<const char*>(s), input_iterator<const char*>(s+52), test(S("1234567890"), cpp17_input_iterator<const char*>(s), cpp17_input_iterator<const char*>(s+52),
S("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz")); S("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz"));
test(S("12345678901234567890"), input_iterator<const char*>(s), input_iterator<const char*>(s), test(S("12345678901234567890"), cpp17_input_iterator<const char*>(s), cpp17_input_iterator<const char*>(s),
S()); S());
test(S("12345678901234567890"), input_iterator<const char*>(s), input_iterator<const char*>(s+1), test(S("12345678901234567890"), cpp17_input_iterator<const char*>(s), cpp17_input_iterator<const char*>(s+1),
S("A")); S("A"));
test(S("12345678901234567890"), input_iterator<const char*>(s), input_iterator<const char*>(s+10), test(S("12345678901234567890"), cpp17_input_iterator<const char*>(s), cpp17_input_iterator<const char*>(s+10),
S("ABCDEFGHIJ")); S("ABCDEFGHIJ"));
test(S("12345678901234567890"), input_iterator<const char*>(s), input_iterator<const char*>(s+52), test(S("12345678901234567890"), cpp17_input_iterator<const char*>(s), cpp17_input_iterator<const char*>(s+52),
S("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz")); S("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz"));
} }
#if TEST_STD_VER >= 11 #if TEST_STD_VER >= 11
{ {
typedef std::basic_string<char, std::char_traits<char>, min_allocator<char>> S; typedef std::basic_string<char, std::char_traits<char>, min_allocator<char>> S;
const char* s = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz"; const char* s = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz";
test(S(), s, s, S()); test(S(), s, s, S());
test(S(), s, s+1, S("A")); test(S(), s, s+1, S("A"));
Show All 11 Lines#if TEST_STD_VER >= 11
test(S("1234567890"), s, s+52, S("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz")); test(S("1234567890"), s, s+52, S("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz"));
test(S("12345678901234567890"), s, s, S()); test(S("12345678901234567890"), s, s, S());
test(S("12345678901234567890"), s, s+1, S("A")); test(S("12345678901234567890"), s, s+1, S("A"));
test(S("12345678901234567890"), s, s+10, S("ABCDEFGHIJ")); test(S("12345678901234567890"), s, s+10, S("ABCDEFGHIJ"));
test(S("12345678901234567890"), s, s+52, test(S("12345678901234567890"), s, s+52,
S("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz")); S("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz"));
test(S(), input_iterator<const char*>(s), input_iterator<const char*>(s), S()); test(S(), cpp17_input_iterator<const char*>(s), cpp17_input_iterator<const char*>(s), S());
test(S(), input_iterator<const char*>(s), input_iterator<const char*>(s+1), S("A")); test(S(), cpp17_input_iterator<const char*>(s), cpp17_input_iterator<const char*>(s+1), S("A"));
test(S(), input_iterator<const char*>(s), input_iterator<const char*>(s+10), test(S(), cpp17_input_iterator<const char*>(s), cpp17_input_iterator<const char*>(s+10),
S("ABCDEFGHIJ")); S("ABCDEFGHIJ"));
test(S(), input_iterator<const char*>(s), input_iterator<const char*>(s+52), test(S(), cpp17_input_iterator<const char*>(s), cpp17_input_iterator<const char*>(s+52),
S("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz")); S("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz"));
test(S("12345"), input_iterator<const char*>(s), input_iterator<const char*>(s), test(S("12345"), cpp17_input_iterator<const char*>(s), cpp17_input_iterator<const char*>(s),
S()); S());
test(S("12345"), input_iterator<const char*>(s), input_iterator<const char*>(s+1), test(S("12345"), cpp17_input_iterator<const char*>(s), cpp17_input_iterator<const char*>(s+1),
S("A")); S("A"));
test(S("12345"), input_iterator<const char*>(s), input_iterator<const char*>(s+10), test(S("12345"), cpp17_input_iterator<const char*>(s), cpp17_input_iterator<const char*>(s+10),
S("ABCDEFGHIJ")); S("ABCDEFGHIJ"));
test(S("12345"), input_iterator<const char*>(s), input_iterator<const char*>(s+52), test(S("12345"), cpp17_input_iterator<const char*>(s), cpp17_input_iterator<const char*>(s+52),
S("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz")); S("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz"));
test(S("1234567890"), input_iterator<const char*>(s), input_iterator<const char*>(s), test(S("1234567890"), cpp17_input_iterator<const char*>(s), cpp17_input_iterator<const char*>(s),
S()); S());
test(S("1234567890"), input_iterator<const char*>(s), input_iterator<const char*>(s+1), test(S("1234567890"), cpp17_input_iterator<const char*>(s), cpp17_input_iterator<const char*>(s+1),
S("A")); S("A"));
test(S("1234567890"), input_iterator<const char*>(s), input_iterator<const char*>(s+10), test(S("1234567890"), cpp17_input_iterator<const char*>(s), cpp17_input_iterator<const char*>(s+10),
S("ABCDEFGHIJ")); S("ABCDEFGHIJ"));
test(S("1234567890"), input_iterator<const char*>(s), input_iterator<const char*>(s+52), test(S("1234567890"), cpp17_input_iterator<const char*>(s), cpp17_input_iterator<const char*>(s+52),
S("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz")); S("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz"));
test(S("12345678901234567890"), input_iterator<const char*>(s), input_iterator<const char*>(s), test(S("12345678901234567890"), cpp17_input_iterator<const char*>(s), cpp17_input_iterator<const char*>(s),
S()); S());
test(S("12345678901234567890"), input_iterator<const char*>(s), input_iterator<const char*>(s+1), test(S("12345678901234567890"), cpp17_input_iterator<const char*>(s), cpp17_input_iterator<const char*>(s+1),
S("A")); S("A"));
test(S("12345678901234567890"), input_iterator<const char*>(s), input_iterator<const char*>(s+10), test(S("12345678901234567890"), cpp17_input_iterator<const char*>(s), cpp17_input_iterator<const char*>(s+10),
S("ABCDEFGHIJ")); S("ABCDEFGHIJ"));
test(S("12345678901234567890"), input_iterator<const char*>(s), input_iterator<const char*>(s+52), test(S("12345678901234567890"), cpp17_input_iterator<const char*>(s), cpp17_input_iterator<const char*>(s+52),
S("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz")); S("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz"));
} }
#endif #endif
#ifndef TEST_HAS_NO_EXCEPTIONS #ifndef TEST_HAS_NO_EXCEPTIONS
{ // test iterator operations that throw { // test iterator operations that throw
typedef std::string S; typedef std::string S;
typedef ThrowingIterator<char> TIter; typedef ThrowingIterator<char> TIter;
typedef input_iterator<TIter> IIter; typedef cpp17_input_iterator<TIter> IIter;
const char* s = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz"; const char* s = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz";
test_exceptions(S(), IIter(TIter(s, s+10, 4, TIter::TAIncrement)), IIter()); test_exceptions(S(), IIter(TIter(s, s+10, 4, TIter::TAIncrement)), IIter());
test_exceptions(S(), IIter(TIter(s, s+10, 5, TIter::TADereference)), IIter()); test_exceptions(S(), IIter(TIter(s, s+10, 5, TIter::TADereference)), IIter());
test_exceptions(S(), IIter(TIter(s, s+10, 6, TIter::TAComparison)), IIter()); test_exceptions(S(), IIter(TIter(s, s+10, 6, TIter::TAComparison)), IIter());
test_exceptions(S(), TIter(s, s+10, 4, TIter::TAIncrement), TIter()); test_exceptions(S(), TIter(s, s+10, 4, TIter::TAIncrement), TIter());
test_exceptions(S(), TIter(s, s+10, 5, TIter::TADereference), TIter()); test_exceptions(S(), TIter(s, s+10, 5, TIter::TADereference), TIter());
test_exceptions(S(), TIter(s, s+10, 6, TIter::TAComparison), TIter()); test_exceptions(S(), TIter(s, s+10, 6, TIter::TAComparison), TIter());
▲ Show 20 Lines • Show All 41 Lines • Show Last 20 Lines

libcxx/test/std/strings/basic.string/string.modifiers/string_insert/iter_iter_iter.pass.cpp

Show First 20 Lines • Show All 76 Lines • ▼ Show 20 Linesint main(int, char**)
test(S("1234567890"), 8, s, s+52, S("12345678ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz90")); test(S("1234567890"), 8, s, s+52, S("12345678ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz90"));
test(S("12345678901234567890"), 3, s, s, S("12345678901234567890")); test(S("12345678901234567890"), 3, s, s, S("12345678901234567890"));
test(S("12345678901234567890"), 3, s, s+1, S("123A45678901234567890")); test(S("12345678901234567890"), 3, s, s+1, S("123A45678901234567890"));
test(S("12345678901234567890"), 15, s, s+10, S("123456789012345ABCDEFGHIJ67890")); test(S("12345678901234567890"), 15, s, s+10, S("123456789012345ABCDEFGHIJ67890"));
test(S("12345678901234567890"), 20, s, s+52, test(S("12345678901234567890"), 20, s, s+52,
S("12345678901234567890ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz")); S("12345678901234567890ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz"));
test(S(), 0, input_iterator<const char*>(s), input_iterator<const char*>(s), S()); test(S(), 0, cpp17_input_iterator<const char*>(s), cpp17_input_iterator<const char*>(s), S());
test(S(), 0, input_iterator<const char*>(s), input_iterator<const char*>(s+1), S("A")); test(S(), 0, cpp17_input_iterator<const char*>(s), cpp17_input_iterator<const char*>(s+1), S("A"));
test(S(), 0, input_iterator<const char*>(s), input_iterator<const char*>(s+10), S("ABCDEFGHIJ")); test(S(), 0, cpp17_input_iterator<const char*>(s), cpp17_input_iterator<const char*>(s+10), S("ABCDEFGHIJ"));
test(S(), 0, input_iterator<const char*>(s), input_iterator<const char*>(s+52), S("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz")); test(S(), 0, cpp17_input_iterator<const char*>(s), cpp17_input_iterator<const char*>(s+52), S("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz"));
test(S("12345"), 0, input_iterator<const char*>(s), input_iterator<const char*>(s), S("12345")); test(S("12345"), 0, cpp17_input_iterator<const char*>(s), cpp17_input_iterator<const char*>(s), S("12345"));
test(S("12345"), 1, input_iterator<const char*>(s), input_iterator<const char*>(s+1), S("1A2345")); test(S("12345"), 1, cpp17_input_iterator<const char*>(s), cpp17_input_iterator<const char*>(s+1), S("1A2345"));
test(S("12345"), 4, input_iterator<const char*>(s), input_iterator<const char*>(s+10), S("1234ABCDEFGHIJ5")); test(S("12345"), 4, cpp17_input_iterator<const char*>(s), cpp17_input_iterator<const char*>(s+10), S("1234ABCDEFGHIJ5"));
test(S("12345"), 5, input_iterator<const char*>(s), input_iterator<const char*>(s+52), S("12345ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz")); test(S("12345"), 5, cpp17_input_iterator<const char*>(s), cpp17_input_iterator<const char*>(s+52), S("12345ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz"));
test(S("1234567890"), 0, input_iterator<const char*>(s), input_iterator<const char*>(s), S("1234567890")); test(S("1234567890"), 0, cpp17_input_iterator<const char*>(s), cpp17_input_iterator<const char*>(s), S("1234567890"));
test(S("1234567890"), 1, input_iterator<const char*>(s), input_iterator<const char*>(s+1), S("1A234567890")); test(S("1234567890"), 1, cpp17_input_iterator<const char*>(s), cpp17_input_iterator<const char*>(s+1), S("1A234567890"));
test(S("1234567890"), 10, input_iterator<const char*>(s), input_iterator<const char*>(s+10), S("1234567890ABCDEFGHIJ")); test(S("1234567890"), 10, cpp17_input_iterator<const char*>(s), cpp17_input_iterator<const char*>(s+10), S("1234567890ABCDEFGHIJ"));
test(S("1234567890"), 8, input_iterator<const char*>(s), input_iterator<const char*>(s+52), S("12345678ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz90")); test(S("1234567890"), 8, cpp17_input_iterator<const char*>(s), cpp17_input_iterator<const char*>(s+52), S("12345678ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz90"));
test(S("12345678901234567890"), 3, input_iterator<const char*>(s), input_iterator<const char*>(s), S("12345678901234567890")); test(S("12345678901234567890"), 3, cpp17_input_iterator<const char*>(s), cpp17_input_iterator<const char*>(s), S("12345678901234567890"));
test(S("12345678901234567890"), 3, input_iterator<const char*>(s), input_iterator<const char*>(s+1), S("123A45678901234567890")); test(S("12345678901234567890"), 3, cpp17_input_iterator<const char*>(s), cpp17_input_iterator<const char*>(s+1), S("123A45678901234567890"));
test(S("12345678901234567890"), 15, input_iterator<const char*>(s), input_iterator<const char*>(s+10), S("123456789012345ABCDEFGHIJ67890")); test(S("12345678901234567890"), 15, cpp17_input_iterator<const char*>(s), cpp17_input_iterator<const char*>(s+10), S("123456789012345ABCDEFGHIJ67890"));
test(S("12345678901234567890"), 20, input_iterator<const char*>(s), input_iterator<const char*>(s+52), test(S("12345678901234567890"), 20, cpp17_input_iterator<const char*>(s), cpp17_input_iterator<const char*>(s+52),
S("12345678901234567890ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz")); S("12345678901234567890ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz"));
} }
#if TEST_STD_VER >= 11 #if TEST_STD_VER >= 11
{ {
typedef std::basic_string<char, std::char_traits<char>, min_allocator<char>> S; typedef std::basic_string<char, std::char_traits<char>, min_allocator<char>> S;
const char* s = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz"; const char* s = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz";
test(S(), 0, s, s, S()); test(S(), 0, s, s, S());
test(S(), 0, s, s+1, S("A")); test(S(), 0, s, s+1, S("A"));
Show All 11 Lines#if TEST_STD_VER >= 11
test(S("1234567890"), 8, s, s+52, S("12345678ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz90")); test(S("1234567890"), 8, s, s+52, S("12345678ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz90"));
test(S("12345678901234567890"), 3, s, s, S("12345678901234567890")); test(S("12345678901234567890"), 3, s, s, S("12345678901234567890"));
test(S("12345678901234567890"), 3, s, s+1, S("123A45678901234567890")); test(S("12345678901234567890"), 3, s, s+1, S("123A45678901234567890"));
test(S("12345678901234567890"), 15, s, s+10, S("123456789012345ABCDEFGHIJ67890")); test(S("12345678901234567890"), 15, s, s+10, S("123456789012345ABCDEFGHIJ67890"));
test(S("12345678901234567890"), 20, s, s+52, test(S("12345678901234567890"), 20, s, s+52,
S("12345678901234567890ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz")); S("12345678901234567890ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz"));
test(S(), 0, input_iterator<const char*>(s), input_iterator<const char*>(s), S()); test(S(), 0, cpp17_input_iterator<const char*>(s), cpp17_input_iterator<const char*>(s), S());
test(S(), 0, input_iterator<const char*>(s), input_iterator<const char*>(s+1), S("A")); test(S(), 0, cpp17_input_iterator<const char*>(s), cpp17_input_iterator<const char*>(s+1), S("A"));
test(S(), 0, input_iterator<const char*>(s), input_iterator<const char*>(s+10), S("ABCDEFGHIJ")); test(S(), 0, cpp17_input_iterator<const char*>(s), cpp17_input_iterator<const char*>(s+10), S("ABCDEFGHIJ"));
test(S(), 0, input_iterator<const char*>(s), input_iterator<const char*>(s+52), S("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz")); test(S(), 0, cpp17_input_iterator<const char*>(s), cpp17_input_iterator<const char*>(s+52), S("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz"));
test(S("12345"), 0, input_iterator<const char*>(s), input_iterator<const char*>(s), S("12345")); test(S("12345"), 0, cpp17_input_iterator<const char*>(s), cpp17_input_iterator<const char*>(s), S("12345"));
test(S("12345"), 1, input_iterator<const char*>(s), input_iterator<const char*>(s+1), S("1A2345")); test(S("12345"), 1, cpp17_input_iterator<const char*>(s), cpp17_input_iterator<const char*>(s+1), S("1A2345"));
test(S("12345"), 4, input_iterator<const char*>(s), input_iterator<const char*>(s+10), S("1234ABCDEFGHIJ5")); test(S("12345"), 4, cpp17_input_iterator<const char*>(s), cpp17_input_iterator<const char*>(s+10), S("1234ABCDEFGHIJ5"));
test(S("12345"), 5, input_iterator<const char*>(s), input_iterator<const char*>(s+52), S("12345ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz")); test(S("12345"), 5, cpp17_input_iterator<const char*>(s), cpp17_input_iterator<const char*>(s+52), S("12345ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz"));
test(S("1234567890"), 0, input_iterator<const char*>(s), input_iterator<const char*>(s), S("1234567890")); test(S("1234567890"), 0, cpp17_input_iterator<const char*>(s), cpp17_input_iterator<const char*>(s), S("1234567890"));
test(S("1234567890"), 1, input_iterator<const char*>(s), input_iterator<const char*>(s+1), S("1A234567890")); test(S("1234567890"), 1, cpp17_input_iterator<const char*>(s), cpp17_input_iterator<const char*>(s+1), S("1A234567890"));
test(S("1234567890"), 10, input_iterator<const char*>(s), input_iterator<const char*>(s+10), S("1234567890ABCDEFGHIJ")); test(S("1234567890"), 10, cpp17_input_iterator<const char*>(s), cpp17_input_iterator<const char*>(s+10), S("1234567890ABCDEFGHIJ"));
test(S("1234567890"), 8, input_iterator<const char*>(s), input_iterator<const char*>(s+52), S("12345678ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz90")); test(S("1234567890"), 8, cpp17_input_iterator<const char*>(s), cpp17_input_iterator<const char*>(s+52), S("12345678ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz90"));
test(S("12345678901234567890"), 3, input_iterator<const char*>(s), input_iterator<const char*>(s), S("12345678901234567890")); test(S("12345678901234567890"), 3, cpp17_input_iterator<const char*>(s), cpp17_input_iterator<const char*>(s), S("12345678901234567890"));
test(S("12345678901234567890"), 3, input_iterator<const char*>(s), input_iterator<const char*>(s+1), S("123A45678901234567890")); test(S("12345678901234567890"), 3, cpp17_input_iterator<const char*>(s), cpp17_input_iterator<const char*>(s+1), S("123A45678901234567890"));
test(S("12345678901234567890"), 15, input_iterator<const char*>(s), input_iterator<const char*>(s+10), S("123456789012345ABCDEFGHIJ67890")); test(S("12345678901234567890"), 15, cpp17_input_iterator<const char*>(s), cpp17_input_iterator<const char*>(s+10), S("123456789012345ABCDEFGHIJ67890"));
test(S("12345678901234567890"), 20, input_iterator<const char*>(s), input_iterator<const char*>(s+52), test(S("12345678901234567890"), 20, cpp17_input_iterator<const char*>(s), cpp17_input_iterator<const char*>(s+52),
S("12345678901234567890ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz")); S("12345678901234567890ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz"));
} }
#endif #endif
#ifndef TEST_HAS_NO_EXCEPTIONS #ifndef TEST_HAS_NO_EXCEPTIONS
{ // test iterator operations that throw { // test iterator operations that throw
typedef std::string S; typedef std::string S;
typedef ThrowingIterator<char> TIter; typedef ThrowingIterator<char> TIter;
typedef input_iterator<TIter> IIter; typedef cpp17_input_iterator<TIter> IIter;
const char* s = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz"; const char* s = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz";
test_exceptions(S(), 0, IIter(TIter(s, s+10, 4, TIter::TAIncrement)), IIter()); test_exceptions(S(), 0, IIter(TIter(s, s+10, 4, TIter::TAIncrement)), IIter());
test_exceptions(S(), 0, IIter(TIter(s, s+10, 5, TIter::TADereference)), IIter()); test_exceptions(S(), 0, IIter(TIter(s, s+10, 5, TIter::TADereference)), IIter());
test_exceptions(S(), 0, IIter(TIter(s, s+10, 6, TIter::TAComparison)), IIter()); test_exceptions(S(), 0, IIter(TIter(s, s+10, 6, TIter::TAComparison)), IIter());
test_exceptions(S(), 0, TIter(s, s+10, 4, TIter::TAIncrement), TIter()); test_exceptions(S(), 0, TIter(s, s+10, 4, TIter::TAIncrement), TIter());
test_exceptions(S(), 0, TIter(s, s+10, 5, TIter::TADereference), TIter()); test_exceptions(S(), 0, TIter(s, s+10, 5, TIter::TADereference), TIter());
test_exceptions(S(), 0, TIter(s, s+10, 6, TIter::TAComparison), TIter()); test_exceptions(S(), 0, TIter(s, s+10, 6, TIter::TAComparison), TIter());
Show All 37 Lines#endif
test(s_short, 0, s_short.data() + s_short.size(), s_short.data() + s_short.size() + 1, test(s_short, 0, s_short.data() + s_short.size(), s_short.data() + s_short.size() + 1,
std::string("\0hello", 6)); std::string("\0hello", 6));
test(s_long, 0, s_long.data() + s_long.size(), s_long.data() + s_long.size() + 1, test(s_long, 0, s_long.data() + s_long.size(), s_long.data() + s_long.size() + 1,
std::string("\0Lorem ipsum dolor sit amet, consectetur/", 41)); std::string("\0Lorem ipsum dolor sit amet, consectetur/", 41));
test(s_othertype, 1, first + 2, first + 5, std::string("hlloello")); test(s_othertype, 1, first + 2, first + 5, std::string("hlloello"));
} }
{ // test with a move iterator that returns char&& { // test with a move iterator that returns char&&
typedef input_iterator<const char*> It; typedef cpp17_input_iterator<const char*> It;
typedef std::move_iterator<It> MoveIt; typedef std::move_iterator<It> MoveIt;
const char p[] = "ABCD"; const char p[] = "ABCD";
std::string s; std::string s;
s.insert(s.begin(), MoveIt(It(std::begin(p))), MoveIt(It(std::end(p) - 1))); s.insert(s.begin(), MoveIt(It(std::begin(p))), MoveIt(It(std::end(p) - 1)));
assert(s == "ABCD"); assert(s == "ABCD");
} }
{ // test with a move iterator that returns char&& { // test with a move iterator that returns char&&
typedef forward_iterator<const char*> It; typedef forward_iterator<const char*> It;
Show All 17 Lines

libcxx/test/std/strings/basic.string/string.modifiers/string_replace/iter_iter_iter_iter.pass.cpp

Show First 20 Lines • Show All 1,000 Lines • ▼ Show 20 Lines#if TEST_STD_VER >= 11
test7<S>(); test7<S>();
test8<S>(); test8<S>();
} }
#endif #endif
#ifndef TEST_HAS_NO_EXCEPTIONS #ifndef TEST_HAS_NO_EXCEPTIONS
{ // test iterator operations that throw { // test iterator operations that throw
typedef std::string S; typedef std::string S;
typedef ThrowingIterator<char> TIter; typedef ThrowingIterator<char> TIter;
typedef input_iterator<TIter> IIter; typedef cpp17_input_iterator<TIter> IIter;
const char* s = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz"; const char* s = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz";
test_exceptions(S("abcdefghijklmnopqrst"), 10, 5, IIter(TIter(s, s+10, 4, TIter::TAIncrement)), IIter()); test_exceptions(S("abcdefghijklmnopqrst"), 10, 5, IIter(TIter(s, s+10, 4, TIter::TAIncrement)), IIter());
test_exceptions(S("abcdefghijklmnopqrst"), 10, 5, IIter(TIter(s, s+10, 5, TIter::TADereference)), IIter()); test_exceptions(S("abcdefghijklmnopqrst"), 10, 5, IIter(TIter(s, s+10, 5, TIter::TADereference)), IIter());
test_exceptions(S("abcdefghijklmnopqrst"), 10, 5, IIter(TIter(s, s+10, 6, TIter::TAComparison)), IIter()); test_exceptions(S("abcdefghijklmnopqrst"), 10, 5, IIter(TIter(s, s+10, 6, TIter::TAComparison)), IIter());
test_exceptions(S("abcdefghijklmnopqrst"), 10, 5, TIter(s, s+10, 4, TIter::TAIncrement), TIter()); test_exceptions(S("abcdefghijklmnopqrst"), 10, 5, TIter(s, s+10, 4, TIter::TAIncrement), TIter());
test_exceptions(S("abcdefghijklmnopqrst"), 10, 5, TIter(s, s+10, 5, TIter::TADereference), TIter()); test_exceptions(S("abcdefghijklmnopqrst"), 10, 5, TIter(s, s+10, 5, TIter::TADereference), TIter());
test_exceptions(S("abcdefghijklmnopqrst"), 10, 5, TIter(s, s+10, 6, TIter::TAComparison), TIter()); test_exceptions(S("abcdefghijklmnopqrst"), 10, 5, TIter(s, s+10, 6, TIter::TAComparison), TIter());
Show All 38 Lines

libcxx/test/std/utilities/memory/specialized.algorithms/uninitialized.move/uninitialized_move.pass.cpp

Show First 20 Lines • Show All 73 Lines • ▼ Show 20 Lines#ifndef TEST_HAS_NO_EXCEPTIONS
assert(values[2] == 0); assert(values[2] == 0);
assert(values[3] == 4); assert(values[3] == 4);
assert(values[4] == 5); assert(values[4] == 5);
#endif #endif
} }
void test_counted() void test_counted()
{ {
using It = input_iterator<int*>; using It = cpp17_input_iterator<int*>;
using FIt = forward_iterator<Counted*>; using FIt = forward_iterator<Counted*>;
const int N = 5; const int N = 5;
int values[N] = {1, 2, 3, 4, 5}; int values[N] = {1, 2, 3, 4, 5};
alignas(Counted) char pool[sizeof(Counted)*N] = {}; alignas(Counted) char pool[sizeof(Counted)*N] = {};
Counted* p = (Counted*)pool; Counted* p = (Counted*)pool;
auto ret = std::uninitialized_move(It(values), It(values + 1), FIt(p)); auto ret = std::uninitialized_move(It(values), It(values + 1), FIt(p));
assert(ret == FIt(p +1)); assert(ret == FIt(p +1));
assert(Counted::constructed == 1); assert(Counted::constructed == 1);
Show All 25 Lines

libcxx/test/std/utilities/memory/specialized.algorithms/uninitialized.move/uninitialized_move_n.pass.cpp

Show First 20 Lines • Show All 73 Lines • ▼ Show 20 Lines#ifndef TEST_HAS_NO_EXCEPTIONS
assert(values[2] == 0); assert(values[2] == 0);
assert(values[3] == 4); assert(values[3] == 4);
assert(values[4] == 5); assert(values[4] == 5);
#endif #endif
} }
void test_counted() void test_counted()
{ {
using It = input_iterator<int*>; using It = cpp17_input_iterator<int*>;
using FIt = forward_iterator<Counted*>; using FIt = forward_iterator<Counted*>;
const int N = 5; const int N = 5;
int values[N] = {1, 2, 3, 4, 5}; int values[N] = {1, 2, 3, 4, 5};
alignas(Counted) char pool[sizeof(Counted)*N] = {}; alignas(Counted) char pool[sizeof(Counted)*N] = {};
Counted* p = (Counted*)pool; Counted* p = (Counted*)pool;
auto ret = std::uninitialized_move_n(It(values), 1, FIt(p)); auto ret = std::uninitialized_move_n(It(values), 1, FIt(p));
assert(ret.first == It(values +1)); assert(ret.first == It(values +1));
assert(ret.second == FIt(p +1)); assert(ret.second == FIt(p +1));
Show All 28 Lines

libcxx/test/support/test_iterators.h

//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
MordanteUnsubmitted
Not Done
ReplyInline Actions

The new C++20 style iterators will they also be put in this file or will they get their own header. If the latter then maybe rename this file to test_legacy_iterator.h.

Mordante: The new C++20 style iterators will they also be put in this file or will they get their own…
cjdbAuthorUnsubmitted
Done
ReplyInline Actions

My intention was to add them here and guard them with a ranges support macro. C++20 ranges may want to test both in certain circumstances.

cjdb: My intention was to add them here and guard them with a ranges support macro. C++20 ranges may…
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#ifndef ITERATORS_H #ifndef ITERATORS_H
Show All 37 Linespublic:
TEST_CONSTEXPR_CXX14 output_iterator& operator++() {++it_; return *this;} TEST_CONSTEXPR_CXX14 output_iterator& operator++() {++it_; return *this;}
TEST_CONSTEXPR_CXX14 output_iterator operator++(int) TEST_CONSTEXPR_CXX14 output_iterator operator++(int)
{output_iterator tmp(*this); ++(*this); return tmp;} {output_iterator tmp(*this); ++(*this); return tmp;}
template <class T> template <class T>
void operator,(T const &) DELETE_FUNCTION; void operator,(T const &) DELETE_FUNCTION;
}; };
// This is the Cpp17InputIterator requirement as described in Table 87 ([input.iterators]),
// formerly known as InputIterator prior to C++20.
template <class It, template <class It,
class ItTraits = It> class ItTraits = It>
class input_iterator class cpp17_input_iterator
{ {
typedef std::iterator_traits<ItTraits> Traits; typedef std::iterator_traits<ItTraits> Traits;
It it_; It it_;
template <class U, class T> friend class input_iterator; template <class U, class T> friend class cpp17_input_iterator;
public: public:
typedef std::input_iterator_tag iterator_category; typedef std::input_iterator_tag iterator_category;
QuuxplusoneUnsubmitted
Not Done
ReplyInline Actions

@cjdb wrote:

tl;dr yes. At minimum, the iterator tags are now mandatory.

The existing iterators already have tags, though. So that's not a concern for us.

I suggested to Louis in chat but will put here for the record: If the main concern of this patch is to make sure we have a test iterator which is a "non-comparable input iterator" (comparable only to its sentinel type, but not to itself), then I suggest you leave everything the way it is in main but then add the new C++20-only, sentinel-comparison-only test iterator, like this:

#if TEST_STD_VER >= 20
template<class It>
class incomparable_input_iterator {
    // This is an input iterator according to C++>=20, but not according to C++<=17.
    // It is comparable with its sentinel type, but not with its own type.
    [...mostly the same stuff as the regular input iterator test type...]
public:
    struct sentinel {
        constexpr explicit sentinel(It it) : it_(it) {}
    };
    friend constexpr bool operator==(const incomparable_input_iterator& x, const sentinel& y)
        {return x.it_ == y.it_;}
};
#endif

This probably belongs right above contiguous_iterator, circa line 315, because we intend it to be new in C++20.

Quuxplusone: @cjdb wrote: > tl;dr yes. At minimum, the iterator tags are now mandatory. The existing…
cjdbAuthorUnsubmitted
Done
ReplyInline Actions

If the main concern of this patch is to make sure we have a test iterator which is a "non-comparable input iterator" (comparable only to its sentinel type, but not to itself)

This isn't the only difference between Cpp17InputIterator and std::input_iterator.

I suggest you leave everything the way it is in main but then add the new C++20-only, sentinel-comparison-only test iterator

That leaves ambiguity as to whether or not input_iterator refers to a Cpp17InputIterator or is a strict std::input_iterator. It needs to be renamed to clear up that ambiguity.

cjdb: > If the main concern of this patch is to make sure we have a test iterator which is a "non…
QuuxplusoneUnsubmitted
Not Done
ReplyInline Actions

This isn't the only difference

Obligatory "What are the differences you care about, then?"
No two things in the world are ever exactly the same. That doesn't mean we make libc++ PRs about it. :)

Quuxplusone: > This isn't the only difference Obligatory "What are the differences you care about, then?"…
cjdbAuthorUnsubmitted
Done
ReplyInline Actions

The most salient difference is that C++20 input iterators need not be copyable. I expected that this would be fresh in your mind, since you've recently reviewed D100271, which is why I didn't mention it.

cjdb: The most salient difference is that C++20 input iterators need not be copyable. I expected that…
QuuxplusoneUnsubmitted
Not Done
ReplyInline Actions

So basically the intent of D101242-plus-D100271 is to introduce moveonly_input_iterator (and moveonly_output_iterator) while leaving everything else the same? I would approve of that direction.

But I notice that D100271 doesn't introduce a sentinel with which its new iterator type could be compared. It probably should include a sentinel, in order to make the new iterator type more useful with C++20 algorithms like std::ranges::copy. Still, I'm a little leery of introducing too many knobs. We probably don't want all four of a "copyable, comparable iterator" (i.e. the existing input_iterator/output_iterator) and a "move-only, comparable iterator" and a "copyable, sentineled iterator" and a "move-only, sentineled iterator"; but I'm still not sure what we do want.

(Fortunately, std::forward_iterator and higher all require std::regular, which means "copyable and comparable"; so the above combinatorial explosion applies only to input iterators and output iterators.)

Quuxplusone: So basically the intent of D101242-plus-D100271 is to introduce `moveonly_input_iterator` (and…
cjdbAuthorUnsubmitted
Done
ReplyInline Actions

So basically the intent of D101242-plus-D100271 is to introduce moveonly_input_iterator (and moveonly_output_iterator) while leaving everything else the same? I would approve of that direction.

That + prefixing current input_iterator with cpp17_ (or copyable_, which is more descriptive, but longer).

But I notice that D100271 doesn't introduce a sentinel with which its new iterator type could be compared. It probably should include a sentinel, in order to make the new iterator type more useful with C++20 algorithms like std::ranges::copy.

The patch has no need for a sentinel, so it's not added. I think it'd be a good idea for us to think about what the new sentinel type should do, and add it either with the first algorithm or as a follow-up patch to D100271 (it certainly shouldn't be blocking).

Still, I'm a little leery of introducing too many knobs. We probably don't want all four of a "copyable, comparable iterator" (i.e. the existing input_iterator/output_iterator) and a "move-only, comparable iterator" and a "copyable, sentineled iterator" and a "move-only, sentineled iterator"; but I'm still not sure what we do want.

Yeah, that's a bad idea. My intention is for the new, move-only input iterator is for it to be a completely minimal interface (i.e. move-only, not a self-sentinel).

cjdb: > So basically the intent of D101242-plus-D100271 is to introduce `moveonly_input_iterator`…
typedef typename Traits::value_type value_type; typedef typename Traits::value_type value_type;
typedef typename Traits::difference_type difference_type; typedef typename Traits::difference_type difference_type;
typedef It pointer; typedef It pointer;
typedef typename Traits::reference reference; typedef typename Traits::reference reference;
TEST_CONSTEXPR_CXX14 It base() const {return it_;} TEST_CONSTEXPR_CXX14 It base() const {return it_;}
TEST_CONSTEXPR_CXX14 input_iterator() : it_() {} TEST_CONSTEXPR_CXX14 cpp17_input_iterator() : it_() {}
explicit TEST_CONSTEXPR_CXX14 input_iterator(It it) : it_(it) {} explicit TEST_CONSTEXPR_CXX14 cpp17_input_iterator(It it) : it_(it) {}
template <class U, class T> template <class U, class T>
TEST_CONSTEXPR_CXX14 input_iterator(const input_iterator<U, T>& u) :it_(u.it_) {} TEST_CONSTEXPR_CXX14 cpp17_input_iterator(const cpp17_input_iterator<U, T>& u) :it_(u.it_) {}
TEST_CONSTEXPR_CXX14 reference operator*() const {return *it_;} TEST_CONSTEXPR_CXX14 reference operator*() const {return *it_;}
TEST_CONSTEXPR_CXX14 pointer operator->() const {return it_;} TEST_CONSTEXPR_CXX14 pointer operator->() const {return it_;}
TEST_CONSTEXPR_CXX14 input_iterator& operator++() {++it_; return *this;} TEST_CONSTEXPR_CXX14 cpp17_input_iterator& operator++() {++it_; return *this;}
TEST_CONSTEXPR_CXX14 input_iterator operator++(int) TEST_CONSTEXPR_CXX14 cpp17_input_iterator operator++(int)
{input_iterator tmp(*this); ++(*this); return tmp;} {cpp17_input_iterator tmp(*this); ++(*this); return tmp;}
friend TEST_CONSTEXPR_CXX14 bool operator==(const input_iterator& x, const input_iterator& y) friend TEST_CONSTEXPR_CXX14 bool operator==(const cpp17_input_iterator& x, const cpp17_input_iterator& y)
{return x.it_ == y.it_;} {return x.it_ == y.it_;}
friend TEST_CONSTEXPR_CXX14 bool operator!=(const input_iterator& x, const input_iterator& y) friend TEST_CONSTEXPR_CXX14 bool operator!=(const cpp17_input_iterator& x, const cpp17_input_iterator& y)
{return !(x == y);} {return !(x == y);}
template <class T> template <class T>
void operator,(T const &) DELETE_FUNCTION; void operator,(T const &) DELETE_FUNCTION;
}; };
template <class T, class TV, class U, class UV> template <class T, class TV, class U, class UV>
inline inline
bool bool
operator==(const input_iterator<T, TV>& x, const input_iterator<U, UV>& y) operator==(const cpp17_input_iterator<T, TV>& x, const cpp17_input_iterator<U, UV>& y)
{ {
return x.base() == y.base(); return x.base() == y.base();
} }
template <class T, class TV, class U, class UV> template <class T, class TV, class U, class UV>
inline inline
bool bool
operator!=(const input_iterator<T, TV>& x, const input_iterator<U, UV>& y) operator!=(const cpp17_input_iterator<T, TV>& x, const cpp17_input_iterator<U, UV>& y)
{ {
return !(x == y); return !(x == y);
} }
template <class It> template <class It>
class forward_iterator class forward_iterator
{ {
It it_; It it_;
▲ Show 20 Lines • Show All 278 Lines • ▼ Show 20 Linespublic:
} }
}; };
#endif #endif
template <class Iter> template <class Iter>
inline TEST_CONSTEXPR_CXX14 Iter base(output_iterator<Iter> i) { return i.base(); } inline TEST_CONSTEXPR_CXX14 Iter base(output_iterator<Iter> i) { return i.base(); }
template <class Iter> template <class Iter>
inline TEST_CONSTEXPR_CXX14 Iter base(input_iterator<Iter> i) { return i.base(); } inline TEST_CONSTEXPR_CXX14 Iter base(cpp17_input_iterator<Iter> i) { return i.base(); }
template <class Iter> template <class Iter>
inline TEST_CONSTEXPR_CXX14 Iter base(forward_iterator<Iter> i) { return i.base(); } inline TEST_CONSTEXPR_CXX14 Iter base(forward_iterator<Iter> i) { return i.base(); }
template <class Iter> template <class Iter>
inline TEST_CONSTEXPR_CXX14 Iter base(bidirectional_iterator<Iter> i) { return i.base(); } inline TEST_CONSTEXPR_CXX14 Iter base(bidirectional_iterator<Iter> i) { return i.base(); }
template <class Iter> template <class Iter>
▲ Show 20 Lines • Show All 267 Lines • Show Last 20 Lines

libcxx/test/support/test_range.h

Show All 16 Lines
#error "test/suppoort/test_range.h" can only be included in builds supporting ranges #error "test/suppoort/test_range.h" can only be included in builds supporting ranges
#endif #endif
struct sentinel { struct sentinel {
bool operator==(std::input_or_output_iterator auto const&) const; bool operator==(std::input_or_output_iterator auto const&) const;
}; };
// clang-format off // clang-format off
template <template <class...> class I = input_iterator> template <template <class...> class I>
requires std::input_or_output_iterator<I<int*> > requires std::input_or_output_iterator<I<int*> >
struct test_range { struct test_range {
I<int*> begin(); I<int*> begin();
I<int const*> begin() const; I<int const*> begin() const;
sentinel end(); sentinel end();
sentinel end() const; sentinel end() const;
}; };
template <template <class...> class I = input_iterator> template <template <class...> class I>
requires std::input_or_output_iterator<I<int*> > requires std::input_or_output_iterator<I<int*> >
struct test_non_const_range { struct test_non_const_range {
I<int*> begin(); I<int*> begin();
sentinel end(); sentinel end();
}; };
template <template <class...> class I = input_iterator> template <template <class...> class I>
requires std::input_or_output_iterator<I<int*> > requires std::input_or_output_iterator<I<int*> >
struct test_common_range { struct test_common_range {
I<int*> begin(); I<int*> begin();
I<int const*> begin() const; I<int const*> begin() const;
I<int*> end(); I<int*> end();
I<int const*> end() const; I<int const*> end() const;
}; };
template <template <class...> class I = input_iterator> template <template <class...> class I>
requires std::input_or_output_iterator<I<int*> > requires std::input_or_output_iterator<I<int*> >
struct test_non_const_common_range { struct test_non_const_common_range {
I<int*> begin(); I<int*> begin();
I<int*> end(); I<int*> end();
}; };
// clang-format on // clang-format on
#endif // LIBCXX_TEST_SUPPORT_TEST_RANGE_H #endif // LIBCXX_TEST_SUPPORT_TEST_RANGE_H