This is an archive of the discontinued LLVM Phabricator instance.

Differential D26294

[libcxx] [test] Replace _LIBCPP_STD_VER with TEST_STD_VER.
ClosedPublic

Authored by STL_MSFT on Nov 3 2016, 6:58 PM.

Details

Reviewers
mclow.lists
EricWF
Summary

This replaces every occurrence of _LIBCPP_STD_VER in the tests with TEST_STD_VER. Additionally, for every affected file, #include "test_macros.h" is being added explicitly if it wasn't already there.

Diff Detail

Event Timeline

STL_MSFT updated this revision to Diff 76905.Nov 3 2016, 6:58 PM
STL_MSFT retitled this revision from to [libcxx] [test] Replace _LIBCPP_STD_VER with TEST_STD_VER..
STL_MSFT updated this object.
STL_MSFT added reviewers: EricWF, mclow.lists.
STL_MSFT added a subscriber: cfe-commits.
EricWF accepted this revision.Nov 4 2016, 12:56 PM
EricWF edited edge metadata.

LGTM. Holy crap. Thanks STL!

Just a note _LIBCPP_STD_VER is set to 11 in C++03 mode, it's silly but that's the way it is. So that makes me wonder if some of the _LIBCPP_STD_VER > 11 really should be TEST_STD_VER >= 11, since they may have just been disabling the test in C++03. Either way this preserves the status quo.

This revision is now accepted and ready to land.Nov 4 2016, 12:56 PM
STL_MSFT closed this revision.Nov 4 2016, 1:46 PM

Committed as r286007.

Revision Contents

PathSize
test/
std/
containers/
associative/
map/
map.access/
3 lines
map.cons/
3 lines
map.ops/
3 lines
5 lines
5 lines
5 lines
3 lines
5 lines
5 lines
5 lines
3 lines
5 lines
5 lines
5 lines
3 lines
3 lines
3 lines
3 lines
3 lines
3 lines
3 lines
3 lines
multimap/
3 lines
multimap.cons/
3 lines
multimap.ops/
3 lines
5 lines
5 lines
5 lines
3 lines
5 lines
5 lines
5 lines
3 lines
5 lines
5 lines
5 lines
3 lines
3 lines
3 lines
3 lines
3 lines
3 lines
3 lines
3 lines
multiset/
3 lines
3 lines
3 lines
3 lines
3 lines
multiset.cons/
3 lines
3 lines
3 lines
set/
3 lines
3 lines
3 lines
3 lines
3 lines
set.cons/
3 lines
3 lines
3 lines
sequences/
array/
4 lines
deque/
deque.cons/
7 lines
3 lines
forwardlist/
forwardlist.cons/
3 lines
forwardlist.iter/
3 lines
list/
3 lines
list.cons/
5 lines
vector.bool/
3 lines
vector/
3 lines
unord/
unord.map/
3 lines
unord.map.cnstr/
3 lines
3 lines
unord.multimap/
3 lines
unord.multimap.cnstr/
2 lines
3 lines
3 lines
unord.multiset/
3 lines
unord.multiset.cnstr/
2 lines
3 lines
3 lines
unord.set/
3 lines
unord.set.cnstr/
2 lines
3 lines
3 lines
experimental/
optional/
optional.nullops/
4 lines
string.view/
string.view.access/
2 lines
2 lines
string.view.capacity/
2 lines
string.view.comparison/
3 lines
3 lines
3 lines
3 lines
3 lines
3 lines
3 lines
3 lines
3 lines
3 lines
3 lines
3 lines
string.view.cons/
4 lines
3 lines
8 lines
string.view.find/
3 lines
3 lines
3 lines
3 lines
3 lines
3 lines
3 lines
3 lines
3 lines
3 lines
3 lines
3 lines
3 lines
3 lines
3 lines
3 lines
3 lines
3 lines
3 lines
3 lines
string.view.iterators/
2 lines
2 lines
string.view.modifiers/
4 lines
4 lines
4 lines
4 lines
string.view.nonmem/
4 lines
string.view.ops/
3 lines
3 lines
input.output/
file.streams/
c.files/
4 lines
iterators/
iterator.range/
12 lines
language.support/
support.initlist/
support.initlist.access/
10 lines
support.initlist.cons/
6 lines
support.initlist.range/
10 lines
localization/
locales/
locale.convenience/
conversions/
conversions.buffer/
3 lines
conversions.string/
4 lines
4 lines
numerics/
complex.number/
cmplx.over/
5 lines
5 lines
complex.members/
4 lines
complex.ops/
4 lines
4 lines
4 lines
4 lines
4 lines
4 lines
strings/
string.view/
string.view.access/
2 lines
2 lines
string.view.capacity/
2 lines
string.view.comparison/
3 lines
3 lines
3 lines
3 lines
3 lines
3 lines
3 lines
3 lines
3 lines
3 lines
3 lines
3 lines
string.view.cons/
4 lines
3 lines
8 lines
string.view.find/
3 lines
3 lines
3 lines
3 lines
3 lines
3 lines
3 lines
3 lines
3 lines
3 lines
3 lines
3 lines
3 lines
3 lines
3 lines
3 lines
3 lines
3 lines
3 lines
3 lines
string.view.iterators/
2 lines
2 lines
string.view.modifiers/
4 lines
4 lines
4 lines
4 lines
string.view.nonmem/
4 lines
string.view.ops/
3 lines
3 lines
utilities/
function.objects/
arithmetic.operations/
4 lines
4 lines
4 lines
4 lines
4 lines
4 lines
bitwise.operations/
4 lines
4 lines
4 lines
logical.operations/
4 lines
4 lines
4 lines
intseq/
intseq.intseq/
6 lines
memory/
storage.iterator/
3 lines
meta/
meta.help/
4 lines
meta.trans/
meta.trans.arr/
4 lines
4 lines
meta.trans.cv/
4 lines
4 lines
4 lines
4 lines
4 lines
4 lines
meta.trans.other/
20 lines
4 lines
4 lines
4 lines
meta.trans.sign/
2 lines
2 lines
meta.unary/
meta.unary.cat/
4 lines
4 lines
time/
time.point/
time.point.cast/
6 lines
time.point.comparisons/
4 lines
4 lines
time.point.cons/
4 lines
3 lines
4 lines
time.point.nonmember/
4 lines
4 lines
4 lines
tuple/
tuple.tuple/
tuple.helper/
4 lines
tuple.cnstr/
3 lines
5 lines
4 lines
6 lines
4 lines
tuple.creation/
6 lines
4 lines
4 lines
3 lines
tuple.elem/
4 lines
2 lines
tuple.rel/
4 lines
4 lines
utility/
pairs/
pairs.spec/
4 lines
support/
4 lines

Diff 76905

test/std/containers/associative/map/map.access/iterator.pass.cpp

Show All 23 Lines
// const_iterator cbegin() const; // const_iterator cbegin() const;
// const_iterator cend() const; // const_iterator cend() const;
// const_reverse_iterator crbegin() const; // const_reverse_iterator crbegin() const;
// const_reverse_iterator crend() const; // const_reverse_iterator crend() const;
#include <map> #include <map>
#include <cassert> #include <cassert>
#include "test_macros.h"
#include "min_allocator.h" #include "min_allocator.h"
int main() int main()
{ {
{ {
typedef std::pair<const int, double> V; typedef std::pair<const int, double> V;
V ar[] = V ar[] =
{ {
▲ Show 20 Lines • Show All 162 Lines • ▼ Show 20 Lines#if TEST_STD_VER >= 11
i = m.begin(); i = m.begin();
for (int j = 1; j <= m.size(); ++j, ++i) for (int j = 1; j <= m.size(); ++j, ++i)
{ {
assert(i->first == j); assert(i->first == j);
assert(i->second == 1); assert(i->second == 1);
} }
} }
#endif #endif
#if _LIBCPP_STD_VER > 11 #if TEST_STD_VER > 11
{ // N3644 testing { // N3644 testing
typedef std::map<int, double> C; typedef std::map<int, double> C;
C::iterator ii1{}, ii2{}; C::iterator ii1{}, ii2{};
C::iterator ii4 = ii1; C::iterator ii4 = ii1;
C::const_iterator cii{}; C::const_iterator cii{};
assert ( ii1 == ii2 ); assert ( ii1 == ii2 );
assert ( ii1 == ii4 ); assert ( ii1 == ii4 );
Show All 9 Lines

test/std/containers/associative/map/map.cons/iter_iter_comp_alloc.pass.cpp

Show All 12 Lines
// template <class InputIterator> // template <class InputIterator>
// map(InputIterator first, InputIterator last, // map(InputIterator first, InputIterator last,
// const key_compare& comp, const allocator_type& a); // const key_compare& comp, const allocator_type& a);
#include <map> #include <map>
#include <cassert> #include <cassert>
#include "test_macros.h"
#include "../../../test_compare.h" #include "../../../test_compare.h"
#include "test_allocator.h" #include "test_allocator.h"
#include "min_allocator.h" #include "min_allocator.h"
int main() int main()
{ {
{ {
typedef std::pair<const int, double> V; typedef std::pair<const int, double> V;
▲ Show 20 Lines • Show All 41 Lines • ▼ Show 20 Lines#if TEST_STD_VER >= 11
assert(m.get_allocator() == A()); assert(m.get_allocator() == A());
assert(m.key_comp() == C(5)); assert(m.key_comp() == C(5));
assert(m.size() == 3); assert(m.size() == 3);
assert(distance(m.begin(), m.end()) == 3); assert(distance(m.begin(), m.end()) == 3);
assert(*m.begin() == V(1, 1)); assert(*m.begin() == V(1, 1));
assert(*next(m.begin()) == V(2, 1)); assert(*next(m.begin()) == V(2, 1));
assert(*next(m.begin(), 2) == V(3, 1)); assert(*next(m.begin(), 2) == V(3, 1));
} }
#if _LIBCPP_STD_VER > 11 #if TEST_STD_VER > 11
{ {
typedef std::pair<const int, double> V; typedef std::pair<const int, double> V;
V ar[] = V ar[] =
{ {
V(1, 1), V(1, 1),
V(1, 1.5), V(1, 1.5),
V(1, 2), V(1, 2),
V(2, 1), V(2, 1),
Show All 38 Lines

test/std/containers/associative/map/map.ops/count.pass.cpp

Show All 10 Lines
// class map // class map
// size_type count(const key_type& k) const; // size_type count(const key_type& k) const;
#include <map> #include <map>
#include <cassert> #include <cassert>
#include "test_macros.h"
#include "min_allocator.h" #include "min_allocator.h"
#include "private_constructor.hpp" #include "private_constructor.hpp"
#include "is_transparent.h" #include "is_transparent.h"
int main() int main()
{ {
{ {
typedef std::pair<const int, double> V; typedef std::pair<const int, double> V;
▲ Show 20 Lines • Show All 66 Lines • ▼ Show 20 Lines typedef std::map<int, double, std::less<int>, min_allocator<V>> M;
assert(r == 1); assert(r == 1);
r = m.count(12); r = m.count(12);
assert(r == 1); assert(r == 1);
r = m.count(4); r = m.count(4);
assert(r == 0); assert(r == 0);
} }
} }
#endif #endif
#if _LIBCPP_STD_VER > 11 #if TEST_STD_VER > 11
{ {
typedef std::pair<const int, double> V; typedef std::pair<const int, double> V;
typedef std::map<int, double, std::less <>> M; typedef std::map<int, double, std::less <>> M;
typedef M::size_type R; typedef M::size_type R;
V ar[] = V ar[] =
{ {
V(5, 5), V(5, 5),
▲ Show 20 Lines • Show All 84 Lines • Show Last 20 Lines

test/std/containers/associative/map/map.ops/count1.fail.cpp

Show All 16 Lines
// The member function templates find, count, lower_bound, upper_bound, and // The member function templates find, count, lower_bound, upper_bound, and
// equal_range shall not participate in overload resolution unless the // equal_range shall not participate in overload resolution unless the
// qualified-id Compare::is_transparent is valid and denotes a type // qualified-id Compare::is_transparent is valid and denotes a type
#include <map> #include <map>
#include <cassert> #include <cassert>
#include "test_macros.h"
#include "is_transparent.h" #include "is_transparent.h"
#if _LIBCPP_STD_VER <= 11 #if TEST_STD_VER <= 11
#error "This test requires is C++14 (or later)" #error "This test requires is C++14 (or later)"
#else #else
int main() int main()
{ {
{ {
typedef std::map<int, double, transparent_less_no_type> M; typedef std::map<int, double, transparent_less_no_type> M;
M().count(C2Int{5}); M().count(C2Int{5});
} }
} }
#endif #endif
No newline at end of file

test/std/containers/associative/map/map.ops/count2.fail.cpp

Show All 16 Lines
// The member function templates find, count, lower_bound, upper_bound, and // The member function templates find, count, lower_bound, upper_bound, and
// equal_range shall not participate in overload resolution unless the // equal_range shall not participate in overload resolution unless the
// qualified-id Compare::is_transparent is valid and denotes a type // qualified-id Compare::is_transparent is valid and denotes a type
#include <map> #include <map>
#include <cassert> #include <cassert>
#include "test_macros.h"
#include "is_transparent.h" #include "is_transparent.h"
#if _LIBCPP_STD_VER <= 11 #if TEST_STD_VER <= 11
#error "This test requires is C++14 (or later)" #error "This test requires is C++14 (or later)"
#else #else
int main() int main()
{ {
{ {
typedef std::map<int, double, transparent_less_private> M; typedef std::map<int, double, transparent_less_private> M;
M().count(C2Int{5}); M().count(C2Int{5});
} }
} }
#endif #endif
No newline at end of file

test/std/containers/associative/map/map.ops/count3.fail.cpp

Show All 16 Lines
// The member function templates find, count, lower_bound, upper_bound, and // The member function templates find, count, lower_bound, upper_bound, and
// equal_range shall not participate in overload resolution unless the // equal_range shall not participate in overload resolution unless the
// qualified-id Compare::is_transparent is valid and denotes a type // qualified-id Compare::is_transparent is valid and denotes a type
#include <map> #include <map>
#include <cassert> #include <cassert>
#include "test_macros.h"
#include "is_transparent.h" #include "is_transparent.h"
#if _LIBCPP_STD_VER <= 11 #if TEST_STD_VER <= 11
#error "This test requires is C++14 (or later)" #error "This test requires is C++14 (or later)"
#else #else
int main() int main()
{ {
{ {
typedef std::map<int, double, transparent_less_not_a_type> M; typedef std::map<int, double, transparent_less_not_a_type> M;
M().count(C2Int{5}); M().count(C2Int{5});
} }
} }
#endif #endif
No newline at end of file

test/std/containers/associative/map/map.ops/equal_range.pass.cpp

Show All 11 Lines
// class map // class map
// pair<iterator,iterator> equal_range(const key_type& k); // pair<iterator,iterator> equal_range(const key_type& k);
// pair<const_iterator,const_iterator> equal_range(const key_type& k) const; // pair<const_iterator,const_iterator> equal_range(const key_type& k) const;
#include <map> #include <map>
#include <cassert> #include <cassert>
#include "test_macros.h"
#include "min_allocator.h" #include "min_allocator.h"
#include "private_constructor.hpp" #include "private_constructor.hpp"
#include "is_transparent.h" #include "is_transparent.h"
int main() int main()
{ {
{ {
typedef std::pair<const int, double> V; typedef std::pair<const int, double> V;
▲ Show 20 Lines • Show All 264 Lines • ▼ Show 20 Lines typedef std::map<int, double, std::less<int>, min_allocator<V>> M;
assert(r.first == next(m.begin(), 7)); assert(r.first == next(m.begin(), 7));
assert(r.second == next(m.begin(), 7)); assert(r.second == next(m.begin(), 7));
r = m.equal_range(20); r = m.equal_range(20);
assert(r.first == next(m.begin(), 8)); assert(r.first == next(m.begin(), 8));
assert(r.second == next(m.begin(), 8)); assert(r.second == next(m.begin(), 8));
} }
} }
#endif #endif
#if _LIBCPP_STD_VER > 11 #if TEST_STD_VER > 11
{ {
typedef std::pair<const int, double> V; typedef std::pair<const int, double> V;
typedef std::map<int, double, std::less<>> M; typedef std::map<int, double, std::less<>> M;
typedef std::pair<M::iterator, M::iterator> R; typedef std::pair<M::iterator, M::iterator> R;
V ar[] = V ar[] =
{ {
V(5, 5), V(5, 5),
▲ Show 20 Lines • Show All 182 Lines • Show Last 20 Lines

test/std/containers/associative/map/map.ops/equal_range1.fail.cpp

Show All 16 Lines
// The member function templates find, count, lower_bound, upper_bound, and // The member function templates find, count, lower_bound, upper_bound, and
// equal_range shall not participate in overload resolution unless the // equal_range shall not participate in overload resolution unless the
// qualified-id Compare::is_transparent is valid and denotes a type // qualified-id Compare::is_transparent is valid and denotes a type
#include <map> #include <map>
#include <cassert> #include <cassert>
#include "test_macros.h"
#include "is_transparent.h" #include "is_transparent.h"
#if _LIBCPP_STD_VER <= 11 #if TEST_STD_VER <= 11
#error "This test requires is C++14 (or later)" #error "This test requires is C++14 (or later)"
#else #else
int main() int main()
{ {
{ {
typedef std::map<int, double, transparent_less_no_type> M; typedef std::map<int, double, transparent_less_no_type> M;
M().equal_range(C2Int{5}); M().equal_range(C2Int{5});
} }
} }
#endif #endif
No newline at end of file

test/std/containers/associative/map/map.ops/equal_range2.fail.cpp

Show All 16 Lines
// The member function templates find, count, lower_bound, upper_bound, and // The member function templates find, count, lower_bound, upper_bound, and
// equal_range shall not participate in overload resolution unless the // equal_range shall not participate in overload resolution unless the
// qualified-id Compare::is_transparent is valid and denotes a type // qualified-id Compare::is_transparent is valid and denotes a type
#include <map> #include <map>
#include <cassert> #include <cassert>
#include "test_macros.h"
#include "is_transparent.h" #include "is_transparent.h"
#if _LIBCPP_STD_VER <= 11 #if TEST_STD_VER <= 11
#error "This test requires is C++14 (or later)" #error "This test requires is C++14 (or later)"
#else #else
int main() int main()
{ {
{ {
typedef std::map<int, double, transparent_less_private> M; typedef std::map<int, double, transparent_less_private> M;
M().equal_range(C2Int{5}); M().equal_range(C2Int{5});
} }
} }
#endif #endif
No newline at end of file

test/std/containers/associative/map/map.ops/equal_range3.fail.cpp

Show All 16 Lines
// The member function templates find, count, lower_bound, upper_bound, and // The member function templates find, count, lower_bound, upper_bound, and
// equal_range shall not participate in overload resolution unless the // equal_range shall not participate in overload resolution unless the
// qualified-id Compare::is_transparent is valid and denotes a type // qualified-id Compare::is_transparent is valid and denotes a type
#include <map> #include <map>
#include <cassert> #include <cassert>
#include "test_macros.h"
#include "is_transparent.h" #include "is_transparent.h"
#if _LIBCPP_STD_VER <= 11 #if TEST_STD_VER <= 11
#error "This test requires is C++14 (or later)" #error "This test requires is C++14 (or later)"
#else #else
int main() int main()
{ {
{ {
typedef std::map<int, double, transparent_less_not_a_type> M; typedef std::map<int, double, transparent_less_not_a_type> M;
M().equal_range(C2Int{5}); M().equal_range(C2Int{5});
} }
} }
#endif #endif
No newline at end of file

test/std/containers/associative/map/map.ops/find.pass.cpp

Show All 11 Lines
// class map // class map
// iterator find(const key_type& k); // iterator find(const key_type& k);
// const_iterator find(const key_type& k) const; // const_iterator find(const key_type& k) const;
#include <map> #include <map>
#include <cassert> #include <cassert>
#include "test_macros.h"
#include "min_allocator.h" #include "min_allocator.h"
#include "private_constructor.hpp" #include "private_constructor.hpp"
#include "is_transparent.h" #include "is_transparent.h"
int main() int main()
{ {
{ {
typedef std::pair<const int, double> V; typedef std::pair<const int, double> V;
▲ Show 20 Lines • Show All 132 Lines • ▼ Show 20 Lines typedef std::map<int, double, std::less<int>, min_allocator<V>> M;
assert(r == next(m.begin(), 6)); assert(r == next(m.begin(), 6));
r = m.find(12); r = m.find(12);
assert(r == next(m.begin(), 7)); assert(r == next(m.begin(), 7));
r = m.find(4); r = m.find(4);
assert(r == next(m.begin(), 8)); assert(r == next(m.begin(), 8));
} }
} }
#endif #endif
#if _LIBCPP_STD_VER > 11 #if TEST_STD_VER > 11
{ {
typedef std::pair<const int, double> V; typedef std::pair<const int, double> V;
typedef std::map<int, double, std::less<>> M; typedef std::map<int, double, std::less<>> M;
typedef M::iterator R; typedef M::iterator R;
V ar[] = V ar[] =
{ {
V(5, 5), V(5, 5),
▲ Show 20 Lines • Show All 84 Lines • Show Last 20 Lines

test/std/containers/associative/map/map.ops/find1.fail.cpp

Show All 16 Lines
// The member function templates find, count, lower_bound, upper_bound, and // The member function templates find, count, lower_bound, upper_bound, and
// equal_range shall not participate in overload resolution unless the // equal_range shall not participate in overload resolution unless the
// qualified-id Compare::is_transparent is valid and denotes a type // qualified-id Compare::is_transparent is valid and denotes a type
#include <map> #include <map>
#include <cassert> #include <cassert>
#include "test_macros.h"
#include "is_transparent.h" #include "is_transparent.h"
#if _LIBCPP_STD_VER <= 11 #if TEST_STD_VER <= 11
#error "This test requires is C++14 (or later)" #error "This test requires is C++14 (or later)"
#else #else
int main() int main()
{ {
{ {
typedef std::map<int, double, transparent_less_no_type> M; typedef std::map<int, double, transparent_less_no_type> M;
M().find(C2Int{5}); M().find(C2Int{5});
} }
} }
#endif #endif
No newline at end of file

test/std/containers/associative/map/map.ops/find2.fail.cpp

Show All 16 Lines
// The member function templates find, count, lower_bound, upper_bound, and // The member function templates find, count, lower_bound, upper_bound, and
// equal_range shall not participate in overload resolution unless the // equal_range shall not participate in overload resolution unless the
// qualified-id Compare::is_transparent is valid and denotes a type // qualified-id Compare::is_transparent is valid and denotes a type
#include <map> #include <map>
#include <cassert> #include <cassert>
#include "test_macros.h"
#include "is_transparent.h" #include "is_transparent.h"
#if _LIBCPP_STD_VER <= 11 #if TEST_STD_VER <= 11
#error "This test requires is C++14 (or later)" #error "This test requires is C++14 (or later)"
#else #else
int main() int main()
{ {
{ {
typedef std::map<int, double, transparent_less_private> M; typedef std::map<int, double, transparent_less_private> M;
M().find(C2Int{5}); M().find(C2Int{5});
} }
} }
#endif #endif
No newline at end of file

test/std/containers/associative/map/map.ops/find3.fail.cpp

Show All 16 Lines
// The member function templates find, count, lower_bound, upper_bound, and // The member function templates find, count, lower_bound, upper_bound, and
// equal_range shall not participate in overload resolution unless the // equal_range shall not participate in overload resolution unless the
// qualified-id Compare::is_transparent is valid and denotes a type // qualified-id Compare::is_transparent is valid and denotes a type
#include <map> #include <map>
#include <cassert> #include <cassert>
#include "test_macros.h"
#include "is_transparent.h" #include "is_transparent.h"
#if _LIBCPP_STD_VER <= 11 #if TEST_STD_VER <= 11
#error "This test requires is C++14 (or later)" #error "This test requires is C++14 (or later)"
#else #else
int main() int main()
{ {
{ {
typedef std::map<int, double, transparent_less_not_a_type> M; typedef std::map<int, double, transparent_less_not_a_type> M;
M().find(C2Int{5}); M().find(C2Int{5});
} }
} }
#endif #endif
No newline at end of file

test/std/containers/associative/map/map.ops/lower_bound.pass.cpp

Show All 11 Lines
// class map // class map
// iterator lower_bound(const key_type& k); // iterator lower_bound(const key_type& k);
// const_iterator lower_bound(const key_type& k) const; // const_iterator lower_bound(const key_type& k) const;
#include <map> #include <map>
#include <cassert> #include <cassert>
#include "test_macros.h"
#include "min_allocator.h" #include "min_allocator.h"
#include "private_constructor.hpp" #include "private_constructor.hpp"
#include "is_transparent.h" #include "is_transparent.h"
int main() int main()
{ {
{ {
typedef std::pair<const int, double> V; typedef std::pair<const int, double> V;
▲ Show 20 Lines • Show All 196 Lines • ▼ Show 20 Lines typedef std::map<int, double, std::less<int>, min_allocator<V>> M;
assert(r == next(m.begin(), 6)); assert(r == next(m.begin(), 6));
r = m.lower_bound(18); r = m.lower_bound(18);
assert(r == next(m.begin(), 7)); assert(r == next(m.begin(), 7));
r = m.lower_bound(20); r = m.lower_bound(20);
assert(r == next(m.begin(), 8)); assert(r == next(m.begin(), 8));
} }
} }
#endif #endif
#if _LIBCPP_STD_VER > 11 #if TEST_STD_VER > 11
{ {
typedef std::pair<const int, double> V; typedef std::pair<const int, double> V;
typedef std::map<int, double, std::less <>> M; typedef std::map<int, double, std::less <>> M;
typedef M::iterator R; typedef M::iterator R;
V ar[] = V ar[] =
{ {
V(5, 5), V(5, 5),
▲ Show 20 Lines • Show All 132 Lines • Show Last 20 Lines

test/std/containers/associative/map/map.ops/lower_bound1.fail.cpp

Show All 16 Lines
// The member function templates find, count, lower_bound, upper_bound, and // The member function templates find, count, lower_bound, upper_bound, and
// equal_range shall not participate in overload resolution unless the // equal_range shall not participate in overload resolution unless the
// qualified-id Compare::is_transparent is valid and denotes a type // qualified-id Compare::is_transparent is valid and denotes a type
#include <map> #include <map>
#include <cassert> #include <cassert>
#include "test_macros.h"
#include "is_transparent.h" #include "is_transparent.h"
#if _LIBCPP_STD_VER <= 11 #if TEST_STD_VER <= 11
#error "This test requires is C++14 (or later)" #error "This test requires is C++14 (or later)"
#else #else
int main() int main()
{ {
{ {
typedef std::map<int, double, transparent_less_no_type> M; typedef std::map<int, double, transparent_less_no_type> M;
M().lower_bound(C2Int{5}); M().lower_bound(C2Int{5});
} }
} }
#endif #endif

test/std/containers/associative/map/map.ops/lower_bound2.fail.cpp

Show All 16 Lines
// The member function templates find, count, lower_bound, upper_bound, and // The member function templates find, count, lower_bound, upper_bound, and
// equal_range shall not participate in overload resolution unless the // equal_range shall not participate in overload resolution unless the
// qualified-id Compare::is_transparent is valid and denotes a type // qualified-id Compare::is_transparent is valid and denotes a type
#include <map> #include <map>
#include <cassert> #include <cassert>
#include "test_macros.h"
#include "is_transparent.h" #include "is_transparent.h"
#if _LIBCPP_STD_VER <= 11 #if TEST_STD_VER <= 11
#error "This test requires is C++14 (or later)" #error "This test requires is C++14 (or later)"
#else #else
int main() int main()
{ {
{ {
typedef std::map<int, double, transparent_less_private> M; typedef std::map<int, double, transparent_less_private> M;
M().lower_bound(C2Int{5}); M().lower_bound(C2Int{5});
} }
} }
#endif #endif

test/std/containers/associative/map/map.ops/lower_bound3.fail.cpp

Show All 16 Lines
// The member function templates find, count, lower_bound, upper_bound, and // The member function templates find, count, lower_bound, upper_bound, and
// equal_range shall not participate in overload resolution unless the // equal_range shall not participate in overload resolution unless the
// qualified-id Compare::is_transparent is valid and denotes a type // qualified-id Compare::is_transparent is valid and denotes a type
#include <map> #include <map>
#include <cassert> #include <cassert>
#include "test_macros.h"
#include "is_transparent.h" #include "is_transparent.h"
#if _LIBCPP_STD_VER <= 11 #if TEST_STD_VER <= 11
#error "This test requires is C++14 (or later)" #error "This test requires is C++14 (or later)"
#else #else
int main() int main()
{ {
{ {
typedef std::map<int, double, transparent_less_not_a_type> M; typedef std::map<int, double, transparent_less_not_a_type> M;
M().lower_bound(C2Int{5}); M().lower_bound(C2Int{5});
} }
} }
#endif #endif

test/std/containers/associative/map/map.ops/upper_bound.pass.cpp

Show All 11 Lines
// class map // class map
// iterator upper_bound(const key_type& k); // iterator upper_bound(const key_type& k);
// const_iterator upper_bound(const key_type& k) const; // const_iterator upper_bound(const key_type& k) const;
#include <map> #include <map>
#include <cassert> #include <cassert>
#include "test_macros.h"
#include "min_allocator.h" #include "min_allocator.h"
#include "private_constructor.hpp" #include "private_constructor.hpp"
int main() int main()
{ {
{ {
typedef std::pair<const int, double> V; typedef std::pair<const int, double> V;
typedef std::map<int, double> M; typedef std::map<int, double> M;
▲ Show 20 Lines • Show All 195 Lines • ▼ Show 20 Lines typedef std::map<int, double, std::less<int>, min_allocator<V>> M;
assert(r == next(m.begin(), 6)); assert(r == next(m.begin(), 6));
r = m.upper_bound(18); r = m.upper_bound(18);
assert(r == next(m.begin(), 7)); assert(r == next(m.begin(), 7));
r = m.upper_bound(20); r = m.upper_bound(20);
assert(r == next(m.begin(), 8)); assert(r == next(m.begin(), 8));
} }
} }
#endif #endif
#if _LIBCPP_STD_VER > 11 #if TEST_STD_VER > 11
{ {
typedef std::pair<const int, double> V; typedef std::pair<const int, double> V;
typedef std::map<int, double, std::less<>> M; typedef std::map<int, double, std::less<>> M;
typedef M::iterator R; typedef M::iterator R;
V ar[] = V ar[] =
{ {
V(5, 5), V(5, 5),
V(7, 6), V(7, 6),
▲ Show 20 Lines • Show All 96 Lines • Show Last 20 Lines

test/std/containers/associative/map/map.ops/upper_bound1.fail.cpp

Show All 16 Lines
// The member function templates find, count, lower_bound, upper_bound, and // The member function templates find, count, lower_bound, upper_bound, and
// equal_range shall not participate in overload resolution unless the // equal_range shall not participate in overload resolution unless the
// qualified-id Compare::is_transparent is valid and denotes a type // qualified-id Compare::is_transparent is valid and denotes a type
#include <map> #include <map>
#include <cassert> #include <cassert>
#include "test_macros.h"
#include "is_transparent.h" #include "is_transparent.h"
#if _LIBCPP_STD_VER <= 11 #if TEST_STD_VER <= 11
#error "This test requires is C++14 (or later)" #error "This test requires is C++14 (or later)"
#else #else
int main() int main()
{ {
{ {
typedef std::map<int, double, transparent_less_no_type> M; typedef std::map<int, double, transparent_less_no_type> M;
M().upper_bound(C2Int{5}); M().upper_bound(C2Int{5});
} }
} }
#endif #endif

test/std/containers/associative/map/map.ops/upper_bound2.fail.cpp

Show All 16 Lines
// The member function templates find, count, lower_bound, upper_bound, and // The member function templates find, count, lower_bound, upper_bound, and
// equal_range shall not participate in overload resolution unless the // equal_range shall not participate in overload resolution unless the
// qualified-id Compare::is_transparent is valid and denotes a type // qualified-id Compare::is_transparent is valid and denotes a type
#include <map> #include <map>
#include <cassert> #include <cassert>
#include "test_macros.h"
#include "is_transparent.h" #include "is_transparent.h"
#if _LIBCPP_STD_VER <= 11 #if TEST_STD_VER <= 11
#error "This test requires is C++14 (or later)" #error "This test requires is C++14 (or later)"
#else #else
int main() int main()
{ {
{ {
typedef std::map<int, double, transparent_less_private> M; typedef std::map<int, double, transparent_less_private> M;
M().upper_bound(C2Int{5}); M().upper_bound(C2Int{5});
} }
} }
#endif #endif

test/std/containers/associative/map/map.ops/upper_bound3.fail.cpp

Show All 16 Lines
// The member function templates find, count, lower_bound, upper_bound, and // The member function templates find, count, lower_bound, upper_bound, and
// equal_range shall not participate in overload resolution unless the // equal_range shall not participate in overload resolution unless the
// qualified-id Compare::is_transparent is valid and denotes a type // qualified-id Compare::is_transparent is valid and denotes a type
#include <map> #include <map>
#include <cassert> #include <cassert>
#include "test_macros.h"
#include "is_transparent.h" #include "is_transparent.h"
#if _LIBCPP_STD_VER <= 11 #if TEST_STD_VER <= 11
#error "This test requires is C++14 (or later)" #error "This test requires is C++14 (or later)"
#else #else
int main() int main()
{ {
{ {
typedef std::map<int, double, transparent_less_not_a_type> M; typedef std::map<int, double, transparent_less_not_a_type> M;
M().upper_bound(C2Int{5}); M().upper_bound(C2Int{5});
} }
} }
#endif #endif

test/std/containers/associative/multimap/iterator.pass.cpp

Show All 23 Lines
// const_iterator cbegin() const; // const_iterator cbegin() const;
// const_iterator cend() const; // const_iterator cend() const;
// const_reverse_iterator crbegin() const; // const_reverse_iterator crbegin() const;
// const_reverse_iterator crend() const; // const_reverse_iterator crend() const;
#include <map> #include <map>
#include <cassert> #include <cassert>
#include "test_macros.h"
#include "min_allocator.h" #include "min_allocator.h"
int main() int main()
{ {
{ {
typedef std::pair<const int, double> V; typedef std::pair<const int, double> V;
V ar[] = V ar[] =
{ {
▲ Show 20 Lines • Show All 166 Lines • ▼ Show 20 Lines#if TEST_STD_VER >= 11
for (int j = 1; j <= 8; ++j) for (int j = 1; j <= 8; ++j)
for (double d = 1; d <= 2; d += .5, ++i) for (double d = 1; d <= 2; d += .5, ++i)
{ {
assert(i->first == j); assert(i->first == j);
assert(i->second == d); assert(i->second == d);
} }
} }
#endif #endif
#if _LIBCPP_STD_VER > 11 #if TEST_STD_VER > 11
{ // N3644 testing { // N3644 testing
typedef std::multimap<int, double> C; typedef std::multimap<int, double> C;
C::iterator ii1{}, ii2{}; C::iterator ii1{}, ii2{};
C::iterator ii4 = ii1; C::iterator ii4 = ii1;
C::const_iterator cii{}; C::const_iterator cii{};
assert ( ii1 == ii2 ); assert ( ii1 == ii2 );
assert ( ii1 == ii4 ); assert ( ii1 == ii4 );
Show All 9 Lines

test/std/containers/associative/multimap/multimap.cons/iter_iter.pass.cpp

Show All 11 Lines
// class multimap // class multimap
// template <class InputIterator> // template <class InputIterator>
// multimap(InputIterator first, InputIterator last); // multimap(InputIterator first, InputIterator last);
#include <map> #include <map>
#include <cassert> #include <cassert>
#include "test_macros.h"
#include "min_allocator.h" #include "min_allocator.h"
int main() int main()
{ {
{ {
typedef std::pair<const int, double> V; typedef std::pair<const int, double> V;
V ar[] = V ar[] =
{ {
▲ Show 20 Lines • Show All 43 Lines • ▼ Show 20 Lines#if TEST_STD_VER >= 11
assert(*next(m.begin(), 2) == V(1, 2)); assert(*next(m.begin(), 2) == V(1, 2));
assert(*next(m.begin(), 3) == V(2, 1)); assert(*next(m.begin(), 3) == V(2, 1));
assert(*next(m.begin(), 4) == V(2, 1.5)); assert(*next(m.begin(), 4) == V(2, 1.5));
assert(*next(m.begin(), 5) == V(2, 2)); assert(*next(m.begin(), 5) == V(2, 2));
assert(*next(m.begin(), 6) == V(3, 1)); assert(*next(m.begin(), 6) == V(3, 1));
assert(*next(m.begin(), 7) == V(3, 1.5)); assert(*next(m.begin(), 7) == V(3, 1.5));
assert(*next(m.begin(), 8) == V(3, 2)); assert(*next(m.begin(), 8) == V(3, 2));
} }
#if _LIBCPP_STD_VER > 11 #if TEST_STD_VER > 11
{ {
typedef std::pair<const int, double> V; typedef std::pair<const int, double> V;
V ar[] = V ar[] =
{ {
V(1, 1), V(1, 1),
V(1, 1.5), V(1, 1.5),
V(1, 2), V(1, 2),
V(2, 1), V(2, 1),
Show All 25 Lines

test/std/containers/associative/multimap/multimap.ops/count.pass.cpp

Show All 10 Lines
// class multimap // class multimap
// size_type count(const key_type& k) const; // size_type count(const key_type& k) const;
#include <map> #include <map>
#include <cassert> #include <cassert>
#include "test_macros.h"
#include "min_allocator.h" #include "min_allocator.h"
#include "private_constructor.hpp" #include "private_constructor.hpp"
#include "is_transparent.h" #include "is_transparent.h"
int main() int main()
{ {
typedef std::pair<const int, double> V; typedef std::pair<const int, double> V;
{ {
▲ Show 20 Lines • Show All 60 Lines • ▼ Show 20 Lines typedef std::multimap<int, double, std::less<int>, min_allocator<std::pair<const int, double>>> M;
r = m.count(9); r = m.count(9);
assert(r == 3); assert(r == 3);
r = m.count(10); r = m.count(10);
assert(r == 0); assert(r == 0);
} }
} }
#endif #endif
#if _LIBCPP_STD_VER > 11 #if TEST_STD_VER > 11
{ {
typedef std::multimap<int, double, std::less<>> M; typedef std::multimap<int, double, std::less<>> M;
typedef M::size_type R; typedef M::size_type R;
V ar[] = V ar[] =
{ {
V(5, 1), V(5, 1),
V(5, 2), V(5, 2),
V(5, 3), V(5, 3),
▲ Show 20 Lines • Show All 72 Lines • Show Last 20 Lines

test/std/containers/associative/multimap/multimap.ops/count1.fail.cpp

Show All 16 Lines
// The member function templates find, count, lower_bound, upper_bound, and // The member function templates find, count, lower_bound, upper_bound, and
// equal_range shall not participate in overload resolution unless the // equal_range shall not participate in overload resolution unless the
// qualified-id Compare::is_transparent is valid and denotes a type // qualified-id Compare::is_transparent is valid and denotes a type
#include <map> #include <map>
#include <cassert> #include <cassert>
#include "test_macros.h"
#include "is_transparent.h" #include "is_transparent.h"
#if _LIBCPP_STD_VER <= 11 #if TEST_STD_VER <= 11
#error "This test requires is C++14 (or later)" #error "This test requires is C++14 (or later)"
#else #else
int main() int main()
{ {
typedef std::multimap<int, double, transparent_less_no_type> M; typedef std::multimap<int, double, transparent_less_no_type> M;
M().count(C2Int{5}); M().count(C2Int{5});
} }
#endif #endif
No newline at end of file

test/std/containers/associative/multimap/multimap.ops/count2.fail.cpp

Show All 16 Lines
// The member function templates find, count, lower_bound, upper_bound, and // The member function templates find, count, lower_bound, upper_bound, and
// equal_range shall not participate in overload resolution unless the // equal_range shall not participate in overload resolution unless the
// qualified-id Compare::is_transparent is valid and denotes a type // qualified-id Compare::is_transparent is valid and denotes a type
#include <map> #include <map>
#include <cassert> #include <cassert>
#include "test_macros.h"
#include "is_transparent.h" #include "is_transparent.h"
#if _LIBCPP_STD_VER <= 11 #if TEST_STD_VER <= 11
#error "This test requires is C++14 (or later)" #error "This test requires is C++14 (or later)"
#else #else
int main() int main()
{ {
typedef std::multimap<int, double, transparent_less_private> M; typedef std::multimap<int, double, transparent_less_private> M;
M().count(C2Int{5}); M().count(C2Int{5});
} }
#endif #endif
No newline at end of file

test/std/containers/associative/multimap/multimap.ops/count3.fail.cpp

Show All 16 Lines
// The member function templates find, count, lower_bound, upper_bound, and // The member function templates find, count, lower_bound, upper_bound, and
// equal_range shall not participate in overload resolution unless the // equal_range shall not participate in overload resolution unless the
// qualified-id Compare::is_transparent is valid and denotes a type // qualified-id Compare::is_transparent is valid and denotes a type
#include <map> #include <map>
#include <cassert> #include <cassert>
#include "test_macros.h"
#include "is_transparent.h" #include "is_transparent.h"
#if _LIBCPP_STD_VER <= 11 #if TEST_STD_VER <= 11
#error "This test requires is C++14 (or later)" #error "This test requires is C++14 (or later)"
#else #else
int main() int main()
{ {
typedef std::multimap<int, double, transparent_less_not_a_type> M; typedef std::multimap<int, double, transparent_less_not_a_type> M;
M().count(C2Int{5}); M().count(C2Int{5});
} }
#endif #endif
No newline at end of file

test/std/containers/associative/multimap/multimap.ops/equal_range.pass.cpp

Show All 11 Lines
// class multimap // class multimap
// pair<iterator, iterator> equal_range(const key_type& k); // pair<iterator, iterator> equal_range(const key_type& k);
// pair<const_iterator, const_iterator> equal_range(const key_type& k) const; // pair<const_iterator, const_iterator> equal_range(const key_type& k) const;
#include <map> #include <map>
#include <cassert> #include <cassert>
#include "test_macros.h"
#include "min_allocator.h" #include "min_allocator.h"
#include "private_constructor.hpp" #include "private_constructor.hpp"
#include "is_transparent.h" #include "is_transparent.h"
int main() int main()
{ {
typedef std::pair<const int, double> V; typedef std::pair<const int, double> V;
{ {
▲ Show 20 Lines • Show All 147 Lines • ▼ Show 20 Lines typedef std::multimap<int, double, std::less<int>, min_allocator<std::pair<const int, double>>> M;
assert(r.first == next(m.begin(), 6)); assert(r.first == next(m.begin(), 6));
assert(r.second == next(m.begin(), 9)); assert(r.second == next(m.begin(), 9));
r = m.equal_range(10); r = m.equal_range(10);
assert(r.first == m.end()); assert(r.first == m.end());
assert(r.second == m.end()); assert(r.second == m.end());
} }
} }
#endif #endif
#if _LIBCPP_STD_VER > 11 #if TEST_STD_VER > 11
{ {
typedef std::pair<const int, double> V; typedef std::pair<const int, double> V;
typedef std::multimap<int, double, std::less<>> M; typedef std::multimap<int, double, std::less<>> M;
typedef std::pair<M::iterator, M::iterator> R; typedef std::pair<M::iterator, M::iterator> R;
V ar[] = V ar[] =
{ {
V(5, 1), V(5, 1),
▲ Show 20 Lines • Show All 96 Lines • Show Last 20 Lines

test/std/containers/associative/multimap/multimap.ops/equal_range1.fail.cpp

Show All 16 Lines
// The member function templates find, count, lower_bound, upper_bound, and // The member function templates find, count, lower_bound, upper_bound, and
// equal_range shall not participate in overload resolution unless the // equal_range shall not participate in overload resolution unless the
// qualified-id Compare::is_transparent is valid and denotes a type // qualified-id Compare::is_transparent is valid and denotes a type
#include <map> #include <map>
#include <cassert> #include <cassert>
#include "test_macros.h"
#include "is_transparent.h" #include "is_transparent.h"
#if _LIBCPP_STD_VER <= 11 #if TEST_STD_VER <= 11
#error "This test requires is C++14 (or later)" #error "This test requires is C++14 (or later)"
#else #else
int main() int main()
{ {
typedef std::multimap<int, double, transparent_less_no_type> M; typedef std::multimap<int, double, transparent_less_no_type> M;
M().equal_range(C2Int{5}); M().equal_range(C2Int{5});
} }
#endif #endif
No newline at end of file

test/std/containers/associative/multimap/multimap.ops/equal_range2.fail.cpp

Show All 16 Lines
// The member function templates find, count, lower_bound, upper_bound, and // The member function templates find, count, lower_bound, upper_bound, and
// equal_range shall not participate in overload resolution unless the // equal_range shall not participate in overload resolution unless the
// qualified-id Compare::is_transparent is valid and denotes a type // qualified-id Compare::is_transparent is valid and denotes a type
#include <map> #include <map>
#include <cassert> #include <cassert>
#include "test_macros.h"
#include "is_transparent.h" #include "is_transparent.h"
#if _LIBCPP_STD_VER <= 11 #if TEST_STD_VER <= 11
#error "This test requires is C++14 (or later)" #error "This test requires is C++14 (or later)"
#else #else
int main() int main()
{ {
{ {
typedef std::multimap<int, double, transparent_less_private> M; typedef std::multimap<int, double, transparent_less_private> M;
M().equal_range(C2Int{5}); M().equal_range(C2Int{5});
} }
} }
#endif #endif
No newline at end of file

test/std/containers/associative/multimap/multimap.ops/equal_range3.fail.cpp

Show All 16 Lines
// The member function templates find, count, lower_bound, upper_bound, and // The member function templates find, count, lower_bound, upper_bound, and
// equal_range shall not participate in overload resolution unless the // equal_range shall not participate in overload resolution unless the
// qualified-id Compare::is_transparent is valid and denotes a type // qualified-id Compare::is_transparent is valid and denotes a type
#include <map> #include <map>
#include <cassert> #include <cassert>
#include "test_macros.h"
#include "is_transparent.h" #include "is_transparent.h"
#if _LIBCPP_STD_VER <= 11 #if TEST_STD_VER <= 11
#error "This test requires is C++14 (or later)" #error "This test requires is C++14 (or later)"
#else #else
int main() int main()
{ {
{ {
typedef std::multimap<int, double, transparent_less_not_a_type> M; typedef std::multimap<int, double, transparent_less_not_a_type> M;
M().equal_range(C2Int{5}); M().equal_range(C2Int{5});
} }
} }
#endif #endif
No newline at end of file

test/std/containers/associative/multimap/multimap.ops/find.pass.cpp

Show All 11 Lines
// class multimap // class multimap
// iterator find(const key_type& k); // iterator find(const key_type& k);
// const_iterator find(const key_type& k) const; // const_iterator find(const key_type& k) const;
#include <map> #include <map>
#include <cassert> #include <cassert>
#include "test_macros.h"
#include "min_allocator.h" #include "min_allocator.h"
#include "private_constructor.hpp" #include "private_constructor.hpp"
#include "is_transparent.h" #include "is_transparent.h"
int main() int main()
{ {
typedef std::pair<const int, double> V; typedef std::pair<const int, double> V;
{ {
▲ Show 20 Lines • Show All 111 Lines • ▼ Show 20 Lines typedef std::multimap<int, double, std::less<int>, min_allocator<std::pair<const int, double>>> M;
assert(r == m.end()); assert(r == m.end());
r = m.find(9); r = m.find(9);
assert(r == next(m.begin(), 6)); assert(r == next(m.begin(), 6));
r = m.find(10); r = m.find(10);
assert(r == m.end()); assert(r == m.end());
} }
} }
#endif #endif
#if _LIBCPP_STD_VER > 11 #if TEST_STD_VER > 11
{ {
typedef std::pair<const int, double> V; typedef std::pair<const int, double> V;
typedef std::multimap<int, double, std::less<>> M; typedef std::multimap<int, double, std::less<>> M;
typedef M::iterator R; typedef M::iterator R;
V ar[] = V ar[] =
{ {
V(5, 1), V(5, 1),
▲ Show 20 Lines • Show All 68 Lines • Show Last 20 Lines

test/std/containers/associative/multimap/multimap.ops/find1.fail.cpp

Show All 16 Lines
// The member function templates find, count, lower_bound, upper_bound, and // The member function templates find, count, lower_bound, upper_bound, and
// equal_range shall not participate in overload resolution unless the // equal_range shall not participate in overload resolution unless the
// qualified-id Compare::is_transparent is valid and denotes a type // qualified-id Compare::is_transparent is valid and denotes a type
#include <map> #include <map>
#include <cassert> #include <cassert>
#include "test_macros.h"
#include "is_transparent.h" #include "is_transparent.h"
#if _LIBCPP_STD_VER <= 11 #if TEST_STD_VER <= 11
#error "This test requires is C++14 (or later)" #error "This test requires is C++14 (or later)"
#else #else
int main() int main()
{ {
{ {
typedef std::multimap<int, double, transparent_less_no_type> M; typedef std::multimap<int, double, transparent_less_no_type> M;
M().find(C2Int{5}); M().find(C2Int{5});
} }
} }
#endif #endif
No newline at end of file

test/std/containers/associative/multimap/multimap.ops/find2.fail.cpp

Show All 16 Lines
// The member function templates find, count, lower_bound, upper_bound, and // The member function templates find, count, lower_bound, upper_bound, and
// equal_range shall not participate in overload resolution unless the // equal_range shall not participate in overload resolution unless the
// qualified-id Compare::is_transparent is valid and denotes a type // qualified-id Compare::is_transparent is valid and denotes a type
#include <map> #include <map>
#include <cassert> #include <cassert>
#include "test_macros.h"
#include "is_transparent.h" #include "is_transparent.h"
#if _LIBCPP_STD_VER <= 11 #if TEST_STD_VER <= 11
#error "This test requires is C++14 (or later)" #error "This test requires is C++14 (or later)"
#else #else
int main() int main()
{ {
{ {
typedef std::multimap<int, double, transparent_less_private> M; typedef std::multimap<int, double, transparent_less_private> M;
M().find(C2Int{5}); M().find(C2Int{5});
} }
} }
#endif #endif
No newline at end of file

test/std/containers/associative/multimap/multimap.ops/find3.fail.cpp

Show All 16 Lines
// The member function templates find, count, lower_bound, upper_bound, and // The member function templates find, count, lower_bound, upper_bound, and
// equal_range shall not participate in overload resolution unless the // equal_range shall not participate in overload resolution unless the
// qualified-id Compare::is_transparent is valid and denotes a type // qualified-id Compare::is_transparent is valid and denotes a type
#include <map> #include <map>
#include <cassert> #include <cassert>
#include "test_macros.h"
#include "is_transparent.h" #include "is_transparent.h"
#if _LIBCPP_STD_VER <= 11 #if TEST_STD_VER <= 11
#error "This test requires is C++14 (or later)" #error "This test requires is C++14 (or later)"
#else #else
int main() int main()
{ {
{ {
typedef std::multimap<int, double, transparent_less_not_a_type> M; typedef std::multimap<int, double, transparent_less_not_a_type> M;
M().find(C2Int{5}); M().find(C2Int{5});
} }
} }
#endif #endif
No newline at end of file

test/std/containers/associative/multimap/multimap.ops/lower_bound.pass.cpp

Show All 11 Lines
// class multimap // class multimap
// iterator lower_bound(const key_type& k); // iterator lower_bound(const key_type& k);
// const_iterator lower_bound(const key_type& k) const; // const_iterator lower_bound(const key_type& k) const;
#include <map> #include <map>
#include <cassert> #include <cassert>
#include "test_macros.h"
#include "min_allocator.h" #include "min_allocator.h"
#include "private_constructor.hpp" #include "private_constructor.hpp"
#include "is_transparent.h" #include "is_transparent.h"
int main() int main()
{ {
typedef std::pair<const int, double> V; typedef std::pair<const int, double> V;
{ {
▲ Show 20 Lines • Show All 119 Lines • ▼ Show 20 Lines typedef std::multimap<int, double, std::less<int>, min_allocator<std::pair<const int, double>>> M;
assert(r == next(m.begin(), 6)); assert(r == next(m.begin(), 6));
r = m.lower_bound(9); r = m.lower_bound(9);
assert(r == next(m.begin(), 6)); assert(r == next(m.begin(), 6));
r = m.lower_bound(10); r = m.lower_bound(10);
assert(r == m.end()); assert(r == m.end());
} }
} }
#endif #endif
#if _LIBCPP_STD_VER > 11 #if TEST_STD_VER > 11
{ {
typedef std::pair<const int, double> V; typedef std::pair<const int, double> V;
typedef std::multimap<int, double, std::less<>> M; typedef std::multimap<int, double, std::less<>> M;
typedef M::iterator R; typedef M::iterator R;
V ar[] = V ar[] =
{ {
V(5, 1), V(5, 1),
V(5, 2), V(5, 2),
▲ Show 20 Lines • Show All 74 Lines • Show Last 20 Lines

test/std/containers/associative/multimap/multimap.ops/lower_bound1.fail.cpp

Show All 16 Lines
// The member function templates find, count, lower_bound, upper_bound, and // The member function templates find, count, lower_bound, upper_bound, and
// equal_range shall not participate in overload resolution unless the // equal_range shall not participate in overload resolution unless the
// qualified-id Compare::is_transparent is valid and denotes a type // qualified-id Compare::is_transparent is valid and denotes a type
#include <map> #include <map>
#include <cassert> #include <cassert>
#include "test_macros.h"
#include "is_transparent.h" #include "is_transparent.h"
#if _LIBCPP_STD_VER <= 11 #if TEST_STD_VER <= 11
#error "This test requires is C++14 (or later)" #error "This test requires is C++14 (or later)"
#else #else
int main() int main()
{ {
{ {
typedef std::multimap<int, double, transparent_less_no_type> M; typedef std::multimap<int, double, transparent_less_no_type> M;
M().lower_bound(C2Int{5}); M().lower_bound(C2Int{5});
} }
} }
#endif #endif

test/std/containers/associative/multimap/multimap.ops/lower_bound2.fail.cpp

Show All 16 Lines
// The member function templates find, count, lower_bound, upper_bound, and // The member function templates find, count, lower_bound, upper_bound, and
// equal_range shall not participate in overload resolution unless the // equal_range shall not participate in overload resolution unless the
// qualified-id Compare::is_transparent is valid and denotes a type // qualified-id Compare::is_transparent is valid and denotes a type
#include <map> #include <map>
#include <cassert> #include <cassert>
#include "test_macros.h"
#include "is_transparent.h" #include "is_transparent.h"
#if _LIBCPP_STD_VER <= 11 #if TEST_STD_VER <= 11
#error "This test requires is C++14 (or later)" #error "This test requires is C++14 (or later)"
#else #else
int main() int main()
{ {
{ {
typedef std::multimap<int, double, transparent_less_private> M; typedef std::multimap<int, double, transparent_less_private> M;
M().lower_bound(C2Int{5}); M().lower_bound(C2Int{5});
} }
} }
#endif #endif

test/std/containers/associative/multimap/multimap.ops/lower_bound3.fail.cpp

Show All 16 Lines
// The member function templates find, count, lower_bound, upper_bound, and // The member function templates find, count, lower_bound, upper_bound, and
// equal_range shall not participate in overload resolution unless the // equal_range shall not participate in overload resolution unless the
// qualified-id Compare::is_transparent is valid and denotes a type // qualified-id Compare::is_transparent is valid and denotes a type
#include <map> #include <map>
#include <cassert> #include <cassert>
#include "test_macros.h"
#include "is_transparent.h" #include "is_transparent.h"
#if _LIBCPP_STD_VER <= 11 #if TEST_STD_VER <= 11
#error "This test requires is C++14 (or later)" #error "This test requires is C++14 (or later)"
#else #else
int main() int main()
{ {
{ {
typedef std::multimap<int, double, transparent_less_not_a_type> M; typedef std::multimap<int, double, transparent_less_not_a_type> M;
M().lower_bound(C2Int{5}); M().lower_bound(C2Int{5});
} }
} }
#endif #endif

test/std/containers/associative/multimap/multimap.ops/upper_bound.pass.cpp

Show All 11 Lines
// class multimap // class multimap
// iterator upper_bound(const key_type& k); // iterator upper_bound(const key_type& k);
// const_iterator upper_bound(const key_type& k) const; // const_iterator upper_bound(const key_type& k) const;
#include <map> #include <map>
#include <cassert> #include <cassert>
#include "test_macros.h"
#include "min_allocator.h" #include "min_allocator.h"
#include "private_constructor.hpp" #include "private_constructor.hpp"
#include "is_transparent.h" #include "is_transparent.h"
int main() int main()
{ {
typedef std::pair<const int, double> V; typedef std::pair<const int, double> V;
{ {
▲ Show 20 Lines • Show All 119 Lines • ▼ Show 20 Lines typedef std::multimap<int, double, std::less<int>, min_allocator<std::pair<const int, double>>> M;
assert(r == next(m.begin(), 6)); assert(r == next(m.begin(), 6));
r = m.upper_bound(9); r = m.upper_bound(9);
assert(r == next(m.begin(), 9)); assert(r == next(m.begin(), 9));
r = m.upper_bound(10); r = m.upper_bound(10);
assert(r == m.end()); assert(r == m.end());
} }
} }
#endif #endif
#if _LIBCPP_STD_VER > 11 #if TEST_STD_VER > 11
{ {
typedef std::pair<const int, double> V; typedef std::pair<const int, double> V;
typedef std::multimap<int, double, std::less<>> M; typedef std::multimap<int, double, std::less<>> M;
typedef M::iterator R; typedef M::iterator R;
V ar[] = V ar[] =
{ {
V(5, 1), V(5, 1),
V(5, 2), V(5, 2),
▲ Show 20 Lines • Show All 73 Lines • Show Last 20 Lines

test/std/containers/associative/multimap/multimap.ops/upper_bound1.fail.cpp

Show All 16 Lines
// The member function templates find, count, lower_bound, upper_bound, and // The member function templates find, count, lower_bound, upper_bound, and
// equal_range shall not participate in overload resolution unless the // equal_range shall not participate in overload resolution unless the
// qualified-id Compare::is_transparent is valid and denotes a type // qualified-id Compare::is_transparent is valid and denotes a type
#include <map> #include <map>
#include <cassert> #include <cassert>
#include "test_macros.h"
#include "is_transparent.h" #include "is_transparent.h"
#if _LIBCPP_STD_VER <= 11 #if TEST_STD_VER <= 11
#error "This test requires is C++14 (or later)" #error "This test requires is C++14 (or later)"
#else #else
int main() int main()
{ {
{ {
typedef std::multimap<int, double, transparent_less_no_type> M; typedef std::multimap<int, double, transparent_less_no_type> M;
M().upper_bound(C2Int{5}); M().upper_bound(C2Int{5});
} }
} }
#endif #endif

test/std/containers/associative/multimap/multimap.ops/upper_bound2.fail.cpp

Show All 16 Lines
// The member function templates find, count, lower_bound, upper_bound, and // The member function templates find, count, lower_bound, upper_bound, and
// equal_range shall not participate in overload resolution unless the // equal_range shall not participate in overload resolution unless the
// qualified-id Compare::is_transparent is valid and denotes a type // qualified-id Compare::is_transparent is valid and denotes a type
#include <map> #include <map>
#include <cassert> #include <cassert>
#include "test_macros.h"
#include "is_transparent.h" #include "is_transparent.h"
#if _LIBCPP_STD_VER <= 11 #if TEST_STD_VER <= 11
#error "This test requires is C++14 (or later)" #error "This test requires is C++14 (or later)"
#else #else
int main() int main()
{ {
{ {
typedef std::multimap<int, double, transparent_less_private> M; typedef std::multimap<int, double, transparent_less_private> M;
M().upper_bound(C2Int{5}); M().upper_bound(C2Int{5});
} }
} }
#endif #endif

test/std/containers/associative/multimap/multimap.ops/upper_bound3.fail.cpp

Show All 16 Lines
// The member function templates find, count, lower_bound, upper_bound, and // The member function templates find, count, lower_bound, upper_bound, and
// equal_range shall not participate in overload resolution unless the // equal_range shall not participate in overload resolution unless the
// qualified-id Compare::is_transparent is valid and denotes a type // qualified-id Compare::is_transparent is valid and denotes a type
#include <map> #include <map>
#include <cassert> #include <cassert>
#include "test_macros.h"
#include "is_transparent.h" #include "is_transparent.h"
#if _LIBCPP_STD_VER <= 11 #if TEST_STD_VER <= 11
#error "This test requires is C++14 (or later)" #error "This test requires is C++14 (or later)"
#else #else
int main() int main()
{ {
{ {
typedef std::multimap<int, double, transparent_less_not_a_type> M; typedef std::multimap<int, double, transparent_less_not_a_type> M;
M().upper_bound(C2Int{5}); M().upper_bound(C2Int{5});
} }
} }
#endif #endif

test/std/containers/associative/multiset/count.pass.cpp

Show All 10 Lines
// class multiset // class multiset
// size_type count(const key_type& k) const; // size_type count(const key_type& k) const;
#include <set> #include <set>
#include <cassert> #include <cassert>
#include "test_macros.h"
#include "min_allocator.h" #include "min_allocator.h"
#include "private_constructor.hpp" #include "private_constructor.hpp"
int main() int main()
{ {
{ {
typedef int V; typedef int V;
typedef std::multiset<int> M; typedef std::multiset<int> M;
▲ Show 20 Lines • Show All 59 Lines • ▼ Show 20 Lines typedef std::multiset<int, std::less<int>, min_allocator<int>> M;
assert(r == 0); assert(r == 0);
r = m.count(9); r = m.count(9);
assert(r == 2); assert(r == 2);
r = m.count(10); r = m.count(10);
assert(r == 0); assert(r == 0);
} }
} }
#endif #endif
#if _LIBCPP_STD_VER > 11 #if TEST_STD_VER > 11
{ {
typedef int V; typedef int V;
typedef std::multiset<int, std::less<>> M; typedef std::multiset<int, std::less<>> M;
typedef M::size_type R; typedef M::size_type R;
V ar[] = V ar[] =
{ {
5, 5,
5, 5,
▲ Show 20 Lines • Show All 58 Lines • Show Last 20 Lines

test/std/containers/associative/multiset/equal_range.pass.cpp

Show All 11 Lines
// class multiset // class multiset
// pair<iterator,iterator> equal_range(const key_type& k); // pair<iterator,iterator> equal_range(const key_type& k);
// pair<const_iterator,const_iterator> equal_range(const key_type& k) const; // pair<const_iterator,const_iterator> equal_range(const key_type& k) const;
#include <set> #include <set>
#include <cassert> #include <cassert>
#include "test_macros.h"
#include "min_allocator.h" #include "min_allocator.h"
#include "private_constructor.hpp" #include "private_constructor.hpp"
int main() int main()
{ {
{ {
typedef int V; typedef int V;
typedef std::multiset<int> M; typedef std::multiset<int> M;
▲ Show 20 Lines • Show All 147 Lines • ▼ Show 20 Lines typedef std::multiset<int, std::less<int>, min_allocator<int>> M;
assert(r.first == next(m.begin(), 6)); assert(r.first == next(m.begin(), 6));
assert(r.second == next(m.begin(), 9)); assert(r.second == next(m.begin(), 9));
r = m.equal_range(10); r = m.equal_range(10);
assert(r.first == next(m.begin(), 9)); assert(r.first == next(m.begin(), 9));
assert(r.second == next(m.begin(), 9)); assert(r.second == next(m.begin(), 9));
} }
} }
#endif #endif
#if _LIBCPP_STD_VER > 11 #if TEST_STD_VER > 11
{ {
typedef int V; typedef int V;
typedef std::multiset<V, std::less<>> M; typedef std::multiset<V, std::less<>> M;
typedef std::pair<M::iterator, M::iterator> R; typedef std::pair<M::iterator, M::iterator> R;
V ar[] = V ar[] =
{ {
5, 5,
5, 5,
▲ Show 20 Lines • Show All 72 Lines • Show Last 20 Lines

test/std/containers/associative/multiset/find.pass.cpp

Show All 11 Lines
// class multiset // class multiset
// iterator find(const key_type& k); // iterator find(const key_type& k);
// const_iterator find(const key_type& k) const; // const_iterator find(const key_type& k) const;
#include <set> #include <set>
#include <cassert> #include <cassert>
#include "test_macros.h"
#include "min_allocator.h" #include "min_allocator.h"
#include "private_constructor.hpp" #include "private_constructor.hpp"
int main() int main()
{ {
{ {
typedef int V; typedef int V;
typedef std::multiset<int> M; typedef std::multiset<int> M;
▲ Show 20 Lines • Show All 131 Lines • ▼ Show 20 Lines#if TEST_STD_VER >= 11
assert(r == next(m.begin(), 6)); assert(r == next(m.begin(), 6));
r = m.find(12); r = m.find(12);
assert(r == next(m.begin(), 7)); assert(r == next(m.begin(), 7));
r = m.find(4); r = m.find(4);
assert(r == next(m.begin(), 8)); assert(r == next(m.begin(), 8));
} }
} }
#endif #endif
#if _LIBCPP_STD_VER > 11 #if TEST_STD_VER > 11
{ {
typedef int V; typedef int V;
typedef std::multiset<V, std::less<>> M; typedef std::multiset<V, std::less<>> M;
typedef M::iterator R; typedef M::iterator R;
V ar[] = V ar[] =
{ {
5, 5,
▲ Show 20 Lines • Show All 65 Lines • Show Last 20 Lines

test/std/containers/associative/multiset/iterator.pass.cpp

Show All 23 Lines
// const_iterator cbegin() const; // const_iterator cbegin() const;
// const_iterator cend() const; // const_iterator cend() const;
// const_reverse_iterator crbegin() const; // const_reverse_iterator crbegin() const;
// const_reverse_iterator crend() const; // const_reverse_iterator crend() const;
#include <set> #include <set>
#include <cassert> #include <cassert>
#include "test_macros.h"
#include "min_allocator.h" #include "min_allocator.h"
int main() int main()
{ {
{ {
typedef int V; typedef int V;
V ar[] = V ar[] =
{ {
▲ Show 20 Lines • Show All 150 Lines • ▼ Show 20 Lines#if TEST_STD_VER >= 11
assert(std::distance(m.crbegin(), m.crend()) == m.size()); assert(std::distance(m.crbegin(), m.crend()) == m.size());
std::multiset<int, std::less<int>, min_allocator<int>>::const_iterator i; std::multiset<int, std::less<int>, min_allocator<int>>::const_iterator i;
i = m.begin(); i = m.begin();
for (int j = 1; j <= 8; ++j) for (int j = 1; j <= 8; ++j)
for (int k = 0; k < 3; ++k, ++i) for (int k = 0; k < 3; ++k, ++i)
assert(*i == j); assert(*i == j);
} }
#endif #endif
#if _LIBCPP_STD_VER > 11 #if TEST_STD_VER > 11
{ // N3644 testing { // N3644 testing
typedef std::multiset<int> C; typedef std::multiset<int> C;
C::iterator ii1{}, ii2{}; C::iterator ii1{}, ii2{};
C::iterator ii4 = ii1; C::iterator ii4 = ii1;
C::const_iterator cii{}; C::const_iterator cii{};
assert ( ii1 == ii2 ); assert ( ii1 == ii2 );
assert ( ii1 == ii4 ); assert ( ii1 == ii4 );
Show All 9 Lines

test/std/containers/associative/multiset/lower_bound.pass.cpp

Show All 11 Lines
// class multiset // class multiset
// iterator lower_bound(const key_type& k); // iterator lower_bound(const key_type& k);
// const_iterator lower_bound(const key_type& k) const; // const_iterator lower_bound(const key_type& k) const;
#include <set> #include <set>
#include <cassert> #include <cassert>
#include "test_macros.h"
#include "min_allocator.h" #include "min_allocator.h"
#include "private_constructor.hpp" #include "private_constructor.hpp"
int main() int main()
{ {
{ {
typedef int V; typedef int V;
typedef std::multiset<int> M; typedef std::multiset<int> M;
▲ Show 20 Lines • Show All 119 Lines • ▼ Show 20 Lines#if TEST_STD_VER >= 11
assert(r == next(m.begin(), 6)); assert(r == next(m.begin(), 6));
r = m.lower_bound(9); r = m.lower_bound(9);
assert(r == next(m.begin(), 6)); assert(r == next(m.begin(), 6));
r = m.lower_bound(11); r = m.lower_bound(11);
assert(r == next(m.begin(), 9)); assert(r == next(m.begin(), 9));
} }
} }
#endif #endif
#if _LIBCPP_STD_VER > 11 #if TEST_STD_VER > 11
{ {
typedef int V; typedef int V;
typedef std::multiset<V, std::less<>> M; typedef std::multiset<V, std::less<>> M;
typedef M::iterator R; typedef M::iterator R;
V ar[] = V ar[] =
{ {
5, 5,
▲ Show 20 Lines • Show All 60 Lines • Show Last 20 Lines

test/std/containers/associative/multiset/multiset.cons/initializer_list.pass.cpp

Show All 10 Lines
// class multiset // class multiset
// multiset(initializer_list<value_type> il, const key_compare& comp = key_compare()); // multiset(initializer_list<value_type> il, const key_compare& comp = key_compare());
#include <set> #include <set>
#include <cassert> #include <cassert>
#include "test_macros.h"
#include "min_allocator.h" #include "min_allocator.h"
int main() int main()
{ {
#ifndef _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS #ifndef _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS
{ {
typedef std::multiset<int> C; typedef std::multiset<int> C;
typedef C::value_type V; typedef C::value_type V;
Show All 19 Lines#if TEST_STD_VER >= 11
C::const_iterator i = m.cbegin(); C::const_iterator i = m.cbegin();
assert(*i == V(1)); assert(*i == V(1));
assert(*++i == V(2)); assert(*++i == V(2));
assert(*++i == V(3)); assert(*++i == V(3));
assert(*++i == V(4)); assert(*++i == V(4));
assert(*++i == V(5)); assert(*++i == V(5));
assert(*++i == V(6)); assert(*++i == V(6));
} }
#if _LIBCPP_STD_VER > 11 #if TEST_STD_VER > 11
{ {
typedef std::multiset<int, std::less<int>, min_allocator<int>> C; typedef std::multiset<int, std::less<int>, min_allocator<int>> C;
typedef C::value_type V; typedef C::value_type V;
min_allocator<int> a; min_allocator<int> a;
C m ({1, 2, 3, 4, 5, 6}, a); C m ({1, 2, 3, 4, 5, 6}, a);
assert(m.size() == 6); assert(m.size() == 6);
assert(distance(m.begin(), m.end()) == 6); assert(distance(m.begin(), m.end()) == 6);
C::const_iterator i = m.cbegin(); C::const_iterator i = m.cbegin();
Show All 11 Lines

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

Show All 12 Lines
// template <class InputIterator> // template <class InputIterator>
// multiset(InputIterator first, InputIterator last, // multiset(InputIterator first, InputIterator last,
// const value_compare& comp, const allocator_type& a); // const value_compare& comp, const allocator_type& a);
#include <set> #include <set>
#include <cassert> #include <cassert>
#include "test_macros.h"
#include "test_iterators.h" #include "test_iterators.h"
#include "../../../test_compare.h" #include "../../../test_compare.h"
#include "test_allocator.h" #include "test_allocator.h"
int main() int main()
{ {
{ {
typedef int V; typedef int V;
Show All 23 Linesint main()
assert(*next(m.begin(), 2) == 1); assert(*next(m.begin(), 2) == 1);
assert(*next(m.begin(), 3) == 2); assert(*next(m.begin(), 3) == 2);
assert(*next(m.begin(), 4) == 2); assert(*next(m.begin(), 4) == 2);
assert(*next(m.begin(), 5) == 2); assert(*next(m.begin(), 5) == 2);
assert(*next(m.begin(), 6) == 3); assert(*next(m.begin(), 6) == 3);
assert(*next(m.begin(), 7) == 3); assert(*next(m.begin(), 7) == 3);
assert(*next(m.begin(), 8) == 3); assert(*next(m.begin(), 8) == 3);
} }
#if _LIBCPP_STD_VER > 11 #if TEST_STD_VER > 11
{ {
typedef int V; typedef int V;
V ar[] = V ar[] =
{ {
1, 1,
1, 1,
1, 1,
2, 2,
Show All 26 Lines

test/std/containers/associative/multiset/upper_bound.pass.cpp

Show All 11 Lines
// class multiset // class multiset
// iterator upper_bound(const key_type& k); // iterator upper_bound(const key_type& k);
// const_iterator upper_bound(const key_type& k) const; // const_iterator upper_bound(const key_type& k) const;
#include <set> #include <set>
#include <cassert> #include <cassert>
#include "test_macros.h"
#include "min_allocator.h" #include "min_allocator.h"
#include "private_constructor.hpp" #include "private_constructor.hpp"
int main() int main()
{ {
{ {
typedef int V; typedef int V;
typedef std::multiset<int> M; typedef std::multiset<int> M;
▲ Show 20 Lines • Show All 119 Lines • ▼ Show 20 Lines typedef std::multiset<int, std::less<int>, min_allocator<int>> M;
assert(r == next(m.begin(), 6)); assert(r == next(m.begin(), 6));
r = m.upper_bound(9); r = m.upper_bound(9);
assert(r == next(m.begin(), 9)); assert(r == next(m.begin(), 9));
r = m.upper_bound(11); r = m.upper_bound(11);
assert(r == next(m.begin(), 9)); assert(r == next(m.begin(), 9));
} }
} }
#endif #endif
#if _LIBCPP_STD_VER > 11 #if TEST_STD_VER > 11
{ {
typedef int V; typedef int V;
typedef std::multiset<V, std::less<>> M; typedef std::multiset<V, std::less<>> M;
typedef M::iterator R; typedef M::iterator R;
V ar[] = V ar[] =
{ {
5, 5,
▲ Show 20 Lines • Show All 59 Lines • Show Last 20 Lines

test/std/containers/associative/set/count.pass.cpp

Show All 10 Lines
// class set // class set
// size_type count(const key_type& k) const; // size_type count(const key_type& k) const;
#include <set> #include <set>
#include <cassert> #include <cassert>
#include "test_macros.h"
#include "min_allocator.h" #include "min_allocator.h"
#include "private_constructor.hpp" #include "private_constructor.hpp"
int main() int main()
{ {
{ {
typedef int V; typedef int V;
typedef std::set<int> M; typedef std::set<int> M;
▲ Show 20 Lines • Show All 61 Lines • ▼ Show 20 Lines#if TEST_STD_VER >= 11
r = m.count(11); r = m.count(11);
assert(r == 1); assert(r == 1);
r = m.count(12); r = m.count(12);
assert(r == 1); assert(r == 1);
r = m.count(4); r = m.count(4);
assert(r == 0); assert(r == 0);
} }
#endif #endif
#if _LIBCPP_STD_VER > 11 #if TEST_STD_VER > 11
{ {
typedef int V; typedef int V;
typedef std::set<int, std::less<>> M; typedef std::set<int, std::less<>> M;
typedef M::size_type R; typedef M::size_type R;
V ar[] = V ar[] =
{ {
5, 5,
6, 6,
▲ Show 20 Lines • Show All 64 Lines • Show Last 20 Lines

test/std/containers/associative/set/equal_range.pass.cpp

Show All 11 Lines
// class set // class set
// pair<iterator,iterator> equal_range(const key_type& k); // pair<iterator,iterator> equal_range(const key_type& k);
// pair<const_iterator,const_iterator> equal_range(const key_type& k) const; // pair<const_iterator,const_iterator> equal_range(const key_type& k) const;
#include <set> #include <set>
#include <cassert> #include <cassert>
#include "test_macros.h"
#include "min_allocator.h" #include "min_allocator.h"
#include "private_constructor.hpp" #include "private_constructor.hpp"
int main() int main()
{ {
{ {
typedef int V; typedef int V;
typedef std::set<int> M; typedef std::set<int> M;
▲ Show 20 Lines • Show All 195 Lines • ▼ Show 20 Lines#if TEST_STD_VER >= 11
r = m.equal_range(18); r = m.equal_range(18);
assert(r.first == next(m.begin(), 7)); assert(r.first == next(m.begin(), 7));
assert(r.second == next(m.begin(), 7)); assert(r.second == next(m.begin(), 7));
r = m.equal_range(20); r = m.equal_range(20);
assert(r.first == next(m.begin(), 8)); assert(r.first == next(m.begin(), 8));
assert(r.second == next(m.begin(), 8)); assert(r.second == next(m.begin(), 8));
} }
#endif #endif
#if _LIBCPP_STD_VER > 11 #if TEST_STD_VER > 11
{ {
typedef int V; typedef int V;
typedef std::set<V, std::less<>> M; typedef std::set<V, std::less<>> M;
{ {
typedef std::pair<M::iterator, M::iterator> R; typedef std::pair<M::iterator, M::iterator> R;
V ar[] = V ar[] =
{ {
5, 5,
▲ Show 20 Lines • Show All 131 Lines • Show Last 20 Lines

test/std/containers/associative/set/find.pass.cpp

Show All 11 Lines
// class set // class set
// iterator find(const key_type& k); // iterator find(const key_type& k);
// const_iterator find(const key_type& k) const; // const_iterator find(const key_type& k) const;
#include <set> #include <set>
#include <cassert> #include <cassert>
#include "test_macros.h"
#include "min_allocator.h" #include "min_allocator.h"
#include "private_constructor.hpp" #include "private_constructor.hpp"
int main() int main()
{ {
{ {
typedef int V; typedef int V;
typedef std::set<int> M; typedef std::set<int> M;
▲ Show 20 Lines • Show All 131 Lines • ▼ Show 20 Lines typedef std::set<int, std::less<int>, min_allocator<int>> M;
assert(r == next(m.begin(), 6)); assert(r == next(m.begin(), 6));
r = m.find(12); r = m.find(12);
assert(r == next(m.begin(), 7)); assert(r == next(m.begin(), 7));
r = m.find(4); r = m.find(4);
assert(r == next(m.begin(), 8)); assert(r == next(m.begin(), 8));
} }
} }
#endif #endif
#if _LIBCPP_STD_VER > 11 #if TEST_STD_VER > 11
{ {
typedef int V; typedef int V;
typedef std::set<V, std::less<>> M; typedef std::set<V, std::less<>> M;
typedef M::iterator R; typedef M::iterator R;
V ar[] = V ar[] =
{ {
5, 5,
▲ Show 20 Lines • Show All 65 Lines • Show Last 20 Lines

test/std/containers/associative/set/iterator.pass.cpp

Show All 23 Lines
// const_iterator cbegin() const; // const_iterator cbegin() const;
// const_iterator cend() const; // const_iterator cend() const;
// const_reverse_iterator crbegin() const; // const_reverse_iterator crbegin() const;
// const_reverse_iterator crend() const; // const_reverse_iterator crend() const;
#include <set> #include <set>
#include <cassert> #include <cassert>
#include "test_macros.h"
#include "min_allocator.h" #include "min_allocator.h"
int main() int main()
{ {
{ {
typedef int V; typedef int V;
V ar[] = V ar[] =
{ {
▲ Show 20 Lines • Show All 146 Lines • ▼ Show 20 Lines#if TEST_STD_VER >= 11
assert(std::distance(m.rbegin(), m.rend()) == m.size()); assert(std::distance(m.rbegin(), m.rend()) == m.size());
assert(std::distance(m.crbegin(), m.crend()) == m.size()); assert(std::distance(m.crbegin(), m.crend()) == m.size());
std::set<int, std::less<int>, min_allocator<int>>::const_iterator i; std::set<int, std::less<int>, min_allocator<int>>::const_iterator i;
i = m.begin(); i = m.begin();
for (int j = 1; j <= m.size(); ++j, ++i) for (int j = 1; j <= m.size(); ++j, ++i)
assert(*i == j); assert(*i == j);
} }
#endif #endif
#if _LIBCPP_STD_VER > 11 #if TEST_STD_VER > 11
{ // N3644 testing { // N3644 testing
typedef std::set<int> C; typedef std::set<int> C;
C::iterator ii1{}, ii2{}; C::iterator ii1{}, ii2{};
C::iterator ii4 = ii1; C::iterator ii4 = ii1;
C::const_iterator cii{}; C::const_iterator cii{};
assert ( ii1 == ii2 ); assert ( ii1 == ii2 );
assert ( ii1 == ii4 ); assert ( ii1 == ii4 );
Show All 9 Lines

test/std/containers/associative/set/lower_bound.pass.cpp

Show All 11 Lines
// class set // class set
// iterator lower_bound(const key_type& k); // iterator lower_bound(const key_type& k);
// const_iterator lower_bound(const key_type& k) const; // const_iterator lower_bound(const key_type& k) const;
#include <set> #include <set>
#include <cassert> #include <cassert>
#include "test_macros.h"
#include "min_allocator.h" #include "min_allocator.h"
#include "private_constructor.hpp" #include "private_constructor.hpp"
int main() int main()
{ {
{ {
typedef int V; typedef int V;
typedef std::set<int> M; typedef std::set<int> M;
▲ Show 20 Lines • Show All 195 Lines • ▼ Show 20 Lines typedef std::set<int, std::less<int>, min_allocator<int>> M;
assert(r == next(m.begin(), 6)); assert(r == next(m.begin(), 6));
r = m.lower_bound(18); r = m.lower_bound(18);
assert(r == next(m.begin(), 7)); assert(r == next(m.begin(), 7));
r = m.lower_bound(20); r = m.lower_bound(20);
assert(r == next(m.begin(), 8)); assert(r == next(m.begin(), 8));
} }
} }
#endif #endif
#if _LIBCPP_STD_VER > 11 #if TEST_STD_VER > 11
{ {
typedef int V; typedef int V;
typedef std::set<V, std::less<>> M; typedef std::set<V, std::less<>> M;
typedef M::iterator R; typedef M::iterator R;
V ar[] = V ar[] =
{ {
5, 5,
▲ Show 20 Lines • Show All 98 Lines • Show Last 20 Lines

test/std/containers/associative/set/set.cons/initializer_list_compare_alloc.pass.cpp

Show All 10 Lines
// class set // class set
// set(initializer_list<value_type> il, const key_compare& comp, const allocator_type& a); // set(initializer_list<value_type> il, const key_compare& comp, const allocator_type& a);
// set(initializer_list<value_type> il, const allocator_type& a); // set(initializer_list<value_type> il, const allocator_type& a);
#include <set> #include <set>
#include <cassert> #include <cassert>
#include "test_macros.h"
#include "../../../test_compare.h" #include "../../../test_compare.h"
#include "test_allocator.h" #include "test_allocator.h"
int main() int main()
{ {
#ifndef _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS #ifndef _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS
{ {
typedef test_compare<std::less<int> > Cmp; typedef test_compare<std::less<int> > Cmp;
typedef test_allocator<int> A; typedef test_allocator<int> A;
typedef std::set<int, Cmp, A> C; typedef std::set<int, Cmp, A> C;
typedef C::value_type V; typedef C::value_type V;
C m({1, 2, 3, 4, 5, 6}, Cmp(10), A(4)); C m({1, 2, 3, 4, 5, 6}, Cmp(10), A(4));
assert(m.size() == 6); assert(m.size() == 6);
assert(distance(m.begin(), m.end()) == 6); assert(distance(m.begin(), m.end()) == 6);
C::const_iterator i = m.cbegin(); C::const_iterator i = m.cbegin();
assert(*i == V(1)); assert(*i == V(1));
assert(*++i == V(2)); assert(*++i == V(2));
assert(*++i == V(3)); assert(*++i == V(3));
assert(*++i == V(4)); assert(*++i == V(4));
assert(*++i == V(5)); assert(*++i == V(5));
assert(*++i == V(6)); assert(*++i == V(6));
assert(m.key_comp() == Cmp(10)); assert(m.key_comp() == Cmp(10));
assert(m.get_allocator() == A(4)); assert(m.get_allocator() == A(4));
} }
#if _LIBCPP_STD_VER > 11 #if TEST_STD_VER > 11
{ {
typedef test_compare<std::less<int> > Cmp; typedef test_compare<std::less<int> > Cmp;
typedef test_allocator<int> A; typedef test_allocator<int> A;
typedef std::set<int, Cmp, A> C; typedef std::set<int, Cmp, A> C;
typedef C::value_type V; typedef C::value_type V;
C m({1, 2, 3, 4, 5, 6}, A(4)); C m({1, 2, 3, 4, 5, 6}, A(4));
assert(m.size() == 6); assert(m.size() == 6);
assert(distance(m.begin(), m.end()) == 6); assert(distance(m.begin(), m.end()) == 6);
Show All 12 Lines

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

Show All 16 Lines
// //
// template <class InputIterator> // template <class InputIterator>
// set(InputIterator first, InputIterator last, // set(InputIterator first, InputIterator last,
// const allocator_type& a); // const allocator_type& a);
#include <set> #include <set>
#include <cassert> #include <cassert>
#include "test_macros.h"
#include "test_iterators.h" #include "test_iterators.h"
#include "../../../test_compare.h" #include "../../../test_compare.h"
#include "test_allocator.h" #include "test_allocator.h"
int main() int main()
{ {
{ {
typedef int V; typedef int V;
Show All 17 Linesint main()
assert(m.value_comp() == C(5)); assert(m.value_comp() == C(5));
assert(m.get_allocator() == A(7)); assert(m.get_allocator() == A(7));
assert(m.size() == 3); assert(m.size() == 3);
assert(distance(m.begin(), m.end()) == 3); assert(distance(m.begin(), m.end()) == 3);
assert(*m.begin() == 1); assert(*m.begin() == 1);
assert(*next(m.begin()) == 2); assert(*next(m.begin()) == 2);
assert(*next(m.begin(), 2) == 3); assert(*next(m.begin(), 2) == 3);
} }
#if _LIBCPP_STD_VER > 11 #if TEST_STD_VER > 11
{ {
typedef int V; typedef int V;
V ar[] = V ar[] =
{ {
1, 1,
1, 1,
1, 1,
2, 2,
Show All 20 Lines

test/std/containers/associative/set/upper_bound.pass.cpp

Show All 11 Lines
// class set // class set
// iterator upper_bound(const key_type& k); // iterator upper_bound(const key_type& k);
// const_iterator upper_bound(const key_type& k) const; // const_iterator upper_bound(const key_type& k) const;
#include <set> #include <set>
#include <cassert> #include <cassert>
#include "test_macros.h"
#include "min_allocator.h" #include "min_allocator.h"
#include "private_constructor.hpp" #include "private_constructor.hpp"
int main() int main()
{ {
{ {
typedef int V; typedef int V;
typedef std::set<int> M; typedef std::set<int> M;
▲ Show 20 Lines • Show All 195 Lines • ▼ Show 20 Lines typedef std::set<int, std::less<int>, min_allocator<int>> M;
assert(r == next(m.begin(), 6)); assert(r == next(m.begin(), 6));
r = m.upper_bound(18); r = m.upper_bound(18);
assert(r == next(m.begin(), 7)); assert(r == next(m.begin(), 7));
r = m.upper_bound(20); r = m.upper_bound(20);
assert(r == next(m.begin(), 8)); assert(r == next(m.begin(), 8));
} }
} }
#endif #endif
#if _LIBCPP_STD_VER > 11 #if TEST_STD_VER > 11
{ {
typedef int V; typedef int V;
typedef std::set<V, std::less<>> M; typedef std::set<V, std::less<>> M;
typedef M::iterator R; typedef M::iterator R;
V ar[] = V ar[] =
{ {
5, 5,
▲ Show 20 Lines • Show All 97 Lines • Show Last 20 Lines

test/std/containers/sequences/array/iterators.pass.cpp

Show All 9 Lines
// <array> // <array>
// iterator, const_iterator // iterator, const_iterator
#include <array> #include <array>
#include <iterator> #include <iterator>
#include <cassert> #include <cassert>
#include "test_macros.h"
int main() int main()
{ {
{ {
typedef std::array<int, 5> C; typedef std::array<int, 5> C;
C c; C c;
C::iterator i; C::iterator i;
i = c.begin(); i = c.begin();
C::const_iterator j; C::const_iterator j;
j = c.cbegin(); j = c.cbegin();
assert(i == j); assert(i == j);
} }
{ {
typedef std::array<int, 0> C; typedef std::array<int, 0> C;
C c; C c;
C::iterator i; C::iterator i;
i = c.begin(); i = c.begin();
C::const_iterator j; C::const_iterator j;
j = c.cbegin(); j = c.cbegin();
assert(i == j); assert(i == j);
} }
#if _LIBCPP_STD_VER > 11 #if TEST_STD_VER > 11
{ // N3644 testing { // N3644 testing
{ {
typedef std::array<int, 5> C; typedef std::array<int, 5> C;
C::iterator ii1{}, ii2{}; C::iterator ii1{}, ii2{};
C::iterator ii4 = ii1; C::iterator ii4 = ii1;
C::const_iterator cii{}; C::const_iterator cii{};
assert ( ii1 == ii2 ); assert ( ii1 == ii2 );
assert ( ii1 == ii4 ); assert ( ii1 == ii4 );
▲ Show 20 Lines • Show All 63 Lines • Show Last 20 Lines

test/std/containers/sequences/deque/deque.cons/size.pass.cpp

//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// The LLVM Compiler Infrastructure // The LLVM Compiler Infrastructure
// //
// This file is dual licensed under the MIT and the University of Illinois Open // This file is dual licensed under the MIT and the University of Illinois Open
// Source Licenses. See LICENSE.TXT for details. // Source Licenses. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// <deque> // <deque>
// explicit deque(size_type n); // explicit deque(size_type n);
#include <deque> #include <deque>
#include <cassert> #include <cassert>
#include "test_macros.h"
#include "test_allocator.h" #include "test_allocator.h"
#include "DefaultOnly.h" #include "DefaultOnly.h"
#include "min_allocator.h" #include "min_allocator.h"
template <class T, class Allocator> template <class T, class Allocator>
void void
test2(unsigned n) test2(unsigned n)
{ {
#if _LIBCPP_STD_VER > 11 #if TEST_STD_VER > 11
typedef std::deque<T, Allocator> C; typedef std::deque<T, Allocator> C;
typedef typename C::const_iterator const_iterator; typedef typename C::const_iterator const_iterator;
assert(DefaultOnly::count == 0); assert(DefaultOnly::count == 0);
{ {
C d(n, Allocator()); C d(n, Allocator());
assert(DefaultOnly::count == n); assert(DefaultOnly::count == n);
assert(d.size() == n); assert(d.size() == n);
assert(distance(d.begin(), d.end()) == d.size()); assert(distance(d.begin(), d.end()) == d.size());
Show All 25 Lines#endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES
} }
assert(DefaultOnly::count == 0); assert(DefaultOnly::count == 0);
} }
template <class T, class Allocator> template <class T, class Allocator>
void void
test3(unsigned n, Allocator const &alloc = Allocator()) test3(unsigned n, Allocator const &alloc = Allocator())
{ {
#if _LIBCPP_STD_VER > 11 #if TEST_STD_VER > 11
typedef std::deque<T, Allocator> C; typedef std::deque<T, Allocator> C;
typedef typename C::const_iterator const_iterator; typedef typename C::const_iterator const_iterator;
{ {
C d(n, alloc); C d(n, alloc);
assert(d.size() == n); assert(d.size() == n);
assert(d.get_allocator() == alloc); assert(d.get_allocator() == alloc);
} }
#endif #endif
Show All 23 Linesint main()
test<DefaultOnly, std::allocator<DefaultOnly> >(4097); test<DefaultOnly, std::allocator<DefaultOnly> >(4097);
LIBCPP_ONLY(test1<DefaultOnly, limited_allocator<DefaultOnly, 4096> >(4095)); LIBCPP_ONLY(test1<DefaultOnly, limited_allocator<DefaultOnly, 4096> >(4095));
#if TEST_STD_VER >= 11 #if TEST_STD_VER >= 11
test<DefaultOnly, min_allocator<DefaultOnly> >(4095); test<DefaultOnly, min_allocator<DefaultOnly> >(4095);
#endif #endif
#if _LIBCPP_STD_VER > 11 #if TEST_STD_VER > 11
test3<DefaultOnly, std::allocator<DefaultOnly>> (1023); test3<DefaultOnly, std::allocator<DefaultOnly>> (1023);
test3<int, std::allocator<int>>(1); test3<int, std::allocator<int>>(1);
test3<int, min_allocator<int>> (3); test3<int, min_allocator<int>> (3);
#endif #endif
} }

test/std/containers/sequences/deque/iterators.pass.cpp

Show All 14 Lines
// class deque; // class deque;
// iterator, const_iterator // iterator, const_iterator
#include <deque> #include <deque>
#include <iterator> #include <iterator>
#include <cassert> #include <cassert>
#include "test_macros.h"
#include "min_allocator.h" #include "min_allocator.h"
int main() int main()
{ {
{ {
typedef std::deque<int> C; typedef std::deque<int> C;
C c; C c;
C::iterator i; C::iterator i;
i = c.begin(); i = c.begin();
C::const_iterator j; C::const_iterator j;
j = c.cbegin(); j = c.cbegin();
assert(i == j); assert(i == j);
} }
#if TEST_STD_VER >= 11 #if TEST_STD_VER >= 11
{ {
typedef std::deque<int, min_allocator<int>> C; typedef std::deque<int, min_allocator<int>> C;
C c; C c;
C::iterator i; C::iterator i;
i = c.begin(); i = c.begin();
C::const_iterator j; C::const_iterator j;
j = c.cbegin(); j = c.cbegin();
assert(i == j); assert(i == j);
} }
#endif #endif
#if _LIBCPP_STD_VER > 11 #if TEST_STD_VER > 11
{ // N3644 testing { // N3644 testing
std::deque<int>::iterator ii1{}, ii2{}; std::deque<int>::iterator ii1{}, ii2{};
std::deque<int>::iterator ii4 = ii1; std::deque<int>::iterator ii4 = ii1;
std::deque<int>::const_iterator cii{}; std::deque<int>::const_iterator cii{};
assert ( ii1 == ii2 ); assert ( ii1 == ii2 );
assert ( ii1 == ii4 ); assert ( ii1 == ii4 );
assert (!(ii1 != ii2 )); assert (!(ii1 != ii2 ));
Show All 24 Lines

test/std/containers/sequences/forwardlist/forwardlist.cons/size.pass.cpp

Show All 9 Lines
// <forward_list> // <forward_list>
// explicit forward_list(size_type n); // explicit forward_list(size_type n);
// explicit forward_list(size_type n, const Alloc& a); // explicit forward_list(size_type n, const Alloc& a);
#include <forward_list> #include <forward_list>
#include <cassert> #include <cassert>
#include "test_macros.h"
#include "DefaultOnly.h" #include "DefaultOnly.h"
#include "min_allocator.h" #include "min_allocator.h"
template <class T, class Allocator> template <class T, class Allocator>
void check_allocator(unsigned n, Allocator const &alloc = Allocator()) void check_allocator(unsigned n, Allocator const &alloc = Allocator())
{ {
#if _LIBCPP_STD_VER > 11 #if TEST_STD_VER > 11
typedef std::forward_list<T, Allocator> C; typedef std::forward_list<T, Allocator> C;
C d(n, alloc); C d(n, alloc);
assert(d.get_allocator() == alloc); assert(d.get_allocator() == alloc);
assert(std::distance(d.begin(), d.end()) == n); assert(std::distance(d.begin(), d.end()) == n);
#endif #endif
} }
int main() int main()
Show All 34 Lines

test/std/containers/sequences/forwardlist/forwardlist.iter/iterators.pass.cpp

Show All 14 Lines
// const_iterator end() const; // const_iterator end() const;
// const_iterator cbegin() const; // const_iterator cbegin() const;
// const_iterator cend() const; // const_iterator cend() const;
#include <forward_list> #include <forward_list>
#include <cassert> #include <cassert>
#include <iterator> #include <iterator>
#include "test_macros.h"
#include "min_allocator.h" #include "min_allocator.h"
int main() int main()
{ {
{ {
typedef int T; typedef int T;
typedef std::forward_list<T> C; typedef std::forward_list<T> C;
C c; C c;
▲ Show 20 Lines • Show All 84 Lines • ▼ Show 20 Lines#if TEST_STD_VER >= 11
} }
{ {
typedef int T; typedef int T;
typedef std::forward_list<T, min_allocator<T>> C; typedef std::forward_list<T, min_allocator<T>> C;
C::iterator i; C::iterator i;
C::const_iterator j; C::const_iterator j;
} }
#endif #endif
#if _LIBCPP_STD_VER > 11 #if TEST_STD_VER > 11
{ // N3644 testing { // N3644 testing
std::forward_list<int>::iterator ii1{}, ii2{}; std::forward_list<int>::iterator ii1{}, ii2{};
std::forward_list<int>::iterator ii4 = ii1; std::forward_list<int>::iterator ii4 = ii1;
std::forward_list<int>::const_iterator cii{}; std::forward_list<int>::const_iterator cii{};
assert ( ii1 == ii2 ); assert ( ii1 == ii2 );
assert ( ii1 == ii4 ); assert ( ii1 == ii4 );
assert (!(ii1 != ii2 )); assert (!(ii1 != ii2 ));
Show All 14 Lines

test/std/containers/sequences/list/iterators.pass.cpp

Show All 14 Lines
// const_iterator end() const; // const_iterator end() const;
// const_iterator cbegin() const; // const_iterator cbegin() const;
// const_iterator cend() const; // const_iterator cend() const;
#include <list> #include <list>
#include <cassert> #include <cassert>
#include <iterator> #include <iterator>
#include "test_macros.h"
#include "min_allocator.h" #include "min_allocator.h"
struct A struct A
{ {
int first; int first;
int second; int second;
}; };
▲ Show 20 Lines • Show All 99 Lines • ▼ Show 20 Lines#if TEST_STD_VER >= 11
typedef std::list<T, min_allocator<T>> C; typedef std::list<T, min_allocator<T>> C;
C c = {A{1, 2}}; C c = {A{1, 2}};
C::iterator i = c.begin(); C::iterator i = c.begin();
i->first = 3; i->first = 3;
C::const_iterator j = i; C::const_iterator j = i;
assert(j->first == 3); assert(j->first == 3);
} }
#endif #endif
#if _LIBCPP_STD_VER > 11 #if TEST_STD_VER > 11
{ {
std::list<int> c; std::list<int> c;
std::list<int>::iterator ii1{}, ii2{}; std::list<int>::iterator ii1{}, ii2{};
std::list<int>::iterator ii4 = ii1; std::list<int>::iterator ii4 = ii1;
std::list<int>::const_iterator cii{}; std::list<int>::const_iterator cii{};
assert ( ii1 == ii2 ); assert ( ii1 == ii2 );
assert ( ii1 == ii4 ); assert ( ii1 == ii4 );
Show All 13 Lines

test/std/containers/sequences/list/list.cons/size_type.pass.cpp

//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// The LLVM Compiler Infrastructure // The LLVM Compiler Infrastructure
// //
// This file is dual licensed under the MIT and the University of Illinois Open // This file is dual licensed under the MIT and the University of Illinois Open
// Source Licenses. See LICENSE.TXT for details. // Source Licenses. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// <list> // <list>
// explicit list(size_type n); // explicit list(size_type n);
#include <list> #include <list>
#include <cassert> #include <cassert>
#include "test_macros.h"
#include "DefaultOnly.h" #include "DefaultOnly.h"
#include "test_allocator.h" #include "test_allocator.h"
#include "min_allocator.h" #include "min_allocator.h"
template <class T, class Allocator> template <class T, class Allocator>
void void
test3(unsigned n, Allocator const &alloc = Allocator()) test3(unsigned n, Allocator const &alloc = Allocator())
{ {
#if _LIBCPP_STD_VER > 11 #if TEST_STD_VER > 11
typedef std::list<T, Allocator> C; typedef std::list<T, Allocator> C;
typedef typename C::const_iterator const_iterator; typedef typename C::const_iterator const_iterator;
{ {
C d(n, alloc); C d(n, alloc);
assert(d.size() == n); assert(d.size() == n);
assert(std::distance(d.begin(), d.end()) == n); assert(std::distance(d.begin(), d.end()) == n);
assert(d.get_allocator() == alloc); assert(d.get_allocator() == alloc);
} }
Show All 21 Linesint main()
assert(std::distance(l.begin(), l.end()) == 3); assert(std::distance(l.begin(), l.end()) == 3);
std::list<int>::const_iterator i = l.begin(); std::list<int>::const_iterator i = l.begin();
assert(*i == 0); assert(*i == 0);
++i; ++i;
assert(*i == 0); assert(*i == 0);
++i; ++i;
assert(*i == 0); assert(*i == 0);
} }
#if _LIBCPP_STD_VER > 11 #if TEST_STD_VER > 11
{ {
typedef std::list<int, min_allocator<int> > C; typedef std::list<int, min_allocator<int> > C;
C l(3, min_allocator<int> ()); C l(3, min_allocator<int> ());
assert(l.size() == 3); assert(l.size() == 3);
assert(std::distance(l.begin(), l.end()) == 3); assert(std::distance(l.begin(), l.end()) == 3);
C::const_iterator i = l.begin(); C::const_iterator i = l.begin();
assert(*i == 0); assert(*i == 0);
++i; ++i;
Show All 34 Lines

test/std/containers/sequences/vector.bool/iterators.pass.cpp

Show All 14 Lines
// const_iterator end() const; // const_iterator end() const;
// const_iterator cbegin() const; // const_iterator cbegin() const;
// const_iterator cend() const; // const_iterator cend() const;
#include <vector> #include <vector>
#include <cassert> #include <cassert>
#include <iterator> #include <iterator>
#include "test_macros.h"
#include "min_allocator.h" #include "min_allocator.h"
int main() int main()
{ {
{ {
typedef bool T; typedef bool T;
typedef std::vector<T> C; typedef std::vector<T> C;
C c; C c;
▲ Show 20 Lines • Show All 58 Lines • ▼ Show 20 Lines#if TEST_STD_VER >= 11
} }
{ {
typedef bool T; typedef bool T;
typedef std::vector<T, min_allocator<T>> C; typedef std::vector<T, min_allocator<T>> C;
C::iterator i; C::iterator i;
C::const_iterator j; C::const_iterator j;
} }
#endif #endif
#if _LIBCPP_STD_VER > 11 #if TEST_STD_VER > 11
{ // N3644 testing { // N3644 testing
std::vector<bool>::iterator ii1{}, ii2{}; std::vector<bool>::iterator ii1{}, ii2{};
std::vector<bool>::iterator ii4 = ii1; std::vector<bool>::iterator ii4 = ii1;
std::vector<bool>::const_iterator cii{}; std::vector<bool>::const_iterator cii{};
assert ( ii1 == ii2 ); assert ( ii1 == ii2 );
assert ( ii1 == ii4 ); assert ( ii1 == ii4 );
assert (!(ii1 != ii2 )); assert (!(ii1 != ii2 ));
Show All 18 Lines

test/std/containers/sequences/vector/iterators.pass.cpp

Show All 14 Lines
// const_iterator end() const; // const_iterator end() const;
// const_iterator cbegin() const; // const_iterator cbegin() const;
// const_iterator cend() const; // const_iterator cend() const;
#include <vector> #include <vector>
#include <cassert> #include <cassert>
#include <iterator> #include <iterator>
#include "test_macros.h"
#include "min_allocator.h" #include "min_allocator.h"
struct A struct A
{ {
int first; int first;
int second; int second;
}; };
▲ Show 20 Lines • Show All 99 Lines • ▼ Show 20 Lines#if TEST_STD_VER >= 11
typedef std::vector<T, min_allocator<T>> C; typedef std::vector<T, min_allocator<T>> C;
C c = {A{1, 2}}; C c = {A{1, 2}};
C::iterator i = c.begin(); C::iterator i = c.begin();
i->first = 3; i->first = 3;
C::const_iterator j = i; C::const_iterator j = i;
assert(j->first == 3); assert(j->first == 3);
} }
#endif #endif
#if _LIBCPP_STD_VER > 11 #if TEST_STD_VER > 11
{ // N3644 testing { // N3644 testing
typedef std::vector<int> C; typedef std::vector<int> C;
C::iterator ii1{}, ii2{}; C::iterator ii1{}, ii2{};
C::iterator ii4 = ii1; C::iterator ii4 = ii1;
C::const_iterator cii{}; C::const_iterator cii{};
assert ( ii1 == ii2 ); assert ( ii1 == ii2 );
assert ( ii1 == ii4 ); assert ( ii1 == ii4 );
Show All 19 Lines

test/std/containers/unord/unord.map/iterators.pass.cpp

Show All 18 Lines
// const_iterator end() const {return __table_.end();} // const_iterator end() const {return __table_.end();}
// const_iterator cbegin() const {return __table_.begin();} // const_iterator cbegin() const {return __table_.begin();}
// const_iterator cend() const {return __table_.end();} // const_iterator cend() const {return __table_.end();}
#include <unordered_map> #include <unordered_map>
#include <string> #include <string>
#include <cassert> #include <cassert>
#include "test_macros.h"
#include "min_allocator.h" #include "min_allocator.h"
int main() int main()
{ {
{ {
typedef std::unordered_map<int, std::string> C; typedef std::unordered_map<int, std::string> C;
typedef std::pair<int, std::string> P; typedef std::pair<int, std::string> P;
P a[] = P a[] =
▲ Show 20 Lines • Show All 68 Lines • ▼ Show 20 Lines#if TEST_STD_VER >= 11
const C c(a, a + sizeof(a)/sizeof(a[0])); const C c(a, a + sizeof(a)/sizeof(a[0]));
assert(c.bucket_count() >= 5); assert(c.bucket_count() >= 5);
assert(c.size() == 4); assert(c.size() == 4);
assert(std::distance(c.begin(), c.end()) == c.size()); assert(std::distance(c.begin(), c.end()) == c.size());
assert(std::distance(c.cbegin(), c.cend()) == c.size()); assert(std::distance(c.cbegin(), c.cend()) == c.size());
C::const_iterator i; C::const_iterator i;
} }
#endif #endif
#if _LIBCPP_STD_VER > 11 #if TEST_STD_VER > 11
{ // N3644 testing { // N3644 testing
typedef std::unordered_map<int,double> C; typedef std::unordered_map<int,double> C;
C::iterator ii1{}, ii2{}; C::iterator ii1{}, ii2{};
C::iterator ii4 = ii1; C::iterator ii4 = ii1;
C::const_iterator cii{}; C::const_iterator cii{};
assert ( ii1 == ii2 ); assert ( ii1 == ii2 );
assert ( ii1 == ii4 ); assert ( ii1 == ii4 );
Show All 9 Lines

test/std/containers/unord/unord.map/unord.map.cnstr/init.pass.cpp

Show All 14 Lines
// unordered_map(initializer_list<value_type> il); // unordered_map(initializer_list<value_type> il);
#include <unordered_map> #include <unordered_map>
#include <string> #include <string>
#include <cassert> #include <cassert>
#include <cfloat> #include <cfloat>
#include "test_macros.h"
#include "../../../test_compare.h" #include "../../../test_compare.h"
#include "../../../test_hash.h" #include "../../../test_hash.h"
#include "test_allocator.h" #include "test_allocator.h"
#include "min_allocator.h" #include "min_allocator.h"
int main() int main()
{ {
#ifndef _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS #ifndef _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS
▲ Show 20 Lines • Show All 55 Lines • ▼ Show 20 Lines#if TEST_STD_VER >= 11
assert(c.get_allocator() == assert(c.get_allocator() ==
(min_allocator<std::pair<const int, std::string> >())); (min_allocator<std::pair<const int, std::string> >()));
assert(!c.empty()); assert(!c.empty());
assert(std::distance(c.begin(), c.end()) == c.size()); assert(std::distance(c.begin(), c.end()) == c.size());
assert(std::distance(c.cbegin(), c.cend()) == c.size()); assert(std::distance(c.cbegin(), c.cend()) == c.size());
assert(fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON); assert(fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
assert(c.max_load_factor() == 1); assert(c.max_load_factor() == 1);
} }
#if _LIBCPP_STD_VER > 11 #if TEST_STD_VER > 11
{ {
typedef std::pair<int, std::string> P; typedef std::pair<int, std::string> P;
typedef test_allocator<std::pair<const int, std::string>> A; typedef test_allocator<std::pair<const int, std::string>> A;
typedef test_hash<std::hash<int>> HF; typedef test_hash<std::hash<int>> HF;
typedef test_compare<std::equal_to<int>> Comp; typedef test_compare<std::equal_to<int>> Comp;
typedef std::unordered_map<int, std::string, HF, Comp, A> C; typedef std::unordered_map<int, std::string, HF, Comp, A> C;
A a(42); A a(42);
▲ Show 20 Lines • Show All 60 Lines • Show Last 20 Lines

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

Show All 15 Lines
// template <class InputIterator> // template <class InputIterator>
// unordered_map(InputIterator first, InputIterator last); // unordered_map(InputIterator first, InputIterator last);
#include <unordered_map> #include <unordered_map>
#include <string> #include <string>
#include <cassert> #include <cassert>
#include <cfloat> #include <cfloat>
#include "test_macros.h"
#include "test_iterators.h" #include "test_iterators.h"
#include "../../../NotConstructible.h" #include "../../../NotConstructible.h"
#include "../../../test_compare.h" #include "../../../test_compare.h"
#include "../../../test_hash.h" #include "../../../test_hash.h"
#include "test_allocator.h" #include "test_allocator.h"
#include "min_allocator.h" #include "min_allocator.h"
int main() int main()
▲ Show 20 Lines • Show All 60 Lines • ▼ Show 20 Lines#if TEST_STD_VER >= 11
assert(c.get_allocator() == assert(c.get_allocator() ==
(min_allocator<std::pair<const int, std::string> >())); (min_allocator<std::pair<const int, std::string> >()));
assert(!c.empty()); assert(!c.empty());
assert(std::distance(c.begin(), c.end()) == c.size()); assert(std::distance(c.begin(), c.end()) == c.size());
assert(std::distance(c.cbegin(), c.cend()) == c.size()); assert(std::distance(c.cbegin(), c.cend()) == c.size());
assert(fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON); assert(fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
assert(c.max_load_factor() == 1); assert(c.max_load_factor() == 1);
} }
#if _LIBCPP_STD_VER > 11 #if TEST_STD_VER > 11
{ {
typedef std::pair<int, std::string> P; typedef std::pair<int, std::string> P;
typedef test_allocator<std::pair<const int, std::string>> A; typedef test_allocator<std::pair<const int, std::string>> A;
typedef test_hash<std::hash<int>> HF; typedef test_hash<std::hash<int>> HF;
typedef test_compare<std::equal_to<int>> Comp; typedef test_compare<std::equal_to<int>> Comp;
typedef std::unordered_map<int, std::string, HF, Comp, A> C; typedef std::unordered_map<int, std::string, HF, Comp, A> C;
P arr[] = P arr[] =
▲ Show 20 Lines • Show All 62 Lines • Show Last 20 Lines

test/std/containers/unord/unord.multimap/iterators.pass.cpp

Show All 18 Lines
// const_iterator end() const {return __table_.end();} // const_iterator end() const {return __table_.end();}
// const_iterator cbegin() const {return __table_.begin();} // const_iterator cbegin() const {return __table_.begin();}
// const_iterator cend() const {return __table_.end();} // const_iterator cend() const {return __table_.end();}
#include <unordered_map> #include <unordered_map>
#include <string> #include <string>
#include <cassert> #include <cassert>
#include "test_macros.h"
#include "min_allocator.h" #include "min_allocator.h"
int main() int main()
{ {
{ {
typedef std::unordered_multimap<int, std::string> C; typedef std::unordered_multimap<int, std::string> C;
typedef std::pair<int, std::string> P; typedef std::pair<int, std::string> P;
P a[] = P a[] =
▲ Show 20 Lines • Show All 74 Lines • ▼ Show 20 Lines#if TEST_STD_VER >= 11
const C c(a, a + sizeof(a)/sizeof(a[0])); const C c(a, a + sizeof(a)/sizeof(a[0]));
assert(c.bucket_count() >= 7); assert(c.bucket_count() >= 7);
assert(c.size() == 6); assert(c.size() == 6);
assert(std::distance(c.begin(), c.end()) == c.size()); assert(std::distance(c.begin(), c.end()) == c.size());
assert(std::distance(c.cbegin(), c.cend()) == c.size()); assert(std::distance(c.cbegin(), c.cend()) == c.size());
C::const_iterator i; C::const_iterator i;
} }
#endif #endif
#if _LIBCPP_STD_VER > 11 #if TEST_STD_VER > 11
{ // N3644 testing { // N3644 testing
typedef std::unordered_multimap<int,double> C; typedef std::unordered_multimap<int,double> C;
C::iterator ii1{}, ii2{}; C::iterator ii1{}, ii2{};
C::iterator ii4 = ii1; C::iterator ii4 = ii1;
C::const_iterator cii{}; C::const_iterator cii{};
assert ( ii1 == ii2 ); assert ( ii1 == ii2 );
assert ( ii1 == ii4 ); assert ( ii1 == ii4 );
Show All 9 Lines

test/std/containers/unord/unord.multimap/unord.multimap.cnstr/allocator.pass.cpp

Show First 20 Lines • Show All 78 Lines • ▼ Show 20 Lines#if TEST_STD_VER >= 11
assert(c.key_eq() == test_compare<std::equal_to<NotConstructible> >()); assert(c.key_eq() == test_compare<std::equal_to<NotConstructible> >());
assert(c.get_allocator() == A{}); assert(c.get_allocator() == A{});
assert(c.size() == 0); assert(c.size() == 0);
assert(c.empty()); assert(c.empty());
assert(std::distance(c.begin(), c.end()) == 0); assert(std::distance(c.begin(), c.end()) == 0);
assert(c.load_factor() == 0); assert(c.load_factor() == 0);
assert(c.max_load_factor() == 1); assert(c.max_load_factor() == 1);
} }
#if _LIBCPP_STD_VER > 11 #if TEST_STD_VER > 11
{ {
typedef NotConstructible T; typedef NotConstructible T;
typedef test_allocator<std::pair<const T, T>> A; typedef test_allocator<std::pair<const T, T>> A;
typedef test_hash<std::hash<T>> HF; typedef test_hash<std::hash<T>> HF;
typedef test_compare<std::equal_to<T>> Comp; typedef test_compare<std::equal_to<T>> Comp;
typedef std::unordered_multimap<T, T, HF, Comp, A> C; typedef std::unordered_multimap<T, T, HF, Comp, A> C;
A a(10); A a(10);
Show All 35 Lines

test/std/containers/unord/unord.multimap/unord.multimap.cnstr/init.pass.cpp

Show All 14 Lines
// unordered_multimap(initializer_list<value_type> il); // unordered_multimap(initializer_list<value_type> il);
#include <unordered_map> #include <unordered_map>
#include <string> #include <string>
#include <cassert> #include <cassert>
#include <cfloat> #include <cfloat>
#include "test_macros.h"
#include "../../../test_compare.h" #include "../../../test_compare.h"
#include "../../../test_hash.h" #include "../../../test_hash.h"
#include "test_allocator.h" #include "test_allocator.h"
#include "min_allocator.h" #include "min_allocator.h"
int main() int main()
{ {
#ifndef _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS #ifndef _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS
▲ Show 20 Lines • Show All 99 Lines • ▼ Show 20 Lines#if TEST_STD_VER >= 11
assert(std::distance(c.begin(), c.end()) == c.size()); assert(std::distance(c.begin(), c.end()) == c.size());
assert(std::distance(c.cbegin(), c.cend()) == c.size()); assert(std::distance(c.cbegin(), c.cend()) == c.size());
assert(fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON); assert(fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
assert(c.max_load_factor() == 1); assert(c.max_load_factor() == 1);
assert(c.hash_function() == test_hash<std::hash<int> >()); assert(c.hash_function() == test_hash<std::hash<int> >());
assert(c.key_eq() == test_compare<std::equal_to<int> >()); assert(c.key_eq() == test_compare<std::equal_to<int> >());
assert((c.get_allocator() == min_allocator<std::pair<const int, std::string> >())); assert((c.get_allocator() == min_allocator<std::pair<const int, std::string> >()));
} }
#if _LIBCPP_STD_VER > 11 #if TEST_STD_VER > 11
{ {
typedef std::pair<int, std::string> P; typedef std::pair<int, std::string> P;
typedef test_allocator<std::pair<const int, std::string>> A; typedef test_allocator<std::pair<const int, std::string>> A;
typedef test_hash<std::hash<int>> HF; typedef test_hash<std::hash<int>> HF;
typedef test_compare<std::equal_to<int>> Comp; typedef test_compare<std::equal_to<int>> Comp;
typedef std::unordered_multimap<int, std::string, HF, Comp, A> C; typedef std::unordered_multimap<int, std::string, HF, Comp, A> C;
A a(42); A a(42);
▲ Show 20 Lines • Show All 108 Lines • Show Last 20 Lines

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

Show All 15 Lines
// template <class InputIterator> // template <class InputIterator>
// unordered_multimap(InputIterator first, InputIterator last); // unordered_multimap(InputIterator first, InputIterator last);
#include <unordered_map> #include <unordered_map>
#include <string> #include <string>
#include <cassert> #include <cassert>
#include <cfloat> #include <cfloat>
#include "test_macros.h"
#include "test_iterators.h" #include "test_iterators.h"
#include "../../../NotConstructible.h" #include "../../../NotConstructible.h"
#include "../../../test_compare.h" #include "../../../test_compare.h"
#include "../../../test_hash.h" #include "../../../test_hash.h"
#include "test_allocator.h" #include "test_allocator.h"
#include "min_allocator.h" #include "min_allocator.h"
int main() int main()
▲ Show 20 Lines • Show All 104 Lines • ▼ Show 20 Lines#if TEST_STD_VER >= 11
assert(std::distance(c.begin(), c.end()) == c.size()); assert(std::distance(c.begin(), c.end()) == c.size());
assert(std::distance(c.cbegin(), c.cend()) == c.size()); assert(std::distance(c.cbegin(), c.cend()) == c.size());
assert(fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON); assert(fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
assert(c.max_load_factor() == 1); assert(c.max_load_factor() == 1);
assert(c.hash_function() == test_hash<std::hash<int> >()); assert(c.hash_function() == test_hash<std::hash<int> >());
assert(c.key_eq() == test_compare<std::equal_to<int> >()); assert(c.key_eq() == test_compare<std::equal_to<int> >());
assert((c.get_allocator() == min_allocator<std::pair<const int, std::string> >())); assert((c.get_allocator() == min_allocator<std::pair<const int, std::string> >()));
} }
#if _LIBCPP_STD_VER > 11 #if TEST_STD_VER > 11
{ {
typedef std::pair<int, std::string> P; typedef std::pair<int, std::string> P;
typedef test_allocator<std::pair<const int, std::string>> A; typedef test_allocator<std::pair<const int, std::string>> A;
typedef test_hash<std::hash<int>> HF; typedef test_hash<std::hash<int>> HF;
typedef test_compare<std::equal_to<int>> Comp; typedef test_compare<std::equal_to<int>> Comp;
typedef std::unordered_multimap<int, std::string, HF, Comp, A> C; typedef std::unordered_multimap<int, std::string, HF, Comp, A> C;
P arr[] = P arr[] =
▲ Show 20 Lines • Show All 111 Lines • Show Last 20 Lines

test/std/containers/unord/unord.multiset/iterators.pass.cpp

Show All 17 Lines
// const_iterator begin() const; // const_iterator begin() const;
// const_iterator end() const; // const_iterator end() const;
// const_iterator cbegin() const; // const_iterator cbegin() const;
// const_iterator cend() const; // const_iterator cend() const;
#include <unordered_set> #include <unordered_set>
#include <cassert> #include <cassert>
#include "test_macros.h"
#include "min_allocator.h" #include "min_allocator.h"
int main() int main()
{ {
{ {
typedef std::unordered_multiset<int> C; typedef std::unordered_multiset<int> C;
typedef int P; typedef int P;
P a[] = P a[] =
▲ Show 20 Lines • Show All 68 Lines • ▼ Show 20 Lines#if TEST_STD_VER >= 11
const C c(a, a + sizeof(a)/sizeof(a[0])); const C c(a, a + sizeof(a)/sizeof(a[0]));
assert(c.bucket_count() >= 7); assert(c.bucket_count() >= 7);
assert(c.size() == 6); assert(c.size() == 6);
assert(std::distance(c.begin(), c.end()) == c.size()); assert(std::distance(c.begin(), c.end()) == c.size());
assert(std::distance(c.cbegin(), c.cend()) == c.size()); assert(std::distance(c.cbegin(), c.cend()) == c.size());
C::const_iterator i; C::const_iterator i;
} }
#endif #endif
#if _LIBCPP_STD_VER > 11 #if TEST_STD_VER > 11
{ // N3644 testing { // N3644 testing
typedef std::unordered_multiset<int> C; typedef std::unordered_multiset<int> C;
C::iterator ii1{}, ii2{}; C::iterator ii1{}, ii2{};
C::iterator ii4 = ii1; C::iterator ii4 = ii1;
C::const_iterator cii{}; C::const_iterator cii{};
assert ( ii1 == ii2 ); assert ( ii1 == ii2 );
assert ( ii1 == ii4 ); assert ( ii1 == ii4 );
Show All 9 Lines

test/std/containers/unord/unord.multiset/unord.multiset.cnstr/allocator.pass.cpp

Show First 20 Lines • Show All 56 Lines • ▼ Show 20 Lines#if TEST_STD_VER >= 11
assert(c.key_eq() == test_compare<std::equal_to<NotConstructible> >()); assert(c.key_eq() == test_compare<std::equal_to<NotConstructible> >());
assert(c.get_allocator() == min_allocator<NotConstructible>()); assert(c.get_allocator() == min_allocator<NotConstructible>());
assert(c.size() == 0); assert(c.size() == 0);
assert(c.empty()); assert(c.empty());
assert(std::distance(c.begin(), c.end()) == 0); assert(std::distance(c.begin(), c.end()) == 0);
assert(c.load_factor() == 0); assert(c.load_factor() == 0);
assert(c.max_load_factor() == 1); assert(c.max_load_factor() == 1);
} }
#if _LIBCPP_STD_VER > 11 #if TEST_STD_VER > 11
{ {
typedef NotConstructible T; typedef NotConstructible T;
typedef test_hash<std::hash<T>> HF; typedef test_hash<std::hash<T>> HF;
typedef test_compare<std::equal_to<T>> Comp; typedef test_compare<std::equal_to<T>> Comp;
typedef test_allocator<T> A; typedef test_allocator<T> A;
typedef std::unordered_multiset<T, HF, Comp, A> C; typedef std::unordered_multiset<T, HF, Comp, A> C;
A a(43); A a(43);
Show All 37 Lines

test/std/containers/unord/unord.multiset/unord.multiset.cnstr/init.pass.cpp

Show All 13 Lines
// class unordered_multiset // class unordered_multiset
// unordered_multiset(initializer_list<value_type> il); // unordered_multiset(initializer_list<value_type> il);
#include <unordered_set> #include <unordered_set>
#include <cassert> #include <cassert>
#include <cfloat> #include <cfloat>
#include "test_macros.h"
#include "../../../test_compare.h" #include "../../../test_compare.h"
#include "../../../test_hash.h" #include "../../../test_hash.h"
#include "test_allocator.h" #include "test_allocator.h"
#include "min_allocator.h" #include "min_allocator.h"
int main() int main()
{ {
#ifndef _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS #ifndef _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS
▲ Show 20 Lines • Show All 53 Lines • ▼ Show 20 Lines#if TEST_STD_VER >= 11
assert(c.key_eq() == test_compare<std::equal_to<int> >()); assert(c.key_eq() == test_compare<std::equal_to<int> >());
assert(c.get_allocator() == min_allocator<int>()); assert(c.get_allocator() == min_allocator<int>());
assert(!c.empty()); assert(!c.empty());
assert(std::distance(c.begin(), c.end()) == c.size()); assert(std::distance(c.begin(), c.end()) == c.size());
assert(std::distance(c.cbegin(), c.cend()) == c.size()); assert(std::distance(c.cbegin(), c.cend()) == c.size());
assert(fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON); assert(fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
assert(c.max_load_factor() == 1); assert(c.max_load_factor() == 1);
} }
#if _LIBCPP_STD_VER > 11 #if TEST_STD_VER > 11
{ {
typedef int T; typedef int T;
typedef test_hash<std::hash<T>> HF; typedef test_hash<std::hash<T>> HF;
typedef test_compare<std::equal_to<T>> Comp; typedef test_compare<std::equal_to<T>> Comp;
typedef test_allocator<T> A; typedef test_allocator<T> A;
typedef std::unordered_multiset<T, HF, Comp, A> C; typedef std::unordered_multiset<T, HF, Comp, A> C;
A a(42); A a(42);
▲ Show 20 Lines • Show All 64 Lines • Show Last 20 Lines

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

Show All 14 Lines
// template <class InputIterator> // template <class InputIterator>
// unordered_multiset(InputIterator first, InputIterator last); // unordered_multiset(InputIterator first, InputIterator last);
#include <unordered_set> #include <unordered_set>
#include <cassert> #include <cassert>
#include <cfloat> #include <cfloat>
#include "test_macros.h"
#include "test_iterators.h" #include "test_iterators.h"
#include "../../../test_compare.h" #include "../../../test_compare.h"
#include "../../../test_hash.h" #include "../../../test_hash.h"
#include "test_allocator.h" #include "test_allocator.h"
#include "min_allocator.h" #include "min_allocator.h"
int main() int main()
{ {
▲ Show 20 Lines • Show All 57 Lines • ▼ Show 20 Lines#if TEST_STD_VER >= 11
assert(c.key_eq() == test_compare<std::equal_to<int> >()); assert(c.key_eq() == test_compare<std::equal_to<int> >());
assert(c.get_allocator() == min_allocator<int>()); assert(c.get_allocator() == min_allocator<int>());
assert(!c.empty()); assert(!c.empty());
assert(std::distance(c.begin(), c.end()) == c.size()); assert(std::distance(c.begin(), c.end()) == c.size());
assert(std::distance(c.cbegin(), c.cend()) == c.size()); assert(std::distance(c.cbegin(), c.cend()) == c.size());
assert(fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON); assert(fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
assert(c.max_load_factor() == 1); assert(c.max_load_factor() == 1);
} }
#if _LIBCPP_STD_VER > 11 #if TEST_STD_VER > 11
{ {
typedef int T; typedef int T;
typedef test_hash<std::hash<T>> HF; typedef test_hash<std::hash<T>> HF;
typedef test_compare<std::equal_to<T>> Comp; typedef test_compare<std::equal_to<T>> Comp;
typedef test_allocator<T> A; typedef test_allocator<T> A;
typedef std::unordered_multiset<T, HF, Comp, A> C; typedef std::unordered_multiset<T, HF, Comp, A> C;
T arr[] = T arr[] =
{ {
▲ Show 20 Lines • Show All 63 Lines • Show Last 20 Lines

test/std/containers/unord/unord.set/iterators.pass.cpp

Show All 17 Lines
// const_iterator begin() const {return __table_.begin();} // const_iterator begin() const {return __table_.begin();}
// const_iterator end() const {return __table_.end();} // const_iterator end() const {return __table_.end();}
// const_iterator cbegin() const {return __table_.begin();} // const_iterator cbegin() const {return __table_.begin();}
// const_iterator cend() const {return __table_.end();} // const_iterator cend() const {return __table_.end();}
#include <unordered_set> #include <unordered_set>
#include <cassert> #include <cassert>
#include "test_macros.h"
#include "min_allocator.h" #include "min_allocator.h"
int main() int main()
{ {
{ {
typedef std::unordered_set<int> C; typedef std::unordered_set<int> C;
typedef int P; typedef int P;
P a[] = P a[] =
▲ Show 20 Lines • Show All 68 Lines • ▼ Show 20 Lines#if TEST_STD_VER >= 11
const C c(a, a + sizeof(a)/sizeof(a[0])); const C c(a, a + sizeof(a)/sizeof(a[0]));
assert(c.bucket_count() >= 5); assert(c.bucket_count() >= 5);
assert(c.size() == 4); assert(c.size() == 4);
assert(std::distance(c.begin(), c.end()) == c.size()); assert(std::distance(c.begin(), c.end()) == c.size());
assert(std::distance(c.cbegin(), c.cend()) == c.size()); assert(std::distance(c.cbegin(), c.cend()) == c.size());
C::const_iterator i; C::const_iterator i;
} }
#endif #endif
#if _LIBCPP_STD_VER > 11 #if TEST_STD_VER > 11
{ // N3644 testing { // N3644 testing
typedef std::unordered_set<int> C; typedef std::unordered_set<int> C;
C::iterator ii1{}, ii2{}; C::iterator ii1{}, ii2{};
C::iterator ii4 = ii1; C::iterator ii4 = ii1;
C::const_iterator cii{}; C::const_iterator cii{};
assert ( ii1 == ii2 ); assert ( ii1 == ii2 );
assert ( ii1 == ii4 ); assert ( ii1 == ii4 );
Show All 9 Lines

test/std/containers/unord/unord.set/unord.set.cnstr/allocator.pass.cpp

Show First 20 Lines • Show All 56 Lines • ▼ Show 20 Lines#if TEST_STD_VER >= 11
assert(c.key_eq() == test_compare<std::equal_to<NotConstructible> >()); assert(c.key_eq() == test_compare<std::equal_to<NotConstructible> >());
assert(c.get_allocator() == min_allocator<NotConstructible>()); assert(c.get_allocator() == min_allocator<NotConstructible>());
assert(c.size() == 0); assert(c.size() == 0);
assert(c.empty()); assert(c.empty());
assert(std::distance(c.begin(), c.end()) == 0); assert(std::distance(c.begin(), c.end()) == 0);
assert(c.load_factor() == 0); assert(c.load_factor() == 0);
assert(c.max_load_factor() == 1); assert(c.max_load_factor() == 1);
} }
#if _LIBCPP_STD_VER > 11 #if TEST_STD_VER > 11
{ {
typedef NotConstructible T; typedef NotConstructible T;
typedef test_hash<std::hash<T>> HF; typedef test_hash<std::hash<T>> HF;
typedef test_compare<std::equal_to<T>> Comp; typedef test_compare<std::equal_to<T>> Comp;
typedef test_allocator<T> A; typedef test_allocator<T> A;
typedef std::unordered_set<T, HF, Comp, A> C; typedef std::unordered_set<T, HF, Comp, A> C;
A a(43); A a(43);
Show All 37 Lines

test/std/containers/unord/unord.set/unord.set.cnstr/init.pass.cpp

Show All 13 Lines
// class unordered_set // class unordered_set
// unordered_set(initializer_list<value_type> il); // unordered_set(initializer_list<value_type> il);
#include <unordered_set> #include <unordered_set>
#include <cassert> #include <cassert>
#include <cfloat> #include <cfloat>
#include "test_macros.h"
#include "../../../test_compare.h" #include "../../../test_compare.h"
#include "../../../test_hash.h" #include "../../../test_hash.h"
#include "test_allocator.h" #include "test_allocator.h"
#include "min_allocator.h" #include "min_allocator.h"
int main() int main()
{ {
#ifndef _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS #ifndef _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS
▲ Show 20 Lines • Show All 53 Lines • ▼ Show 20 Lines#if TEST_STD_VER >= 11
assert(c.key_eq() == test_compare<std::equal_to<int> >()); assert(c.key_eq() == test_compare<std::equal_to<int> >());
assert(c.get_allocator() == min_allocator<int>()); assert(c.get_allocator() == min_allocator<int>());
assert(!c.empty()); assert(!c.empty());
assert(std::distance(c.begin(), c.end()) == c.size()); assert(std::distance(c.begin(), c.end()) == c.size());
assert(std::distance(c.cbegin(), c.cend()) == c.size()); assert(std::distance(c.cbegin(), c.cend()) == c.size());
assert(fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON); assert(fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
assert(c.max_load_factor() == 1); assert(c.max_load_factor() == 1);
} }
#if _LIBCPP_STD_VER > 11 #if TEST_STD_VER > 11
{ {
typedef int T; typedef int T;
typedef test_hash<std::hash<T>> HF; typedef test_hash<std::hash<T>> HF;
typedef test_compare<std::equal_to<T>> Comp; typedef test_compare<std::equal_to<T>> Comp;
typedef test_allocator<T> A; typedef test_allocator<T> A;
typedef std::unordered_set<T, HF, Comp, A> C; typedef std::unordered_set<T, HF, Comp, A> C;
A a(42); A a(42);
▲ Show 20 Lines • Show All 64 Lines • Show Last 20 Lines

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

Show All 14 Lines
// template <class InputIterator> // template <class InputIterator>
// unordered_set(InputIterator first, InputIterator last); // unordered_set(InputIterator first, InputIterator last);
#include <unordered_set> #include <unordered_set>
#include <cassert> #include <cassert>
#include <cfloat> #include <cfloat>
#include "test_macros.h"
#include "test_iterators.h" #include "test_iterators.h"
#include "../../../test_compare.h" #include "../../../test_compare.h"
#include "../../../test_hash.h" #include "../../../test_hash.h"
#include "test_allocator.h" #include "test_allocator.h"
#include "min_allocator.h" #include "min_allocator.h"
int main() int main()
{ {
▲ Show 20 Lines • Show All 57 Lines • ▼ Show 20 Lines#if TEST_STD_VER >= 11
assert(c.key_eq() == test_compare<std::equal_to<int> >()); assert(c.key_eq() == test_compare<std::equal_to<int> >());
assert(c.get_allocator() == min_allocator<int>()); assert(c.get_allocator() == min_allocator<int>());
assert(!c.empty()); assert(!c.empty());
assert(std::distance(c.begin(), c.end()) == c.size()); assert(std::distance(c.begin(), c.end()) == c.size());
assert(std::distance(c.cbegin(), c.cend()) == c.size()); assert(std::distance(c.cbegin(), c.cend()) == c.size());
assert(fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON); assert(fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
assert(c.max_load_factor() == 1); assert(c.max_load_factor() == 1);
} }
#if _LIBCPP_STD_VER > 11 #if TEST_STD_VER > 11
{ {
typedef int T; typedef int T;
typedef test_hash<std::hash<T>> HF; typedef test_hash<std::hash<T>> HF;
typedef test_compare<std::equal_to<T>> Comp; typedef test_compare<std::equal_to<T>> Comp;
typedef test_allocator<T> A; typedef test_allocator<T> A;
typedef std::unordered_set<T, HF, Comp, A> C; typedef std::unordered_set<T, HF, Comp, A> C;
T arr[] = T arr[] =
{ {
▲ Show 20 Lines • Show All 64 Lines • Show Last 20 Lines

test/std/experimental/optional/optional.nullops/less_equal.pass.cpp

Show All 9 Lines
// <optional> // <optional>
// template <class T> constexpr bool operator<=(const optional<T>& x, nullopt_t) noexcept; // template <class T> constexpr bool operator<=(const optional<T>& x, nullopt_t) noexcept;
// template <class T> constexpr bool operator<=(nullopt_t, const optional<T>& x) noexcept; // template <class T> constexpr bool operator<=(nullopt_t, const optional<T>& x) noexcept;
#include <experimental/optional> #include <experimental/optional>
#include "test_macros.h"
int main() int main()
{ {
#if _LIBCPP_STD_VER > 11 #if TEST_STD_VER > 11
using std::experimental::optional; using std::experimental::optional;
using std::experimental::nullopt_t; using std::experimental::nullopt_t;
using std::experimental::nullopt; using std::experimental::nullopt;
{ {
typedef int T; typedef int T;
typedef optional<T> O; typedef optional<T> O;
Show All 13 Lines

test/std/experimental/string.view/string.view.access/data.pass.cpp

Show All 33 Lines
#if TEST_STD_VER >= 11 #if TEST_STD_VER >= 11
test ( u"ABCDE", 5 ); test ( u"ABCDE", 5 );
test ( u"a", 1 ); test ( u"a", 1 );
test ( U"ABCDE", 5 ); test ( U"ABCDE", 5 );
test ( U"a", 1 ); test ( U"a", 1 );
#endif #endif
#if _LIBCPP_STD_VER > 11 #if TEST_STD_VER > 11
{ {
constexpr const char *s = "ABC"; constexpr const char *s = "ABC";
constexpr std::experimental::basic_string_view<char> sv( s, 2 ); constexpr std::experimental::basic_string_view<char> sv( s, 2 );
static_assert( sv.length() == 2, "" ); static_assert( sv.length() == 2, "" );
static_assert( sv.data() == s, "" ); static_assert( sv.data() == s, "" );
} }
#endif #endif
} }

test/std/experimental/string.view/string.view.access/index.pass.cpp

Show All 36 Lines
#if TEST_STD_VER >= 11 #if TEST_STD_VER >= 11
test ( u"ABCDE", 5 ); test ( u"ABCDE", 5 );
test ( u"a", 1 ); test ( u"a", 1 );
test ( U"ABCDE", 5 ); test ( U"ABCDE", 5 );
test ( U"a", 1 ); test ( U"a", 1 );
#endif #endif
#if _LIBCPP_STD_VER > 11 #if TEST_STD_VER > 11
{ {
constexpr std::experimental::basic_string_view<char> sv ( "ABC", 2 ); constexpr std::experimental::basic_string_view<char> sv ( "ABC", 2 );
static_assert ( sv.length() == 2, "" ); static_assert ( sv.length() == 2, "" );
static_assert ( sv[0] == 'A', "" ); static_assert ( sv[0] == 'A', "" );
static_assert ( sv[1] == 'B', "" ); static_assert ( sv[1] == 'B', "" );
} }
#endif #endif
} }

test/std/experimental/string.view/string.view.capacity/capacity.pass.cpp

Show All 17 Lines
#include <experimental/string_view> #include <experimental/string_view>
#include <cassert> #include <cassert>
#include "test_macros.h" #include "test_macros.h"
template<typename SV> template<typename SV>
void test1 () { void test1 () {
#if _LIBCPP_STD_VER > 11 #if TEST_STD_VER > 11
{ {
constexpr SV sv1; constexpr SV sv1;
static_assert ( sv1.size() == 0, "" ); static_assert ( sv1.size() == 0, "" );
static_assert ( sv1.empty(), ""); static_assert ( sv1.empty(), "");
static_assert ( sv1.size() == sv1.length(), "" ); static_assert ( sv1.size() == sv1.length(), "" );
static_assert ( sv1.max_size() > sv1.size(), ""); static_assert ( sv1.max_size() > sv1.size(), "");
} }
#endif #endif
▲ Show 20 Lines • Show All 55 Lines • Show Last 20 Lines

test/std/experimental/string.view/string.view.comparison/opeq.string_view.pointer.pass.cpp

Show All 11 Lines
// template<class charT, class traits> // template<class charT, class traits>
// constexpr bool operator==(basic_string_view<charT,traits> lhs, const charT* rhs); // constexpr bool operator==(basic_string_view<charT,traits> lhs, const charT* rhs);
// template<class charT, class traits> // template<class charT, class traits>
// constexpr bool operator==(const charT* lhs, basic_string_view<charT,traits> rhs); // constexpr bool operator==(const charT* lhs, basic_string_view<charT,traits> rhs);
#include <experimental/string_view> #include <experimental/string_view>
#include <cassert> #include <cassert>
#include "test_macros.h"
#include "constexpr_char_traits.hpp" #include "constexpr_char_traits.hpp"
template <class S> template <class S>
void void
test(S lhs, const typename S::value_type* rhs, bool x) test(S lhs, const typename S::value_type* rhs, bool x)
{ {
assert((lhs == rhs) == x); assert((lhs == rhs) == x);
assert((rhs == lhs) == x); assert((rhs == lhs) == x);
Show All 16 Linesint main()
test(S("abcdefghij"), "abcdefghij", true); test(S("abcdefghij"), "abcdefghij", true);
test(S("abcdefghij"), "abcdefghijklmnopqrst", false); test(S("abcdefghij"), "abcdefghijklmnopqrst", false);
test(S("abcdefghijklmnopqrst"), "", false); test(S("abcdefghijklmnopqrst"), "", false);
test(S("abcdefghijklmnopqrst"), "abcde", false); test(S("abcdefghijklmnopqrst"), "abcde", false);
test(S("abcdefghijklmnopqrst"), "abcdefghij", false); test(S("abcdefghijklmnopqrst"), "abcdefghij", false);
test(S("abcdefghijklmnopqrst"), "abcdefghijklmnopqrst", true); test(S("abcdefghijklmnopqrst"), "abcdefghijklmnopqrst", true);
} }
#if _LIBCPP_STD_VER > 11 #if TEST_STD_VER > 11
{ {
typedef std::experimental::basic_string_view<char, constexpr_char_traits<char>> SV; typedef std::experimental::basic_string_view<char, constexpr_char_traits<char>> SV;
constexpr SV sv1; constexpr SV sv1;
constexpr SV sv2 { "abcde", 5 }; constexpr SV sv2 { "abcde", 5 };
static_assert ( sv1 == "", "" ); static_assert ( sv1 == "", "" );
static_assert ( "" == sv1, "" ); static_assert ( "" == sv1, "" );
static_assert (!(sv1 == "abcde"), "" ); static_assert (!(sv1 == "abcde"), "" );
static_assert (!("abcde" == sv1), "" ); static_assert (!("abcde" == sv1), "" );
static_assert ( sv2 == "abcde", "" ); static_assert ( sv2 == "abcde", "" );
static_assert ( "abcde" == sv2, "" ); static_assert ( "abcde" == sv2, "" );
static_assert (!(sv2 == "abcde0"), "" ); static_assert (!(sv2 == "abcde0"), "" );
static_assert (!("abcde0" == sv2), "" ); static_assert (!("abcde0" == sv2), "" );
} }
#endif #endif
} }

test/std/experimental/string.view/string.view.comparison/opeq.string_view.string_view.pass.cpp

Show All 10 Lines
// template<class charT, class traits, class Allocator> // template<class charT, class traits, class Allocator>
// constexpr bool operator==(const basic_string_view<charT,traits> lhs, // constexpr bool operator==(const basic_string_view<charT,traits> lhs,
// const basic_string_view<charT,traits> rhs); // const basic_string_view<charT,traits> rhs);
#include <experimental/string_view> #include <experimental/string_view>
#include <cassert> #include <cassert>
#include "test_macros.h"
#include "constexpr_char_traits.hpp" #include "constexpr_char_traits.hpp"
template <class S> template <class S>
void void
test(S lhs, S rhs, bool x) test(S lhs, S rhs, bool x)
{ {
assert((lhs == rhs) == x); assert((lhs == rhs) == x);
assert((rhs == lhs) == x); assert((rhs == lhs) == x);
Show All 16 Linesint main()
test(S("abcdefghij"), S("abcdefghij"), true); test(S("abcdefghij"), S("abcdefghij"), true);
test(S("abcdefghij"), S("abcdefghijklmnopqrst"), false); test(S("abcdefghij"), S("abcdefghijklmnopqrst"), false);
test(S("abcdefghijklmnopqrst"), S(""), false); test(S("abcdefghijklmnopqrst"), S(""), false);
test(S("abcdefghijklmnopqrst"), S("abcde"), false); test(S("abcdefghijklmnopqrst"), S("abcde"), false);
test(S("abcdefghijklmnopqrst"), S("abcdefghij"), false); test(S("abcdefghijklmnopqrst"), S("abcdefghij"), false);
test(S("abcdefghijklmnopqrst"), S("abcdefghijklmnopqrst"), true); test(S("abcdefghijklmnopqrst"), S("abcdefghijklmnopqrst"), true);
} }
#if _LIBCPP_STD_VER > 11 #if TEST_STD_VER > 11
{ {
typedef std::experimental::basic_string_view<char, constexpr_char_traits<char>> SV; typedef std::experimental::basic_string_view<char, constexpr_char_traits<char>> SV;
constexpr SV sv1; constexpr SV sv1;
constexpr SV sv2; constexpr SV sv2;
constexpr SV sv3 { "abcde", 5 }; constexpr SV sv3 { "abcde", 5 };
static_assert ( sv1 == sv2, "" ); static_assert ( sv1 == sv2, "" );
static_assert (!(sv1 == sv3), "" ); static_assert (!(sv1 == sv3), "" );
} }
#endif #endif
} }

test/std/experimental/string.view/string.view.comparison/opge.string_view.pointer.pass.cpp

Show All 11 Lines
// template<class charT, class traits, class Allocator> // template<class charT, class traits, class Allocator>
// constexpr bool operator>=(const charT* lhs, basic_string_wiew<charT,traits> rhs); // constexpr bool operator>=(const charT* lhs, basic_string_wiew<charT,traits> rhs);
// template<class charT, class traits, class Allocator> // template<class charT, class traits, class Allocator>
// constexpr bool operator>=(basic_string_wiew<charT,traits> lhs, const charT* rhs); // constexpr bool operator>=(basic_string_wiew<charT,traits> lhs, const charT* rhs);
#include <experimental/string_view> #include <experimental/string_view>
#include <cassert> #include <cassert>
#include "test_macros.h"
#include "constexpr_char_traits.hpp" #include "constexpr_char_traits.hpp"
template <class S> template <class S>
void void
test(const typename S::value_type* lhs, const S& rhs, bool x, bool y) test(const typename S::value_type* lhs, const S& rhs, bool x, bool y)
{ {
assert((lhs >= rhs) == x); assert((lhs >= rhs) == x);
assert((rhs >= lhs) == y); assert((rhs >= lhs) == y);
Show All 16 Linesint main()
test("abcdefghij", S("abcdefghij"), true, true); test("abcdefghij", S("abcdefghij"), true, true);
test("abcdefghij", S("abcdefghijklmnopqrst"), false, true); test("abcdefghij", S("abcdefghijklmnopqrst"), false, true);
test("abcdefghijklmnopqrst", S(""), true, false); test("abcdefghijklmnopqrst", S(""), true, false);
test("abcdefghijklmnopqrst", S("abcde"), true, false); test("abcdefghijklmnopqrst", S("abcde"), true, false);
test("abcdefghijklmnopqrst", S("abcdefghij"), true, false); test("abcdefghijklmnopqrst", S("abcdefghij"), true, false);
test("abcdefghijklmnopqrst", S("abcdefghijklmnopqrst"), true, true); test("abcdefghijklmnopqrst", S("abcdefghijklmnopqrst"), true, true);
} }
#if _LIBCPP_STD_VER > 11 #if TEST_STD_VER > 11
{ {
typedef std::experimental::basic_string_view<char, constexpr_char_traits<char>> SV; typedef std::experimental::basic_string_view<char, constexpr_char_traits<char>> SV;
constexpr SV sv1; constexpr SV sv1;
constexpr SV sv2 { "abcde", 5 }; constexpr SV sv2 { "abcde", 5 };
static_assert ( sv1 >= "", "" ); static_assert ( sv1 >= "", "" );
static_assert ( "" >= sv1, "" ); static_assert ( "" >= sv1, "" );
static_assert (!(sv1 >= "abcde"), "" ); static_assert (!(sv1 >= "abcde"), "" );
Show All 11 Lines

test/std/experimental/string.view/string.view.comparison/opge.string_view.string_view.pass.cpp

Show All 10 Lines
// template<class charT, class traits> // template<class charT, class traits>
// constexpr bool operator>=(basic_string_view<charT,traits> lhs, // constexpr bool operator>=(basic_string_view<charT,traits> lhs,
// basic_string_view<charT,traits> rhs); // basic_string_view<charT,traits> rhs);
#include <experimental/string_view> #include <experimental/string_view>
#include <cassert> #include <cassert>
#include "test_macros.h"
#include "constexpr_char_traits.hpp" #include "constexpr_char_traits.hpp"
template <class S> template <class S>
void void
test(const S& lhs, const S& rhs, bool x, bool y) test(const S& lhs, const S& rhs, bool x, bool y)
{ {
assert((lhs >= rhs) == x); assert((lhs >= rhs) == x);
assert((rhs >= lhs) == y); assert((rhs >= lhs) == y);
Show All 16 Linesint main()
test(S("abcdefghij"), S("abcdefghij"), true, true); test(S("abcdefghij"), S("abcdefghij"), true, true);
test(S("abcdefghij"), S("abcdefghijklmnopqrst"), false, true); test(S("abcdefghij"), S("abcdefghijklmnopqrst"), false, true);
test(S("abcdefghijklmnopqrst"), S(""), true, false); test(S("abcdefghijklmnopqrst"), S(""), true, false);
test(S("abcdefghijklmnopqrst"), S("abcde"), true, false); test(S("abcdefghijklmnopqrst"), S("abcde"), true, false);
test(S("abcdefghijklmnopqrst"), S("abcdefghij"), true, false); test(S("abcdefghijklmnopqrst"), S("abcdefghij"), true, false);
test(S("abcdefghijklmnopqrst"), S("abcdefghijklmnopqrst"), true, true); test(S("abcdefghijklmnopqrst"), S("abcdefghijklmnopqrst"), true, true);
} }
#if _LIBCPP_STD_VER > 11 #if TEST_STD_VER > 11
{ {
typedef std::experimental::basic_string_view<char, constexpr_char_traits<char>> SV; typedef std::experimental::basic_string_view<char, constexpr_char_traits<char>> SV;
constexpr SV sv1; constexpr SV sv1;
constexpr SV sv2 { "abcde", 5 }; constexpr SV sv2 { "abcde", 5 };
static_assert ( sv1 >= sv1, "" ); static_assert ( sv1 >= sv1, "" );
static_assert ( sv2 >= sv2, "" ); static_assert ( sv2 >= sv2, "" );
static_assert (!(sv1 >= sv2), "" ); static_assert (!(sv1 >= sv2), "" );
static_assert ( sv2 >= sv1, "" ); static_assert ( sv2 >= sv1, "" );
} }
#endif #endif
} }

test/std/experimental/string.view/string.view.comparison/opgt.string_view.pointer.pass.cpp

Show All 11 Lines
// constexpr template<class charT, class traits, class Allocator> // constexpr template<class charT, class traits, class Allocator>
// bool operator>(const charT* lhs, basic_string_wiew<charT,traits> rhs); // bool operator>(const charT* lhs, basic_string_wiew<charT,traits> rhs);
// constexpr template<class charT, class traits, class Allocator> // constexpr template<class charT, class traits, class Allocator>
// bool operator>(basic_string_wiew<charT,traits> lhs, const charT* rhs); // bool operator>(basic_string_wiew<charT,traits> lhs, const charT* rhs);
#include <experimental/string_view> #include <experimental/string_view>
#include <cassert> #include <cassert>
#include "test_macros.h"
#include "constexpr_char_traits.hpp" #include "constexpr_char_traits.hpp"
template <class S> template <class S>
void void
test(const typename S::value_type* lhs, const S& rhs, bool x, bool y) test(const typename S::value_type* lhs, const S& rhs, bool x, bool y)
{ {
assert((lhs > rhs) == x); assert((lhs > rhs) == x);
assert((rhs > lhs) == y); assert((rhs > lhs) == y);
Show All 16 Linesint main()
test("abcdefghij", S("abcdefghij"), false, false); test("abcdefghij", S("abcdefghij"), false, false);
test("abcdefghij", S("abcdefghijklmnopqrst"), false, true); test("abcdefghij", S("abcdefghijklmnopqrst"), false, true);
test("abcdefghijklmnopqrst", S(""), true, false); test("abcdefghijklmnopqrst", S(""), true, false);
test("abcdefghijklmnopqrst", S("abcde"), true, false); test("abcdefghijklmnopqrst", S("abcde"), true, false);
test("abcdefghijklmnopqrst", S("abcdefghij"), true, false); test("abcdefghijklmnopqrst", S("abcdefghij"), true, false);
test("abcdefghijklmnopqrst", S("abcdefghijklmnopqrst"), false, false); test("abcdefghijklmnopqrst", S("abcdefghijklmnopqrst"), false, false);
} }
#if _LIBCPP_STD_VER > 11 #if TEST_STD_VER > 11
{ {
typedef std::experimental::basic_string_view<char, constexpr_char_traits<char>> SV; typedef std::experimental::basic_string_view<char, constexpr_char_traits<char>> SV;
constexpr SV sv1; constexpr SV sv1;
constexpr SV sv2 { "abcde", 5 }; constexpr SV sv2 { "abcde", 5 };
static_assert (!(sv1 > ""), "" ); static_assert (!(sv1 > ""), "" );
static_assert (!("" > sv1), "" ); static_assert (!("" > sv1), "" );
static_assert (!(sv1 > "abcde"), "" ); static_assert (!(sv1 > "abcde"), "" );
Show All 11 Lines

test/std/experimental/string.view/string.view.comparison/opgt.string_view.string_view.pass.cpp

Show All 10 Lines
// template<class charT, class traits> // template<class charT, class traits>
// constexpr bool operator>(basic_string_view<charT,traits> lhs, // constexpr bool operator>(basic_string_view<charT,traits> lhs,
// basic_string_view<charT,traits> rhs); // basic_string_view<charT,traits> rhs);
#include <experimental/string_view> #include <experimental/string_view>
#include <cassert> #include <cassert>
#include "test_macros.h"
#include "constexpr_char_traits.hpp" #include "constexpr_char_traits.hpp"
template <class S> template <class S>
void void
test(const S& lhs, const S& rhs, bool x, bool y) test(const S& lhs, const S& rhs, bool x, bool y)
{ {
assert((lhs > rhs) == x); assert((lhs > rhs) == x);
assert((rhs > lhs) == y); assert((rhs > lhs) == y);
Show All 16 Linesint main()
test(S("abcdefghij"), S("abcdefghij"), false, false); test(S("abcdefghij"), S("abcdefghij"), false, false);
test(S("abcdefghij"), S("abcdefghijklmnopqrst"), false, true); test(S("abcdefghij"), S("abcdefghijklmnopqrst"), false, true);
test(S("abcdefghijklmnopqrst"), S(""), true, false); test(S("abcdefghijklmnopqrst"), S(""), true, false);
test(S("abcdefghijklmnopqrst"), S("abcde"), true, false); test(S("abcdefghijklmnopqrst"), S("abcde"), true, false);
test(S("abcdefghijklmnopqrst"), S("abcdefghij"), true, false); test(S("abcdefghijklmnopqrst"), S("abcdefghij"), true, false);
test(S("abcdefghijklmnopqrst"), S("abcdefghijklmnopqrst"), false, false); test(S("abcdefghijklmnopqrst"), S("abcdefghijklmnopqrst"), false, false);
} }
#if _LIBCPP_STD_VER > 11 #if TEST_STD_VER > 11
{ {
typedef std::experimental::basic_string_view<char, constexpr_char_traits<char>> SV; typedef std::experimental::basic_string_view<char, constexpr_char_traits<char>> SV;
constexpr SV sv1; constexpr SV sv1;
constexpr SV sv2 { "abcde", 5 }; constexpr SV sv2 { "abcde", 5 };
static_assert (!(sv1 > sv1), "" ); static_assert (!(sv1 > sv1), "" );
static_assert (!(sv2 > sv2), "" ); static_assert (!(sv2 > sv2), "" );
static_assert (!(sv1 > sv2), "" ); static_assert (!(sv1 > sv2), "" );
static_assert ( sv2 > sv1, "" ); static_assert ( sv2 > sv1, "" );
} }
#endif #endif
} }

test/std/experimental/string.view/string.view.comparison/ople.string_view.pointer.pass.cpp

Show All 11 Lines
// template<class charT, class traits, class Allocator> // template<class charT, class traits, class Allocator>
// constexpr bool operator<=(const charT* lhs, basic_string_wiew<charT,traits> rhs); // constexpr bool operator<=(const charT* lhs, basic_string_wiew<charT,traits> rhs);
// template<class charT, class traits, class Allocator> // template<class charT, class traits, class Allocator>
// constexpr bool operator<=(basic_string_wiew<charT,traits> lhs, const charT* rhs); // constexpr bool operator<=(basic_string_wiew<charT,traits> lhs, const charT* rhs);
#include <experimental/string_view> #include <experimental/string_view>
#include <cassert> #include <cassert>
#include "test_macros.h"
#include "constexpr_char_traits.hpp" #include "constexpr_char_traits.hpp"
template <class S> template <class S>
void void
test(const typename S::value_type* lhs, const S& rhs, bool x, bool y) test(const typename S::value_type* lhs, const S& rhs, bool x, bool y)
{ {
assert((lhs <= rhs) == x); assert((lhs <= rhs) == x);
assert((rhs <= lhs) == y); assert((rhs <= lhs) == y);
Show All 16 Linesint main()
test("abcdefghij", S("abcdefghij"), true, true); test("abcdefghij", S("abcdefghij"), true, true);
test("abcdefghij", S("abcdefghijklmnopqrst"), true, false); test("abcdefghij", S("abcdefghijklmnopqrst"), true, false);
test("abcdefghijklmnopqrst", S(""), false, true); test("abcdefghijklmnopqrst", S(""), false, true);
test("abcdefghijklmnopqrst", S("abcde"), false, true); test("abcdefghijklmnopqrst", S("abcde"), false, true);
test("abcdefghijklmnopqrst", S("abcdefghij"), false, true); test("abcdefghijklmnopqrst", S("abcdefghij"), false, true);
test("abcdefghijklmnopqrst", S("abcdefghijklmnopqrst"), true, true); test("abcdefghijklmnopqrst", S("abcdefghijklmnopqrst"), true, true);
} }
#if _LIBCPP_STD_VER > 11 #if TEST_STD_VER > 11
{ {
typedef std::experimental::basic_string_view<char, constexpr_char_traits<char>> SV; typedef std::experimental::basic_string_view<char, constexpr_char_traits<char>> SV;
constexpr SV sv1; constexpr SV sv1;
constexpr SV sv2 { "abcde", 5 }; constexpr SV sv2 { "abcde", 5 };
static_assert ( sv1 <= "", "" ); static_assert ( sv1 <= "", "" );
static_assert ( "" <= sv1, "" ); static_assert ( "" <= sv1, "" );
static_assert ( sv1 <= "abcde", "" ); static_assert ( sv1 <= "abcde", "" );
Show All 11 Lines

test/std/experimental/string.view/string.view.comparison/ople.string_view.string_view.pass.cpp

Show All 10 Lines
// template<class charT, class traits> // template<class charT, class traits>
// constexpr bool operator<=(basic_string_view<charT,traits> lhs, // constexpr bool operator<=(basic_string_view<charT,traits> lhs,
// basic_string_view<charT,traits> rhs); // basic_string_view<charT,traits> rhs);
#include <experimental/string_view> #include <experimental/string_view>
#include <cassert> #include <cassert>
#include "test_macros.h"
#include "constexpr_char_traits.hpp" #include "constexpr_char_traits.hpp"
template <class S> template <class S>
void void
test(const S& lhs, const S& rhs, bool x, bool y) test(const S& lhs, const S& rhs, bool x, bool y)
{ {
assert((lhs <= rhs) == x); assert((lhs <= rhs) == x);
assert((rhs <= lhs) == y); assert((rhs <= lhs) == y);
Show All 16 Linesint main()
test(S("abcdefghij"), S("abcdefghij"), true, true); test(S("abcdefghij"), S("abcdefghij"), true, true);
test(S("abcdefghij"), S("abcdefghijklmnopqrst"), true, false); test(S("abcdefghij"), S("abcdefghijklmnopqrst"), true, false);
test(S("abcdefghijklmnopqrst"), S(""), false, true); test(S("abcdefghijklmnopqrst"), S(""), false, true);
test(S("abcdefghijklmnopqrst"), S("abcde"), false, true); test(S("abcdefghijklmnopqrst"), S("abcde"), false, true);
test(S("abcdefghijklmnopqrst"), S("abcdefghij"), false, true); test(S("abcdefghijklmnopqrst"), S("abcdefghij"), false, true);
test(S("abcdefghijklmnopqrst"), S("abcdefghijklmnopqrst"), true, true); test(S("abcdefghijklmnopqrst"), S("abcdefghijklmnopqrst"), true, true);
} }
#if _LIBCPP_STD_VER > 11 #if TEST_STD_VER > 11
{ {
typedef std::experimental::basic_string_view<char, constexpr_char_traits<char>> SV; typedef std::experimental::basic_string_view<char, constexpr_char_traits<char>> SV;
constexpr SV sv1; constexpr SV sv1;
constexpr SV sv2 { "abcde", 5 }; constexpr SV sv2 { "abcde", 5 };
static_assert ( sv1 <= sv1, "" ); static_assert ( sv1 <= sv1, "" );
static_assert ( sv2 <= sv2, "" ); static_assert ( sv2 <= sv2, "" );
static_assert ( sv1 <= sv2, "" ); static_assert ( sv1 <= sv2, "" );
static_assert (!(sv2 <= sv1), "" ); static_assert (!(sv2 <= sv1), "" );
} }
#endif #endif
} }

test/std/experimental/string.view/string.view.comparison/oplt.string_view.pointer.pass.cpp

Show All 11 Lines
// template<class charT, class traits, class Allocator> // template<class charT, class traits, class Allocator>
// constexpr bool operator<(const charT* lhs, basic_string_wiew<charT,traits> rhs); // constexpr bool operator<(const charT* lhs, basic_string_wiew<charT,traits> rhs);
// template<class charT, class traits, class Allocator> // template<class charT, class traits, class Allocator>
// constexpr bool operator<(basic_string_wiew<charT,traits> lhs, const charT* rhs); // constexpr bool operator<(basic_string_wiew<charT,traits> lhs, const charT* rhs);
#include <experimental/string_view> #include <experimental/string_view>
#include <cassert> #include <cassert>
#include "test_macros.h"
#include "constexpr_char_traits.hpp" #include "constexpr_char_traits.hpp"
template <class S> template <class S>
void void
test(const typename S::value_type* lhs, const S& rhs, bool x, bool y) test(const typename S::value_type* lhs, const S& rhs, bool x, bool y)
{ {
assert((lhs < rhs) == x); assert((lhs < rhs) == x);
assert((rhs < lhs) == y); assert((rhs < lhs) == y);
Show All 16 Linesint main()
test("abcdefghij", S("abcdefghij"), false, false); test("abcdefghij", S("abcdefghij"), false, false);
test("abcdefghij", S("abcdefghijklmnopqrst"), true, false); test("abcdefghij", S("abcdefghijklmnopqrst"), true, false);
test("abcdefghijklmnopqrst", S(""), false, true); test("abcdefghijklmnopqrst", S(""), false, true);
test("abcdefghijklmnopqrst", S("abcde"), false, true); test("abcdefghijklmnopqrst", S("abcde"), false, true);
test("abcdefghijklmnopqrst", S("abcdefghij"), false, true); test("abcdefghijklmnopqrst", S("abcdefghij"), false, true);
test("abcdefghijklmnopqrst", S("abcdefghijklmnopqrst"), false, false); test("abcdefghijklmnopqrst", S("abcdefghijklmnopqrst"), false, false);
} }
#if _LIBCPP_STD_VER > 11 #if TEST_STD_VER > 11
{ {
typedef std::experimental::basic_string_view<char, constexpr_char_traits<char>> SV; typedef std::experimental::basic_string_view<char, constexpr_char_traits<char>> SV;
constexpr SV sv1; constexpr SV sv1;
constexpr SV sv2 { "abcde", 5 }; constexpr SV sv2 { "abcde", 5 };
static_assert (!(sv1 < ""), "" ); static_assert (!(sv1 < ""), "" );
static_assert (!("" < sv1), "" ); static_assert (!("" < sv1), "" );
static_assert ( sv1 < "abcde", "" ); static_assert ( sv1 < "abcde", "" );
Show All 11 Lines

test/std/experimental/string.view/string.view.comparison/oplt.string_view.string_view.pass.cpp

Show All 10 Lines
// template<class charT, class traits> // template<class charT, class traits>
// constexpr bool operator<(basic_string_view<charT,traits> lhs, // constexpr bool operator<(basic_string_view<charT,traits> lhs,
// basic_string_view<charT,traits> rhs); // basic_string_view<charT,traits> rhs);
#include <experimental/string_view> #include <experimental/string_view>
#include <cassert> #include <cassert>
#include "test_macros.h"
#include "constexpr_char_traits.hpp" #include "constexpr_char_traits.hpp"
template <class S> template <class S>
void void
test(const S& lhs, const S& rhs, bool x, bool y) test(const S& lhs, const S& rhs, bool x, bool y)
{ {
assert((lhs < rhs) == x); assert((lhs < rhs) == x);
assert((rhs < lhs) == y); assert((rhs < lhs) == y);
Show All 16 Linesint main()
test(S("abcdefghij"), S("abcdefghij"), false, false); test(S("abcdefghij"), S("abcdefghij"), false, false);
test(S("abcdefghij"), S("abcdefghijklmnopqrst"), true, false); test(S("abcdefghij"), S("abcdefghijklmnopqrst"), true, false);
test(S("abcdefghijklmnopqrst"), S(""), false, true); test(S("abcdefghijklmnopqrst"), S(""), false, true);
test(S("abcdefghijklmnopqrst"), S("abcde"), false, true); test(S("abcdefghijklmnopqrst"), S("abcde"), false, true);
test(S("abcdefghijklmnopqrst"), S("abcdefghij"), false, true); test(S("abcdefghijklmnopqrst"), S("abcdefghij"), false, true);
test(S("abcdefghijklmnopqrst"), S("abcdefghijklmnopqrst"), false, false); test(S("abcdefghijklmnopqrst"), S("abcdefghijklmnopqrst"), false, false);
} }
#if _LIBCPP_STD_VER > 11 #if TEST_STD_VER > 11
{ {
typedef std::experimental::basic_string_view<char, constexpr_char_traits<char>> SV; typedef std::experimental::basic_string_view<char, constexpr_char_traits<char>> SV;
constexpr SV sv1; constexpr SV sv1;
constexpr SV sv2 { "abcde", 5 }; constexpr SV sv2 { "abcde", 5 };
static_assert (!(sv1 < sv1), "" ); static_assert (!(sv1 < sv1), "" );
static_assert (!(sv2 < sv2), "" ); static_assert (!(sv2 < sv2), "" );
static_assert ( sv1 < sv2, "" ); static_assert ( sv1 < sv2, "" );
static_assert (!(sv2 < sv1), "" ); static_assert (!(sv2 < sv1), "" );
} }
#endif #endif
} }

test/std/experimental/string.view/string.view.comparison/opne.string_view.pointer.pass.cpp

Show All 11 Lines
// template<class charT, class traits> // template<class charT, class traits>
// constexpr bool operator!=(basic_string_view<charT,traits> lhs, const charT* rhs); // constexpr bool operator!=(basic_string_view<charT,traits> lhs, const charT* rhs);
// template<class charT, class traits> // template<class charT, class traits>
// constexpr bool operator!=(const charT* lhs, basic_string_view<charT,traits> rhs); // constexpr bool operator!=(const charT* lhs, basic_string_view<charT,traits> rhs);
#include <experimental/string_view> #include <experimental/string_view>
#include <cassert> #include <cassert>
#include "test_macros.h"
#include "constexpr_char_traits.hpp" #include "constexpr_char_traits.hpp"
template <class S> template <class S>
void void
test(S lhs, const typename S::value_type* rhs, bool x) test(S lhs, const typename S::value_type* rhs, bool x)
{ {
assert((lhs != rhs) == x); assert((lhs != rhs) == x);
assert((rhs != lhs) == x); assert((rhs != lhs) == x);
Show All 16 Linesint main()
test(S("abcdefghij"), "abcdefghij", false); test(S("abcdefghij"), "abcdefghij", false);
test(S("abcdefghij"), "abcdefghijklmnopqrst", true); test(S("abcdefghij"), "abcdefghijklmnopqrst", true);
test(S("abcdefghijklmnopqrst"), "", true); test(S("abcdefghijklmnopqrst"), "", true);
test(S("abcdefghijklmnopqrst"), "abcde", true); test(S("abcdefghijklmnopqrst"), "abcde", true);
test(S("abcdefghijklmnopqrst"), "abcdefghij", true); test(S("abcdefghijklmnopqrst"), "abcdefghij", true);
test(S("abcdefghijklmnopqrst"), "abcdefghijklmnopqrst", false); test(S("abcdefghijklmnopqrst"), "abcdefghijklmnopqrst", false);
} }
#if _LIBCPP_STD_VER > 11 #if TEST_STD_VER > 11
{ {
typedef std::experimental::basic_string_view<char, constexpr_char_traits<char>> SV; typedef std::experimental::basic_string_view<char, constexpr_char_traits<char>> SV;
constexpr SV sv1; constexpr SV sv1;
constexpr SV sv2 { "abcde", 5 }; constexpr SV sv2 { "abcde", 5 };
static_assert (!(sv1 != ""), "" ); static_assert (!(sv1 != ""), "" );
static_assert (!("" != sv1), "" ); static_assert (!("" != sv1), "" );
static_assert ( sv1 != "abcde", "" ); static_assert ( sv1 != "abcde", "" );
Show All 9 Lines

test/std/experimental/string.view/string.view.comparison/opne.string_view.string_view.pass.cpp

Show All 10 Lines
// template<class charT, class traits, class Allocator> // template<class charT, class traits, class Allocator>
// constexpr bool operator!=(const basic_string_view<charT,traits> lhs, // constexpr bool operator!=(const basic_string_view<charT,traits> lhs,
// const basic_string_view<charT,traits> rhs); // const basic_string_view<charT,traits> rhs);
#include <experimental/string_view> #include <experimental/string_view>
#include <cassert> #include <cassert>
#include "test_macros.h"
#include "constexpr_char_traits.hpp" #include "constexpr_char_traits.hpp"
template <class S> template <class S>
void void
test(S lhs, S rhs, bool x) test(S lhs, S rhs, bool x)
{ {
assert((lhs != rhs) == x); assert((lhs != rhs) == x);
assert((rhs != lhs) == x); assert((rhs != lhs) == x);
Show All 16 Linesint main()
test(S("abcdefghij"), S("abcdefghij"), false); test(S("abcdefghij"), S("abcdefghij"), false);
test(S("abcdefghij"), S("abcdefghijklmnopqrst"), true); test(S("abcdefghij"), S("abcdefghijklmnopqrst"), true);
test(S("abcdefghijklmnopqrst"), S(""), true); test(S("abcdefghijklmnopqrst"), S(""), true);
test(S("abcdefghijklmnopqrst"), S("abcde"), true); test(S("abcdefghijklmnopqrst"), S("abcde"), true);
test(S("abcdefghijklmnopqrst"), S("abcdefghij"), true); test(S("abcdefghijklmnopqrst"), S("abcdefghij"), true);
test(S("abcdefghijklmnopqrst"), S("abcdefghijklmnopqrst"), false); test(S("abcdefghijklmnopqrst"), S("abcdefghijklmnopqrst"), false);
} }
#if _LIBCPP_STD_VER > 11 #if TEST_STD_VER > 11
{ {
typedef std::experimental::basic_string_view<char, constexpr_char_traits<char>> SV; typedef std::experimental::basic_string_view<char, constexpr_char_traits<char>> SV;
constexpr SV sv1; constexpr SV sv1;
constexpr SV sv2; constexpr SV sv2;
constexpr SV sv3 { "abcde", 5 }; constexpr SV sv3 { "abcde", 5 };
static_assert (!( sv1 != sv2), "" ); static_assert (!( sv1 != sv2), "" );
static_assert ( sv1 != sv3, "" ); static_assert ( sv1 != sv3, "" );
} }
#endif #endif
} }

test/std/experimental/string.view/string.view.cons/default.pass.cpp

Show All 9 Lines
// <string_view> // <string_view>
// constexpr basic_string_view () noexcept; // constexpr basic_string_view () noexcept;
#include <experimental/string_view> #include <experimental/string_view>
#include <cassert> #include <cassert>
#include "test_macros.h"
template<typename T> template<typename T>
void test () { void test () {
#if _LIBCPP_STD_VER > 11 #if TEST_STD_VER > 11
{ {
constexpr T sv1; constexpr T sv1;
static_assert ( sv1.size() == 0, "" ); static_assert ( sv1.size() == 0, "" );
static_assert ( sv1.empty(), ""); static_assert ( sv1.empty(), "");
} }
#endif #endif
{ {
Show All 18 Lines

test/std/experimental/string.view/string.view.cons/from_literal.pass.cpp

Show All 12 Lines
// constexpr basic_string_view(const _CharT* _s) // constexpr basic_string_view(const _CharT* _s)
// : __data (_s), __size(_Traits::length(_s)) {} // : __data (_s), __size(_Traits::length(_s)) {}
#include <experimental/string_view> #include <experimental/string_view>
#include <string> #include <string>
#include <cassert> #include <cassert>
#include "test_macros.h"
#include "constexpr_char_traits.hpp" #include "constexpr_char_traits.hpp"
template<typename CharT> template<typename CharT>
size_t StrLen ( const CharT *s ) { size_t StrLen ( const CharT *s ) {
size_t retVal = 0; size_t retVal = 0;
while ( *s != 0 ) { ++retVal; ++s; } while ( *s != 0 ) { ++retVal; ++s; }
return retVal; return retVal;
} }
Show All 21 Lines#if TEST_STD_VER >= 11
test ( u"A" ); test ( u"A" );
test ( u"" ); test ( u"" );
test ( U"QBCDE" ); test ( U"QBCDE" );
test ( U"A" ); test ( U"A" );
test ( U"" ); test ( U"" );
#endif #endif
#if _LIBCPP_STD_VER > 11 #if TEST_STD_VER > 11
{ {
constexpr std::experimental::basic_string_view<char, constexpr_char_traits<char>> sv1 ( "ABCDE" ); constexpr std::experimental::basic_string_view<char, constexpr_char_traits<char>> sv1 ( "ABCDE" );
static_assert ( sv1.size() == 5, ""); static_assert ( sv1.size() == 5, "");
} }
#endif #endif
} }

test/std/experimental/string.view/string.view.cons/from_ptr_len.pass.cpp

Show All 28 Linesvoid test ( const CharT *s, size_t sz ) {
} }
} }
int main () { int main () {
test ( "QBCDE", 5 ); test ( "QBCDE", 5 );
test ( "QBCDE", 2 ); test ( "QBCDE", 2 );
test ( "", 0 ); test ( "", 0 );
#if _LIBCPP_STD_VER > 11 #if TEST_STD_VER > 11
{ {
constexpr const char *s = "QBCDE"; constexpr const char *s = "QBCDE";
constexpr std::experimental::basic_string_view<char> sv1 ( s, 2 ); constexpr std::experimental::basic_string_view<char> sv1 ( s, 2 );
static_assert ( sv1.size() == 2, "" ); static_assert ( sv1.size() == 2, "" );
static_assert ( sv1.data() == s, "" ); static_assert ( sv1.data() == s, "" );
} }
#endif #endif
test ( L"QBCDE", 5 ); test ( L"QBCDE", 5 );
test ( L"QBCDE", 2 ); test ( L"QBCDE", 2 );
test ( L"", 0 ); test ( L"", 0 );
#if _LIBCPP_STD_VER > 11 #if TEST_STD_VER > 11
{ {
constexpr const wchar_t *s = L"QBCDE"; constexpr const wchar_t *s = L"QBCDE";
constexpr std::experimental::basic_string_view<wchar_t> sv1 ( s, 2 ); constexpr std::experimental::basic_string_view<wchar_t> sv1 ( s, 2 );
static_assert ( sv1.size() == 2, "" ); static_assert ( sv1.size() == 2, "" );
static_assert ( sv1.data() == s, "" ); static_assert ( sv1.data() == s, "" );
} }
#endif #endif
#if TEST_STD_VER >= 11 #if TEST_STD_VER >= 11
test ( u"QBCDE", 5 ); test ( u"QBCDE", 5 );
test ( u"QBCDE", 2 ); test ( u"QBCDE", 2 );
test ( u"", 0 ); test ( u"", 0 );
#if _LIBCPP_STD_VER > 11 #if TEST_STD_VER > 11
{ {
constexpr const char16_t *s = u"QBCDE"; constexpr const char16_t *s = u"QBCDE";
constexpr std::experimental::basic_string_view<char16_t> sv1 ( s, 2 ); constexpr std::experimental::basic_string_view<char16_t> sv1 ( s, 2 );
static_assert ( sv1.size() == 2, "" ); static_assert ( sv1.size() == 2, "" );
static_assert ( sv1.data() == s, "" ); static_assert ( sv1.data() == s, "" );
} }
#endif #endif
test ( U"QBCDE", 5 ); test ( U"QBCDE", 5 );
test ( U"QBCDE", 2 ); test ( U"QBCDE", 2 );
test ( U"", 0 ); test ( U"", 0 );
#if _LIBCPP_STD_VER > 11 #if TEST_STD_VER > 11
{ {
constexpr const char32_t *s = U"QBCDE"; constexpr const char32_t *s = U"QBCDE";
constexpr std::experimental::basic_string_view<char32_t> sv1 ( s, 2 ); constexpr std::experimental::basic_string_view<char32_t> sv1 ( s, 2 );
static_assert ( sv1.size() == 2, "" ); static_assert ( sv1.size() == 2, "" );
static_assert ( sv1.data() == s, "" ); static_assert ( sv1.data() == s, "" );
} }
#endif #endif
#endif #endif
} }

test/std/experimental/string.view/string.view.find/find_char_size.pass.cpp

//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// The LLVM Compiler Infrastructure // The LLVM Compiler Infrastructure
// //
// This file is dual licensed under the MIT and the University of Illinois Open // This file is dual licensed under the MIT and the University of Illinois Open
// Source Licenses. See LICENSE.TXT for details. // Source Licenses. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// <string_view> // <string_view>
// constexpr size_type find(charT c, size_type pos = 0) const; // constexpr size_type find(charT c, size_type pos = 0) const;
#include <experimental/string_view> #include <experimental/string_view>
#include <cassert> #include <cassert>
#include "test_macros.h"
#include "constexpr_char_traits.hpp" #include "constexpr_char_traits.hpp"
template <class S> template <class S>
void void
test(const S& s, typename S::value_type c, typename S::size_type pos, test(const S& s, typename S::value_type c, typename S::size_type pos,
typename S::size_type x) typename S::size_type x)
{ {
assert(s.find(c, pos) == x); assert(s.find(c, pos) == x);
Show All 36 Linesint main()
test(S("abcdeabcdeabcdeabcde"), 'c', 21, S::npos); test(S("abcdeabcdeabcdeabcde"), 'c', 21, S::npos);
test(S(""), 'c', S::npos); test(S(""), 'c', S::npos);
test(S("abcde"), 'c', 2); test(S("abcde"), 'c', 2);
test(S("abcdeabcde"), 'c', 2); test(S("abcdeabcde"), 'c', 2);
test(S("abcdeabcdeabcdeabcde"), 'c', 2); test(S("abcdeabcdeabcdeabcde"), 'c', 2);
} }
#if _LIBCPP_STD_VER > 11 #if TEST_STD_VER > 11
{ {
typedef std::experimental::basic_string_view<char, constexpr_char_traits<char>> SV; typedef std::experimental::basic_string_view<char, constexpr_char_traits<char>> SV;
constexpr SV sv1; constexpr SV sv1;
constexpr SV sv2 { "abcde", 5 }; constexpr SV sv2 { "abcde", 5 };
static_assert (sv1.find( 'c', 0 ) == SV::npos, "" ); static_assert (sv1.find( 'c', 0 ) == SV::npos, "" );
static_assert (sv1.find( 'c', 1 ) == SV::npos, "" ); static_assert (sv1.find( 'c', 1 ) == SV::npos, "" );
static_assert (sv2.find( 'c', 0 ) == 2, "" ); static_assert (sv2.find( 'c', 0 ) == 2, "" );
static_assert (sv2.find( 'c', 1 ) == 2, "" ); static_assert (sv2.find( 'c', 1 ) == 2, "" );
static_assert (sv2.find( 'c', 2 ) == 2, "" ); static_assert (sv2.find( 'c', 2 ) == 2, "" );
static_assert (sv2.find( 'c', 3 ) == SV::npos, "" ); static_assert (sv2.find( 'c', 3 ) == SV::npos, "" );
static_assert (sv2.find( 'c', 4 ) == SV::npos, "" ); static_assert (sv2.find( 'c', 4 ) == SV::npos, "" );
} }
#endif #endif
} }

test/std/experimental/string.view/string.view.find/find_first_not_of_char_size.pass.cpp

//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// The LLVM Compiler Infrastructure // The LLVM Compiler Infrastructure
// //
// This file is dual licensed under the MIT and the University of Illinois Open // This file is dual licensed under the MIT and the University of Illinois Open
// Source Licenses. See LICENSE.TXT for details. // Source Licenses. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// <string_view> // <string_view>
// constexpr size_type find_first_not_of(charT c, size_type pos = 0) const; // constexpr size_type find_first_not_of(charT c, size_type pos = 0) const;
#include <experimental/string_view> #include <experimental/string_view>
#include <cassert> #include <cassert>
#include "test_macros.h"
#include "constexpr_char_traits.hpp" #include "constexpr_char_traits.hpp"
template <class S> template <class S>
void void
test(const S& s, typename S::value_type c, typename S::size_type pos, test(const S& s, typename S::value_type c, typename S::size_type pos,
typename S::size_type x) typename S::size_type x)
{ {
assert(s.find_first_not_of(c, pos) == x); assert(s.find_first_not_of(c, pos) == x);
Show All 38 Linesint main()
test(S(""), 'q', S::npos); test(S(""), 'q', S::npos);
test(S("q"), 'q', S::npos); test(S("q"), 'q', S::npos);
test(S("qqq"), 'q', S::npos); test(S("qqq"), 'q', S::npos);
test(S("csope"), 'q', 0); test(S("csope"), 'q', 0);
test(S("gfsmthlkon"), 'q', 0); test(S("gfsmthlkon"), 'q', 0);
test(S("laenfsbridchgotmkqpj"), 'q', 0); test(S("laenfsbridchgotmkqpj"), 'q', 0);
} }
#if _LIBCPP_STD_VER > 11 #if TEST_STD_VER > 11
{ {
typedef std::experimental::basic_string_view<char, constexpr_char_traits<char>> SV; typedef std::experimental::basic_string_view<char, constexpr_char_traits<char>> SV;
constexpr SV sv1; constexpr SV sv1;
constexpr SV sv2 { "abcde", 5 }; constexpr SV sv2 { "abcde", 5 };
static_assert (sv1.find_first_not_of( 'q', 0 ) == SV::npos, "" ); static_assert (sv1.find_first_not_of( 'q', 0 ) == SV::npos, "" );
static_assert (sv1.find_first_not_of( 'q', 1 ) == SV::npos, "" ); static_assert (sv1.find_first_not_of( 'q', 1 ) == SV::npos, "" );
static_assert (sv2.find_first_not_of( 'q', 0 ) == 0, "" ); static_assert (sv2.find_first_not_of( 'q', 0 ) == 0, "" );
static_assert (sv2.find_first_not_of( 'q', 1 ) == 1, "" ); static_assert (sv2.find_first_not_of( 'q', 1 ) == 1, "" );
static_assert (sv2.find_first_not_of( 'q', 5 ) == SV::npos, "" ); static_assert (sv2.find_first_not_of( 'q', 5 ) == SV::npos, "" );
} }
#endif #endif
} }

test/std/experimental/string.view/string.view.find/find_first_not_of_pointer_size.pass.cpp

//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// The LLVM Compiler Infrastructure // The LLVM Compiler Infrastructure
// //
// This file is dual licensed under the MIT and the University of Illinois Open // This file is dual licensed under the MIT and the University of Illinois Open
// Source Licenses. See LICENSE.TXT for details. // Source Licenses. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// <string_view> // <string_view>
// constexpr size_type find_first_not_of(const charT* s, size_type pos = 0) const; // constexpr size_type find_first_not_of(const charT* s, size_type pos = 0) const;
#include <experimental/string_view> #include <experimental/string_view>
#include <cassert> #include <cassert>
#include "test_macros.h"
#include "constexpr_char_traits.hpp" #include "constexpr_char_traits.hpp"
template <class S> template <class S>
void void
test(const S& s, const typename S::value_type* str, typename S::size_type pos, test(const S& s, const typename S::value_type* str, typename S::size_type pos,
typename S::size_type x) typename S::size_type x)
{ {
assert(s.find_first_not_of(str, pos) == x); assert(s.find_first_not_of(str, pos) == x);
▲ Show 20 Lines • Show All 119 Lines • ▼ Show 20 Lines
int main() int main()
{ {
{ {
typedef std::experimental::string_view S; typedef std::experimental::string_view S;
test0<S>(); test0<S>();
test1<S>(); test1<S>();
} }
#if _LIBCPP_STD_VER > 11 #if TEST_STD_VER > 11
{ {
typedef std::experimental::basic_string_view<char, constexpr_char_traits<char>> SV; typedef std::experimental::basic_string_view<char, constexpr_char_traits<char>> SV;
constexpr SV sv1; constexpr SV sv1;
constexpr SV sv2 { "abcde", 5 }; constexpr SV sv2 { "abcde", 5 };
static_assert (sv1.find_first_not_of( "", 0) == SV::npos, "" ); static_assert (sv1.find_first_not_of( "", 0) == SV::npos, "" );
static_assert (sv1.find_first_not_of( "irkhs", 0) == SV::npos, "" ); static_assert (sv1.find_first_not_of( "irkhs", 0) == SV::npos, "" );
static_assert (sv2.find_first_not_of( "", 0) == 0, "" ); static_assert (sv2.find_first_not_of( "", 0) == 0, "" );
static_assert (sv2.find_first_not_of( "gfsrt", 0) == 0, "" ); static_assert (sv2.find_first_not_of( "gfsrt", 0) == 0, "" );
static_assert (sv2.find_first_not_of( "lecar", 0) == 1, "" ); static_assert (sv2.find_first_not_of( "lecar", 0) == 1, "" );
} }
#endif #endif
} }

test/std/experimental/string.view/string.view.find/find_first_not_of_pointer_size_size.pass.cpp

//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// The LLVM Compiler Infrastructure // The LLVM Compiler Infrastructure
// //
// This file is dual licensed under the MIT and the University of Illinois Open // This file is dual licensed under the MIT and the University of Illinois Open
// Source Licenses. See LICENSE.TXT for details. // Source Licenses. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// <string_view> // <string_view>
// constexpr size_type find_first_not_of(const charT* s, size_type pos, size_type n) const; // constexpr size_type find_first_not_of(const charT* s, size_type pos, size_type n) const;
#include <experimental/string_view> #include <experimental/string_view>
#include <cassert> #include <cassert>
#include "test_macros.h"
#include "constexpr_char_traits.hpp" #include "constexpr_char_traits.hpp"
template <class S> template <class S>
void void
test(const S& s, const typename S::value_type* str, typename S::size_type pos, test(const S& s, const typename S::value_type* str, typename S::size_type pos,
typename S::size_type n, typename S::size_type x) typename S::size_type n, typename S::size_type x)
{ {
assert(s.find_first_not_of(str, pos, n) == x); assert(s.find_first_not_of(str, pos, n) == x);
▲ Show 20 Lines • Show All 346 Lines • ▼ Show 20 Linesint main()
{ {
typedef std::experimental::string_view S; typedef std::experimental::string_view S;
test0<S>(); test0<S>();
test1<S>(); test1<S>();
test2<S>(); test2<S>();
test3<S>(); test3<S>();
} }
#if _LIBCPP_STD_VER > 11 #if TEST_STD_VER > 11
{ {
typedef std::experimental::basic_string_view<char, constexpr_char_traits<char>> SV; typedef std::experimental::basic_string_view<char, constexpr_char_traits<char>> SV;
constexpr SV sv1; constexpr SV sv1;
constexpr SV sv2 { "abcde", 5 }; constexpr SV sv2 { "abcde", 5 };
static_assert (sv1.find_first_not_of( "", 0, 0) == SV::npos, "" ); static_assert (sv1.find_first_not_of( "", 0, 0) == SV::npos, "" );
static_assert (sv1.find_first_not_of( "irkhs", 0, 5) == SV::npos, "" ); static_assert (sv1.find_first_not_of( "irkhs", 0, 5) == SV::npos, "" );
static_assert (sv2.find_first_not_of( "", 0, 0) == 0, "" ); static_assert (sv2.find_first_not_of( "", 0, 0) == 0, "" );
static_assert (sv2.find_first_not_of( "gfsrt", 0, 5) == 0, "" ); static_assert (sv2.find_first_not_of( "gfsrt", 0, 5) == 0, "" );
static_assert (sv2.find_first_not_of( "lecar", 0, 5) == 1, "" ); static_assert (sv2.find_first_not_of( "lecar", 0, 5) == 1, "" );
} }
#endif #endif
} }

test/std/experimental/string.view/string.view.find/find_first_of_char_size.pass.cpp

//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// The LLVM Compiler Infrastructure // The LLVM Compiler Infrastructure
// //
// This file is dual licensed under the MIT and the University of Illinois Open // This file is dual licensed under the MIT and the University of Illinois Open
// Source Licenses. See LICENSE.TXT for details. // Source Licenses. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// <string> // <string>
// constexpr size_type find_first_of(charT c, size_type pos = 0) const; // constexpr size_type find_first_of(charT c, size_type pos = 0) const;
#include <experimental/string_view> #include <experimental/string_view>
#include <cassert> #include <cassert>
#include "test_macros.h"
#include "constexpr_char_traits.hpp" #include "constexpr_char_traits.hpp"
template <class S> template <class S>
void void
test(const S& s, typename S::value_type c, typename S::size_type pos, test(const S& s, typename S::value_type c, typename S::size_type pos,
typename S::size_type x) typename S::size_type x)
{ {
assert(s.find_first_of(c, pos) == x); assert(s.find_first_of(c, pos) == x);
Show All 36 Linesint main()
test(S("oselktgbcapndfjihrmq"), 'e', 21, S::npos); test(S("oselktgbcapndfjihrmq"), 'e', 21, S::npos);
test(S(""), 'e', S::npos); test(S(""), 'e', S::npos);
test(S("csope"), 'e', 4); test(S("csope"), 'e', 4);
test(S("gfsmthlkon"), 'e', S::npos); test(S("gfsmthlkon"), 'e', S::npos);
test(S("laenfsbridchgotmkqpj"), 'e', 2); test(S("laenfsbridchgotmkqpj"), 'e', 2);
} }
#if _LIBCPP_STD_VER > 11 #if TEST_STD_VER > 11
{ {
typedef std::experimental::basic_string_view<char, constexpr_char_traits<char>> SV; typedef std::experimental::basic_string_view<char, constexpr_char_traits<char>> SV;
constexpr SV sv1; constexpr SV sv1;
constexpr SV sv2 { "abcde", 5 }; constexpr SV sv2 { "abcde", 5 };
static_assert (sv1.find_first_of( 'e', 0 ) == SV::npos, "" ); static_assert (sv1.find_first_of( 'e', 0 ) == SV::npos, "" );
static_assert (sv1.find_first_of( 'e', 1 ) == SV::npos, "" ); static_assert (sv1.find_first_of( 'e', 1 ) == SV::npos, "" );
static_assert (sv2.find_first_of( 'q', 0 ) == SV::npos, "" ); static_assert (sv2.find_first_of( 'q', 0 ) == SV::npos, "" );
static_assert (sv2.find_first_of( 'e', 1 ) == 4, "" ); static_assert (sv2.find_first_of( 'e', 1 ) == 4, "" );
static_assert (sv2.find_first_of( 'e', 5 ) == SV::npos, "" ); static_assert (sv2.find_first_of( 'e', 5 ) == SV::npos, "" );
} }
#endif #endif
} }

test/std/experimental/string.view/string.view.find/find_first_of_pointer_size.pass.cpp

//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// The LLVM Compiler Infrastructure // The LLVM Compiler Infrastructure
// //
// This file is dual licensed under the MIT and the University of Illinois Open // This file is dual licensed under the MIT and the University of Illinois Open
// Source Licenses. See LICENSE.TXT for details. // Source Licenses. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// <string> // <string>
// constexpr size_type find_first_of(const charT* s, size_type pos = 0) const; // constexpr size_type find_first_of(const charT* s, size_type pos = 0) const;
#include <experimental/string_view> #include <experimental/string_view>
#include <cassert> #include <cassert>
#include "test_macros.h"
#include "constexpr_char_traits.hpp" #include "constexpr_char_traits.hpp"
template <class S> template <class S>
void void
test(const S& s, const typename S::value_type* str, typename S::size_type pos, test(const S& s, const typename S::value_type* str, typename S::size_type pos,
typename S::size_type x) typename S::size_type x)
{ {
assert(s.find_first_of(str, pos) == x); assert(s.find_first_of(str, pos) == x);
▲ Show 20 Lines • Show All 119 Lines • ▼ Show 20 Lines
int main() int main()
{ {
{ {
typedef std::experimental::string_view S; typedef std::experimental::string_view S;
test0<S>(); test0<S>();
test1<S>(); test1<S>();
} }
#if _LIBCPP_STD_VER > 11 #if TEST_STD_VER > 11
{ {
typedef std::experimental::basic_string_view<char, constexpr_char_traits<char>> SV; typedef std::experimental::basic_string_view<char, constexpr_char_traits<char>> SV;
constexpr SV sv1; constexpr SV sv1;
constexpr SV sv2 { "abcde", 5 }; constexpr SV sv2 { "abcde", 5 };
static_assert (sv1.find_first_of( "", 0) == SV::npos, "" ); static_assert (sv1.find_first_of( "", 0) == SV::npos, "" );
static_assert (sv1.find_first_of( "irkhs", 0) == SV::npos, "" ); static_assert (sv1.find_first_of( "irkhs", 0) == SV::npos, "" );
static_assert (sv2.find_first_of( "", 0) == SV::npos, "" ); static_assert (sv2.find_first_of( "", 0) == SV::npos, "" );
static_assert (sv2.find_first_of( "gfsrt", 0) == SV::npos, "" ); static_assert (sv2.find_first_of( "gfsrt", 0) == SV::npos, "" );
static_assert (sv2.find_first_of( "lecar", 0) == 0, "" ); static_assert (sv2.find_first_of( "lecar", 0) == 0, "" );
} }
#endif #endif
} }

test/std/experimental/string.view/string.view.find/find_first_of_pointer_size_size.pass.cpp

//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// The LLVM Compiler Infrastructure // The LLVM Compiler Infrastructure
// //
// This file is dual licensed under the MIT and the University of Illinois Open // This file is dual licensed under the MIT and the University of Illinois Open
// Source Licenses. See LICENSE.TXT for details. // Source Licenses. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// <string> // <string>
// constexpr size_type find_first_of(const charT* s, size_type pos, size_type n) const; // constexpr size_type find_first_of(const charT* s, size_type pos, size_type n) const;
#include <experimental/string_view> #include <experimental/string_view>
#include <cassert> #include <cassert>
#include "test_macros.h"
#include "constexpr_char_traits.hpp" #include "constexpr_char_traits.hpp"
template <class S> template <class S>
void void
test(const S& s, const typename S::value_type* str, typename S::size_type pos, test(const S& s, const typename S::value_type* str, typename S::size_type pos,
typename S::size_type n, typename S::size_type x) typename S::size_type n, typename S::size_type x)
{ {
assert(s.find_first_of(str, pos, n) == x); assert(s.find_first_of(str, pos, n) == x);
▲ Show 20 Lines • Show All 346 Lines • ▼ Show 20 Linesint main()
{ {
typedef std::experimental::string_view S; typedef std::experimental::string_view S;
test0<S>(); test0<S>();
test1<S>(); test1<S>();
test2<S>(); test2<S>();
test3<S>(); test3<S>();
} }
#if _LIBCPP_STD_VER > 11 #if TEST_STD_VER > 11
{ {
typedef std::experimental::basic_string_view<char, constexpr_char_traits<char>> SV; typedef std::experimental::basic_string_view<char, constexpr_char_traits<char>> SV;
constexpr SV sv1; constexpr SV sv1;
constexpr SV sv2 { "abcde", 5 }; constexpr SV sv2 { "abcde", 5 };
static_assert (sv1.find_first_of( "", 0, 0) == SV::npos, "" ); static_assert (sv1.find_first_of( "", 0, 0) == SV::npos, "" );
static_assert (sv1.find_first_of( "irkhs", 0, 5) == SV::npos, "" ); static_assert (sv1.find_first_of( "irkhs", 0, 5) == SV::npos, "" );
static_assert (sv2.find_first_of( "", 0, 0) == SV::npos, "" ); static_assert (sv2.find_first_of( "", 0, 0) == SV::npos, "" );
static_assert (sv2.find_first_of( "gfsrt", 0, 5) == SV::npos, "" ); static_assert (sv2.find_first_of( "gfsrt", 0, 5) == SV::npos, "" );
static_assert (sv2.find_first_of( "lecar", 0, 5) == 0, "" ); static_assert (sv2.find_first_of( "lecar", 0, 5) == 0, "" );
} }
#endif #endif
} }

test/std/experimental/string.view/string.view.find/find_last_not_of_char_size.pass.cpp

//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// The LLVM Compiler Infrastructure // The LLVM Compiler Infrastructure
// //
// This file is dual licensed under the MIT and the University of Illinois Open // This file is dual licensed under the MIT and the University of Illinois Open
// Source Licenses. See LICENSE.TXT for details. // Source Licenses. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// <string_view> // <string_view>
// const size_type find_last_not_of(charT c, size_type pos = npos) const; // const size_type find_last_not_of(charT c, size_type pos = npos) const;
#include <experimental/string_view> #include <experimental/string_view>
#include <cassert> #include <cassert>
#include "test_macros.h"
#include "constexpr_char_traits.hpp" #include "constexpr_char_traits.hpp"
template <class S> template <class S>
void void
test(const S& s, typename S::value_type c, typename S::size_type pos, test(const S& s, typename S::value_type c, typename S::size_type pos,
typename S::size_type x) typename S::size_type x)
{ {
assert(s.find_last_not_of(c, pos) == x); assert(s.find_last_not_of(c, pos) == x);
Show All 36 Linesint main()
test(S("oselktgbcapndfjihrmq"), 'i', 21, 19); test(S("oselktgbcapndfjihrmq"), 'i', 21, 19);
test(S(""), 'i', S::npos); test(S(""), 'i', S::npos);
test(S("csope"), 'i', 4); test(S("csope"), 'i', 4);
test(S("gfsmthlkon"), 'i', 9); test(S("gfsmthlkon"), 'i', 9);
test(S("laenfsbridchgotmkqpj"), 'i', 19); test(S("laenfsbridchgotmkqpj"), 'i', 19);
} }
#if _LIBCPP_STD_VER > 11 #if TEST_STD_VER > 11
{ {
typedef std::experimental::basic_string_view<char, constexpr_char_traits<char>> SV; typedef std::experimental::basic_string_view<char, constexpr_char_traits<char>> SV;
constexpr SV sv1; constexpr SV sv1;
constexpr SV sv2 { "abcde", 5 }; constexpr SV sv2 { "abcde", 5 };
static_assert (sv1.find_last_not_of( 'i', 0 ) == SV::npos, "" ); static_assert (sv1.find_last_not_of( 'i', 0 ) == SV::npos, "" );
static_assert (sv1.find_last_not_of( 'i', 1 ) == SV::npos, "" ); static_assert (sv1.find_last_not_of( 'i', 1 ) == SV::npos, "" );
static_assert (sv2.find_last_not_of( 'a', 0 ) == SV::npos, "" ); static_assert (sv2.find_last_not_of( 'a', 0 ) == SV::npos, "" );
static_assert (sv2.find_last_not_of( 'a', 1 ) == 1, "" ); static_assert (sv2.find_last_not_of( 'a', 1 ) == 1, "" );
static_assert (sv2.find_last_not_of( 'e', 5 ) == 3, "" ); static_assert (sv2.find_last_not_of( 'e', 5 ) == 3, "" );
} }
#endif #endif
} }

test/std/experimental/string.view/string.view.find/find_last_not_of_pointer_size.pass.cpp

//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// The LLVM Compiler Infrastructure // The LLVM Compiler Infrastructure
// //
// This file is dual licensed under the MIT and the University of Illinois Open // This file is dual licensed under the MIT and the University of Illinois Open
// Source Licenses. See LICENSE.TXT for details. // Source Licenses. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// <string_view> // <string_view>
// constexpr size_type find_last_not_of(const charT* s, size_type pos = npos) const; // constexpr size_type find_last_not_of(const charT* s, size_type pos = npos) const;
#include <experimental/string_view> #include <experimental/string_view>
#include <cassert> #include <cassert>
#include "test_macros.h"
#include "constexpr_char_traits.hpp" #include "constexpr_char_traits.hpp"
template <class S> template <class S>
void void
test(const S& s, const typename S::value_type* str, typename S::size_type pos, test(const S& s, const typename S::value_type* str, typename S::size_type pos,
typename S::size_type x) typename S::size_type x)
{ {
assert(s.find_last_not_of(str, pos) == x); assert(s.find_last_not_of(str, pos) == x);
▲ Show 20 Lines • Show All 119 Lines • ▼ Show 20 Lines
int main() int main()
{ {
{ {
typedef std::experimental::string_view S; typedef std::experimental::string_view S;
test0<S>(); test0<S>();
test1<S>(); test1<S>();
} }
#if _LIBCPP_STD_VER > 11 #if TEST_STD_VER > 11
{ {
typedef std::experimental::basic_string_view<char, constexpr_char_traits<char>> SV; typedef std::experimental::basic_string_view<char, constexpr_char_traits<char>> SV;
constexpr SV sv1; constexpr SV sv1;
constexpr SV sv2 { "abcde", 5 }; constexpr SV sv2 { "abcde", 5 };
static_assert (sv1.find_last_not_of( "", 0) == SV::npos, "" ); static_assert (sv1.find_last_not_of( "", 0) == SV::npos, "" );
static_assert (sv1.find_last_not_of( "irkhs", 5) == SV::npos, "" ); static_assert (sv1.find_last_not_of( "irkhs", 5) == SV::npos, "" );
static_assert (sv2.find_last_not_of( "", 0) == 0, "" ); static_assert (sv2.find_last_not_of( "", 0) == 0, "" );
static_assert (sv2.find_last_not_of( "gfsrt", 5) == 4, "" ); static_assert (sv2.find_last_not_of( "gfsrt", 5) == 4, "" );
static_assert (sv2.find_last_not_of( "lecar", 5) == 3, "" ); static_assert (sv2.find_last_not_of( "lecar", 5) == 3, "" );
} }
#endif #endif
} }

test/std/experimental/string.view/string.view.find/find_last_not_of_pointer_size_size.pass.cpp

//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// The LLVM Compiler Infrastructure // The LLVM Compiler Infrastructure
// //
// This file is dual licensed under the MIT and the University of Illinois Open // This file is dual licensed under the MIT and the University of Illinois Open
// Source Licenses. See LICENSE.TXT for details. // Source Licenses. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// <string> // <string>
// constexpr size_type find_last_not_of(const charT* s, size_type pos, size_type n) const; // constexpr size_type find_last_not_of(const charT* s, size_type pos, size_type n) const;
#include <experimental/string_view> #include <experimental/string_view>
#include <cassert> #include <cassert>
#include "test_macros.h"
#include "constexpr_char_traits.hpp" #include "constexpr_char_traits.hpp"
template <class S> template <class S>
void void
test(const S& s, const typename S::value_type* str, typename S::size_type pos, test(const S& s, const typename S::value_type* str, typename S::size_type pos,
typename S::size_type n, typename S::size_type x) typename S::size_type n, typename S::size_type x)
{ {
assert(s.find_last_not_of(str, pos, n) == x); assert(s.find_last_not_of(str, pos, n) == x);
▲ Show 20 Lines • Show All 346 Lines • ▼ Show 20 Linesint main()
{ {
typedef std::experimental::string_view S; typedef std::experimental::string_view S;
test0<S>(); test0<S>();
test1<S>(); test1<S>();
test2<S>(); test2<S>();
test3<S>(); test3<S>();
} }
#if _LIBCPP_STD_VER > 11 #if TEST_STD_VER > 11
{ {
typedef std::experimental::basic_string_view<char, constexpr_char_traits<char>> SV; typedef std::experimental::basic_string_view<char, constexpr_char_traits<char>> SV;
constexpr SV sv1; constexpr SV sv1;
constexpr SV sv2 { "abcde", 5 }; constexpr SV sv2 { "abcde", 5 };
static_assert (sv1.find_last_not_of( "", 0, 0) == SV::npos, "" ); static_assert (sv1.find_last_not_of( "", 0, 0) == SV::npos, "" );
static_assert (sv1.find_last_not_of( "irkhs", 0, 5) == SV::npos, "" ); static_assert (sv1.find_last_not_of( "irkhs", 0, 5) == SV::npos, "" );
static_assert (sv2.find_last_not_of( "", 0, 0) == 0, "" ); static_assert (sv2.find_last_not_of( "", 0, 0) == 0, "" );
static_assert (sv2.find_last_not_of( "gfsrt", 5, 0) == 4, "" ); static_assert (sv2.find_last_not_of( "gfsrt", 5, 0) == 4, "" );
static_assert (sv2.find_last_not_of( "lecar", 5, 0) == 4, "" ); static_assert (sv2.find_last_not_of( "lecar", 5, 0) == 4, "" );
} }
#endif #endif
} }

test/std/experimental/string.view/string.view.find/find_last_of_char_size.pass.cpp

//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// The LLVM Compiler Infrastructure // The LLVM Compiler Infrastructure
// //
// This file is dual licensed under the MIT and the University of Illinois Open // This file is dual licensed under the MIT and the University of Illinois Open
// Source Licenses. See LICENSE.TXT for details. // Source Licenses. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// <string_view> // <string_view>
// constexpr size_type find_last_of(charT c, size_type pos = npos) const; // constexpr size_type find_last_of(charT c, size_type pos = npos) const;
#include <experimental/string_view> #include <experimental/string_view>
#include <cassert> #include <cassert>
#include "test_macros.h"
#include "constexpr_char_traits.hpp" #include "constexpr_char_traits.hpp"
template <class S> template <class S>
void void
test(const S& s, typename S::value_type c, typename S::size_type pos, test(const S& s, typename S::value_type c, typename S::size_type pos,
typename S::size_type x) typename S::size_type x)
{ {
assert(s.find_last_of(c, pos) == x); assert(s.find_last_of(c, pos) == x);
Show All 36 Linesint main()
test(S("oselktgbcapndfjihrmq"), 'm', 21, 18); test(S("oselktgbcapndfjihrmq"), 'm', 21, 18);
test(S(""), 'm', S::npos); test(S(""), 'm', S::npos);
test(S("csope"), 'm', S::npos); test(S("csope"), 'm', S::npos);
test(S("gfsmthlkon"), 'm', 3); test(S("gfsmthlkon"), 'm', 3);
test(S("laenfsbridchgotmkqpj"), 'm', 15); test(S("laenfsbridchgotmkqpj"), 'm', 15);
} }
#if _LIBCPP_STD_VER > 11 #if TEST_STD_VER > 11
{ {
typedef std::experimental::basic_string_view<char, constexpr_char_traits<char>> SV; typedef std::experimental::basic_string_view<char, constexpr_char_traits<char>> SV;
constexpr SV sv1; constexpr SV sv1;
constexpr SV sv2 { "abcde", 5 }; constexpr SV sv2 { "abcde", 5 };
static_assert (sv1.find_last_of( 'i', 0 ) == SV::npos, "" ); static_assert (sv1.find_last_of( 'i', 0 ) == SV::npos, "" );
static_assert (sv1.find_last_of( 'i', 1 ) == SV::npos, "" ); static_assert (sv1.find_last_of( 'i', 1 ) == SV::npos, "" );
static_assert (sv2.find_last_of( 'a', 0 ) == 0, "" ); static_assert (sv2.find_last_of( 'a', 0 ) == 0, "" );
static_assert (sv2.find_last_of( 'a', 1 ) == 0, "" ); static_assert (sv2.find_last_of( 'a', 1 ) == 0, "" );
static_assert (sv2.find_last_of( 'e', 5 ) == 4, "" ); static_assert (sv2.find_last_of( 'e', 5 ) == 4, "" );
} }
#endif #endif
} }

test/std/experimental/string.view/string.view.find/find_last_of_pointer_size.pass.cpp

//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// The LLVM Compiler Infrastructure // The LLVM Compiler Infrastructure
// //
// This file is dual licensed under the MIT and the University of Illinois Open // This file is dual licensed under the MIT and the University of Illinois Open
// Source Licenses. See LICENSE.TXT for details. // Source Licenses. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// <string_view> // <string_view>
// constexpr size_type find_last_of(const charT* s, size_type pos = npos) const; // constexpr size_type find_last_of(const charT* s, size_type pos = npos) const;
#include <experimental/string_view> #include <experimental/string_view>
#include <cassert> #include <cassert>
#include "test_macros.h"
#include "constexpr_char_traits.hpp" #include "constexpr_char_traits.hpp"
template <class S> template <class S>
void void
test(const S& s, const typename S::value_type* str, typename S::size_type pos, test(const S& s, const typename S::value_type* str, typename S::size_type pos,
typename S::size_type x) typename S::size_type x)
{ {
assert(s.find_last_of(str, pos) == x); assert(s.find_last_of(str, pos) == x);
▲ Show 20 Lines • Show All 119 Lines • ▼ Show 20 Lines
int main() int main()
{ {
{ {
typedef std::experimental::string_view S; typedef std::experimental::string_view S;
test0<S>(); test0<S>();
test1<S>(); test1<S>();
} }
#if _LIBCPP_STD_VER > 11 #if TEST_STD_VER > 11
{ {
typedef std::experimental::basic_string_view<char, constexpr_char_traits<char>> SV; typedef std::experimental::basic_string_view<char, constexpr_char_traits<char>> SV;
constexpr SV sv1; constexpr SV sv1;
constexpr SV sv2 { "abcde", 5 }; constexpr SV sv2 { "abcde", 5 };
static_assert (sv1.find_last_of( "", 0) == SV::npos, "" ); static_assert (sv1.find_last_of( "", 0) == SV::npos, "" );
static_assert (sv1.find_last_of( "irkhs", 5) == SV::npos, "" ); static_assert (sv1.find_last_of( "irkhs", 5) == SV::npos, "" );
static_assert (sv2.find_last_of( "", 0) == SV::npos, "" ); static_assert (sv2.find_last_of( "", 0) == SV::npos, "" );
static_assert (sv2.find_last_of( "gfsrt", 5) == SV::npos, "" ); static_assert (sv2.find_last_of( "gfsrt", 5) == SV::npos, "" );
static_assert (sv2.find_last_of( "lecar", 5) == 4, "" ); static_assert (sv2.find_last_of( "lecar", 5) == 4, "" );
} }
#endif #endif
} }

test/std/experimental/string.view/string.view.find/find_last_of_pointer_size_size.pass.cpp

//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// The LLVM Compiler Infrastructure // The LLVM Compiler Infrastructure
// //
// This file is dual licensed under the MIT and the University of Illinois Open // This file is dual licensed under the MIT and the University of Illinois Open
// Source Licenses. See LICENSE.TXT for details. // Source Licenses. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// <string_view> // <string_view>
// constexpr size_type find_last_of(const charT* s, size_type pos, size_type n) const; // constexpr size_type find_last_of(const charT* s, size_type pos, size_type n) const;
#include <experimental/string_view> #include <experimental/string_view>
#include <cassert> #include <cassert>
#include "test_macros.h"
#include "constexpr_char_traits.hpp" #include "constexpr_char_traits.hpp"
template <class S> template <class S>
void void
test(const S& s, const typename S::value_type* str, typename S::size_type pos, test(const S& s, const typename S::value_type* str, typename S::size_type pos,
typename S::size_type n, typename S::size_type x) typename S::size_type n, typename S::size_type x)
{ {
assert(s.find_last_of(str, pos, n) == x); assert(s.find_last_of(str, pos, n) == x);
▲ Show 20 Lines • Show All 346 Lines • ▼ Show 20 Linesint main()
{ {
typedef std::experimental::string_view S; typedef std::experimental::string_view S;
test0<S>(); test0<S>();
test1<S>(); test1<S>();
test2<S>(); test2<S>();
test3<S>(); test3<S>();
} }
#if _LIBCPP_STD_VER > 11 #if TEST_STD_VER > 11
{ {
typedef std::experimental::basic_string_view<char, constexpr_char_traits<char>> SV; typedef std::experimental::basic_string_view<char, constexpr_char_traits<char>> SV;
constexpr SV sv1; constexpr SV sv1;
constexpr SV sv2 { "abcde", 5 }; constexpr SV sv2 { "abcde", 5 };
static_assert (sv1.find_last_of( "", 0, 0) == SV::npos, "" ); static_assert (sv1.find_last_of( "", 0, 0) == SV::npos, "" );
static_assert (sv1.find_last_of( "irkhs", 0, 5) == SV::npos, "" ); static_assert (sv1.find_last_of( "irkhs", 0, 5) == SV::npos, "" );
static_assert (sv2.find_last_of( "", 0, 0) == SV::npos, "" ); static_assert (sv2.find_last_of( "", 0, 0) == SV::npos, "" );
static_assert (sv2.find_last_of( "gfsrt", 5, 5) == SV::npos, "" ); static_assert (sv2.find_last_of( "gfsrt", 5, 5) == SV::npos, "" );
static_assert (sv2.find_last_of( "lecar", 5, 5) == 4, "" ); static_assert (sv2.find_last_of( "lecar", 5, 5) == 4, "" );
} }
#endif #endif
} }

test/std/experimental/string.view/string.view.find/find_pointer_size.pass.cpp

//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// The LLVM Compiler Infrastructure // The LLVM Compiler Infrastructure
// //
// This file is dual licensed under the MIT and the University of Illinois Open // This file is dual licensed under the MIT and the University of Illinois Open
// Source Licenses. See LICENSE.TXT for details. // Source Licenses. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// <string> // <string>
// constexpr size_type find(const charT* s, size_type pos = 0) const; // constexpr size_type find(const charT* s, size_type pos = 0) const;
#include <experimental/string_view> #include <experimental/string_view>
#include <cassert> #include <cassert>
#include "test_macros.h"
#include "constexpr_char_traits.hpp" #include "constexpr_char_traits.hpp"
template <class S> template <class S>
void void
test(const S& s, const typename S::value_type* str, typename S::size_type pos, test(const S& s, const typename S::value_type* str, typename S::size_type pos,
typename S::size_type x) typename S::size_type x)
{ {
assert(s.find(str, pos) == x); assert(s.find(str, pos) == x);
▲ Show 20 Lines • Show All 125 Lines • ▼ Show 20 Lines
int main() int main()
{ {
{ {
typedef std::experimental::string_view S; typedef std::experimental::string_view S;
test0<S>(); test0<S>();
test1<S>(); test1<S>();
} }
#if _LIBCPP_STD_VER > 11 #if TEST_STD_VER > 11
{ {
typedef std::experimental::basic_string_view<char, constexpr_char_traits<char>> SV; typedef std::experimental::basic_string_view<char, constexpr_char_traits<char>> SV;
constexpr SV sv1; constexpr SV sv1;
constexpr SV sv2 { "abcde", 5 }; constexpr SV sv2 { "abcde", 5 };
static_assert (sv1.find( "") == 0, "" ); static_assert (sv1.find( "") == 0, "" );
static_assert (sv1.find( "abcde") == SV::npos, "" ); static_assert (sv1.find( "abcde") == SV::npos, "" );
static_assert (sv2.find( "") == 0, "" ); static_assert (sv2.find( "") == 0, "" );
static_assert (sv2.find( "abcde") == 0, "" ); static_assert (sv2.find( "abcde") == 0, "" );
static_assert (sv2.find( "abcde", 1) == SV::npos, "" ); static_assert (sv2.find( "abcde", 1) == SV::npos, "" );
} }
#endif #endif
} }

test/std/experimental/string.view/string.view.find/find_pointer_size_size.pass.cpp

//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// The LLVM Compiler Infrastructure // The LLVM Compiler Infrastructure
// //
// This file is dual licensed under the MIT and the University of Illinois Open // This file is dual licensed under the MIT and the University of Illinois Open
// Source Licenses. See LICENSE.TXT for details. // Source Licenses. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// <string_view> // <string_view>
// constexpr size_type find(const charT* s, size_type pos, size_type n) const; // constexpr size_type find(const charT* s, size_type pos, size_type n) const;
#include <experimental/string_view> #include <experimental/string_view>
#include <cassert> #include <cassert>
#include "test_macros.h"
#include "constexpr_char_traits.hpp" #include "constexpr_char_traits.hpp"
template <class S> template <class S>
void void
test(const S& s, const typename S::value_type* str, typename S::size_type pos, test(const S& s, const typename S::value_type* str, typename S::size_type pos,
typename S::size_type n, typename S::size_type x) typename S::size_type n, typename S::size_type x)
{ {
assert(s.find(str, pos, n) == x); assert(s.find(str, pos, n) == x);
▲ Show 20 Lines • Show All 346 Lines • ▼ Show 20 Linesint main()
{ {
typedef std::experimental::string_view S; typedef std::experimental::string_view S;
test0<S>(); test0<S>();
test1<S>(); test1<S>();
test2<S>(); test2<S>();
test3<S>(); test3<S>();
} }
#if _LIBCPP_STD_VER > 11 #if TEST_STD_VER > 11
{ {
typedef std::experimental::basic_string_view<char, constexpr_char_traits<char>> SV; typedef std::experimental::basic_string_view<char, constexpr_char_traits<char>> SV;
constexpr SV sv1; constexpr SV sv1;
constexpr SV sv2 { "abcde", 5 }; constexpr SV sv2 { "abcde", 5 };
static_assert (sv1.find( "", 0, 0 ) == 0, "" ); static_assert (sv1.find( "", 0, 0 ) == 0, "" );
static_assert (sv1.find( "abcde", 0, 0 ) == 0, "" ); static_assert (sv1.find( "abcde", 0, 0 ) == 0, "" );
static_assert (sv1.find( "abcde", 0, 1 ) == SV::npos, "" ); static_assert (sv1.find( "abcde", 0, 1 ) == SV::npos, "" );
static_assert (sv2.find( "", 0, 0 ) == 0, "" ); static_assert (sv2.find( "", 0, 0 ) == 0, "" );
static_assert (sv2.find( "abcde", 0, 0 ) == 0, "" ); static_assert (sv2.find( "abcde", 0, 0 ) == 0, "" );
static_assert (sv2.find( "abcde", 0, 1 ) == 0, "" ); static_assert (sv2.find( "abcde", 0, 1 ) == 0, "" );
} }
#endif #endif
} }

test/std/experimental/string.view/string.view.find/find_string_view_size.pass.cpp

//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// The LLVM Compiler Infrastructure // The LLVM Compiler Infrastructure
// //
// This file is dual licensed under the MIT and the University of Illinois Open // This file is dual licensed under the MIT and the University of Illinois Open
// Source Licenses. See LICENSE.TXT for details. // Source Licenses. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// <string_view> // <string_view>
// constexpr size_type find(const basic_string_view& str, size_type pos = 0) const; // constexpr size_type find(const basic_string_view& str, size_type pos = 0) const;
#include <experimental/string_view> #include <experimental/string_view>
#include <cassert> #include <cassert>
#include "test_macros.h"
#include "constexpr_char_traits.hpp" #include "constexpr_char_traits.hpp"
template <class S> template <class S>
void void
test(const S& s, const S& str, typename S::size_type pos, typename S::size_type x) test(const S& s, const S& str, typename S::size_type pos, typename S::size_type x)
{ {
assert(s.find(str, pos) == x); assert(s.find(str, pos) == x);
if (x != S::npos) if (x != S::npos)
▲ Show 20 Lines • Show All 118 Lines • ▼ Show 20 Lines
int main() int main()
{ {
{ {
typedef std::experimental::string_view S; typedef std::experimental::string_view S;
test0<S>(); test0<S>();
test1<S>(); test1<S>();
} }
#if _LIBCPP_STD_VER > 11 #if TEST_STD_VER > 11
{ {
typedef std::experimental::basic_string_view<char, constexpr_char_traits<char>> SV; typedef std::experimental::basic_string_view<char, constexpr_char_traits<char>> SV;
constexpr SV sv1; constexpr SV sv1;
constexpr SV sv2 { "abcde", 5 }; constexpr SV sv2 { "abcde", 5 };
static_assert (sv1.find(sv1) == 0, "" ); static_assert (sv1.find(sv1) == 0, "" );
static_assert (sv1.find(sv2) == SV::npos, "" ); static_assert (sv1.find(sv2) == SV::npos, "" );
static_assert (sv2.find(sv1) == 0, "" ); static_assert (sv2.find(sv1) == 0, "" );
static_assert (sv2.find(sv2) == 0, "" ); static_assert (sv2.find(sv2) == 0, "" );
static_assert (sv2.find(sv2, 1 ) == SV::npos, "" ); static_assert (sv2.find(sv2, 1 ) == SV::npos, "" );
} }
#endif #endif
} }

test/std/experimental/string.view/string.view.find/rfind_char_size.pass.cpp

//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// The LLVM Compiler Infrastructure // The LLVM Compiler Infrastructure
// //
// This file is dual licensed under the MIT and the University of Illinois Open // This file is dual licensed under the MIT and the University of Illinois Open
// Source Licenses. See LICENSE.TXT for details. // Source Licenses. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// <string_view> // <string_view>
// constexpr size_type rfind(charT c, size_type pos = npos) const; // constexpr size_type rfind(charT c, size_type pos = npos) const;
#include <experimental/string_view> #include <experimental/string_view>
#include <cassert> #include <cassert>
#include "test_macros.h"
#include "constexpr_char_traits.hpp" #include "constexpr_char_traits.hpp"
template <class S> template <class S>
void void
test(const S& s, typename S::value_type c, typename S::size_type pos, test(const S& s, typename S::value_type c, typename S::size_type pos,
typename S::size_type x) typename S::size_type x)
{ {
assert(s.rfind(c, pos) == x); assert(s.rfind(c, pos) == x);
Show All 36 Linesint main()
test(S("abcdeabcdeabcdeabcde"), 'b', 21, 16); test(S("abcdeabcdeabcdeabcde"), 'b', 21, 16);
test(S(""), 'b', S::npos); test(S(""), 'b', S::npos);
test(S("abcde"), 'b', 1); test(S("abcde"), 'b', 1);
test(S("abcdeabcde"), 'b', 6); test(S("abcdeabcde"), 'b', 6);
test(S("abcdeabcdeabcdeabcde"), 'b', 16); test(S("abcdeabcdeabcdeabcde"), 'b', 16);
} }
#if _LIBCPP_STD_VER > 11 #if TEST_STD_VER > 11
{ {
typedef std::experimental::basic_string_view<char, constexpr_char_traits<char>> SV; typedef std::experimental::basic_string_view<char, constexpr_char_traits<char>> SV;
constexpr SV sv1; constexpr SV sv1;
constexpr SV sv2 { "abcde", 5 }; constexpr SV sv2 { "abcde", 5 };
static_assert (sv1.rfind( 'b', 0 ) == SV::npos, "" ); static_assert (sv1.rfind( 'b', 0 ) == SV::npos, "" );
static_assert (sv1.rfind( 'b', 1 ) == SV::npos, "" ); static_assert (sv1.rfind( 'b', 1 ) == SV::npos, "" );
static_assert (sv2.rfind( 'b', 0 ) == SV::npos, "" ); static_assert (sv2.rfind( 'b', 0 ) == SV::npos, "" );
static_assert (sv2.rfind( 'b', 1 ) == 1, "" ); static_assert (sv2.rfind( 'b', 1 ) == 1, "" );
static_assert (sv2.rfind( 'b', 2 ) == 1, "" ); static_assert (sv2.rfind( 'b', 2 ) == 1, "" );
static_assert (sv2.rfind( 'b', 3 ) == 1, "" ); static_assert (sv2.rfind( 'b', 3 ) == 1, "" );
static_assert (sv2.rfind( 'b', 4 ) == 1, "" ); static_assert (sv2.rfind( 'b', 4 ) == 1, "" );
} }
#endif #endif
} }

test/std/experimental/string.view/string.view.find/rfind_pointer_size.pass.cpp

//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// The LLVM Compiler Infrastructure // The LLVM Compiler Infrastructure
// //
// This file is dual licensed under the MIT and the University of Illinois Open // This file is dual licensed under the MIT and the University of Illinois Open
// Source Licenses. See LICENSE.TXT for details. // Source Licenses. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// <string_view> // <string_view>
// constexpr size_type rfind(const charT* s, size_type pos = npos) const; // constexpr size_type rfind(const charT* s, size_type pos = npos) const;
#include <experimental/string_view> #include <experimental/string_view>
#include <cassert> #include <cassert>
#include "test_macros.h"
#include "constexpr_char_traits.hpp" #include "constexpr_char_traits.hpp"
template <class S> template <class S>
void void
test(const S& s, const typename S::value_type* str, typename S::size_type pos, test(const S& s, const typename S::value_type* str, typename S::size_type pos,
typename S::size_type x) typename S::size_type x)
{ {
assert(s.rfind(str, pos) == x); assert(s.rfind(str, pos) == x);
▲ Show 20 Lines • Show All 126 Lines • ▼ Show 20 Lines
int main() int main()
{ {
{ {
typedef std::experimental::string_view S; typedef std::experimental::string_view S;
test0<S>(); test0<S>();
test1<S>(); test1<S>();
} }
#if _LIBCPP_STD_VER > 11 #if TEST_STD_VER > 11
{ {
typedef std::experimental::basic_string_view<char, constexpr_char_traits<char>> SV; typedef std::experimental::basic_string_view<char, constexpr_char_traits<char>> SV;
constexpr SV sv1; constexpr SV sv1;
constexpr SV sv2 { "abcde", 5 }; constexpr SV sv2 { "abcde", 5 };
static_assert (sv1.rfind( "") == 0, "" ); static_assert (sv1.rfind( "") == 0, "" );
static_assert (sv1.rfind( "abcde") == SV::npos, "" ); static_assert (sv1.rfind( "abcde") == SV::npos, "" );
static_assert (sv2.rfind( "") == 5, "" ); static_assert (sv2.rfind( "") == 5, "" );
static_assert (sv2.rfind( "abcde") == 0, "" ); static_assert (sv2.rfind( "abcde") == 0, "" );
static_assert (sv2.rfind( "abcde", 1) == 0, "" ); static_assert (sv2.rfind( "abcde", 1) == 0, "" );
} }
#endif #endif
} }

test/std/experimental/string.view/string.view.find/rfind_pointer_size_size.pass.cpp

//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// The LLVM Compiler Infrastructure // The LLVM Compiler Infrastructure
// //
// This file is dual licensed under the MIT and the University of Illinois Open // This file is dual licensed under the MIT and the University of Illinois Open
// Source Licenses. See LICENSE.TXT for details. // Source Licenses. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// <string_view> // <string_view>
// constexpr size_type rfind(const charT* s, size_type pos, size_type n) const; // constexpr size_type rfind(const charT* s, size_type pos, size_type n) const;
#include <experimental/string_view> #include <experimental/string_view>
#include <cassert> #include <cassert>
#include "test_macros.h"
#include "constexpr_char_traits.hpp" #include "constexpr_char_traits.hpp"
template <class S> template <class S>
void void
test(const S& s, const typename S::value_type* str, typename S::size_type pos, test(const S& s, const typename S::value_type* str, typename S::size_type pos,
typename S::size_type n, typename S::size_type x) typename S::size_type n, typename S::size_type x)
{ {
assert(s.rfind(str, pos, n) == x); assert(s.rfind(str, pos, n) == x);
▲ Show 20 Lines • Show All 346 Lines • ▼ Show 20 Linesint main()
{ {
typedef std::experimental::string_view S; typedef std::experimental::string_view S;
test0<S>(); test0<S>();
test1<S>(); test1<S>();
test2<S>(); test2<S>();
test3<S>(); test3<S>();
} }
#if _LIBCPP_STD_VER > 11 #if TEST_STD_VER > 11
{ {
typedef std::experimental::basic_string_view<char, constexpr_char_traits<char>> SV; typedef std::experimental::basic_string_view<char, constexpr_char_traits<char>> SV;
constexpr SV sv1; constexpr SV sv1;
constexpr SV sv2 { "abcde", 5 }; constexpr SV sv2 { "abcde", 5 };
static_assert (sv1.rfind( "", 0, 0 ) == 0, "" ); static_assert (sv1.rfind( "", 0, 0 ) == 0, "" );
static_assert (sv1.rfind( "abcde", 0, 0 ) == 0, "" ); static_assert (sv1.rfind( "abcde", 0, 0 ) == 0, "" );
static_assert (sv1.rfind( "abcde", 0, 1 ) == SV::npos, "" ); static_assert (sv1.rfind( "abcde", 0, 1 ) == SV::npos, "" );
static_assert (sv2.rfind( "", 0, 0 ) == 0, "" ); static_assert (sv2.rfind( "", 0, 0 ) == 0, "" );
static_assert (sv2.rfind( "abcde", 0, 0 ) == 0, "" ); static_assert (sv2.rfind( "abcde", 0, 0 ) == 0, "" );
static_assert (sv2.rfind( "abcde", 0, 1 ) == 0, "" ); static_assert (sv2.rfind( "abcde", 0, 1 ) == 0, "" );
} }
#endif #endif
} }

test/std/experimental/string.view/string.view.find/rfind_string_view_size.pass.cpp

//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// The LLVM Compiler Infrastructure // The LLVM Compiler Infrastructure
// //
// This file is dual licensed under the MIT and the University of Illinois Open // This file is dual licensed under the MIT and the University of Illinois Open
// Source Licenses. See LICENSE.TXT for details. // Source Licenses. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// <string_view> // <string_view>
// constexpr size_type rfind(const basic_string& str, size_type pos = npos) const; // constexpr size_type rfind(const basic_string& str, size_type pos = npos) const;
#include <experimental/string_view> #include <experimental/string_view>
#include <cassert> #include <cassert>
#include "test_macros.h"
#include "constexpr_char_traits.hpp" #include "constexpr_char_traits.hpp"
template <class S> template <class S>
void void
test(const S& s, const S& str, typename S::size_type pos, typename S::size_type x) test(const S& s, const S& str, typename S::size_type pos, typename S::size_type x)
{ {
assert(s.rfind(str, pos) == x); assert(s.rfind(str, pos) == x);
if (x != S::npos) if (x != S::npos)
▲ Show 20 Lines • Show All 118 Lines • ▼ Show 20 Lines
int main() int main()
{ {
{ {
typedef std::experimental::string_view S; typedef std::experimental::string_view S;
test0<S>(); test0<S>();
test1<S>(); test1<S>();
} }
#if _LIBCPP_STD_VER > 11 #if TEST_STD_VER > 11
{ {
typedef std::experimental::basic_string_view<char, constexpr_char_traits<char>> SV; typedef std::experimental::basic_string_view<char, constexpr_char_traits<char>> SV;
constexpr SV sv1; constexpr SV sv1;
constexpr SV sv2 { "abcde", 5 }; constexpr SV sv2 { "abcde", 5 };
static_assert (sv1.rfind(sv1) == 0, "" ); static_assert (sv1.rfind(sv1) == 0, "" );
static_assert (sv1.rfind(sv2) == SV::npos, "" ); static_assert (sv1.rfind(sv2) == SV::npos, "" );
static_assert (sv2.rfind(sv1) == 5, "" ); static_assert (sv2.rfind(sv1) == 5, "" );
static_assert (sv2.rfind(sv2) == 0, "" ); static_assert (sv2.rfind(sv2) == 0, "" );
static_assert (sv2.rfind(sv2, 1) == 0, "" ); static_assert (sv2.rfind(sv2, 1) == 0, "" );
} }
#endif #endif
} }

test/std/experimental/string.view/string.view.iterators/begin.pass.cpp

Show First 20 Lines • Show All 52 Lines • ▼ Show 20 Linesint main()
test(wstring_view ()); test(wstring_view ());
test(string_view ( "123")); test(string_view ( "123"));
test(wstring_view (L"123")); test(wstring_view (L"123"));
#if TEST_STD_VER >= 11 #if TEST_STD_VER >= 11
test(u16string_view{u"123"}); test(u16string_view{u"123"});
test(u32string_view{U"123"}); test(u32string_view{U"123"});
#endif #endif
#if _LIBCPP_STD_VER > 11 #if TEST_STD_VER > 11
{ {
constexpr string_view sv { "123", 3 }; constexpr string_view sv { "123", 3 };
constexpr u16string_view u16sv {u"123", 3 }; constexpr u16string_view u16sv {u"123", 3 };
constexpr u32string_view u32sv {U"123", 3 }; constexpr u32string_view u32sv {U"123", 3 };
constexpr wstring_view wsv {L"123", 3 }; constexpr wstring_view wsv {L"123", 3 };
static_assert ( *sv.begin() == sv[0], "" ); static_assert ( *sv.begin() == sv[0], "" );
static_assert ( *u16sv.begin() == u16sv[0], "" ); static_assert ( *u16sv.begin() == u16sv[0], "" );
Show All 10 Lines

test/std/experimental/string.view/string.view.iterators/end.pass.cpp

Show First 20 Lines • Show All 60 Lines • ▼ Show 20 Linesint main()
test(wstring_view ()); test(wstring_view ());
test(string_view ( "123")); test(string_view ( "123"));
test(wstring_view (L"123")); test(wstring_view (L"123"));
#if TEST_STD_VER >= 11 #if TEST_STD_VER >= 11
test(u16string_view{u"123"}); test(u16string_view{u"123"});
test(u32string_view{U"123"}); test(u32string_view{U"123"});
#endif #endif
#if _LIBCPP_STD_VER > 11 #if TEST_STD_VER > 11
{ {
constexpr string_view sv { "123", 3 }; constexpr string_view sv { "123", 3 };
constexpr u16string_view u16sv {u"123", 3 }; constexpr u16string_view u16sv {u"123", 3 };
constexpr u32string_view u32sv {U"123", 3 }; constexpr u32string_view u32sv {U"123", 3 };
constexpr wstring_view wsv {L"123", 3 }; constexpr wstring_view wsv {L"123", 3 };
static_assert ( sv.begin() != sv.end(), "" ); static_assert ( sv.begin() != sv.end(), "" );
static_assert ( u16sv.begin() != u16sv.end(), "" ); static_assert ( u16sv.begin() != u16sv.end(), "" );
Show All 10 Lines

test/std/experimental/string.view/string.view.modifiers/clear.pass.cpp

Show All 26 Linesvoid test ( const CharT *s, size_t len ) {
sv1.clear (); sv1.clear ();
assert ( sv1.data() == nullptr ); assert ( sv1.data() == nullptr );
assert ( sv1.size() == 0 ); assert ( sv1.size() == 0 );
assert ( sv1 == SV()); assert ( sv1 == SV());
} }
} }
#if _LIBCPP_STD_VER > 11 #if TEST_STD_VER > 11
constexpr size_t test_ce ( size_t n ) { constexpr size_t test_ce ( size_t n ) {
typedef std::experimental::basic_string_view<char> SV; typedef std::experimental::basic_string_view<char> SV;
SV sv1{ "ABCDEFGHIJKL", n }; SV sv1{ "ABCDEFGHIJKL", n };
sv1.clear(); sv1.clear();
return sv1.size(); return sv1.size();
} }
#endif #endif
Show All 11 Lines#if TEST_STD_VER >= 11
test ( u"a", 1 ); test ( u"a", 1 );
test ( u"", 0 ); test ( u"", 0 );
test ( U"ABCDE", 5 ); test ( U"ABCDE", 5 );
test ( U"a", 1 ); test ( U"a", 1 );
test ( U"", 0 ); test ( U"", 0 );
#endif #endif
#if _LIBCPP_STD_VER > 11 #if TEST_STD_VER > 11
static_assert ( test_ce (5) == 0, "" ); static_assert ( test_ce (5) == 0, "" );
#endif #endif
} }

test/std/experimental/string.view/string.view.modifiers/remove_prefix.pass.cpp

Show All 33 Linesvoid test ( const CharT *s, size_t len ) {
} }
assert ( sv1.size() == 0 ); assert ( sv1.size() == 0 );
sv1.remove_prefix ( 0 ); sv1.remove_prefix ( 0 );
assert ( sv1.size() == 0 ); assert ( sv1.size() == 0 );
} }
} }
#if _LIBCPP_STD_VER > 11 #if TEST_STD_VER > 11
constexpr size_t test_ce ( size_t n, size_t k ) { constexpr size_t test_ce ( size_t n, size_t k ) {
typedef std::experimental::basic_string_view<char> SV; typedef std::experimental::basic_string_view<char> SV;
SV sv1{ "ABCDEFGHIJKL", n }; SV sv1{ "ABCDEFGHIJKL", n };
sv1.remove_prefix ( k ); sv1.remove_prefix ( k );
return sv1.size(); return sv1.size();
} }
#endif #endif
Show All 11 Lines#if TEST_STD_VER >= 11
test ( u"a", 1 ); test ( u"a", 1 );
test ( u"", 0 ); test ( u"", 0 );
test ( U"ABCDE", 5 ); test ( U"ABCDE", 5 );
test ( U"a", 1 ); test ( U"a", 1 );
test ( U"", 0 ); test ( U"", 0 );
#endif #endif
#if _LIBCPP_STD_VER > 11 #if TEST_STD_VER > 11
{ {
static_assert ( test_ce ( 5, 0 ) == 5, "" ); static_assert ( test_ce ( 5, 0 ) == 5, "" );
static_assert ( test_ce ( 5, 1 ) == 4, "" ); static_assert ( test_ce ( 5, 1 ) == 4, "" );
static_assert ( test_ce ( 5, 5 ) == 0, "" ); static_assert ( test_ce ( 5, 5 ) == 0, "" );
static_assert ( test_ce ( 9, 3 ) == 6, "" ); static_assert ( test_ce ( 9, 3 ) == 6, "" );
} }
#endif #endif
} }

test/std/experimental/string.view/string.view.modifiers/remove_suffix.pass.cpp

Show All 33 Linesvoid test ( const CharT *s, size_t len ) {
assert ( sv1.size() == 0 ); assert ( sv1.size() == 0 );
sv1.remove_suffix ( 0 ); sv1.remove_suffix ( 0 );
assert ( sv1.size() == 0 ); assert ( sv1.size() == 0 );
} }
} }
#if _LIBCPP_STD_VER > 11 #if TEST_STD_VER > 11
constexpr size_t test_ce ( size_t n, size_t k ) { constexpr size_t test_ce ( size_t n, size_t k ) {
typedef std::experimental::basic_string_view<char> SV; typedef std::experimental::basic_string_view<char> SV;
SV sv1{ "ABCDEFGHIJKL", n }; SV sv1{ "ABCDEFGHIJKL", n };
sv1.remove_suffix ( k ); sv1.remove_suffix ( k );
return sv1.size(); return sv1.size();
} }
#endif #endif
Show All 11 Lines#if TEST_STD_VER >= 11
test ( u"a", 1 ); test ( u"a", 1 );
test ( u"", 0 ); test ( u"", 0 );
test ( U"ABCDE", 5 ); test ( U"ABCDE", 5 );
test ( U"a", 1 ); test ( U"a", 1 );
test ( U"", 0 ); test ( U"", 0 );
#endif #endif
#if _LIBCPP_STD_VER > 11 #if TEST_STD_VER > 11
{ {
static_assert ( test_ce ( 5, 0 ) == 5, "" ); static_assert ( test_ce ( 5, 0 ) == 5, "" );
static_assert ( test_ce ( 5, 1 ) == 4, "" ); static_assert ( test_ce ( 5, 1 ) == 4, "" );
static_assert ( test_ce ( 5, 5 ) == 0, "" ); static_assert ( test_ce ( 5, 5 ) == 0, "" );
static_assert ( test_ce ( 9, 3 ) == 6, "" ); static_assert ( test_ce ( 9, 3 ) == 6, "" );
} }
#endif #endif
} }

test/std/experimental/string.view/string.view.modifiers/swap.pass.cpp

Show All 30 Linesvoid test ( const CharT *s, size_t len ) {
sv1.swap ( sv2 ); sv1.swap ( sv2 );
assert ( sv1.size() == 0 ); assert ( sv1.size() == 0 );
assert ( sv2.size() == len ); assert ( sv2.size() == len );
assert ( sv2.data() == s ); assert ( sv2.data() == s );
} }
} }
#if _LIBCPP_STD_VER > 11 #if TEST_STD_VER > 11
constexpr size_t test_ce ( size_t n, size_t k ) { constexpr size_t test_ce ( size_t n, size_t k ) {
typedef std::experimental::basic_string_view<char> SV; typedef std::experimental::basic_string_view<char> SV;
SV sv1{ "ABCDEFGHIJKL", n }; SV sv1{ "ABCDEFGHIJKL", n };
SV sv2 { sv1.data(), k }; SV sv2 { sv1.data(), k };
sv1.swap ( sv2 ); sv1.swap ( sv2 );
return sv1.size(); return sv1.size();
} }
#endif #endif
Show All 13 Lines#if TEST_STD_VER >= 11
test ( u"a", 1 ); test ( u"a", 1 );
test ( u"", 0 ); test ( u"", 0 );
test ( U"ABCDE", 5 ); test ( U"ABCDE", 5 );
test ( U"a", 1 ); test ( U"a", 1 );
test ( U"", 0 ); test ( U"", 0 );
#endif #endif
#if _LIBCPP_STD_VER > 11 #if TEST_STD_VER > 11
{ {
static_assert ( test_ce (2, 3) == 3, "" ); static_assert ( test_ce (2, 3) == 3, "" );
static_assert ( test_ce (5, 3) == 3, "" ); static_assert ( test_ce (5, 3) == 3, "" );
static_assert ( test_ce (0, 1) == 1, "" ); static_assert ( test_ce (0, 1) == 1, "" );
} }
#endif #endif
} }

test/std/experimental/string.view/string.view.nonmem/quoted.pass.cpp

Show All 10 Lines
// quoted // quoted
#include <iomanip> #include <iomanip>
#include <sstream> #include <sstream>
#include <experimental/string_view> #include <experimental/string_view>
#include <cassert> #include <cassert>
#if _LIBCPP_STD_VER > 11 #include "test_macros.h"
#if TEST_STD_VER > 11
// quoted is C++14 only // quoted is C++14 only
bool is_skipws ( const std::istream *is ) { bool is_skipws ( const std::istream *is ) {
return ( is->flags() & std::ios_base::skipws ) != 0; return ( is->flags() & std::ios_base::skipws ) != 0;
} }
bool is_skipws ( const std::wistream *is ) { bool is_skipws ( const std::wistream *is ) {
▲ Show 20 Lines • Show All 185 Lines • Show Last 20 Lines

test/std/experimental/string.view/string.view.ops/compare.pointer.pass.cpp

//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// The LLVM Compiler Infrastructure // The LLVM Compiler Infrastructure
// //
// This file is dual licensed under the MIT and the University of Illinois Open // This file is dual licensed under the MIT and the University of Illinois Open
// Source Licenses. See LICENSE.TXT for details. // Source Licenses. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// <string_view> // <string_view>
// constexpr int compare(const charT* s) const; // constexpr int compare(const charT* s) const;
#include <experimental/string_view> #include <experimental/string_view>
#include <cassert> #include <cassert>
#include "test_macros.h"
#include "constexpr_char_traits.hpp" #include "constexpr_char_traits.hpp"
int sign ( int x ) { return x > 0 ? 1 : ( x < 0 ? -1 : 0 ); } int sign ( int x ) { return x > 0 ? 1 : ( x < 0 ? -1 : 0 ); }
template<typename CharT> template<typename CharT>
void test1 ( std::experimental::basic_string_view<CharT> sv1, const CharT *s, int expected ) { void test1 ( std::experimental::basic_string_view<CharT> sv1, const CharT *s, int expected ) {
assert ( sign( sv1.compare(s)) == sign(expected)); assert ( sign( sv1.compare(s)) == sign(expected));
} }
▲ Show 20 Lines • Show All 82 Lines • ▼ Show 20 Lines#if TEST_STD_VER >= 11
test(u"abcdefghij", u"abcdefghijklmnopqrst", -10); test(u"abcdefghij", u"abcdefghijklmnopqrst", -10);
test(u"abcdefghijklmnopqrst", u"", 20); test(u"abcdefghijklmnopqrst", u"", 20);
test(u"abcdefghijklmnopqrst", u"abcde", 15); test(u"abcdefghijklmnopqrst", u"abcde", 15);
test(u"abcdefghijklmnopqrst", u"abcdefghij", 10); test(u"abcdefghijklmnopqrst", u"abcdefghij", 10);
test(u"abcdefghijklmnopqrst", u"abcdefghijklmnopqrst", 0); test(u"abcdefghijklmnopqrst", u"abcdefghijklmnopqrst", 0);
} }
#endif #endif
#if _LIBCPP_STD_VER > 11 #if TEST_STD_VER > 11
{ {
typedef std::experimental::basic_string_view<char, constexpr_char_traits<char>> SV; typedef std::experimental::basic_string_view<char, constexpr_char_traits<char>> SV;
constexpr SV sv1; constexpr SV sv1;
constexpr SV sv2 { "abcde", 5 }; constexpr SV sv2 { "abcde", 5 };
static_assert ( sv1.compare("") == 0, "" ); static_assert ( sv1.compare("") == 0, "" );
static_assert ( sv1.compare("abcde") == -1, "" ); static_assert ( sv1.compare("abcde") == -1, "" );
static_assert ( sv2.compare("") == 1, "" ); static_assert ( sv2.compare("") == 1, "" );
static_assert ( sv2.compare("abcde") == 0, "" ); static_assert ( sv2.compare("abcde") == 0, "" );
} }
#endif #endif
} }

test/std/experimental/string.view/string.view.ops/compare.sv.pass.cpp

//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// The LLVM Compiler Infrastructure // The LLVM Compiler Infrastructure
// //
// This file is dual licensed under the MIT and the University of Illinois Open // This file is dual licensed under the MIT and the University of Illinois Open
// Source Licenses. See LICENSE.TXT for details. // Source Licenses. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// <string_view> // <string_view>
// constexpr int compare(basic_string_view str) const noexcept; // constexpr int compare(basic_string_view str) const noexcept;
#include <experimental/string_view> #include <experimental/string_view>
#include <cassert> #include <cassert>
#include "test_macros.h"
#include "constexpr_char_traits.hpp" #include "constexpr_char_traits.hpp"
int sign ( int x ) { return x > 0 ? 1 : ( x < 0 ? -1 : 0 ); } int sign ( int x ) { return x > 0 ? 1 : ( x < 0 ? -1 : 0 ); }
template<typename CharT> template<typename CharT>
void test1 ( std::experimental::basic_string_view<CharT> sv1, void test1 ( std::experimental::basic_string_view<CharT> sv1,
std::experimental::basic_string_view<CharT> sv2, int expected ) { std::experimental::basic_string_view<CharT> sv2, int expected ) {
assert ( sign( sv1.compare(sv2)) == sign(expected)); assert ( sign( sv1.compare(sv2)) == sign(expected));
▲ Show 20 Lines • Show All 76 Lines • ▼ Show 20 Lines#if TEST_STD_VER >= 11
test(U"abcdefghij", U"abcdefghij", 0); test(U"abcdefghij", U"abcdefghij", 0);
test(U"abcdefghij", U"abcdefghijklmnopqrst", -10); test(U"abcdefghij", U"abcdefghijklmnopqrst", -10);
test(U"abcdefghijklmnopqrst", U"", 20); test(U"abcdefghijklmnopqrst", U"", 20);
test(U"abcdefghijklmnopqrst", U"abcde", 15); test(U"abcdefghijklmnopqrst", U"abcde", 15);
test(U"abcdefghijklmnopqrst", U"abcdefghij", 10); test(U"abcdefghijklmnopqrst", U"abcdefghij", 10);
test(U"abcdefghijklmnopqrst", U"abcdefghijklmnopqrst", 0); test(U"abcdefghijklmnopqrst", U"abcdefghijklmnopqrst", 0);
#endif #endif
#if _LIBCPP_STD_VER > 11 #if TEST_STD_VER > 11
{ {
typedef std::experimental::basic_string_view<char, constexpr_char_traits<char>> SV; typedef std::experimental::basic_string_view<char, constexpr_char_traits<char>> SV;
constexpr SV sv1 { "abcde", 5 }; constexpr SV sv1 { "abcde", 5 };
constexpr SV sv2 { "abcde", 5 }; constexpr SV sv2 { "abcde", 5 };
constexpr SV sv3 { "edcba0", 6 }; constexpr SV sv3 { "edcba0", 6 };
static_assert ( sv1.compare(sv2) == 0, "" ); static_assert ( sv1.compare(sv2) == 0, "" );
static_assert ( sv2.compare(sv1) == 0, "" ); static_assert ( sv2.compare(sv1) == 0, "" );
static_assert ( sv3.compare(sv2) > 0, "" ); static_assert ( sv3.compare(sv2) > 0, "" );
static_assert ( sv2.compare(sv3) < 0, "" ); static_assert ( sv2.compare(sv3) < 0, "" );
} }
#endif #endif
} }

test/std/input.output/file.streams/c.files/cstdio.pass.cpp

//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// The LLVM Compiler Infrastructure // The LLVM Compiler Infrastructure
// //
// This file is dual licensed under the MIT and the University of Illinois Open // This file is dual licensed under the MIT and the University of Illinois Open
// Source Licenses. See LICENSE.TXT for details. // Source Licenses. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// test <cstdio> // test <cstdio>
#include <cstdio> #include <cstdio>
#include <type_traits> #include <type_traits>
#include "test_macros.h"
#ifndef BUFSIZ #ifndef BUFSIZ
#error BUFSIZ not defined #error BUFSIZ not defined
#endif #endif
#ifndef EOF #ifndef EOF
#error EOF not defined #error EOF not defined
#endif #endif
▲ Show 20 Lines • Show All 112 Lines • ▼ Show 20 Lines#ifndef _LIBCPP_HAS_NO_GLOBAL_FILESYSTEM_NAMESPACE
static_assert((std::is_same<decltype(std::remove("")), int>::value), ""); static_assert((std::is_same<decltype(std::remove("")), int>::value), "");
static_assert((std::is_same<decltype(std::rename("","")), int>::value), ""); static_assert((std::is_same<decltype(std::rename("","")), int>::value), "");
static_assert((std::is_same<decltype(std::tmpfile()), std::FILE*>::value), ""); static_assert((std::is_same<decltype(std::tmpfile()), std::FILE*>::value), "");
static_assert((std::is_same<decltype(std::tmpnam(cp)), char*>::value), ""); static_assert((std::is_same<decltype(std::tmpnam(cp)), char*>::value), "");
#endif #endif
#ifndef _LIBCPP_HAS_NO_STDIN #ifndef _LIBCPP_HAS_NO_STDIN
static_assert((std::is_same<decltype(std::getchar()), int>::value), ""); static_assert((std::is_same<decltype(std::getchar()), int>::value), "");
#if _LIBCPP_STD_VER <= 11 #if TEST_STD_VER <= 11
static_assert((std::is_same<decltype(std::gets(cp)), char*>::value), ""); static_assert((std::is_same<decltype(std::gets(cp)), char*>::value), "");
#endif #endif
static_assert((std::is_same<decltype(std::scanf(" ")), int>::value), ""); static_assert((std::is_same<decltype(std::scanf(" ")), int>::value), "");
static_assert((std::is_same<decltype(std::vscanf("",va)), int>::value), ""); static_assert((std::is_same<decltype(std::vscanf("",va)), int>::value), "");
#endif #endif
#ifndef _LIBCPP_HAS_NO_STDOUT #ifndef _LIBCPP_HAS_NO_STDOUT
static_assert((std::is_same<decltype(std::printf(" ")), int>::value), ""); static_assert((std::is_same<decltype(std::printf(" ")), int>::value), "");
static_assert((std::is_same<decltype(std::putchar(0)), int>::value), ""); static_assert((std::is_same<decltype(std::putchar(0)), int>::value), "");
static_assert((std::is_same<decltype(std::puts("")), int>::value), ""); static_assert((std::is_same<decltype(std::puts("")), int>::value), "");
static_assert((std::is_same<decltype(std::vprintf(" ",va)), int>::value), ""); static_assert((std::is_same<decltype(std::vprintf(" ",va)), int>::value), "");
#endif #endif
} }

test/std/iterators/iterator.range/begin-end.pass.cpp

Show All 26 Lines
#include <initializer_list> #include <initializer_list>
template<typename C> template<typename C>
void test_const_container( const C & c, typename C::value_type val ) { void test_const_container( const C & c, typename C::value_type val ) {
assert ( std::begin(c) == c.begin()); assert ( std::begin(c) == c.begin());
assert (*std::begin(c) == val ); assert (*std::begin(c) == val );
assert ( std::begin(c) != c.end()); assert ( std::begin(c) != c.end());
assert ( std::end(c) == c.end()); assert ( std::end(c) == c.end());
#if _LIBCPP_STD_VER > 11 #if TEST_STD_VER > 11
assert ( std::cbegin(c) == c.cbegin()); assert ( std::cbegin(c) == c.cbegin());
assert ( std::cbegin(c) != c.cend()); assert ( std::cbegin(c) != c.cend());
assert ( std::cend(c) == c.cend()); assert ( std::cend(c) == c.cend());
assert ( std::rbegin(c) == c.rbegin()); assert ( std::rbegin(c) == c.rbegin());
assert ( std::rbegin(c) != c.rend()); assert ( std::rbegin(c) != c.rend());
assert ( std::rend(c) == c.rend()); assert ( std::rend(c) == c.rend());
assert ( std::crbegin(c) == c.crbegin()); assert ( std::crbegin(c) == c.crbegin());
assert ( std::crbegin(c) != c.crend()); assert ( std::crbegin(c) != c.crend());
assert ( std::crend(c) == c.crend()); assert ( std::crend(c) == c.crend());
#endif #endif
} }
template<typename T> template<typename T>
void test_const_container( const std::initializer_list<T> & c, T val ) { void test_const_container( const std::initializer_list<T> & c, T val ) {
assert ( std::begin(c) == c.begin()); assert ( std::begin(c) == c.begin());
assert (*std::begin(c) == val ); assert (*std::begin(c) == val );
assert ( std::begin(c) != c.end()); assert ( std::begin(c) != c.end());
assert ( std::end(c) == c.end()); assert ( std::end(c) == c.end());
#if _LIBCPP_STD_VER > 11 #if TEST_STD_VER > 11
// initializer_list doesn't have cbegin/cend/rbegin/rend // initializer_list doesn't have cbegin/cend/rbegin/rend
// but std::cbegin(),etc work (b/c they're general fn templates) // but std::cbegin(),etc work (b/c they're general fn templates)
// assert ( std::cbegin(c) == c.cbegin()); // assert ( std::cbegin(c) == c.cbegin());
// assert ( std::cbegin(c) != c.cend()); // assert ( std::cbegin(c) != c.cend());
// assert ( std::cend(c) == c.cend()); // assert ( std::cend(c) == c.cend());
// assert ( std::rbegin(c) == c.rbegin()); // assert ( std::rbegin(c) == c.rbegin());
// assert ( std::rbegin(c) != c.rend()); // assert ( std::rbegin(c) != c.rend());
// assert ( std::rend(c) == c.rend()); // assert ( std::rend(c) == c.rend());
// assert ( std::crbegin(c) == c.crbegin()); // assert ( std::crbegin(c) == c.crbegin());
// assert ( std::crbegin(c) != c.crend()); // assert ( std::crbegin(c) != c.crend());
// assert ( std::crend(c) == c.crend()); // assert ( std::crend(c) == c.crend());
#endif #endif
} }
template<typename C> template<typename C>
void test_container( C & c, typename C::value_type val ) { void test_container( C & c, typename C::value_type val ) {
assert ( std::begin(c) == c.begin()); assert ( std::begin(c) == c.begin());
assert (*std::begin(c) == val ); assert (*std::begin(c) == val );
assert ( std::begin(c) != c.end()); assert ( std::begin(c) != c.end());
assert ( std::end(c) == c.end()); assert ( std::end(c) == c.end());
#if _LIBCPP_STD_VER > 11 #if TEST_STD_VER > 11
assert ( std::cbegin(c) == c.cbegin()); assert ( std::cbegin(c) == c.cbegin());
assert ( std::cbegin(c) != c.cend()); assert ( std::cbegin(c) != c.cend());
assert ( std::cend(c) == c.cend()); assert ( std::cend(c) == c.cend());
assert ( std::rbegin(c) == c.rbegin()); assert ( std::rbegin(c) == c.rbegin());
assert ( std::rbegin(c) != c.rend()); assert ( std::rbegin(c) != c.rend());
assert ( std::rend(c) == c.rend()); assert ( std::rend(c) == c.rend());
assert ( std::crbegin(c) == c.crbegin()); assert ( std::crbegin(c) == c.crbegin());
assert ( std::crbegin(c) != c.crend()); assert ( std::crbegin(c) != c.crend());
assert ( std::crend(c) == c.crend()); assert ( std::crend(c) == c.crend());
#endif #endif
} }
template<typename T> template<typename T>
void test_container( std::initializer_list<T> & c, T val ) { void test_container( std::initializer_list<T> & c, T val ) {
assert ( std::begin(c) == c.begin()); assert ( std::begin(c) == c.begin());
assert (*std::begin(c) == val ); assert (*std::begin(c) == val );
assert ( std::begin(c) != c.end()); assert ( std::begin(c) != c.end());
assert ( std::end(c) == c.end()); assert ( std::end(c) == c.end());
#if _LIBCPP_STD_VER > 11 #if TEST_STD_VER > 11
// initializer_list doesn't have cbegin/cend/rbegin/rend // initializer_list doesn't have cbegin/cend/rbegin/rend
// assert ( std::cbegin(c) == c.cbegin()); // assert ( std::cbegin(c) == c.cbegin());
// assert ( std::cbegin(c) != c.cend()); // assert ( std::cbegin(c) != c.cend());
// assert ( std::cend(c) == c.cend()); // assert ( std::cend(c) == c.cend());
// assert ( std::rbegin(c) == c.rbegin()); // assert ( std::rbegin(c) == c.rbegin());
// assert ( std::rbegin(c) != c.rend()); // assert ( std::rbegin(c) != c.rend());
// assert ( std::rend(c) == c.rend()); // assert ( std::rend(c) == c.rend());
// assert ( std::crbegin(c) == c.crbegin()); // assert ( std::crbegin(c) == c.crbegin());
// assert ( std::crbegin(c) != c.crend()); // assert ( std::crbegin(c) != c.crend());
// assert ( std::crend(c) == c.crend()); // assert ( std::crend(c) == c.crend());
#endif #endif
} }
template<typename T, size_t Sz> template<typename T, size_t Sz>
void test_const_array( const T (&array)[Sz] ) { void test_const_array( const T (&array)[Sz] ) {
assert ( std::begin(array) == array ); assert ( std::begin(array) == array );
assert (*std::begin(array) == array[0] ); assert (*std::begin(array) == array[0] );
assert ( std::begin(array) != std::end(array)); assert ( std::begin(array) != std::end(array));
assert ( std::end(array) == array + Sz); assert ( std::end(array) == array + Sz);
#if _LIBCPP_STD_VER > 11 #if TEST_STD_VER > 11
assert ( std::cbegin(array) == array ); assert ( std::cbegin(array) == array );
assert (*std::cbegin(array) == array[0] ); assert (*std::cbegin(array) == array[0] );
assert ( std::cbegin(array) != std::cend(array)); assert ( std::cbegin(array) != std::cend(array));
assert ( std::cend(array) == array + Sz); assert ( std::cend(array) == array + Sz);
#endif #endif
} }
int main(){ int main(){
Show All 9 Linesint main(){
test_const_container ( v, 1 ); test_const_container ( v, 1 );
test_const_container ( l, 2 ); test_const_container ( l, 2 );
test_const_container ( a, 3 ); test_const_container ( a, 3 );
test_const_container ( il, 4 ); test_const_container ( il, 4 );
static constexpr int arrA [] { 1, 2, 3 }; static constexpr int arrA [] { 1, 2, 3 };
test_const_array ( arrA ); test_const_array ( arrA );
#if _LIBCPP_STD_VER > 11 #if TEST_STD_VER > 11
constexpr const int *b = std::cbegin(arrA); constexpr const int *b = std::cbegin(arrA);
constexpr const int *e = std::cend(arrA); constexpr const int *e = std::cend(arrA);
static_assert(e - b == 3, ""); static_assert(e - b == 3, "");
#endif #endif
} }

test/std/language.support/support.initlist/support.initlist.access/access.pass.cpp

Show All 10 Lines
// const E* begin() const; // const E* begin() const;
// const E* end() const; // const E* end() const;
// size_t size() const; // size_t size() const;
#include <initializer_list> #include <initializer_list>
#include <cassert> #include <cassert>
#include "test_macros.h"
#ifndef _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS #ifndef _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS
struct A struct A
{ {
A(std::initializer_list<int> il) A(std::initializer_list<int> il)
{ {
const int* b = il.begin(); const int* b = il.begin();
const int* e = il.end(); const int* e = il.end();
assert(il.size() == 3); assert(il.size() == 3);
assert(e - b == il.size()); assert(e - b == il.size());
assert(*b++ == 3); assert(*b++ == 3);
assert(*b++ == 2); assert(*b++ == 2);
assert(*b++ == 1); assert(*b++ == 1);
} }
}; };
#if _LIBCPP_STD_VER > 11 #if TEST_STD_VER > 11
struct B struct B
{ {
constexpr B(std::initializer_list<int> il) constexpr B(std::initializer_list<int> il)
{ {
const int* b = il.begin(); const int* b = il.begin();
const int* e = il.end(); const int* e = il.end();
assert(il.size() == 3); assert(il.size() == 3);
assert(e - b == il.size()); assert(e - b == il.size());
assert(*b++ == 3); assert(*b++ == 3);
assert(*b++ == 2); assert(*b++ == 2);
assert(*b++ == 1); assert(*b++ == 1);
} }
}; };
#endif // _LIBCPP_STD_VER > 11 #endif // TEST_STD_VER > 11
#endif // _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS #endif // _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS
int main() int main()
{ {
#ifndef _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS #ifndef _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS
A test1 = {3, 2, 1}; A test1 = {3, 2, 1};
#endif #endif
#if _LIBCPP_STD_VER > 11 #if TEST_STD_VER > 11
constexpr B test2 = {3, 2, 1}; constexpr B test2 = {3, 2, 1};
#endif // _LIBCPP_STD_VER > 11 #endif // TEST_STD_VER > 11
} }

test/std/language.support/support.initlist/support.initlist.cons/default.pass.cpp

//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// The LLVM Compiler Infrastructure // The LLVM Compiler Infrastructure
// //
// This file is dual licensed under the MIT and the University of Illinois Open // This file is dual licensed under the MIT and the University of Illinois Open
// Source Licenses. See LICENSE.TXT for details. // Source Licenses. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// template<class E> class initializer_list; // template<class E> class initializer_list;
// initializer_list(); // initializer_list();
#include <initializer_list> #include <initializer_list>
#include <cassert> #include <cassert>
#include "test_macros.h"
struct A {}; struct A {};
int main() int main()
{ {
#ifndef _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS #ifndef _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS
std::initializer_list<A> il; std::initializer_list<A> il;
assert(il.size() == 0); assert(il.size() == 0);
#endif // _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS #endif // _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS
#if _LIBCPP_STD_VER > 11 #if TEST_STD_VER > 11
constexpr std::initializer_list<A> il2; constexpr std::initializer_list<A> il2;
static_assert(il2.size() == 0, ""); static_assert(il2.size() == 0, "");
#endif // _LIBCPP_STD_VER > 11 #endif // TEST_STD_VER > 11
} }

test/std/language.support/support.initlist/support.initlist.range/begin_end.pass.cpp

//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// The LLVM Compiler Infrastructure // The LLVM Compiler Infrastructure
// //
// This file is dual licensed under the MIT and the University of Illinois Open // This file is dual licensed under the MIT and the University of Illinois Open
// Source Licenses. See LICENSE.TXT for details. // Source Licenses. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// <initializer_list> // <initializer_list>
// template<class E> const E* begin(initializer_list<E> il); // template<class E> const E* begin(initializer_list<E> il);
#include <initializer_list> #include <initializer_list>
#include <cassert> #include <cassert>
#include "test_macros.h"
#ifndef _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS #ifndef _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS
struct A struct A
{ {
A(std::initializer_list<int> il) A(std::initializer_list<int> il)
{ {
const int* b = begin(il); const int* b = begin(il);
const int* e = end(il); const int* e = end(il);
assert(il.size() == 3); assert(il.size() == 3);
assert(e - b == il.size()); assert(e - b == il.size());
assert(*b++ == 3); assert(*b++ == 3);
assert(*b++ == 2); assert(*b++ == 2);
assert(*b++ == 1); assert(*b++ == 1);
} }
}; };
#if _LIBCPP_STD_VER > 11 #if TEST_STD_VER > 11
struct B struct B
{ {
constexpr B(std::initializer_list<int> il) constexpr B(std::initializer_list<int> il)
{ {
const int* b = begin(il); const int* b = begin(il);
const int* e = end(il); const int* e = end(il);
assert(il.size() == 3); assert(il.size() == 3);
assert(e - b == il.size()); assert(e - b == il.size());
assert(*b++ == 3); assert(*b++ == 3);
assert(*b++ == 2); assert(*b++ == 2);
assert(*b++ == 1); assert(*b++ == 1);
} }
}; };
#endif // _LIBCPP_STD_VER > 11 #endif // TEST_STD_VER > 11
#endif // _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS #endif // _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS
int main() int main()
{ {
#ifndef _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS #ifndef _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS
A test1 = {3, 2, 1}; A test1 = {3, 2, 1};
#endif #endif
#if _LIBCPP_STD_VER > 11 #if TEST_STD_VER > 11
constexpr B test2 = {3, 2, 1}; constexpr B test2 = {3, 2, 1};
#endif // _LIBCPP_STD_VER > 11 #endif // TEST_STD_VER > 11
} }

test/std/localization/locales/locale.convenience/conversions/conversions.buffer/ctor.pass.cpp

Show All 13 Lines
// wbuffer_convert(streambuf *bytebuf = 0, Codecvt *pcvt = new Codecvt, // wbuffer_convert(streambuf *bytebuf = 0, Codecvt *pcvt = new Codecvt,
// state_type state = state_type()); // state_type state = state_type());
#include <locale> #include <locale>
#include <codecvt> #include <codecvt>
#include <sstream> #include <sstream>
#include <cassert> #include <cassert>
#include "test_macros.h"
#include "count_new.hpp" #include "count_new.hpp"
int main() int main()
{ {
typedef std::wbuffer_convert<std::codecvt_utf8<wchar_t> > B; typedef std::wbuffer_convert<std::codecvt_utf8<wchar_t> > B;
#if _LIBCPP_STD_VER > 11 #if TEST_STD_VER > 11
static_assert(!std::is_convertible<std::streambuf*, B>::value, ""); static_assert(!std::is_convertible<std::streambuf*, B>::value, "");
static_assert( std::is_constructible<B, std::streambuf*>::value, ""); static_assert( std::is_constructible<B, std::streambuf*>::value, "");
#endif #endif
{ {
B b; B b;
assert(b.rdbuf() == nullptr); assert(b.rdbuf() == nullptr);
assert(globalMemCounter.checkOutstandingNewNotEq(0)); assert(globalMemCounter.checkOutstandingNewNotEq(0));
} }
Show All 23 Lines

test/std/localization/locales/locale.convenience/conversions/conversions.string/ctor_codecvt.pass.cpp

Show All 11 Lines
// wstring_convert<Codecvt, Elem, Wide_alloc, Byte_alloc> // wstring_convert<Codecvt, Elem, Wide_alloc, Byte_alloc>
// wstring_convert(Codecvt* pcvt = new Codecvt); // wstring_convert(Codecvt* pcvt = new Codecvt);
#include <locale> #include <locale>
#include <codecvt> #include <codecvt>
#include <cassert> #include <cassert>
#include "test_macros.h"
int main() int main()
{ {
{ {
typedef std::codecvt_utf8<wchar_t> Codecvt; typedef std::codecvt_utf8<wchar_t> Codecvt;
typedef std::wstring_convert<Codecvt> Myconv; typedef std::wstring_convert<Codecvt> Myconv;
Myconv myconv; Myconv myconv;
assert(myconv.converted() == 0); assert(myconv.converted() == 0);
} }
{ {
typedef std::codecvt_utf8<wchar_t> Codecvt; typedef std::codecvt_utf8<wchar_t> Codecvt;
typedef std::wstring_convert<Codecvt> Myconv; typedef std::wstring_convert<Codecvt> Myconv;
Myconv myconv(new Codecvt); Myconv myconv(new Codecvt);
assert(myconv.converted() == 0); assert(myconv.converted() == 0);
#if _LIBCPP_STD_VER > 11 #if TEST_STD_VER > 11
static_assert(!std::is_convertible<Codecvt*, Myconv>::value, ""); static_assert(!std::is_convertible<Codecvt*, Myconv>::value, "");
static_assert( std::is_constructible<Myconv, Codecvt*>::value, ""); static_assert( std::is_constructible<Myconv, Codecvt*>::value, "");
#endif #endif
} }
} }

test/std/localization/locales/locale.convenience/conversions/conversions.string/ctor_err_string.pass.cpp

Show All 13 Lines
// wstring_convert(const byte_string& byte_err, // wstring_convert(const byte_string& byte_err,
// const wide_string& wide_err = wide_string()); // const wide_string& wide_err = wide_string());
#include <locale> #include <locale>
#include <codecvt> #include <codecvt>
#include <cassert> #include <cassert>
#include "test_macros.h"
int main() int main()
{ {
typedef std::codecvt_utf8<wchar_t> Codecvt; typedef std::codecvt_utf8<wchar_t> Codecvt;
typedef std::wstring_convert<Codecvt> Myconv; typedef std::wstring_convert<Codecvt> Myconv;
#if _LIBCPP_STD_VER > 11 #if TEST_STD_VER > 11
static_assert(!std::is_convertible<std::string, Myconv>::value, ""); static_assert(!std::is_convertible<std::string, Myconv>::value, "");
static_assert( std::is_constructible<Myconv, std::string>::value, ""); static_assert( std::is_constructible<Myconv, std::string>::value, "");
#endif #endif
{ {
Myconv myconv; Myconv myconv;
try try
{ {
myconv.to_bytes(L"\xDA83"); myconv.to_bytes(L"\xDA83");
Show All 35 Lines

test/std/numerics/complex.number/cmplx.over/imag.pass.cpp

Show All 11 Lines
// template<Arithmetic T> // template<Arithmetic T>
// T // T
// imag(const T& x); // imag(const T& x);
#include <complex> #include <complex>
#include <type_traits> #include <type_traits>
#include <cassert> #include <cassert>
#include "test_macros.h"
#include "../cases.h" #include "../cases.h"
template <class T, int x> template <class T, int x>
void void
test(typename std::enable_if<std::is_integral<T>::value>::type* = 0) test(typename std::enable_if<std::is_integral<T>::value>::type* = 0)
{ {
static_assert((std::is_same<decltype(std::imag(T(x))), double>::value), ""); static_assert((std::is_same<decltype(std::imag(T(x))), double>::value), "");
assert(std::imag(x) == 0); assert(std::imag(x) == 0);
#if _LIBCPP_STD_VER > 11 #if TEST_STD_VER > 11
constexpr T val {x}; constexpr T val {x};
static_assert(std::imag(val) == 0, ""); static_assert(std::imag(val) == 0, "");
constexpr std::complex<T> t{val, val}; constexpr std::complex<T> t{val, val};
static_assert(t.imag() == x, "" ); static_assert(t.imag() == x, "" );
#endif #endif
} }
template <class T, int x> template <class T, int x>
void void
test(typename std::enable_if<!std::is_integral<T>::value>::type* = 0) test(typename std::enable_if<!std::is_integral<T>::value>::type* = 0)
{ {
static_assert((std::is_same<decltype(std::imag(T(x))), T>::value), ""); static_assert((std::is_same<decltype(std::imag(T(x))), T>::value), "");
assert(std::imag(x) == 0); assert(std::imag(x) == 0);
#if _LIBCPP_STD_VER > 11 #if TEST_STD_VER > 11
constexpr T val {x}; constexpr T val {x};
static_assert(std::imag(val) == 0, ""); static_assert(std::imag(val) == 0, "");
constexpr std::complex<T> t{val, val}; constexpr std::complex<T> t{val, val};
static_assert(t.imag() == x, "" ); static_assert(t.imag() == x, "" );
#endif #endif
} }
template <class T> template <class T>
Show All 17 Lines

test/std/numerics/complex.number/cmplx.over/real.pass.cpp

Show All 11 Lines
// template<Arithmetic T> // template<Arithmetic T>
// T // T
// real(const T& x); // real(const T& x);
#include <complex> #include <complex>
#include <type_traits> #include <type_traits>
#include <cassert> #include <cassert>
#include "test_macros.h"
#include "../cases.h" #include "../cases.h"
template <class T, int x> template <class T, int x>
void void
test(typename std::enable_if<std::is_integral<T>::value>::type* = 0) test(typename std::enable_if<std::is_integral<T>::value>::type* = 0)
{ {
static_assert((std::is_same<decltype(std::real(T(x))), double>::value), ""); static_assert((std::is_same<decltype(std::real(T(x))), double>::value), "");
assert(std::real(x) == x); assert(std::real(x) == x);
#if _LIBCPP_STD_VER > 11 #if TEST_STD_VER > 11
constexpr T val {x}; constexpr T val {x};
static_assert(std::real(val) == val, ""); static_assert(std::real(val) == val, "");
constexpr std::complex<T> t{val, val}; constexpr std::complex<T> t{val, val};
static_assert(t.real() == x, "" ); static_assert(t.real() == x, "" );
#endif #endif
} }
template <class T, int x> template <class T, int x>
void void
test(typename std::enable_if<!std::is_integral<T>::value>::type* = 0) test(typename std::enable_if<!std::is_integral<T>::value>::type* = 0)
{ {
static_assert((std::is_same<decltype(std::real(T(x))), T>::value), ""); static_assert((std::is_same<decltype(std::real(T(x))), T>::value), "");
assert(std::real(x) == x); assert(std::real(x) == x);
#if _LIBCPP_STD_VER > 11 #if TEST_STD_VER > 11
constexpr T val {x}; constexpr T val {x};
static_assert(std::real(val) == val, ""); static_assert(std::real(val) == val, "");
constexpr std::complex<T> t{val, val}; constexpr std::complex<T> t{val, val};
static_assert(t.real() == x, "" ); static_assert(t.real() == x, "" );
#endif #endif
} }
template <class T> template <class T>
Show All 17 Lines

test/std/numerics/complex.number/complex.members/real_imag.pass.cpp

Show All 9 Lines
// <complex> // <complex>
// void real(T val); // void real(T val);
// void imag(T val); // void imag(T val);
#include <complex> #include <complex>
#include <cassert> #include <cassert>
#include "test_macros.h"
template <class T> template <class T>
void void
test_constexpr() test_constexpr()
{ {
#if _LIBCPP_STD_VER > 11 #if TEST_STD_VER > 11
constexpr std::complex<T> c1; constexpr std::complex<T> c1;
static_assert(c1.real() == 0, ""); static_assert(c1.real() == 0, "");
static_assert(c1.imag() == 0, ""); static_assert(c1.imag() == 0, "");
constexpr std::complex<T> c2(3); constexpr std::complex<T> c2(3);
static_assert(c2.real() == 3, ""); static_assert(c2.real() == 3, "");
static_assert(c2.imag() == 0, ""); static_assert(c2.imag() == 0, "");
constexpr std::complex<T> c3(3, 4); constexpr std::complex<T> c3(3, 4);
static_assert(c3.real() == 3, ""); static_assert(c3.real() == 3, "");
Show All 34 Lines

test/std/numerics/complex.number/complex.ops/complex_equals_complex.pass.cpp

Show All 10 Lines
// template<class T> // template<class T>
// bool // bool
// operator==(const complex<T>& lhs, const complex<T>& rhs); // operator==(const complex<T>& lhs, const complex<T>& rhs);
#include <complex> #include <complex>
#include <cassert> #include <cassert>
#include "test_macros.h"
template <class T> template <class T>
void void
test_constexpr() test_constexpr()
{ {
#if _LIBCPP_STD_VER > 11 #if TEST_STD_VER > 11
{ {
constexpr std::complex<T> lhs(1.5, 2.5); constexpr std::complex<T> lhs(1.5, 2.5);
constexpr std::complex<T> rhs(1.5, -2.5); constexpr std::complex<T> rhs(1.5, -2.5);
static_assert( !(lhs == rhs), ""); static_assert( !(lhs == rhs), "");
} }
{ {
constexpr std::complex<T> lhs(1.5, 2.5); constexpr std::complex<T> lhs(1.5, 2.5);
constexpr std::complex<T> rhs(1.5, 2.5); constexpr std::complex<T> rhs(1.5, 2.5);
Show All 29 Lines

test/std/numerics/complex.number/complex.ops/complex_equals_scalar.pass.cpp

Show All 10 Lines
// template<class T> // template<class T>
// bool // bool
// operator==(const complex<T>& lhs, const T& rhs); // operator==(const complex<T>& lhs, const T& rhs);
#include <complex> #include <complex>
#include <cassert> #include <cassert>
#include "test_macros.h"
template <class T> template <class T>
void void
test_constexpr() test_constexpr()
{ {
#if _LIBCPP_STD_VER > 11 #if TEST_STD_VER > 11
{ {
constexpr std::complex<T> lhs(1.5, 2.5); constexpr std::complex<T> lhs(1.5, 2.5);
constexpr T rhs(-2.5); constexpr T rhs(-2.5);
static_assert(!(lhs == rhs), ""); static_assert(!(lhs == rhs), "");
} }
{ {
constexpr std::complex<T> lhs(1.5, 0); constexpr std::complex<T> lhs(1.5, 0);
constexpr T rhs(-2.5); constexpr T rhs(-2.5);
▲ Show 20 Lines • Show All 50 Lines • Show Last 20 Lines

test/std/numerics/complex.number/complex.ops/complex_not_equals_complex.pass.cpp

Show All 10 Lines
// template<class T> // template<class T>
// bool // bool
// operator!=(const complex<T>& lhs, const complex<T>& rhs); // operator!=(const complex<T>& lhs, const complex<T>& rhs);
#include <complex> #include <complex>
#include <cassert> #include <cassert>
#include "test_macros.h"
template <class T> template <class T>
void void
test_constexpr() test_constexpr()
{ {
#if _LIBCPP_STD_VER > 11 #if TEST_STD_VER > 11
{ {
constexpr std::complex<T> lhs(1.5, 2.5); constexpr std::complex<T> lhs(1.5, 2.5);
constexpr std::complex<T> rhs(1.5, -2.5); constexpr std::complex<T> rhs(1.5, -2.5);
static_assert(lhs != rhs, ""); static_assert(lhs != rhs, "");
} }
{ {
constexpr std::complex<T> lhs(1.5, 2.5); constexpr std::complex<T> lhs(1.5, 2.5);
constexpr std::complex<T> rhs(1.5, 2.5); constexpr std::complex<T> rhs(1.5, 2.5);
Show All 31 Lines

test/std/numerics/complex.number/complex.ops/complex_not_equals_scalar.pass.cpp

Show All 10 Lines
// template<class T> // template<class T>
// bool // bool
// operator!=(const complex<T>& lhs, const T& rhs); // operator!=(const complex<T>& lhs, const T& rhs);
#include <complex> #include <complex>
#include <cassert> #include <cassert>
#include "test_macros.h"
template <class T> template <class T>
void void
test_constexpr() test_constexpr()
{ {
#if _LIBCPP_STD_VER > 11 #if TEST_STD_VER > 11
{ {
constexpr std::complex<T> lhs(1.5, 2.5); constexpr std::complex<T> lhs(1.5, 2.5);
constexpr T rhs(-2.5); constexpr T rhs(-2.5);
static_assert(lhs != rhs, ""); static_assert(lhs != rhs, "");
} }
{ {
constexpr std::complex<T> lhs(1.5, 0); constexpr std::complex<T> lhs(1.5, 0);
constexpr T rhs(-2.5); constexpr T rhs(-2.5);
▲ Show 20 Lines • Show All 50 Lines • Show Last 20 Lines

test/std/numerics/complex.number/complex.ops/scalar_equals_complex.pass.cpp

Show All 10 Lines
// template<class T> // template<class T>
// bool // bool
// operator==(const T& lhs, const complex<T>& rhs); // operator==(const T& lhs, const complex<T>& rhs);
#include <complex> #include <complex>
#include <cassert> #include <cassert>
#include "test_macros.h"
template <class T> template <class T>
void void
test_constexpr() test_constexpr()
{ {
#if _LIBCPP_STD_VER > 11 #if TEST_STD_VER > 11
{ {
constexpr T lhs(-2.5); constexpr T lhs(-2.5);
constexpr std::complex<T> rhs(1.5, 2.5); constexpr std::complex<T> rhs(1.5, 2.5);
static_assert(!(lhs == rhs), ""); static_assert(!(lhs == rhs), "");
} }
{ {
constexpr T lhs(-2.5); constexpr T lhs(-2.5);
constexpr std::complex<T> rhs(1.5, 0); constexpr std::complex<T> rhs(1.5, 0);
▲ Show 20 Lines • Show All 50 Lines • Show Last 20 Lines

test/std/numerics/complex.number/complex.ops/scalar_not_equals_complex.pass.cpp

Show All 10 Lines
// template<class T> // template<class T>
// bool // bool
// operator!=(const T& lhs, const complex<T>& rhs); // operator!=(const T& lhs, const complex<T>& rhs);
#include <complex> #include <complex>
#include <cassert> #include <cassert>
#include "test_macros.h"
template <class T> template <class T>
void void
test_constexpr() test_constexpr()
{ {
#if _LIBCPP_STD_VER > 11 #if TEST_STD_VER > 11
{ {
constexpr T lhs(-2.5); constexpr T lhs(-2.5);
constexpr std::complex<T> rhs(1.5, 2.5); constexpr std::complex<T> rhs(1.5, 2.5);
static_assert (lhs != rhs, ""); static_assert (lhs != rhs, "");
} }
{ {
constexpr T lhs(-2.5); constexpr T lhs(-2.5);
constexpr std::complex<T> rhs(1.5, 0); constexpr std::complex<T> rhs(1.5, 0);
▲ Show 20 Lines • Show All 50 Lines • Show Last 20 Lines

test/std/strings/string.view/string.view.access/data.pass.cpp

Show All 33 Lines
#if TEST_STD_VER >= 11 #if TEST_STD_VER >= 11
test ( u"ABCDE", 5 ); test ( u"ABCDE", 5 );
test ( u"a", 1 ); test ( u"a", 1 );
test ( U"ABCDE", 5 ); test ( U"ABCDE", 5 );
test ( U"a", 1 ); test ( U"a", 1 );
#endif #endif
#if _LIBCPP_STD_VER > 11 #if TEST_STD_VER > 11
{ {
constexpr const char *s = "ABC"; constexpr const char *s = "ABC";
constexpr std::basic_string_view<char> sv( s, 2 ); constexpr std::basic_string_view<char> sv( s, 2 );
static_assert( sv.length() == 2, "" ); static_assert( sv.length() == 2, "" );
static_assert( sv.data() == s, "" ); static_assert( sv.data() == s, "" );
} }
#endif #endif
} }

test/std/strings/string.view/string.view.access/index.pass.cpp

Show All 36 Lines
#if TEST_STD_VER >= 11 #if TEST_STD_VER >= 11
test ( u"ABCDE", 5 ); test ( u"ABCDE", 5 );
test ( u"a", 1 ); test ( u"a", 1 );
test ( U"ABCDE", 5 ); test ( U"ABCDE", 5 );
test ( U"a", 1 ); test ( U"a", 1 );
#endif #endif
#if _LIBCPP_STD_VER > 11 #if TEST_STD_VER > 11
{ {
constexpr std::basic_string_view<char> sv ( "ABC", 2 ); constexpr std::basic_string_view<char> sv ( "ABC", 2 );
static_assert ( sv.length() == 2, "" ); static_assert ( sv.length() == 2, "" );
static_assert ( sv[0] == 'A', "" ); static_assert ( sv[0] == 'A', "" );
static_assert ( sv[1] == 'B', "" ); static_assert ( sv[1] == 'B', "" );
} }
#endif #endif
} }

test/std/strings/string.view/string.view.capacity/capacity.pass.cpp

Show All 17 Lines
#include <string_view> #include <string_view>
#include <cassert> #include <cassert>
#include "test_macros.h" #include "test_macros.h"
template<typename SV> template<typename SV>
void test1 () { void test1 () {
#if _LIBCPP_STD_VER > 11 #if TEST_STD_VER > 11
{ {
constexpr SV sv1; constexpr SV sv1;
static_assert ( sv1.size() == 0, "" ); static_assert ( sv1.size() == 0, "" );
static_assert ( sv1.empty(), ""); static_assert ( sv1.empty(), "");
static_assert ( sv1.size() == sv1.length(), "" ); static_assert ( sv1.size() == sv1.length(), "" );
static_assert ( sv1.max_size() > sv1.size(), ""); static_assert ( sv1.max_size() > sv1.size(), "");
} }
#endif #endif
▲ Show 20 Lines • Show All 55 Lines • Show Last 20 Lines

test/std/strings/string.view/string.view.comparison/opeq.string_view.pointer.pass.cpp

Show All 11 Lines
// template<class charT, class traits> // template<class charT, class traits>
// constexpr bool operator==(basic_string_view<charT,traits> lhs, const charT* rhs); // constexpr bool operator==(basic_string_view<charT,traits> lhs, const charT* rhs);
// template<class charT, class traits> // template<class charT, class traits>
// constexpr bool operator==(const charT* lhs, basic_string_view<charT,traits> rhs); // constexpr bool operator==(const charT* lhs, basic_string_view<charT,traits> rhs);
#include <string_view> #include <string_view>
#include <cassert> #include <cassert>
#include "test_macros.h"
#include "constexpr_char_traits.hpp" #include "constexpr_char_traits.hpp"
template <class S> template <class S>
void void
test(S lhs, const typename S::value_type* rhs, bool x) test(S lhs, const typename S::value_type* rhs, bool x)
{ {
assert((lhs == rhs) == x); assert((lhs == rhs) == x);
assert((rhs == lhs) == x); assert((rhs == lhs) == x);
Show All 16 Linesint main()
test(S("abcdefghij"), "abcdefghij", true); test(S("abcdefghij"), "abcdefghij", true);
test(S("abcdefghij"), "abcdefghijklmnopqrst", false); test(S("abcdefghij"), "abcdefghijklmnopqrst", false);
test(S("abcdefghijklmnopqrst"), "", false); test(S("abcdefghijklmnopqrst"), "", false);
test(S("abcdefghijklmnopqrst"), "abcde", false); test(S("abcdefghijklmnopqrst"), "abcde", false);
test(S("abcdefghijklmnopqrst"), "abcdefghij", false); test(S("abcdefghijklmnopqrst"), "abcdefghij", false);
test(S("abcdefghijklmnopqrst"), "abcdefghijklmnopqrst", true); test(S("abcdefghijklmnopqrst"), "abcdefghijklmnopqrst", true);
} }
#if _LIBCPP_STD_VER > 11 #if TEST_STD_VER > 11
{ {
typedef std::basic_string_view<char, constexpr_char_traits<char>> SV; typedef std::basic_string_view<char, constexpr_char_traits<char>> SV;
constexpr SV sv1; constexpr SV sv1;
constexpr SV sv2 { "abcde", 5 }; constexpr SV sv2 { "abcde", 5 };
static_assert ( sv1 == "", "" ); static_assert ( sv1 == "", "" );
static_assert ( "" == sv1, "" ); static_assert ( "" == sv1, "" );
static_assert (!(sv1 == "abcde"), "" ); static_assert (!(sv1 == "abcde"), "" );
static_assert (!("abcde" == sv1), "" ); static_assert (!("abcde" == sv1), "" );
static_assert ( sv2 == "abcde", "" ); static_assert ( sv2 == "abcde", "" );
static_assert ( "abcde" == sv2, "" ); static_assert ( "abcde" == sv2, "" );
static_assert (!(sv2 == "abcde0"), "" ); static_assert (!(sv2 == "abcde0"), "" );
static_assert (!("abcde0" == sv2), "" ); static_assert (!("abcde0" == sv2), "" );
} }
#endif #endif
} }

test/std/strings/string.view/string.view.comparison/opeq.string_view.string_view.pass.cpp

Show All 10 Lines
// template<class charT, class traits, class Allocator> // template<class charT, class traits, class Allocator>
// constexpr bool operator==(const basic_string_view<charT,traits> lhs, // constexpr bool operator==(const basic_string_view<charT,traits> lhs,
// const basic_string_view<charT,traits> rhs); // const basic_string_view<charT,traits> rhs);
#include <string_view> #include <string_view>
#include <cassert> #include <cassert>
#include "test_macros.h"
#include "constexpr_char_traits.hpp" #include "constexpr_char_traits.hpp"
template <class S> template <class S>
void void
test(S lhs, S rhs, bool x) test(S lhs, S rhs, bool x)
{ {
assert((lhs == rhs) == x); assert((lhs == rhs) == x);
assert((rhs == lhs) == x); assert((rhs == lhs) == x);
Show All 16 Linesint main()
test(S("abcdefghij"), S("abcdefghij"), true); test(S("abcdefghij"), S("abcdefghij"), true);
test(S("abcdefghij"), S("abcdefghijklmnopqrst"), false); test(S("abcdefghij"), S("abcdefghijklmnopqrst"), false);
test(S("abcdefghijklmnopqrst"), S(""), false); test(S("abcdefghijklmnopqrst"), S(""), false);
test(S("abcdefghijklmnopqrst"), S("abcde"), false); test(S("abcdefghijklmnopqrst"), S("abcde"), false);
test(S("abcdefghijklmnopqrst"), S("abcdefghij"), false); test(S("abcdefghijklmnopqrst"), S("abcdefghij"), false);
test(S("abcdefghijklmnopqrst"), S("abcdefghijklmnopqrst"), true); test(S("abcdefghijklmnopqrst"), S("abcdefghijklmnopqrst"), true);
} }
#if _LIBCPP_STD_VER > 11 #if TEST_STD_VER > 11
{ {
typedef std::basic_string_view<char, constexpr_char_traits<char>> SV; typedef std::basic_string_view<char, constexpr_char_traits<char>> SV;
constexpr SV sv1; constexpr SV sv1;
constexpr SV sv2; constexpr SV sv2;
constexpr SV sv3 { "abcde", 5 }; constexpr SV sv3 { "abcde", 5 };
static_assert ( sv1 == sv2, "" ); static_assert ( sv1 == sv2, "" );
static_assert (!(sv1 == sv3), "" ); static_assert (!(sv1 == sv3), "" );
} }
#endif #endif
} }

test/std/strings/string.view/string.view.comparison/opge.string_view.pointer.pass.cpp

Show All 11 Lines
// template<class charT, class traits, class Allocator> // template<class charT, class traits, class Allocator>
// constexpr bool operator>=(const charT* lhs, basic_string_wiew<charT,traits> rhs); // constexpr bool operator>=(const charT* lhs, basic_string_wiew<charT,traits> rhs);
// template<class charT, class traits, class Allocator> // template<class charT, class traits, class Allocator>
// constexpr bool operator>=(basic_string_wiew<charT,traits> lhs, const charT* rhs); // constexpr bool operator>=(basic_string_wiew<charT,traits> lhs, const charT* rhs);
#include <string_view> #include <string_view>
#include <cassert> #include <cassert>
#include "test_macros.h"
#include "constexpr_char_traits.hpp" #include "constexpr_char_traits.hpp"
template <class S> template <class S>
void void
test(const typename S::value_type* lhs, const S& rhs, bool x, bool y) test(const typename S::value_type* lhs, const S& rhs, bool x, bool y)
{ {
assert((lhs >= rhs) == x); assert((lhs >= rhs) == x);
assert((rhs >= lhs) == y); assert((rhs >= lhs) == y);
Show All 16 Linesint main()
test("abcdefghij", S("abcdefghij"), true, true); test("abcdefghij", S("abcdefghij"), true, true);
test("abcdefghij", S("abcdefghijklmnopqrst"), false, true); test("abcdefghij", S("abcdefghijklmnopqrst"), false, true);
test("abcdefghijklmnopqrst", S(""), true, false); test("abcdefghijklmnopqrst", S(""), true, false);
test("abcdefghijklmnopqrst", S("abcde"), true, false); test("abcdefghijklmnopqrst", S("abcde"), true, false);
test("abcdefghijklmnopqrst", S("abcdefghij"), true, false); test("abcdefghijklmnopqrst", S("abcdefghij"), true, false);
test("abcdefghijklmnopqrst", S("abcdefghijklmnopqrst"), true, true); test("abcdefghijklmnopqrst", S("abcdefghijklmnopqrst"), true, true);
} }
#if _LIBCPP_STD_VER > 11 #if TEST_STD_VER > 11
{ {
typedef std::basic_string_view<char, constexpr_char_traits<char>> SV; typedef std::basic_string_view<char, constexpr_char_traits<char>> SV;
constexpr SV sv1; constexpr SV sv1;
constexpr SV sv2 { "abcde", 5 }; constexpr SV sv2 { "abcde", 5 };
static_assert ( sv1 >= "", "" ); static_assert ( sv1 >= "", "" );
static_assert ( "" >= sv1, "" ); static_assert ( "" >= sv1, "" );
static_assert (!(sv1 >= "abcde"), "" ); static_assert (!(sv1 >= "abcde"), "" );
Show All 11 Lines

test/std/strings/string.view/string.view.comparison/opge.string_view.string_view.pass.cpp

Show All 10 Lines
// template<class charT, class traits> // template<class charT, class traits>
// constexpr bool operator>=(basic_string_view<charT,traits> lhs, // constexpr bool operator>=(basic_string_view<charT,traits> lhs,
// basic_string_view<charT,traits> rhs); // basic_string_view<charT,traits> rhs);
#include <string_view> #include <string_view>
#include <cassert> #include <cassert>
#include "test_macros.h"
#include "constexpr_char_traits.hpp" #include "constexpr_char_traits.hpp"
template <class S> template <class S>
void void
test(const S& lhs, const S& rhs, bool x, bool y) test(const S& lhs, const S& rhs, bool x, bool y)
{ {
assert((lhs >= rhs) == x); assert((lhs >= rhs) == x);
assert((rhs >= lhs) == y); assert((rhs >= lhs) == y);
Show All 16 Linesint main()
test(S("abcdefghij"), S("abcdefghij"), true, true); test(S("abcdefghij"), S("abcdefghij"), true, true);
test(S("abcdefghij"), S("abcdefghijklmnopqrst"), false, true); test(S("abcdefghij"), S("abcdefghijklmnopqrst"), false, true);
test(S("abcdefghijklmnopqrst"), S(""), true, false); test(S("abcdefghijklmnopqrst"), S(""), true, false);
test(S("abcdefghijklmnopqrst"), S("abcde"), true, false); test(S("abcdefghijklmnopqrst"), S("abcde"), true, false);
test(S("abcdefghijklmnopqrst"), S("abcdefghij"), true, false); test(S("abcdefghijklmnopqrst"), S("abcdefghij"), true, false);
test(S("abcdefghijklmnopqrst"), S("abcdefghijklmnopqrst"), true, true); test(S("abcdefghijklmnopqrst"), S("abcdefghijklmnopqrst"), true, true);
} }
#if _LIBCPP_STD_VER > 11 #if TEST_STD_VER > 11
{ {
typedef std::basic_string_view<char, constexpr_char_traits<char>> SV; typedef std::basic_string_view<char, constexpr_char_traits<char>> SV;
constexpr SV sv1; constexpr SV sv1;
constexpr SV sv2 { "abcde", 5 }; constexpr SV sv2 { "abcde", 5 };
static_assert ( sv1 >= sv1, "" ); static_assert ( sv1 >= sv1, "" );
static_assert ( sv2 >= sv2, "" ); static_assert ( sv2 >= sv2, "" );
static_assert (!(sv1 >= sv2), "" ); static_assert (!(sv1 >= sv2), "" );
static_assert ( sv2 >= sv1, "" ); static_assert ( sv2 >= sv1, "" );
} }
#endif #endif
} }

test/std/strings/string.view/string.view.comparison/opgt.string_view.pointer.pass.cpp

Show All 11 Lines
// constexpr template<class charT, class traits, class Allocator> // constexpr template<class charT, class traits, class Allocator>
// bool operator>(const charT* lhs, basic_string_wiew<charT,traits> rhs); // bool operator>(const charT* lhs, basic_string_wiew<charT,traits> rhs);
// constexpr template<class charT, class traits, class Allocator> // constexpr template<class charT, class traits, class Allocator>
// bool operator>(basic_string_wiew<charT,traits> lhs, const charT* rhs); // bool operator>(basic_string_wiew<charT,traits> lhs, const charT* rhs);
#include <string_view> #include <string_view>
#include <cassert> #include <cassert>
#include "test_macros.h"
#include "constexpr_char_traits.hpp" #include "constexpr_char_traits.hpp"
template <class S> template <class S>
void void
test(const typename S::value_type* lhs, const S& rhs, bool x, bool y) test(const typename S::value_type* lhs, const S& rhs, bool x, bool y)
{ {
assert((lhs > rhs) == x); assert((lhs > rhs) == x);
assert((rhs > lhs) == y); assert((rhs > lhs) == y);
Show All 16 Linesint main()
test("abcdefghij", S("abcdefghij"), false, false); test("abcdefghij", S("abcdefghij"), false, false);
test("abcdefghij", S("abcdefghijklmnopqrst"), false, true); test("abcdefghij", S("abcdefghijklmnopqrst"), false, true);
test("abcdefghijklmnopqrst", S(""), true, false); test("abcdefghijklmnopqrst", S(""), true, false);
test("abcdefghijklmnopqrst", S("abcde"), true, false); test("abcdefghijklmnopqrst", S("abcde"), true, false);
test("abcdefghijklmnopqrst", S("abcdefghij"), true, false); test("abcdefghijklmnopqrst", S("abcdefghij"), true, false);
test("abcdefghijklmnopqrst", S("abcdefghijklmnopqrst"), false, false); test("abcdefghijklmnopqrst", S("abcdefghijklmnopqrst"), false, false);
} }
#if _LIBCPP_STD_VER > 11 #if TEST_STD_VER > 11
{ {
typedef std::basic_string_view<char, constexpr_char_traits<char>> SV; typedef std::basic_string_view<char, constexpr_char_traits<char>> SV;
constexpr SV sv1; constexpr SV sv1;
constexpr SV sv2 { "abcde", 5 }; constexpr SV sv2 { "abcde", 5 };
static_assert (!(sv1 > ""), "" ); static_assert (!(sv1 > ""), "" );
static_assert (!("" > sv1), "" ); static_assert (!("" > sv1), "" );
static_assert (!(sv1 > "abcde"), "" ); static_assert (!(sv1 > "abcde"), "" );
Show All 11 Lines

test/std/strings/string.view/string.view.comparison/opgt.string_view.string_view.pass.cpp

Show All 10 Lines
// template<class charT, class traits> // template<class charT, class traits>
// constexpr bool operator>(basic_string_view<charT,traits> lhs, // constexpr bool operator>(basic_string_view<charT,traits> lhs,
// basic_string_view<charT,traits> rhs); // basic_string_view<charT,traits> rhs);
#include <string_view> #include <string_view>
#include <cassert> #include <cassert>
#include "test_macros.h"
#include "constexpr_char_traits.hpp" #include "constexpr_char_traits.hpp"
template <class S> template <class S>
void void
test(const S& lhs, const S& rhs, bool x, bool y) test(const S& lhs, const S& rhs, bool x, bool y)
{ {
assert((lhs > rhs) == x); assert((lhs > rhs) == x);
assert((rhs > lhs) == y); assert((rhs > lhs) == y);
Show All 16 Linesint main()
test(S("abcdefghij"), S("abcdefghij"), false, false); test(S("abcdefghij"), S("abcdefghij"), false, false);
test(S("abcdefghij"), S("abcdefghijklmnopqrst"), false, true); test(S("abcdefghij"), S("abcdefghijklmnopqrst"), false, true);
test(S("abcdefghijklmnopqrst"), S(""), true, false); test(S("abcdefghijklmnopqrst"), S(""), true, false);
test(S("abcdefghijklmnopqrst"), S("abcde"), true, false); test(S("abcdefghijklmnopqrst"), S("abcde"), true, false);
test(S("abcdefghijklmnopqrst"), S("abcdefghij"), true, false); test(S("abcdefghijklmnopqrst"), S("abcdefghij"), true, false);
test(S("abcdefghijklmnopqrst"), S("abcdefghijklmnopqrst"), false, false); test(S("abcdefghijklmnopqrst"), S("abcdefghijklmnopqrst"), false, false);
} }
#if _LIBCPP_STD_VER > 11 #if TEST_STD_VER > 11
{ {
typedef std::basic_string_view<char, constexpr_char_traits<char>> SV; typedef std::basic_string_view<char, constexpr_char_traits<char>> SV;
constexpr SV sv1; constexpr SV sv1;
constexpr SV sv2 { "abcde", 5 }; constexpr SV sv2 { "abcde", 5 };
static_assert (!(sv1 > sv1), "" ); static_assert (!(sv1 > sv1), "" );
static_assert (!(sv2 > sv2), "" ); static_assert (!(sv2 > sv2), "" );
static_assert (!(sv1 > sv2), "" ); static_assert (!(sv1 > sv2), "" );
static_assert ( sv2 > sv1, "" ); static_assert ( sv2 > sv1, "" );
} }
#endif #endif
} }

test/std/strings/string.view/string.view.comparison/ople.string_view.pointer.pass.cpp

Show All 11 Lines
// template<class charT, class traits, class Allocator> // template<class charT, class traits, class Allocator>
// constexpr bool operator<=(const charT* lhs, basic_string_wiew<charT,traits> rhs); // constexpr bool operator<=(const charT* lhs, basic_string_wiew<charT,traits> rhs);
// template<class charT, class traits, class Allocator> // template<class charT, class traits, class Allocator>
// constexpr bool operator<=(basic_string_wiew<charT,traits> lhs, const charT* rhs); // constexpr bool operator<=(basic_string_wiew<charT,traits> lhs, const charT* rhs);
#include <string_view> #include <string_view>
#include <cassert> #include <cassert>
#include "test_macros.h"
#include "constexpr_char_traits.hpp" #include "constexpr_char_traits.hpp"
template <class S> template <class S>
void void
test(const typename S::value_type* lhs, const S& rhs, bool x, bool y) test(const typename S::value_type* lhs, const S& rhs, bool x, bool y)
{ {
assert((lhs <= rhs) == x); assert((lhs <= rhs) == x);
assert((rhs <= lhs) == y); assert((rhs <= lhs) == y);
Show All 16 Linesint main()
test("abcdefghij", S("abcdefghij"), true, true); test("abcdefghij", S("abcdefghij"), true, true);
test("abcdefghij", S("abcdefghijklmnopqrst"), true, false); test("abcdefghij", S("abcdefghijklmnopqrst"), true, false);
test("abcdefghijklmnopqrst", S(""), false, true); test("abcdefghijklmnopqrst", S(""), false, true);
test("abcdefghijklmnopqrst", S("abcde"), false, true); test("abcdefghijklmnopqrst", S("abcde"), false, true);
test("abcdefghijklmnopqrst", S("abcdefghij"), false, true); test("abcdefghijklmnopqrst", S("abcdefghij"), false, true);
test("abcdefghijklmnopqrst", S("abcdefghijklmnopqrst"), true, true); test("abcdefghijklmnopqrst", S("abcdefghijklmnopqrst"), true, true);
} }
#if _LIBCPP_STD_VER > 11 #if TEST_STD_VER > 11
{ {
typedef std::basic_string_view<char, constexpr_char_traits<char>> SV; typedef std::basic_string_view<char, constexpr_char_traits<char>> SV;
constexpr SV sv1; constexpr SV sv1;
constexpr SV sv2 { "abcde", 5 }; constexpr SV sv2 { "abcde", 5 };
static_assert ( sv1 <= "", "" ); static_assert ( sv1 <= "", "" );
static_assert ( "" <= sv1, "" ); static_assert ( "" <= sv1, "" );
static_assert ( sv1 <= "abcde", "" ); static_assert ( sv1 <= "abcde", "" );
Show All 11 Lines

test/std/strings/string.view/string.view.comparison/ople.string_view.string_view.pass.cpp

Show All 10 Lines
// template<class charT, class traits> // template<class charT, class traits>
// constexpr bool operator<=(basic_string_view<charT,traits> lhs, // constexpr bool operator<=(basic_string_view<charT,traits> lhs,
// basic_string_view<charT,traits> rhs); // basic_string_view<charT,traits> rhs);
#include <string_view> #include <string_view>
#include <cassert> #include <cassert>
#include "test_macros.h"
#include "constexpr_char_traits.hpp" #include "constexpr_char_traits.hpp"
template <class S> template <class S>
void void
test(const S& lhs, const S& rhs, bool x, bool y) test(const S& lhs, const S& rhs, bool x, bool y)
{ {
assert((lhs <= rhs) == x); assert((lhs <= rhs) == x);
assert((rhs <= lhs) == y); assert((rhs <= lhs) == y);
Show All 16 Linesint main()
test(S("abcdefghij"), S("abcdefghij"), true, true); test(S("abcdefghij"), S("abcdefghij"), true, true);
test(S("abcdefghij"), S("abcdefghijklmnopqrst"), true, false); test(S("abcdefghij"), S("abcdefghijklmnopqrst"), true, false);
test(S("abcdefghijklmnopqrst"), S(""), false, true); test(S("abcdefghijklmnopqrst"), S(""), false, true);
test(S("abcdefghijklmnopqrst"), S("abcde"), false, true); test(S("abcdefghijklmnopqrst"), S("abcde"), false, true);
test(S("abcdefghijklmnopqrst"), S("abcdefghij"), false, true); test(S("abcdefghijklmnopqrst"), S("abcdefghij"), false, true);
test(S("abcdefghijklmnopqrst"), S("abcdefghijklmnopqrst"), true, true); test(S("abcdefghijklmnopqrst"), S("abcdefghijklmnopqrst"), true, true);
} }
#if _LIBCPP_STD_VER > 11 #if TEST_STD_VER > 11
{ {
typedef std::basic_string_view<char, constexpr_char_traits<char>> SV; typedef std::basic_string_view<char, constexpr_char_traits<char>> SV;
constexpr SV sv1; constexpr SV sv1;
constexpr SV sv2 { "abcde", 5 }; constexpr SV sv2 { "abcde", 5 };
static_assert ( sv1 <= sv1, "" ); static_assert ( sv1 <= sv1, "" );
static_assert ( sv2 <= sv2, "" ); static_assert ( sv2 <= sv2, "" );
static_assert ( sv1 <= sv2, "" ); static_assert ( sv1 <= sv2, "" );
static_assert (!(sv2 <= sv1), "" ); static_assert (!(sv2 <= sv1), "" );
} }
#endif #endif
} }

test/std/strings/string.view/string.view.comparison/oplt.string_view.pointer.pass.cpp

Show All 11 Lines
// template<class charT, class traits, class Allocator> // template<class charT, class traits, class Allocator>
// constexpr bool operator<(const charT* lhs, basic_string_wiew<charT,traits> rhs); // constexpr bool operator<(const charT* lhs, basic_string_wiew<charT,traits> rhs);
// template<class charT, class traits, class Allocator> // template<class charT, class traits, class Allocator>
// constexpr bool operator<(basic_string_wiew<charT,traits> lhs, const charT* rhs); // constexpr bool operator<(basic_string_wiew<charT,traits> lhs, const charT* rhs);
#include <string_view> #include <string_view>
#include <cassert> #include <cassert>
#include "test_macros.h"
#include "constexpr_char_traits.hpp" #include "constexpr_char_traits.hpp"
template <class S> template <class S>
void void
test(const typename S::value_type* lhs, const S& rhs, bool x, bool y) test(const typename S::value_type* lhs, const S& rhs, bool x, bool y)
{ {
assert((lhs < rhs) == x); assert((lhs < rhs) == x);
assert((rhs < lhs) == y); assert((rhs < lhs) == y);
Show All 16 Linesint main()
test("abcdefghij", S("abcdefghij"), false, false); test("abcdefghij", S("abcdefghij"), false, false);
test("abcdefghij", S("abcdefghijklmnopqrst"), true, false); test("abcdefghij", S("abcdefghijklmnopqrst"), true, false);
test("abcdefghijklmnopqrst", S(""), false, true); test("abcdefghijklmnopqrst", S(""), false, true);
test("abcdefghijklmnopqrst", S("abcde"), false, true); test("abcdefghijklmnopqrst", S("abcde"), false, true);
test("abcdefghijklmnopqrst", S("abcdefghij"), false, true); test("abcdefghijklmnopqrst", S("abcdefghij"), false, true);
test("abcdefghijklmnopqrst", S("abcdefghijklmnopqrst"), false, false); test("abcdefghijklmnopqrst", S("abcdefghijklmnopqrst"), false, false);
} }
#if _LIBCPP_STD_VER > 11 #if TEST_STD_VER > 11
{ {
typedef std::basic_string_view<char, constexpr_char_traits<char>> SV; typedef std::basic_string_view<char, constexpr_char_traits<char>> SV;
constexpr SV sv1; constexpr SV sv1;
constexpr SV sv2 { "abcde", 5 }; constexpr SV sv2 { "abcde", 5 };
static_assert (!(sv1 < ""), "" ); static_assert (!(sv1 < ""), "" );
static_assert (!("" < sv1), "" ); static_assert (!("" < sv1), "" );
static_assert ( sv1 < "abcde", "" ); static_assert ( sv1 < "abcde", "" );
Show All 11 Lines

test/std/strings/string.view/string.view.comparison/oplt.string_view.string_view.pass.cpp

Show All 10 Lines
// template<class charT, class traits> // template<class charT, class traits>
// constexpr bool operator<(basic_string_view<charT,traits> lhs, // constexpr bool operator<(basic_string_view<charT,traits> lhs,
// basic_string_view<charT,traits> rhs); // basic_string_view<charT,traits> rhs);
#include <string_view> #include <string_view>
#include <cassert> #include <cassert>
#include "test_macros.h"
#include "constexpr_char_traits.hpp" #include "constexpr_char_traits.hpp"
template <class S> template <class S>
void void
test(const S& lhs, const S& rhs, bool x, bool y) test(const S& lhs, const S& rhs, bool x, bool y)
{ {
assert((lhs < rhs) == x); assert((lhs < rhs) == x);
assert((rhs < lhs) == y); assert((rhs < lhs) == y);
Show All 16 Linesint main()
test(S("abcdefghij"), S("abcdefghij"), false, false); test(S("abcdefghij"), S("abcdefghij"), false, false);
test(S("abcdefghij"), S("abcdefghijklmnopqrst"), true, false); test(S("abcdefghij"), S("abcdefghijklmnopqrst"), true, false);
test(S("abcdefghijklmnopqrst"), S(""), false, true); test(S("abcdefghijklmnopqrst"), S(""), false, true);
test(S("abcdefghijklmnopqrst"), S("abcde"), false, true); test(S("abcdefghijklmnopqrst"), S("abcde"), false, true);
test(S("abcdefghijklmnopqrst"), S("abcdefghij"), false, true); test(S("abcdefghijklmnopqrst"), S("abcdefghij"), false, true);
test(S("abcdefghijklmnopqrst"), S("abcdefghijklmnopqrst"), false, false); test(S("abcdefghijklmnopqrst"), S("abcdefghijklmnopqrst"), false, false);
} }
#if _LIBCPP_STD_VER > 11 #if TEST_STD_VER > 11
{ {
typedef std::basic_string_view<char, constexpr_char_traits<char>> SV; typedef std::basic_string_view<char, constexpr_char_traits<char>> SV;
constexpr SV sv1; constexpr SV sv1;
constexpr SV sv2 { "abcde", 5 }; constexpr SV sv2 { "abcde", 5 };
static_assert (!(sv1 < sv1), "" ); static_assert (!(sv1 < sv1), "" );
static_assert (!(sv2 < sv2), "" ); static_assert (!(sv2 < sv2), "" );
static_assert ( sv1 < sv2, "" ); static_assert ( sv1 < sv2, "" );
static_assert (!(sv2 < sv1), "" ); static_assert (!(sv2 < sv1), "" );
} }
#endif #endif
} }

test/std/strings/string.view/string.view.comparison/opne.string_view.pointer.pass.cpp

Show All 11 Lines
// template<class charT, class traits> // template<class charT, class traits>
// constexpr bool operator!=(basic_string_view<charT,traits> lhs, const charT* rhs); // constexpr bool operator!=(basic_string_view<charT,traits> lhs, const charT* rhs);
// template<class charT, class traits> // template<class charT, class traits>
// constexpr bool operator!=(const charT* lhs, basic_string_view<charT,traits> rhs); // constexpr bool operator!=(const charT* lhs, basic_string_view<charT,traits> rhs);
#include <string_view> #include <string_view>
#include <cassert> #include <cassert>
#include "test_macros.h"
#include "constexpr_char_traits.hpp" #include "constexpr_char_traits.hpp"
template <class S> template <class S>
void void
test(S lhs, const typename S::value_type* rhs, bool x) test(S lhs, const typename S::value_type* rhs, bool x)
{ {
assert((lhs != rhs) == x); assert((lhs != rhs) == x);
assert((rhs != lhs) == x); assert((rhs != lhs) == x);
Show All 16 Linesint main()
test(S("abcdefghij"), "abcdefghij", false); test(S("abcdefghij"), "abcdefghij", false);
test(S("abcdefghij"), "abcdefghijklmnopqrst", true); test(S("abcdefghij"), "abcdefghijklmnopqrst", true);
test(S("abcdefghijklmnopqrst"), "", true); test(S("abcdefghijklmnopqrst"), "", true);
test(S("abcdefghijklmnopqrst"), "abcde", true); test(S("abcdefghijklmnopqrst"), "abcde", true);
test(S("abcdefghijklmnopqrst"), "abcdefghij", true); test(S("abcdefghijklmnopqrst"), "abcdefghij", true);
test(S("abcdefghijklmnopqrst"), "abcdefghijklmnopqrst", false); test(S("abcdefghijklmnopqrst"), "abcdefghijklmnopqrst", false);
} }
#if _LIBCPP_STD_VER > 11 #if TEST_STD_VER > 11
{ {
typedef std::basic_string_view<char, constexpr_char_traits<char>> SV; typedef std::basic_string_view<char, constexpr_char_traits<char>> SV;
constexpr SV sv1; constexpr SV sv1;
constexpr SV sv2 { "abcde", 5 }; constexpr SV sv2 { "abcde", 5 };
static_assert (!(sv1 != ""), "" ); static_assert (!(sv1 != ""), "" );
static_assert (!("" != sv1), "" ); static_assert (!("" != sv1), "" );
static_assert ( sv1 != "abcde", "" ); static_assert ( sv1 != "abcde", "" );
Show All 9 Lines

test/std/strings/string.view/string.view.comparison/opne.string_view.string_view.pass.cpp

Show All 10 Lines
// template<class charT, class traits, class Allocator> // template<class charT, class traits, class Allocator>
// constexpr bool operator!=(const basic_string_view<charT,traits> lhs, // constexpr bool operator!=(const basic_string_view<charT,traits> lhs,
// const basic_string_view<charT,traits> rhs); // const basic_string_view<charT,traits> rhs);
#include <string_view> #include <string_view>
#include <cassert> #include <cassert>
#include "test_macros.h"
#include "constexpr_char_traits.hpp" #include "constexpr_char_traits.hpp"
template <class S> template <class S>
void void
test(S lhs, S rhs, bool x) test(S lhs, S rhs, bool x)
{ {
assert((lhs != rhs) == x); assert((lhs != rhs) == x);
assert((rhs != lhs) == x); assert((rhs != lhs) == x);
Show All 16 Linesint main()
test(S("abcdefghij"), S("abcdefghij"), false); test(S("abcdefghij"), S("abcdefghij"), false);
test(S("abcdefghij"), S("abcdefghijklmnopqrst"), true); test(S("abcdefghij"), S("abcdefghijklmnopqrst"), true);
test(S("abcdefghijklmnopqrst"), S(""), true); test(S("abcdefghijklmnopqrst"), S(""), true);
test(S("abcdefghijklmnopqrst"), S("abcde"), true); test(S("abcdefghijklmnopqrst"), S("abcde"), true);
test(S("abcdefghijklmnopqrst"), S("abcdefghij"), true); test(S("abcdefghijklmnopqrst"), S("abcdefghij"), true);
test(S("abcdefghijklmnopqrst"), S("abcdefghijklmnopqrst"), false); test(S("abcdefghijklmnopqrst"), S("abcdefghijklmnopqrst"), false);
} }
#if _LIBCPP_STD_VER > 11 #if TEST_STD_VER > 11
{ {
typedef std::basic_string_view<char, constexpr_char_traits<char>> SV; typedef std::basic_string_view<char, constexpr_char_traits<char>> SV;
constexpr SV sv1; constexpr SV sv1;
constexpr SV sv2; constexpr SV sv2;
constexpr SV sv3 { "abcde", 5 }; constexpr SV sv3 { "abcde", 5 };
static_assert (!( sv1 != sv2), "" ); static_assert (!( sv1 != sv2), "" );
static_assert ( sv1 != sv3, "" ); static_assert ( sv1 != sv3, "" );
} }
#endif #endif
} }

test/std/strings/string.view/string.view.cons/default.pass.cpp

Show All 9 Lines
// <string_view> // <string_view>
// constexpr basic_string_view () noexcept; // constexpr basic_string_view () noexcept;
#include <string_view> #include <string_view>
#include <cassert> #include <cassert>
#include "test_macros.h"
template<typename T> template<typename T>
void test () { void test () {
#if _LIBCPP_STD_VER > 11 #if TEST_STD_VER > 11
{ {
constexpr T sv1; constexpr T sv1;
static_assert ( sv1.size() == 0, "" ); static_assert ( sv1.size() == 0, "" );
static_assert ( sv1.empty(), ""); static_assert ( sv1.empty(), "");
} }
#endif #endif
{ {
Show All 18 Lines

test/std/strings/string.view/string.view.cons/from_literal.pass.cpp

Show All 12 Lines
// constexpr basic_string_view(const _CharT* _s) // constexpr basic_string_view(const _CharT* _s)
// : __data (_s), __size(_Traits::length(_s)) {} // : __data (_s), __size(_Traits::length(_s)) {}
#include <string_view> #include <string_view>
#include <string> #include <string>
#include <cassert> #include <cassert>
#include "test_macros.h"
#include "constexpr_char_traits.hpp" #include "constexpr_char_traits.hpp"
template<typename CharT> template<typename CharT>
size_t StrLen ( const CharT *s ) { size_t StrLen ( const CharT *s ) {
size_t retVal = 0; size_t retVal = 0;
while ( *s != 0 ) { ++retVal; ++s; } while ( *s != 0 ) { ++retVal; ++s; }
return retVal; return retVal;
} }
Show All 21 Lines#if TEST_STD_VER >= 11
test ( u"A" ); test ( u"A" );
test ( u"" ); test ( u"" );
test ( U"QBCDE" ); test ( U"QBCDE" );
test ( U"A" ); test ( U"A" );
test ( U"" ); test ( U"" );
#endif #endif
#if _LIBCPP_STD_VER > 11 #if TEST_STD_VER > 11
{ {
constexpr std::basic_string_view<char, constexpr_char_traits<char>> sv1 ( "ABCDE" ); constexpr std::basic_string_view<char, constexpr_char_traits<char>> sv1 ( "ABCDE" );
static_assert ( sv1.size() == 5, ""); static_assert ( sv1.size() == 5, "");
} }
#endif #endif
} }

test/std/strings/string.view/string.view.cons/from_ptr_len.pass.cpp

Show All 28 Linesvoid test ( const CharT *s, size_t sz ) {
} }
} }
int main () { int main () {
test ( "QBCDE", 5 ); test ( "QBCDE", 5 );
test ( "QBCDE", 2 ); test ( "QBCDE", 2 );
test ( "", 0 ); test ( "", 0 );
#if _LIBCPP_STD_VER > 11 #if TEST_STD_VER > 11
{ {
constexpr const char *s = "QBCDE"; constexpr const char *s = "QBCDE";
constexpr std::basic_string_view<char> sv1 ( s, 2 ); constexpr std::basic_string_view<char> sv1 ( s, 2 );
static_assert ( sv1.size() == 2, "" ); static_assert ( sv1.size() == 2, "" );
static_assert ( sv1.data() == s, "" ); static_assert ( sv1.data() == s, "" );
} }
#endif #endif
test ( L"QBCDE", 5 ); test ( L"QBCDE", 5 );
test ( L"QBCDE", 2 ); test ( L"QBCDE", 2 );
test ( L"", 0 ); test ( L"", 0 );
#if _LIBCPP_STD_VER > 11 #if TEST_STD_VER > 11
{ {
constexpr const wchar_t *s = L"QBCDE"; constexpr const wchar_t *s = L"QBCDE";
constexpr std::basic_string_view<wchar_t> sv1 ( s, 2 ); constexpr std::basic_string_view<wchar_t> sv1 ( s, 2 );
static_assert ( sv1.size() == 2, "" ); static_assert ( sv1.size() == 2, "" );
static_assert ( sv1.data() == s, "" ); static_assert ( sv1.data() == s, "" );
} }
#endif #endif
#if TEST_STD_VER >= 11 #if TEST_STD_VER >= 11
test ( u"QBCDE", 5 ); test ( u"QBCDE", 5 );
test ( u"QBCDE", 2 ); test ( u"QBCDE", 2 );
test ( u"", 0 ); test ( u"", 0 );
#if _LIBCPP_STD_VER > 11 #if TEST_STD_VER > 11
{ {
constexpr const char16_t *s = u"QBCDE"; constexpr const char16_t *s = u"QBCDE";
constexpr std::basic_string_view<char16_t> sv1 ( s, 2 ); constexpr std::basic_string_view<char16_t> sv1 ( s, 2 );
static_assert ( sv1.size() == 2, "" ); static_assert ( sv1.size() == 2, "" );
static_assert ( sv1.data() == s, "" ); static_assert ( sv1.data() == s, "" );
} }
#endif #endif
test ( U"QBCDE", 5 ); test ( U"QBCDE", 5 );
test ( U"QBCDE", 2 ); test ( U"QBCDE", 2 );
test ( U"", 0 ); test ( U"", 0 );
#if _LIBCPP_STD_VER > 11 #if TEST_STD_VER > 11
{ {
constexpr const char32_t *s = U"QBCDE"; constexpr const char32_t *s = U"QBCDE";
constexpr std::basic_string_view<char32_t> sv1 ( s, 2 ); constexpr std::basic_string_view<char32_t> sv1 ( s, 2 );
static_assert ( sv1.size() == 2, "" ); static_assert ( sv1.size() == 2, "" );
static_assert ( sv1.data() == s, "" ); static_assert ( sv1.data() == s, "" );
} }
#endif #endif
#endif #endif
} }

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

//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// The LLVM Compiler Infrastructure // The LLVM Compiler Infrastructure
// //
// This file is dual licensed under the MIT and the University of Illinois Open // This file is dual licensed under the MIT and the University of Illinois Open
// Source Licenses. See LICENSE.TXT for details. // Source Licenses. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// <string_view> // <string_view>
// constexpr size_type find(charT c, size_type pos = 0) const; // constexpr size_type find(charT c, size_type pos = 0) const;
#include <string_view> #include <string_view>
#include <cassert> #include <cassert>
#include "test_macros.h"
#include "constexpr_char_traits.hpp" #include "constexpr_char_traits.hpp"
template <class S> template <class S>
void void
test(const S& s, typename S::value_type c, typename S::size_type pos, test(const S& s, typename S::value_type c, typename S::size_type pos,
typename S::size_type x) typename S::size_type x)
{ {
assert(s.find(c, pos) == x); assert(s.find(c, pos) == x);
Show All 36 Linesint main()
test(S("abcdeabcdeabcdeabcde"), 'c', 21, S::npos); test(S("abcdeabcdeabcdeabcde"), 'c', 21, S::npos);
test(S(""), 'c', S::npos); test(S(""), 'c', S::npos);
test(S("abcde"), 'c', 2); test(S("abcde"), 'c', 2);
test(S("abcdeabcde"), 'c', 2); test(S("abcdeabcde"), 'c', 2);
test(S("abcdeabcdeabcdeabcde"), 'c', 2); test(S("abcdeabcdeabcdeabcde"), 'c', 2);
} }
#if _LIBCPP_STD_VER > 11 #if TEST_STD_VER > 11
{ {
typedef std::basic_string_view<char, constexpr_char_traits<char>> SV; typedef std::basic_string_view<char, constexpr_char_traits<char>> SV;
constexpr SV sv1; constexpr SV sv1;
constexpr SV sv2 { "abcde", 5 }; constexpr SV sv2 { "abcde", 5 };
static_assert (sv1.find( 'c', 0 ) == SV::npos, "" ); static_assert (sv1.find( 'c', 0 ) == SV::npos, "" );
static_assert (sv1.find( 'c', 1 ) == SV::npos, "" ); static_assert (sv1.find( 'c', 1 ) == SV::npos, "" );
static_assert (sv2.find( 'c', 0 ) == 2, "" ); static_assert (sv2.find( 'c', 0 ) == 2, "" );
static_assert (sv2.find( 'c', 1 ) == 2, "" ); static_assert (sv2.find( 'c', 1 ) == 2, "" );
static_assert (sv2.find( 'c', 2 ) == 2, "" ); static_assert (sv2.find( 'c', 2 ) == 2, "" );
static_assert (sv2.find( 'c', 3 ) == SV::npos, "" ); static_assert (sv2.find( 'c', 3 ) == SV::npos, "" );
static_assert (sv2.find( 'c', 4 ) == SV::npos, "" ); static_assert (sv2.find( 'c', 4 ) == SV::npos, "" );
} }
#endif #endif
} }

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

//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// The LLVM Compiler Infrastructure // The LLVM Compiler Infrastructure
// //
// This file is dual licensed under the MIT and the University of Illinois Open // This file is dual licensed under the MIT and the University of Illinois Open
// Source Licenses. See LICENSE.TXT for details. // Source Licenses. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// <string_view> // <string_view>
// constexpr size_type find_first_not_of(charT c, size_type pos = 0) const; // constexpr size_type find_first_not_of(charT c, size_type pos = 0) const;
#include <string_view> #include <string_view>
#include <cassert> #include <cassert>
#include "test_macros.h"
#include "constexpr_char_traits.hpp" #include "constexpr_char_traits.hpp"
template <class S> template <class S>
void void
test(const S& s, typename S::value_type c, typename S::size_type pos, test(const S& s, typename S::value_type c, typename S::size_type pos,
typename S::size_type x) typename S::size_type x)
{ {
assert(s.find_first_not_of(c, pos) == x); assert(s.find_first_not_of(c, pos) == x);
Show All 38 Linesint main()
test(S(""), 'q', S::npos); test(S(""), 'q', S::npos);
test(S("q"), 'q', S::npos); test(S("q"), 'q', S::npos);
test(S("qqq"), 'q', S::npos); test(S("qqq"), 'q', S::npos);
test(S("csope"), 'q', 0); test(S("csope"), 'q', 0);
test(S("gfsmthlkon"), 'q', 0); test(S("gfsmthlkon"), 'q', 0);
test(S("laenfsbridchgotmkqpj"), 'q', 0); test(S("laenfsbridchgotmkqpj"), 'q', 0);
} }
#if _LIBCPP_STD_VER > 11 #if TEST_STD_VER > 11
{ {
typedef std::basic_string_view<char, constexpr_char_traits<char>> SV; typedef std::basic_string_view<char, constexpr_char_traits<char>> SV;
constexpr SV sv1; constexpr SV sv1;
constexpr SV sv2 { "abcde", 5 }; constexpr SV sv2 { "abcde", 5 };
static_assert (sv1.find_first_not_of( 'q', 0 ) == SV::npos, "" ); static_assert (sv1.find_first_not_of( 'q', 0 ) == SV::npos, "" );
static_assert (sv1.find_first_not_of( 'q', 1 ) == SV::npos, "" ); static_assert (sv1.find_first_not_of( 'q', 1 ) == SV::npos, "" );
static_assert (sv2.find_first_not_of( 'q', 0 ) == 0, "" ); static_assert (sv2.find_first_not_of( 'q', 0 ) == 0, "" );
static_assert (sv2.find_first_not_of( 'q', 1 ) == 1, "" ); static_assert (sv2.find_first_not_of( 'q', 1 ) == 1, "" );
static_assert (sv2.find_first_not_of( 'q', 5 ) == SV::npos, "" ); static_assert (sv2.find_first_not_of( 'q', 5 ) == SV::npos, "" );
} }
#endif #endif
} }

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

//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// The LLVM Compiler Infrastructure // The LLVM Compiler Infrastructure
// //
// This file is dual licensed under the MIT and the University of Illinois Open // This file is dual licensed under the MIT and the University of Illinois Open
// Source Licenses. See LICENSE.TXT for details. // Source Licenses. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// <string_view> // <string_view>
// constexpr size_type find_first_not_of(const charT* s, size_type pos = 0) const; // constexpr size_type find_first_not_of(const charT* s, size_type pos = 0) const;
#include <string_view> #include <string_view>
#include <cassert> #include <cassert>
#include "test_macros.h"
#include "constexpr_char_traits.hpp" #include "constexpr_char_traits.hpp"
template <class S> template <class S>
void void
test(const S& s, const typename S::value_type* str, typename S::size_type pos, test(const S& s, const typename S::value_type* str, typename S::size_type pos,
typename S::size_type x) typename S::size_type x)
{ {
assert(s.find_first_not_of(str, pos) == x); assert(s.find_first_not_of(str, pos) == x);
▲ Show 20 Lines • Show All 119 Lines • ▼ Show 20 Lines
int main() int main()
{ {
{ {
typedef std::string_view S; typedef std::string_view S;
test0<S>(); test0<S>();
test1<S>(); test1<S>();
} }
#if _LIBCPP_STD_VER > 11 #if TEST_STD_VER > 11
{ {
typedef std::basic_string_view<char, constexpr_char_traits<char>> SV; typedef std::basic_string_view<char, constexpr_char_traits<char>> SV;
constexpr SV sv1; constexpr SV sv1;
constexpr SV sv2 { "abcde", 5 }; constexpr SV sv2 { "abcde", 5 };
static_assert (sv1.find_first_not_of( "", 0) == SV::npos, "" ); static_assert (sv1.find_first_not_of( "", 0) == SV::npos, "" );
static_assert (sv1.find_first_not_of( "irkhs", 0) == SV::npos, "" ); static_assert (sv1.find_first_not_of( "irkhs", 0) == SV::npos, "" );
static_assert (sv2.find_first_not_of( "", 0) == 0, "" ); static_assert (sv2.find_first_not_of( "", 0) == 0, "" );
static_assert (sv2.find_first_not_of( "gfsrt", 0) == 0, "" ); static_assert (sv2.find_first_not_of( "gfsrt", 0) == 0, "" );
static_assert (sv2.find_first_not_of( "lecar", 0) == 1, "" ); static_assert (sv2.find_first_not_of( "lecar", 0) == 1, "" );
} }
#endif #endif
} }

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

//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// The LLVM Compiler Infrastructure // The LLVM Compiler Infrastructure
// //
// This file is dual licensed under the MIT and the University of Illinois Open // This file is dual licensed under the MIT and the University of Illinois Open
// Source Licenses. See LICENSE.TXT for details. // Source Licenses. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// <string_view> // <string_view>
// constexpr size_type find_first_not_of(const charT* s, size_type pos, size_type n) const; // constexpr size_type find_first_not_of(const charT* s, size_type pos, size_type n) const;
#include <string_view> #include <string_view>
#include <cassert> #include <cassert>
#include "test_macros.h"
#include "constexpr_char_traits.hpp" #include "constexpr_char_traits.hpp"
template <class S> template <class S>
void void
test(const S& s, const typename S::value_type* str, typename S::size_type pos, test(const S& s, const typename S::value_type* str, typename S::size_type pos,
typename S::size_type n, typename S::size_type x) typename S::size_type n, typename S::size_type x)
{ {
assert(s.find_first_not_of(str, pos, n) == x); assert(s.find_first_not_of(str, pos, n) == x);
▲ Show 20 Lines • Show All 346 Lines • ▼ Show 20 Linesint main()
{ {
typedef std::string_view S; typedef std::string_view S;
test0<S>(); test0<S>();
test1<S>(); test1<S>();
test2<S>(); test2<S>();
test3<S>(); test3<S>();
} }
#if _LIBCPP_STD_VER > 11 #if TEST_STD_VER > 11
{ {
typedef std::basic_string_view<char, constexpr_char_traits<char>> SV; typedef std::basic_string_view<char, constexpr_char_traits<char>> SV;
constexpr SV sv1; constexpr SV sv1;
constexpr SV sv2 { "abcde", 5 }; constexpr SV sv2 { "abcde", 5 };
static_assert (sv1.find_first_not_of( "", 0, 0) == SV::npos, "" ); static_assert (sv1.find_first_not_of( "", 0, 0) == SV::npos, "" );
static_assert (sv1.find_first_not_of( "irkhs", 0, 5) == SV::npos, "" ); static_assert (sv1.find_first_not_of( "irkhs", 0, 5) == SV::npos, "" );
static_assert (sv2.find_first_not_of( "", 0, 0) == 0, "" ); static_assert (sv2.find_first_not_of( "", 0, 0) == 0, "" );
static_assert (sv2.find_first_not_of( "gfsrt", 0, 5) == 0, "" ); static_assert (sv2.find_first_not_of( "gfsrt", 0, 5) == 0, "" );
static_assert (sv2.find_first_not_of( "lecar", 0, 5) == 1, "" ); static_assert (sv2.find_first_not_of( "lecar", 0, 5) == 1, "" );
} }
#endif #endif
} }

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

//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// The LLVM Compiler Infrastructure // The LLVM Compiler Infrastructure
// //
// This file is dual licensed under the MIT and the University of Illinois Open // This file is dual licensed under the MIT and the University of Illinois Open
// Source Licenses. See LICENSE.TXT for details. // Source Licenses. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// <string> // <string>
// constexpr size_type find_first_of(charT c, size_type pos = 0) const; // constexpr size_type find_first_of(charT c, size_type pos = 0) const;
#include <string_view> #include <string_view>
#include <cassert> #include <cassert>
#include "test_macros.h"
#include "constexpr_char_traits.hpp" #include "constexpr_char_traits.hpp"
template <class S> template <class S>
void void
test(const S& s, typename S::value_type c, typename S::size_type pos, test(const S& s, typename S::value_type c, typename S::size_type pos,
typename S::size_type x) typename S::size_type x)
{ {
assert(s.find_first_of(c, pos) == x); assert(s.find_first_of(c, pos) == x);
Show All 36 Linesint main()
test(S("oselktgbcapndfjihrmq"), 'e', 21, S::npos); test(S("oselktgbcapndfjihrmq"), 'e', 21, S::npos);
test(S(""), 'e', S::npos); test(S(""), 'e', S::npos);
test(S("csope"), 'e', 4); test(S("csope"), 'e', 4);
test(S("gfsmthlkon"), 'e', S::npos); test(S("gfsmthlkon"), 'e', S::npos);
test(S("laenfsbridchgotmkqpj"), 'e', 2); test(S("laenfsbridchgotmkqpj"), 'e', 2);
} }
#if _LIBCPP_STD_VER > 11 #if TEST_STD_VER > 11
{ {
typedef std::basic_string_view<char, constexpr_char_traits<char>> SV; typedef std::basic_string_view<char, constexpr_char_traits<char>> SV;
constexpr SV sv1; constexpr SV sv1;
constexpr SV sv2 { "abcde", 5 }; constexpr SV sv2 { "abcde", 5 };
static_assert (sv1.find_first_of( 'e', 0 ) == SV::npos, "" ); static_assert (sv1.find_first_of( 'e', 0 ) == SV::npos, "" );
static_assert (sv1.find_first_of( 'e', 1 ) == SV::npos, "" ); static_assert (sv1.find_first_of( 'e', 1 ) == SV::npos, "" );
static_assert (sv2.find_first_of( 'q', 0 ) == SV::npos, "" ); static_assert (sv2.find_first_of( 'q', 0 ) == SV::npos, "" );
static_assert (sv2.find_first_of( 'e', 1 ) == 4, "" ); static_assert (sv2.find_first_of( 'e', 1 ) == 4, "" );
static_assert (sv2.find_first_of( 'e', 5 ) == SV::npos, "" ); static_assert (sv2.find_first_of( 'e', 5 ) == SV::npos, "" );
} }
#endif #endif
} }

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

//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// The LLVM Compiler Infrastructure // The LLVM Compiler Infrastructure
// //
// This file is dual licensed under the MIT and the University of Illinois Open // This file is dual licensed under the MIT and the University of Illinois Open
// Source Licenses. See LICENSE.TXT for details. // Source Licenses. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// <string> // <string>
// constexpr size_type find_first_of(const charT* s, size_type pos = 0) const; // constexpr size_type find_first_of(const charT* s, size_type pos = 0) const;
#include <string_view> #include <string_view>
#include <cassert> #include <cassert>
#include "test_macros.h"
#include "constexpr_char_traits.hpp" #include "constexpr_char_traits.hpp"
template <class S> template <class S>
void void
test(const S& s, const typename S::value_type* str, typename S::size_type pos, test(const S& s, const typename S::value_type* str, typename S::size_type pos,
typename S::size_type x) typename S::size_type x)
{ {
assert(s.find_first_of(str, pos) == x); assert(s.find_first_of(str, pos) == x);
▲ Show 20 Lines • Show All 119 Lines • ▼ Show 20 Lines
int main() int main()
{ {
{ {
typedef std::string_view S; typedef std::string_view S;
test0<S>(); test0<S>();
test1<S>(); test1<S>();
} }
#if _LIBCPP_STD_VER > 11 #if TEST_STD_VER > 11
{ {
typedef std::basic_string_view<char, constexpr_char_traits<char>> SV; typedef std::basic_string_view<char, constexpr_char_traits<char>> SV;
constexpr SV sv1; constexpr SV sv1;
constexpr SV sv2 { "abcde", 5 }; constexpr SV sv2 { "abcde", 5 };
static_assert (sv1.find_first_of( "", 0) == SV::npos, "" ); static_assert (sv1.find_first_of( "", 0) == SV::npos, "" );
static_assert (sv1.find_first_of( "irkhs", 0) == SV::npos, "" ); static_assert (sv1.find_first_of( "irkhs", 0) == SV::npos, "" );
static_assert (sv2.find_first_of( "", 0) == SV::npos, "" ); static_assert (sv2.find_first_of( "", 0) == SV::npos, "" );
static_assert (sv2.find_first_of( "gfsrt", 0) == SV::npos, "" ); static_assert (sv2.find_first_of( "gfsrt", 0) == SV::npos, "" );
static_assert (sv2.find_first_of( "lecar", 0) == 0, "" ); static_assert (sv2.find_first_of( "lecar", 0) == 0, "" );
} }
#endif #endif
} }

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

//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// The LLVM Compiler Infrastructure // The LLVM Compiler Infrastructure
// //
// This file is dual licensed under the MIT and the University of Illinois Open // This file is dual licensed under the MIT and the University of Illinois Open
// Source Licenses. See LICENSE.TXT for details. // Source Licenses. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// <string> // <string>
// constexpr size_type find_first_of(const charT* s, size_type pos, size_type n) const; // constexpr size_type find_first_of(const charT* s, size_type pos, size_type n) const;
#include <string_view> #include <string_view>
#include <cassert> #include <cassert>
#include "test_macros.h"
#include "constexpr_char_traits.hpp" #include "constexpr_char_traits.hpp"
template <class S> template <class S>
void void
test(const S& s, const typename S::value_type* str, typename S::size_type pos, test(const S& s, const typename S::value_type* str, typename S::size_type pos,
typename S::size_type n, typename S::size_type x) typename S::size_type n, typename S::size_type x)
{ {
assert(s.find_first_of(str, pos, n) == x); assert(s.find_first_of(str, pos, n) == x);
▲ Show 20 Lines • Show All 346 Lines • ▼ Show 20 Linesint main()
{ {
typedef std::string_view S; typedef std::string_view S;
test0<S>(); test0<S>();
test1<S>(); test1<S>();
test2<S>(); test2<S>();
test3<S>(); test3<S>();
} }
#if _LIBCPP_STD_VER > 11 #if TEST_STD_VER > 11
{ {
typedef std::basic_string_view<char, constexpr_char_traits<char>> SV; typedef std::basic_string_view<char, constexpr_char_traits<char>> SV;
constexpr SV sv1; constexpr SV sv1;
constexpr SV sv2 { "abcde", 5 }; constexpr SV sv2 { "abcde", 5 };
static_assert (sv1.find_first_of( "", 0, 0) == SV::npos, "" ); static_assert (sv1.find_first_of( "", 0, 0) == SV::npos, "" );
static_assert (sv1.find_first_of( "irkhs", 0, 5) == SV::npos, "" ); static_assert (sv1.find_first_of( "irkhs", 0, 5) == SV::npos, "" );
static_assert (sv2.find_first_of( "", 0, 0) == SV::npos, "" ); static_assert (sv2.find_first_of( "", 0, 0) == SV::npos, "" );
static_assert (sv2.find_first_of( "gfsrt", 0, 5) == SV::npos, "" ); static_assert (sv2.find_first_of( "gfsrt", 0, 5) == SV::npos, "" );
static_assert (sv2.find_first_of( "lecar", 0, 5) == 0, "" ); static_assert (sv2.find_first_of( "lecar", 0, 5) == 0, "" );
} }
#endif #endif
} }

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

//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// The LLVM Compiler Infrastructure // The LLVM Compiler Infrastructure
// //
// This file is dual licensed under the MIT and the University of Illinois Open // This file is dual licensed under the MIT and the University of Illinois Open
// Source Licenses. See LICENSE.TXT for details. // Source Licenses. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// <string_view> // <string_view>
// const size_type find_last_not_of(charT c, size_type pos = npos) const; // const size_type find_last_not_of(charT c, size_type pos = npos) const;
#include <string_view> #include <string_view>
#include <cassert> #include <cassert>
#include "test_macros.h"
#include "constexpr_char_traits.hpp" #include "constexpr_char_traits.hpp"
template <class S> template <class S>
void void
test(const S& s, typename S::value_type c, typename S::size_type pos, test(const S& s, typename S::value_type c, typename S::size_type pos,
typename S::size_type x) typename S::size_type x)
{ {
assert(s.find_last_not_of(c, pos) == x); assert(s.find_last_not_of(c, pos) == x);
Show All 36 Linesint main()
test(S("oselktgbcapndfjihrmq"), 'i', 21, 19); test(S("oselktgbcapndfjihrmq"), 'i', 21, 19);
test(S(""), 'i', S::npos); test(S(""), 'i', S::npos);
test(S("csope"), 'i', 4); test(S("csope"), 'i', 4);
test(S("gfsmthlkon"), 'i', 9); test(S("gfsmthlkon"), 'i', 9);
test(S("laenfsbridchgotmkqpj"), 'i', 19); test(S("laenfsbridchgotmkqpj"), 'i', 19);
} }
#if _LIBCPP_STD_VER > 11 #if TEST_STD_VER > 11
{ {
typedef std::basic_string_view<char, constexpr_char_traits<char>> SV; typedef std::basic_string_view<char, constexpr_char_traits<char>> SV;
constexpr SV sv1; constexpr SV sv1;
constexpr SV sv2 { "abcde", 5 }; constexpr SV sv2 { "abcde", 5 };
static_assert (sv1.find_last_not_of( 'i', 0 ) == SV::npos, "" ); static_assert (sv1.find_last_not_of( 'i', 0 ) == SV::npos, "" );
static_assert (sv1.find_last_not_of( 'i', 1 ) == SV::npos, "" ); static_assert (sv1.find_last_not_of( 'i', 1 ) == SV::npos, "" );
static_assert (sv2.find_last_not_of( 'a', 0 ) == SV::npos, "" ); static_assert (sv2.find_last_not_of( 'a', 0 ) == SV::npos, "" );
static_assert (sv2.find_last_not_of( 'a', 1 ) == 1, "" ); static_assert (sv2.find_last_not_of( 'a', 1 ) == 1, "" );
static_assert (sv2.find_last_not_of( 'e', 5 ) == 3, "" ); static_assert (sv2.find_last_not_of( 'e', 5 ) == 3, "" );
} }
#endif #endif
} }

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

//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// The LLVM Compiler Infrastructure // The LLVM Compiler Infrastructure
// //
// This file is dual licensed under the MIT and the University of Illinois Open // This file is dual licensed under the MIT and the University of Illinois Open
// Source Licenses. See LICENSE.TXT for details. // Source Licenses. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// <string_view> // <string_view>
// constexpr size_type find_last_not_of(const charT* s, size_type pos = npos) const; // constexpr size_type find_last_not_of(const charT* s, size_type pos = npos) const;
#include <string_view> #include <string_view>
#include <cassert> #include <cassert>
#include "test_macros.h"
#include "constexpr_char_traits.hpp" #include "constexpr_char_traits.hpp"
template <class S> template <class S>
void void
test(const S& s, const typename S::value_type* str, typename S::size_type pos, test(const S& s, const typename S::value_type* str, typename S::size_type pos,
typename S::size_type x) typename S::size_type x)
{ {
assert(s.find_last_not_of(str, pos) == x); assert(s.find_last_not_of(str, pos) == x);
▲ Show 20 Lines • Show All 119 Lines • ▼ Show 20 Lines
int main() int main()
{ {
{ {
typedef std::string_view S; typedef std::string_view S;
test0<S>(); test0<S>();
test1<S>(); test1<S>();
} }
#if _LIBCPP_STD_VER > 11 #if TEST_STD_VER > 11
{ {
typedef std::basic_string_view<char, constexpr_char_traits<char>> SV; typedef std::basic_string_view<char, constexpr_char_traits<char>> SV;
constexpr SV sv1; constexpr SV sv1;
constexpr SV sv2 { "abcde", 5 }; constexpr SV sv2 { "abcde", 5 };
static_assert (sv1.find_last_not_of( "", 0) == SV::npos, "" ); static_assert (sv1.find_last_not_of( "", 0) == SV::npos, "" );
static_assert (sv1.find_last_not_of( "irkhs", 5) == SV::npos, "" ); static_assert (sv1.find_last_not_of( "irkhs", 5) == SV::npos, "" );
static_assert (sv2.find_last_not_of( "", 0) == 0, "" ); static_assert (sv2.find_last_not_of( "", 0) == 0, "" );
static_assert (sv2.find_last_not_of( "gfsrt", 5) == 4, "" ); static_assert (sv2.find_last_not_of( "gfsrt", 5) == 4, "" );
static_assert (sv2.find_last_not_of( "lecar", 5) == 3, "" ); static_assert (sv2.find_last_not_of( "lecar", 5) == 3, "" );
} }
#endif #endif
} }

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

//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// The LLVM Compiler Infrastructure // The LLVM Compiler Infrastructure
// //
// This file is dual licensed under the MIT and the University of Illinois Open // This file is dual licensed under the MIT and the University of Illinois Open
// Source Licenses. See LICENSE.TXT for details. // Source Licenses. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// <string> // <string>
// constexpr size_type find_last_not_of(const charT* s, size_type pos, size_type n) const; // constexpr size_type find_last_not_of(const charT* s, size_type pos, size_type n) const;
#include <string_view> #include <string_view>
#include <cassert> #include <cassert>
#include "test_macros.h"
#include "constexpr_char_traits.hpp" #include "constexpr_char_traits.hpp"
template <class S> template <class S>
void void
test(const S& s, const typename S::value_type* str, typename S::size_type pos, test(const S& s, const typename S::value_type* str, typename S::size_type pos,
typename S::size_type n, typename S::size_type x) typename S::size_type n, typename S::size_type x)
{ {
assert(s.find_last_not_of(str, pos, n) == x); assert(s.find_last_not_of(str, pos, n) == x);
▲ Show 20 Lines • Show All 346 Lines • ▼ Show 20 Linesint main()
{ {
typedef std::string_view S; typedef std::string_view S;
test0<S>(); test0<S>();
test1<S>(); test1<S>();
test2<S>(); test2<S>();
test3<S>(); test3<S>();
} }
#if _LIBCPP_STD_VER > 11 #if TEST_STD_VER > 11
{ {
typedef std::basic_string_view<char, constexpr_char_traits<char>> SV; typedef std::basic_string_view<char, constexpr_char_traits<char>> SV;
constexpr SV sv1; constexpr SV sv1;
constexpr SV sv2 { "abcde", 5 }; constexpr SV sv2 { "abcde", 5 };
static_assert (sv1.find_last_not_of( "", 0, 0) == SV::npos, "" ); static_assert (sv1.find_last_not_of( "", 0, 0) == SV::npos, "" );
static_assert (sv1.find_last_not_of( "irkhs", 0, 5) == SV::npos, "" ); static_assert (sv1.find_last_not_of( "irkhs", 0, 5) == SV::npos, "" );
static_assert (sv2.find_last_not_of( "", 0, 0) == 0, "" ); static_assert (sv2.find_last_not_of( "", 0, 0) == 0, "" );
static_assert (sv2.find_last_not_of( "gfsrt", 5, 0) == 4, "" ); static_assert (sv2.find_last_not_of( "gfsrt", 5, 0) == 4, "" );
static_assert (sv2.find_last_not_of( "lecar", 5, 0) == 4, "" ); static_assert (sv2.find_last_not_of( "lecar", 5, 0) == 4, "" );
} }
#endif #endif
} }

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

//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// The LLVM Compiler Infrastructure // The LLVM Compiler Infrastructure
// //
// This file is dual licensed under the MIT and the University of Illinois Open // This file is dual licensed under the MIT and the University of Illinois Open
// Source Licenses. See LICENSE.TXT for details. // Source Licenses. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// <string_view> // <string_view>
// constexpr size_type find_last_of(charT c, size_type pos = npos) const; // constexpr size_type find_last_of(charT c, size_type pos = npos) const;
#include <string_view> #include <string_view>
#include <cassert> #include <cassert>
#include "test_macros.h"
#include "constexpr_char_traits.hpp" #include "constexpr_char_traits.hpp"
template <class S> template <class S>
void void
test(const S& s, typename S::value_type c, typename S::size_type pos, test(const S& s, typename S::value_type c, typename S::size_type pos,
typename S::size_type x) typename S::size_type x)
{ {
assert(s.find_last_of(c, pos) == x); assert(s.find_last_of(c, pos) == x);
Show All 36 Linesint main()
test(S("oselktgbcapndfjihrmq"), 'm', 21, 18); test(S("oselktgbcapndfjihrmq"), 'm', 21, 18);
test(S(""), 'm', S::npos); test(S(""), 'm', S::npos);
test(S("csope"), 'm', S::npos); test(S("csope"), 'm', S::npos);
test(S("gfsmthlkon"), 'm', 3); test(S("gfsmthlkon"), 'm', 3);
test(S("laenfsbridchgotmkqpj"), 'm', 15); test(S("laenfsbridchgotmkqpj"), 'm', 15);
} }
#if _LIBCPP_STD_VER > 11 #if TEST_STD_VER > 11
{ {
typedef std::basic_string_view<char, constexpr_char_traits<char>> SV; typedef std::basic_string_view<char, constexpr_char_traits<char>> SV;
constexpr SV sv1; constexpr SV sv1;
constexpr SV sv2 { "abcde", 5 }; constexpr SV sv2 { "abcde", 5 };
static_assert (sv1.find_last_of( 'i', 0 ) == SV::npos, "" ); static_assert (sv1.find_last_of( 'i', 0 ) == SV::npos, "" );
static_assert (sv1.find_last_of( 'i', 1 ) == SV::npos, "" ); static_assert (sv1.find_last_of( 'i', 1 ) == SV::npos, "" );
static_assert (sv2.find_last_of( 'a', 0 ) == 0, "" ); static_assert (sv2.find_last_of( 'a', 0 ) == 0, "" );
static_assert (sv2.find_last_of( 'a', 1 ) == 0, "" ); static_assert (sv2.find_last_of( 'a', 1 ) == 0, "" );
static_assert (sv2.find_last_of( 'e', 5 ) == 4, "" ); static_assert (sv2.find_last_of( 'e', 5 ) == 4, "" );
} }
#endif #endif
} }

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

//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// The LLVM Compiler Infrastructure // The LLVM Compiler Infrastructure
// //
// This file is dual licensed under the MIT and the University of Illinois Open // This file is dual licensed under the MIT and the University of Illinois Open
// Source Licenses. See LICENSE.TXT for details. // Source Licenses. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// <string_view> // <string_view>
// constexpr size_type find_last_of(const charT* s, size_type pos = npos) const; // constexpr size_type find_last_of(const charT* s, size_type pos = npos) const;
#include <string_view> #include <string_view>
#include <cassert> #include <cassert>
#include "test_macros.h"
#include "constexpr_char_traits.hpp" #include "constexpr_char_traits.hpp"
template <class S> template <class S>
void void
test(const S& s, const typename S::value_type* str, typename S::size_type pos, test(const S& s, const typename S::value_type* str, typename S::size_type pos,
typename S::size_type x) typename S::size_type x)
{ {
assert(s.find_last_of(str, pos) == x); assert(s.find_last_of(str, pos) == x);
▲ Show 20 Lines • Show All 119 Lines • ▼ Show 20 Lines
int main() int main()
{ {
{ {
typedef std::string_view S; typedef std::string_view S;
test0<S>(); test0<S>();
test1<S>(); test1<S>();
} }
#if _LIBCPP_STD_VER > 11 #if TEST_STD_VER > 11
{ {
typedef std::basic_string_view<char, constexpr_char_traits<char>> SV; typedef std::basic_string_view<char, constexpr_char_traits<char>> SV;
constexpr SV sv1; constexpr SV sv1;
constexpr SV sv2 { "abcde", 5 }; constexpr SV sv2 { "abcde", 5 };
static_assert (sv1.find_last_of( "", 0) == SV::npos, "" ); static_assert (sv1.find_last_of( "", 0) == SV::npos, "" );
static_assert (sv1.find_last_of( "irkhs", 5) == SV::npos, "" ); static_assert (sv1.find_last_of( "irkhs", 5) == SV::npos, "" );
static_assert (sv2.find_last_of( "", 0) == SV::npos, "" ); static_assert (sv2.find_last_of( "", 0) == SV::npos, "" );
static_assert (sv2.find_last_of( "gfsrt", 5) == SV::npos, "" ); static_assert (sv2.find_last_of( "gfsrt", 5) == SV::npos, "" );
static_assert (sv2.find_last_of( "lecar", 5) == 4, "" ); static_assert (sv2.find_last_of( "lecar", 5) == 4, "" );
} }
#endif #endif
} }

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

//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// The LLVM Compiler Infrastructure // The LLVM Compiler Infrastructure
// //
// This file is dual licensed under the MIT and the University of Illinois Open // This file is dual licensed under the MIT and the University of Illinois Open
// Source Licenses. See LICENSE.TXT for details. // Source Licenses. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// <string_view> // <string_view>
// constexpr size_type find_last_of(const charT* s, size_type pos, size_type n) const; // constexpr size_type find_last_of(const charT* s, size_type pos, size_type n) const;
#include <string_view> #include <string_view>
#include <cassert> #include <cassert>
#include "test_macros.h"
#include "constexpr_char_traits.hpp" #include "constexpr_char_traits.hpp"
template <class S> template <class S>
void void
test(const S& s, const typename S::value_type* str, typename S::size_type pos, test(const S& s, const typename S::value_type* str, typename S::size_type pos,
typename S::size_type n, typename S::size_type x) typename S::size_type n, typename S::size_type x)
{ {
assert(s.find_last_of(str, pos, n) == x); assert(s.find_last_of(str, pos, n) == x);
▲ Show 20 Lines • Show All 346 Lines • ▼ Show 20 Linesint main()
{ {
typedef std::string_view S; typedef std::string_view S;
test0<S>(); test0<S>();
test1<S>(); test1<S>();
test2<S>(); test2<S>();
test3<S>(); test3<S>();
} }
#if _LIBCPP_STD_VER > 11 #if TEST_STD_VER > 11
{ {
typedef std::basic_string_view<char, constexpr_char_traits<char>> SV; typedef std::basic_string_view<char, constexpr_char_traits<char>> SV;
constexpr SV sv1; constexpr SV sv1;
constexpr SV sv2 { "abcde", 5 }; constexpr SV sv2 { "abcde", 5 };
static_assert (sv1.find_last_of( "", 0, 0) == SV::npos, "" ); static_assert (sv1.find_last_of( "", 0, 0) == SV::npos, "" );
static_assert (sv1.find_last_of( "irkhs", 0, 5) == SV::npos, "" ); static_assert (sv1.find_last_of( "irkhs", 0, 5) == SV::npos, "" );
static_assert (sv2.find_last_of( "", 0, 0) == SV::npos, "" ); static_assert (sv2.find_last_of( "", 0, 0) == SV::npos, "" );
static_assert (sv2.find_last_of( "gfsrt", 5, 5) == SV::npos, "" ); static_assert (sv2.find_last_of( "gfsrt", 5, 5) == SV::npos, "" );
static_assert (sv2.find_last_of( "lecar", 5, 5) == 4, "" ); static_assert (sv2.find_last_of( "lecar", 5, 5) == 4, "" );
} }
#endif #endif
} }

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

//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// The LLVM Compiler Infrastructure // The LLVM Compiler Infrastructure
// //
// This file is dual licensed under the MIT and the University of Illinois Open // This file is dual licensed under the MIT and the University of Illinois Open
// Source Licenses. See LICENSE.TXT for details. // Source Licenses. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// <string> // <string>
// constexpr size_type find(const charT* s, size_type pos = 0) const; // constexpr size_type find(const charT* s, size_type pos = 0) const;
#include <string_view> #include <string_view>
#include <cassert> #include <cassert>
#include "test_macros.h"
#include "constexpr_char_traits.hpp" #include "constexpr_char_traits.hpp"
template <class S> template <class S>
void void
test(const S& s, const typename S::value_type* str, typename S::size_type pos, test(const S& s, const typename S::value_type* str, typename S::size_type pos,
typename S::size_type x) typename S::size_type x)
{ {
assert(s.find(str, pos) == x); assert(s.find(str, pos) == x);
▲ Show 20 Lines • Show All 125 Lines • ▼ Show 20 Lines
int main() int main()
{ {
{ {
typedef std::string_view S; typedef std::string_view S;
test0<S>(); test0<S>();
test1<S>(); test1<S>();
} }
#if _LIBCPP_STD_VER > 11 #if TEST_STD_VER > 11
{ {
typedef std::basic_string_view<char, constexpr_char_traits<char>> SV; typedef std::basic_string_view<char, constexpr_char_traits<char>> SV;
constexpr SV sv1; constexpr SV sv1;
constexpr SV sv2 { "abcde", 5 }; constexpr SV sv2 { "abcde", 5 };
static_assert (sv1.find( "") == 0, "" ); static_assert (sv1.find( "") == 0, "" );
static_assert (sv1.find( "abcde") == SV::npos, "" ); static_assert (sv1.find( "abcde") == SV::npos, "" );
static_assert (sv2.find( "") == 0, "" ); static_assert (sv2.find( "") == 0, "" );
static_assert (sv2.find( "abcde") == 0, "" ); static_assert (sv2.find( "abcde") == 0, "" );
static_assert (sv2.find( "abcde", 1) == SV::npos, "" ); static_assert (sv2.find( "abcde", 1) == SV::npos, "" );
} }
#endif #endif
} }

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

//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// The LLVM Compiler Infrastructure // The LLVM Compiler Infrastructure
// //
// This file is dual licensed under the MIT and the University of Illinois Open // This file is dual licensed under the MIT and the University of Illinois Open
// Source Licenses. See LICENSE.TXT for details. // Source Licenses. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// <string_view> // <string_view>
// constexpr size_type find(const charT* s, size_type pos, size_type n) const; // constexpr size_type find(const charT* s, size_type pos, size_type n) const;
#include <string_view> #include <string_view>
#include <cassert> #include <cassert>
#include "test_macros.h"
#include "constexpr_char_traits.hpp" #include "constexpr_char_traits.hpp"
template <class S> template <class S>
void void
test(const S& s, const typename S::value_type* str, typename S::size_type pos, test(const S& s, const typename S::value_type* str, typename S::size_type pos,
typename S::size_type n, typename S::size_type x) typename S::size_type n, typename S::size_type x)
{ {
assert(s.find(str, pos, n) == x); assert(s.find(str, pos, n) == x);
▲ Show 20 Lines • Show All 346 Lines • ▼ Show 20 Linesint main()
{ {
typedef std::string_view S; typedef std::string_view S;
test0<S>(); test0<S>();
test1<S>(); test1<S>();
test2<S>(); test2<S>();
test3<S>(); test3<S>();
} }
#if _LIBCPP_STD_VER > 11 #if TEST_STD_VER > 11
{ {
typedef std::basic_string_view<char, constexpr_char_traits<char>> SV; typedef std::basic_string_view<char, constexpr_char_traits<char>> SV;
constexpr SV sv1; constexpr SV sv1;
constexpr SV sv2 { "abcde", 5 }; constexpr SV sv2 { "abcde", 5 };
static_assert (sv1.find( "", 0, 0 ) == 0, "" ); static_assert (sv1.find( "", 0, 0 ) == 0, "" );
static_assert (sv1.find( "abcde", 0, 0 ) == 0, "" ); static_assert (sv1.find( "abcde", 0, 0 ) == 0, "" );
static_assert (sv1.find( "abcde", 0, 1 ) == SV::npos, "" ); static_assert (sv1.find( "abcde", 0, 1 ) == SV::npos, "" );
static_assert (sv2.find( "", 0, 0 ) == 0, "" ); static_assert (sv2.find( "", 0, 0 ) == 0, "" );
static_assert (sv2.find( "abcde", 0, 0 ) == 0, "" ); static_assert (sv2.find( "abcde", 0, 0 ) == 0, "" );
static_assert (sv2.find( "abcde", 0, 1 ) == 0, "" ); static_assert (sv2.find( "abcde", 0, 1 ) == 0, "" );
} }
#endif #endif
} }

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

//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// The LLVM Compiler Infrastructure // The LLVM Compiler Infrastructure
// //
// This file is dual licensed under the MIT and the University of Illinois Open // This file is dual licensed under the MIT and the University of Illinois Open
// Source Licenses. See LICENSE.TXT for details. // Source Licenses. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// <string_view> // <string_view>
// constexpr size_type find(const basic_string_view& str, size_type pos = 0) const; // constexpr size_type find(const basic_string_view& str, size_type pos = 0) const;
#include <string_view> #include <string_view>
#include <cassert> #include <cassert>
#include "test_macros.h"
#include "constexpr_char_traits.hpp" #include "constexpr_char_traits.hpp"
template <class S> template <class S>
void void
test(const S& s, const S& str, typename S::size_type pos, typename S::size_type x) test(const S& s, const S& str, typename S::size_type pos, typename S::size_type x)
{ {
assert(s.find(str, pos) == x); assert(s.find(str, pos) == x);
if (x != S::npos) if (x != S::npos)
▲ Show 20 Lines • Show All 118 Lines • ▼ Show 20 Lines
int main() int main()
{ {
{ {
typedef std::string_view S; typedef std::string_view S;
test0<S>(); test0<S>();
test1<S>(); test1<S>();
} }
#if _LIBCPP_STD_VER > 11 #if TEST_STD_VER > 11
{ {
typedef std::basic_string_view<char, constexpr_char_traits<char>> SV; typedef std::basic_string_view<char, constexpr_char_traits<char>> SV;
constexpr SV sv1; constexpr SV sv1;
constexpr SV sv2 { "abcde", 5 }; constexpr SV sv2 { "abcde", 5 };
static_assert (sv1.find(sv1) == 0, "" ); static_assert (sv1.find(sv1) == 0, "" );
static_assert (sv1.find(sv2) == SV::npos, "" ); static_assert (sv1.find(sv2) == SV::npos, "" );
static_assert (sv2.find(sv1) == 0, "" ); static_assert (sv2.find(sv1) == 0, "" );
static_assert (sv2.find(sv2) == 0, "" ); static_assert (sv2.find(sv2) == 0, "" );
static_assert (sv2.find(sv2, 1 ) == SV::npos, "" ); static_assert (sv2.find(sv2, 1 ) == SV::npos, "" );
} }
#endif #endif
} }

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

//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// The LLVM Compiler Infrastructure // The LLVM Compiler Infrastructure
// //
// This file is dual licensed under the MIT and the University of Illinois Open // This file is dual licensed under the MIT and the University of Illinois Open
// Source Licenses. See LICENSE.TXT for details. // Source Licenses. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// <string_view> // <string_view>
// constexpr size_type rfind(charT c, size_type pos = npos) const; // constexpr size_type rfind(charT c, size_type pos = npos) const;
#include <string_view> #include <string_view>
#include <cassert> #include <cassert>
#include "test_macros.h"
#include "constexpr_char_traits.hpp" #include "constexpr_char_traits.hpp"
template <class S> template <class S>
void void
test(const S& s, typename S::value_type c, typename S::size_type pos, test(const S& s, typename S::value_type c, typename S::size_type pos,
typename S::size_type x) typename S::size_type x)
{ {
assert(s.rfind(c, pos) == x); assert(s.rfind(c, pos) == x);
Show All 36 Linesint main()
test(S("abcdeabcdeabcdeabcde"), 'b', 21, 16); test(S("abcdeabcdeabcdeabcde"), 'b', 21, 16);
test(S(""), 'b', S::npos); test(S(""), 'b', S::npos);
test(S("abcde"), 'b', 1); test(S("abcde"), 'b', 1);
test(S("abcdeabcde"), 'b', 6); test(S("abcdeabcde"), 'b', 6);
test(S("abcdeabcdeabcdeabcde"), 'b', 16); test(S("abcdeabcdeabcdeabcde"), 'b', 16);
} }
#if _LIBCPP_STD_VER > 11 #if TEST_STD_VER > 11
{ {
typedef std::basic_string_view<char, constexpr_char_traits<char>> SV; typedef std::basic_string_view<char, constexpr_char_traits<char>> SV;
constexpr SV sv1; constexpr SV sv1;
constexpr SV sv2 { "abcde", 5 }; constexpr SV sv2 { "abcde", 5 };
static_assert (sv1.rfind( 'b', 0 ) == SV::npos, "" ); static_assert (sv1.rfind( 'b', 0 ) == SV::npos, "" );
static_assert (sv1.rfind( 'b', 1 ) == SV::npos, "" ); static_assert (sv1.rfind( 'b', 1 ) == SV::npos, "" );
static_assert (sv2.rfind( 'b', 0 ) == SV::npos, "" ); static_assert (sv2.rfind( 'b', 0 ) == SV::npos, "" );
static_assert (sv2.rfind( 'b', 1 ) == 1, "" ); static_assert (sv2.rfind( 'b', 1 ) == 1, "" );
static_assert (sv2.rfind( 'b', 2 ) == 1, "" ); static_assert (sv2.rfind( 'b', 2 ) == 1, "" );
static_assert (sv2.rfind( 'b', 3 ) == 1, "" ); static_assert (sv2.rfind( 'b', 3 ) == 1, "" );
static_assert (sv2.rfind( 'b', 4 ) == 1, "" ); static_assert (sv2.rfind( 'b', 4 ) == 1, "" );
} }
#endif #endif
} }

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

//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// The LLVM Compiler Infrastructure // The LLVM Compiler Infrastructure
// //
// This file is dual licensed under the MIT and the University of Illinois Open // This file is dual licensed under the MIT and the University of Illinois Open
// Source Licenses. See LICENSE.TXT for details. // Source Licenses. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// <string_view> // <string_view>
// constexpr size_type rfind(const charT* s, size_type pos = npos) const; // constexpr size_type rfind(const charT* s, size_type pos = npos) const;
#include <string_view> #include <string_view>
#include <cassert> #include <cassert>
#include "test_macros.h"
#include "constexpr_char_traits.hpp" #include "constexpr_char_traits.hpp"
template <class S> template <class S>
void void
test(const S& s, const typename S::value_type* str, typename S::size_type pos, test(const S& s, const typename S::value_type* str, typename S::size_type pos,
typename S::size_type x) typename S::size_type x)
{ {
assert(s.rfind(str, pos) == x); assert(s.rfind(str, pos) == x);
▲ Show 20 Lines • Show All 126 Lines • ▼ Show 20 Lines
int main() int main()
{ {
{ {
typedef std::string_view S; typedef std::string_view S;
test0<S>(); test0<S>();
test1<S>(); test1<S>();
} }
#if _LIBCPP_STD_VER > 11 #if TEST_STD_VER > 11
{ {
typedef std::basic_string_view<char, constexpr_char_traits<char>> SV; typedef std::basic_string_view<char, constexpr_char_traits<char>> SV;
constexpr SV sv1; constexpr SV sv1;
constexpr SV sv2 { "abcde", 5 }; constexpr SV sv2 { "abcde", 5 };
static_assert (sv1.rfind( "") == 0, "" ); static_assert (sv1.rfind( "") == 0, "" );
static_assert (sv1.rfind( "abcde") == SV::npos, "" ); static_assert (sv1.rfind( "abcde") == SV::npos, "" );
static_assert (sv2.rfind( "") == 5, "" ); static_assert (sv2.rfind( "") == 5, "" );
static_assert (sv2.rfind( "abcde") == 0, "" ); static_assert (sv2.rfind( "abcde") == 0, "" );
static_assert (sv2.rfind( "abcde", 1) == 0, "" ); static_assert (sv2.rfind( "abcde", 1) == 0, "" );
} }
#endif #endif
} }

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

//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// The LLVM Compiler Infrastructure // The LLVM Compiler Infrastructure
// //
// This file is dual licensed under the MIT and the University of Illinois Open // This file is dual licensed under the MIT and the University of Illinois Open
// Source Licenses. See LICENSE.TXT for details. // Source Licenses. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// <string_view> // <string_view>
// constexpr size_type rfind(const charT* s, size_type pos, size_type n) const; // constexpr size_type rfind(const charT* s, size_type pos, size_type n) const;
#include <string_view> #include <string_view>
#include <cassert> #include <cassert>
#include "test_macros.h"
#include "constexpr_char_traits.hpp" #include "constexpr_char_traits.hpp"
template <class S> template <class S>
void void
test(const S& s, const typename S::value_type* str, typename S::size_type pos, test(const S& s, const typename S::value_type* str, typename S::size_type pos,
typename S::size_type n, typename S::size_type x) typename S::size_type n, typename S::size_type x)
{ {
assert(s.rfind(str, pos, n) == x); assert(s.rfind(str, pos, n) == x);
▲ Show 20 Lines • Show All 346 Lines • ▼ Show 20 Linesint main()
{ {
typedef std::string_view S; typedef std::string_view S;
test0<S>(); test0<S>();
test1<S>(); test1<S>();
test2<S>(); test2<S>();
test3<S>(); test3<S>();
} }
#if _LIBCPP_STD_VER > 11 #if TEST_STD_VER > 11
{ {
typedef std::basic_string_view<char, constexpr_char_traits<char>> SV; typedef std::basic_string_view<char, constexpr_char_traits<char>> SV;
constexpr SV sv1; constexpr SV sv1;
constexpr SV sv2 { "abcde", 5 }; constexpr SV sv2 { "abcde", 5 };
static_assert (sv1.rfind( "", 0, 0 ) == 0, "" ); static_assert (sv1.rfind( "", 0, 0 ) == 0, "" );
static_assert (sv1.rfind( "abcde", 0, 0 ) == 0, "" ); static_assert (sv1.rfind( "abcde", 0, 0 ) == 0, "" );
static_assert (sv1.rfind( "abcde", 0, 1 ) == SV::npos, "" ); static_assert (sv1.rfind( "abcde", 0, 1 ) == SV::npos, "" );
static_assert (sv2.rfind( "", 0, 0 ) == 0, "" ); static_assert (sv2.rfind( "", 0, 0 ) == 0, "" );
static_assert (sv2.rfind( "abcde", 0, 0 ) == 0, "" ); static_assert (sv2.rfind( "abcde", 0, 0 ) == 0, "" );
static_assert (sv2.rfind( "abcde", 0, 1 ) == 0, "" ); static_assert (sv2.rfind( "abcde", 0, 1 ) == 0, "" );
} }
#endif #endif
} }

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

//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// The LLVM Compiler Infrastructure // The LLVM Compiler Infrastructure
// //
// This file is dual licensed under the MIT and the University of Illinois Open // This file is dual licensed under the MIT and the University of Illinois Open
// Source Licenses. See LICENSE.TXT for details. // Source Licenses. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// <string_view> // <string_view>
// constexpr size_type rfind(const basic_string& str, size_type pos = npos) const; // constexpr size_type rfind(const basic_string& str, size_type pos = npos) const;
#include <string_view> #include <string_view>
#include <cassert> #include <cassert>
#include "test_macros.h"
#include "constexpr_char_traits.hpp" #include "constexpr_char_traits.hpp"
template <class S> template <class S>
void void
test(const S& s, const S& str, typename S::size_type pos, typename S::size_type x) test(const S& s, const S& str, typename S::size_type pos, typename S::size_type x)
{ {
assert(s.rfind(str, pos) == x); assert(s.rfind(str, pos) == x);
if (x != S::npos) if (x != S::npos)
▲ Show 20 Lines • Show All 118 Lines • ▼ Show 20 Lines
int main() int main()
{ {
{ {
typedef std::string_view S; typedef std::string_view S;
test0<S>(); test0<S>();
test1<S>(); test1<S>();
} }
#if _LIBCPP_STD_VER > 11 #if TEST_STD_VER > 11
{ {
typedef std::basic_string_view<char, constexpr_char_traits<char>> SV; typedef std::basic_string_view<char, constexpr_char_traits<char>> SV;
constexpr SV sv1; constexpr SV sv1;
constexpr SV sv2 { "abcde", 5 }; constexpr SV sv2 { "abcde", 5 };
static_assert (sv1.rfind(sv1) == 0, "" ); static_assert (sv1.rfind(sv1) == 0, "" );
static_assert (sv1.rfind(sv2) == SV::npos, "" ); static_assert (sv1.rfind(sv2) == SV::npos, "" );
static_assert (sv2.rfind(sv1) == 5, "" ); static_assert (sv2.rfind(sv1) == 5, "" );
static_assert (sv2.rfind(sv2) == 0, "" ); static_assert (sv2.rfind(sv2) == 0, "" );
static_assert (sv2.rfind(sv2, 1) == 0, "" ); static_assert (sv2.rfind(sv2, 1) == 0, "" );
} }
#endif #endif
} }

test/std/strings/string.view/string.view.iterators/begin.pass.cpp

Show First 20 Lines • Show All 52 Lines • ▼ Show 20 Linesint main()
test(wstring_view ()); test(wstring_view ());
test(string_view ( "123")); test(string_view ( "123"));
test(wstring_view (L"123")); test(wstring_view (L"123"));
#if TEST_STD_VER >= 11 #if TEST_STD_VER >= 11
test(u16string_view{u"123"}); test(u16string_view{u"123"});
test(u32string_view{U"123"}); test(u32string_view{U"123"});
#endif #endif
#if _LIBCPP_STD_VER > 11 #if TEST_STD_VER > 11
{ {
constexpr string_view sv { "123", 3 }; constexpr string_view sv { "123", 3 };
constexpr u16string_view u16sv {u"123", 3 }; constexpr u16string_view u16sv {u"123", 3 };
constexpr u32string_view u32sv {U"123", 3 }; constexpr u32string_view u32sv {U"123", 3 };
constexpr wstring_view wsv {L"123", 3 }; constexpr wstring_view wsv {L"123", 3 };
static_assert ( *sv.begin() == sv[0], "" ); static_assert ( *sv.begin() == sv[0], "" );
static_assert ( *u16sv.begin() == u16sv[0], "" ); static_assert ( *u16sv.begin() == u16sv[0], "" );
Show All 10 Lines

test/std/strings/string.view/string.view.iterators/end.pass.cpp

Show First 20 Lines • Show All 60 Lines • ▼ Show 20 Linesint main()
test(wstring_view ()); test(wstring_view ());
test(string_view ( "123")); test(string_view ( "123"));
test(wstring_view (L"123")); test(wstring_view (L"123"));
#if TEST_STD_VER >= 11 #if TEST_STD_VER >= 11
test(u16string_view{u"123"}); test(u16string_view{u"123"});
test(u32string_view{U"123"}); test(u32string_view{U"123"});
#endif #endif
#if _LIBCPP_STD_VER > 11 #if TEST_STD_VER > 11
{ {
constexpr string_view sv { "123", 3 }; constexpr string_view sv { "123", 3 };
constexpr u16string_view u16sv {u"123", 3 }; constexpr u16string_view u16sv {u"123", 3 };
constexpr u32string_view u32sv {U"123", 3 }; constexpr u32string_view u32sv {U"123", 3 };
constexpr wstring_view wsv {L"123", 3 }; constexpr wstring_view wsv {L"123", 3 };
static_assert ( sv.begin() != sv.end(), "" ); static_assert ( sv.begin() != sv.end(), "" );
static_assert ( u16sv.begin() != u16sv.end(), "" ); static_assert ( u16sv.begin() != u16sv.end(), "" );
Show All 10 Lines

test/std/strings/string.view/string.view.modifiers/clear.pass.cpp

Show All 26 Linesvoid test ( const CharT *s, size_t len ) {
sv1.clear (); sv1.clear ();
assert ( sv1.data() == nullptr ); assert ( sv1.data() == nullptr );
assert ( sv1.size() == 0 ); assert ( sv1.size() == 0 );
assert ( sv1 == SV()); assert ( sv1 == SV());
} }
} }
#if _LIBCPP_STD_VER > 11 #if TEST_STD_VER > 11
constexpr size_t test_ce ( size_t n ) { constexpr size_t test_ce ( size_t n ) {
typedef std::basic_string_view<char> SV; typedef std::basic_string_view<char> SV;
SV sv1{ "ABCDEFGHIJKL", n }; SV sv1{ "ABCDEFGHIJKL", n };
sv1.clear(); sv1.clear();
return sv1.size(); return sv1.size();
} }
#endif #endif
Show All 11 Lines#if TEST_STD_VER >= 11
test ( u"a", 1 ); test ( u"a", 1 );
test ( u"", 0 ); test ( u"", 0 );
test ( U"ABCDE", 5 ); test ( U"ABCDE", 5 );
test ( U"a", 1 ); test ( U"a", 1 );
test ( U"", 0 ); test ( U"", 0 );
#endif #endif
#if _LIBCPP_STD_VER > 11 #if TEST_STD_VER > 11
static_assert ( test_ce (5) == 0, "" ); static_assert ( test_ce (5) == 0, "" );
#endif #endif
} }

test/std/strings/string.view/string.view.modifiers/remove_prefix.pass.cpp

Show All 33 Linesvoid test ( const CharT *s, size_t len ) {
} }
assert ( sv1.size() == 0 ); assert ( sv1.size() == 0 );
sv1.remove_prefix ( 0 ); sv1.remove_prefix ( 0 );
assert ( sv1.size() == 0 ); assert ( sv1.size() == 0 );
} }
} }
#if _LIBCPP_STD_VER > 11 #if TEST_STD_VER > 11
constexpr size_t test_ce ( size_t n, size_t k ) { constexpr size_t test_ce ( size_t n, size_t k ) {
typedef std::basic_string_view<char> SV; typedef std::basic_string_view<char> SV;
SV sv1{ "ABCDEFGHIJKL", n }; SV sv1{ "ABCDEFGHIJKL", n };
sv1.remove_prefix ( k ); sv1.remove_prefix ( k );
return sv1.size(); return sv1.size();
} }
#endif #endif
Show All 11 Lines#if TEST_STD_VER >= 11
test ( u"a", 1 ); test ( u"a", 1 );
test ( u"", 0 ); test ( u"", 0 );
test ( U"ABCDE", 5 ); test ( U"ABCDE", 5 );
test ( U"a", 1 ); test ( U"a", 1 );
test ( U"", 0 ); test ( U"", 0 );
#endif #endif
#if _LIBCPP_STD_VER > 11 #if TEST_STD_VER > 11
{ {
static_assert ( test_ce ( 5, 0 ) == 5, "" ); static_assert ( test_ce ( 5, 0 ) == 5, "" );
static_assert ( test_ce ( 5, 1 ) == 4, "" ); static_assert ( test_ce ( 5, 1 ) == 4, "" );
static_assert ( test_ce ( 5, 5 ) == 0, "" ); static_assert ( test_ce ( 5, 5 ) == 0, "" );
static_assert ( test_ce ( 9, 3 ) == 6, "" ); static_assert ( test_ce ( 9, 3 ) == 6, "" );
} }
#endif #endif
} }

test/std/strings/string.view/string.view.modifiers/remove_suffix.pass.cpp

Show All 33 Linesvoid test ( const CharT *s, size_t len ) {
assert ( sv1.size() == 0 ); assert ( sv1.size() == 0 );
sv1.remove_suffix ( 0 ); sv1.remove_suffix ( 0 );
assert ( sv1.size() == 0 ); assert ( sv1.size() == 0 );
} }
} }
#if _LIBCPP_STD_VER > 11 #if TEST_STD_VER > 11
constexpr size_t test_ce ( size_t n, size_t k ) { constexpr size_t test_ce ( size_t n, size_t k ) {
typedef std::basic_string_view<char> SV; typedef std::basic_string_view<char> SV;
SV sv1{ "ABCDEFGHIJKL", n }; SV sv1{ "ABCDEFGHIJKL", n };
sv1.remove_suffix ( k ); sv1.remove_suffix ( k );
return sv1.size(); return sv1.size();
} }
#endif #endif
Show All 11 Lines#if TEST_STD_VER >= 11
test ( u"a", 1 ); test ( u"a", 1 );
test ( u"", 0 ); test ( u"", 0 );
test ( U"ABCDE", 5 ); test ( U"ABCDE", 5 );
test ( U"a", 1 ); test ( U"a", 1 );
test ( U"", 0 ); test ( U"", 0 );
#endif #endif
#if _LIBCPP_STD_VER > 11 #if TEST_STD_VER > 11
{ {
static_assert ( test_ce ( 5, 0 ) == 5, "" ); static_assert ( test_ce ( 5, 0 ) == 5, "" );
static_assert ( test_ce ( 5, 1 ) == 4, "" ); static_assert ( test_ce ( 5, 1 ) == 4, "" );
static_assert ( test_ce ( 5, 5 ) == 0, "" ); static_assert ( test_ce ( 5, 5 ) == 0, "" );
static_assert ( test_ce ( 9, 3 ) == 6, "" ); static_assert ( test_ce ( 9, 3 ) == 6, "" );
} }
#endif #endif
} }

test/std/strings/string.view/string.view.modifiers/swap.pass.cpp

Show All 30 Linesvoid test ( const CharT *s, size_t len ) {
sv1.swap ( sv2 ); sv1.swap ( sv2 );
assert ( sv1.size() == 0 ); assert ( sv1.size() == 0 );
assert ( sv2.size() == len ); assert ( sv2.size() == len );
assert ( sv2.data() == s ); assert ( sv2.data() == s );
} }
} }
#if _LIBCPP_STD_VER > 11 #if TEST_STD_VER > 11
constexpr size_t test_ce ( size_t n, size_t k ) { constexpr size_t test_ce ( size_t n, size_t k ) {
typedef std::basic_string_view<char> SV; typedef std::basic_string_view<char> SV;
SV sv1{ "ABCDEFGHIJKL", n }; SV sv1{ "ABCDEFGHIJKL", n };
SV sv2 { sv1.data(), k }; SV sv2 { sv1.data(), k };
sv1.swap ( sv2 ); sv1.swap ( sv2 );
return sv1.size(); return sv1.size();
} }
#endif #endif
Show All 13 Lines#if TEST_STD_VER >= 11
test ( u"a", 1 ); test ( u"a", 1 );
test ( u"", 0 ); test ( u"", 0 );
test ( U"ABCDE", 5 ); test ( U"ABCDE", 5 );
test ( U"a", 1 ); test ( U"a", 1 );
test ( U"", 0 ); test ( U"", 0 );
#endif #endif
#if _LIBCPP_STD_VER > 11 #if TEST_STD_VER > 11
{ {
static_assert ( test_ce (2, 3) == 3, "" ); static_assert ( test_ce (2, 3) == 3, "" );
static_assert ( test_ce (5, 3) == 3, "" ); static_assert ( test_ce (5, 3) == 3, "" );
static_assert ( test_ce (0, 1) == 1, "" ); static_assert ( test_ce (0, 1) == 1, "" );
} }
#endif #endif
} }

test/std/strings/string.view/string.view.nonmem/quoted.pass.cpp

Show All 10 Lines
// quoted // quoted
#include <iomanip> #include <iomanip>
#include <sstream> #include <sstream>
#include <string_view> #include <string_view>
#include <cassert> #include <cassert>
#if _LIBCPP_STD_VER > 11 #include "test_macros.h"
#if TEST_STD_VER > 11
// quoted is C++14 only // quoted is C++14 only
bool is_skipws ( const std::istream *is ) { bool is_skipws ( const std::istream *is ) {
return ( is->flags() & std::ios_base::skipws ) != 0; return ( is->flags() & std::ios_base::skipws ) != 0;
} }
bool is_skipws ( const std::wistream *is ) { bool is_skipws ( const std::wistream *is ) {
▲ Show 20 Lines • Show All 185 Lines • Show Last 20 Lines

test/std/strings/string.view/string.view.ops/compare.pointer.pass.cpp

//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// The LLVM Compiler Infrastructure // The LLVM Compiler Infrastructure
// //
// This file is dual licensed under the MIT and the University of Illinois Open // This file is dual licensed under the MIT and the University of Illinois Open
// Source Licenses. See LICENSE.TXT for details. // Source Licenses. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// <string_view> // <string_view>
// constexpr int compare(const charT* s) const; // constexpr int compare(const charT* s) const;
#include <string_view> #include <string_view>
#include <cassert> #include <cassert>
#include "test_macros.h"
#include "constexpr_char_traits.hpp" #include "constexpr_char_traits.hpp"
int sign ( int x ) { return x > 0 ? 1 : ( x < 0 ? -1 : 0 ); } int sign ( int x ) { return x > 0 ? 1 : ( x < 0 ? -1 : 0 ); }
template<typename CharT> template<typename CharT>
void test1 ( std::basic_string_view<CharT> sv1, const CharT *s, int expected ) { void test1 ( std::basic_string_view<CharT> sv1, const CharT *s, int expected ) {
assert ( sign( sv1.compare(s)) == sign(expected)); assert ( sign( sv1.compare(s)) == sign(expected));
} }
▲ Show 20 Lines • Show All 82 Lines • ▼ Show 20 Lines#if TEST_STD_VER >= 11
test(u"abcdefghij", u"abcdefghijklmnopqrst", -10); test(u"abcdefghij", u"abcdefghijklmnopqrst", -10);
test(u"abcdefghijklmnopqrst", u"", 20); test(u"abcdefghijklmnopqrst", u"", 20);
test(u"abcdefghijklmnopqrst", u"abcde", 15); test(u"abcdefghijklmnopqrst", u"abcde", 15);
test(u"abcdefghijklmnopqrst", u"abcdefghij", 10); test(u"abcdefghijklmnopqrst", u"abcdefghij", 10);
test(u"abcdefghijklmnopqrst", u"abcdefghijklmnopqrst", 0); test(u"abcdefghijklmnopqrst", u"abcdefghijklmnopqrst", 0);
} }
#endif #endif
#if _LIBCPP_STD_VER > 11 #if TEST_STD_VER > 11
{ {
typedef std::basic_string_view<char, constexpr_char_traits<char>> SV; typedef std::basic_string_view<char, constexpr_char_traits<char>> SV;
constexpr SV sv1; constexpr SV sv1;
constexpr SV sv2 { "abcde", 5 }; constexpr SV sv2 { "abcde", 5 };
static_assert ( sv1.compare("") == 0, "" ); static_assert ( sv1.compare("") == 0, "" );
static_assert ( sv1.compare("abcde") == -1, "" ); static_assert ( sv1.compare("abcde") == -1, "" );
static_assert ( sv2.compare("") == 1, "" ); static_assert ( sv2.compare("") == 1, "" );
static_assert ( sv2.compare("abcde") == 0, "" ); static_assert ( sv2.compare("abcde") == 0, "" );
} }
#endif #endif
} }

test/std/strings/string.view/string.view.ops/compare.sv.pass.cpp

//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// The LLVM Compiler Infrastructure // The LLVM Compiler Infrastructure
// //
// This file is dual licensed under the MIT and the University of Illinois Open // This file is dual licensed under the MIT and the University of Illinois Open
// Source Licenses. See LICENSE.TXT for details. // Source Licenses. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// <string_view> // <string_view>
// constexpr int compare(basic_string_view str) const noexcept; // constexpr int compare(basic_string_view str) const noexcept;
#include <string_view> #include <string_view>
#include <cassert> #include <cassert>
#include "test_macros.h"
#include "constexpr_char_traits.hpp" #include "constexpr_char_traits.hpp"
int sign ( int x ) { return x > 0 ? 1 : ( x < 0 ? -1 : 0 ); } int sign ( int x ) { return x > 0 ? 1 : ( x < 0 ? -1 : 0 ); }
template<typename CharT> template<typename CharT>
void test1 ( std::basic_string_view<CharT> sv1, void test1 ( std::basic_string_view<CharT> sv1,
std::basic_string_view<CharT> sv2, int expected ) { std::basic_string_view<CharT> sv2, int expected ) {
assert ( sign( sv1.compare(sv2)) == sign(expected)); assert ( sign( sv1.compare(sv2)) == sign(expected));
▲ Show 20 Lines • Show All 76 Lines • ▼ Show 20 Lines#if TEST_STD_VER >= 11
test(U"abcdefghij", U"abcdefghij", 0); test(U"abcdefghij", U"abcdefghij", 0);
test(U"abcdefghij", U"abcdefghijklmnopqrst", -10); test(U"abcdefghij", U"abcdefghijklmnopqrst", -10);
test(U"abcdefghijklmnopqrst", U"", 20); test(U"abcdefghijklmnopqrst", U"", 20);
test(U"abcdefghijklmnopqrst", U"abcde", 15); test(U"abcdefghijklmnopqrst", U"abcde", 15);
test(U"abcdefghijklmnopqrst", U"abcdefghij", 10); test(U"abcdefghijklmnopqrst", U"abcdefghij", 10);
test(U"abcdefghijklmnopqrst", U"abcdefghijklmnopqrst", 0); test(U"abcdefghijklmnopqrst", U"abcdefghijklmnopqrst", 0);
#endif #endif
#if _LIBCPP_STD_VER > 11 #if TEST_STD_VER > 11
{ {
typedef std::basic_string_view<char, constexpr_char_traits<char>> SV; typedef std::basic_string_view<char, constexpr_char_traits<char>> SV;
constexpr SV sv1 { "abcde", 5 }; constexpr SV sv1 { "abcde", 5 };
constexpr SV sv2 { "abcde", 5 }; constexpr SV sv2 { "abcde", 5 };
constexpr SV sv3 { "edcba0", 6 }; constexpr SV sv3 { "edcba0", 6 };
static_assert ( sv1.compare(sv2) == 0, "" ); static_assert ( sv1.compare(sv2) == 0, "" );
static_assert ( sv2.compare(sv1) == 0, "" ); static_assert ( sv2.compare(sv1) == 0, "" );
static_assert ( sv3.compare(sv2) > 0, "" ); static_assert ( sv3.compare(sv2) > 0, "" );
static_assert ( sv2.compare(sv3) < 0, "" ); static_assert ( sv2.compare(sv3) < 0, "" );
} }
#endif #endif
} }

test/std/utilities/function.objects/arithmetic.operations/divides.pass.cpp

Show All 9 Lines
// <functional> // <functional>
// divides // divides
#include <functional> #include <functional>
#include <type_traits> #include <type_traits>
#include <cassert> #include <cassert>
#include "test_macros.h"
int main() int main()
{ {
typedef std::divides<int> F; typedef std::divides<int> F;
const F f = F(); const F f = F();
static_assert((std::is_same<int, F::first_argument_type>::value), "" ); static_assert((std::is_same<int, F::first_argument_type>::value), "" );
static_assert((std::is_same<int, F::second_argument_type>::value), "" ); static_assert((std::is_same<int, F::second_argument_type>::value), "" );
static_assert((std::is_same<int, F::result_type>::value), "" ); static_assert((std::is_same<int, F::result_type>::value), "" );
assert(f(36, 4) == 9); assert(f(36, 4) == 9);
#if _LIBCPP_STD_VER > 11 #if TEST_STD_VER > 11
typedef std::divides<> F2; typedef std::divides<> F2;
const F2 f2 = F2(); const F2 f2 = F2();
assert(f2(36, 4) == 9); assert(f2(36, 4) == 9);
assert(f2(36.0, 4) == 9); assert(f2(36.0, 4) == 9);
assert(f2(18, 4.0) == 4.5); // exact in binary assert(f2(18, 4.0) == 4.5); // exact in binary
constexpr int foo = std::divides<int> () (3, 2); constexpr int foo = std::divides<int> () (3, 2);
static_assert ( foo == 1, "" ); static_assert ( foo == 1, "" );
constexpr int bar = std::divides<> () (3.0, 2); constexpr int bar = std::divides<> () (3.0, 2);
static_assert ( bar == 1, "" ); static_assert ( bar == 1, "" );
#endif #endif
} }

test/std/utilities/function.objects/arithmetic.operations/minus.pass.cpp

Show All 9 Lines
// <functional> // <functional>
// minus // minus
#include <functional> #include <functional>
#include <type_traits> #include <type_traits>
#include <cassert> #include <cassert>
#include "test_macros.h"
int main() int main()
{ {
typedef std::minus<int> F; typedef std::minus<int> F;
const F f = F(); const F f = F();
static_assert((std::is_same<int, F::first_argument_type>::value), "" ); static_assert((std::is_same<int, F::first_argument_type>::value), "" );
static_assert((std::is_same<int, F::second_argument_type>::value), "" ); static_assert((std::is_same<int, F::second_argument_type>::value), "" );
static_assert((std::is_same<int, F::result_type>::value), "" ); static_assert((std::is_same<int, F::result_type>::value), "" );
assert(f(3, 2) == 1); assert(f(3, 2) == 1);
#if _LIBCPP_STD_VER > 11 #if TEST_STD_VER > 11
typedef std::minus<> F2; typedef std::minus<> F2;
const F2 f2 = F2(); const F2 f2 = F2();
assert(f2(3,2) == 1); assert(f2(3,2) == 1);
assert(f2(3.0, 2) == 1); assert(f2(3.0, 2) == 1);
assert(f2(3, 2.5) == 0.5); assert(f2(3, 2.5) == 0.5);
constexpr int foo = std::minus<int> () (3, 2); constexpr int foo = std::minus<int> () (3, 2);
static_assert ( foo == 1, "" ); static_assert ( foo == 1, "" );
constexpr int bar = std::minus<> () (3.0, 2); constexpr int bar = std::minus<> () (3.0, 2);
static_assert ( bar == 1, "" ); static_assert ( bar == 1, "" );
#endif #endif
} }

test/std/utilities/function.objects/arithmetic.operations/modulus.pass.cpp

Show All 9 Lines
// <functional> // <functional>
// modulus // modulus
#include <functional> #include <functional>
#include <type_traits> #include <type_traits>
#include <cassert> #include <cassert>
#include "test_macros.h"
int main() int main()
{ {
typedef std::modulus<int> F; typedef std::modulus<int> F;
const F f = F(); const F f = F();
static_assert((std::is_same<int, F::first_argument_type>::value), "" ); static_assert((std::is_same<int, F::first_argument_type>::value), "" );
static_assert((std::is_same<int, F::second_argument_type>::value), "" ); static_assert((std::is_same<int, F::second_argument_type>::value), "" );
static_assert((std::is_same<int, F::result_type>::value), "" ); static_assert((std::is_same<int, F::result_type>::value), "" );
assert(f(36, 8) == 4); assert(f(36, 8) == 4);
#if _LIBCPP_STD_VER > 11 #if TEST_STD_VER > 11
typedef std::modulus<> F2; typedef std::modulus<> F2;
const F2 f2 = F2(); const F2 f2 = F2();
assert(f2(36, 8) == 4); assert(f2(36, 8) == 4);
assert(f2(36L, 8) == 4); assert(f2(36L, 8) == 4);
assert(f2(36, 8L) == 4); assert(f2(36, 8L) == 4);
constexpr int foo = std::modulus<int> () (3, 2); constexpr int foo = std::modulus<int> () (3, 2);
static_assert ( foo == 1, "" ); static_assert ( foo == 1, "" );
constexpr int bar = std::modulus<> () (3L, 2); constexpr int bar = std::modulus<> () (3L, 2);
static_assert ( bar == 1, "" ); static_assert ( bar == 1, "" );
#endif #endif
} }

test/std/utilities/function.objects/arithmetic.operations/multiplies.pass.cpp

Show All 9 Lines
// <functional> // <functional>
// multiplies // multiplies
#include <functional> #include <functional>
#include <type_traits> #include <type_traits>
#include <cassert> #include <cassert>
#include "test_macros.h"
int main() int main()
{ {
typedef std::multiplies<int> F; typedef std::multiplies<int> F;
const F f = F(); const F f = F();
static_assert((std::is_same<int, F::first_argument_type>::value), "" ); static_assert((std::is_same<int, F::first_argument_type>::value), "" );
static_assert((std::is_same<int, F::second_argument_type>::value), "" ); static_assert((std::is_same<int, F::second_argument_type>::value), "" );
static_assert((std::is_same<int, F::result_type>::value), "" ); static_assert((std::is_same<int, F::result_type>::value), "" );
assert(f(3, 2) == 6); assert(f(3, 2) == 6);
#if _LIBCPP_STD_VER > 11 #if TEST_STD_VER > 11
typedef std::multiplies<> F2; typedef std::multiplies<> F2;
const F2 f2 = F2(); const F2 f2 = F2();
assert(f2(3,2) == 6); assert(f2(3,2) == 6);
assert(f2(3.0, 2) == 6); assert(f2(3.0, 2) == 6);
assert(f2(3, 2.5) == 7.5); // exact in binary assert(f2(3, 2.5) == 7.5); // exact in binary
constexpr int foo = std::multiplies<int> () (3, 2); constexpr int foo = std::multiplies<int> () (3, 2);
static_assert ( foo == 6, "" ); static_assert ( foo == 6, "" );
constexpr int bar = std::multiplies<> () (3.0, 2); constexpr int bar = std::multiplies<> () (3.0, 2);
static_assert ( bar == 6, "" ); static_assert ( bar == 6, "" );
#endif #endif
} }

test/std/utilities/function.objects/arithmetic.operations/negate.pass.cpp

Show All 9 Lines
// <functional> // <functional>
// negate // negate
#include <functional> #include <functional>
#include <type_traits> #include <type_traits>
#include <cassert> #include <cassert>
#include "test_macros.h"
int main() int main()
{ {
typedef std::negate<int> F; typedef std::negate<int> F;
const F f = F(); const F f = F();
static_assert((std::is_same<F::argument_type, int>::value), "" ); static_assert((std::is_same<F::argument_type, int>::value), "" );
static_assert((std::is_same<F::result_type, int>::value), "" ); static_assert((std::is_same<F::result_type, int>::value), "" );
assert(f(36) == -36); assert(f(36) == -36);
#if _LIBCPP_STD_VER > 11 #if TEST_STD_VER > 11
typedef std::negate<> F2; typedef std::negate<> F2;
const F2 f2 = F2(); const F2 f2 = F2();
assert(f2(36) == -36); assert(f2(36) == -36);
assert(f2(36L) == -36); assert(f2(36L) == -36);
assert(f2(36.0) == -36); assert(f2(36.0) == -36);
constexpr int foo = std::negate<int> () (3); constexpr int foo = std::negate<int> () (3);
static_assert ( foo == -3, "" ); static_assert ( foo == -3, "" );
constexpr int bar = std::negate<> () (3.0); constexpr int bar = std::negate<> () (3.0);
static_assert ( bar == -3, "" ); static_assert ( bar == -3, "" );
#endif #endif
} }

test/std/utilities/function.objects/arithmetic.operations/plus.pass.cpp

Show All 9 Lines
// <functional> // <functional>
// plus // plus
#include <functional> #include <functional>
#include <type_traits> #include <type_traits>
#include <cassert> #include <cassert>
#include "test_macros.h"
int main() int main()
{ {
typedef std::plus<int> F; typedef std::plus<int> F;
const F f = F(); const F f = F();
static_assert((std::is_same<int, F::first_argument_type>::value), "" ); static_assert((std::is_same<int, F::first_argument_type>::value), "" );
static_assert((std::is_same<int, F::second_argument_type>::value), "" ); static_assert((std::is_same<int, F::second_argument_type>::value), "" );
static_assert((std::is_same<int, F::result_type>::value), "" ); static_assert((std::is_same<int, F::result_type>::value), "" );
assert(f(3, 2) == 5); assert(f(3, 2) == 5);
#if _LIBCPP_STD_VER > 11 #if TEST_STD_VER > 11
typedef std::plus<> F2; typedef std::plus<> F2;
const F2 f2 = F2(); const F2 f2 = F2();
assert(f2(3,2) == 5); assert(f2(3,2) == 5);
assert(f2(3.0, 2) == 5); assert(f2(3.0, 2) == 5);
assert(f2(3, 2.5) == 5.5); assert(f2(3, 2.5) == 5.5);
constexpr int foo = std::plus<int> () (3, 2); constexpr int foo = std::plus<int> () (3, 2);
static_assert ( foo == 5, "" ); static_assert ( foo == 5, "" );
constexpr int bar = std::plus<> () (3.0, 2); constexpr int bar = std::plus<> () (3.0, 2);
static_assert ( bar == 5, "" ); static_assert ( bar == 5, "" );
#endif #endif
} }

test/std/utilities/function.objects/bitwise.operations/bit_and.pass.cpp

Show All 9 Lines
// <functional> // <functional>
// bit_and // bit_and
#include <functional> #include <functional>
#include <type_traits> #include <type_traits>
#include <cassert> #include <cassert>
#include "test_macros.h"
int main() int main()
{ {
typedef std::bit_and<int> F; typedef std::bit_and<int> F;
const F f = F(); const F f = F();
static_assert((std::is_same<int, F::first_argument_type>::value), "" ); static_assert((std::is_same<int, F::first_argument_type>::value), "" );
static_assert((std::is_same<int, F::second_argument_type>::value), "" ); static_assert((std::is_same<int, F::second_argument_type>::value), "" );
static_assert((std::is_same<int, F::result_type>::value), "" ); static_assert((std::is_same<int, F::result_type>::value), "" );
assert(f(0xEA95, 0xEA95) == 0xEA95); assert(f(0xEA95, 0xEA95) == 0xEA95);
assert(f(0xEA95, 0x58D3) == 0x4891); assert(f(0xEA95, 0x58D3) == 0x4891);
assert(f(0x58D3, 0xEA95) == 0x4891); assert(f(0x58D3, 0xEA95) == 0x4891);
assert(f(0x58D3, 0) == 0); assert(f(0x58D3, 0) == 0);
assert(f(0xFFFF, 0x58D3) == 0x58D3); assert(f(0xFFFF, 0x58D3) == 0x58D3);
#if _LIBCPP_STD_VER > 11 #if TEST_STD_VER > 11
typedef std::bit_and<> F2; typedef std::bit_and<> F2;
const F2 f2 = F2(); const F2 f2 = F2();
assert(f2(0xEA95, 0xEA95) == 0xEA95); assert(f2(0xEA95, 0xEA95) == 0xEA95);
assert(f2(0xEA95L, 0xEA95) == 0xEA95); assert(f2(0xEA95L, 0xEA95) == 0xEA95);
assert(f2(0xEA95, 0xEA95L) == 0xEA95); assert(f2(0xEA95, 0xEA95L) == 0xEA95);
assert(f2(0xEA95, 0x58D3) == 0x4891); assert(f2(0xEA95, 0x58D3) == 0x4891);
assert(f2(0xEA95L, 0x58D3) == 0x4891); assert(f2(0xEA95L, 0x58D3) == 0x4891);
Show All 21 Lines

test/std/utilities/function.objects/bitwise.operations/bit_or.pass.cpp

Show All 9 Lines
// <functional> // <functional>
// bit_or // bit_or
#include <functional> #include <functional>
#include <type_traits> #include <type_traits>
#include <cassert> #include <cassert>
#include "test_macros.h"
int main() int main()
{ {
typedef std::bit_or<int> F; typedef std::bit_or<int> F;
const F f = F(); const F f = F();
static_assert((std::is_same<int, F::first_argument_type>::value), "" ); static_assert((std::is_same<int, F::first_argument_type>::value), "" );
static_assert((std::is_same<int, F::second_argument_type>::value), "" ); static_assert((std::is_same<int, F::second_argument_type>::value), "" );
static_assert((std::is_same<int, F::result_type>::value), "" ); static_assert((std::is_same<int, F::result_type>::value), "" );
assert(f(0xEA95, 0xEA95) == 0xEA95); assert(f(0xEA95, 0xEA95) == 0xEA95);
assert(f(0xEA95, 0x58D3) == 0xFAD7); assert(f(0xEA95, 0x58D3) == 0xFAD7);
assert(f(0x58D3, 0xEA95) == 0xFAD7); assert(f(0x58D3, 0xEA95) == 0xFAD7);
assert(f(0x58D3, 0) == 0x58D3); assert(f(0x58D3, 0) == 0x58D3);
assert(f(0xFFFF, 0x58D3) == 0xFFFF); assert(f(0xFFFF, 0x58D3) == 0xFFFF);
#if _LIBCPP_STD_VER > 11 #if TEST_STD_VER > 11
typedef std::bit_or<> F2; typedef std::bit_or<> F2;
const F2 f2 = F2(); const F2 f2 = F2();
assert(f2(0xEA95, 0xEA95) == 0xEA95); assert(f2(0xEA95, 0xEA95) == 0xEA95);
assert(f2(0xEA95L, 0xEA95) == 0xEA95); assert(f2(0xEA95L, 0xEA95) == 0xEA95);
assert(f2(0xEA95, 0xEA95L) == 0xEA95); assert(f2(0xEA95, 0xEA95L) == 0xEA95);
assert(f2(0xEA95, 0x58D3) == 0xFAD7); assert(f2(0xEA95, 0x58D3) == 0xFAD7);
assert(f2(0xEA95L, 0x58D3) == 0xFAD7); assert(f2(0xEA95L, 0x58D3) == 0xFAD7);
Show All 21 Lines

test/std/utilities/function.objects/bitwise.operations/bit_xor.pass.cpp

Show All 9 Lines
// <functional> // <functional>
// bit_xor // bit_xor
#include <functional> #include <functional>
#include <type_traits> #include <type_traits>
#include <cassert> #include <cassert>
#include "test_macros.h"
int main() int main()
{ {
{ {
typedef std::bit_xor<int> F; typedef std::bit_xor<int> F;
const F f = F(); const F f = F();
static_assert((std::is_same<int, F::first_argument_type>::value), "" ); static_assert((std::is_same<int, F::first_argument_type>::value), "" );
static_assert((std::is_same<int, F::second_argument_type>::value), "" ); static_assert((std::is_same<int, F::second_argument_type>::value), "" );
static_assert((std::is_same<int, F::result_type>::value), "" ); static_assert((std::is_same<int, F::result_type>::value), "" );
assert(f(0xEA95, 0xEA95) == 0); assert(f(0xEA95, 0xEA95) == 0);
assert(f(0xEA95, 0x58D3) == 0xB246); assert(f(0xEA95, 0x58D3) == 0xB246);
assert(f(0x58D3, 0xEA95) == 0xB246); assert(f(0x58D3, 0xEA95) == 0xB246);
assert(f(0x58D3, 0) == 0x58D3); assert(f(0x58D3, 0) == 0x58D3);
assert(f(0xFFFF, 0x58D3) == 0xA72C); assert(f(0xFFFF, 0x58D3) == 0xA72C);
} }
#if _LIBCPP_STD_VER > 11 #if TEST_STD_VER > 11
{ {
typedef std::bit_xor<> F2; typedef std::bit_xor<> F2;
const F2 f = F2(); const F2 f = F2();
assert(f(0xEA95, 0xEA95) == 0); assert(f(0xEA95, 0xEA95) == 0);
assert(f(0xEA95L, 0xEA95) == 0); assert(f(0xEA95L, 0xEA95) == 0);
assert(f(0xEA95, 0xEA95L) == 0); assert(f(0xEA95, 0xEA95L) == 0);
assert(f(0xEA95, 0x58D3) == 0xB246); assert(f(0xEA95, 0x58D3) == 0xB246);
Show All 23 Lines

test/std/utilities/function.objects/logical.operations/logical_and.pass.cpp

Show All 9 Lines
// <functional> // <functional>
// logical_and // logical_and
#include <functional> #include <functional>
#include <type_traits> #include <type_traits>
#include <cassert> #include <cassert>
#include "test_macros.h"
int main() int main()
{ {
typedef std::logical_and<int> F; typedef std::logical_and<int> F;
const F f = F(); const F f = F();
static_assert((std::is_same<int, F::first_argument_type>::value), "" ); static_assert((std::is_same<int, F::first_argument_type>::value), "" );
static_assert((std::is_same<int, F::second_argument_type>::value), "" ); static_assert((std::is_same<int, F::second_argument_type>::value), "" );
static_assert((std::is_same<bool, F::result_type>::value), "" ); static_assert((std::is_same<bool, F::result_type>::value), "" );
assert(f(36, 36)); assert(f(36, 36));
assert(!f(36, 0)); assert(!f(36, 0));
assert(!f(0, 36)); assert(!f(0, 36));
assert(!f(0, 0)); assert(!f(0, 0));
#if _LIBCPP_STD_VER > 11 #if TEST_STD_VER > 11
typedef std::logical_and<> F2; typedef std::logical_and<> F2;
const F2 f2 = F2(); const F2 f2 = F2();
assert( f2(36, 36)); assert( f2(36, 36));
assert( f2(36, 36L)); assert( f2(36, 36L));
assert( f2(36L, 36)); assert( f2(36L, 36));
assert(!f2(36, 0)); assert(!f2(36, 0));
assert(!f2(0, 36)); assert(!f2(0, 36));
assert( f2(36, 36L)); assert( f2(36, 36L));
Show All 13 Lines

test/std/utilities/function.objects/logical.operations/logical_not.pass.cpp

Show All 9 Lines
// <functional> // <functional>
// logical_not // logical_not
#include <functional> #include <functional>
#include <type_traits> #include <type_traits>
#include <cassert> #include <cassert>
#include "test_macros.h"
int main() int main()
{ {
typedef std::logical_not<int> F; typedef std::logical_not<int> F;
const F f = F(); const F f = F();
static_assert((std::is_same<F::argument_type, int>::value), "" ); static_assert((std::is_same<F::argument_type, int>::value), "" );
static_assert((std::is_same<F::result_type, bool>::value), "" ); static_assert((std::is_same<F::result_type, bool>::value), "" );
assert(!f(36)); assert(!f(36));
assert(f(0)); assert(f(0));
#if _LIBCPP_STD_VER > 11 #if TEST_STD_VER > 11
typedef std::logical_not<> F2; typedef std::logical_not<> F2;
const F2 f2 = F2(); const F2 f2 = F2();
assert(!f2(36)); assert(!f2(36));
assert( f2(0)); assert( f2(0));
assert(!f2(36L)); assert(!f2(36L));
assert( f2(0L)); assert( f2(0L));
constexpr bool foo = std::logical_not<int> () (36); constexpr bool foo = std::logical_not<int> () (36);
static_assert ( !foo, "" ); static_assert ( !foo, "" );
constexpr bool bar = std::logical_not<> () (36); constexpr bool bar = std::logical_not<> () (36);
static_assert ( !bar, "" ); static_assert ( !bar, "" );
#endif #endif
} }

test/std/utilities/function.objects/logical.operations/logical_or.pass.cpp

Show All 9 Lines
// <functional> // <functional>
// logical_or // logical_or
#include <functional> #include <functional>
#include <type_traits> #include <type_traits>
#include <cassert> #include <cassert>
#include "test_macros.h"
int main() int main()
{ {
typedef std::logical_or<int> F; typedef std::logical_or<int> F;
const F f = F(); const F f = F();
static_assert((std::is_same<int, F::first_argument_type>::value), "" ); static_assert((std::is_same<int, F::first_argument_type>::value), "" );
static_assert((std::is_same<int, F::second_argument_type>::value), "" ); static_assert((std::is_same<int, F::second_argument_type>::value), "" );
static_assert((std::is_same<bool, F::result_type>::value), "" ); static_assert((std::is_same<bool, F::result_type>::value), "" );
assert(f(36, 36)); assert(f(36, 36));
assert(f(36, 0)); assert(f(36, 0));
assert(f(0, 36)); assert(f(0, 36));
assert(!f(0, 0)); assert(!f(0, 0));
#if _LIBCPP_STD_VER > 11 #if TEST_STD_VER > 11
typedef std::logical_or<> F2; typedef std::logical_or<> F2;
const F2 f2 = F2(); const F2 f2 = F2();
assert( f2(36, 36)); assert( f2(36, 36));
assert( f2(36, 36L)); assert( f2(36, 36L));
assert( f2(36L, 36)); assert( f2(36L, 36));
assert( f2(36, 0)); assert( f2(36, 0));
assert( f2(0, 36)); assert( f2(0, 36));
assert( f2(36, 0L)); assert( f2(36, 0L));
Show All 12 Lines

test/std/utilities/intseq/intseq.intseq/integer_seq.fail.cpp

Show All 16 Lines
// static constexpr size_t size() noexcept; // static constexpr size_t size() noexcept;
// }; // };
// This test is a conforming extension. The extension turns undefined behavior // This test is a conforming extension. The extension turns undefined behavior
// into a compile-time error. // into a compile-time error.
#include <utility> #include <utility>
#include "test_macros.h"
int main() int main()
{ {
#if _LIBCPP_STD_VER > 11 #if TEST_STD_VER > 11
// Should fail to compile, since float is not an integral type // Should fail to compile, since float is not an integral type
using floatmix = std::integer_sequence<float>; using floatmix = std::integer_sequence<float>;
floatmix::value_type I; floatmix::value_type I;
#else #else
X X
#endif // _LIBCPP_STD_VER > 11 #endif // TEST_STD_VER > 11
} }

test/std/utilities/memory/storage.iterator/raw_storage_iterator.pass.cpp

//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// The LLVM Compiler Infrastructure // The LLVM Compiler Infrastructure
// //
// This file is dual licensed under the MIT and the University of Illinois Open // This file is dual licensed under the MIT and the University of Illinois Open
// Source Licenses. See LICENSE.TXT for details. // Source Licenses. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// raw_storage_iterator // raw_storage_iterator
#include <memory> #include <memory>
#include <type_traits> #include <type_traits>
#include <cassert> #include <cassert>
#include "test_macros.h"
#include <MoveOnly.h> #include <MoveOnly.h>
int A_constructed = 0; int A_constructed = 0;
struct A struct A
{ {
int data_; int data_;
public: public:
Show All 17 Linesint main()
for (int i = 0; i < 3; ++i) for (int i = 0; i < 3; ++i)
{ {
*it++ = S(i+1); *it++ = S(i+1);
S* ap = (S*)&buffer + i; S* ap = (S*)&buffer + i;
assert(*ap == i+1); assert(*ap == i+1);
assert(A_constructed == i+1); assert(A_constructed == i+1);
} }
} }
#if _LIBCPP_STD_VER >= 14 #if TEST_STD_VER >= 14
{ {
typedef MoveOnly S; typedef MoveOnly S;
typedef std::aligned_storage<3*sizeof(S), std::alignment_of<S>::value>::type typedef std::aligned_storage<3*sizeof(S), std::alignment_of<S>::value>::type
Storage; Storage;
Storage buffer; Storage buffer;
std::raw_storage_iterator<S*, S> it((S*)&buffer); std::raw_storage_iterator<S*, S> it((S*)&buffer);
S m{1}; S m{1};
*it++ = std::move(m); *it++ = std::move(m);
assert(m.get() == 0); // moved from assert(m.get() == 0); // moved from
S *ap = (S*) &buffer; S *ap = (S*) &buffer;
assert(ap->get() == 1); // original value assert(ap->get() == 1); // original value
} }
#endif #endif
} }

test/std/utilities/meta/meta.help/integral_constant.pass.cpp

//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// The LLVM Compiler Infrastructure // The LLVM Compiler Infrastructure
// //
// This file is dual licensed under the MIT and the University of Illinois Open // This file is dual licensed under the MIT and the University of Illinois Open
// Source Licenses. See LICENSE.TXT for details. // Source Licenses. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// type_traits // type_traits
// integral_constant // integral_constant
#include <type_traits> #include <type_traits>
#include <cassert> #include <cassert>
#include "test_macros.h"
int main() int main()
{ {
typedef std::integral_constant<int, 5> _5; typedef std::integral_constant<int, 5> _5;
static_assert(_5::value == 5, ""); static_assert(_5::value == 5, "");
static_assert((std::is_same<_5::value_type, int>::value), ""); static_assert((std::is_same<_5::value_type, int>::value), "");
static_assert((std::is_same<_5::type, _5>::value), ""); static_assert((std::is_same<_5::type, _5>::value), "");
#ifndef _LIBCPP_HAS_NO_CONSTEXPR #ifndef _LIBCPP_HAS_NO_CONSTEXPR
static_assert((_5() == 5), ""); static_assert((_5() == 5), "");
#else #else
assert(_5() == 5); assert(_5() == 5);
#endif #endif
#if _LIBCPP_STD_VER > 11 #if TEST_STD_VER > 11
static_assert ( _5{}() == 5, "" ); static_assert ( _5{}() == 5, "" );
static_assert ( std::true_type{}(), "" ); static_assert ( std::true_type{}(), "" );
#endif #endif
static_assert(std::false_type::value == false, ""); static_assert(std::false_type::value == false, "");
static_assert((std::is_same<std::false_type::value_type, bool>::value), ""); static_assert((std::is_same<std::false_type::value_type, bool>::value), "");
static_assert((std::is_same<std::false_type::type, std::false_type>::value), ""); static_assert((std::is_same<std::false_type::type, std::false_type>::value), "");
Show All 12 Lines

test/std/utilities/meta/meta.trans/meta.trans.arr/remove_all_extents.pass.cpp

//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// The LLVM Compiler Infrastructure // The LLVM Compiler Infrastructure
// //
// This file is dual licensed under the MIT and the University of Illinois Open // This file is dual licensed under the MIT and the University of Illinois Open
// Source Licenses. See LICENSE.TXT for details. // Source Licenses. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// type_traits // type_traits
// remove_all_extents // remove_all_extents
#include <type_traits> #include <type_traits>
#include "test_macros.h"
enum Enum {zero, one_}; enum Enum {zero, one_};
template <class T, class U> template <class T, class U>
void test_remove_all_extents() void test_remove_all_extents()
{ {
static_assert((std::is_same<typename std::remove_all_extents<T>::type, U>::value), ""); static_assert((std::is_same<typename std::remove_all_extents<T>::type, U>::value), "");
#if _LIBCPP_STD_VER > 11 #if TEST_STD_VER > 11
static_assert((std::is_same<std::remove_all_extents_t<T>, U>::value), ""); static_assert((std::is_same<std::remove_all_extents_t<T>, U>::value), "");
#endif #endif
} }
int main() int main()
{ {
test_remove_all_extents<int, int> (); test_remove_all_extents<int, int> ();
test_remove_all_extents<const Enum, const Enum> (); test_remove_all_extents<const Enum, const Enum> ();
Show All 11 Lines

test/std/utilities/meta/meta.trans/meta.trans.arr/remove_extent.pass.cpp

//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// The LLVM Compiler Infrastructure // The LLVM Compiler Infrastructure
// //
// This file is dual licensed under the MIT and the University of Illinois Open // This file is dual licensed under the MIT and the University of Illinois Open
// Source Licenses. See LICENSE.TXT for details. // Source Licenses. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// type_traits // type_traits
// remove_extent // remove_extent
#include <type_traits> #include <type_traits>
#include "test_macros.h"
enum Enum {zero, one_}; enum Enum {zero, one_};
template <class T, class U> template <class T, class U>
void test_remove_extent() void test_remove_extent()
{ {
static_assert((std::is_same<typename std::remove_extent<T>::type, U>::value), ""); static_assert((std::is_same<typename std::remove_extent<T>::type, U>::value), "");
#if _LIBCPP_STD_VER > 11 #if TEST_STD_VER > 11
static_assert((std::is_same<std::remove_extent_t<T>, U>::value), ""); static_assert((std::is_same<std::remove_extent_t<T>, U>::value), "");
#endif #endif
} }
int main() int main()
{ {
test_remove_extent<int, int> (); test_remove_extent<int, int> ();
Show All 12 Lines

test/std/utilities/meta/meta.trans/meta.trans.cv/add_const.pass.cpp

//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// The LLVM Compiler Infrastructure // The LLVM Compiler Infrastructure
// //
// This file is dual licensed under the MIT and the University of Illinois Open // This file is dual licensed under the MIT and the University of Illinois Open
// Source Licenses. See LICENSE.TXT for details. // Source Licenses. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// type_traits // type_traits
// add_const // add_const
#include <type_traits> #include <type_traits>
#include "test_macros.h"
template <class T, class U> template <class T, class U>
void test_add_const_imp() void test_add_const_imp()
{ {
static_assert((std::is_same<typename std::add_const<T>::type, const U>::value), ""); static_assert((std::is_same<typename std::add_const<T>::type, const U>::value), "");
#if _LIBCPP_STD_VER > 11 #if TEST_STD_VER > 11
static_assert((std::is_same<std::add_const_t<T>, U>::value), ""); static_assert((std::is_same<std::add_const_t<T>, U>::value), "");
#endif #endif
} }
template <class T> template <class T>
void test_add_const() void test_add_const()
{ {
test_add_const_imp<T, const T>(); test_add_const_imp<T, const T>();
Show All 15 Lines

test/std/utilities/meta/meta.trans/meta.trans.cv/add_cv.pass.cpp

//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// The LLVM Compiler Infrastructure // The LLVM Compiler Infrastructure
// //
// This file is dual licensed under the MIT and the University of Illinois Open // This file is dual licensed under the MIT and the University of Illinois Open
// Source Licenses. See LICENSE.TXT for details. // Source Licenses. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// type_traits // type_traits
// add_cv // add_cv
#include <type_traits> #include <type_traits>
#include "test_macros.h"
template <class T, class U> template <class T, class U>
void test_add_cv_imp() void test_add_cv_imp()
{ {
static_assert((std::is_same<typename std::add_cv<T>::type, const volatile U>::value), ""); static_assert((std::is_same<typename std::add_cv<T>::type, const volatile U>::value), "");
#if _LIBCPP_STD_VER > 11 #if TEST_STD_VER > 11
static_assert((std::is_same<std::add_cv_t<T>, U>::value), ""); static_assert((std::is_same<std::add_cv_t<T>, U>::value), "");
#endif #endif
} }
template <class T> template <class T>
void test_add_cv() void test_add_cv()
{ {
test_add_cv_imp<T, const volatile T>(); test_add_cv_imp<T, const volatile T>();
Show All 15 Lines

test/std/utilities/meta/meta.trans/meta.trans.cv/add_volatile.pass.cpp

//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// The LLVM Compiler Infrastructure // The LLVM Compiler Infrastructure
// //
// This file is dual licensed under the MIT and the University of Illinois Open // This file is dual licensed under the MIT and the University of Illinois Open
// Source Licenses. See LICENSE.TXT for details. // Source Licenses. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// type_traits // type_traits
// add_volatile // add_volatile
#include <type_traits> #include <type_traits>
#include "test_macros.h"
template <class T, class U> template <class T, class U>
void test_add_volatile_imp() void test_add_volatile_imp()
{ {
static_assert((std::is_same<typename std::add_volatile<T>::type, volatile U>::value), ""); static_assert((std::is_same<typename std::add_volatile<T>::type, volatile U>::value), "");
#if _LIBCPP_STD_VER > 11 #if TEST_STD_VER > 11
static_assert((std::is_same<std::add_volatile_t<T>, U>::value), ""); static_assert((std::is_same<std::add_volatile_t<T>, U>::value), "");
#endif #endif
} }
template <class T> template <class T>
void test_add_volatile() void test_add_volatile()
{ {
test_add_volatile_imp<T, volatile T>(); test_add_volatile_imp<T, volatile T>();
Show All 15 Lines

test/std/utilities/meta/meta.trans/meta.trans.cv/remove_const.pass.cpp

//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// The LLVM Compiler Infrastructure // The LLVM Compiler Infrastructure
// //
// This file is dual licensed under the MIT and the University of Illinois Open // This file is dual licensed under the MIT and the University of Illinois Open
// Source Licenses. See LICENSE.TXT for details. // Source Licenses. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// type_traits // type_traits
// remove_const // remove_const
#include <type_traits> #include <type_traits>
#include "test_macros.h"
template <class T, class U> template <class T, class U>
void test_remove_const_imp() void test_remove_const_imp()
{ {
static_assert((std::is_same<typename std::remove_const<T>::type, U>::value), ""); static_assert((std::is_same<typename std::remove_const<T>::type, U>::value), "");
#if _LIBCPP_STD_VER > 11 #if TEST_STD_VER > 11
static_assert((std::is_same<std::remove_const_t<T>, U>::value), ""); static_assert((std::is_same<std::remove_const_t<T>, U>::value), "");
#endif #endif
} }
template <class T> template <class T>
void test_remove_const() void test_remove_const()
{ {
test_remove_const_imp<T, T>(); test_remove_const_imp<T, T>();
Show All 15 Lines

test/std/utilities/meta/meta.trans/meta.trans.cv/remove_cv.pass.cpp

//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// The LLVM Compiler Infrastructure // The LLVM Compiler Infrastructure
// //
// This file is dual licensed under the MIT and the University of Illinois Open // This file is dual licensed under the MIT and the University of Illinois Open
// Source Licenses. See LICENSE.TXT for details. // Source Licenses. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// type_traits // type_traits
// remove_cv // remove_cv
#include <type_traits> #include <type_traits>
#include "test_macros.h"
template <class T, class U> template <class T, class U>
void test_remove_cv_imp() void test_remove_cv_imp()
{ {
static_assert((std::is_same<typename std::remove_cv<T>::type, U>::value), ""); static_assert((std::is_same<typename std::remove_cv<T>::type, U>::value), "");
#if _LIBCPP_STD_VER > 11 #if TEST_STD_VER > 11
static_assert((std::is_same<std::remove_cv_t<T>, U>::value), ""); static_assert((std::is_same<std::remove_cv_t<T>, U>::value), "");
#endif #endif
} }
template <class T> template <class T>
void test_remove_cv() void test_remove_cv()
{ {
test_remove_cv_imp<T, T>(); test_remove_cv_imp<T, T>();
Show All 15 Lines

test/std/utilities/meta/meta.trans/meta.trans.cv/remove_volatile.pass.cpp

//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// The LLVM Compiler Infrastructure // The LLVM Compiler Infrastructure
// //
// This file is dual licensed under the MIT and the University of Illinois Open // This file is dual licensed under the MIT and the University of Illinois Open
// Source Licenses. See LICENSE.TXT for details. // Source Licenses. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// type_traits // type_traits
// remove_volatile // remove_volatile
#include <type_traits> #include <type_traits>
#include "test_macros.h"
template <class T, class U> template <class T, class U>
void test_remove_volatile_imp() void test_remove_volatile_imp()
{ {
static_assert((std::is_same<typename std::remove_volatile<T>::type, U>::value), ""); static_assert((std::is_same<typename std::remove_volatile<T>::type, U>::value), "");
#if _LIBCPP_STD_VER > 11 #if TEST_STD_VER > 11
static_assert((std::is_same<std::remove_volatile_t<T>, U>::value), ""); static_assert((std::is_same<std::remove_volatile_t<T>, U>::value), "");
#endif #endif
} }
template <class T> template <class T>
void test_remove_volatile() void test_remove_volatile()
{ {
test_remove_volatile_imp<T, T>(); test_remove_volatile_imp<T, T>();
Show All 15 Lines

test/std/utilities/meta/meta.trans/meta.trans.other/aligned_union.pass.cpp

//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// The LLVM Compiler Infrastructure // The LLVM Compiler Infrastructure
// //
// This file is dual licensed under the MIT and the University of Illinois Open // This file is dual licensed under the MIT and the University of Illinois Open
// Source Licenses. See LICENSE.TXT for details. // Source Licenses. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// type_traits // type_traits
// aligned_union<size_t Len, class ...Types> // aligned_union<size_t Len, class ...Types>
#include <type_traits> #include <type_traits>
#include "test_macros.h"
int main() int main()
{ {
#ifndef _LIBCPP_HAS_NO_VARIADICS #ifndef _LIBCPP_HAS_NO_VARIADICS
{ {
typedef std::aligned_union<10, char >::type T1; typedef std::aligned_union<10, char >::type T1;
#if _LIBCPP_STD_VER > 11 #if TEST_STD_VER > 11
static_assert(std::is_same<std::aligned_union_t<10, char>, T1>::value, "" ); static_assert(std::is_same<std::aligned_union_t<10, char>, T1>::value, "" );
#endif #endif
static_assert(std::alignment_of<T1>::value == 1, ""); static_assert(std::alignment_of<T1>::value == 1, "");
static_assert(sizeof(T1) == 10, ""); static_assert(sizeof(T1) == 10, "");
} }
{ {
typedef std::aligned_union<10, short >::type T1; typedef std::aligned_union<10, short >::type T1;
#if _LIBCPP_STD_VER > 11 #if TEST_STD_VER > 11
static_assert(std::is_same<std::aligned_union_t<10, short>, T1>::value, "" ); static_assert(std::is_same<std::aligned_union_t<10, short>, T1>::value, "" );
#endif #endif
static_assert(std::alignment_of<T1>::value == 2, ""); static_assert(std::alignment_of<T1>::value == 2, "");
static_assert(sizeof(T1) == 10, ""); static_assert(sizeof(T1) == 10, "");
} }
{ {
typedef std::aligned_union<10, int >::type T1; typedef std::aligned_union<10, int >::type T1;
#if _LIBCPP_STD_VER > 11 #if TEST_STD_VER > 11
static_assert(std::is_same<std::aligned_union_t<10, int>, T1>::value, "" ); static_assert(std::is_same<std::aligned_union_t<10, int>, T1>::value, "" );
#endif #endif
static_assert(std::alignment_of<T1>::value == 4, ""); static_assert(std::alignment_of<T1>::value == 4, "");
static_assert(sizeof(T1) == 12, ""); static_assert(sizeof(T1) == 12, "");
} }
{ {
typedef std::aligned_union<10, double >::type T1; typedef std::aligned_union<10, double >::type T1;
#if _LIBCPP_STD_VER > 11 #if TEST_STD_VER > 11
static_assert(std::is_same<std::aligned_union_t<10, double>, T1>::value, "" ); static_assert(std::is_same<std::aligned_union_t<10, double>, T1>::value, "" );
#endif #endif
static_assert(std::alignment_of<T1>::value == 8, ""); static_assert(std::alignment_of<T1>::value == 8, "");
static_assert(sizeof(T1) == 16, ""); static_assert(sizeof(T1) == 16, "");
} }
{ {
typedef std::aligned_union<10, short, char >::type T1; typedef std::aligned_union<10, short, char >::type T1;
#if _LIBCPP_STD_VER > 11 #if TEST_STD_VER > 11
static_assert(std::is_same<std::aligned_union_t<10, short, char>, T1>::value, "" ); static_assert(std::is_same<std::aligned_union_t<10, short, char>, T1>::value, "" );
#endif #endif
static_assert(std::alignment_of<T1>::value == 2, ""); static_assert(std::alignment_of<T1>::value == 2, "");
static_assert(sizeof(T1) == 10, ""); static_assert(sizeof(T1) == 10, "");
} }
{ {
typedef std::aligned_union<10, char, short >::type T1; typedef std::aligned_union<10, char, short >::type T1;
#if _LIBCPP_STD_VER > 11 #if TEST_STD_VER > 11
static_assert(std::is_same<std::aligned_union_t<10, char, short>, T1>::value, "" ); static_assert(std::is_same<std::aligned_union_t<10, char, short>, T1>::value, "" );
#endif #endif
static_assert(std::alignment_of<T1>::value == 2, ""); static_assert(std::alignment_of<T1>::value == 2, "");
static_assert(sizeof(T1) == 10, ""); static_assert(sizeof(T1) == 10, "");
} }
{ {
typedef std::aligned_union<2, int, char, short >::type T1; typedef std::aligned_union<2, int, char, short >::type T1;
#if _LIBCPP_STD_VER > 11 #if TEST_STD_VER > 11
static_assert(std::is_same<std::aligned_union_t<2, int, char, short>, T1>::value, "" ); static_assert(std::is_same<std::aligned_union_t<2, int, char, short>, T1>::value, "" );
#endif #endif
static_assert(std::alignment_of<T1>::value == 4, ""); static_assert(std::alignment_of<T1>::value == 4, "");
static_assert(sizeof(T1) == 4, ""); static_assert(sizeof(T1) == 4, "");
} }
{ {
typedef std::aligned_union<2, char, int, short >::type T1; typedef std::aligned_union<2, char, int, short >::type T1;
#if _LIBCPP_STD_VER > 11 #if TEST_STD_VER > 11
static_assert(std::is_same<std::aligned_union_t<2, char, int, short >, T1>::value, "" ); static_assert(std::is_same<std::aligned_union_t<2, char, int, short >, T1>::value, "" );
#endif #endif
static_assert(std::alignment_of<T1>::value == 4, ""); static_assert(std::alignment_of<T1>::value == 4, "");
static_assert(sizeof(T1) == 4, ""); static_assert(sizeof(T1) == 4, "");
} }
{ {
typedef std::aligned_union<2, char, short, int >::type T1; typedef std::aligned_union<2, char, short, int >::type T1;
#if _LIBCPP_STD_VER > 11 #if TEST_STD_VER > 11
static_assert(std::is_same<std::aligned_union_t<2, char, short, int >, T1>::value, "" ); static_assert(std::is_same<std::aligned_union_t<2, char, short, int >, T1>::value, "" );
#endif #endif
static_assert(std::alignment_of<T1>::value == 4, ""); static_assert(std::alignment_of<T1>::value == 4, "");
static_assert(sizeof(T1) == 4, ""); static_assert(sizeof(T1) == 4, "");
} }
#endif #endif
} }

test/std/utilities/meta/meta.trans/meta.trans.other/conditional.pass.cpp

//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// The LLVM Compiler Infrastructure // The LLVM Compiler Infrastructure
// //
// This file is dual licensed under the MIT and the University of Illinois Open // This file is dual licensed under the MIT and the University of Illinois Open
// Source Licenses. See LICENSE.TXT for details. // Source Licenses. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// type_traits // type_traits
// conditional // conditional
#include <type_traits> #include <type_traits>
#include "test_macros.h"
int main() int main()
{ {
static_assert((std::is_same<std::conditional<true, char, int>::type, char>::value), ""); static_assert((std::is_same<std::conditional<true, char, int>::type, char>::value), "");
static_assert((std::is_same<std::conditional<false, char, int>::type, int>::value), ""); static_assert((std::is_same<std::conditional<false, char, int>::type, int>::value), "");
#if _LIBCPP_STD_VER > 11 #if TEST_STD_VER > 11
static_assert((std::is_same<std::conditional_t<true, char, int>, char>::value), ""); static_assert((std::is_same<std::conditional_t<true, char, int>, char>::value), "");
static_assert((std::is_same<std::conditional_t<false, char, int>, int>::value), ""); static_assert((std::is_same<std::conditional_t<false, char, int>, int>::value), "");
#endif #endif
} }

test/std/utilities/meta/meta.trans/meta.trans.other/decay.pass.cpp

//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// The LLVM Compiler Infrastructure // The LLVM Compiler Infrastructure
// //
// This file is dual licensed under the MIT and the University of Illinois Open // This file is dual licensed under the MIT and the University of Illinois Open
// Source Licenses. See LICENSE.TXT for details. // Source Licenses. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// type_traits // type_traits
// decay // decay
#include <type_traits> #include <type_traits>
#include "test_macros.h"
template <class T, class U> template <class T, class U>
void test_decay() void test_decay()
{ {
static_assert((std::is_same<typename std::decay<T>::type, U>::value), ""); static_assert((std::is_same<typename std::decay<T>::type, U>::value), "");
#if _LIBCPP_STD_VER > 11 #if TEST_STD_VER > 11
static_assert((std::is_same<std::decay_t<T>, U>::value), ""); static_assert((std::is_same<std::decay_t<T>, U>::value), "");
#endif #endif
} }
int main() int main()
{ {
test_decay<void, void>(); test_decay<void, void>();
test_decay<int, int>(); test_decay<int, int>();
test_decay<const volatile int, int>(); test_decay<const volatile int, int>();
test_decay<int*, int*>(); test_decay<int*, int*>();
test_decay<int[3], int*>(); test_decay<int[3], int*>();
test_decay<const int[3], const int*>(); test_decay<const int[3], const int*>();
test_decay<void(), void (*)()>(); test_decay<void(), void (*)()>();
} }

test/std/utilities/meta/meta.trans/meta.trans.other/enable_if.pass.cpp

//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// The LLVM Compiler Infrastructure // The LLVM Compiler Infrastructure
// //
// This file is dual licensed under the MIT and the University of Illinois Open // This file is dual licensed under the MIT and the University of Illinois Open
// Source Licenses. See LICENSE.TXT for details. // Source Licenses. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// type_traits // type_traits
// enable_if // enable_if
#include <type_traits> #include <type_traits>
#include "test_macros.h"
int main() int main()
{ {
static_assert((std::is_same<std::enable_if<true>::type, void>::value), ""); static_assert((std::is_same<std::enable_if<true>::type, void>::value), "");
static_assert((std::is_same<std::enable_if<true, int>::type, int>::value), ""); static_assert((std::is_same<std::enable_if<true, int>::type, int>::value), "");
#if _LIBCPP_STD_VER > 11 #if TEST_STD_VER > 11
static_assert((std::is_same<std::enable_if_t<true>, void>::value), ""); static_assert((std::is_same<std::enable_if_t<true>, void>::value), "");
static_assert((std::is_same<std::enable_if_t<true, int>, int>::value), ""); static_assert((std::is_same<std::enable_if_t<true, int>, int>::value), "");
#endif #endif
} }

test/std/utilities/meta/meta.trans/meta.trans.sign/make_signed.pass.cpp

Show All 32 Linesenum HugeEnum : __uint128_t
hugezero hugezero
}; };
#endif #endif
template <class T, class U> template <class T, class U>
void test_make_signed() void test_make_signed()
{ {
static_assert((std::is_same<typename std::make_signed<T>::type, U>::value), ""); static_assert((std::is_same<typename std::make_signed<T>::type, U>::value), "");
#if _LIBCPP_STD_VER > 11 #if TEST_STD_VER > 11
static_assert((std::is_same<std::make_signed_t<T>, U>::value), ""); static_assert((std::is_same<std::make_signed_t<T>, U>::value), "");
#endif #endif
} }
int main() int main()
{ {
test_make_signed< signed char, signed char >(); test_make_signed< signed char, signed char >();
test_make_signed< unsigned char, signed char >(); test_make_signed< unsigned char, signed char >();
Show All 21 Lines

test/std/utilities/meta/meta.trans/meta.trans.sign/make_unsigned.pass.cpp

Show All 32 Linesenum HugeEnum : __int128_t
hugezero hugezero
}; };
#endif #endif
template <class T, class U> template <class T, class U>
void test_make_unsigned() void test_make_unsigned()
{ {
static_assert((std::is_same<typename std::make_unsigned<T>::type, U>::value), ""); static_assert((std::is_same<typename std::make_unsigned<T>::type, U>::value), "");
#if _LIBCPP_STD_VER > 11 #if TEST_STD_VER > 11
static_assert((std::is_same<std::make_unsigned_t<T>, U>::value), ""); static_assert((std::is_same<std::make_unsigned_t<T>, U>::value), "");
#endif #endif
} }
int main() int main()
{ {
test_make_unsigned<signed char, unsigned char> (); test_make_unsigned<signed char, unsigned char> ();
test_make_unsigned<unsigned char, unsigned char> (); test_make_unsigned<unsigned char, unsigned char> ();
Show All 22 Lines

test/std/utilities/meta/meta.unary/meta.unary.cat/lvalue_ref.pass.cpp

//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// The LLVM Compiler Infrastructure // The LLVM Compiler Infrastructure
// //
// This file is dual licensed under the MIT and the University of Illinois Open // This file is dual licensed under the MIT and the University of Illinois Open
// Source Licenses. See LICENSE.TXT for details. // Source Licenses. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// type_traits // type_traits
// lvalue_ref // lvalue_ref
#include <type_traits> #include <type_traits>
#include "test_macros.h"
template <class T> template <class T>
void test_lvalue_ref() void test_lvalue_ref()
{ {
static_assert(!std::is_void<T>::value, ""); static_assert(!std::is_void<T>::value, "");
#if _LIBCPP_STD_VER > 11 #if TEST_STD_VER > 11
static_assert(!std::is_null_pointer<T>::value, ""); static_assert(!std::is_null_pointer<T>::value, "");
#endif #endif
static_assert(!std::is_integral<T>::value, ""); static_assert(!std::is_integral<T>::value, "");
static_assert(!std::is_floating_point<T>::value, ""); static_assert(!std::is_floating_point<T>::value, "");
static_assert(!std::is_array<T>::value, ""); static_assert(!std::is_array<T>::value, "");
static_assert(!std::is_pointer<T>::value, ""); static_assert(!std::is_pointer<T>::value, "");
static_assert( std::is_lvalue_reference<T>::value, ""); static_assert( std::is_lvalue_reference<T>::value, "");
static_assert(!std::is_rvalue_reference<T>::value, ""); static_assert(!std::is_rvalue_reference<T>::value, "");
Show All 18 Lines

test/std/utilities/meta/meta.unary/meta.unary.cat/member_function_pointer_no_variadics.pass.cpp

//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// The LLVM Compiler Infrastructure // The LLVM Compiler Infrastructure
// //
// This file is dual licensed under the MIT and the University of Illinois Open // This file is dual licensed under the MIT and the University of Illinois Open
// Source Licenses. See LICENSE.TXT for details. // Source Licenses. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// type_traits // type_traits
// member_function_pointer // member_function_pointer
#define _LIBCPP_HAS_NO_VARIADICS #define _LIBCPP_HAS_NO_VARIADICS
#include <type_traits> #include <type_traits>
#include "test_macros.h"
template <class T> template <class T>
void test_member_function_pointer_imp() void test_member_function_pointer_imp()
{ {
static_assert(!std::is_void<T>::value, ""); static_assert(!std::is_void<T>::value, "");
#if _LIBCPP_STD_VER > 11 #if TEST_STD_VER > 11
static_assert(!std::is_null_pointer<T>::value, ""); static_assert(!std::is_null_pointer<T>::value, "");
#endif #endif
static_assert(!std::is_integral<T>::value, ""); static_assert(!std::is_integral<T>::value, "");
static_assert(!std::is_floating_point<T>::value, ""); static_assert(!std::is_floating_point<T>::value, "");
static_assert(!std::is_array<T>::value, ""); static_assert(!std::is_array<T>::value, "");
static_assert(!std::is_pointer<T>::value, ""); static_assert(!std::is_pointer<T>::value, "");
static_assert(!std::is_lvalue_reference<T>::value, ""); static_assert(!std::is_lvalue_reference<T>::value, "");
static_assert(!std::is_rvalue_reference<T>::value, ""); static_assert(!std::is_rvalue_reference<T>::value, "");
▲ Show 20 Lines • Show All 52 Lines • Show Last 20 Lines

test/std/utilities/time/time.point/time.point.cast/time_point_cast.pass.cpp

Show All 13 Lines
// template <class ToDuration, class Clock, class Duration> // template <class ToDuration, class Clock, class Duration>
// time_point<Clock, ToDuration> // time_point<Clock, ToDuration>
// time_point_cast(const time_point<Clock, Duration>& t); // time_point_cast(const time_point<Clock, Duration>& t);
#include <chrono> #include <chrono>
#include <type_traits> #include <type_traits>
#include <cassert> #include <cassert>
#include "test_macros.h"
template <class FromDuration, class ToDuration> template <class FromDuration, class ToDuration>
void void
test(const FromDuration& df, const ToDuration& d) test(const FromDuration& df, const ToDuration& d)
{ {
typedef std::chrono::system_clock Clock; typedef std::chrono::system_clock Clock;
typedef std::chrono::time_point<Clock, FromDuration> FromTimePoint; typedef std::chrono::time_point<Clock, FromDuration> FromTimePoint;
typedef std::chrono::time_point<Clock, ToDuration> ToTimePoint; typedef std::chrono::time_point<Clock, ToDuration> ToTimePoint;
{ {
FromTimePoint f(df); FromTimePoint f(df);
ToTimePoint t(d); ToTimePoint t(d);
typedef decltype(std::chrono::time_point_cast<ToDuration>(f)) R; typedef decltype(std::chrono::time_point_cast<ToDuration>(f)) R;
static_assert((std::is_same<R, ToTimePoint>::value), ""); static_assert((std::is_same<R, ToTimePoint>::value), "");
assert(std::chrono::time_point_cast<ToDuration>(f) == t); assert(std::chrono::time_point_cast<ToDuration>(f) == t);
} }
} }
#if _LIBCPP_STD_VER > 11 #if TEST_STD_VER > 11
template<class FromDuration, long long From, class ToDuration, long long To> template<class FromDuration, long long From, class ToDuration, long long To>
void test_constexpr () void test_constexpr ()
{ {
typedef std::chrono::system_clock Clock; typedef std::chrono::system_clock Clock;
typedef std::chrono::time_point<Clock, FromDuration> FromTimePoint; typedef std::chrono::time_point<Clock, FromDuration> FromTimePoint;
typedef std::chrono::time_point<Clock, ToDuration> ToTimePoint; typedef std::chrono::time_point<Clock, ToDuration> ToTimePoint;
{ {
Show All 13 Linesint main()
test(std::chrono::milliseconds(7265000), std::chrono::seconds(7265)); test(std::chrono::milliseconds(7265000), std::chrono::seconds(7265));
test(std::chrono::milliseconds(7265000), std::chrono::milliseconds(7265000)); test(std::chrono::milliseconds(7265000), std::chrono::milliseconds(7265000));
test(std::chrono::milliseconds(7265000), std::chrono::microseconds(7265000000LL)); test(std::chrono::milliseconds(7265000), std::chrono::microseconds(7265000000LL));
test(std::chrono::milliseconds(7265000), std::chrono::nanoseconds(7265000000000LL)); test(std::chrono::milliseconds(7265000), std::chrono::nanoseconds(7265000000000LL));
test(std::chrono::milliseconds(7265000), test(std::chrono::milliseconds(7265000),
std::chrono::duration<double, std::ratio<3600> >(7265./3600)); std::chrono::duration<double, std::ratio<3600> >(7265./3600));
test(std::chrono::duration<int, std::ratio<2, 3> >(9), test(std::chrono::duration<int, std::ratio<2, 3> >(9),
std::chrono::duration<int, std::ratio<3, 5> >(10)); std::chrono::duration<int, std::ratio<3, 5> >(10));
#if _LIBCPP_STD_VER > 11 #if TEST_STD_VER > 11
{ {
test_constexpr<std::chrono::milliseconds, 7265000, std::chrono::hours, 2> (); test_constexpr<std::chrono::milliseconds, 7265000, std::chrono::hours, 2> ();
test_constexpr<std::chrono::milliseconds, 7265000, std::chrono::minutes,121> (); test_constexpr<std::chrono::milliseconds, 7265000, std::chrono::minutes,121> ();
test_constexpr<std::chrono::milliseconds, 7265000, std::chrono::seconds,7265> (); test_constexpr<std::chrono::milliseconds, 7265000, std::chrono::seconds,7265> ();
test_constexpr<std::chrono::milliseconds, 7265000, std::chrono::milliseconds,7265000> (); test_constexpr<std::chrono::milliseconds, 7265000, std::chrono::milliseconds,7265000> ();
test_constexpr<std::chrono::milliseconds, 7265000, std::chrono::microseconds,7265000000LL> (); test_constexpr<std::chrono::milliseconds, 7265000, std::chrono::microseconds,7265000000LL> ();
test_constexpr<std::chrono::milliseconds, 7265000, std::chrono::nanoseconds,7265000000000LL> (); test_constexpr<std::chrono::milliseconds, 7265000, std::chrono::nanoseconds,7265000000000LL> ();
typedef std::chrono::duration<int, std::ratio<3, 5>> T1; typedef std::chrono::duration<int, std::ratio<3, 5>> T1;
test_constexpr<std::chrono::duration<int, std::ratio<2, 3>>, 9, T1, 10> (); test_constexpr<std::chrono::duration<int, std::ratio<2, 3>>, 9, T1, 10> ();
} }
#endif #endif
} }

test/std/utilities/time/time.point/time.point.comparisons/op_equal.pass.cpp

Show All 16 Lines
// template <class Clock, class Duration1, class Duration2> // template <class Clock, class Duration1, class Duration2>
// bool // bool
// operator!=(const time_point<Clock, Duration1>& lhs, const time_point<Clock, Duration2>& rhs); // operator!=(const time_point<Clock, Duration1>& lhs, const time_point<Clock, Duration2>& rhs);
#include <chrono> #include <chrono>
#include <cassert> #include <cassert>
#include "test_macros.h"
int main() int main()
{ {
typedef std::chrono::system_clock Clock; typedef std::chrono::system_clock Clock;
typedef std::chrono::milliseconds Duration1; typedef std::chrono::milliseconds Duration1;
typedef std::chrono::microseconds Duration2; typedef std::chrono::microseconds Duration2;
typedef std::chrono::time_point<Clock, Duration1> T1; typedef std::chrono::time_point<Clock, Duration1> T1;
typedef std::chrono::time_point<Clock, Duration2> T2; typedef std::chrono::time_point<Clock, Duration2> T2;
Show All 17 Linesint main()
} }
{ {
T1 t1(Duration1(3)); T1 t1(Duration1(3));
T2 t2(Duration2(3001)); T2 t2(Duration2(3001));
assert(!(t1 == t2)); assert(!(t1 == t2));
assert( (t1 != t2)); assert( (t1 != t2));
} }
#if _LIBCPP_STD_VER > 11 #if TEST_STD_VER > 11
{ {
constexpr T1 t1(Duration1(3)); constexpr T1 t1(Duration1(3));
constexpr T1 t2(Duration1(3)); constexpr T1 t2(Duration1(3));
static_assert( (t1 == t2), ""); static_assert( (t1 == t2), "");
static_assert(!(t1 != t2), ""); static_assert(!(t1 != t2), "");
} }
{ {
constexpr T1 t1(Duration1(3)); constexpr T1 t1(Duration1(3));
Show All 18 Lines

test/std/utilities/time/time.point/time.point.comparisons/op_less.pass.cpp

Show All 24 Lines
// template <class Clock, class Duration1, class Duration2> // template <class Clock, class Duration1, class Duration2>
// bool // bool
// operator>=(const time_point<Clock, Duration1>& lhs, const time_point<Clock, Duration2>& rhs); // operator>=(const time_point<Clock, Duration1>& lhs, const time_point<Clock, Duration2>& rhs);
#include <chrono> #include <chrono>
#include <cassert> #include <cassert>
#include "test_macros.h"
int main() int main()
{ {
typedef std::chrono::system_clock Clock; typedef std::chrono::system_clock Clock;
typedef std::chrono::milliseconds Duration1; typedef std::chrono::milliseconds Duration1;
typedef std::chrono::microseconds Duration2; typedef std::chrono::microseconds Duration2;
typedef std::chrono::time_point<Clock, Duration1> T1; typedef std::chrono::time_point<Clock, Duration1> T1;
typedef std::chrono::time_point<Clock, Duration2> T2; typedef std::chrono::time_point<Clock, Duration2> T2;
Show All 25 Linesint main()
T1 t1(Duration1(3)); T1 t1(Duration1(3));
T2 t2(Duration2(3001)); T2 t2(Duration2(3001));
assert( (t1 < t2)); assert( (t1 < t2));
assert(!(t1 > t2)); assert(!(t1 > t2));
assert( (t1 <= t2)); assert( (t1 <= t2));
assert(!(t1 >= t2)); assert(!(t1 >= t2));
} }
#if _LIBCPP_STD_VER > 11 #if TEST_STD_VER > 11
{ {
constexpr T1 t1(Duration1(3)); constexpr T1 t1(Duration1(3));
constexpr T1 t2(Duration1(3)); constexpr T1 t2(Duration1(3));
static_assert(!(t1 < t2), ""); static_assert(!(t1 < t2), "");
static_assert(!(t1 > t2), ""); static_assert(!(t1 > t2), "");
static_assert( (t1 <= t2), ""); static_assert( (t1 <= t2), "");
static_assert( (t1 >= t2), ""); static_assert( (t1 >= t2), "");
} }
Show All 26 Lines

test/std/utilities/time/time.point/time.point.cons/convert.pass.cpp

Show All 11 Lines
// time_point // time_point
// template <class Duration2> // template <class Duration2>
// time_point(const time_point<clock, Duration2>& t); // time_point(const time_point<clock, Duration2>& t);
#include <chrono> #include <chrono>
#include <cassert> #include <cassert>
#include "test_macros.h"
int main() int main()
{ {
typedef std::chrono::system_clock Clock; typedef std::chrono::system_clock Clock;
typedef std::chrono::microseconds Duration1; typedef std::chrono::microseconds Duration1;
typedef std::chrono::milliseconds Duration2; typedef std::chrono::milliseconds Duration2;
{ {
std::chrono::time_point<Clock, Duration2> t2(Duration2(3)); std::chrono::time_point<Clock, Duration2> t2(Duration2(3));
std::chrono::time_point<Clock, Duration1> t1 = t2; std::chrono::time_point<Clock, Duration1> t1 = t2;
assert(t1.time_since_epoch() == Duration1(3000)); assert(t1.time_since_epoch() == Duration1(3000));
} }
#if _LIBCPP_STD_VER > 11 #if TEST_STD_VER > 11
{ {
constexpr std::chrono::time_point<Clock, Duration2> t2(Duration2(3)); constexpr std::chrono::time_point<Clock, Duration2> t2(Duration2(3));
constexpr std::chrono::time_point<Clock, Duration1> t1 = t2; constexpr std::chrono::time_point<Clock, Duration1> t1 = t2;
static_assert(t1.time_since_epoch() == Duration1(3000), ""); static_assert(t1.time_since_epoch() == Duration1(3000), "");
} }
#endif #endif
} }

test/std/utilities/time/time.point/time.point.cons/default.pass.cpp

Show All 10 Lines
// time_point // time_point
// time_point(); // time_point();
#include <chrono> #include <chrono>
#include <cassert> #include <cassert>
#include "test_macros.h"
#include "../../rep.h" #include "../../rep.h"
int main() int main()
{ {
typedef std::chrono::system_clock Clock; typedef std::chrono::system_clock Clock;
typedef std::chrono::duration<Rep, std::milli> Duration; typedef std::chrono::duration<Rep, std::milli> Duration;
{ {
std::chrono::time_point<Clock, Duration> t; std::chrono::time_point<Clock, Duration> t;
assert(t.time_since_epoch() == Duration::zero()); assert(t.time_since_epoch() == Duration::zero());
} }
#if _LIBCPP_STD_VER > 11 #if TEST_STD_VER > 11
{ {
constexpr std::chrono::time_point<Clock, Duration> t; constexpr std::chrono::time_point<Clock, Duration> t;
static_assert(t.time_since_epoch() == Duration::zero(), ""); static_assert(t.time_since_epoch() == Duration::zero(), "");
} }
#endif #endif
} }

test/std/utilities/time/time.point/time.point.cons/duration.pass.cpp

Show All 10 Lines
// time_point // time_point
// explicit time_point(const duration& d); // explicit time_point(const duration& d);
#include <chrono> #include <chrono>
#include <cassert> #include <cassert>
#include "test_macros.h"
int main() int main()
{ {
typedef std::chrono::system_clock Clock; typedef std::chrono::system_clock Clock;
typedef std::chrono::milliseconds Duration; typedef std::chrono::milliseconds Duration;
{ {
std::chrono::time_point<Clock, Duration> t(Duration(3)); std::chrono::time_point<Clock, Duration> t(Duration(3));
assert(t.time_since_epoch() == Duration(3)); assert(t.time_since_epoch() == Duration(3));
} }
{ {
std::chrono::time_point<Clock, Duration> t(std::chrono::seconds(3)); std::chrono::time_point<Clock, Duration> t(std::chrono::seconds(3));
assert(t.time_since_epoch() == Duration(3000)); assert(t.time_since_epoch() == Duration(3000));
} }
#if _LIBCPP_STD_VER > 11 #if TEST_STD_VER > 11
{ {
constexpr std::chrono::time_point<Clock, Duration> t(Duration(3)); constexpr std::chrono::time_point<Clock, Duration> t(Duration(3));
static_assert(t.time_since_epoch() == Duration(3), ""); static_assert(t.time_since_epoch() == Duration(3), "");
} }
{ {
constexpr std::chrono::time_point<Clock, Duration> t(std::chrono::seconds(3)); constexpr std::chrono::time_point<Clock, Duration> t(std::chrono::seconds(3));
static_assert(t.time_since_epoch() == Duration(3000), ""); static_assert(t.time_since_epoch() == Duration(3000), "");
} }
#endif #endif
} }

test/std/utilities/time/time.point/time.point.nonmember/op_+.pass.cpp

Show All 16 Lines
// template <class Rep1, class Period1, class Clock, class Duration2> // template <class Rep1, class Period1, class Clock, class Duration2>
// time_point<Clock, typename common_type<duration<Rep1, Period1>, Duration2>::type> // time_point<Clock, typename common_type<duration<Rep1, Period1>, Duration2>::type>
// operator+(const duration<Rep1, Period1>& lhs, const time_point<Clock, Duration2>& rhs); // operator+(const duration<Rep1, Period1>& lhs, const time_point<Clock, Duration2>& rhs);
#include <chrono> #include <chrono>
#include <cassert> #include <cassert>
#include "test_macros.h"
int main() int main()
{ {
typedef std::chrono::system_clock Clock; typedef std::chrono::system_clock Clock;
typedef std::chrono::milliseconds Duration1; typedef std::chrono::milliseconds Duration1;
typedef std::chrono::microseconds Duration2; typedef std::chrono::microseconds Duration2;
{ {
std::chrono::time_point<Clock, Duration1> t1(Duration1(3)); std::chrono::time_point<Clock, Duration1> t1(Duration1(3));
std::chrono::time_point<Clock, Duration2> t2 = t1 + Duration2(5); std::chrono::time_point<Clock, Duration2> t2 = t1 + Duration2(5);
assert(t2.time_since_epoch() == Duration2(3005)); assert(t2.time_since_epoch() == Duration2(3005));
t2 = Duration2(6) + t1; t2 = Duration2(6) + t1;
assert(t2.time_since_epoch() == Duration2(3006)); assert(t2.time_since_epoch() == Duration2(3006));
} }
#if _LIBCPP_STD_VER > 11 #if TEST_STD_VER > 11
{ {
constexpr std::chrono::time_point<Clock, Duration1> t1(Duration1(3)); constexpr std::chrono::time_point<Clock, Duration1> t1(Duration1(3));
constexpr std::chrono::time_point<Clock, Duration2> t2 = t1 + Duration2(5); constexpr std::chrono::time_point<Clock, Duration2> t2 = t1 + Duration2(5);
static_assert(t2.time_since_epoch() == Duration2(3005), ""); static_assert(t2.time_since_epoch() == Duration2(3005), "");
constexpr std::chrono::time_point<Clock, Duration2> t3 = Duration2(6) + t1; constexpr std::chrono::time_point<Clock, Duration2> t3 = Duration2(6) + t1;
static_assert(t3.time_since_epoch() == Duration2(3006), ""); static_assert(t3.time_since_epoch() == Duration2(3006), "");
} }
#endif #endif
} }

test/std/utilities/time/time.point/time.point.nonmember/op_-duration.pass.cpp

Show All 12 Lines
// template <class Clock, class Duration1, class Rep2, class Period2> // template <class Clock, class Duration1, class Rep2, class Period2>
// time_point<Clock, typename common_type<Duration1, duration<Rep2, Period2>>::type> // time_point<Clock, typename common_type<Duration1, duration<Rep2, Period2>>::type>
// operator-(const time_point<Clock, Duration1>& lhs, const duration<Rep2, Period2>& rhs); // operator-(const time_point<Clock, Duration1>& lhs, const duration<Rep2, Period2>& rhs);
#include <chrono> #include <chrono>
#include <cassert> #include <cassert>
#include "test_macros.h"
int main() int main()
{ {
typedef std::chrono::system_clock Clock; typedef std::chrono::system_clock Clock;
typedef std::chrono::milliseconds Duration1; typedef std::chrono::milliseconds Duration1;
typedef std::chrono::microseconds Duration2; typedef std::chrono::microseconds Duration2;
{ {
std::chrono::time_point<Clock, Duration1> t1(Duration1(3)); std::chrono::time_point<Clock, Duration1> t1(Duration1(3));
std::chrono::time_point<Clock, Duration2> t2 = t1 - Duration2(5); std::chrono::time_point<Clock, Duration2> t2 = t1 - Duration2(5);
assert(t2.time_since_epoch() == Duration2(2995)); assert(t2.time_since_epoch() == Duration2(2995));
} }
#if _LIBCPP_STD_VER > 11 #if TEST_STD_VER > 11
{ {
constexpr std::chrono::time_point<Clock, Duration1> t1(Duration1(3)); constexpr std::chrono::time_point<Clock, Duration1> t1(Duration1(3));
constexpr std::chrono::time_point<Clock, Duration2> t2 = t1 - Duration2(5); constexpr std::chrono::time_point<Clock, Duration2> t2 = t1 - Duration2(5);
static_assert(t2.time_since_epoch() == Duration2(2995), ""); static_assert(t2.time_since_epoch() == Duration2(2995), "");
} }
#endif #endif
} }

test/std/utilities/time/time.point/time.point.nonmember/op_-time_point.pass.cpp

Show All 12 Lines
// template <class Clock, class Duration1, class Duration2> // template <class Clock, class Duration1, class Duration2>
// typename common_type<Duration1, Duration2>::type // typename common_type<Duration1, Duration2>::type
// operator-(const time_point<Clock, Duration1>& lhs, const time_point<Clock, Duration2>& rhs); // operator-(const time_point<Clock, Duration1>& lhs, const time_point<Clock, Duration2>& rhs);
#include <chrono> #include <chrono>
#include <cassert> #include <cassert>
#include "test_macros.h"
int main() int main()
{ {
typedef std::chrono::system_clock Clock; typedef std::chrono::system_clock Clock;
typedef std::chrono::milliseconds Duration1; typedef std::chrono::milliseconds Duration1;
typedef std::chrono::microseconds Duration2; typedef std::chrono::microseconds Duration2;
{ {
std::chrono::time_point<Clock, Duration1> t1(Duration1(3)); std::chrono::time_point<Clock, Duration1> t1(Duration1(3));
std::chrono::time_point<Clock, Duration2> t2(Duration2(5)); std::chrono::time_point<Clock, Duration2> t2(Duration2(5));
assert((t1 - t2) == Duration2(2995)); assert((t1 - t2) == Duration2(2995));
} }
#if _LIBCPP_STD_VER > 11 #if TEST_STD_VER > 11
{ {
constexpr std::chrono::time_point<Clock, Duration1> t1(Duration1(3)); constexpr std::chrono::time_point<Clock, Duration1> t1(Duration1(3));
constexpr std::chrono::time_point<Clock, Duration2> t2(Duration2(5)); constexpr std::chrono::time_point<Clock, Duration2> t2(Duration2(5));
static_assert((t1 - t2) == Duration2(2995), ""); static_assert((t1 - t2) == Duration2(2995), "");
} }
#endif #endif
} }

test/std/utilities/tuple/tuple.tuple/tuple.helper/tuple_element.pass.cpp

Show All 17 Lines
// typedef Ti type; // typedef Ti type;
// }; // };
// UNSUPPORTED: c++98, c++03 // UNSUPPORTED: c++98, c++03
#include <tuple> #include <tuple>
#include <type_traits> #include <type_traits>
#include "test_macros.h"
template <class T, std::size_t N, class U> template <class T, std::size_t N, class U>
void test() void test()
{ {
static_assert((std::is_same<typename std::tuple_element<N, T>::type, U>::value), ""); static_assert((std::is_same<typename std::tuple_element<N, T>::type, U>::value), "");
static_assert((std::is_same<typename std::tuple_element<N, const T>::type, const U>::value), ""); static_assert((std::is_same<typename std::tuple_element<N, const T>::type, const U>::value), "");
static_assert((std::is_same<typename std::tuple_element<N, volatile T>::type, volatile U>::value), ""); static_assert((std::is_same<typename std::tuple_element<N, volatile T>::type, volatile U>::value), "");
static_assert((std::is_same<typename std::tuple_element<N, const volatile T>::type, const volatile U>::value), ""); static_assert((std::is_same<typename std::tuple_element<N, const volatile T>::type, const volatile U>::value), "");
#if _LIBCPP_STD_VER > 11 #if TEST_STD_VER > 11
static_assert((std::is_same<typename std::tuple_element_t<N, T>, U>::value), ""); static_assert((std::is_same<typename std::tuple_element_t<N, T>, U>::value), "");
static_assert((std::is_same<typename std::tuple_element_t<N, const T>, const U>::value), ""); static_assert((std::is_same<typename std::tuple_element_t<N, const T>, const U>::value), "");
static_assert((std::is_same<typename std::tuple_element_t<N, volatile T>, volatile U>::value), ""); static_assert((std::is_same<typename std::tuple_element_t<N, volatile T>, volatile U>::value), "");
static_assert((std::is_same<typename std::tuple_element_t<N, const volatile T>, const volatile U>::value), ""); static_assert((std::is_same<typename std::tuple_element_t<N, const volatile T>, const volatile U>::value), "");
#endif #endif
} }
int main() int main()
{ {
test<std::tuple<int>, 0, int>(); test<std::tuple<int>, 0, int>();
test<std::tuple<char, int>, 0, char>(); test<std::tuple<char, int>, 0, char>();
test<std::tuple<char, int>, 1, int>(); test<std::tuple<char, int>, 1, int>();
test<std::tuple<int*, char, int>, 0, int*>(); test<std::tuple<int*, char, int>, 0, int*>();
test<std::tuple<int*, char, int>, 1, char>(); test<std::tuple<int*, char, int>, 1, char>();
test<std::tuple<int*, char, int>, 2, int>(); test<std::tuple<int*, char, int>, 2, int>();
} }

test/std/utilities/tuple/tuple.tuple/tuple.cnstr/UTypes.pass.cpp

Show All 14 Lines
// explicit tuple(UTypes&&... u); // explicit tuple(UTypes&&... u);
// UNSUPPORTED: c++98, c++03 // UNSUPPORTED: c++98, c++03
#include <tuple> #include <tuple>
#include <cassert> #include <cassert>
#include <type_traits> #include <type_traits>
#include "test_macros.h"
#include "MoveOnly.h" #include "MoveOnly.h"
#if _LIBCPP_STD_VER > 11 #if TEST_STD_VER > 11
struct Empty {}; struct Empty {};
struct A struct A
{ {
int id_; int id_;
explicit constexpr A(int i) : id_(i) {} explicit constexpr A(int i) : id_(i) {}
}; };
▲ Show 20 Lines • Show All 118 Lines • Show Last 20 Lines

test/std/utilities/tuple/tuple.tuple/tuple.cnstr/const_Types.pass.cpp

Show All 13 Lines
// explicit tuple(const T&...); // explicit tuple(const T&...);
// UNSUPPORTED: c++98, c++03 // UNSUPPORTED: c++98, c++03
#include <tuple> #include <tuple>
#include <string> #include <string>
#include <cassert> #include <cassert>
#include "test_macros.h"
template <class ...> template <class ...>
struct never { struct never {
enum { value = 0 }; enum { value = 0 };
}; };
struct NoValueCtor struct NoValueCtor
{ {
▲ Show 20 Lines • Show All 51 Lines • ▼ Show 20 Linesint main()
{ {
// check that the literal '0' can implicitly initialize a stored pointer. // check that the literal '0' can implicitly initialize a stored pointer.
std::tuple<int*> t = 0; std::tuple<int*> t = 0;
} }
{ {
std::tuple<int> t(2); std::tuple<int> t(2);
assert(std::get<0>(t) == 2); assert(std::get<0>(t) == 2);
} }
#if _LIBCPP_STD_VER > 11 #if TEST_STD_VER > 11
{ {
constexpr std::tuple<int> t(2); constexpr std::tuple<int> t(2);
static_assert(std::get<0>(t) == 2, ""); static_assert(std::get<0>(t) == 2, "");
} }
{ {
constexpr std::tuple<int> t; constexpr std::tuple<int> t;
static_assert(std::get<0>(t) == 0, ""); static_assert(std::get<0>(t) == 0, "");
} }
#endif #endif
{ {
std::tuple<int, char*> t(2, 0); std::tuple<int, char*> t(2, 0);
assert(std::get<0>(t) == 2); assert(std::get<0>(t) == 2);
assert(std::get<1>(t) == nullptr); assert(std::get<1>(t) == nullptr);
} }
#if _LIBCPP_STD_VER > 11 #if TEST_STD_VER > 11
{ {
constexpr std::tuple<int, char*> t(2, nullptr); constexpr std::tuple<int, char*> t(2, nullptr);
static_assert(std::get<0>(t) == 2, ""); static_assert(std::get<0>(t) == 2, "");
static_assert(std::get<1>(t) == nullptr, ""); static_assert(std::get<1>(t) == nullptr, "");
} }
#endif #endif
{ {
std::tuple<int, char*> t(2, nullptr); std::tuple<int, char*> t(2, nullptr);
▲ Show 20 Lines • Show All 49 Lines • Show Last 20 Lines

test/std/utilities/tuple/tuple.tuple/tuple.cnstr/const_pair.pass.cpp

Show All 13 Lines
// template <class U1, class U2> tuple(const pair<U1, U2>& u); // template <class U1, class U2> tuple(const pair<U1, U2>& u);
// UNSUPPORTED: c++98, c++03 // UNSUPPORTED: c++98, c++03
#include <tuple> #include <tuple>
#include <utility> #include <utility>
#include <cassert> #include <cassert>
#include "test_macros.h"
int main() int main()
{ {
{ {
typedef std::pair<double, char> T0; typedef std::pair<double, char> T0;
typedef std::tuple<int, short> T1; typedef std::tuple<int, short> T1;
T0 t0(2.5, 'a'); T0 t0(2.5, 'a');
T1 t1 = t0; T1 t1 = t0;
assert(std::get<0>(t1) == 2); assert(std::get<0>(t1) == 2);
assert(std::get<1>(t1) == short('a')); assert(std::get<1>(t1) == short('a'));
} }
#if _LIBCPP_STD_VER > 11 #if TEST_STD_VER > 11
{ {
typedef std::pair<double, char> P0; typedef std::pair<double, char> P0;
typedef std::tuple<int, short> T1; typedef std::tuple<int, short> T1;
constexpr P0 p0(2.5, 'a'); constexpr P0 p0(2.5, 'a');
constexpr T1 t1 = p0; constexpr T1 t1 = p0;
static_assert(std::get<0>(t1) != std::get<0>(p0), ""); static_assert(std::get<0>(t1) != std::get<0>(p0), "");
static_assert(std::get<1>(t1) == std::get<1>(p0), ""); static_assert(std::get<1>(t1) == std::get<1>(p0), "");
static_assert(std::get<0>(t1) == 2, ""); static_assert(std::get<0>(t1) == 2, "");
static_assert(std::get<1>(t1) == short('a'), ""); static_assert(std::get<1>(t1) == short('a'), "");
} }
#endif #endif
} }

test/std/utilities/tuple/tuple.tuple/tuple.cnstr/convert_copy.pass.cpp

Show All 14 Lines
// UNSUPPORTED: c++98, c++03 // UNSUPPORTED: c++98, c++03
#include <tuple> #include <tuple>
#include <utility> #include <utility>
#include <string> #include <string>
#include <cassert> #include <cassert>
#include "test_macros.h"
struct Explicit { struct Explicit {
int value; int value;
explicit Explicit(int x) : value(x) {} explicit Explicit(int x) : value(x) {}
}; };
struct Implicit { struct Implicit {
int value; int value;
Implicit(int x) : value(x) {} Implicit(int x) : value(x) {}
}; };
struct B struct B
{ {
int id_; int id_;
explicit B(int i) : id_(i) {} explicit B(int i) : id_(i) {}
}; };
struct D struct D
: B : B
{ {
explicit D(int i) : B(i) {} explicit D(int i) : B(i) {}
}; };
#if _LIBCPP_STD_VER > 11 #if TEST_STD_VER > 11
struct A struct A
{ {
int id_; int id_;
constexpr A(int i) : id_(i) {} constexpr A(int i) : id_(i) {}
friend constexpr bool operator==(const A& x, const A& y) {return x.id_ == y.id_;} friend constexpr bool operator==(const A& x, const A& y) {return x.id_ == y.id_;}
}; };
Show All 12 Lines
{ {
{ {
typedef std::tuple<double> T0; typedef std::tuple<double> T0;
typedef std::tuple<int> T1; typedef std::tuple<int> T1;
T0 t0(2.5); T0 t0(2.5);
T1 t1 = t0; T1 t1 = t0;
assert(std::get<0>(t1) == 2); assert(std::get<0>(t1) == 2);
} }
#if _LIBCPP_STD_VER > 11 #if TEST_STD_VER > 11
{ {
typedef std::tuple<double> T0; typedef std::tuple<double> T0;
typedef std::tuple<A> T1; typedef std::tuple<A> T1;
constexpr T0 t0(2.5); constexpr T0 t0(2.5);
constexpr T1 t1 = t0; constexpr T1 t1 = t0;
static_assert(std::get<0>(t1) == 2, ""); static_assert(std::get<0>(t1) == 2, "");
} }
{ {
▲ Show 20 Lines • Show All 55 Lines • Show Last 20 Lines

test/std/utilities/tuple/tuple.tuple/tuple.cnstr/copy.pass.cpp

Show All 13 Lines
// tuple(const tuple& u) = default; // tuple(const tuple& u) = default;
// UNSUPPORTED: c++98, c++03 // UNSUPPORTED: c++98, c++03
#include <tuple> #include <tuple>
#include <string> #include <string>
#include <cassert> #include <cassert>
#include "test_macros.h"
struct Empty {}; struct Empty {};
int main() int main()
{ {
{ {
typedef std::tuple<> T; typedef std::tuple<> T;
T t0; T t0;
T t = t0; T t = t0;
Show All 15 Linesint main()
{ {
typedef std::tuple<int, char, std::string> T; typedef std::tuple<int, char, std::string> T;
const T t0(2, 'a', "some text"); const T t0(2, 'a', "some text");
T t = t0; T t = t0;
assert(std::get<0>(t) == 2); assert(std::get<0>(t) == 2);
assert(std::get<1>(t) == 'a'); assert(std::get<1>(t) == 'a');
assert(std::get<2>(t) == "some text"); assert(std::get<2>(t) == "some text");
} }
#if _LIBCPP_STD_VER > 11 #if TEST_STD_VER > 11
{ {
typedef std::tuple<int> T; typedef std::tuple<int> T;
constexpr T t0(2); constexpr T t0(2);
constexpr T t = t0; constexpr T t = t0;
static_assert(std::get<0>(t) == 2, ""); static_assert(std::get<0>(t) == 2, "");
} }
{ {
typedef std::tuple<Empty> T; typedef std::tuple<Empty> T;
constexpr T t0; constexpr T t0;
constexpr T t = t0; constexpr T t = t0;
constexpr Empty e = std::get<0>(t); constexpr Empty e = std::get<0>(t);
((void)e); // Prevent unused warning ((void)e); // Prevent unused warning
} }
#endif #endif
} }

test/std/utilities/tuple/tuple.tuple/tuple.creation/forward_as_tuple.pass.cpp

Show All 12 Lines
// tuple<Types&&...> forward_as_tuple(Types&&... t); // tuple<Types&&...> forward_as_tuple(Types&&... t);
// UNSUPPORTED: c++98, c++03 // UNSUPPORTED: c++98, c++03
#include <tuple> #include <tuple>
#include <type_traits> #include <type_traits>
#include <cassert> #include <cassert>
#include "test_macros.h"
template <class Tuple> template <class Tuple>
void void
test0(const Tuple&) test0(const Tuple&)
{ {
static_assert(std::tuple_size<Tuple>::value == 0, ""); static_assert(std::tuple_size<Tuple>::value == 0, "");
} }
template <class Tuple> template <class Tuple>
Show All 20 Lines
{ {
static_assert(std::tuple_size<Tuple>::value == 2, ""); static_assert(std::tuple_size<Tuple>::value == 2, "");
static_assert(std::is_same<typename std::tuple_element<0, Tuple>::type, double&>::value, ""); static_assert(std::is_same<typename std::tuple_element<0, Tuple>::type, double&>::value, "");
static_assert(std::is_same<typename std::tuple_element<1, Tuple>::type, char&>::value, ""); static_assert(std::is_same<typename std::tuple_element<1, Tuple>::type, char&>::value, "");
assert(std::get<0>(t) == 2.5); assert(std::get<0>(t) == 2.5);
assert(std::get<1>(t) == 'a'); assert(std::get<1>(t) == 'a');
} }
#if _LIBCPP_STD_VER > 11 #if TEST_STD_VER > 11
template <class Tuple> template <class Tuple>
constexpr int constexpr int
test3(const Tuple&) test3(const Tuple&)
{ {
return std::tuple_size<Tuple>::value; return std::tuple_size<Tuple>::value;
} }
#endif #endif
int main() int main()
{ {
{ {
test0(std::forward_as_tuple()); test0(std::forward_as_tuple());
} }
{ {
test1a(std::forward_as_tuple(1)); test1a(std::forward_as_tuple(1));
} }
{ {
int i = 2; int i = 2;
test1b(std::forward_as_tuple(i)); test1b(std::forward_as_tuple(i));
} }
{ {
double i = 2.5; double i = 2.5;
char c = 'a'; char c = 'a';
test2a(std::forward_as_tuple(i, c)); test2a(std::forward_as_tuple(i, c));
#if _LIBCPP_STD_VER > 11 #if TEST_STD_VER > 11
static_assert ( test3 (std::forward_as_tuple(i, c)) == 2, "" ); static_assert ( test3 (std::forward_as_tuple(i, c)) == 2, "" );
#endif #endif
} }
} }

test/std/utilities/tuple/tuple.tuple/tuple.creation/make_tuple.pass.cpp

Show All 14 Lines
// tuple<VTypes...> make_tuple(Types&&... t); // tuple<VTypes...> make_tuple(Types&&... t);
// UNSUPPORTED: c++98, c++03 // UNSUPPORTED: c++98, c++03
#include <tuple> #include <tuple>
#include <functional> #include <functional>
#include <cassert> #include <cassert>
#include "test_macros.h"
int main() int main()
{ {
{ {
int i = 0; int i = 0;
float j = 0; float j = 0;
std::tuple<int, int&, float&> t = std::make_tuple(1, std::ref(i), std::tuple<int, int&, float&> t = std::make_tuple(1, std::ref(i),
std::ref(j)); std::ref(j));
assert(std::get<0>(t) == 1); assert(std::get<0>(t) == 1);
assert(std::get<1>(t) == 0); assert(std::get<1>(t) == 0);
assert(std::get<2>(t) == 0); assert(std::get<2>(t) == 0);
i = 2; i = 2;
j = 3.5; j = 3.5;
assert(std::get<0>(t) == 1); assert(std::get<0>(t) == 1);
assert(std::get<1>(t) == 2); assert(std::get<1>(t) == 2);
assert(std::get<2>(t) == 3.5); assert(std::get<2>(t) == 3.5);
std::get<1>(t) = 0; std::get<1>(t) = 0;
std::get<2>(t) = 0; std::get<2>(t) = 0;
assert(i == 0); assert(i == 0);
assert(j == 0); assert(j == 0);
} }
#if _LIBCPP_STD_VER > 11 #if TEST_STD_VER > 11
{ {
constexpr auto t1 = std::make_tuple(0, 1, 3.14); constexpr auto t1 = std::make_tuple(0, 1, 3.14);
constexpr int i1 = std::get<1>(t1); constexpr int i1 = std::get<1>(t1);
constexpr double d1 = std::get<2>(t1); constexpr double d1 = std::get<2>(t1);
static_assert (i1 == 1, "" ); static_assert (i1 == 1, "" );
static_assert (d1 == 3.14, "" ); static_assert (d1 == 3.14, "" );
} }
#endif #endif
} }

test/std/utilities/tuple/tuple.tuple/tuple.creation/tie.pass.cpp

Show All 14 Lines
// tuple<Types&...> tie(Types&... t); // tuple<Types&...> tie(Types&... t);
// UNSUPPORTED: c++98, c++03 // UNSUPPORTED: c++98, c++03
#include <tuple> #include <tuple>
#include <string> #include <string>
#include <cassert> #include <cassert>
#include "test_macros.h"
int main() int main()
{ {
{ {
int i = 0; int i = 0;
std::string s; std::string s;
std::tie(i, std::ignore, s) = std::make_tuple(42, 3.14, "C++"); std::tie(i, std::ignore, s) = std::make_tuple(42, 3.14, "C++");
assert(i == 42); assert(i == 42);
assert(s == "C++"); assert(s == "C++");
} }
#if _LIBCPP_STD_VER > 11 #if TEST_STD_VER > 11
{ {
static constexpr int i = 42; static constexpr int i = 42;
static constexpr double f = 1.1; static constexpr double f = 1.1;
constexpr std::tuple<const int &, const double &> t = std::tie(i, f); constexpr std::tuple<const int &, const double &> t = std::tie(i, f);
static_assert ( std::get<0>(t) == 42, "" ); static_assert ( std::get<0>(t) == 42, "" );
static_assert ( std::get<1>(t) == 1.1, "" ); static_assert ( std::get<1>(t) == 1.1, "" );
} }
#endif #endif
} }

test/std/utilities/tuple/tuple.tuple/tuple.creation/tuple_cat.pass.cpp

Show All 15 Lines
// UNSUPPORTED: c++98, c++03 // UNSUPPORTED: c++98, c++03
#include <tuple> #include <tuple>
#include <utility> #include <utility>
#include <array> #include <array>
#include <string> #include <string>
#include <cassert> #include <cassert>
#include "test_macros.h"
#include "MoveOnly.h" #include "MoveOnly.h"
int main() int main()
{ {
{ {
std::tuple<> t = std::tuple_cat(); std::tuple<> t = std::tuple_cat();
((void)t); // Prevent unused warning ((void)t); // Prevent unused warning
} }
Show All 11 Linesint main()
((void)t); // Prevent unused warning ((void)t); // Prevent unused warning
} }
{ {
std::tuple<int> t1(1); std::tuple<int> t1(1);
std::tuple<int> t = std::tuple_cat(t1); std::tuple<int> t = std::tuple_cat(t1);
assert(std::get<0>(t) == 1); assert(std::get<0>(t) == 1);
} }
#if _LIBCPP_STD_VER > 11 #if TEST_STD_VER > 11
{ {
constexpr std::tuple<> t = std::tuple_cat(); constexpr std::tuple<> t = std::tuple_cat();
((void)t); // Prevent unused warning ((void)t); // Prevent unused warning
} }
{ {
constexpr std::tuple<> t1; constexpr std::tuple<> t1;
constexpr std::tuple<> t2 = std::tuple_cat(t1); constexpr std::tuple<> t2 = std::tuple_cat(t1);
((void)t2); // Prevent unused warning ((void)t2); // Prevent unused warning
▲ Show 20 Lines • Show All 182 Lines • Show Last 20 Lines

test/std/utilities/tuple/tuple.tuple/tuple.elem/get_const.pass.cpp

Show All 15 Lines
// get(const tuple<Types...>& t); // get(const tuple<Types...>& t);
// UNSUPPORTED: c++98, c++03 // UNSUPPORTED: c++98, c++03
#include <tuple> #include <tuple>
#include <string> #include <string>
#include <cassert> #include <cassert>
#include "test_macros.h"
struct Empty {}; struct Empty {};
int main() int main()
{ {
{ {
typedef std::tuple<int> T; typedef std::tuple<int> T;
const T t(3); const T t(3);
assert(std::get<0>(t) == 3); assert(std::get<0>(t) == 3);
} }
{ {
typedef std::tuple<std::string, int> T; typedef std::tuple<std::string, int> T;
const T t("high", 5); const T t("high", 5);
assert(std::get<0>(t) == "high"); assert(std::get<0>(t) == "high");
assert(std::get<1>(t) == 5); assert(std::get<1>(t) == 5);
} }
#if _LIBCPP_STD_VER > 11 #if TEST_STD_VER > 11
{ {
typedef std::tuple<double, int> T; typedef std::tuple<double, int> T;
constexpr T t(2.718, 5); constexpr T t(2.718, 5);
static_assert(std::get<0>(t) == 2.718, ""); static_assert(std::get<0>(t) == 2.718, "");
static_assert(std::get<1>(t) == 5, ""); static_assert(std::get<1>(t) == 5, "");
} }
{ {
typedef std::tuple<Empty> T; typedef std::tuple<Empty> T;
Show All 19 Lines

test/std/utilities/tuple/tuple.tuple/tuple.elem/get_non_const.pass.cpp

Show First 20 Lines • Show All 65 Lines • ▼ Show 20 Linesint main()
std::get<0>(t) = 2.5; std::get<0>(t) = 2.5;
std::get<1>(t) = "four"; std::get<1>(t) = "four";
std::get<2>(t) = 4; std::get<2>(t) = 4;
assert(std::get<0>(t) == 2.5); assert(std::get<0>(t) == 2.5);
assert(std::get<1>(t) == "four"); assert(std::get<1>(t) == "four");
assert(std::get<2>(t) == 4); assert(std::get<2>(t) == 4);
assert(d == 2.5); assert(d == 2.5);
} }
#if _LIBCPP_STD_VER > 11 #if TEST_STD_VER > 11
{ // get on an rvalue tuple { // get on an rvalue tuple
static_assert ( std::get<0> ( std::make_tuple ( 0.0f, 1, 2.0, 3L )) == 0, "" ); static_assert ( std::get<0> ( std::make_tuple ( 0.0f, 1, 2.0, 3L )) == 0, "" );
static_assert ( std::get<1> ( std::make_tuple ( 0.0f, 1, 2.0, 3L )) == 1, "" ); static_assert ( std::get<1> ( std::make_tuple ( 0.0f, 1, 2.0, 3L )) == 1, "" );
static_assert ( std::get<2> ( std::make_tuple ( 0.0f, 1, 2.0, 3L )) == 2, "" ); static_assert ( std::get<2> ( std::make_tuple ( 0.0f, 1, 2.0, 3L )) == 2, "" );
static_assert ( std::get<3> ( std::make_tuple ( 0.0f, 1, 2.0, 3L )) == 3, "" ); static_assert ( std::get<3> ( std::make_tuple ( 0.0f, 1, 2.0, 3L )) == 3, "" );
static_assert(S().k == 1, ""); static_assert(S().k == 1, "");
static_assert(std::get<1>(getP()) == 4, ""); static_assert(std::get<1>(getP()) == 4, "");
} }
#endif #endif
} }

test/std/utilities/tuple/tuple.tuple/tuple.rel/eq.pass.cpp

Show All 15 Lines
// operator==(const tuple<TTypes...>& t, const tuple<UTypes...>& u); // operator==(const tuple<TTypes...>& t, const tuple<UTypes...>& u);
// UNSUPPORTED: c++98, c++03 // UNSUPPORTED: c++98, c++03
#include <tuple> #include <tuple>
#include <string> #include <string>
#include <cassert> #include <cassert>
#include "test_macros.h"
int main() int main()
{ {
{ {
typedef std::tuple<> T1; typedef std::tuple<> T1;
typedef std::tuple<> T2; typedef std::tuple<> T2;
const T1 t1; const T1 t1;
const T2 t2; const T2 t2;
assert(t1 == t2); assert(t1 == t2);
▲ Show 20 Lines • Show All 106 Lines • ▼ Show 20 Linesint main()
{ {
typedef std::tuple<char, int, double> T1; typedef std::tuple<char, int, double> T1;
typedef std::tuple<double, char, int> T2; typedef std::tuple<double, char, int> T2;
const T1 t1(1, 2, 3); const T1 t1(1, 2, 3);
const T2 t2(1.1, 3, 2); const T2 t2(1.1, 3, 2);
assert(!(t1 == t2)); assert(!(t1 == t2));
assert(t1 != t2); assert(t1 != t2);
} }
#if _LIBCPP_STD_VER > 11 #if TEST_STD_VER > 11
{ {
typedef std::tuple<char, int, double> T1; typedef std::tuple<char, int, double> T1;
typedef std::tuple<double, char, int> T2; typedef std::tuple<double, char, int> T2;
constexpr T1 t1(1, 2, 3); constexpr T1 t1(1, 2, 3);
constexpr T2 t2(1.1, 3, 2); constexpr T2 t2(1.1, 3, 2);
static_assert(!(t1 == t2), ""); static_assert(!(t1 == t2), "");
static_assert(t1 != t2, ""); static_assert(t1 != t2, "");
} }
#endif #endif
} }

test/std/utilities/tuple/tuple.tuple/tuple.rel/lt.pass.cpp

Show All 27 Lines
// operator>=(const tuple<TTypes...>& t, const tuple<UTypes...>& u); // operator>=(const tuple<TTypes...>& t, const tuple<UTypes...>& u);
// UNSUPPORTED: c++98, c++03 // UNSUPPORTED: c++98, c++03
#include <tuple> #include <tuple>
#include <string> #include <string>
#include <cassert> #include <cassert>
#include "test_macros.h"
int main() int main()
{ {
{ {
typedef std::tuple<> T1; typedef std::tuple<> T1;
typedef std::tuple<> T2; typedef std::tuple<> T2;
const T1 t1; const T1 t1;
const T2 t2; const T2 t2;
assert(!(t1 < t2)); assert(!(t1 < t2));
▲ Show 20 Lines • Show All 146 Lines • ▼ Show 20 Linesint main()
typedef std::tuple<double, char, int> T2; typedef std::tuple<double, char, int> T2;
const T1 t1(1, 2, 3); const T1 t1(1, 2, 3);
const T2 t2(1, 2, 4); const T2 t2(1, 2, 4);
assert( (t1 < t2)); assert( (t1 < t2));
assert( (t1 <= t2)); assert( (t1 <= t2));
assert(!(t1 > t2)); assert(!(t1 > t2));
assert(!(t1 >= t2)); assert(!(t1 >= t2));
} }
#if _LIBCPP_STD_VER > 11 #if TEST_STD_VER > 11
{ {
typedef std::tuple<char, int, double> T1; typedef std::tuple<char, int, double> T1;
typedef std::tuple<double, char, int> T2; typedef std::tuple<double, char, int> T2;
constexpr T1 t1(1, 2, 3); constexpr T1 t1(1, 2, 3);
constexpr T2 t2(1, 2, 4); constexpr T2 t2(1, 2, 4);
static_assert( (t1 < t2), ""); static_assert( (t1 < t2), "");
static_assert( (t1 <= t2), ""); static_assert( (t1 <= t2), "");
static_assert(!(t1 > t2), ""); static_assert(!(t1 > t2), "");
static_assert(!(t1 >= t2), ""); static_assert(!(t1 >= t2), "");
} }
#endif #endif
} }

test/std/utilities/utility/pairs/pairs.spec/comparison.pass.cpp

Show All 15 Lines
// template <class T1, class T2> bool operator< (const pair<T1,T2>&, const pair<T1,T2>&); // template <class T1, class T2> bool operator< (const pair<T1,T2>&, const pair<T1,T2>&);
// template <class T1, class T2> bool operator> (const pair<T1,T2>&, const pair<T1,T2>&); // template <class T1, class T2> bool operator> (const pair<T1,T2>&, const pair<T1,T2>&);
// template <class T1, class T2> bool operator>=(const pair<T1,T2>&, const pair<T1,T2>&); // template <class T1, class T2> bool operator>=(const pair<T1,T2>&, const pair<T1,T2>&);
// template <class T1, class T2> bool operator<=(const pair<T1,T2>&, const pair<T1,T2>&); // template <class T1, class T2> bool operator<=(const pair<T1,T2>&, const pair<T1,T2>&);
#include <utility> #include <utility>
#include <cassert> #include <cassert>
#include "test_macros.h"
int main() int main()
{ {
{ {
typedef std::pair<int, short> P; typedef std::pair<int, short> P;
P p1(3, 4); P p1(3, 4);
P p2(3, 4); P p2(3, 4);
assert( (p1 == p2)); assert( (p1 == p2));
assert(!(p1 != p2)); assert(!(p1 != p2));
▲ Show 20 Lines • Show All 42 Lines • ▼ Show 20 Linesint main()
assert(!(p1 == p2)); assert(!(p1 == p2));
assert( (p1 != p2)); assert( (p1 != p2));
assert(!(p1 < p2)); assert(!(p1 < p2));
assert(!(p1 <= p2)); assert(!(p1 <= p2));
assert( (p1 > p2)); assert( (p1 > p2));
assert( (p1 >= p2)); assert( (p1 >= p2));
} }
#if _LIBCPP_STD_VER > 11 #if TEST_STD_VER > 11
{ {
typedef std::pair<int, short> P; typedef std::pair<int, short> P;
constexpr P p1(3, 4); constexpr P p1(3, 4);
constexpr P p2(3, 2); constexpr P p2(3, 2);
static_assert(!(p1 == p2), ""); static_assert(!(p1 == p2), "");
static_assert( (p1 != p2), ""); static_assert( (p1 != p2), "");
static_assert(!(p1 < p2), ""); static_assert(!(p1 < p2), "");
static_assert(!(p1 <= p2), ""); static_assert(!(p1 <= p2), "");
static_assert( (p1 > p2), ""); static_assert( (p1 > p2), "");
static_assert( (p1 >= p2), ""); static_assert( (p1 >= p2), "");
} }
#endif #endif
} }

test/support/is_transparent.h

//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// The LLVM Compiler Infrastructure // The LLVM Compiler Infrastructure
// //
// This file is dual licensed under the MIT and the University of Illinois Open // This file is dual licensed under the MIT and the University of Illinois Open
// Source Licenses. See LICENSE.TXT for details. // Source Licenses. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#ifndef TRANSPARENT_H #ifndef TRANSPARENT_H
#define TRANSPARENT_H #define TRANSPARENT_H
#include "test_macros.h"
// testing transparent // testing transparent
#if _LIBCPP_STD_VER > 11 #if TEST_STD_VER > 11
struct transparent_less struct transparent_less
{ {
template <class T, class U> template <class T, class U>
constexpr auto operator()(T&& t, U&& u) const constexpr auto operator()(T&& t, U&& u) const
noexcept(noexcept(std::forward<T>(t) < std::forward<U>(u))) noexcept(noexcept(std::forward<T>(t) < std::forward<U>(u)))
-> decltype (std::forward<T>(t) < std::forward<U>(u)) -> decltype (std::forward<T>(t) < std::forward<U>(u))
{ return std::forward<T>(t) < std::forward<U>(u); } { return std::forward<T>(t) < std::forward<U>(u); }
▲ Show 20 Lines • Show All 51 Lines • Show Last 20 Lines