This is an archive of the discontinued LLVM Phabricator instance.

Differential D72640

[libcxx] Qualify make_pair in searcher implementations to prevent ADL
ClosedPublic

Authored by logan-5 on Jan 13 2020, 12:37 PM.

Details

Reviewers
mclow.lists
EricWF
Group Reviewers
Restricted Project
Commits
rG5b4a98eb58aa: [libcxx] Qualify make_pair in searcher implementations to prevent ADL
Summary

This patch adds _VSTD:: to some calls to make_pair inside the implementations of searchers, to prevent things exploding if there is a make_pair in an associated namespace of a user-defined type. https://godbolt.org/z/xAFG98

I didn't fix (or add tests to) the Boyer-Moore or Boyer-Moore-Horspool searchers in experimental/, since I couldn't get those to work with user-defined types at all. After defining the hash function properly, there seems to be an issue with a vector<value_type> __scratch in a helper function that I don't understand. See https://godbolt.org/z/heJ75B -- the same code works with libstdc++. If this is a separate issue, I'd be happy to write up a bug. (Also, I don't even know... is the experimental/ stuff still actively supported/bugfixed/etc?)

I did, however, add tests to the regular (currently XFAILed) BM and BMH tests in utilities.

I found this (and a couple other issues, patches forthcoming) by running https://reviews.llvm.org/D72282 over libc++ locally.

Diff Detail

Event Timeline

logan-5 created this revision.Jan 13 2020, 12:37 PM
Herald added subscribers: libcxx-commits, ldionne, christof. · View Herald TranscriptJan 13 2020, 12:37 PM
• Quuxplusone added a comment.Jan 13 2020, 2:30 PM

there seems to be an issue with a vector<value_type> __scratch in a helper function that I don't understand

My relatively uneducated guess is that it should have been a vector<size_t> __scratch all along. If you make that change, then your test case compiles. Also, if you're searching in a string of char, then char is smaller than size_t and bad stuff happens:
https://godbolt.org/z/i52zkN triggers an assertion failure corrupted size vs. prev_size and I can't even figure out where that message is coming from!

logan-5 updated this revision to Diff 238615.Jan 16 2020, 2:07 PM

Fixed some wrong author information in the patch.

EricWF accepted this revision.Jan 17 2020, 12:14 PM

I don't know that you needed to duplicate all the tests, but this works for me.

LGTM.

libcxx/test/std/utilities/function.objects/func.search/func.search.bmh/pred.pass.cpp
70

delete;

This revision is now accepted and ready to land.Jan 17 2020, 12:14 PM
logan-5 marked an inline comment as done.Jan 22 2020, 10:33 AM

Thanks. In that case I'll need help committing this.

libcxx/test/std/utilities/function.objects/func.search/func.search.bmh/pred.pass.cpp
70

What's the advantage of = delete;ing this function versus what I've done here?

• Quuxplusone added a comment.Feb 6 2020, 11:19 AM

@EricWF ping! (@logan-5 says he needs someone to land this patch, and I think that's you.)

@logan-5, you mentioned that you have found other cases of unintended ADL by applying the clang-tidy check in D72282, right? But those patches have not yet been uploaded to Phab? Is there any help I can offer that would advance that work?

logan-5 added a comment.Feb 6 2020, 12:10 PM
In D72640#1862239, @Quuxplusone wrote:

@logan-5, you mentioned that you have found other cases of unintended ADL by applying the clang-tidy check in D72282, right? But those patches have not yet been uploaded to Phab? Is there any help I can offer that would advance that work?

Hi @Quuxplusone, thanks a lot for the ping. I did indeed promise more patches for more cases found by that clang-tidy check, but I haven't gotten a chance to implement them yet. I think I was waiting for this one to land completely for some reason.

I think I'll be able to get to it this weekend... unless somebody beats me to it. :)

logan-5 added a comment.May 5 2020, 4:26 PM

Pinging this again.

Herald added a reviewer: Restricted Project. · View Herald TranscriptMay 5 2020, 4:26 PM
Herald added a subscriber: broadwaylamb. · View Herald Transcript
This revision now requires review to proceed.May 5 2020, 4:26 PM
EricWF requested changes to this revision.May 5 2020, 6:00 PM

There are some simplifications suggested in the inline comments.
Once those are addressed, this LGTM.

libcxx/test/std/algorithms/alg.nonmodifying/alg.search/search.pass.cpp
51

Please add a single additional test for each function that was fixed.
Separation of test concerns is better than carpet bombing the tests to prevent ADL,
and it makes the added test more understandable.

Once that's done this diff should be much smaller than it currently is.

63

Make this a non-member.

69

= delete

This revision now requires changes to proceed.May 5 2020, 6:00 PM
logan-5 updated this revision to Diff 262308.May 6 2020, 1:06 AM
logan-5 marked 5 inline comments as done.

Pruned down tests to the essentials.

libcxx/test/std/algorithms/alg.nonmodifying/alg.search/search.pass.cpp
63

No problem, but curious about the reason.

69

Also curious. This doesn't seem like it makes much of a difference, although I suppose = delete communicates better that we don't intend to call this in the tests anywhere.

Harbormaster failed remote builds in B55896: Diff 262308!May 6 2020, 2:07 AM
logan-5 updated this revision to Diff 262412.May 6 2020, 10:19 AM

Formatting.

logan-5 marked an inline comment as done.May 6 2020, 10:21 AM
logan-5 added inline comments.
libcxx/test/std/algorithms/alg.nonmodifying/alg.search/search.pass.cpp
113

I used this formatting (and the rest of the formatting in this diff) to be consistent with the pre-existing surrounding code in this file. The clang-tidy lint check is complaining here though. Is it more important to make those checks pass, or be consistent with the surrounding file? Genuine question.

Harbormaster failed remote builds in B55950: Diff 262412!May 6 2020, 11:20 AM
EricWF accepted this revision.May 6 2020, 1:28 PM

LGTM.

Thanks!

This revision is now accepted and ready to land.May 6 2020, 1:28 PM
logan-5 added a comment.May 6 2020, 3:25 PM

Thanks. I'll need committing help, if this is good to go.

ldionne added a comment.May 7 2020, 8:57 AM

Thanks for the patch! Committed as

commit 5b4a98eb58aa7672bbdc5e31e573f8f1220fc9c7
Author: Logan Smith <logan.r.smith0@gmail.com>
Date:   Thu May 7 11:54:25 2020 -0400

    [libcxx] Qualify make_pair in searcher implementations to prevent ADL

    This patch adds `_VSTD::` to some calls to `make_pair` inside the
    implementations of searchers, to prevent things exploding if there is
    a make_pair in an associated namespace of a user-defined type.
    https://godbolt.org/z/xAFG98

    Differential Revision: https://reviews.llvm.org/D72640
Closed by commit rG5b4a98eb58aa: [libcxx] Qualify make_pair in searcher implementations to prevent ADL (authored by logan-5, committed by ldionne). · Explain WhyMay 7 2020, 9:05 AM
This revision was automatically updated to reflect the committed changes.
rprichard mentioned this in D139380: [libc++][Android] Rename user NS to User to avoid conflict with struct.Dec 5 2022, 4:50 PM

Revision Contents

PathSize
libcxx/
include/
16 lines
test/
std/
algorithms/
alg.nonmodifying/
alg.search/
63 lines
experimental/
func/
func.searchers/
func.searchers.default/
63 lines
59 lines
utilities/
function.objects/
func.search/
func.search.bm/
88 lines
74 lines
76 lines
79 lines
func.search.bmh/
88 lines
74 lines
74 lines
79 lines
func.search.default/
63 lines
59 lines

Diff 238615

libcxx/include/functional

Show First 20 Lines • Show All 2,961 Lines • ▼ Show 20 Lines
template <class _BinaryPredicate, class _ForwardIterator1, class _ForwardIterator2> template <class _BinaryPredicate, class _ForwardIterator1, class _ForwardIterator2>
pair<_ForwardIterator1, _ForwardIterator1> _LIBCPP_CONSTEXPR_AFTER_CXX11 pair<_ForwardIterator1, _ForwardIterator1> _LIBCPP_CONSTEXPR_AFTER_CXX11
__search(_ForwardIterator1 __first1, _ForwardIterator1 __last1, __search(_ForwardIterator1 __first1, _ForwardIterator1 __last1,
_ForwardIterator2 __first2, _ForwardIterator2 __last2, _BinaryPredicate __pred, _ForwardIterator2 __first2, _ForwardIterator2 __last2, _BinaryPredicate __pred,
forward_iterator_tag, forward_iterator_tag) forward_iterator_tag, forward_iterator_tag)
{ {
if (__first2 == __last2) if (__first2 == __last2)
return make_pair(__first1, __first1); // Everything matches an empty sequence return _VSTD::make_pair(__first1, __first1); // Everything matches an empty sequence
while (true) while (true)
{ {
// Find first element in sequence 1 that matchs *__first2, with a mininum of loop checks // Find first element in sequence 1 that matchs *__first2, with a mininum of loop checks
while (true) while (true)
{ {
if (__first1 == __last1) // return __last1 if no element matches *__first2 if (__first1 == __last1) // return __last1 if no element matches *__first2
return make_pair(__last1, __last1); return _VSTD::make_pair(__last1, __last1);
if (__pred(*__first1, *__first2)) if (__pred(*__first1, *__first2))
break; break;
++__first1; ++__first1;
} }
// *__first1 matches *__first2, now match elements after here // *__first1 matches *__first2, now match elements after here
_ForwardIterator1 __m1 = __first1; _ForwardIterator1 __m1 = __first1;
_ForwardIterator2 __m2 = __first2; _ForwardIterator2 __m2 = __first2;
while (true) while (true)
{ {
if (++__m2 == __last2) // If pattern exhausted, __first1 is the answer (works for 1 element pattern) if (++__m2 == __last2) // If pattern exhausted, __first1 is the answer (works for 1 element pattern)
return make_pair(__first1, __m1); return _VSTD::make_pair(__first1, __m1);
if (++__m1 == __last1) // Otherwise if source exhaused, pattern not found if (++__m1 == __last1) // Otherwise if source exhaused, pattern not found
return make_pair(__last1, __last1); return _VSTD::make_pair(__last1, __last1);
if (!__pred(*__m1, *__m2)) // if there is a mismatch, restart with a new __first1 if (!__pred(*__m1, *__m2)) // if there is a mismatch, restart with a new __first1
{ {
++__first1; ++__first1;
break; break;
} // else there is a match, check next elements } // else there is a match, check next elements
} }
} }
} }
template <class _BinaryPredicate, class _RandomAccessIterator1, class _RandomAccessIterator2> template <class _BinaryPredicate, class _RandomAccessIterator1, class _RandomAccessIterator2>
_LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_CONSTEXPR_AFTER_CXX11
pair<_RandomAccessIterator1, _RandomAccessIterator1> pair<_RandomAccessIterator1, _RandomAccessIterator1>
__search(_RandomAccessIterator1 __first1, _RandomAccessIterator1 __last1, __search(_RandomAccessIterator1 __first1, _RandomAccessIterator1 __last1,
_RandomAccessIterator2 __first2, _RandomAccessIterator2 __last2, _BinaryPredicate __pred, _RandomAccessIterator2 __first2, _RandomAccessIterator2 __last2, _BinaryPredicate __pred,
random_access_iterator_tag, random_access_iterator_tag) random_access_iterator_tag, random_access_iterator_tag)
{ {
typedef typename iterator_traits<_RandomAccessIterator1>::difference_type _D1; typedef typename iterator_traits<_RandomAccessIterator1>::difference_type _D1;
typedef typename iterator_traits<_RandomAccessIterator2>::difference_type _D2; typedef typename iterator_traits<_RandomAccessIterator2>::difference_type _D2;
// Take advantage of knowing source and pattern lengths. Stop short when source is smaller than pattern // Take advantage of knowing source and pattern lengths. Stop short when source is smaller than pattern
const _D2 __len2 = __last2 - __first2; const _D2 __len2 = __last2 - __first2;
if (__len2 == 0) if (__len2 == 0)
return make_pair(__first1, __first1); return _VSTD::make_pair(__first1, __first1);
const _D1 __len1 = __last1 - __first1; const _D1 __len1 = __last1 - __first1;
if (__len1 < __len2) if (__len1 < __len2)
return make_pair(__last1, __last1); return _VSTD::make_pair(__last1, __last1);
const _RandomAccessIterator1 __s = __last1 - (__len2 - 1); // Start of pattern match can't go beyond here const _RandomAccessIterator1 __s = __last1 - (__len2 - 1); // Start of pattern match can't go beyond here
while (true) while (true)
{ {
while (true) while (true)
{ {
if (__first1 == __s) if (__first1 == __s)
return make_pair(__last1, __last1); return _VSTD::make_pair(__last1, __last1);
if (__pred(*__first1, *__first2)) if (__pred(*__first1, *__first2))
break; break;
++__first1; ++__first1;
} }
_RandomAccessIterator1 __m1 = __first1; _RandomAccessIterator1 __m1 = __first1;
_RandomAccessIterator2 __m2 = __first2; _RandomAccessIterator2 __m2 = __first2;
while (true) while (true)
{ {
if (++__m2 == __last2) if (++__m2 == __last2)
return make_pair(__first1, __first1 + __len2); return _VSTD::make_pair(__first1, __first1 + __len2);
++__m1; // no need to check range on __m1 because __s guarantees we have enough source ++__m1; // no need to check range on __m1 because __s guarantees we have enough source
if (!__pred(*__m1, *__m2)) if (!__pred(*__m1, *__m2))
{ {
++__first1; ++__first1;
break; break;
} }
} }
} }
▲ Show 20 Lines • Show All 54 Lines • Show Last 20 Lines

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

Show First 20 Lines • Show All 42 Lines • ▼ Show 20 Lines return (std::search(std::begin(ic), std::end(ic), std::begin(ia), std::end(ia)) == ic+3)
; ;
} }
#endif #endif
int searcher_called = 0; int searcher_called = 0;
struct MySearcher { struct MySearcher {
template <typename Iterator> template <typename Iterator>
std::pair<Iterator, Iterator> std::pair<Iterator, Iterator>
EricWFUnsubmitted
Done
ReplyInline Actions

Please add a single additional test for each function that was fixed.
Separation of test concerns is better than carpet bombing the tests to prevent ADL,
and it makes the added test more understandable.

Once that's done this diff should be much smaller than it currently is.

EricWF: Please add a single additional test for each function that was fixed. Separation of test…
operator() (Iterator b, Iterator e) const operator() (Iterator b, Iterator e) const
{ {
++searcher_called; ++searcher_called;
return std::make_pair(b, e); return std::make_pair(b, e);
} }
}; };
template <class Iter1, class Iter2> namespace User {
struct S {
S(int x) : x(x) {}
int x;
bool operator==(S other) const
EricWFUnsubmitted
Done
ReplyInline Actions

Make this a non-member.

EricWF: Make this a non-member.
logan-5AuthorUnsubmitted
Done
ReplyInline Actions

No problem, but curious about the reason.

logan-5: No problem, but curious about the reason.
{
return x == other.x;
}
};
template <class T, class U>
void make_pair(T&&, U&&) {}
EricWFUnsubmitted
Done
ReplyInline Actions

= delete

EricWF: `= delete`
logan-5AuthorUnsubmitted
Done
ReplyInline Actions

Also curious. This doesn't seem like it makes much of a difference, although I suppose = delete communicates better that we don't intend to call this in the tests anywhere.

logan-5: Also curious. This doesn't seem like it makes much of a difference, although I suppose `=…
} // namespace User
template <class T, class Iter1, class Iter2>
void void
test() test()
{ {
int ia[] = {0, 1, 2, 3, 4, 5}; T ia[] = {0, 1, 2, 3, 4, 5};
const unsigned sa = sizeof(ia)/sizeof(ia[0]); const unsigned sa = sizeof(ia)/sizeof(ia[0]);
assert(std::search(Iter1(ia), Iter1(ia+sa), Iter2(ia), Iter2(ia)) == Iter1(ia)); assert(std::search(Iter1(ia), Iter1(ia+sa), Iter2(ia), Iter2(ia)) == Iter1(ia));
assert(std::search(Iter1(ia), Iter1(ia+sa), Iter2(ia), Iter2(ia+1)) == Iter1(ia)); assert(std::search(Iter1(ia), Iter1(ia+sa), Iter2(ia), Iter2(ia+1)) == Iter1(ia));
assert(std::search(Iter1(ia), Iter1(ia+sa), Iter2(ia+1), Iter2(ia+2)) == Iter1(ia+1)); assert(std::search(Iter1(ia), Iter1(ia+sa), Iter2(ia+1), Iter2(ia+2)) == Iter1(ia+1));
assert(std::search(Iter1(ia), Iter1(ia+sa), Iter2(ia+2), Iter2(ia+2)) == Iter1(ia)); assert(std::search(Iter1(ia), Iter1(ia+sa), Iter2(ia+2), Iter2(ia+2)) == Iter1(ia));
assert(std::search(Iter1(ia), Iter1(ia+sa), Iter2(ia+2), Iter2(ia+3)) == Iter1(ia+2)); assert(std::search(Iter1(ia), Iter1(ia+sa), Iter2(ia+2), Iter2(ia+3)) == Iter1(ia+2));
assert(std::search(Iter1(ia), Iter1(ia+sa), Iter2(ia+2), Iter2(ia+3)) == Iter1(ia+2)); assert(std::search(Iter1(ia), Iter1(ia+sa), Iter2(ia+2), Iter2(ia+3)) == Iter1(ia+2));
assert(std::search(Iter1(ia), Iter1(ia), Iter2(ia+2), Iter2(ia+3)) == Iter1(ia)); assert(std::search(Iter1(ia), Iter1(ia), Iter2(ia+2), Iter2(ia+3)) == Iter1(ia));
assert(std::search(Iter1(ia), Iter1(ia+sa), Iter2(ia+sa-1), Iter2(ia+sa)) == Iter1(ia+sa-1)); assert(std::search(Iter1(ia), Iter1(ia+sa), Iter2(ia+sa-1), Iter2(ia+sa)) == Iter1(ia+sa-1));
assert(std::search(Iter1(ia), Iter1(ia+sa), Iter2(ia+sa-3), Iter2(ia+sa)) == Iter1(ia+sa-3)); assert(std::search(Iter1(ia), Iter1(ia+sa), Iter2(ia+sa-3), Iter2(ia+sa)) == Iter1(ia+sa-3));
assert(std::search(Iter1(ia), Iter1(ia+sa), Iter2(ia), Iter2(ia+sa)) == Iter1(ia)); assert(std::search(Iter1(ia), Iter1(ia+sa), Iter2(ia), Iter2(ia+sa)) == Iter1(ia));
assert(std::search(Iter1(ia), Iter1(ia+sa-1), Iter2(ia), Iter2(ia+sa)) == Iter1(ia+sa-1)); assert(std::search(Iter1(ia), Iter1(ia+sa-1), Iter2(ia), Iter2(ia+sa)) == Iter1(ia+sa-1));
assert(std::search(Iter1(ia), Iter1(ia+1), Iter2(ia), Iter2(ia+sa)) == Iter1(ia+1)); assert(std::search(Iter1(ia), Iter1(ia+1), Iter2(ia), Iter2(ia+sa)) == Iter1(ia+1));
int ib[] = {0, 1, 2, 0, 1, 2, 3, 0, 1, 2, 3, 4}; T ib[] = {0, 1, 2, 0, 1, 2, 3, 0, 1, 2, 3, 4};
const unsigned sb = sizeof(ib)/sizeof(ib[0]); const unsigned sb = sizeof(ib)/sizeof(ib[0]);
int ic[] = {1}; T ic[] = {1};
assert(std::search(Iter1(ib), Iter1(ib+sb), Iter2(ic), Iter2(ic+1)) == Iter1(ib+1)); assert(std::search(Iter1(ib), Iter1(ib+sb), Iter2(ic), Iter2(ic+1)) == Iter1(ib+1));
int id[] = {1, 2}; T id[] = {1, 2};
assert(std::search(Iter1(ib), Iter1(ib+sb), Iter2(id), Iter2(id+2)) == Iter1(ib+1)); assert(std::search(Iter1(ib), Iter1(ib+sb), Iter2(id), Iter2(id+2)) == Iter1(ib+1));
int ie[] = {1, 2, 3}; T ie[] = {1, 2, 3};
assert(std::search(Iter1(ib), Iter1(ib+sb), Iter2(ie), Iter2(ie+3)) == Iter1(ib+4)); assert(std::search(Iter1(ib), Iter1(ib+sb), Iter2(ie), Iter2(ie+3)) == Iter1(ib+4));
int ig[] = {1, 2, 3, 4}; T ig[] = {1, 2, 3, 4};
assert(std::search(Iter1(ib), Iter1(ib+sb), Iter2(ig), Iter2(ig+4)) == Iter1(ib+8)); assert(std::search(Iter1(ib), Iter1(ib+sb), Iter2(ig), Iter2(ig+4)) == Iter1(ib+8));
int ih[] = {0, 1, 1, 1, 1, 2, 3, 0, 1, 2, 3, 4}; T ih[] = {0, 1, 1, 1, 1, 2, 3, 0, 1, 2, 3, 4};
const unsigned sh = sizeof(ih)/sizeof(ih[0]); const unsigned sh = sizeof(ih)/sizeof(ih[0]);
int ii[] = {1, 1, 2}; T ii[] = {1, 1, 2};
assert(std::search(Iter1(ih), Iter1(ih+sh), Iter2(ii), Iter2(ii+3)) == Iter1(ih+3)); assert(std::search(Iter1(ih), Iter1(ih+sh), Iter2(ii), Iter2(ii+3)) == Iter1(ih+3));
int ij[] = {0, 1, 0, 0, 1, 0, 0, 0, 0, 0, 1, 1, 1, 1, 0, 0}; T ij[] = {0, 1, 0, 0, 1, 0, 0, 0, 0, 0, 1, 1, 1, 1, 0, 0};
const unsigned sj = sizeof(ij)/sizeof(ij[0]); const unsigned sj = sizeof(ij)/sizeof(ij[0]);
int ik[] = {0, 0, 0, 0, 1, 1, 1, 1, 0, 0}; T ik[] = {0, 0, 0, 0, 1, 1, 1, 1, 0, 0};
const unsigned sk = sizeof(ik)/sizeof(ik[0]); const unsigned sk = sizeof(ik)/sizeof(ik[0]);
assert(std::search(Iter1(ij), Iter1(ij+sj), Iter2(ik), Iter2(ik+sk)) == Iter1(ij+6)); assert(std::search(Iter1(ij), Iter1(ij+sj), Iter2(ik), Iter2(ik+sk)) == Iter1(ij+6));
} }
int main(int, char**) int main(int, char**)
{ {
test<forward_iterator<const int*>, forward_iterator<const int*> >(); test<int, forward_iterator<const int*>, forward_iterator<const int*> >();
logan-5AuthorUnsubmitted
Done
ReplyInline Actions

I used this formatting (and the rest of the formatting in this diff) to be consistent with the pre-existing surrounding code in this file. The clang-tidy lint check is complaining here though. Is it more important to make those checks pass, or be consistent with the surrounding file? Genuine question.

logan-5: I used this formatting (and the rest of the formatting in this diff) to be consistent with the…
test<forward_iterator<const int*>, bidirectional_iterator<const int*> >(); test<int, forward_iterator<const int*>, bidirectional_iterator<const int*> >();
test<forward_iterator<const int*>, random_access_iterator<const int*> >(); test<int, forward_iterator<const int*>, random_access_iterator<const int*> >();
test<bidirectional_iterator<const int*>, forward_iterator<const int*> >(); test<int, bidirectional_iterator<const int*>, forward_iterator<const int*> >();
test<bidirectional_iterator<const int*>, bidirectional_iterator<const int*> >(); test<int, bidirectional_iterator<const int*>, bidirectional_iterator<const int*> >();
test<bidirectional_iterator<const int*>, random_access_iterator<const int*> >(); test<int, bidirectional_iterator<const int*>, random_access_iterator<const int*> >();
test<random_access_iterator<const int*>, forward_iterator<const int*> >(); test<int, random_access_iterator<const int*>, forward_iterator<const int*> >();
test<random_access_iterator<const int*>, bidirectional_iterator<const int*> >(); test<int, random_access_iterator<const int*>, bidirectional_iterator<const int*> >();
test<random_access_iterator<const int*>, random_access_iterator<const int*> >(); test<int, random_access_iterator<const int*>, random_access_iterator<const int*> >();
test<User::S, forward_iterator<const User::S*>, forward_iterator<const User::S*> >();
test<User::S, forward_iterator<const User::S*>, bidirectional_iterator<const User::S*> >();
test<User::S, forward_iterator<const User::S*>, random_access_iterator<const User::S*> >();
test<User::S, bidirectional_iterator<const User::S*>, forward_iterator<const User::S*> >();
test<User::S, bidirectional_iterator<const User::S*>, bidirectional_iterator<const User::S*> >();
test<User::S, bidirectional_iterator<const User::S*>, random_access_iterator<const User::S*> >();
test<User::S, random_access_iterator<const User::S*>, forward_iterator<const User::S*> >();
test<User::S, random_access_iterator<const User::S*>, bidirectional_iterator<const User::S*> >();
test<User::S, random_access_iterator<const User::S*>, random_access_iterator<const User::S*> >();
#if TEST_STD_VER > 14 #if TEST_STD_VER > 14
{ {
typedef int * RI; typedef int * RI;
static_assert((std::is_same<RI, decltype(std::search(RI(), RI(), MySearcher()))>::value), "" ); static_assert((std::is_same<RI, decltype(std::search(RI(), RI(), MySearcher()))>::value), "" );
RI it(nullptr); RI it(nullptr);
assert(it == std::search(it, it, MySearcher())); assert(it == std::search(it, it, MySearcher()));
Show All 10 Lines

libcxx/test/std/experimental/func/func.searchers/func.searchers.default/default.pass.cpp

Show All 38 Lines
#include "test_iterators.h" #include "test_iterators.h"
template <typename Iter1, typename Iter2> template <typename Iter1, typename Iter2>
void do_search(Iter1 b1, Iter1 e1, Iter2 b2, Iter2 e2, Iter1 result) { void do_search(Iter1 b1, Iter1 e1, Iter2 b2, Iter2 e2, Iter1 result) {
std::experimental::default_searcher<Iter2> s{b2, e2}; std::experimental::default_searcher<Iter2> s{b2, e2};
assert(result == std::experimental::search(b1, e1, s)); assert(result == std::experimental::search(b1, e1, s));
} }
template <class Iter1, class Iter2> namespace User {
struct S {
S(int x) : x(x) {}
int x;
bool operator==(S other) const
{
return x == other.x;
}
};
template <class T, class U>
void make_pair(T&&, U&&) {}
} // namespace User
template <class T, class Iter1, class Iter2>
void void
test() test()
{ {
int ia[] = {0, 1, 2, 3, 4, 5}; T ia[] = {0, 1, 2, 3, 4, 5};
const unsigned sa = sizeof(ia)/sizeof(ia[0]); const unsigned sa = sizeof(ia)/sizeof(ia[0]);
do_search(Iter1(ia), Iter1(ia+sa), Iter2(ia), Iter2(ia), Iter1(ia)); do_search(Iter1(ia), Iter1(ia+sa), Iter2(ia), Iter2(ia), Iter1(ia));
do_search(Iter1(ia), Iter1(ia+sa), Iter2(ia), Iter2(ia+1), Iter1(ia)); do_search(Iter1(ia), Iter1(ia+sa), Iter2(ia), Iter2(ia+1), Iter1(ia));
do_search(Iter1(ia), Iter1(ia+sa), Iter2(ia+1), Iter2(ia+2), Iter1(ia+1)); do_search(Iter1(ia), Iter1(ia+sa), Iter2(ia+1), Iter2(ia+2), Iter1(ia+1));
do_search(Iter1(ia), Iter1(ia+sa), Iter2(ia+2), Iter2(ia+2), Iter1(ia)); do_search(Iter1(ia), Iter1(ia+sa), Iter2(ia+2), Iter2(ia+2), Iter1(ia));
do_search(Iter1(ia), Iter1(ia+sa), Iter2(ia+2), Iter2(ia+3), Iter1(ia+2)); do_search(Iter1(ia), Iter1(ia+sa), Iter2(ia+2), Iter2(ia+3), Iter1(ia+2));
do_search(Iter1(ia), Iter1(ia+sa), Iter2(ia+2), Iter2(ia+3), Iter1(ia+2)); do_search(Iter1(ia), Iter1(ia+sa), Iter2(ia+2), Iter2(ia+3), Iter1(ia+2));
do_search(Iter1(ia), Iter1(ia), Iter2(ia+2), Iter2(ia+3), Iter1(ia)); do_search(Iter1(ia), Iter1(ia), Iter2(ia+2), Iter2(ia+3), Iter1(ia));
do_search(Iter1(ia), Iter1(ia+sa), Iter2(ia+sa-1), Iter2(ia+sa), Iter1(ia+sa-1)); do_search(Iter1(ia), Iter1(ia+sa), Iter2(ia+sa-1), Iter2(ia+sa), Iter1(ia+sa-1));
do_search(Iter1(ia), Iter1(ia+sa), Iter2(ia+sa-3), Iter2(ia+sa), Iter1(ia+sa-3)); do_search(Iter1(ia), Iter1(ia+sa), Iter2(ia+sa-3), Iter2(ia+sa), Iter1(ia+sa-3));
do_search(Iter1(ia), Iter1(ia+sa), Iter2(ia), Iter2(ia+sa), Iter1(ia)); do_search(Iter1(ia), Iter1(ia+sa), Iter2(ia), Iter2(ia+sa), Iter1(ia));
do_search(Iter1(ia), Iter1(ia+sa-1), Iter2(ia), Iter2(ia+sa), Iter1(ia+sa-1)); do_search(Iter1(ia), Iter1(ia+sa-1), Iter2(ia), Iter2(ia+sa), Iter1(ia+sa-1));
do_search(Iter1(ia), Iter1(ia+1), Iter2(ia), Iter2(ia+sa), Iter1(ia+1)); do_search(Iter1(ia), Iter1(ia+1), Iter2(ia), Iter2(ia+sa), Iter1(ia+1));
int ib[] = {0, 1, 2, 0, 1, 2, 3, 0, 1, 2, 3, 4}; T ib[] = {0, 1, 2, 0, 1, 2, 3, 0, 1, 2, 3, 4};
const unsigned sb = sizeof(ib)/sizeof(ib[0]); const unsigned sb = sizeof(ib)/sizeof(ib[0]);
int ic[] = {1}; T ic[] = {1};
do_search(Iter1(ib), Iter1(ib+sb), Iter2(ic), Iter2(ic+1), Iter1(ib+1)); do_search(Iter1(ib), Iter1(ib+sb), Iter2(ic), Iter2(ic+1), Iter1(ib+1));
int id[] = {1, 2}; T id[] = {1, 2};
do_search(Iter1(ib), Iter1(ib+sb), Iter2(id), Iter2(id+2), Iter1(ib+1)); do_search(Iter1(ib), Iter1(ib+sb), Iter2(id), Iter2(id+2), Iter1(ib+1));
int ie[] = {1, 2, 3}; T ie[] = {1, 2, 3};
do_search(Iter1(ib), Iter1(ib+sb), Iter2(ie), Iter2(ie+3), Iter1(ib+4)); do_search(Iter1(ib), Iter1(ib+sb), Iter2(ie), Iter2(ie+3), Iter1(ib+4));
int ig[] = {1, 2, 3, 4}; T ig[] = {1, 2, 3, 4};
do_search(Iter1(ib), Iter1(ib+sb), Iter2(ig), Iter2(ig+4), Iter1(ib+8)); do_search(Iter1(ib), Iter1(ib+sb), Iter2(ig), Iter2(ig+4), Iter1(ib+8));
int ih[] = {0, 1, 1, 1, 1, 2, 3, 0, 1, 2, 3, 4}; T ih[] = {0, 1, 1, 1, 1, 2, 3, 0, 1, 2, 3, 4};
const unsigned sh = sizeof(ih)/sizeof(ih[0]); const unsigned sh = sizeof(ih)/sizeof(ih[0]);
int ii[] = {1, 1, 2}; T ii[] = {1, 1, 2};
do_search(Iter1(ih), Iter1(ih+sh), Iter2(ii), Iter2(ii+3), Iter1(ih+3)); do_search(Iter1(ih), Iter1(ih+sh), Iter2(ii), Iter2(ii+3), Iter1(ih+3));
int ij[] = {0, 1, 0, 0, 1, 0, 0, 0, 0, 0, 1, 1, 1, 1, 0, 0}; T ij[] = {0, 1, 0, 0, 1, 0, 0, 0, 0, 0, 1, 1, 1, 1, 0, 0};
const unsigned sj = sizeof(ij)/sizeof(ij[0]); const unsigned sj = sizeof(ij)/sizeof(ij[0]);
int ik[] = {0, 0, 0, 0, 1, 1, 1, 1, 0, 0}; T ik[] = {0, 0, 0, 0, 1, 1, 1, 1, 0, 0};
const unsigned sk = sizeof(ik)/sizeof(ik[0]); const unsigned sk = sizeof(ik)/sizeof(ik[0]);
do_search(Iter1(ij), Iter1(ij+sj), Iter2(ik), Iter2(ik+sk), Iter1(ij+6)); do_search(Iter1(ij), Iter1(ij+sj), Iter2(ik), Iter2(ik+sk), Iter1(ij+6));
} }
int main(int, char**) { int main(int, char**) {
test<forward_iterator<const int*>, forward_iterator<const int*> >(); test<int, forward_iterator<const int*>, forward_iterator<const int*> >();
test<forward_iterator<const int*>, bidirectional_iterator<const int*> >(); test<int, forward_iterator<const int*>, bidirectional_iterator<const int*> >();
test<forward_iterator<const int*>, random_access_iterator<const int*> >(); test<int, forward_iterator<const int*>, random_access_iterator<const int*> >();
test<bidirectional_iterator<const int*>, forward_iterator<const int*> >(); test<int, bidirectional_iterator<const int*>, forward_iterator<const int*> >();
test<bidirectional_iterator<const int*>, bidirectional_iterator<const int*> >(); test<int, bidirectional_iterator<const int*>, bidirectional_iterator<const int*> >();
test<bidirectional_iterator<const int*>, random_access_iterator<const int*> >(); test<int, bidirectional_iterator<const int*>, random_access_iterator<const int*> >();
test<random_access_iterator<const int*>, forward_iterator<const int*> >(); test<int, random_access_iterator<const int*>, forward_iterator<const int*> >();
test<random_access_iterator<const int*>, bidirectional_iterator<const int*> >(); test<int, random_access_iterator<const int*>, bidirectional_iterator<const int*> >();
test<random_access_iterator<const int*>, random_access_iterator<const int*> >(); test<int, random_access_iterator<const int*>, random_access_iterator<const int*> >();
test<User::S, forward_iterator<const User::S*>, forward_iterator<const User::S*> >();
test<User::S, forward_iterator<const User::S*>, bidirectional_iterator<const User::S*> >();
test<User::S, forward_iterator<const User::S*>, random_access_iterator<const User::S*> >();
test<User::S, bidirectional_iterator<const User::S*>, forward_iterator<const User::S*> >();
test<User::S, bidirectional_iterator<const User::S*>, bidirectional_iterator<const User::S*> >();
test<User::S, bidirectional_iterator<const User::S*>, random_access_iterator<const User::S*> >();
test<User::S, random_access_iterator<const User::S*>, forward_iterator<const User::S*> >();
test<User::S, random_access_iterator<const User::S*>, bidirectional_iterator<const User::S*> >();
test<User::S, random_access_iterator<const User::S*>, random_access_iterator<const User::S*> >();
return 0; return 0;
} }

libcxx/test/std/experimental/func/func.searchers/func.searchers.default/default.pred.pass.cpp

Show First 20 Lines • Show All 50 Lines • ▼ Show 20 Lines
template <typename Iter1, typename Iter2> template <typename Iter1, typename Iter2>
void do_search(Iter1 b1, Iter1 e1, Iter2 b2, Iter2 e2, Iter1 result, unsigned max_count) { void do_search(Iter1 b1, Iter1 e1, Iter2 b2, Iter2 e2, Iter1 result, unsigned max_count) {
std::experimental::default_searcher<Iter2, count_equal> s{b2, e2}; std::experimental::default_searcher<Iter2, count_equal> s{b2, e2};
count_equal::count = 0; count_equal::count = 0;
assert(result == std::experimental::search(b1, e1, s)); assert(result == std::experimental::search(b1, e1, s));
assert(count_equal::count <= max_count); assert(count_equal::count <= max_count);
} }
template <class Iter1, class Iter2> namespace User {
struct S {
S(int x) : x(x) {}
int x;
bool operator==(S other) const
{
return x == other.x;
}
};
template <class T, class U>
void make_pair(T&&, U&&) {}
} // namespace User
template <class T, class Iter1, class Iter2>
void void
test() test()
{ {
int ia[] = {0, 1, 2, 3, 4, 5}; T ia[] = {0, 1, 2, 3, 4, 5};
const unsigned sa = sizeof(ia)/sizeof(ia[0]); const unsigned sa = sizeof(ia)/sizeof(ia[0]);
do_search(Iter1(ia), Iter1(ia+sa), Iter2(ia), Iter2(ia), Iter1(ia), 0); do_search(Iter1(ia), Iter1(ia+sa), Iter2(ia), Iter2(ia), Iter1(ia), 0);
do_search(Iter1(ia), Iter1(ia+sa), Iter2(ia), Iter2(ia+1), Iter1(ia), sa); do_search(Iter1(ia), Iter1(ia+sa), Iter2(ia), Iter2(ia+1), Iter1(ia), sa);
do_search(Iter1(ia), Iter1(ia+sa), Iter2(ia+1), Iter2(ia+2), Iter1(ia+1), sa); do_search(Iter1(ia), Iter1(ia+sa), Iter2(ia+1), Iter2(ia+2), Iter1(ia+1), sa);
do_search(Iter1(ia), Iter1(ia+sa), Iter2(ia+2), Iter2(ia+2), Iter1(ia), 0); do_search(Iter1(ia), Iter1(ia+sa), Iter2(ia+2), Iter2(ia+2), Iter1(ia), 0);
do_search(Iter1(ia), Iter1(ia+sa), Iter2(ia+2), Iter2(ia+3), Iter1(ia+2), sa); do_search(Iter1(ia), Iter1(ia+sa), Iter2(ia+2), Iter2(ia+3), Iter1(ia+2), sa);
do_search(Iter1(ia), Iter1(ia+sa), Iter2(ia+2), Iter2(ia+3), Iter1(ia+2), sa); do_search(Iter1(ia), Iter1(ia+sa), Iter2(ia+2), Iter2(ia+3), Iter1(ia+2), sa);
do_search(Iter1(ia), Iter1(ia), Iter2(ia+2), Iter2(ia+3), Iter1(ia), 0); do_search(Iter1(ia), Iter1(ia), Iter2(ia+2), Iter2(ia+3), Iter1(ia), 0);
do_search(Iter1(ia), Iter1(ia+sa), Iter2(ia+sa-1), Iter2(ia+sa), Iter1(ia+sa-1), sa); do_search(Iter1(ia), Iter1(ia+sa), Iter2(ia+sa-1), Iter2(ia+sa), Iter1(ia+sa-1), sa);
do_search(Iter1(ia), Iter1(ia+sa), Iter2(ia+sa-3), Iter2(ia+sa), Iter1(ia+sa-3), 3*sa); do_search(Iter1(ia), Iter1(ia+sa), Iter2(ia+sa-3), Iter2(ia+sa), Iter1(ia+sa-3), 3*sa);
do_search(Iter1(ia), Iter1(ia+sa), Iter2(ia), Iter2(ia+sa), Iter1(ia), sa*sa); do_search(Iter1(ia), Iter1(ia+sa), Iter2(ia), Iter2(ia+sa), Iter1(ia), sa*sa);
do_search(Iter1(ia), Iter1(ia+sa-1), Iter2(ia), Iter2(ia+sa), Iter1(ia+sa-1), (sa-1)*sa); do_search(Iter1(ia), Iter1(ia+sa-1), Iter2(ia), Iter2(ia+sa), Iter1(ia+sa-1), (sa-1)*sa);
do_search(Iter1(ia), Iter1(ia+1), Iter2(ia), Iter2(ia+sa), Iter1(ia+1), sa); do_search(Iter1(ia), Iter1(ia+1), Iter2(ia), Iter2(ia+sa), Iter1(ia+1), sa);
int ib[] = {0, 1, 2, 0, 1, 2, 3, 0, 1, 2, 3, 4}; T ib[] = {0, 1, 2, 0, 1, 2, 3, 0, 1, 2, 3, 4};
const unsigned sb = sizeof(ib)/sizeof(ib[0]); const unsigned sb = sizeof(ib)/sizeof(ib[0]);
int ic[] = {1}; T ic[] = {1};
do_search(Iter1(ib), Iter1(ib+sb), Iter2(ic), Iter2(ic+1), Iter1(ib+1), sb); do_search(Iter1(ib), Iter1(ib+sb), Iter2(ic), Iter2(ic+1), Iter1(ib+1), sb);
int id[] = {1, 2}; T id[] = {1, 2};
do_search(Iter1(ib), Iter1(ib+sb), Iter2(id), Iter2(id+2), Iter1(ib+1), sb*2); do_search(Iter1(ib), Iter1(ib+sb), Iter2(id), Iter2(id+2), Iter1(ib+1), sb*2);
int ie[] = {1, 2, 3}; T ie[] = {1, 2, 3};
do_search(Iter1(ib), Iter1(ib+sb), Iter2(ie), Iter2(ie+3), Iter1(ib+4), sb*3); do_search(Iter1(ib), Iter1(ib+sb), Iter2(ie), Iter2(ie+3), Iter1(ib+4), sb*3);
int ig[] = {1, 2, 3, 4}; T ig[] = {1, 2, 3, 4};
do_search(Iter1(ib), Iter1(ib+sb), Iter2(ig), Iter2(ig+4), Iter1(ib+8), sb*4); do_search(Iter1(ib), Iter1(ib+sb), Iter2(ig), Iter2(ig+4), Iter1(ib+8), sb*4);
int ih[] = {0, 1, 1, 1, 1, 2, 3, 0, 1, 2, 3, 4}; T ih[] = {0, 1, 1, 1, 1, 2, 3, 0, 1, 2, 3, 4};
const unsigned sh = sizeof(ih)/sizeof(ih[0]); const unsigned sh = sizeof(ih)/sizeof(ih[0]);
int ii[] = {1, 1, 2}; T ii[] = {1, 1, 2};
do_search(Iter1(ih), Iter1(ih+sh), Iter2(ii), Iter2(ii+3), Iter1(ih+3), sh*3); do_search(Iter1(ih), Iter1(ih+sh), Iter2(ii), Iter2(ii+3), Iter1(ih+3), sh*3);
} }
int main(int, char**) { int main(int, char**) {
test<forward_iterator<const int*>, forward_iterator<const int*> >(); test<int, forward_iterator<const int*>, forward_iterator<const int*> >();
test<forward_iterator<const int*>, bidirectional_iterator<const int*> >(); test<int, forward_iterator<const int*>, bidirectional_iterator<const int*> >();
test<forward_iterator<const int*>, random_access_iterator<const int*> >(); test<int, forward_iterator<const int*>, random_access_iterator<const int*> >();
test<bidirectional_iterator<const int*>, forward_iterator<const int*> >(); test<int, bidirectional_iterator<const int*>, forward_iterator<const int*> >();
test<bidirectional_iterator<const int*>, bidirectional_iterator<const int*> >(); test<int, bidirectional_iterator<const int*>, bidirectional_iterator<const int*> >();
test<bidirectional_iterator<const int*>, random_access_iterator<const int*> >(); test<int, bidirectional_iterator<const int*>, random_access_iterator<const int*> >();
test<random_access_iterator<const int*>, forward_iterator<const int*> >(); test<int, random_access_iterator<const int*>, forward_iterator<const int*> >();
test<random_access_iterator<const int*>, bidirectional_iterator<const int*> >(); test<int, random_access_iterator<const int*>, bidirectional_iterator<const int*> >();
test<random_access_iterator<const int*>, random_access_iterator<const int*> >(); test<int, random_access_iterator<const int*>, random_access_iterator<const int*> >();
test<User::S, forward_iterator<const User::S*>, forward_iterator<const User::S*> >();
test<User::S, forward_iterator<const User::S*>, bidirectional_iterator<const User::S*> >();
test<User::S, forward_iterator<const User::S*>, random_access_iterator<const User::S*> >();
test<User::S, bidirectional_iterator<const User::S*>, forward_iterator<const User::S*> >();
test<User::S, bidirectional_iterator<const User::S*>, bidirectional_iterator<const User::S*> >();
test<User::S, bidirectional_iterator<const User::S*>, random_access_iterator<const User::S*> >();
test<User::S, random_access_iterator<const User::S*>, forward_iterator<const User::S*> >();
test<User::S, random_access_iterator<const User::S*>, bidirectional_iterator<const User::S*> >();
test<User::S, random_access_iterator<const User::S*>, random_access_iterator<const User::S*> >();
return 0; return 0;
} }

libcxx/test/std/utilities/function.objects/func.search/func.search.bm/default.pass.cpp

Show All 39 Lines
#include "test_iterators.h" #include "test_iterators.h"
template <typename Iter1, typename Iter2> template <typename Iter1, typename Iter2>
void do_search(Iter1 b1, Iter1 e1, Iter2 b2, Iter2 e2, Iter1 result) { void do_search(Iter1 b1, Iter1 e1, Iter2 b2, Iter2 e2, Iter1 result) {
std::boyer_moore_searcher<Iter2> s{b2, e2}; std::boyer_moore_searcher<Iter2> s{b2, e2};
assert(result == std::search(b1, e1, s)); assert(result == std::search(b1, e1, s));
} }
template <class Iter1, class Iter2> namespace User {
void struct S {
test() S(int x) : x(x) {}
int x;
bool operator==(S other) const
{ {
int ia[] = {0, 1, 2, 3, 4, 5}; return x == other.x;
const unsigned sa = sizeof(ia)/sizeof(ia[0]);
do_search(Iter1(ia), Iter1(ia+sa), Iter2(ia), Iter2(ia), Iter1(ia));
do_search(Iter1(ia), Iter1(ia+sa), Iter2(ia), Iter2(ia+1), Iter1(ia));
do_search(Iter1(ia), Iter1(ia+sa), Iter2(ia+1), Iter2(ia+2), Iter1(ia+1));
do_search(Iter1(ia), Iter1(ia+sa), Iter2(ia+2), Iter2(ia+2), Iter1(ia));
do_search(Iter1(ia), Iter1(ia+sa), Iter2(ia+2), Iter2(ia+3), Iter1(ia+2));
do_search(Iter1(ia), Iter1(ia+sa), Iter2(ia+2), Iter2(ia+3), Iter1(ia+2));
do_search(Iter1(ia), Iter1(ia), Iter2(ia+2), Iter2(ia+3), Iter1(ia));
do_search(Iter1(ia), Iter1(ia+sa), Iter2(ia+sa-1), Iter2(ia+sa), Iter1(ia+sa-1));
do_search(Iter1(ia), Iter1(ia+sa), Iter2(ia+sa-3), Iter2(ia+sa), Iter1(ia+sa-3));
do_search(Iter1(ia), Iter1(ia+sa), Iter2(ia), Iter2(ia+sa), Iter1(ia));
do_search(Iter1(ia), Iter1(ia+sa-1), Iter2(ia), Iter2(ia+sa), Iter1(ia+sa-1));
do_search(Iter1(ia), Iter1(ia+1), Iter2(ia), Iter2(ia+sa), Iter1(ia+1));
int ib[] = {0, 1, 2, 0, 1, 2, 3, 0, 1, 2, 3, 4};
const unsigned sb = sizeof(ib)/sizeof(ib[0]);
int ic[] = {1};
do_search(Iter1(ib), Iter1(ib+sb), Iter2(ic), Iter2(ic+1), Iter1(ib+1));
int id[] = {1, 2};
do_search(Iter1(ib), Iter1(ib+sb), Iter2(id), Iter2(id+2), Iter1(ib+1));
int ie[] = {1, 2, 3};
do_search(Iter1(ib), Iter1(ib+sb), Iter2(ie), Iter2(ie+3), Iter1(ib+4));
int ig[] = {1, 2, 3, 4};
do_search(Iter1(ib), Iter1(ib+sb), Iter2(ig), Iter2(ig+4), Iter1(ib+8));
int ih[] = {0, 1, 1, 1, 1, 2, 3, 0, 1, 2, 3, 4};
const unsigned sh = sizeof(ih)/sizeof(ih[0]);
int ii[] = {1, 1, 2};
do_search(Iter1(ih), Iter1(ih+sh), Iter2(ii), Iter2(ii+3), Iter1(ih+3));
int ij[] = {0, 1, 0, 0, 1, 0, 0, 0, 0, 0, 1, 1, 1, 1, 0, 0};
const unsigned sj = sizeof(ij)/sizeof(ij[0]);
int ik[] = {0, 0, 0, 0, 1, 1, 1, 1, 0, 0};
const unsigned sk = sizeof(ik)/sizeof(ik[0]);
do_search(Iter1(ij), Iter1(ij+sj), Iter2(ik), Iter2(ik+sk), Iter1(ij+6));
} }
};
template <class T, class U>
void make_pair(T&&, U&&) {}
} // namespace User
namespace std {
template <> struct hash<User::S> {
std::size_t operator()(const User::S& s) const
{
return s.x;
}
};
} // namespace std
template <class Iter1, class Iter2> template <class T, class Iter1, class Iter2>
void void
test2() test()
{ {
char ia[] = {0, 1, 2, 3, 4, 5}; T ia[] = {0, 1, 2, 3, 4, 5};
const unsigned sa = sizeof(ia)/sizeof(ia[0]); const unsigned sa = sizeof(ia)/sizeof(ia[0]);
do_search(Iter1(ia), Iter1(ia+sa), Iter2(ia), Iter2(ia), Iter1(ia)); do_search(Iter1(ia), Iter1(ia+sa), Iter2(ia), Iter2(ia), Iter1(ia));
do_search(Iter1(ia), Iter1(ia+sa), Iter2(ia), Iter2(ia+1), Iter1(ia)); do_search(Iter1(ia), Iter1(ia+sa), Iter2(ia), Iter2(ia+1), Iter1(ia));
do_search(Iter1(ia), Iter1(ia+sa), Iter2(ia+1), Iter2(ia+2), Iter1(ia+1)); do_search(Iter1(ia), Iter1(ia+sa), Iter2(ia+1), Iter2(ia+2), Iter1(ia+1));
do_search(Iter1(ia), Iter1(ia+sa), Iter2(ia+2), Iter2(ia+2), Iter1(ia)); do_search(Iter1(ia), Iter1(ia+sa), Iter2(ia+2), Iter2(ia+2), Iter1(ia));
do_search(Iter1(ia), Iter1(ia+sa), Iter2(ia+2), Iter2(ia+3), Iter1(ia+2)); do_search(Iter1(ia), Iter1(ia+sa), Iter2(ia+2), Iter2(ia+3), Iter1(ia+2));
do_search(Iter1(ia), Iter1(ia+sa), Iter2(ia+2), Iter2(ia+3), Iter1(ia+2)); do_search(Iter1(ia), Iter1(ia+sa), Iter2(ia+2), Iter2(ia+3), Iter1(ia+2));
do_search(Iter1(ia), Iter1(ia), Iter2(ia+2), Iter2(ia+3), Iter1(ia)); do_search(Iter1(ia), Iter1(ia), Iter2(ia+2), Iter2(ia+3), Iter1(ia));
do_search(Iter1(ia), Iter1(ia+sa), Iter2(ia+sa-1), Iter2(ia+sa), Iter1(ia+sa-1)); do_search(Iter1(ia), Iter1(ia+sa), Iter2(ia+sa-1), Iter2(ia+sa), Iter1(ia+sa-1));
do_search(Iter1(ia), Iter1(ia+sa), Iter2(ia+sa-3), Iter2(ia+sa), Iter1(ia+sa-3)); do_search(Iter1(ia), Iter1(ia+sa), Iter2(ia+sa-3), Iter2(ia+sa), Iter1(ia+sa-3));
do_search(Iter1(ia), Iter1(ia+sa), Iter2(ia), Iter2(ia+sa), Iter1(ia)); do_search(Iter1(ia), Iter1(ia+sa), Iter2(ia), Iter2(ia+sa), Iter1(ia));
do_search(Iter1(ia), Iter1(ia+sa-1), Iter2(ia), Iter2(ia+sa), Iter1(ia+sa-1)); do_search(Iter1(ia), Iter1(ia+sa-1), Iter2(ia), Iter2(ia+sa), Iter1(ia+sa-1));
do_search(Iter1(ia), Iter1(ia+1), Iter2(ia), Iter2(ia+sa), Iter1(ia+1)); do_search(Iter1(ia), Iter1(ia+1), Iter2(ia), Iter2(ia+sa), Iter1(ia+1));
char ib[] = {0, 1, 2, 0, 1, 2, 3, 0, 1, 2, 3, 4}; T ib[] = {0, 1, 2, 0, 1, 2, 3, 0, 1, 2, 3, 4};
const unsigned sb = sizeof(ib)/sizeof(ib[0]); const unsigned sb = sizeof(ib)/sizeof(ib[0]);
char ic[] = {1}; T ic[] = {1};
do_search(Iter1(ib), Iter1(ib+sb), Iter2(ic), Iter2(ic+1), Iter1(ib+1)); do_search(Iter1(ib), Iter1(ib+sb), Iter2(ic), Iter2(ic+1), Iter1(ib+1));
char id[] = {1, 2}; T id[] = {1, 2};
do_search(Iter1(ib), Iter1(ib+sb), Iter2(id), Iter2(id+2), Iter1(ib+1)); do_search(Iter1(ib), Iter1(ib+sb), Iter2(id), Iter2(id+2), Iter1(ib+1));
char ie[] = {1, 2, 3}; T ie[] = {1, 2, 3};
do_search(Iter1(ib), Iter1(ib+sb), Iter2(ie), Iter2(ie+3), Iter1(ib+4)); do_search(Iter1(ib), Iter1(ib+sb), Iter2(ie), Iter2(ie+3), Iter1(ib+4));
char ig[] = {1, 2, 3, 4}; T ig[] = {1, 2, 3, 4};
do_search(Iter1(ib), Iter1(ib+sb), Iter2(ig), Iter2(ig+4), Iter1(ib+8)); do_search(Iter1(ib), Iter1(ib+sb), Iter2(ig), Iter2(ig+4), Iter1(ib+8));
char ih[] = {0, 1, 1, 1, 1, 2, 3, 0, 1, 2, 3, 4}; T ih[] = {0, 1, 1, 1, 1, 2, 3, 0, 1, 2, 3, 4};
const unsigned sh = sizeof(ih)/sizeof(ih[0]); const unsigned sh = sizeof(ih)/sizeof(ih[0]);
char ii[] = {1, 1, 2}; T ii[] = {1, 1, 2};
do_search(Iter1(ih), Iter1(ih+sh), Iter2(ii), Iter2(ii+3), Iter1(ih+3)); do_search(Iter1(ih), Iter1(ih+sh), Iter2(ii), Iter2(ii+3), Iter1(ih+3));
char ij[] = {0, 1, 0, 0, 1, 0, 0, 0, 0, 0, 1, 1, 1, 1, 0, 0}; T ij[] = {0, 1, 0, 0, 1, 0, 0, 0, 0, 0, 1, 1, 1, 1, 0, 0};
const unsigned sj = sizeof(ij)/sizeof(ij[0]); const unsigned sj = sizeof(ij)/sizeof(ij[0]);
char ik[] = {0, 0, 0, 0, 1, 1, 1, 1, 0, 0}; T ik[] = {0, 0, 0, 0, 1, 1, 1, 1, 0, 0};
const unsigned sk = sizeof(ik)/sizeof(ik[0]); const unsigned sk = sizeof(ik)/sizeof(ik[0]);
do_search(Iter1(ij), Iter1(ij+sj), Iter2(ik), Iter2(ik+sk), Iter1(ij+6)); do_search(Iter1(ij), Iter1(ij+sj), Iter2(ik), Iter2(ik+sk), Iter1(ij+6));
} }
int main(int, char**) { int main(int, char**) {
test<random_access_iterator<const int*>, random_access_iterator<const int*> >(); test<int, random_access_iterator<const int*>, random_access_iterator<const int*> >();
test2<random_access_iterator<const char*>, random_access_iterator<const char*> >(); test<char, random_access_iterator<const char*>, random_access_iterator<const char*> >();
test<User::S, random_access_iterator<const User::S*>, random_access_iterator<const User::S*> >();
return 0; return 0;
} }

libcxx/test/std/utilities/function.objects/func.search/func.search.bm/hash.pass.cpp

Show First 20 Lines • Show All 45 Lines • ▼ Show 20 Lines
template <typename Iter1, typename Iter2> template <typename Iter1, typename Iter2>
void do_search(Iter1 b1, Iter1 e1, Iter2 b2, Iter2 e2, Iter1 result, unsigned /*max_count*/) { void do_search(Iter1 b1, Iter1 e1, Iter2 b2, Iter2 e2, Iter1 result, unsigned /*max_count*/) {
std::boyer_moore_searcher<Iter2, std::boyer_moore_searcher<Iter2,
MyHash<typename std::remove_cv<typename std::iterator_traits<Iter2>::value_type>::type>> MyHash<typename std::remove_cv<typename std::iterator_traits<Iter2>::value_type>::type>>
s{b2, e2}; s{b2, e2};
assert(result == std::search(b1, e1, s)); assert(result == std::search(b1, e1, s));
} }
template <class Iter1, class Iter2> namespace User {
void struct S {
test() S(int x) : x(x) {}
int x;
bool operator==(S other) const
{ {
int ia[] = {0, 1, 2, 3, 4, 5}; return x == other.x;
const unsigned sa = sizeof(ia)/sizeof(ia[0]); }
do_search(Iter1(ia), Iter1(ia+sa), Iter2(ia), Iter2(ia), Iter1(ia), 0); explicit operator size_t() const
do_search(Iter1(ia), Iter1(ia+sa), Iter2(ia), Iter2(ia+1), Iter1(ia), sa); {
do_search(Iter1(ia), Iter1(ia+sa), Iter2(ia+1), Iter2(ia+2), Iter1(ia+1), sa); return static_cast<size_t>(x);
do_search(Iter1(ia), Iter1(ia+sa), Iter2(ia+2), Iter2(ia+2), Iter1(ia), 0);
do_search(Iter1(ia), Iter1(ia+sa), Iter2(ia+2), Iter2(ia+3), Iter1(ia+2), sa);
do_search(Iter1(ia), Iter1(ia+sa), Iter2(ia+2), Iter2(ia+3), Iter1(ia+2), sa);
do_search(Iter1(ia), Iter1(ia), Iter2(ia+2), Iter2(ia+3), Iter1(ia), 0);
do_search(Iter1(ia), Iter1(ia+sa), Iter2(ia+sa-1), Iter2(ia+sa), Iter1(ia+sa-1), sa);
do_search(Iter1(ia), Iter1(ia+sa), Iter2(ia+sa-3), Iter2(ia+sa), Iter1(ia+sa-3), 3*sa);
do_search(Iter1(ia), Iter1(ia+sa), Iter2(ia), Iter2(ia+sa), Iter1(ia), sa*sa);
do_search(Iter1(ia), Iter1(ia+sa-1), Iter2(ia), Iter2(ia+sa), Iter1(ia+sa-1), (sa-1)*sa);
do_search(Iter1(ia), Iter1(ia+1), Iter2(ia), Iter2(ia+sa), Iter1(ia+1), sa);
int ib[] = {0, 1, 2, 0, 1, 2, 3, 0, 1, 2, 3, 4};
const unsigned sb = sizeof(ib)/sizeof(ib[0]);
int ic[] = {1};
do_search(Iter1(ib), Iter1(ib+sb), Iter2(ic), Iter2(ic+1), Iter1(ib+1), sb);
int id[] = {1, 2};
do_search(Iter1(ib), Iter1(ib+sb), Iter2(id), Iter2(id+2), Iter1(ib+1), sb*2);
int ie[] = {1, 2, 3};
do_search(Iter1(ib), Iter1(ib+sb), Iter2(ie), Iter2(ie+3), Iter1(ib+4), sb*3);
int ig[] = {1, 2, 3, 4};
do_search(Iter1(ib), Iter1(ib+sb), Iter2(ig), Iter2(ig+4), Iter1(ib+8), sb*4);
int ih[] = {0, 1, 1, 1, 1, 2, 3, 0, 1, 2, 3, 4};
const unsigned sh = sizeof(ih)/sizeof(ih[0]);
int ii[] = {1, 1, 2};
do_search(Iter1(ih), Iter1(ih+sh), Iter2(ii), Iter2(ii+3), Iter1(ih+3), sh*3);
} }
};
template <class T, class U>
void make_pair(T&&, U&&) {}
} // namespace User
template <class Iter1, class Iter2> template <class T, class Iter1, class Iter2>
void void
test2() test()
{ {
char ia[] = {0, 1, 2, 3, 4, 5}; T ia[] = {0, 1, 2, 3, 4, 5};
const unsigned sa = sizeof(ia)/sizeof(ia[0]); const unsigned sa = sizeof(ia)/sizeof(ia[0]);
do_search(Iter1(ia), Iter1(ia+sa), Iter2(ia), Iter2(ia), Iter1(ia), 0); do_search(Iter1(ia), Iter1(ia+sa), Iter2(ia), Iter2(ia), Iter1(ia), 0);
do_search(Iter1(ia), Iter1(ia+sa), Iter2(ia), Iter2(ia+1), Iter1(ia), sa); do_search(Iter1(ia), Iter1(ia+sa), Iter2(ia), Iter2(ia+1), Iter1(ia), sa);
do_search(Iter1(ia), Iter1(ia+sa), Iter2(ia+1), Iter2(ia+2), Iter1(ia+1), sa); do_search(Iter1(ia), Iter1(ia+sa), Iter2(ia+1), Iter2(ia+2), Iter1(ia+1), sa);
do_search(Iter1(ia), Iter1(ia+sa), Iter2(ia+2), Iter2(ia+2), Iter1(ia), 0); do_search(Iter1(ia), Iter1(ia+sa), Iter2(ia+2), Iter2(ia+2), Iter1(ia), 0);
do_search(Iter1(ia), Iter1(ia+sa), Iter2(ia+2), Iter2(ia+3), Iter1(ia+2), sa); do_search(Iter1(ia), Iter1(ia+sa), Iter2(ia+2), Iter2(ia+3), Iter1(ia+2), sa);
do_search(Iter1(ia), Iter1(ia+sa), Iter2(ia+2), Iter2(ia+3), Iter1(ia+2), sa); do_search(Iter1(ia), Iter1(ia+sa), Iter2(ia+2), Iter2(ia+3), Iter1(ia+2), sa);
do_search(Iter1(ia), Iter1(ia), Iter2(ia+2), Iter2(ia+3), Iter1(ia), 0); do_search(Iter1(ia), Iter1(ia), Iter2(ia+2), Iter2(ia+3), Iter1(ia), 0);
do_search(Iter1(ia), Iter1(ia+sa), Iter2(ia+sa-1), Iter2(ia+sa), Iter1(ia+sa-1), sa); do_search(Iter1(ia), Iter1(ia+sa), Iter2(ia+sa-1), Iter2(ia+sa), Iter1(ia+sa-1), sa);
do_search(Iter1(ia), Iter1(ia+sa), Iter2(ia+sa-3), Iter2(ia+sa), Iter1(ia+sa-3), 3*sa); do_search(Iter1(ia), Iter1(ia+sa), Iter2(ia+sa-3), Iter2(ia+sa), Iter1(ia+sa-3), 3*sa);
do_search(Iter1(ia), Iter1(ia+sa), Iter2(ia), Iter2(ia+sa), Iter1(ia), sa*sa); do_search(Iter1(ia), Iter1(ia+sa), Iter2(ia), Iter2(ia+sa), Iter1(ia), sa*sa);
do_search(Iter1(ia), Iter1(ia+sa-1), Iter2(ia), Iter2(ia+sa), Iter1(ia+sa-1), (sa-1)*sa); do_search(Iter1(ia), Iter1(ia+sa-1), Iter2(ia), Iter2(ia+sa), Iter1(ia+sa-1), (sa-1)*sa);
do_search(Iter1(ia), Iter1(ia+1), Iter2(ia), Iter2(ia+sa), Iter1(ia+1), sa); do_search(Iter1(ia), Iter1(ia+1), Iter2(ia), Iter2(ia+sa), Iter1(ia+1), sa);
char ib[] = {0, 1, 2, 0, 1, 2, 3, 0, 1, 2, 3, 4}; T ib[] = {0, 1, 2, 0, 1, 2, 3, 0, 1, 2, 3, 4};
const unsigned sb = sizeof(ib)/sizeof(ib[0]); const unsigned sb = sizeof(ib)/sizeof(ib[0]);
char ic[] = {1}; T ic[] = {1};
do_search(Iter1(ib), Iter1(ib+sb), Iter2(ic), Iter2(ic+1), Iter1(ib+1), sb); do_search(Iter1(ib), Iter1(ib+sb), Iter2(ic), Iter2(ic+1), Iter1(ib+1), sb);
char id[] = {1, 2}; T id[] = {1, 2};
do_search(Iter1(ib), Iter1(ib+sb), Iter2(id), Iter2(id+2), Iter1(ib+1), sb*2); do_search(Iter1(ib), Iter1(ib+sb), Iter2(id), Iter2(id+2), Iter1(ib+1), sb*2);
char ie[] = {1, 2, 3}; T ie[] = {1, 2, 3};
do_search(Iter1(ib), Iter1(ib+sb), Iter2(ie), Iter2(ie+3), Iter1(ib+4), sb*3); do_search(Iter1(ib), Iter1(ib+sb), Iter2(ie), Iter2(ie+3), Iter1(ib+4), sb*3);
char ig[] = {1, 2, 3, 4}; T ig[] = {1, 2, 3, 4};
do_search(Iter1(ib), Iter1(ib+sb), Iter2(ig), Iter2(ig+4), Iter1(ib+8), sb*4); do_search(Iter1(ib), Iter1(ib+sb), Iter2(ig), Iter2(ig+4), Iter1(ib+8), sb*4);
char ih[] = {0, 1, 1, 1, 1, 2, 3, 0, 1, 2, 3, 4}; T ih[] = {0, 1, 1, 1, 1, 2, 3, 0, 1, 2, 3, 4};
const unsigned sh = sizeof(ih)/sizeof(ih[0]); const unsigned sh = sizeof(ih)/sizeof(ih[0]);
char ii[] = {1, 1, 2}; T ii[] = {1, 1, 2};
do_search(Iter1(ih), Iter1(ih+sh), Iter2(ii), Iter2(ii+3), Iter1(ih+3), sh*3); do_search(Iter1(ih), Iter1(ih+sh), Iter2(ii), Iter2(ii+3), Iter1(ih+3), sh*3);
} }
int main(int, char**) { int main(int, char**) {
test<random_access_iterator<const int*>, random_access_iterator<const int*> >(); test<int, random_access_iterator<const int*>, random_access_iterator<const int*> >();
test2<random_access_iterator<const char*>, random_access_iterator<const char*> >(); test<char, random_access_iterator<const char*>, random_access_iterator<const char*> >();
test<User::S, random_access_iterator<const User::S*>, random_access_iterator<const User::S*> >();
return 0; return 0;
} }

libcxx/test/std/utilities/function.objects/func.search/func.search.bm/hash.pred.pass.cpp

Show First 20 Lines • Show All 58 Lines • ▼ Show 20 Lines std::boyer_moore_searcher<Iter2,
MyHash<typename std::remove_cv<typename std::iterator_traits<Iter2>::value_type>::type>, MyHash<typename std::remove_cv<typename std::iterator_traits<Iter2>::value_type>::type>,
count_equal> count_equal>
s{b2, e2}; s{b2, e2};
count_equal::count = 0; count_equal::count = 0;
assert(result == std::search(b1, e1, s)); assert(result == std::search(b1, e1, s));
assert(count_equal::count <= max_count); assert(count_equal::count <= max_count);
} }
template <class Iter1, class Iter2> namespace User {
void struct S {
test() S(int x) : x(x) {}
int x;
bool operator==(S other) const
{ {
int ia[] = {0, 1, 2, 3, 4, 5}; return x == other.x;
const unsigned sa = sizeof(ia)/sizeof(ia[0]); }
do_search(Iter1(ia), Iter1(ia+sa), Iter2(ia), Iter2(ia), Iter1(ia), 0); explicit operator size_t() const
do_search(Iter1(ia), Iter1(ia+sa), Iter2(ia), Iter2(ia+1), Iter1(ia), sa); {
do_search(Iter1(ia), Iter1(ia+sa), Iter2(ia+1), Iter2(ia+2), Iter1(ia+1), sa); return static_cast<size_t>(x);
do_search(Iter1(ia), Iter1(ia+sa), Iter2(ia+2), Iter2(ia+2), Iter1(ia), 0);
do_search(Iter1(ia), Iter1(ia+sa), Iter2(ia+2), Iter2(ia+3), Iter1(ia+2), sa);
do_search(Iter1(ia), Iter1(ia+sa), Iter2(ia+2), Iter2(ia+3), Iter1(ia+2), sa);
do_search(Iter1(ia), Iter1(ia), Iter2(ia+2), Iter2(ia+3), Iter1(ia), 0);
do_search(Iter1(ia), Iter1(ia+sa), Iter2(ia+sa-1), Iter2(ia+sa), Iter1(ia+sa-1), sa);
do_search(Iter1(ia), Iter1(ia+sa), Iter2(ia+sa-3), Iter2(ia+sa), Iter1(ia+sa-3), 3*sa);
do_search(Iter1(ia), Iter1(ia+sa), Iter2(ia), Iter2(ia+sa), Iter1(ia), sa*sa);
do_search(Iter1(ia), Iter1(ia+sa-1), Iter2(ia), Iter2(ia+sa), Iter1(ia+sa-1), (sa-1)*sa);
do_search(Iter1(ia), Iter1(ia+1), Iter2(ia), Iter2(ia+sa), Iter1(ia+1), sa);
int ib[] = {0, 1, 2, 0, 1, 2, 3, 0, 1, 2, 3, 4};
const unsigned sb = sizeof(ib)/sizeof(ib[0]);
int ic[] = {1};
do_search(Iter1(ib), Iter1(ib+sb), Iter2(ic), Iter2(ic+1), Iter1(ib+1), sb);
int id[] = {1, 2};
do_search(Iter1(ib), Iter1(ib+sb), Iter2(id), Iter2(id+2), Iter1(ib+1), sb*2);
int ie[] = {1, 2, 3};
do_search(Iter1(ib), Iter1(ib+sb), Iter2(ie), Iter2(ie+3), Iter1(ib+4), sb*3);
int ig[] = {1, 2, 3, 4};
do_search(Iter1(ib), Iter1(ib+sb), Iter2(ig), Iter2(ig+4), Iter1(ib+8), sb*4);
int ih[] = {0, 1, 1, 1, 1, 2, 3, 0, 1, 2, 3, 4};
const unsigned sh = sizeof(ih)/sizeof(ih[0]);
int ii[] = {1, 1, 2};
do_search(Iter1(ih), Iter1(ih+sh), Iter2(ii), Iter2(ii+3), Iter1(ih+3), sh*3);
} }
};
template <class T, class U>
void make_pair(T&&, U&&) {}
} // namespace User
template <class Iter1, class Iter2> template <class T, class Iter1, class Iter2>
void void
test2() test()
{ {
char ia[] = {0, 1, 2, 3, 4, 5}; T ia[] = {0, 1, 2, 3, 4, 5};
const unsigned sa = sizeof(ia)/sizeof(ia[0]); const unsigned sa = sizeof(ia)/sizeof(ia[0]);
do_search(Iter1(ia), Iter1(ia+sa), Iter2(ia), Iter2(ia), Iter1(ia), 0); do_search(Iter1(ia), Iter1(ia+sa), Iter2(ia), Iter2(ia), Iter1(ia), 0);
do_search(Iter1(ia), Iter1(ia+sa), Iter2(ia), Iter2(ia+1), Iter1(ia), sa); do_search(Iter1(ia), Iter1(ia+sa), Iter2(ia), Iter2(ia+1), Iter1(ia), sa);
do_search(Iter1(ia), Iter1(ia+sa), Iter2(ia+1), Iter2(ia+2), Iter1(ia+1), sa); do_search(Iter1(ia), Iter1(ia+sa), Iter2(ia+1), Iter2(ia+2), Iter1(ia+1), sa);
do_search(Iter1(ia), Iter1(ia+sa), Iter2(ia+2), Iter2(ia+2), Iter1(ia), 0); do_search(Iter1(ia), Iter1(ia+sa), Iter2(ia+2), Iter2(ia+2), Iter1(ia), 0);
do_search(Iter1(ia), Iter1(ia+sa), Iter2(ia+2), Iter2(ia+3), Iter1(ia+2), sa); do_search(Iter1(ia), Iter1(ia+sa), Iter2(ia+2), Iter2(ia+3), Iter1(ia+2), sa);
do_search(Iter1(ia), Iter1(ia+sa), Iter2(ia+2), Iter2(ia+3), Iter1(ia+2), sa); do_search(Iter1(ia), Iter1(ia+sa), Iter2(ia+2), Iter2(ia+3), Iter1(ia+2), sa);
do_search(Iter1(ia), Iter1(ia), Iter2(ia+2), Iter2(ia+3), Iter1(ia), 0); do_search(Iter1(ia), Iter1(ia), Iter2(ia+2), Iter2(ia+3), Iter1(ia), 0);
do_search(Iter1(ia), Iter1(ia+sa), Iter2(ia+sa-1), Iter2(ia+sa), Iter1(ia+sa-1), sa); do_search(Iter1(ia), Iter1(ia+sa), Iter2(ia+sa-1), Iter2(ia+sa), Iter1(ia+sa-1), sa);
do_search(Iter1(ia), Iter1(ia+sa), Iter2(ia+sa-3), Iter2(ia+sa), Iter1(ia+sa-3), 3*sa); do_search(Iter1(ia), Iter1(ia+sa), Iter2(ia+sa-3), Iter2(ia+sa), Iter1(ia+sa-3), 3*sa);
do_search(Iter1(ia), Iter1(ia+sa), Iter2(ia), Iter2(ia+sa), Iter1(ia), sa*sa); do_search(Iter1(ia), Iter1(ia+sa), Iter2(ia), Iter2(ia+sa), Iter1(ia), sa*sa);
do_search(Iter1(ia), Iter1(ia+sa-1), Iter2(ia), Iter2(ia+sa), Iter1(ia+sa-1), (sa-1)*sa); do_search(Iter1(ia), Iter1(ia+sa-1), Iter2(ia), Iter2(ia+sa), Iter1(ia+sa-1), (sa-1)*sa);
do_search(Iter1(ia), Iter1(ia+1), Iter2(ia), Iter2(ia+sa), Iter1(ia+1), sa); do_search(Iter1(ia), Iter1(ia+1), Iter2(ia), Iter2(ia+sa), Iter1(ia+1), sa);
char ib[] = {0, 1, 2, 0, 1, 2, 3, 0, 1, 2, 3, 4}; T ib[] = {0, 1, 2, 0, 1, 2, 3, 0, 1, 2, 3, 4};
const unsigned sb = sizeof(ib)/sizeof(ib[0]); const unsigned sb = sizeof(ib)/sizeof(ib[0]);
char ic[] = {1}; T ic[] = {1};
do_search(Iter1(ib), Iter1(ib+sb), Iter2(ic), Iter2(ic+1), Iter1(ib+1), sb); do_search(Iter1(ib), Iter1(ib+sb), Iter2(ic), Iter2(ic+1), Iter1(ib+1), sb);
char id[] = {1, 2}; T id[] = {1, 2};
do_search(Iter1(ib), Iter1(ib+sb), Iter2(id), Iter2(id+2), Iter1(ib+1), sb*2); do_search(Iter1(ib), Iter1(ib+sb), Iter2(id), Iter2(id+2), Iter1(ib+1), sb*2);
char ie[] = {1, 2, 3}; T ie[] = {1, 2, 3};
do_search(Iter1(ib), Iter1(ib+sb), Iter2(ie), Iter2(ie+3), Iter1(ib+4), sb*3); do_search(Iter1(ib), Iter1(ib+sb), Iter2(ie), Iter2(ie+3), Iter1(ib+4), sb*3);
char ig[] = {1, 2, 3, 4}; T ig[] = {1, 2, 3, 4};
do_search(Iter1(ib), Iter1(ib+sb), Iter2(ig), Iter2(ig+4), Iter1(ib+8), sb*4); do_search(Iter1(ib), Iter1(ib+sb), Iter2(ig), Iter2(ig+4), Iter1(ib+8), sb*4);
char ih[] = {0, 1, 1, 1, 1, 2, 3, 0, 1, 2, 3, 4}; T ih[] = {0, 1, 1, 1, 1, 2, 3, 0, 1, 2, 3, 4};
const unsigned sh = sizeof(ih)/sizeof(ih[0]); const unsigned sh = sizeof(ih)/sizeof(ih[0]);
char ii[] = {1, 1, 2}; T ii[] = {1, 1, 2};
do_search(Iter1(ih), Iter1(ih+sh), Iter2(ii), Iter2(ii+3), Iter1(ih+3), sh*3); do_search(Iter1(ih), Iter1(ih+sh), Iter2(ii), Iter2(ii+3), Iter1(ih+3), sh*3);
} }
int main(int, char**) { int main(int, char**) {
test<random_access_iterator<const int*>, random_access_iterator<const int*> >(); test<int, random_access_iterator<const int*>, random_access_iterator<const int*> >();
test2<random_access_iterator<const char*>, random_access_iterator<const char*> >(); test<char, random_access_iterator<const char*>, random_access_iterator<const char*> >();
test<User::S, random_access_iterator<const User::S*>, random_access_iterator<const User::S*> >();
return 0; return 0;
} }

libcxx/test/std/utilities/function.objects/func.search/func.search.bm/pred.pass.cpp

Show First 20 Lines • Show All 52 Lines • ▼ Show 20 Lines
void do_search(Iter1 b1, Iter1 e1, Iter2 b2, Iter2 e2, Iter1 result, unsigned max_count) { void do_search(Iter1 b1, Iter1 e1, Iter2 b2, Iter2 e2, Iter1 result, unsigned max_count) {
std::boyer_moore_searcher<Iter2, std::boyer_moore_searcher<Iter2,
typename std::hash<typename std::remove_cv<typename std::iterator_traits<Iter2>::value_type>::type>, count_equal> s{b2, e2}; typename std::hash<typename std::remove_cv<typename std::iterator_traits<Iter2>::value_type>::type>, count_equal> s{b2, e2};
count_equal::count = 0; count_equal::count = 0;
assert(result == std::search(b1, e1, s)); assert(result == std::search(b1, e1, s));
assert(count_equal::count <= max_count); assert(count_equal::count <= max_count);
} }
template <class Iter1, class Iter2> namespace User {
void struct S {
test() S(int x) : x(x) {}
int x;
bool operator==(S other) const
{ {
int ia[] = {0, 1, 2, 3, 4, 5}; return x == other.x;
const unsigned sa = sizeof(ia)/sizeof(ia[0]);
do_search(Iter1(ia), Iter1(ia+sa), Iter2(ia), Iter2(ia), Iter1(ia), 0);
do_search(Iter1(ia), Iter1(ia+sa), Iter2(ia), Iter2(ia+1), Iter1(ia), sa);
do_search(Iter1(ia), Iter1(ia+sa), Iter2(ia+1), Iter2(ia+2), Iter1(ia+1), sa);
do_search(Iter1(ia), Iter1(ia+sa), Iter2(ia+2), Iter2(ia+2), Iter1(ia), 0);
do_search(Iter1(ia), Iter1(ia+sa), Iter2(ia+2), Iter2(ia+3), Iter1(ia+2), sa);
do_search(Iter1(ia), Iter1(ia+sa), Iter2(ia+2), Iter2(ia+3), Iter1(ia+2), sa);
do_search(Iter1(ia), Iter1(ia), Iter2(ia+2), Iter2(ia+3), Iter1(ia), 0);
do_search(Iter1(ia), Iter1(ia+sa), Iter2(ia+sa-1), Iter2(ia+sa), Iter1(ia+sa-1), sa);
do_search(Iter1(ia), Iter1(ia+sa), Iter2(ia+sa-3), Iter2(ia+sa), Iter1(ia+sa-3), 3*sa);
do_search(Iter1(ia), Iter1(ia+sa), Iter2(ia), Iter2(ia+sa), Iter1(ia), sa*sa);
do_search(Iter1(ia), Iter1(ia+sa-1), Iter2(ia), Iter2(ia+sa), Iter1(ia+sa-1), (sa-1)*sa);
do_search(Iter1(ia), Iter1(ia+1), Iter2(ia), Iter2(ia+sa), Iter1(ia+1), sa);
int ib[] = {0, 1, 2, 0, 1, 2, 3, 0, 1, 2, 3, 4};
const unsigned sb = sizeof(ib)/sizeof(ib[0]);
int ic[] = {1};
do_search(Iter1(ib), Iter1(ib+sb), Iter2(ic), Iter2(ic+1), Iter1(ib+1), sb);
int id[] = {1, 2};
do_search(Iter1(ib), Iter1(ib+sb), Iter2(id), Iter2(id+2), Iter1(ib+1), sb*2);
int ie[] = {1, 2, 3};
do_search(Iter1(ib), Iter1(ib+sb), Iter2(ie), Iter2(ie+3), Iter1(ib+4), sb*3);
int ig[] = {1, 2, 3, 4};
do_search(Iter1(ib), Iter1(ib+sb), Iter2(ig), Iter2(ig+4), Iter1(ib+8), sb*4);
int ih[] = {0, 1, 1, 1, 1, 2, 3, 0, 1, 2, 3, 4};
const unsigned sh = sizeof(ih)/sizeof(ih[0]);
int ii[] = {1, 1, 2};
do_search(Iter1(ih), Iter1(ih+sh), Iter2(ii), Iter2(ii+3), Iter1(ih+3), sh*3);
} }
};
template <class T, class U>
void make_pair(T&&, U&&) {}
} // namespace User
namespace std {
template <> struct hash<User::S> {
std::size_t operator()(const User::S& s) const
{
return s.x;
}
};
} // namespace std
template <class Iter1, class Iter2> template <class T, class Iter1, class Iter2>
void void
test2() test()
{ {
char ia[] = {0, 1, 2, 3, 4, 5}; T ia[] = {0, 1, 2, 3, 4, 5};
const unsigned sa = sizeof(ia)/sizeof(ia[0]); const unsigned sa = sizeof(ia)/sizeof(ia[0]);
do_search(Iter1(ia), Iter1(ia+sa), Iter2(ia), Iter2(ia), Iter1(ia), 0); do_search(Iter1(ia), Iter1(ia+sa), Iter2(ia), Iter2(ia), Iter1(ia), 0);
do_search(Iter1(ia), Iter1(ia+sa), Iter2(ia), Iter2(ia+1), Iter1(ia), sa); do_search(Iter1(ia), Iter1(ia+sa), Iter2(ia), Iter2(ia+1), Iter1(ia), sa);
do_search(Iter1(ia), Iter1(ia+sa), Iter2(ia+1), Iter2(ia+2), Iter1(ia+1), sa); do_search(Iter1(ia), Iter1(ia+sa), Iter2(ia+1), Iter2(ia+2), Iter1(ia+1), sa);
do_search(Iter1(ia), Iter1(ia+sa), Iter2(ia+2), Iter2(ia+2), Iter1(ia), 0); do_search(Iter1(ia), Iter1(ia+sa), Iter2(ia+2), Iter2(ia+2), Iter1(ia), 0);
do_search(Iter1(ia), Iter1(ia+sa), Iter2(ia+2), Iter2(ia+3), Iter1(ia+2), sa); do_search(Iter1(ia), Iter1(ia+sa), Iter2(ia+2), Iter2(ia+3), Iter1(ia+2), sa);
do_search(Iter1(ia), Iter1(ia+sa), Iter2(ia+2), Iter2(ia+3), Iter1(ia+2), sa); do_search(Iter1(ia), Iter1(ia+sa), Iter2(ia+2), Iter2(ia+3), Iter1(ia+2), sa);
do_search(Iter1(ia), Iter1(ia), Iter2(ia+2), Iter2(ia+3), Iter1(ia), 0); do_search(Iter1(ia), Iter1(ia), Iter2(ia+2), Iter2(ia+3), Iter1(ia), 0);
do_search(Iter1(ia), Iter1(ia+sa), Iter2(ia+sa-1), Iter2(ia+sa), Iter1(ia+sa-1), sa); do_search(Iter1(ia), Iter1(ia+sa), Iter2(ia+sa-1), Iter2(ia+sa), Iter1(ia+sa-1), sa);
do_search(Iter1(ia), Iter1(ia+sa), Iter2(ia+sa-3), Iter2(ia+sa), Iter1(ia+sa-3), 3*sa); do_search(Iter1(ia), Iter1(ia+sa), Iter2(ia+sa-3), Iter2(ia+sa), Iter1(ia+sa-3), 3*sa);
do_search(Iter1(ia), Iter1(ia+sa), Iter2(ia), Iter2(ia+sa), Iter1(ia), sa*sa); do_search(Iter1(ia), Iter1(ia+sa), Iter2(ia), Iter2(ia+sa), Iter1(ia), sa*sa);
do_search(Iter1(ia), Iter1(ia+sa-1), Iter2(ia), Iter2(ia+sa), Iter1(ia+sa-1), (sa-1)*sa); do_search(Iter1(ia), Iter1(ia+sa-1), Iter2(ia), Iter2(ia+sa), Iter1(ia+sa-1), (sa-1)*sa);
do_search(Iter1(ia), Iter1(ia+1), Iter2(ia), Iter2(ia+sa), Iter1(ia+1), sa); do_search(Iter1(ia), Iter1(ia+1), Iter2(ia), Iter2(ia+sa), Iter1(ia+1), sa);
char ib[] = {0, 1, 2, 0, 1, 2, 3, 0, 1, 2, 3, 4};
T ib[] = {0, 1, 2, 0, 1, 2, 3, 0, 1, 2, 3, 4};
const unsigned sb = sizeof(ib)/sizeof(ib[0]); const unsigned sb = sizeof(ib)/sizeof(ib[0]);
char ic[] = {1}; T ic[] = {1};
do_search(Iter1(ib), Iter1(ib+sb), Iter2(ic), Iter2(ic+1), Iter1(ib+1), sb); do_search(Iter1(ib), Iter1(ib+sb), Iter2(ic), Iter2(ic+1), Iter1(ib+1), sb);
char id[] = {1, 2}; T id[] = {1, 2};
do_search(Iter1(ib), Iter1(ib+sb), Iter2(id), Iter2(id+2), Iter1(ib+1), sb*2); do_search(Iter1(ib), Iter1(ib+sb), Iter2(id), Iter2(id+2), Iter1(ib+1), sb*2);
char ie[] = {1, 2, 3}; T ie[] = {1, 2, 3};
do_search(Iter1(ib), Iter1(ib+sb), Iter2(ie), Iter2(ie+3), Iter1(ib+4), sb*3); do_search(Iter1(ib), Iter1(ib+sb), Iter2(ie), Iter2(ie+3), Iter1(ib+4), sb*3);
char ig[] = {1, 2, 3, 4}; T ig[] = {1, 2, 3, 4};
do_search(Iter1(ib), Iter1(ib+sb), Iter2(ig), Iter2(ig+4), Iter1(ib+8), sb*4); do_search(Iter1(ib), Iter1(ib+sb), Iter2(ig), Iter2(ig+4), Iter1(ib+8), sb*4);
char ih[] = {0, 1, 1, 1, 1, 2, 3, 0, 1, 2, 3, 4}; T ih[] = {0, 1, 1, 1, 1, 2, 3, 0, 1, 2, 3, 4};
const unsigned sh = sizeof(ih)/sizeof(ih[0]); const unsigned sh = sizeof(ih)/sizeof(ih[0]);
char ii[] = {1, 1, 2}; T ii[] = {1, 1, 2};
do_search(Iter1(ih), Iter1(ih+sh), Iter2(ii), Iter2(ii+3), Iter1(ih+3), sh*3); do_search(Iter1(ih), Iter1(ih+sh), Iter2(ii), Iter2(ii+3), Iter1(ih+3), sh*3);
} }
int main(int, char**) { int main(int, char**) {
test<random_access_iterator<const int*>, random_access_iterator<const int*> >(); test<int, random_access_iterator<const int*>, random_access_iterator<const int*> >();
test2<random_access_iterator<const char*>, random_access_iterator<const char*> >(); test<char, random_access_iterator<const char*>, random_access_iterator<const char*> >();
test<User::S, random_access_iterator<const User::S*>, random_access_iterator<const User::S*> >();
return 0; return 0;
} }

libcxx/test/std/utilities/function.objects/func.search/func.search.bmh/default.pass.cpp

Show All 39 Lines
#include "test_iterators.h" #include "test_iterators.h"
template <typename Iter1, typename Iter2> template <typename Iter1, typename Iter2>
void do_search(Iter1 b1, Iter1 e1, Iter2 b2, Iter2 e2, Iter1 result) { void do_search(Iter1 b1, Iter1 e1, Iter2 b2, Iter2 e2, Iter1 result) {
std::boyer_moore_horspool_searcher<Iter2> s{b2, e2}; std::boyer_moore_horspool_searcher<Iter2> s{b2, e2};
assert(result == std::search(b1, e1, s)); assert(result == std::search(b1, e1, s));
} }
template <class Iter1, class Iter2> namespace User {
void struct S {
test() S(int x) : x(x) {}
int x;
bool operator==(S other) const
{ {
int ia[] = {0, 1, 2, 3, 4, 5}; return x == other.x;
const unsigned sa = sizeof(ia)/sizeof(ia[0]);
do_search(Iter1(ia), Iter1(ia+sa), Iter2(ia), Iter2(ia), Iter1(ia));
do_search(Iter1(ia), Iter1(ia+sa), Iter2(ia), Iter2(ia+1), Iter1(ia));
do_search(Iter1(ia), Iter1(ia+sa), Iter2(ia+1), Iter2(ia+2), Iter1(ia+1));
do_search(Iter1(ia), Iter1(ia+sa), Iter2(ia+2), Iter2(ia+2), Iter1(ia));
do_search(Iter1(ia), Iter1(ia+sa), Iter2(ia+2), Iter2(ia+3), Iter1(ia+2));
do_search(Iter1(ia), Iter1(ia+sa), Iter2(ia+2), Iter2(ia+3), Iter1(ia+2));
do_search(Iter1(ia), Iter1(ia), Iter2(ia+2), Iter2(ia+3), Iter1(ia));
do_search(Iter1(ia), Iter1(ia+sa), Iter2(ia+sa-1), Iter2(ia+sa), Iter1(ia+sa-1));
do_search(Iter1(ia), Iter1(ia+sa), Iter2(ia+sa-3), Iter2(ia+sa), Iter1(ia+sa-3));
do_search(Iter1(ia), Iter1(ia+sa), Iter2(ia), Iter2(ia+sa), Iter1(ia));
do_search(Iter1(ia), Iter1(ia+sa-1), Iter2(ia), Iter2(ia+sa), Iter1(ia+sa-1));
do_search(Iter1(ia), Iter1(ia+1), Iter2(ia), Iter2(ia+sa), Iter1(ia+1));
int ib[] = {0, 1, 2, 0, 1, 2, 3, 0, 1, 2, 3, 4};
const unsigned sb = sizeof(ib)/sizeof(ib[0]);
int ic[] = {1};
do_search(Iter1(ib), Iter1(ib+sb), Iter2(ic), Iter2(ic+1), Iter1(ib+1));
int id[] = {1, 2};
do_search(Iter1(ib), Iter1(ib+sb), Iter2(id), Iter2(id+2), Iter1(ib+1));
int ie[] = {1, 2, 3};
do_search(Iter1(ib), Iter1(ib+sb), Iter2(ie), Iter2(ie+3), Iter1(ib+4));
int ig[] = {1, 2, 3, 4};
do_search(Iter1(ib), Iter1(ib+sb), Iter2(ig), Iter2(ig+4), Iter1(ib+8));
int ih[] = {0, 1, 1, 1, 1, 2, 3, 0, 1, 2, 3, 4};
const unsigned sh = sizeof(ih)/sizeof(ih[0]);
int ii[] = {1, 1, 2};
do_search(Iter1(ih), Iter1(ih+sh), Iter2(ii), Iter2(ii+3), Iter1(ih+3));
int ij[] = {0, 1, 0, 0, 1, 0, 0, 0, 0, 0, 1, 1, 1, 1, 0, 0};
const unsigned sj = sizeof(ij)/sizeof(ij[0]);
int ik[] = {0, 0, 0, 0, 1, 1, 1, 1, 0, 0};
const unsigned sk = sizeof(ik)/sizeof(ik[0]);
do_search(Iter1(ij), Iter1(ij+sj), Iter2(ik), Iter2(ik+sk), Iter1(ij+6));
} }
};
template <class T, class U>
void make_pair(T&&, U&&) {}
} // namespace User
namespace std {
template <> struct hash<User::S> {
std::size_t operator()(const User::S& s) const
{
return s.x;
}
};
} // namespace std
template <class Iter1, class Iter2> template <class T, class Iter1, class Iter2>
void void
test2() test()
{ {
char ia[] = {0, 1, 2, 3, 4, 5}; T ia[] = {0, 1, 2, 3, 4, 5};
const unsigned sa = sizeof(ia)/sizeof(ia[0]); const unsigned sa = sizeof(ia)/sizeof(ia[0]);
do_search(Iter1(ia), Iter1(ia+sa), Iter2(ia), Iter2(ia), Iter1(ia)); do_search(Iter1(ia), Iter1(ia+sa), Iter2(ia), Iter2(ia), Iter1(ia));
do_search(Iter1(ia), Iter1(ia+sa), Iter2(ia), Iter2(ia+1), Iter1(ia)); do_search(Iter1(ia), Iter1(ia+sa), Iter2(ia), Iter2(ia+1), Iter1(ia));
do_search(Iter1(ia), Iter1(ia+sa), Iter2(ia+1), Iter2(ia+2), Iter1(ia+1)); do_search(Iter1(ia), Iter1(ia+sa), Iter2(ia+1), Iter2(ia+2), Iter1(ia+1));
do_search(Iter1(ia), Iter1(ia+sa), Iter2(ia+2), Iter2(ia+2), Iter1(ia)); do_search(Iter1(ia), Iter1(ia+sa), Iter2(ia+2), Iter2(ia+2), Iter1(ia));
do_search(Iter1(ia), Iter1(ia+sa), Iter2(ia+2), Iter2(ia+3), Iter1(ia+2)); do_search(Iter1(ia), Iter1(ia+sa), Iter2(ia+2), Iter2(ia+3), Iter1(ia+2));
do_search(Iter1(ia), Iter1(ia+sa), Iter2(ia+2), Iter2(ia+3), Iter1(ia+2)); do_search(Iter1(ia), Iter1(ia+sa), Iter2(ia+2), Iter2(ia+3), Iter1(ia+2));
do_search(Iter1(ia), Iter1(ia), Iter2(ia+2), Iter2(ia+3), Iter1(ia)); do_search(Iter1(ia), Iter1(ia), Iter2(ia+2), Iter2(ia+3), Iter1(ia));
do_search(Iter1(ia), Iter1(ia+sa), Iter2(ia+sa-1), Iter2(ia+sa), Iter1(ia+sa-1)); do_search(Iter1(ia), Iter1(ia+sa), Iter2(ia+sa-1), Iter2(ia+sa), Iter1(ia+sa-1));
do_search(Iter1(ia), Iter1(ia+sa), Iter2(ia+sa-3), Iter2(ia+sa), Iter1(ia+sa-3)); do_search(Iter1(ia), Iter1(ia+sa), Iter2(ia+sa-3), Iter2(ia+sa), Iter1(ia+sa-3));
do_search(Iter1(ia), Iter1(ia+sa), Iter2(ia), Iter2(ia+sa), Iter1(ia)); do_search(Iter1(ia), Iter1(ia+sa), Iter2(ia), Iter2(ia+sa), Iter1(ia));
do_search(Iter1(ia), Iter1(ia+sa-1), Iter2(ia), Iter2(ia+sa), Iter1(ia+sa-1)); do_search(Iter1(ia), Iter1(ia+sa-1), Iter2(ia), Iter2(ia+sa), Iter1(ia+sa-1));
do_search(Iter1(ia), Iter1(ia+1), Iter2(ia), Iter2(ia+sa), Iter1(ia+1)); do_search(Iter1(ia), Iter1(ia+1), Iter2(ia), Iter2(ia+sa), Iter1(ia+1));
char ib[] = {0, 1, 2, 0, 1, 2, 3, 0, 1, 2, 3, 4}; T ib[] = {0, 1, 2, 0, 1, 2, 3, 0, 1, 2, 3, 4};
const unsigned sb = sizeof(ib)/sizeof(ib[0]); const unsigned sb = sizeof(ib)/sizeof(ib[0]);
char ic[] = {1}; T ic[] = {1};
do_search(Iter1(ib), Iter1(ib+sb), Iter2(ic), Iter2(ic+1), Iter1(ib+1)); do_search(Iter1(ib), Iter1(ib+sb), Iter2(ic), Iter2(ic+1), Iter1(ib+1));
char id[] = {1, 2}; T id[] = {1, 2};
do_search(Iter1(ib), Iter1(ib+sb), Iter2(id), Iter2(id+2), Iter1(ib+1)); do_search(Iter1(ib), Iter1(ib+sb), Iter2(id), Iter2(id+2), Iter1(ib+1));
char ie[] = {1, 2, 3}; T ie[] = {1, 2, 3};
do_search(Iter1(ib), Iter1(ib+sb), Iter2(ie), Iter2(ie+3), Iter1(ib+4)); do_search(Iter1(ib), Iter1(ib+sb), Iter2(ie), Iter2(ie+3), Iter1(ib+4));
char ig[] = {1, 2, 3, 4}; T ig[] = {1, 2, 3, 4};
do_search(Iter1(ib), Iter1(ib+sb), Iter2(ig), Iter2(ig+4), Iter1(ib+8)); do_search(Iter1(ib), Iter1(ib+sb), Iter2(ig), Iter2(ig+4), Iter1(ib+8));
char ih[] = {0, 1, 1, 1, 1, 2, 3, 0, 1, 2, 3, 4}; T ih[] = {0, 1, 1, 1, 1, 2, 3, 0, 1, 2, 3, 4};
const unsigned sh = sizeof(ih)/sizeof(ih[0]); const unsigned sh = sizeof(ih)/sizeof(ih[0]);
char ii[] = {1, 1, 2}; T ii[] = {1, 1, 2};
do_search(Iter1(ih), Iter1(ih+sh), Iter2(ii), Iter2(ii+3), Iter1(ih+3)); do_search(Iter1(ih), Iter1(ih+sh), Iter2(ii), Iter2(ii+3), Iter1(ih+3));
char ij[] = {0, 1, 0, 0, 1, 0, 0, 0, 0, 0, 1, 1, 1, 1, 0, 0}; T ij[] = {0, 1, 0, 0, 1, 0, 0, 0, 0, 0, 1, 1, 1, 1, 0, 0};
const unsigned sj = sizeof(ij)/sizeof(ij[0]); const unsigned sj = sizeof(ij)/sizeof(ij[0]);
char ik[] = {0, 0, 0, 0, 1, 1, 1, 1, 0, 0}; T ik[] = {0, 0, 0, 0, 1, 1, 1, 1, 0, 0};
const unsigned sk = sizeof(ik)/sizeof(ik[0]); const unsigned sk = sizeof(ik)/sizeof(ik[0]);
do_search(Iter1(ij), Iter1(ij+sj), Iter2(ik), Iter2(ik+sk), Iter1(ij+6)); do_search(Iter1(ij), Iter1(ij+sj), Iter2(ik), Iter2(ik+sk), Iter1(ij+6));
} }
int main(int, char**) { int main(int, char**) {
test<random_access_iterator<const int*>, random_access_iterator<const int*> >(); test<int, random_access_iterator<const int*>, random_access_iterator<const int*> >();
test2<random_access_iterator<const char*>, random_access_iterator<const char*> >(); test<char, random_access_iterator<const char*>, random_access_iterator<const char*> >();
test<User::S, random_access_iterator<const User::S*>, random_access_iterator<const User::S*> >();
return 0; return 0;
} }

libcxx/test/std/utilities/function.objects/func.search/func.search.bmh/hash.pass.cpp

Show First 20 Lines • Show All 44 Lines • ▼ Show 20 Lines
template <typename Iter1, typename Iter2> template <typename Iter1, typename Iter2>
void do_search(Iter1 b1, Iter1 e1, Iter2 b2, Iter2 e2, Iter1 result, unsigned /*max_count*/) { void do_search(Iter1 b1, Iter1 e1, Iter2 b2, Iter2 e2, Iter1 result, unsigned /*max_count*/) {
std::boyer_moore_horspool_searcher<Iter2, std::boyer_moore_horspool_searcher<Iter2,
MyHash<typename std::remove_cv<typename std::iterator_traits<Iter2>::value_type>::type>> MyHash<typename std::remove_cv<typename std::iterator_traits<Iter2>::value_type>::type>>
s{b2, e2}; s{b2, e2};
assert(result == std::search(b1, e1, s)); assert(result == std::search(b1, e1, s));
} }
template <class Iter1, class Iter2> namespace User {
void struct S {
test() S(int x) : x(x) {}
int x;
bool operator==(S other) const
{ {
int ia[] = {0, 1, 2, 3, 4, 5}; return x == other.x;
const unsigned sa = sizeof(ia)/sizeof(ia[0]); }
do_search(Iter1(ia), Iter1(ia+sa), Iter2(ia), Iter2(ia), Iter1(ia), 0); explicit operator size_t() const
do_search(Iter1(ia), Iter1(ia+sa), Iter2(ia), Iter2(ia+1), Iter1(ia), sa); {
do_search(Iter1(ia), Iter1(ia+sa), Iter2(ia+1), Iter2(ia+2), Iter1(ia+1), sa); return static_cast<size_t>(x);
do_search(Iter1(ia), Iter1(ia+sa), Iter2(ia+2), Iter2(ia+2), Iter1(ia), 0);
do_search(Iter1(ia), Iter1(ia+sa), Iter2(ia+2), Iter2(ia+3), Iter1(ia+2), sa);
do_search(Iter1(ia), Iter1(ia+sa), Iter2(ia+2), Iter2(ia+3), Iter1(ia+2), sa);
do_search(Iter1(ia), Iter1(ia), Iter2(ia+2), Iter2(ia+3), Iter1(ia), 0);
do_search(Iter1(ia), Iter1(ia+sa), Iter2(ia+sa-1), Iter2(ia+sa), Iter1(ia+sa-1), sa);
do_search(Iter1(ia), Iter1(ia+sa), Iter2(ia+sa-3), Iter2(ia+sa), Iter1(ia+sa-3), 3*sa);
do_search(Iter1(ia), Iter1(ia+sa), Iter2(ia), Iter2(ia+sa), Iter1(ia), sa*sa);
do_search(Iter1(ia), Iter1(ia+sa-1), Iter2(ia), Iter2(ia+sa), Iter1(ia+sa-1), (sa-1)*sa);
do_search(Iter1(ia), Iter1(ia+1), Iter2(ia), Iter2(ia+sa), Iter1(ia+1), sa);
int ib[] = {0, 1, 2, 0, 1, 2, 3, 0, 1, 2, 3, 4};
const unsigned sb = sizeof(ib)/sizeof(ib[0]);
int ic[] = {1};
do_search(Iter1(ib), Iter1(ib+sb), Iter2(ic), Iter2(ic+1), Iter1(ib+1), sb);
int id[] = {1, 2};
do_search(Iter1(ib), Iter1(ib+sb), Iter2(id), Iter2(id+2), Iter1(ib+1), sb*2);
int ie[] = {1, 2, 3};
do_search(Iter1(ib), Iter1(ib+sb), Iter2(ie), Iter2(ie+3), Iter1(ib+4), sb*3);
int ig[] = {1, 2, 3, 4};
do_search(Iter1(ib), Iter1(ib+sb), Iter2(ig), Iter2(ig+4), Iter1(ib+8), sb*4);
int ih[] = {0, 1, 1, 1, 1, 2, 3, 0, 1, 2, 3, 4};
const unsigned sh = sizeof(ih)/sizeof(ih[0]);
int ii[] = {1, 1, 2};
do_search(Iter1(ih), Iter1(ih+sh), Iter2(ii), Iter2(ii+3), Iter1(ih+3), sh*3);
} }
};
template <class T, class U>
void make_pair(T&&, U&&) {}
} // namespace User
template <class Iter1, class Iter2> template <class T, class Iter1, class Iter2>
void void
test2() test()
{ {
char ia[] = {0, 1, 2, 3, 4, 5}; T ia[] = {0, 1, 2, 3, 4, 5};
const unsigned sa = sizeof(ia)/sizeof(ia[0]); const unsigned sa = sizeof(ia)/sizeof(ia[0]);
do_search(Iter1(ia), Iter1(ia+sa), Iter2(ia), Iter2(ia), Iter1(ia), 0); do_search(Iter1(ia), Iter1(ia+sa), Iter2(ia), Iter2(ia), Iter1(ia), 0);
do_search(Iter1(ia), Iter1(ia+sa), Iter2(ia), Iter2(ia+1), Iter1(ia), sa); do_search(Iter1(ia), Iter1(ia+sa), Iter2(ia), Iter2(ia+1), Iter1(ia), sa);
do_search(Iter1(ia), Iter1(ia+sa), Iter2(ia+1), Iter2(ia+2), Iter1(ia+1), sa); do_search(Iter1(ia), Iter1(ia+sa), Iter2(ia+1), Iter2(ia+2), Iter1(ia+1), sa);
do_search(Iter1(ia), Iter1(ia+sa), Iter2(ia+2), Iter2(ia+2), Iter1(ia), 0); do_search(Iter1(ia), Iter1(ia+sa), Iter2(ia+2), Iter2(ia+2), Iter1(ia), 0);
do_search(Iter1(ia), Iter1(ia+sa), Iter2(ia+2), Iter2(ia+3), Iter1(ia+2), sa); do_search(Iter1(ia), Iter1(ia+sa), Iter2(ia+2), Iter2(ia+3), Iter1(ia+2), sa);
do_search(Iter1(ia), Iter1(ia+sa), Iter2(ia+2), Iter2(ia+3), Iter1(ia+2), sa); do_search(Iter1(ia), Iter1(ia+sa), Iter2(ia+2), Iter2(ia+3), Iter1(ia+2), sa);
do_search(Iter1(ia), Iter1(ia), Iter2(ia+2), Iter2(ia+3), Iter1(ia), 0); do_search(Iter1(ia), Iter1(ia), Iter2(ia+2), Iter2(ia+3), Iter1(ia), 0);
do_search(Iter1(ia), Iter1(ia+sa), Iter2(ia+sa-1), Iter2(ia+sa), Iter1(ia+sa-1), sa); do_search(Iter1(ia), Iter1(ia+sa), Iter2(ia+sa-1), Iter2(ia+sa), Iter1(ia+sa-1), sa);
do_search(Iter1(ia), Iter1(ia+sa), Iter2(ia+sa-3), Iter2(ia+sa), Iter1(ia+sa-3), 3*sa); do_search(Iter1(ia), Iter1(ia+sa), Iter2(ia+sa-3), Iter2(ia+sa), Iter1(ia+sa-3), 3*sa);
do_search(Iter1(ia), Iter1(ia+sa), Iter2(ia), Iter2(ia+sa), Iter1(ia), sa*sa); do_search(Iter1(ia), Iter1(ia+sa), Iter2(ia), Iter2(ia+sa), Iter1(ia), sa*sa);
do_search(Iter1(ia), Iter1(ia+sa-1), Iter2(ia), Iter2(ia+sa), Iter1(ia+sa-1), (sa-1)*sa); do_search(Iter1(ia), Iter1(ia+sa-1), Iter2(ia), Iter2(ia+sa), Iter1(ia+sa-1), (sa-1)*sa);
do_search(Iter1(ia), Iter1(ia+1), Iter2(ia), Iter2(ia+sa), Iter1(ia+1), sa); do_search(Iter1(ia), Iter1(ia+1), Iter2(ia), Iter2(ia+sa), Iter1(ia+1), sa);
char ib[] = {0, 1, 2, 0, 1, 2, 3, 0, 1, 2, 3, 4}; T ib[] = {0, 1, 2, 0, 1, 2, 3, 0, 1, 2, 3, 4};
const unsigned sb = sizeof(ib)/sizeof(ib[0]); const unsigned sb = sizeof(ib)/sizeof(ib[0]);
char ic[] = {1}; T ic[] = {1};
do_search(Iter1(ib), Iter1(ib+sb), Iter2(ic), Iter2(ic+1), Iter1(ib+1), sb); do_search(Iter1(ib), Iter1(ib+sb), Iter2(ic), Iter2(ic+1), Iter1(ib+1), sb);
char id[] = {1, 2}; T id[] = {1, 2};
do_search(Iter1(ib), Iter1(ib+sb), Iter2(id), Iter2(id+2), Iter1(ib+1), sb*2); do_search(Iter1(ib), Iter1(ib+sb), Iter2(id), Iter2(id+2), Iter1(ib+1), sb*2);
char ie[] = {1, 2, 3}; T ie[] = {1, 2, 3};
do_search(Iter1(ib), Iter1(ib+sb), Iter2(ie), Iter2(ie+3), Iter1(ib+4), sb*3); do_search(Iter1(ib), Iter1(ib+sb), Iter2(ie), Iter2(ie+3), Iter1(ib+4), sb*3);
char ig[] = {1, 2, 3, 4}; T ig[] = {1, 2, 3, 4};
do_search(Iter1(ib), Iter1(ib+sb), Iter2(ig), Iter2(ig+4), Iter1(ib+8), sb*4); do_search(Iter1(ib), Iter1(ib+sb), Iter2(ig), Iter2(ig+4), Iter1(ib+8), sb*4);
char ih[] = {0, 1, 1, 1, 1, 2, 3, 0, 1, 2, 3, 4}; T ih[] = {0, 1, 1, 1, 1, 2, 3, 0, 1, 2, 3, 4};
const unsigned sh = sizeof(ih)/sizeof(ih[0]); const unsigned sh = sizeof(ih)/sizeof(ih[0]);
char ii[] = {1, 1, 2}; T ii[] = {1, 1, 2};
do_search(Iter1(ih), Iter1(ih+sh), Iter2(ii), Iter2(ii+3), Iter1(ih+3), sh*3); do_search(Iter1(ih), Iter1(ih+sh), Iter2(ii), Iter2(ii+3), Iter1(ih+3), sh*3);
} }
int main(int, char**) { int main(int, char**) {
test<random_access_iterator<const int*>, random_access_iterator<const int*> >(); test<int, random_access_iterator<const int*>, random_access_iterator<const int*> >();
test2<random_access_iterator<const char*>, random_access_iterator<const char*> >(); test<char, random_access_iterator<const char*>, random_access_iterator<const char*> >();
test<User::S, random_access_iterator<const User::S*>, random_access_iterator<const User::S*> >();
return 0; return 0;
} }

libcxx/test/std/utilities/function.objects/func.search/func.search.bmh/hash.pred.pass.cpp

Show First 20 Lines • Show All 57 Lines • ▼ Show 20 Lines std::boyer_moore_horspool_searcher<Iter2,
MyHash<typename std::remove_cv<typename std::iterator_traits<Iter2>::value_type>::type>, MyHash<typename std::remove_cv<typename std::iterator_traits<Iter2>::value_type>::type>,
count_equal> count_equal>
s{b2, e2}; s{b2, e2};
count_equal::count = 0; count_equal::count = 0;
assert(result == std::search(b1, e1, s)); assert(result == std::search(b1, e1, s));
assert(count_equal::count <= max_count); assert(count_equal::count <= max_count);
} }
template <class Iter1, class Iter2> namespace User {
void struct S {
test() S(int x) : x(x) {}
int x;
bool operator==(S other) const
{ {
int ia[] = {0, 1, 2, 3, 4, 5}; return x == other.x;
const unsigned sa = sizeof(ia)/sizeof(ia[0]); }
do_search(Iter1(ia), Iter1(ia+sa), Iter2(ia), Iter2(ia), Iter1(ia), 0); explicit operator size_t() const
do_search(Iter1(ia), Iter1(ia+sa), Iter2(ia), Iter2(ia+1), Iter1(ia), sa); {
do_search(Iter1(ia), Iter1(ia+sa), Iter2(ia+1), Iter2(ia+2), Iter1(ia+1), sa); return static_cast<size_t>(x);
do_search(Iter1(ia), Iter1(ia+sa), Iter2(ia+2), Iter2(ia+2), Iter1(ia), 0);
do_search(Iter1(ia), Iter1(ia+sa), Iter2(ia+2), Iter2(ia+3), Iter1(ia+2), sa);
do_search(Iter1(ia), Iter1(ia+sa), Iter2(ia+2), Iter2(ia+3), Iter1(ia+2), sa);
do_search(Iter1(ia), Iter1(ia), Iter2(ia+2), Iter2(ia+3), Iter1(ia), 0);
do_search(Iter1(ia), Iter1(ia+sa), Iter2(ia+sa-1), Iter2(ia+sa), Iter1(ia+sa-1), sa);
do_search(Iter1(ia), Iter1(ia+sa), Iter2(ia+sa-3), Iter2(ia+sa), Iter1(ia+sa-3), 3*sa);
do_search(Iter1(ia), Iter1(ia+sa), Iter2(ia), Iter2(ia+sa), Iter1(ia), sa*sa);
do_search(Iter1(ia), Iter1(ia+sa-1), Iter2(ia), Iter2(ia+sa), Iter1(ia+sa-1), (sa-1)*sa);
do_search(Iter1(ia), Iter1(ia+1), Iter2(ia), Iter2(ia+sa), Iter1(ia+1), sa);
int ib[] = {0, 1, 2, 0, 1, 2, 3, 0, 1, 2, 3, 4};
const unsigned sb = sizeof(ib)/sizeof(ib[0]);
int ic[] = {1};
do_search(Iter1(ib), Iter1(ib+sb), Iter2(ic), Iter2(ic+1), Iter1(ib+1), sb);
int id[] = {1, 2};
do_search(Iter1(ib), Iter1(ib+sb), Iter2(id), Iter2(id+2), Iter1(ib+1), sb*2);
int ie[] = {1, 2, 3};
do_search(Iter1(ib), Iter1(ib+sb), Iter2(ie), Iter2(ie+3), Iter1(ib+4), sb*3);
int ig[] = {1, 2, 3, 4};
do_search(Iter1(ib), Iter1(ib+sb), Iter2(ig), Iter2(ig+4), Iter1(ib+8), sb*4);
int ih[] = {0, 1, 1, 1, 1, 2, 3, 0, 1, 2, 3, 4};
const unsigned sh = sizeof(ih)/sizeof(ih[0]);
int ii[] = {1, 1, 2};
do_search(Iter1(ih), Iter1(ih+sh), Iter2(ii), Iter2(ii+3), Iter1(ih+3), sh*3);
} }
};
template <class T, class U>
void make_pair(T&&, U&&) {}
} // namespace User
template <class Iter1, class Iter2> template <class T, class Iter1, class Iter2>
void void
test2() test()
{ {
char ia[] = {0, 1, 2, 3, 4, 5}; T ia[] = {0, 1, 2, 3, 4, 5};
const unsigned sa = sizeof(ia)/sizeof(ia[0]); const unsigned sa = sizeof(ia)/sizeof(ia[0]);
do_search(Iter1(ia), Iter1(ia+sa), Iter2(ia), Iter2(ia), Iter1(ia), 0); do_search(Iter1(ia), Iter1(ia+sa), Iter2(ia), Iter2(ia), Iter1(ia), 0);
do_search(Iter1(ia), Iter1(ia+sa), Iter2(ia), Iter2(ia+1), Iter1(ia), sa); do_search(Iter1(ia), Iter1(ia+sa), Iter2(ia), Iter2(ia+1), Iter1(ia), sa);
do_search(Iter1(ia), Iter1(ia+sa), Iter2(ia+1), Iter2(ia+2), Iter1(ia+1), sa); do_search(Iter1(ia), Iter1(ia+sa), Iter2(ia+1), Iter2(ia+2), Iter1(ia+1), sa);
do_search(Iter1(ia), Iter1(ia+sa), Iter2(ia+2), Iter2(ia+2), Iter1(ia), 0); do_search(Iter1(ia), Iter1(ia+sa), Iter2(ia+2), Iter2(ia+2), Iter1(ia), 0);
do_search(Iter1(ia), Iter1(ia+sa), Iter2(ia+2), Iter2(ia+3), Iter1(ia+2), sa); do_search(Iter1(ia), Iter1(ia+sa), Iter2(ia+2), Iter2(ia+3), Iter1(ia+2), sa);
do_search(Iter1(ia), Iter1(ia+sa), Iter2(ia+2), Iter2(ia+3), Iter1(ia+2), sa); do_search(Iter1(ia), Iter1(ia+sa), Iter2(ia+2), Iter2(ia+3), Iter1(ia+2), sa);
do_search(Iter1(ia), Iter1(ia), Iter2(ia+2), Iter2(ia+3), Iter1(ia), 0); do_search(Iter1(ia), Iter1(ia), Iter2(ia+2), Iter2(ia+3), Iter1(ia), 0);
do_search(Iter1(ia), Iter1(ia+sa), Iter2(ia+sa-1), Iter2(ia+sa), Iter1(ia+sa-1), sa); do_search(Iter1(ia), Iter1(ia+sa), Iter2(ia+sa-1), Iter2(ia+sa), Iter1(ia+sa-1), sa);
do_search(Iter1(ia), Iter1(ia+sa), Iter2(ia+sa-3), Iter2(ia+sa), Iter1(ia+sa-3), 3*sa); do_search(Iter1(ia), Iter1(ia+sa), Iter2(ia+sa-3), Iter2(ia+sa), Iter1(ia+sa-3), 3*sa);
do_search(Iter1(ia), Iter1(ia+sa), Iter2(ia), Iter2(ia+sa), Iter1(ia), sa*sa); do_search(Iter1(ia), Iter1(ia+sa), Iter2(ia), Iter2(ia+sa), Iter1(ia), sa*sa);
do_search(Iter1(ia), Iter1(ia+sa-1), Iter2(ia), Iter2(ia+sa), Iter1(ia+sa-1), (sa-1)*sa); do_search(Iter1(ia), Iter1(ia+sa-1), Iter2(ia), Iter2(ia+sa), Iter1(ia+sa-1), (sa-1)*sa);
do_search(Iter1(ia), Iter1(ia+1), Iter2(ia), Iter2(ia+sa), Iter1(ia+1), sa); do_search(Iter1(ia), Iter1(ia+1), Iter2(ia), Iter2(ia+sa), Iter1(ia+1), sa);
char ib[] = {0, 1, 2, 0, 1, 2, 3, 0, 1, 2, 3, 4}; T ib[] = {0, 1, 2, 0, 1, 2, 3, 0, 1, 2, 3, 4};
const unsigned sb = sizeof(ib)/sizeof(ib[0]); const unsigned sb = sizeof(ib)/sizeof(ib[0]);
char ic[] = {1}; T ic[] = {1};
do_search(Iter1(ib), Iter1(ib+sb), Iter2(ic), Iter2(ic+1), Iter1(ib+1), sb); do_search(Iter1(ib), Iter1(ib+sb), Iter2(ic), Iter2(ic+1), Iter1(ib+1), sb);
char id[] = {1, 2}; T id[] = {1, 2};
do_search(Iter1(ib), Iter1(ib+sb), Iter2(id), Iter2(id+2), Iter1(ib+1), sb*2); do_search(Iter1(ib), Iter1(ib+sb), Iter2(id), Iter2(id+2), Iter1(ib+1), sb*2);
char ie[] = {1, 2, 3}; T ie[] = {1, 2, 3};
do_search(Iter1(ib), Iter1(ib+sb), Iter2(ie), Iter2(ie+3), Iter1(ib+4), sb*3); do_search(Iter1(ib), Iter1(ib+sb), Iter2(ie), Iter2(ie+3), Iter1(ib+4), sb*3);
char ig[] = {1, 2, 3, 4}; T ig[] = {1, 2, 3, 4};
do_search(Iter1(ib), Iter1(ib+sb), Iter2(ig), Iter2(ig+4), Iter1(ib+8), sb*4); do_search(Iter1(ib), Iter1(ib+sb), Iter2(ig), Iter2(ig+4), Iter1(ib+8), sb*4);
char ih[] = {0, 1, 1, 1, 1, 2, 3, 0, 1, 2, 3, 4}; T ih[] = {0, 1, 1, 1, 1, 2, 3, 0, 1, 2, 3, 4};
const unsigned sh = sizeof(ih)/sizeof(ih[0]); const unsigned sh = sizeof(ih)/sizeof(ih[0]);
char ii[] = {1, 1, 2}; T ii[] = {1, 1, 2};
do_search(Iter1(ih), Iter1(ih+sh), Iter2(ii), Iter2(ii+3), Iter1(ih+3), sh*3); do_search(Iter1(ih), Iter1(ih+sh), Iter2(ii), Iter2(ii+3), Iter1(ih+3), sh*3);
} }
int main(int, char**) { int main(int, char**) {
test<random_access_iterator<const int*>, random_access_iterator<const int*> >(); test<int, random_access_iterator<const int*>, random_access_iterator<const int*> >();
test2<random_access_iterator<const char*>, random_access_iterator<const char*> >(); test<char, random_access_iterator<const char*>, random_access_iterator<const char*> >();
test<User::S, random_access_iterator<const User::S*>, random_access_iterator<const User::S*> >();
return 0; return 0;
} }

libcxx/test/std/utilities/function.objects/func.search/func.search.bmh/pred.pass.cpp

Show First 20 Lines • Show All 51 Lines • ▼ Show 20 Lines
void do_search(Iter1 b1, Iter1 e1, Iter2 b2, Iter2 e2, Iter1 result, unsigned max_count) { void do_search(Iter1 b1, Iter1 e1, Iter2 b2, Iter2 e2, Iter1 result, unsigned max_count) {
std::boyer_moore_horspool_searcher<Iter2, std::boyer_moore_horspool_searcher<Iter2,
typename std::hash<typename std::remove_cv<typename std::iterator_traits<Iter2>::value_type>::type>, count_equal> s{b2, e2}; typename std::hash<typename std::remove_cv<typename std::iterator_traits<Iter2>::value_type>::type>, count_equal> s{b2, e2};
count_equal::count = 0; count_equal::count = 0;
assert(result == std::search(b1, e1, s)); assert(result == std::search(b1, e1, s));
assert(count_equal::count <= max_count); assert(count_equal::count <= max_count);
} }
template <class Iter1, class Iter2> namespace User {
void struct S {
test() S(int x) : x(x) {}
int x;
bool operator==(S other) const
{ {
int ia[] = {0, 1, 2, 3, 4, 5}; return x == other.x;
const unsigned sa = sizeof(ia)/sizeof(ia[0]); }
do_search(Iter1(ia), Iter1(ia+sa), Iter2(ia), Iter2(ia), Iter1(ia), 0); };
do_search(Iter1(ia), Iter1(ia+sa), Iter2(ia), Iter2(ia+1), Iter1(ia), sa); template <class T, class U>
do_search(Iter1(ia), Iter1(ia+sa), Iter2(ia+1), Iter2(ia+2), Iter1(ia+1), sa); void make_pair(T&&, U&&) {}
EricWFUnsubmitted
Not Done
ReplyInline Actions

delete;

EricWF: = delete;
logan-5AuthorUnsubmitted
Done
ReplyInline Actions

What's the advantage of = delete;ing this function versus what I've done here?

logan-5: What's the advantage of `= delete;`ing this function versus what I've done here?
do_search(Iter1(ia), Iter1(ia+sa), Iter2(ia+2), Iter2(ia+2), Iter1(ia), 0); } // namespace User
do_search(Iter1(ia), Iter1(ia+sa), Iter2(ia+2), Iter2(ia+3), Iter1(ia+2), sa);
do_search(Iter1(ia), Iter1(ia+sa), Iter2(ia+2), Iter2(ia+3), Iter1(ia+2), sa); namespace std {
do_search(Iter1(ia), Iter1(ia), Iter2(ia+2), Iter2(ia+3), Iter1(ia), 0); template <> struct hash<User::S> {
do_search(Iter1(ia), Iter1(ia+sa), Iter2(ia+sa-1), Iter2(ia+sa), Iter1(ia+sa-1), sa); std::size_t operator()(const User::S& s) const
do_search(Iter1(ia), Iter1(ia+sa), Iter2(ia+sa-3), Iter2(ia+sa), Iter1(ia+sa-3), 3*sa); {
do_search(Iter1(ia), Iter1(ia+sa), Iter2(ia), Iter2(ia+sa), Iter1(ia), sa*sa); return s.x;
do_search(Iter1(ia), Iter1(ia+sa-1), Iter2(ia), Iter2(ia+sa), Iter1(ia+sa-1), (sa-1)*sa);
do_search(Iter1(ia), Iter1(ia+1), Iter2(ia), Iter2(ia+sa), Iter1(ia+1), sa);
int ib[] = {0, 1, 2, 0, 1, 2, 3, 0, 1, 2, 3, 4};
const unsigned sb = sizeof(ib)/sizeof(ib[0]);
int ic[] = {1};
do_search(Iter1(ib), Iter1(ib+sb), Iter2(ic), Iter2(ic+1), Iter1(ib+1), sb);
int id[] = {1, 2};
do_search(Iter1(ib), Iter1(ib+sb), Iter2(id), Iter2(id+2), Iter1(ib+1), sb*2);
int ie[] = {1, 2, 3};
do_search(Iter1(ib), Iter1(ib+sb), Iter2(ie), Iter2(ie+3), Iter1(ib+4), sb*3);
int ig[] = {1, 2, 3, 4};
do_search(Iter1(ib), Iter1(ib+sb), Iter2(ig), Iter2(ig+4), Iter1(ib+8), sb*4);
int ih[] = {0, 1, 1, 1, 1, 2, 3, 0, 1, 2, 3, 4};
const unsigned sh = sizeof(ih)/sizeof(ih[0]);
int ii[] = {1, 1, 2};
do_search(Iter1(ih), Iter1(ih+sh), Iter2(ii), Iter2(ii+3), Iter1(ih+3), sh*3);
} }
};
} // namespace std
template <class Iter1, class Iter2> template <class T, class Iter1, class Iter2>
void void
test2() test()
{ {
char ia[] = {0, 1, 2, 3, 4, 5}; T ia[] = {0, 1, 2, 3, 4, 5};
const unsigned sa = sizeof(ia)/sizeof(ia[0]); const unsigned sa = sizeof(ia)/sizeof(ia[0]);
do_search(Iter1(ia), Iter1(ia+sa), Iter2(ia), Iter2(ia), Iter1(ia), 0); do_search(Iter1(ia), Iter1(ia+sa), Iter2(ia), Iter2(ia), Iter1(ia), 0);
do_search(Iter1(ia), Iter1(ia+sa), Iter2(ia), Iter2(ia+1), Iter1(ia), sa); do_search(Iter1(ia), Iter1(ia+sa), Iter2(ia), Iter2(ia+1), Iter1(ia), sa);
do_search(Iter1(ia), Iter1(ia+sa), Iter2(ia+1), Iter2(ia+2), Iter1(ia+1), sa); do_search(Iter1(ia), Iter1(ia+sa), Iter2(ia+1), Iter2(ia+2), Iter1(ia+1), sa);
do_search(Iter1(ia), Iter1(ia+sa), Iter2(ia+2), Iter2(ia+2), Iter1(ia), 0); do_search(Iter1(ia), Iter1(ia+sa), Iter2(ia+2), Iter2(ia+2), Iter1(ia), 0);
do_search(Iter1(ia), Iter1(ia+sa), Iter2(ia+2), Iter2(ia+3), Iter1(ia+2), sa); do_search(Iter1(ia), Iter1(ia+sa), Iter2(ia+2), Iter2(ia+3), Iter1(ia+2), sa);
do_search(Iter1(ia), Iter1(ia+sa), Iter2(ia+2), Iter2(ia+3), Iter1(ia+2), sa); do_search(Iter1(ia), Iter1(ia+sa), Iter2(ia+2), Iter2(ia+3), Iter1(ia+2), sa);
do_search(Iter1(ia), Iter1(ia), Iter2(ia+2), Iter2(ia+3), Iter1(ia), 0); do_search(Iter1(ia), Iter1(ia), Iter2(ia+2), Iter2(ia+3), Iter1(ia), 0);
do_search(Iter1(ia), Iter1(ia+sa), Iter2(ia+sa-1), Iter2(ia+sa), Iter1(ia+sa-1), sa); do_search(Iter1(ia), Iter1(ia+sa), Iter2(ia+sa-1), Iter2(ia+sa), Iter1(ia+sa-1), sa);
do_search(Iter1(ia), Iter1(ia+sa), Iter2(ia+sa-3), Iter2(ia+sa), Iter1(ia+sa-3), 3*sa); do_search(Iter1(ia), Iter1(ia+sa), Iter2(ia+sa-3), Iter2(ia+sa), Iter1(ia+sa-3), 3*sa);
do_search(Iter1(ia), Iter1(ia+sa), Iter2(ia), Iter2(ia+sa), Iter1(ia), sa*sa); do_search(Iter1(ia), Iter1(ia+sa), Iter2(ia), Iter2(ia+sa), Iter1(ia), sa*sa);
do_search(Iter1(ia), Iter1(ia+sa-1), Iter2(ia), Iter2(ia+sa), Iter1(ia+sa-1), (sa-1)*sa); do_search(Iter1(ia), Iter1(ia+sa-1), Iter2(ia), Iter2(ia+sa), Iter1(ia+sa-1), (sa-1)*sa);
do_search(Iter1(ia), Iter1(ia+1), Iter2(ia), Iter2(ia+sa), Iter1(ia+1), sa); do_search(Iter1(ia), Iter1(ia+1), Iter2(ia), Iter2(ia+sa), Iter1(ia+1), sa);
char ib[] = {0, 1, 2, 0, 1, 2, 3, 0, 1, 2, 3, 4}; T ib[] = {0, 1, 2, 0, 1, 2, 3, 0, 1, 2, 3, 4};
const unsigned sb = sizeof(ib)/sizeof(ib[0]); const unsigned sb = sizeof(ib)/sizeof(ib[0]);
char ic[] = {1}; T ic[] = {1};
do_search(Iter1(ib), Iter1(ib+sb), Iter2(ic), Iter2(ic+1), Iter1(ib+1), sb); do_search(Iter1(ib), Iter1(ib+sb), Iter2(ic), Iter2(ic+1), Iter1(ib+1), sb);
char id[] = {1, 2}; T id[] = {1, 2};
do_search(Iter1(ib), Iter1(ib+sb), Iter2(id), Iter2(id+2), Iter1(ib+1), sb*2); do_search(Iter1(ib), Iter1(ib+sb), Iter2(id), Iter2(id+2), Iter1(ib+1), sb*2);
char ie[] = {1, 2, 3}; T ie[] = {1, 2, 3};
do_search(Iter1(ib), Iter1(ib+sb), Iter2(ie), Iter2(ie+3), Iter1(ib+4), sb*3); do_search(Iter1(ib), Iter1(ib+sb), Iter2(ie), Iter2(ie+3), Iter1(ib+4), sb*3);
char ig[] = {1, 2, 3, 4}; T ig[] = {1, 2, 3, 4};
do_search(Iter1(ib), Iter1(ib+sb), Iter2(ig), Iter2(ig+4), Iter1(ib+8), sb*4); do_search(Iter1(ib), Iter1(ib+sb), Iter2(ig), Iter2(ig+4), Iter1(ib+8), sb*4);
char ih[] = {0, 1, 1, 1, 1, 2, 3, 0, 1, 2, 3, 4}; T ih[] = {0, 1, 1, 1, 1, 2, 3, 0, 1, 2, 3, 4};
const unsigned sh = sizeof(ih)/sizeof(ih[0]); const unsigned sh = sizeof(ih)/sizeof(ih[0]);
char ii[] = {1, 1, 2}; T ii[] = {1, 1, 2};
do_search(Iter1(ih), Iter1(ih+sh), Iter2(ii), Iter2(ii+3), Iter1(ih+3), sh*3); do_search(Iter1(ih), Iter1(ih+sh), Iter2(ii), Iter2(ii+3), Iter1(ih+3), sh*3);
} }
int main(int, char**) { int main(int, char**) {
test<random_access_iterator<const int*>, random_access_iterator<const int*> >(); test<int, random_access_iterator<const int*>, random_access_iterator<const int*> >();
test2<random_access_iterator<const char*>, random_access_iterator<const char*> >(); test<char, random_access_iterator<const char*>, random_access_iterator<const char*> >();
test<User::S, random_access_iterator<const User::S*>, random_access_iterator<const User::S*> >();
return 0; return 0;
} }

libcxx/test/std/utilities/function.objects/func.search/func.search.default/default.pass.cpp

Show All 38 Lines
#include "test_iterators.h" #include "test_iterators.h"
template <typename Iter1, typename Iter2> template <typename Iter1, typename Iter2>
void do_search(Iter1 b1, Iter1 e1, Iter2 b2, Iter2 e2, Iter1 result) { void do_search(Iter1 b1, Iter1 e1, Iter2 b2, Iter2 e2, Iter1 result) {
std::default_searcher<Iter2> s{b2, e2}; std::default_searcher<Iter2> s{b2, e2};
assert(result == std::search(b1, e1, s)); assert(result == std::search(b1, e1, s));
} }
template <class Iter1, class Iter2> namespace User {
struct S {
S(int x) : x(x) {}
int x;
bool operator==(S other) const
{
return x == other.x;
}
};
template <class T, class U>
void make_pair(T&&, U&&) {}
} // namespace User
template <class T, class Iter1, class Iter2>
void void
test() test()
{ {
int ia[] = {0, 1, 2, 3, 4, 5}; T ia[] = {0, 1, 2, 3, 4, 5};
const unsigned sa = sizeof(ia)/sizeof(ia[0]); const unsigned sa = sizeof(ia)/sizeof(ia[0]);
do_search(Iter1(ia), Iter1(ia+sa), Iter2(ia), Iter2(ia), Iter1(ia)); do_search(Iter1(ia), Iter1(ia+sa), Iter2(ia), Iter2(ia), Iter1(ia));
do_search(Iter1(ia), Iter1(ia+sa), Iter2(ia), Iter2(ia+1), Iter1(ia)); do_search(Iter1(ia), Iter1(ia+sa), Iter2(ia), Iter2(ia+1), Iter1(ia));
do_search(Iter1(ia), Iter1(ia+sa), Iter2(ia+1), Iter2(ia+2), Iter1(ia+1)); do_search(Iter1(ia), Iter1(ia+sa), Iter2(ia+1), Iter2(ia+2), Iter1(ia+1));
do_search(Iter1(ia), Iter1(ia+sa), Iter2(ia+2), Iter2(ia+2), Iter1(ia)); do_search(Iter1(ia), Iter1(ia+sa), Iter2(ia+2), Iter2(ia+2), Iter1(ia));
do_search(Iter1(ia), Iter1(ia+sa), Iter2(ia+2), Iter2(ia+3), Iter1(ia+2)); do_search(Iter1(ia), Iter1(ia+sa), Iter2(ia+2), Iter2(ia+3), Iter1(ia+2));
do_search(Iter1(ia), Iter1(ia+sa), Iter2(ia+2), Iter2(ia+3), Iter1(ia+2)); do_search(Iter1(ia), Iter1(ia+sa), Iter2(ia+2), Iter2(ia+3), Iter1(ia+2));
do_search(Iter1(ia), Iter1(ia), Iter2(ia+2), Iter2(ia+3), Iter1(ia)); do_search(Iter1(ia), Iter1(ia), Iter2(ia+2), Iter2(ia+3), Iter1(ia));
do_search(Iter1(ia), Iter1(ia+sa), Iter2(ia+sa-1), Iter2(ia+sa), Iter1(ia+sa-1)); do_search(Iter1(ia), Iter1(ia+sa), Iter2(ia+sa-1), Iter2(ia+sa), Iter1(ia+sa-1));
do_search(Iter1(ia), Iter1(ia+sa), Iter2(ia+sa-3), Iter2(ia+sa), Iter1(ia+sa-3)); do_search(Iter1(ia), Iter1(ia+sa), Iter2(ia+sa-3), Iter2(ia+sa), Iter1(ia+sa-3));
do_search(Iter1(ia), Iter1(ia+sa), Iter2(ia), Iter2(ia+sa), Iter1(ia)); do_search(Iter1(ia), Iter1(ia+sa), Iter2(ia), Iter2(ia+sa), Iter1(ia));
do_search(Iter1(ia), Iter1(ia+sa-1), Iter2(ia), Iter2(ia+sa), Iter1(ia+sa-1)); do_search(Iter1(ia), Iter1(ia+sa-1), Iter2(ia), Iter2(ia+sa), Iter1(ia+sa-1));
do_search(Iter1(ia), Iter1(ia+1), Iter2(ia), Iter2(ia+sa), Iter1(ia+1)); do_search(Iter1(ia), Iter1(ia+1), Iter2(ia), Iter2(ia+sa), Iter1(ia+1));
int ib[] = {0, 1, 2, 0, 1, 2, 3, 0, 1, 2, 3, 4}; T ib[] = {0, 1, 2, 0, 1, 2, 3, 0, 1, 2, 3, 4};
const unsigned sb = sizeof(ib)/sizeof(ib[0]); const unsigned sb = sizeof(ib)/sizeof(ib[0]);
int ic[] = {1}; T ic[] = {1};
do_search(Iter1(ib), Iter1(ib+sb), Iter2(ic), Iter2(ic+1), Iter1(ib+1)); do_search(Iter1(ib), Iter1(ib+sb), Iter2(ic), Iter2(ic+1), Iter1(ib+1));
int id[] = {1, 2}; T id[] = {1, 2};
do_search(Iter1(ib), Iter1(ib+sb), Iter2(id), Iter2(id+2), Iter1(ib+1)); do_search(Iter1(ib), Iter1(ib+sb), Iter2(id), Iter2(id+2), Iter1(ib+1));
int ie[] = {1, 2, 3}; T ie[] = {1, 2, 3};
do_search(Iter1(ib), Iter1(ib+sb), Iter2(ie), Iter2(ie+3), Iter1(ib+4)); do_search(Iter1(ib), Iter1(ib+sb), Iter2(ie), Iter2(ie+3), Iter1(ib+4));
int ig[] = {1, 2, 3, 4}; T ig[] = {1, 2, 3, 4};
do_search(Iter1(ib), Iter1(ib+sb), Iter2(ig), Iter2(ig+4), Iter1(ib+8)); do_search(Iter1(ib), Iter1(ib+sb), Iter2(ig), Iter2(ig+4), Iter1(ib+8));
int ih[] = {0, 1, 1, 1, 1, 2, 3, 0, 1, 2, 3, 4}; T ih[] = {0, 1, 1, 1, 1, 2, 3, 0, 1, 2, 3, 4};
const unsigned sh = sizeof(ih)/sizeof(ih[0]); const unsigned sh = sizeof(ih)/sizeof(ih[0]);
int ii[] = {1, 1, 2}; T ii[] = {1, 1, 2};
do_search(Iter1(ih), Iter1(ih+sh), Iter2(ii), Iter2(ii+3), Iter1(ih+3)); do_search(Iter1(ih), Iter1(ih+sh), Iter2(ii), Iter2(ii+3), Iter1(ih+3));
int ij[] = {0, 1, 0, 0, 1, 0, 0, 0, 0, 0, 1, 1, 1, 1, 0, 0}; T ij[] = {0, 1, 0, 0, 1, 0, 0, 0, 0, 0, 1, 1, 1, 1, 0, 0};
const unsigned sj = sizeof(ij)/sizeof(ij[0]); const unsigned sj = sizeof(ij)/sizeof(ij[0]);
int ik[] = {0, 0, 0, 0, 1, 1, 1, 1, 0, 0}; T ik[] = {0, 0, 0, 0, 1, 1, 1, 1, 0, 0};
const unsigned sk = sizeof(ik)/sizeof(ik[0]); const unsigned sk = sizeof(ik)/sizeof(ik[0]);
do_search(Iter1(ij), Iter1(ij+sj), Iter2(ik), Iter2(ik+sk), Iter1(ij+6)); do_search(Iter1(ij), Iter1(ij+sj), Iter2(ik), Iter2(ik+sk), Iter1(ij+6));
} }
int main(int, char**) { int main(int, char**) {
test<forward_iterator<const int*>, forward_iterator<const int*> >(); test<int, forward_iterator<const int*>, forward_iterator<const int*> >();
test<forward_iterator<const int*>, bidirectional_iterator<const int*> >(); test<int, forward_iterator<const int*>, bidirectional_iterator<const int*> >();
test<forward_iterator<const int*>, random_access_iterator<const int*> >(); test<int, forward_iterator<const int*>, random_access_iterator<const int*> >();
test<bidirectional_iterator<const int*>, forward_iterator<const int*> >(); test<int, bidirectional_iterator<const int*>, forward_iterator<const int*> >();
test<bidirectional_iterator<const int*>, bidirectional_iterator<const int*> >(); test<int, bidirectional_iterator<const int*>, bidirectional_iterator<const int*> >();
test<bidirectional_iterator<const int*>, random_access_iterator<const int*> >(); test<int, bidirectional_iterator<const int*>, random_access_iterator<const int*> >();
test<random_access_iterator<const int*>, forward_iterator<const int*> >(); test<int, random_access_iterator<const int*>, forward_iterator<const int*> >();
test<random_access_iterator<const int*>, bidirectional_iterator<const int*> >(); test<int, random_access_iterator<const int*>, bidirectional_iterator<const int*> >();
test<random_access_iterator<const int*>, random_access_iterator<const int*> >(); test<int, random_access_iterator<const int*>, random_access_iterator<const int*> >();
test<User::S, forward_iterator<const User::S*>, forward_iterator<const User::S*> >();
test<User::S, forward_iterator<const User::S*>, bidirectional_iterator<const User::S*> >();
test<User::S, forward_iterator<const User::S*>, random_access_iterator<const User::S*> >();
test<User::S, bidirectional_iterator<const User::S*>, forward_iterator<const User::S*> >();
test<User::S, bidirectional_iterator<const User::S*>, bidirectional_iterator<const User::S*> >();
test<User::S, bidirectional_iterator<const User::S*>, random_access_iterator<const User::S*> >();
test<User::S, random_access_iterator<const User::S*>, forward_iterator<const User::S*> >();
test<User::S, random_access_iterator<const User::S*>, bidirectional_iterator<const User::S*> >();
test<User::S, random_access_iterator<const User::S*>, random_access_iterator<const User::S*> >();
return 0; return 0;
} }

libcxx/test/std/utilities/function.objects/func.search/func.search.default/default.pred.pass.cpp

Show First 20 Lines • Show All 50 Lines • ▼ Show 20 Lines
template <typename Iter1, typename Iter2> template <typename Iter1, typename Iter2>
void do_search(Iter1 b1, Iter1 e1, Iter2 b2, Iter2 e2, Iter1 result, unsigned max_count) { void do_search(Iter1 b1, Iter1 e1, Iter2 b2, Iter2 e2, Iter1 result, unsigned max_count) {
std::default_searcher<Iter2, count_equal> s{b2, e2}; std::default_searcher<Iter2, count_equal> s{b2, e2};
count_equal::count = 0; count_equal::count = 0;
assert(result == std::search(b1, e1, s)); assert(result == std::search(b1, e1, s));
assert(count_equal::count <= max_count); assert(count_equal::count <= max_count);
} }
template <class Iter1, class Iter2> namespace User {
struct S {
S(int x) : x(x) {}
int x;
bool operator==(S other) const
{
return x == other.x;
}
};
template <class T, class U>
void make_pair(T&&, U&&) {}
} // namespace User
template <class T, class Iter1, class Iter2>
void void
test() test()
{ {
int ia[] = {0, 1, 2, 3, 4, 5}; T ia[] = {0, 1, 2, 3, 4, 5};
const unsigned sa = sizeof(ia)/sizeof(ia[0]); const unsigned sa = sizeof(ia)/sizeof(ia[0]);
do_search(Iter1(ia), Iter1(ia+sa), Iter2(ia), Iter2(ia), Iter1(ia), 0); do_search(Iter1(ia), Iter1(ia+sa), Iter2(ia), Iter2(ia), Iter1(ia), 0);
do_search(Iter1(ia), Iter1(ia+sa), Iter2(ia), Iter2(ia+1), Iter1(ia), sa); do_search(Iter1(ia), Iter1(ia+sa), Iter2(ia), Iter2(ia+1), Iter1(ia), sa);
do_search(Iter1(ia), Iter1(ia+sa), Iter2(ia+1), Iter2(ia+2), Iter1(ia+1), sa); do_search(Iter1(ia), Iter1(ia+sa), Iter2(ia+1), Iter2(ia+2), Iter1(ia+1), sa);
do_search(Iter1(ia), Iter1(ia+sa), Iter2(ia+2), Iter2(ia+2), Iter1(ia), 0); do_search(Iter1(ia), Iter1(ia+sa), Iter2(ia+2), Iter2(ia+2), Iter1(ia), 0);
do_search(Iter1(ia), Iter1(ia+sa), Iter2(ia+2), Iter2(ia+3), Iter1(ia+2), sa); do_search(Iter1(ia), Iter1(ia+sa), Iter2(ia+2), Iter2(ia+3), Iter1(ia+2), sa);
do_search(Iter1(ia), Iter1(ia+sa), Iter2(ia+2), Iter2(ia+3), Iter1(ia+2), sa); do_search(Iter1(ia), Iter1(ia+sa), Iter2(ia+2), Iter2(ia+3), Iter1(ia+2), sa);
do_search(Iter1(ia), Iter1(ia), Iter2(ia+2), Iter2(ia+3), Iter1(ia), 0); do_search(Iter1(ia), Iter1(ia), Iter2(ia+2), Iter2(ia+3), Iter1(ia), 0);
do_search(Iter1(ia), Iter1(ia+sa), Iter2(ia+sa-1), Iter2(ia+sa), Iter1(ia+sa-1), sa); do_search(Iter1(ia), Iter1(ia+sa), Iter2(ia+sa-1), Iter2(ia+sa), Iter1(ia+sa-1), sa);
do_search(Iter1(ia), Iter1(ia+sa), Iter2(ia+sa-3), Iter2(ia+sa), Iter1(ia+sa-3), 3*sa); do_search(Iter1(ia), Iter1(ia+sa), Iter2(ia+sa-3), Iter2(ia+sa), Iter1(ia+sa-3), 3*sa);
do_search(Iter1(ia), Iter1(ia+sa), Iter2(ia), Iter2(ia+sa), Iter1(ia), sa*sa); do_search(Iter1(ia), Iter1(ia+sa), Iter2(ia), Iter2(ia+sa), Iter1(ia), sa*sa);
do_search(Iter1(ia), Iter1(ia+sa-1), Iter2(ia), Iter2(ia+sa), Iter1(ia+sa-1), (sa-1)*sa); do_search(Iter1(ia), Iter1(ia+sa-1), Iter2(ia), Iter2(ia+sa), Iter1(ia+sa-1), (sa-1)*sa);
do_search(Iter1(ia), Iter1(ia+1), Iter2(ia), Iter2(ia+sa), Iter1(ia+1), sa); do_search(Iter1(ia), Iter1(ia+1), Iter2(ia), Iter2(ia+sa), Iter1(ia+1), sa);
int ib[] = {0, 1, 2, 0, 1, 2, 3, 0, 1, 2, 3, 4}; T ib[] = {0, 1, 2, 0, 1, 2, 3, 0, 1, 2, 3, 4};
const unsigned sb = sizeof(ib)/sizeof(ib[0]); const unsigned sb = sizeof(ib)/sizeof(ib[0]);
int ic[] = {1}; T ic[] = {1};
do_search(Iter1(ib), Iter1(ib+sb), Iter2(ic), Iter2(ic+1), Iter1(ib+1), sb); do_search(Iter1(ib), Iter1(ib+sb), Iter2(ic), Iter2(ic+1), Iter1(ib+1), sb);
int id[] = {1, 2}; T id[] = {1, 2};
do_search(Iter1(ib), Iter1(ib+sb), Iter2(id), Iter2(id+2), Iter1(ib+1), sb*2); do_search(Iter1(ib), Iter1(ib+sb), Iter2(id), Iter2(id+2), Iter1(ib+1), sb*2);
int ie[] = {1, 2, 3}; T ie[] = {1, 2, 3};
do_search(Iter1(ib), Iter1(ib+sb), Iter2(ie), Iter2(ie+3), Iter1(ib+4), sb*3); do_search(Iter1(ib), Iter1(ib+sb), Iter2(ie), Iter2(ie+3), Iter1(ib+4), sb*3);
int ig[] = {1, 2, 3, 4}; T ig[] = {1, 2, 3, 4};
do_search(Iter1(ib), Iter1(ib+sb), Iter2(ig), Iter2(ig+4), Iter1(ib+8), sb*4); do_search(Iter1(ib), Iter1(ib+sb), Iter2(ig), Iter2(ig+4), Iter1(ib+8), sb*4);
int ih[] = {0, 1, 1, 1, 1, 2, 3, 0, 1, 2, 3, 4}; T ih[] = {0, 1, 1, 1, 1, 2, 3, 0, 1, 2, 3, 4};
const unsigned sh = sizeof(ih)/sizeof(ih[0]); const unsigned sh = sizeof(ih)/sizeof(ih[0]);
int ii[] = {1, 1, 2}; T ii[] = {1, 1, 2};
do_search(Iter1(ih), Iter1(ih+sh), Iter2(ii), Iter2(ii+3), Iter1(ih+3), sh*3); do_search(Iter1(ih), Iter1(ih+sh), Iter2(ii), Iter2(ii+3), Iter1(ih+3), sh*3);
} }
int main(int, char**) { int main(int, char**) {
test<forward_iterator<const int*>, forward_iterator<const int*> >(); test<int, forward_iterator<const int*>, forward_iterator<const int*> >();
test<forward_iterator<const int*>, bidirectional_iterator<const int*> >(); test<int, forward_iterator<const int*>, bidirectional_iterator<const int*> >();
test<forward_iterator<const int*>, random_access_iterator<const int*> >(); test<int, forward_iterator<const int*>, random_access_iterator<const int*> >();
test<bidirectional_iterator<const int*>, forward_iterator<const int*> >(); test<int, bidirectional_iterator<const int*>, forward_iterator<const int*> >();
test<bidirectional_iterator<const int*>, bidirectional_iterator<const int*> >(); test<int, bidirectional_iterator<const int*>, bidirectional_iterator<const int*> >();
test<bidirectional_iterator<const int*>, random_access_iterator<const int*> >(); test<int, bidirectional_iterator<const int*>, random_access_iterator<const int*> >();
test<random_access_iterator<const int*>, forward_iterator<const int*> >(); test<int, random_access_iterator<const int*>, forward_iterator<const int*> >();
test<random_access_iterator<const int*>, bidirectional_iterator<const int*> >(); test<int, random_access_iterator<const int*>, bidirectional_iterator<const int*> >();
test<random_access_iterator<const int*>, random_access_iterator<const int*> >(); test<int, random_access_iterator<const int*>, random_access_iterator<const int*> >();
test<User::S, forward_iterator<const User::S*>, forward_iterator<const User::S*> >();
test<User::S, forward_iterator<const User::S*>, bidirectional_iterator<const User::S*> >();
test<User::S, forward_iterator<const User::S*>, random_access_iterator<const User::S*> >();
test<User::S, bidirectional_iterator<const User::S*>, forward_iterator<const User::S*> >();
test<User::S, bidirectional_iterator<const User::S*>, bidirectional_iterator<const User::S*> >();
test<User::S, bidirectional_iterator<const User::S*>, random_access_iterator<const User::S*> >();
test<User::S, random_access_iterator<const User::S*>, forward_iterator<const User::S*> >();
test<User::S, random_access_iterator<const User::S*>, bidirectional_iterator<const User::S*> >();
test<User::S, random_access_iterator<const User::S*>, random_access_iterator<const User::S*> >();
return 0; return 0;
} }