This is an archive of the discontinued LLVM Phabricator instance.

Differential D95848

Add `noexcept` to `string::find` and similar members.
ClosedPublic

Authored by zoecarver on Feb 1 2021, 10:15 PM.

Details

Reviewers
ldionne
mclow.lists
curdeius
Group Reviewers
Restricted Project
Commits
rGdea74b282061: [libc++] Add `noexcept` to `string::find` and similar members.
Summary

Adds noexcept to string_view/string::find and similar members
(rfind, etc.). See discussion in D95251. Refs D95821.

Diff Detail

Event Timeline

zoecarver requested review of this revision.Feb 1 2021, 10:15 PM
zoecarver created this revision.
Herald added a project: Restricted Project. · View Herald TranscriptFeb 1 2021, 10:15 PM
Herald added a reviewer: Restricted Project. · View Herald Transcript
Herald added a subscriber: libcxx-commits. · View Herald Transcript
zoecarver retitled this revision from [libc++] Add `noexcept` to `string::find` and similar members. to Add `noexcept` to `string::find` and similar members..Feb 1 2021, 10:16 PM
Harbormaster completed remote builds in B87471: Diff 320676.Feb 1 2021, 11:04 PM
curdeius added a subscriber: curdeius.EditedFeb 2 2021, 5:11 AM

Shouldn't it be tested with ASSERT_NOEXCEPT or rather with its libc++-specific equivalent (LIBCPP_ASSERT_NOEXCEPT)?

zoecarver added a comment.Feb 2 2021, 9:48 AM

Shouldn't it be tested with ASSERT_NOEXCEPT or rather with its libc++-specific equivalent (LIBCPP_ASSERT_NOEXCEPT)?

Hmm, as far as I can tell, currently we don't test whether these members are noexcept, but that also doesn't mean we shouldn't. If I do add it, I'll put it under the libcxx/ directory (and I should probably test the other overloads as well). I don't really like the idea of testing something this simple, I'm not sure how much we gain from that, especially when the standard doesn't require it. What's the case where one of these tests would fail?

zoecarver added a comment.Feb 2 2021, 9:53 AM
In D95848#2537017, @zoecarver wrote:

Shouldn't it be tested with ASSERT_NOEXCEPT or rather with its libc++-specific equivalent (LIBCPP_ASSERT_NOEXCEPT)?

Hmm, as far as I can tell, currently we don't test whether these members are noexcept, but that also doesn't mean we shouldn't. If I do add it, I'll put it under the libcxx/ directory (and I should probably test the other overloads as well). I don't really like the idea of testing something this simple, I'm not sure how much we gain from that, especially when the standard doesn't require it. What's the case where one of these tests would fail?

Thinking about it more. I think we do try to test noexcept specifiers in other places, so it probably does make sense to test these as well. I'll add tests for the changed functions and other overloads.

zoecarver updated this revision to Diff 320883.Feb 2 2021, 12:38 PM
  • Add LIBCPP_ASSERT_NOEXCEPT tests.
curdeius added inline comments.Feb 2 2021, 12:57 PM
libcxx/include/string
1387

It seems that you haven't tested this change.
Should be somewhere here: https://github.com/llvm/llvm-project/tree/main/libcxx/test/std/strings/basic.string/string.ops/string_compare.

zoecarver added inline comments.Feb 2 2021, 3:16 PM
libcxx/include/string
1387

Good catch, thanks. Updated.

zoecarver updated this revision to Diff 320926.Feb 2 2021, 3:16 PM
  • Add tests for string::compare
Harbormaster completed remote builds in B87569: Diff 320883.Feb 2 2021, 10:49 PM
Harbormaster completed remote builds in B87594: Diff 320926.Feb 3 2021, 5:24 AM
curdeius accepted this revision.Feb 3 2021, 9:20 AM

LGTM.

ldionne requested changes to this revision.Feb 5 2021, 8:29 AM

Can we mark the functions we added noexcept on as such in the synopsis, and add // noexcept as an extension? I think it's useful to track those. Apart from that, this LGTM.

This revision now requires changes to proceed.Feb 5 2021, 8:29 AM
zoecarver updated this revision to Diff 321841.Feb 5 2021, 11:36 AM
  • Mark noexcept in synopsis
ldionne accepted this revision.Feb 5 2021, 11:53 AM

LGTM, please ship once CI passes. Thanks!

We should also look into marking some more char_traits operations as noexcept if they are not and if we're allowed. Otherwise, calling a non-noexcept function from a noexcept function forces the compiler to generate code that looks like:

try { f(); } catch (...) { std::terminate(); }

which isn't great.

This revision is now accepted and ready to land.Feb 5 2021, 11:53 AM
zoecarver added a comment.Feb 5 2021, 1:08 PM

LGTM, please ship once CI passes. Thanks!

CI's been "going" for 90 minutes now... is there any way to see what the status is or if it's even started?

curdeius added a comment.Feb 5 2021, 1:16 PM

@zoecarver, https://buildkite.com/llvm-project/libcxx-ci/builds/1294
To get there just click on "pre-merge checks", then the non-clickable link in the log: https://buildkite.com/llvm-project/diff-checks/builds/28054.
Then just follow the tasks.
Looks green, just Mac builds still waiting for an agent.

zoecarver added a comment.Feb 5 2021, 2:14 PM
In D95848#2546010, @curdeius wrote:

@zoecarver, https://buildkite.com/llvm-project/libcxx-ci/builds/1294
To get there just click on "pre-merge checks", then the non-clickable link in the log: https://buildkite.com/llvm-project/diff-checks/builds/28054.
Then just follow the tasks.
Looks green, just Mac builds still waiting for an agent.

Aha! Thanks for the help, @curdeius! I didn't realize the link to the status is in the build logs.

Harbormaster completed remote builds in B88118: Diff 321841.Feb 5 2021, 7:02 PM
Closed by commit rGdea74b282061: [libc++] Add `noexcept` to `string::find` and similar members. (authored by zoecarver). · Explain WhyFeb 9 2021, 11:48 AM
This revision was automatically updated to reflect the committed changes.
zoecarver added a commit: rGdea74b282061: [libc++] Add `noexcept` to `string::find` and similar members..

Revision Contents

PathSize
libcxx/
include/
2 lines
42 lines
48 lines
test/
std/
strings/
basic.string/
string.ops/
string_compare/
1 line
1 line
1 line
string_find.first.not.of/
2 lines
1 line
1 line
2 lines
2 lines
string_find.first.of/
2 lines
2 lines
1 line
2 lines
2 lines
string_find.last.not.of/
2 lines
2 lines
1 line
2 lines
2 lines
string_find.last.of/
2 lines
2 lines
1 line
2 lines
2 lines
string_find/
2 lines
2 lines
1 line
2 lines
2 lines
string_rfind/
2 lines
2 lines
1 line
2 lines
2 lines
string.view/
string.view.find/
1 line
2 lines
1 line
1 line
1 line
1 line
2 lines
1 line
2 lines
2 lines
1 line
1 line
2 lines
2 lines
2 lines
1 line
2 lines
2 lines
1 line
2 lines
2 lines
2 lines
1 line
2 lines

Diff 322463

libcxx/include/__string

Show First 20 Lines • Show All 947 Lines • ▼ Show 20 Lines__str_find(const _CharT *__p, _SizeT __sz,
if (__r == nullptr) if (__r == nullptr)
return __npos; return __npos;
return static_cast<_SizeT>(__r - __p); return static_cast<_SizeT>(__r - __p);
} }
template <class _CharT, class _Traits> template <class _CharT, class _Traits>
inline _LIBCPP_CONSTEXPR_AFTER_CXX11 const _CharT * inline _LIBCPP_CONSTEXPR_AFTER_CXX11 const _CharT *
__search_substring(const _CharT *__first1, const _CharT *__last1, __search_substring(const _CharT *__first1, const _CharT *__last1,
const _CharT *__first2, const _CharT *__last2) { const _CharT *__first2, const _CharT *__last2) _NOEXCEPT {
// Take advantage of knowing source and pattern lengths. // Take advantage of knowing source and pattern lengths.
// Stop short when source is smaller than pattern. // Stop short when source is smaller than pattern.
const ptrdiff_t __len2 = __last2 - __first2; const ptrdiff_t __len2 = __last2 - __first2;
if (__len2 == 0) if (__len2 == 0)
return __first1; return __first1;
ptrdiff_t __len1 = __last1 - __first1; ptrdiff_t __len1 = __last1 - __first1;
if (__len1 < __len2) if (__len1 < __len2)
▲ Show 20 Lines • Show All 216 Lines • Show Last 20 Lines

libcxx/include/string

Show First 20 Lines • Show All 256 Lines • ▼ Show 20 Lines// types:
const value_type* c_str() const noexcept; const value_type* c_str() const noexcept;
const value_type* data() const noexcept; const value_type* data() const noexcept;
value_type* data() noexcept; // C++17 value_type* data() noexcept; // C++17
allocator_type get_allocator() const noexcept; allocator_type get_allocator() const noexcept;
size_type find(const basic_string& str, size_type pos = 0) const noexcept; size_type find(const basic_string& str, size_type pos = 0) const noexcept;
template <class T> template <class T>
size_type find(const T& t, size_type pos = 0) const; // C++17 size_type find(const T& t, size_type pos = 0) const noexcept; // C++17, noexcept as an extension
size_type find(const value_type* s, size_type pos, size_type n) const noexcept; size_type find(const value_type* s, size_type pos, size_type n) const noexcept;
size_type find(const value_type* s, size_type pos = 0) const noexcept; size_type find(const value_type* s, size_type pos = 0) const noexcept;
size_type find(value_type c, size_type pos = 0) const noexcept; size_type find(value_type c, size_type pos = 0) const noexcept;
size_type rfind(const basic_string& str, size_type pos = npos) const noexcept; size_type rfind(const basic_string& str, size_type pos = npos) const noexcept;
template <class T> template <class T>
size_type rfind(const T& t, size_type pos = npos) const; // C++17 size_type rfind(const T& t, size_type pos = npos) const noexcept; // C++17, noexcept as an extension
size_type rfind(const value_type* s, size_type pos, size_type n) const noexcept; size_type rfind(const value_type* s, size_type pos, size_type n) const noexcept;
size_type rfind(const value_type* s, size_type pos = npos) const noexcept; size_type rfind(const value_type* s, size_type pos = npos) const noexcept;
size_type rfind(value_type c, size_type pos = npos) const noexcept; size_type rfind(value_type c, size_type pos = npos) const noexcept;
size_type find_first_of(const basic_string& str, size_type pos = 0) const noexcept; size_type find_first_of(const basic_string& str, size_type pos = 0) const noexcept;
template <class T> template <class T>
size_type find_first_of(const T& t, size_type pos = 0) const; // C++17 size_type find_first_of(const T& t, size_type pos = 0) const noexcept; // C++17, noexcept as an extension
size_type find_first_of(const value_type* s, size_type pos, size_type n) const noexcept; size_type find_first_of(const value_type* s, size_type pos, size_type n) const noexcept;
size_type find_first_of(const value_type* s, size_type pos = 0) const noexcept; size_type find_first_of(const value_type* s, size_type pos = 0) const noexcept;
size_type find_first_of(value_type c, size_type pos = 0) const noexcept; size_type find_first_of(value_type c, size_type pos = 0) const noexcept;
size_type find_last_of(const basic_string& str, size_type pos = npos) const noexcept; size_type find_last_of(const basic_string& str, size_type pos = npos) const noexcept;
template <class T> template <class T>
size_type find_last_of(const T& t, size_type pos = npos) const noexcept; // C++17 size_type find_last_of(const T& t, size_type pos = npos) const noexcept noexcept; // C++17, noexcept as an extension
size_type find_last_of(const value_type* s, size_type pos, size_type n) const noexcept; size_type find_last_of(const value_type* s, size_type pos, size_type n) const noexcept;
size_type find_last_of(const value_type* s, size_type pos = npos) const noexcept; size_type find_last_of(const value_type* s, size_type pos = npos) const noexcept;
size_type find_last_of(value_type c, size_type pos = npos) const noexcept; size_type find_last_of(value_type c, size_type pos = npos) const noexcept;
size_type find_first_not_of(const basic_string& str, size_type pos = 0) const noexcept; size_type find_first_not_of(const basic_string& str, size_type pos = 0) const noexcept;
template <class T> template <class T>
size_type find_first_not_of(const T& t, size_type pos = 0) const; // C++17 size_type find_first_not_of(const T& t, size_type pos = 0) const noexcept; // C++17, noexcept as an extension
size_type find_first_not_of(const value_type* s, size_type pos, size_type n) const noexcept; size_type find_first_not_of(const value_type* s, size_type pos, size_type n) const noexcept;
size_type find_first_not_of(const value_type* s, size_type pos = 0) const noexcept; size_type find_first_not_of(const value_type* s, size_type pos = 0) const noexcept;
size_type find_first_not_of(value_type c, size_type pos = 0) const noexcept; size_type find_first_not_of(value_type c, size_type pos = 0) const noexcept;
size_type find_last_not_of(const basic_string& str, size_type pos = npos) const noexcept; size_type find_last_not_of(const basic_string& str, size_type pos = npos) const noexcept;
template <class T> template <class T>
size_type find_last_not_of(const T& t, size_type pos = npos) const; // C++17 size_type find_last_not_of(const T& t, size_type pos = npos) const noexcept; // C++17, noexcept as an extension
size_type find_last_not_of(const value_type* s, size_type pos, size_type n) const noexcept; size_type find_last_not_of(const value_type* s, size_type pos, size_type n) const noexcept;
size_type find_last_not_of(const value_type* s, size_type pos = npos) const noexcept; size_type find_last_not_of(const value_type* s, size_type pos = npos) const noexcept;
size_type find_last_not_of(value_type c, size_type pos = npos) const noexcept; size_type find_last_not_of(value_type c, size_type pos = npos) const noexcept;
int compare(const basic_string& str) const noexcept; int compare(const basic_string& str) const noexcept;
template <class T> template <class T>
int compare(const T& t) const noexcept; // C++17 int compare(const T& t) const noexcept; // C++17, noexcept as an extension
int compare(size_type pos1, size_type n1, const basic_string& str) const; int compare(size_type pos1, size_type n1, const basic_string& str) const;
template <class T> template <class T>
int compare(size_type pos1, size_type n1, const T& t) const; // C++17 int compare(size_type pos1, size_type n1, const T& t) const; // C++17
int compare(size_type pos1, size_type n1, const basic_string& str, int compare(size_type pos1, size_type n1, const basic_string& str,
size_type pos2, size_type n2=npos) const; // C++14 size_type pos2, size_type n2=npos) const; // C++14
template <class T> template <class T>
int compare(size_type pos1, size_type n1, const T& t, int compare(size_type pos1, size_type n1, const T& t,
size_type pos2, size_type n2=npos) const; // C++17 size_type pos2, size_type n2=npos) const; // C++17
▲ Show 20 Lines • Show All 963 Lines • ▼ Show 20 Lines#endif
template <class _Tp> template <class _Tp>
_LIBCPP_METHOD_TEMPLATE_IMPLICIT_INSTANTIATION_VIS _LIBCPP_METHOD_TEMPLATE_IMPLICIT_INSTANTIATION_VIS
_EnableIf _EnableIf
< <
__can_be_converted_to_string_view<_CharT, _Traits, _Tp>::value, __can_be_converted_to_string_view<_CharT, _Traits, _Tp>::value,
size_type size_type
> >
find(const _Tp& __t, size_type __pos = 0) const; find(const _Tp& __t, size_type __pos = 0) const _NOEXCEPT;
size_type find(const value_type* __s, size_type __pos, size_type __n) const _NOEXCEPT; size_type find(const value_type* __s, size_type __pos, size_type __n) const _NOEXCEPT;
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
size_type find(const value_type* __s, size_type __pos = 0) const _NOEXCEPT; size_type find(const value_type* __s, size_type __pos = 0) const _NOEXCEPT;
size_type find(value_type __c, size_type __pos = 0) const _NOEXCEPT; size_type find(value_type __c, size_type __pos = 0) const _NOEXCEPT;
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
size_type rfind(const basic_string& __str, size_type __pos = npos) const _NOEXCEPT; size_type rfind(const basic_string& __str, size_type __pos = npos) const _NOEXCEPT;
template <class _Tp> template <class _Tp>
_LIBCPP_METHOD_TEMPLATE_IMPLICIT_INSTANTIATION_VIS _LIBCPP_METHOD_TEMPLATE_IMPLICIT_INSTANTIATION_VIS
_EnableIf _EnableIf
< <
__can_be_converted_to_string_view<_CharT, _Traits, _Tp>::value, __can_be_converted_to_string_view<_CharT, _Traits, _Tp>::value,
size_type size_type
> >
rfind(const _Tp& __t, size_type __pos = npos) const; rfind(const _Tp& __t, size_type __pos = npos) const _NOEXCEPT;
size_type rfind(const value_type* __s, size_type __pos, size_type __n) const _NOEXCEPT; size_type rfind(const value_type* __s, size_type __pos, size_type __n) const _NOEXCEPT;
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
size_type rfind(const value_type* __s, size_type __pos = npos) const _NOEXCEPT; size_type rfind(const value_type* __s, size_type __pos = npos) const _NOEXCEPT;
size_type rfind(value_type __c, size_type __pos = npos) const _NOEXCEPT; size_type rfind(value_type __c, size_type __pos = npos) const _NOEXCEPT;
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
size_type find_first_of(const basic_string& __str, size_type __pos = 0) const _NOEXCEPT; size_type find_first_of(const basic_string& __str, size_type __pos = 0) const _NOEXCEPT;
template <class _Tp> template <class _Tp>
_LIBCPP_METHOD_TEMPLATE_IMPLICIT_INSTANTIATION_VIS _LIBCPP_METHOD_TEMPLATE_IMPLICIT_INSTANTIATION_VIS
_EnableIf _EnableIf
< <
__can_be_converted_to_string_view<_CharT, _Traits, _Tp>::value, __can_be_converted_to_string_view<_CharT, _Traits, _Tp>::value,
size_type size_type
> >
find_first_of(const _Tp& __t, size_type __pos = 0) const; find_first_of(const _Tp& __t, size_type __pos = 0) const _NOEXCEPT;
size_type find_first_of(const value_type* __s, size_type __pos, size_type __n) const _NOEXCEPT; size_type find_first_of(const value_type* __s, size_type __pos, size_type __n) const _NOEXCEPT;
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
size_type find_first_of(const value_type* __s, size_type __pos = 0) const _NOEXCEPT; size_type find_first_of(const value_type* __s, size_type __pos = 0) const _NOEXCEPT;
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
size_type find_first_of(value_type __c, size_type __pos = 0) const _NOEXCEPT; size_type find_first_of(value_type __c, size_type __pos = 0) const _NOEXCEPT;
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
size_type find_last_of(const basic_string& __str, size_type __pos = npos) const _NOEXCEPT; size_type find_last_of(const basic_string& __str, size_type __pos = npos) const _NOEXCEPT;
template <class _Tp> template <class _Tp>
_LIBCPP_METHOD_TEMPLATE_IMPLICIT_INSTANTIATION_VIS _LIBCPP_METHOD_TEMPLATE_IMPLICIT_INSTANTIATION_VIS
_EnableIf _EnableIf
< <
__can_be_converted_to_string_view<_CharT, _Traits, _Tp>::value, __can_be_converted_to_string_view<_CharT, _Traits, _Tp>::value,
size_type size_type
> >
find_last_of(const _Tp& __t, size_type __pos = npos) const; find_last_of(const _Tp& __t, size_type __pos = npos) const _NOEXCEPT;
size_type find_last_of(const value_type* __s, size_type __pos, size_type __n) const _NOEXCEPT; size_type find_last_of(const value_type* __s, size_type __pos, size_type __n) const _NOEXCEPT;
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
size_type find_last_of(const value_type* __s, size_type __pos = npos) const _NOEXCEPT; size_type find_last_of(const value_type* __s, size_type __pos = npos) const _NOEXCEPT;
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
size_type find_last_of(value_type __c, size_type __pos = npos) const _NOEXCEPT; size_type find_last_of(value_type __c, size_type __pos = npos) const _NOEXCEPT;
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
size_type find_first_not_of(const basic_string& __str, size_type __pos = 0) const _NOEXCEPT; size_type find_first_not_of(const basic_string& __str, size_type __pos = 0) const _NOEXCEPT;
template <class _Tp> template <class _Tp>
_LIBCPP_METHOD_TEMPLATE_IMPLICIT_INSTANTIATION_VIS _LIBCPP_METHOD_TEMPLATE_IMPLICIT_INSTANTIATION_VIS
_EnableIf _EnableIf
< <
__can_be_converted_to_string_view<_CharT, _Traits, _Tp>::value, __can_be_converted_to_string_view<_CharT, _Traits, _Tp>::value,
size_type size_type
> >
find_first_not_of(const _Tp &__t, size_type __pos = 0) const; find_first_not_of(const _Tp &__t, size_type __pos = 0) const _NOEXCEPT;
size_type find_first_not_of(const value_type* __s, size_type __pos, size_type __n) const _NOEXCEPT; size_type find_first_not_of(const value_type* __s, size_type __pos, size_type __n) const _NOEXCEPT;
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
size_type find_first_not_of(const value_type* __s, size_type __pos = 0) const _NOEXCEPT; size_type find_first_not_of(const value_type* __s, size_type __pos = 0) const _NOEXCEPT;
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
size_type find_first_not_of(value_type __c, size_type __pos = 0) const _NOEXCEPT; size_type find_first_not_of(value_type __c, size_type __pos = 0) const _NOEXCEPT;
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
size_type find_last_not_of(const basic_string& __str, size_type __pos = npos) const _NOEXCEPT; size_type find_last_not_of(const basic_string& __str, size_type __pos = npos) const _NOEXCEPT;
template <class _Tp> template <class _Tp>
_LIBCPP_METHOD_TEMPLATE_IMPLICIT_INSTANTIATION_VIS _LIBCPP_METHOD_TEMPLATE_IMPLICIT_INSTANTIATION_VIS
_EnableIf _EnableIf
< <
__can_be_converted_to_string_view<_CharT, _Traits, _Tp>::value, __can_be_converted_to_string_view<_CharT, _Traits, _Tp>::value,
size_type size_type
> >
find_last_not_of(const _Tp& __t, size_type __pos = npos) const; find_last_not_of(const _Tp& __t, size_type __pos = npos) const _NOEXCEPT;
size_type find_last_not_of(const value_type* __s, size_type __pos, size_type __n) const _NOEXCEPT; size_type find_last_not_of(const value_type* __s, size_type __pos, size_type __n) const _NOEXCEPT;
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
size_type find_last_not_of(const value_type* __s, size_type __pos = npos) const _NOEXCEPT; size_type find_last_not_of(const value_type* __s, size_type __pos = npos) const _NOEXCEPT;
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
size_type find_last_not_of(value_type __c, size_type __pos = npos) const _NOEXCEPT; size_type find_last_not_of(value_type __c, size_type __pos = npos) const _NOEXCEPT;
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
int compare(const basic_string& __str) const _NOEXCEPT; int compare(const basic_string& __str) const _NOEXCEPT;
template <class _Tp> template <class _Tp>
_LIBCPP_METHOD_TEMPLATE_IMPLICIT_INSTANTIATION_VIS _LIBCPP_METHOD_TEMPLATE_IMPLICIT_INSTANTIATION_VIS
_EnableIf _EnableIf
< <
__can_be_converted_to_string_view<_CharT, _Traits, _Tp>::value, __can_be_converted_to_string_view<_CharT, _Traits, _Tp>::value,
int int
> >
compare(const _Tp &__t) const; compare(const _Tp &__t) const _NOEXCEPT;
curdeiusUnsubmitted
Not Done
ReplyInline Actions

It seems that you haven't tested this change.
Should be somewhere here: https://github.com/llvm/llvm-project/tree/main/libcxx/test/std/strings/basic.string/string.ops/string_compare.

curdeius: It seems that you haven't tested this change. Should be somewhere here: https://github.
zoecarverAuthorUnsubmitted
Done
ReplyInline Actions

Good catch, thanks. Updated.

zoecarver: Good catch, thanks. Updated.
template <class _Tp> template <class _Tp>
_LIBCPP_METHOD_TEMPLATE_IMPLICIT_INSTANTIATION_VIS _LIBCPP_METHOD_TEMPLATE_IMPLICIT_INSTANTIATION_VIS
_EnableIf _EnableIf
< <
__can_be_converted_to_string_view<_CharT, _Traits, _Tp>::value, __can_be_converted_to_string_view<_CharT, _Traits, _Tp>::value,
int int
> >
▲ Show 20 Lines • Show All 2,142 Lines • ▼ Show 20 Lines
template<class _CharT, class _Traits, class _Allocator> template<class _CharT, class _Traits, class _Allocator>
template <class _Tp> template <class _Tp>
_EnableIf _EnableIf
< <
__can_be_converted_to_string_view<_CharT, _Traits, _Tp>::value, __can_be_converted_to_string_view<_CharT, _Traits, _Tp>::value,
typename basic_string<_CharT, _Traits, _Allocator>::size_type typename basic_string<_CharT, _Traits, _Allocator>::size_type
> >
basic_string<_CharT, _Traits, _Allocator>::find(const _Tp &__t, basic_string<_CharT, _Traits, _Allocator>::find(const _Tp &__t,
size_type __pos) const size_type __pos) const _NOEXCEPT
{ {
__self_view __sv = __t; __self_view __sv = __t;
return __str_find<value_type, size_type, traits_type, npos> return __str_find<value_type, size_type, traits_type, npos>
(data(), size(), __sv.data(), __pos, __sv.size()); (data(), size(), __sv.data(), __pos, __sv.size());
} }
template<class _CharT, class _Traits, class _Allocator> template<class _CharT, class _Traits, class _Allocator>
inline inline
▲ Show 20 Lines • Show All 41 Lines • ▼ Show 20 Lines
template<class _CharT, class _Traits, class _Allocator> template<class _CharT, class _Traits, class _Allocator>
template <class _Tp> template <class _Tp>
_EnableIf _EnableIf
< <
__can_be_converted_to_string_view<_CharT, _Traits, _Tp>::value, __can_be_converted_to_string_view<_CharT, _Traits, _Tp>::value,
typename basic_string<_CharT, _Traits, _Allocator>::size_type typename basic_string<_CharT, _Traits, _Allocator>::size_type
> >
basic_string<_CharT, _Traits, _Allocator>::rfind(const _Tp& __t, basic_string<_CharT, _Traits, _Allocator>::rfind(const _Tp& __t,
size_type __pos) const size_type __pos) const _NOEXCEPT
{ {
__self_view __sv = __t; __self_view __sv = __t;
return __str_rfind<value_type, size_type, traits_type, npos> return __str_rfind<value_type, size_type, traits_type, npos>
(data(), size(), __sv.data(), __pos, __sv.size()); (data(), size(), __sv.data(), __pos, __sv.size());
} }
template<class _CharT, class _Traits, class _Allocator> template<class _CharT, class _Traits, class _Allocator>
inline inline
▲ Show 20 Lines • Show All 41 Lines • ▼ Show 20 Lines
template<class _CharT, class _Traits, class _Allocator> template<class _CharT, class _Traits, class _Allocator>
template <class _Tp> template <class _Tp>
_EnableIf _EnableIf
< <
__can_be_converted_to_string_view<_CharT, _Traits, _Tp>::value, __can_be_converted_to_string_view<_CharT, _Traits, _Tp>::value,
typename basic_string<_CharT, _Traits, _Allocator>::size_type typename basic_string<_CharT, _Traits, _Allocator>::size_type
> >
basic_string<_CharT, _Traits, _Allocator>::find_first_of(const _Tp& __t, basic_string<_CharT, _Traits, _Allocator>::find_first_of(const _Tp& __t,
size_type __pos) const size_type __pos) const _NOEXCEPT
{ {
__self_view __sv = __t; __self_view __sv = __t;
return __str_find_first_of<value_type, size_type, traits_type, npos> return __str_find_first_of<value_type, size_type, traits_type, npos>
(data(), size(), __sv.data(), __pos, __sv.size()); (data(), size(), __sv.data(), __pos, __sv.size());
} }
template<class _CharT, class _Traits, class _Allocator> template<class _CharT, class _Traits, class _Allocator>
inline inline
▲ Show 20 Lines • Show All 41 Lines • ▼ Show 20 Lines
template<class _CharT, class _Traits, class _Allocator> template<class _CharT, class _Traits, class _Allocator>
template <class _Tp> template <class _Tp>
_EnableIf _EnableIf
< <
__can_be_converted_to_string_view<_CharT, _Traits, _Tp>::value, __can_be_converted_to_string_view<_CharT, _Traits, _Tp>::value,
typename basic_string<_CharT, _Traits, _Allocator>::size_type typename basic_string<_CharT, _Traits, _Allocator>::size_type
> >
basic_string<_CharT, _Traits, _Allocator>::find_last_of(const _Tp& __t, basic_string<_CharT, _Traits, _Allocator>::find_last_of(const _Tp& __t,
size_type __pos) const size_type __pos) const _NOEXCEPT
{ {
__self_view __sv = __t; __self_view __sv = __t;
return __str_find_last_of<value_type, size_type, traits_type, npos> return __str_find_last_of<value_type, size_type, traits_type, npos>
(data(), size(), __sv.data(), __pos, __sv.size()); (data(), size(), __sv.data(), __pos, __sv.size());
} }
template<class _CharT, class _Traits, class _Allocator> template<class _CharT, class _Traits, class _Allocator>
inline inline
▲ Show 20 Lines • Show All 41 Lines • ▼ Show 20 Lines
template<class _CharT, class _Traits, class _Allocator> template<class _CharT, class _Traits, class _Allocator>
template <class _Tp> template <class _Tp>
_EnableIf _EnableIf
< <
__can_be_converted_to_string_view<_CharT, _Traits, _Tp>::value, __can_be_converted_to_string_view<_CharT, _Traits, _Tp>::value,
typename basic_string<_CharT, _Traits, _Allocator>::size_type typename basic_string<_CharT, _Traits, _Allocator>::size_type
> >
basic_string<_CharT, _Traits, _Allocator>::find_first_not_of(const _Tp& __t, basic_string<_CharT, _Traits, _Allocator>::find_first_not_of(const _Tp& __t,
size_type __pos) const size_type __pos) const _NOEXCEPT
{ {
__self_view __sv = __t; __self_view __sv = __t;
return __str_find_first_not_of<value_type, size_type, traits_type, npos> return __str_find_first_not_of<value_type, size_type, traits_type, npos>
(data(), size(), __sv.data(), __pos, __sv.size()); (data(), size(), __sv.data(), __pos, __sv.size());
} }
template<class _CharT, class _Traits, class _Allocator> template<class _CharT, class _Traits, class _Allocator>
inline inline
▲ Show 20 Lines • Show All 42 Lines • ▼ Show 20 Lines
template<class _CharT, class _Traits, class _Allocator> template<class _CharT, class _Traits, class _Allocator>
template <class _Tp> template <class _Tp>
_EnableIf _EnableIf
< <
__can_be_converted_to_string_view<_CharT, _Traits, _Tp>::value, __can_be_converted_to_string_view<_CharT, _Traits, _Tp>::value,
typename basic_string<_CharT, _Traits, _Allocator>::size_type typename basic_string<_CharT, _Traits, _Allocator>::size_type
> >
basic_string<_CharT, _Traits, _Allocator>::find_last_not_of(const _Tp& __t, basic_string<_CharT, _Traits, _Allocator>::find_last_not_of(const _Tp& __t,
size_type __pos) const size_type __pos) const _NOEXCEPT
{ {
__self_view __sv = __t; __self_view __sv = __t;
return __str_find_last_not_of<value_type, size_type, traits_type, npos> return __str_find_last_not_of<value_type, size_type, traits_type, npos>
(data(), size(), __sv.data(), __pos, __sv.size()); (data(), size(), __sv.data(), __pos, __sv.size());
} }
template<class _CharT, class _Traits, class _Allocator> template<class _CharT, class _Traits, class _Allocator>
inline inline
Show All 20 Lines
template <class _CharT, class _Traits, class _Allocator> template <class _CharT, class _Traits, class _Allocator>
template <class _Tp> template <class _Tp>
_EnableIf _EnableIf
< <
__can_be_converted_to_string_view<_CharT, _Traits, _Tp>::value, __can_be_converted_to_string_view<_CharT, _Traits, _Tp>::value,
int int
> >
basic_string<_CharT, _Traits, _Allocator>::compare(const _Tp& __t) const basic_string<_CharT, _Traits, _Allocator>::compare(const _Tp& __t) const _NOEXCEPT
{ {
__self_view __sv = __t; __self_view __sv = __t;
size_t __lhs_sz = size(); size_t __lhs_sz = size();
size_t __rhs_sz = __sv.size(); size_t __rhs_sz = __sv.size();
int __result = traits_type::compare(data(), __sv.data(), int __result = traits_type::compare(data(), __sv.data(),
_VSTD::min(__lhs_sz, __rhs_sz)); _VSTD::min(__lhs_sz, __rhs_sz));
if (__result != 0) if (__result != 0)
return __result; return __result;
▲ Show 20 Lines • Show All 681 Lines • Show Last 20 Lines

libcxx/include/string_view

Show First 20 Lines • Show All 113 Lines • ▼ Show 20 Lines class basic_string_view {
constexpr int compare(size_type pos1, size_type n1, constexpr int compare(size_type pos1, size_type n1,
basic_string_view s, size_type pos2, size_type n2) const; basic_string_view s, size_type pos2, size_type n2) const;
constexpr int compare(const charT* s) const; constexpr int compare(const charT* s) const;
constexpr int compare(size_type pos1, size_type n1, const charT* s) const; constexpr int compare(size_type pos1, size_type n1, const charT* s) const;
constexpr int compare(size_type pos1, size_type n1, constexpr int compare(size_type pos1, size_type n1,
const charT* s, size_type n2) const; const charT* s, size_type n2) const;
constexpr size_type find(basic_string_view s, size_type pos = 0) const noexcept; constexpr size_type find(basic_string_view s, size_type pos = 0) const noexcept;
constexpr size_type find(charT c, size_type pos = 0) const noexcept; constexpr size_type find(charT c, size_type pos = 0) const noexcept;
constexpr size_type find(const charT* s, size_type pos, size_type n) const; constexpr size_type find(const charT* s, size_type pos, size_type n) const noexcept; // noexcept as an extension
constexpr size_type find(const charT* s, size_type pos = 0) const; constexpr size_type find(const charT* s, size_type pos = 0) const noexcept; // noexcept as an extension
constexpr size_type rfind(basic_string_view s, size_type pos = npos) const noexcept; constexpr size_type rfind(basic_string_view s, size_type pos = npos) const noexcept;
constexpr size_type rfind(charT c, size_type pos = npos) const noexcept; constexpr size_type rfind(charT c, size_type pos = npos) const noexcept;
constexpr size_type rfind(const charT* s, size_type pos, size_type n) const; constexpr size_type rfind(const charT* s, size_type pos, size_type n) const noexcept; // noexcept as an extension
constexpr size_type rfind(const charT* s, size_type pos = npos) const; constexpr size_type rfind(const charT* s, size_type pos = npos) const noexcept; // noexcept as an extension
constexpr size_type find_first_of(basic_string_view s, size_type pos = 0) const noexcept; constexpr size_type find_first_of(basic_string_view s, size_type pos = 0) const noexcept;
constexpr size_type find_first_of(charT c, size_type pos = 0) const noexcept; constexpr size_type find_first_of(charT c, size_type pos = 0) const noexcept;
constexpr size_type find_first_of(const charT* s, size_type pos, size_type n) const; constexpr size_type find_first_of(const charT* s, size_type pos, size_type n) const noexcept; // noexcept as an extension
constexpr size_type find_first_of(const charT* s, size_type pos = 0) const; constexpr size_type find_first_of(const charT* s, size_type pos = 0) const noexcept; // noexcept as an extension
constexpr size_type find_last_of(basic_string_view s, size_type pos = npos) const noexcept; constexpr size_type find_last_of(basic_string_view s, size_type pos = npos) const noexcept;
constexpr size_type find_last_of(charT c, size_type pos = npos) const noexcept; constexpr size_type find_last_of(charT c, size_type pos = npos) const noexcept;
constexpr size_type find_last_of(const charT* s, size_type pos, size_type n) const; constexpr size_type find_last_of(const charT* s, size_type pos, size_type n) const noexcept; // noexcept as an extension
constexpr size_type find_last_of(const charT* s, size_type pos = npos) const; constexpr size_type find_last_of(const charT* s, size_type pos = npos) const noexcept; // noexcept as an extension
constexpr size_type find_first_not_of(basic_string_view s, size_type pos = 0) const noexcept; constexpr size_type find_first_not_of(basic_string_view s, size_type pos = 0) const noexcept;
constexpr size_type find_first_not_of(charT c, size_type pos = 0) const noexcept; constexpr size_type find_first_not_of(charT c, size_type pos = 0) const noexcept;
constexpr size_type find_first_not_of(const charT* s, size_type pos, size_type n) const; constexpr size_type find_first_not_of(const charT* s, size_type pos, size_type n) const noexcept; // noexcept as an extension
constexpr size_type find_first_not_of(const charT* s, size_type pos = 0) const; constexpr size_type find_first_not_of(const charT* s, size_type pos = 0) const noexcept; // noexcept as an extension
constexpr size_type find_last_not_of(basic_string_view s, size_type pos = npos) const noexcept; constexpr size_type find_last_not_of(basic_string_view s, size_type pos = npos) const noexcept;
constexpr size_type find_last_not_of(charT c, size_type pos = npos) const noexcept; constexpr size_type find_last_not_of(charT c, size_type pos = npos) const noexcept;
constexpr size_type find_last_not_of(const charT* s, size_type pos, size_type n) const; constexpr size_type find_last_not_of(const charT* s, size_type pos, size_type n) const noexcept; // noexcept as an extension
constexpr size_type find_last_not_of(const charT* s, size_type pos = npos) const; constexpr size_type find_last_not_of(const charT* s, size_type pos = npos) const noexcept; // noexcept as an extension
constexpr bool starts_with(basic_string_view s) const noexcept; // C++20 constexpr bool starts_with(basic_string_view s) const noexcept; // C++20
constexpr bool starts_with(charT c) const noexcept; // C++20 constexpr bool starts_with(charT c) const noexcept; // C++20
constexpr bool starts_with(const charT* s) const; // C++20 constexpr bool starts_with(const charT* s) const; // C++20
constexpr bool ends_with(basic_string_view s) const noexcept; // C++20 constexpr bool ends_with(basic_string_view s) const noexcept; // C++20
constexpr bool ends_with(charT c) const noexcept; // C++20 constexpr bool ends_with(charT c) const noexcept; // C++20
constexpr bool ends_with(const charT* s) const; // C++20 constexpr bool ends_with(const charT* s) const; // C++20
▲ Show 20 Lines • Show All 274 Lines • ▼ Show 20 Lines#endif
_LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY
size_type find(_CharT __c, size_type __pos = 0) const _NOEXCEPT size_type find(_CharT __c, size_type __pos = 0) const _NOEXCEPT
{ {
return __str_find<value_type, size_type, traits_type, npos> return __str_find<value_type, size_type, traits_type, npos>
(data(), size(), __c, __pos); (data(), size(), __c, __pos);
} }
_LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY
size_type find(const _CharT* __s, size_type __pos, size_type __n) const size_type find(const _CharT* __s, size_type __pos, size_type __n) const _NOEXCEPT
{ {
_LIBCPP_ASSERT(__n == 0 || __s != nullptr, "string_view::find(): received nullptr"); _LIBCPP_ASSERT(__n == 0 || __s != nullptr, "string_view::find(): received nullptr");
return __str_find<value_type, size_type, traits_type, npos> return __str_find<value_type, size_type, traits_type, npos>
(data(), size(), __s, __pos, __n); (data(), size(), __s, __pos, __n);
} }
_LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY
size_type find(const _CharT* __s, size_type __pos = 0) const size_type find(const _CharT* __s, size_type __pos = 0) const _NOEXCEPT
{ {
_LIBCPP_ASSERT(__s != nullptr, "string_view::find(): received nullptr"); _LIBCPP_ASSERT(__s != nullptr, "string_view::find(): received nullptr");
return __str_find<value_type, size_type, traits_type, npos> return __str_find<value_type, size_type, traits_type, npos>
(data(), size(), __s, __pos, traits_type::length(__s)); (data(), size(), __s, __pos, traits_type::length(__s));
} }
// rfind // rfind
_LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY
size_type rfind(basic_string_view __s, size_type __pos = npos) const _NOEXCEPT size_type rfind(basic_string_view __s, size_type __pos = npos) const _NOEXCEPT
{ {
_LIBCPP_ASSERT(__s.size() == 0 || __s.data() != nullptr, "string_view::find(): received nullptr"); _LIBCPP_ASSERT(__s.size() == 0 || __s.data() != nullptr, "string_view::find(): received nullptr");
return __str_rfind<value_type, size_type, traits_type, npos> return __str_rfind<value_type, size_type, traits_type, npos>
(data(), size(), __s.data(), __pos, __s.size()); (data(), size(), __s.data(), __pos, __s.size());
} }
_LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY
size_type rfind(_CharT __c, size_type __pos = npos) const _NOEXCEPT size_type rfind(_CharT __c, size_type __pos = npos) const _NOEXCEPT
{ {
return __str_rfind<value_type, size_type, traits_type, npos> return __str_rfind<value_type, size_type, traits_type, npos>
(data(), size(), __c, __pos); (data(), size(), __c, __pos);
} }
_LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY
size_type rfind(const _CharT* __s, size_type __pos, size_type __n) const size_type rfind(const _CharT* __s, size_type __pos, size_type __n) const _NOEXCEPT
{ {
_LIBCPP_ASSERT(__n == 0 || __s != nullptr, "string_view::rfind(): received nullptr"); _LIBCPP_ASSERT(__n == 0 || __s != nullptr, "string_view::rfind(): received nullptr");
return __str_rfind<value_type, size_type, traits_type, npos> return __str_rfind<value_type, size_type, traits_type, npos>
(data(), size(), __s, __pos, __n); (data(), size(), __s, __pos, __n);
} }
_LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY
size_type rfind(const _CharT* __s, size_type __pos=npos) const size_type rfind(const _CharT* __s, size_type __pos=npos) const _NOEXCEPT
{ {
_LIBCPP_ASSERT(__s != nullptr, "string_view::rfind(): received nullptr"); _LIBCPP_ASSERT(__s != nullptr, "string_view::rfind(): received nullptr");
return __str_rfind<value_type, size_type, traits_type, npos> return __str_rfind<value_type, size_type, traits_type, npos>
(data(), size(), __s, __pos, traits_type::length(__s)); (data(), size(), __s, __pos, traits_type::length(__s));
} }
// find_first_of // find_first_of
_LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY
size_type find_first_of(basic_string_view __s, size_type __pos = 0) const _NOEXCEPT size_type find_first_of(basic_string_view __s, size_type __pos = 0) const _NOEXCEPT
{ {
_LIBCPP_ASSERT(__s.size() == 0 || __s.data() != nullptr, "string_view::find_first_of(): received nullptr"); _LIBCPP_ASSERT(__s.size() == 0 || __s.data() != nullptr, "string_view::find_first_of(): received nullptr");
return __str_find_first_of<value_type, size_type, traits_type, npos> return __str_find_first_of<value_type, size_type, traits_type, npos>
(data(), size(), __s.data(), __pos, __s.size()); (data(), size(), __s.data(), __pos, __s.size());
} }
_LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY
size_type find_first_of(_CharT __c, size_type __pos = 0) const _NOEXCEPT size_type find_first_of(_CharT __c, size_type __pos = 0) const _NOEXCEPT
{ return find(__c, __pos); } { return find(__c, __pos); }
_LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY
size_type find_first_of(const _CharT* __s, size_type __pos, size_type __n) const size_type find_first_of(const _CharT* __s, size_type __pos, size_type __n) const _NOEXCEPT
{ {
_LIBCPP_ASSERT(__n == 0 || __s != nullptr, "string_view::find_first_of(): received nullptr"); _LIBCPP_ASSERT(__n == 0 || __s != nullptr, "string_view::find_first_of(): received nullptr");
return __str_find_first_of<value_type, size_type, traits_type, npos> return __str_find_first_of<value_type, size_type, traits_type, npos>
(data(), size(), __s, __pos, __n); (data(), size(), __s, __pos, __n);
} }
_LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY
size_type find_first_of(const _CharT* __s, size_type __pos=0) const size_type find_first_of(const _CharT* __s, size_type __pos=0) const _NOEXCEPT
{ {
_LIBCPP_ASSERT(__s != nullptr, "string_view::find_first_of(): received nullptr"); _LIBCPP_ASSERT(__s != nullptr, "string_view::find_first_of(): received nullptr");
return __str_find_first_of<value_type, size_type, traits_type, npos> return __str_find_first_of<value_type, size_type, traits_type, npos>
(data(), size(), __s, __pos, traits_type::length(__s)); (data(), size(), __s, __pos, traits_type::length(__s));
} }
// find_last_of // find_last_of
_LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY
size_type find_last_of(basic_string_view __s, size_type __pos=npos) const _NOEXCEPT size_type find_last_of(basic_string_view __s, size_type __pos=npos) const _NOEXCEPT
{ {
_LIBCPP_ASSERT(__s.size() == 0 || __s.data() != nullptr, "string_view::find_last_of(): received nullptr"); _LIBCPP_ASSERT(__s.size() == 0 || __s.data() != nullptr, "string_view::find_last_of(): received nullptr");
return __str_find_last_of<value_type, size_type, traits_type, npos> return __str_find_last_of<value_type, size_type, traits_type, npos>
(data(), size(), __s.data(), __pos, __s.size()); (data(), size(), __s.data(), __pos, __s.size());
} }
_LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY
size_type find_last_of(_CharT __c, size_type __pos = npos) const _NOEXCEPT size_type find_last_of(_CharT __c, size_type __pos = npos) const _NOEXCEPT
{ return rfind(__c, __pos); } { return rfind(__c, __pos); }
_LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY
size_type find_last_of(const _CharT* __s, size_type __pos, size_type __n) const size_type find_last_of(const _CharT* __s, size_type __pos, size_type __n) const _NOEXCEPT
{ {
_LIBCPP_ASSERT(__n == 0 || __s != nullptr, "string_view::find_last_of(): received nullptr"); _LIBCPP_ASSERT(__n == 0 || __s != nullptr, "string_view::find_last_of(): received nullptr");
return __str_find_last_of<value_type, size_type, traits_type, npos> return __str_find_last_of<value_type, size_type, traits_type, npos>
(data(), size(), __s, __pos, __n); (data(), size(), __s, __pos, __n);
} }
_LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY
size_type find_last_of(const _CharT* __s, size_type __pos=npos) const size_type find_last_of(const _CharT* __s, size_type __pos=npos) const _NOEXCEPT
{ {
_LIBCPP_ASSERT(__s != nullptr, "string_view::find_last_of(): received nullptr"); _LIBCPP_ASSERT(__s != nullptr, "string_view::find_last_of(): received nullptr");
return __str_find_last_of<value_type, size_type, traits_type, npos> return __str_find_last_of<value_type, size_type, traits_type, npos>
(data(), size(), __s, __pos, traits_type::length(__s)); (data(), size(), __s, __pos, traits_type::length(__s));
} }
// find_first_not_of // find_first_not_of
_LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY
size_type find_first_not_of(basic_string_view __s, size_type __pos=0) const _NOEXCEPT size_type find_first_not_of(basic_string_view __s, size_type __pos=0) const _NOEXCEPT
{ {
_LIBCPP_ASSERT(__s.size() == 0 || __s.data() != nullptr, "string_view::find_first_not_of(): received nullptr"); _LIBCPP_ASSERT(__s.size() == 0 || __s.data() != nullptr, "string_view::find_first_not_of(): received nullptr");
return __str_find_first_not_of<value_type, size_type, traits_type, npos> return __str_find_first_not_of<value_type, size_type, traits_type, npos>
(data(), size(), __s.data(), __pos, __s.size()); (data(), size(), __s.data(), __pos, __s.size());
} }
_LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY
size_type find_first_not_of(_CharT __c, size_type __pos=0) const _NOEXCEPT size_type find_first_not_of(_CharT __c, size_type __pos=0) const _NOEXCEPT
{ {
return __str_find_first_not_of<value_type, size_type, traits_type, npos> return __str_find_first_not_of<value_type, size_type, traits_type, npos>
(data(), size(), __c, __pos); (data(), size(), __c, __pos);
} }
_LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY
size_type find_first_not_of(const _CharT* __s, size_type __pos, size_type __n) const size_type find_first_not_of(const _CharT* __s, size_type __pos, size_type __n) const _NOEXCEPT
{ {
_LIBCPP_ASSERT(__n == 0 || __s != nullptr, "string_view::find_first_not_of(): received nullptr"); _LIBCPP_ASSERT(__n == 0 || __s != nullptr, "string_view::find_first_not_of(): received nullptr");
return __str_find_first_not_of<value_type, size_type, traits_type, npos> return __str_find_first_not_of<value_type, size_type, traits_type, npos>
(data(), size(), __s, __pos, __n); (data(), size(), __s, __pos, __n);
} }
_LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY
size_type find_first_not_of(const _CharT* __s, size_type __pos=0) const size_type find_first_not_of(const _CharT* __s, size_type __pos=0) const _NOEXCEPT
{ {
_LIBCPP_ASSERT(__s != nullptr, "string_view::find_first_not_of(): received nullptr"); _LIBCPP_ASSERT(__s != nullptr, "string_view::find_first_not_of(): received nullptr");
return __str_find_first_not_of<value_type, size_type, traits_type, npos> return __str_find_first_not_of<value_type, size_type, traits_type, npos>
(data(), size(), __s, __pos, traits_type::length(__s)); (data(), size(), __s, __pos, traits_type::length(__s));
} }
// find_last_not_of // find_last_not_of
_LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY
size_type find_last_not_of(basic_string_view __s, size_type __pos=npos) const _NOEXCEPT size_type find_last_not_of(basic_string_view __s, size_type __pos=npos) const _NOEXCEPT
{ {
_LIBCPP_ASSERT(__s.size() == 0 || __s.data() != nullptr, "string_view::find_last_not_of(): received nullptr"); _LIBCPP_ASSERT(__s.size() == 0 || __s.data() != nullptr, "string_view::find_last_not_of(): received nullptr");
return __str_find_last_not_of<value_type, size_type, traits_type, npos> return __str_find_last_not_of<value_type, size_type, traits_type, npos>
(data(), size(), __s.data(), __pos, __s.size()); (data(), size(), __s.data(), __pos, __s.size());
} }
_LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY
size_type find_last_not_of(_CharT __c, size_type __pos=npos) const _NOEXCEPT size_type find_last_not_of(_CharT __c, size_type __pos=npos) const _NOEXCEPT
{ {
return __str_find_last_not_of<value_type, size_type, traits_type, npos> return __str_find_last_not_of<value_type, size_type, traits_type, npos>
(data(), size(), __c, __pos); (data(), size(), __c, __pos);
} }
_LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY
size_type find_last_not_of(const _CharT* __s, size_type __pos, size_type __n) const size_type find_last_not_of(const _CharT* __s, size_type __pos, size_type __n) const _NOEXCEPT
{ {
_LIBCPP_ASSERT(__n == 0 || __s != nullptr, "string_view::find_last_not_of(): received nullptr"); _LIBCPP_ASSERT(__n == 0 || __s != nullptr, "string_view::find_last_not_of(): received nullptr");
return __str_find_last_not_of<value_type, size_type, traits_type, npos> return __str_find_last_not_of<value_type, size_type, traits_type, npos>
(data(), size(), __s, __pos, __n); (data(), size(), __s, __pos, __n);
} }
_LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY
size_type find_last_not_of(const _CharT* __s, size_type __pos=npos) const size_type find_last_not_of(const _CharT* __s, size_type __pos=npos) const _NOEXCEPT
{ {
_LIBCPP_ASSERT(__s != nullptr, "string_view::find_last_not_of(): received nullptr"); _LIBCPP_ASSERT(__s != nullptr, "string_view::find_last_not_of(): received nullptr");
return __str_find_last_not_of<value_type, size_type, traits_type, npos> return __str_find_last_not_of<value_type, size_type, traits_type, npos>
(data(), size(), __s, __pos, traits_type::length(__s)); (data(), size(), __s, __pos, traits_type::length(__s));
} }
#if _LIBCPP_STD_VER > 17 #if _LIBCPP_STD_VER > 17
_LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY
▲ Show 20 Lines • Show All 267 Lines • Show Last 20 Lines

libcxx/test/std/strings/basic.string/string.ops/string_compare/pointer.pass.cpp

Show All 23 Lines if (x < 0)
return -1; return -1;
return 1; return 1;
} }
template <class S> template <class S>
void void
test(const S& s, const typename S::value_type* str, int x) test(const S& s, const typename S::value_type* str, int x)
{ {
LIBCPP_ASSERT_NOEXCEPT(s.compare(str));
assert(sign(s.compare(str)) == sign(x)); assert(sign(s.compare(str)) == sign(x));
} }
int main(int, char**) int main(int, char**)
{ {
{ {
typedef std::string S; typedef std::string S;
test(S(""), "", 0); test(S(""), "", 0);
Show All 40 Lines

libcxx/test/std/strings/basic.string/string.ops/string_compare/string.pass.cpp

Show All 23 Lines if (x < 0)
return -1; return -1;
return 1; return 1;
} }
template <class S> template <class S>
void void
test(const S& s, const S& str, int x) test(const S& s, const S& str, int x)
{ {
LIBCPP_ASSERT_NOEXCEPT(s.compare(str));
assert(sign(s.compare(str)) == sign(x)); assert(sign(s.compare(str)) == sign(x));
} }
int main(int, char**) int main(int, char**)
{ {
{ {
typedef std::string S; typedef std::string S;
test(S(""), S(""), 0); test(S(""), S(""), 0);
▲ Show 20 Lines • Show All 47 Lines • Show Last 20 Lines

libcxx/test/std/strings/basic.string/string.ops/string_compare/string_view.pass.cpp

Show All 23 Lines if (x < 0)
return -1; return -1;
return 1; return 1;
} }
template <class S, class SV> template <class S, class SV>
void void
test(const S& s, SV sv, int x) test(const S& s, SV sv, int x)
{ {
LIBCPP_ASSERT_NOEXCEPT(s.compare(sv));
assert(sign(s.compare(sv)) == sign(x)); assert(sign(s.compare(sv)) == sign(x));
} }
int main(int, char**) int main(int, char**)
{ {
{ {
typedef std::string S; typedef std::string S;
typedef std::string_view SV; typedef std::string_view SV;
▲ Show 20 Lines • Show All 42 Lines • Show Last 20 Lines

libcxx/test/std/strings/basic.string/string.ops/string_find.first.not.of/char_size.pass.cpp

Show All 15 Lines
#include "test_macros.h" #include "test_macros.h"
#include "min_allocator.h" #include "min_allocator.h"
template <class S> template <class S>
void void
test(const S& s, typename S::value_type c, typename S::size_type pos, test(const S& s, typename S::value_type c, typename S::size_type pos,
typename S::size_type x) typename S::size_type x)
{ {
LIBCPP_ASSERT_NOEXCEPT(s.find_first_not_of(c, pos));
assert(s.find_first_not_of(c, pos) == x); assert(s.find_first_not_of(c, pos) == x);
if (x != S::npos) if (x != S::npos)
assert(pos <= x && x < s.size()); assert(pos <= x && x < s.size());
} }
template <class S> template <class S>
void void
test(const S& s, typename S::value_type c, typename S::size_type x) test(const S& s, typename S::value_type c, typename S::size_type x)
{ {
LIBCPP_ASSERT_NOEXCEPT(s.find_first_not_of(c));
assert(s.find_first_not_of(c) == x); assert(s.find_first_not_of(c) == x);
if (x != S::npos) if (x != S::npos)
assert(x < s.size()); assert(x < s.size());
} }
int main(int, char**) int main(int, char**)
{ {
{ {
▲ Show 20 Lines • Show All 64 Lines • Show Last 20 Lines

libcxx/test/std/strings/basic.string/string.ops/string_find.first.not.of/pointer_size.pass.cpp

Show All 15 Lines
#include "test_macros.h" #include "test_macros.h"
#include "min_allocator.h" #include "min_allocator.h"
template <class S> template <class S>
void void
test(const S& s, const typename S::value_type* str, typename S::size_type pos, test(const S& s, const typename S::value_type* str, typename S::size_type pos,
typename S::size_type x) typename S::size_type x)
{ {
LIBCPP_ASSERT_NOEXCEPT(s.find_first_not_of(str, pos));
assert(s.find_first_not_of(str, pos) == x); assert(s.find_first_not_of(str, pos) == x);
if (x != S::npos) if (x != S::npos)
assert(pos <= x && x < s.size()); assert(pos <= x && x < s.size());
} }
template <class S> template <class S>
void void
test(const S& s, const typename S::value_type* str, typename S::size_type x) test(const S& s, const typename S::value_type* str, typename S::size_type x)
▲ Show 20 Lines • Show All 129 Lines • Show Last 20 Lines

libcxx/test/std/strings/basic.string/string.ops/string_find.first.not.of/pointer_size_size.pass.cpp

Show All 15 Lines
#include "test_macros.h" #include "test_macros.h"
#include "min_allocator.h" #include "min_allocator.h"
template <class S> template <class S>
void void
test(const S& s, const typename S::value_type* str, typename S::size_type pos, test(const S& s, const typename S::value_type* str, typename S::size_type pos,
typename S::size_type n, typename S::size_type x) typename S::size_type n, typename S::size_type x)
{ {
LIBCPP_ASSERT_NOEXCEPT(s.find_first_not_of(str, pos, n));
assert(s.find_first_not_of(str, pos, n) == x); assert(s.find_first_not_of(str, pos, n) == x);
if (x != S::npos) if (x != S::npos)
assert(pos <= x && x < s.size()); assert(pos <= x && x < s.size());
} }
template <class S> template <class S>
void test0() void test0()
{ {
▲ Show 20 Lines • Show All 358 Lines • Show Last 20 Lines

libcxx/test/std/strings/basic.string/string.ops/string_find.first.not.of/string_size.pass.cpp

Show All 14 Lines
#include "test_macros.h" #include "test_macros.h"
#include "min_allocator.h" #include "min_allocator.h"
template <class S> template <class S>
void void
test(const S& s, const S& str, typename S::size_type pos, typename S::size_type x) test(const S& s, const S& str, typename S::size_type pos, typename S::size_type x)
{ {
LIBCPP_ASSERT_NOEXCEPT(s.find_first_not_of(str, pos));
assert(s.find_first_not_of(str, pos) == x); assert(s.find_first_not_of(str, pos) == x);
if (x != S::npos) if (x != S::npos)
assert(pos <= x && x < s.size()); assert(pos <= x && x < s.size());
} }
template <class S> template <class S>
void void
test(const S& s, const S& str, typename S::size_type x) test(const S& s, const S& str, typename S::size_type x)
{ {
LIBCPP_ASSERT_NOEXCEPT(s.find_first_not_of(str));
assert(s.find_first_not_of(str) == x); assert(s.find_first_not_of(str) == x);
if (x != S::npos) if (x != S::npos)
assert(x < s.size()); assert(x < s.size());
} }
template <class S> template <class S>
void test0() void test0()
{ {
▲ Show 20 Lines • Show All 127 Lines • Show Last 20 Lines

libcxx/test/std/strings/basic.string/string.ops/string_find.first.not.of/string_view_size.pass.cpp

Show All 14 Lines
#include "test_macros.h" #include "test_macros.h"
#include "min_allocator.h" #include "min_allocator.h"
template <class S, class SV> template <class S, class SV>
void void
test(const S& s, SV sv, typename S::size_type pos, typename S::size_type x) test(const S& s, SV sv, typename S::size_type pos, typename S::size_type x)
{ {
LIBCPP_ASSERT_NOEXCEPT(s.find_first_not_of(sv, pos));
assert(s.find_first_not_of(sv, pos) == x); assert(s.find_first_not_of(sv, pos) == x);
if (x != S::npos) if (x != S::npos)
assert(pos <= x && x < s.size()); assert(pos <= x && x < s.size());
} }
template <class S, class SV> template <class S, class SV>
void void
test(const S& s, SV sv, typename S::size_type x) test(const S& s, SV sv, typename S::size_type x)
{ {
LIBCPP_ASSERT_NOEXCEPT(s.find_first_not_of(sv));
assert(s.find_first_not_of(sv) == x); assert(s.find_first_not_of(sv) == x);
if (x != S::npos) if (x != S::npos)
assert(x < s.size()); assert(x < s.size());
} }
template <class S, class SV> template <class S, class SV>
void test0() void test0()
{ {
▲ Show 20 Lines • Show All 122 Lines • Show Last 20 Lines

libcxx/test/std/strings/basic.string/string.ops/string_find.first.of/char_size.pass.cpp

Show All 15 Lines
#include "test_macros.h" #include "test_macros.h"
#include "min_allocator.h" #include "min_allocator.h"
template <class S> template <class S>
void void
test(const S& s, typename S::value_type c, typename S::size_type pos, test(const S& s, typename S::value_type c, typename S::size_type pos,
typename S::size_type x) typename S::size_type x)
{ {
LIBCPP_ASSERT_NOEXCEPT(s.find_first_of(c, pos));
assert(s.find_first_of(c, pos) == x); assert(s.find_first_of(c, pos) == x);
if (x != S::npos) if (x != S::npos)
assert(pos <= x && x < s.size()); assert(pos <= x && x < s.size());
} }
template <class S> template <class S>
void void
test(const S& s, typename S::value_type c, typename S::size_type x) test(const S& s, typename S::value_type c, typename S::size_type x)
{ {
LIBCPP_ASSERT_NOEXCEPT(s.find_first_of(c));
assert(s.find_first_of(c) == x); assert(s.find_first_of(c) == x);
if (x != S::npos) if (x != S::npos)
assert(x < s.size()); assert(x < s.size());
} }
int main(int, char**) int main(int, char**)
{ {
{ {
▲ Show 20 Lines • Show All 60 Lines • Show Last 20 Lines

libcxx/test/std/strings/basic.string/string.ops/string_find.first.of/pointer_size.pass.cpp

Show All 15 Lines
#include "test_macros.h" #include "test_macros.h"
#include "min_allocator.h" #include "min_allocator.h"
template <class S> template <class S>
void void
test(const S& s, const typename S::value_type* str, typename S::size_type pos, test(const S& s, const typename S::value_type* str, typename S::size_type pos,
typename S::size_type x) typename S::size_type x)
{ {
LIBCPP_ASSERT_NOEXCEPT(s.find_first_of(str, pos));
assert(s.find_first_of(str, pos) == x); assert(s.find_first_of(str, pos) == x);
if (x != S::npos) if (x != S::npos)
assert(pos <= x && x < s.size()); assert(pos <= x && x < s.size());
} }
template <class S> template <class S>
void void
test(const S& s, const typename S::value_type* str, typename S::size_type x) test(const S& s, const typename S::value_type* str, typename S::size_type x)
{ {
LIBCPP_ASSERT_NOEXCEPT(s.find_first_of(str));
assert(s.find_first_of(str) == x); assert(s.find_first_of(str) == x);
if (x != S::npos) if (x != S::npos)
assert(x < s.size()); assert(x < s.size());
} }
template <class S> template <class S>
void test0() void test0()
{ {
▲ Show 20 Lines • Show All 120 Lines • Show Last 20 Lines

libcxx/test/std/strings/basic.string/string.ops/string_find.first.of/pointer_size_size.pass.cpp

Show All 15 Lines
#include "test_macros.h" #include "test_macros.h"
#include "min_allocator.h" #include "min_allocator.h"
template <class S> template <class S>
void void
test(const S& s, const typename S::value_type* str, typename S::size_type pos, test(const S& s, const typename S::value_type* str, typename S::size_type pos,
typename S::size_type n, typename S::size_type x) typename S::size_type n, typename S::size_type x)
{ {
LIBCPP_ASSERT_NOEXCEPT(s.find_first_of(str, pos, n));
assert(s.find_first_of(str, pos, n) == x); assert(s.find_first_of(str, pos, n) == x);
if (x != S::npos) if (x != S::npos)
assert(pos <= x && x < s.size()); assert(pos <= x && x < s.size());
} }
template <class S> template <class S>
void test0() void test0()
{ {
▲ Show 20 Lines • Show All 358 Lines • Show Last 20 Lines

libcxx/test/std/strings/basic.string/string.ops/string_find.first.of/string_size.pass.cpp

Show All 14 Lines
#include "test_macros.h" #include "test_macros.h"
#include "min_allocator.h" #include "min_allocator.h"
template <class S> template <class S>
void void
test(const S& s, const S& str, typename S::size_type pos, typename S::size_type x) test(const S& s, const S& str, typename S::size_type pos, typename S::size_type x)
{ {
LIBCPP_ASSERT_NOEXCEPT(s.find_first_of(str, pos));
assert(s.find_first_of(str, pos) == x); assert(s.find_first_of(str, pos) == x);
if (x != S::npos) if (x != S::npos)
assert(pos <= x && x < s.size()); assert(pos <= x && x < s.size());
} }
template <class S> template <class S>
void void
test(const S& s, const S& str, typename S::size_type x) test(const S& s, const S& str, typename S::size_type x)
{ {
LIBCPP_ASSERT_NOEXCEPT(s.find_first_of(str));
assert(s.find_first_of(str) == x); assert(s.find_first_of(str) == x);
if (x != S::npos) if (x != S::npos)
assert(x < s.size()); assert(x < s.size());
} }
template <class S> template <class S>
void test0() void test0()
{ {
▲ Show 20 Lines • Show All 127 Lines • Show Last 20 Lines

libcxx/test/std/strings/basic.string/string.ops/string_find.first.of/string_view_size.pass.cpp

Show All 14 Lines
#include "test_macros.h" #include "test_macros.h"
#include "min_allocator.h" #include "min_allocator.h"
template <class S, class SV> template <class S, class SV>
void void
test(const S& s, SV sv, typename S::size_type pos, typename S::size_type x) test(const S& s, SV sv, typename S::size_type pos, typename S::size_type x)
{ {
LIBCPP_ASSERT_NOEXCEPT(s.find_first_of(sv, pos));
assert(s.find_first_of(sv, pos) == x); assert(s.find_first_of(sv, pos) == x);
if (x != S::npos) if (x != S::npos)
assert(pos <= x && x < s.size()); assert(pos <= x && x < s.size());
} }
template <class S, class SV> template <class S, class SV>
void void
test(const S& s, SV sv, typename S::size_type x) test(const S& s, SV sv, typename S::size_type x)
{ {
LIBCPP_ASSERT_NOEXCEPT(s.find_first_of(sv));
assert(s.find_first_of(sv) == x); assert(s.find_first_of(sv) == x);
if (x != S::npos) if (x != S::npos)
assert(x < s.size()); assert(x < s.size());
} }
template <class S, class SV> template <class S, class SV>
void test0() void test0()
{ {
▲ Show 20 Lines • Show All 122 Lines • Show Last 20 Lines

libcxx/test/std/strings/basic.string/string.ops/string_find.last.not.of/char_size.pass.cpp

Show All 15 Lines
#include "test_macros.h" #include "test_macros.h"
#include "min_allocator.h" #include "min_allocator.h"
template <class S> template <class S>
void void
test(const S& s, typename S::value_type c, typename S::size_type pos, test(const S& s, typename S::value_type c, typename S::size_type pos,
typename S::size_type x) typename S::size_type x)
{ {
LIBCPP_ASSERT_NOEXCEPT(s.find_last_not_of(c, pos));
assert(s.find_last_not_of(c, pos) == x); assert(s.find_last_not_of(c, pos) == x);
if (x != S::npos) if (x != S::npos)
assert(x <= pos && x < s.size()); assert(x <= pos && x < s.size());
} }
template <class S> template <class S>
void void
test(const S& s, typename S::value_type c, typename S::size_type x) test(const S& s, typename S::value_type c, typename S::size_type x)
{ {
LIBCPP_ASSERT_NOEXCEPT(s.find_last_not_of(c));
assert(s.find_last_not_of(c) == x); assert(s.find_last_not_of(c) == x);
if (x != S::npos) if (x != S::npos)
assert(x < s.size()); assert(x < s.size());
} }
int main(int, char**) int main(int, char**)
{ {
{ {
▲ Show 20 Lines • Show All 60 Lines • Show Last 20 Lines

libcxx/test/std/strings/basic.string/string.ops/string_find.last.not.of/pointer_size.pass.cpp

Show All 15 Lines
#include "test_macros.h" #include "test_macros.h"
#include "min_allocator.h" #include "min_allocator.h"
template <class S> template <class S>
void void
test(const S& s, const typename S::value_type* str, typename S::size_type pos, test(const S& s, const typename S::value_type* str, typename S::size_type pos,
typename S::size_type x) typename S::size_type x)
{ {
LIBCPP_ASSERT_NOEXCEPT(s.find_last_not_of(str, pos));
assert(s.find_last_not_of(str, pos) == x); assert(s.find_last_not_of(str, pos) == x);
if (x != S::npos) if (x != S::npos)
assert(x <= pos && x < s.size()); assert(x <= pos && x < s.size());
} }
template <class S> template <class S>
void void
test(const S& s, const typename S::value_type* str, typename S::size_type x) test(const S& s, const typename S::value_type* str, typename S::size_type x)
{ {
LIBCPP_ASSERT_NOEXCEPT(s.find_last_not_of(str));
assert(s.find_last_not_of(str) == x); assert(s.find_last_not_of(str) == x);
if (x != S::npos) if (x != S::npos)
assert(x < s.size()); assert(x < s.size());
} }
template <class S> template <class S>
void test0() void test0()
{ {
▲ Show 20 Lines • Show All 120 Lines • Show Last 20 Lines

libcxx/test/std/strings/basic.string/string.ops/string_find.last.not.of/pointer_size_size.pass.cpp

Show All 15 Lines
#include "test_macros.h" #include "test_macros.h"
#include "min_allocator.h" #include "min_allocator.h"
template <class S> template <class S>
void void
test(const S& s, const typename S::value_type* str, typename S::size_type pos, test(const S& s, const typename S::value_type* str, typename S::size_type pos,
typename S::size_type n, typename S::size_type x) typename S::size_type n, typename S::size_type x)
{ {
LIBCPP_ASSERT_NOEXCEPT(s.find_last_not_of(str, pos, n));
assert(s.find_last_not_of(str, pos, n) == x); assert(s.find_last_not_of(str, pos, n) == x);
if (x != S::npos) if (x != S::npos)
assert(x <= pos && x < s.size()); assert(x <= pos && x < s.size());
} }
template <class S> template <class S>
void test0() void test0()
{ {
▲ Show 20 Lines • Show All 358 Lines • Show Last 20 Lines

libcxx/test/std/strings/basic.string/string.ops/string_find.last.not.of/string_size.pass.cpp

Show All 14 Lines
#include "test_macros.h" #include "test_macros.h"
#include "min_allocator.h" #include "min_allocator.h"
template <class S> template <class S>
void void
test(const S& s, const S& str, typename S::size_type pos, typename S::size_type x) test(const S& s, const S& str, typename S::size_type pos, typename S::size_type x)
{ {
LIBCPP_ASSERT_NOEXCEPT(s.find_last_not_of(str, pos));
assert(s.find_last_not_of(str, pos) == x); assert(s.find_last_not_of(str, pos) == x);
if (x != S::npos) if (x != S::npos)
assert(x <= pos && x < s.size()); assert(x <= pos && x < s.size());
} }
template <class S> template <class S>
void void
test(const S& s, const S& str, typename S::size_type x) test(const S& s, const S& str, typename S::size_type x)
{ {
LIBCPP_ASSERT_NOEXCEPT(s.find_last_not_of(str));
assert(s.find_last_not_of(str) == x); assert(s.find_last_not_of(str) == x);
if (x != S::npos) if (x != S::npos)
assert(x < s.size()); assert(x < s.size());
} }
template <class S> template <class S>
void test0() void test0()
{ {
▲ Show 20 Lines • Show All 127 Lines • Show Last 20 Lines

libcxx/test/std/strings/basic.string/string.ops/string_find.last.not.of/string_view_size.pass.cpp

Show All 14 Lines
#include "test_macros.h" #include "test_macros.h"
#include "min_allocator.h" #include "min_allocator.h"
template <class S, class SV> template <class S, class SV>
void void
test(const S& s, SV sv, typename S::size_type pos, typename S::size_type x) test(const S& s, SV sv, typename S::size_type pos, typename S::size_type x)
{ {
LIBCPP_ASSERT_NOEXCEPT(s.find_last_not_of(sv, pos));
assert(s.find_last_not_of(sv, pos) == x); assert(s.find_last_not_of(sv, pos) == x);
if (x != S::npos) if (x != S::npos)
assert(x <= pos && x < s.size()); assert(x <= pos && x < s.size());
} }
template <class S, class SV> template <class S, class SV>
void void
test(const S& s, SV sv, typename S::size_type x) test(const S& s, SV sv, typename S::size_type x)
{ {
LIBCPP_ASSERT_NOEXCEPT(s.find_last_not_of(sv));
assert(s.find_last_not_of(sv) == x); assert(s.find_last_not_of(sv) == x);
if (x != S::npos) if (x != S::npos)
assert(x < s.size()); assert(x < s.size());
} }
template <class S, class SV> template <class S, class SV>
void test0() void test0()
{ {
▲ Show 20 Lines • Show All 122 Lines • Show Last 20 Lines

libcxx/test/std/strings/basic.string/string.ops/string_find.last.of/char_size.pass.cpp

Show All 15 Lines
#include "test_macros.h" #include "test_macros.h"
#include "min_allocator.h" #include "min_allocator.h"
template <class S> template <class S>
void void
test(const S& s, typename S::value_type c, typename S::size_type pos, test(const S& s, typename S::value_type c, typename S::size_type pos,
typename S::size_type x) typename S::size_type x)
{ {
LIBCPP_ASSERT_NOEXCEPT(s.find_last_of(c, pos));
assert(s.find_last_of(c, pos) == x); assert(s.find_last_of(c, pos) == x);
if (x != S::npos) if (x != S::npos)
assert(x <= pos && x < s.size()); assert(x <= pos && x < s.size());
} }
template <class S> template <class S>
void void
test(const S& s, typename S::value_type c, typename S::size_type x) test(const S& s, typename S::value_type c, typename S::size_type x)
{ {
LIBCPP_ASSERT_NOEXCEPT(s.find_last_of(c));
assert(s.find_last_of(c) == x); assert(s.find_last_of(c) == x);
if (x != S::npos) if (x != S::npos)
assert(x < s.size()); assert(x < s.size());
} }
int main(int, char**) int main(int, char**)
{ {
{ {
▲ Show 20 Lines • Show All 60 Lines • Show Last 20 Lines

libcxx/test/std/strings/basic.string/string.ops/string_find.last.of/pointer_size.pass.cpp

Show All 15 Lines
#include "test_macros.h" #include "test_macros.h"
#include "min_allocator.h" #include "min_allocator.h"
template <class S> template <class S>
void void
test(const S& s, const typename S::value_type* str, typename S::size_type pos, test(const S& s, const typename S::value_type* str, typename S::size_type pos,
typename S::size_type x) typename S::size_type x)
{ {
LIBCPP_ASSERT_NOEXCEPT(s.find_last_of(str, pos));
assert(s.find_last_of(str, pos) == x); assert(s.find_last_of(str, pos) == x);
if (x != S::npos) if (x != S::npos)
assert(x <= pos && x < s.size()); assert(x <= pos && x < s.size());
} }
template <class S> template <class S>
void void
test(const S& s, const typename S::value_type* str, typename S::size_type x) test(const S& s, const typename S::value_type* str, typename S::size_type x)
{ {
LIBCPP_ASSERT_NOEXCEPT(s.find_last_of(str));
assert(s.find_last_of(str) == x); assert(s.find_last_of(str) == x);
if (x != S::npos) if (x != S::npos)
assert(x < s.size()); assert(x < s.size());
} }
template <class S> template <class S>
void test0() void test0()
{ {
▲ Show 20 Lines • Show All 120 Lines • Show Last 20 Lines

libcxx/test/std/strings/basic.string/string.ops/string_find.last.of/pointer_size_size.pass.cpp

Show All 15 Lines
#include "test_macros.h" #include "test_macros.h"
#include "min_allocator.h" #include "min_allocator.h"
template <class S> template <class S>
void void
test(const S& s, const typename S::value_type* str, typename S::size_type pos, test(const S& s, const typename S::value_type* str, typename S::size_type pos,
typename S::size_type n, typename S::size_type x) typename S::size_type n, typename S::size_type x)
{ {
LIBCPP_ASSERT_NOEXCEPT(s.find_last_of(str, pos, n));
assert(s.find_last_of(str, pos, n) == x); assert(s.find_last_of(str, pos, n) == x);
if (x != S::npos) if (x != S::npos)
assert(x <= pos && x < s.size()); assert(x <= pos && x < s.size());
} }
template <class S> template <class S>
void test0() void test0()
{ {
▲ Show 20 Lines • Show All 358 Lines • Show Last 20 Lines

libcxx/test/std/strings/basic.string/string.ops/string_find.last.of/string_size.pass.cpp

Show All 14 Lines
#include "test_macros.h" #include "test_macros.h"
#include "min_allocator.h" #include "min_allocator.h"
template <class S> template <class S>
void void
test(const S& s, const S& str, typename S::size_type pos, typename S::size_type x) test(const S& s, const S& str, typename S::size_type pos, typename S::size_type x)
{ {
LIBCPP_ASSERT_NOEXCEPT(s.find_last_of(str, pos));
assert(s.find_last_of(str, pos) == x); assert(s.find_last_of(str, pos) == x);
if (x != S::npos) if (x != S::npos)
assert(x <= pos && x < s.size()); assert(x <= pos && x < s.size());
} }
template <class S> template <class S>
void void
test(const S& s, const S& str, typename S::size_type x) test(const S& s, const S& str, typename S::size_type x)
{ {
LIBCPP_ASSERT_NOEXCEPT(s.find_last_of(str));
assert(s.find_last_of(str) == x); assert(s.find_last_of(str) == x);
if (x != S::npos) if (x != S::npos)
assert(x < s.size()); assert(x < s.size());
} }
template <class S> template <class S>
void test0() void test0()
{ {
▲ Show 20 Lines • Show All 127 Lines • Show Last 20 Lines

libcxx/test/std/strings/basic.string/string.ops/string_find.last.of/string_view_size.pass.cpp

Show All 14 Lines
#include "test_macros.h" #include "test_macros.h"
#include "min_allocator.h" #include "min_allocator.h"
template <class S, class SV> template <class S, class SV>
void void
test(const S& s, SV sv, typename S::size_type pos, typename S::size_type x) test(const S& s, SV sv, typename S::size_type pos, typename S::size_type x)
{ {
LIBCPP_ASSERT_NOEXCEPT(s.find_last_of(sv, pos));
assert(s.find_last_of(sv, pos) == x); assert(s.find_last_of(sv, pos) == x);
if (x != S::npos) if (x != S::npos)
assert(x <= pos && x < s.size()); assert(x <= pos && x < s.size());
} }
template <class S, class SV> template <class S, class SV>
void void
test(const S& s, SV sv, typename S::size_type x) test(const S& s, SV sv, typename S::size_type x)
{ {
LIBCPP_ASSERT_NOEXCEPT(s.find_last_of(sv));
assert(s.find_last_of(sv) == x); assert(s.find_last_of(sv) == x);
if (x != S::npos) if (x != S::npos)
assert(x < s.size()); assert(x < s.size());
} }
template <class S, class SV> template <class S, class SV>
void test0() void test0()
{ {
▲ Show 20 Lines • Show All 122 Lines • Show Last 20 Lines

libcxx/test/std/strings/basic.string/string.ops/string_find/char_size.pass.cpp

Show All 15 Lines
#include "test_macros.h" #include "test_macros.h"
#include "min_allocator.h" #include "min_allocator.h"
template <class S> template <class S>
void void
test(const S& s, typename S::value_type c, typename S::size_type pos, test(const S& s, typename S::value_type c, typename S::size_type pos,
typename S::size_type x) typename S::size_type x)
{ {
LIBCPP_ASSERT_NOEXCEPT(s.find(c, pos));
assert(s.find(c, pos) == x); assert(s.find(c, pos) == x);
if (x != S::npos) if (x != S::npos)
assert(pos <= x && x + 1 <= s.size()); assert(pos <= x && x + 1 <= s.size());
} }
template <class S> template <class S>
void void
test(const S& s, typename S::value_type c, typename S::size_type x) test(const S& s, typename S::value_type c, typename S::size_type x)
{ {
LIBCPP_ASSERT_NOEXCEPT(s.find(c));
assert(s.find(c) == x); assert(s.find(c) == x);
if (x != S::npos) if (x != S::npos)
assert(0 <= x && x + 1 <= s.size()); assert(0 <= x && x + 1 <= s.size());
} }
int main(int, char**) int main(int, char**)
{ {
{ {
▲ Show 20 Lines • Show All 60 Lines • Show Last 20 Lines

libcxx/test/std/strings/basic.string/string.ops/string_find/pointer_size.pass.cpp

Show All 15 Lines
#include "test_macros.h" #include "test_macros.h"
#include "min_allocator.h" #include "min_allocator.h"
template <class S> template <class S>
void void
test(const S& s, const typename S::value_type* str, typename S::size_type pos, test(const S& s, const typename S::value_type* str, typename S::size_type pos,
typename S::size_type x) typename S::size_type x)
{ {
LIBCPP_ASSERT_NOEXCEPT(s.find(str, pos));
assert(s.find(str, pos) == x); assert(s.find(str, pos) == x);
if (x != S::npos) if (x != S::npos)
{ {
typename S::size_type n = S::traits_type::length(str); typename S::size_type n = S::traits_type::length(str);
assert(pos <= x && x + n <= s.size()); assert(pos <= x && x + n <= s.size());
} }
} }
template <class S> template <class S>
void void
test(const S& s, const typename S::value_type* str, typename S::size_type x) test(const S& s, const typename S::value_type* str, typename S::size_type x)
{ {
LIBCPP_ASSERT_NOEXCEPT(s.find(str));
assert(s.find(str) == x); assert(s.find(str) == x);
if (x != S::npos) if (x != S::npos)
{ {
typename S::size_type n = S::traits_type::length(str); typename S::size_type n = S::traits_type::length(str);
assert(0 <= x && x + n <= s.size()); assert(0 <= x && x + n <= s.size());
} }
} }
▲ Show 20 Lines • Show All 123 Lines • Show Last 20 Lines

libcxx/test/std/strings/basic.string/string.ops/string_find/pointer_size_size.pass.cpp

Show All 15 Lines
#include "test_macros.h" #include "test_macros.h"
#include "min_allocator.h" #include "min_allocator.h"
template <class S> template <class S>
void void
test(const S& s, const typename S::value_type* str, typename S::size_type pos, test(const S& s, const typename S::value_type* str, typename S::size_type pos,
typename S::size_type n, typename S::size_type x) typename S::size_type n, typename S::size_type x)
{ {
LIBCPP_ASSERT_NOEXCEPT(s.find(str, pos, n));
assert(s.find(str, pos, n) == x); assert(s.find(str, pos, n) == x);
if (x != S::npos) if (x != S::npos)
assert(pos <= x && x + n <= s.size()); assert(pos <= x && x + n <= s.size());
} }
template <class S> template <class S>
void test0() void test0()
{ {
▲ Show 20 Lines • Show All 358 Lines • Show Last 20 Lines

libcxx/test/std/strings/basic.string/string.ops/string_find/string_size.pass.cpp

Show All 14 Lines
#include "test_macros.h" #include "test_macros.h"
#include "min_allocator.h" #include "min_allocator.h"
template <class S> template <class S>
void void
test(const S& s, const S& str, typename S::size_type pos, typename S::size_type x) test(const S& s, const S& str, typename S::size_type pos, typename S::size_type x)
{ {
LIBCPP_ASSERT_NOEXCEPT(s.find(str, pos));
assert(s.find(str, pos) == x); assert(s.find(str, pos) == x);
if (x != S::npos) if (x != S::npos)
assert(pos <= x && x + str.size() <= s.size()); assert(pos <= x && x + str.size() <= s.size());
} }
template <class S> template <class S>
void void
test(const S& s, const S& str, typename S::size_type x) test(const S& s, const S& str, typename S::size_type x)
{ {
LIBCPP_ASSERT_NOEXCEPT(s.find(str));
assert(s.find(str) == x); assert(s.find(str) == x);
if (x != S::npos) if (x != S::npos)
assert(0 <= x && x + str.size() <= s.size()); assert(0 <= x && x + str.size() <= s.size());
} }
template <class S> template <class S>
void test0() void test0()
{ {
▲ Show 20 Lines • Show All 127 Lines • Show Last 20 Lines

libcxx/test/std/strings/basic.string/string.ops/string_find/string_view_size.pass.cpp

Show All 14 Lines
#include "test_macros.h" #include "test_macros.h"
#include "min_allocator.h" #include "min_allocator.h"
template <class S, class SV> template <class S, class SV>
void void
test(const S& s, SV sv, typename S::size_type pos, typename S::size_type x) test(const S& s, SV sv, typename S::size_type pos, typename S::size_type x)
{ {
LIBCPP_ASSERT_NOEXCEPT(s.find(sv, pos));
assert(s.find(sv, pos) == x); assert(s.find(sv, pos) == x);
if (x != S::npos) if (x != S::npos)
assert(pos <= x && x + sv.size() <= s.size()); assert(pos <= x && x + sv.size() <= s.size());
} }
template <class S, class SV> template <class S, class SV>
void void
test(const S& s, SV sv, typename S::size_type x) test(const S& s, SV sv, typename S::size_type x)
{ {
LIBCPP_ASSERT_NOEXCEPT(s.find(sv));
assert(s.find(sv) == x); assert(s.find(sv) == x);
if (x != S::npos) if (x != S::npos)
assert(0 <= x && x + sv.size() <= s.size()); assert(0 <= x && x + sv.size() <= s.size());
} }
template <class S, class SV> template <class S, class SV>
void test0() void test0()
{ {
▲ Show 20 Lines • Show All 122 Lines • Show Last 20 Lines

libcxx/test/std/strings/basic.string/string.ops/string_rfind/char_size.pass.cpp

Show All 15 Lines
#include "test_macros.h" #include "test_macros.h"
#include "min_allocator.h" #include "min_allocator.h"
template <class S> template <class S>
void void
test(const S& s, typename S::value_type c, typename S::size_type pos, test(const S& s, typename S::value_type c, typename S::size_type pos,
typename S::size_type x) typename S::size_type x)
{ {
LIBCPP_ASSERT_NOEXCEPT(s.rfind(c, pos));
assert(s.rfind(c, pos) == x); assert(s.rfind(c, pos) == x);
if (x != S::npos) if (x != S::npos)
assert(x <= pos && x + 1 <= s.size()); assert(x <= pos && x + 1 <= s.size());
} }
template <class S> template <class S>
void void
test(const S& s, typename S::value_type c, typename S::size_type x) test(const S& s, typename S::value_type c, typename S::size_type x)
{ {
LIBCPP_ASSERT_NOEXCEPT(s.rfind(c));
assert(s.rfind(c) == x); assert(s.rfind(c) == x);
if (x != S::npos) if (x != S::npos)
assert(x + 1 <= s.size()); assert(x + 1 <= s.size());
} }
int main(int, char**) int main(int, char**)
{ {
{ {
▲ Show 20 Lines • Show All 60 Lines • Show Last 20 Lines

libcxx/test/std/strings/basic.string/string.ops/string_rfind/pointer_size.pass.cpp

Show All 15 Lines
#include "test_macros.h" #include "test_macros.h"
#include "min_allocator.h" #include "min_allocator.h"
template <class S> template <class S>
void void
test(const S& s, const typename S::value_type* str, typename S::size_type pos, test(const S& s, const typename S::value_type* str, typename S::size_type pos,
typename S::size_type x) typename S::size_type x)
{ {
LIBCPP_ASSERT_NOEXCEPT(s.rfind(str, pos));
assert(s.rfind(str, pos) == x); assert(s.rfind(str, pos) == x);
if (x != S::npos) if (x != S::npos)
{ {
typename S::size_type n = S::traits_type::length(str); typename S::size_type n = S::traits_type::length(str);
assert(x <= pos && x + n <= s.size()); assert(x <= pos && x + n <= s.size());
} }
} }
template <class S> template <class S>
void void
test(const S& s, const typename S::value_type* str, typename S::size_type x) test(const S& s, const typename S::value_type* str, typename S::size_type x)
{ {
LIBCPP_ASSERT_NOEXCEPT(s.rfind(str));
assert(s.rfind(str) == x); assert(s.rfind(str) == x);
if (x != S::npos) if (x != S::npos)
{ {
typename S::size_type pos = s.size(); typename S::size_type pos = s.size();
typename S::size_type n = S::traits_type::length(str); typename S::size_type n = S::traits_type::length(str);
assert(x <= pos && x + n <= s.size()); assert(x <= pos && x + n <= s.size());
} }
} }
▲ Show 20 Lines • Show All 124 Lines • Show Last 20 Lines

libcxx/test/std/strings/basic.string/string.ops/string_rfind/pointer_size_size.pass.cpp

Show All 15 Lines
#include "test_macros.h" #include "test_macros.h"
#include "min_allocator.h" #include "min_allocator.h"
template <class S> template <class S>
void void
test(const S& s, const typename S::value_type* str, typename S::size_type pos, test(const S& s, const typename S::value_type* str, typename S::size_type pos,
typename S::size_type n, typename S::size_type x) typename S::size_type n, typename S::size_type x)
{ {
LIBCPP_ASSERT_NOEXCEPT(s.rfind(str, pos, n));
assert(s.rfind(str, pos, n) == x); assert(s.rfind(str, pos, n) == x);
if (x != S::npos) if (x != S::npos)
assert(x <= pos && x + n <= s.size()); assert(x <= pos && x + n <= s.size());
} }
template <class S> template <class S>
void test0() void test0()
{ {
▲ Show 20 Lines • Show All 358 Lines • Show Last 20 Lines

libcxx/test/std/strings/basic.string/string.ops/string_rfind/string_size.pass.cpp

Show All 14 Lines
#include "test_macros.h" #include "test_macros.h"
#include "min_allocator.h" #include "min_allocator.h"
template <class S> template <class S>
void void
test(const S& s, const S& str, typename S::size_type pos, typename S::size_type x) test(const S& s, const S& str, typename S::size_type pos, typename S::size_type x)
{ {
LIBCPP_ASSERT_NOEXCEPT(s.rfind(str, pos));
assert(s.rfind(str, pos) == x); assert(s.rfind(str, pos) == x);
if (x != S::npos) if (x != S::npos)
assert(x <= pos && x + str.size() <= s.size()); assert(x <= pos && x + str.size() <= s.size());
} }
template <class S> template <class S>
void void
test(const S& s, const S& str, typename S::size_type x) test(const S& s, const S& str, typename S::size_type x)
{ {
LIBCPP_ASSERT_NOEXCEPT(s.rfind(str));
assert(s.rfind(str) == x); assert(s.rfind(str) == x);
if (x != S::npos) if (x != S::npos)
assert(0 <= x && x + str.size() <= s.size()); assert(0 <= x && x + str.size() <= s.size());
} }
template <class S> template <class S>
void test0() void test0()
{ {
▲ Show 20 Lines • Show All 127 Lines • Show Last 20 Lines

libcxx/test/std/strings/basic.string/string.ops/string_rfind/string_view_size.pass.cpp

Show All 14 Lines
#include "test_macros.h" #include "test_macros.h"
#include "min_allocator.h" #include "min_allocator.h"
template <class S, class SV> template <class S, class SV>
void void
test(const S& s, SV sv, typename S::size_type pos, typename S::size_type x) test(const S& s, SV sv, typename S::size_type pos, typename S::size_type x)
{ {
LIBCPP_ASSERT_NOEXCEPT(s.rfind(sv, pos));
assert(s.rfind(sv, pos) == x); assert(s.rfind(sv, pos) == x);
if (x != S::npos) if (x != S::npos)
assert(x <= pos && x + sv.size() <= s.size()); assert(x <= pos && x + sv.size() <= s.size());
} }
template <class S, class SV> template <class S, class SV>
void void
test(const S& s, SV sv, typename S::size_type x) test(const S& s, SV sv, typename S::size_type x)
{ {
LIBCPP_ASSERT_NOEXCEPT(s.rfind(sv));
assert(s.rfind(sv) == x); assert(s.rfind(sv) == x);
if (x != S::npos) if (x != S::npos)
assert(0 <= x && x + sv.size() <= s.size()); assert(0 <= x && x + sv.size() <= s.size());
} }
template <class S, class SV> template <class S, class SV>
void test0() void test0()
{ {
▲ Show 20 Lines • Show All 122 Lines • Show Last 20 Lines

libcxx/test/std/strings/string.view/string.view.find/find_char_size.pass.cpp

Show All 15 Lines
#include "test_macros.h" #include "test_macros.h"
#include "constexpr_char_traits.h" #include "constexpr_char_traits.h"
template <class S> template <class S>
void void
test(const S& s, typename S::value_type c, typename S::size_type pos, test(const S& s, typename S::value_type c, typename S::size_type pos,
typename S::size_type x) typename S::size_type x)
{ {
LIBCPP_ASSERT_NOEXCEPT(s.find(c, pos));
assert(s.find(c, pos) == x); assert(s.find(c, pos) == x);
if (x != S::npos) if (x != S::npos)
assert(pos <= x && x + 1 <= s.size()); assert(pos <= x && x + 1 <= s.size());
} }
template <class S> template <class S>
void void
test(const S& s, typename S::value_type c, typename S::size_type x) test(const S& s, typename S::value_type c, typename S::size_type x)
▲ Show 20 Lines • Show All 55 Lines • Show Last 20 Lines

libcxx/test/std/strings/string.view/string.view.find/find_first_not_of_char_size.pass.cpp

Show All 15 Lines
#include "test_macros.h" #include "test_macros.h"
#include "constexpr_char_traits.h" #include "constexpr_char_traits.h"
template <class S> template <class S>
void void
test(const S& s, typename S::value_type c, typename S::size_type pos, test(const S& s, typename S::value_type c, typename S::size_type pos,
typename S::size_type x) typename S::size_type x)
{ {
LIBCPP_ASSERT_NOEXCEPT(s.find_first_not_of(c, pos));
assert(s.find_first_not_of(c, pos) == x); assert(s.find_first_not_of(c, pos) == x);
if (x != S::npos) if (x != S::npos)
assert(pos <= x && x < s.size()); assert(pos <= x && x < s.size());
} }
template <class S> template <class S>
void void
test(const S& s, typename S::value_type c, typename S::size_type x) test(const S& s, typename S::value_type c, typename S::size_type x)
{ {
LIBCPP_ASSERT_NOEXCEPT(s.find_first_not_of(c));
assert(s.find_first_not_of(c) == x); assert(s.find_first_not_of(c) == x);
if (x != S::npos) if (x != S::npos)
assert(x < s.size()); assert(x < s.size());
} }
int main(int, char**) int main(int, char**)
{ {
{ {
▲ Show 20 Lines • Show All 46 Lines • Show Last 20 Lines

libcxx/test/std/strings/string.view/string.view.find/find_first_not_of_pointer_size.pass.cpp

Show All 15 Lines
#include "test_macros.h" #include "test_macros.h"
#include "constexpr_char_traits.h" #include "constexpr_char_traits.h"
template <class S> template <class S>
void void
test(const S& s, const typename S::value_type* str, typename S::size_type pos, test(const S& s, const typename S::value_type* str, typename S::size_type pos,
typename S::size_type x) typename S::size_type x)
{ {
LIBCPP_ASSERT_NOEXCEPT(s.find_first_not_of(str, pos));
assert(s.find_first_not_of(str, pos) == x); assert(s.find_first_not_of(str, pos) == x);
if (x != S::npos) if (x != S::npos)
assert(pos <= x && x < s.size()); assert(pos <= x && x < s.size());
} }
template <class S> template <class S>
void void
test(const S& s, const typename S::value_type* str, typename S::size_type x) test(const S& s, const typename S::value_type* str, typename S::size_type x)
▲ Show 20 Lines • Show All 136 Lines • Show Last 20 Lines

libcxx/test/std/strings/string.view/string.view.find/find_first_not_of_pointer_size_size.pass.cpp

Show All 15 Lines
#include "test_macros.h" #include "test_macros.h"
#include "constexpr_char_traits.h" #include "constexpr_char_traits.h"
template <class S> template <class S>
void void
test(const S& s, const typename S::value_type* str, typename S::size_type pos, test(const S& s, const typename S::value_type* str, typename S::size_type pos,
typename S::size_type n, typename S::size_type x) typename S::size_type n, typename S::size_type x)
{ {
LIBCPP_ASSERT_NOEXCEPT(s.find_first_not_of(str, pos, n));
assert(s.find_first_not_of(str, pos, n) == x); assert(s.find_first_not_of(str, pos, n) == x);
if (x != S::npos) if (x != S::npos)
assert(pos <= x && x < s.size()); assert(pos <= x && x < s.size());
} }
template <class S> template <class S>
void test0() void test0()
{ {
▲ Show 20 Lines • Show All 363 Lines • Show Last 20 Lines

libcxx/test/std/strings/string.view/string.view.find/find_first_not_of_string_view_size.pass.cpp

Show All 13 Lines
#include <cassert> #include <cassert>
#include "test_macros.h" #include "test_macros.h"
template <class S> template <class S>
void void
test(const S& s, const S& str, typename S::size_type pos, typename S::size_type x) test(const S& s, const S& str, typename S::size_type pos, typename S::size_type x)
{ {
LIBCPP_ASSERT_NOEXCEPT(s.find_first_not_of(str, pos));
assert(s.find_first_not_of(str, pos) == x); assert(s.find_first_not_of(str, pos) == x);
if (x != S::npos) if (x != S::npos)
assert(pos <= x && x < s.size()); assert(pos <= x && x < s.size());
} }
template <class S> template <class S>
void void
test(const S& s, const S& str, typename S::size_type x) test(const S& s, const S& str, typename S::size_type x)
▲ Show 20 Lines • Show All 122 Lines • Show Last 20 Lines

libcxx/test/std/strings/string.view/string.view.find/find_first_of_char_size.pass.cpp

Show All 15 Lines
#include "test_macros.h" #include "test_macros.h"
#include "constexpr_char_traits.h" #include "constexpr_char_traits.h"
template <class S> template <class S>
void void
test(const S& s, typename S::value_type c, typename S::size_type pos, test(const S& s, typename S::value_type c, typename S::size_type pos,
typename S::size_type x) typename S::size_type x)
{ {
LIBCPP_ASSERT_NOEXCEPT(s.find_first_of(c, pos));
assert(s.find_first_of(c, pos) == x); assert(s.find_first_of(c, pos) == x);
if (x != S::npos) if (x != S::npos)
assert(pos <= x && x < s.size()); assert(pos <= x && x < s.size());
} }
template <class S> template <class S>
void void
test(const S& s, typename S::value_type c, typename S::size_type x) test(const S& s, typename S::value_type c, typename S::size_type x)
▲ Show 20 Lines • Show All 53 Lines • Show Last 20 Lines

libcxx/test/std/strings/string.view/string.view.find/find_first_of_pointer_size.pass.cpp

Show All 15 Lines
#include "test_macros.h" #include "test_macros.h"
#include "constexpr_char_traits.h" #include "constexpr_char_traits.h"
template <class S> template <class S>
void void
test(const S& s, const typename S::value_type* str, typename S::size_type pos, test(const S& s, const typename S::value_type* str, typename S::size_type pos,
typename S::size_type x) typename S::size_type x)
{ {
LIBCPP_ASSERT_NOEXCEPT(s.find_first_of(str, pos));
assert(s.find_first_of(str, pos) == x); assert(s.find_first_of(str, pos) == x);
if (x != S::npos) if (x != S::npos)
assert(pos <= x && x < s.size()); assert(pos <= x && x < s.size());
} }
template <class S> template <class S>
void void
test(const S& s, const typename S::value_type* str, typename S::size_type x) test(const S& s, const typename S::value_type* str, typename S::size_type x)
{ {
LIBCPP_ASSERT_NOEXCEPT(s.find_first_of(str));
assert(s.find_first_of(str) == x); assert(s.find_first_of(str) == x);
if (x != S::npos) if (x != S::npos)
assert(x < s.size()); assert(x < s.size());
} }
template <class S> template <class S>
void test0() void test0()
{ {
▲ Show 20 Lines • Show All 127 Lines • Show Last 20 Lines

libcxx/test/std/strings/string.view/string.view.find/find_first_of_pointer_size_size.pass.cpp

Show All 15 Lines
#include "test_macros.h" #include "test_macros.h"
#include "constexpr_char_traits.h" #include "constexpr_char_traits.h"
template <class S> template <class S>
void void
test(const S& s, const typename S::value_type* str, typename S::size_type pos, test(const S& s, const typename S::value_type* str, typename S::size_type pos,
typename S::size_type n, typename S::size_type x) typename S::size_type n, typename S::size_type x)
{ {
LIBCPP_ASSERT_NOEXCEPT(s.find_first_of(str, pos, n));
assert(s.find_first_of(str, pos, n) == x); assert(s.find_first_of(str, pos, n) == x);
if (x != S::npos) if (x != S::npos)
assert(pos <= x && x < s.size()); assert(pos <= x && x < s.size());
} }
template <class S> template <class S>
void test0() void test0()
{ {
▲ Show 20 Lines • Show All 363 Lines • Show Last 20 Lines

libcxx/test/std/strings/string.view/string.view.find/find_first_of_string_view_size.pass.cpp

Show All 13 Lines
#include <cassert> #include <cassert>
#include "test_macros.h" #include "test_macros.h"
template <class S> template <class S>
void void
test(const S& s, const S& str, typename S::size_type pos, typename S::size_type x) test(const S& s, const S& str, typename S::size_type pos, typename S::size_type x)
{ {
LIBCPP_ASSERT_NOEXCEPT(s.find_first_of(str, pos));
assert(s.find_first_of(str, pos) == x); assert(s.find_first_of(str, pos) == x);
if (x != S::npos) if (x != S::npos)
assert(pos <= x && x < s.size()); assert(pos <= x && x < s.size());
} }
template <class S> template <class S>
void void
test(const S& s, const S& str, typename S::size_type x) test(const S& s, const S& str, typename S::size_type x)
{ {
LIBCPP_ASSERT_NOEXCEPT(s.find_first_of(str));
assert(s.find_first_of(str) == x); assert(s.find_first_of(str) == x);
if (x != S::npos) if (x != S::npos)
assert(x < s.size()); assert(x < s.size());
} }
template <class S> template <class S>
void test0() void test0()
{ {
▲ Show 20 Lines • Show All 113 Lines • Show Last 20 Lines

libcxx/test/std/strings/string.view/string.view.find/find_last_not_of_char_size.pass.cpp

Show All 15 Lines
#include "test_macros.h" #include "test_macros.h"
#include "constexpr_char_traits.h" #include "constexpr_char_traits.h"
template <class S> template <class S>
void void
test(const S& s, typename S::value_type c, typename S::size_type pos, test(const S& s, typename S::value_type c, typename S::size_type pos,
typename S::size_type x) typename S::size_type x)
{ {
LIBCPP_ASSERT_NOEXCEPT(s.find_last_not_of(c, pos));
assert(s.find_last_not_of(c, pos) == x); assert(s.find_last_not_of(c, pos) == x);
if (x != S::npos) if (x != S::npos)
assert(x <= pos && x < s.size()); assert(x <= pos && x < s.size());
} }
template <class S> template <class S>
void void
test(const S& s, typename S::value_type c, typename S::size_type x) test(const S& s, typename S::value_type c, typename S::size_type x)
{ {
LIBCPP_ASSERT_NOEXCEPT(s.find_last_not_of(c));
assert(s.find_last_not_of(c) == x); assert(s.find_last_not_of(c) == x);
if (x != S::npos) if (x != S::npos)
assert(x < s.size()); assert(x < s.size());
} }
int main(int, char**) int main(int, char**)
{ {
{ {
▲ Show 20 Lines • Show All 44 Lines • Show Last 20 Lines

libcxx/test/std/strings/string.view/string.view.find/find_last_not_of_pointer_size.pass.cpp

Show All 15 Lines
#include "test_macros.h" #include "test_macros.h"
#include "constexpr_char_traits.h" #include "constexpr_char_traits.h"
template <class S> template <class S>
void void
test(const S& s, const typename S::value_type* str, typename S::size_type pos, test(const S& s, const typename S::value_type* str, typename S::size_type pos,
typename S::size_type x) typename S::size_type x)
{ {
LIBCPP_ASSERT_NOEXCEPT(s.find_last_not_of(str, pos));
assert(s.find_last_not_of(str, pos) == x); assert(s.find_last_not_of(str, pos) == x);
if (x != S::npos) if (x != S::npos)
assert(x <= pos && x < s.size()); assert(x <= pos && x < s.size());
} }
template <class S> template <class S>
void void
test(const S& s, const typename S::value_type* str, typename S::size_type x) test(const S& s, const typename S::value_type* str, typename S::size_type x)
▲ Show 20 Lines • Show All 136 Lines • Show Last 20 Lines

libcxx/test/std/strings/string.view/string.view.find/find_last_not_of_pointer_size_size.pass.cpp

Show All 15 Lines
#include "test_macros.h" #include "test_macros.h"
#include "constexpr_char_traits.h" #include "constexpr_char_traits.h"
template <class S> template <class S>
void void
test(const S& s, const typename S::value_type* str, typename S::size_type pos, test(const S& s, const typename S::value_type* str, typename S::size_type pos,
typename S::size_type n, typename S::size_type x) typename S::size_type n, typename S::size_type x)
{ {
LIBCPP_ASSERT_NOEXCEPT(s.find_last_not_of(str, pos, n));
assert(s.find_last_not_of(str, pos, n) == x); assert(s.find_last_not_of(str, pos, n) == x);
if (x != S::npos) if (x != S::npos)
assert(x <= pos && x < s.size()); assert(x <= pos && x < s.size());
} }
template <class S> template <class S>
void test0() void test0()
{ {
▲ Show 20 Lines • Show All 363 Lines • Show Last 20 Lines

libcxx/test/std/strings/string.view/string.view.find/find_last_not_of_string_view_size.pass.cpp

Show All 13 Lines
#include <cassert> #include <cassert>
#include "test_macros.h" #include "test_macros.h"
template <class S> template <class S>
void void
test(const S& s, const S& str, typename S::size_type pos, typename S::size_type x) test(const S& s, const S& str, typename S::size_type pos, typename S::size_type x)
{ {
LIBCPP_ASSERT_NOEXCEPT(s.find_last_not_of(str, pos));
assert(s.find_last_not_of(str, pos) == x); assert(s.find_last_not_of(str, pos) == x);
if (x != S::npos) if (x != S::npos)
assert(x <= pos && x < s.size()); assert(x <= pos && x < s.size());
} }
template <class S> template <class S>
void void
test(const S& s, const S& str, typename S::size_type x) test(const S& s, const S& str, typename S::size_type x)
{ {
LIBCPP_ASSERT_NOEXCEPT(s.find_last_not_of(str));
assert(s.find_last_not_of(str) == x); assert(s.find_last_not_of(str) == x);
if (x != S::npos) if (x != S::npos)
assert(x < s.size()); assert(x < s.size());
} }
template <class S> template <class S>
void test0() void test0()
{ {
▲ Show 20 Lines • Show All 113 Lines • Show Last 20 Lines

libcxx/test/std/strings/string.view/string.view.find/find_last_of_char_size.pass.cpp

Show All 15 Lines
#include "test_macros.h" #include "test_macros.h"
#include "constexpr_char_traits.h" #include "constexpr_char_traits.h"
template <class S> template <class S>
void void
test(const S& s, typename S::value_type c, typename S::size_type pos, test(const S& s, typename S::value_type c, typename S::size_type pos,
typename S::size_type x) typename S::size_type x)
{ {
LIBCPP_ASSERT_NOEXCEPT(s.find_last_of(c, pos));
assert(s.find_last_of(c, pos) == x); assert(s.find_last_of(c, pos) == x);
if (x != S::npos) if (x != S::npos)
assert(x <= pos && x < s.size()); assert(x <= pos && x < s.size());
} }
template <class S> template <class S>
void void
test(const S& s, typename S::value_type c, typename S::size_type x) test(const S& s, typename S::value_type c, typename S::size_type x)
{ {
LIBCPP_ASSERT_NOEXCEPT(s.find_last_of(c));
assert(s.find_last_of(c) == x); assert(s.find_last_of(c) == x);
if (x != S::npos) if (x != S::npos)
assert(x < s.size()); assert(x < s.size());
} }
int main(int, char**) int main(int, char**)
{ {
{ {
▲ Show 20 Lines • Show All 44 Lines • Show Last 20 Lines

libcxx/test/std/strings/string.view/string.view.find/find_last_of_pointer_size.pass.cpp

Show All 15 Lines
#include "test_macros.h" #include "test_macros.h"
#include "constexpr_char_traits.h" #include "constexpr_char_traits.h"
template <class S> template <class S>
void void
test(const S& s, const typename S::value_type* str, typename S::size_type pos, test(const S& s, const typename S::value_type* str, typename S::size_type pos,
typename S::size_type x) typename S::size_type x)
{ {
LIBCPP_ASSERT_NOEXCEPT(s.find_last_of(str, pos));
assert(s.find_last_of(str, pos) == x); assert(s.find_last_of(str, pos) == x);
if (x != S::npos) if (x != S::npos)
assert(x <= pos && x < s.size()); assert(x <= pos && x < s.size());
} }
template <class S> template <class S>
void void
test(const S& s, const typename S::value_type* str, typename S::size_type x) test(const S& s, const typename S::value_type* str, typename S::size_type x)
{ {
LIBCPP_ASSERT_NOEXCEPT(s.find_last_of(str));
assert(s.find_last_of(str) == x); assert(s.find_last_of(str) == x);
if (x != S::npos) if (x != S::npos)
assert(x < s.size()); assert(x < s.size());
} }
template <class S> template <class S>
void test0() void test0()
{ {
▲ Show 20 Lines • Show All 127 Lines • Show Last 20 Lines

libcxx/test/std/strings/string.view/string.view.find/find_last_of_pointer_size_size.pass.cpp

Show All 15 Lines
#include "test_macros.h" #include "test_macros.h"
#include "constexpr_char_traits.h" #include "constexpr_char_traits.h"
template <class S> template <class S>
void void
test(const S& s, const typename S::value_type* str, typename S::size_type pos, test(const S& s, const typename S::value_type* str, typename S::size_type pos,
typename S::size_type n, typename S::size_type x) typename S::size_type n, typename S::size_type x)
{ {
LIBCPP_ASSERT_NOEXCEPT(s.find_last_of(str, pos, n));
assert(s.find_last_of(str, pos, n) == x); assert(s.find_last_of(str, pos, n) == x);
if (x != S::npos) if (x != S::npos)
assert(x <= pos && x < s.size()); assert(x <= pos && x < s.size());
} }
template <class S> template <class S>
void test0() void test0()
{ {
▲ Show 20 Lines • Show All 363 Lines • Show Last 20 Lines

libcxx/test/std/strings/string.view/string.view.find/find_last_of_string_view_size.pass.cpp

Show All 13 Lines
#include <cassert> #include <cassert>
#include "test_macros.h" #include "test_macros.h"
template <class S> template <class S>
void void
test(const S& s, const S& str, typename S::size_type pos, typename S::size_type x) test(const S& s, const S& str, typename S::size_type pos, typename S::size_type x)
{ {
LIBCPP_ASSERT_NOEXCEPT(s.find_last_of(str, pos));
assert(s.find_last_of(str, pos) == x); assert(s.find_last_of(str, pos) == x);
if (x != S::npos) if (x != S::npos)
assert(x <= pos && x < s.size()); assert(x <= pos && x < s.size());
} }
template <class S> template <class S>
void void
test(const S& s, const S& str, typename S::size_type x) test(const S& s, const S& str, typename S::size_type x)
{ {
LIBCPP_ASSERT_NOEXCEPT(s.find_last_of(str));
assert(s.find_last_of(str) == x); assert(s.find_last_of(str) == x);
if (x != S::npos) if (x != S::npos)
assert(x < s.size()); assert(x < s.size());
} }
template <class S> template <class S>
void test0() void test0()
{ {
▲ Show 20 Lines • Show All 113 Lines • Show Last 20 Lines

libcxx/test/std/strings/string.view/string.view.find/find_pointer_size.pass.cpp

Show All 15 Lines
#include "test_macros.h" #include "test_macros.h"
#include "constexpr_char_traits.h" #include "constexpr_char_traits.h"
template <class S> template <class S>
void void
test(const S& s, const typename S::value_type* str, typename S::size_type pos, test(const S& s, const typename S::value_type* str, typename S::size_type pos,
typename S::size_type x) typename S::size_type x)
{ {
LIBCPP_ASSERT_NOEXCEPT(s.find(str, pos));
assert(s.find(str, pos) == x); assert(s.find(str, pos) == x);
if (x != S::npos) if (x != S::npos)
{ {
typename S::size_type n = S::traits_type::length(str); typename S::size_type n = S::traits_type::length(str);
assert(pos <= x && x + n <= s.size()); assert(pos <= x && x + n <= s.size());
} }
} }
template <class S> template <class S>
void void
test(const S& s, const typename S::value_type* str, typename S::size_type x) test(const S& s, const typename S::value_type* str, typename S::size_type x)
{ {
LIBCPP_ASSERT_NOEXCEPT(s.find(str));
assert(s.find(str) == x); assert(s.find(str) == x);
if (x != S::npos) if (x != S::npos)
{ {
typename S::size_type n = S::traits_type::length(str); typename S::size_type n = S::traits_type::length(str);
assert(0 <= x && x + n <= s.size()); assert(0 <= x && x + n <= s.size());
} }
} }
▲ Show 20 Lines • Show All 130 Lines • Show Last 20 Lines

libcxx/test/std/strings/string.view/string.view.find/find_pointer_size_size.pass.cpp

Show All 15 Lines
#include "test_macros.h" #include "test_macros.h"
#include "constexpr_char_traits.h" #include "constexpr_char_traits.h"
template <class S> template <class S>
void void
test(const S& s, const typename S::value_type* str, typename S::size_type pos, test(const S& s, const typename S::value_type* str, typename S::size_type pos,
typename S::size_type n, typename S::size_type x) typename S::size_type n, typename S::size_type x)
{ {
LIBCPP_ASSERT_NOEXCEPT(s.find(str, pos, n));
assert(s.find(str, pos, n) == x); assert(s.find(str, pos, n) == x);
if (x != S::npos) if (x != S::npos)
assert(pos <= x && x + n <= s.size()); assert(pos <= x && x + n <= s.size());
} }
template <class S> template <class S>
void test0() void test0()
{ {
▲ Show 20 Lines • Show All 364 Lines • Show Last 20 Lines

libcxx/test/std/strings/string.view/string.view.find/find_string_view_size.pass.cpp

Show All 14 Lines
#include "test_macros.h" #include "test_macros.h"
#include "constexpr_char_traits.h" #include "constexpr_char_traits.h"
template <class S> template <class S>
void void
test(const S& s, const S& str, typename S::size_type pos, typename S::size_type x) test(const S& s, const S& str, typename S::size_type pos, typename S::size_type x)
{ {
LIBCPP_ASSERT_NOEXCEPT(s.find(str, pos));
assert(s.find(str, pos) == x); assert(s.find(str, pos) == x);
if (x != S::npos) if (x != S::npos)
assert(pos <= x && x + str.size() <= s.size()); assert(pos <= x && x + str.size() <= s.size());
} }
template <class S> template <class S>
void void
test(const S& s, const S& str, typename S::size_type x) test(const S& s, const S& str, typename S::size_type x)
{ {
LIBCPP_ASSERT_NOEXCEPT(s.find(str));
assert(s.find(str) == x); assert(s.find(str) == x);
if (x != S::npos) if (x != S::npos)
assert(0 <= x && x + str.size() <= s.size()); assert(0 <= x && x + str.size() <= s.size());
} }
template <class S> template <class S>
void test0() void test0()
{ {
▲ Show 20 Lines • Show All 127 Lines • Show Last 20 Lines

libcxx/test/std/strings/string.view/string.view.find/rfind_char_size.pass.cpp

Show All 14 Lines
#include "test_macros.h" #include "test_macros.h"
#include "constexpr_char_traits.h" #include "constexpr_char_traits.h"
template <class S> template <class S>
void void
test(const S& s, typename S::value_type c, typename S::size_type pos, test(const S& s, typename S::value_type c, typename S::size_type pos,
typename S::size_type x) typename S::size_type x)
{ {
LIBCPP_ASSERT_NOEXCEPT(s.rfind(c, pos));
assert(s.rfind(c, pos) == x); assert(s.rfind(c, pos) == x);
if (x != S::npos) if (x != S::npos)
assert(x <= pos && x + 1 <= s.size()); assert(x <= pos && x + 1 <= s.size());
} }
template <class S> template <class S>
void void
test(const S& s, typename S::value_type c, typename S::size_type x) test(const S& s, typename S::value_type c, typename S::size_type x)
{ {
LIBCPP_ASSERT_NOEXCEPT(s.rfind(c));
assert(s.rfind(c) == x); assert(s.rfind(c) == x);
if (x != S::npos) if (x != S::npos)
assert(x + 1 <= s.size()); assert(x + 1 <= s.size());
} }
int main(int, char**) int main(int, char**)
{ {
{ {
▲ Show 20 Lines • Show All 46 Lines • Show Last 20 Lines

libcxx/test/std/strings/string.view/string.view.find/rfind_pointer_size.pass.cpp

Show All 14 Lines
#include "test_macros.h" #include "test_macros.h"
#include "constexpr_char_traits.h" #include "constexpr_char_traits.h"
template <class S> template <class S>
void void
test(const S& s, const typename S::value_type* str, typename S::size_type pos, test(const S& s, const typename S::value_type* str, typename S::size_type pos,
typename S::size_type x) typename S::size_type x)
{ {
LIBCPP_ASSERT_NOEXCEPT(s.rfind(str, pos));
assert(s.rfind(str, pos) == x); assert(s.rfind(str, pos) == x);
if (x != S::npos) if (x != S::npos)
{ {
typename S::size_type n = S::traits_type::length(str); typename S::size_type n = S::traits_type::length(str);
assert(x <= pos && x + n <= s.size()); assert(x <= pos && x + n <= s.size());
} }
} }
template <class S> template <class S>
void void
test(const S& s, const typename S::value_type* str, typename S::size_type x) test(const S& s, const typename S::value_type* str, typename S::size_type x)
{ {
LIBCPP_ASSERT_NOEXCEPT(s.rfind(str));
assert(s.rfind(str) == x); assert(s.rfind(str) == x);
if (x != S::npos) if (x != S::npos)
{ {
typename S::size_type pos = s.size(); typename S::size_type pos = s.size();
typename S::size_type n = S::traits_type::length(str); typename S::size_type n = S::traits_type::length(str);
assert(x <= pos && x + n <= s.size()); assert(x <= pos && x + n <= s.size());
} }
} }
▲ Show 20 Lines • Show All 131 Lines • Show Last 20 Lines

libcxx/test/std/strings/string.view/string.view.find/rfind_pointer_size_size.pass.cpp

Show All 14 Lines
#include "test_macros.h" #include "test_macros.h"
#include "constexpr_char_traits.h" #include "constexpr_char_traits.h"
template <class S> template <class S>
void void
test(const S& s, const typename S::value_type* str, typename S::size_type pos, test(const S& s, const typename S::value_type* str, typename S::size_type pos,
typename S::size_type n, typename S::size_type x) typename S::size_type n, typename S::size_type x)
{ {
LIBCPP_ASSERT_NOEXCEPT(s.rfind(str, pos, n));
assert(s.rfind(str, pos, n) == x); assert(s.rfind(str, pos, n) == x);
if (x != S::npos) if (x != S::npos)
assert(x <= pos && x + n <= s.size()); assert(x <= pos && x + n <= s.size());
} }
template <class S> template <class S>
void test0() void test0()
{ {
▲ Show 20 Lines • Show All 364 Lines • Show Last 20 Lines

libcxx/test/std/strings/string.view/string.view.find/rfind_string_view_size.pass.cpp

Show All 14 Lines
#include "test_macros.h" #include "test_macros.h"
#include "constexpr_char_traits.h" #include "constexpr_char_traits.h"
template <class S> template <class S>
void void
test(const S& s, const S& str, typename S::size_type pos, typename S::size_type x) test(const S& s, const S& str, typename S::size_type pos, typename S::size_type x)
{ {
LIBCPP_ASSERT_NOEXCEPT(s.rfind(str, pos));
assert(s.rfind(str, pos) == x); assert(s.rfind(str, pos) == x);
if (x != S::npos) if (x != S::npos)
assert(x <= pos && x + str.size() <= s.size()); assert(x <= pos && x + str.size() <= s.size());
} }
template <class S> template <class S>
void void
test(const S& s, const S& str, typename S::size_type x) test(const S& s, const S& str, typename S::size_type x)
{ {
LIBCPP_ASSERT_NOEXCEPT(s.rfind(str));
assert(s.rfind(str) == x); assert(s.rfind(str) == x);
if (x != S::npos) if (x != S::npos)
assert(0 <= x && x + str.size() <= s.size()); assert(0 <= x && x + str.size() <= s.size());
} }
template <class S> template <class S>
void test0() void test0()
{ {
▲ Show 20 Lines • Show All 127 Lines • Show Last 20 Lines