This is an archive of the discontinued LLVM Phabricator instance.

Differential D146372

[libc++]Enforce `-Wzero-as-null-pointer-constant`
AbandonedPublic

Authored by fsb4000 on Mar 18 2023, 7:19 PM.

Details

Reviewers
Mordante
philnik
ldionne
EricWF
Group Reviewers
Restricted Project
Summary

Fixes https://github.com/llvm/llvm-project/issues/43670

From https://www.open-std.org/jtc1/sc22/wg21/docs/papers/2017/p0768r1.pdf :

The relational and equality operators for the comparison category types are specified with an
anonymous parameter of unspecified type. This type shall be selected by the implementation such
that these parameters can accept literal 0 as a corresponding argument. [Example: nullptr_t
satisfies this requirement. — end example] In this context, the behavior of a program that supplies
an argument other than a literal 0 is undefined

So after this patch we will accept not literal 0 but consteval zero like

#include <compare>

consteval int test() { return 0;}
auto b = 1 <=> 2 < test();

But before we accepted nullptr. So I guess it's fine and the behavior is undefined in the both cases.

Oh, I see that we rejected nullptr: https://github.com/llvm/llvm-project/blob/93a04a0591c1958d5344f3541157fbd8b8ff7370/libcxx/test/std/language.support/cmp/cmp.categories.pre/zero_type.verify.cpp

That code was accepted. Yes, the probability of it in reality is much lower than auto b = 1 <=> 2 < (1-1). But I think (1-1) is also low enough...

#include <compare>

consteval int test() { return 0;}
auto b = 1 <=> 2 < (int std::_CmpUnspecifiedParam::*)nullptr;

Diff Detail

Unit TestsFailed

TimeTest
1,300 mslibcxx CI C++11 > llvm-libc++-shared-cfg-in.libcxx/algorithms::robust_against_copying_comparators.pass.cpp
1,300 mslibcxx CI C++11 > llvm-libc++-shared-cfg-in.libcxx/algorithms::robust_against_copying_comparators.pass.cpp
310 mslibcxx CI C++11 > llvm-libc++-shared-cfg-in.libcxx/atomics/atomics_types_operations/atomics_types_operations_req::atomic_fetch_add.verify.cpp
310 mslibcxx CI C++11 > llvm-libc++-shared-cfg-in.libcxx/atomics/atomics_types_operations/atomics_types_operations_req::atomic_fetch_add.verify.cpp
300 mslibcxx CI C++11 > llvm-libc++-shared-cfg-in.libcxx/atomics/atomics_types_operations/atomics_types_operations_req::atomic_fetch_add_explicit.verify.cpp
View Full Test Results (4,938 Failed)

Event Timeline

fsb4000 created this revision.Mar 18 2023, 7:19 PM
Herald added a project: Restricted Project. · View Herald TranscriptMar 18 2023, 7:19 PM
Herald added a subscriber: mikhail.ramalho. · View Herald Transcript
fsb4000 requested review of this revision.Mar 18 2023, 7:19 PM
Herald added a subscriber: libcxx-commits. · View Herald TranscriptMar 18 2023, 7:19 PM
Harbormaster completed remote builds in B220264: Diff 506343.Mar 18 2023, 7:19 PM
fsb4000 edited the summary of this revision. (Show Details)Mar 18 2023, 8:38 PM
fsb4000 updated this revision to Diff 506348.Mar 18 2023, 8:52 PM
fsb4000 edited the summary of this revision. (Show Details)Mar 18 2023, 9:06 PM
fsb4000 edited the summary of this revision. (Show Details)Mar 18 2023, 9:16 PM
Harbormaster completed remote builds in B220266: Diff 506348.Mar 18 2023, 9:19 PM
fsb4000 updated this revision to Diff 506349.Mar 18 2023, 9:32 PM
Harbormaster completed remote builds in B220267: Diff 506349.Mar 18 2023, 10:12 PM
philnik added inline comments.Mar 19 2023, 1:59 AM
libcxx/include/__compare/ordering.h
45–50
48

This produces way better error messages on most compilers: https://godbolt.org/z/PhjaTav68

libcxx/test/libcxx/language.support/cmp/cmp.categories.pre/zero_type.verify.cpp
1

I think this test should be inside test/libcxx, since it is very implementation-specific.

libcxx/test/std/language.support/cmp/cmp.partialord/partialord.pass.cpp
10 ↗(On Diff #506349)

Is there a reason we can't enable this globally?

fsb4000 updated this revision to Diff 506379.Mar 19 2023, 4:32 AM

removed unneeded _LIBCPP_HIDE_FROM_ABI

added __literal_zero_is_expected function for a better error message.

added -Wzero-as-null-pointer-constant warning for all tests

moved cmp/cmp.categories.pre/zero_type.verify.cpp. test to libcxx tests

Also I created the same PR for MSVC STL: https://github.com/microsoft/STL/pull/3581

And GCC failed with this change: "in ‘constexpr’ expansion of ‘f.test_range()::<lambda()>()’ cc1plus: error: taking address of an immediate function ‘consteval std::__1::_CmpUnspecifiedParam::_CmpUnspecifiedParam(int)" (std/algorithms/alg_sorting/alg_min_max/ranges.min.pass.cpp")

I will try to investigate this.

Herald added a subscriber: arichardson. · View Herald TranscriptMar 19 2023, 4:32 AM
fsb4000 marked 2 inline comments as done.Mar 19 2023, 4:32 AM
fsb4000 added inline comments.
libcxx/include/__compare/ordering.h
45–50

Thanks!

48

Yes, the error messages are better but if I remember correctly we can't use throw because we need to support no-exceptions.

libcxx/test/libcxx/language.support/cmp/cmp.categories.pre/zero_type.verify.cpp
1

Ok.

libcxx/test/std/language.support/cmp/cmp.partialord/partialord.pass.cpp
10 ↗(On Diff #506349)

Ok, I will try.
Let's see if that break something.

fsb4000 marked 2 inline comments as done.Mar 19 2023, 4:35 AM
Harbormaster completed remote builds in B220284: Diff 506379.Mar 19 2023, 5:00 AM
fsb4000 updated this revision to Diff 506384.Mar 19 2023, 6:26 AM
Harbormaster completed remote builds in B220287: Diff 506384.Mar 19 2023, 6:51 AM
fsb4000 updated this revision to Diff 506388.Mar 19 2023, 7:00 AM
fsb4000 updated this revision to Diff 506393.Mar 19 2023, 7:28 AM
fsb4000 updated this revision to Diff 506396.Mar 19 2023, 7:55 AM
Harbormaster completed remote builds in B220297: Diff 506396.Mar 19 2023, 9:03 AM
fsb4000 updated this revision to Diff 506401.Mar 19 2023, 9:22 AM
fsb4000 retitled this revision from [libc++]Don't warn when using operator<=> with 0 to [libc++]Enforce `-Wzero-as-null-pointer-constant`.Mar 19 2023, 9:27 AM
philnik added a comment.Mar 19 2023, 9:42 AM

These are a lot more changes then expected. Let's split this up into multiple patches. I would suggest that we first enable the warning inside the clang-tidy test to check our headers and then enable the warning inside the tests. As a third patch we can then change the three way comparison.

fsb4000 updated this revision to Diff 506403.Mar 19 2023, 9:50 AM

@philnik , Okay, I'll deal with that tomorrow.

Harbormaster completed remote builds in B220303: Diff 506403.Mar 19 2023, 11:08 AM
Mordante added a comment.Mar 19 2023, 12:01 PM

Thanks for working on this!

In D146372#4204837, @philnik wrote:

These are a lot more changes then expected. Let's split this up into multiple patches. I would suggest that we first enable the warning inside the clang-tidy test to check our headers and then enable the warning inside the tests. As a third patch we can then change the three way comparison.

+1 for splitting the patch especially since the changes fail in the CI.

libcxx/test/std/input.output/iostream.format/input.streams/istream.formatted/istream.formatted.arithmetic/int.pass.cpp
50

Doesn't this work too?

EricWF requested changes to this revision.Mar 20 2023, 11:45 AM
EricWF added a subscriber: EricWF.
EricWF added inline comments.
libcxx/include/__compare/ordering.h
46

Richard Smith and I have talked about creating a special type in Clang to use here.
I think we should investigate this approach more thoroughly before going down the path suggested here.

As is, your change makes the number of values and types accepted as an argument to _CmpUnspecifiedParam MUCH larger.

Before, it would only accept the _LITERAL_ zero, now it accepts anything that evaluates to zero, including (0 + 42 - 42), foo(), etc.

So this makes the library much less conforming than it was. This cannot proceed as is.

Though I grant it's very frustrating that the warning is triggered here. But we'll need Clang's help to resolve that.

libcxx/test/libcxx/language.support/cmp/cmp.categories.pre/zero_type.verify.cpp
22

This change seems wrong. It looks like we're enforcing that an error actually occurs when zero is used.
But those test cases get removed?

Maybe we should disable the warning in this test.

This revision now requires changes to proceed.Mar 20 2023, 11:45 AM
fsb4000 abandoned this revision.Sep 20 2023, 8:44 AM
Herald added a subscriber: wangpc. · View Herald TranscriptSep 20 2023, 8:44 AM

Revision Contents

PathSize
libcxx/
include/
__algorithm/
4 lines
2 lines
__atomic/
2 lines
__compare/
10 lines
__exception/
4 lines
__functional/
12 lines
__iterator/
2 lines
__memory/
4 lines
4 lines
6 lines
2 lines
4 lines
4 lines
__random/
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
28 lines
6 lines
8 lines
30 lines
30 lines
10 lines
8 lines
test/
libcxx/
depr/
depr.default.allocator/
allocator.members/
2 lines
strings/
string.view/
2 lines
libcxx/
language.support/
cmp/
cmp.categories.pre/
std/
language.support/
cmp/
cmp.categories.pre/
22 lines
std/
depr/
depr.auto.ptr/
auto.ptr/
auto.ptr.cons/
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
auto.ptr.conv/
2 lines
2 lines
auto.ptr.members/
2 lines
2 lines
depr.c.headers/
8 lines
12 lines
4 lines
8 lines
8 lines
12 lines
4 lines
input.output/
file.streams/
c.files/
8 lines
8 lines
fstreams/
filebuf.assign/
4 lines
filebuf.virtuals/
4 lines
iostream.format/
input.streams/
iostreamclass/
iostream.assign/
8 lines
8 lines
iostream.cons/
8 lines
4 lines
istream.formatted/
istream.formatted.arithmetic/
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
4 lines
2 lines
2 lines
2 lines
2 lines
2 lines
istream_extractors/
2 lines
2 lines
2 lines
istream/
istream.assign/
8 lines
8 lines
istream.cons/
8 lines
4 lines
istream_sentry/
4 lines
output.streams/
ostream.assign/
8 lines
8 lines
ostream.cons/
8 lines
4 lines
ostream.formatted/
ostream.inserters.arithmetic/
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
ostream.inserters.character/
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
ostream.seeks/
2 lines
2 lines
2 lines
ostream.unformatted/
4 lines
4 lines
ostream_sentry/
2 lines
2 lines
iostreams.base/
ios/
basic.ios.cons/
4 lines
basic.ios.members/
2 lines
2 lines
2 lines
4 lines
2 lines
4 lines
6 lines
2 lines
2 lines
2 lines
2 lines
iostate.flags/
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
string.streams/
istringstream/
istringstream.assign/
4 lines
4 lines
4 lines
istringstream.cons/
8 lines
4 lines
8 lines
istringstream.members/
4 lines
ostringstream/
ostringstream.assign/
4 lines
4 lines
4 lines
ostringstream.cons/
8 lines
4 lines
8 lines
ostringstream.members/
4 lines
stringstream.cons/
8 lines
4 lines
4 lines
stringstream.assign/
4 lines
4 lines
4 lines
stringstream.members/
4 lines
iterators/
iterator.primitives/
iterator.traits/
2 lines
language.support/
cmp/
cmp.categories.pre/
support.dynamic/
new.delete/
new.delete.array/
2 lines
4 lines
2 lines
4 lines
new.delete.single/
2 lines
2 lines
4 lines
4 lines
support.runtime/
8 lines
localization/
locale.categories/
category.monetary/
locale.money.get/
locale.money.get.members/
2 lines
2 lines
2 lines
2 lines
2 lines
locale.money.put/
locale.money.put.members/
2 lines
2 lines
2 lines
2 lines
2 lines
category.numeric/
locale.nm.put/
facet.num.put.members/
6 lines
4 lines
12 lines
54 lines
4 lines
20 lines
54 lines
2 lines
54 lines
54 lines
locale.num.get/
facet.num.get.members/
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
4 lines
category.time/
locale.time.get.byname/
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
locale.time.get/
locale.time.get.members/
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
locale.time.put.byname/
2 lines
locale.time.put/
locale.time.put.members/
2 lines
2 lines
locales/
locale.convenience/
conversions/
conversions.buffer/
2 lines
locale/
locale.cons/
2 lines
2 lines
numerics/
c.math/
12 lines
complex.number/
cmplx.over/
4 lines
6 lines
4 lines
4 lines
6 lines
6 lines
4 lines
strings/
c.strings/
8 lines
12 lines
4 lines
utilities/
allocator.adaptor/
allocator.adaptor.members/
4 lines
2 lines
function.objects/
arithmetic.operations/
2 lines
bitwise.operations/
2 lines
comparisons/
2 lines
logical.operations/
2 lines
refwrap/
2 lines
memory/
util.smartptr/
util.smartptr.shared/
util.smartptr.shared.assign/
8 lines
8 lines
8 lines
10 lines
util.smartptr.shared.cast/
4 lines
util.smartptr.shared.const/
4 lines
2 lines
4 lines
2 lines
6 lines
8 lines
util.smartptr.shared.mod/
4 lines
util.smartptr.weak/
util.smartptr.weak.obs/
4 lines
smartptr/
unique.ptr/
unique.ptr.class/
unique.ptr.asgn/
6 lines
2 lines
2 lines
2 lines
2 lines
unique.ptr.ctor/
4 lines
6 lines
6 lines
1 line
6 lines
utility/
pairs/
pairs.pair/
2 lines
support/
2 lines
14 lines
2 lines
2 lines
utils/
libcxx/
test/
2 lines
1 line
libunwind/
test/
2 lines
4 lines
4 lines

Diff 506403

libcxx/include/__algorithm/stable_partition.h

Show First 20 Lines • Show All 131 Lines • ▼ Show 20 Lines while (true)
break; break;
++__first; ++__first;
} }
// We now have a reduced range [__first, __last) // We now have a reduced range [__first, __last)
// *__first is known to be false // *__first is known to be false
typedef typename iterator_traits<_ForwardIterator>::difference_type difference_type; typedef typename iterator_traits<_ForwardIterator>::difference_type difference_type;
typedef typename iterator_traits<_ForwardIterator>::value_type value_type; typedef typename iterator_traits<_ForwardIterator>::value_type value_type;
difference_type __len = _IterOps<_AlgPolicy>::distance(__first, __last); difference_type __len = _IterOps<_AlgPolicy>::distance(__first, __last);
pair<value_type*, ptrdiff_t> __p(0, 0); pair<value_type*, ptrdiff_t> __p(nullptr, 0);
unique_ptr<value_type, __return_temporary_buffer> __h; unique_ptr<value_type, __return_temporary_buffer> __h;
if (__len >= __alloc_limit) if (__len >= __alloc_limit)
{ {
// TODO: Remove the use of std::get_temporary_buffer // TODO: Remove the use of std::get_temporary_buffer
_LIBCPP_SUPPRESS_DEPRECATED_PUSH _LIBCPP_SUPPRESS_DEPRECATED_PUSH
__p = _VSTD::get_temporary_buffer<value_type>(__len); __p = _VSTD::get_temporary_buffer<value_type>(__len);
_LIBCPP_SUPPRESS_DEPRECATED_POP _LIBCPP_SUPPRESS_DEPRECATED_POP
__h.reset(__p.first); __h.reset(__p.first);
▲ Show 20 Lines • Show All 137 Lines • ▼ Show 20 Lines do
if (__first == --__last) if (__first == --__last)
return __first; return __first;
} while (!__pred(*__last)); } while (!__pred(*__last));
// We now have a reduced range [__first, __last] // We now have a reduced range [__first, __last]
// *__first is known to be false // *__first is known to be false
// *__last is known to be true // *__last is known to be true
// __len >= 2 // __len >= 2
difference_type __len = _IterOps<_AlgPolicy>::distance(__first, __last) + 1; difference_type __len = _IterOps<_AlgPolicy>::distance(__first, __last) + 1;
pair<value_type*, ptrdiff_t> __p(0, 0); pair<value_type*, ptrdiff_t> __p(nullptr, 0);
unique_ptr<value_type, __return_temporary_buffer> __h; unique_ptr<value_type, __return_temporary_buffer> __h;
if (__len >= __alloc_limit) if (__len >= __alloc_limit)
{ {
// TODO: Remove the use of std::get_temporary_buffer // TODO: Remove the use of std::get_temporary_buffer
_LIBCPP_SUPPRESS_DEPRECATED_PUSH _LIBCPP_SUPPRESS_DEPRECATED_PUSH
__p = _VSTD::get_temporary_buffer<value_type>(__len); __p = _VSTD::get_temporary_buffer<value_type>(__len);
_LIBCPP_SUPPRESS_DEPRECATED_POP _LIBCPP_SUPPRESS_DEPRECATED_POP
__h.reset(__p.first); __h.reset(__p.first);
Show All 26 Lines

libcxx/include/__algorithm/stable_sort.h

Show First 20 Lines • Show All 211 Lines • ▼ Show 20 Lines
template <class _AlgPolicy, class _RandomAccessIterator, class _Compare> template <class _AlgPolicy, class _RandomAccessIterator, class _Compare>
inline _LIBCPP_HIDE_FROM_ABI inline _LIBCPP_HIDE_FROM_ABI
void __stable_sort_impl(_RandomAccessIterator __first, _RandomAccessIterator __last, _Compare& __comp) { void __stable_sort_impl(_RandomAccessIterator __first, _RandomAccessIterator __last, _Compare& __comp) {
using value_type = typename iterator_traits<_RandomAccessIterator>::value_type; using value_type = typename iterator_traits<_RandomAccessIterator>::value_type;
using difference_type = typename iterator_traits<_RandomAccessIterator>::difference_type; using difference_type = typename iterator_traits<_RandomAccessIterator>::difference_type;
difference_type __len = __last - __first; difference_type __len = __last - __first;
pair<value_type*, ptrdiff_t> __buf(0, 0); pair<value_type*, ptrdiff_t> __buf(nullptr, 0);
unique_ptr<value_type, __return_temporary_buffer> __h; unique_ptr<value_type, __return_temporary_buffer> __h;
if (__len > static_cast<difference_type>(__stable_sort_switch<value_type>::value)) { if (__len > static_cast<difference_type>(__stable_sort_switch<value_type>::value)) {
// TODO: Remove the use of std::get_temporary_buffer // TODO: Remove the use of std::get_temporary_buffer
_LIBCPP_SUPPRESS_DEPRECATED_PUSH _LIBCPP_SUPPRESS_DEPRECATED_PUSH
__buf = std::get_temporary_buffer<value_type>(__len); __buf = std::get_temporary_buffer<value_type>(__len);
_LIBCPP_SUPPRESS_DEPRECATED_POP _LIBCPP_SUPPRESS_DEPRECATED_POP
__h.reset(__buf.first); __h.reset(__buf.first);
} }
Show All 19 Lines

libcxx/include/__atomic/is_always_lock_free.h

Show All 14 Lines
# pragma GCC system_header # pragma GCC system_header
#endif #endif
_LIBCPP_BEGIN_NAMESPACE_STD _LIBCPP_BEGIN_NAMESPACE_STD
template <class _Tp> template <class _Tp>
struct __libcpp_is_always_lock_free { struct __libcpp_is_always_lock_free {
// __atomic_always_lock_free is available in all Standard modes // __atomic_always_lock_free is available in all Standard modes
static const bool __value = __atomic_always_lock_free(sizeof(_Tp), 0); static const bool __value = __atomic_always_lock_free(sizeof(_Tp), nullptr);
}; };
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP___ATOMIC_IS_ALWAYS_LOCK_FREE_H #endif // _LIBCPP___ATOMIC_IS_ALWAYS_LOCK_FREE_H

libcxx/include/__compare/ordering.h

Show All 33 Lines
class partial_ordering; class partial_ordering;
class weak_ordering; class weak_ordering;
class strong_ordering; class strong_ordering;
template<class _Tp, class... _Args> template<class _Tp, class... _Args>
inline constexpr bool __one_of_v = (is_same_v<_Tp, _Args> || ...); inline constexpr bool __one_of_v = (is_same_v<_Tp, _Args> || ...);
void __literal_zero_is_expected();
struct _CmpUnspecifiedParam { struct _CmpUnspecifiedParam {
_LIBCPP_HIDE_FROM_ABI constexpr consteval
_CmpUnspecifiedParam(int _CmpUnspecifiedParam::*) noexcept {} _CmpUnspecifiedParam(int __literal_zero) noexcept {
EricWFUnsubmitted
Not Done
ReplyInline Actions

Richard Smith and I have talked about creating a special type in Clang to use here.
I think we should investigate this approach more thoroughly before going down the path suggested here.

As is, your change makes the number of values and types accepted as an argument to _CmpUnspecifiedParam MUCH larger.

Before, it would only accept the _LITERAL_ zero, now it accepts anything that evaluates to zero, including (0 + 42 - 42), foo(), etc.

So this makes the library much less conforming than it was. This cannot proceed as is.

Though I grant it's very frustrating that the warning is triggered here. But we'll need Clang's help to resolve that.

EricWF: Richard Smith and I have talked about creating a special type in Clang to use here. I think we…
if (__literal_zero != 0) {
__literal_zero_is_expected();
philnikUnsubmitted
Not Done
ReplyInline Actions
if (__literal_zero != 0) {
- __builtin_abort();
+ throw "orderings can only be compared to a literal 0";
}
}

This produces way better error messages on most compilers: https://godbolt.org/z/PhjaTav68

philnik: This produces way better error messages on most compilers: https://godbolt.org/z/PhjaTav68
fsb4000AuthorUnsubmitted
Done
ReplyInline Actions

Yes, the error messages are better but if I remember correctly we can't use throw because we need to support no-exceptions.

fsb4000: Yes, the error messages are better but if I remember correctly we can't use `throw` because we…
}
}
philnikUnsubmitted
Done
ReplyInline Actions
struct _CmpUnspecifiedParam {
- _LIBCPP_HIDE_FROM_ABI consteval
+ consteval
_CmpUnspecifiedParam(int __literal_zero) noexcept {
philnik:
fsb4000AuthorUnsubmitted
Done
ReplyInline Actions

Thanks!

fsb4000: Thanks!
template<class _Tp, class = enable_if_t<!__one_of_v<_Tp, int, partial_ordering, weak_ordering, strong_ordering>>> template<class _Tp, class = enable_if_t<!__one_of_v<_Tp, int, partial_ordering, weak_ordering, strong_ordering>>>
_CmpUnspecifiedParam(_Tp) = delete; _CmpUnspecifiedParam(_Tp) = delete;
}; };
class partial_ordering { class partial_ordering {
using _ValueT = signed char; using _ValueT = signed char;
▲ Show 20 Lines • Show All 274 Lines • Show Last 20 Lines

libcxx/include/__exception/nested_exception.h

Show First 20 Lines • Show All 80 Lines • ▼ Show 20 Lines
template <class _From, class _To> template <class _From, class _To>
struct __can_dynamic_cast struct __can_dynamic_cast
: _BoolConstant< is_polymorphic<_From>::value && : _BoolConstant< is_polymorphic<_From>::value &&
(!is_base_of<_To, _From>::value || is_convertible<const _From*, const _To*>::value)> {}; (!is_base_of<_To, _From>::value || is_convertible<const _From*, const _To*>::value)> {};
template <class _Ep> template <class _Ep>
inline _LIBCPP_HIDE_FROM_ABI void inline _LIBCPP_HIDE_FROM_ABI void
rethrow_if_nested(const _Ep& __e, __enable_if_t< __can_dynamic_cast<_Ep, nested_exception>::value>* = 0) { rethrow_if_nested(const _Ep& __e, __enable_if_t< __can_dynamic_cast<_Ep, nested_exception>::value>* = nullptr) {
const nested_exception* __nep = dynamic_cast<const nested_exception*>(std::addressof(__e)); const nested_exception* __nep = dynamic_cast<const nested_exception*>(std::addressof(__e));
if (__nep) if (__nep)
__nep->rethrow_nested(); __nep->rethrow_nested();
} }
template <class _Ep> template <class _Ep>
inline _LIBCPP_HIDE_FROM_ABI void inline _LIBCPP_HIDE_FROM_ABI void
rethrow_if_nested(const _Ep&, __enable_if_t<!__can_dynamic_cast<_Ep, nested_exception>::value>* = 0) {} rethrow_if_nested(const _Ep&, __enable_if_t<!__can_dynamic_cast<_Ep, nested_exception>::value>* = nullptr) {}
} // namespace std } // namespace std
#endif // _LIBCPP___EXCEPTION_NESTED_EXCEPTION_H #endif // _LIBCPP___EXCEPTION_NESTED_EXCEPTION_H

libcxx/include/__functional/weak_result_type.h

Show All 23 Lines
_LIBCPP_BEGIN_NAMESPACE_STD _LIBCPP_BEGIN_NAMESPACE_STD
template <class _Tp> template <class _Tp>
struct __has_result_type struct __has_result_type
{ {
private: private:
template <class _Up> static false_type __test(...); template <class _Up> static false_type __test(...);
template <class _Up> static true_type __test(typename _Up::result_type* = 0); template <class _Up> static true_type __test(typename _Up::result_type* = nullptr);
public: public:
static const bool value = decltype(__test<_Tp>(0))::value; static const bool value = decltype(__test<_Tp>(nullptr))::value;
}; };
// __weak_result_type // __weak_result_type
template <class _Tp> template <class _Tp>
struct __derives_from_unary_function struct __derives_from_unary_function
{ {
private: private:
struct __two {char __lx; char __lxx;}; struct __two {char __lx; char __lxx;};
static __two __test(...); static __two __test(...);
template <class _Ap, class _Rp> template <class _Ap, class _Rp>
static __unary_function<_Ap, _Rp> static __unary_function<_Ap, _Rp>
__test(const volatile __unary_function<_Ap, _Rp>*); __test(const volatile __unary_function<_Ap, _Rp>*);
public: public:
static const bool value = !is_same<decltype(__test((_Tp*)0)), __two>::value; static const bool value = !is_same<decltype(__test((_Tp*)nullptr)), __two>::value;
typedef decltype(__test((_Tp*)0)) type; typedef decltype(__test((_Tp*)nullptr)) type;
}; };
template <class _Tp> template <class _Tp>
struct __derives_from_binary_function struct __derives_from_binary_function
{ {
private: private:
struct __two {char __lx; char __lxx;}; struct __two {char __lx; char __lxx;};
static __two __test(...); static __two __test(...);
template <class _A1, class _A2, class _Rp> template <class _A1, class _A2, class _Rp>
static __binary_function<_A1, _A2, _Rp> static __binary_function<_A1, _A2, _Rp>
__test(const volatile __binary_function<_A1, _A2, _Rp>*); __test(const volatile __binary_function<_A1, _A2, _Rp>*);
public: public:
static const bool value = !is_same<decltype(__test((_Tp*)0)), __two>::value; static const bool value = !is_same<decltype(__test((_Tp*)nullptr)), __two>::value;
typedef decltype(__test((_Tp*)0)) type; typedef decltype(__test((_Tp*)nullptr)) type;
}; };
template <class _Tp, bool = __derives_from_unary_function<_Tp>::value> template <class _Tp, bool = __derives_from_unary_function<_Tp>::value>
struct __maybe_derive_from_unary_function // bool is true struct __maybe_derive_from_unary_function // bool is true
: public __derives_from_unary_function<_Tp>::type : public __derives_from_unary_function<_Tp>::type
{ {
}; };
▲ Show 20 Lines • Show All 220 Lines • Show Last 20 Lines

libcxx/include/__iterator/iterator_traits.h

Show First 20 Lines • Show All 127 Lines • ▼ Show 20 Lines
private: private:
template <class _Up> static false_type __test(...); template <class _Up> static false_type __test(...);
template <class _Up> static true_type __test(__void_t<typename _Up::iterator_category>* = nullptr, template <class _Up> static true_type __test(__void_t<typename _Up::iterator_category>* = nullptr,
__void_t<typename _Up::difference_type>* = nullptr, __void_t<typename _Up::difference_type>* = nullptr,
__void_t<typename _Up::value_type>* = nullptr, __void_t<typename _Up::value_type>* = nullptr,
__void_t<typename _Up::reference>* = nullptr, __void_t<typename _Up::reference>* = nullptr,
__void_t<typename _Up::pointer>* = nullptr); __void_t<typename _Up::pointer>* = nullptr);
public: public:
static const bool value = decltype(__test<_Tp>(0,0,0,0,0))::value; static const bool value = decltype(__test<_Tp>(nullptr,nullptr,nullptr,nullptr,nullptr))::value;
}; };
template <class _Tp> template <class _Tp>
struct __has_iterator_category struct __has_iterator_category
{ {
private: private:
template <class _Up> static false_type __test(...); template <class _Up> static false_type __test(...);
▲ Show 20 Lines • Show All 395 Lines • Show Last 20 Lines

libcxx/include/__memory/auto_ptr.h

Show All 28 Lines
template<class _Tp> template<class _Tp>
class _LIBCPP_TEMPLATE_VIS _LIBCPP_DEPRECATED_IN_CXX11 auto_ptr class _LIBCPP_TEMPLATE_VIS _LIBCPP_DEPRECATED_IN_CXX11 auto_ptr
{ {
private: private:
_Tp* __ptr_; _Tp* __ptr_;
public: public:
typedef _Tp element_type; typedef _Tp element_type;
_LIBCPP_INLINE_VISIBILITY explicit auto_ptr(_Tp* __p = 0) _NOEXCEPT : __ptr_(__p) {} _LIBCPP_INLINE_VISIBILITY explicit auto_ptr(_Tp* __p = nullptr) _NOEXCEPT : __ptr_(__p) {}
_LIBCPP_INLINE_VISIBILITY auto_ptr(auto_ptr& __p) _NOEXCEPT : __ptr_(__p.release()) {} _LIBCPP_INLINE_VISIBILITY auto_ptr(auto_ptr& __p) _NOEXCEPT : __ptr_(__p.release()) {}
template<class _Up> _LIBCPP_INLINE_VISIBILITY auto_ptr(auto_ptr<_Up>& __p) _NOEXCEPT template<class _Up> _LIBCPP_INLINE_VISIBILITY auto_ptr(auto_ptr<_Up>& __p) _NOEXCEPT
: __ptr_(__p.release()) {} : __ptr_(__p.release()) {}
_LIBCPP_INLINE_VISIBILITY auto_ptr& operator=(auto_ptr& __p) _NOEXCEPT _LIBCPP_INLINE_VISIBILITY auto_ptr& operator=(auto_ptr& __p) _NOEXCEPT
{reset(__p.release()); return *this;} {reset(__p.release()); return *this;}
template<class _Up> _LIBCPP_INLINE_VISIBILITY auto_ptr& operator=(auto_ptr<_Up>& __p) _NOEXCEPT template<class _Up> _LIBCPP_INLINE_VISIBILITY auto_ptr& operator=(auto_ptr<_Up>& __p) _NOEXCEPT
{reset(__p.release()); return *this;} {reset(__p.release()); return *this;}
_LIBCPP_INLINE_VISIBILITY auto_ptr& operator=(auto_ptr_ref<_Tp> __p) _NOEXCEPT _LIBCPP_INLINE_VISIBILITY auto_ptr& operator=(auto_ptr_ref<_Tp> __p) _NOEXCEPT
{reset(__p.__ptr_); return *this;} {reset(__p.__ptr_); return *this;}
_LIBCPP_INLINE_VISIBILITY ~auto_ptr() _NOEXCEPT {delete __ptr_;} _LIBCPP_INLINE_VISIBILITY ~auto_ptr() _NOEXCEPT {delete __ptr_;}
_LIBCPP_INLINE_VISIBILITY _Tp& operator*() const _NOEXCEPT _LIBCPP_INLINE_VISIBILITY _Tp& operator*() const _NOEXCEPT
{return *__ptr_;} {return *__ptr_;}
_LIBCPP_INLINE_VISIBILITY _Tp* operator->() const _NOEXCEPT {return __ptr_;} _LIBCPP_INLINE_VISIBILITY _Tp* operator->() const _NOEXCEPT {return __ptr_;}
_LIBCPP_INLINE_VISIBILITY _Tp* get() const _NOEXCEPT {return __ptr_;} _LIBCPP_INLINE_VISIBILITY _Tp* get() const _NOEXCEPT {return __ptr_;}
_LIBCPP_INLINE_VISIBILITY _Tp* release() _NOEXCEPT _LIBCPP_INLINE_VISIBILITY _Tp* release() _NOEXCEPT
{ {
_Tp* __t = __ptr_; _Tp* __t = __ptr_;
__ptr_ = nullptr; __ptr_ = nullptr;
return __t; return __t;
} }
_LIBCPP_INLINE_VISIBILITY void reset(_Tp* __p = 0) _NOEXCEPT _LIBCPP_INLINE_VISIBILITY void reset(_Tp* __p = nullptr) _NOEXCEPT
{ {
if (__ptr_ != __p) if (__ptr_ != __p)
delete __ptr_; delete __ptr_;
__ptr_ = __p; __ptr_ = __p;
} }
_LIBCPP_INLINE_VISIBILITY auto_ptr(auto_ptr_ref<_Tp> __p) _NOEXCEPT : __ptr_(__p.__ptr_) {} _LIBCPP_INLINE_VISIBILITY auto_ptr(auto_ptr_ref<_Tp> __p) _NOEXCEPT : __ptr_(__p.__ptr_) {}
template<class _Up> _LIBCPP_INLINE_VISIBILITY operator auto_ptr_ref<_Up>() _NOEXCEPT template<class _Up> _LIBCPP_INLINE_VISIBILITY operator auto_ptr_ref<_Up>() _NOEXCEPT
Show All 17 Lines

libcxx/include/__memory/pointer_traits.h

Show First 20 Lines • Show All 73 Lines • ▼ Show 20 Lines
}; };
template <class _Tp, class _Up> template <class _Tp, class _Up>
struct __has_rebind struct __has_rebind
{ {
private: private:
template <class _Xp> static false_type __test(...); template <class _Xp> static false_type __test(...);
_LIBCPP_SUPPRESS_DEPRECATED_PUSH _LIBCPP_SUPPRESS_DEPRECATED_PUSH
template <class _Xp> static true_type __test(typename _Xp::template rebind<_Up>* = 0); template <class _Xp> static true_type __test(typename _Xp::template rebind<_Up>* = nullptr);
_LIBCPP_SUPPRESS_DEPRECATED_POP _LIBCPP_SUPPRESS_DEPRECATED_POP
public: public:
static const bool value = decltype(__test<_Tp>(0))::value; static const bool value = decltype(__test<_Tp>(nullptr))::value;
}; };
template <class _Tp, class _Up, bool = __has_rebind<_Tp, _Up>::value> template <class _Tp, class _Up, bool = __has_rebind<_Tp, _Up>::value>
struct __pointer_traits_rebind struct __pointer_traits_rebind
{ {
#ifndef _LIBCPP_CXX03_LANG #ifndef _LIBCPP_CXX03_LANG
typedef _LIBCPP_NODEBUG typename _Tp::template rebind<_Up> type; typedef _LIBCPP_NODEBUG typename _Tp::template rebind<_Up> type;
#else #else
▲ Show 20 Lines • Show All 149 Lines • Show Last 20 Lines

libcxx/include/__memory/shared_ptr.h

Show First 20 Lines • Show All 1,571 Lines • ▼ Show 20 Lines
private: private:
element_type* __ptr_; element_type* __ptr_;
__shared_weak_count* __cntrl_; __shared_weak_count* __cntrl_;
public: public:
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
_LIBCPP_CONSTEXPR weak_ptr() _NOEXCEPT; _LIBCPP_CONSTEXPR weak_ptr() _NOEXCEPT;
template<class _Yp> _LIBCPP_INLINE_VISIBILITY weak_ptr(shared_ptr<_Yp> const& __r, template<class _Yp> _LIBCPP_INLINE_VISIBILITY weak_ptr(shared_ptr<_Yp> const& __r,
typename enable_if<__compatible_with<_Yp, _Tp>::value, __nat*>::type = 0) typename enable_if<__compatible_with<_Yp, _Tp>::value, __nat*>::type = nullptr)
_NOEXCEPT; _NOEXCEPT;
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
weak_ptr(weak_ptr const& __r) _NOEXCEPT; weak_ptr(weak_ptr const& __r) _NOEXCEPT;
template<class _Yp> _LIBCPP_INLINE_VISIBILITY weak_ptr(weak_ptr<_Yp> const& __r, template<class _Yp> _LIBCPP_INLINE_VISIBILITY weak_ptr(weak_ptr<_Yp> const& __r,
typename enable_if<__compatible_with<_Yp, _Tp>::value, __nat*>::type = 0) typename enable_if<__compatible_with<_Yp, _Tp>::value, __nat*>::type = nullptr)
_NOEXCEPT; _NOEXCEPT;
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
weak_ptr(weak_ptr&& __r) _NOEXCEPT; weak_ptr(weak_ptr&& __r) _NOEXCEPT;
template<class _Yp> _LIBCPP_INLINE_VISIBILITY weak_ptr(weak_ptr<_Yp>&& __r, template<class _Yp> _LIBCPP_INLINE_VISIBILITY weak_ptr(weak_ptr<_Yp>&& __r,
typename enable_if<__compatible_with<_Yp, _Tp>::value, __nat*>::type = 0) typename enable_if<__compatible_with<_Yp, _Tp>::value, __nat*>::type = nullptr)
_NOEXCEPT; _NOEXCEPT;
~weak_ptr(); ~weak_ptr();
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
weak_ptr& operator=(weak_ptr const& __r) _NOEXCEPT; weak_ptr& operator=(weak_ptr const& __r) _NOEXCEPT;
template<class _Yp> template<class _Yp>
typename enable_if typename enable_if
< <
▲ Show 20 Lines • Show All 491 Lines • Show Last 20 Lines

libcxx/include/__memory/temporary_buffer.h

Show All 21 Lines
_LIBCPP_BEGIN_NAMESPACE_STD _LIBCPP_BEGIN_NAMESPACE_STD
template <class _Tp> template <class _Tp>
_LIBCPP_NODISCARD_EXT _LIBCPP_HIDE_FROM_ABI _LIBCPP_NO_CFI _LIBCPP_DEPRECATED_IN_CXX17 _LIBCPP_NODISCARD_EXT _LIBCPP_HIDE_FROM_ABI _LIBCPP_NO_CFI _LIBCPP_DEPRECATED_IN_CXX17
pair<_Tp*, ptrdiff_t> pair<_Tp*, ptrdiff_t>
get_temporary_buffer(ptrdiff_t __n) _NOEXCEPT get_temporary_buffer(ptrdiff_t __n) _NOEXCEPT
{ {
pair<_Tp*, ptrdiff_t> __r(0, 0); pair<_Tp*, ptrdiff_t> __r(nullptr, 0);
const ptrdiff_t __m = (~ptrdiff_t(0) ^ const ptrdiff_t __m = (~ptrdiff_t(0) ^
ptrdiff_t(ptrdiff_t(1) << (sizeof(ptrdiff_t) * __CHAR_BIT__ - 1))) ptrdiff_t(ptrdiff_t(1) << (sizeof(ptrdiff_t) * __CHAR_BIT__ - 1)))
/ sizeof(_Tp); / sizeof(_Tp);
if (__n > __m) if (__n > __m)
__n = __m; __n = __m;
while (__n > 0) while (__n > 0)
{ {
#if !defined(_LIBCPP_HAS_NO_ALIGNED_ALLOCATION) #if !defined(_LIBCPP_HAS_NO_ALIGNED_ALLOCATION)
▲ Show 20 Lines • Show All 49 Lines • Show Last 20 Lines

libcxx/include/__memory/unique_ptr.h

Show First 20 Lines • Show All 51 Lines • ▼ Show 20 Lines static_assert(!is_function<_Tp>::value,
"default_delete cannot be instantiated for function types"); "default_delete cannot be instantiated for function types");
#ifndef _LIBCPP_CXX03_LANG #ifndef _LIBCPP_CXX03_LANG
_LIBCPP_INLINE_VISIBILITY constexpr default_delete() _NOEXCEPT = default; _LIBCPP_INLINE_VISIBILITY constexpr default_delete() _NOEXCEPT = default;
#else #else
_LIBCPP_INLINE_VISIBILITY default_delete() {} _LIBCPP_INLINE_VISIBILITY default_delete() {}
#endif #endif
template <class _Up> template <class _Up>
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX23 default_delete( _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX23 default_delete(
const default_delete<_Up>&, typename enable_if<is_convertible<_Up*, _Tp*>::value>::type* = 0) _NOEXCEPT {} const default_delete<_Up>&, typename enable_if<is_convertible<_Up*, _Tp*>::value>::type* = nullptr) _NOEXCEPT {}
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX23 void operator()(_Tp* __ptr) const _NOEXCEPT { _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX23 void operator()(_Tp* __ptr) const _NOEXCEPT {
static_assert(sizeof(_Tp) >= 0, "cannot delete an incomplete type"); static_assert(sizeof(_Tp) >= 0, "cannot delete an incomplete type");
static_assert(!is_void<_Tp>::value, "cannot delete an incomplete type"); static_assert(!is_void<_Tp>::value, "cannot delete an incomplete type");
delete __ptr; delete __ptr;
} }
}; };
template <class _Tp> template <class _Tp>
struct _LIBCPP_TEMPLATE_VIS default_delete<_Tp[]> { struct _LIBCPP_TEMPLATE_VIS default_delete<_Tp[]> {
private: private:
template <class _Up> template <class _Up>
struct _EnableIfConvertible struct _EnableIfConvertible
: enable_if<is_convertible<_Up(*)[], _Tp(*)[]>::value> {}; : enable_if<is_convertible<_Up(*)[], _Tp(*)[]>::value> {};
public: public:
#ifndef _LIBCPP_CXX03_LANG #ifndef _LIBCPP_CXX03_LANG
_LIBCPP_INLINE_VISIBILITY constexpr default_delete() _NOEXCEPT = default; _LIBCPP_INLINE_VISIBILITY constexpr default_delete() _NOEXCEPT = default;
#else #else
_LIBCPP_INLINE_VISIBILITY default_delete() {} _LIBCPP_INLINE_VISIBILITY default_delete() {}
#endif #endif
template <class _Up> template <class _Up>
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX23 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX23
default_delete(const default_delete<_Up[]>&, typename _EnableIfConvertible<_Up>::type* = 0) _NOEXCEPT {} default_delete(const default_delete<_Up[]>&, typename _EnableIfConvertible<_Up>::type* = nullptr) _NOEXCEPT {}
template <class _Up> template <class _Up>
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX23 typename _EnableIfConvertible<_Up>::type _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX23 typename _EnableIfConvertible<_Up>::type
operator()(_Up* __ptr) const _NOEXCEPT { operator()(_Up* __ptr) const _NOEXCEPT {
static_assert(sizeof(_Up) >= 0, "cannot delete an incomplete type"); static_assert(sizeof(_Up) >= 0, "cannot delete an incomplete type");
delete[] __ptr; delete[] __ptr;
} }
}; };
▲ Show 20 Lines • Show All 653 Lines • Show Last 20 Lines

libcxx/include/__memory/uses_allocator.h

Show All 19 Lines
_LIBCPP_BEGIN_NAMESPACE_STD _LIBCPP_BEGIN_NAMESPACE_STD
template <class _Tp> template <class _Tp>
struct __has_allocator_type struct __has_allocator_type
{ {
private: private:
template <class _Up> static false_type __test(...); template <class _Up> static false_type __test(...);
template <class _Up> static true_type __test(typename _Up::allocator_type* = 0); template <class _Up> static true_type __test(typename _Up::allocator_type* = nullptr);
public: public:
static const bool value = decltype(__test<_Tp>(0))::value; static const bool value = decltype(__test<_Tp>(nullptr))::value;
}; };
template <class _Tp, class _Alloc, bool = __has_allocator_type<_Tp>::value> template <class _Tp, class _Alloc, bool = __has_allocator_type<_Tp>::value>
struct __uses_allocator struct __uses_allocator
: public integral_constant<bool, : public integral_constant<bool,
is_convertible<_Alloc, typename _Tp::allocator_type>::value> is_convertible<_Alloc, typename _Tp::allocator_type>::value>
{ {
}; };
Show All 21 Lines

libcxx/include/__random/discard_block_engine.h

Show First 20 Lines • Show All 70 Lines • ▼ Show 20 Lines explicit discard_block_engine(_Engine&& __e)
: __e_(_VSTD::move(__e)), __n_(0) {} : __e_(_VSTD::move(__e)), __n_(0) {}
#endif // _LIBCPP_CXX03_LANG #endif // _LIBCPP_CXX03_LANG
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
explicit discard_block_engine(result_type __sd) : __e_(__sd), __n_(0) {} explicit discard_block_engine(result_type __sd) : __e_(__sd), __n_(0) {}
template<class _Sseq> template<class _Sseq>
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
explicit discard_block_engine(_Sseq& __q, explicit discard_block_engine(_Sseq& __q,
typename enable_if<__is_seed_sequence<_Sseq, discard_block_engine>::value && typename enable_if<__is_seed_sequence<_Sseq, discard_block_engine>::value &&
!is_convertible<_Sseq, _Engine>::value>::type* = 0) !is_convertible<_Sseq, _Engine>::value>::type* = nullptr)
: __e_(__q), __n_(0) {} : __e_(__q), __n_(0) {}
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
void seed() {__e_.seed(); __n_ = 0;} void seed() {__e_.seed(); __n_ = 0;}
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
void seed(result_type __sd) {__e_.seed(__sd); __n_ = 0;} void seed(result_type __sd) {__e_.seed(__sd); __n_ = 0;}
template<class _Sseq> template<class _Sseq>
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
typename enable_if typename enable_if
▲ Show 20 Lines • Show All 120 Lines • Show Last 20 Lines

libcxx/include/__random/independent_bits_engine.h

Show First 20 Lines • Show All 102 Lines • ▼ Show 20 Lines explicit independent_bits_engine(_Engine&& __e)
: __e_(_VSTD::move(__e)) {} : __e_(_VSTD::move(__e)) {}
#endif // _LIBCPP_CXX03_LANG #endif // _LIBCPP_CXX03_LANG
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
explicit independent_bits_engine(result_type __sd) : __e_(__sd) {} explicit independent_bits_engine(result_type __sd) : __e_(__sd) {}
template<class _Sseq> template<class _Sseq>
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
explicit independent_bits_engine(_Sseq& __q, explicit independent_bits_engine(_Sseq& __q,
typename enable_if<__is_seed_sequence<_Sseq, independent_bits_engine>::value && typename enable_if<__is_seed_sequence<_Sseq, independent_bits_engine>::value &&
!is_convertible<_Sseq, _Engine>::value>::type* = 0) !is_convertible<_Sseq, _Engine>::value>::type* = nullptr)
: __e_(__q) {} : __e_(__q) {}
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
void seed() {__e_.seed();} void seed() {__e_.seed();}
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
void seed(result_type __sd) {__e_.seed(__sd);} void seed(result_type __sd) {__e_.seed(__sd);}
template<class _Sseq> template<class _Sseq>
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
typename enable_if typename enable_if
▲ Show 20 Lines • Show All 151 Lines • Show Last 20 Lines

libcxx/include/__random/linear_congruential_engine.h

Show First 20 Lines • Show All 243 Lines • ▼ Show 20 Lines#else
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
explicit linear_congruential_engine(result_type __s = default_seed) { explicit linear_congruential_engine(result_type __s = default_seed) {
seed(__s); seed(__s);
} }
#endif #endif
template<class _Sseq> template<class _Sseq>
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
explicit linear_congruential_engine(_Sseq& __q, explicit linear_congruential_engine(_Sseq& __q,
typename enable_if<__is_seed_sequence<_Sseq, linear_congruential_engine>::value>::type* = 0) typename enable_if<__is_seed_sequence<_Sseq, linear_congruential_engine>::value>::type* = nullptr)
{seed(__q);} {seed(__q);}
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
void seed(result_type __s = default_seed) void seed(result_type __s = default_seed)
{seed(integral_constant<bool, __m == 0>(), {seed(integral_constant<bool, __m == 0>(),
integral_constant<bool, __c == 0>(), __s);} integral_constant<bool, __c == 0>(), __s);}
template<class _Sseq> template<class _Sseq>
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
typename enable_if typename enable_if
▲ Show 20 Lines • Show All 140 Lines • Show Last 20 Lines

libcxx/include/__random/mersenne_twister_engine.h

Show First 20 Lines • Show All 132 Lines • ▼ Show 20 Lines#else
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
explicit mersenne_twister_engine(result_type __sd = default_seed) { explicit mersenne_twister_engine(result_type __sd = default_seed) {
seed(__sd); seed(__sd);
} }
#endif #endif
template<class _Sseq> template<class _Sseq>
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
explicit mersenne_twister_engine(_Sseq& __q, explicit mersenne_twister_engine(_Sseq& __q,
typename enable_if<__is_seed_sequence<_Sseq, mersenne_twister_engine>::value>::type* = 0) typename enable_if<__is_seed_sequence<_Sseq, mersenne_twister_engine>::value>::type* = nullptr)
{seed(__q);} {seed(__q);}
void seed(result_type __sd = default_seed); void seed(result_type __sd = default_seed);
template<class _Sseq> template<class _Sseq>
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
typename enable_if typename enable_if
< <
__is_seed_sequence<_Sseq, mersenne_twister_engine>::value, __is_seed_sequence<_Sseq, mersenne_twister_engine>::value,
void void
▲ Show 20 Lines • Show All 384 Lines • Show Last 20 Lines

libcxx/include/__random/shuffle_order_engine.h

Show First 20 Lines • Show All 96 Lines • ▼ Show 20 Lines explicit shuffle_order_engine(_Engine&& __e)
: __e_(_VSTD::move(__e)) {__init();} : __e_(_VSTD::move(__e)) {__init();}
#endif // _LIBCPP_CXX03_LANG #endif // _LIBCPP_CXX03_LANG
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
explicit shuffle_order_engine(result_type __sd) : __e_(__sd) {__init();} explicit shuffle_order_engine(result_type __sd) : __e_(__sd) {__init();}
template<class _Sseq> template<class _Sseq>
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
explicit shuffle_order_engine(_Sseq& __q, explicit shuffle_order_engine(_Sseq& __q,
typename enable_if<__is_seed_sequence<_Sseq, shuffle_order_engine>::value && typename enable_if<__is_seed_sequence<_Sseq, shuffle_order_engine>::value &&
!is_convertible<_Sseq, _Engine>::value>::type* = 0) !is_convertible<_Sseq, _Engine>::value>::type* = nullptr)
: __e_(__q) {__init();} : __e_(__q) {__init();}
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
void seed() {__e_.seed(); __init();} void seed() {__e_.seed(); __init();}
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
void seed(result_type __sd) {__e_.seed(__sd); __init();} void seed(result_type __sd) {__e_.seed(__sd); __init();}
template<class _Sseq> template<class _Sseq>
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
typename enable_if typename enable_if
▲ Show 20 Lines • Show All 173 Lines • Show Last 20 Lines

libcxx/include/__random/subtract_with_carry_engine.h

Show First 20 Lines • Show All 98 Lines • ▼ Show 20 Lines#else
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
explicit subtract_with_carry_engine(result_type __sd = default_seed) { explicit subtract_with_carry_engine(result_type __sd = default_seed) {
seed(__sd); seed(__sd);
} }
#endif #endif
template<class _Sseq> template<class _Sseq>
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
explicit subtract_with_carry_engine(_Sseq& __q, explicit subtract_with_carry_engine(_Sseq& __q,
typename enable_if<__is_seed_sequence<_Sseq, subtract_with_carry_engine>::value>::type* = 0) typename enable_if<__is_seed_sequence<_Sseq, subtract_with_carry_engine>::value>::type* = nullptr)
{seed(__q);} {seed(__q);}
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
void seed(result_type __sd = default_seed) void seed(result_type __sd = default_seed)
{seed(__sd, integral_constant<unsigned, 1 + (__w - 1) / 32>());} {seed(__sd, integral_constant<unsigned, 1 + (__w - 1) / 32>());}
template<class _Sseq> template<class _Sseq>
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
typename enable_if typename enable_if
< <
▲ Show 20 Lines • Show All 236 Lines • Show Last 20 Lines

libcxx/include/deque

Show First 20 Lines • Show All 258 Lines • ▼ Show 20 Lines
#if _LIBCPP_STD_VER >= 14 #if _LIBCPP_STD_VER >= 14
: __m_iter_(nullptr), __ptr_(nullptr) : __m_iter_(nullptr), __ptr_(nullptr)
#endif #endif
{} {}
template <class _Pp, class _Rp, class _MP> template <class _Pp, class _Rp, class _MP>
_LIBCPP_HIDE_FROM_ABI _LIBCPP_HIDE_FROM_ABI
__deque_iterator(const __deque_iterator<value_type, _Pp, _Rp, _MP, difference_type, _BS>& __it, __deque_iterator(const __deque_iterator<value_type, _Pp, _Rp, _MP, difference_type, _BS>& __it,
typename enable_if<is_convertible<_Pp, pointer>::value>::type* = 0) _NOEXCEPT typename enable_if<is_convertible<_Pp, pointer>::value>::type* = nullptr) _NOEXCEPT
: __m_iter_(__it.__m_iter_), __ptr_(__it.__ptr_) {} : __m_iter_(__it.__m_iter_), __ptr_(__it.__ptr_) {}
_LIBCPP_HIDE_FROM_ABI reference operator*() const {return *__ptr_;} _LIBCPP_HIDE_FROM_ABI reference operator*() const {return *__ptr_;}
_LIBCPP_HIDE_FROM_ABI pointer operator->() const {return __ptr_;} _LIBCPP_HIDE_FROM_ABI pointer operator->() const {return __ptr_;}
_LIBCPP_HIDE_FROM_ABI __deque_iterator& operator++() _LIBCPP_HIDE_FROM_ABI __deque_iterator& operator++()
{ {
if (++__ptr_ - *__m_iter_ == __block_size) if (++__ptr_ - *__m_iter_ == __block_size)
▲ Show 20 Lines • Show All 305 Lines • ▼ Show 20 Lines _LIBCPP_HIDE_FROM_ABI deque(size_type __n, const value_type& __v, const allocator_type& __a)
: __map_(__pointer_allocator(__a)), __start_(0), __size_(0, __a) : __map_(__pointer_allocator(__a)), __start_(0), __size_(0, __a)
{ {
if (__n > 0) if (__n > 0)
__append(__n, __v); __append(__n, __v);
} }
template <class _InputIter> template <class _InputIter>
_LIBCPP_HIDE_FROM_ABI deque(_InputIter __f, _InputIter __l, _LIBCPP_HIDE_FROM_ABI deque(_InputIter __f, _InputIter __l,
typename enable_if<__is_cpp17_input_iterator<_InputIter>::value>::type* = 0); typename enable_if<__is_cpp17_input_iterator<_InputIter>::value>::type* = nullptr);
template <class _InputIter> template <class _InputIter>
_LIBCPP_HIDE_FROM_ABI deque(_InputIter __f, _InputIter __l, const allocator_type& __a, _LIBCPP_HIDE_FROM_ABI deque(_InputIter __f, _InputIter __l, const allocator_type& __a,
typename enable_if<__is_cpp17_input_iterator<_InputIter>::value>::type* = 0); typename enable_if<__is_cpp17_input_iterator<_InputIter>::value>::type* = nullptr);
_LIBCPP_HIDE_FROM_ABI deque(const deque& __c); _LIBCPP_HIDE_FROM_ABI deque(const deque& __c);
_LIBCPP_HIDE_FROM_ABI deque(const deque& __c, const __type_identity_t<allocator_type>& __a); _LIBCPP_HIDE_FROM_ABI deque(const deque& __c, const __type_identity_t<allocator_type>& __a);
_LIBCPP_HIDE_FROM_ABI deque& operator=(const deque& __c); _LIBCPP_HIDE_FROM_ABI deque& operator=(const deque& __c);
#ifndef _LIBCPP_CXX03_LANG #ifndef _LIBCPP_CXX03_LANG
_LIBCPP_HIDE_FROM_ABI deque(initializer_list<value_type> __il); _LIBCPP_HIDE_FROM_ABI deque(initializer_list<value_type> __il);
_LIBCPP_HIDE_FROM_ABI deque(initializer_list<value_type> __il, const allocator_type& __a); _LIBCPP_HIDE_FROM_ABI deque(initializer_list<value_type> __il, const allocator_type& __a);
Show All 12 Lines#ifndef _LIBCPP_CXX03_LANG
_LIBCPP_HIDE_FROM_ABI _LIBCPP_HIDE_FROM_ABI
void assign(initializer_list<value_type> __il) {assign(__il.begin(), __il.end());} void assign(initializer_list<value_type> __il) {assign(__il.begin(), __il.end());}
#endif // _LIBCPP_CXX03_LANG #endif // _LIBCPP_CXX03_LANG
template <class _InputIter> template <class _InputIter>
_LIBCPP_HIDE_FROM_ABI void assign(_InputIter __f, _InputIter __l, _LIBCPP_HIDE_FROM_ABI void assign(_InputIter __f, _InputIter __l,
typename enable_if<__is_cpp17_input_iterator<_InputIter>::value && typename enable_if<__is_cpp17_input_iterator<_InputIter>::value &&
!__is_cpp17_random_access_iterator<_InputIter>::value>::type* = 0); !__is_cpp17_random_access_iterator<_InputIter>::value>::type* = nullptr);
template <class _RAIter> template <class _RAIter>
_LIBCPP_HIDE_FROM_ABI void assign(_RAIter __f, _RAIter __l, _LIBCPP_HIDE_FROM_ABI void assign(_RAIter __f, _RAIter __l,
typename enable_if<__is_cpp17_random_access_iterator<_RAIter>::value>::type* = 0); typename enable_if<__is_cpp17_random_access_iterator<_RAIter>::value>::type* = nullptr);
_LIBCPP_HIDE_FROM_ABI void assign(size_type __n, const value_type& __v); _LIBCPP_HIDE_FROM_ABI void assign(size_type __n, const value_type& __v);
_LIBCPP_HIDE_FROM_ABI _LIBCPP_HIDE_FROM_ABI
allocator_type get_allocator() const _NOEXCEPT; allocator_type get_allocator() const _NOEXCEPT;
_LIBCPP_HIDE_FROM_ABI allocator_type& __alloc() _NOEXCEPT { return __size_.second(); } _LIBCPP_HIDE_FROM_ABI allocator_type& __alloc() _NOEXCEPT { return __size_.second(); }
_LIBCPP_HIDE_FROM_ABI const allocator_type& __alloc() const _NOEXCEPT { return __size_.second(); } _LIBCPP_HIDE_FROM_ABI const allocator_type& __alloc() const _NOEXCEPT { return __size_.second(); }
// iterators: // iterators:
_LIBCPP_HIDE_FROM_ABI iterator begin() _NOEXCEPT { _LIBCPP_HIDE_FROM_ABI iterator begin() _NOEXCEPT {
__map_pointer __mp = __map_.begin() + __start_ / __block_size; __map_pointer __mp = __map_.begin() + __start_ / __block_size;
return iterator(__mp, __map_.empty() ? 0 : *__mp + __start_ % __block_size); return iterator(__mp, __map_.empty() ? nullptr : *__mp + __start_ % __block_size);
} }
_LIBCPP_HIDE_FROM_ABI const_iterator begin() const _NOEXCEPT { _LIBCPP_HIDE_FROM_ABI const_iterator begin() const _NOEXCEPT {
__map_const_pointer __mp = __map_const_pointer __mp =
static_cast<__map_const_pointer>(__map_.begin() + __start_ / __block_size); static_cast<__map_const_pointer>(__map_.begin() + __start_ / __block_size);
return const_iterator(__mp, __map_.empty() ? 0 : *__mp + __start_ % __block_size); return const_iterator(__mp, __map_.empty() ? nullptr : *__mp + __start_ % __block_size);
} }
_LIBCPP_HIDE_FROM_ABI iterator end() _NOEXCEPT { _LIBCPP_HIDE_FROM_ABI iterator end() _NOEXCEPT {
size_type __p = size() + __start_; size_type __p = size() + __start_;
__map_pointer __mp = __map_.begin() + __p / __block_size; __map_pointer __mp = __map_.begin() + __p / __block_size;
return iterator(__mp, __map_.empty() ? 0 : *__mp + __p % __block_size); return iterator(__mp, __map_.empty() ? nullptr : *__mp + __p % __block_size);
} }
_LIBCPP_HIDE_FROM_ABI const_iterator end() const _NOEXCEPT { _LIBCPP_HIDE_FROM_ABI const_iterator end() const _NOEXCEPT {
size_type __p = size() + __start_; size_type __p = size() + __start_;
__map_const_pointer __mp = static_cast<__map_const_pointer>(__map_.begin() + __p / __block_size); __map_const_pointer __mp = static_cast<__map_const_pointer>(__map_.begin() + __p / __block_size);
return const_iterator(__mp, __map_.empty() ? 0 : *__mp + __p % __block_size); return const_iterator(__mp, __map_.empty() ? nullptr : *__mp + __p % __block_size);
} }
_LIBCPP_HIDE_FROM_ABI _LIBCPP_HIDE_FROM_ABI
reverse_iterator rbegin() _NOEXCEPT reverse_iterator rbegin() _NOEXCEPT
{return reverse_iterator(end());} {return reverse_iterator(end());}
_LIBCPP_HIDE_FROM_ABI _LIBCPP_HIDE_FROM_ABI
const_reverse_iterator rbegin() const _NOEXCEPT const_reverse_iterator rbegin() const _NOEXCEPT
{return const_reverse_iterator(end());} {return const_reverse_iterator(end());}
▲ Show 20 Lines • Show All 73 Lines • ▼ Show 20 Lines#endif
_LIBCPP_HIDE_FROM_ABI _LIBCPP_HIDE_FROM_ABI
iterator insert(const_iterator __p, initializer_list<value_type> __il) iterator insert(const_iterator __p, initializer_list<value_type> __il)
{return insert(__p, __il.begin(), __il.end());} {return insert(__p, __il.begin(), __il.end());}
#endif // _LIBCPP_CXX03_LANG #endif // _LIBCPP_CXX03_LANG
_LIBCPP_HIDE_FROM_ABI iterator insert(const_iterator __p, const value_type& __v); _LIBCPP_HIDE_FROM_ABI iterator insert(const_iterator __p, const value_type& __v);
_LIBCPP_HIDE_FROM_ABI iterator insert(const_iterator __p, size_type __n, const value_type& __v); _LIBCPP_HIDE_FROM_ABI iterator insert(const_iterator __p, size_type __n, const value_type& __v);
template <class _InputIter> template <class _InputIter>
_LIBCPP_HIDE_FROM_ABI iterator insert(const_iterator __p, _InputIter __f, _InputIter __l, _LIBCPP_HIDE_FROM_ABI iterator insert(const_iterator __p, _InputIter __f, _InputIter __l,
typename enable_if<__is_exactly_cpp17_input_iterator<_InputIter>::value>::type* = 0); typename enable_if<__is_exactly_cpp17_input_iterator<_InputIter>::value>::type* = nullptr);
template <class _ForwardIterator> template <class _ForwardIterator>
_LIBCPP_HIDE_FROM_ABI iterator insert(const_iterator __p, _ForwardIterator __f, _ForwardIterator __l, _LIBCPP_HIDE_FROM_ABI iterator insert(const_iterator __p, _ForwardIterator __f, _ForwardIterator __l,
typename enable_if<__is_exactly_cpp17_forward_iterator<_ForwardIterator>::value>::type* = 0); typename enable_if<__is_exactly_cpp17_forward_iterator<_ForwardIterator>::value>::type* = nullptr);
template <class _BiIter> template <class _BiIter>
_LIBCPP_HIDE_FROM_ABI iterator insert(const_iterator __p, _BiIter __f, _BiIter __l, _LIBCPP_HIDE_FROM_ABI iterator insert(const_iterator __p, _BiIter __f, _BiIter __l,
typename enable_if<__is_cpp17_bidirectional_iterator<_BiIter>::value>::type* = 0); typename enable_if<__is_cpp17_bidirectional_iterator<_BiIter>::value>::type* = nullptr);
_LIBCPP_HIDE_FROM_ABI void pop_front(); _LIBCPP_HIDE_FROM_ABI void pop_front();
_LIBCPP_HIDE_FROM_ABI void pop_back(); _LIBCPP_HIDE_FROM_ABI void pop_back();
_LIBCPP_HIDE_FROM_ABI iterator erase(const_iterator __p); _LIBCPP_HIDE_FROM_ABI iterator erase(const_iterator __p);
_LIBCPP_HIDE_FROM_ABI iterator erase(const_iterator __f, const_iterator __l); _LIBCPP_HIDE_FROM_ABI iterator erase(const_iterator __f, const_iterator __l);
_LIBCPP_HIDE_FROM_ABI _LIBCPP_HIDE_FROM_ABI
void swap(deque& __c) void swap(deque& __c)
▲ Show 20 Lines • Show All 119 Lines • ▼ Show 20 Lines bool __maybe_remove_back_spare(bool __keep_one = true) {
__map_.pop_back(); __map_.pop_back();
return true; return true;
} }
return false; return false;
} }
template <class _InpIter> template <class _InpIter>
_LIBCPP_HIDE_FROM_ABI void __append(_InpIter __f, _InpIter __l, _LIBCPP_HIDE_FROM_ABI void __append(_InpIter __f, _InpIter __l,
typename enable_if<__is_exactly_cpp17_input_iterator<_InpIter>::value>::type* = 0); typename enable_if<__is_exactly_cpp17_input_iterator<_InpIter>::value>::type* = nullptr);
template <class _ForIter> template <class _ForIter>
_LIBCPP_HIDE_FROM_ABI void __append(_ForIter __f, _ForIter __l, _LIBCPP_HIDE_FROM_ABI void __append(_ForIter __f, _ForIter __l,
typename enable_if<__is_cpp17_forward_iterator<_ForIter>::value>::type* = 0); typename enable_if<__is_cpp17_forward_iterator<_ForIter>::value>::type* = nullptr);
_LIBCPP_HIDE_FROM_ABI void __append(size_type __n); _LIBCPP_HIDE_FROM_ABI void __append(size_type __n);
_LIBCPP_HIDE_FROM_ABI void __append(size_type __n, const value_type& __v); _LIBCPP_HIDE_FROM_ABI void __append(size_type __n, const value_type& __v);
_LIBCPP_HIDE_FROM_ABI void __erase_to_end(const_iterator __f); _LIBCPP_HIDE_FROM_ABI void __erase_to_end(const_iterator __f);
_LIBCPP_HIDE_FROM_ABI void __add_front_capacity(); _LIBCPP_HIDE_FROM_ABI void __add_front_capacity();
_LIBCPP_HIDE_FROM_ABI void __add_front_capacity(size_type __n); _LIBCPP_HIDE_FROM_ABI void __add_front_capacity(size_type __n);
_LIBCPP_HIDE_FROM_ABI void __add_back_capacity(); _LIBCPP_HIDE_FROM_ABI void __add_back_capacity();
_LIBCPP_HIDE_FROM_ABI void __add_back_capacity(size_type __n); _LIBCPP_HIDE_FROM_ABI void __add_back_capacity(size_type __n);
_LIBCPP_HIDE_FROM_ABI iterator __move_and_check(iterator __f, iterator __l, iterator __r, _LIBCPP_HIDE_FROM_ABI iterator __move_and_check(iterator __f, iterator __l, iterator __r,
▲ Show 20 Lines • Show All 1,569 Lines • Show Last 20 Lines

libcxx/include/fstream

Show First 20 Lines • Show All 374 Lines • ▼ Show 20 Linesbasic_filebuf<_CharT, _Traits>::basic_filebuf(basic_filebuf&& __rhs)
__rhs.__ibs_ = 0; __rhs.__ibs_ = 0;
__rhs.__file_ = nullptr; __rhs.__file_ = nullptr;
__rhs.__st_ = state_type(); __rhs.__st_ = state_type();
__rhs.__st_last_ = state_type(); __rhs.__st_last_ = state_type();
__rhs.__om_ = 0; __rhs.__om_ = 0;
__rhs.__cm_ = 0; __rhs.__cm_ = 0;
__rhs.__owns_eb_ = false; __rhs.__owns_eb_ = false;
__rhs.__owns_ib_ = false; __rhs.__owns_ib_ = false;
__rhs.setg(0, 0, 0); __rhs.setg(nullptr, nullptr, nullptr);
__rhs.setp(0, 0); __rhs.setp(nullptr, nullptr);
} }
template <class _CharT, class _Traits> template <class _CharT, class _Traits>
inline inline
basic_filebuf<_CharT, _Traits>& basic_filebuf<_CharT, _Traits>&
basic_filebuf<_CharT, _Traits>::operator=(basic_filebuf&& __rhs) basic_filebuf<_CharT, _Traits>::operator=(basic_filebuf&& __rhs)
{ {
close(); close();
▲ Show 20 Lines • Show All 320 Lines • ▼ Show 20 Linesbasic_filebuf<_CharT, _Traits>::close()
{ {
__rt = this; __rt = this;
unique_ptr<FILE, int(*)(FILE*)> __h(__file_, fclose); unique_ptr<FILE, int(*)(FILE*)> __h(__file_, fclose);
if (sync()) if (sync())
__rt = nullptr; __rt = nullptr;
if (fclose(__h.release())) if (fclose(__h.release()))
__rt = nullptr; __rt = nullptr;
__file_ = nullptr; __file_ = nullptr;
setbuf(0, 0); setbuf(nullptr, 0);
} }
return __rt; return __rt;
} }
template <class _CharT, class _Traits> template <class _CharT, class _Traits>
typename basic_filebuf<_CharT, _Traits>::int_type typename basic_filebuf<_CharT, _Traits>::int_type
basic_filebuf<_CharT, _Traits>::underflow() basic_filebuf<_CharT, _Traits>::underflow()
{ {
▲ Show 20 Lines • Show All 1,033 Lines • Show Last 20 Lines

libcxx/include/list

Show First 20 Lines • Show All 875 Lines • ▼ Show 20 Lines#endif
{ {
_VSTD::__debug_db_insert_c(this); _VSTD::__debug_db_insert_c(this);
for (; __n > 0; --__n) for (; __n > 0; --__n)
push_back(__x); push_back(__x);
} }
template <class _InpIter> template <class _InpIter>
list(_InpIter __f, _InpIter __l, list(_InpIter __f, _InpIter __l,
__enable_if_t<__is_cpp17_input_iterator<_InpIter>::value>* = 0); __enable_if_t<__is_cpp17_input_iterator<_InpIter>::value>* = nullptr);
template <class _InpIter> template <class _InpIter>
list(_InpIter __f, _InpIter __l, const allocator_type& __a, list(_InpIter __f, _InpIter __l, const allocator_type& __a,
__enable_if_t<__is_cpp17_input_iterator<_InpIter>::value>* = 0); __enable_if_t<__is_cpp17_input_iterator<_InpIter>::value>* = nullptr);
list(const list& __c); list(const list& __c);
list(const list& __c, const __type_identity_t<allocator_type>& __a); list(const list& __c, const __type_identity_t<allocator_type>& __a);
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
list& operator=(const list& __c); list& operator=(const list& __c);
#ifndef _LIBCPP_CXX03_LANG #ifndef _LIBCPP_CXX03_LANG
list(initializer_list<value_type> __il); list(initializer_list<value_type> __il);
list(initializer_list<value_type> __il, const allocator_type& __a); list(initializer_list<value_type> __il, const allocator_type& __a);
Show All 15 Lines#ifndef _LIBCPP_CXX03_LANG
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
void assign(initializer_list<value_type> __il) void assign(initializer_list<value_type> __il)
{assign(__il.begin(), __il.end());} {assign(__il.begin(), __il.end());}
#endif // _LIBCPP_CXX03_LANG #endif // _LIBCPP_CXX03_LANG
template <class _InpIter> template <class _InpIter>
void assign(_InpIter __f, _InpIter __l, void assign(_InpIter __f, _InpIter __l,
__enable_if_t<__is_cpp17_input_iterator<_InpIter>::value>* = 0); __enable_if_t<__is_cpp17_input_iterator<_InpIter>::value>* = nullptr);
void assign(size_type __n, const value_type& __x); void assign(size_type __n, const value_type& __x);
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
allocator_type get_allocator() const _NOEXCEPT; allocator_type get_allocator() const _NOEXCEPT;
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
size_type size() const _NOEXCEPT {return base::__sz();} size_type size() const _NOEXCEPT {return base::__sz();}
_LIBCPP_NODISCARD_AFTER_CXX17 _LIBCPP_INLINE_VISIBILITY _LIBCPP_NODISCARD_AFTER_CXX17 _LIBCPP_INLINE_VISIBILITY
▲ Show 20 Lines • Show All 100 Lines • ▼ Show 20 Lines#else
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
void __emplace_back(value_type const& __arg) { push_back(__arg); } void __emplace_back(value_type const& __arg) { push_back(__arg); }
#endif #endif
iterator insert(const_iterator __p, const value_type& __x); iterator insert(const_iterator __p, const value_type& __x);
iterator insert(const_iterator __p, size_type __n, const value_type& __x); iterator insert(const_iterator __p, size_type __n, const value_type& __x);
template <class _InpIter> template <class _InpIter>
iterator insert(const_iterator __p, _InpIter __f, _InpIter __l, iterator insert(const_iterator __p, _InpIter __f, _InpIter __l,
__enable_if_t<__is_cpp17_input_iterator<_InpIter>::value>* = 0); __enable_if_t<__is_cpp17_input_iterator<_InpIter>::value>* = nullptr);
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
void swap(list& __c) void swap(list& __c)
#if _LIBCPP_STD_VER >= 14 #if _LIBCPP_STD_VER >= 14
_NOEXCEPT _NOEXCEPT
#else #else
_NOEXCEPT_(!__node_alloc_traits::propagate_on_container_swap::value || _NOEXCEPT_(!__node_alloc_traits::propagate_on_container_swap::value ||
__is_nothrow_swappable<__node_allocator>::value) __is_nothrow_swappable<__node_allocator>::value)
▲ Show 20 Lines • Show All 1,368 Lines • Show Last 20 Lines

libcxx/include/locale

Show First 20 Lines • Show All 3,391 Lines • ▼ Show 20 Linesmoney_put<_CharT, _OutputIterator>::do_put(iter_type __s, bool __intl,
size_t __exn = __n > __fd ? size_t __exn = __n > __fd ?
(static_cast<size_t>(__n) - static_cast<size_t>(__fd)) * 2 + (static_cast<size_t>(__n) - static_cast<size_t>(__fd)) * 2 +
__sn.size() + __sym.size() + static_cast<size_t>(__fd) + 1 __sn.size() + __sym.size() + static_cast<size_t>(__fd) + 1
: __sn.size() + __sym.size() + static_cast<size_t>(__fd) + 2; : __sn.size() + __sym.size() + static_cast<size_t>(__fd) + 2;
if (__exn > __bs) if (__exn > __bs)
{ {
__hw.reset((char_type*)malloc(__exn * sizeof(char_type))); __hw.reset((char_type*)malloc(__exn * sizeof(char_type)));
__mb = __hw.get(); __mb = __hw.get();
if (__mb == 0) if (__mb == nullptr)
__throw_bad_alloc(); __throw_bad_alloc();
} }
// format // format
char_type* __mi; char_type* __mi;
char_type* __me; char_type* __me;
this->__format(__mb, __mi, __me, __iob.flags(), this->__format(__mb, __mi, __me, __iob.flags(),
__db, __db + __n, __ct, __db, __db + __n, __ct,
__neg, __pat, __dp, __ts, __grp, __sym, __sn, __fd); __neg, __pat, __dp, __ts, __grp, __sym, __sn, __fd);
Show All 25 Linesmoney_put<_CharT, _OutputIterator>::do_put(iter_type __s, bool __intl,
size_t __exn = static_cast<int>(__digits.size()) > __fd ? size_t __exn = static_cast<int>(__digits.size()) > __fd ?
(__digits.size() - static_cast<size_t>(__fd)) * 2 + (__digits.size() - static_cast<size_t>(__fd)) * 2 +
__sn.size() + __sym.size() + static_cast<size_t>(__fd) + 1 __sn.size() + __sym.size() + static_cast<size_t>(__fd) + 1
: __sn.size() + __sym.size() + static_cast<size_t>(__fd) + 2; : __sn.size() + __sym.size() + static_cast<size_t>(__fd) + 2;
if (__exn > 100) if (__exn > 100)
{ {
__h.reset((char_type*)malloc(__exn * sizeof(char_type))); __h.reset((char_type*)malloc(__exn * sizeof(char_type)));
__mb = __h.get(); __mb = __h.get();
if (__mb == 0) if (__mb == nullptr)
__throw_bad_alloc(); __throw_bad_alloc();
} }
// format // format
char_type* __mi; char_type* __mi;
char_type* __me; char_type* __me;
this->__format(__mb, __mi, __me, __iob.flags(), this->__format(__mb, __mi, __me, __iob.flags(),
__digits.data(), __digits.data() + __digits.size(), __ct, __digits.data(), __digits.data() + __digits.size(), __ct,
__neg, __pat, __dp, __ts, __grp, __sym, __sn, __fd); __neg, __pat, __dp, __ts, __grp, __sym, __sn, __fd);
▲ Show 20 Lines • Show All 528 Lines • ▼ Show 20 Lines if (__owns_ib_)
delete [] __intbuf_; delete [] __intbuf_;
} }
template <class _Codecvt, class _Elem, class _Tr> template <class _Codecvt, class _Elem, class _Tr>
typename wbuffer_convert<_Codecvt, _Elem, _Tr>::int_type typename wbuffer_convert<_Codecvt, _Elem, _Tr>::int_type
wbuffer_convert<_Codecvt, _Elem, _Tr>::underflow() wbuffer_convert<_Codecvt, _Elem, _Tr>::underflow()
{ {
_LIBCPP_SUPPRESS_DEPRECATED_POP _LIBCPP_SUPPRESS_DEPRECATED_POP
if (__cv_ == 0 || __bufptr_ == 0) if (__cv_ == 0 || __bufptr_ == nullptr)
return traits_type::eof(); return traits_type::eof();
bool __initial = __read_mode(); bool __initial = __read_mode();
char_type __1buf; char_type __1buf;
if (this->gptr() == 0) if (this->gptr() == 0)
this->setg(&__1buf, &__1buf+1, &__1buf+1); this->setg(&__1buf, &__1buf+1, &__1buf+1);
const size_t __unget_sz = __initial ? 0 : std::min<size_t>((this->egptr() - this->eback()) / 2, 4); const size_t __unget_sz = __initial ? 0 : std::min<size_t>((this->egptr() - this->eback()) / 2, 4);
int_type __c = traits_type::eof(); int_type __c = traits_type::eof();
if (this->gptr() == this->egptr()) if (this->gptr() == this->egptr())
▲ Show 20 Lines • Show All 45 Lines • ▼ Show 20 Lines if (this->gptr() == this->egptr())
__c = *this->gptr(); __c = *this->gptr();
} }
} }
} }
} }
else else
__c = *this->gptr(); __c = *this->gptr();
if (this->eback() == &__1buf) if (this->eback() == &__1buf)
this->setg(0, 0, 0); this->setg(nullptr, nullptr, nullptr);
return __c; return __c;
} }
_LIBCPP_SUPPRESS_DEPRECATED_PUSH _LIBCPP_SUPPRESS_DEPRECATED_PUSH
template <class _Codecvt, class _Elem, class _Tr> template <class _Codecvt, class _Elem, class _Tr>
typename wbuffer_convert<_Codecvt, _Elem, _Tr>::int_type typename wbuffer_convert<_Codecvt, _Elem, _Tr>::int_type
wbuffer_convert<_Codecvt, _Elem, _Tr>::pbackfail(int_type __c) wbuffer_convert<_Codecvt, _Elem, _Tr>::pbackfail(int_type __c)
{ {
_LIBCPP_SUPPRESS_DEPRECATED_POP _LIBCPP_SUPPRESS_DEPRECATED_POP
if (__cv_ != 0 && __bufptr_ != 0 && this->eback() < this->gptr()) if (__cv_ != 0 && __bufptr_ != nullptr && this->eback() < this->gptr())
{ {
if (traits_type::eq_int_type(__c, traits_type::eof())) if (traits_type::eq_int_type(__c, traits_type::eof()))
{ {
this->gbump(-1); this->gbump(-1);
return traits_type::not_eof(__c); return traits_type::not_eof(__c);
} }
if (traits_type::eq(traits_type::to_char_type(__c), this->gptr()[-1])) if (traits_type::eq(traits_type::to_char_type(__c), this->gptr()[-1]))
{ {
this->gbump(-1); this->gbump(-1);
*this->gptr() = traits_type::to_char_type(__c); *this->gptr() = traits_type::to_char_type(__c);
return __c; return __c;
} }
} }
return traits_type::eof(); return traits_type::eof();
} }
_LIBCPP_SUPPRESS_DEPRECATED_PUSH _LIBCPP_SUPPRESS_DEPRECATED_PUSH
template <class _Codecvt, class _Elem, class _Tr> template <class _Codecvt, class _Elem, class _Tr>
typename wbuffer_convert<_Codecvt, _Elem, _Tr>::int_type typename wbuffer_convert<_Codecvt, _Elem, _Tr>::int_type
wbuffer_convert<_Codecvt, _Elem, _Tr>::overflow(int_type __c) wbuffer_convert<_Codecvt, _Elem, _Tr>::overflow(int_type __c)
{ {
_LIBCPP_SUPPRESS_DEPRECATED_POP _LIBCPP_SUPPRESS_DEPRECATED_POP
if (__cv_ == 0 || __bufptr_ == 0) if (__cv_ == 0 || __bufptr_ == nullptr)
return traits_type::eof(); return traits_type::eof();
__write_mode(); __write_mode();
char_type __1buf; char_type __1buf;
char_type* __pb_save = this->pbase(); char_type* __pb_save = this->pbase();
char_type* __epb_save = this->epptr(); char_type* __epb_save = this->epptr();
if (!traits_type::eq_int_type(__c, traits_type::eof())) if (!traits_type::eq_int_type(__c, traits_type::eof()))
{ {
if (this->pptr() == 0) if (this->pptr() == 0)
▲ Show 20 Lines • Show All 47 Lines • ▼ Show 20 Lines
} }
_LIBCPP_SUPPRESS_DEPRECATED_PUSH _LIBCPP_SUPPRESS_DEPRECATED_PUSH
template <class _Codecvt, class _Elem, class _Tr> template <class _Codecvt, class _Elem, class _Tr>
basic_streambuf<_Elem, _Tr>* basic_streambuf<_Elem, _Tr>*
wbuffer_convert<_Codecvt, _Elem, _Tr>::setbuf(char_type* __s, streamsize __n) wbuffer_convert<_Codecvt, _Elem, _Tr>::setbuf(char_type* __s, streamsize __n)
{ {
_LIBCPP_SUPPRESS_DEPRECATED_POP _LIBCPP_SUPPRESS_DEPRECATED_POP
this->setg(0, 0, 0); this->setg(nullptr, nullptr, nullptr);
this->setp(0, 0); this->setp(nullptr, nullptr);
if (__owns_eb_) if (__owns_eb_)
delete [] __extbuf_; delete [] __extbuf_;
if (__owns_ib_) if (__owns_ib_)
delete [] __intbuf_; delete [] __intbuf_;
__ebs_ = __n; __ebs_ = __n;
if (__ebs_ > sizeof(__extbuf_min_)) if (__ebs_ > sizeof(__extbuf_min_))
{ {
if (__always_noconv_ && __s) if (__always_noconv_ && __s)
Show All 38 Lines
_LIBCPP_SUPPRESS_DEPRECATED_PUSH _LIBCPP_SUPPRESS_DEPRECATED_PUSH
template <class _Codecvt, class _Elem, class _Tr> template <class _Codecvt, class _Elem, class _Tr>
typename wbuffer_convert<_Codecvt, _Elem, _Tr>::pos_type typename wbuffer_convert<_Codecvt, _Elem, _Tr>::pos_type
wbuffer_convert<_Codecvt, _Elem, _Tr>::seekoff(off_type __off, ios_base::seekdir __way, wbuffer_convert<_Codecvt, _Elem, _Tr>::seekoff(off_type __off, ios_base::seekdir __way,
ios_base::openmode __om) ios_base::openmode __om)
{ {
int __width = __cv_->encoding(); int __width = __cv_->encoding();
if (__cv_ == 0 || __bufptr_ == 0 || (__width <= 0 && __off != 0) || sync()) if (__cv_ == 0 || __bufptr_ == nullptr || (__width <= 0 && __off != 0) || sync())
return pos_type(off_type(-1)); return pos_type(off_type(-1));
// __width > 0 || __off == 0, now check __way // __width > 0 || __off == 0, now check __way
if (__way != ios_base::beg && __way != ios_base::cur && __way != ios_base::end) if (__way != ios_base::beg && __way != ios_base::cur && __way != ios_base::end)
return pos_type(off_type(-1)); return pos_type(off_type(-1));
pos_type __r = __bufptr_->pubseekoff(__width * __off, __way, __om); pos_type __r = __bufptr_->pubseekoff(__width * __off, __way, __om);
__r.state(__st_); __r.state(__st_);
return __r; return __r;
} }
template <class _Codecvt, class _Elem, class _Tr> template <class _Codecvt, class _Elem, class _Tr>
typename wbuffer_convert<_Codecvt, _Elem, _Tr>::pos_type typename wbuffer_convert<_Codecvt, _Elem, _Tr>::pos_type
wbuffer_convert<_Codecvt, _Elem, _Tr>::seekpos(pos_type __sp, ios_base::openmode __wch) wbuffer_convert<_Codecvt, _Elem, _Tr>::seekpos(pos_type __sp, ios_base::openmode __wch)
{ {
if (__cv_ == 0 || __bufptr_ == 0 || sync()) if (__cv_ == 0 || __bufptr_ == nullptr || sync())
return pos_type(off_type(-1)); return pos_type(off_type(-1));
if (__bufptr_->pubseekpos(__sp, __wch) == pos_type(off_type(-1))) if (__bufptr_->pubseekpos(__sp, __wch) == pos_type(off_type(-1)))
return pos_type(off_type(-1)); return pos_type(off_type(-1));
return __sp; return __sp;
} }
template <class _Codecvt, class _Elem, class _Tr> template <class _Codecvt, class _Elem, class _Tr>
int int
wbuffer_convert<_Codecvt, _Elem, _Tr>::sync() wbuffer_convert<_Codecvt, _Elem, _Tr>::sync()
{ {
_LIBCPP_SUPPRESS_DEPRECATED_POP _LIBCPP_SUPPRESS_DEPRECATED_POP
if (__cv_ == 0 || __bufptr_ == 0) if (__cv_ == 0 || __bufptr_ == nullptr)
return 0; return 0;
if (__cm_ & ios_base::out) if (__cm_ & ios_base::out)
{ {
if (this->pptr() != this->pbase()) if (this->pptr() != this->pbase())
if (overflow() == traits_type::eof()) if (overflow() == traits_type::eof())
return -1; return -1;
codecvt_base::result __r; codecvt_base::result __r;
do do
▲ Show 20 Lines • Show All 45 Lines • ▼ Show 20 Lines else if (__cm_ & ios_base::in)
return -1; return -1;
} }
} while (__r == codecvt_base::partial); } while (__r == codecvt_base::partial);
} }
} }
} }
if (__bufptr_->pubseekoff(-__c, ios_base::cur, __cm_) == pos_type(off_type(-1))) if (__bufptr_->pubseekoff(-__c, ios_base::cur, __cm_) == pos_type(off_type(-1)))
return -1; return -1;
this->setg(0, 0, 0); this->setg(nullptr, nullptr, nullptr);
__cm_ = 0; __cm_ = 0;
} }
return 0; return 0;
} }
_LIBCPP_SUPPRESS_DEPRECATED_PUSH _LIBCPP_SUPPRESS_DEPRECATED_PUSH
template <class _Codecvt, class _Elem, class _Tr> template <class _Codecvt, class _Elem, class _Tr>
bool bool
wbuffer_convert<_Codecvt, _Elem, _Tr>::__read_mode() wbuffer_convert<_Codecvt, _Elem, _Tr>::__read_mode()
{ {
if (!(__cm_ & ios_base::in)) if (!(__cm_ & ios_base::in))
{ {
this->setp(0, 0); this->setp(nullptr, nullptr);
if (__always_noconv_) if (__always_noconv_)
this->setg((char_type*)__extbuf_, this->setg((char_type*)__extbuf_,
(char_type*)__extbuf_ + __ebs_, (char_type*)__extbuf_ + __ebs_,
(char_type*)__extbuf_ + __ebs_); (char_type*)__extbuf_ + __ebs_);
else else
this->setg(__intbuf_, __intbuf_ + __ibs_, __intbuf_ + __ibs_); this->setg(__intbuf_, __intbuf_ + __ibs_, __intbuf_ + __ibs_);
__cm_ = ios_base::in; __cm_ = ios_base::in;
return true; return true;
} }
return false; return false;
} }
template <class _Codecvt, class _Elem, class _Tr> template <class _Codecvt, class _Elem, class _Tr>
void void
wbuffer_convert<_Codecvt, _Elem, _Tr>::__write_mode() wbuffer_convert<_Codecvt, _Elem, _Tr>::__write_mode()
{ {
if (!(__cm_ & ios_base::out)) if (!(__cm_ & ios_base::out))
{ {
this->setg(0, 0, 0); this->setg(nullptr, nullptr, nullptr);
if (__ebs_ > sizeof(__extbuf_min_)) if (__ebs_ > sizeof(__extbuf_min_))
{ {
if (__always_noconv_) if (__always_noconv_)
this->setp((char_type*)__extbuf_, this->setp((char_type*)__extbuf_,
(char_type*)__extbuf_ + (__ebs_ - 1)); (char_type*)__extbuf_ + (__ebs_ - 1));
else else
this->setp(__intbuf_, __intbuf_ + (__ibs_ - 1)); this->setp(__intbuf_, __intbuf_ + (__ibs_ - 1));
} }
else else
this->setp(0, 0); this->setp(nullptr, nullptr);
__cm_ = ios_base::out; __cm_ = ios_base::out;
} }
} }
template <class _Codecvt, class _Elem, class _Tr> template <class _Codecvt, class _Elem, class _Tr>
wbuffer_convert<_Codecvt, _Elem, _Tr>* wbuffer_convert<_Codecvt, _Elem, _Tr>*
wbuffer_convert<_Codecvt, _Elem, _Tr>::__close() wbuffer_convert<_Codecvt, _Elem, _Tr>::__close()
{ {
Show All 29 Lines

libcxx/include/queue

Show First 20 Lines • Show All 309 Lines • ▼ Show 20 Lines#endif // _LIBCPP_CXX03_LANG
explicit queue(const container_type& __c) : c(__c) {} explicit queue(const container_type& __c) : c(__c) {}
#ifndef _LIBCPP_CXX03_LANG #ifndef _LIBCPP_CXX03_LANG
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
explicit queue(container_type&& __c) : c(_VSTD::move(__c)) {} explicit queue(container_type&& __c) : c(_VSTD::move(__c)) {}
#endif // _LIBCPP_CXX03_LANG #endif // _LIBCPP_CXX03_LANG
template <class _Alloc> template <class _Alloc>
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
explicit queue(const _Alloc& __a, explicit queue(const _Alloc& __a,
__enable_if_t<uses_allocator<container_type, _Alloc>::value>* = 0) __enable_if_t<uses_allocator<container_type, _Alloc>::value>* = nullptr)
: c(__a) {} : c(__a) {}
template <class _Alloc> template <class _Alloc>
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
queue(const queue& __q, const _Alloc& __a, queue(const queue& __q, const _Alloc& __a,
__enable_if_t<uses_allocator<container_type, _Alloc>::value>* = 0) __enable_if_t<uses_allocator<container_type, _Alloc>::value>* = nullptr)
: c(__q.c, __a) {} : c(__q.c, __a) {}
template <class _Alloc> template <class _Alloc>
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
queue(const container_type& __c, const _Alloc& __a, queue(const container_type& __c, const _Alloc& __a,
__enable_if_t<uses_allocator<container_type, _Alloc>::value>* = 0) __enable_if_t<uses_allocator<container_type, _Alloc>::value>* = nullptr)
: c(__c, __a) {} : c(__c, __a) {}
#ifndef _LIBCPP_CXX03_LANG #ifndef _LIBCPP_CXX03_LANG
template <class _Alloc> template <class _Alloc>
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
queue(container_type&& __c, const _Alloc& __a, queue(container_type&& __c, const _Alloc& __a,
__enable_if_t<uses_allocator<container_type, _Alloc>::value>* = 0) __enable_if_t<uses_allocator<container_type, _Alloc>::value>* = nullptr)
: c(_VSTD::move(__c), __a) {} : c(_VSTD::move(__c), __a) {}
template <class _Alloc> template <class _Alloc>
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
queue(queue&& __q, const _Alloc& __a, queue(queue&& __q, const _Alloc& __a,
__enable_if_t<uses_allocator<container_type, _Alloc>::value>* = 0) __enable_if_t<uses_allocator<container_type, _Alloc>::value>* = nullptr)
: c(_VSTD::move(__q.c), __a) {} : c(_VSTD::move(__q.c), __a) {}
#endif // _LIBCPP_CXX03_LANG #endif // _LIBCPP_CXX03_LANG
_LIBCPP_NODISCARD_AFTER_CXX17 _LIBCPP_INLINE_VISIBILITY _LIBCPP_NODISCARD_AFTER_CXX17 _LIBCPP_INLINE_VISIBILITY
bool empty() const {return c.empty();} bool empty() const {return c.empty();}
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
size_type size() const {return c.size();} size_type size() const {return c.size();}
▲ Show 20 Lines • Show All 207 Lines • ▼ Show 20 Lines#ifndef _LIBCPP_CXX03_LANG
template <class _InputIter, class = __enable_if_t<__is_cpp17_input_iterator<_InputIter>::value> > template <class _InputIter, class = __enable_if_t<__is_cpp17_input_iterator<_InputIter>::value> >
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
priority_queue(_InputIter __f, _InputIter __l, priority_queue(_InputIter __f, _InputIter __l,
const value_compare& __comp, container_type&& __c); const value_compare& __comp, container_type&& __c);
#endif // _LIBCPP_CXX03_LANG #endif // _LIBCPP_CXX03_LANG
template <class _Alloc> template <class _Alloc>
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
explicit priority_queue(const _Alloc& __a, explicit priority_queue(const _Alloc& __a,
__enable_if_t<uses_allocator<container_type, _Alloc>::value>* = 0); __enable_if_t<uses_allocator<container_type, _Alloc>::value>* = nullptr);
template <class _Alloc> template <class _Alloc>
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
priority_queue(const value_compare& __comp, const _Alloc& __a, priority_queue(const value_compare& __comp, const _Alloc& __a,
__enable_if_t<uses_allocator<container_type, _Alloc>::value>* = 0); __enable_if_t<uses_allocator<container_type, _Alloc>::value>* = nullptr);
template <class _Alloc> template <class _Alloc>
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
priority_queue(const value_compare& __comp, const container_type& __c, priority_queue(const value_compare& __comp, const container_type& __c,
const _Alloc& __a, const _Alloc& __a,
__enable_if_t<uses_allocator<container_type, _Alloc>::value>* = 0); __enable_if_t<uses_allocator<container_type, _Alloc>::value>* = nullptr);
template <class _Alloc> template <class _Alloc>
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
priority_queue(const priority_queue& __q, const _Alloc& __a, priority_queue(const priority_queue& __q, const _Alloc& __a,
__enable_if_t<uses_allocator<container_type, _Alloc>::value>* = 0); __enable_if_t<uses_allocator<container_type, _Alloc>::value>* = nullptr);
#ifndef _LIBCPP_CXX03_LANG #ifndef _LIBCPP_CXX03_LANG
template <class _Alloc> template <class _Alloc>
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
priority_queue(const value_compare& __comp, container_type&& __c, priority_queue(const value_compare& __comp, container_type&& __c,
const _Alloc& __a, const _Alloc& __a,
__enable_if_t<uses_allocator<container_type, _Alloc>::value>* = 0); __enable_if_t<uses_allocator<container_type, _Alloc>::value>* = nullptr);
template <class _Alloc> template <class _Alloc>
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
priority_queue(priority_queue&& __q, const _Alloc& __a, priority_queue(priority_queue&& __q, const _Alloc& __a,
__enable_if_t<uses_allocator<container_type, _Alloc>::value>* = 0); __enable_if_t<uses_allocator<container_type, _Alloc>::value>* = nullptr);
#endif // _LIBCPP_CXX03_LANG #endif // _LIBCPP_CXX03_LANG
template <class _InputIter, class _Alloc, class = __enable_if_t<__is_cpp17_input_iterator<_InputIter>::value> > template <class _InputIter, class _Alloc, class = __enable_if_t<__is_cpp17_input_iterator<_InputIter>::value> >
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
priority_queue(_InputIter __f, _InputIter __l, const _Alloc& __a, priority_queue(_InputIter __f, _InputIter __l, const _Alloc& __a,
__enable_if_t<uses_allocator<container_type, _Alloc>::value>* = 0); __enable_if_t<uses_allocator<container_type, _Alloc>::value>* = nullptr);
template <class _InputIter, class _Alloc, class = __enable_if_t<__is_cpp17_input_iterator<_InputIter>::value> > template <class _InputIter, class _Alloc, class = __enable_if_t<__is_cpp17_input_iterator<_InputIter>::value> >
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
priority_queue(_InputIter __f, _InputIter __l, priority_queue(_InputIter __f, _InputIter __l,
const value_compare& __comp, const _Alloc& __a, const value_compare& __comp, const _Alloc& __a,
__enable_if_t<uses_allocator<container_type, _Alloc>::value>* = 0); __enable_if_t<uses_allocator<container_type, _Alloc>::value>* = nullptr);
template <class _InputIter, class _Alloc, class = __enable_if_t<__is_cpp17_input_iterator<_InputIter>::value> > template <class _InputIter, class _Alloc, class = __enable_if_t<__is_cpp17_input_iterator<_InputIter>::value> >
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
priority_queue(_InputIter __f, _InputIter __l, priority_queue(_InputIter __f, _InputIter __l,
const value_compare& __comp, const container_type& __c, const _Alloc& __a, const value_compare& __comp, const container_type& __c, const _Alloc& __a,
__enable_if_t<uses_allocator<container_type, _Alloc>::value>* = 0); __enable_if_t<uses_allocator<container_type, _Alloc>::value>* = nullptr);
#ifndef _LIBCPP_CXX03_LANG #ifndef _LIBCPP_CXX03_LANG
template <class _InputIter, class _Alloc, class = __enable_if_t<__is_cpp17_input_iterator<_InputIter>::value> > template <class _InputIter, class _Alloc, class = __enable_if_t<__is_cpp17_input_iterator<_InputIter>::value> >
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
priority_queue(_InputIter __f, _InputIter __l, priority_queue(_InputIter __f, _InputIter __l,
const value_compare& __comp, container_type&& __c, const _Alloc& __a, const value_compare& __comp, container_type&& __c, const _Alloc& __a,
__enable_if_t<uses_allocator<container_type, _Alloc>::value>* = 0); __enable_if_t<uses_allocator<container_type, _Alloc>::value>* = nullptr);
#endif // _LIBCPP_CXX03_LANG #endif // _LIBCPP_CXX03_LANG
_LIBCPP_NODISCARD_AFTER_CXX17 _LIBCPP_INLINE_VISIBILITY _LIBCPP_NODISCARD_AFTER_CXX17 _LIBCPP_INLINE_VISIBILITY
bool empty() const {return c.empty();} bool empty() const {return c.empty();}
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
size_type size() const {return c.size();} size_type size() const {return c.size();}
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
const_reference top() const {return c.front();} const_reference top() const {return c.front();}
▲ Show 20 Lines • Show All 351 Lines • Show Last 20 Lines

libcxx/include/stack

Show First 20 Lines • Show All 173 Lines • ▼ Show 20 Lines
#endif // _LIBCPP_CXX03_LANG #endif // _LIBCPP_CXX03_LANG
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
explicit stack(const container_type& __c) : c(__c) {} explicit stack(const container_type& __c) : c(__c) {}
template <class _Alloc> template <class _Alloc>
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
explicit stack(const _Alloc& __a, explicit stack(const _Alloc& __a,
__enable_if_t<uses_allocator<container_type, _Alloc>::value>* = 0) __enable_if_t<uses_allocator<container_type, _Alloc>::value>* = nullptr)
: c(__a) {} : c(__a) {}
template <class _Alloc> template <class _Alloc>
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
stack(const container_type& __c, const _Alloc& __a, stack(const container_type& __c, const _Alloc& __a,
__enable_if_t<uses_allocator<container_type, _Alloc>::value>* = 0) __enable_if_t<uses_allocator<container_type, _Alloc>::value>* = nullptr)
: c(__c, __a) {} : c(__c, __a) {}
template <class _Alloc> template <class _Alloc>
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
stack(const stack& __s, const _Alloc& __a, stack(const stack& __s, const _Alloc& __a,
__enable_if_t<uses_allocator<container_type, _Alloc>::value>* = 0) __enable_if_t<uses_allocator<container_type, _Alloc>::value>* = nullptr)
: c(__s.c, __a) {} : c(__s.c, __a) {}
#ifndef _LIBCPP_CXX03_LANG #ifndef _LIBCPP_CXX03_LANG
template <class _Alloc> template <class _Alloc>
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
stack(container_type&& __c, const _Alloc& __a, stack(container_type&& __c, const _Alloc& __a,
__enable_if_t<uses_allocator<container_type, _Alloc>::value>* = 0) __enable_if_t<uses_allocator<container_type, _Alloc>::value>* = nullptr)
: c(_VSTD::move(__c), __a) {} : c(_VSTD::move(__c), __a) {}
template <class _Alloc> template <class _Alloc>
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
stack(stack&& __s, const _Alloc& __a, stack(stack&& __s, const _Alloc& __a,
__enable_if_t<uses_allocator<container_type, _Alloc>::value>* = 0) __enable_if_t<uses_allocator<container_type, _Alloc>::value>* = nullptr)
: c(_VSTD::move(__s.c), __a) {} : c(_VSTD::move(__s.c), __a) {}
#endif // _LIBCPP_CXX03_LANG #endif // _LIBCPP_CXX03_LANG
#if _LIBCPP_STD_VER >= 23 #if _LIBCPP_STD_VER >= 23
template <class _InputIterator, template <class _InputIterator,
class = __enable_if_t<__is_cpp17_input_iterator<_InputIterator>::value>> class = __enable_if_t<__is_cpp17_input_iterator<_InputIterator>::value>>
_LIBCPP_HIDE_FROM_ABI _LIBCPP_HIDE_FROM_ABI
stack(_InputIterator __first, _InputIterator __last) : c(__first, __last) {} stack(_InputIterator __first, _InputIterator __last) : c(__first, __last) {}
▲ Show 20 Lines • Show All 161 Lines • Show Last 20 Lines

libcxx/include/vector

Show First 20 Lines • Show All 2,127 Lines • ▼ Show 20 Lines _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 ~vector() { __destroy_vector(*this)(); }
_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 explicit vector(size_type __n); _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 explicit vector(size_type __n);
#if _LIBCPP_STD_VER >= 14 #if _LIBCPP_STD_VER >= 14
_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 explicit vector(size_type __n, const allocator_type& __a); _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 explicit vector(size_type __n, const allocator_type& __a);
#endif #endif
_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 vector(size_type __n, const value_type& __v); _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 vector(size_type __n, const value_type& __v);
_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 vector(size_type __n, const value_type& __v, const allocator_type& __a); _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 vector(size_type __n, const value_type& __v, const allocator_type& __a);
template <class _InputIterator> template <class _InputIterator>
_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 vector(_InputIterator __first, _InputIterator __last, _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 vector(_InputIterator __first, _InputIterator __last,
typename enable_if<__is_exactly_cpp17_input_iterator<_InputIterator>::value>::type* = 0); typename enable_if<__is_exactly_cpp17_input_iterator<_InputIterator>::value>::type* = nullptr);
template <class _InputIterator> template <class _InputIterator>
_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 vector(_InputIterator __first, _InputIterator __last, const allocator_type& __a, _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 vector(_InputIterator __first, _InputIterator __last, const allocator_type& __a,
typename enable_if<__is_exactly_cpp17_input_iterator<_InputIterator>::value>::type* = 0); typename enable_if<__is_exactly_cpp17_input_iterator<_InputIterator>::value>::type* = nullptr);
template <class _ForwardIterator> template <class _ForwardIterator>
_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 vector(_ForwardIterator __first, _ForwardIterator __last, _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 vector(_ForwardIterator __first, _ForwardIterator __last,
typename enable_if<__is_cpp17_forward_iterator<_ForwardIterator>::value>::type* = 0); typename enable_if<__is_cpp17_forward_iterator<_ForwardIterator>::value>::type* = nullptr);
template <class _ForwardIterator> template <class _ForwardIterator>
_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 vector(_ForwardIterator __first, _ForwardIterator __last, const allocator_type& __a, _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 vector(_ForwardIterator __first, _ForwardIterator __last, const allocator_type& __a,
typename enable_if<__is_cpp17_forward_iterator<_ForwardIterator>::value>::type* = 0); typename enable_if<__is_cpp17_forward_iterator<_ForwardIterator>::value>::type* = nullptr);
_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 vector(const vector& __v); _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 vector(const vector& __v);
_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 vector(const vector& __v, const allocator_type& __a); _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 vector(const vector& __v, const allocator_type& __a);
_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 vector& operator=(const vector& __v); _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 vector& operator=(const vector& __v);
#ifndef _LIBCPP_CXX03_LANG #ifndef _LIBCPP_CXX03_LANG
_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 vector(initializer_list<value_type> __il); _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 vector(initializer_list<value_type> __il);
_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 vector(initializer_list<value_type> __il, const allocator_type& __a); _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 vector(initializer_list<value_type> __il, const allocator_type& __a);
▲ Show 20 Lines • Show All 1,217 Lines • Show Last 20 Lines

libcxx/test/libcxx/depr/depr.default.allocator/allocator.members/construct.cxx2a.pass.cpp

Show First 20 Lines • Show All 93 Lines • ▼ Show 20 Lines globalMemCounter.reset();
a.construct(ap, 5); a.construct(ap, 5);
assert(globalMemCounter.checkOutstandingNewEq(1)); assert(globalMemCounter.checkOutstandingNewEq(1));
assert(A_constructed == 1); assert(A_constructed == 1);
a.destroy(ap); a.destroy(ap);
assert(globalMemCounter.checkOutstandingNewEq(1)); assert(globalMemCounter.checkOutstandingNewEq(1));
assert(A_constructed == 0); assert(A_constructed == 0);
a.construct(ap, 5, (int*)0); a.construct(ap, 5, (int*)nullptr);
assert(globalMemCounter.checkOutstandingNewEq(1)); assert(globalMemCounter.checkOutstandingNewEq(1));
assert(A_constructed == 1); assert(A_constructed == 1);
a.destroy(ap); a.destroy(ap);
assert(globalMemCounter.checkOutstandingNewEq(1)); assert(globalMemCounter.checkOutstandingNewEq(1));
assert(A_constructed == 0); assert(A_constructed == 0);
a.deallocate(ap, 3); a.deallocate(ap, 3);
▲ Show 20 Lines • Show All 42 Lines • Show Last 20 Lines

libcxx/test/libcxx/language.support/cmp/cmp.categories.pre/zero_type.verify.cpp

  • This file was moved from libcxx/test/std/language.support/cmp/cmp.categories.pre/zero_type.verify.cpp.
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
philnikUnsubmitted
Done
ReplyInline Actions

I think this test should be inside test/libcxx, since it is very implementation-specific.

philnik: I think this test should be inside `test/libcxx`, since it is very implementation-specific.
fsb4000AuthorUnsubmitted
Done
ReplyInline Actions

Ok.

fsb4000: Ok.
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// UNSUPPORTED: c++03, c++11, c++14, c++17 // UNSUPPORTED: c++03, c++11, c++14, c++17
// In MSVC mode, there's a slightly different number of errors printed for
// each of these, so it doesn't add up to the exact expected count of 18.
// XFAIL: msvc
// <compare> // <compare>
// Ensure we reject all cases where an argument other than a literal 0 is used // Ensure we reject all cases where an argument other than a literal 0 is used
// for a comparison against a comparison category type. // for a comparison against a comparison category type.
#include <compare> #include <compare>
#define TEST_FAIL(v, op) \ #define TEST_FAIL(v, op) \
void(v op 0L); \ void(v op 0L); \
void(0L op v); \ void(0L op v); \
void(v op nullptr); \ void(v op nullptr); \
void(nullptr op v); \ void(nullptr op v)
EricWFUnsubmitted
Not Done
ReplyInline Actions

This change seems wrong. It looks like we're enforcing that an error actually occurs when zero is used.
But those test cases get removed?

Maybe we should disable the warning in this test.

EricWF: This change seems wrong. It looks like we're enforcing that an error actually occurs when zero…
void(v op(1 - 1)); \
void((1 - 1) op v)
#define TEST_PASS(v, op) \ #define TEST_PASS(v, op) \
void(v op 0); \ void(v op 0); \
void(0 op v) void(0 op v)
template <typename T> template <typename T>
void test_category(T v) { void test_category(T v) {
TEST_FAIL(v, ==); // expected-error 18 {{}} TEST_FAIL(v, ==); // expected-error 12 {{}}
TEST_FAIL(v, !=); // expected-error 18 {{}} TEST_FAIL(v, !=); // expected-error 12 {{}}
TEST_FAIL(v, <); // expected-error 18 {{}} TEST_FAIL(v, <); // expected-error 12 {{}}
TEST_FAIL(v, <=); // expected-error 18 {{}} TEST_FAIL(v, <=); // expected-error 12 {{}}
TEST_FAIL(v, >); // expected-error 18 {{}} TEST_FAIL(v, >); // expected-error 12 {{}}
TEST_FAIL(v, >=); // expected-error 18 {{}} TEST_FAIL(v, >=); // expected-error 12 {{}}
TEST_FAIL(v, <=>); // expected-error 18 {{}} TEST_FAIL(v, <=>); // expected-error 12 {{}}
TEST_PASS(v, ==); TEST_PASS(v, ==);
TEST_PASS(v, !=); TEST_PASS(v, !=);
TEST_PASS(v, <); TEST_PASS(v, <);
TEST_PASS(v, >); TEST_PASS(v, >);
TEST_PASS(v, <=); TEST_PASS(v, <=);
TEST_PASS(v, >=); TEST_PASS(v, >=);
TEST_PASS(v, <=>); TEST_PASS(v, <=>);
} }
void f() { void f() {
test_category(std::strong_ordering::equivalent); test_category(std::strong_ordering::equivalent);
test_category(std::weak_ordering::equivalent); test_category(std::weak_ordering::equivalent);
test_category(std::partial_ordering::equivalent); test_category(std::partial_ordering::equivalent);
} }

libcxx/test/libcxx/strings/string.view/assert.ctor.pointer.pass.cpp

//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// REQUIRES: has-unix-headers // REQUIRES: has-unix-headers
// UNSUPPORTED: c++11, c++14 // UNSUPPORTED: c++11, c++14
// UNSUPPORTED: c++03 // UNSUPPORTED: c++03
// XFAIL: use_system_cxx_lib && target={{.+}}-apple-macosx{{10.9|10.10|10.11|10.12|10.13|10.14|10.15|11.0|12.0}} // XFAIL: use_system_cxx_lib && target={{.+}}-apple-macosx{{10.9|10.10|10.11|10.12|10.13|10.14|10.15|11.0|12.0}}
// ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_ENABLE_ASSERTIONS=1 // ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_ENABLE_ASSERTIONS=1 -Wno-zero-as-null-pointer-constant
// Construct a string_view from a null pointer // Construct a string_view from a null pointer
// constexpr basic_string_view( const CharT* s ); // constexpr basic_string_view( const CharT* s );
#include <string_view> #include <string_view>
#include "check_assertion.h" #include "check_assertion.h"
Show All 14 Lines

libcxx/test/std/depr/depr.auto.ptr/auto.ptr/auto.ptr.cons/assignment.compile.fail.cpp

Show All 25 Linestest()
A* p2 = new A(2); A* p2 = new A(2);
std::auto_ptr<A> ap2(p2); std::auto_ptr<A> ap2(p2);
assert(A::count == 2); assert(A::count == 2);
assert(ap1.get() == p1); assert(ap1.get() == p1);
assert(ap2.get() == p2); assert(ap2.get() == p2);
std::auto_ptr<A>& apr = ap2 = ap1; std::auto_ptr<A>& apr = ap2 = ap1;
assert(&apr == &ap2); assert(&apr == &ap2);
assert(A::count == 1); assert(A::count == 1);
assert(ap1.get() == 0); assert(ap1.get() == nullptr);
assert(ap2.get() == p1); assert(ap2.get() == p1);
} }
assert(A::count == 0); assert(A::count == 0);
} }
int main(int, char**) int main(int, char**)
{ {
test(); test();
return 0; return 0;
} }

libcxx/test/std/depr/depr.auto.ptr/auto.ptr/auto.ptr.cons/assignment.pass.cpp

Show All 29 Linestest()
A* p2 = new A(2); A* p2 = new A(2);
std::auto_ptr<A> ap2(p2); std::auto_ptr<A> ap2(p2);
assert(A::count == 2); assert(A::count == 2);
assert(ap1.get() == p1); assert(ap1.get() == p1);
assert(ap2.get() == p2); assert(ap2.get() == p2);
std::auto_ptr<A>& apr = ap2 = ap1; std::auto_ptr<A>& apr = ap2 = ap1;
assert(&apr == &ap2); assert(&apr == &ap2);
assert(A::count == 1); assert(A::count == 1);
assert(ap1.get() == 0); assert(ap1.get() == nullptr);
assert(ap2.get() == p1); assert(ap2.get() == p1);
} }
assert(A::count == 0); assert(A::count == 0);
} }
int main(int, char**) int main(int, char**)
{ {
test(); test();
return 0; return 0;
} }

libcxx/test/std/depr/depr.auto.ptr/auto.ptr/auto.ptr.cons/convert.compile.fail.cpp

Show All 18 Lines
void void
test() test()
{ {
{ {
B* p = new B(1); B* p = new B(1);
const std::auto_ptr<B> ap1(p); const std::auto_ptr<B> ap1(p);
std::auto_ptr<A> ap2(ap1); std::auto_ptr<A> ap2(ap1);
assert(ap1.get() == 0); assert(ap1.get() == nullptr);
assert(ap2.get() == p); assert(ap2.get() == p);
assert(A::count == 1); assert(A::count == 1);
assert(B::count == 1); assert(B::count == 1);
} }
assert(A::count == 0); assert(A::count == 0);
assert(B::count == 0); assert(B::count == 0);
} }
int main(int, char**) int main(int, char**)
{ {
test(); test();
return 0; return 0;
} }

libcxx/test/std/depr/depr.auto.ptr/auto.ptr/auto.ptr.cons/convert.pass.cpp

Show All 22 Lines
void void
test() test()
{ {
{ {
B* p = new B(1); B* p = new B(1);
std::auto_ptr<B> ap1(p); std::auto_ptr<B> ap1(p);
std::auto_ptr<A> ap2(ap1); std::auto_ptr<A> ap2(ap1);
assert(ap1.get() == 0); assert(ap1.get() == nullptr);
assert(ap2.get() == p); assert(ap2.get() == p);
assert(A::count == 1); assert(A::count == 1);
assert(B::count == 1); assert(B::count == 1);
} }
assert(A::count == 0); assert(A::count == 0);
assert(B::count == 0); assert(B::count == 0);
} }
int main(int, char**) int main(int, char**)
{ {
test(); test();
return 0; return 0;
} }

libcxx/test/std/depr/depr.auto.ptr/auto.ptr/auto.ptr.cons/convert_assignment.compile.fail.cpp

Show All 29 Linestest()
assert(A::count == 2); assert(A::count == 2);
assert(B::count == 1); assert(B::count == 1);
assert(ap1.get() == p1); assert(ap1.get() == p1);
assert(ap2.get() == p2); assert(ap2.get() == p2);
std::auto_ptr<A>& apr = ap2 = ap1; std::auto_ptr<A>& apr = ap2 = ap1;
assert(&apr == &ap2); assert(&apr == &ap2);
assert(A::count == 1); assert(A::count == 1);
assert(B::count == 1); assert(B::count == 1);
assert(ap1.get() == 0); assert(ap1.get() == nullptr);
assert(ap2.get() == p1); assert(ap2.get() == p1);
} }
assert(A::count == 0); assert(A::count == 0);
assert(B::count == 0); assert(B::count == 0);
} }
int main(int, char**) int main(int, char**)
{ {
test(); test();
return 0; return 0;
} }

libcxx/test/std/depr/depr.auto.ptr/auto.ptr/auto.ptr.cons/convert_assignment.pass.cpp

Show All 31 Linestest()
assert(A::count == 2); assert(A::count == 2);
assert(B::count == 1); assert(B::count == 1);
assert(ap1.get() == p1); assert(ap1.get() == p1);
assert(ap2.get() == p2); assert(ap2.get() == p2);
std::auto_ptr<A>& apr = ap2 = ap1; std::auto_ptr<A>& apr = ap2 = ap1;
assert(&apr == &ap2); assert(&apr == &ap2);
assert(A::count == 1); assert(A::count == 1);
assert(B::count == 1); assert(B::count == 1);
assert(ap1.get() == 0); assert(ap1.get() == nullptr);
assert(ap2.get() == p1); assert(ap2.get() == p1);
} }
assert(A::count == 0); assert(A::count == 0);
assert(B::count == 0); assert(B::count == 0);
} }
int main(int, char**) int main(int, char**)
{ {
test(); test();
return 0; return 0;
} }

libcxx/test/std/depr/depr.auto.ptr/auto.ptr/auto.ptr.cons/copy.compile.fail.cpp

Show All 20 Lines
void void
test() test()
{ {
{ {
A* p = new A(1); A* p = new A(1);
const std::auto_ptr<A> ap1(p); const std::auto_ptr<A> ap1(p);
std::auto_ptr<A> ap2(ap1); std::auto_ptr<A> ap2(ap1);
assert(ap1.get() == 0); assert(ap1.get() == nullptr);
assert(ap2.get() == p); assert(ap2.get() == p);
assert(A::count == 1); assert(A::count == 1);
} }
assert(A::count == 0); assert(A::count == 0);
} }
int main(int, char**) int main(int, char**)
{ {
test(); test();
return 0; return 0;
} }

libcxx/test/std/depr/depr.auto.ptr/auto.ptr/auto.ptr.cons/copy.pass.cpp

Show All 22 Lines
void void
test() test()
{ {
{ {
A* p = new A(1); A* p = new A(1);
std::auto_ptr<A> ap1(p); std::auto_ptr<A> ap1(p);
std::auto_ptr<A> ap2(ap1); std::auto_ptr<A> ap2(ap1);
assert(ap1.get() == 0); assert(ap1.get() == nullptr);
assert(ap2.get() == p); assert(ap2.get() == p);
assert(A::count == 1); assert(A::count == 1);
} }
assert(A::count == 0); assert(A::count == 0);
} }
int main(int, char**) int main(int, char**)
{ {
test(); test();
return 0; return 0;
} }

libcxx/test/std/depr/depr.auto.ptr/auto.ptr/auto.ptr.cons/explicit.compile.fail.cpp

Show All 25 Linestest()
A* p = new A(1); A* p = new A(1);
std::auto_ptr<A> ap = p; std::auto_ptr<A> ap = p;
assert(ap.get() == p); assert(ap.get() == p);
assert(A::count == 1); assert(A::count == 1);
} }
assert(A::count == 0); assert(A::count == 0);
{ {
std::auto_ptr<A> ap; std::auto_ptr<A> ap;
assert(ap.get() == 0); assert(ap.get() == nullptr);
} }
} }
int main(int, char**) int main(int, char**)
{ {
test(); test();
return 0; return 0;
} }

libcxx/test/std/depr/depr.auto.ptr/auto.ptr/auto.ptr.cons/pointer.pass.cpp

Show All 27 Linestest()
A* p = new A(1); A* p = new A(1);
std::auto_ptr<A> ap(p); std::auto_ptr<A> ap(p);
assert(ap.get() == p); assert(ap.get() == p);
assert(A::count == 1); assert(A::count == 1);
} }
assert(A::count == 0); assert(A::count == 0);
{ {
std::auto_ptr<A> ap; std::auto_ptr<A> ap;
assert(ap.get() == 0); assert(ap.get() == nullptr);
} }
} }
int main(int, char**) int main(int, char**)
{ {
test(); test();
return 0; return 0;
} }

libcxx/test/std/depr/depr.auto.ptr/auto.ptr/auto.ptr.conv/assign_from_auto_ptr_ref.pass.cpp

Show All 26 Linestest()
{ {
A* p1 = new A(1); A* p1 = new A(1);
std::auto_ptr<A> ap1(p1); std::auto_ptr<A> ap1(p1);
std::auto_ptr_ref<A> apr = ap1; std::auto_ptr_ref<A> apr = ap1;
std::auto_ptr<A> ap2(new A(2)); std::auto_ptr<A> ap2(new A(2));
ap2 = apr; ap2 = apr;
assert(A::count == 1); assert(A::count == 1);
assert(ap2.get() == p1); assert(ap2.get() == p1);
assert(ap1.get() == 0); assert(ap1.get() == nullptr);
} }
assert(A::count == 0); assert(A::count == 0);
} }
int main(int, char**) int main(int, char**)
{ {
test(); test();
return 0; return 0;
} }

libcxx/test/std/depr/depr.auto.ptr/auto.ptr/auto.ptr.conv/convert_from_auto_ptr_ref.pass.cpp

Show All 24 Lines
test() test()
{ {
{ {
B* p1 = new B(1); B* p1 = new B(1);
std::auto_ptr<B> ap1(p1); std::auto_ptr<B> ap1(p1);
std::auto_ptr_ref<A> apr = ap1; std::auto_ptr_ref<A> apr = ap1;
std::auto_ptr<A> ap2(apr); std::auto_ptr<A> ap2(apr);
assert(ap2.get() == p1); assert(ap2.get() == p1);
assert(ap1.get() == 0); assert(ap1.get() == nullptr);
} }
assert(A::count == 0); assert(A::count == 0);
assert(B::count == 0); assert(B::count == 0);
} }
int main(int, char**) int main(int, char**)
{ {
test(); test();
return 0; return 0;
} }

libcxx/test/std/depr/depr.auto.ptr/auto.ptr/auto.ptr.members/release.pass.cpp

Show All 23 Lines
void void
test() test()
{ {
{ {
A* p = new A(1); A* p = new A(1);
std::auto_ptr<A> ap(p); std::auto_ptr<A> ap(p);
A* p2 = ap.release(); A* p2 = ap.release();
assert(p2 == p); assert(p2 == p);
assert(ap.get() == 0); assert(ap.get() == nullptr);
delete p; delete p;
} }
assert(A::count == 0); assert(A::count == 0);
} }
int main(int, char**) int main(int, char**)
{ {
test(); test();
return 0; return 0;
} }

libcxx/test/std/depr/depr.auto.ptr/auto.ptr/auto.ptr.members/reset.pass.cpp

Show All 22 Lines
void void
test() test()
{ {
{ {
A* p = new A(1); A* p = new A(1);
std::auto_ptr<A> ap(p); std::auto_ptr<A> ap(p);
ap.reset(); ap.reset();
assert(ap.get() == 0); assert(ap.get() == nullptr);
assert(A::count == 0); assert(A::count == 0);
} }
assert(A::count == 0); assert(A::count == 0);
{ {
A* p = new A(1); A* p = new A(1);
std::auto_ptr<A> ap(p); std::auto_ptr<A> ap(p);
ap.reset(p); ap.reset(p);
assert(ap.get() == p); assert(ap.get() == p);
Show All 20 Lines

libcxx/test/std/depr/depr.c.headers/inttypes_h.compile.pass.cpp

Show First 20 Lines • Show All 907 Lines • ▼ Show 20 Linesvoid f() {
{ intmax_t x = 0; (void)x; } { intmax_t x = 0; (void)x; }
{ uintmax_t x = 0; (void)x; } { uintmax_t x = 0; (void)x; }
{ imaxdiv_t x = {}; (void)x; } { imaxdiv_t x = {}; (void)x; }
intmax_t i = 0; (void)i; intmax_t i = 0; (void)i;
ASSERT_SAME_TYPE(intmax_t, decltype(imaxabs(i))); ASSERT_SAME_TYPE(intmax_t, decltype(imaxabs(i)));
ASSERT_SAME_TYPE(imaxdiv_t, decltype(imaxdiv(i, i))); ASSERT_SAME_TYPE(imaxdiv_t, decltype(imaxdiv(i, i)));
ASSERT_SAME_TYPE(intmax_t, decltype(strtoimax("", (char**)0, 0))); ASSERT_SAME_TYPE(intmax_t, decltype(strtoimax("", (char**)nullptr, 0)));
ASSERT_SAME_TYPE(uintmax_t, decltype(strtoumax("", (char**)0, 0))); ASSERT_SAME_TYPE(uintmax_t, decltype(strtoumax("", (char**)nullptr, 0)));
#ifndef TEST_HAS_NO_WIDE_CHARACTERS #ifndef TEST_HAS_NO_WIDE_CHARACTERS
ASSERT_SAME_TYPE(intmax_t, decltype(wcstoimax(L"", (wchar_t**)0, 0))); ASSERT_SAME_TYPE(intmax_t, decltype(wcstoimax(L"", (wchar_t**)nullptr, 0)));
ASSERT_SAME_TYPE(uintmax_t, decltype(wcstoumax(L"", (wchar_t**)0, 0))); ASSERT_SAME_TYPE(uintmax_t, decltype(wcstoumax(L"", (wchar_t**)nullptr, 0)));
#endif #endif
} }

libcxx/test/std/depr/depr.c.headers/math_h.pass.cpp

Show First 20 Lines • Show All 232 Lines • ▼ Show 20 Lines
void test_log10() { void test_log10() {
ASSERT_SAME_TYPE(decltype(log10f(0)), float); ASSERT_SAME_TYPE(decltype(log10f(0)), float);
ASSERT_SAME_TYPE(decltype(log10l(0)), long double); ASSERT_SAME_TYPE(decltype(log10l(0)), long double);
ASSERT_SAME_TYPE(decltype(log10(Ambiguous())), Ambiguous); ASSERT_SAME_TYPE(decltype(log10(Ambiguous())), Ambiguous);
assert(log10(1) == 0); assert(log10(1) == 0);
} }
void test_modf() { void test_modf() {
ASSERT_SAME_TYPE(decltype(modf((float)0, (float*)0)), float); ASSERT_SAME_TYPE(decltype(modf((float)0, (float*)nullptr)), float);
ASSERT_SAME_TYPE(decltype(modf((double)0, (double*)0)), double); ASSERT_SAME_TYPE(decltype(modf((double)0, (double*)nullptr)), double);
ASSERT_SAME_TYPE(decltype(modf((long double)0, (long double*)0)), long double); ASSERT_SAME_TYPE(decltype(modf((long double)0, (long double*)nullptr)), long double);
ASSERT_SAME_TYPE(decltype(modff(0, (float*)0)), float); ASSERT_SAME_TYPE(decltype(modff(0, (float*)nullptr)), float);
ASSERT_SAME_TYPE(decltype(modfl(0, (long double*)0)), long double); ASSERT_SAME_TYPE(decltype(modfl(0, (long double*)nullptr)), long double);
ASSERT_SAME_TYPE(decltype(modf(Ambiguous(), (Ambiguous*)0)), Ambiguous); ASSERT_SAME_TYPE(decltype(modf(Ambiguous(), (Ambiguous*)nullptr)), Ambiguous);
double i; double i;
assert(modf(1., &i) == 0); assert(modf(1., &i) == 0);
} }
void test_pow() { void test_pow() {
ASSERT_SAME_TYPE(decltype(powf(0,0)), float); ASSERT_SAME_TYPE(decltype(powf(0,0)), float);
ASSERT_SAME_TYPE(decltype(powl(0,0)), long double); ASSERT_SAME_TYPE(decltype(powl(0,0)), long double);
ASSERT_SAME_TYPE(decltype(pow((int)0, (int)0)), double); ASSERT_SAME_TYPE(decltype(pow((int)0, (int)0)), double);
▲ Show 20 Lines • Show All 742 Lines • Show Last 20 Lines

libcxx/test/std/depr/depr.c.headers/stdio_h.compile.pass.cpp

Show First 20 Lines • Show All 97 Lines • ▼ Show 20 Lines
#endif #endif
TEST_CLANG_DIAGNOSTIC_IGNORED("-Wformat-zero-length") TEST_CLANG_DIAGNOSTIC_IGNORED("-Wformat-zero-length")
TEST_GCC_DIAGNOSTIC_IGNORED("-Wformat-zero-length") TEST_GCC_DIAGNOSTIC_IGNORED("-Wformat-zero-length")
FILE* fp = 0; FILE* fp = 0;
fpos_t fpos = fpos_t(); fpos_t fpos = fpos_t();
size_t s = 0; size_t s = 0;
char* cp = 0; char* cp = nullptr;
char arr[] = {'a', 'b'}; char arr[] = {'a', 'b'};
va_list va; va_list va;
ASSERT_SAME_TYPE(int, decltype(remove(""))); ASSERT_SAME_TYPE(int, decltype(remove("")));
ASSERT_SAME_TYPE(int, decltype(rename("",""))); ASSERT_SAME_TYPE(int, decltype(rename("","")));
ASSERT_SAME_TYPE(FILE*, decltype(tmpfile())); ASSERT_SAME_TYPE(FILE*, decltype(tmpfile()));
TEST_DIAGNOSTIC_PUSH TEST_DIAGNOSTIC_PUSH
TEST_CLANG_DIAGNOSTIC_IGNORED("-Wdeprecated-declarations") TEST_CLANG_DIAGNOSTIC_IGNORED("-Wdeprecated-declarations")
TEST_GCC_DIAGNOSTIC_IGNORED("-Wdeprecated-declarations") TEST_GCC_DIAGNOSTIC_IGNORED("-Wdeprecated-declarations")
Show All 39 Lines
TEST_GCC_DIAGNOSTIC_IGNORED("-Wdeprecated-declarations") TEST_GCC_DIAGNOSTIC_IGNORED("-Wdeprecated-declarations")
ASSERT_SAME_TYPE(char*, decltype(gets(cp))); ASSERT_SAME_TYPE(char*, decltype(gets(cp)));
TEST_DIAGNOSTIC_POP TEST_DIAGNOSTIC_POP
#endif #endif
ASSERT_SAME_TYPE(int, decltype(putc(0,fp))); ASSERT_SAME_TYPE(int, decltype(putc(0,fp)));
ASSERT_SAME_TYPE(int, decltype(putchar(0))); ASSERT_SAME_TYPE(int, decltype(putchar(0)));
ASSERT_SAME_TYPE(int, decltype(puts(""))); ASSERT_SAME_TYPE(int, decltype(puts("")));
ASSERT_SAME_TYPE(int, decltype(ungetc(0,fp))); ASSERT_SAME_TYPE(int, decltype(ungetc(0,fp)));
ASSERT_SAME_TYPE(size_t, decltype(fread((void*)0,0,0,fp))); ASSERT_SAME_TYPE(size_t, decltype(fread((void*)nullptr,0,0,fp)));
ASSERT_SAME_TYPE(size_t, decltype(fwrite((const void*)arr,1,0,fp))); ASSERT_SAME_TYPE(size_t, decltype(fwrite((const void*)arr,1,0,fp)));
#ifndef TEST_HAS_NO_FGETPOS_FSETPOS #ifndef TEST_HAS_NO_FGETPOS_FSETPOS
ASSERT_SAME_TYPE(int, decltype(fgetpos(fp, &fpos))); ASSERT_SAME_TYPE(int, decltype(fgetpos(fp, &fpos)));
#endif #endif
ASSERT_SAME_TYPE(int, decltype(fseek(fp, 0,0))); ASSERT_SAME_TYPE(int, decltype(fseek(fp, 0,0)));
#ifndef TEST_HAS_NO_FGETPOS_FSETPOS #ifndef TEST_HAS_NO_FGETPOS_FSETPOS
ASSERT_SAME_TYPE(int, decltype(fsetpos(fp, &fpos))); ASSERT_SAME_TYPE(int, decltype(fsetpos(fp, &fpos)));
#endif #endif
ASSERT_SAME_TYPE(long, decltype(ftell(fp))); ASSERT_SAME_TYPE(long, decltype(ftell(fp)));
ASSERT_SAME_TYPE(void, decltype(rewind(fp))); ASSERT_SAME_TYPE(void, decltype(rewind(fp)));
ASSERT_SAME_TYPE(void, decltype(clearerr(fp))); ASSERT_SAME_TYPE(void, decltype(clearerr(fp)));
ASSERT_SAME_TYPE(int, decltype(feof(fp))); ASSERT_SAME_TYPE(int, decltype(feof(fp)));
ASSERT_SAME_TYPE(int, decltype(ferror(fp))); ASSERT_SAME_TYPE(int, decltype(ferror(fp)));
ASSERT_SAME_TYPE(void, decltype(perror(""))); ASSERT_SAME_TYPE(void, decltype(perror("")));

libcxx/test/std/depr/depr.c.headers/stdlib_h.pass.cpp

Show First 20 Lines • Show All 109 Lines • ▼ Show 20 Linesint main(int, char**) {
ASSERT_SAME_TYPE(long long, decltype(strtoll("", endptr,0))); ASSERT_SAME_TYPE(long long, decltype(strtoll("", endptr,0)));
ASSERT_SAME_TYPE(unsigned long, decltype(strtoul("", endptr,0))); ASSERT_SAME_TYPE(unsigned long, decltype(strtoul("", endptr,0)));
ASSERT_SAME_TYPE(unsigned long long, decltype(strtoull("", endptr,0))); ASSERT_SAME_TYPE(unsigned long long, decltype(strtoull("", endptr,0)));
ASSERT_SAME_TYPE(int, decltype(rand())); ASSERT_SAME_TYPE(int, decltype(rand()));
ASSERT_SAME_TYPE(void, decltype(srand(0))); ASSERT_SAME_TYPE(void, decltype(srand(0)));
// aligned_alloc tested in stdlib_h.aligned_alloc.compile.pass.cpp // aligned_alloc tested in stdlib_h.aligned_alloc.compile.pass.cpp
void* pv = 0; void* pv = nullptr;
void (*handler)() = 0; void (*handler)() = nullptr;
int (*comp)(void const*, void const*) = 0; int (*comp)(void const*, void const*) = nullptr;
ASSERT_SAME_TYPE(void*, decltype(calloc(0,0))); ASSERT_SAME_TYPE(void*, decltype(calloc(0,0)));
ASSERT_SAME_TYPE(void, decltype(free(0))); ASSERT_SAME_TYPE(void, decltype(free(nullptr)));
ASSERT_SAME_TYPE(void*, decltype(malloc(0))); ASSERT_SAME_TYPE(void*, decltype(malloc(0)));
ASSERT_SAME_TYPE(void*, decltype(realloc(0,0))); ASSERT_SAME_TYPE(void*, decltype(realloc(0,0)));
ASSERT_SAME_TYPE(void, decltype(abort())); ASSERT_SAME_TYPE(void, decltype(abort()));
ASSERT_SAME_TYPE(int, decltype(atexit(handler))); ASSERT_SAME_TYPE(int, decltype(atexit(handler)));
ASSERT_SAME_TYPE(void, decltype(exit(0))); ASSERT_SAME_TYPE(void, decltype(exit(0)));
ASSERT_SAME_TYPE(void, decltype(_Exit(0))); ASSERT_SAME_TYPE(void, decltype(_Exit(0)));
ASSERT_SAME_TYPE(char*, decltype(getenv(""))); ASSERT_SAME_TYPE(char*, decltype(getenv("")));
ASSERT_SAME_TYPE(int, decltype(system(""))); ASSERT_SAME_TYPE(int, decltype(system("")));
Show All 23 Lines

libcxx/test/std/depr/depr.c.headers/string_h.pass.cpp

Show All 15 Lines
#ifndef NULL #ifndef NULL
#error NULL not defined #error NULL not defined
#endif #endif
int main(int, char**) { int main(int, char**) {
// Functions we get directly from the C library (just check the signature) // Functions we get directly from the C library (just check the signature)
{ {
size_t s = 0; size_t s = 0;
void* vp = 0; void* vp = nullptr;
const void* vpc = 0; const void* vpc = nullptr;
char* cp = 0; char* cp = nullptr;
const char* cpc = 0; const char* cpc = nullptr;
ASSERT_SAME_TYPE(void*, decltype(memcpy(vp, vpc, s))); ASSERT_SAME_TYPE(void*, decltype(memcpy(vp, vpc, s)));
ASSERT_SAME_TYPE(void*, decltype(memmove(vp, vpc, s))); ASSERT_SAME_TYPE(void*, decltype(memmove(vp, vpc, s)));
ASSERT_SAME_TYPE(char*, decltype(strcpy(cp, cpc))); ASSERT_SAME_TYPE(char*, decltype(strcpy(cp, cpc)));
ASSERT_SAME_TYPE(char*, decltype(strncpy(cp, cpc, s))); ASSERT_SAME_TYPE(char*, decltype(strncpy(cp, cpc, s)));
ASSERT_SAME_TYPE(char*, decltype(strcat(cp, cpc))); ASSERT_SAME_TYPE(char*, decltype(strcat(cp, cpc)));
ASSERT_SAME_TYPE(char*, decltype(strncat(cp, cpc, s))); ASSERT_SAME_TYPE(char*, decltype(strncat(cp, cpc, s)));
ASSERT_SAME_TYPE(int, decltype(memcmp(vpc, vpc, s))); ASSERT_SAME_TYPE(int, decltype(memcmp(vpc, vpc, s)));
ASSERT_SAME_TYPE(int, decltype(strcmp(cpc, cpc))); ASSERT_SAME_TYPE(int, decltype(strcmp(cpc, cpc)));
▲ Show 20 Lines • Show All 101 Lines • Show Last 20 Lines

libcxx/test/std/depr/depr.c.headers/uchar_h.compile.pass.cpp

Show All 18 Lines
#include <uchar.h> #include <uchar.h>
#include "test_macros.h" #include "test_macros.h"
// __STDC_UTF_16__ may or may not be defined by the C standard library // __STDC_UTF_16__ may or may not be defined by the C standard library
// __STDC_UTF_32__ may or may not be defined by the C standard library // __STDC_UTF_32__ may or may not be defined by the C standard library
#if !defined(TEST_HAS_NO_C8RTOMB_MBRTOC8) #if !defined(TEST_HAS_NO_C8RTOMB_MBRTOC8)
ASSERT_SAME_TYPE(size_t, decltype(mbrtoc8((char8_t*)0, (const char*)0, (size_t)0, (mbstate_t*)0))); ASSERT_SAME_TYPE(size_t, decltype(mbrtoc8((char8_t*)nullptr, (const char*)nullptr, (size_t)0, (mbstate_t*)nullptr)));
ASSERT_SAME_TYPE(size_t, decltype(c8rtomb((char*)0, (char8_t)0, (mbstate_t*)0))); ASSERT_SAME_TYPE(size_t, decltype(c8rtomb((char*)nullptr, (char8_t)0, (mbstate_t*)nullptr)));
#endif #endif
ASSERT_SAME_TYPE(size_t, decltype(mbrtoc16((char16_t*)0, (const char*)0, (size_t)0, (mbstate_t*)0))); ASSERT_SAME_TYPE(size_t, decltype(mbrtoc16((char16_t*)nullptr, (const char*)nullptr, (size_t)0, (mbstate_t*)nullptr)));
ASSERT_SAME_TYPE(size_t, decltype(c16rtomb((char*)0, (char16_t)0, (mbstate_t*)0))); ASSERT_SAME_TYPE(size_t, decltype(c16rtomb((char*)nullptr, (char16_t)0, (mbstate_t*)nullptr)));
ASSERT_SAME_TYPE(size_t, decltype(mbrtoc32((char32_t*)0, (const char*)0, (size_t)0, (mbstate_t*)0))); ASSERT_SAME_TYPE(size_t, decltype(mbrtoc32((char32_t*)nullptr, (const char*)nullptr, (size_t)0, (mbstate_t*)nullptr)));
ASSERT_SAME_TYPE(size_t, decltype(c16rtomb((char*)0, (char32_t)0, (mbstate_t*)0))); ASSERT_SAME_TYPE(size_t, decltype(c16rtomb((char*)nullptr, (char32_t)0, (mbstate_t*)nullptr)));

libcxx/test/std/depr/depr.c.headers/wchar_h.compile.pass.cpp

Show First 20 Lines • Show All 98 Lines • ▼ Show 20 Lines
ASSERT_SAME_TYPE(wchar_t*, decltype(wmemset(ws, L' ', s))); ASSERT_SAME_TYPE(wchar_t*, decltype(wmemset(ws, L' ', s)));
ASSERT_SAME_TYPE(size_t, decltype(wcsftime(ws, s, L"", tm))); ASSERT_SAME_TYPE(size_t, decltype(wcsftime(ws, s, L"", tm)));
ASSERT_SAME_TYPE(wint_t, decltype(btowc(0))); ASSERT_SAME_TYPE(wint_t, decltype(btowc(0)));
ASSERT_SAME_TYPE(int, decltype(wctob(w))); ASSERT_SAME_TYPE(int, decltype(wctob(w)));
ASSERT_SAME_TYPE(int, decltype(mbsinit(&mb))); ASSERT_SAME_TYPE(int, decltype(mbsinit(&mb)));
ASSERT_SAME_TYPE(size_t, decltype(mbrlen("", s, &mb))); ASSERT_SAME_TYPE(size_t, decltype(mbrlen("", s, &mb)));
ASSERT_SAME_TYPE(size_t, decltype(mbrtowc(ws, "", s, &mb))); ASSERT_SAME_TYPE(size_t, decltype(mbrtowc(ws, "", s, &mb)));
ASSERT_SAME_TYPE(size_t, decltype(wcrtomb(ns, L' ', &mb))); ASSERT_SAME_TYPE(size_t, decltype(wcrtomb(ns, L' ', &mb)));
ASSERT_SAME_TYPE(size_t, decltype(mbsrtowcs(ws, (const char**)0, s, &mb))); ASSERT_SAME_TYPE(size_t, decltype(mbsrtowcs(ws, (const char**)nullptr, s, &mb)));
ASSERT_SAME_TYPE(size_t, decltype(wcsrtombs(ns, (const wchar_t**)0, s, &mb))); ASSERT_SAME_TYPE(size_t, decltype(wcsrtombs(ns, (const wchar_t**)nullptr, s, &mb)));
ASSERT_SAME_TYPE(wint_t, decltype(getwchar())); ASSERT_SAME_TYPE(wint_t, decltype(getwchar()));
ASSERT_SAME_TYPE(int, decltype(vwscanf(L"", va))); ASSERT_SAME_TYPE(int, decltype(vwscanf(L"", va)));
ASSERT_SAME_TYPE(int, decltype(wscanf(L""))); ASSERT_SAME_TYPE(int, decltype(wscanf(L"")));
ASSERT_SAME_TYPE(wint_t, decltype(putwchar(L' '))); ASSERT_SAME_TYPE(wint_t, decltype(putwchar(L' ')));
ASSERT_SAME_TYPE(int, decltype(vwprintf(L"", va))); ASSERT_SAME_TYPE(int, decltype(vwprintf(L"", va)));
ASSERT_SAME_TYPE(int, decltype(wprintf(L""))); ASSERT_SAME_TYPE(int, decltype(wprintf(L"")));

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

Show First 20 Lines • Show All 919 Lines • ▼ Show 20 Linesint main(int, char**)
std::imaxdiv_t i1 = {}; std::imaxdiv_t i1 = {};
((void)i1); // Prevent unused warning ((void)i1); // Prevent unused warning
} }
std::intmax_t i = 0; std::intmax_t i = 0;
((void)i); // Prevent unused warning ((void)i); // Prevent unused warning
static_assert((std::is_same<decltype(std::imaxabs(i)), std::intmax_t>::value), ""); static_assert((std::is_same<decltype(std::imaxabs(i)), std::intmax_t>::value), "");
static_assert((std::is_same<decltype(std::imaxdiv(i, i)), std::imaxdiv_t>::value), ""); static_assert((std::is_same<decltype(std::imaxdiv(i, i)), std::imaxdiv_t>::value), "");
static_assert((std::is_same<decltype(std::strtoimax("", (char**)0, 0)), std::intmax_t>::value), ""); static_assert((std::is_same<decltype(std::strtoimax("", (char**)nullptr, 0)), std::intmax_t>::value), "");
static_assert((std::is_same<decltype(std::strtoumax("", (char**)0, 0)), std::uintmax_t>::value), ""); static_assert((std::is_same<decltype(std::strtoumax("", (char**)nullptr, 0)), std::uintmax_t>::value), "");
#ifndef TEST_HAS_NO_WIDE_CHARACTERS #ifndef TEST_HAS_NO_WIDE_CHARACTERS
static_assert((std::is_same<decltype(std::wcstoimax(L"", (wchar_t**)0, 0)), std::intmax_t>::value), ""); static_assert((std::is_same<decltype(std::wcstoimax(L"", (wchar_t**)nullptr, 0)), std::intmax_t>::value), "");
static_assert((std::is_same<decltype(std::wcstoumax(L"", (wchar_t**)0, 0)), std::uintmax_t>::value), ""); static_assert((std::is_same<decltype(std::wcstoumax(L"", (wchar_t**)nullptr, 0)), std::uintmax_t>::value), "");
#endif #endif
return 0; return 0;
} }

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

Show First 20 Lines • Show All 77 Lines • ▼ Show 20 Lines
#endif #endif
#include <cstdarg> #include <cstdarg>
TEST_CLANG_DIAGNOSTIC_IGNORED("-Wformat-zero-length") TEST_CLANG_DIAGNOSTIC_IGNORED("-Wformat-zero-length")
int main(int, char**) int main(int, char**)
{ {
std::FILE* fp = 0; std::FILE* fp = nullptr;
std::fpos_t fpos = std::fpos_t(); std::fpos_t fpos = std::fpos_t();
std::size_t s = 0; std::size_t s = 0;
char* cp = 0; char* cp = nullptr;
std::va_list va; std::va_list va;
void const* vp = 0; void const* vp = nullptr;
((void)fp); // Prevent unused warning ((void)fp); // Prevent unused warning
((void)fpos); // Prevent unused warning ((void)fpos); // Prevent unused warning
((void)s); // Prevent unused warning ((void)s); // Prevent unused warning
((void)cp); // Prevent unused warning ((void)cp); // Prevent unused warning
((void)va); // Prevent unused warning ((void)va); // Prevent unused warning
((void)vp); // Prevent unused warning ((void)vp); // Prevent unused warning
static_assert((std::is_same<decltype(std::fclose(fp)), int>::value), ""); static_assert((std::is_same<decltype(std::fclose(fp)), int>::value), "");
static_assert((std::is_same<decltype(std::fflush(fp)), int>::value), ""); static_assert((std::is_same<decltype(std::fflush(fp)), int>::value), "");
Show All 19 Linesint main(int, char**)
static_assert((std::is_same<decltype(std::vsscanf(""," ",va)), int>::value), ""); static_assert((std::is_same<decltype(std::vsscanf(""," ",va)), int>::value), "");
static_assert((std::is_same<decltype(std::fgetc(fp)), int>::value), ""); static_assert((std::is_same<decltype(std::fgetc(fp)), int>::value), "");
static_assert((std::is_same<decltype(std::fgets(cp,0,fp)), char*>::value), ""); static_assert((std::is_same<decltype(std::fgets(cp,0,fp)), char*>::value), "");
static_assert((std::is_same<decltype(std::fputc(0,fp)), int>::value), ""); static_assert((std::is_same<decltype(std::fputc(0,fp)), int>::value), "");
static_assert((std::is_same<decltype(std::fputs("",fp)), int>::value), ""); static_assert((std::is_same<decltype(std::fputs("",fp)), int>::value), "");
static_assert((std::is_same<decltype(std::getc(fp)), int>::value), ""); static_assert((std::is_same<decltype(std::getc(fp)), int>::value), "");
static_assert((std::is_same<decltype(std::putc(0,fp)), int>::value), ""); static_assert((std::is_same<decltype(std::putc(0,fp)), int>::value), "");
static_assert((std::is_same<decltype(std::ungetc(0,fp)), int>::value), ""); static_assert((std::is_same<decltype(std::ungetc(0,fp)), int>::value), "");
static_assert((std::is_same<decltype(std::fread((void*)0,0,0,fp)), std::size_t>::value), ""); static_assert((std::is_same<decltype(std::fread((void*)nullptr,0,0,fp)), std::size_t>::value), "");
static_assert((std::is_same<decltype(std::fwrite(vp,0,0,fp)), std::size_t>::value), ""); static_assert((std::is_same<decltype(std::fwrite(vp,0,0,fp)), std::size_t>::value), "");
#ifndef TEST_HAS_NO_FGETPOS_FSETPOS #ifndef TEST_HAS_NO_FGETPOS_FSETPOS
static_assert((std::is_same<decltype(std::fgetpos(fp, &fpos)), int>::value), ""); static_assert((std::is_same<decltype(std::fgetpos(fp, &fpos)), int>::value), "");
#endif #endif
static_assert((std::is_same<decltype(std::fseek(fp, 0,0)), int>::value), ""); static_assert((std::is_same<decltype(std::fseek(fp, 0,0)), int>::value), "");
#ifndef TEST_HAS_NO_FGETPOS_FSETPOS #ifndef TEST_HAS_NO_FGETPOS_FSETPOS
static_assert((std::is_same<decltype(std::fsetpos(fp, &fpos)), int>::value), ""); static_assert((std::is_same<decltype(std::fsetpos(fp, &fpos)), int>::value), "");
#endif #endif
Show All 37 Lines

libcxx/test/std/input.output/file.streams/fstreams/filebuf.assign/nonmember_swap_min.pass.cpp

Show All 31 Lines std::string tmpB = get_temp_file_name();
std::ofstream sa(tmpA), sb(tmpB); std::ofstream sa(tmpA), sb(tmpB);
sa << "AAAA"; sa << "AAAA";
sb << "BBBB"; sb << "BBBB";
} }
std::filebuf f1; std::filebuf f1;
assert(f1.open(tmpA, std::ios_base::in) != 0); assert(f1.open(tmpA, std::ios_base::in) != 0);
assert(f1.is_open()); assert(f1.is_open());
f1.pubsetbuf(0, 0); f1.pubsetbuf(nullptr, 0);
std::filebuf f2; std::filebuf f2;
assert(f2.open(tmpB, std::ios_base::in) != 0); assert(f2.open(tmpB, std::ios_base::in) != 0);
assert(f2.is_open()); assert(f2.is_open());
f2.pubsetbuf(0, 0); f2.pubsetbuf(nullptr, 0);
assert(f1.sgetc() == 'A'); assert(f1.sgetc() == 'A');
assert(f2.sgetc() == 'B'); assert(f2.sgetc() == 'B');
swap(f1, f2); swap(f1, f2);
assert(f1.is_open()); assert(f1.is_open());
assert(f2.is_open()); assert(f2.is_open());
Show All 9 Lines

libcxx/test/std/input.output/file.streams/fstreams/filebuf.virtuals/overflow.pass.cpp

Show First 20 Lines • Show All 54 Lines • ▼ Show 20 Linesint main(int, char**)
test_buf<char> f; test_buf<char> f;
assert(f.open("overflow.dat", std::ios_base::in) != 0); assert(f.open("overflow.dat", std::ios_base::in) != 0);
assert(f.is_open()); assert(f.is_open());
assert(f.sgetc() == 'a'); assert(f.sgetc() == 'a');
} }
std::remove("overflow.dat"); std::remove("overflow.dat");
{ {
test_buf<char> f; test_buf<char> f;
f.pubsetbuf(0, 0); f.pubsetbuf(nullptr, 0);
assert(f.open("overflow.dat", std::ios_base::out) != 0); assert(f.open("overflow.dat", std::ios_base::out) != 0);
assert(f.is_open()); assert(f.is_open());
assert(f.pbase() == 0); assert(f.pbase() == 0);
assert(f.pptr() == 0); assert(f.pptr() == 0);
assert(f.epptr() == 0); assert(f.epptr() == 0);
assert(f.overflow('a') == 'a'); assert(f.overflow('a') == 'a');
assert(f.pbase() == 0); assert(f.pbase() == 0);
assert(f.pptr() == 0); assert(f.pptr() == 0);
Show All 24 Lines#ifndef TEST_HAS_NO_WIDE_CHARACTERS
test_buf<wchar_t> f; test_buf<wchar_t> f;
assert(f.open("overflow.dat", std::ios_base::in) != 0); assert(f.open("overflow.dat", std::ios_base::in) != 0);
assert(f.is_open()); assert(f.is_open());
assert(f.sgetc() == L'a'); assert(f.sgetc() == L'a');
} }
std::remove("overflow.dat"); std::remove("overflow.dat");
{ {
test_buf<wchar_t> f; test_buf<wchar_t> f;
f.pubsetbuf(0, 0); f.pubsetbuf(nullptr, 0);
assert(f.open("overflow.dat", std::ios_base::out) != 0); assert(f.open("overflow.dat", std::ios_base::out) != 0);
assert(f.is_open()); assert(f.is_open());
assert(f.pbase() == 0); assert(f.pbase() == 0);
assert(f.pptr() == 0); assert(f.pptr() == 0);
assert(f.epptr() == 0); assert(f.epptr() == 0);
assert(f.overflow(L'a') == L'a'); assert(f.overflow(L'a') == L'a');
assert(f.pbase() == 0); assert(f.pbase() == 0);
assert(f.pptr() == 0); assert(f.pptr() == 0);
Show All 37 Lines

libcxx/test/std/input.output/iostream.format/input.streams/iostreamclass/iostream.assign/member_swap.pass.cpp

Show All 38 Lines
{ {
{ {
testbuf<char> sb1; testbuf<char> sb1;
testbuf<char> sb2; testbuf<char> sb2;
test_iostream<char> is1(&sb1); test_iostream<char> is1(&sb1);
test_iostream<char> is2(&sb2); test_iostream<char> is2(&sb2);
is1.swap(is2); is1.swap(is2);
assert(is1.rdbuf() == &sb1); assert(is1.rdbuf() == &sb1);
assert(is1.tie() == 0); assert(is1.tie() == nullptr);
assert(is1.fill() == ' '); assert(is1.fill() == ' ');
assert(is1.rdstate() == is1.goodbit); assert(is1.rdstate() == is1.goodbit);
assert(is1.exceptions() == is1.goodbit); assert(is1.exceptions() == is1.goodbit);
assert(is1.flags() == (is1.skipws | is1.dec)); assert(is1.flags() == (is1.skipws | is1.dec));
assert(is1.precision() == 6); assert(is1.precision() == 6);
assert(is1.getloc().name() == "C"); assert(is1.getloc().name() == "C");
assert(is2.rdbuf() == &sb2); assert(is2.rdbuf() == &sb2);
assert(is2.tie() == 0); assert(is2.tie() == nullptr);
assert(is2.fill() == ' '); assert(is2.fill() == ' ');
assert(is2.rdstate() == is2.goodbit); assert(is2.rdstate() == is2.goodbit);
assert(is2.exceptions() == is2.goodbit); assert(is2.exceptions() == is2.goodbit);
assert(is2.flags() == (is2.skipws | is2.dec)); assert(is2.flags() == (is2.skipws | is2.dec));
assert(is2.precision() == 6); assert(is2.precision() == 6);
assert(is2.getloc().name() == "C"); assert(is2.getloc().name() == "C");
} }
#ifndef TEST_HAS_NO_WIDE_CHARACTERS #ifndef TEST_HAS_NO_WIDE_CHARACTERS
{ {
testbuf<wchar_t> sb1; testbuf<wchar_t> sb1;
testbuf<wchar_t> sb2; testbuf<wchar_t> sb2;
test_iostream<wchar_t> is1(&sb1); test_iostream<wchar_t> is1(&sb1);
test_iostream<wchar_t> is2(&sb2); test_iostream<wchar_t> is2(&sb2);
is1.swap(is2); is1.swap(is2);
assert(is1.rdbuf() == &sb1); assert(is1.rdbuf() == &sb1);
assert(is1.tie() == 0); assert(is1.tie() == nullptr);
assert(is1.fill() == ' '); assert(is1.fill() == ' ');
assert(is1.rdstate() == is1.goodbit); assert(is1.rdstate() == is1.goodbit);
assert(is1.exceptions() == is1.goodbit); assert(is1.exceptions() == is1.goodbit);
assert(is1.flags() == (is1.skipws | is1.dec)); assert(is1.flags() == (is1.skipws | is1.dec));
assert(is1.precision() == 6); assert(is1.precision() == 6);
assert(is1.getloc().name() == "C"); assert(is1.getloc().name() == "C");
assert(is2.rdbuf() == &sb2); assert(is2.rdbuf() == &sb2);
assert(is2.tie() == 0); assert(is2.tie() == nullptr);
assert(is2.fill() == ' '); assert(is2.fill() == ' ');
assert(is2.rdstate() == is2.goodbit); assert(is2.rdstate() == is2.goodbit);
assert(is2.exceptions() == is2.goodbit); assert(is2.exceptions() == is2.goodbit);
assert(is2.flags() == (is2.skipws | is2.dec)); assert(is2.flags() == (is2.skipws | is2.dec));
assert(is2.precision() == 6); assert(is2.precision() == 6);
assert(is2.getloc().name() == "C"); assert(is2.getloc().name() == "C");
} }
#endif #endif
return 0; return 0;
} }

libcxx/test/std/input.output/iostream.format/input.streams/iostreamclass/iostream.assign/move_assign.pass.cpp

Show First 20 Lines • Show All 41 Lines • ▼ Show 20 Lines
{ {
{ {
testbuf<char> sb1; testbuf<char> sb1;
testbuf<char> sb2; testbuf<char> sb2;
test_iostream<char> is1(&sb1); test_iostream<char> is1(&sb1);
test_iostream<char> is2(&sb2); test_iostream<char> is2(&sb2);
is2 = (std::move(is1)); is2 = (std::move(is1));
assert(is1.rdbuf() == &sb1); assert(is1.rdbuf() == &sb1);
assert(is1.tie() == 0); assert(is1.tie() == nullptr);
assert(is1.fill() == ' '); assert(is1.fill() == ' ');
assert(is1.rdstate() == is1.goodbit); assert(is1.rdstate() == is1.goodbit);
assert(is1.exceptions() == is1.goodbit); assert(is1.exceptions() == is1.goodbit);
assert(is1.flags() == (is1.skipws | is1.dec)); assert(is1.flags() == (is1.skipws | is1.dec));
assert(is1.precision() == 6); assert(is1.precision() == 6);
assert(is1.getloc().name() == "C"); assert(is1.getloc().name() == "C");
assert(is2.rdbuf() == &sb2); assert(is2.rdbuf() == &sb2);
assert(is2.tie() == 0); assert(is2.tie() == nullptr);
assert(is2.fill() == ' '); assert(is2.fill() == ' ');
assert(is2.rdstate() == is2.goodbit); assert(is2.rdstate() == is2.goodbit);
assert(is2.exceptions() == is2.goodbit); assert(is2.exceptions() == is2.goodbit);
assert(is2.flags() == (is2.skipws | is2.dec)); assert(is2.flags() == (is2.skipws | is2.dec));
assert(is2.precision() == 6); assert(is2.precision() == 6);
assert(is2.getloc().name() == "C"); assert(is2.getloc().name() == "C");
} }
#ifndef TEST_HAS_NO_WIDE_CHARACTERS #ifndef TEST_HAS_NO_WIDE_CHARACTERS
{ {
testbuf<wchar_t> sb1; testbuf<wchar_t> sb1;
testbuf<wchar_t> sb2; testbuf<wchar_t> sb2;
test_iostream<wchar_t> is1(&sb1); test_iostream<wchar_t> is1(&sb1);
test_iostream<wchar_t> is2(&sb2); test_iostream<wchar_t> is2(&sb2);
is2 = (std::move(is1)); is2 = (std::move(is1));
assert(is1.rdbuf() == &sb1); assert(is1.rdbuf() == &sb1);
assert(is1.tie() == 0); assert(is1.tie() == nullptr);
assert(is1.fill() == ' '); assert(is1.fill() == ' ');
assert(is1.rdstate() == is1.goodbit); assert(is1.rdstate() == is1.goodbit);
assert(is1.exceptions() == is1.goodbit); assert(is1.exceptions() == is1.goodbit);
assert(is1.flags() == (is1.skipws | is1.dec)); assert(is1.flags() == (is1.skipws | is1.dec));
assert(is1.precision() == 6); assert(is1.precision() == 6);
assert(is1.getloc().name() == "C"); assert(is1.getloc().name() == "C");
assert(is2.rdbuf() == &sb2); assert(is2.rdbuf() == &sb2);
assert(is2.tie() == 0); assert(is2.tie() == nullptr);
assert(is2.fill() == ' '); assert(is2.fill() == ' ');
assert(is2.rdstate() == is2.goodbit); assert(is2.rdstate() == is2.goodbit);
assert(is2.exceptions() == is2.goodbit); assert(is2.exceptions() == is2.goodbit);
assert(is2.flags() == (is2.skipws | is2.dec)); assert(is2.flags() == (is2.skipws | is2.dec));
assert(is2.precision() == 6); assert(is2.precision() == 6);
assert(is2.getloc().name() == "C"); assert(is2.getloc().name() == "C");
} }
#endif #endif
return 0; return 0;
} }

libcxx/test/std/input.output/iostream.format/input.streams/iostreamclass/iostream.cons/move.pass.cpp

Show First 20 Lines • Show All 41 Lines • ▼ Show 20 Lines
{ {
{ {
testbuf<char> sb; testbuf<char> sb;
test_iostream<char> is1(&sb); test_iostream<char> is1(&sb);
test_iostream<char> is(std::move(is1)); test_iostream<char> is(std::move(is1));
assert(is1.rdbuf() == &sb); assert(is1.rdbuf() == &sb);
assert(is1.gcount() == 0); assert(is1.gcount() == 0);
assert(is.gcount() == 0); assert(is.gcount() == 0);
assert(is.rdbuf() == 0); assert(is.rdbuf() == nullptr);
assert(is.tie() == 0); assert(is.tie() == nullptr);
assert(is.fill() == ' '); assert(is.fill() == ' ');
assert(is.rdstate() == is.goodbit); assert(is.rdstate() == is.goodbit);
assert(is.exceptions() == is.goodbit); assert(is.exceptions() == is.goodbit);
assert(is.flags() == (is.skipws | is.dec)); assert(is.flags() == (is.skipws | is.dec));
assert(is.precision() == 6); assert(is.precision() == 6);
assert(is.getloc().name() == "C"); assert(is.getloc().name() == "C");
} }
#ifndef TEST_HAS_NO_WIDE_CHARACTERS #ifndef TEST_HAS_NO_WIDE_CHARACTERS
{ {
testbuf<wchar_t> sb; testbuf<wchar_t> sb;
test_iostream<wchar_t> is1(&sb); test_iostream<wchar_t> is1(&sb);
test_iostream<wchar_t> is(std::move(is1)); test_iostream<wchar_t> is(std::move(is1));
assert(is1.gcount() == 0); assert(is1.gcount() == 0);
assert(is.gcount() == 0); assert(is.gcount() == 0);
assert(is1.rdbuf() == &sb); assert(is1.rdbuf() == &sb);
assert(is.rdbuf() == 0); assert(is.rdbuf() == nullptr);
assert(is.tie() == 0); assert(is.tie() == nullptr);
assert(is.fill() == L' '); assert(is.fill() == L' ');
assert(is.rdstate() == is.goodbit); assert(is.rdstate() == is.goodbit);
assert(is.exceptions() == is.goodbit); assert(is.exceptions() == is.goodbit);
assert(is.flags() == (is.skipws | is.dec)); assert(is.flags() == (is.skipws | is.dec));
assert(is.precision() == 6); assert(is.precision() == 6);
assert(is.getloc().name() == "C"); assert(is.getloc().name() == "C");
} }
#endif #endif
return 0; return 0;
} }

libcxx/test/std/input.output/iostream.format/input.streams/iostreamclass/iostream.cons/streambuf.pass.cpp

Show All 25 Lines
}; };
int main(int, char**) int main(int, char**)
{ {
{ {
testbuf<char> sb; testbuf<char> sb;
std::basic_iostream<char> is(&sb); std::basic_iostream<char> is(&sb);
assert(is.rdbuf() == &sb); assert(is.rdbuf() == &sb);
assert(is.tie() == 0); assert(is.tie() == nullptr);
assert(is.fill() == ' '); assert(is.fill() == ' ');
assert(is.rdstate() == is.goodbit); assert(is.rdstate() == is.goodbit);
assert(is.exceptions() == is.goodbit); assert(is.exceptions() == is.goodbit);
assert(is.flags() == (is.skipws | is.dec)); assert(is.flags() == (is.skipws | is.dec));
assert(is.precision() == 6); assert(is.precision() == 6);
assert(is.getloc().name() == "C"); assert(is.getloc().name() == "C");
assert(is.gcount() == 0); assert(is.gcount() == 0);
} }
#ifndef TEST_HAS_NO_WIDE_CHARACTERS #ifndef TEST_HAS_NO_WIDE_CHARACTERS
{ {
testbuf<wchar_t> sb; testbuf<wchar_t> sb;
std::basic_iostream<wchar_t> is(&sb); std::basic_iostream<wchar_t> is(&sb);
assert(is.rdbuf() == &sb); assert(is.rdbuf() == &sb);
assert(is.tie() == 0); assert(is.tie() == nullptr);
assert(is.fill() == L' '); assert(is.fill() == L' ');
assert(is.rdstate() == is.goodbit); assert(is.rdstate() == is.goodbit);
assert(is.exceptions() == is.goodbit); assert(is.exceptions() == is.goodbit);
assert(is.flags() == (is.skipws | is.dec)); assert(is.flags() == (is.skipws | is.dec));
assert(is.precision() == 6); assert(is.precision() == 6);
assert(is.getloc().name() == "C"); assert(is.getloc().name() == "C");
assert(is.gcount() == 0); assert(is.gcount() == 0);
} }
#endif #endif
return 0; return 0;
} }

libcxx/test/std/input.output/iostream.format/input.streams/istream.formatted/istream.formatted.arithmetic/bool.pass.cpp

Show All 40 Linespublic:
CharT* eback() const {return base::eback();} CharT* eback() const {return base::eback();}
CharT* gptr() const {return base::gptr();} CharT* gptr() const {return base::gptr();}
CharT* egptr() const {return base::egptr();} CharT* egptr() const {return base::egptr();}
}; };
int main(int, char**) int main(int, char**)
{ {
{ {
std::istream is((std::streambuf*)0); std::istream is((std::streambuf*)nullptr);
bool n = 0; bool n = 0;
is >> n; is >> n;
assert(is.fail()); assert(is.fail());
} }
{ {
testbuf<char> sb("0"); testbuf<char> sb("0");
std::istream is(&sb); std::istream is(&sb);
bool n = true; bool n = true;
▲ Show 20 Lines • Show All 66 Lines • Show Last 20 Lines

libcxx/test/std/input.output/iostream.format/input.streams/istream.formatted/istream.formatted.arithmetic/double.pass.cpp

Show All 40 Linespublic:
CharT* eback() const {return base::eback();} CharT* eback() const {return base::eback();}
CharT* gptr() const {return base::gptr();} CharT* gptr() const {return base::gptr();}
CharT* egptr() const {return base::egptr();} CharT* egptr() const {return base::egptr();}
}; };
int main(int, char**) int main(int, char**)
{ {
{ {
std::istream is((std::streambuf*)0); std::istream is((std::streambuf*)nullptr);
double n = 0; double n = 0;
is >> n; is >> n;
assert(is.fail()); assert(is.fail());
} }
{ {
testbuf<char> sb("0"); testbuf<char> sb("0");
std::istream is(&sb); std::istream is(&sb);
double n = 10; double n = 10;
▲ Show 20 Lines • Show All 66 Lines • Show Last 20 Lines

libcxx/test/std/input.output/iostream.format/input.streams/istream.formatted/istream.formatted.arithmetic/float.pass.cpp

Show All 40 Linespublic:
CharT* eback() const {return base::eback();} CharT* eback() const {return base::eback();}
CharT* gptr() const {return base::gptr();} CharT* gptr() const {return base::gptr();}
CharT* egptr() const {return base::egptr();} CharT* egptr() const {return base::egptr();}
}; };
int main(int, char**) int main(int, char**)
{ {
{ {
std::istream is((std::streambuf*)0); std::istream is((std::streambuf*)nullptr);
float n = 0; float n = 0;
is >> n; is >> n;
assert(is.fail()); assert(is.fail());
} }
{ {
testbuf<char> sb("0"); testbuf<char> sb("0");
std::istream is(&sb); std::istream is(&sb);
float n = 10; float n = 10;
▲ Show 20 Lines • Show All 66 Lines • Show Last 20 Lines

libcxx/test/std/input.output/iostream.format/input.streams/istream.formatted/istream.formatted.arithmetic/int.pass.cpp

Show First 20 Lines • Show All 41 Lines • ▼ Show 20 Linespublic:
CharT* eback() const {return base::eback();} CharT* eback() const {return base::eback();}
CharT* gptr() const {return base::gptr();} CharT* gptr() const {return base::gptr();}
CharT* egptr() const {return base::egptr();} CharT* egptr() const {return base::egptr();}
}; };
int main(int, char**) int main(int, char**)
{ {
{ {
std::istream is((std::streambuf*)0); std::istream is((std::streambuf*)nullptr);
MordanteUnsubmitted
Not Done
ReplyInline Actions
int main(int, char**)
{
{
- std::istream is((std::streambuf*)nullptr);
+ std::istream is(nullptr);
int n = 0;

Doesn't this work too?

Mordante: Doesn't this work too?
int n = 0; int n = 0;
is >> n; is >> n;
assert(is.fail()); assert(is.fail());
} }
{ {
testbuf<char> sb("0"); testbuf<char> sb("0");
std::istream is(&sb); std::istream is(&sb);
int n = 10; int n = 10;
▲ Show 20 Lines • Show All 66 Lines • Show Last 20 Lines

libcxx/test/std/input.output/iostream.format/input.streams/istream.formatted/istream.formatted.arithmetic/long.pass.cpp

Show All 40 Linespublic:
CharT* eback() const {return base::eback();} CharT* eback() const {return base::eback();}
CharT* gptr() const {return base::gptr();} CharT* gptr() const {return base::gptr();}
CharT* egptr() const {return base::egptr();} CharT* egptr() const {return base::egptr();}
}; };
int main(int, char**) int main(int, char**)
{ {
{ {
std::istream is((std::streambuf*)0); std::istream is((std::streambuf*)nullptr);
long n = 0; long n = 0;
is >> n; is >> n;
assert(is.fail()); assert(is.fail());
} }
{ {
testbuf<char> sb("0"); testbuf<char> sb("0");
std::istream is(&sb); std::istream is(&sb);
long n = 10; long n = 10;
▲ Show 20 Lines • Show All 66 Lines • Show Last 20 Lines

libcxx/test/std/input.output/iostream.format/input.streams/istream.formatted/istream.formatted.arithmetic/long_double.pass.cpp

Show All 40 Linespublic:
CharT* eback() const {return base::eback();} CharT* eback() const {return base::eback();}
CharT* gptr() const {return base::gptr();} CharT* gptr() const {return base::gptr();}
CharT* egptr() const {return base::egptr();} CharT* egptr() const {return base::egptr();}
}; };
int main(int, char**) int main(int, char**)
{ {
{ {
std::istream is((std::streambuf*)0); std::istream is((std::streambuf*)nullptr);
long double n = 0; long double n = 0;
is >> n; is >> n;
assert(is.fail()); assert(is.fail());
} }
{ {
testbuf<char> sb("0"); testbuf<char> sb("0");
std::istream is(&sb); std::istream is(&sb);
long double n = 10; long double n = 10;
▲ Show 20 Lines • Show All 66 Lines • Show Last 20 Lines

libcxx/test/std/input.output/iostream.format/input.streams/istream.formatted/istream.formatted.arithmetic/long_long.pass.cpp

Show All 40 Linespublic:
CharT* eback() const {return base::eback();} CharT* eback() const {return base::eback();}
CharT* gptr() const {return base::gptr();} CharT* gptr() const {return base::gptr();}
CharT* egptr() const {return base::egptr();} CharT* egptr() const {return base::egptr();}
}; };
int main(int, char**) int main(int, char**)
{ {
{ {
std::istream is((std::streambuf*)0); std::istream is((std::streambuf*)nullptr);
long long n = 0; long long n = 0;
is >> n; is >> n;
assert(is.fail()); assert(is.fail());
} }
{ {
testbuf<char> sb("0"); testbuf<char> sb("0");
std::istream is(&sb); std::istream is(&sb);
long long n = 10; long long n = 10;
▲ Show 20 Lines • Show All 66 Lines • Show Last 20 Lines

libcxx/test/std/input.output/iostream.format/input.streams/istream.formatted/istream.formatted.arithmetic/pointer.pass.cpp

Show All 40 Linespublic:
CharT* eback() const {return base::eback();} CharT* eback() const {return base::eback();}
CharT* gptr() const {return base::gptr();} CharT* gptr() const {return base::gptr();}
CharT* egptr() const {return base::egptr();} CharT* egptr() const {return base::egptr();}
}; };
int main(int, char**) int main(int, char**)
{ {
{ {
std::istream is((std::streambuf*)0); std::istream is((std::streambuf*)nullptr);
void* n = 0; void* n = nullptr;
is >> n; is >> n;
assert(is.fail()); assert(is.fail());
} }
{ {
testbuf<char> sb("0"); testbuf<char> sb("0");
std::istream is(&sb); std::istream is(&sb);
void* n = (void*)1; void* n = (void*)1;
is >> n; is >> n;
▲ Show 20 Lines • Show All 85 Lines • Show Last 20 Lines

libcxx/test/std/input.output/iostream.format/input.streams/istream.formatted/istream.formatted.arithmetic/short.pass.cpp

Show First 20 Lines • Show All 41 Lines • ▼ Show 20 Linespublic:
CharT* eback() const {return base::eback();} CharT* eback() const {return base::eback();}
CharT* gptr() const {return base::gptr();} CharT* gptr() const {return base::gptr();}
CharT* egptr() const {return base::egptr();} CharT* egptr() const {return base::egptr();}
}; };
int main(int, char**) int main(int, char**)
{ {
{ {
std::istream is((std::streambuf*)0); std::istream is((std::streambuf*)nullptr);
short n = 0; short n = 0;
is >> n; is >> n;
assert(is.fail()); assert(is.fail());
} }
{ {
testbuf<char> sb("0"); testbuf<char> sb("0");
std::istream is(&sb); std::istream is(&sb);
short n = 10; short n = 10;
▲ Show 20 Lines • Show All 66 Lines • Show Last 20 Lines

libcxx/test/std/input.output/iostream.format/input.streams/istream.formatted/istream.formatted.arithmetic/unsigned_int.pass.cpp

Show All 40 Linespublic:
CharT* eback() const {return base::eback();} CharT* eback() const {return base::eback();}
CharT* gptr() const {return base::gptr();} CharT* gptr() const {return base::gptr();}
CharT* egptr() const {return base::egptr();} CharT* egptr() const {return base::egptr();}
}; };
int main(int, char**) int main(int, char**)
{ {
{ {
std::istream is((std::streambuf*)0); std::istream is((std::streambuf*)nullptr);
unsigned int n = 0; unsigned int n = 0;
is >> n; is >> n;
assert(is.fail()); assert(is.fail());
} }
{ {
testbuf<char> sb("0"); testbuf<char> sb("0");
std::istream is(&sb); std::istream is(&sb);
unsigned int n = 10; unsigned int n = 10;
▲ Show 20 Lines • Show All 66 Lines • Show Last 20 Lines

libcxx/test/std/input.output/iostream.format/input.streams/istream.formatted/istream.formatted.arithmetic/unsigned_long.pass.cpp

Show All 40 Linespublic:
CharT* eback() const {return base::eback();} CharT* eback() const {return base::eback();}
CharT* gptr() const {return base::gptr();} CharT* gptr() const {return base::gptr();}
CharT* egptr() const {return base::egptr();} CharT* egptr() const {return base::egptr();}
}; };
int main(int, char**) int main(int, char**)
{ {
{ {
std::istream is((std::streambuf*)0); std::istream is((std::streambuf*)nullptr);
unsigned long n = 0; unsigned long n = 0;
is >> n; is >> n;
assert(is.fail()); assert(is.fail());
} }
{ {
testbuf<char> sb("0"); testbuf<char> sb("0");
std::istream is(&sb); std::istream is(&sb);
unsigned long n = 10; unsigned long n = 10;
▲ Show 20 Lines • Show All 66 Lines • Show Last 20 Lines

libcxx/test/std/input.output/iostream.format/input.streams/istream.formatted/istream.formatted.arithmetic/unsigned_long_long.pass.cpp

Show All 40 Linespublic:
CharT* eback() const {return base::eback();} CharT* eback() const {return base::eback();}
CharT* gptr() const {return base::gptr();} CharT* gptr() const {return base::gptr();}
CharT* egptr() const {return base::egptr();} CharT* egptr() const {return base::egptr();}
}; };
int main(int, char**) int main(int, char**)
{ {
{ {
std::istream is((std::streambuf*)0); std::istream is((std::streambuf*)nullptr);
unsigned long long n = 0; unsigned long long n = 0;
is >> n; is >> n;
assert(is.fail()); assert(is.fail());
} }
{ {
testbuf<char> sb("0"); testbuf<char> sb("0");
std::istream is(&sb); std::istream is(&sb);
unsigned long long n = 10; unsigned long long n = 10;
▲ Show 20 Lines • Show All 66 Lines • Show Last 20 Lines

libcxx/test/std/input.output/iostream.format/input.streams/istream.formatted/istream.formatted.arithmetic/unsigned_short.pass.cpp

Show All 40 Linespublic:
CharT* eback() const {return base::eback();} CharT* eback() const {return base::eback();}
CharT* gptr() const {return base::gptr();} CharT* gptr() const {return base::gptr();}
CharT* egptr() const {return base::egptr();} CharT* egptr() const {return base::egptr();}
}; };
int main(int, char**) int main(int, char**)
{ {
{ {
std::istream is((std::streambuf*)0); std::istream is((std::streambuf*)nullptr);
unsigned short n = 0; unsigned short n = 0;
is >> n; is >> n;
assert(is.fail()); assert(is.fail());
} }
{ {
testbuf<char> sb("0"); testbuf<char> sb("0");
std::istream is(&sb); std::istream is(&sb);
unsigned short n = 10; unsigned short n = 10;
▲ Show 20 Lines • Show All 66 Lines • Show Last 20 Lines

libcxx/test/std/input.output/iostream.format/input.streams/istream.formatted/istream_extractors/basic_ios.pass.cpp

Show All 26 Lines
{ {
++f_called; ++f_called;
return is; return is;
} }
int main(int, char**) int main(int, char**)
{ {
{ {
std::istream is((std::streambuf*)0); std::istream is((std::streambuf*)nullptr);
is >> f; is >> f;
assert(f_called == 1); assert(f_called == 1);
} }
return 0; return 0;
} }

libcxx/test/std/input.output/iostream.format/input.streams/istream.formatted/istream_extractors/ios_base.pass.cpp

Show All 24 Lines
{ {
++f_called; ++f_called;
return is; return is;
} }
int main(int, char**) int main(int, char**)
{ {
{ {
std::istream is((std::streambuf*)0); std::istream is((std::streambuf*)nullptr);
is >> f; is >> f;
assert(f_called == 1); assert(f_called == 1);
} }
return 0; return 0;
} }

libcxx/test/std/input.output/iostream.format/input.streams/istream.formatted/istream_extractors/istream.pass.cpp

Show All 26 Lines
{ {
++f_called; ++f_called;
return is; return is;
} }
int main(int, char**) int main(int, char**)
{ {
{ {
std::istream is((std::streambuf*)0); std::istream is((std::streambuf*)nullptr);
is >> f; is >> f;
assert(f_called == 1); assert(f_called == 1);
} }
return 0; return 0;
} }

libcxx/test/std/input.output/iostream.format/input.streams/istream/istream.assign/member_swap.pass.cpp

Show All 38 Lines
{ {
{ {
testbuf<char> sb1; testbuf<char> sb1;
testbuf<char> sb2; testbuf<char> sb2;
test_istream<char> is1(&sb1); test_istream<char> is1(&sb1);
test_istream<char> is2(&sb2); test_istream<char> is2(&sb2);
is1.swap(is2); is1.swap(is2);
assert(is1.rdbuf() == &sb1); assert(is1.rdbuf() == &sb1);
assert(is1.tie() == 0); assert(is1.tie() == nullptr);
assert(is1.fill() == ' '); assert(is1.fill() == ' ');
assert(is1.rdstate() == is1.goodbit); assert(is1.rdstate() == is1.goodbit);
assert(is1.exceptions() == is1.goodbit); assert(is1.exceptions() == is1.goodbit);
assert(is1.flags() == (is1.skipws | is1.dec)); assert(is1.flags() == (is1.skipws | is1.dec));
assert(is1.precision() == 6); assert(is1.precision() == 6);
assert(is1.getloc().name() == "C"); assert(is1.getloc().name() == "C");
assert(is2.rdbuf() == &sb2); assert(is2.rdbuf() == &sb2);
assert(is2.tie() == 0); assert(is2.tie() == nullptr);
assert(is2.fill() == ' '); assert(is2.fill() == ' ');
assert(is2.rdstate() == is2.goodbit); assert(is2.rdstate() == is2.goodbit);
assert(is2.exceptions() == is2.goodbit); assert(is2.exceptions() == is2.goodbit);
assert(is2.flags() == (is2.skipws | is2.dec)); assert(is2.flags() == (is2.skipws | is2.dec));
assert(is2.precision() == 6); assert(is2.precision() == 6);
assert(is2.getloc().name() == "C"); assert(is2.getloc().name() == "C");
} }
#ifndef TEST_HAS_NO_WIDE_CHARACTERS #ifndef TEST_HAS_NO_WIDE_CHARACTERS
{ {
testbuf<wchar_t> sb1; testbuf<wchar_t> sb1;
testbuf<wchar_t> sb2; testbuf<wchar_t> sb2;
test_istream<wchar_t> is1(&sb1); test_istream<wchar_t> is1(&sb1);
test_istream<wchar_t> is2(&sb2); test_istream<wchar_t> is2(&sb2);
is1.swap(is2); is1.swap(is2);
assert(is1.rdbuf() == &sb1); assert(is1.rdbuf() == &sb1);
assert(is1.tie() == 0); assert(is1.tie() == nullptr);
assert(is1.fill() == ' '); assert(is1.fill() == ' ');
assert(is1.rdstate() == is1.goodbit); assert(is1.rdstate() == is1.goodbit);
assert(is1.exceptions() == is1.goodbit); assert(is1.exceptions() == is1.goodbit);
assert(is1.flags() == (is1.skipws | is1.dec)); assert(is1.flags() == (is1.skipws | is1.dec));
assert(is1.precision() == 6); assert(is1.precision() == 6);
assert(is1.getloc().name() == "C"); assert(is1.getloc().name() == "C");
assert(is2.rdbuf() == &sb2); assert(is2.rdbuf() == &sb2);
assert(is2.tie() == 0); assert(is2.tie() == nullptr);
assert(is2.fill() == ' '); assert(is2.fill() == ' ');
assert(is2.rdstate() == is2.goodbit); assert(is2.rdstate() == is2.goodbit);
assert(is2.exceptions() == is2.goodbit); assert(is2.exceptions() == is2.goodbit);
assert(is2.flags() == (is2.skipws | is2.dec)); assert(is2.flags() == (is2.skipws | is2.dec));
assert(is2.precision() == 6); assert(is2.precision() == 6);
assert(is2.getloc().name() == "C"); assert(is2.getloc().name() == "C");
} }
#endif #endif
return 0; return 0;
} }

libcxx/test/std/input.output/iostream.format/input.streams/istream/istream.assign/move_assign.pass.cpp

Show First 20 Lines • Show All 41 Lines • ▼ Show 20 Lines
{ {
{ {
testbuf<char> sb1; testbuf<char> sb1;
testbuf<char> sb2; testbuf<char> sb2;
test_istream<char> is1(&sb1); test_istream<char> is1(&sb1);
test_istream<char> is2(&sb2); test_istream<char> is2(&sb2);
is2 = (std::move(is1)); is2 = (std::move(is1));
assert(is1.rdbuf() == &sb1); assert(is1.rdbuf() == &sb1);
assert(is1.tie() == 0); assert(is1.tie() == nullptr);
assert(is1.fill() == ' '); assert(is1.fill() == ' ');
assert(is1.rdstate() == is1.goodbit); assert(is1.rdstate() == is1.goodbit);
assert(is1.exceptions() == is1.goodbit); assert(is1.exceptions() == is1.goodbit);
assert(is1.flags() == (is1.skipws | is1.dec)); assert(is1.flags() == (is1.skipws | is1.dec));
assert(is1.precision() == 6); assert(is1.precision() == 6);
assert(is1.getloc().name() == "C"); assert(is1.getloc().name() == "C");
assert(is2.rdbuf() == &sb2); assert(is2.rdbuf() == &sb2);
assert(is2.tie() == 0); assert(is2.tie() == nullptr);
assert(is2.fill() == ' '); assert(is2.fill() == ' ');
assert(is2.rdstate() == is2.goodbit); assert(is2.rdstate() == is2.goodbit);
assert(is2.exceptions() == is2.goodbit); assert(is2.exceptions() == is2.goodbit);
assert(is2.flags() == (is2.skipws | is2.dec)); assert(is2.flags() == (is2.skipws | is2.dec));
assert(is2.precision() == 6); assert(is2.precision() == 6);
assert(is2.getloc().name() == "C"); assert(is2.getloc().name() == "C");
} }
#ifndef TEST_HAS_NO_WIDE_CHARACTERS #ifndef TEST_HAS_NO_WIDE_CHARACTERS
{ {
testbuf<wchar_t> sb1; testbuf<wchar_t> sb1;
testbuf<wchar_t> sb2; testbuf<wchar_t> sb2;
test_istream<wchar_t> is1(&sb1); test_istream<wchar_t> is1(&sb1);
test_istream<wchar_t> is2(&sb2); test_istream<wchar_t> is2(&sb2);
is2 = (std::move(is1)); is2 = (std::move(is1));
assert(is1.rdbuf() == &sb1); assert(is1.rdbuf() == &sb1);
assert(is1.tie() == 0); assert(is1.tie() == nullptr);
assert(is1.fill() == ' '); assert(is1.fill() == ' ');
assert(is1.rdstate() == is1.goodbit); assert(is1.rdstate() == is1.goodbit);
assert(is1.exceptions() == is1.goodbit); assert(is1.exceptions() == is1.goodbit);
assert(is1.flags() == (is1.skipws | is1.dec)); assert(is1.flags() == (is1.skipws | is1.dec));
assert(is1.precision() == 6); assert(is1.precision() == 6);
assert(is1.getloc().name() == "C"); assert(is1.getloc().name() == "C");
assert(is2.rdbuf() == &sb2); assert(is2.rdbuf() == &sb2);
assert(is2.tie() == 0); assert(is2.tie() == nullptr);
assert(is2.fill() == ' '); assert(is2.fill() == ' ');
assert(is2.rdstate() == is2.goodbit); assert(is2.rdstate() == is2.goodbit);
assert(is2.exceptions() == is2.goodbit); assert(is2.exceptions() == is2.goodbit);
assert(is2.flags() == (is2.skipws | is2.dec)); assert(is2.flags() == (is2.skipws | is2.dec));
assert(is2.precision() == 6); assert(is2.precision() == 6);
assert(is2.getloc().name() == "C"); assert(is2.getloc().name() == "C");
} }
#endif #endif
return 0; return 0;
} }

libcxx/test/std/input.output/iostream.format/input.streams/istream/istream.cons/move.pass.cpp

Show All 39 Lines
{ {
{ {
testbuf<char> sb; testbuf<char> sb;
test_istream<char> is1(&sb); test_istream<char> is1(&sb);
test_istream<char> is(std::move(is1)); test_istream<char> is(std::move(is1));
assert(is1.rdbuf() == &sb); assert(is1.rdbuf() == &sb);
assert(is1.gcount() == 0); assert(is1.gcount() == 0);
assert(is.gcount() == 0); assert(is.gcount() == 0);
assert(is.rdbuf() == 0); assert(is.rdbuf() == nullptr);
assert(is.tie() == 0); assert(is.tie() == nullptr);
assert(is.fill() == ' '); assert(is.fill() == ' ');
assert(is.rdstate() == is.goodbit); assert(is.rdstate() == is.goodbit);
assert(is.exceptions() == is.goodbit); assert(is.exceptions() == is.goodbit);
assert(is.flags() == (is.skipws | is.dec)); assert(is.flags() == (is.skipws | is.dec));
assert(is.precision() == 6); assert(is.precision() == 6);
assert(is.getloc().name() == "C"); assert(is.getloc().name() == "C");
} }
#ifndef TEST_HAS_NO_WIDE_CHARACTERS #ifndef TEST_HAS_NO_WIDE_CHARACTERS
{ {
testbuf<wchar_t> sb; testbuf<wchar_t> sb;
test_istream<wchar_t> is1(&sb); test_istream<wchar_t> is1(&sb);
test_istream<wchar_t> is(std::move(is1)); test_istream<wchar_t> is(std::move(is1));
assert(is1.gcount() == 0); assert(is1.gcount() == 0);
assert(is.gcount() == 0); assert(is.gcount() == 0);
assert(is1.rdbuf() == &sb); assert(is1.rdbuf() == &sb);
assert(is.rdbuf() == 0); assert(is.rdbuf() == nullptr);
assert(is.tie() == 0); assert(is.tie() == nullptr);
assert(is.fill() == L' '); assert(is.fill() == L' ');
assert(is.rdstate() == is.goodbit); assert(is.rdstate() == is.goodbit);
assert(is.exceptions() == is.goodbit); assert(is.exceptions() == is.goodbit);
assert(is.flags() == (is.skipws | is.dec)); assert(is.flags() == (is.skipws | is.dec));
assert(is.precision() == 6); assert(is.precision() == 6);
assert(is.getloc().name() == "C"); assert(is.getloc().name() == "C");
} }
#endif #endif
return 0; return 0;
} }

libcxx/test/std/input.output/iostream.format/input.streams/istream/istream.cons/streambuf.pass.cpp

Show All 25 Lines
}; };
int main(int, char**) int main(int, char**)
{ {
{ {
testbuf<char> sb; testbuf<char> sb;
std::basic_istream<char> is(&sb); std::basic_istream<char> is(&sb);
assert(is.rdbuf() == &sb); assert(is.rdbuf() == &sb);
assert(is.tie() == 0); assert(is.tie() == nullptr);
assert(is.fill() == ' '); assert(is.fill() == ' ');
assert(is.rdstate() == is.goodbit); assert(is.rdstate() == is.goodbit);
assert(is.exceptions() == is.goodbit); assert(is.exceptions() == is.goodbit);
assert(is.flags() == (is.skipws | is.dec)); assert(is.flags() == (is.skipws | is.dec));
assert(is.precision() == 6); assert(is.precision() == 6);
assert(is.getloc().name() == "C"); assert(is.getloc().name() == "C");
assert(is.gcount() == 0); assert(is.gcount() == 0);
} }
#ifndef TEST_HAS_NO_WIDE_CHARACTERS #ifndef TEST_HAS_NO_WIDE_CHARACTERS
{ {
testbuf<wchar_t> sb; testbuf<wchar_t> sb;
std::basic_istream<wchar_t> is(&sb); std::basic_istream<wchar_t> is(&sb);
assert(is.rdbuf() == &sb); assert(is.rdbuf() == &sb);
assert(is.tie() == 0); assert(is.tie() == nullptr);
assert(is.fill() == L' '); assert(is.fill() == L' ');
assert(is.rdstate() == is.goodbit); assert(is.rdstate() == is.goodbit);
assert(is.exceptions() == is.goodbit); assert(is.exceptions() == is.goodbit);
assert(is.flags() == (is.skipws | is.dec)); assert(is.flags() == (is.skipws | is.dec));
assert(is.precision() == 6); assert(is.precision() == 6);
assert(is.getloc().name() == "C"); assert(is.getloc().name() == "C");
assert(is.gcount() == 0); assert(is.gcount() == 0);
} }
#endif #endif
return 0; return 0;
} }

libcxx/test/std/input.output/iostream.format/input.streams/istream/istream_sentry/ctor.pass.cpp

Show First 20 Lines • Show All 48 Lines • ▼ Show 20 Lines int virtual sync()
++sync_called; ++sync_called;
return 1; return 1;
} }
}; };
int main(int, char**) int main(int, char**)
{ {
{ {
std::istream is((testbuf<char>*)0); std::istream is((testbuf<char>*)nullptr);
std::istream::sentry sen(is, true); std::istream::sentry sen(is, true);
assert(!(bool)sen); assert(!(bool)sen);
assert(!is.good()); assert(!is.good());
assert(is.gcount() == 0); assert(is.gcount() == 0);
assert(sync_called == 0); assert(sync_called == 0);
} }
{ {
testbuf<char> sb(" 123"); testbuf<char> sb(" 123");
Show All 31 Linesint main(int, char**)
assert((bool)sen); assert((bool)sen);
assert(is.good()); assert(is.good());
assert(sync_called == 0); assert(sync_called == 0);
assert(sb.gptr() == sb.eback()); assert(sb.gptr() == sb.eback());
} }
#ifndef TEST_HAS_NO_WIDE_CHARACTERS #ifndef TEST_HAS_NO_WIDE_CHARACTERS
{ {
std::wistream is((testbuf<wchar_t>*)0); std::wistream is((testbuf<wchar_t>*)nullptr);
std::wistream::sentry sen(is, true); std::wistream::sentry sen(is, true);
assert(!(bool)sen); assert(!(bool)sen);
assert(!is.good()); assert(!is.good());
assert(is.gcount() == 0); assert(is.gcount() == 0);
assert(sync_called == 0); assert(sync_called == 0);
} }
{ {
testbuf<wchar_t> sb(L" 123"); testbuf<wchar_t> sb(L" 123");
Show All 21 Lines

libcxx/test/std/input.output/iostream.format/output.streams/ostream.assign/member_swap.pass.cpp

Show All 38 Lines
{ {
{ {
testbuf<char> sb1; testbuf<char> sb1;
testbuf<char> sb2; testbuf<char> sb2;
test_ostream<char> os1(&sb1); test_ostream<char> os1(&sb1);
test_ostream<char> os2(&sb2); test_ostream<char> os2(&sb2);
os1.swap(os2); os1.swap(os2);
assert(os1.rdbuf() == &sb1); assert(os1.rdbuf() == &sb1);
assert(os1.tie() == 0); assert(os1.tie() == nullptr);
assert(os1.fill() == ' '); assert(os1.fill() == ' ');
assert(os1.rdstate() == os1.goodbit); assert(os1.rdstate() == os1.goodbit);
assert(os1.exceptions() == os1.goodbit); assert(os1.exceptions() == os1.goodbit);
assert(os1.flags() == (os1.skipws | os1.dec)); assert(os1.flags() == (os1.skipws | os1.dec));
assert(os1.precision() == 6); assert(os1.precision() == 6);
assert(os1.getloc().name() == "C"); assert(os1.getloc().name() == "C");
assert(os2.rdbuf() == &sb2); assert(os2.rdbuf() == &sb2);
assert(os2.tie() == 0); assert(os2.tie() == nullptr);
assert(os2.fill() == ' '); assert(os2.fill() == ' ');
assert(os2.rdstate() == os2.goodbit); assert(os2.rdstate() == os2.goodbit);
assert(os2.exceptions() == os2.goodbit); assert(os2.exceptions() == os2.goodbit);
assert(os2.flags() == (os2.skipws | os2.dec)); assert(os2.flags() == (os2.skipws | os2.dec));
assert(os2.precision() == 6); assert(os2.precision() == 6);
assert(os2.getloc().name() == "C"); assert(os2.getloc().name() == "C");
} }
#ifndef TEST_HAS_NO_WIDE_CHARACTERS #ifndef TEST_HAS_NO_WIDE_CHARACTERS
{ {
testbuf<wchar_t> sb1; testbuf<wchar_t> sb1;
testbuf<wchar_t> sb2; testbuf<wchar_t> sb2;
test_ostream<wchar_t> os1(&sb1); test_ostream<wchar_t> os1(&sb1);
test_ostream<wchar_t> os2(&sb2); test_ostream<wchar_t> os2(&sb2);
os1.swap(os2); os1.swap(os2);
assert(os1.rdbuf() == &sb1); assert(os1.rdbuf() == &sb1);
assert(os1.tie() == 0); assert(os1.tie() == nullptr);
assert(os1.fill() == ' '); assert(os1.fill() == ' ');
assert(os1.rdstate() == os1.goodbit); assert(os1.rdstate() == os1.goodbit);
assert(os1.exceptions() == os1.goodbit); assert(os1.exceptions() == os1.goodbit);
assert(os1.flags() == (os1.skipws | os1.dec)); assert(os1.flags() == (os1.skipws | os1.dec));
assert(os1.precision() == 6); assert(os1.precision() == 6);
assert(os1.getloc().name() == "C"); assert(os1.getloc().name() == "C");
assert(os2.rdbuf() == &sb2); assert(os2.rdbuf() == &sb2);
assert(os2.tie() == 0); assert(os2.tie() == nullptr);
assert(os2.fill() == ' '); assert(os2.fill() == ' ');
assert(os2.rdstate() == os2.goodbit); assert(os2.rdstate() == os2.goodbit);
assert(os2.exceptions() == os2.goodbit); assert(os2.exceptions() == os2.goodbit);
assert(os2.flags() == (os2.skipws | os2.dec)); assert(os2.flags() == (os2.skipws | os2.dec));
assert(os2.precision() == 6); assert(os2.precision() == 6);
assert(os2.getloc().name() == "C"); assert(os2.getloc().name() == "C");
} }
#endif #endif
return 0; return 0;
} }

libcxx/test/std/input.output/iostream.format/output.streams/ostream.assign/move_assign.pass.cpp

Show First 20 Lines • Show All 41 Lines • ▼ Show 20 Lines
{ {
{ {
testbuf<char> sb1; testbuf<char> sb1;
testbuf<char> sb2; testbuf<char> sb2;
test_ostream<char> os1(&sb1); test_ostream<char> os1(&sb1);
test_ostream<char> os2(&sb2); test_ostream<char> os2(&sb2);
os2 = (std::move(os1)); os2 = (std::move(os1));
assert(os1.rdbuf() == &sb1); assert(os1.rdbuf() == &sb1);
assert(os1.tie() == 0); assert(os1.tie() == nullptr);
assert(os1.fill() == ' '); assert(os1.fill() == ' ');
assert(os1.rdstate() == os1.goodbit); assert(os1.rdstate() == os1.goodbit);
assert(os1.exceptions() == os1.goodbit); assert(os1.exceptions() == os1.goodbit);
assert(os1.flags() == (os1.skipws | os1.dec)); assert(os1.flags() == (os1.skipws | os1.dec));
assert(os1.precision() == 6); assert(os1.precision() == 6);
assert(os1.getloc().name() == "C"); assert(os1.getloc().name() == "C");
assert(os2.rdbuf() == &sb2); assert(os2.rdbuf() == &sb2);
assert(os2.tie() == 0); assert(os2.tie() == nullptr);
assert(os2.fill() == ' '); assert(os2.fill() == ' ');
assert(os2.rdstate() == os2.goodbit); assert(os2.rdstate() == os2.goodbit);
assert(os2.exceptions() == os2.goodbit); assert(os2.exceptions() == os2.goodbit);
assert(os2.flags() == (os2.skipws | os2.dec)); assert(os2.flags() == (os2.skipws | os2.dec));
assert(os2.precision() == 6); assert(os2.precision() == 6);
assert(os2.getloc().name() == "C"); assert(os2.getloc().name() == "C");
} }
#ifndef TEST_HAS_NO_WIDE_CHARACTERS #ifndef TEST_HAS_NO_WIDE_CHARACTERS
{ {
testbuf<wchar_t> sb1; testbuf<wchar_t> sb1;
testbuf<wchar_t> sb2; testbuf<wchar_t> sb2;
test_ostream<wchar_t> os1(&sb1); test_ostream<wchar_t> os1(&sb1);
test_ostream<wchar_t> os2(&sb2); test_ostream<wchar_t> os2(&sb2);
os2 = (std::move(os1)); os2 = (std::move(os1));
assert(os1.rdbuf() == &sb1); assert(os1.rdbuf() == &sb1);
assert(os1.tie() == 0); assert(os1.tie() == nullptr);
assert(os1.fill() == ' '); assert(os1.fill() == ' ');
assert(os1.rdstate() == os1.goodbit); assert(os1.rdstate() == os1.goodbit);
assert(os1.exceptions() == os1.goodbit); assert(os1.exceptions() == os1.goodbit);
assert(os1.flags() == (os1.skipws | os1.dec)); assert(os1.flags() == (os1.skipws | os1.dec));
assert(os1.precision() == 6); assert(os1.precision() == 6);
assert(os1.getloc().name() == "C"); assert(os1.getloc().name() == "C");
assert(os2.rdbuf() == &sb2); assert(os2.rdbuf() == &sb2);
assert(os2.tie() == 0); assert(os2.tie() == nullptr);
assert(os2.fill() == ' '); assert(os2.fill() == ' ');
assert(os2.rdstate() == os2.goodbit); assert(os2.rdstate() == os2.goodbit);
assert(os2.exceptions() == os2.goodbit); assert(os2.exceptions() == os2.goodbit);
assert(os2.flags() == (os2.skipws | os2.dec)); assert(os2.flags() == (os2.skipws | os2.dec));
assert(os2.precision() == 6); assert(os2.precision() == 6);
assert(os2.getloc().name() == "C"); assert(os2.getloc().name() == "C");
} }
#endif #endif
return 0; return 0;
} }

libcxx/test/std/input.output/iostream.format/output.streams/ostream.cons/move.pass.cpp

Show All 39 Lines
int main(int, char**) int main(int, char**)
{ {
{ {
testbuf<char> sb; testbuf<char> sb;
test_ostream<char> os1(&sb); test_ostream<char> os1(&sb);
test_ostream<char> os(std::move(os1)); test_ostream<char> os(std::move(os1));
assert(os1.rdbuf() == &sb); assert(os1.rdbuf() == &sb);
assert(os.rdbuf() == 0); assert(os.rdbuf() == nullptr);
assert(os.tie() == 0); assert(os.tie() == nullptr);
assert(os.fill() == ' '); assert(os.fill() == ' ');
assert(os.rdstate() == os.goodbit); assert(os.rdstate() == os.goodbit);
assert(os.exceptions() == os.goodbit); assert(os.exceptions() == os.goodbit);
assert(os.flags() == (os.skipws | os.dec)); assert(os.flags() == (os.skipws | os.dec));
assert(os.precision() == 6); assert(os.precision() == 6);
assert(os.getloc().name() == "C"); assert(os.getloc().name() == "C");
} }
#ifndef TEST_HAS_NO_WIDE_CHARACTERS #ifndef TEST_HAS_NO_WIDE_CHARACTERS
{ {
testbuf<wchar_t> sb; testbuf<wchar_t> sb;
test_ostream<wchar_t> os1(&sb); test_ostream<wchar_t> os1(&sb);
test_ostream<wchar_t> os(std::move(os1)); test_ostream<wchar_t> os(std::move(os1));
assert(os1.rdbuf() == &sb); assert(os1.rdbuf() == &sb);
assert(os.rdbuf() == 0); assert(os.rdbuf() == nullptr);
assert(os.tie() == 0); assert(os.tie() == nullptr);
assert(os.fill() == L' '); assert(os.fill() == L' ');
assert(os.rdstate() == os.goodbit); assert(os.rdstate() == os.goodbit);
assert(os.exceptions() == os.goodbit); assert(os.exceptions() == os.goodbit);
assert(os.flags() == (os.skipws | os.dec)); assert(os.flags() == (os.skipws | os.dec));
assert(os.precision() == 6); assert(os.precision() == 6);
assert(os.getloc().name() == "C"); assert(os.getloc().name() == "C");
} }
#endif #endif
return 0; return 0;
} }

libcxx/test/std/input.output/iostream.format/output.streams/ostream.cons/streambuf.pass.cpp

Show All 25 Lines
}; };
int main(int, char**) int main(int, char**)
{ {
{ {
testbuf<char> sb; testbuf<char> sb;
std::basic_ostream<char> os(&sb); std::basic_ostream<char> os(&sb);
assert(os.rdbuf() == &sb); assert(os.rdbuf() == &sb);
assert(os.tie() == 0); assert(os.tie() == nullptr);
assert(os.fill() == ' '); assert(os.fill() == ' ');
assert(os.rdstate() == os.goodbit); assert(os.rdstate() == os.goodbit);
assert(os.exceptions() == os.goodbit); assert(os.exceptions() == os.goodbit);
assert(os.flags() == (os.skipws | os.dec)); assert(os.flags() == (os.skipws | os.dec));
assert(os.precision() == 6); assert(os.precision() == 6);
assert(os.getloc().name() == "C"); assert(os.getloc().name() == "C");
} }
#ifndef TEST_HAS_NO_WIDE_CHARACTERS #ifndef TEST_HAS_NO_WIDE_CHARACTERS
{ {
testbuf<wchar_t> sb; testbuf<wchar_t> sb;
std::basic_ostream<wchar_t> os(&sb); std::basic_ostream<wchar_t> os(&sb);
assert(os.rdbuf() == &sb); assert(os.rdbuf() == &sb);
assert(os.tie() == 0); assert(os.tie() == nullptr);
assert(os.fill() == L' '); assert(os.fill() == L' ');
assert(os.rdstate() == os.goodbit); assert(os.rdstate() == os.goodbit);
assert(os.exceptions() == os.goodbit); assert(os.exceptions() == os.goodbit);
assert(os.flags() == (os.skipws | os.dec)); assert(os.flags() == (os.skipws | os.dec));
assert(os.precision() == 6); assert(os.precision() == 6);
assert(os.getloc().name() == "C"); assert(os.getloc().name() == "C");
} }
#endif #endif
return 0; return 0;
} }

libcxx/test/std/input.output/iostream.format/output.streams/ostream.formatted/ostream.inserters.arithmetic/bool.pass.cpp

Show First 20 Lines • Show All 47 Lines • ▼ Show 20 Lines virtual typename base::int_type
} }
return ch; return ch;
} }
}; };
int main(int, char**) int main(int, char**)
{ {
{ {
std::ostream os((std::streambuf*)0); std::ostream os((std::streambuf*)nullptr);
bool b = false; bool b = false;
os << b; os << b;
assert(os.bad()); assert(os.bad());
assert(os.fail()); assert(os.fail());
} }
{ {
testbuf<char> sb; testbuf<char> sb;
std::ostream os(&sb); std::ostream os(&sb);
Show All 30 Lines

libcxx/test/std/input.output/iostream.format/output.streams/ostream.formatted/ostream.inserters.arithmetic/double.pass.cpp

Show First 20 Lines • Show All 47 Lines • ▼ Show 20 Lines virtual typename base::int_type
} }
return ch; return ch;
} }
}; };
int main(int, char**) int main(int, char**)
{ {
{ {
std::ostream os((std::streambuf*)0); std::ostream os((std::streambuf*)nullptr);
double n = 0; double n = 0;
os << n; os << n;
assert(os.bad()); assert(os.bad());
assert(os.fail()); assert(os.fail());
} }
{ {
testbuf<char> sb; testbuf<char> sb;
std::ostream os(&sb); std::ostream os(&sb);
Show All 22 Lines

libcxx/test/std/input.output/iostream.format/output.streams/ostream.formatted/ostream.inserters.arithmetic/float.pass.cpp

Show First 20 Lines • Show All 47 Lines • ▼ Show 20 Lines virtual typename base::int_type
} }
return ch; return ch;
} }
}; };
int main(int, char**) int main(int, char**)
{ {
{ {
std::ostream os((std::streambuf*)0); std::ostream os((std::streambuf*)nullptr);
float n = 0; float n = 0;
os << n; os << n;
assert(os.bad()); assert(os.bad());
assert(os.fail()); assert(os.fail());
} }
{ {
testbuf<char> sb; testbuf<char> sb;
std::ostream os(&sb); std::ostream os(&sb);
Show All 22 Lines

libcxx/test/std/input.output/iostream.format/output.streams/ostream.formatted/ostream.inserters.arithmetic/int.pass.cpp

Show First 20 Lines • Show All 47 Lines • ▼ Show 20 Lines virtual typename base::int_type
} }
return ch; return ch;
} }
}; };
int main(int, char**) int main(int, char**)
{ {
{ {
std::ostream os((std::streambuf*)0); std::ostream os((std::streambuf*)nullptr);
int n = 0; int n = 0;
os << n; os << n;
assert(os.bad()); assert(os.bad());
assert(os.fail()); assert(os.fail());
} }
{ {
testbuf<char> sb; testbuf<char> sb;
std::ostream os(&sb); std::ostream os(&sb);
Show All 22 Lines

libcxx/test/std/input.output/iostream.format/output.streams/ostream.formatted/ostream.inserters.arithmetic/long.pass.cpp

Show First 20 Lines • Show All 47 Lines • ▼ Show 20 Lines virtual typename base::int_type
} }
return ch; return ch;
} }
}; };
int main(int, char**) int main(int, char**)
{ {
{ {
std::ostream os((std::streambuf*)0); std::ostream os((std::streambuf*)nullptr);
long n = 0; long n = 0;
os << n; os << n;
assert(os.bad()); assert(os.bad());
assert(os.fail()); assert(os.fail());
} }
{ {
testbuf<char> sb; testbuf<char> sb;
std::ostream os(&sb); std::ostream os(&sb);
Show All 22 Lines

libcxx/test/std/input.output/iostream.format/output.streams/ostream.formatted/ostream.inserters.arithmetic/long_double.pass.cpp

Show First 20 Lines • Show All 47 Lines • ▼ Show 20 Lines virtual typename base::int_type
} }
return ch; return ch;
} }
}; };
int main(int, char**) int main(int, char**)
{ {
{ {
std::ostream os((std::streambuf*)0); std::ostream os((std::streambuf*)nullptr);
long double n = 0; long double n = 0;
os << n; os << n;
assert(os.bad()); assert(os.bad());
assert(os.fail()); assert(os.fail());
} }
{ {
testbuf<char> sb; testbuf<char> sb;
std::ostream os(&sb); std::ostream os(&sb);
Show All 22 Lines

libcxx/test/std/input.output/iostream.format/output.streams/ostream.formatted/ostream.inserters.arithmetic/long_long.pass.cpp

Show First 20 Lines • Show All 47 Lines • ▼ Show 20 Lines virtual typename base::int_type
} }
return ch; return ch;
} }
}; };
int main(int, char**) int main(int, char**)
{ {
{ {
std::ostream os((std::streambuf*)0); std::ostream os((std::streambuf*)nullptr);
long long n = 0; long long n = 0;
os << n; os << n;
assert(os.bad()); assert(os.bad());
assert(os.fail()); assert(os.fail());
} }
{ {
testbuf<char> sb; testbuf<char> sb;
std::ostream os(&sb); std::ostream os(&sb);
Show All 22 Lines

libcxx/test/std/input.output/iostream.format/output.streams/ostream.formatted/ostream.inserters.arithmetic/pointer.pass.cpp

Show First 20 Lines • Show All 47 Lines • ▼ Show 20 Lines virtual typename base::int_type
} }
return ch; return ch;
} }
}; };
int main(int, char**) int main(int, char**)
{ {
{ {
std::ostream os((std::streambuf*)0); std::ostream os((std::streambuf*)nullptr);
const void* n = 0; const void* n = 0;
os << n; os << n;
assert(os.bad()); assert(os.bad());
assert(os.fail()); assert(os.fail());
} }
{ {
testbuf<char> sb1; testbuf<char> sb1;
std::ostream os1(&sb1); std::ostream os1(&sb1);
Show All 30 Lines

libcxx/test/std/input.output/iostream.format/output.streams/ostream.formatted/ostream.inserters.arithmetic/short.pass.cpp

Show First 20 Lines • Show All 47 Lines • ▼ Show 20 Lines virtual typename base::int_type
} }
return ch; return ch;
} }
}; };
int main(int, char**) int main(int, char**)
{ {
{ {
std::ostream os((std::streambuf*)0); std::ostream os((std::streambuf*)nullptr);
short n = 0; short n = 0;
os << n; os << n;
assert(os.bad()); assert(os.bad());
assert(os.fail()); assert(os.fail());
} }
{ {
testbuf<char> sb; testbuf<char> sb;
std::ostream os(&sb); std::ostream os(&sb);
Show All 22 Lines

libcxx/test/std/input.output/iostream.format/output.streams/ostream.formatted/ostream.inserters.arithmetic/unsigned_int.pass.cpp

Show First 20 Lines • Show All 47 Lines • ▼ Show 20 Lines virtual typename base::int_type
} }
return ch; return ch;
} }
}; };
int main(int, char**) int main(int, char**)
{ {
{ {
std::ostream os((std::streambuf*)0); std::ostream os((std::streambuf*)nullptr);
unsigned int n = 0; unsigned int n = 0;
os << n; os << n;
assert(os.bad()); assert(os.bad());
assert(os.fail()); assert(os.fail());
} }
{ {
testbuf<char> sb; testbuf<char> sb;
std::ostream os(&sb); std::ostream os(&sb);
Show All 22 Lines

libcxx/test/std/input.output/iostream.format/output.streams/ostream.formatted/ostream.inserters.arithmetic/unsigned_long.pass.cpp

Show First 20 Lines • Show All 47 Lines • ▼ Show 20 Lines virtual typename base::int_type
} }
return ch; return ch;
} }
}; };
int main(int, char**) int main(int, char**)
{ {
{ {
std::ostream os((std::streambuf*)0); std::ostream os((std::streambuf*)nullptr);
unsigned long n = 0; unsigned long n = 0;
os << n; os << n;
assert(os.bad()); assert(os.bad());
assert(os.fail()); assert(os.fail());
} }
{ {
testbuf<char> sb; testbuf<char> sb;
std::ostream os(&sb); std::ostream os(&sb);
Show All 22 Lines

libcxx/test/std/input.output/iostream.format/output.streams/ostream.formatted/ostream.inserters.arithmetic/unsigned_long_long.pass.cpp

Show First 20 Lines • Show All 47 Lines • ▼ Show 20 Lines virtual typename base::int_type
} }
return ch; return ch;
} }
}; };
int main(int, char**) int main(int, char**)
{ {
{ {
std::ostream os((std::streambuf*)0); std::ostream os((std::streambuf*)nullptr);
unsigned long long n = 0; unsigned long long n = 0;
os << n; os << n;
assert(os.bad()); assert(os.bad());
assert(os.fail()); assert(os.fail());
} }
{ {
testbuf<char> sb; testbuf<char> sb;
std::ostream os(&sb); std::ostream os(&sb);
Show All 22 Lines

libcxx/test/std/input.output/iostream.format/output.streams/ostream.formatted/ostream.inserters.arithmetic/unsigned_short.pass.cpp

Show First 20 Lines • Show All 47 Lines • ▼ Show 20 Lines virtual typename base::int_type
} }
return ch; return ch;
} }
}; };
int main(int, char**) int main(int, char**)
{ {
{ {
std::ostream os((std::streambuf*)0); std::ostream os((std::streambuf*)nullptr);
unsigned short n = 0; unsigned short n = 0;
os << n; os << n;
assert(os.bad()); assert(os.bad());
assert(os.fail()); assert(os.fail());
} }
{ {
testbuf<char> sb; testbuf<char> sb;
std::ostream os(&sb); std::ostream os(&sb);
Show All 22 Lines

libcxx/test/std/input.output/iostream.format/output.streams/ostream.formatted/ostream.inserters.character/CharT.pass.cpp

Show First 20 Lines • Show All 50 Lines • ▼ Show 20 Lines virtual typename base::int_type
} }
return ch; return ch;
} }
}; };
int main(int, char**) int main(int, char**)
{ {
{ {
std::wostream os((std::wstreambuf*)0); std::wostream os((std::wstreambuf*)nullptr);
wchar_t c = L'a'; wchar_t c = L'a';
os << c; os << c;
assert(os.bad()); assert(os.bad());
assert(os.fail()); assert(os.fail());
} }
{ {
testbuf<wchar_t> sb; testbuf<wchar_t> sb;
std::wostream os(&sb); std::wostream os(&sb);
Show All 26 Lines

libcxx/test/std/input.output/iostream.format/output.streams/ostream.formatted/ostream.inserters.character/CharT_pointer.pass.cpp

Show First 20 Lines • Show All 50 Lines • ▼ Show 20 Lines virtual typename base::int_type
} }
return ch; return ch;
} }
}; };
int main(int, char**) int main(int, char**)
{ {
{ {
std::wostream os((std::wstreambuf*)0); std::wostream os((std::wstreambuf*)nullptr);
const wchar_t* c = L"123"; const wchar_t* c = L"123";
os << c; os << c;
assert(os.bad()); assert(os.bad());
assert(os.fail()); assert(os.fail());
} }
{ {
testbuf<wchar_t> sb; testbuf<wchar_t> sb;
std::wostream os(&sb); std::wostream os(&sb);
Show All 26 Lines

libcxx/test/std/input.output/iostream.format/output.streams/ostream.formatted/ostream.inserters.character/char.pass.cpp

Show First 20 Lines • Show All 48 Lines • ▼ Show 20 Lines virtual typename base::int_type
} }
return ch; return ch;
} }
}; };
int main(int, char**) int main(int, char**)
{ {
{ {
std::ostream os((std::streambuf*)0); std::ostream os((std::streambuf*)nullptr);
char c = 'a'; char c = 'a';
os << c; os << c;
assert(os.bad()); assert(os.bad());
assert(os.fail()); assert(os.fail());
} }
{ {
testbuf<char> sb; testbuf<char> sb;
std::ostream os(&sb); std::ostream os(&sb);
Show All 26 Lines

libcxx/test/std/input.output/iostream.format/output.streams/ostream.formatted/ostream.inserters.character/char_pointer.pass.cpp

Show First 20 Lines • Show All 48 Lines • ▼ Show 20 Lines virtual typename base::int_type
} }
return ch; return ch;
} }
}; };
int main(int, char**) int main(int, char**)
{ {
{ {
std::ostream os((std::streambuf*)0); std::ostream os((std::streambuf*)nullptr);
const char* c = "123"; const char* c = "123";
os << c; os << c;
assert(os.bad()); assert(os.bad());
assert(os.fail()); assert(os.fail());
} }
{ {
testbuf<char> sb; testbuf<char> sb;
std::ostream os(&sb); std::ostream os(&sb);
Show All 26 Lines

libcxx/test/std/input.output/iostream.format/output.streams/ostream.formatted/ostream.inserters.character/char_to_wide.pass.cpp

Show First 20 Lines • Show All 50 Lines • ▼ Show 20 Lines virtual typename base::int_type
} }
return ch; return ch;
} }
}; };
int main(int, char**) int main(int, char**)
{ {
{ {
std::wostream os((std::wstreambuf*)0); std::wostream os((std::wstreambuf*)nullptr);
char c = 'a'; char c = 'a';
os << c; os << c;
assert(os.bad()); assert(os.bad());
assert(os.fail()); assert(os.fail());
} }
{ {
testbuf<wchar_t> sb; testbuf<wchar_t> sb;
std::wostream os(&sb); std::wostream os(&sb);
Show All 26 Lines

libcxx/test/std/input.output/iostream.format/output.streams/ostream.formatted/ostream.inserters.character/char_to_wide_pointer.pass.cpp

Show First 20 Lines • Show All 50 Lines • ▼ Show 20 Lines virtual typename base::int_type
} }
return ch; return ch;
} }
}; };
int main(int, char**) int main(int, char**)
{ {
{ {
std::wostream os((std::wstreambuf*)0); std::wostream os((std::wstreambuf*)nullptr);
const char* c = "123"; const char* c = "123";
os << c; os << c;
assert(os.bad()); assert(os.bad());
assert(os.fail()); assert(os.fail());
} }
{ {
testbuf<wchar_t> sb; testbuf<wchar_t> sb;
std::wostream os(&sb); std::wostream os(&sb);
Show All 26 Lines

libcxx/test/std/input.output/iostream.format/output.streams/ostream.formatted/ostream.inserters.character/signed_char.pass.cpp

Show First 20 Lines • Show All 48 Lines • ▼ Show 20 Lines virtual typename base::int_type
} }
return ch; return ch;
} }
}; };
int main(int, char**) int main(int, char**)
{ {
{ {
std::ostream os((std::streambuf*)0); std::ostream os((std::streambuf*)nullptr);
signed char c = 'a'; signed char c = 'a';
os << c; os << c;
assert(os.bad()); assert(os.bad());
assert(os.fail()); assert(os.fail());
} }
{ {
testbuf<char> sb; testbuf<char> sb;
std::ostream os(&sb); std::ostream os(&sb);
Show All 26 Lines

libcxx/test/std/input.output/iostream.format/output.streams/ostream.formatted/ostream.inserters.character/signed_char_pointer.pass.cpp

Show First 20 Lines • Show All 48 Lines • ▼ Show 20 Lines virtual typename base::int_type
} }
return ch; return ch;
} }
}; };
int main(int, char**) int main(int, char**)
{ {
{ {
std::ostream os((std::streambuf*)0); std::ostream os((std::streambuf*)nullptr);
const signed char* c = (const signed char*)"123"; const signed char* c = (const signed char*)"123";
os << c; os << c;
assert(os.bad()); assert(os.bad());
assert(os.fail()); assert(os.fail());
} }
{ {
testbuf<char> sb; testbuf<char> sb;
std::ostream os(&sb); std::ostream os(&sb);
Show All 26 Lines

libcxx/test/std/input.output/iostream.format/output.streams/ostream.formatted/ostream.inserters.character/unsigned_char.pass.cpp

Show First 20 Lines • Show All 48 Lines • ▼ Show 20 Lines virtual typename base::int_type
} }
return ch; return ch;
} }
}; };
int main(int, char**) int main(int, char**)
{ {
{ {
std::ostream os((std::streambuf*)0); std::ostream os((std::streambuf*)nullptr);
unsigned char c = 'a'; unsigned char c = 'a';
os << c; os << c;
assert(os.bad()); assert(os.bad());
assert(os.fail()); assert(os.fail());
} }
{ {
testbuf<char> sb; testbuf<char> sb;
std::ostream os(&sb); std::ostream os(&sb);
Show All 26 Lines

libcxx/test/std/input.output/iostream.format/output.streams/ostream.formatted/ostream.inserters.character/unsigned_char_pointer.pass.cpp

Show First 20 Lines • Show All 48 Lines • ▼ Show 20 Lines virtual typename base::int_type
} }
return ch; return ch;
} }
}; };
int main(int, char**) int main(int, char**)
{ {
{ {
std::ostream os((std::streambuf*)0); std::ostream os((std::streambuf*)nullptr);
const unsigned char* c = (const unsigned char*)"123"; const unsigned char* c = (const unsigned char*)"123";
os << c; os << c;
assert(os.bad()); assert(os.bad());
assert(os.fail()); assert(os.fail());
} }
{ {
testbuf<char> sb; testbuf<char> sb;
std::ostream os(&sb); std::ostream os(&sb);
Show All 26 Lines

libcxx/test/std/input.output/iostream.format/output.streams/ostream.seeks/seekp.pass.cpp

Show All 36 Lines seekpos(typename base::pos_type sp, std::ios_base::openmode which)
return sp; return sp;
} }
}; };
int main(int, char**) int main(int, char**)
{ {
{ {
seekpos_called = 0; seekpos_called = 0;
std::ostream os((std::streambuf*)0); std::ostream os((std::streambuf*)nullptr);
assert(&os.seekp(5) == &os); assert(&os.seekp(5) == &os);
assert(seekpos_called == 0); assert(seekpos_called == 0);
} }
{ {
seekpos_called = 0; seekpos_called = 0;
testbuf<char> sb; testbuf<char> sb;
std::ostream os(&sb); std::ostream os(&sb);
assert(&os.seekp(10) == &os); assert(&os.seekp(10) == &os);
Show All 18 Lines

libcxx/test/std/input.output/iostream.format/output.streams/ostream.seeks/seekp2.pass.cpp

Show All 38 Lines seekoff(typename base::off_type off, std::ios_base::seekdir way,
return off; return off;
} }
}; };
int main(int, char**) int main(int, char**)
{ {
{ {
seekoff_called = 0; seekoff_called = 0;
std::ostream os((std::streambuf*)0); std::ostream os((std::streambuf*)nullptr);
assert(&os.seekp(5, std::ios_base::beg) == &os); assert(&os.seekp(5, std::ios_base::beg) == &os);
assert(seekoff_called == 0); assert(seekoff_called == 0);
} }
{ {
seekoff_called = 0; seekoff_called = 0;
testbuf<char> sb; testbuf<char> sb;
std::ostream os(&sb); std::ostream os(&sb);
assert(&os.seekp(10, std::ios_base::beg) == &os); assert(&os.seekp(10, std::ios_base::beg) == &os);
Show All 18 Lines

libcxx/test/std/input.output/iostream.format/output.streams/ostream.seeks/tellp.pass.cpp

Show All 37 Lines seekoff(typename base::off_type off, std::ios_base::seekdir way, std::ios_base::openmode which)
++seekoff_called; ++seekoff_called;
return 10; return 10;
} }
}; };
int main(int, char**) int main(int, char**)
{ {
{ {
std::ostream os((std::streambuf*)0); std::ostream os((std::streambuf*)nullptr);
assert(os.tellp() == -1); assert(os.tellp() == -1);
} }
{ {
testbuf<char> sb; testbuf<char> sb;
std::ostream os(&sb); std::ostream os(&sb);
assert(os.tellp() == 10); assert(os.tellp() == 10);
assert(seekoff_called == 1); assert(seekoff_called == 1);
} }
return 0; return 0;
} }

libcxx/test/std/input.output/iostream.format/output.streams/ostream.unformatted/put.pass.cpp

Show First 20 Lines • Show All 47 Lines • ▼ Show 20 Lines virtual typename base::int_type
} }
return ch; return ch;
} }
}; };
int main(int, char**) int main(int, char**)
{ {
{ {
std::ostream os((std::streambuf*)0); std::ostream os((std::streambuf*)nullptr);
char c = 'a'; char c = 'a';
os.put(c); os.put(c);
assert(os.bad()); assert(os.bad());
} }
{ {
testbuf<char> sb; testbuf<char> sb;
std::ostream os(&sb); std::ostream os(&sb);
char c = 'a'; char c = 'a';
os.put(c); os.put(c);
assert(sb.str() == "a"); assert(sb.str() == "a");
assert(os.good()); assert(os.good());
} }
#ifndef TEST_HAS_NO_WIDE_CHARACTERS #ifndef TEST_HAS_NO_WIDE_CHARACTERS
{ {
std::wostream os((std::wstreambuf*)0); std::wostream os((std::wstreambuf*)nullptr);
wchar_t c = L'a'; wchar_t c = L'a';
os.put(c); os.put(c);
assert(os.bad()); assert(os.bad());
} }
{ {
testbuf<wchar_t> sb; testbuf<wchar_t> sb;
std::wostream os(&sb); std::wostream os(&sb);
wchar_t c = L'a'; wchar_t c = L'a';
os.put(c); os.put(c);
assert(sb.str() == L"a"); assert(sb.str() == L"a");
assert(os.good()); assert(os.good());
} }
#endif #endif
return 0; return 0;
} }

libcxx/test/std/input.output/iostream.format/output.streams/ostream.unformatted/write.pass.cpp

Show First 20 Lines • Show All 47 Lines • ▼ Show 20 Lines virtual typename base::int_type
} }
return ch; return ch;
} }
}; };
int main(int, char**) int main(int, char**)
{ {
{ {
std::ostream os((std::streambuf*)0); std::ostream os((std::streambuf*)nullptr);
const char s[] = "123456790"; const char s[] = "123456790";
os.write(s, sizeof(s)/sizeof(s[0])-1); os.write(s, sizeof(s)/sizeof(s[0])-1);
assert(os.bad()); assert(os.bad());
} }
{ {
testbuf<char> sb; testbuf<char> sb;
std::ostream os(&sb); std::ostream os(&sb);
const char s[] = "123456790"; const char s[] = "123456790";
os.write(s, sizeof(s)/sizeof(s[0])-1); os.write(s, sizeof(s)/sizeof(s[0])-1);
assert(sb.str() == s); assert(sb.str() == s);
assert(os.good()); assert(os.good());
} }
#ifndef TEST_HAS_NO_WIDE_CHARACTERS #ifndef TEST_HAS_NO_WIDE_CHARACTERS
{ {
std::wostream os((std::wstreambuf*)0); std::wostream os((std::wstreambuf*)nullptr);
const wchar_t s[] = L"123456790"; const wchar_t s[] = L"123456790";
os.write(s, sizeof(s)/sizeof(s[0])-1); os.write(s, sizeof(s)/sizeof(s[0])-1);
assert(os.bad()); assert(os.bad());
} }
{ {
testbuf<wchar_t> sb; testbuf<wchar_t> sb;
std::wostream os(&sb); std::wostream os(&sb);
const wchar_t s[] = L"123456790"; const wchar_t s[] = L"123456790";
os.write(s, sizeof(s)/sizeof(s[0])-1); os.write(s, sizeof(s)/sizeof(s[0])-1);
assert(os.good()); assert(os.good());
assert(sb.str() == s); assert(sb.str() == s);
} }
#endif #endif
return 0; return 0;
} }

libcxx/test/std/input.output/iostream.format/output.streams/ostream_sentry/construct.pass.cpp

Show All 32 Lines int virtual sync()
++sync_called; ++sync_called;
return 1; return 1;
} }
}; };
int main(int, char**) int main(int, char**)
{ {
{ {
std::ostream os((std::streambuf*)0); std::ostream os((std::streambuf*)nullptr);
std::ostream::sentry s(os); std::ostream::sentry s(os);
assert(!bool(s)); assert(!bool(s));
} }
{ {
testbuf1<char> sb; testbuf1<char> sb;
std::ostream os(&sb); std::ostream os(&sb);
std::ostream::sentry s(os); std::ostream::sentry s(os);
assert(bool(s)); assert(bool(s));
Show All 15 Lines

libcxx/test/std/input.output/iostream.format/output.streams/ostream_sentry/destruct.pass.cpp

Show All 32 Lines int virtual sync()
++sync_called; ++sync_called;
return 1; return 1;
} }
}; };
int main(int, char**) int main(int, char**)
{ {
{ {
std::ostream os((std::streambuf*)0); std::ostream os((std::streambuf*)nullptr);
std::ostream::sentry s(os); std::ostream::sentry s(os);
assert(!bool(s)); assert(!bool(s));
} }
assert(sync_called == 0); assert(sync_called == 0);
{ {
testbuf1<char> sb; testbuf1<char> sb;
std::ostream os(&sb); std::ostream os(&sb);
std::ostream::sentry s(os); std::ostream::sentry s(os);
Show All 31 Lines

libcxx/test/std/input.output/iostreams.base/ios/basic.ios.cons/ctor_streambuf.pass.cpp

Show All 18 Lines
#include "test_macros.h" #include "test_macros.h"
int main(int, char**) int main(int, char**)
{ {
{ {
std::streambuf* sb = 0; std::streambuf* sb = 0;
std::basic_ios<char> ios(sb); std::basic_ios<char> ios(sb);
assert(ios.rdbuf() == sb); assert(ios.rdbuf() == sb);
assert(ios.tie() == 0); assert(ios.tie() == nullptr);
assert(ios.rdstate() == std::ios::badbit); assert(ios.rdstate() == std::ios::badbit);
assert(ios.exceptions() == std::ios::goodbit); assert(ios.exceptions() == std::ios::goodbit);
assert(ios.flags() == (std::ios::skipws | std::ios::dec)); assert(ios.flags() == (std::ios::skipws | std::ios::dec));
assert(ios.width() == 0); assert(ios.width() == 0);
assert(ios.precision() == 6); assert(ios.precision() == 6);
assert(ios.fill() == ' '); assert(ios.fill() == ' ');
assert(ios.getloc() == std::locale()); assert(ios.getloc() == std::locale());
} }
{ {
std::streambuf* sb = (std::streambuf*)1; std::streambuf* sb = (std::streambuf*)1;
std::basic_ios<char> ios(sb); std::basic_ios<char> ios(sb);
assert(ios.rdbuf() == sb); assert(ios.rdbuf() == sb);
assert(ios.tie() == 0); assert(ios.tie() == nullptr);
assert(ios.rdstate() == std::ios::goodbit); assert(ios.rdstate() == std::ios::goodbit);
assert(ios.exceptions() == std::ios::goodbit); assert(ios.exceptions() == std::ios::goodbit);
assert(ios.flags() == (std::ios::skipws | std::ios::dec)); assert(ios.flags() == (std::ios::skipws | std::ios::dec));
assert(ios.width() == 0); assert(ios.width() == 0);
assert(ios.precision() == 6); assert(ios.precision() == 6);
assert(ios.fill() == ' '); assert(ios.fill() == ' ');
assert(ios.getloc() == std::locale()); assert(ios.getloc() == std::locale());
} }
return 0; return 0;
} }

libcxx/test/std/input.output/iostreams.base/ios/basic.ios.members/fill.pass.cpp

Show All 13 Lines
#include <ios> #include <ios>
#include <cassert> #include <cassert>
#include "test_macros.h" #include "test_macros.h"
int main(int, char**) int main(int, char**)
{ {
const std::ios ios(0); const std::ios ios(nullptr);
assert(ios.fill() == ' '); assert(ios.fill() == ' ');
return 0; return 0;
} }

libcxx/test/std/input.output/iostreams.base/ios/basic.ios.members/fill_char_type.pass.cpp

Show All 13 Lines
#include <ios> #include <ios>
#include <cassert> #include <cassert>
#include "test_macros.h" #include "test_macros.h"
int main(int, char**) int main(int, char**)
{ {
std::ios ios(0); std::ios ios(nullptr);
char c = ios.fill('*'); char c = ios.fill('*');
assert(c == ' '); assert(c == ' ');
assert(ios.fill() == '*'); assert(ios.fill() == '*');
return 0; return 0;
} }

libcxx/test/std/input.output/iostreams.base/ios/basic.ios.members/imbue.pass.cpp

Show First 20 Lines • Show All 66 Lines • ▼ Show 20 Lines if (ev == std::ios_base::imbue_event)
assert(index == 6); assert(index == 6);
f3_called = true; f3_called = true;
} }
} }
int main(int, char**) int main(int, char**)
{ {
{ {
std::ios ios(0); std::ios ios(nullptr);
ios.register_callback(f1, 4); ios.register_callback(f1, 4);
ios.register_callback(f2, 5); ios.register_callback(f2, 5);
ios.register_callback(f3, 6); ios.register_callback(f3, 6);
std::locale l = ios.imbue(std::locale(LOCALE_en_US_UTF_8)); std::locale l = ios.imbue(std::locale(LOCALE_en_US_UTF_8));
assert(l.name() == std::string("C")); assert(l.name() == std::string("C"));
assert(ios.getloc().name() == std::string(LOCALE_en_US_UTF_8)); assert(ios.getloc().name() == std::string(LOCALE_en_US_UTF_8));
assert(f1_called); assert(f1_called);
assert(f2_called); assert(f2_called);
Show All 22 Lines

libcxx/test/std/input.output/iostreams.base/ios/basic.ios.members/move.pass.cpp

Show First 20 Lines • Show All 101 Lines • ▼ Show 20 Linesint main(int, char**)
ios2.pword(0) = &d1; ios2.pword(0) = &d1;
ios2.pword(1) = &d2; ios2.pword(1) = &d2;
ios2.tie((std::ostream*)2); ios2.tie((std::ostream*)2);
ios2.fill('2'); ios2.fill('2');
ios1.move(ios2); ios1.move(ios2);
assert(ios1.rdstate() == std::ios::goodbit); assert(ios1.rdstate() == std::ios::goodbit);
assert(ios1.rdbuf() == 0); assert(ios1.rdbuf() == nullptr);
assert(ios1.flags() == (std::ios::showpoint | std::ios::uppercase)); assert(ios1.flags() == (std::ios::showpoint | std::ios::uppercase));
assert(ios1.precision() == 2); assert(ios1.precision() == 2);
assert(ios1.width() == 12); assert(ios1.width() == 12);
assert(ios1.getloc().name() == LOCALE_fr_FR_UTF_8); assert(ios1.getloc().name() == LOCALE_fr_FR_UTF_8);
assert(ios1.exceptions() == std::ios::eofbit); assert(ios1.exceptions() == std::ios::eofbit);
assert(!f1_called); assert(!f1_called);
assert(!f2_called); assert(!f2_called);
assert(!g1_called); assert(!g1_called);
Show All 12 Linesint main(int, char**)
ios1.imbue(std::locale("C")); ios1.imbue(std::locale("C"));
assert(!f1_called); assert(!f1_called);
assert(!f2_called); assert(!f2_called);
assert(g1_called); assert(g1_called);
assert(g2_called); assert(g2_called);
assert(g3_called); assert(g3_called);
assert(ios2.rdbuf() == &sb2); assert(ios2.rdbuf() == &sb2);
assert(ios2.tie() == 0); assert(ios2.tie() == nullptr);
return 0; return 0;
} }

libcxx/test/std/input.output/iostreams.base/ios/basic.ios.members/narrow.pass.cpp

Show All 15 Lines
#include <ios> #include <ios>
#include <cassert> #include <cassert>
#include "test_macros.h" #include "test_macros.h"
int main(int, char**) int main(int, char**)
{ {
const std::wios ios(0); const std::wios ios(nullptr);
assert(ios.narrow(L'c', '*') == 'c'); assert(ios.narrow(L'c', '*') == 'c');
assert(ios.narrow(L'\u203C', '*') == '*'); assert(ios.narrow(L'\u203C', '*') == '*');
return 0; return 0;
} }

libcxx/test/std/input.output/iostreams.base/ios/basic.ios.members/rdbuf.pass.cpp

Show All 15 Lines
#include <streambuf> #include <streambuf>
#include <cassert> #include <cassert>
#include "test_macros.h" #include "test_macros.h"
int main(int, char**) int main(int, char**)
{ {
{ {
const std::ios ios(0); const std::ios ios(nullptr);
assert(ios.rdbuf() == 0); assert(ios.rdbuf() == nullptr);
} }
{ {
std::streambuf* sb = (std::streambuf*)1; std::streambuf* sb = (std::streambuf*)1;
const std::ios ios(sb); const std::ios ios(sb);
assert(ios.rdbuf() == sb); assert(ios.rdbuf() == sb);
} }
return 0; return 0;
} }

libcxx/test/std/input.output/iostreams.base/ios/basic.ios.members/rdbuf_streambuf.pass.cpp

Show All 14 Lines
#include <ios> #include <ios>
#include <streambuf> #include <streambuf>
#include <cassert> #include <cassert>
#include "test_macros.h" #include "test_macros.h"
int main(int, char**) int main(int, char**)
{ {
std::ios ios(0); std::ios ios(nullptr);
assert(ios.rdbuf() == 0); assert(ios.rdbuf() == nullptr);
assert(!ios.good()); assert(!ios.good());
std::streambuf* sb = (std::streambuf*)1; std::streambuf* sb = (std::streambuf*)1;
std::streambuf* sb2 = ios.rdbuf(sb); std::streambuf* sb2 = ios.rdbuf(sb);
assert(sb2 == 0); assert(sb2 == 0);
assert(ios.rdbuf() == sb); assert(ios.rdbuf() == sb);
assert(ios.good()); assert(ios.good());
sb2 = ios.rdbuf(0); sb2 = ios.rdbuf(0);
assert(sb2 == (std::streambuf*)1); assert(sb2 == (std::streambuf*)1);
assert(ios.rdbuf() == 0); assert(ios.rdbuf() == nullptr);
assert(ios.bad()); assert(ios.bad());
return 0; return 0;
} }

libcxx/test/std/input.output/iostreams.base/ios/basic.ios.members/set_rdbuf.pass.cpp

Show First 20 Lines • Show All 53 Lines • ▼ Show 20 Lines try
ios.setstate(std::ios::badbit); ios.setstate(std::ios::badbit);
ios.exceptions(std::ios::badbit); ios.exceptions(std::ios::badbit);
} }
catch (...) catch (...)
{ {
} }
#endif #endif
ios.set_rdbuf(0); ios.set_rdbuf(0);
assert(ios.rdbuf() == 0); assert(ios.rdbuf() == nullptr);
return 0; return 0;
} }

libcxx/test/std/input.output/iostreams.base/ios/basic.ios.members/tie.pass.cpp

Show All 14 Lines
#include <ios> #include <ios>
#include <cassert> #include <cassert>
#include "test_macros.h" #include "test_macros.h"
int main(int, char**) int main(int, char**)
{ {
const std::basic_ios<char> ios(0); const std::basic_ios<char> ios(0);
assert(ios.tie() == 0); assert(ios.tie() == nullptr);
return 0; return 0;
} }

libcxx/test/std/input.output/iostreams.base/ios/basic.ios.members/tie_ostream.pass.cpp

Show All 13 Lines
#include <ios> #include <ios>
#include <cassert> #include <cassert>
#include "test_macros.h" #include "test_macros.h"
int main(int, char**) int main(int, char**)
{ {
std::ios ios(0); std::ios ios(nullptr);
std::ostream* os = (std::ostream*)1; std::ostream* os = (std::ostream*)1;
std::ostream* r = ios.tie(os); std::ostream* r = ios.tie(os);
assert(r == 0); assert(r == 0);
assert(ios.tie() == os); assert(ios.tie() == os);
return 0; return 0;
} }

libcxx/test/std/input.output/iostreams.base/ios/basic.ios.members/widen.pass.cpp

Show All 13 Lines
#include <ios> #include <ios>
#include <cassert> #include <cassert>
#include "test_macros.h" #include "test_macros.h"
int main(int, char**) int main(int, char**)
{ {
const std::ios ios(0); const std::ios ios(nullptr);
assert(ios.widen('c') == 'c'); assert(ios.widen('c') == 'c');
return 0; return 0;
} }

libcxx/test/std/input.output/iostreams.base/ios/iostate.flags/bad.pass.cpp

Show All 17 Lines
#include "test_macros.h" #include "test_macros.h"
struct testbuf : public std::streambuf {}; struct testbuf : public std::streambuf {};
int main(int, char**) int main(int, char**)
{ {
{ {
std::ios ios(0); std::ios ios(nullptr);
assert(ios.bad()); assert(ios.bad());
ios.setstate(std::ios::eofbit); ios.setstate(std::ios::eofbit);
assert(ios.bad()); assert(ios.bad());
} }
{ {
testbuf sb; testbuf sb;
std::ios ios(&sb); std::ios ios(&sb);
assert(!ios.bad()); assert(!ios.bad());
Show All 10 Lines

libcxx/test/std/input.output/iostreams.base/ios/iostate.flags/bool.pass.cpp

Show All 14 Lines
#include <ios> #include <ios>
#include <type_traits> #include <type_traits>
#include <cassert> #include <cassert>
#include "test_macros.h" #include "test_macros.h"
int main(int, char**) int main(int, char**)
{ {
std::ios ios(0); std::ios ios(nullptr);
assert(static_cast<bool>(ios) == !ios.fail()); assert(static_cast<bool>(ios) == !ios.fail());
ios.setstate(std::ios::failbit); ios.setstate(std::ios::failbit);
assert(static_cast<bool>(ios) == !ios.fail()); assert(static_cast<bool>(ios) == !ios.fail());
static_assert((!std::is_convertible<std::ios, int>::value), ""); static_assert((!std::is_convertible<std::ios, int>::value), "");
static_assert((!std::is_convertible<std::ios const&, int>::value), ""); static_assert((!std::is_convertible<std::ios const&, int>::value), "");
#if TEST_STD_VER >= 11 #if TEST_STD_VER >= 11
static_assert(!std::is_convertible<std::ios, void*>::value, ""); static_assert(!std::is_convertible<std::ios, void*>::value, "");
static_assert(!std::is_convertible<std::ios, bool>::value, ""); static_assert(!std::is_convertible<std::ios, bool>::value, "");
#else #else
static_assert(std::is_convertible<std::ios, void*>::value, ""); static_assert(std::is_convertible<std::ios, void*>::value, "");
static_assert(std::is_convertible<std::ios, bool>::value, ""); static_assert(std::is_convertible<std::ios, bool>::value, "");
(void)(ios == 0); // SPEC2006 apparently relies on this to compile (void)(ios == 0); // SPEC2006 apparently relies on this to compile
#endif #endif
return 0; return 0;
} }

libcxx/test/std/input.output/iostreams.base/ios/iostate.flags/clear.pass.cpp

Show All 17 Lines
#include "test_macros.h" #include "test_macros.h"
struct testbuf : public std::streambuf {}; struct testbuf : public std::streambuf {};
int main(int, char**) int main(int, char**)
{ {
{ {
std::ios ios(0); std::ios ios(nullptr);
ios.clear(); ios.clear();
assert(ios.rdstate() == std::ios::badbit); assert(ios.rdstate() == std::ios::badbit);
#ifndef TEST_HAS_NO_EXCEPTIONS #ifndef TEST_HAS_NO_EXCEPTIONS
try try
{ {
ios.exceptions(std::ios::badbit); ios.exceptions(std::ios::badbit);
assert(false); assert(false);
} }
Show All 37 Lines

libcxx/test/std/input.output/iostreams.base/ios/iostate.flags/eof.pass.cpp

Show All 17 Lines
#include "test_macros.h" #include "test_macros.h"
struct testbuf : public std::streambuf {}; struct testbuf : public std::streambuf {};
int main(int, char**) int main(int, char**)
{ {
{ {
std::ios ios(0); std::ios ios(nullptr);
assert(!ios.eof()); assert(!ios.eof());
ios.setstate(std::ios::eofbit); ios.setstate(std::ios::eofbit);
assert(ios.eof()); assert(ios.eof());
} }
{ {
testbuf sb; testbuf sb;
std::ios ios(&sb); std::ios ios(&sb);
assert(!ios.eof()); assert(!ios.eof());
ios.setstate(std::ios::eofbit); ios.setstate(std::ios::eofbit);
assert(ios.eof()); assert(ios.eof());
} }
return 0; return 0;
} }

libcxx/test/std/input.output/iostreams.base/ios/iostate.flags/exceptions.pass.cpp

Show All 17 Lines
#include "test_macros.h" #include "test_macros.h"
struct testbuf : public std::streambuf {}; struct testbuf : public std::streambuf {};
int main(int, char**) int main(int, char**)
{ {
{ {
const std::ios ios(0); const std::ios ios(nullptr);
assert(ios.exceptions() == std::ios::goodbit); assert(ios.exceptions() == std::ios::goodbit);
} }
{ {
testbuf sb; testbuf sb;
const std::ios ios(&sb); const std::ios ios(&sb);
assert(ios.exceptions() == std::ios::goodbit); assert(ios.exceptions() == std::ios::goodbit);
} }
return 0; return 0;
} }

libcxx/test/std/input.output/iostreams.base/ios/iostate.flags/exceptions_iostate.pass.cpp

Show All 17 Lines
#include "test_macros.h" #include "test_macros.h"
struct testbuf : public std::streambuf {}; struct testbuf : public std::streambuf {};
int main(int, char**) int main(int, char**)
{ {
{ {
std::ios ios(0); std::ios ios(nullptr);
assert(ios.exceptions() == std::ios::goodbit); assert(ios.exceptions() == std::ios::goodbit);
ios.exceptions(std::ios::eofbit); ios.exceptions(std::ios::eofbit);
assert(ios.exceptions() == std::ios::eofbit); assert(ios.exceptions() == std::ios::eofbit);
#ifndef TEST_HAS_NO_EXCEPTIONS #ifndef TEST_HAS_NO_EXCEPTIONS
try try
{ {
ios.exceptions(std::ios::badbit); ios.exceptions(std::ios::badbit);
assert(false); assert(false);
Show All 19 Lines

libcxx/test/std/input.output/iostreams.base/ios/iostate.flags/fail.pass.cpp

Show All 17 Lines
#include "test_macros.h" #include "test_macros.h"
struct testbuf : public std::streambuf {}; struct testbuf : public std::streambuf {};
int main(int, char**) int main(int, char**)
{ {
{ {
std::ios ios(0); std::ios ios(nullptr);
assert(ios.fail()); assert(ios.fail());
ios.setstate(std::ios::eofbit); ios.setstate(std::ios::eofbit);
assert(ios.fail()); assert(ios.fail());
} }
{ {
testbuf sb; testbuf sb;
std::ios ios(&sb); std::ios ios(&sb);
assert(!ios.fail()); assert(!ios.fail());
Show All 10 Lines

libcxx/test/std/input.output/iostreams.base/ios/iostate.flags/good.pass.cpp

Show All 17 Lines
#include "test_macros.h" #include "test_macros.h"
struct testbuf : public std::streambuf {}; struct testbuf : public std::streambuf {};
int main(int, char**) int main(int, char**)
{ {
{ {
std::ios ios(0); std::ios ios(nullptr);
assert(!ios.good()); assert(!ios.good());
} }
{ {
testbuf sb; testbuf sb;
std::ios ios(&sb); std::ios ios(&sb);
assert(ios.good()); assert(ios.good());
ios.setstate(std::ios::eofbit); ios.setstate(std::ios::eofbit);
assert(!ios.good()); assert(!ios.good());
} }
return 0; return 0;
} }

libcxx/test/std/input.output/iostreams.base/ios/iostate.flags/not.pass.cpp

Show All 13 Lines
#include <ios> #include <ios>
#include <cassert> #include <cassert>
#include "test_macros.h" #include "test_macros.h"
int main(int, char**) int main(int, char**)
{ {
std::ios ios(0); std::ios ios(nullptr);
assert(!ios == ios.fail()); assert(!ios == ios.fail());
ios.setstate(std::ios::failbit); ios.setstate(std::ios::failbit);
assert(!ios == ios.fail()); assert(!ios == ios.fail());
return 0; return 0;
} }

libcxx/test/std/input.output/iostreams.base/ios/iostate.flags/rdstate.pass.cpp

Show All 13 Lines
#include <ios> #include <ios>
#include <cassert> #include <cassert>
#include "test_macros.h" #include "test_macros.h"
int main(int, char**) int main(int, char**)
{ {
std::ios ios(0); std::ios ios(nullptr);
assert(ios.rdstate() == std::ios::badbit); assert(ios.rdstate() == std::ios::badbit);
ios.setstate(std::ios::failbit); ios.setstate(std::ios::failbit);
assert(ios.rdstate() == (std::ios::failbit | std::ios::badbit)); assert(ios.rdstate() == (std::ios::failbit | std::ios::badbit));
return 0; return 0;
} }

libcxx/test/std/input.output/iostreams.base/ios/iostate.flags/setstate.pass.cpp

Show All 17 Lines
#include "test_macros.h" #include "test_macros.h"
struct testbuf : public std::streambuf {}; struct testbuf : public std::streambuf {};
int main(int, char**) int main(int, char**)
{ {
{ {
std::ios ios(0); std::ios ios(nullptr);
ios.setstate(std::ios::goodbit); ios.setstate(std::ios::goodbit);
assert(ios.rdstate() == std::ios::badbit); assert(ios.rdstate() == std::ios::badbit);
#ifndef TEST_HAS_NO_EXCEPTIONS #ifndef TEST_HAS_NO_EXCEPTIONS
try try
{ {
ios.exceptions(std::ios::badbit); ios.exceptions(std::ios::badbit);
assert(false); assert(false);
} }
Show All 36 Lines

libcxx/test/std/input.output/string.streams/istringstream/istringstream.assign/member_swap.pass.cpp

Show All 18 Lines
#include "test_macros.h" #include "test_macros.h"
int main(int, char**) int main(int, char**)
{ {
{ {
std::istringstream ss0(" 123 456"); std::istringstream ss0(" 123 456");
std::istringstream ss(" 789 321"); std::istringstream ss(" 789 321");
ss.swap(ss0); ss.swap(ss0);
assert(ss.rdbuf() != 0); assert(ss.rdbuf() != nullptr);
assert(ss.good()); assert(ss.good());
assert(ss.str() == " 123 456"); assert(ss.str() == " 123 456");
int i = 0; int i = 0;
ss >> i; ss >> i;
assert(i == 123); assert(i == 123);
ss >> i; ss >> i;
assert(i == 456); assert(i == 456);
ss0 >> i; ss0 >> i;
assert(i == 789); assert(i == 789);
ss0 >> i; ss0 >> i;
assert(i == 321); assert(i == 321);
} }
#ifndef TEST_HAS_NO_WIDE_CHARACTERS #ifndef TEST_HAS_NO_WIDE_CHARACTERS
{ {
std::wistringstream ss0(L" 123 456"); std::wistringstream ss0(L" 123 456");
std::wistringstream ss(L" 789 321"); std::wistringstream ss(L" 789 321");
ss.swap(ss0); ss.swap(ss0);
assert(ss.rdbuf() != 0); assert(ss.rdbuf() != nullptr);
assert(ss.good()); assert(ss.good());
assert(ss.str() == L" 123 456"); assert(ss.str() == L" 123 456");
int i = 0; int i = 0;
ss >> i; ss >> i;
assert(i == 123); assert(i == 123);
ss >> i; ss >> i;
assert(i == 456); assert(i == 456);
ss0 >> i; ss0 >> i;
assert(i == 789); assert(i == 789);
ss0 >> i; ss0 >> i;
assert(i == 321); assert(i == 321);
} }
#endif #endif
return 0; return 0;
} }

libcxx/test/std/input.output/string.streams/istringstream/istringstream.assign/move.pass.cpp

Show All 18 Lines
#include "test_macros.h" #include "test_macros.h"
int main(int, char**) int main(int, char**)
{ {
{ {
std::istringstream ss0(" 123 456"); std::istringstream ss0(" 123 456");
std::istringstream ss; std::istringstream ss;
ss = std::move(ss0); ss = std::move(ss0);
assert(ss.rdbuf() != 0); assert(ss.rdbuf() != nullptr);
assert(ss.good()); assert(ss.good());
assert(ss.str() == " 123 456"); assert(ss.str() == " 123 456");
int i = 0; int i = 0;
ss >> i; ss >> i;
assert(i == 123); assert(i == 123);
ss >> i; ss >> i;
assert(i == 456); assert(i == 456);
} }
Show All 15 Linesint main(int, char**)
s1 >> s; s1 >> s;
assert(s == "Dddddddddddddddddd"); assert(s == "Dddddddddddddddddd");
} }
#ifndef TEST_HAS_NO_WIDE_CHARACTERS #ifndef TEST_HAS_NO_WIDE_CHARACTERS
{ {
std::wistringstream ss0(L" 123 456"); std::wistringstream ss0(L" 123 456");
std::wistringstream ss; std::wistringstream ss;
ss = std::move(ss0); ss = std::move(ss0);
assert(ss.rdbuf() != 0); assert(ss.rdbuf() != nullptr);
assert(ss.good()); assert(ss.good());
assert(ss.str() == L" 123 456"); assert(ss.str() == L" 123 456");
int i = 0; int i = 0;
ss >> i; ss >> i;
assert(i == 123); assert(i == 123);
ss >> i; ss >> i;
assert(i == 456); assert(i == 456);
} }
Show All 22 Lines

libcxx/test/std/input.output/string.streams/istringstream/istringstream.assign/nonmember_swap.pass.cpp

Show All 21 Lines
#include "test_macros.h" #include "test_macros.h"
int main(int, char**) int main(int, char**)
{ {
{ {
std::istringstream ss0(" 123 456"); std::istringstream ss0(" 123 456");
std::istringstream ss(" 789 321"); std::istringstream ss(" 789 321");
swap(ss, ss0); swap(ss, ss0);
assert(ss.rdbuf() != 0); assert(ss.rdbuf() != nullptr);
assert(ss.good()); assert(ss.good());
assert(ss.str() == " 123 456"); assert(ss.str() == " 123 456");
int i = 0; int i = 0;
ss >> i; ss >> i;
assert(i == 123); assert(i == 123);
ss >> i; ss >> i;
assert(i == 456); assert(i == 456);
ss0 >> i; ss0 >> i;
assert(i == 789); assert(i == 789);
ss0 >> i; ss0 >> i;
assert(i == 321); assert(i == 321);
} }
#ifndef TEST_HAS_NO_WIDE_CHARACTERS #ifndef TEST_HAS_NO_WIDE_CHARACTERS
{ {
std::wistringstream ss0(L" 123 456"); std::wistringstream ss0(L" 123 456");
std::wistringstream ss(L" 789 321"); std::wistringstream ss(L" 789 321");
swap(ss, ss0); swap(ss, ss0);
assert(ss.rdbuf() != 0); assert(ss.rdbuf() != nullptr);
assert(ss.good()); assert(ss.good());
assert(ss.str() == L" 123 456"); assert(ss.str() == L" 123 456");
int i = 0; int i = 0;
ss >> i; ss >> i;
assert(i == 123); assert(i == 123);
ss >> i; ss >> i;
assert(i == 456); assert(i == 456);
ss0 >> i; ss0 >> i;
assert(i == 789); assert(i == 789);
ss0 >> i; ss0 >> i;
assert(i == 321); assert(i == 321);
} }
#endif #endif
return 0; return 0;
} }

libcxx/test/std/input.output/string.streams/istringstream/istringstream.cons/default.pass.cpp

Show All 27 Linesvoid test() {
static_assert(!test_convertible<S, std::ios_base::openmode>(), ""); static_assert(!test_convertible<S, std::ios_base::openmode>(), "");
} }
#endif #endif
int main(int, char**) int main(int, char**)
{ {
{ {
std::istringstream ss; std::istringstream ss;
assert(ss.rdbuf() != 0); assert(ss.rdbuf() != nullptr);
assert(ss.good()); assert(ss.good());
assert(ss.str() == ""); assert(ss.str() == "");
} }
{ {
std::istringstream ss(std::ios_base::in); std::istringstream ss(std::ios_base::in);
assert(ss.rdbuf() != 0); assert(ss.rdbuf() != nullptr);
assert(ss.good()); assert(ss.good());
assert(ss.str() == ""); assert(ss.str() == "");
} }
#ifndef TEST_HAS_NO_WIDE_CHARACTERS #ifndef TEST_HAS_NO_WIDE_CHARACTERS
{ {
std::wistringstream ss; std::wistringstream ss;
assert(ss.rdbuf() != 0); assert(ss.rdbuf() != nullptr);
assert(ss.good()); assert(ss.good());
assert(ss.str() == L""); assert(ss.str() == L"");
} }
{ {
std::wistringstream ss(std::ios_base::in); std::wistringstream ss(std::ios_base::in);
assert(ss.rdbuf() != 0); assert(ss.rdbuf() != nullptr);
assert(ss.good()); assert(ss.good());
assert(ss.str() == L""); assert(ss.str() == L"");
} }
#endif #endif
#if TEST_STD_VER >= 11 #if TEST_STD_VER >= 11
test<std::istringstream>(); test<std::istringstream>();
# ifndef TEST_HAS_NO_WIDE_CHARACTERS # ifndef TEST_HAS_NO_WIDE_CHARACTERS
test<std::wistringstream>(); test<std::wistringstream>();
# endif # endif
#endif #endif
return 0; return 0;
} }

libcxx/test/std/input.output/string.streams/istringstream/istringstream.cons/move.pass.cpp

Show All 17 Lines
#include "test_macros.h" #include "test_macros.h"
int main(int, char**) int main(int, char**)
{ {
{ {
std::istringstream ss0(" 123 456"); std::istringstream ss0(" 123 456");
std::istringstream ss(std::move(ss0)); std::istringstream ss(std::move(ss0));
assert(ss.rdbuf() != 0); assert(ss.rdbuf() != nullptr);
assert(ss.good()); assert(ss.good());
assert(ss.str() == " 123 456"); assert(ss.str() == " 123 456");
int i = 0; int i = 0;
ss >> i; ss >> i;
assert(i == 123); assert(i == 123);
ss >> i; ss >> i;
assert(i == 456); assert(i == 456);
} }
#ifndef TEST_HAS_NO_WIDE_CHARACTERS #ifndef TEST_HAS_NO_WIDE_CHARACTERS
{ {
std::wistringstream ss0(L" 123 456"); std::wistringstream ss0(L" 123 456");
std::wistringstream ss(std::move(ss0)); std::wistringstream ss(std::move(ss0));
assert(ss.rdbuf() != 0); assert(ss.rdbuf() != nullptr);
assert(ss.good()); assert(ss.good());
assert(ss.str() == L" 123 456"); assert(ss.str() == L" 123 456");
int i = 0; int i = 0;
ss >> i; ss >> i;
assert(i == 123); assert(i == 123);
ss >> i; ss >> i;
assert(i == 456); assert(i == 456);
} }
#endif #endif
return 0; return 0;
} }

libcxx/test/std/input.output/string.streams/istringstream/istringstream.cons/string.pass.cpp

Show All 17 Lines
#include <cassert> #include <cassert>
#include "test_macros.h" #include "test_macros.h"
int main(int, char**) int main(int, char**)
{ {
{ {
std::istringstream ss(" 123 456"); std::istringstream ss(" 123 456");
assert(ss.rdbuf() != 0); assert(ss.rdbuf() != nullptr);
assert(ss.good()); assert(ss.good());
assert(ss.str() == " 123 456"); assert(ss.str() == " 123 456");
int i = 0; int i = 0;
ss >> i; ss >> i;
assert(i == 123); assert(i == 123);
ss >> i; ss >> i;
assert(i == 456); assert(i == 456);
} }
{ {
std::istringstream ss(" 123 456", std::ios_base::out); std::istringstream ss(" 123 456", std::ios_base::out);
assert(ss.rdbuf() != 0); assert(ss.rdbuf() != nullptr);
assert(ss.good()); assert(ss.good());
assert(ss.str() == " 123 456"); assert(ss.str() == " 123 456");
int i = 0; int i = 0;
ss >> i; ss >> i;
assert(i == 123); assert(i == 123);
ss >> i; ss >> i;
assert(i == 456); assert(i == 456);
} }
#ifndef TEST_HAS_NO_WIDE_CHARACTERS #ifndef TEST_HAS_NO_WIDE_CHARACTERS
{ {
std::wistringstream ss(L" 123 456"); std::wistringstream ss(L" 123 456");
assert(ss.rdbuf() != 0); assert(ss.rdbuf() != nullptr);
assert(ss.good()); assert(ss.good());
assert(ss.str() == L" 123 456"); assert(ss.str() == L" 123 456");
int i = 0; int i = 0;
ss >> i; ss >> i;
assert(i == 123); assert(i == 123);
ss >> i; ss >> i;
assert(i == 456); assert(i == 456);
} }
{ {
std::wistringstream ss(L" 123 456", std::ios_base::out); std::wistringstream ss(L" 123 456", std::ios_base::out);
assert(ss.rdbuf() != 0); assert(ss.rdbuf() != nullptr);
assert(ss.good()); assert(ss.good());
assert(ss.str() == L" 123 456"); assert(ss.str() == L" 123 456");
int i = 0; int i = 0;
ss >> i; ss >> i;
assert(i == 123); assert(i == 123);
ss >> i; ss >> i;
assert(i == 456); assert(i == 456);
} }
#endif #endif
return 0; return 0;
} }

libcxx/test/std/input.output/string.streams/istringstream/istringstream.members/str.pass.cpp

Show All 16 Lines
#include <cassert> #include <cassert>
#include "test_macros.h" #include "test_macros.h"
int main(int, char**) int main(int, char**)
{ {
{ {
std::istringstream ss(" 123 456"); std::istringstream ss(" 123 456");
assert(ss.rdbuf() != 0); assert(ss.rdbuf() != nullptr);
assert(ss.good()); assert(ss.good());
assert(ss.str() == " 123 456"); assert(ss.str() == " 123 456");
int i = 0; int i = 0;
ss >> i; ss >> i;
assert(i == 123); assert(i == 123);
ss >> i; ss >> i;
assert(i == 456); assert(i == 456);
ss.str(" 789"); ss.str(" 789");
ss.clear(); ss.clear();
assert(ss.good()); assert(ss.good());
assert(ss.str() == " 789"); assert(ss.str() == " 789");
ss >> i; ss >> i;
assert(i == 789); assert(i == 789);
} }
#ifndef TEST_HAS_NO_WIDE_CHARACTERS #ifndef TEST_HAS_NO_WIDE_CHARACTERS
{ {
std::wistringstream ss(L" 123 456"); std::wistringstream ss(L" 123 456");
assert(ss.rdbuf() != 0); assert(ss.rdbuf() != nullptr);
assert(ss.good()); assert(ss.good());
assert(ss.str() == L" 123 456"); assert(ss.str() == L" 123 456");
int i = 0; int i = 0;
ss >> i; ss >> i;
assert(i == 123); assert(i == 123);
ss >> i; ss >> i;
assert(i == 456); assert(i == 456);
ss.str(L" 789"); ss.str(L" 789");
Show All 10 Lines

libcxx/test/std/input.output/string.streams/ostringstream/ostringstream.assign/member_swap.pass.cpp

Show All 18 Lines
#include "test_macros.h" #include "test_macros.h"
int main(int, char**) int main(int, char**)
{ {
{ {
std::ostringstream ss0(" 123 456"); std::ostringstream ss0(" 123 456");
std::ostringstream ss; std::ostringstream ss;
ss.swap(ss0); ss.swap(ss0);
assert(ss.rdbuf() != 0); assert(ss.rdbuf() != nullptr);
assert(ss.good()); assert(ss.good());
assert(ss.str() == " 123 456"); assert(ss.str() == " 123 456");
int i = 234; int i = 234;
ss << i << ' ' << 567; ss << i << ' ' << 567;
assert(ss.str() == "234 5676"); assert(ss.str() == "234 5676");
ss0 << i << ' ' << 567; ss0 << i << ' ' << 567;
assert(ss0.str() == "234 567"); assert(ss0.str() == "234 567");
} }
#ifndef TEST_HAS_NO_WIDE_CHARACTERS #ifndef TEST_HAS_NO_WIDE_CHARACTERS
{ {
std::wostringstream ss0(L" 123 456"); std::wostringstream ss0(L" 123 456");
std::wostringstream ss; std::wostringstream ss;
ss.swap(ss0); ss.swap(ss0);
assert(ss.rdbuf() != 0); assert(ss.rdbuf() != nullptr);
assert(ss.good()); assert(ss.good());
assert(ss.str() == L" 123 456"); assert(ss.str() == L" 123 456");
int i = 234; int i = 234;
ss << i << ' ' << 567; ss << i << ' ' << 567;
assert(ss.str() == L"234 5676"); assert(ss.str() == L"234 5676");
ss0 << i << ' ' << 567; ss0 << i << ' ' << 567;
assert(ss0.str() == L"234 567"); assert(ss0.str() == L"234 567");
} }
#endif #endif
return 0; return 0;
} }

libcxx/test/std/input.output/string.streams/ostringstream/ostringstream.assign/move.pass.cpp

Show All 18 Lines
#include "test_macros.h" #include "test_macros.h"
int main(int, char**) int main(int, char**)
{ {
{ {
std::ostringstream ss0(" 123 456"); std::ostringstream ss0(" 123 456");
std::ostringstream ss; std::ostringstream ss;
ss = std::move(ss0); ss = std::move(ss0);
assert(ss.rdbuf() != 0); assert(ss.rdbuf() != nullptr);
assert(ss.good()); assert(ss.good());
assert(ss.str() == " 123 456"); assert(ss.str() == " 123 456");
int i = 234; int i = 234;
ss << i << ' ' << 567; ss << i << ' ' << 567;
assert(ss.str() == "234 5676"); assert(ss.str() == "234 5676");
} }
#ifndef TEST_HAS_NO_WIDE_CHARACTERS #ifndef TEST_HAS_NO_WIDE_CHARACTERS
{ {
std::wostringstream ss0(L" 123 456"); std::wostringstream ss0(L" 123 456");
std::wostringstream ss; std::wostringstream ss;
ss = std::move(ss0); ss = std::move(ss0);
assert(ss.rdbuf() != 0); assert(ss.rdbuf() != nullptr);
assert(ss.good()); assert(ss.good());
assert(ss.str() == L" 123 456"); assert(ss.str() == L" 123 456");
int i = 234; int i = 234;
ss << i << ' ' << 567; ss << i << ' ' << 567;
assert(ss.str() == L"234 5676"); assert(ss.str() == L"234 5676");
} }
#endif #endif
return 0; return 0;
} }

libcxx/test/std/input.output/string.streams/ostringstream/ostringstream.assign/nonmember_swap.pass.cpp

Show All 18 Lines
#include "test_macros.h" #include "test_macros.h"
int main(int, char**) int main(int, char**)
{ {
{ {
std::ostringstream ss0(" 123 456"); std::ostringstream ss0(" 123 456");
std::ostringstream ss; std::ostringstream ss;
swap(ss, ss0); swap(ss, ss0);
assert(ss.rdbuf() != 0); assert(ss.rdbuf() != nullptr);
assert(ss.good()); assert(ss.good());
assert(ss.str() == " 123 456"); assert(ss.str() == " 123 456");
int i = 234; int i = 234;
ss << i << ' ' << 567; ss << i << ' ' << 567;
assert(ss.str() == "234 5676"); assert(ss.str() == "234 5676");
ss0 << i << ' ' << 567; ss0 << i << ' ' << 567;
assert(ss0.str() == "234 567"); assert(ss0.str() == "234 567");
} }
#ifndef TEST_HAS_NO_WIDE_CHARACTERS #ifndef TEST_HAS_NO_WIDE_CHARACTERS
{ {
std::wostringstream ss0(L" 123 456"); std::wostringstream ss0(L" 123 456");
std::wostringstream ss; std::wostringstream ss;
swap(ss, ss0); swap(ss, ss0);
assert(ss.rdbuf() != 0); assert(ss.rdbuf() != nullptr);
assert(ss.good()); assert(ss.good());
assert(ss.str() == L" 123 456"); assert(ss.str() == L" 123 456");
int i = 234; int i = 234;
ss << i << ' ' << 567; ss << i << ' ' << 567;
assert(ss.str() == L"234 5676"); assert(ss.str() == L"234 5676");
ss0 << i << ' ' << 567; ss0 << i << ' ' << 567;
assert(ss0.str() == L"234 567"); assert(ss0.str() == L"234 567");
} }
#endif #endif
return 0; return 0;
} }

libcxx/test/std/input.output/string.streams/ostringstream/ostringstream.cons/default.pass.cpp

Show All 27 Linesvoid test() {
static_assert(!test_convertible<S, std::ios_base::openmode>(), ""); static_assert(!test_convertible<S, std::ios_base::openmode>(), "");
} }
#endif #endif
int main(int, char**) int main(int, char**)
{ {
{ {
std::ostringstream ss; std::ostringstream ss;
assert(ss.rdbuf() != 0); assert(ss.rdbuf() != nullptr);
assert(ss.good()); assert(ss.good());
assert(ss.str() == ""); assert(ss.str() == "");
} }
{ {
std::ostringstream ss(std::ios_base::out); std::ostringstream ss(std::ios_base::out);
assert(ss.rdbuf() != 0); assert(ss.rdbuf() != nullptr);
assert(ss.good()); assert(ss.good());
assert(ss.str() == ""); assert(ss.str() == "");
} }
#ifndef TEST_HAS_NO_WIDE_CHARACTERS #ifndef TEST_HAS_NO_WIDE_CHARACTERS
{ {
std::wostringstream ss; std::wostringstream ss;
assert(ss.rdbuf() != 0); assert(ss.rdbuf() != nullptr);
assert(ss.good()); assert(ss.good());
assert(ss.str() == L""); assert(ss.str() == L"");
} }
{ {
std::wostringstream ss(std::ios_base::out); std::wostringstream ss(std::ios_base::out);
assert(ss.rdbuf() != 0); assert(ss.rdbuf() != nullptr);
assert(ss.good()); assert(ss.good());
assert(ss.str() == L""); assert(ss.str() == L"");
} }
#endif // TEST_HAS_NO_WIDE_CHARACTERS #endif // TEST_HAS_NO_WIDE_CHARACTERS
#if TEST_STD_VER >= 11 #if TEST_STD_VER >= 11
test<std::ostringstream>(); test<std::ostringstream>();
# ifndef TEST_HAS_NO_WIDE_CHARACTERS # ifndef TEST_HAS_NO_WIDE_CHARACTERS
test<std::wostringstream>(); test<std::wostringstream>();
# endif # endif
#endif #endif
return 0; return 0;
} }

libcxx/test/std/input.output/string.streams/ostringstream/ostringstream.cons/move.pass.cpp

Show All 17 Lines
#include "test_macros.h" #include "test_macros.h"
int main(int, char**) int main(int, char**)
{ {
{ {
std::ostringstream ss0(" 123 456"); std::ostringstream ss0(" 123 456");
std::ostringstream ss(std::move(ss0)); std::ostringstream ss(std::move(ss0));
assert(ss.rdbuf() != 0); assert(ss.rdbuf() != nullptr);
assert(ss.good()); assert(ss.good());
assert(ss.str() == " 123 456"); assert(ss.str() == " 123 456");
int i = 234; int i = 234;
ss << i << ' ' << 567; ss << i << ' ' << 567;
assert(ss.str() == "234 5676"); assert(ss.str() == "234 5676");
} }
#ifndef TEST_HAS_NO_WIDE_CHARACTERS #ifndef TEST_HAS_NO_WIDE_CHARACTERS
{ {
std::wostringstream ss0(L" 123 456"); std::wostringstream ss0(L" 123 456");
std::wostringstream ss(std::move(ss0)); std::wostringstream ss(std::move(ss0));
assert(ss.rdbuf() != 0); assert(ss.rdbuf() != nullptr);
assert(ss.good()); assert(ss.good());
assert(ss.str() == L" 123 456"); assert(ss.str() == L" 123 456");
int i = 234; int i = 234;
ss << i << ' ' << 567; ss << i << ' ' << 567;
assert(ss.str() == L"234 5676"); assert(ss.str() == L"234 5676");
} }
#endif #endif
return 0; return 0;
} }

libcxx/test/std/input.output/string.streams/ostringstream/ostringstream.cons/string.pass.cpp

Show All 17 Lines
#include <cassert> #include <cassert>
#include "test_macros.h" #include "test_macros.h"
int main(int, char**) int main(int, char**)
{ {
{ {
std::ostringstream ss(" 123 456"); std::ostringstream ss(" 123 456");
assert(ss.rdbuf() != 0); assert(ss.rdbuf() != nullptr);
assert(ss.good()); assert(ss.good());
assert(ss.str() == " 123 456"); assert(ss.str() == " 123 456");
int i = 234; int i = 234;
ss << i << ' ' << 567; ss << i << ' ' << 567;
assert(ss.str() == "234 5676"); assert(ss.str() == "234 5676");
} }
{ {
std::ostringstream ss(" 123 456", std::ios_base::in); std::ostringstream ss(" 123 456", std::ios_base::in);
assert(ss.rdbuf() != 0); assert(ss.rdbuf() != nullptr);
assert(ss.good()); assert(ss.good());
assert(ss.str() == " 123 456"); assert(ss.str() == " 123 456");
int i = 234; int i = 234;
ss << i << ' ' << 567; ss << i << ' ' << 567;
assert(ss.str() == "234 5676"); assert(ss.str() == "234 5676");
} }
#ifndef TEST_HAS_NO_WIDE_CHARACTERS #ifndef TEST_HAS_NO_WIDE_CHARACTERS
{ {
std::wostringstream ss(L" 123 456"); std::wostringstream ss(L" 123 456");
assert(ss.rdbuf() != 0); assert(ss.rdbuf() != nullptr);
assert(ss.good()); assert(ss.good());
assert(ss.str() == L" 123 456"); assert(ss.str() == L" 123 456");
int i = 234; int i = 234;
ss << i << ' ' << 567; ss << i << ' ' << 567;
assert(ss.str() == L"234 5676"); assert(ss.str() == L"234 5676");
} }
{ {
std::wostringstream ss(L" 123 456", std::ios_base::in); std::wostringstream ss(L" 123 456", std::ios_base::in);
assert(ss.rdbuf() != 0); assert(ss.rdbuf() != nullptr);
assert(ss.good()); assert(ss.good());
assert(ss.str() == L" 123 456"); assert(ss.str() == L" 123 456");
int i = 234; int i = 234;
ss << i << ' ' << 567; ss << i << ' ' << 567;
assert(ss.str() == L"234 5676"); assert(ss.str() == L"234 5676");
} }
#endif #endif
return 0; return 0;
} }

libcxx/test/std/input.output/string.streams/ostringstream/ostringstream.members/str.pass.cpp

Show All 16 Lines
#include <cassert> #include <cassert>
#include "test_macros.h" #include "test_macros.h"
int main(int, char**) int main(int, char**)
{ {
{ {
std::ostringstream ss(" 123 456"); std::ostringstream ss(" 123 456");
assert(ss.rdbuf() != 0); assert(ss.rdbuf() != nullptr);
assert(ss.good()); assert(ss.good());
assert(ss.str() == " 123 456"); assert(ss.str() == " 123 456");
int i = 0; int i = 0;
ss << i; ss << i;
assert(ss.str() == "0123 456"); assert(ss.str() == "0123 456");
ss << 456; ss << 456;
assert(ss.str() == "0456 456"); assert(ss.str() == "0456 456");
ss.str(" 789"); ss.str(" 789");
assert(ss.str() == " 789"); assert(ss.str() == " 789");
ss << "abc"; ss << "abc";
assert(ss.str() == "abc9"); assert(ss.str() == "abc9");
} }
#ifndef TEST_HAS_NO_WIDE_CHARACTERS #ifndef TEST_HAS_NO_WIDE_CHARACTERS
{ {
std::wostringstream ss(L" 123 456"); std::wostringstream ss(L" 123 456");
assert(ss.rdbuf() != 0); assert(ss.rdbuf() != nullptr);
assert(ss.good()); assert(ss.good());
assert(ss.str() == L" 123 456"); assert(ss.str() == L" 123 456");
int i = 0; int i = 0;
ss << i; ss << i;
assert(ss.str() == L"0123 456"); assert(ss.str() == L"0123 456");
ss << 456; ss << 456;
assert(ss.str() == L"0456 456"); assert(ss.str() == L"0456 456");
ss.str(L" 789"); ss.str(L" 789");
assert(ss.str() == L" 789"); assert(ss.str() == L" 789");
ss << L"abc"; ss << L"abc";
assert(ss.str() == L"abc9"); assert(ss.str() == L"abc9");
} }
#endif #endif
return 0; return 0;
} }

libcxx/test/std/input.output/string.streams/stringstream.cons/default.pass.cpp

Show All 27 Linesvoid test() {
static_assert(!test_convertible<S, std::ios_base::openmode>(), ""); static_assert(!test_convertible<S, std::ios_base::openmode>(), "");
} }
#endif #endif
int main(int, char**) int main(int, char**)
{ {
{ {
std::stringstream ss; std::stringstream ss;
assert(ss.rdbuf() != 0); assert(ss.rdbuf() != nullptr);
assert(ss.good()); assert(ss.good());
assert(ss.str() == ""); assert(ss.str() == "");
} }
{ {
std::stringstream ss(std::ios_base::in); std::stringstream ss(std::ios_base::in);
assert(ss.rdbuf() != 0); assert(ss.rdbuf() != nullptr);
assert(ss.good()); assert(ss.good());
assert(ss.str() == ""); assert(ss.str() == "");
} }
#ifndef TEST_HAS_NO_WIDE_CHARACTERS #ifndef TEST_HAS_NO_WIDE_CHARACTERS
{ {
std::wstringstream ss; std::wstringstream ss;
assert(ss.rdbuf() != 0); assert(ss.rdbuf() != nullptr);
assert(ss.good()); assert(ss.good());
assert(ss.str() == L""); assert(ss.str() == L"");
} }
{ {
std::wstringstream ss(std::ios_base::in); std::wstringstream ss(std::ios_base::in);
assert(ss.rdbuf() != 0); assert(ss.rdbuf() != nullptr);
assert(ss.good()); assert(ss.good());
assert(ss.str() == L""); assert(ss.str() == L"");
} }
#endif #endif
#if TEST_STD_VER >= 11 #if TEST_STD_VER >= 11
test<std::stringstream>(); test<std::stringstream>();
# ifndef TEST_HAS_NO_WIDE_CHARACTERS # ifndef TEST_HAS_NO_WIDE_CHARACTERS
test<std::wstringstream>(); test<std::wstringstream>();
# endif # endif
#endif #endif
return 0; return 0;
} }

libcxx/test/std/input.output/string.streams/stringstream.cons/move.pass.cpp

Show All 17 Lines
#include "test_macros.h" #include "test_macros.h"
int main(int, char**) int main(int, char**)
{ {
{ {
std::stringstream ss0(" 123 456 "); std::stringstream ss0(" 123 456 ");
std::stringstream ss(std::move(ss0)); std::stringstream ss(std::move(ss0));
assert(ss.rdbuf() != 0); assert(ss.rdbuf() != nullptr);
assert(ss.good()); assert(ss.good());
assert(ss.str() == " 123 456 "); assert(ss.str() == " 123 456 ");
int i = 0; int i = 0;
ss >> i; ss >> i;
assert(i == 123); assert(i == 123);
ss >> i; ss >> i;
assert(i == 456); assert(i == 456);
ss << i << ' ' << 123; ss << i << ' ' << 123;
assert(ss.str() == "456 1236 "); assert(ss.str() == "456 1236 ");
} }
#ifndef TEST_HAS_NO_WIDE_CHARACTERS #ifndef TEST_HAS_NO_WIDE_CHARACTERS
{ {
std::wstringstream ss0(L" 123 456 "); std::wstringstream ss0(L" 123 456 ");
std::wstringstream ss(std::move(ss0)); std::wstringstream ss(std::move(ss0));
assert(ss.rdbuf() != 0); assert(ss.rdbuf() != nullptr);
assert(ss.good()); assert(ss.good());
assert(ss.str() == L" 123 456 "); assert(ss.str() == L" 123 456 ");
int i = 0; int i = 0;
ss >> i; ss >> i;
assert(i == 123); assert(i == 123);
ss >> i; ss >> i;
assert(i == 456); assert(i == 456);
ss << i << ' ' << 123; ss << i << ' ' << 123;
assert(ss.str() == L"456 1236 "); assert(ss.str() == L"456 1236 ");
} }
#endif #endif
return 0; return 0;
} }

libcxx/test/std/input.output/string.streams/stringstream.cons/string.pass.cpp

Show All 27 Linesstruct NoDefaultAllocator : std::allocator<T>
int id; int id;
}; };
int main(int, char**) int main(int, char**)
{ {
{ {
std::stringstream ss(" 123 456 "); std::stringstream ss(" 123 456 ");
assert(ss.rdbuf() != 0); assert(ss.rdbuf() != nullptr);
assert(ss.good()); assert(ss.good());
assert(ss.str() == " 123 456 "); assert(ss.str() == " 123 456 ");
int i = 0; int i = 0;
ss >> i; ss >> i;
assert(i == 123); assert(i == 123);
ss >> i; ss >> i;
assert(i == 456); assert(i == 456);
ss << i << ' ' << 123; ss << i << ' ' << 123;
assert(ss.str() == "456 1236 "); assert(ss.str() == "456 1236 ");
} }
#ifndef TEST_HAS_NO_WIDE_CHARACTERS #ifndef TEST_HAS_NO_WIDE_CHARACTERS
{ {
std::wstringstream ss(L" 123 456 "); std::wstringstream ss(L" 123 456 ");
assert(ss.rdbuf() != 0); assert(ss.rdbuf() != nullptr);
assert(ss.good()); assert(ss.good());
assert(ss.str() == L" 123 456 "); assert(ss.str() == L" 123 456 ");
int i = 0; int i = 0;
ss >> i; ss >> i;
assert(i == 123); assert(i == 123);
ss >> i; ss >> i;
assert(i == 456); assert(i == 456);
ss << i << ' ' << 123; ss << i << ' ' << 123;
Show All 15 Lines

libcxx/test/std/input.output/string.streams/stringstream.cons/stringstream.assign/member_swap.pass.cpp

Show All 18 Lines
#include "test_macros.h" #include "test_macros.h"
int main(int, char**) int main(int, char**)
{ {
{ {
std::stringstream ss0(" 123 456 "); std::stringstream ss0(" 123 456 ");
std::stringstream ss; std::stringstream ss;
ss.swap(ss0); ss.swap(ss0);
assert(ss.rdbuf() != 0); assert(ss.rdbuf() != nullptr);
assert(ss.good()); assert(ss.good());
assert(ss.str() == " 123 456 "); assert(ss.str() == " 123 456 ");
int i = 0; int i = 0;
ss >> i; ss >> i;
assert(i == 123); assert(i == 123);
ss >> i; ss >> i;
assert(i == 456); assert(i == 456);
ss << i << ' ' << 123; ss << i << ' ' << 123;
assert(ss.str() == "456 1236 "); assert(ss.str() == "456 1236 ");
ss0 << i << ' ' << 123; ss0 << i << ' ' << 123;
assert(ss0.str() == "456 123"); assert(ss0.str() == "456 123");
} }
#ifndef TEST_HAS_NO_WIDE_CHARACTERS #ifndef TEST_HAS_NO_WIDE_CHARACTERS
{ {
std::wstringstream ss0(L" 123 456 "); std::wstringstream ss0(L" 123 456 ");
std::wstringstream ss; std::wstringstream ss;
ss.swap(ss0); ss.swap(ss0);
assert(ss.rdbuf() != 0); assert(ss.rdbuf() != nullptr);
assert(ss.good()); assert(ss.good());
assert(ss.str() == L" 123 456 "); assert(ss.str() == L" 123 456 ");
int i = 0; int i = 0;
ss >> i; ss >> i;
assert(i == 123); assert(i == 123);
ss >> i; ss >> i;
assert(i == 456); assert(i == 456);
ss << i << ' ' << 123; ss << i << ' ' << 123;
assert(ss.str() == L"456 1236 "); assert(ss.str() == L"456 1236 ");
ss0 << i << ' ' << 123; ss0 << i << ' ' << 123;
assert(ss0.str() == L"456 123"); assert(ss0.str() == L"456 123");
} }
#endif // TEST_HAS_NO_WIDE_CHARACTERS #endif // TEST_HAS_NO_WIDE_CHARACTERS
return 0; return 0;
} }

libcxx/test/std/input.output/string.streams/stringstream.cons/stringstream.assign/move.pass.cpp

Show All 18 Lines
#include "test_macros.h" #include "test_macros.h"
int main(int, char**) int main(int, char**)
{ {
{ {
std::stringstream ss0(" 123 456 "); std::stringstream ss0(" 123 456 ");
std::stringstream ss; std::stringstream ss;
ss = std::move(ss0); ss = std::move(ss0);
assert(ss.rdbuf() != 0); assert(ss.rdbuf() != nullptr);
assert(ss.good()); assert(ss.good());
assert(ss.str() == " 123 456 "); assert(ss.str() == " 123 456 ");
int i = 0; int i = 0;
ss >> i; ss >> i;
assert(i == 123); assert(i == 123);
ss >> i; ss >> i;
assert(i == 456); assert(i == 456);
ss << i << ' ' << 123; ss << i << ' ' << 123;
assert(ss.str() == "456 1236 "); assert(ss.str() == "456 1236 ");
} }
#ifndef TEST_HAS_NO_WIDE_CHARACTERS #ifndef TEST_HAS_NO_WIDE_CHARACTERS
{ {
std::wstringstream ss0(L" 123 456 "); std::wstringstream ss0(L" 123 456 ");
std::wstringstream ss; std::wstringstream ss;
ss = std::move(ss0); ss = std::move(ss0);
assert(ss.rdbuf() != 0); assert(ss.rdbuf() != nullptr);
assert(ss.good()); assert(ss.good());
assert(ss.str() == L" 123 456 "); assert(ss.str() == L" 123 456 ");
int i = 0; int i = 0;
ss >> i; ss >> i;
assert(i == 123); assert(i == 123);
ss >> i; ss >> i;
assert(i == 456); assert(i == 456);
ss << i << ' ' << 123; ss << i << ' ' << 123;
assert(ss.str() == L"456 1236 "); assert(ss.str() == L"456 1236 ");
} }
#endif #endif
return 0; return 0;
} }

libcxx/test/std/input.output/string.streams/stringstream.cons/stringstream.assign/nonmember_swap.pass.cpp

Show All 21 Lines
#include "test_macros.h" #include "test_macros.h"
int main(int, char**) int main(int, char**)
{ {
{ {
std::stringstream ss0(" 123 456 "); std::stringstream ss0(" 123 456 ");
std::stringstream ss; std::stringstream ss;
swap(ss, ss0); swap(ss, ss0);
assert(ss.rdbuf() != 0); assert(ss.rdbuf() != nullptr);
assert(ss.good()); assert(ss.good());
assert(ss.str() == " 123 456 "); assert(ss.str() == " 123 456 ");
int i = 0; int i = 0;
ss >> i; ss >> i;
assert(i == 123); assert(i == 123);
ss >> i; ss >> i;
assert(i == 456); assert(i == 456);
ss << i << ' ' << 123; ss << i << ' ' << 123;
assert(ss.str() == "456 1236 "); assert(ss.str() == "456 1236 ");
ss0 << i << ' ' << 123; ss0 << i << ' ' << 123;
assert(ss0.str() == "456 123"); assert(ss0.str() == "456 123");
} }
#ifndef TEST_HAS_NO_WIDE_CHARACTERS #ifndef TEST_HAS_NO_WIDE_CHARACTERS
{ {
std::wstringstream ss0(L" 123 456 "); std::wstringstream ss0(L" 123 456 ");
std::wstringstream ss; std::wstringstream ss;
swap(ss, ss0); swap(ss, ss0);
assert(ss.rdbuf() != 0); assert(ss.rdbuf() != nullptr);
assert(ss.good()); assert(ss.good());
assert(ss.str() == L" 123 456 "); assert(ss.str() == L" 123 456 ");
int i = 0; int i = 0;
ss >> i; ss >> i;
assert(i == 123); assert(i == 123);
ss >> i; ss >> i;
assert(i == 456); assert(i == 456);
ss << i << ' ' << 123; ss << i << ' ' << 123;
assert(ss.str() == L"456 1236 "); assert(ss.str() == L"456 1236 ");
ss0 << i << ' ' << 123; ss0 << i << ' ' << 123;
assert(ss0.str() == L"456 123"); assert(ss0.str() == L"456 123");
} }
#endif #endif
return 0; return 0;
} }

libcxx/test/std/input.output/string.streams/stringstream.members/str.pass.cpp

Show All 16 Lines
#include <cassert> #include <cassert>
#include "test_macros.h" #include "test_macros.h"
int main(int, char**) int main(int, char**)
{ {
{ {
std::stringstream ss(" 123 456 "); std::stringstream ss(" 123 456 ");
assert(ss.rdbuf() != 0); assert(ss.rdbuf() != nullptr);
assert(ss.good()); assert(ss.good());
assert(ss.str() == " 123 456 "); assert(ss.str() == " 123 456 ");
int i = 0; int i = 0;
ss >> i; ss >> i;
assert(i == 123); assert(i == 123);
ss >> i; ss >> i;
assert(i == 456); assert(i == 456);
ss << i << ' ' << 123; ss << i << ' ' << 123;
assert(ss.str() == "456 1236 "); assert(ss.str() == "456 1236 ");
ss.str("5466 89 "); ss.str("5466 89 ");
ss >> i; ss >> i;
assert(i == 5466); assert(i == 5466);
ss >> i; ss >> i;
assert(i == 89); assert(i == 89);
ss << i << ' ' << 321; ss << i << ' ' << 321;
assert(ss.str() == "89 3219 "); assert(ss.str() == "89 3219 ");
} }
#ifndef TEST_HAS_NO_WIDE_CHARACTERS #ifndef TEST_HAS_NO_WIDE_CHARACTERS
{ {
std::wstringstream ss(L" 123 456 "); std::wstringstream ss(L" 123 456 ");
assert(ss.rdbuf() != 0); assert(ss.rdbuf() != nullptr);
assert(ss.good()); assert(ss.good());
assert(ss.str() == L" 123 456 "); assert(ss.str() == L" 123 456 ");
int i = 0; int i = 0;
ss >> i; ss >> i;
assert(i == 123); assert(i == 123);
ss >> i; ss >> i;
assert(i == 456); assert(i == 456);
ss << i << ' ' << 123; ss << i << ' ' << 123;
Show All 18 Lines

libcxx/test/std/iterators/iterator.primitives/iterator.traits/empty.pass.cpp

Show All 21 Lines
}; };
template <class T> template <class T>
struct has_value_type struct has_value_type
{ {
private: private:
struct two {char lx; char lxx;}; struct two {char lx; char lxx;};
template <class U> static two test(...); template <class U> static two test(...);
template <class U> static char test(typename U::value_type* = 0); template <class U> static char test(typename U::value_type* = nullptr);
public: public:
static const bool value = sizeof(test<T>(0)) == 1; static const bool value = sizeof(test<T>(0)) == 1;
}; };
int main(int, char**) int main(int, char**)
{ {
typedef std::iterator_traits<not_an_iterator> It; typedef std::iterator_traits<not_an_iterator> It;
static_assert(!(has_value_type<It>::value), ""); static_assert(!(has_value_type<It>::value), "");
return 0; return 0;
} }

libcxx/test/std/language.support/cmp/cmp.categories.pre/zero_type.verify.cpp

  • This file was moved to libcxx/test/libcxx/language.support/cmp/cmp.categories.pre/zero_type.verify.cpp.

libcxx/test/std/language.support/support.dynamic/new.delete/new.delete.array/new_align_val_t.pass.cpp

Show All 30 Lines
constexpr auto OverAligned = __STDCPP_DEFAULT_NEW_ALIGNMENT__ * 2; constexpr auto OverAligned = __STDCPP_DEFAULT_NEW_ALIGNMENT__ * 2;
int new_handler_called = 0; int new_handler_called = 0;
void my_new_handler() void my_new_handler()
{ {
++new_handler_called; ++new_handler_called;
std::set_new_handler(0); std::set_new_handler(nullptr);
} }
int A_constructed = 0; int A_constructed = 0;
struct alignas(OverAligned) A struct alignas(OverAligned) A
{ {
A() { ++A_constructed;} A() { ++A_constructed;}
~A() { --A_constructed;} ~A() { --A_constructed;}
Show All 39 Lines

libcxx/test/std/language.support/support.dynamic/new.delete/new.delete.array/new_align_val_t_nothrow.pass.cpp

Show All 30 Lines
constexpr auto OverAligned = __STDCPP_DEFAULT_NEW_ALIGNMENT__ * 2; constexpr auto OverAligned = __STDCPP_DEFAULT_NEW_ALIGNMENT__ * 2;
int new_handler_called = 0; int new_handler_called = 0;
void my_new_handler() void my_new_handler()
{ {
++new_handler_called; ++new_handler_called;
std::set_new_handler(0); std::set_new_handler(nullptr);
} }
int A_constructed = 0; int A_constructed = 0;
struct alignas(OverAligned) A struct alignas(OverAligned) A
{ {
A() { ++A_constructed; } A() { ++A_constructed; }
~A() { --A_constructed; } ~A() { --A_constructed; }
}; };
void test_max_alloc() { void test_max_alloc() {
std::set_new_handler(my_new_handler); std::set_new_handler(my_new_handler);
auto do_test = []() { auto do_test = []() {
void* vp = operator new [](std::numeric_limits<std::size_t>::max(), void* vp = operator new [](std::numeric_limits<std::size_t>::max(),
std::align_val_t(OverAligned), std::align_val_t(OverAligned),
std::nothrow); std::nothrow);
assert(new_handler_called == 1); assert(new_handler_called == 1);
assert(vp == 0); assert(vp == nullptr);
}; };
#ifndef TEST_HAS_NO_EXCEPTIONS #ifndef TEST_HAS_NO_EXCEPTIONS
try try
{ {
do_test(); do_test();
} }
catch (...) catch (...)
{ {
Show All 23 Lines

libcxx/test/std/language.support/support.dynamic/new.delete/new.delete.array/new_array.pass.cpp

Show All 17 Lines
#include "test_macros.h" #include "test_macros.h"
int new_handler_called = 0; int new_handler_called = 0;
void my_new_handler() void my_new_handler()
{ {
++new_handler_called; ++new_handler_called;
std::set_new_handler(0); std::set_new_handler(nullptr);
} }
int A_constructed = 0; int A_constructed = 0;
struct A struct A
{ {
A() {++A_constructed;} A() {++A_constructed;}
~A() {--A_constructed;} ~A() {--A_constructed;}
Show All 31 Lines

libcxx/test/std/language.support/support.dynamic/new.delete/new.delete.array/new_array_nothrow.pass.cpp

Show All 17 Lines
#include "test_macros.h" #include "test_macros.h"
int new_handler_called = 0; int new_handler_called = 0;
void my_new_handler() void my_new_handler()
{ {
++new_handler_called; ++new_handler_called;
std::set_new_handler(0); std::set_new_handler(nullptr);
} }
int A_constructed = 0; int A_constructed = 0;
struct A struct A
{ {
A() {++A_constructed;} A() {++A_constructed;}
~A() {--A_constructed;} ~A() {--A_constructed;}
}; };
int main(int, char**) int main(int, char**)
{ {
new_handler_called = 0; new_handler_called = 0;
std::set_new_handler(my_new_handler); std::set_new_handler(my_new_handler);
#ifndef TEST_HAS_NO_EXCEPTIONS #ifndef TEST_HAS_NO_EXCEPTIONS
try try
#endif #endif
{ {
void* vp = operator new [] (std::numeric_limits<std::size_t>::max(), std::nothrow); void* vp = operator new [] (std::numeric_limits<std::size_t>::max(), std::nothrow);
DoNotOptimize(vp); DoNotOptimize(vp);
assert(new_handler_called == 1); assert(new_handler_called == 1);
assert(vp == 0); assert(vp == nullptr);
} }
#ifndef TEST_HAS_NO_EXCEPTIONS #ifndef TEST_HAS_NO_EXCEPTIONS
catch (...) catch (...)
{ {
assert(false); assert(false);
} }
#endif #endif
A* ap = new(std::nothrow) A[3]; A* ap = new(std::nothrow) A[3];
Show All 9 Lines

libcxx/test/std/language.support/support.dynamic/new.delete/new.delete.single/new.pass.cpp

Show All 17 Lines
#include "test_macros.h" #include "test_macros.h"
int new_handler_called = 0; int new_handler_called = 0;
void my_new_handler() void my_new_handler()
{ {
++new_handler_called; ++new_handler_called;
std::set_new_handler(0); std::set_new_handler(nullptr);
} }
bool A_constructed = false; bool A_constructed = false;
struct A struct A
{ {
A() {A_constructed = true;} A() {A_constructed = true;}
~A() {A_constructed = false;} ~A() {A_constructed = false;}
Show All 29 Lines

libcxx/test/std/language.support/support.dynamic/new.delete/new.delete.single/new_align_val_t.pass.cpp

Show All 30 Lines
constexpr auto OverAligned = __STDCPP_DEFAULT_NEW_ALIGNMENT__ * 2; constexpr auto OverAligned = __STDCPP_DEFAULT_NEW_ALIGNMENT__ * 2;
int new_handler_called = 0; int new_handler_called = 0;
void my_new_handler() void my_new_handler()
{ {
++new_handler_called; ++new_handler_called;
std::set_new_handler(0); std::set_new_handler(nullptr);
} }
bool A_constructed = false; bool A_constructed = false;
struct alignas(OverAligned) A struct alignas(OverAligned) A
{ {
A() {A_constructed = true;} A() {A_constructed = true;}
~A() {A_constructed = false;} ~A() {A_constructed = false;}
Show All 39 Lines

libcxx/test/std/language.support/support.dynamic/new.delete/new.delete.single/new_align_val_t_nothrow.pass.cpp

Show All 30 Lines
constexpr auto OverAligned = __STDCPP_DEFAULT_NEW_ALIGNMENT__ * 2; constexpr auto OverAligned = __STDCPP_DEFAULT_NEW_ALIGNMENT__ * 2;
int new_handler_called = 0; int new_handler_called = 0;
void my_new_handler() void my_new_handler()
{ {
++new_handler_called; ++new_handler_called;
std::set_new_handler(0); std::set_new_handler(nullptr);
} }
bool A_constructed = false; bool A_constructed = false;
struct alignas(OverAligned) A struct alignas(OverAligned) A
{ {
A() {A_constructed = true;} A() {A_constructed = true;}
~A() {A_constructed = false;} ~A() {A_constructed = false;}
}; };
void test_max_alloc() { void test_max_alloc() {
std::set_new_handler(my_new_handler); std::set_new_handler(my_new_handler);
auto do_test = []() { auto do_test = []() {
void* vp = operator new (std::numeric_limits<std::size_t>::max(), void* vp = operator new (std::numeric_limits<std::size_t>::max(),
std::align_val_t(OverAligned), std::align_val_t(OverAligned),
std::nothrow); std::nothrow);
assert(new_handler_called == 1); assert(new_handler_called == 1);
assert(vp == 0); assert(vp == nullptr);
}; };
#ifndef TEST_HAS_NO_EXCEPTIONS #ifndef TEST_HAS_NO_EXCEPTIONS
try try
{ {
do_test(); do_test();
} }
catch (...) catch (...)
{ {
Show All 23 Lines

libcxx/test/std/language.support/support.dynamic/new.delete/new.delete.single/new_nothrow.pass.cpp

Show All 17 Lines
#include "test_macros.h" #include "test_macros.h"
int new_handler_called = 0; int new_handler_called = 0;
void my_new_handler() void my_new_handler()
{ {
++new_handler_called; ++new_handler_called;
std::set_new_handler(0); std::set_new_handler(nullptr);
} }
bool A_constructed = false; bool A_constructed = false;
struct A struct A
{ {
A() {A_constructed = true;} A() {A_constructed = true;}
~A() {A_constructed = false;} ~A() {A_constructed = false;}
}; };
int main(int, char**) int main(int, char**)
{ {
std::set_new_handler(my_new_handler); std::set_new_handler(my_new_handler);
#ifndef TEST_HAS_NO_EXCEPTIONS #ifndef TEST_HAS_NO_EXCEPTIONS
try try
#endif #endif
{ {
void* vp = operator new (std::numeric_limits<std::size_t>::max(), std::nothrow); void* vp = operator new (std::numeric_limits<std::size_t>::max(), std::nothrow);
assert(new_handler_called == 1); assert(new_handler_called == 1);
assert(vp == 0); assert(vp == nullptr);
} }
#ifndef TEST_HAS_NO_EXCEPTIONS #ifndef TEST_HAS_NO_EXCEPTIONS
catch (...) catch (...)
{ {
assert(false); assert(false);
} }
#endif #endif
A* ap = new(std::nothrow) A; A* ap = new(std::nothrow) A;
assert(ap); assert(ap);
assert(A_constructed); assert(A_constructed);
delete ap; delete ap;
assert(!A_constructed); assert(!A_constructed);
return 0; return 0;
} }

libcxx/test/std/language.support/support.runtime/cstdlib.pass.cpp

Show First 20 Lines • Show All 105 Lines • ▼ Show 20 Linesint main(int, char**)
static_assert((std::is_same<decltype(std::strtoll("", endptr,0)), long long>::value), ""); static_assert((std::is_same<decltype(std::strtoll("", endptr,0)), long long>::value), "");
static_assert((std::is_same<decltype(std::strtoul("", endptr,0)), unsigned long>::value), ""); static_assert((std::is_same<decltype(std::strtoul("", endptr,0)), unsigned long>::value), "");
static_assert((std::is_same<decltype(std::strtoull("", endptr,0)), unsigned long long>::value), ""); static_assert((std::is_same<decltype(std::strtoull("", endptr,0)), unsigned long long>::value), "");
static_assert((std::is_same<decltype(std::rand()), int>::value), ""); static_assert((std::is_same<decltype(std::rand()), int>::value), "");
static_assert((std::is_same<decltype(std::srand(0)), void>::value), ""); static_assert((std::is_same<decltype(std::srand(0)), void>::value), "");
// std::aligned_alloc tested in cstdlib.aligned_alloc.compile.pass.cpp // std::aligned_alloc tested in cstdlib.aligned_alloc.compile.pass.cpp
void* pv = 0; void* pv = nullptr;
void (*handler)() = 0; void (*handler)() = nullptr;
int (*comp)(void const*, void const*) = 0; int (*comp)(void const*, void const*) = nullptr;
static_assert((std::is_same<decltype(std::calloc(0,0)), void*>::value), ""); static_assert((std::is_same<decltype(std::calloc(0,0)), void*>::value), "");
static_assert((std::is_same<decltype(std::free(0)), void>::value), ""); static_assert((std::is_same<decltype(std::free(nullptr)), void>::value), "");
static_assert((std::is_same<decltype(std::malloc(0)), void*>::value), ""); static_assert((std::is_same<decltype(std::malloc(0)), void*>::value), "");
static_assert((std::is_same<decltype(std::realloc(0,0)), void*>::value), ""); static_assert((std::is_same<decltype(std::realloc(0,0)), void*>::value), "");
static_assert((std::is_same<decltype(std::abort()), void>::value), ""); static_assert((std::is_same<decltype(std::abort()), void>::value), "");
static_assert((std::is_same<decltype(std::atexit(handler)), int>::value), ""); static_assert((std::is_same<decltype(std::atexit(handler)), int>::value), "");
static_assert((std::is_same<decltype(std::exit(0)), void>::value), ""); static_assert((std::is_same<decltype(std::exit(0)), void>::value), "");
static_assert((std::is_same<decltype(std::_Exit(0)), void>::value), ""); static_assert((std::is_same<decltype(std::_Exit(0)), void>::value), "");
static_assert((std::is_same<decltype(std::getenv("")), char*>::value), ""); static_assert((std::is_same<decltype(std::getenv("")), char*>::value), "");
static_assert((std::is_same<decltype(std::system("")), int>::value), ""); static_assert((std::is_same<decltype(std::system("")), int>::value), "");
Show All 27 Lines

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

Show First 20 Lines • Show All 43 Lines • ▼ Show 20 Lines
public: public:
explicit my_facetw(std::size_t refs = 0) explicit my_facetw(std::size_t refs = 0)
: Fw(refs) {} : Fw(refs) {}
}; };
#endif #endif
int main(int, char**) int main(int, char**)
{ {
std::ios ios(0); std::ios ios(nullptr);
std::string loc_name(LOCALE_en_US_UTF_8); std::string loc_name(LOCALE_en_US_UTF_8);
ios.imbue(std::locale(ios.getloc(), ios.imbue(std::locale(ios.getloc(),
new std::moneypunct_byname<char, false>(loc_name))); new std::moneypunct_byname<char, false>(loc_name)));
ios.imbue(std::locale(ios.getloc(), ios.imbue(std::locale(ios.getloc(),
new std::moneypunct_byname<char, true>(loc_name))); new std::moneypunct_byname<char, true>(loc_name)));
#ifndef TEST_HAS_NO_WIDE_CHARACTERS #ifndef TEST_HAS_NO_WIDE_CHARACTERS
ios.imbue(std::locale(ios.getloc(), ios.imbue(std::locale(ios.getloc(),
new std::moneypunct_byname<wchar_t, false>(loc_name))); new std::moneypunct_byname<wchar_t, false>(loc_name)));
▲ Show 20 Lines • Show All 683 Lines • Show Last 20 Lines

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

Show First 20 Lines • Show All 54 Lines • ▼ Show 20 Lines
static std::wstring convert_thousands_sep(std::wstring const& in) { static std::wstring convert_thousands_sep(std::wstring const& in) {
return LocaleHelpers::convert_thousands_sep_fr_FR(in); return LocaleHelpers::convert_thousands_sep_fr_FR(in);
} }
#endif // TEST_HAS_NO_WIDE_CHARACTERS #endif // TEST_HAS_NO_WIDE_CHARACTERS
int main(int, char**) int main(int, char**)
{ {
std::ios ios(0); std::ios ios(nullptr);
std::string loc_name(LOCALE_fr_FR_UTF_8); std::string loc_name(LOCALE_fr_FR_UTF_8);
ios.imbue(std::locale(ios.getloc(), ios.imbue(std::locale(ios.getloc(),
new std::moneypunct_byname<char, false>(loc_name))); new std::moneypunct_byname<char, false>(loc_name)));
ios.imbue(std::locale(ios.getloc(), ios.imbue(std::locale(ios.getloc(),
new std::moneypunct_byname<char, true>(loc_name))); new std::moneypunct_byname<char, true>(loc_name)));
#ifndef TEST_HAS_NO_WIDE_CHARACTERS #ifndef TEST_HAS_NO_WIDE_CHARACTERS
ios.imbue(std::locale(ios.getloc(), ios.imbue(std::locale(ios.getloc(),
new std::moneypunct_byname<wchar_t, false>(loc_name))); new std::moneypunct_byname<wchar_t, false>(loc_name)));
▲ Show 20 Lines • Show All 673 Lines • Show Last 20 Lines

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

Show First 20 Lines • Show All 52 Lines • ▼ Show 20 Lines
static std::wstring convert_thousands_sep(std::wstring const& in) { static std::wstring convert_thousands_sep(std::wstring const& in) {
return LocaleHelpers::convert_thousands_sep_ru_RU(in); return LocaleHelpers::convert_thousands_sep_ru_RU(in);
} }
#endif // TEST_HAS_NO_WIDE_CHARACTERS #endif // TEST_HAS_NO_WIDE_CHARACTERS
int main(int, char**) int main(int, char**)
{ {
std::ios ios(0); std::ios ios(nullptr);
std::string loc_name(LOCALE_ru_RU_UTF_8); std::string loc_name(LOCALE_ru_RU_UTF_8);
ios.imbue(std::locale(ios.getloc(), ios.imbue(std::locale(ios.getloc(),
new std::moneypunct_byname<char, false>(loc_name))); new std::moneypunct_byname<char, false>(loc_name)));
ios.imbue(std::locale(ios.getloc(), ios.imbue(std::locale(ios.getloc(),
new std::moneypunct_byname<char, true>(loc_name))); new std::moneypunct_byname<char, true>(loc_name)));
#ifndef TEST_HAS_NO_WIDE_CHARACTERS #ifndef TEST_HAS_NO_WIDE_CHARACTERS
ios.imbue(std::locale(ios.getloc(), ios.imbue(std::locale(ios.getloc(),
new std::moneypunct_byname<wchar_t, false>(loc_name))); new std::moneypunct_byname<wchar_t, false>(loc_name)));
▲ Show 20 Lines • Show All 678 Lines • Show Last 20 Lines

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

Show First 20 Lines • Show All 49 Lines • ▼ Show 20 Lines
public: public:
explicit my_facetw(std::size_t refs = 0) explicit my_facetw(std::size_t refs = 0)
: Fw(refs) {} : Fw(refs) {}
}; };
#endif #endif
int main(int, char**) int main(int, char**)
{ {
std::ios ios(0); std::ios ios(nullptr);
std::string loc_name(LOCALE_zh_CN_UTF_8); std::string loc_name(LOCALE_zh_CN_UTF_8);
ios.imbue(std::locale(ios.getloc(), ios.imbue(std::locale(ios.getloc(),
new std::moneypunct_byname<char, false>(loc_name))); new std::moneypunct_byname<char, false>(loc_name)));
ios.imbue(std::locale(ios.getloc(), ios.imbue(std::locale(ios.getloc(),
new std::moneypunct_byname<char, true>(loc_name))); new std::moneypunct_byname<char, true>(loc_name)));
#ifndef TEST_HAS_NO_WIDE_CHARACTERS #ifndef TEST_HAS_NO_WIDE_CHARACTERS
ios.imbue(std::locale(ios.getloc(), ios.imbue(std::locale(ios.getloc(),
new std::moneypunct_byname<wchar_t, false>(loc_name))); new std::moneypunct_byname<wchar_t, false>(loc_name)));
▲ Show 20 Lines • Show All 708 Lines • Show Last 20 Lines

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

Show First 20 Lines • Show All 43 Lines • ▼ Show 20 Lines
public: public:
explicit my_facetw(std::size_t refs = 0) explicit my_facetw(std::size_t refs = 0)
: Fw(refs) {} : Fw(refs) {}
}; };
#endif #endif
int main(int, char**) int main(int, char**)
{ {
std::ios ios(0); std::ios ios(nullptr);
std::string loc_name(LOCALE_en_US_UTF_8); std::string loc_name(LOCALE_en_US_UTF_8);
ios.imbue(std::locale(ios.getloc(), ios.imbue(std::locale(ios.getloc(),
new std::moneypunct_byname<char, false>(loc_name))); new std::moneypunct_byname<char, false>(loc_name)));
ios.imbue(std::locale(ios.getloc(), ios.imbue(std::locale(ios.getloc(),
new std::moneypunct_byname<char, true>(loc_name))); new std::moneypunct_byname<char, true>(loc_name)));
#ifndef TEST_HAS_NO_WIDE_CHARACTERS #ifndef TEST_HAS_NO_WIDE_CHARACTERS
ios.imbue(std::locale(ios.getloc(), ios.imbue(std::locale(ios.getloc(),
new std::moneypunct_byname<wchar_t, false>(loc_name))); new std::moneypunct_byname<wchar_t, false>(loc_name)));
▲ Show 20 Lines • Show All 691 Lines • Show Last 20 Lines

libcxx/test/std/localization/locale.categories/category.monetary/locale.money.put/locale.money.put.members/put_long_double_en_US.pass.cpp

Show First 20 Lines • Show All 42 Lines • ▼ Show 20 Lines
public: public:
explicit my_facetw(std::size_t refs = 0) explicit my_facetw(std::size_t refs = 0)
: Fw(refs) {} : Fw(refs) {}
}; };
#endif #endif
int main(int, char**) int main(int, char**)
{ {
std::ios ios(0); std::ios ios(nullptr);
std::string loc_name(LOCALE_en_US_UTF_8); std::string loc_name(LOCALE_en_US_UTF_8);
ios.imbue(std::locale(ios.getloc(), ios.imbue(std::locale(ios.getloc(),
new std::moneypunct_byname<char, false>(loc_name))); new std::moneypunct_byname<char, false>(loc_name)));
ios.imbue(std::locale(ios.getloc(), ios.imbue(std::locale(ios.getloc(),
new std::moneypunct_byname<char, true>(loc_name))); new std::moneypunct_byname<char, true>(loc_name)));
#ifndef TEST_HAS_NO_WIDE_CHARACTERS #ifndef TEST_HAS_NO_WIDE_CHARACTERS
ios.imbue(std::locale(ios.getloc(), ios.imbue(std::locale(ios.getloc(),
new std::moneypunct_byname<wchar_t, false>(loc_name))); new std::moneypunct_byname<wchar_t, false>(loc_name)));
▲ Show 20 Lines • Show All 526 Lines • Show Last 20 Lines

libcxx/test/std/localization/locale.categories/category.monetary/locale.money.put/locale.money.put.members/put_long_double_fr_FR.pass.cpp

Show First 20 Lines • Show All 54 Lines • ▼ Show 20 Lines
static std::wstring convert_thousands_sep(std::wstring const& in) { static std::wstring convert_thousands_sep(std::wstring const& in) {
return LocaleHelpers::convert_thousands_sep_fr_FR(in); return LocaleHelpers::convert_thousands_sep_fr_FR(in);
} }
#endif // TEST_HAS_NO_WIDE_CHARACTERS #endif // TEST_HAS_NO_WIDE_CHARACTERS
int main(int, char**) int main(int, char**)
{ {
std::ios ios(0); std::ios ios(nullptr);
std::string loc_name(LOCALE_fr_FR_UTF_8); std::string loc_name(LOCALE_fr_FR_UTF_8);
ios.imbue(std::locale(ios.getloc(), ios.imbue(std::locale(ios.getloc(),
new std::moneypunct_byname<char, false>(loc_name))); new std::moneypunct_byname<char, false>(loc_name)));
ios.imbue(std::locale(ios.getloc(), ios.imbue(std::locale(ios.getloc(),
new std::moneypunct_byname<char, true>(loc_name))); new std::moneypunct_byname<char, true>(loc_name)));
#ifndef TEST_HAS_NO_WIDE_CHARACTERS #ifndef TEST_HAS_NO_WIDE_CHARACTERS
ios.imbue(std::locale(ios.getloc(), ios.imbue(std::locale(ios.getloc(),
new std::moneypunct_byname<wchar_t, false>(loc_name))); new std::moneypunct_byname<wchar_t, false>(loc_name)));
▲ Show 20 Lines • Show All 398 Lines • Show Last 20 Lines

libcxx/test/std/localization/locale.categories/category.monetary/locale.money.put/locale.money.put.members/put_long_double_ru_RU.pass.cpp

Show First 20 Lines • Show All 52 Lines • ▼ Show 20 Lines
static std::wstring convert_thousands_sep(std::wstring const& in) { static std::wstring convert_thousands_sep(std::wstring const& in) {
return LocaleHelpers::convert_thousands_sep_ru_RU(in); return LocaleHelpers::convert_thousands_sep_ru_RU(in);
} }
#endif // TEST_HAS_NO_WIDE_CHARACTERS #endif // TEST_HAS_NO_WIDE_CHARACTERS
int main(int, char**) int main(int, char**)
{ {
std::ios ios(0); std::ios ios(nullptr);
std::string loc_name(LOCALE_ru_RU_UTF_8); std::string loc_name(LOCALE_ru_RU_UTF_8);
ios.imbue(std::locale(ios.getloc(), ios.imbue(std::locale(ios.getloc(),
new std::moneypunct_byname<char, false>(loc_name))); new std::moneypunct_byname<char, false>(loc_name)));
ios.imbue(std::locale(ios.getloc(), ios.imbue(std::locale(ios.getloc(),
new std::moneypunct_byname<char, true>(loc_name))); new std::moneypunct_byname<char, true>(loc_name)));
#ifndef TEST_HAS_NO_WIDE_CHARACTERS #ifndef TEST_HAS_NO_WIDE_CHARACTERS
ios.imbue(std::locale(ios.getloc(), ios.imbue(std::locale(ios.getloc(),
new std::moneypunct_byname<wchar_t, false>(loc_name))); new std::moneypunct_byname<wchar_t, false>(loc_name)));
▲ Show 20 Lines • Show All 400 Lines • Show Last 20 Lines

libcxx/test/std/localization/locale.categories/category.monetary/locale.money.put/locale.money.put.members/put_long_double_zh_CN.pass.cpp

Show First 20 Lines • Show All 49 Lines • ▼ Show 20 Lines
public: public:
explicit my_facetw(std::size_t refs = 0) explicit my_facetw(std::size_t refs = 0)
: Fw(refs) {} : Fw(refs) {}
}; };
#endif #endif
int main(int, char**) int main(int, char**)
{ {
std::ios ios(0); std::ios ios(nullptr);
std::string loc_name(LOCALE_zh_CN_UTF_8); std::string loc_name(LOCALE_zh_CN_UTF_8);
ios.imbue(std::locale(ios.getloc(), ios.imbue(std::locale(ios.getloc(),
new std::moneypunct_byname<char, false>(loc_name))); new std::moneypunct_byname<char, false>(loc_name)));
ios.imbue(std::locale(ios.getloc(), ios.imbue(std::locale(ios.getloc(),
new std::moneypunct_byname<char, true>(loc_name))); new std::moneypunct_byname<char, true>(loc_name)));
#ifndef TEST_HAS_NO_WIDE_CHARACTERS #ifndef TEST_HAS_NO_WIDE_CHARACTERS
ios.imbue(std::locale(ios.getloc(), ios.imbue(std::locale(ios.getloc(),
new std::moneypunct_byname<wchar_t, false>(loc_name))); new std::moneypunct_byname<wchar_t, false>(loc_name)));
▲ Show 20 Lines • Show All 453 Lines • Show Last 20 Lines

libcxx/test/std/localization/locale.categories/category.monetary/locale.money.put/locale.money.put.members/put_string_en_US.pass.cpp

Show First 20 Lines • Show All 42 Lines • ▼ Show 20 Lines
public: public:
explicit my_facetw(std::size_t refs = 0) explicit my_facetw(std::size_t refs = 0)
: Fw(refs) {} : Fw(refs) {}
}; };
#endif #endif
int main(int, char**) int main(int, char**)
{ {
std::ios ios(0); std::ios ios(nullptr);
std::string loc_name(LOCALE_en_US_UTF_8); std::string loc_name(LOCALE_en_US_UTF_8);
ios.imbue(std::locale(ios.getloc(), ios.imbue(std::locale(ios.getloc(),
new std::moneypunct_byname<char, false>(loc_name))); new std::moneypunct_byname<char, false>(loc_name)));
ios.imbue(std::locale(ios.getloc(), ios.imbue(std::locale(ios.getloc(),
new std::moneypunct_byname<char, true>(loc_name))); new std::moneypunct_byname<char, true>(loc_name)));
#ifndef TEST_HAS_NO_WIDE_CHARACTERS #ifndef TEST_HAS_NO_WIDE_CHARACTERS
ios.imbue(std::locale(ios.getloc(), ios.imbue(std::locale(ios.getloc(),
new std::moneypunct_byname<wchar_t, false>(loc_name))); new std::moneypunct_byname<wchar_t, false>(loc_name)));
▲ Show 20 Lines • Show All 526 Lines • Show Last 20 Lines

libcxx/test/std/localization/locale.categories/category.numeric/locale.nm.put/facet.num.put.members/put_bool.pass.cpp

Show All 38 Linesprotected:
virtual string_type do_truename() const {return "yes";} virtual string_type do_truename() const {return "yes";}
virtual string_type do_falsename() const {return "no";} virtual string_type do_falsename() const {return "no";}
}; };
int main(int, char**) int main(int, char**)
{ {
const my_facet f(1); const my_facet f(1);
{ {
std::ios ios(0); std::ios ios(nullptr);
{ {
bool v = false; bool v = false;
char str[50]; char str[50];
cpp17_output_iterator<char*> iter = f.put(cpp17_output_iterator<char*>(str), ios, '*', v); cpp17_output_iterator<char*> iter = f.put(cpp17_output_iterator<char*>(str), ios, '*', v);
std::string ex(str, base(iter)); std::string ex(str, base(iter));
assert(ex == "0"); assert(ex == "0");
} }
{ {
bool v = true; bool v = true;
char str[50]; char str[50];
cpp17_output_iterator<char*> iter = f.put(cpp17_output_iterator<char*>(str), ios, '*', v); cpp17_output_iterator<char*> iter = f.put(cpp17_output_iterator<char*>(str), ios, '*', v);
std::string ex(str, base(iter)); std::string ex(str, base(iter));
assert(ex == "1"); assert(ex == "1");
} }
} }
{ {
std::ios ios(0); std::ios ios(nullptr);
std::boolalpha(ios); std::boolalpha(ios);
{ {
bool v = false; bool v = false;
char str[50]; char str[50];
cpp17_output_iterator<char*> iter = f.put(cpp17_output_iterator<char*>(str), ios, '*', v); cpp17_output_iterator<char*> iter = f.put(cpp17_output_iterator<char*>(str), ios, '*', v);
std::string ex(str, base(iter)); std::string ex(str, base(iter));
assert(ex == "false"); assert(ex == "false");
} }
{ {
bool v = true; bool v = true;
char str[50]; char str[50];
cpp17_output_iterator<char*> iter = f.put(cpp17_output_iterator<char*>(str), ios, '*', v); cpp17_output_iterator<char*> iter = f.put(cpp17_output_iterator<char*>(str), ios, '*', v);
std::string ex(str, base(iter)); std::string ex(str, base(iter));
assert(ex == "true"); assert(ex == "true");
} }
} }
{ {
std::ios ios(0); std::ios ios(nullptr);
std::boolalpha(ios); std::boolalpha(ios);
ios.imbue(std::locale(std::locale::classic(), new my_numpunct)); ios.imbue(std::locale(std::locale::classic(), new my_numpunct));
{ {
bool v = false; bool v = false;
char str[50]; char str[50];
cpp17_output_iterator<char*> iter = f.put(cpp17_output_iterator<char*>(str), ios, '*', v); cpp17_output_iterator<char*> iter = f.put(cpp17_output_iterator<char*>(str), ios, '*', v);
std::string ex(str, base(iter)); std::string ex(str, base(iter));
assert(ex == "no"); assert(ex == "no");
Show All 12 Lines

libcxx/test/std/localization/locale.categories/category.numeric/locale.nm.put/facet.num.put.members/put_double.hex.pass.cpp

Show First 20 Lines • Show All 51 Lines • ▼ Show 20 Lines
void test1() void test1()
{ {
char str[200]; char str[200];
std::locale lc = std::locale::classic(); std::locale lc = std::locale::classic();
std::locale lg(lc, new my_numpunct); std::locale lg(lc, new my_numpunct);
const my_facet f(1); const my_facet f(1);
{ {
double v = -0.; double v = -0.;
std::ios ios(0); std::ios ios(nullptr);
std::hexfloat(ios); std::hexfloat(ios);
// %a // %a
{ {
ios.precision(0); ios.precision(0);
{ {
std::nouppercase(ios); std::nouppercase(ios);
{ {
std::noshowpos(ios); std::noshowpos(ios);
▲ Show 20 Lines • Show All 1,772 Lines • ▼ Show 20 Lines
void test2() void test2()
{ {
char str[200]; char str[200];
std::locale lc = std::locale::classic(); std::locale lc = std::locale::classic();
std::locale lg(lc, new my_numpunct); std::locale lg(lc, new my_numpunct);
const my_facet f(1); const my_facet f(1);
{ {
double v = 1234567890.125; double v = 1234567890.125;
std::ios ios(0); std::ios ios(nullptr);
std::hexfloat(ios); std::hexfloat(ios);
// %a // %a
{ {
ios.precision(0); ios.precision(0);
{ {
std::nouppercase(ios); std::nouppercase(ios);
{ {
std::noshowpos(ios); std::noshowpos(ios);
▲ Show 20 Lines • Show All 1,779 Lines • Show Last 20 Lines

libcxx/test/std/localization/locale.categories/category.numeric/locale.nm.put/facet.num.put.members/put_double.pass.cpp

  • This file is larger than 256 KB, so syntax highlighting is disabled by default.
Show First 20 Lines • Show All 46 Lines • ▼ Show 20 Lines
void test1() void test1()
{ {
char str[200]; char str[200];
std::locale lc = std::locale::classic(); std::locale lc = std::locale::classic();
std::locale lg(lc, new my_numpunct); std::locale lg(lc, new my_numpunct);
const my_facet f(1); const my_facet f(1);
{ {
double v = +0.; double v = +0.;
std::ios ios(0); std::ios ios(nullptr);
// %g // %g
{ {
ios.precision(0); ios.precision(0);
{ {
std::nouppercase(ios); std::nouppercase(ios);
{ {
std::noshowpos(ios); std::noshowpos(ios);
{ {
▲ Show 20 Lines • Show All 2,943 Lines • ▼ Show 20 Lines
void test2() void test2()
{ {
char str[200]; char str[200];
std::locale lc = std::locale::classic(); std::locale lc = std::locale::classic();
std::locale lg(lc, new my_numpunct); std::locale lg(lc, new my_numpunct);
const my_facet f(1); const my_facet f(1);
{ {
double v = 1234567890.125; double v = 1234567890.125;
std::ios ios(0); std::ios ios(nullptr);
// %g // %g
{ {
ios.precision(0); ios.precision(0);
{ {
std::nouppercase(ios); std::nouppercase(ios);
{ {
std::noshowpos(ios); std::noshowpos(ios);
{ {
▲ Show 20 Lines • Show All 2,943 Lines • ▼ Show 20 Lines
void test3() void test3()
{ {
char str[200]; char str[200];
std::locale lc = std::locale::classic(); std::locale lc = std::locale::classic();
std::locale lg(lc, new my_numpunct); std::locale lg(lc, new my_numpunct);
const my_facet f(1); const my_facet f(1);
{ {
double v = +0.; double v = +0.;
std::ios ios(0); std::ios ios(nullptr);
std::fixed(ios); std::fixed(ios);
// %f // %f
{ {
ios.precision(0); ios.precision(0);
{ {
std::nouppercase(ios); std::nouppercase(ios);
{ {
std::noshowpos(ios); std::noshowpos(ios);
▲ Show 20 Lines • Show All 2,944 Lines • ▼ Show 20 Lines
void test4() void test4()
{ {
char str[200]; char str[200];
std::locale lc = std::locale::classic(); std::locale lc = std::locale::classic();
std::locale lg(lc, new my_numpunct); std::locale lg(lc, new my_numpunct);
const my_facet f(1); const my_facet f(1);
{ {
double v = 1234567890.125; double v = 1234567890.125;
std::ios ios(0); std::ios ios(nullptr);
std::fixed(ios); std::fixed(ios);
// %f // %f
{ {
ios.precision(0); ios.precision(0);
{ {
std::nouppercase(ios); std::nouppercase(ios);
{ {
std::noshowpos(ios); std::noshowpos(ios);
▲ Show 20 Lines • Show All 1,770 Lines • ▼ Show 20 Lines
void test5() void test5()
{ {
char str[200]; char str[200];
std::locale lc = std::locale::classic(); std::locale lc = std::locale::classic();
std::locale lg(lc, new my_numpunct); std::locale lg(lc, new my_numpunct);
const my_facet f(1); const my_facet f(1);
{ {
double v = -0.; double v = -0.;
std::ios ios(0); std::ios ios(nullptr);
std::scientific(ios); std::scientific(ios);
// %e // %e
{ {
ios.precision(0); ios.precision(0);
{ {
std::nouppercase(ios); std::nouppercase(ios);
{ {
std::noshowpos(ios); std::noshowpos(ios);
▲ Show 20 Lines • Show All 1,772 Lines • ▼ Show 20 Lines
void test6() void test6()
{ {
char str[200]; char str[200];
std::locale lc = std::locale::classic(); std::locale lc = std::locale::classic();
std::locale lg(lc, new my_numpunct); std::locale lg(lc, new my_numpunct);
const my_facet f(1); const my_facet f(1);
{ {
double v = 1234567890.125; double v = 1234567890.125;
std::ios ios(0); std::ios ios(nullptr);
std::scientific(ios); std::scientific(ios);
// %e // %e
{ {
ios.precision(0); ios.precision(0);
{ {
std::nouppercase(ios); std::nouppercase(ios);
{ {
std::noshowpos(ios); std::noshowpos(ios);
▲ Show 20 Lines • Show All 1,783 Lines • Show Last 20 Lines

libcxx/test/std/localization/locale.categories/category.numeric/locale.nm.put/facet.num.put.members/put_long.pass.cpp

Show All 38 Linesprotected:
virtual char_type do_thousands_sep() const {return '_';} virtual char_type do_thousands_sep() const {return '_';}
virtual std::string do_grouping() const {return std::string("\1\2\3");} virtual std::string do_grouping() const {return std::string("\1\2\3");}
}; };
int main(int, char**) int main(int, char**)
{ {
const my_facet f(1); const my_facet f(1);
{ {
std::ios ios(0); std::ios ios(nullptr);
long v = 0; long v = 0;
char str[50]; char str[50];
cpp17_output_iterator<char*> iter = f.put(cpp17_output_iterator<char*>(str), ios, '*', v); cpp17_output_iterator<char*> iter = f.put(cpp17_output_iterator<char*>(str), ios, '*', v);
std::string ex(str, base(iter)); std::string ex(str, base(iter));
assert(ex == "0"); assert(ex == "0");
} }
{ {
std::ios ios(0); std::ios ios(nullptr);
long v = 1; long v = 1;
char str[50]; char str[50];
cpp17_output_iterator<char*> iter = f.put(cpp17_output_iterator<char*>(str), ios, '*', v); cpp17_output_iterator<char*> iter = f.put(cpp17_output_iterator<char*>(str), ios, '*', v);
std::string ex(str, base(iter)); std::string ex(str, base(iter));
assert(ex == "1"); assert(ex == "1");
} }
{ {
std::ios ios(0); std::ios ios(nullptr);
long v = -1; long v = -1;
char str[50]; char str[50];
cpp17_output_iterator<char*> iter = f.put(cpp17_output_iterator<char*>(str), ios, '*', v); cpp17_output_iterator<char*> iter = f.put(cpp17_output_iterator<char*>(str), ios, '*', v);
std::string ex(str, base(iter)); std::string ex(str, base(iter));
assert(ex == "-1"); assert(ex == "-1");
} }
{ {
std::ios ios(0); std::ios ios(nullptr);
long v = -1000; long v = -1000;
char str[50]; char str[50];
cpp17_output_iterator<char*> iter = f.put(cpp17_output_iterator<char*>(str), ios, '*', v); cpp17_output_iterator<char*> iter = f.put(cpp17_output_iterator<char*>(str), ios, '*', v);
std::string ex(str, base(iter)); std::string ex(str, base(iter));
assert(ex == "-1000"); assert(ex == "-1000");
} }
{ {
std::ios ios(0); std::ios ios(nullptr);
long v = 1000; long v = 1000;
char str[50]; char str[50];
cpp17_output_iterator<char*> iter = f.put(cpp17_output_iterator<char*>(str), ios, '*', v); cpp17_output_iterator<char*> iter = f.put(cpp17_output_iterator<char*>(str), ios, '*', v);
std::string ex(str, base(iter)); std::string ex(str, base(iter));
assert(ex == "1000"); assert(ex == "1000");
} }
{ {
std::ios ios(0); std::ios ios(nullptr);
std::showpos(ios); std::showpos(ios);
long v = 1000; long v = 1000;
char str[50]; char str[50];
cpp17_output_iterator<char*> iter = f.put(cpp17_output_iterator<char*>(str), ios, '*', v); cpp17_output_iterator<char*> iter = f.put(cpp17_output_iterator<char*>(str), ios, '*', v);
std::string ex(str, base(iter)); std::string ex(str, base(iter));
assert(ex == "+1000"); assert(ex == "+1000");
} }
{ {
std::ios ios(0); std::ios ios(nullptr);
std::oct(ios); std::oct(ios);
long v = 1000; long v = 1000;
char str[50]; char str[50];
cpp17_output_iterator<char*> iter = f.put(cpp17_output_iterator<char*>(str), ios, '*', v); cpp17_output_iterator<char*> iter = f.put(cpp17_output_iterator<char*>(str), ios, '*', v);
std::string ex(str, base(iter)); std::string ex(str, base(iter));
assert(ex == "1750"); assert(ex == "1750");
} }
{ {
std::ios ios(0); std::ios ios(nullptr);
std::oct(ios); std::oct(ios);
std::showbase(ios); std::showbase(ios);
long v = 1000; long v = 1000;
char str[50]; char str[50];
cpp17_output_iterator<char*> iter = f.put(cpp17_output_iterator<char*>(str), ios, '*', v); cpp17_output_iterator<char*> iter = f.put(cpp17_output_iterator<char*>(str), ios, '*', v);
std::string ex(str, base(iter)); std::string ex(str, base(iter));
assert(ex == "01750"); assert(ex == "01750");
} }
{ {
std::ios ios(0); std::ios ios(nullptr);
std::hex(ios); std::hex(ios);
long v = 1000; long v = 1000;
char str[50]; char str[50];
cpp17_output_iterator<char*> iter = f.put(cpp17_output_iterator<char*>(str), ios, '*', v); cpp17_output_iterator<char*> iter = f.put(cpp17_output_iterator<char*>(str), ios, '*', v);
std::string ex(str, base(iter)); std::string ex(str, base(iter));
assert(ex == "3e8"); assert(ex == "3e8");
} }
{ {
std::ios ios(0); std::ios ios(nullptr);
std::hex(ios); std::hex(ios);
std::showbase(ios); std::showbase(ios);
long v = 1000; long v = 1000;
char str[50]; char str[50];
cpp17_output_iterator<char*> iter = f.put(cpp17_output_iterator<char*>(str), ios, '*', v); cpp17_output_iterator<char*> iter = f.put(cpp17_output_iterator<char*>(str), ios, '*', v);
std::string ex(str, base(iter)); std::string ex(str, base(iter));
assert(ex == "0x3e8"); assert(ex == "0x3e8");
} }
{ {
std::ios ios(0); std::ios ios(nullptr);
std::hex(ios); std::hex(ios);
std::showbase(ios); std::showbase(ios);
std::uppercase(ios); std::uppercase(ios);
long v = 1000; long v = 1000;
char str[50]; char str[50];
cpp17_output_iterator<char*> iter = f.put(cpp17_output_iterator<char*>(str), ios, '*', v); cpp17_output_iterator<char*> iter = f.put(cpp17_output_iterator<char*>(str), ios, '*', v);
std::string ex(str, base(iter)); std::string ex(str, base(iter));
assert(ex == "0X3E8"); assert(ex == "0X3E8");
} }
{ {
std::ios ios(0); std::ios ios(nullptr);
ios.imbue(std::locale(std::locale::classic(), new my_numpunct)); ios.imbue(std::locale(std::locale::classic(), new my_numpunct));
std::hex(ios); std::hex(ios);
std::showbase(ios); std::showbase(ios);
std::uppercase(ios); std::uppercase(ios);
long v = 1000; long v = 1000;
char str[50]; char str[50];
cpp17_output_iterator<char*> iter = f.put(cpp17_output_iterator<char*>(str), ios, '*', v); cpp17_output_iterator<char*> iter = f.put(cpp17_output_iterator<char*>(str), ios, '*', v);
std::string ex(str, base(iter)); std::string ex(str, base(iter));
assert(ex == "0X3E_8"); assert(ex == "0X3E_8");
} }
{ {
std::ios ios(0); std::ios ios(nullptr);
ios.imbue(std::locale(std::locale::classic(), new my_numpunct)); ios.imbue(std::locale(std::locale::classic(), new my_numpunct));
std::hex(ios); std::hex(ios);
std::showbase(ios); std::showbase(ios);
long v = 2147483647; long v = 2147483647;
char str[50]; char str[50];
cpp17_output_iterator<char*> iter = f.put(cpp17_output_iterator<char*>(str), ios, '*', v); cpp17_output_iterator<char*> iter = f.put(cpp17_output_iterator<char*>(str), ios, '*', v);
std::string ex(str, base(iter)); std::string ex(str, base(iter));
assert(ex == "0x7f_fff_ff_f"); assert(ex == "0x7f_fff_ff_f");
} }
{ {
std::ios ios(0); std::ios ios(nullptr);
ios.imbue(std::locale(std::locale::classic(), new my_numpunct)); ios.imbue(std::locale(std::locale::classic(), new my_numpunct));
std::oct(ios); std::oct(ios);
long v = 0123467; long v = 0123467;
char str[50]; char str[50];
cpp17_output_iterator<char*> iter = f.put(cpp17_output_iterator<char*>(str), ios, '*', v); cpp17_output_iterator<char*> iter = f.put(cpp17_output_iterator<char*>(str), ios, '*', v);
std::string ex(str, base(iter)); std::string ex(str, base(iter));
assert(ex == "123_46_7"); assert(ex == "123_46_7");
} }
{ {
std::ios ios(0); std::ios ios(nullptr);
ios.imbue(std::locale(std::locale::classic(), new my_numpunct)); ios.imbue(std::locale(std::locale::classic(), new my_numpunct));
std::oct(ios); std::oct(ios);
std::showbase(ios); std::showbase(ios);
long v = 0123467; long v = 0123467;
char str[50]; char str[50];
cpp17_output_iterator<char*> iter = f.put(cpp17_output_iterator<char*>(str), ios, '*', v); cpp17_output_iterator<char*> iter = f.put(cpp17_output_iterator<char*>(str), ios, '*', v);
std::string ex(str, base(iter)); std::string ex(str, base(iter));
assert(ex == "0_123_46_7"); assert(ex == "0_123_46_7");
} }
{ {
std::ios ios(0); std::ios ios(nullptr);
ios.imbue(std::locale(std::locale::classic(), new my_numpunct)); ios.imbue(std::locale(std::locale::classic(), new my_numpunct));
std::oct(ios); std::oct(ios);
std::showbase(ios); std::showbase(ios);
std::right(ios); std::right(ios);
ios.width(15); ios.width(15);
long v = 0123467; long v = 0123467;
char str[50]; char str[50];
cpp17_output_iterator<char*> iter = f.put(cpp17_output_iterator<char*>(str), ios, '*', v); cpp17_output_iterator<char*> iter = f.put(cpp17_output_iterator<char*>(str), ios, '*', v);
std::string ex(str, base(iter)); std::string ex(str, base(iter));
assert(ex == "*****0_123_46_7"); assert(ex == "*****0_123_46_7");
} }
{ {
std::ios ios(0); std::ios ios(nullptr);
ios.imbue(std::locale(std::locale::classic(), new my_numpunct)); ios.imbue(std::locale(std::locale::classic(), new my_numpunct));
std::oct(ios); std::oct(ios);
std::showbase(ios); std::showbase(ios);
std::left(ios); std::left(ios);
ios.width(15); ios.width(15);
long v = 0123467; long v = 0123467;
char str[50]; char str[50];
cpp17_output_iterator<char*> iter = f.put(cpp17_output_iterator<char*>(str), ios, '*', v); cpp17_output_iterator<char*> iter = f.put(cpp17_output_iterator<char*>(str), ios, '*', v);
std::string ex(str, base(iter)); std::string ex(str, base(iter));
assert(ex == "0_123_46_7*****"); assert(ex == "0_123_46_7*****");
} }
{ {
std::ios ios(0); std::ios ios(nullptr);
ios.imbue(std::locale(std::locale::classic(), new my_numpunct)); ios.imbue(std::locale(std::locale::classic(), new my_numpunct));
std::oct(ios); std::oct(ios);
std::showbase(ios); std::showbase(ios);
std::internal(ios); std::internal(ios);
ios.width(15); ios.width(15);
long v = 0123467; long v = 0123467;
char str[50]; char str[50];
cpp17_output_iterator<char*> iter = f.put(cpp17_output_iterator<char*>(str), ios, '*', v); cpp17_output_iterator<char*> iter = f.put(cpp17_output_iterator<char*>(str), ios, '*', v);
std::string ex(str, base(iter)); std::string ex(str, base(iter));
assert(ex == "*****0_123_46_7"); assert(ex == "*****0_123_46_7");
assert(ios.width() == 0); assert(ios.width() == 0);
} }
{ {
std::ios ios(0); std::ios ios(nullptr);
ios.imbue(std::locale(std::locale::classic(), new my_numpunct)); ios.imbue(std::locale(std::locale::classic(), new my_numpunct));
std::hex(ios); std::hex(ios);
std::showbase(ios); std::showbase(ios);
std::right(ios); std::right(ios);
ios.width(15); ios.width(15);
long v = 2147483647; long v = 2147483647;
char str[50]; char str[50];
cpp17_output_iterator<char*> iter = f.put(cpp17_output_iterator<char*>(str), ios, '*', v); cpp17_output_iterator<char*> iter = f.put(cpp17_output_iterator<char*>(str), ios, '*', v);
std::string ex(str, base(iter)); std::string ex(str, base(iter));
assert(ex == "**0x7f_fff_ff_f"); assert(ex == "**0x7f_fff_ff_f");
} }
{ {
std::ios ios(0); std::ios ios(nullptr);
ios.imbue(std::locale(std::locale::classic(), new my_numpunct)); ios.imbue(std::locale(std::locale::classic(), new my_numpunct));
std::hex(ios); std::hex(ios);
std::showbase(ios); std::showbase(ios);
std::left(ios); std::left(ios);
ios.width(15); ios.width(15);
long v = 2147483647; long v = 2147483647;
char str[50]; char str[50];
cpp17_output_iterator<char*> iter = f.put(cpp17_output_iterator<char*>(str), ios, '*', v); cpp17_output_iterator<char*> iter = f.put(cpp17_output_iterator<char*>(str), ios, '*', v);
std::string ex(str, base(iter)); std::string ex(str, base(iter));
assert(ex == "0x7f_fff_ff_f**"); assert(ex == "0x7f_fff_ff_f**");
} }
{ {
std::ios ios(0); std::ios ios(nullptr);
ios.imbue(std::locale(std::locale::classic(), new my_numpunct)); ios.imbue(std::locale(std::locale::classic(), new my_numpunct));
std::hex(ios); std::hex(ios);
std::showbase(ios); std::showbase(ios);
std::internal(ios); std::internal(ios);
ios.width(15); ios.width(15);
long v = 2147483647; long v = 2147483647;
char str[50]; char str[50];
cpp17_output_iterator<char*> iter = f.put(cpp17_output_iterator<char*>(str), ios, '*', v); cpp17_output_iterator<char*> iter = f.put(cpp17_output_iterator<char*>(str), ios, '*', v);
std::string ex(str, base(iter)); std::string ex(str, base(iter));
assert(ex == "0x**7f_fff_ff_f"); assert(ex == "0x**7f_fff_ff_f");
assert(ios.width() == 0); assert(ios.width() == 0);
} }
{ {
std::ios ios(0); std::ios ios(nullptr);
ios.imbue(std::locale(std::locale::classic(), new my_numpunct)); ios.imbue(std::locale(std::locale::classic(), new my_numpunct));
std::showpos(ios); std::showpos(ios);
long v = 1000; long v = 1000;
std::right(ios); std::right(ios);
ios.width(10); ios.width(10);
char str[50]; char str[50];
cpp17_output_iterator<char*> iter = f.put(cpp17_output_iterator<char*>(str), ios, '*', v); cpp17_output_iterator<char*> iter = f.put(cpp17_output_iterator<char*>(str), ios, '*', v);
std::string ex(str, base(iter)); std::string ex(str, base(iter));
assert(ex == "***+1_00_0"); assert(ex == "***+1_00_0");
assert(ios.width() == 0); assert(ios.width() == 0);
} }
{ {
std::ios ios(0); std::ios ios(nullptr);
ios.imbue(std::locale(std::locale::classic(), new my_numpunct)); ios.imbue(std::locale(std::locale::classic(), new my_numpunct));
std::showpos(ios); std::showpos(ios);
long v = 1000; long v = 1000;
std::left(ios); std::left(ios);
ios.width(10); ios.width(10);
char str[50]; char str[50];
cpp17_output_iterator<char*> iter = f.put(cpp17_output_iterator<char*>(str), ios, '*', v); cpp17_output_iterator<char*> iter = f.put(cpp17_output_iterator<char*>(str), ios, '*', v);
std::string ex(str, base(iter)); std::string ex(str, base(iter));
assert(ex == "+1_00_0***"); assert(ex == "+1_00_0***");
assert(ios.width() == 0); assert(ios.width() == 0);
} }
{ {
std::ios ios(0); std::ios ios(nullptr);
ios.imbue(std::locale(std::locale::classic(), new my_numpunct)); ios.imbue(std::locale(std::locale::classic(), new my_numpunct));
std::showpos(ios); std::showpos(ios);
long v = 1000; long v = 1000;
std::internal(ios); std::internal(ios);
ios.width(10); ios.width(10);
char str[50]; char str[50];
cpp17_output_iterator<char*> iter = f.put(cpp17_output_iterator<char*>(str), ios, '*', v); cpp17_output_iterator<char*> iter = f.put(cpp17_output_iterator<char*>(str), ios, '*', v);
std::string ex(str, base(iter)); std::string ex(str, base(iter));
assert(ex == "+***1_00_0"); assert(ex == "+***1_00_0");
assert(ios.width() == 0); assert(ios.width() == 0);
} }
{ {
std::ios ios(0); std::ios ios(nullptr);
ios.imbue(std::locale(std::locale::classic(), new my_numpunct)); ios.imbue(std::locale(std::locale::classic(), new my_numpunct));
long v = -1000; long v = -1000;
std::right(ios); std::right(ios);
std::showpos(ios); std::showpos(ios);
ios.width(10); ios.width(10);
char str[50]; char str[50];
cpp17_output_iterator<char*> iter = f.put(cpp17_output_iterator<char*>(str), ios, '*', v); cpp17_output_iterator<char*> iter = f.put(cpp17_output_iterator<char*>(str), ios, '*', v);
std::string ex(str, base(iter)); std::string ex(str, base(iter));
assert(ex == "***-1_00_0"); assert(ex == "***-1_00_0");
assert(ios.width() == 0); assert(ios.width() == 0);
} }
{ {
std::ios ios(0); std::ios ios(nullptr);
ios.imbue(std::locale(std::locale::classic(), new my_numpunct)); ios.imbue(std::locale(std::locale::classic(), new my_numpunct));
long v = -1000; long v = -1000;
std::left(ios); std::left(ios);
ios.width(10); ios.width(10);
char str[50]; char str[50];
cpp17_output_iterator<char*> iter = f.put(cpp17_output_iterator<char*>(str), ios, '*', v); cpp17_output_iterator<char*> iter = f.put(cpp17_output_iterator<char*>(str), ios, '*', v);
std::string ex(str, base(iter)); std::string ex(str, base(iter));
assert(ex == "-1_00_0***"); assert(ex == "-1_00_0***");
assert(ios.width() == 0); assert(ios.width() == 0);
} }
{ {
std::ios ios(0); std::ios ios(nullptr);
ios.imbue(std::locale(std::locale::classic(), new my_numpunct)); ios.imbue(std::locale(std::locale::classic(), new my_numpunct));
long v = -1000; long v = -1000;
std::internal(ios); std::internal(ios);
ios.width(10); ios.width(10);
char str[50]; char str[50];
cpp17_output_iterator<char*> iter = f.put(cpp17_output_iterator<char*>(str), ios, '*', v); cpp17_output_iterator<char*> iter = f.put(cpp17_output_iterator<char*>(str), ios, '*', v);
std::string ex(str, base(iter)); std::string ex(str, base(iter));
assert(ex == "-***1_00_0"); assert(ex == "-***1_00_0");
assert(ios.width() == 0); assert(ios.width() == 0);
} }
return 0; return 0;
} }

libcxx/test/std/localization/locale.categories/category.numeric/locale.nm.put/facet.num.put.members/put_long_double.hex.pass.cpp

Show First 20 Lines • Show All 51 Lines • ▼ Show 20 Lines
void test1() void test1()
{ {
char str[200]; char str[200];
std::locale lc = std::locale::classic(); std::locale lc = std::locale::classic();
std::locale lg(lc, new my_numpunct); std::locale lg(lc, new my_numpunct);
const my_facet f(1); const my_facet f(1);
{ {
long double v = -0.; long double v = -0.;
std::ios ios(0); std::ios ios(nullptr);
std::hexfloat(ios); std::hexfloat(ios);
// %a // %a
{ {
ios.precision(0); ios.precision(0);
{ {
std::nouppercase(ios); std::nouppercase(ios);
{ {
std::noshowpos(ios); std::noshowpos(ios);
▲ Show 20 Lines • Show All 1,777 Lines • ▼ Show 20 Lines
// This test is failing on FreeBSD, possibly due to different representations // This test is failing on FreeBSD, possibly due to different representations
// of the floating point numbers. // of the floating point numbers.
// This test is failing in MSVC environments, where long double is equal to regular // This test is failing in MSVC environments, where long double is equal to regular
// double, and instead of "0x9.32c05a44p+27", this prints "0x1.26580b4880000p+30". // double, and instead of "0x9.32c05a44p+27", this prints "0x1.26580b4880000p+30".
const my_facet f(1); const my_facet f(1);
char str[200]; char str[200];
{ {
long double v = 1234567890.125; long double v = 1234567890.125;
std::ios ios(0); std::ios ios(nullptr);
std::hexfloat(ios); std::hexfloat(ios);
// %a // %a
{ {
ios.precision(0); ios.precision(0);
{ {
std::nouppercase(ios); std::nouppercase(ios);
{ {
std::noshowpos(ios); std::noshowpos(ios);
▲ Show 20 Lines • Show All 1,780 Lines • Show Last 20 Lines

libcxx/test/std/localization/locale.categories/category.numeric/locale.nm.put/facet.num.put.members/put_long_double.pass.cpp

  • This file is larger than 256 KB, so syntax highlighting is disabled by default.
Show First 20 Lines • Show All 46 Lines • ▼ Show 20 Lines
void test1() void test1()
{ {
char str[200]; char str[200];
std::locale lc = std::locale::classic(); std::locale lc = std::locale::classic();
std::locale lg(lc, new my_numpunct); std::locale lg(lc, new my_numpunct);
const my_facet f(1); const my_facet f(1);
{ {
long double v = +0.; long double v = +0.;
std::ios ios(0); std::ios ios(nullptr);
// %g // %g
{ {
ios.precision(0); ios.precision(0);
{ {
std::nouppercase(ios); std::nouppercase(ios);
{ {
std::noshowpos(ios); std::noshowpos(ios);
{ {
▲ Show 20 Lines • Show All 2,943 Lines • ▼ Show 20 Lines
void test2() void test2()
{ {
char str[200]; char str[200];
std::locale lc = std::locale::classic(); std::locale lc = std::locale::classic();
std::locale lg(lc, new my_numpunct); std::locale lg(lc, new my_numpunct);
const my_facet f(1); const my_facet f(1);
{ {
long double v = -0.; long double v = -0.;
std::ios ios(0); std::ios ios(nullptr);
// %g // %g
{ {
ios.precision(0); ios.precision(0);
{ {
std::nouppercase(ios); std::nouppercase(ios);
{ {
std::noshowpos(ios); std::noshowpos(ios);
{ {
▲ Show 20 Lines • Show All 2,943 Lines • ▼ Show 20 Lines
void test3() void test3()
{ {
char str[200]; char str[200];
std::locale lc = std::locale::classic(); std::locale lc = std::locale::classic();
std::locale lg(lc, new my_numpunct); std::locale lg(lc, new my_numpunct);
const my_facet f(1); const my_facet f(1);
{ {
long double v = 1234567890.125; long double v = 1234567890.125;
std::ios ios(0); std::ios ios(nullptr);
// %g // %g
{ {
ios.precision(0); ios.precision(0);
{ {
std::nouppercase(ios); std::nouppercase(ios);
{ {
std::noshowpos(ios); std::noshowpos(ios);
{ {
▲ Show 20 Lines • Show All 2,949 Lines • ▼ Show 20 Lines#ifdef _AIX
std::string inf = "INF"; std::string inf = "INF";
#else #else
std::string inf = "inf"; std::string inf = "inf";
#endif #endif
const my_facet f(1); const my_facet f(1);
{ {
long double v = -INFINITY; long double v = -INFINITY;
std::ios ios(0); std::ios ios(nullptr);
// %g // %g
{ {
ios.precision(0); ios.precision(0);
{ {
std::nouppercase(ios); std::nouppercase(ios);
{ {
std::noshowpos(ios); std::noshowpos(ios);
{ {
▲ Show 20 Lines • Show All 1,787 Lines • ▼ Show 20 Lines#if defined(TEST_HAS_GLIBC) || defined(_WIN32)
std::string pnan_padding25 = "*********************"; std::string pnan_padding25 = "*********************";
#else #else
std::string pnan_sign = ""; std::string pnan_sign = "";
std::string pnan_padding25 = "**********************"; std::string pnan_padding25 = "**********************";
#endif #endif
#endif #endif
{ {
long double v = std::nan(""); long double v = std::nan("");
std::ios ios(0); std::ios ios(nullptr);
// %g // %g
{ {
ios.precision(0); ios.precision(0);
{ {
std::nouppercase(ios); std::nouppercase(ios);
{ {
std::noshowpos(ios); std::noshowpos(ios);
{ {
▲ Show 20 Lines • Show All 595 Lines • ▼ Show 20 Lines
void test6() void test6()
{ {
char str[200]; char str[200];
std::locale lc = std::locale::classic(); std::locale lc = std::locale::classic();
std::locale lg(lc, new my_numpunct); std::locale lg(lc, new my_numpunct);
const my_facet f(1); const my_facet f(1);
{ {
long double v = +0.; long double v = +0.;
std::ios ios(0); std::ios ios(nullptr);
std::fixed(ios); std::fixed(ios);
// %f // %f
{ {
ios.precision(0); ios.precision(0);
{ {
std::nouppercase(ios); std::nouppercase(ios);
{ {
std::noshowpos(ios); std::noshowpos(ios);
▲ Show 20 Lines • Show All 2,944 Lines • ▼ Show 20 Lines
void test7() void test7()
{ {
char str[200]; char str[200];
std::locale lc = std::locale::classic(); std::locale lc = std::locale::classic();
std::locale lg(lc, new my_numpunct); std::locale lg(lc, new my_numpunct);
const my_facet f(1); const my_facet f(1);
{ {
long double v = -0.; long double v = -0.;
std::ios ios(0); std::ios ios(nullptr);
std::fixed(ios); std::fixed(ios);
// %f // %f
{ {
ios.precision(0); ios.precision(0);
{ {
std::nouppercase(ios); std::nouppercase(ios);
{ {
std::noshowpos(ios); std::noshowpos(ios);
▲ Show 20 Lines • Show All 2,944 Lines • ▼ Show 20 Lines
void test8() void test8()
{ {
char str[200]; char str[200];
std::locale lc = std::locale::classic(); std::locale lc = std::locale::classic();
std::locale lg(lc, new my_numpunct); std::locale lg(lc, new my_numpunct);
const my_facet f(1); const my_facet f(1);
{ {
long double v = 1234567890.125; long double v = 1234567890.125;
std::ios ios(0); std::ios ios(nullptr);
std::fixed(ios); std::fixed(ios);
// %f // %f
{ {
ios.precision(0); ios.precision(0);
{ {
std::nouppercase(ios); std::nouppercase(ios);
{ {
std::noshowpos(ios); std::noshowpos(ios);
▲ Show 20 Lines • Show All 1,770 Lines • ▼ Show 20 Lines
void test9() void test9()
{ {
char str[200]; char str[200];
std::locale lc = std::locale::classic(); std::locale lc = std::locale::classic();
std::locale lg(lc, new my_numpunct); std::locale lg(lc, new my_numpunct);
const my_facet f(1); const my_facet f(1);
{ {
long double v = -0.; long double v = -0.;
std::ios ios(0); std::ios ios(nullptr);
std::scientific(ios); std::scientific(ios);
// %e // %e
{ {
ios.precision(0); ios.precision(0);
{ {
std::nouppercase(ios); std::nouppercase(ios);
{ {
std::noshowpos(ios); std::noshowpos(ios);
▲ Show 20 Lines • Show All 1,772 Lines • ▼ Show 20 Lines
void test10() void test10()
{ {
char str[200]; char str[200];
std::locale lc = std::locale::classic(); std::locale lc = std::locale::classic();
std::locale lg(lc, new my_numpunct); std::locale lg(lc, new my_numpunct);
const my_facet f(1); const my_facet f(1);
{ {
long double v = 1234567890.125; long double v = 1234567890.125;
std::ios ios(0); std::ios ios(nullptr);
std::scientific(ios); std::scientific(ios);
// %e // %e
{ {
ios.precision(0); ios.precision(0);
{ {
std::nouppercase(ios); std::nouppercase(ios);
{ {
std::noshowpos(ios); std::noshowpos(ios);
▲ Show 20 Lines • Show All 1,812 Lines • Show Last 20 Lines

libcxx/test/std/localization/locale.categories/category.numeric/locale.nm.put/facet.num.put.members/put_long_long.pass.cpp

Show All 38 Linesprotected:
virtual char_type do_thousands_sep() const {return '_';} virtual char_type do_thousands_sep() const {return '_';}
virtual std::string do_grouping() const {return std::string("\1\2\3");} virtual std::string do_grouping() const {return std::string("\1\2\3");}
}; };
int main(int, char**) int main(int, char**)
{ {
const my_facet f(1); const my_facet f(1);
{ {
std::ios ios(0); std::ios ios(nullptr);
long long v = 0; long long v = 0;
char str[50]; char str[50];
cpp17_output_iterator<char*> iter = f.put(cpp17_output_iterator<char*>(str), ios, '*', v); cpp17_output_iterator<char*> iter = f.put(cpp17_output_iterator<char*>(str), ios, '*', v);
std::string ex(str, base(iter)); std::string ex(str, base(iter));
assert(ex == "0"); assert(ex == "0");
} }
{ {
std::ios ios(0); std::ios ios(nullptr);
long long v = 1; long long v = 1;
char str[50]; char str[50];
cpp17_output_iterator<char*> iter = f.put(cpp17_output_iterator<char*>(str), ios, '*', v); cpp17_output_iterator<char*> iter = f.put(cpp17_output_iterator<char*>(str), ios, '*', v);
std::string ex(str, base(iter)); std::string ex(str, base(iter));
assert(ex == "1"); assert(ex == "1");
} }
{ {
std::ios ios(0); std::ios ios(nullptr);
long long v = -1; long long v = -1;
char str[50]; char str[50];
cpp17_output_iterator<char*> iter = f.put(cpp17_output_iterator<char*>(str), ios, '*', v); cpp17_output_iterator<char*> iter = f.put(cpp17_output_iterator<char*>(str), ios, '*', v);
std::string ex(str, base(iter)); std::string ex(str, base(iter));
assert(ex == "-1"); assert(ex == "-1");
} }
{ {
std::ios ios(0); std::ios ios(nullptr);
long long v = -1000; long long v = -1000;
char str[50]; char str[50];
cpp17_output_iterator<char*> iter = f.put(cpp17_output_iterator<char*>(str), ios, '*', v); cpp17_output_iterator<char*> iter = f.put(cpp17_output_iterator<char*>(str), ios, '*', v);
std::string ex(str, base(iter)); std::string ex(str, base(iter));
assert(ex == "-1000"); assert(ex == "-1000");
} }
{ {
std::ios ios(0); std::ios ios(nullptr);
long long v = 1000; long long v = 1000;
char str[50]; char str[50];
cpp17_output_iterator<char*> iter = f.put(cpp17_output_iterator<char*>(str), ios, '*', v); cpp17_output_iterator<char*> iter = f.put(cpp17_output_iterator<char*>(str), ios, '*', v);
std::string ex(str, base(iter)); std::string ex(str, base(iter));
assert(ex == "1000"); assert(ex == "1000");
} }
{ {
std::ios ios(0); std::ios ios(nullptr);
std::showpos(ios); std::showpos(ios);
long long v = 1000; long long v = 1000;
char str[50]; char str[50];
cpp17_output_iterator<char*> iter = f.put(cpp17_output_iterator<char*>(str), ios, '*', v); cpp17_output_iterator<char*> iter = f.put(cpp17_output_iterator<char*>(str), ios, '*', v);
std::string ex(str, base(iter)); std::string ex(str, base(iter));
assert(ex == "+1000"); assert(ex == "+1000");
} }
{ {
std::ios ios(0); std::ios ios(nullptr);
std::oct(ios); std::oct(ios);
long long v = 1000; long long v = 1000;
char str[50]; char str[50];
cpp17_output_iterator<char*> iter = f.put(cpp17_output_iterator<char*>(str), ios, '*', v); cpp17_output_iterator<char*> iter = f.put(cpp17_output_iterator<char*>(str), ios, '*', v);
std::string ex(str, base(iter)); std::string ex(str, base(iter));
assert(ex == "1750"); assert(ex == "1750");
} }
{ {
std::ios ios(0); std::ios ios(nullptr);
std::oct(ios); std::oct(ios);
std::showbase(ios); std::showbase(ios);
long long v = 1000; long long v = 1000;
char str[50]; char str[50];
cpp17_output_iterator<char*> iter = f.put(cpp17_output_iterator<char*>(str), ios, '*', v); cpp17_output_iterator<char*> iter = f.put(cpp17_output_iterator<char*>(str), ios, '*', v);
std::string ex(str, base(iter)); std::string ex(str, base(iter));
assert(ex == "01750"); assert(ex == "01750");
} }
{ {
std::ios ios(0); std::ios ios(nullptr);
std::hex(ios); std::hex(ios);
long long v = 1000; long long v = 1000;
char str[50]; char str[50];
cpp17_output_iterator<char*> iter = f.put(cpp17_output_iterator<char*>(str), ios, '*', v); cpp17_output_iterator<char*> iter = f.put(cpp17_output_iterator<char*>(str), ios, '*', v);
std::string ex(str, base(iter)); std::string ex(str, base(iter));
assert(ex == "3e8"); assert(ex == "3e8");
} }
{ {
std::ios ios(0); std::ios ios(nullptr);
std::hex(ios); std::hex(ios);
std::showbase(ios); std::showbase(ios);
long long v = 1000; long long v = 1000;
char str[50]; char str[50];
cpp17_output_iterator<char*> iter = f.put(cpp17_output_iterator<char*>(str), ios, '*', v); cpp17_output_iterator<char*> iter = f.put(cpp17_output_iterator<char*>(str), ios, '*', v);
std::string ex(str, base(iter)); std::string ex(str, base(iter));
assert(ex == "0x3e8"); assert(ex == "0x3e8");
} }
{ {
std::ios ios(0); std::ios ios(nullptr);
std::hex(ios); std::hex(ios);
std::showbase(ios); std::showbase(ios);
std::uppercase(ios); std::uppercase(ios);
long long v = 1000; long long v = 1000;
char str[50]; char str[50];
cpp17_output_iterator<char*> iter = f.put(cpp17_output_iterator<char*>(str), ios, '*', v); cpp17_output_iterator<char*> iter = f.put(cpp17_output_iterator<char*>(str), ios, '*', v);
std::string ex(str, base(iter)); std::string ex(str, base(iter));
assert(ex == "0X3E8"); assert(ex == "0X3E8");
} }
{ {
std::ios ios(0); std::ios ios(nullptr);
ios.imbue(std::locale(std::locale::classic(), new my_numpunct)); ios.imbue(std::locale(std::locale::classic(), new my_numpunct));
std::hex(ios); std::hex(ios);
std::showbase(ios); std::showbase(ios);
std::uppercase(ios); std::uppercase(ios);
long long v = 1000; long long v = 1000;
char str[50]; char str[50];
cpp17_output_iterator<char*> iter = f.put(cpp17_output_iterator<char*>(str), ios, '*', v); cpp17_output_iterator<char*> iter = f.put(cpp17_output_iterator<char*>(str), ios, '*', v);
std::string ex(str, base(iter)); std::string ex(str, base(iter));
assert(ex == "0X3E_8"); assert(ex == "0X3E_8");
} }
{ {
std::ios ios(0); std::ios ios(nullptr);
ios.imbue(std::locale(std::locale::classic(), new my_numpunct)); ios.imbue(std::locale(std::locale::classic(), new my_numpunct));
std::hex(ios); std::hex(ios);
std::showbase(ios); std::showbase(ios);
long long v = 2147483647; long long v = 2147483647;
char str[50]; char str[50];
cpp17_output_iterator<char*> iter = f.put(cpp17_output_iterator<char*>(str), ios, '*', v); cpp17_output_iterator<char*> iter = f.put(cpp17_output_iterator<char*>(str), ios, '*', v);
std::string ex(str, base(iter)); std::string ex(str, base(iter));
assert(ex == "0x7f_fff_ff_f"); assert(ex == "0x7f_fff_ff_f");
} }
{ {
std::ios ios(0); std::ios ios(nullptr);
ios.imbue(std::locale(std::locale::classic(), new my_numpunct)); ios.imbue(std::locale(std::locale::classic(), new my_numpunct));
std::oct(ios); std::oct(ios);
long long v = 0123467; long long v = 0123467;
char str[50]; char str[50];
cpp17_output_iterator<char*> iter = f.put(cpp17_output_iterator<char*>(str), ios, '*', v); cpp17_output_iterator<char*> iter = f.put(cpp17_output_iterator<char*>(str), ios, '*', v);
std::string ex(str, base(iter)); std::string ex(str, base(iter));
assert(ex == "123_46_7"); assert(ex == "123_46_7");
} }
{ {
std::ios ios(0); std::ios ios(nullptr);
ios.imbue(std::locale(std::locale::classic(), new my_numpunct)); ios.imbue(std::locale(std::locale::classic(), new my_numpunct));
std::oct(ios); std::oct(ios);
std::showbase(ios); std::showbase(ios);
long long v = 0123467; long long v = 0123467;
char str[50]; char str[50];
cpp17_output_iterator<char*> iter = f.put(cpp17_output_iterator<char*>(str), ios, '*', v); cpp17_output_iterator<char*> iter = f.put(cpp17_output_iterator<char*>(str), ios, '*', v);
std::string ex(str, base(iter)); std::string ex(str, base(iter));
assert(ex == "0_123_46_7"); assert(ex == "0_123_46_7");
} }
{ {
std::ios ios(0); std::ios ios(nullptr);
ios.imbue(std::locale(std::locale::classic(), new my_numpunct)); ios.imbue(std::locale(std::locale::classic(), new my_numpunct));
std::oct(ios); std::oct(ios);
std::showbase(ios); std::showbase(ios);
std::right(ios); std::right(ios);
ios.width(15); ios.width(15);
long long v = 0123467; long long v = 0123467;
char str[50]; char str[50];
cpp17_output_iterator<char*> iter = f.put(cpp17_output_iterator<char*>(str), ios, '*', v); cpp17_output_iterator<char*> iter = f.put(cpp17_output_iterator<char*>(str), ios, '*', v);
std::string ex(str, base(iter)); std::string ex(str, base(iter));
assert(ex == "*****0_123_46_7"); assert(ex == "*****0_123_46_7");
} }
{ {
std::ios ios(0); std::ios ios(nullptr);
ios.imbue(std::locale(std::locale::classic(), new my_numpunct)); ios.imbue(std::locale(std::locale::classic(), new my_numpunct));
std::oct(ios); std::oct(ios);
std::showbase(ios); std::showbase(ios);
std::left(ios); std::left(ios);
ios.width(15); ios.width(15);
long long v = 0123467; long long v = 0123467;
char str[50]; char str[50];
cpp17_output_iterator<char*> iter = f.put(cpp17_output_iterator<char*>(str), ios, '*', v); cpp17_output_iterator<char*> iter = f.put(cpp17_output_iterator<char*>(str), ios, '*', v);
std::string ex(str, base(iter)); std::string ex(str, base(iter));
assert(ex == "0_123_46_7*****"); assert(ex == "0_123_46_7*****");
} }
{ {
std::ios ios(0); std::ios ios(nullptr);
ios.imbue(std::locale(std::locale::classic(), new my_numpunct)); ios.imbue(std::locale(std::locale::classic(), new my_numpunct));
std::oct(ios); std::oct(ios);
std::showbase(ios); std::showbase(ios);
std::internal(ios); std::internal(ios);
ios.width(15); ios.width(15);
long long v = 0123467; long long v = 0123467;
char str[50]; char str[50];
cpp17_output_iterator<char*> iter = f.put(cpp17_output_iterator<char*>(str), ios, '*', v); cpp17_output_iterator<char*> iter = f.put(cpp17_output_iterator<char*>(str), ios, '*', v);
std::string ex(str, base(iter)); std::string ex(str, base(iter));
assert(ex == "*****0_123_46_7"); assert(ex == "*****0_123_46_7");
assert(ios.width() == 0); assert(ios.width() == 0);
} }
{ {
std::ios ios(0); std::ios ios(nullptr);
ios.imbue(std::locale(std::locale::classic(), new my_numpunct)); ios.imbue(std::locale(std::locale::classic(), new my_numpunct));
std::hex(ios); std::hex(ios);
std::showbase(ios); std::showbase(ios);
std::right(ios); std::right(ios);
ios.width(15); ios.width(15);
long long v = 2147483647; long long v = 2147483647;
char str[50]; char str[50];
cpp17_output_iterator<char*> iter = f.put(cpp17_output_iterator<char*>(str), ios, '*', v); cpp17_output_iterator<char*> iter = f.put(cpp17_output_iterator<char*>(str), ios, '*', v);
std::string ex(str, base(iter)); std::string ex(str, base(iter));
assert(ex == "**0x7f_fff_ff_f"); assert(ex == "**0x7f_fff_ff_f");
} }
{ {
std::ios ios(0); std::ios ios(nullptr);
ios.imbue(std::locale(std::locale::classic(), new my_numpunct)); ios.imbue(std::locale(std::locale::classic(), new my_numpunct));
std::hex(ios); std::hex(ios);
std::showbase(ios); std::showbase(ios);
std::left(ios); std::left(ios);
ios.width(15); ios.width(15);
long long v = 2147483647; long long v = 2147483647;
char str[50]; char str[50];
cpp17_output_iterator<char*> iter = f.put(cpp17_output_iterator<char*>(str), ios, '*', v); cpp17_output_iterator<char*> iter = f.put(cpp17_output_iterator<char*>(str), ios, '*', v);
std::string ex(str, base(iter)); std::string ex(str, base(iter));
assert(ex == "0x7f_fff_ff_f**"); assert(ex == "0x7f_fff_ff_f**");
} }
{ {
std::ios ios(0); std::ios ios(nullptr);
ios.imbue(std::locale(std::locale::classic(), new my_numpunct)); ios.imbue(std::locale(std::locale::classic(), new my_numpunct));
std::hex(ios); std::hex(ios);
std::showbase(ios); std::showbase(ios);
std::internal(ios); std::internal(ios);
ios.width(15); ios.width(15);
long long v = 2147483647; long long v = 2147483647;
char str[50]; char str[50];
cpp17_output_iterator<char*> iter = f.put(cpp17_output_iterator<char*>(str), ios, '*', v); cpp17_output_iterator<char*> iter = f.put(cpp17_output_iterator<char*>(str), ios, '*', v);
std::string ex(str, base(iter)); std::string ex(str, base(iter));
assert(ex == "0x**7f_fff_ff_f"); assert(ex == "0x**7f_fff_ff_f");
assert(ios.width() == 0); assert(ios.width() == 0);
} }
{ {
std::ios ios(0); std::ios ios(nullptr);
ios.imbue(std::locale(std::locale::classic(), new my_numpunct)); ios.imbue(std::locale(std::locale::classic(), new my_numpunct));
std::showpos(ios); std::showpos(ios);
long long v = 1000; long long v = 1000;
std::right(ios); std::right(ios);
ios.width(10); ios.width(10);
char str[50]; char str[50];
cpp17_output_iterator<char*> iter = f.put(cpp17_output_iterator<char*>(str), ios, '*', v); cpp17_output_iterator<char*> iter = f.put(cpp17_output_iterator<char*>(str), ios, '*', v);
std::string ex(str, base(iter)); std::string ex(str, base(iter));
assert(ex == "***+1_00_0"); assert(ex == "***+1_00_0");
assert(ios.width() == 0); assert(ios.width() == 0);
} }
{ {
std::ios ios(0); std::ios ios(nullptr);
ios.imbue(std::locale(std::locale::classic(), new my_numpunct)); ios.imbue(std::locale(std::locale::classic(), new my_numpunct));
std::showpos(ios); std::showpos(ios);
long long v = 1000; long long v = 1000;
std::left(ios); std::left(ios);
ios.width(10); ios.width(10);
char str[50]; char str[50];
cpp17_output_iterator<char*> iter = f.put(cpp17_output_iterator<char*>(str), ios, '*', v); cpp17_output_iterator<char*> iter = f.put(cpp17_output_iterator<char*>(str), ios, '*', v);
std::string ex(str, base(iter)); std::string ex(str, base(iter));
assert(ex == "+1_00_0***"); assert(ex == "+1_00_0***");
assert(ios.width() == 0); assert(ios.width() == 0);
} }
{ {
std::ios ios(0); std::ios ios(nullptr);
ios.imbue(std::locale(std::locale::classic(), new my_numpunct)); ios.imbue(std::locale(std::locale::classic(), new my_numpunct));
std::showpos(ios); std::showpos(ios);
long long v = 1000; long long v = 1000;
std::internal(ios); std::internal(ios);
ios.width(10); ios.width(10);
char str[50]; char str[50];
cpp17_output_iterator<char*> iter = f.put(cpp17_output_iterator<char*>(str), ios, '*', v); cpp17_output_iterator<char*> iter = f.put(cpp17_output_iterator<char*>(str), ios, '*', v);
std::string ex(str, base(iter)); std::string ex(str, base(iter));
assert(ex == "+***1_00_0"); assert(ex == "+***1_00_0");
assert(ios.width() == 0); assert(ios.width() == 0);
} }
{ {
std::ios ios(0); std::ios ios(nullptr);
ios.imbue(std::locale(std::locale::classic(), new my_numpunct)); ios.imbue(std::locale(std::locale::classic(), new my_numpunct));
long long v = -1000; long long v = -1000;
std::right(ios); std::right(ios);
std::showpos(ios); std::showpos(ios);
ios.width(10); ios.width(10);
char str[50]; char str[50];
cpp17_output_iterator<char*> iter = f.put(cpp17_output_iterator<char*>(str), ios, '*', v); cpp17_output_iterator<char*> iter = f.put(cpp17_output_iterator<char*>(str), ios, '*', v);
std::string ex(str, base(iter)); std::string ex(str, base(iter));
assert(ex == "***-1_00_0"); assert(ex == "***-1_00_0");
assert(ios.width() == 0); assert(ios.width() == 0);
} }
{ {
std::ios ios(0); std::ios ios(nullptr);
ios.imbue(std::locale(std::locale::classic(), new my_numpunct)); ios.imbue(std::locale(std::locale::classic(), new my_numpunct));
long long v = -1000; long long v = -1000;
std::left(ios); std::left(ios);
ios.width(10); ios.width(10);
char str[50]; char str[50];
cpp17_output_iterator<char*> iter = f.put(cpp17_output_iterator<char*>(str), ios, '*', v); cpp17_output_iterator<char*> iter = f.put(cpp17_output_iterator<char*>(str), ios, '*', v);
std::string ex(str, base(iter)); std::string ex(str, base(iter));
assert(ex == "-1_00_0***"); assert(ex == "-1_00_0***");
assert(ios.width() == 0); assert(ios.width() == 0);
} }
{ {
std::ios ios(0); std::ios ios(nullptr);
ios.imbue(std::locale(std::locale::classic(), new my_numpunct)); ios.imbue(std::locale(std::locale::classic(), new my_numpunct));
long long v = -1000; long long v = -1000;
std::internal(ios); std::internal(ios);
ios.width(10); ios.width(10);
char str[50]; char str[50];
cpp17_output_iterator<char*> iter = f.put(cpp17_output_iterator<char*>(str), ios, '*', v); cpp17_output_iterator<char*> iter = f.put(cpp17_output_iterator<char*>(str), ios, '*', v);
std::string ex(str, base(iter)); std::string ex(str, base(iter));
assert(ex == "-***1_00_0"); assert(ex == "-***1_00_0");
assert(ios.width() == 0); assert(ios.width() == 0);
} }
return 0; return 0;
} }

libcxx/test/std/localization/locale.categories/category.numeric/locale.nm.put/facet.num.put.members/put_pointer.pass.cpp

Show All 27 Linespublic:
explicit my_facet(std::size_t refs = 0) explicit my_facet(std::size_t refs = 0)
: F(refs) {} : F(refs) {}
}; };
int main(int, char**) int main(int, char**)
{ {
const my_facet f(1); const my_facet f(1);
{ {
std::ios ios(0); std::ios ios(nullptr);
void* v = 0; void* v = 0;
char str[50]; char str[50];
cpp17_output_iterator<char*> iter = f.put(cpp17_output_iterator<char*>(str), ios, '*', v); cpp17_output_iterator<char*> iter = f.put(cpp17_output_iterator<char*>(str), ios, '*', v);
std::string ex(str, base(iter)); std::string ex(str, base(iter));
char expected_str[32] = {}; char expected_str[32] = {};
// num_put::put uses %p for pointer types, but the exact format of %p is // num_put::put uses %p for pointer types, but the exact format of %p is
// implementation defined behavior for the C library. Compare output to // implementation defined behavior for the C library. Compare output to
// snprintf for portability. // snprintf for portability.
int rc = snprintf(expected_str, sizeof(expected_str), "%p", v); int rc = snprintf(expected_str, sizeof(expected_str), "%p", v);
assert(rc > 0); assert(rc > 0);
assert(ex == expected_str); assert(ex == expected_str);
} }
return 0; return 0;
} }

libcxx/test/std/localization/locale.categories/category.numeric/locale.nm.put/facet.num.put.members/put_unsigned_long.pass.cpp

Show All 38 Linesprotected:
virtual char_type do_thousands_sep() const {return '_';} virtual char_type do_thousands_sep() const {return '_';}
virtual std::string do_grouping() const {return std::string("\1\2\3");} virtual std::string do_grouping() const {return std::string("\1\2\3");}
}; };
int main(int, char**) int main(int, char**)
{ {
const my_facet f(1); const my_facet f(1);
{ {
std::ios ios(0); std::ios ios(nullptr);
unsigned long v = 0; unsigned long v = 0;
char str[50]; char str[50];
cpp17_output_iterator<char*> iter = f.put(cpp17_output_iterator<char*>(str), ios, '*', v); cpp17_output_iterator<char*> iter = f.put(cpp17_output_iterator<char*>(str), ios, '*', v);
std::string ex(str, base(iter)); std::string ex(str, base(iter));
assert(ex == "0"); assert(ex == "0");
} }
{ {
std::ios ios(0); std::ios ios(nullptr);
unsigned long v = 1; unsigned long v = 1;
char str[50]; char str[50];
cpp17_output_iterator<char*> iter = f.put(cpp17_output_iterator<char*>(str), ios, '*', v); cpp17_output_iterator<char*> iter = f.put(cpp17_output_iterator<char*>(str), ios, '*', v);
std::string ex(str, base(iter)); std::string ex(str, base(iter));
assert(ex == "1"); assert(ex == "1");
} }
{ {
std::ios ios(0); std::ios ios(nullptr);
unsigned long v = static_cast<unsigned long>(-1); unsigned long v = static_cast<unsigned long>(-1);
char str[50]; char str[50];
cpp17_output_iterator<char*> iter = f.put(cpp17_output_iterator<char*>(str), ios, '*', v); cpp17_output_iterator<char*> iter = f.put(cpp17_output_iterator<char*>(str), ios, '*', v);
std::string ex(str, base(iter)); std::string ex(str, base(iter));
assert(ex == (sizeof(unsigned long) == 4 ? "4294967295" : "18446744073709551615")); assert(ex == (sizeof(unsigned long) == 4 ? "4294967295" : "18446744073709551615"));
} }
{ {
std::ios ios(0); std::ios ios(nullptr);
unsigned long v = static_cast<unsigned long>(-1000); unsigned long v = static_cast<unsigned long>(-1000);
char str[50]; char str[50];
cpp17_output_iterator<char*> iter = f.put(cpp17_output_iterator<char*>(str), ios, '*', v); cpp17_output_iterator<char*> iter = f.put(cpp17_output_iterator<char*>(str), ios, '*', v);
std::string ex(str, base(iter)); std::string ex(str, base(iter));
assert(ex == (sizeof(unsigned long) == 4 ? "4294966296" : "18446744073709550616")); assert(ex == (sizeof(unsigned long) == 4 ? "4294966296" : "18446744073709550616"));
} }
{ {
std::ios ios(0); std::ios ios(nullptr);
unsigned long v = 1000; unsigned long v = 1000;
char str[50]; char str[50];
cpp17_output_iterator<char*> iter = f.put(cpp17_output_iterator<char*>(str), ios, '*', v); cpp17_output_iterator<char*> iter = f.put(cpp17_output_iterator<char*>(str), ios, '*', v);
std::string ex(str, base(iter)); std::string ex(str, base(iter));
assert(ex == "1000"); assert(ex == "1000");
} }
{ {
std::ios ios(0); std::ios ios(nullptr);
std::showpos(ios); std::showpos(ios);
unsigned long v = 1000; unsigned long v = 1000;
char str[50]; char str[50];
cpp17_output_iterator<char*> iter = f.put(cpp17_output_iterator<char*>(str), ios, '*', v); cpp17_output_iterator<char*> iter = f.put(cpp17_output_iterator<char*>(str), ios, '*', v);
std::string ex(str, base(iter)); std::string ex(str, base(iter));
assert(ex == "1000"); assert(ex == "1000");
} }
{ {
std::ios ios(0); std::ios ios(nullptr);
std::oct(ios); std::oct(ios);
unsigned long v = 1000; unsigned long v = 1000;
char str[50]; char str[50];
cpp17_output_iterator<char*> iter = f.put(cpp17_output_iterator<char*>(str), ios, '*', v); cpp17_output_iterator<char*> iter = f.put(cpp17_output_iterator<char*>(str), ios, '*', v);
std::string ex(str, base(iter)); std::string ex(str, base(iter));
assert(ex == "1750"); assert(ex == "1750");
} }
{ {
std::ios ios(0); std::ios ios(nullptr);
std::oct(ios); std::oct(ios);
std::showbase(ios); std::showbase(ios);
unsigned long v = 1000; unsigned long v = 1000;
char str[50]; char str[50];
cpp17_output_iterator<char*> iter = f.put(cpp17_output_iterator<char*>(str), ios, '*', v); cpp17_output_iterator<char*> iter = f.put(cpp17_output_iterator<char*>(str), ios, '*', v);
std::string ex(str, base(iter)); std::string ex(str, base(iter));
assert(ex == "01750"); assert(ex == "01750");
} }
{ {
std::ios ios(0); std::ios ios(nullptr);
std::hex(ios); std::hex(ios);
unsigned long v = 1000; unsigned long v = 1000;
char str[50]; char str[50];
cpp17_output_iterator<char*> iter = f.put(cpp17_output_iterator<char*>(str), ios, '*', v); cpp17_output_iterator<char*> iter = f.put(cpp17_output_iterator<char*>(str), ios, '*', v);
std::string ex(str, base(iter)); std::string ex(str, base(iter));
assert(ex == "3e8"); assert(ex == "3e8");
} }
{ {
std::ios ios(0); std::ios ios(nullptr);
std::hex(ios); std::hex(ios);
std::showbase(ios); std::showbase(ios);
unsigned long v = 1000; unsigned long v = 1000;
char str[50]; char str[50];
cpp17_output_iterator<char*> iter = f.put(cpp17_output_iterator<char*>(str), ios, '*', v); cpp17_output_iterator<char*> iter = f.put(cpp17_output_iterator<char*>(str), ios, '*', v);
std::string ex(str, base(iter)); std::string ex(str, base(iter));
assert(ex == "0x3e8"); assert(ex == "0x3e8");
} }
{ {
std::ios ios(0); std::ios ios(nullptr);
std::hex(ios); std::hex(ios);
std::showbase(ios); std::showbase(ios);
std::uppercase(ios); std::uppercase(ios);
unsigned long v = 1000; unsigned long v = 1000;
char str[50]; char str[50];
cpp17_output_iterator<char*> iter = f.put(cpp17_output_iterator<char*>(str), ios, '*', v); cpp17_output_iterator<char*> iter = f.put(cpp17_output_iterator<char*>(str), ios, '*', v);
std::string ex(str, base(iter)); std::string ex(str, base(iter));
assert(ex == "0X3E8"); assert(ex == "0X3E8");
} }
{ {
std::ios ios(0); std::ios ios(nullptr);
ios.imbue(std::locale(std::locale::classic(), new my_numpunct)); ios.imbue(std::locale(std::locale::classic(), new my_numpunct));
std::hex(ios); std::hex(ios);
std::showbase(ios); std::showbase(ios);
std::uppercase(ios); std::uppercase(ios);
unsigned long v = 1000; unsigned long v = 1000;
char str[50]; char str[50];
cpp17_output_iterator<char*> iter = f.put(cpp17_output_iterator<char*>(str), ios, '*', v); cpp17_output_iterator<char*> iter = f.put(cpp17_output_iterator<char*>(str), ios, '*', v);
std::string ex(str, base(iter)); std::string ex(str, base(iter));
assert(ex == "0X3E_8"); assert(ex == "0X3E_8");
} }
{ {
std::ios ios(0); std::ios ios(nullptr);
ios.imbue(std::locale(std::locale::classic(), new my_numpunct)); ios.imbue(std::locale(std::locale::classic(), new my_numpunct));
std::hex(ios); std::hex(ios);
std::showbase(ios); std::showbase(ios);
unsigned long v = 2147483647; unsigned long v = 2147483647;
char str[50]; char str[50];
cpp17_output_iterator<char*> iter = f.put(cpp17_output_iterator<char*>(str), ios, '*', v); cpp17_output_iterator<char*> iter = f.put(cpp17_output_iterator<char*>(str), ios, '*', v);
std::string ex(str, base(iter)); std::string ex(str, base(iter));
assert(ex == "0x7f_fff_ff_f"); assert(ex == "0x7f_fff_ff_f");
} }
{ {
std::ios ios(0); std::ios ios(nullptr);
ios.imbue(std::locale(std::locale::classic(), new my_numpunct)); ios.imbue(std::locale(std::locale::classic(), new my_numpunct));
std::oct(ios); std::oct(ios);
unsigned long v = 0123467; unsigned long v = 0123467;
char str[50]; char str[50];
cpp17_output_iterator<char*> iter = f.put(cpp17_output_iterator<char*>(str), ios, '*', v); cpp17_output_iterator<char*> iter = f.put(cpp17_output_iterator<char*>(str), ios, '*', v);
std::string ex(str, base(iter)); std::string ex(str, base(iter));
assert(ex == "123_46_7"); assert(ex == "123_46_7");
} }
{ {
std::ios ios(0); std::ios ios(nullptr);
ios.imbue(std::locale(std::locale::classic(), new my_numpunct)); ios.imbue(std::locale(std::locale::classic(), new my_numpunct));
std::oct(ios); std::oct(ios);
std::showbase(ios); std::showbase(ios);
unsigned long v = 0123467; unsigned long v = 0123467;
char str[50]; char str[50];
cpp17_output_iterator<char*> iter = f.put(cpp17_output_iterator<char*>(str), ios, '*', v); cpp17_output_iterator<char*> iter = f.put(cpp17_output_iterator<char*>(str), ios, '*', v);
std::string ex(str, base(iter)); std::string ex(str, base(iter));
assert(ex == "0_123_46_7"); assert(ex == "0_123_46_7");
} }
{ {
std::ios ios(0); std::ios ios(nullptr);
ios.imbue(std::locale(std::locale::classic(), new my_numpunct)); ios.imbue(std::locale(std::locale::classic(), new my_numpunct));
std::oct(ios); std::oct(ios);
std::showbase(ios); std::showbase(ios);
std::right(ios); std::right(ios);
ios.width(15); ios.width(15);
unsigned long v = 0123467; unsigned long v = 0123467;
char str[50]; char str[50];
cpp17_output_iterator<char*> iter = f.put(cpp17_output_iterator<char*>(str), ios, '*', v); cpp17_output_iterator<char*> iter = f.put(cpp17_output_iterator<char*>(str), ios, '*', v);
std::string ex(str, base(iter)); std::string ex(str, base(iter));
assert(ex == "*****0_123_46_7"); assert(ex == "*****0_123_46_7");
} }
{ {
std::ios ios(0); std::ios ios(nullptr);
ios.imbue(std::locale(std::locale::classic(), new my_numpunct)); ios.imbue(std::locale(std::locale::classic(), new my_numpunct));
std::oct(ios); std::oct(ios);
std::showbase(ios); std::showbase(ios);
std::left(ios); std::left(ios);
ios.width(15); ios.width(15);
unsigned long v = 0123467; unsigned long v = 0123467;
char str[50]; char str[50];
cpp17_output_iterator<char*> iter = f.put(cpp17_output_iterator<char*>(str), ios, '*', v); cpp17_output_iterator<char*> iter = f.put(cpp17_output_iterator<char*>(str), ios, '*', v);
std::string ex(str, base(iter)); std::string ex(str, base(iter));
assert(ex == "0_123_46_7*****"); assert(ex == "0_123_46_7*****");
} }
{ {
std::ios ios(0); std::ios ios(nullptr);
ios.imbue(std::locale(std::locale::classic(), new my_numpunct)); ios.imbue(std::locale(std::locale::classic(), new my_numpunct));
std::oct(ios); std::oct(ios);
std::showbase(ios); std::showbase(ios);
std::internal(ios); std::internal(ios);
ios.width(15); ios.width(15);
unsigned long v = 0123467; unsigned long v = 0123467;
char str[50]; char str[50];
cpp17_output_iterator<char*> iter = f.put(cpp17_output_iterator<char*>(str), ios, '*', v); cpp17_output_iterator<char*> iter = f.put(cpp17_output_iterator<char*>(str), ios, '*', v);
std::string ex(str, base(iter)); std::string ex(str, base(iter));
assert(ex == "*****0_123_46_7"); assert(ex == "*****0_123_46_7");
assert(ios.width() == 0); assert(ios.width() == 0);
} }
{ {
std::ios ios(0); std::ios ios(nullptr);
ios.imbue(std::locale(std::locale::classic(), new my_numpunct)); ios.imbue(std::locale(std::locale::classic(), new my_numpunct));
std::hex(ios); std::hex(ios);
std::showbase(ios); std::showbase(ios);
std::right(ios); std::right(ios);
ios.width(15); ios.width(15);
unsigned long v = 2147483647; unsigned long v = 2147483647;
char str[50]; char str[50];
cpp17_output_iterator<char*> iter = f.put(cpp17_output_iterator<char*>(str), ios, '*', v); cpp17_output_iterator<char*> iter = f.put(cpp17_output_iterator<char*>(str), ios, '*', v);
std::string ex(str, base(iter)); std::string ex(str, base(iter));
assert(ex == "**0x7f_fff_ff_f"); assert(ex == "**0x7f_fff_ff_f");
} }
{ {
std::ios ios(0); std::ios ios(nullptr);
ios.imbue(std::locale(std::locale::classic(), new my_numpunct)); ios.imbue(std::locale(std::locale::classic(), new my_numpunct));
std::hex(ios); std::hex(ios);
std::showbase(ios); std::showbase(ios);
std::left(ios); std::left(ios);
ios.width(15); ios.width(15);
unsigned long v = 2147483647; unsigned long v = 2147483647;
char str[50]; char str[50];
cpp17_output_iterator<char*> iter = f.put(cpp17_output_iterator<char*>(str), ios, '*', v); cpp17_output_iterator<char*> iter = f.put(cpp17_output_iterator<char*>(str), ios, '*', v);
std::string ex(str, base(iter)); std::string ex(str, base(iter));
assert(ex == "0x7f_fff_ff_f**"); assert(ex == "0x7f_fff_ff_f**");
} }
{ {
std::ios ios(0); std::ios ios(nullptr);
ios.imbue(std::locale(std::locale::classic(), new my_numpunct)); ios.imbue(std::locale(std::locale::classic(), new my_numpunct));
std::hex(ios); std::hex(ios);
std::showbase(ios); std::showbase(ios);
std::internal(ios); std::internal(ios);
ios.width(15); ios.width(15);
unsigned long v = 2147483647; unsigned long v = 2147483647;
char str[50]; char str[50];
cpp17_output_iterator<char*> iter = f.put(cpp17_output_iterator<char*>(str), ios, '*', v); cpp17_output_iterator<char*> iter = f.put(cpp17_output_iterator<char*>(str), ios, '*', v);
std::string ex(str, base(iter)); std::string ex(str, base(iter));
assert(ex == "0x**7f_fff_ff_f"); assert(ex == "0x**7f_fff_ff_f");
assert(ios.width() == 0); assert(ios.width() == 0);
} }
{ {
std::ios ios(0); std::ios ios(nullptr);
ios.imbue(std::locale(std::locale::classic(), new my_numpunct)); ios.imbue(std::locale(std::locale::classic(), new my_numpunct));
std::showpos(ios); std::showpos(ios);
unsigned long v = 1000; unsigned long v = 1000;
std::right(ios); std::right(ios);
ios.width(10); ios.width(10);
char str[50]; char str[50];
cpp17_output_iterator<char*> iter = f.put(cpp17_output_iterator<char*>(str), ios, '*', v); cpp17_output_iterator<char*> iter = f.put(cpp17_output_iterator<char*>(str), ios, '*', v);
std::string ex(str, base(iter)); std::string ex(str, base(iter));
assert(ex == "****1_00_0"); assert(ex == "****1_00_0");
assert(ios.width() == 0); assert(ios.width() == 0);
} }
{ {
std::ios ios(0); std::ios ios(nullptr);
ios.imbue(std::locale(std::locale::classic(), new my_numpunct)); ios.imbue(std::locale(std::locale::classic(), new my_numpunct));
std::showpos(ios); std::showpos(ios);
unsigned long v = 1000; unsigned long v = 1000;
std::left(ios); std::left(ios);
ios.width(10); ios.width(10);
char str[50]; char str[50];
cpp17_output_iterator<char*> iter = f.put(cpp17_output_iterator<char*>(str), ios, '*', v); cpp17_output_iterator<char*> iter = f.put(cpp17_output_iterator<char*>(str), ios, '*', v);
std::string ex(str, base(iter)); std::string ex(str, base(iter));
assert(ex == "1_00_0****"); assert(ex == "1_00_0****");
assert(ios.width() == 0); assert(ios.width() == 0);
} }
{ {
std::ios ios(0); std::ios ios(nullptr);
ios.imbue(std::locale(std::locale::classic(), new my_numpunct)); ios.imbue(std::locale(std::locale::classic(), new my_numpunct));
std::showpos(ios); std::showpos(ios);
unsigned long v = 1000; unsigned long v = 1000;
std::internal(ios); std::internal(ios);
ios.width(10); ios.width(10);
char str[50]; char str[50];
cpp17_output_iterator<char*> iter = f.put(cpp17_output_iterator<char*>(str), ios, '*', v); cpp17_output_iterator<char*> iter = f.put(cpp17_output_iterator<char*>(str), ios, '*', v);
std::string ex(str, base(iter)); std::string ex(str, base(iter));
assert(ex == "****1_00_0"); assert(ex == "****1_00_0");
assert(ios.width() == 0); assert(ios.width() == 0);
} }
{ {
std::ios ios(0); std::ios ios(nullptr);
ios.imbue(std::locale(std::locale::classic(), new my_numpunct)); ios.imbue(std::locale(std::locale::classic(), new my_numpunct));
unsigned long v = static_cast<unsigned long>(-1000); unsigned long v = static_cast<unsigned long>(-1000);
std::right(ios); std::right(ios);
std::showpos(ios); std::showpos(ios);
ios.width(10); ios.width(10);
char str[50]; char str[50];
cpp17_output_iterator<char*> iter = f.put(cpp17_output_iterator<char*>(str), ios, '*', v); cpp17_output_iterator<char*> iter = f.put(cpp17_output_iterator<char*>(str), ios, '*', v);
std::string ex(str, base(iter)); std::string ex(str, base(iter));
assert(ex == (sizeof(unsigned long) == 4 ? "4_294_966_29_6" assert(ex == (sizeof(unsigned long) == 4 ? "4_294_966_29_6"
: "18_446_744_073_709_550_61_6")); : "18_446_744_073_709_550_61_6"));
assert(ios.width() == 0); assert(ios.width() == 0);
} }
{ {
std::ios ios(0); std::ios ios(nullptr);
ios.imbue(std::locale(std::locale::classic(), new my_numpunct)); ios.imbue(std::locale(std::locale::classic(), new my_numpunct));
unsigned long v = static_cast<unsigned long>(-1000); unsigned long v = static_cast<unsigned long>(-1000);
std::left(ios); std::left(ios);
ios.width(10); ios.width(10);
char str[50]; char str[50];
cpp17_output_iterator<char*> iter = f.put(cpp17_output_iterator<char*>(str), ios, '*', v); cpp17_output_iterator<char*> iter = f.put(cpp17_output_iterator<char*>(str), ios, '*', v);
std::string ex(str, base(iter)); std::string ex(str, base(iter));
assert(ex == (sizeof(unsigned long) == 4 ? "4_294_966_29_6" assert(ex == (sizeof(unsigned long) == 4 ? "4_294_966_29_6"
: "18_446_744_073_709_550_61_6")); : "18_446_744_073_709_550_61_6"));
assert(ios.width() == 0); assert(ios.width() == 0);
} }
{ {
std::ios ios(0); std::ios ios(nullptr);
ios.imbue(std::locale(std::locale::classic(), new my_numpunct)); ios.imbue(std::locale(std::locale::classic(), new my_numpunct));
unsigned long v = static_cast<unsigned long>(-1000); unsigned long v = static_cast<unsigned long>(-1000);
std::internal(ios); std::internal(ios);
ios.width(10); ios.width(10);
char str[50]; char str[50];
cpp17_output_iterator<char*> iter = f.put(cpp17_output_iterator<char*>(str), ios, '*', v); cpp17_output_iterator<char*> iter = f.put(cpp17_output_iterator<char*>(str), ios, '*', v);
std::string ex(str, base(iter)); std::string ex(str, base(iter));
assert(ex == (sizeof(unsigned long) == 4 ? "4_294_966_29_6" assert(ex == (sizeof(unsigned long) == 4 ? "4_294_966_29_6"
: "18_446_744_073_709_550_61_6")); : "18_446_744_073_709_550_61_6"));
assert(ios.width() == 0); assert(ios.width() == 0);
} }
return 0; return 0;
} }

libcxx/test/std/localization/locale.categories/category.numeric/locale.nm.put/facet.num.put.members/put_unsigned_long_long.pass.cpp

Show All 38 Linesprotected:
virtual char_type do_thousands_sep() const {return '_';} virtual char_type do_thousands_sep() const {return '_';}
virtual std::string do_grouping() const {return std::string("\1\2\3");} virtual std::string do_grouping() const {return std::string("\1\2\3");}
}; };
int main(int, char**) int main(int, char**)
{ {
const my_facet f(1); const my_facet f(1);
{ {
std::ios ios(0); std::ios ios(nullptr);
unsigned long long v = 0; unsigned long long v = 0;
char str[50]; char str[50];
cpp17_output_iterator<char*> iter = f.put(cpp17_output_iterator<char*>(str), ios, '*', v); cpp17_output_iterator<char*> iter = f.put(cpp17_output_iterator<char*>(str), ios, '*', v);
std::string ex(str, base(iter)); std::string ex(str, base(iter));
assert(ex == "0"); assert(ex == "0");
} }
{ {
std::ios ios(0); std::ios ios(nullptr);
unsigned long long v = 1; unsigned long long v = 1;
char str[50]; char str[50];
cpp17_output_iterator<char*> iter = f.put(cpp17_output_iterator<char*>(str), ios, '*', v); cpp17_output_iterator<char*> iter = f.put(cpp17_output_iterator<char*>(str), ios, '*', v);
std::string ex(str, base(iter)); std::string ex(str, base(iter));
assert(ex == "1"); assert(ex == "1");
} }
{ {
std::ios ios(0); std::ios ios(nullptr);
unsigned long long v = static_cast<unsigned long long>(-1); unsigned long long v = static_cast<unsigned long long>(-1);
char str[50]; char str[50];
cpp17_output_iterator<char*> iter = f.put(cpp17_output_iterator<char*>(str), ios, '*', v); cpp17_output_iterator<char*> iter = f.put(cpp17_output_iterator<char*>(str), ios, '*', v);
std::string ex(str, base(iter)); std::string ex(str, base(iter));
assert(ex == "18446744073709551615"); assert(ex == "18446744073709551615");
} }
{ {
std::ios ios(0); std::ios ios(nullptr);
unsigned long long v = static_cast<unsigned long long>(-1000); unsigned long long v = static_cast<unsigned long long>(-1000);
char str[50]; char str[50];
cpp17_output_iterator<char*> iter = f.put(cpp17_output_iterator<char*>(str), ios, '*', v); cpp17_output_iterator<char*> iter = f.put(cpp17_output_iterator<char*>(str), ios, '*', v);
std::string ex(str, base(iter)); std::string ex(str, base(iter));
assert(ex == "18446744073709550616"); assert(ex == "18446744073709550616");
} }
{ {
std::ios ios(0); std::ios ios(nullptr);
unsigned long long v = 1000; unsigned long long v = 1000;
char str[50]; char str[50];
cpp17_output_iterator<char*> iter = f.put(cpp17_output_iterator<char*>(str), ios, '*', v); cpp17_output_iterator<char*> iter = f.put(cpp17_output_iterator<char*>(str), ios, '*', v);
std::string ex(str, base(iter)); std::string ex(str, base(iter));
assert(ex == "1000"); assert(ex == "1000");
} }
{ {
std::ios ios(0); std::ios ios(nullptr);
std::showpos(ios); std::showpos(ios);
unsigned long long v = 1000; unsigned long long v = 1000;
char str[50]; char str[50];
cpp17_output_iterator<char*> iter = f.put(cpp17_output_iterator<char*>(str), ios, '*', v); cpp17_output_iterator<char*> iter = f.put(cpp17_output_iterator<char*>(str), ios, '*', v);
std::string ex(str, base(iter)); std::string ex(str, base(iter));
assert(ex == "1000"); assert(ex == "1000");
} }
{ {
std::ios ios(0); std::ios ios(nullptr);
std::oct(ios); std::oct(ios);
unsigned long long v = 1000; unsigned long long v = 1000;
char str[50]; char str[50];
cpp17_output_iterator<char*> iter = f.put(cpp17_output_iterator<char*>(str), ios, '*', v); cpp17_output_iterator<char*> iter = f.put(cpp17_output_iterator<char*>(str), ios, '*', v);
std::string ex(str, base(iter)); std::string ex(str, base(iter));
assert(ex == "1750"); assert(ex == "1750");
} }
{ {
std::ios ios(0); std::ios ios(nullptr);
std::oct(ios); std::oct(ios);
std::showbase(ios); std::showbase(ios);
unsigned long long v = 1000; unsigned long long v = 1000;
char str[50]; char str[50];
cpp17_output_iterator<char*> iter = f.put(cpp17_output_iterator<char*>(str), ios, '*', v); cpp17_output_iterator<char*> iter = f.put(cpp17_output_iterator<char*>(str), ios, '*', v);
std::string ex(str, base(iter)); std::string ex(str, base(iter));
assert(ex == "01750"); assert(ex == "01750");
} }
{ {
std::ios ios(0); std::ios ios(nullptr);
std::hex(ios); std::hex(ios);
unsigned long long v = 1000; unsigned long long v = 1000;
char str[50]; char str[50];
cpp17_output_iterator<char*> iter = f.put(cpp17_output_iterator<char*>(str), ios, '*', v); cpp17_output_iterator<char*> iter = f.put(cpp17_output_iterator<char*>(str), ios, '*', v);
std::string ex(str, base(iter)); std::string ex(str, base(iter));
assert(ex == "3e8"); assert(ex == "3e8");
} }
{ {
std::ios ios(0); std::ios ios(nullptr);
std::hex(ios); std::hex(ios);
std::showbase(ios); std::showbase(ios);
unsigned long long v = 1000; unsigned long long v = 1000;
char str[50]; char str[50];
cpp17_output_iterator<char*> iter = f.put(cpp17_output_iterator<char*>(str), ios, '*', v); cpp17_output_iterator<char*> iter = f.put(cpp17_output_iterator<char*>(str), ios, '*', v);
std::string ex(str, base(iter)); std::string ex(str, base(iter));
assert(ex == "0x3e8"); assert(ex == "0x3e8");
} }
{ {
std::ios ios(0); std::ios ios(nullptr);
std::hex(ios); std::hex(ios);
std::showbase(ios); std::showbase(ios);
std::uppercase(ios); std::uppercase(ios);
unsigned long long v = 1000; unsigned long long v = 1000;
char str[50]; char str[50];
cpp17_output_iterator<char*> iter = f.put(cpp17_output_iterator<char*>(str), ios, '*', v); cpp17_output_iterator<char*> iter = f.put(cpp17_output_iterator<char*>(str), ios, '*', v);
std::string ex(str, base(iter)); std::string ex(str, base(iter));
assert(ex == "0X3E8"); assert(ex == "0X3E8");
} }
{ {
std::ios ios(0); std::ios ios(nullptr);
ios.imbue(std::locale(std::locale::classic(), new my_numpunct)); ios.imbue(std::locale(std::locale::classic(), new my_numpunct));
std::hex(ios); std::hex(ios);
std::showbase(ios); std::showbase(ios);
std::uppercase(ios); std::uppercase(ios);
unsigned long long v = 1000; unsigned long long v = 1000;
char str[50]; char str[50];
cpp17_output_iterator<char*> iter = f.put(cpp17_output_iterator<char*>(str), ios, '*', v); cpp17_output_iterator<char*> iter = f.put(cpp17_output_iterator<char*>(str), ios, '*', v);
std::string ex(str, base(iter)); std::string ex(str, base(iter));
assert(ex == "0X3E_8"); assert(ex == "0X3E_8");
} }
{ {
std::ios ios(0); std::ios ios(nullptr);
ios.imbue(std::locale(std::locale::classic(), new my_numpunct)); ios.imbue(std::locale(std::locale::classic(), new my_numpunct));
std::hex(ios); std::hex(ios);
std::showbase(ios); std::showbase(ios);
unsigned long long v = 2147483647; unsigned long long v = 2147483647;
char str[50]; char str[50];
cpp17_output_iterator<char*> iter = f.put(cpp17_output_iterator<char*>(str), ios, '*', v); cpp17_output_iterator<char*> iter = f.put(cpp17_output_iterator<char*>(str), ios, '*', v);
std::string ex(str, base(iter)); std::string ex(str, base(iter));
assert(ex == "0x7f_fff_ff_f"); assert(ex == "0x7f_fff_ff_f");
} }
{ {
std::ios ios(0); std::ios ios(nullptr);
ios.imbue(std::locale(std::locale::classic(), new my_numpunct)); ios.imbue(std::locale(std::locale::classic(), new my_numpunct));
std::oct(ios); std::oct(ios);
unsigned long long v = 0123467; unsigned long long v = 0123467;
char str[50]; char str[50];
cpp17_output_iterator<char*> iter = f.put(cpp17_output_iterator<char*>(str), ios, '*', v); cpp17_output_iterator<char*> iter = f.put(cpp17_output_iterator<char*>(str), ios, '*', v);
std::string ex(str, base(iter)); std::string ex(str, base(iter));
assert(ex == "123_46_7"); assert(ex == "123_46_7");
} }
{ {
std::ios ios(0); std::ios ios(nullptr);
ios.imbue(std::locale(std::locale::classic(), new my_numpunct)); ios.imbue(std::locale(std::locale::classic(), new my_numpunct));
std::oct(ios); std::oct(ios);
std::showbase(ios); std::showbase(ios);
unsigned long long v = 0123467; unsigned long long v = 0123467;
char str[50]; char str[50];
cpp17_output_iterator<char*> iter = f.put(cpp17_output_iterator<char*>(str), ios, '*', v); cpp17_output_iterator<char*> iter = f.put(cpp17_output_iterator<char*>(str), ios, '*', v);
std::string ex(str, base(iter)); std::string ex(str, base(iter));
assert(ex == "0_123_46_7"); assert(ex == "0_123_46_7");
} }
{ {
std::ios ios(0); std::ios ios(nullptr);
ios.imbue(std::locale(std::locale::classic(), new my_numpunct)); ios.imbue(std::locale(std::locale::classic(), new my_numpunct));
std::oct(ios); std::oct(ios);
std::showbase(ios); std::showbase(ios);
std::right(ios); std::right(ios);
ios.width(15); ios.width(15);
unsigned long long v = 0123467; unsigned long long v = 0123467;
char str[50]; char str[50];
cpp17_output_iterator<char*> iter = f.put(cpp17_output_iterator<char*>(str), ios, '*', v); cpp17_output_iterator<char*> iter = f.put(cpp17_output_iterator<char*>(str), ios, '*', v);
std::string ex(str, base(iter)); std::string ex(str, base(iter));
assert(ex == "*****0_123_46_7"); assert(ex == "*****0_123_46_7");
} }
{ {
std::ios ios(0); std::ios ios(nullptr);
ios.imbue(std::locale(std::locale::classic(), new my_numpunct)); ios.imbue(std::locale(std::locale::classic(), new my_numpunct));
std::oct(ios); std::oct(ios);
std::showbase(ios); std::showbase(ios);
std::left(ios); std::left(ios);
ios.width(15); ios.width(15);
unsigned long long v = 0123467; unsigned long long v = 0123467;
char str[50]; char str[50];
cpp17_output_iterator<char*> iter = f.put(cpp17_output_iterator<char*>(str), ios, '*', v); cpp17_output_iterator<char*> iter = f.put(cpp17_output_iterator<char*>(str), ios, '*', v);
std::string ex(str, base(iter)); std::string ex(str, base(iter));
assert(ex == "0_123_46_7*****"); assert(ex == "0_123_46_7*****");
} }
{ {
std::ios ios(0); std::ios ios(nullptr);
ios.imbue(std::locale(std::locale::classic(), new my_numpunct)); ios.imbue(std::locale(std::locale::classic(), new my_numpunct));
std::oct(ios); std::oct(ios);
std::showbase(ios); std::showbase(ios);
std::internal(ios); std::internal(ios);
ios.width(15); ios.width(15);
unsigned long long v = 0123467; unsigned long long v = 0123467;
char str[50]; char str[50];
cpp17_output_iterator<char*> iter = f.put(cpp17_output_iterator<char*>(str), ios, '*', v); cpp17_output_iterator<char*> iter = f.put(cpp17_output_iterator<char*>(str), ios, '*', v);
std::string ex(str, base(iter)); std::string ex(str, base(iter));
assert(ex == "*****0_123_46_7"); assert(ex == "*****0_123_46_7");
assert(ios.width() == 0); assert(ios.width() == 0);
} }
{ {
std::ios ios(0); std::ios ios(nullptr);
ios.imbue(std::locale(std::locale::classic(), new my_numpunct)); ios.imbue(std::locale(std::locale::classic(), new my_numpunct));
std::hex(ios); std::hex(ios);
std::showbase(ios); std::showbase(ios);
std::right(ios); std::right(ios);
ios.width(15); ios.width(15);
unsigned long long v = 2147483647; unsigned long long v = 2147483647;
char str[50]; char str[50];
cpp17_output_iterator<char*> iter = f.put(cpp17_output_iterator<char*>(str), ios, '*', v); cpp17_output_iterator<char*> iter = f.put(cpp17_output_iterator<char*>(str), ios, '*', v);
std::string ex(str, base(iter)); std::string ex(str, base(iter));
assert(ex == "**0x7f_fff_ff_f"); assert(ex == "**0x7f_fff_ff_f");
} }
{ {
std::ios ios(0); std::ios ios(nullptr);
ios.imbue(std::locale(std::locale::classic(), new my_numpunct)); ios.imbue(std::locale(std::locale::classic(), new my_numpunct));
std::hex(ios); std::hex(ios);
std::showbase(ios); std::showbase(ios);
std::left(ios); std::left(ios);
ios.width(15); ios.width(15);
unsigned long long v = 2147483647; unsigned long long v = 2147483647;
char str[50]; char str[50];
cpp17_output_iterator<char*> iter = f.put(cpp17_output_iterator<char*>(str), ios, '*', v); cpp17_output_iterator<char*> iter = f.put(cpp17_output_iterator<char*>(str), ios, '*', v);
std::string ex(str, base(iter)); std::string ex(str, base(iter));
assert(ex == "0x7f_fff_ff_f**"); assert(ex == "0x7f_fff_ff_f**");
} }
{ {
std::ios ios(0); std::ios ios(nullptr);
ios.imbue(std::locale(std::locale::classic(), new my_numpunct)); ios.imbue(std::locale(std::locale::classic(), new my_numpunct));
std::hex(ios); std::hex(ios);
std::showbase(ios); std::showbase(ios);
std::internal(ios); std::internal(ios);
ios.width(15); ios.width(15);
unsigned long long v = 2147483647; unsigned long long v = 2147483647;
char str[50]; char str[50];
cpp17_output_iterator<char*> iter = f.put(cpp17_output_iterator<char*>(str), ios, '*', v); cpp17_output_iterator<char*> iter = f.put(cpp17_output_iterator<char*>(str), ios, '*', v);
std::string ex(str, base(iter)); std::string ex(str, base(iter));
assert(ex == "0x**7f_fff_ff_f"); assert(ex == "0x**7f_fff_ff_f");
assert(ios.width() == 0); assert(ios.width() == 0);
} }
{ {
std::ios ios(0); std::ios ios(nullptr);
ios.imbue(std::locale(std::locale::classic(), new my_numpunct)); ios.imbue(std::locale(std::locale::classic(), new my_numpunct));
std::showpos(ios); std::showpos(ios);
unsigned long long v = 1000; unsigned long long v = 1000;
std::right(ios); std::right(ios);
ios.width(10); ios.width(10);
char str[50]; char str[50];
cpp17_output_iterator<char*> iter = f.put(cpp17_output_iterator<char*>(str), ios, '*', v); cpp17_output_iterator<char*> iter = f.put(cpp17_output_iterator<char*>(str), ios, '*', v);
std::string ex(str, base(iter)); std::string ex(str, base(iter));
assert(ex == "****1_00_0"); assert(ex == "****1_00_0");
assert(ios.width() == 0); assert(ios.width() == 0);
} }
{ {
std::ios ios(0); std::ios ios(nullptr);
ios.imbue(std::locale(std::locale::classic(), new my_numpunct)); ios.imbue(std::locale(std::locale::classic(), new my_numpunct));
std::showpos(ios); std::showpos(ios);
unsigned long long v = 1000; unsigned long long v = 1000;
std::left(ios); std::left(ios);
ios.width(10); ios.width(10);
char str[50]; char str[50];
cpp17_output_iterator<char*> iter = f.put(cpp17_output_iterator<char*>(str), ios, '*', v); cpp17_output_iterator<char*> iter = f.put(cpp17_output_iterator<char*>(str), ios, '*', v);
std::string ex(str, base(iter)); std::string ex(str, base(iter));
assert(ex == "1_00_0****"); assert(ex == "1_00_0****");
assert(ios.width() == 0); assert(ios.width() == 0);
} }
{ {
std::ios ios(0); std::ios ios(nullptr);
ios.imbue(std::locale(std::locale::classic(), new my_numpunct)); ios.imbue(std::locale(std::locale::classic(), new my_numpunct));
std::showpos(ios); std::showpos(ios);
unsigned long long v = 1000; unsigned long long v = 1000;
std::internal(ios); std::internal(ios);
ios.width(10); ios.width(10);
char str[50]; char str[50];
cpp17_output_iterator<char*> iter = f.put(cpp17_output_iterator<char*>(str), ios, '*', v); cpp17_output_iterator<char*> iter = f.put(cpp17_output_iterator<char*>(str), ios, '*', v);
std::string ex(str, base(iter)); std::string ex(str, base(iter));
assert(ex == "****1_00_0"); assert(ex == "****1_00_0");
assert(ios.width() == 0); assert(ios.width() == 0);
} }
{ {
std::ios ios(0); std::ios ios(nullptr);
ios.imbue(std::locale(std::locale::classic(), new my_numpunct)); ios.imbue(std::locale(std::locale::classic(), new my_numpunct));
unsigned long long v = static_cast<unsigned long long>(-1000); unsigned long long v = static_cast<unsigned long long>(-1000);
std::right(ios); std::right(ios);
std::showpos(ios); std::showpos(ios);
ios.width(10); ios.width(10);
char str[50]; char str[50];
cpp17_output_iterator<char*> iter = f.put(cpp17_output_iterator<char*>(str), ios, '*', v); cpp17_output_iterator<char*> iter = f.put(cpp17_output_iterator<char*>(str), ios, '*', v);
std::string ex(str, base(iter)); std::string ex(str, base(iter));
assert(ex == "18_446_744_073_709_550_61_6"); assert(ex == "18_446_744_073_709_550_61_6");
assert(ios.width() == 0); assert(ios.width() == 0);
} }
{ {
std::ios ios(0); std::ios ios(nullptr);
ios.imbue(std::locale(std::locale::classic(), new my_numpunct)); ios.imbue(std::locale(std::locale::classic(), new my_numpunct));
unsigned long long v = static_cast<unsigned long long>(-1000); unsigned long long v = static_cast<unsigned long long>(-1000);
std::left(ios); std::left(ios);
ios.width(10); ios.width(10);
char str[50]; char str[50];
cpp17_output_iterator<char*> iter = f.put(cpp17_output_iterator<char*>(str), ios, '*', v); cpp17_output_iterator<char*> iter = f.put(cpp17_output_iterator<char*>(str), ios, '*', v);
std::string ex(str, base(iter)); std::string ex(str, base(iter));
assert(ex == "18_446_744_073_709_550_61_6"); assert(ex == "18_446_744_073_709_550_61_6");
assert(ios.width() == 0); assert(ios.width() == 0);
} }
{ {
std::ios ios(0); std::ios ios(nullptr);
ios.imbue(std::locale(std::locale::classic(), new my_numpunct)); ios.imbue(std::locale(std::locale::classic(), new my_numpunct));
unsigned long long v = static_cast<unsigned long long>(-1000); unsigned long long v = static_cast<unsigned long long>(-1000);
std::internal(ios); std::internal(ios);
ios.width(10); ios.width(10);
char str[50]; char str[50];
cpp17_output_iterator<char*> iter = f.put(cpp17_output_iterator<char*>(str), ios, '*', v); cpp17_output_iterator<char*> iter = f.put(cpp17_output_iterator<char*>(str), ios, '*', v);
std::string ex(str, base(iter)); std::string ex(str, base(iter));
assert(ex == "18_446_744_073_709_550_61_6"); assert(ex == "18_446_744_073_709_550_61_6");
assert(ios.width() == 0); assert(ios.width() == 0);
} }
return 0; return 0;
} }

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

Show First 20 Lines • Show All 49 Lines • ▼ Show 20 Lines
protected: protected:
virtual string_type do_truename() const {return "a";} virtual string_type do_truename() const {return "a";}
virtual string_type do_falsename() const {return "ab";} virtual string_type do_falsename() const {return "ab";}
}; };
int main(int, char**) int main(int, char**)
{ {
const my_facet f(1); const my_facet f(1);
std::ios ios(0); std::ios ios(nullptr);
{ {
const char str[] = "1"; const char str[] = "1";
std::ios_base::iostate err = ios.goodbit; std::ios_base::iostate err = ios.goodbit;
bool b; bool b;
cpp17_input_iterator<const char*> iter = cpp17_input_iterator<const char*> iter =
f.get(cpp17_input_iterator<const char*>(str), f.get(cpp17_input_iterator<const char*>(str),
cpp17_input_iterator<const char*>(str+sizeof(str)), cpp17_input_iterator<const char*>(str+sizeof(str)),
ios, err, b); ios, err, b);
▲ Show 20 Lines • Show All 166 Lines • Show Last 20 Lines

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

Show First 20 Lines • Show All 41 Lines • ▼ Show 20 Linesprotected:
virtual char_type do_decimal_point() const {return ';';} virtual char_type do_decimal_point() const {return ';';}
virtual char_type do_thousands_sep() const {return '_';} virtual char_type do_thousands_sep() const {return '_';}
virtual std::string do_grouping() const {return std::string("\1\2\3");} virtual std::string do_grouping() const {return std::string("\1\2\3");}
}; };
int main(int, char**) int main(int, char**)
{ {
const my_facet f(1); const my_facet f(1);
std::ios ios(0); std::ios ios(nullptr);
double v = -1; double v = -1;
{ {
const char str[] = "123"; const char str[] = "123";
assert((ios.flags() & ios.basefield) == ios.dec); assert((ios.flags() & ios.basefield) == ios.dec);
assert(ios.getloc().name() == "C"); assert(ios.getloc().name() == "C");
std::ios_base::iostate err = ios.goodbit; std::ios_base::iostate err = ios.goodbit;
cpp17_input_iterator<const char*> iter = cpp17_input_iterator<const char*> iter =
f.get(cpp17_input_iterator<const char*>(str), f.get(cpp17_input_iterator<const char*>(str),
▲ Show 20 Lines • Show All 223 Lines • Show Last 20 Lines

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

Show All 30 Linespublic:
explicit my_facet(std::size_t refs = 0) explicit my_facet(std::size_t refs = 0)
: F(refs) {} : F(refs) {}
}; };
int main(int, char**) int main(int, char**)
{ {
const my_facet f(1); const my_facet f(1);
std::ios ios(0); std::ios ios(nullptr);
float v = -1; float v = -1;
{ {
const char str[] = "123"; const char str[] = "123";
assert((ios.flags() & ios.basefield) == ios.dec); assert((ios.flags() & ios.basefield) == ios.dec);
assert(ios.getloc().name() == "C"); assert(ios.getloc().name() == "C");
std::ios_base::iostate err = ios.goodbit; std::ios_base::iostate err = ios.goodbit;
cpp17_input_iterator<const char*> iter = cpp17_input_iterator<const char*> iter =
f.get(cpp17_input_iterator<const char*>(str), f.get(cpp17_input_iterator<const char*>(str),
▲ Show 20 Lines • Show All 164 Lines • Show Last 20 Lines

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

Show First 20 Lines • Show All 43 Lines • ▼ Show 20 Lines
protected: protected:
virtual char_type do_thousands_sep() const {return '_';} virtual char_type do_thousands_sep() const {return '_';}
virtual std::string do_grouping() const {return std::string("\1\2\3");} virtual std::string do_grouping() const {return std::string("\1\2\3");}
}; };
int main(int, char**) int main(int, char**)
{ {
const my_facet f(1); const my_facet f(1);
std::ios ios(0); std::ios ios(nullptr);
long v = -1; long v = -1;
const std::ios_base::fmtflags zf = static_cast<std::ios_base::fmtflags>(0); const std::ios_base::fmtflags zf = static_cast<std::ios_base::fmtflags>(0);
{ {
const char str[] = "123"; const char str[] = "123";
assert((ios.flags() & ios.basefield) == ios.dec); assert((ios.flags() & ios.basefield) == ios.dec);
assert(ios.getloc().name() == "C"); assert(ios.getloc().name() == "C");
std::ios_base::iostate err = ios.goodbit; std::ios_base::iostate err = ios.goodbit;
cpp17_input_iterator<const char*> iter = cpp17_input_iterator<const char*> iter =
▲ Show 20 Lines • Show All 468 Lines • Show Last 20 Lines

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

Show All 30 Linespublic:
explicit my_facet(std::size_t refs = 0) explicit my_facet(std::size_t refs = 0)
: F(refs) {} : F(refs) {}
}; };
int main(int, char**) int main(int, char**)
{ {
const my_facet f(1); const my_facet f(1);
std::ios ios(0); std::ios ios(nullptr);
long double v = -1; long double v = -1;
{ {
const char str[] = "123"; const char str[] = "123";
assert((ios.flags() & ios.basefield) == ios.dec); assert((ios.flags() & ios.basefield) == ios.dec);
assert(ios.getloc().name() == "C"); assert(ios.getloc().name() == "C");
std::ios_base::iostate err = ios.goodbit; std::ios_base::iostate err = ios.goodbit;
cpp17_input_iterator<const char*> iter = cpp17_input_iterator<const char*> iter =
f.get(cpp17_input_iterator<const char*>(str), f.get(cpp17_input_iterator<const char*>(str),
▲ Show 20 Lines • Show All 223 Lines • Show Last 20 Lines

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

Show All 38 Lines
protected: protected:
virtual char_type do_thousands_sep() const {return '_';} virtual char_type do_thousands_sep() const {return '_';}
virtual std::string do_grouping() const {return std::string("\1\2\3");} virtual std::string do_grouping() const {return std::string("\1\2\3");}
}; };
int main(int, char**) int main(int, char**)
{ {
const my_facet f(1); const my_facet f(1);
std::ios ios(0); std::ios ios(nullptr);
long long v = -1; long long v = -1;
{ {
const char str[] = "0"; const char str[] = "0";
std::ios_base::iostate err = ios.goodbit; std::ios_base::iostate err = ios.goodbit;
cpp17_input_iterator<const char*> iter = cpp17_input_iterator<const char*> iter =
f.get(cpp17_input_iterator<const char*>(str), f.get(cpp17_input_iterator<const char*>(str),
cpp17_input_iterator<const char*>(str+sizeof(str)), cpp17_input_iterator<const char*>(str+sizeof(str)),
ios, err, v); ios, err, v);
▲ Show 20 Lines • Show All 53 Lines • Show Last 20 Lines

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

Show All 27 Lines
public: public:
explicit my_facet(std::size_t refs = 0) explicit my_facet(std::size_t refs = 0)
: F(refs) {} : F(refs) {}
}; };
int main(int, char**) int main(int, char**)
{ {
const my_facet f(1); const my_facet f(1);
std::ios ios(0); std::ios ios(nullptr);
{ {
const char str[] = "0x0"; const char str[] = "0x0";
std::ios_base::iostate err = ios.goodbit; std::ios_base::iostate err = ios.goodbit;
void* p; void* p;
cpp17_input_iterator<const char*> iter = cpp17_input_iterator<const char*> iter =
f.get(cpp17_input_iterator<const char*>(str), f.get(cpp17_input_iterator<const char*>(str),
cpp17_input_iterator<const char*>(str+sizeof(str)), cpp17_input_iterator<const char*>(str+sizeof(str)),
ios, err, p); ios, err, p);
Show All 19 Lines

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

Show All 38 Lines
protected: protected:
virtual char_type do_thousands_sep() const {return '_';} virtual char_type do_thousands_sep() const {return '_';}
virtual std::string do_grouping() const {return std::string("\1\2\3");} virtual std::string do_grouping() const {return std::string("\1\2\3");}
}; };
int main(int, char**) int main(int, char**)
{ {
const my_facet f(1); const my_facet f(1);
std::ios ios(0); std::ios ios(nullptr);
unsigned int v = static_cast<unsigned int>(-1); unsigned int v = static_cast<unsigned int>(-1);
{ {
const char str[] = "0"; const char str[] = "0";
std::ios_base::iostate err = ios.goodbit; std::ios_base::iostate err = ios.goodbit;
cpp17_input_iterator<const char*> iter = cpp17_input_iterator<const char*> iter =
f.get(cpp17_input_iterator<const char*>(str), f.get(cpp17_input_iterator<const char*>(str),
cpp17_input_iterator<const char*>(str+sizeof(str)), cpp17_input_iterator<const char*>(str+sizeof(str)),
ios, err, v); ios, err, v);
Show All 30 Lines

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

Show All 38 Lines
protected: protected:
virtual char_type do_thousands_sep() const {return '_';} virtual char_type do_thousands_sep() const {return '_';}
virtual std::string do_grouping() const {return std::string("\1\2\3");} virtual std::string do_grouping() const {return std::string("\1\2\3");}
}; };
int main(int, char**) int main(int, char**)
{ {
const my_facet f(1); const my_facet f(1);
std::ios ios(0); std::ios ios(nullptr);
unsigned long v = static_cast<unsigned long>(-1); unsigned long v = static_cast<unsigned long>(-1);
{ {
const char str[] = "0"; const char str[] = "0";
std::ios_base::iostate err = ios.goodbit; std::ios_base::iostate err = ios.goodbit;
cpp17_input_iterator<const char*> iter = cpp17_input_iterator<const char*> iter =
f.get(cpp17_input_iterator<const char*>(str), f.get(cpp17_input_iterator<const char*>(str),
cpp17_input_iterator<const char*>(str+sizeof(str)), cpp17_input_iterator<const char*>(str+sizeof(str)),
ios, err, v); ios, err, v);
Show All 30 Lines

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

Show All 38 Lines
protected: protected:
virtual char_type do_thousands_sep() const {return '_';} virtual char_type do_thousands_sep() const {return '_';}
virtual std::string do_grouping() const {return std::string("\1\2\3");} virtual std::string do_grouping() const {return std::string("\1\2\3");}
}; };
int main(int, char**) int main(int, char**)
{ {
const my_facet f(1); const my_facet f(1);
std::ios ios(0); std::ios ios(nullptr);
unsigned long long v = static_cast<unsigned long long>(-1); unsigned long long v = static_cast<unsigned long long>(-1);
{ {
const char str[] = "0"; const char str[] = "0";
std::ios_base::iostate err = ios.goodbit; std::ios_base::iostate err = ios.goodbit;
cpp17_input_iterator<const char*> iter = cpp17_input_iterator<const char*> iter =
f.get(cpp17_input_iterator<const char*>(str), f.get(cpp17_input_iterator<const char*>(str),
cpp17_input_iterator<const char*>(str+sizeof(str)), cpp17_input_iterator<const char*>(str+sizeof(str)),
ios, err, v); ios, err, v);
Show All 30 Lines

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

Show All 38 Lines
protected: protected:
virtual char_type do_thousands_sep() const {return '_';} virtual char_type do_thousands_sep() const {return '_';}
virtual std::string do_grouping() const {return std::string("\1\2\3");} virtual std::string do_grouping() const {return std::string("\1\2\3");}
}; };
int main(int, char**) int main(int, char**)
{ {
const my_facet f(1); const my_facet f(1);
std::ios ios(0); std::ios ios(nullptr);
unsigned short v = static_cast<unsigned short>(-1); unsigned short v = static_cast<unsigned short>(-1);
{ {
const char str[] = "0"; const char str[] = "0";
std::ios_base::iostate err = ios.goodbit; std::ios_base::iostate err = ios.goodbit;
cpp17_input_iterator<const char*> iter = cpp17_input_iterator<const char*> iter =
f.get(cpp17_input_iterator<const char*>(str), f.get(cpp17_input_iterator<const char*>(str),
cpp17_input_iterator<const char*>(str+sizeof(str)), cpp17_input_iterator<const char*>(str+sizeof(str)),
ios, err, v); ios, err, v);
Show All 30 Lines

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

Show All 40 Linesstd::string make_neg_string(T value) {
assert(ss << value); assert(ss << value);
std::string res = ss.str(); std::string res = ss.str();
return '-' + res; return '-' + res;
} }
template <class T> template <class T>
void test_neg_one() { void test_neg_one() {
const my_facet f(1); const my_facet f(1);
std::ios ios(0); std::ios ios(nullptr);
T v = static_cast<T>(42); T v = static_cast<T>(42);
{ {
const char str[] = "-1"; const char str[] = "-1";
std::ios_base::iostate err = ios.goodbit; std::ios_base::iostate err = ios.goodbit;
cpp17_input_iterator<const char*> iter = cpp17_input_iterator<const char*> iter =
f.get(cpp17_input_iterator<const char*>(str), f.get(cpp17_input_iterator<const char*>(str),
cpp17_input_iterator<const char*>(str+sizeof(str)), cpp17_input_iterator<const char*>(str+sizeof(str)),
ios, err, v); ios, err, v);
Show All 14 Lines v = 42;
assert(v == 0); assert(v == 0);
} }
} }
template <class T> template <class T>
void test_negate() { void test_negate() {
typedef typename std::make_signed<T>::type SignedT; typedef typename std::make_signed<T>::type SignedT;
const my_facet f(1); const my_facet f(1);
std::ios ios(0); std::ios ios(nullptr);
T v = 42; T v = 42;
{ {
T value = std::numeric_limits<SignedT>::max(); T value = std::numeric_limits<SignedT>::max();
++value; ++value;
std::string std_str = make_neg_string(value); std::string std_str = make_neg_string(value);
const char* str = std_str.data(); const char* str = std_str.data();
size_t size = std_str.size(); size_t size = std_str.size();
std::ios_base::iostate err = ios.goodbit; std::ios_base::iostate err = ios.goodbit;
▲ Show 20 Lines • Show All 76 Lines • Show Last 20 Lines

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

Show All 37 Lines
{ {
public: public:
explicit my_facet(const std::string& nm, std::size_t refs = 0) explicit my_facet(const std::string& nm, std::size_t refs = 0)
: F(nm, refs) {} : F(nm, refs) {}
}; };
int main(int, char**) int main(int, char**)
{ {
std::ios ios(0); std::ios ios(nullptr);
std::ios_base::iostate err; std::ios_base::iostate err;
std::tm t; std::tm t;
{ {
const my_facet f(LOCALE_en_US_UTF_8, 1); const my_facet f(LOCALE_en_US_UTF_8, 1);
const char in[] = "06/10/2009"; const char in[] = "06/10/2009";
err = std::ios_base::goodbit; err = std::ios_base::goodbit;
t = std::tm(); t = std::tm();
I i = f.get_date(I(in), I(in+sizeof(in)/sizeof(in[0])-1), ios, err, &t); I i = f.get_date(I(in), I(in+sizeof(in)/sizeof(in[0])-1), ios, err, &t);
▲ Show 20 Lines • Show All 105 Lines • Show Last 20 Lines

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

Show All 39 Lines
{ {
public: public:
explicit my_facet(const std::string& nm, std::size_t refs = 0) explicit my_facet(const std::string& nm, std::size_t refs = 0)
: F(nm, refs) {} : F(nm, refs) {}
}; };
int main(int, char**) int main(int, char**)
{ {
std::ios ios(0); std::ios ios(nullptr);
std::ios_base::iostate err; std::ios_base::iostate err;
std::tm t; std::tm t;
{ {
const my_facet f(LOCALE_en_US_UTF_8, 1); const my_facet f(LOCALE_en_US_UTF_8, 1);
const wchar_t in[] = L"06/10/2009"; const wchar_t in[] = L"06/10/2009";
err = std::ios_base::goodbit; err = std::ios_base::goodbit;
t = std::tm(); t = std::tm();
I i = f.get_date(I(in), I(in+sizeof(in)/sizeof(in[0])-1), ios, err, &t); I i = f.get_date(I(in), I(in+sizeof(in)/sizeof(in[0])-1), ios, err, &t);
▲ Show 20 Lines • Show All 53 Lines • Show Last 20 Lines

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

Show All 35 Lines
{ {
public: public:
explicit my_facet(const std::string& nm, std::size_t refs = 0) explicit my_facet(const std::string& nm, std::size_t refs = 0)
: F(nm, refs) {} : F(nm, refs) {}
}; };
int main(int, char**) int main(int, char**)
{ {
std::ios ios(0); std::ios ios(nullptr);
std::ios_base::iostate err; std::ios_base::iostate err;
std::tm t; std::tm t;
{ {
const my_facet f(LOCALE_en_US_UTF_8, 1); const my_facet f(LOCALE_en_US_UTF_8, 1);
const char in[] = "June"; const char in[] = "June";
err = std::ios_base::goodbit; err = std::ios_base::goodbit;
t = std::tm(); t = std::tm();
I i = f.get_monthname(I(in), I(in+sizeof(in)/sizeof(in[0])-1), ios, err, &t); I i = f.get_monthname(I(in), I(in+sizeof(in)/sizeof(in[0])-1), ios, err, &t);
Show All 27 Lines

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

Show First 20 Lines • Show All 45 Lines • ▼ Show 20 Lines
{ {
public: public:
explicit my_facet2(const std::string& nm, std::size_t refs = 0) explicit my_facet2(const std::string& nm, std::size_t refs = 0)
: F2(nm, refs) {} : F2(nm, refs) {}
}; };
int main(int, char**) int main(int, char**)
{ {
std::ios ios(0); std::ios ios(nullptr);
std::ios_base::iostate err; std::ios_base::iostate err;
std::tm t; std::tm t;
{ {
const my_facet f(LOCALE_en_US_UTF_8, 1); const my_facet f(LOCALE_en_US_UTF_8, 1);
const wchar_t in[] = L"June"; const wchar_t in[] = L"June";
err = std::ios_base::goodbit; err = std::ios_base::goodbit;
t = std::tm(); t = std::tm();
I i = f.get_monthname(I(in), I(in+sizeof(in)/sizeof(in[0])-1), ios, err, &t); I i = f.get_monthname(I(in), I(in+sizeof(in)/sizeof(in[0])-1), ios, err, &t);
Show All 27 Lines

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

Show All 38 Lines
{ {
public: public:
explicit my_facet(const std::string& nm, std::size_t refs = 0) explicit my_facet(const std::string& nm, std::size_t refs = 0)
: F(nm, refs) {} : F(nm, refs) {}
}; };
int main(int, char**) int main(int, char**)
{ {
std::ios ios(0); std::ios ios(nullptr);
std::ios_base::iostate err; std::ios_base::iostate err;
std::tm t; std::tm t;
{ {
const my_facet f(LOCALE_en_US_UTF_8, 1); const my_facet f(LOCALE_en_US_UTF_8, 1);
#ifdef _WIN32 #ifdef _WIN32
// On Windows, the "%c" format lacks the leading week day, which // On Windows, the "%c" format lacks the leading week day, which
// means that t.tm_wday doesn't get set when parsing the string. // means that t.tm_wday doesn't get set when parsing the string.
const char in[] = "12/31/2061 11:55:59 PM"; const char in[] = "12/31/2061 11:55:59 PM";
▲ Show 20 Lines • Show All 186 Lines • Show Last 20 Lines

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

Show All 40 Lines
{ {
public: public:
explicit my_facet(const std::string& nm, std::size_t refs = 0) explicit my_facet(const std::string& nm, std::size_t refs = 0)
: F(nm, refs) {} : F(nm, refs) {}
}; };
int main(int, char**) int main(int, char**)
{ {
std::ios ios(0); std::ios ios(nullptr);
std::ios_base::iostate err; std::ios_base::iostate err;
std::tm t; std::tm t;
{ {
const my_facet f(LOCALE_en_US_UTF_8, 1); const my_facet f(LOCALE_en_US_UTF_8, 1);
#ifdef _WIN32 #ifdef _WIN32
// On Windows, the "%c" format lacks the leading week day, which // On Windows, the "%c" format lacks the leading week day, which
// means that t.tm_wday doesn't get set when parsing the string. // means that t.tm_wday doesn't get set when parsing the string.
const wchar_t in[] = L"12/31/2061 11:55:59 PM"; const wchar_t in[] = L"12/31/2061 11:55:59 PM";
▲ Show 20 Lines • Show All 155 Lines • Show Last 20 Lines

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

Show All 35 Lines
{ {
public: public:
explicit my_facet(const std::string& nm, std::size_t refs = 0) explicit my_facet(const std::string& nm, std::size_t refs = 0)
: F(nm, refs) {} : F(nm, refs) {}
}; };
int main(int, char**) int main(int, char**)
{ {
std::ios ios(0); std::ios ios(nullptr);
std::ios_base::iostate err; std::ios_base::iostate err;
std::tm t; std::tm t;
{ {
const my_facet f(LOCALE_en_US_UTF_8, 1); const my_facet f(LOCALE_en_US_UTF_8, 1);
const char in[] = "13:14:15"; const char in[] = "13:14:15";
err = std::ios_base::goodbit; err = std::ios_base::goodbit;
t = std::tm(); t = std::tm();
I i = f.get_time(I(in), I(in+sizeof(in)-1), ios, err, &t); I i = f.get_time(I(in), I(in+sizeof(in)-1), ios, err, &t);
▲ Show 20 Lines • Show All 45 Lines • Show Last 20 Lines

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

Show All 37 Lines
{ {
public: public:
explicit my_facet(const std::string& nm, std::size_t refs = 0) explicit my_facet(const std::string& nm, std::size_t refs = 0)
: F(nm, refs) {} : F(nm, refs) {}
}; };
int main(int, char**) int main(int, char**)
{ {
std::ios ios(0); std::ios ios(nullptr);
std::ios_base::iostate err; std::ios_base::iostate err;
std::tm t; std::tm t;
{ {
const my_facet f(LOCALE_en_US_UTF_8, 1); const my_facet f(LOCALE_en_US_UTF_8, 1);
const wchar_t in[] = L"13:14:15"; const wchar_t in[] = L"13:14:15";
err = std::ios_base::goodbit; err = std::ios_base::goodbit;
t = std::tm(); t = std::tm();
I i = f.get_time(I(in), I(in+sizeof(in)/sizeof(in[0])-1), ios, err, &t); I i = f.get_time(I(in), I(in+sizeof(in)/sizeof(in[0])-1), ios, err, &t);
▲ Show 20 Lines • Show All 45 Lines • Show Last 20 Lines

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

Show All 34 Lines
{ {
public: public:
explicit my_facet(const std::string& nm, std::size_t refs = 0) explicit my_facet(const std::string& nm, std::size_t refs = 0)
: F(nm, refs) {} : F(nm, refs) {}
}; };
int main(int, char**) int main(int, char**)
{ {
std::ios ios(0); std::ios ios(nullptr);
std::ios_base::iostate err; std::ios_base::iostate err;
std::tm t; std::tm t;
{ {
const my_facet f(LOCALE_en_US_UTF_8, 1); const my_facet f(LOCALE_en_US_UTF_8, 1);
const char in[] = "Monday"; const char in[] = "Monday";
err = std::ios_base::goodbit; err = std::ios_base::goodbit;
t = std::tm(); t = std::tm();
I i = f.get_weekday(I(in), I(in+sizeof(in)/sizeof(in[0])-1), ios, err, &t); I i = f.get_weekday(I(in), I(in+sizeof(in)/sizeof(in[0])-1), ios, err, &t);
▲ Show 20 Lines • Show All 45 Lines • Show Last 20 Lines

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

Show All 36 Lines
{ {
public: public:
explicit my_facet(const std::string& nm, std::size_t refs = 0) explicit my_facet(const std::string& nm, std::size_t refs = 0)
: F(nm, refs) {} : F(nm, refs) {}
}; };
int main(int, char**) int main(int, char**)
{ {
std::ios ios(0); std::ios ios(nullptr);
std::ios_base::iostate err; std::ios_base::iostate err;
std::tm t; std::tm t;
{ {
const my_facet f(LOCALE_en_US_UTF_8, 1); const my_facet f(LOCALE_en_US_UTF_8, 1);
const wchar_t in[] = L"Monday"; const wchar_t in[] = L"Monday";
err = std::ios_base::goodbit; err = std::ios_base::goodbit;
t = std::tm(); t = std::tm();
I i = f.get_weekday(I(in), I(in+sizeof(in)/sizeof(in[0])-1), ios, err, &t); I i = f.get_weekday(I(in), I(in+sizeof(in)/sizeof(in[0])-1), ios, err, &t);
▲ Show 20 Lines • Show All 41 Lines • Show Last 20 Lines

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

Show All 34 Lines
{ {
public: public:
explicit my_facet(const std::string& nm, std::size_t refs = 0) explicit my_facet(const std::string& nm, std::size_t refs = 0)
: F(nm, refs) {} : F(nm, refs) {}
}; };
int main(int, char**) int main(int, char**)
{ {
std::ios ios(0); std::ios ios(nullptr);
std::ios_base::iostate err; std::ios_base::iostate err;
std::tm t; std::tm t;
{ {
const my_facet f(LOCALE_en_US_UTF_8, 1); const my_facet f(LOCALE_en_US_UTF_8, 1);
const char in[] = "2009"; const char in[] = "2009";
err = std::ios_base::goodbit; err = std::ios_base::goodbit;
t = std::tm(); t = std::tm();
I i = f.get_year(I(in), I(in+sizeof(in)/sizeof(in[0])-1), ios, err, &t); I i = f.get_year(I(in), I(in+sizeof(in)/sizeof(in[0])-1), ios, err, &t);
Show All 37 Lines

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

Show All 36 Lines
{ {
public: public:
explicit my_facet(const std::string& nm, std::size_t refs = 0) explicit my_facet(const std::string& nm, std::size_t refs = 0)
: F(nm, refs) {} : F(nm, refs) {}
}; };
int main(int, char**) int main(int, char**)
{ {
std::ios ios(0); std::ios ios(nullptr);
std::ios_base::iostate err; std::ios_base::iostate err;
std::tm t; std::tm t;
{ {
const my_facet f(LOCALE_en_US_UTF_8, 1); const my_facet f(LOCALE_en_US_UTF_8, 1);
const wchar_t in[] = L"2009"; const wchar_t in[] = L"2009";
err = std::ios_base::goodbit; err = std::ios_base::goodbit;
t = std::tm(); t = std::tm();
I i = f.get_year(I(in), I(in+sizeof(in)/sizeof(in[0])-1), ios, err, &t); I i = f.get_year(I(in), I(in+sizeof(in)/sizeof(in[0])-1), ios, err, &t);
Show All 37 Lines

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

Show All 29 Lines
public: public:
explicit my_facet(std::size_t refs = 0) explicit my_facet(std::size_t refs = 0)
: F(refs) {} : F(refs) {}
}; };
int main(int, char**) int main(int, char**)
{ {
const my_facet f(1); const my_facet f(1);
std::ios ios(0); std::ios ios(nullptr);
std::ios_base::iostate err; std::ios_base::iostate err;
std::tm t; std::tm t;
{ {
const char in[] = "5/5/5"; const char in[] = "5/5/5";
err = std::ios_base::goodbit; err = std::ios_base::goodbit;
t = std::tm(); t = std::tm();
I i = f.get_date(I(in), I(in+sizeof(in)-1), ios, err, &t); I i = f.get_date(I(in), I(in+sizeof(in)-1), ios, err, &t);
assert(base(i) == in+sizeof(in)-1); assert(base(i) == in+sizeof(in)-1);
assert(t.tm_mon == 4); assert(t.tm_mon == 4);
assert(t.tm_mday == 5); assert(t.tm_mday == 5);
assert(t.tm_year == 105); assert(t.tm_year == 105);
assert(err == std::ios_base::eofbit); assert(err == std::ios_base::eofbit);
} }
return 0; return 0;
} }

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

Show All 31 Lines
public: public:
explicit my_facet(std::size_t refs = 0) explicit my_facet(std::size_t refs = 0)
: F(refs) {} : F(refs) {}
}; };
int main(int, char**) int main(int, char**)
{ {
const my_facet f(1); const my_facet f(1);
std::ios ios(0); std::ios ios(nullptr);
std::ios_base::iostate err; std::ios_base::iostate err;
std::tm t; std::tm t;
{ {
const wchar_t in[] = L"5/5/5"; const wchar_t in[] = L"5/5/5";
err = std::ios_base::goodbit; err = std::ios_base::goodbit;
t = std::tm(); t = std::tm();
I i = f.get_date(I(in), I(in+sizeof(in)/sizeof(in[0])-1), ios, err, &t); I i = f.get_date(I(in), I(in+sizeof(in)/sizeof(in[0])-1), ios, err, &t);
assert(base(i) == in+sizeof(in)/sizeof(in[0])-1); assert(base(i) == in+sizeof(in)/sizeof(in[0])-1);
assert(t.tm_mon == 4); assert(t.tm_mon == 4);
assert(t.tm_mday == 5); assert(t.tm_mday == 5);
assert(t.tm_year == 105); assert(t.tm_year == 105);
assert(err == std::ios_base::eofbit); assert(err == std::ios_base::eofbit);
} }
return 0; return 0;
} }

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

Show All 29 Lines
public: public:
explicit my_facet(std::size_t refs = 0) explicit my_facet(std::size_t refs = 0)
: F(refs) {} : F(refs) {}
}; };
int main(int, char**) int main(int, char**)
{ {
const my_facet f(1); const my_facet f(1);
std::ios ios(0); std::ios ios(nullptr);
std::ios_base::iostate err; std::ios_base::iostate err;
std::tm t; std::tm t;
{ {
const char in[] = "2009 May 9, 10:27pm"; const char in[] = "2009 May 9, 10:27pm";
const char fmt[] = "%Y %b %d, %I:%M%p"; const char fmt[] = "%Y %b %d, %I:%M%p";
err = std::ios_base::goodbit; err = std::ios_base::goodbit;
t = std::tm(); t = std::tm();
I i = f.get(I(in), I(in+sizeof(in)-1), ios, err, &t, fmt, fmt+sizeof(fmt)-1); I i = f.get(I(in), I(in+sizeof(in)-1), ios, err, &t, fmt, fmt+sizeof(fmt)-1);
Show All 25 Lines

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

Show All 28 Lines
public: public:
explicit my_facet(std::size_t refs = 0) explicit my_facet(std::size_t refs = 0)
: F(refs) {} : F(refs) {}
}; };
int main(int, char**) int main(int, char**)
{ {
const my_facet f(1); const my_facet f(1);
std::ios ios(0); std::ios ios(nullptr);
std::ios_base::iostate err; std::ios_base::iostate err;
std::tm t; std::tm t;
{ {
const char in[] = "Jan"; const char in[] = "Jan";
err = std::ios_base::goodbit; err = std::ios_base::goodbit;
t = std::tm(); t = std::tm();
I i = f.get_monthname(I(in), I(in+sizeof(in)-1), ios, err, &t); I i = f.get_monthname(I(in), I(in+sizeof(in)-1), ios, err, &t);
assert(base(i) == in+3); assert(base(i) == in+3);
▲ Show 20 Lines • Show All 222 Lines • Show Last 20 Lines

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

Show All 30 Lines
public: public:
explicit my_facet(std::size_t refs = 0) explicit my_facet(std::size_t refs = 0)
: F(refs) {} : F(refs) {}
}; };
int main(int, char**) int main(int, char**)
{ {
const my_facet f(1); const my_facet f(1);
std::ios ios(0); std::ios ios(nullptr);
std::ios_base::iostate err; std::ios_base::iostate err;
std::tm t; std::tm t;
{ {
const wchar_t in[] = L"Jan"; const wchar_t in[] = L"Jan";
err = std::ios_base::goodbit; err = std::ios_base::goodbit;
t = std::tm(); t = std::tm();
I i = f.get_monthname(I(in), I(in+sizeof(in)/sizeof(in[0])-1), ios, err, &t); I i = f.get_monthname(I(in), I(in+sizeof(in)/sizeof(in[0])-1), ios, err, &t);
assert(base(i) == in+3); assert(base(i) == in+3);
▲ Show 20 Lines • Show All 222 Lines • Show Last 20 Lines

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

Show All 27 Lines
public: public:
explicit my_facet(std::size_t refs = 0) explicit my_facet(std::size_t refs = 0)
: F(refs) {} : F(refs) {}
}; };
int main(int, char**) int main(int, char**)
{ {
const my_facet f(1); const my_facet f(1);
std::ios ios(0); std::ios ios(nullptr);
std::ios_base::iostate err; std::ios_base::iostate err;
std::tm t; std::tm t;
{ {
const char in[] = "mon"; const char in[] = "mon";
err = std::ios_base::goodbit; err = std::ios_base::goodbit;
t = std::tm(); t = std::tm();
I i = f.get(I(in), I(in+sizeof(in)-1), ios, err, &t, 'a'); I i = f.get(I(in), I(in+sizeof(in)-1), ios, err, &t, 'a');
assert(base(i) == in+sizeof(in)-1); assert(base(i) == in+sizeof(in)-1);
▲ Show 20 Lines • Show All 263 Lines • Show Last 20 Lines

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

Show All 28 Lines
public: public:
explicit my_facet(std::size_t refs = 0) explicit my_facet(std::size_t refs = 0)
: F(refs) {} : F(refs) {}
}; };
int main(int, char**) int main(int, char**)
{ {
const my_facet f(1); const my_facet f(1);
std::ios ios(0); std::ios ios(nullptr);
std::ios_base::iostate err; std::ios_base::iostate err;
std::tm t; std::tm t;
{ {
const char in[] = "0:0:0"; const char in[] = "0:0:0";
err = std::ios_base::goodbit; err = std::ios_base::goodbit;
t = std::tm(); t = std::tm();
I i = f.get_time(I(in), I(in+sizeof(in)-1), ios, err, &t); I i = f.get_time(I(in), I(in+sizeof(in)-1), ios, err, &t);
assert(base(i) == in+sizeof(in)-1); assert(base(i) == in+sizeof(in)-1);
▲ Show 20 Lines • Show All 74 Lines • Show Last 20 Lines

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

Show All 30 Lines
public: public:
explicit my_facet(std::size_t refs = 0) explicit my_facet(std::size_t refs = 0)
: F(refs) {} : F(refs) {}
}; };
int main(int, char**) int main(int, char**)
{ {
const my_facet f(1); const my_facet f(1);
std::ios ios(0); std::ios ios(nullptr);
std::ios_base::iostate err; std::ios_base::iostate err;
std::tm t; std::tm t;
{ {
const wchar_t in[] = L"0:0:0"; const wchar_t in[] = L"0:0:0";
err = std::ios_base::goodbit; err = std::ios_base::goodbit;
t = std::tm(); t = std::tm();
I i = f.get_time(I(in), I(in+sizeof(in)/sizeof(in[0])-1), ios, err, &t); I i = f.get_time(I(in), I(in+sizeof(in)/sizeof(in[0])-1), ios, err, &t);
assert(base(i) == in+sizeof(in)/sizeof(in[0])-1); assert(base(i) == in+sizeof(in)/sizeof(in[0])-1);
▲ Show 20 Lines • Show All 74 Lines • Show Last 20 Lines

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

Show All 28 Lines
public: public:
explicit my_facet(std::size_t refs = 0) explicit my_facet(std::size_t refs = 0)
: F(refs) {} : F(refs) {}
}; };
int main(int, char**) int main(int, char**)
{ {
const my_facet f(1); const my_facet f(1);
std::ios ios(0); std::ios ios(nullptr);
std::ios_base::iostate err; std::ios_base::iostate err;
std::tm t; std::tm t;
{ {
const char in[] = "Sun"; const char in[] = "Sun";
err = std::ios_base::goodbit; err = std::ios_base::goodbit;
t = std::tm(); t = std::tm();
I i = f.get_weekday(I(in), I(in+sizeof(in)-1), ios, err, &t); I i = f.get_weekday(I(in), I(in+sizeof(in)-1), ios, err, &t);
assert(base(i) == in+3); assert(base(i) == in+3);
▲ Show 20 Lines • Show All 177 Lines • Show Last 20 Lines

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

Show All 30 Lines
public: public:
explicit my_facet(std::size_t refs = 0) explicit my_facet(std::size_t refs = 0)
: F(refs) {} : F(refs) {}
}; };
int main(int, char**) int main(int, char**)
{ {
const my_facet f(1); const my_facet f(1);
std::ios ios(0); std::ios ios(nullptr);
std::ios_base::iostate err; std::ios_base::iostate err;
std::tm t; std::tm t;
{ {
const wchar_t in[] = L"Sun"; const wchar_t in[] = L"Sun";
err = std::ios_base::goodbit; err = std::ios_base::goodbit;
t = std::tm(); t = std::tm();
I i = f.get_weekday(I(in), I(in+sizeof(in)/sizeof(in[0])-1), ios, err, &t); I i = f.get_weekday(I(in), I(in+sizeof(in)/sizeof(in[0])-1), ios, err, &t);
assert(base(i) == in+3); assert(base(i) == in+3);
▲ Show 20 Lines • Show All 177 Lines • Show Last 20 Lines

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

Show All 28 Lines
public: public:
explicit my_facet(std::size_t refs = 0) explicit my_facet(std::size_t refs = 0)
: F(refs) {} : F(refs) {}
}; };
int main(int, char**) int main(int, char**)
{ {
const my_facet f(1); const my_facet f(1);
std::ios ios(0); std::ios ios(nullptr);
std::ios_base::iostate err; std::ios_base::iostate err;
std::tm t; std::tm t;
{ {
const char in[] = "0"; const char in[] = "0";
err = std::ios_base::goodbit; err = std::ios_base::goodbit;
t = std::tm(); t = std::tm();
I i = f.get_year(I(in), I(in+sizeof(in)-1), ios, err, &t); I i = f.get_year(I(in), I(in+sizeof(in)-1), ios, err, &t);
assert(base(i) == in+sizeof(in)-1); assert(base(i) == in+sizeof(in)-1);
▲ Show 20 Lines • Show All 96 Lines • Show Last 20 Lines

libcxx/test/std/localization/locale.categories/category.time/locale.time.put.byname/put1.pass.cpp

Show First 20 Lines • Show All 53 Lines • ▼ Show 20 Linesint main(int, char**)
t.tm_min = 3; t.tm_min = 3;
t.tm_hour = 13; t.tm_hour = 13;
t.tm_mday = 2; t.tm_mday = 2;
t.tm_mon = 4; t.tm_mon = 4;
t.tm_year = 109; t.tm_year = 109;
t.tm_wday = 6; t.tm_wday = 6;
t.tm_yday = -1; t.tm_yday = -1;
t.tm_isdst = 1; t.tm_isdst = 1;
std::ios ios(0); std::ios ios(nullptr);
{ {
const my_facet f(LOCALE_en_US_UTF_8, 1); const my_facet f(LOCALE_en_US_UTF_8, 1);
std::string pat("Today is %A which is abbreviated %a."); std::string pat("Today is %A which is abbreviated %a.");
cpp17_output_iterator<char*> iter = cpp17_output_iterator<char*> iter =
f.put(cpp17_output_iterator<char*>(str), ios, '*', &t, pat.data(), pat.data() + pat.size()); f.put(cpp17_output_iterator<char*>(str), ios, '*', &t, pat.data(), pat.data() + pat.size());
std::string ex(str, base(iter)); std::string ex(str, base(iter));
assert(ex == "Today is Saturday which is abbreviated Sat."); assert(ex == "Today is Saturday which is abbreviated Sat.");
} }
Show All 25 Lines

libcxx/test/std/localization/locale.categories/category.time/locale.time.put/locale.time.put.members/put1.pass.cpp

Show All 37 Linesint main(int, char**)
t.tm_min = 3; t.tm_min = 3;
t.tm_hour = 13; t.tm_hour = 13;
t.tm_mday = 2; t.tm_mday = 2;
t.tm_mon = 4; t.tm_mon = 4;
t.tm_year = 109; t.tm_year = 109;
t.tm_wday = 6; t.tm_wday = 6;
t.tm_yday = -1; t.tm_yday = -1;
t.tm_isdst = 1; t.tm_isdst = 1;
std::ios ios(0); std::ios ios(nullptr);
{ {
std::string pat("Today is %A which is abbreviated %a."); std::string pat("Today is %A which is abbreviated %a.");
cpp17_output_iterator<char*> iter = cpp17_output_iterator<char*> iter =
f.put(cpp17_output_iterator<char*>(str), ios, '*', &t, pat.data(), pat.data() + pat.size()); f.put(cpp17_output_iterator<char*>(str), ios, '*', &t, pat.data(), pat.data() + pat.size());
std::string ex(str, base(iter)); std::string ex(str, base(iter));
assert(ex == "Today is Saturday which is abbreviated Sat."); assert(ex == "Today is Saturday which is abbreviated Sat.");
} }
{ {
Show All 9 Lines

libcxx/test/std/localization/locale.categories/category.time/locale.time.put/locale.time.put.members/put2.pass.cpp

Show All 36 Linesint main(int, char**)
t.tm_min = 3; t.tm_min = 3;
t.tm_hour = 13; t.tm_hour = 13;
t.tm_mday = 2; t.tm_mday = 2;
t.tm_mon = 4; t.tm_mon = 4;
t.tm_year = 109; t.tm_year = 109;
t.tm_wday = 6; t.tm_wday = 6;
t.tm_yday = 121; t.tm_yday = 121;
t.tm_isdst = 1; t.tm_isdst = 1;
std::ios ios(0); std::ios ios(nullptr);
{ {
cpp17_output_iterator<char*> iter = f.put(cpp17_output_iterator<char*>(str), ios, '*', &t, 'A'); cpp17_output_iterator<char*> iter = f.put(cpp17_output_iterator<char*>(str), ios, '*', &t, 'A');
std::string ex(str, base(iter)); std::string ex(str, base(iter));
assert(ex == "Saturday"); assert(ex == "Saturday");
} }
{ {
cpp17_output_iterator<char*> iter = f.put(cpp17_output_iterator<char*>(str), ios, '*', &t, 'a'); cpp17_output_iterator<char*> iter = f.put(cpp17_output_iterator<char*>(str), ios, '*', &t, 'a');
std::string ex(str, base(iter)); std::string ex(str, base(iter));
▲ Show 20 Lines • Show All 284 Lines • Show Last 20 Lines

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

Show First 20 Lines • Show All 65 Lines • ▼ Show 20 Linesint main(int, char**)
assert(f.sgetc() == L'a'); assert(f.sgetc() == L'a');
} }
} }
{ {
std::string s; std::string s;
{ {
std::ostringstream out; std::ostringstream out;
test_buf f(out.rdbuf()); test_buf f(out.rdbuf());
f.pubsetbuf(0, 0); f.pubsetbuf(nullptr, 0);
assert(f.pbase() == 0); assert(f.pbase() == 0);
assert(f.pptr() == 0); assert(f.pptr() == 0);
assert(f.epptr() == 0); assert(f.epptr() == 0);
assert(f.overflow('a') == 'a'); assert(f.overflow('a') == 'a');
assert(f.pbase() == 0); assert(f.pbase() == 0);
assert(f.pptr() == 0); assert(f.pptr() == 0);
assert(f.epptr() == 0); assert(f.epptr() == 0);
s = out.str(); s = out.str();
Show All 37 Lines

libcxx/test/std/localization/locales/locale/locale.cons/char_pointer.pass.cpp

Show First 20 Lines • Show All 79 Lines • ▼ Show 20 Linesint main(int, char**)
assert(loc == loc2); assert(loc == loc2);
std::locale loc3(LOCALE_zh_CN_UTF_8); std::locale loc3(LOCALE_zh_CN_UTF_8);
check(loc3); check(loc3);
assert(!(loc == loc3)); assert(!(loc == loc3));
assert(loc != loc3); assert(loc != loc3);
#ifndef TEST_HAS_NO_EXCEPTIONS #ifndef TEST_HAS_NO_EXCEPTIONS
try try
{ {
std::locale((const char*)0); std::locale((const char*)nullptr);
assert(false); assert(false);
} }
catch (std::runtime_error&) catch (std::runtime_error&)
{ {
} }
try try
{ {
std::locale("spazbot"); std::locale("spazbot");
Show All 12 Lines

libcxx/test/std/localization/locales/locale/locale.cons/locale_facetptr.pass.cpp

Show First 20 Lines • Show All 85 Lines • ▼ Show 20 Linesint main(int, char**)
assert((std::has_facet<my_facet>(loc2))); assert((std::has_facet<my_facet>(loc2)));
const my_facet& f = std::use_facet<my_facet>(loc2); const my_facet& f = std::use_facet<my_facet>(loc2);
assert(f.test() == 5); assert(f.test() == 5);
} }
assert(globalMemCounter.checkOutstandingNewEq(0)); assert(globalMemCounter.checkOutstandingNewEq(0));
{ {
std::locale loc; std::locale loc;
check(loc); check(loc);
std::locale loc2(loc, (std::ctype<char>*)0); std::locale loc2(loc, (std::ctype<char>*)nullptr);
check(loc2); check(loc2);
assert(loc == loc2); assert(loc == loc2);
} }
assert(globalMemCounter.checkOutstandingNewEq(0)); assert(globalMemCounter.checkOutstandingNewEq(0));
return 0; return 0;
} }

libcxx/test/std/numerics/c.math/cmath.pass.cpp

Show First 20 Lines • Show All 432 Lines • ▼ Show 20 Linesvoid test_log10()
static_assert((std::is_same<decltype(std::log10f(0)), float>::value), ""); static_assert((std::is_same<decltype(std::log10f(0)), float>::value), "");
static_assert((std::is_same<decltype(std::log10l(0)), long double>::value), ""); static_assert((std::is_same<decltype(std::log10l(0)), long double>::value), "");
static_assert((std::is_same<decltype(log10(Ambiguous())), Ambiguous>::value), ""); static_assert((std::is_same<decltype(log10(Ambiguous())), Ambiguous>::value), "");
assert(std::log10(1) == 0); assert(std::log10(1) == 0);
} }
void test_modf() void test_modf()
{ {
static_assert((std::is_same<decltype(std::modf((float)0, (float*)0)), float>::value), ""); static_assert((std::is_same<decltype(std::modf((float)0, (float*)nullptr)), float>::value), "");
static_assert((std::is_same<decltype(std::modf((double)0, (double*)0)), double>::value), ""); static_assert((std::is_same<decltype(std::modf((double)0, (double*)nullptr)), double>::value), "");
static_assert((std::is_same<decltype(std::modf((long double)0, (long double*)0)), long double>::value), ""); static_assert((std::is_same<decltype(std::modf((long double)0, (long double*)nullptr)), long double>::value), "");
static_assert((std::is_same<decltype(std::modff(0, (float*)0)), float>::value), ""); static_assert((std::is_same<decltype(std::modff(0, (float*)nullptr)), float>::value), "");
static_assert((std::is_same<decltype(std::modfl(0, (long double*)0)), long double>::value), ""); static_assert((std::is_same<decltype(std::modfl(0, (long double*)nullptr)), long double>::value), "");
static_assert((std::is_same<decltype(modf(Ambiguous(), (Ambiguous*)0)), Ambiguous>::value), ""); static_assert((std::is_same<decltype(modf(Ambiguous(), (Ambiguous*)nullptr)), Ambiguous>::value), "");
double i; double i;
assert(std::modf(1., &i) == 0); assert(std::modf(1., &i) == 0);
} }
void test_pow() void test_pow()
{ {
static_assert((std::is_same<decltype(std::pow((float)0, (float)0)), float>::value), ""); static_assert((std::is_same<decltype(std::pow((float)0, (float)0)), float>::value), "");
static_assert((std::is_same<decltype(std::pow((bool)0, (float)0)), double>::value), ""); static_assert((std::is_same<decltype(std::pow((bool)0, (float)0)), double>::value), "");
▲ Show 20 Lines • Show All 1,199 Lines • Show Last 20 Lines

libcxx/test/std/numerics/complex.number/cmplx.over/arg.pass.cpp

Show All 15 Lines
#include <type_traits> #include <type_traits>
#include <cassert> #include <cassert>
#include "test_macros.h" #include "test_macros.h"
#include "../cases.h" #include "../cases.h"
template <class T> template <class T>
void void
test(T x, typename std::enable_if<std::is_integral<T>::value>::type* = 0) test(T x, typename std::enable_if<std::is_integral<T>::value>::type* = nullptr)
{ {
static_assert((std::is_same<decltype(std::arg(x)), double>::value), ""); static_assert((std::is_same<decltype(std::arg(x)), double>::value), "");
assert(std::arg(x) == arg(std::complex<double>(static_cast<double>(x), 0))); assert(std::arg(x) == arg(std::complex<double>(static_cast<double>(x), 0)));
} }
template <class T> template <class T>
void void
test(T x, typename std::enable_if<!std::is_integral<T>::value>::type* = 0) test(T x, typename std::enable_if<!std::is_integral<T>::value>::type* = nullptr)
{ {
static_assert((std::is_same<decltype(std::arg(x)), T>::value), ""); static_assert((std::is_same<decltype(std::arg(x)), T>::value), "");
assert(std::arg(x) == arg(std::complex<T>(x, 0))); assert(std::arg(x) == arg(std::complex<T>(x, 0)));
} }
template <class T> template <class T>
void void
test() test()
Show All 17 Lines

libcxx/test/std/numerics/complex.number/cmplx.over/conj.pass.cpp

Show All 18 Lines
#include <cassert> #include <cassert>
#include "test_macros.h" #include "test_macros.h"
#include "../cases.h" #include "../cases.h"
template <class T> template <class T>
TEST_CONSTEXPR_CXX20 TEST_CONSTEXPR_CXX20
void void
test(T x, typename std::enable_if<std::is_integral<T>::value>::type* = 0) test(T x, typename std::enable_if<std::is_integral<T>::value>::type* = nullptr)
{ {
static_assert((std::is_same<decltype(std::conj(x)), std::complex<double> >::value), ""); static_assert((std::is_same<decltype(std::conj(x)), std::complex<double> >::value), "");
assert(std::conj(x) == conj(std::complex<double>(x, 0))); assert(std::conj(x) == conj(std::complex<double>(x, 0)));
} }
template <class T> template <class T>
TEST_CONSTEXPR_CXX20 TEST_CONSTEXPR_CXX20
void void
test(T x, typename std::enable_if<std::is_floating_point<T>::value>::type* = 0) test(T x, typename std::enable_if<std::is_floating_point<T>::value>::type* = nullptr)
{ {
static_assert((std::is_same<decltype(std::conj(x)), std::complex<T> >::value), ""); static_assert((std::is_same<decltype(std::conj(x)), std::complex<T> >::value), "");
assert(std::conj(x) == conj(std::complex<T>(x, 0))); assert(std::conj(x) == conj(std::complex<T>(x, 0)));
} }
template <class T> template <class T>
TEST_CONSTEXPR_CXX20 TEST_CONSTEXPR_CXX20
void void
test(T x, typename std::enable_if<!std::is_integral<T>::value && test(T x, typename std::enable_if<!std::is_integral<T>::value &&
!std::is_floating_point<T>::value>::type* = 0) !std::is_floating_point<T>::value>::type* = nullptr)
{ {
static_assert((std::is_same<decltype(std::conj(x)), std::complex<T> >::value), ""); static_assert((std::is_same<decltype(std::conj(x)), std::complex<T> >::value), "");
assert(std::conj(x) == conj(std::complex<T>(x, 0))); assert(std::conj(x) == conj(std::complex<T>(x, 0)));
} }
template <class T> template <class T>
TEST_CONSTEXPR_CXX20 TEST_CONSTEXPR_CXX20
bool bool
Show All 28 Lines

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

Show All 15 Lines
#include <type_traits> #include <type_traits>
#include <cassert> #include <cassert>
#include "test_macros.h" #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* = nullptr)
{ {
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 TEST_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* = nullptr)
{ {
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 TEST_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, "" );
Show All 23 Lines

libcxx/test/std/numerics/complex.number/cmplx.over/norm.pass.cpp

Show All 16 Lines
#include <cassert> #include <cassert>
#include "test_macros.h" #include "test_macros.h"
#include "../cases.h" #include "../cases.h"
template <class T> template <class T>
TEST_CONSTEXPR_CXX20 TEST_CONSTEXPR_CXX20
void void
test(T x, typename std::enable_if<std::is_integral<T>::value>::type* = 0) test(T x, typename std::enable_if<std::is_integral<T>::value>::type* = nullptr)
{ {
static_assert((std::is_same<decltype(std::norm(x)), double>::value), ""); static_assert((std::is_same<decltype(std::norm(x)), double>::value), "");
assert(std::norm(x) == norm(std::complex<double>(static_cast<double>(x), 0))); assert(std::norm(x) == norm(std::complex<double>(static_cast<double>(x), 0)));
} }
template <class T> template <class T>
TEST_CONSTEXPR_CXX20 TEST_CONSTEXPR_CXX20
void void
test(T x, typename std::enable_if<!std::is_integral<T>::value>::type* = 0) test(T x, typename std::enable_if<!std::is_integral<T>::value>::type* = nullptr)
{ {
static_assert((std::is_same<decltype(std::norm(x)), T>::value), ""); static_assert((std::is_same<decltype(std::norm(x)), T>::value), "");
assert(std::norm(x) == norm(std::complex<T>(x, 0))); assert(std::norm(x) == norm(std::complex<T>(x, 0)));
} }
template <class T> template <class T>
TEST_CONSTEXPR_CXX20 TEST_CONSTEXPR_CXX20
bool bool
Show All 28 Lines

libcxx/test/std/numerics/complex.number/cmplx.over/pow.pass.cpp

Show All 23 Lines
#include <type_traits> #include <type_traits>
#include <cassert> #include <cassert>
#include "test_macros.h" #include "test_macros.h"
#include "../cases.h" #include "../cases.h"
template <class T> template <class T>
double double
promote(T, typename std::enable_if<std::is_integral<T>::value>::type* = 0); promote(T, typename std::enable_if<std::is_integral<T>::value>::type* = nullptr);
float promote(float); float promote(float);
double promote(double); double promote(double);
long double promote(long double); long double promote(long double);
template <class T, class U> template <class T, class U>
void void
test(T x, const std::complex<U>& y) test(T x, const std::complex<U>& y)
Show All 18 Lines
{ {
typedef decltype(promote(real(x))+promote(real(y))) V; typedef decltype(promote(real(x))+promote(real(y))) V;
static_assert((std::is_same<decltype(std::pow(x, y)), std::complex<V> >::value), ""); static_assert((std::is_same<decltype(std::pow(x, y)), std::complex<V> >::value), "");
assert(std::pow(x, y) == pow(std::complex<V>(x), std::complex<V>(y))); assert(std::pow(x, y) == pow(std::complex<V>(x), std::complex<V>(y)));
} }
template <class T, class U> template <class T, class U>
void void
test(typename std::enable_if<std::is_integral<T>::value>::type* = 0, typename std::enable_if<!std::is_integral<U>::value>::type* = 0) test(typename std::enable_if<std::is_integral<T>::value>::type* = nullptr, typename std::enable_if<!std::is_integral<U>::value>::type* = nullptr)
{ {
test(T(3), std::complex<U>(4, 5)); test(T(3), std::complex<U>(4, 5));
test(std::complex<U>(3, 4), T(5)); test(std::complex<U>(3, 4), T(5));
} }
template <class T, class U> template <class T, class U>
void void
test(typename std::enable_if<!std::is_integral<T>::value>::type* = 0, typename std::enable_if<!std::is_integral<U>::value>::type* = 0) test(typename std::enable_if<!std::is_integral<T>::value>::type* = nullptr, typename std::enable_if<!std::is_integral<U>::value>::type* = nullptr)
{ {
test(T(3), std::complex<U>(4, 5)); test(T(3), std::complex<U>(4, 5));
test(std::complex<T>(3, 4), U(5)); test(std::complex<T>(3, 4), U(5));
test(std::complex<T>(3, 4), std::complex<U>(5, 6)); test(std::complex<T>(3, 4), std::complex<U>(5, 6));
} }
int main(int, char**) int main(int, char**)
{ {
Show All 23 Lines

libcxx/test/std/numerics/complex.number/cmplx.over/proj.pass.cpp

Show All 17 Lines
#include <type_traits> #include <type_traits>
#include <cassert> #include <cassert>
#include "test_macros.h" #include "test_macros.h"
#include "../cases.h" #include "../cases.h"
template <class T> template <class T>
void void
test(T x, typename std::enable_if<std::is_integral<T>::value>::type* = 0) test(T x, typename std::enable_if<std::is_integral<T>::value>::type* = nullptr)
{ {
static_assert((std::is_same<decltype(std::proj(x)), std::complex<double> >::value), ""); static_assert((std::is_same<decltype(std::proj(x)), std::complex<double> >::value), "");
assert(std::proj(x) == proj(std::complex<double>(x, 0))); assert(std::proj(x) == proj(std::complex<double>(x, 0)));
} }
template <class T> template <class T>
void void
test(T x, typename std::enable_if<std::is_floating_point<T>::value>::type* = 0) test(T x, typename std::enable_if<std::is_floating_point<T>::value>::type* = nullptr)
{ {
static_assert((std::is_same<decltype(std::proj(x)), std::complex<T> >::value), ""); static_assert((std::is_same<decltype(std::proj(x)), std::complex<T> >::value), "");
assert(std::proj(x) == proj(std::complex<T>(x, 0))); assert(std::proj(x) == proj(std::complex<T>(x, 0)));
} }
template <class T> template <class T>
void void
test(T x, typename std::enable_if<!std::is_integral<T>::value && test(T x, typename std::enable_if<!std::is_integral<T>::value &&
!std::is_floating_point<T>::value>::type* = 0) !std::is_floating_point<T>::value>::type* = nullptr)
{ {
static_assert((std::is_same<decltype(std::proj(x)), std::complex<T> >::value), ""); static_assert((std::is_same<decltype(std::proj(x)), std::complex<T> >::value), "");
assert(std::proj(x) == proj(std::complex<T>(x, 0))); assert(std::proj(x) == proj(std::complex<T>(x, 0)));
} }
template <class T> template <class T>
void void
test() test()
Show All 17 Lines

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

Show All 15 Lines
#include <type_traits> #include <type_traits>
#include <cassert> #include <cassert>
#include "test_macros.h" #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* = nullptr)
{ {
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 TEST_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* = nullptr)
{ {
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 TEST_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, "" );
Show All 23 Lines

libcxx/test/std/strings/c.strings/cstring.pass.cpp

Show All 17 Lines
#error NULL not defined #error NULL not defined
#endif #endif
int main(int, char**) int main(int, char**)
{ {
// Functions we get directly from the C library (just check the signature) // Functions we get directly from the C library (just check the signature)
{ {
std::size_t s = 0; std::size_t s = 0;
void* vp = 0; void* vp = nullptr;
const void* vpc = 0; const void* vpc = nullptr;
char* cp = 0; char* cp = nullptr;
const char* cpc = 0; const char* cpc = nullptr;
ASSERT_SAME_TYPE(void*, decltype(std::memcpy(vp, vpc, s))); ASSERT_SAME_TYPE(void*, decltype(std::memcpy(vp, vpc, s)));
ASSERT_SAME_TYPE(void*, decltype(std::memmove(vp, vpc, s))); ASSERT_SAME_TYPE(void*, decltype(std::memmove(vp, vpc, s)));
ASSERT_SAME_TYPE(char*, decltype(std::strcpy(cp, cpc))); ASSERT_SAME_TYPE(char*, decltype(std::strcpy(cp, cpc)));
ASSERT_SAME_TYPE(char*, decltype(std::strncpy(cp, cpc, s))); ASSERT_SAME_TYPE(char*, decltype(std::strncpy(cp, cpc, s)));
ASSERT_SAME_TYPE(char*, decltype(std::strcat(cp, cpc))); ASSERT_SAME_TYPE(char*, decltype(std::strcat(cp, cpc)));
ASSERT_SAME_TYPE(char*, decltype(std::strncat(cp, cpc, s))); ASSERT_SAME_TYPE(char*, decltype(std::strncat(cp, cpc, s)));
ASSERT_SAME_TYPE(int, decltype(std::memcmp(vpc, vpc, s))); ASSERT_SAME_TYPE(int, decltype(std::memcmp(vpc, vpc, s)));
ASSERT_SAME_TYPE(int, decltype(std::strcmp(cpc, cpc))); ASSERT_SAME_TYPE(int, decltype(std::strcmp(cpc, cpc)));
▲ Show 20 Lines • Show All 101 Lines • Show Last 20 Lines

libcxx/test/std/strings/c.strings/cuchar.compile.pass.cpp

Show All 18 Lines
#include <cuchar> #include <cuchar>
#include "test_macros.h" #include "test_macros.h"
// __STDC_UTF_16__ may or may not be defined by the C standard library // __STDC_UTF_16__ may or may not be defined by the C standard library
// __STDC_UTF_32__ may or may not be defined by the C standard library // __STDC_UTF_32__ may or may not be defined by the C standard library
#if !defined(TEST_HAS_NO_C8RTOMB_MBRTOC8) #if !defined(TEST_HAS_NO_C8RTOMB_MBRTOC8)
ASSERT_SAME_TYPE(size_t, decltype(std::mbrtoc8((char8_t*)0, (const char*)0, (size_t)0, (mbstate_t*)0))); ASSERT_SAME_TYPE(size_t, decltype(std::mbrtoc8((char8_t*)nullptr, (const char*)nullptr, (size_t)0, (mbstate_t*)nullptr)));
ASSERT_SAME_TYPE(size_t, decltype(std::c8rtomb((char*)0, (char8_t)0, (mbstate_t*)0))); ASSERT_SAME_TYPE(size_t, decltype(std::c8rtomb((char*)nullptr, (char8_t)0, (mbstate_t*)nullptr)));
#endif #endif
ASSERT_SAME_TYPE(size_t, decltype(std::mbrtoc16((char16_t*)0, (const char*)0, (size_t)0, (mbstate_t*)0))); ASSERT_SAME_TYPE(size_t, decltype(std::mbrtoc16((char16_t*)nullptr, (const char*)nullptr, (size_t)0, (mbstate_t*)nullptr)));
ASSERT_SAME_TYPE(size_t, decltype(std::c16rtomb((char*)0, (char16_t)0, (mbstate_t*)0))); ASSERT_SAME_TYPE(size_t, decltype(std::c16rtomb((char*)nullptr, (char16_t)0, (mbstate_t*)nullptr)));
ASSERT_SAME_TYPE(size_t, decltype(std::mbrtoc32((char32_t*)0, (const char*)0, (size_t)0, (mbstate_t*)0))); ASSERT_SAME_TYPE(size_t, decltype(std::mbrtoc32((char32_t*)nullptr, (const char*)nullptr, (size_t)0, (mbstate_t*)nullptr)));
ASSERT_SAME_TYPE(size_t, decltype(std::c16rtomb((char*)0, (char32_t)0, (mbstate_t*)0))); ASSERT_SAME_TYPE(size_t, decltype(std::c16rtomb((char*)nullptr, (char32_t)0, (mbstate_t*)nullptr)));

libcxx/test/std/strings/c.strings/cwchar.pass.cpp

Show First 20 Lines • Show All 109 Lines • ▼ Show 20 Linesint main(int, char**)
ASSERT_SAME_TYPE(wchar_t*, decltype(std::wmemset(ws, L' ', s))); ASSERT_SAME_TYPE(wchar_t*, decltype(std::wmemset(ws, L' ', s)));
ASSERT_SAME_TYPE(std::size_t, decltype(std::wcsftime(ws, s, L"", tm))); ASSERT_SAME_TYPE(std::size_t, decltype(std::wcsftime(ws, s, L"", tm)));
ASSERT_SAME_TYPE(wint_t, decltype(std::btowc(0))); ASSERT_SAME_TYPE(wint_t, decltype(std::btowc(0)));
ASSERT_SAME_TYPE(int, decltype(std::wctob(w))); ASSERT_SAME_TYPE(int, decltype(std::wctob(w)));
ASSERT_SAME_TYPE(int, decltype(std::mbsinit(&mb))); ASSERT_SAME_TYPE(int, decltype(std::mbsinit(&mb)));
ASSERT_SAME_TYPE(std::size_t, decltype(std::mbrlen("", s, &mb))); ASSERT_SAME_TYPE(std::size_t, decltype(std::mbrlen("", s, &mb)));
ASSERT_SAME_TYPE(std::size_t, decltype(std::mbrtowc(ws, "", s, &mb))); ASSERT_SAME_TYPE(std::size_t, decltype(std::mbrtowc(ws, "", s, &mb)));
ASSERT_SAME_TYPE(std::size_t, decltype(std::wcrtomb(ns, L' ', &mb))); ASSERT_SAME_TYPE(std::size_t, decltype(std::wcrtomb(ns, L' ', &mb)));
ASSERT_SAME_TYPE(std::size_t, decltype(std::mbsrtowcs(ws, (const char**)0, s, &mb))); ASSERT_SAME_TYPE(std::size_t, decltype(std::mbsrtowcs(ws, (const char**)nullptr, s, &mb)));
ASSERT_SAME_TYPE(std::size_t, decltype(std::wcsrtombs(ns, (const wchar_t**)0, s, &mb))); ASSERT_SAME_TYPE(std::size_t, decltype(std::wcsrtombs(ns, (const wchar_t**)nullptr, s, &mb)));
ASSERT_SAME_TYPE(std::wint_t, decltype(std::getwchar())); ASSERT_SAME_TYPE(std::wint_t, decltype(std::getwchar()));
ASSERT_SAME_TYPE(int, decltype(std::vwscanf(L"", va))); ASSERT_SAME_TYPE(int, decltype(std::vwscanf(L"", va)));
ASSERT_SAME_TYPE(int, decltype(std::wscanf(L""))); ASSERT_SAME_TYPE(int, decltype(std::wscanf(L"")));
ASSERT_SAME_TYPE(std::wint_t, decltype(std::putwchar(L' '))); ASSERT_SAME_TYPE(std::wint_t, decltype(std::putwchar(L' ')));
ASSERT_SAME_TYPE(int, decltype(std::vwprintf(L"", va))); ASSERT_SAME_TYPE(int, decltype(std::vwprintf(L"", va)));
ASSERT_SAME_TYPE(int, decltype(std::wprintf(L""))); ASSERT_SAME_TYPE(int, decltype(std::wprintf(L"")));
return 0; return 0;
} }

libcxx/test/std/utilities/allocator.adaptor/allocator.adaptor.members/allocate_size_hint.pass.cpp

Show All 21 Lines
#include "allocators.h" #include "allocators.h"
int main(int, char**) int main(int, char**)
{ {
{ {
typedef std::scoped_allocator_adaptor<A1<int>> A; typedef std::scoped_allocator_adaptor<A1<int>> A;
A a; A a;
A1<int>::allocate_called = false; A1<int>::allocate_called = false;
assert(a.allocate(10, (const void*)0) == (int*)10); assert(a.allocate(10, (const void*)nullptr) == (int*)10);
assert(A1<int>::allocate_called == true); assert(A1<int>::allocate_called == true);
} }
{ {
typedef std::scoped_allocator_adaptor<A1<int>, A2<int>> A; typedef std::scoped_allocator_adaptor<A1<int>, A2<int>> A;
A a; A a;
A1<int>::allocate_called = false; A1<int>::allocate_called = false;
assert(a.allocate(10, (const void*)10) == (int*)10); assert(a.allocate(10, (const void*)10) == (int*)10);
assert(A1<int>::allocate_called == true); assert(A1<int>::allocate_called == true);
} }
{ {
typedef std::scoped_allocator_adaptor<A1<int>, A2<int>, A3<int>> A; typedef std::scoped_allocator_adaptor<A1<int>, A2<int>, A3<int>> A;
A a; A a;
A1<int>::allocate_called = false; A1<int>::allocate_called = false;
assert(a.allocate(10, (const void*)20) == (int*)10); assert(a.allocate(10, (const void*)20) == (int*)10);
assert(A1<int>::allocate_called == true); assert(A1<int>::allocate_called == true);
} }
{ {
typedef std::scoped_allocator_adaptor<A2<int>> A; typedef std::scoped_allocator_adaptor<A2<int>> A;
A a; A a;
A2<int>::allocate_called = false; A2<int>::allocate_called = false;
assert(a.allocate(10, (const void*)0) == (int*)0); assert(a.allocate(10, (const void*)nullptr) == (int*)nullptr);
assert(A2<int>::allocate_called == true); assert(A2<int>::allocate_called == true);
} }
{ {
typedef std::scoped_allocator_adaptor<A2<int>, A2<int>> A; typedef std::scoped_allocator_adaptor<A2<int>, A2<int>> A;
A a; A a;
A2<int>::allocate_called = false; A2<int>::allocate_called = false;
assert(a.allocate(10, (const void*)10) == (int*)10); assert(a.allocate(10, (const void*)10) == (int*)10);
assert(A2<int>::allocate_called == true); assert(A2<int>::allocate_called == true);
Show All 11 Lines

libcxx/test/std/utilities/allocator.adaptor/allocator.adaptor.members/allocate_size_hint.verify.cpp

Show All 15 Lines
// pointer allocate(size_type n, const_void_pointer hint); // pointer allocate(size_type n, const_void_pointer hint);
#include <scoped_allocator> #include <scoped_allocator>
#include "allocators.h" #include "allocators.h"
void f() { void f() {
std::scoped_allocator_adaptor<A1<int>> a; std::scoped_allocator_adaptor<A1<int>> a;
a.allocate(10, (const void*)0); // expected-warning {{ignoring return value of function declared with 'nodiscard' attribute}} a.allocate(10, (const void*)nullptr); // expected-warning {{ignoring return value of function declared with 'nodiscard' attribute}}
} }

libcxx/test/std/utilities/function.objects/arithmetic.operations/transparent.pass.cpp

Show All 12 Lines
#include "test_macros.h" #include "test_macros.h"
template <class T> template <class T>
struct is_transparent struct is_transparent
{ {
private: private:
struct two {char lx; char lxx;}; struct two {char lx; char lxx;};
template <class U> static two test(...); template <class U> static two test(...);
template <class U> static char test(typename U::is_transparent* = 0); template <class U> static char test(typename U::is_transparent* = nullptr);
public: public:
static const bool value = sizeof(test<T>(0)) == 1; static const bool value = sizeof(test<T>(0)) == 1;
}; };
int main(int, char**) int main(int, char**)
{ {
static_assert ( !is_transparent<std::plus<int>>::value, "" ); static_assert ( !is_transparent<std::plus<int>>::value, "" );
Show All 31 Lines

libcxx/test/std/utilities/function.objects/bitwise.operations/transparent.pass.cpp

Show All 12 Lines
#include "test_macros.h" #include "test_macros.h"
template <class T> template <class T>
struct is_transparent struct is_transparent
{ {
private: private:
struct two {char lx; char lxx;}; struct two {char lx; char lxx;};
template <class U> static two test(...); template <class U> static two test(...);
template <class U> static char test(typename U::is_transparent* = 0); template <class U> static char test(typename U::is_transparent* = nullptr);
public: public:
static const bool value = sizeof(test<T>(0)) == 1; static const bool value = sizeof(test<T>(0)) == 1;
}; };
int main(int, char**) { int main(int, char**) {
static_assert ( !is_transparent<std::bit_and<int>>::value, "" ); static_assert ( !is_transparent<std::bit_and<int>>::value, "" );
static_assert ( !is_transparent<std::bit_and<std::string>>::value, "" ); static_assert ( !is_transparent<std::bit_and<std::string>>::value, "" );
Show All 20 Lines

libcxx/test/std/utilities/function.objects/comparisons/transparent.pass.cpp

Show All 12 Lines
#include "test_macros.h" #include "test_macros.h"
template <class T> template <class T>
struct is_transparent struct is_transparent
{ {
private: private:
struct two {char lx; char lxx;}; struct two {char lx; char lxx;};
template <class U> static two test(...); template <class U> static two test(...);
template <class U> static char test(typename U::is_transparent* = 0); template <class U> static char test(typename U::is_transparent* = nullptr);
public: public:
static const bool value = sizeof(test<T>(0)) == 1; static const bool value = sizeof(test<T>(0)) == 1;
}; };
int main(int, char**) int main(int, char**)
{ {
static_assert ( !is_transparent<std::less<int>>::value, "" ); static_assert ( !is_transparent<std::less<int>>::value, "" );
Show All 31 Lines

libcxx/test/std/utilities/function.objects/logical.operations/transparent.pass.cpp

Show All 12 Lines
#include "test_macros.h" #include "test_macros.h"
template <class T> template <class T>
struct is_transparent struct is_transparent
{ {
private: private:
struct two {char lx; char lxx;}; struct two {char lx; char lxx;};
template <class U> static two test(...); template <class U> static two test(...);
template <class U> static char test(typename U::is_transparent* = 0); template <class U> static char test(typename U::is_transparent* = nullptr);
public: public:
static const bool value = sizeof(test<T>(0)) == 1; static const bool value = sizeof(test<T>(0)) == 1;
}; };
int main(int, char**) int main(int, char**)
{ {
static_assert ( !is_transparent<std::logical_and<int>>::value, "" ); static_assert ( !is_transparent<std::logical_and<int>>::value, "" );
Show All 16 Lines

libcxx/test/std/utilities/function.objects/refwrap/weak_result.pass.cpp

Show First 20 Lines • Show All 63 Lines • ▼ Show 20 Lines
class C {}; class C {};
template <class T> template <class T>
struct has_result_type struct has_result_type
{ {
private: private:
struct two {char _; char __;}; struct two {char _; char __;};
template <class U> static two test(...); template <class U> static two test(...);
template <class U> static char test(typename U::result_type* = 0); template <class U> static char test(typename U::result_type* = nullptr);
public: public:
static const bool value = sizeof(test<T>(0)) == 1; static const bool value = sizeof(test<T>(0)) == 1;
}; };
int main(int, char**) int main(int, char**)
{ {
static_assert((std::is_same<std::reference_wrapper<functor1>::result_type, static_assert((std::is_same<std::reference_wrapper<functor1>::result_type,
char>::value), ""); char>::value), "");
Show All 24 Lines

libcxx/test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.assign/auto_ptr_Y.pass.cpp

Show First 20 Lines • Show All 49 Lines • ▼ Show 20 Linesint main(int, char**)
std::auto_ptr<A> pA(new A); std::auto_ptr<A> pA(new A);
A* ptrA = pA.get(); A* ptrA = pA.get();
{ {
std::shared_ptr<B> pB(new B); std::shared_ptr<B> pB(new B);
pB = std::move(pA); pB = std::move(pA);
assert(B::count == 1); assert(B::count == 1);
assert(A::count == 1); assert(A::count == 1);
assert(pB.use_count() == 1); assert(pB.use_count() == 1);
assert(pA.get() == 0); assert(pA.get() == nullptr);
assert(pB.get() == ptrA); assert(pB.get() == ptrA);
} }
assert(B::count == 0); assert(B::count == 0);
assert(A::count == 0); assert(A::count == 0);
} }
assert(B::count == 0); assert(B::count == 0);
assert(A::count == 0); assert(A::count == 0);
{ {
std::auto_ptr<A> pA; std::auto_ptr<A> pA;
A* ptrA = pA.get(); A* ptrA = pA.get();
{ {
std::shared_ptr<B> pB(new B); std::shared_ptr<B> pB(new B);
pB = std::move(pA); pB = std::move(pA);
assert(B::count == 0); assert(B::count == 0);
assert(A::count == 0); assert(A::count == 0);
assert(pB.use_count() == 1); assert(pB.use_count() == 1);
assert(pA.get() == 0); assert(pA.get() == nullptr);
assert(pB.get() == ptrA); assert(pB.get() == ptrA);
} }
assert(B::count == 0); assert(B::count == 0);
assert(A::count == 0); assert(A::count == 0);
} }
assert(B::count == 0); assert(B::count == 0);
assert(A::count == 0); assert(A::count == 0);
{ {
std::auto_ptr<A> pA(new A); std::auto_ptr<A> pA(new A);
A* ptrA = pA.get(); A* ptrA = pA.get();
{ {
std::shared_ptr<B> pB; std::shared_ptr<B> pB;
pB = std::move(pA); pB = std::move(pA);
assert(B::count == 1); assert(B::count == 1);
assert(A::count == 1); assert(A::count == 1);
assert(pB.use_count() == 1); assert(pB.use_count() == 1);
assert(pA.get() == 0); assert(pA.get() == nullptr);
assert(pB.get() == ptrA); assert(pB.get() == ptrA);
} }
assert(B::count == 0); assert(B::count == 0);
assert(A::count == 0); assert(A::count == 0);
} }
assert(B::count == 0); assert(B::count == 0);
assert(A::count == 0); assert(A::count == 0);
{ {
std::auto_ptr<A> pA; std::auto_ptr<A> pA;
A* ptrA = pA.get(); A* ptrA = pA.get();
{ {
std::shared_ptr<B> pB; std::shared_ptr<B> pB;
pB = std::move(pA); pB = std::move(pA);
assert(B::count == 0); assert(B::count == 0);
assert(A::count == 0); assert(A::count == 0);
assert(pB.use_count() == 1); assert(pB.use_count() == 1);
assert(pA.get() == 0); assert(pA.get() == nullptr);
assert(pB.get() == ptrA); assert(pB.get() == ptrA);
} }
assert(B::count == 0); assert(B::count == 0);
assert(A::count == 0); assert(A::count == 0);
} }
assert(B::count == 0); assert(B::count == 0);
assert(A::count == 0); assert(A::count == 0);
return 0; return 0;
} }

libcxx/test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.assign/shared_ptr_Y_rv.pass.cpp

Show First 20 Lines • Show All 50 Lines • ▼ Show 20 Linesint main(int, char**)
A* ptrA = pA.get(); A* ptrA = pA.get();
{ {
std::shared_ptr<B> pB(new B); std::shared_ptr<B> pB(new B);
pB = std::move(pA); pB = std::move(pA);
assert(B::count == 1); assert(B::count == 1);
assert(A::count == 1); assert(A::count == 1);
assert(pB.use_count() == 1); assert(pB.use_count() == 1);
assert(pA.use_count() == 0); assert(pA.use_count() == 0);
assert(pA.get() == 0); assert(pA.get() == nullptr);
assert(pB.get() == ptrA); assert(pB.get() == ptrA);
} }
assert(pA.use_count() == 0); assert(pA.use_count() == 0);
assert(B::count == 0); assert(B::count == 0);
assert(A::count == 0); assert(A::count == 0);
} }
assert(B::count == 0); assert(B::count == 0);
assert(A::count == 0); assert(A::count == 0);
{ {
std::shared_ptr<A> pA; std::shared_ptr<A> pA;
A* ptrA = pA.get(); A* ptrA = pA.get();
{ {
std::shared_ptr<B> pB(new B); std::shared_ptr<B> pB(new B);
pB = std::move(pA); pB = std::move(pA);
assert(B::count == 0); assert(B::count == 0);
assert(A::count == 0); assert(A::count == 0);
assert(pB.use_count() == 0); assert(pB.use_count() == 0);
assert(pA.use_count() == 0); assert(pA.use_count() == 0);
assert(pA.get() == 0); assert(pA.get() == nullptr);
assert(pB.get() == ptrA); assert(pB.get() == ptrA);
} }
assert(pA.use_count() == 0); assert(pA.use_count() == 0);
assert(B::count == 0); assert(B::count == 0);
assert(A::count == 0); assert(A::count == 0);
} }
assert(B::count == 0); assert(B::count == 0);
assert(A::count == 0); assert(A::count == 0);
{ {
std::shared_ptr<A> pA(new A); std::shared_ptr<A> pA(new A);
A* ptrA = pA.get(); A* ptrA = pA.get();
{ {
std::shared_ptr<B> pB; std::shared_ptr<B> pB;
pB = std::move(pA); pB = std::move(pA);
assert(B::count == 1); assert(B::count == 1);
assert(A::count == 1); assert(A::count == 1);
assert(pB.use_count() == 1); assert(pB.use_count() == 1);
assert(pA.use_count() == 0); assert(pA.use_count() == 0);
assert(pA.get() == 0); assert(pA.get() == nullptr);
assert(pB.get() == ptrA); assert(pB.get() == ptrA);
} }
assert(pA.use_count() == 0); assert(pA.use_count() == 0);
assert(B::count == 0); assert(B::count == 0);
assert(A::count == 0); assert(A::count == 0);
} }
assert(B::count == 0); assert(B::count == 0);
assert(A::count == 0); assert(A::count == 0);
{ {
std::shared_ptr<A> pA; std::shared_ptr<A> pA;
A* ptrA = pA.get(); A* ptrA = pA.get();
{ {
std::shared_ptr<B> pB; std::shared_ptr<B> pB;
pB = std::move(pA); pB = std::move(pA);
assert(B::count == 0); assert(B::count == 0);
assert(A::count == 0); assert(A::count == 0);
assert(pB.use_count() == 0); assert(pB.use_count() == 0);
assert(pA.use_count() == 0); assert(pA.use_count() == 0);
assert(pA.get() == 0); assert(pA.get() == nullptr);
assert(pB.get() == ptrA); assert(pB.get() == ptrA);
} }
assert(pA.use_count() == 0); assert(pA.use_count() == 0);
assert(B::count == 0); assert(B::count == 0);
assert(A::count == 0); assert(A::count == 0);
} }
assert(B::count == 0); assert(B::count == 0);
assert(A::count == 0); assert(A::count == 0);
Show All 23 Lines

libcxx/test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.assign/shared_ptr_rv.pass.cpp

Show First 20 Lines • Show All 50 Lines • ▼ Show 20 Linesint main(int, char**)
A* ptrA = pA.get(); A* ptrA = pA.get();
{ {
std::shared_ptr<A> pB(new A); std::shared_ptr<A> pB(new A);
pB = std::move(pA); pB = std::move(pA);
assert(B::count == 1); assert(B::count == 1);
assert(A::count == 1); assert(A::count == 1);
assert(pB.use_count() == 1); assert(pB.use_count() == 1);
assert(pA.use_count() == 0); assert(pA.use_count() == 0);
assert(pA.get() == 0); assert(pA.get() == nullptr);
assert(pB.get() == ptrA); assert(pB.get() == ptrA);
} }
assert(pA.use_count() == 0); assert(pA.use_count() == 0);
assert(B::count == 0); assert(B::count == 0);
assert(A::count == 0); assert(A::count == 0);
} }
assert(B::count == 0); assert(B::count == 0);
assert(A::count == 0); assert(A::count == 0);
{ {
std::shared_ptr<A> pA; std::shared_ptr<A> pA;
A* ptrA = pA.get(); A* ptrA = pA.get();
{ {
std::shared_ptr<A> pB(new A); std::shared_ptr<A> pB(new A);
pB = std::move(pA); pB = std::move(pA);
assert(B::count == 0); assert(B::count == 0);
assert(A::count == 0); assert(A::count == 0);
assert(pB.use_count() == 0); assert(pB.use_count() == 0);
assert(pA.use_count() == 0); assert(pA.use_count() == 0);
assert(pA.get() == 0); assert(pA.get() == nullptr);
assert(pB.get() == ptrA); assert(pB.get() == ptrA);
} }
assert(pA.use_count() == 0); assert(pA.use_count() == 0);
assert(B::count == 0); assert(B::count == 0);
assert(A::count == 0); assert(A::count == 0);
} }
assert(B::count == 0); assert(B::count == 0);
assert(A::count == 0); assert(A::count == 0);
{ {
std::shared_ptr<A> pA(new A); std::shared_ptr<A> pA(new A);
A* ptrA = pA.get(); A* ptrA = pA.get();
{ {
std::shared_ptr<A> pB; std::shared_ptr<A> pB;
pB = std::move(pA); pB = std::move(pA);
assert(B::count == 1); assert(B::count == 1);
assert(A::count == 1); assert(A::count == 1);
assert(pB.use_count() == 1); assert(pB.use_count() == 1);
assert(pA.use_count() == 0); assert(pA.use_count() == 0);
assert(pA.get() == 0); assert(pA.get() == nullptr);
assert(pB.get() == ptrA); assert(pB.get() == ptrA);
} }
assert(pA.use_count() == 0); assert(pA.use_count() == 0);
assert(B::count == 0); assert(B::count == 0);
assert(A::count == 0); assert(A::count == 0);
} }
assert(B::count == 0); assert(B::count == 0);
assert(A::count == 0); assert(A::count == 0);
{ {
std::shared_ptr<A> pA; std::shared_ptr<A> pA;
A* ptrA = pA.get(); A* ptrA = pA.get();
{ {
std::shared_ptr<A> pB; std::shared_ptr<A> pB;
pB = std::move(pA); pB = std::move(pA);
assert(B::count == 0); assert(B::count == 0);
assert(A::count == 0); assert(A::count == 0);
assert(pB.use_count() == 0); assert(pB.use_count() == 0);
assert(pA.use_count() == 0); assert(pA.use_count() == 0);
assert(pA.get() == 0); assert(pA.get() == nullptr);
assert(pB.get() == ptrA); assert(pB.get() == ptrA);
} }
assert(pA.use_count() == 0); assert(pA.use_count() == 0);
assert(B::count == 0); assert(B::count == 0);
assert(A::count == 0); assert(A::count == 0);
} }
assert(B::count == 0); assert(B::count == 0);
assert(A::count == 0); assert(A::count == 0);
return 0; return 0;
} }

libcxx/test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.assign/unique_ptr_Y.pass.cpp

Show First 20 Lines • Show All 70 Lines • ▼ Show 20 Linesint main(int, char**)
std::unique_ptr<A> pA(new A); std::unique_ptr<A> pA(new A);
A* ptrA = pA.get(); A* ptrA = pA.get();
{ {
std::shared_ptr<B> pB(new B); std::shared_ptr<B> pB(new B);
pB = std::move(pA); pB = std::move(pA);
assert(B::count == 1); assert(B::count == 1);
assert(A::count == 1); assert(A::count == 1);
assert(pB.use_count() == 1); assert(pB.use_count() == 1);
assert(pA.get() == 0); assert(pA.get() == nullptr);
assert(pB.get() == ptrA); assert(pB.get() == ptrA);
} }
assert(B::count == 0); assert(B::count == 0);
assert(A::count == 0); assert(A::count == 0);
} }
assert(B::count == 0); assert(B::count == 0);
assert(A::count == 0); assert(A::count == 0);
{ {
std::unique_ptr<A> pA; std::unique_ptr<A> pA;
A* ptrA = pA.get(); A* ptrA = pA.get();
{ {
std::shared_ptr<B> pB(new B); std::shared_ptr<B> pB(new B);
pB = std::move(pA); pB = std::move(pA);
assert(B::count == 0); assert(B::count == 0);
assert(A::count == 0); assert(A::count == 0);
// assert(pB.use_count() == 1); // no longer true due to LWG 2415 // assert(pB.use_count() == 1); // no longer true due to LWG 2415
assert(pA.get() == 0); assert(pA.get() == nullptr);
assert(pB.get() == ptrA); assert(pB.get() == ptrA);
} }
assert(B::count == 0); assert(B::count == 0);
assert(A::count == 0); assert(A::count == 0);
} }
assert(B::count == 0); assert(B::count == 0);
assert(A::count == 0); assert(A::count == 0);
{ {
std::unique_ptr<A> pA(new A); std::unique_ptr<A> pA(new A);
A* ptrA = pA.get(); A* ptrA = pA.get();
{ {
std::shared_ptr<B> pB; std::shared_ptr<B> pB;
pB = std::move(pA); pB = std::move(pA);
assert(B::count == 1); assert(B::count == 1);
assert(A::count == 1); assert(A::count == 1);
assert(pB.use_count() == 1); assert(pB.use_count() == 1);
assert(pA.get() == 0); assert(pA.get() == nullptr);
assert(pB.get() == ptrA); assert(pB.get() == ptrA);
} }
assert(B::count == 0); assert(B::count == 0);
assert(A::count == 0); assert(A::count == 0);
} }
assert(B::count == 0); assert(B::count == 0);
assert(A::count == 0); assert(A::count == 0);
{ {
std::unique_ptr<A> pA; std::unique_ptr<A> pA;
A* ptrA = pA.get(); A* ptrA = pA.get();
{ {
std::shared_ptr<B> pB; std::shared_ptr<B> pB;
pB = std::move(pA); pB = std::move(pA);
assert(B::count == 0); assert(B::count == 0);
assert(A::count == 0); assert(A::count == 0);
// assert(pB.use_count() == 1); // no longer true due to LWG 2415 // assert(pB.use_count() == 1); // no longer true due to LWG 2415
assert(pA.get() == 0); assert(pA.get() == nullptr);
assert(pB.get() == ptrA); assert(pB.get() == ptrA);
} }
assert(B::count == 0); assert(B::count == 0);
assert(A::count == 0); assert(A::count == 0);
} }
assert(B::count == 0); assert(B::count == 0);
assert(A::count == 0); assert(A::count == 0);
Show All 12 Lines#if TEST_STD_VER > 14
{ {
std::unique_ptr<A[]> ptr(new A[8]); std::unique_ptr<A[]> ptr(new A[8]);
A* raw_ptr = ptr.get(); A* raw_ptr = ptr.get();
std::shared_ptr<A[]> p; std::shared_ptr<A[]> p;
p = std::move(ptr); p = std::move(ptr);
assert(A::count == 8); assert(A::count == 8);
assert(p.use_count() == 1); assert(p.use_count() == 1);
assert(p.get() == raw_ptr); assert(p.get() == raw_ptr);
assert(ptr.get() == 0); assert(ptr.get() == nullptr);
} }
assert(A::count == 0); assert(A::count == 0);
{ {
std::unique_ptr<int[]> ptr(new int[8]); std::unique_ptr<int[]> ptr(new int[8]);
std::shared_ptr<int[]> p; std::shared_ptr<int[]> p;
p = std::move(ptr); p = std::move(ptr);
} }
#endif // TEST_STD_VER >= 14 #endif // TEST_STD_VER >= 14
return 0; return 0;
} }

libcxx/test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.cast/dynamic_pointer_cast.pass.cpp

Show First 20 Lines • Show All 48 Lines • ▼ Show 20 Linesint main(int, char**)
const std::shared_ptr<B> pB(new A); const std::shared_ptr<B> pB(new A);
std::shared_ptr<A> pA = std::dynamic_pointer_cast<A>(pB); std::shared_ptr<A> pA = std::dynamic_pointer_cast<A>(pB);
assert(pA.get() == pB.get()); assert(pA.get() == pB.get());
assert(!pB.owner_before(pA) && !pA.owner_before(pB)); assert(!pB.owner_before(pA) && !pA.owner_before(pB));
} }
{ {
const std::shared_ptr<B> pB(new B); const std::shared_ptr<B> pB(new B);
std::shared_ptr<A> pA = std::dynamic_pointer_cast<A>(pB); std::shared_ptr<A> pA = std::dynamic_pointer_cast<A>(pB);
assert(pA.get() == 0); assert(pA.get() == nullptr);
assert(pA.use_count() == 0); assert(pA.use_count() == 0);
} }
#if TEST_STD_VER > 14 #if TEST_STD_VER > 14
{ {
const std::shared_ptr<B[8]> pB(new B[8]); const std::shared_ptr<B[8]> pB(new B[8]);
std::shared_ptr<A[8]> pA = std::dynamic_pointer_cast<A[8]>(pB); std::shared_ptr<A[8]> pA = std::dynamic_pointer_cast<A[8]>(pB);
assert(pA.get() == 0); assert(pA.get() == nullptr);
assert(pA.use_count() == 0); assert(pA.use_count() == 0);
} }
#endif // TEST_STD_VER > 14 #endif // TEST_STD_VER > 14
return 0; return 0;
} }

libcxx/test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.const/auto_ptr.pass.cpp

Show First 20 Lines • Show All 49 Lines • ▼ Show 20 Linesint main(int, char**)
{ {
std::auto_ptr<A> ptr(new A); std::auto_ptr<A> ptr(new A);
A* raw_ptr = ptr.get(); A* raw_ptr = ptr.get();
std::shared_ptr<B> p(std::move(ptr)); std::shared_ptr<B> p(std::move(ptr));
assert(A::count == 1); assert(A::count == 1);
assert(B::count == 1); assert(B::count == 1);
assert(p.use_count() == 1); assert(p.use_count() == 1);
assert(p.get() == raw_ptr); assert(p.get() == raw_ptr);
assert(ptr.get() == 0); assert(ptr.get() == nullptr);
} }
assert(A::count == 0); assert(A::count == 0);
assert(globalMemCounter.checkOutstandingNewEq(0)); assert(globalMemCounter.checkOutstandingNewEq(0));
globalMemCounter.reset(); globalMemCounter.reset();
{ {
std::auto_ptr<A const> ptr(new A); std::auto_ptr<A const> ptr(new A);
A const* raw_ptr = ptr.get(); A const* raw_ptr = ptr.get();
std::shared_ptr<B const> p(std::move(ptr)); std::shared_ptr<B const> p(std::move(ptr));
assert(A::count == 1); assert(A::count == 1);
assert(B::count == 1); assert(B::count == 1);
assert(p.use_count() == 1); assert(p.use_count() == 1);
assert(p.get() == raw_ptr); assert(p.get() == raw_ptr);
assert(ptr.get() == 0); assert(ptr.get() == nullptr);
} }
assert(A::count == 0); assert(A::count == 0);
assert(globalMemCounter.checkOutstandingNewEq(0)); assert(globalMemCounter.checkOutstandingNewEq(0));
#if !defined(TEST_HAS_NO_EXCEPTIONS) && !defined(DISABLE_NEW_COUNT) #if !defined(TEST_HAS_NO_EXCEPTIONS) && !defined(DISABLE_NEW_COUNT)
{ {
std::auto_ptr<A> ptr(new A); std::auto_ptr<A> ptr(new A);
A* raw_ptr = ptr.get(); A* raw_ptr = ptr.get();
Show All 19 Lines

libcxx/test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.const/default.pass.cpp

Show All 15 Lines
#include "test_macros.h" #include "test_macros.h"
struct A {}; struct A {};
template <class T> template <class T>
void test() { void test() {
std::shared_ptr<T> p; std::shared_ptr<T> p;
assert(p.use_count() == 0); assert(p.use_count() == 0);
assert(p.get() == 0); assert(p.get() == nullptr);
} }
int main(int, char**) { int main(int, char**) {
test<int>(); test<int>();
test<int const>(); test<int const>();
test<A>(); test<A>();
test<A const>(); test<A const>();
test<int*>(); test<int*>();
test<int const*>(); test<int const*>();
test<int[]>(); test<int[]>();
test<int[8]>(); test<int[8]>();
return 0; return 0;
} }

libcxx/test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.const/nullptr_t.pass.cpp

Show All 14 Lines
#include "test_macros.h" #include "test_macros.h"
int main(int, char**) int main(int, char**)
{ {
{ {
std::shared_ptr<int> p(nullptr); std::shared_ptr<int> p(nullptr);
assert(p.use_count() == 0); assert(p.use_count() == 0);
assert(p.get() == 0); assert(p.get() == nullptr);
} }
{ {
std::shared_ptr<int const> p(nullptr); std::shared_ptr<int const> p(nullptr);
assert(p.use_count() == 0); assert(p.use_count() == 0);
assert(p.get() == 0); assert(p.get() == nullptr);
} }
return 0; return 0;
} }

libcxx/test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.const/nullptr_t_deleter.pass.cpp

Show All 28 Lines
int A::count = 0; int A::count = 0;
int main(int, char**) int main(int, char**)
{ {
{ {
std::shared_ptr<A> p(nullptr, test_deleter<A>(3)); std::shared_ptr<A> p(nullptr, test_deleter<A>(3));
assert(A::count == 0); assert(A::count == 0);
assert(p.use_count() == 1); assert(p.use_count() == 1);
assert(p.get() == 0); assert(p.get() == nullptr);
assert(test_deleter<A>::count == 1); assert(test_deleter<A>::count == 1);
assert(test_deleter<A>::dealloc_count == 0); assert(test_deleter<A>::dealloc_count == 0);
#ifndef TEST_HAS_NO_RTTI #ifndef TEST_HAS_NO_RTTI
test_deleter<A>* d = std::get_deleter<test_deleter<A> >(p); test_deleter<A>* d = std::get_deleter<test_deleter<A> >(p);
assert(d); assert(d);
assert(d->state() == 3); assert(d->state() == 3);
#endif #endif
} }
Show All 11 Lines

libcxx/test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.const/nullptr_t_deleter_allocator.pass.cpp

Show All 29 Lines
int main(int, char**) int main(int, char**)
{ {
test_allocator_statistics alloc_stats; test_allocator_statistics alloc_stats;
{ {
std::shared_ptr<A> p(nullptr, test_deleter<A>(3), test_allocator<A>(5, &alloc_stats)); std::shared_ptr<A> p(nullptr, test_deleter<A>(3), test_allocator<A>(5, &alloc_stats));
assert(A::count == 0); assert(A::count == 0);
assert(p.use_count() == 1); assert(p.use_count() == 1);
assert(p.get() == 0); assert(p.get() == nullptr);
assert(test_deleter<A>::count == 1); assert(test_deleter<A>::count == 1);
assert(test_deleter<A>::dealloc_count == 0); assert(test_deleter<A>::dealloc_count == 0);
#ifndef TEST_HAS_NO_RTTI #ifndef TEST_HAS_NO_RTTI
test_deleter<A>* d = std::get_deleter<test_deleter<A> >(p); test_deleter<A>* d = std::get_deleter<test_deleter<A> >(p);
assert(d); assert(d);
assert(d->state() == 3); assert(d->state() == 3);
#endif #endif
assert(alloc_stats.count == 1); assert(alloc_stats.count == 1);
assert(alloc_stats.alloc_count == 1); assert(alloc_stats.alloc_count == 1);
} }
assert(A::count == 0); assert(A::count == 0);
assert(test_deleter<A>::count == 0); assert(test_deleter<A>::count == 0);
assert(test_deleter<A>::dealloc_count == 1); assert(test_deleter<A>::dealloc_count == 1);
assert(alloc_stats.count == 0); assert(alloc_stats.count == 0);
assert(alloc_stats.alloc_count == 0); assert(alloc_stats.alloc_count == 0);
test_deleter<A>::dealloc_count = 0; test_deleter<A>::dealloc_count = 0;
// Test an allocator with a minimal interface // Test an allocator with a minimal interface
{ {
std::shared_ptr<A> p(nullptr, test_deleter<A>(1), bare_allocator<void>()); std::shared_ptr<A> p(nullptr, test_deleter<A>(1), bare_allocator<void>());
assert(A::count == 0); assert(A::count == 0);
assert(p.use_count() == 1); assert(p.use_count() == 1);
assert(p.get() == 0); assert(p.get() == nullptr);
assert(test_deleter<A>::count ==1); assert(test_deleter<A>::count ==1);
assert(test_deleter<A>::dealloc_count == 0); assert(test_deleter<A>::dealloc_count == 0);
#ifndef TEST_HAS_NO_RTTI #ifndef TEST_HAS_NO_RTTI
test_deleter<A>* d = std::get_deleter<test_deleter<A> >(p); test_deleter<A>* d = std::get_deleter<test_deleter<A> >(p);
assert(d); assert(d);
assert(d->state() == 1); assert(d->state() == 1);
#endif #endif
} }
assert(A::count == 0); assert(A::count == 0);
assert(test_deleter<A>::count == 0); assert(test_deleter<A>::count == 0);
assert(test_deleter<A>::dealloc_count == 1); assert(test_deleter<A>::dealloc_count == 1);
test_deleter<A>::dealloc_count = 0; test_deleter<A>::dealloc_count = 0;
#if TEST_STD_VER >= 11 #if TEST_STD_VER >= 11
// Test an allocator that returns class-type pointers // Test an allocator that returns class-type pointers
{ {
std::shared_ptr<A> p(nullptr, test_deleter<A>(1), min_allocator<void>()); std::shared_ptr<A> p(nullptr, test_deleter<A>(1), min_allocator<void>());
assert(A::count == 0); assert(A::count == 0);
assert(p.use_count() == 1); assert(p.use_count() == 1);
assert(p.get() == 0); assert(p.get() == nullptr);
assert(test_deleter<A>::count ==1); assert(test_deleter<A>::count ==1);
assert(test_deleter<A>::dealloc_count == 0); assert(test_deleter<A>::dealloc_count == 0);
#ifndef TEST_HAS_NO_RTTI #ifndef TEST_HAS_NO_RTTI
test_deleter<A>* d = std::get_deleter<test_deleter<A> >(p); test_deleter<A>* d = std::get_deleter<test_deleter<A> >(p);
assert(d); assert(d);
assert(d->state() == 1); assert(d->state() == 1);
#endif #endif
} }
Show All 13 Lines

libcxx/test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.const/unique_ptr.pass.cpp

Show First 20 Lines • Show All 104 Lines • ▼ Show 20 Linesint main(int, char**)
{ {
std::unique_ptr<A> ptr(new A); std::unique_ptr<A> ptr(new A);
A* raw_ptr = ptr.get(); A* raw_ptr = ptr.get();
std::shared_ptr<B> p(std::move(ptr)); std::shared_ptr<B> p(std::move(ptr));
assert(A::count == 1); assert(A::count == 1);
assert(B::count == 1); assert(B::count == 1);
assert(p.use_count() == 1); assert(p.use_count() == 1);
assert(p.get() == raw_ptr); assert(p.get() == raw_ptr);
assert(ptr.get() == 0); assert(ptr.get() == nullptr);
} }
{ {
std::unique_ptr<A const> ptr(new A); std::unique_ptr<A const> ptr(new A);
A const* raw_ptr = ptr.get(); A const* raw_ptr = ptr.get();
std::shared_ptr<B const> p(std::move(ptr)); std::shared_ptr<B const> p(std::move(ptr));
assert(A::count == 1); assert(A::count == 1);
assert(B::count == 1); assert(B::count == 1);
assert(p.use_count() == 1); assert(p.use_count() == 1);
assert(p.get() == raw_ptr); assert(p.get() == raw_ptr);
assert(ptr.get() == 0); assert(ptr.get() == nullptr);
} }
#ifndef TEST_HAS_NO_EXCEPTIONS #ifndef TEST_HAS_NO_EXCEPTIONS
assert(A::count == 0); assert(A::count == 0);
{ {
std::unique_ptr<A> ptr(new A); std::unique_ptr<A> ptr(new A);
A* raw_ptr = ptr.get(); A* raw_ptr = ptr.get();
globalMemCounter.throw_after = 0; globalMemCounter.throw_after = 0;
Show All 10 Lines assert(A::count == 0);
} }
} }
#endif #endif
#if TEST_STD_VER > 14 #if TEST_STD_VER > 14
{ {
std::unique_ptr<int> ptr; std::unique_ptr<int> ptr;
std::shared_ptr<int> p(std::move(ptr)); std::shared_ptr<int> p(std::move(ptr));
assert(p.get() == 0); assert(p.get() == nullptr);
assert(p.use_count() == 0); assert(p.use_count() == 0);
} }
#endif #endif
{ {
StatefulDeleter<A> d; StatefulDeleter<A> d;
std::unique_ptr<A, StatefulDeleter<A>&> u(new A, d); std::unique_ptr<A, StatefulDeleter<A>&> u(new A, d);
std::shared_ptr<A> p(std::move(u)); std::shared_ptr<A> p(std::move(u));
Show All 33 Lines#if TEST_STD_VER > 14
{ {
std::unique_ptr<A[]> ptr(new A[8]); std::unique_ptr<A[]> ptr(new A[8]);
A* raw_ptr = ptr.get(); A* raw_ptr = ptr.get();
std::shared_ptr<A[]> p(std::move(ptr)); std::shared_ptr<A[]> p(std::move(ptr));
assert(A::count == 8); assert(A::count == 8);
assert(p.use_count() == 1); assert(p.use_count() == 1);
assert(p.get() == raw_ptr); assert(p.get() == raw_ptr);
assert(ptr.get() == 0); assert(ptr.get() == nullptr);
} }
assert(A::count == 0); assert(A::count == 0);
{ {
int *p = new int[8]; int *p = new int[8];
std::unique_ptr<int[]> u(p); std::unique_ptr<int[]> u(p);
std::shared_ptr<int[]> s(std::move(u)); std::shared_ptr<int[]> s(std::move(u));
assert(u == nullptr); assert(u == nullptr);
Show All 32 Lines

libcxx/test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.mod/reset.pass.cpp

Show First 20 Lines • Show All 42 Lines • ▼ Show 20 Lines
int main(int, char**) int main(int, char**)
{ {
{ {
std::shared_ptr<B> p(new B); std::shared_ptr<B> p(new B);
p.reset(); p.reset();
assert(A::count == 0); assert(A::count == 0);
assert(B::count == 0); assert(B::count == 0);
assert(p.use_count() == 0); assert(p.use_count() == 0);
assert(p.get() == 0); assert(p.get() == nullptr);
} }
assert(A::count == 0); assert(A::count == 0);
{ {
std::shared_ptr<B> p; std::shared_ptr<B> p;
p.reset(); p.reset();
assert(A::count == 0); assert(A::count == 0);
assert(B::count == 0); assert(B::count == 0);
assert(p.use_count() == 0); assert(p.use_count() == 0);
assert(p.get() == 0); assert(p.get() == nullptr);
} }
assert(A::count == 0); assert(A::count == 0);
return 0; return 0;
} }

libcxx/test/std/utilities/memory/util.smartptr/util.smartptr.weak/util.smartptr.weak.obs/lock.pass.cpp

Show All 28 Lines
int A::count = 0; int A::count = 0;
int main(int, char**) int main(int, char**)
{ {
{ {
std::weak_ptr<A> wp; std::weak_ptr<A> wp;
std::shared_ptr<A> sp = wp.lock(); std::shared_ptr<A> sp = wp.lock();
assert(sp.use_count() == 0); assert(sp.use_count() == 0);
assert(sp.get() == 0); assert(sp.get() == nullptr);
assert(A::count == 0); assert(A::count == 0);
} }
{ {
std::shared_ptr<A> sp0(new A); std::shared_ptr<A> sp0(new A);
std::weak_ptr<A> wp(sp0); std::weak_ptr<A> wp(sp0);
std::shared_ptr<A> sp = wp.lock(); std::shared_ptr<A> sp = wp.lock();
assert(sp.use_count() == 2); assert(sp.use_count() == 2);
assert(sp.get() == sp0.get()); assert(sp.get() == sp0.get());
assert(A::count == 1); assert(A::count == 1);
} }
assert(A::count == 0); assert(A::count == 0);
{ {
std::shared_ptr<A> sp0(new A); std::shared_ptr<A> sp0(new A);
std::weak_ptr<A> wp(sp0); std::weak_ptr<A> wp(sp0);
sp0.reset(); sp0.reset();
std::shared_ptr<A> sp = wp.lock(); std::shared_ptr<A> sp = wp.lock();
assert(sp.use_count() == 0); assert(sp.use_count() == 0);
assert(sp.get() == 0); assert(sp.get() == nullptr);
assert(A::count == 0); assert(A::count == 0);
} }
assert(A::count == 0); assert(A::count == 0);
return 0; return 0;
} }

libcxx/test/std/utilities/smartptr/unique.ptr/unique.ptr.class/unique.ptr.asgn/move.pass.cpp

Show All 40 Lines const int expect_alive = IsArray ? 5 : 1;
A* p = s1.get(); A* p = s1.get();
std::unique_ptr<VT> s2(newValue<VT>(expect_alive)); std::unique_ptr<VT> s2(newValue<VT>(expect_alive));
if (!TEST_IS_CONSTANT_EVALUATED) if (!TEST_IS_CONSTANT_EVALUATED)
assert(A::count == (expect_alive * 2)); assert(A::count == (expect_alive * 2));
s2 = std::move(s1); s2 = std::move(s1);
if (!TEST_IS_CONSTANT_EVALUATED) if (!TEST_IS_CONSTANT_EVALUATED)
assert(A::count == expect_alive); assert(A::count == expect_alive);
assert(s2.get() == p); assert(s2.get() == p);
assert(s1.get() == 0); assert(s1.get() == nullptr);
} }
if (!TEST_IS_CONSTANT_EVALUATED) if (!TEST_IS_CONSTANT_EVALUATED)
assert(A::count == 0); assert(A::count == 0);
{ {
std::unique_ptr<VT, Deleter<VT> > s1(newValue<VT>(expect_alive), std::unique_ptr<VT, Deleter<VT> > s1(newValue<VT>(expect_alive),
Deleter<VT>(5)); Deleter<VT>(5));
A* p = s1.get(); A* p = s1.get();
std::unique_ptr<VT, Deleter<VT> > s2(newValue<VT>(expect_alive)); std::unique_ptr<VT, Deleter<VT> > s2(newValue<VT>(expect_alive));
if (!TEST_IS_CONSTANT_EVALUATED) if (!TEST_IS_CONSTANT_EVALUATED)
assert(A::count == (expect_alive * 2)); assert(A::count == (expect_alive * 2));
s2 = std::move(s1); s2 = std::move(s1);
assert(s2.get() == p); assert(s2.get() == p);
assert(s1.get() == 0); assert(s1.get() == nullptr);
if (!TEST_IS_CONSTANT_EVALUATED) if (!TEST_IS_CONSTANT_EVALUATED)
assert(A::count == expect_alive); assert(A::count == expect_alive);
assert(s2.get_deleter().state() == 5); assert(s2.get_deleter().state() == 5);
assert(s1.get_deleter().state() == 0); assert(s1.get_deleter().state() == 0);
} }
if (!TEST_IS_CONSTANT_EVALUATED) if (!TEST_IS_CONSTANT_EVALUATED)
assert(A::count == 0); assert(A::count == 0);
{ {
CDeleter<VT> d1(5); CDeleter<VT> d1(5);
std::unique_ptr<VT, CDeleter<VT>&> s1(newValue<VT>(expect_alive), d1); std::unique_ptr<VT, CDeleter<VT>&> s1(newValue<VT>(expect_alive), d1);
A* p = s1.get(); A* p = s1.get();
CDeleter<VT> d2(6); CDeleter<VT> d2(6);
std::unique_ptr<VT, CDeleter<VT>&> s2(newValue<VT>(expect_alive), d2); std::unique_ptr<VT, CDeleter<VT>&> s2(newValue<VT>(expect_alive), d2);
s2 = std::move(s1); s2 = std::move(s1);
assert(s2.get() == p); assert(s2.get() == p);
assert(s1.get() == 0); assert(s1.get() == nullptr);
if (!TEST_IS_CONSTANT_EVALUATED) if (!TEST_IS_CONSTANT_EVALUATED)
assert(A::count == expect_alive); assert(A::count == expect_alive);
assert(d1.state() == 5); assert(d1.state() == 5);
assert(d2.state() == 5); assert(d2.state() == 5);
} }
if (!TEST_IS_CONSTANT_EVALUATED) if (!TEST_IS_CONSTANT_EVALUATED)
assert(A::count == 0); assert(A::count == 0);
{ {
▲ Show 20 Lines • Show All 65 Lines • Show Last 20 Lines

libcxx/test/std/utilities/smartptr/unique.ptr/unique.ptr.class/unique.ptr.asgn/move_convert.runtime.pass.cpp

Show All 21 Lines
#include "unique_ptr_test_helper.h" #include "unique_ptr_test_helper.h"
template <class APtr, class BPtr> template <class APtr, class BPtr>
void testAssign(APtr& aptr, BPtr& bptr) { void testAssign(APtr& aptr, BPtr& bptr) {
A* p = bptr.get(); A* p = bptr.get();
assert(A::count == 2); assert(A::count == 2);
aptr = std::move(bptr); aptr = std::move(bptr);
assert(aptr.get() == p); assert(aptr.get() == p);
assert(bptr.get() == 0); assert(bptr.get() == nullptr);
assert(A::count == 1); assert(A::count == 1);
assert(B::count == 1); assert(B::count == 1);
} }
template <class LHS, class RHS> template <class LHS, class RHS>
void checkDeleter(LHS& lhs, RHS& rhs, int LHSState, int RHSState) { void checkDeleter(LHS& lhs, RHS& rhs, int LHSState, int RHSState) {
assert(lhs.get_deleter().state() == LHSState); assert(lhs.get_deleter().state() == LHSState);
assert(rhs.get_deleter().state() == RHSState); assert(rhs.get_deleter().state() == RHSState);
▲ Show 20 Lines • Show All 85 Lines • Show Last 20 Lines

libcxx/test/std/utilities/smartptr/unique.ptr/unique.ptr.class/unique.ptr.asgn/move_convert.single.pass.cpp

Show All 23 Lines
template <class APtr, class BPtr> template <class APtr, class BPtr>
TEST_CONSTEXPR_CXX23 void testAssign(APtr& aptr, BPtr& bptr) { TEST_CONSTEXPR_CXX23 void testAssign(APtr& aptr, BPtr& bptr) {
A* p = bptr.get(); A* p = bptr.get();
if (!TEST_IS_CONSTANT_EVALUATED) if (!TEST_IS_CONSTANT_EVALUATED)
assert(A::count == 2); assert(A::count == 2);
aptr = std::move(bptr); aptr = std::move(bptr);
assert(aptr.get() == p); assert(aptr.get() == p);
assert(bptr.get() == 0); assert(bptr.get() == nullptr);
if (!TEST_IS_CONSTANT_EVALUATED) { if (!TEST_IS_CONSTANT_EVALUATED) {
assert(A::count == 1); assert(A::count == 1);
assert(B::count == 1); assert(B::count == 1);
} }
} }
template <class LHS, class RHS> template <class LHS, class RHS>
TEST_CONSTEXPR_CXX23 void checkDeleter(LHS& lhs, RHS& rhs, int LHSState, int RHSState) { TEST_CONSTEXPR_CXX23 void checkDeleter(LHS& lhs, RHS& rhs, int LHSState, int RHSState) {
▲ Show 20 Lines • Show All 125 Lines • Show Last 20 Lines

libcxx/test/std/utilities/smartptr/unique.ptr/unique.ptr.class/unique.ptr.asgn/null.pass.cpp

Show All 24 LinesTEST_CONSTEXPR_CXX23 void test_basic() {
const int expect_alive = IsArray ? 5 : 1; const int expect_alive = IsArray ? 5 : 1;
{ {
std::unique_ptr<VT> s2(newValue<VT>(expect_alive)); std::unique_ptr<VT> s2(newValue<VT>(expect_alive));
if (!TEST_IS_CONSTANT_EVALUATED) if (!TEST_IS_CONSTANT_EVALUATED)
assert(A::count == expect_alive); assert(A::count == expect_alive);
s2 = NULL; s2 = NULL;
if (!TEST_IS_CONSTANT_EVALUATED) if (!TEST_IS_CONSTANT_EVALUATED)
assert(A::count == 0); assert(A::count == 0);
assert(s2.get() == 0); assert(s2.get() == nullptr);
} }
if (!TEST_IS_CONSTANT_EVALUATED) if (!TEST_IS_CONSTANT_EVALUATED)
assert(A::count == 0); assert(A::count == 0);
} }
TEST_CONSTEXPR_CXX23 bool test() { TEST_CONSTEXPR_CXX23 bool test() {
test_basic</*IsArray*/ false>(); test_basic</*IsArray*/ false>();
test_basic<true>(); test_basic<true>();
Show All 12 Lines

libcxx/test/std/utilities/smartptr/unique.ptr/unique.ptr.class/unique.ptr.asgn/nullptr.pass.cpp

Show All 25 LinesTEST_CONSTEXPR_CXX23 void test_basic() {
const int expect_alive = IsArray ? 5 : 1; const int expect_alive = IsArray ? 5 : 1;
{ {
std::unique_ptr<VT> s2(newValue<VT>(expect_alive)); std::unique_ptr<VT> s2(newValue<VT>(expect_alive));
if (!TEST_IS_CONSTANT_EVALUATED) if (!TEST_IS_CONSTANT_EVALUATED)
assert(A::count == expect_alive); assert(A::count == expect_alive);
s2 = nullptr; s2 = nullptr;
if (!TEST_IS_CONSTANT_EVALUATED) if (!TEST_IS_CONSTANT_EVALUATED)
assert(A::count == 0); assert(A::count == 0);
assert(s2.get() == 0); assert(s2.get() == nullptr);
} }
if (!TEST_IS_CONSTANT_EVALUATED) if (!TEST_IS_CONSTANT_EVALUATED)
assert(A::count == 0); assert(A::count == 0);
} }
TEST_CONSTEXPR_CXX23 bool test() { TEST_CONSTEXPR_CXX23 bool test() {
test_basic</*IsArray*/ false>(); test_basic</*IsArray*/ false>();
test_basic<true>(); test_basic<true>();
Show All 12 Lines

libcxx/test/std/utilities/smartptr/unique.ptr/unique.ptr.class/unique.ptr.ctor/auto_pointer.pass.cpp

Show First 20 Lines • Show All 62 Lines • ▼ Show 20 Lines
} }
int main(int, char**) { int main(int, char**) {
{ {
B* p = new B; B* p = new B;
std::auto_ptr<B> ap(p); std::auto_ptr<B> ap(p);
std::unique_ptr<A> up(std::move(ap)); std::unique_ptr<A> up(std::move(ap));
assert(up.get() == p); assert(up.get() == p);
assert(ap.get() == 0); assert(ap.get() == nullptr);
assert(A::count == 1); assert(A::count == 1);
assert(B::count == 1); assert(B::count == 1);
} }
assert(A::count == 0); assert(A::count == 0);
assert(B::count == 0); assert(B::count == 0);
{ {
B* p = new B; B* p = new B;
std::auto_ptr<B> ap(p); std::auto_ptr<B> ap(p);
std::unique_ptr<A> up; std::unique_ptr<A> up;
up = std::move(ap); up = std::move(ap);
assert(up.get() == p); assert(up.get() == p);
assert(ap.get() == 0); assert(ap.get() == nullptr);
assert(A::count == 1); assert(A::count == 1);
assert(B::count == 1); assert(B::count == 1);
} }
assert(A::count == 0); assert(A::count == 0);
assert(B::count == 0); assert(B::count == 0);
#if TEST_STD_VER >= 11 #if TEST_STD_VER >= 11
{ {
static_assert(std::is_nothrow_constructible<std::unique_ptr<A>, static_assert(std::is_nothrow_constructible<std::unique_ptr<A>,
std::auto_ptr<B>&&>::value, std::auto_ptr<B>&&>::value,
""); "");
} }
#endif #endif
test_sfinae(); test_sfinae();
return 0; return 0;
} }

libcxx/test/std/utilities/smartptr/unique.ptr/unique.ptr.class/unique.ptr.ctor/default.pass.cpp

Show First 20 Lines • Show All 67 Lines • ▼ Show 20 Lines#if TEST_STD_VER >= 11
using U1 = std::unique_ptr<ElemType>; using U1 = std::unique_ptr<ElemType>;
using U2 = std::unique_ptr<ElemType, Deleter<ElemType> >; using U2 = std::unique_ptr<ElemType, Deleter<ElemType> >;
static_assert(std::is_nothrow_default_constructible<U1>::value, ""); static_assert(std::is_nothrow_default_constructible<U1>::value, "");
static_assert(std::is_nothrow_default_constructible<U2>::value, ""); static_assert(std::is_nothrow_default_constructible<U2>::value, "");
} }
#endif #endif
{ {
std::unique_ptr<ElemType> p; std::unique_ptr<ElemType> p;
assert(p.get() == 0); assert(p.get() == nullptr);
} }
{ {
std::unique_ptr<ElemType, NCDeleter<ElemType> > p; std::unique_ptr<ElemType, NCDeleter<ElemType> > p;
assert(p.get() == 0); assert(p.get() == nullptr);
assert(p.get_deleter().state() == 0); assert(p.get_deleter().state() == 0);
p.get_deleter().set_state(5); p.get_deleter().set_state(5);
assert(p.get_deleter().state() == 5); assert(p.get_deleter().state() == 5);
} }
{ {
std::unique_ptr<ElemType, DefaultCtorDeleter<ElemType> > p; std::unique_ptr<ElemType, DefaultCtorDeleter<ElemType> > p;
assert(p.get() == 0); assert(p.get() == nullptr);
assert(p.get_deleter().state() == 0); assert(p.get_deleter().state() == 0);
} }
return true; return true;
} }
DEFINE_AND_RUN_IS_INCOMPLETE_TEST({ DEFINE_AND_RUN_IS_INCOMPLETE_TEST({
doIncompleteTypeTest(0); doIncompleteTypeTest(0);
Show All 27 Lines

libcxx/test/std/utilities/smartptr/unique.ptr/unique.ptr.class/unique.ptr.ctor/move.pass.cpp

Show First 20 Lines • Show All 84 Lines • ▼ Show 20 LinesTEST_CONSTEXPR_CXX23 void test_basic() {
typedef typename std::conditional<!IsArray, A, A[]>::type VT; typedef typename std::conditional<!IsArray, A, A[]>::type VT;
const int expect_alive = IsArray ? 5 : 1; const int expect_alive = IsArray ? 5 : 1;
{ {
typedef std::unique_ptr<VT> APtr; typedef std::unique_ptr<VT> APtr;
APtr s(newValue<VT>(expect_alive)); APtr s(newValue<VT>(expect_alive));
A* p = s.get(); A* p = s.get();
APtr s2 = std::move(s); APtr s2 = std::move(s);
assert(s2.get() == p); assert(s2.get() == p);
assert(s.get() == 0); assert(s.get() == nullptr);
if (!TEST_IS_CONSTANT_EVALUATED) if (!TEST_IS_CONSTANT_EVALUATED)
assert(A::count == expect_alive); assert(A::count == expect_alive);
} }
if (!TEST_IS_CONSTANT_EVALUATED) if (!TEST_IS_CONSTANT_EVALUATED)
assert(A::count == 0); assert(A::count == 0);
{ {
typedef Deleter<VT> MoveDel; typedef Deleter<VT> MoveDel;
typedef std::unique_ptr<VT, MoveDel> APtr; typedef std::unique_ptr<VT, MoveDel> APtr;
MoveDel d(5); MoveDel d(5);
APtr s(newValue<VT>(expect_alive), std::move(d)); APtr s(newValue<VT>(expect_alive), std::move(d));
assert(d.state() == 0); assert(d.state() == 0);
assert(s.get_deleter().state() == 5); assert(s.get_deleter().state() == 5);
A* p = s.get(); A* p = s.get();
APtr s2 = std::move(s); APtr s2 = std::move(s);
assert(s2.get() == p); assert(s2.get() == p);
assert(s.get() == 0); assert(s.get() == nullptr);
if (!TEST_IS_CONSTANT_EVALUATED) if (!TEST_IS_CONSTANT_EVALUATED)
assert(A::count == expect_alive); assert(A::count == expect_alive);
assert(s2.get_deleter().state() == 5); assert(s2.get_deleter().state() == 5);
assert(s.get_deleter().state() == 0); assert(s.get_deleter().state() == 0);
} }
if (!TEST_IS_CONSTANT_EVALUATED) if (!TEST_IS_CONSTANT_EVALUATED)
assert(A::count == 0); assert(A::count == 0);
{ {
typedef NCDeleter<VT> NonCopyDel; typedef NCDeleter<VT> NonCopyDel;
typedef std::unique_ptr<VT, NonCopyDel&> APtr; typedef std::unique_ptr<VT, NonCopyDel&> APtr;
NonCopyDel d; NonCopyDel d;
APtr s(newValue<VT>(expect_alive), d); APtr s(newValue<VT>(expect_alive), d);
A* p = s.get(); A* p = s.get();
APtr s2 = std::move(s); APtr s2 = std::move(s);
assert(s2.get() == p); assert(s2.get() == p);
assert(s.get() == 0); assert(s.get() == nullptr);
if (!TEST_IS_CONSTANT_EVALUATED) if (!TEST_IS_CONSTANT_EVALUATED)
assert(A::count == expect_alive); assert(A::count == expect_alive);
d.set_state(6); d.set_state(6);
assert(s2.get_deleter().state() == d.state()); assert(s2.get_deleter().state() == d.state());
assert(s.get_deleter().state() == d.state()); assert(s.get_deleter().state() == d.state());
} }
if (!TEST_IS_CONSTANT_EVALUATED) if (!TEST_IS_CONSTANT_EVALUATED)
assert(A::count == 0); assert(A::count == 0);
▲ Show 20 Lines • Show All 66 Lines • Show Last 20 Lines

libcxx/test/std/utilities/smartptr/unique.ptr/unique.ptr.class/unique.ptr.ctor/null.pass.cpp

//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// UNSUPPORTED: c++03 // UNSUPPORTED: c++03
// ADDITIONAL_COMPILE_FLAGS: -Wno-zero-as-null-pointer-constant
// <memory> // <memory>
// unique_ptr // unique_ptr
// FIXME(EricWF): This test contains tests for constructing a unique_ptr from NULL. // FIXME(EricWF): This test contains tests for constructing a unique_ptr from NULL.
// The behavior demonstrated in this test is not meant to be standard; It simply // The behavior demonstrated in this test is not meant to be standard; It simply
// tests the current status quo in libc++. // tests the current status quo in libc++.
▲ Show 20 Lines • Show All 67 Lines • Show Last 20 Lines

libcxx/test/std/utilities/smartptr/unique.ptr/unique.ptr.class/unique.ptr.ctor/nullptr.pass.cpp

Show All 34 Lines#if TEST_STD_VER >= 11
using U1 = std::unique_ptr<VT>; using U1 = std::unique_ptr<VT>;
using U2 = std::unique_ptr<VT, Deleter<VT> >; using U2 = std::unique_ptr<VT, Deleter<VT> >;
static_assert(std::is_nothrow_constructible<U1, decltype(nullptr)>::value, ""); static_assert(std::is_nothrow_constructible<U1, decltype(nullptr)>::value, "");
static_assert(std::is_nothrow_constructible<U2, decltype(nullptr)>::value, ""); static_assert(std::is_nothrow_constructible<U2, decltype(nullptr)>::value, "");
} }
#endif #endif
{ {
std::unique_ptr<VT> p(nullptr); std::unique_ptr<VT> p(nullptr);
assert(p.get() == 0); assert(p.get() == nullptr);
} }
{ {
std::unique_ptr<VT, NCDeleter<VT> > p(nullptr); std::unique_ptr<VT, NCDeleter<VT> > p(nullptr);
assert(p.get() == 0); assert(p.get() == nullptr);
assert(p.get_deleter().state() == 0); assert(p.get_deleter().state() == 0);
} }
{ {
std::unique_ptr<VT, DefaultCtorDeleter<VT> > p(nullptr); std::unique_ptr<VT, DefaultCtorDeleter<VT> > p(nullptr);
assert(p.get() == 0); assert(p.get() == nullptr);
assert(p.get_deleter().state() == 0); assert(p.get_deleter().state() == 0);
} }
} }
template <class VT> template <class VT>
TEST_CONSTEXPR_CXX23 void test_sfinae() { TEST_CONSTEXPR_CXX23 void test_sfinae() {
#if TEST_STD_VER >= 11 #if TEST_STD_VER >= 11
{ // the constructor does not participate in overload resolution when { // the constructor does not participate in overload resolution when
▲ Show 20 Lines • Show All 49 Lines • Show Last 20 Lines

libcxx/test/std/utilities/utility/pairs/pairs.pair/ctor.const_first_const_second_cxx03.pass.cpp

Show All 24 Linespublic:
bool operator==(const A& a) const {return data_ == a.data_;} bool operator==(const A& a) const {return data_ == a.data_;}
}; };
int main(int, char**) int main(int, char**)
{ {
{ {
typedef std::pair<float, short*> P; typedef std::pair<float, short*> P;
P p(3.5f, 0); P p(3.5f, nullptr);
assert(p.first == 3.5f); assert(p.first == 3.5f);
assert(p.second == nullptr); assert(p.second == nullptr);
} }
{ {
typedef std::pair<A, int> P; typedef std::pair<A, int> P;
P p(1, 2); P p(1, 2);
assert(p.first == A(1)); assert(p.first == A(1));
assert(p.second == 2); assert(p.second == 2);
} }
return 0; return 0;
} }

libcxx/test/support/controlled_allocators.h

Show First 20 Lines • Show All 66 Lines • ▼ Show 20 Linesstruct AllocController {
int is_equal_count = 0; int is_equal_count = 0;
std::size_t alive_size; std::size_t alive_size;
std::size_t allocated_size; std::size_t allocated_size;
std::size_t deallocated_size; std::size_t deallocated_size;
std::size_t last_size = 0; std::size_t last_size = 0;
std::size_t last_align = 0; std::size_t last_align = 0;
void * last_pointer = 0; void * last_pointer = nullptr;
std::size_t last_alloc_size = 0; std::size_t last_alloc_size = 0;
std::size_t last_alloc_align = 0; std::size_t last_alloc_align = 0;
void * last_alloc_pointer = nullptr; void * last_alloc_pointer = nullptr;
std::size_t last_dealloc_size = 0; std::size_t last_dealloc_size = 0;
std::size_t last_dealloc_align = 0; std::size_t last_dealloc_align = 0;
void * last_dealloc_pointer = nullptr; void * last_dealloc_pointer = nullptr;
▲ Show 20 Lines • Show All 425 Lines • Show Last 20 Lines

libcxx/test/support/deleter_types.h

Show First 20 Lines • Show All 41 Lines • ▼ Show 20 Linespublic:
TEST_CONSTEXPR_CXX23 Deleter() : state_(0) {} TEST_CONSTEXPR_CXX23 Deleter() : state_(0) {}
TEST_CONSTEXPR_CXX23 explicit Deleter(int s) : state_(s) {} TEST_CONSTEXPR_CXX23 explicit Deleter(int s) : state_(s) {}
TEST_CONSTEXPR_CXX23 ~Deleter() { TEST_CONSTEXPR_CXX23 ~Deleter() {
assert(state_ >= 0); assert(state_ >= 0);
state_ = -1; state_ = -1;
} }
template <class U> template <class U>
TEST_CONSTEXPR_CXX23 Deleter(Deleter<U>&& d, typename std::enable_if<!std::is_same<U, T>::value>::type* = 0) TEST_CONSTEXPR_CXX23 Deleter(Deleter<U>&& d, typename std::enable_if<!std::is_same<U, T>::value>::type* = nullptr)
: state_(d.state()) { : state_(d.state()) {
d.set_state(0); d.set_state(0);
} }
private: private:
template <class U> template <class U>
Deleter(const Deleter<U>& d, typename std::enable_if<!std::is_same<U, T>::value>::type* = 0); Deleter(const Deleter<U>& d, typename std::enable_if<!std::is_same<U, T>::value>::type* = nullptr);
public: public:
TEST_CONSTEXPR_CXX23 int state() const { return state_; } TEST_CONSTEXPR_CXX23 int state() const { return state_; }
TEST_CONSTEXPR_CXX23 void set_state(int i) { state_ = i; } TEST_CONSTEXPR_CXX23 void set_state(int i) { state_ = i; }
TEST_CONSTEXPR_CXX23 void operator()(T* p) { delete p; } TEST_CONSTEXPR_CXX23 void operator()(T* p) { delete p; }
}; };
▲ Show 20 Lines • Show All 43 Lines • ▼ Show 20 Linespublic:
} }
~Deleter() { ~Deleter() {
assert(state_ >= 0); assert(state_ >= 0);
state_ = -1; state_ = -1;
} }
template <class U> template <class U>
Deleter(Deleter<U> d, typename std::enable_if<!std::is_same<U, T>::value>::type* = 0) : state_(d.state()) {} Deleter(Deleter<U> d, typename std::enable_if<!std::is_same<U, T>::value>::type* = nullptr) : state_(d.state()) {}
public: public:
int state() const { return state_; } int state() const { return state_; }
void set_state(int i) { state_ = i; } void set_state(int i) { state_ = i; }
void operator()(T* p) { delete p; } void operator()(T* p) { delete p; }
}; };
▲ Show 20 Lines • Show All 269 Lines • ▼ Show 20 Linespublic:
TEST_CONSTEXPR_CXX23 PointerDeleter() = default; TEST_CONSTEXPR_CXX23 PointerDeleter() = default;
TEST_CONSTEXPR_CXX23 PointerDeleter(PointerDeleter&&) = default; TEST_CONSTEXPR_CXX23 PointerDeleter(PointerDeleter&&) = default;
TEST_CONSTEXPR_CXX23 PointerDeleter& operator=(PointerDeleter&&) = default; TEST_CONSTEXPR_CXX23 PointerDeleter& operator=(PointerDeleter&&) = default;
TEST_CONSTEXPR_CXX23 explicit PointerDeleter(int) {} TEST_CONSTEXPR_CXX23 explicit PointerDeleter(int) {}
template <class U> template <class U>
TEST_CONSTEXPR_CXX23 TEST_CONSTEXPR_CXX23
PointerDeleter(PointerDeleter<U, ID>&&, typename std::enable_if<!std::is_same<U, T>::value>::type* = 0) {} PointerDeleter(PointerDeleter<U, ID>&&, typename std::enable_if<!std::is_same<U, T>::value>::type* = nullptr) {}
TEST_CONSTEXPR_CXX23 void operator()(pointer p) { TEST_CONSTEXPR_CXX23 void operator()(pointer p) {
if (p) { if (p) {
delete std::addressof(*p); delete std::addressof(*p);
} }
} }
private: private:
template <class U> template <class U>
PointerDeleter(const PointerDeleter<U, ID>&, typename std::enable_if<!std::is_same<U, T>::value>::type* = 0); PointerDeleter(const PointerDeleter<U, ID>&, typename std::enable_if<!std::is_same<U, T>::value>::type* = nullptr);
}; };
template <class T, size_t ID> template <class T, size_t ID>
class PointerDeleter<T[], ID> { class PointerDeleter<T[], ID> {
PointerDeleter(const PointerDeleter&); PointerDeleter(const PointerDeleter&);
PointerDeleter& operator=(const PointerDeleter&); PointerDeleter& operator=(const PointerDeleter&);
public: public:
typedef min_pointer<T, std::integral_constant<size_t, ID> > pointer; typedef min_pointer<T, std::integral_constant<size_t, ID> > pointer;
TEST_CONSTEXPR_CXX23 PointerDeleter() = default; TEST_CONSTEXPR_CXX23 PointerDeleter() = default;
TEST_CONSTEXPR_CXX23 PointerDeleter(PointerDeleter&&) = default; TEST_CONSTEXPR_CXX23 PointerDeleter(PointerDeleter&&) = default;
TEST_CONSTEXPR_CXX23 PointerDeleter& operator=(PointerDeleter&&) = default; TEST_CONSTEXPR_CXX23 PointerDeleter& operator=(PointerDeleter&&) = default;
TEST_CONSTEXPR_CXX23 explicit PointerDeleter(int) {} TEST_CONSTEXPR_CXX23 explicit PointerDeleter(int) {}
template <class U> template <class U>
TEST_CONSTEXPR_CXX23 TEST_CONSTEXPR_CXX23
PointerDeleter(PointerDeleter<U, ID>&&, typename std::enable_if<!std::is_same<U, T>::value>::type* = 0) {} PointerDeleter(PointerDeleter<U, ID>&&, typename std::enable_if<!std::is_same<U, T>::value>::type* = nullptr) {}
TEST_CONSTEXPR_CXX23 void operator()(pointer p) { TEST_CONSTEXPR_CXX23 void operator()(pointer p) {
if (p) { if (p) {
delete[] std::addressof(*p); delete[] std::addressof(*p);
} }
} }
private: private:
template <class U> template <class U>
PointerDeleter(const PointerDeleter<U, ID>&, typename std::enable_if<!std::is_same<U, T>::value>::type* = 0); PointerDeleter(const PointerDeleter<U, ID>&, typename std::enable_if<!std::is_same<U, T>::value>::type* = nullptr);
}; };
#endif // TEST_STD_VER >= 11 #endif // TEST_STD_VER >= 11
template <class T> template <class T>
class DefaultCtorDeleter { class DefaultCtorDeleter {
int state_; int state_;
Show All 15 Lines

libcxx/test/support/make_string.h

Show All 38 Lines
#define MKSTR(Str) MultiStringType( \ #define MKSTR(Str) MultiStringType( \
MKSTR_WCHAR_ONLY(MKSTR_AS_WCHAR_LITERAL(Str),) \ MKSTR_WCHAR_ONLY(MKSTR_AS_WCHAR_LITERAL(Str),) \
MKSTR_CHAR8_ONLY(MKSTR_AS_U8_LITERAL(Str),) \ MKSTR_CHAR8_ONLY(MKSTR_AS_U8_LITERAL(Str),) \
MKSTR_CXX11_ONLY(MKSTR_AS_U16_LITERAL(Str), \ MKSTR_CXX11_ONLY(MKSTR_AS_U16_LITERAL(Str), \
MKSTR_AS_U32_LITERAL(Str),) \ MKSTR_AS_U32_LITERAL(Str),) \
Str, sizeof(Str) - 1 \ Str, sizeof(Str) - 1 \
) )
#define MKSTR_LEN(CharT, Str) MKSTR(Str).length((const CharT*)0) #define MKSTR_LEN(CharT, Str) MKSTR(Str).length((const CharT*)nullptr)
struct MultiStringType { struct MultiStringType {
MKSTR_WCHAR_ONLY(const wchar_t* w_; size_t wn_; ) MKSTR_WCHAR_ONLY(const wchar_t* w_; size_t wn_; )
MKSTR_CHAR8_ONLY(const char8_t* u8_; size_t u8n_; ) MKSTR_CHAR8_ONLY(const char8_t* u8_; size_t u8n_; )
MKSTR_CXX11_ONLY(const char16_t* u16_; size_t u16n_; ) MKSTR_CXX11_ONLY(const char16_t* u16_; size_t u16n_; )
MKSTR_CXX11_ONLY(const char32_t* u32_; size_t u32n_; ) MKSTR_CXX11_ONLY(const char32_t* u32_; size_t u32n_; )
const char* s_; size_t sn_; const char* s_; size_t sn_;
▲ Show 20 Lines • Show All 47 Lines • Show Last 20 Lines

libcxx/test/support/nasty_string.h

Show First 20 Lines • Show All 107 Lines • ▼ Show 20 Lines
} }
constexpr const nasty_char* nasty_char_traits::find(const nasty_char* s, size_t n, const nasty_char& a) { constexpr const nasty_char* nasty_char_traits::find(const nasty_char* s, size_t n, const nasty_char& a) {
for (; n; --n) { for (; n; --n) {
if (eq(*s, a)) if (eq(*s, a))
return s; return s;
++s; ++s;
} }
return 0; return nullptr;
} }
constexpr nasty_char* nasty_char_traits::move(nasty_char* s1, const nasty_char* s2, size_t n) { constexpr nasty_char* nasty_char_traits::move(nasty_char* s1, const nasty_char* s2, size_t n) {
nasty_char* r = s1; nasty_char* r = s1;
if (s1 < s2) { if (s1 < s2) {
for (; n; --n, ++s1, ++s2) for (; n; --n, ++s1, ++s2)
assign(*s1, *s2); assign(*s1, *s2);
} else if (s2 < s1) { } else if (s2 < s1) {
▲ Show 20 Lines • Show All 60 Lines • Show Last 20 Lines

libcxx/utils/libcxx/test/dsl.py

Show First 20 Lines • Show All 247 Lines • ▼ Show 20 Linesdef hasAnyLocale(config, locales):
program = """ program = """
#include <stddef.h> #include <stddef.h>
#if defined(_LIBCPP_HAS_NO_LOCALIZATION) #if defined(_LIBCPP_HAS_NO_LOCALIZATION)
int main(int, char**) { return 1; } int main(int, char**) { return 1; }
#else #else
#include <locale.h> #include <locale.h>
int main(int argc, char** argv) { int main(int argc, char** argv) {
for (int i = 1; i < argc; i++) { for (int i = 1; i < argc; i++) {
if (::setlocale(LC_ALL, argv[i]) != NULL) { if (::setlocale(LC_ALL, argv[i]) != nullptr) {
return 0; return 0;
} }
} }
return 1; return 1;
} }
#endif #endif
""" """
return programSucceeds(config, program, args=[pipes.quote(l) for l in locales]) return programSucceeds(config, program, args=[pipes.quote(l) for l in locales])
▲ Show 20 Lines • Show All 456 Lines • Show Last 20 Lines

libcxx/utils/libcxx/test/params.py

Show All 12 Lines
_warningFlags = [ _warningFlags = [
'-Werror', '-Werror',
'-Wall', '-Wall',
'-Wctad-maybe-unsupported', '-Wctad-maybe-unsupported',
'-Wextra', '-Wextra',
'-Wshadow', '-Wshadow',
'-Wundef', '-Wundef',
'-Wunused-template', '-Wunused-template',
'-Wzero-as-null-pointer-constant',
'-Wno-unused-command-line-argument', '-Wno-unused-command-line-argument',
'-Wno-attributes', '-Wno-attributes',
'-Wno-pessimizing-move', '-Wno-pessimizing-move',
'-Wno-c++11-extensions', '-Wno-c++11-extensions',
'-Wno-noexcept-type', '-Wno-noexcept-type',
'-Wno-aligned-allocation-unavailable', '-Wno-aligned-allocation-unavailable',
'-Wno-atomic-alignment', '-Wno-atomic-alignment',
▲ Show 20 Lines • Show All 222 Lines • Show Last 20 Lines

libunwind/test/forceunwind.pass.cpp

Show All 35 Lines_Unwind_Reason_Code stop(int version, _Unwind_Action actions,
struct _Unwind_Context *context, struct _Unwind_Context *context,
void *stop_parameter) { void *stop_parameter) {
assert(version == 1); assert(version == 1);
assert((actions & _UA_FORCE_UNWIND) != 0); assert((actions & _UA_FORCE_UNWIND) != 0);
(void)exceptionClass; (void)exceptionClass;
assert(exceptionObject == &ex); assert(exceptionObject == &ex);
assert(stop_parameter == &foo); assert(stop_parameter == &foo);
Dl_info info = {0, 0, 0, 0}; Dl_info info = {nullptr, nullptr, nullptr, nullptr};
// Unwind util the main is reached, above frames depend on the platform and // Unwind util the main is reached, above frames depend on the platform and
// architecture. // architecture.
if (dladdr(reinterpret_cast<void *>(_Unwind_GetIP(context)), &info) && if (dladdr(reinterpret_cast<void *>(_Unwind_GetIP(context)), &info) &&
info.dli_sname && !strcmp("main", info.dli_sname)) { info.dli_sname && !strcmp("main", info.dli_sname)) {
_Exit(0); _Exit(0);
} }
return _URC_NO_REASON; return _URC_NO_REASON;
Show All 20 Lines

libunwind/test/signal_unwind.pass.cpp

Show All 20 Lines
#include <stdlib.h> #include <stdlib.h>
#include <string.h> #include <string.h>
#include <sys/types.h> #include <sys/types.h>
#include <unistd.h> #include <unistd.h>
#include <unwind.h> #include <unwind.h>
_Unwind_Reason_Code frame_handler(struct _Unwind_Context* ctx, void* arg) { _Unwind_Reason_Code frame_handler(struct _Unwind_Context* ctx, void* arg) {
(void)arg; (void)arg;
Dl_info info = { 0, 0, 0, 0 }; Dl_info info = { nullptr, nullptr, nullptr, nullptr };
// Unwind util the main is reached, above frames depend on the platform and // Unwind util the main is reached, above frames depend on the platform and
// architecture. // architecture.
if (dladdr(reinterpret_cast<void *>(_Unwind_GetIP(ctx)), &info) && if (dladdr(reinterpret_cast<void *>(_Unwind_GetIP(ctx)), &info) &&
info.dli_sname && !strcmp("main", info.dli_sname)) { info.dli_sname && !strcmp("main", info.dli_sname)) {
_Exit(0); _Exit(0);
} }
return _URC_NO_REASON; return _URC_NO_REASON;
} }
void signal_handler(int signum) { void signal_handler(int signum) {
(void)signum; (void)signum;
_Unwind_Backtrace(frame_handler, NULL); _Unwind_Backtrace(frame_handler, nullptr);
_Exit(-1); _Exit(-1);
} }
int main(int, char**) { int main(int, char**) {
signal(SIGUSR1, signal_handler); signal(SIGUSR1, signal_handler);
kill(getpid(), SIGUSR1); kill(getpid(), SIGUSR1);
return -2; return -2;
} }

libunwind/test/unwind_leaffunction.pass.cpp

Show All 20 Lines
#include <stdlib.h> #include <stdlib.h>
#include <string.h> #include <string.h>
#include <sys/types.h> #include <sys/types.h>
#include <unistd.h> #include <unistd.h>
#include <unwind.h> #include <unwind.h>
_Unwind_Reason_Code frame_handler(struct _Unwind_Context* ctx, void* arg) { _Unwind_Reason_Code frame_handler(struct _Unwind_Context* ctx, void* arg) {
(void)arg; (void)arg;
Dl_info info = { 0, 0, 0, 0 }; Dl_info info = { nullptr, nullptr, nullptr, nullptr };
// Unwind until the main is reached, above frames deeped on the platform and // Unwind until the main is reached, above frames deeped on the platform and
// architecture. // architecture.
if (dladdr(reinterpret_cast<void *>(_Unwind_GetIP(ctx)), &info) && if (dladdr(reinterpret_cast<void *>(_Unwind_GetIP(ctx)), &info) &&
info.dli_sname && !strcmp("main", info.dli_sname)) { info.dli_sname && !strcmp("main", info.dli_sname)) {
_Exit(0); _Exit(0);
} }
return _URC_NO_REASON; return _URC_NO_REASON;
} }
void signal_handler(int signum) { void signal_handler(int signum) {
(void)signum; (void)signum;
_Unwind_Backtrace(frame_handler, NULL); _Unwind_Backtrace(frame_handler, nullptr);
_Exit(-1); _Exit(-1);
} }
__attribute__((noinline)) void crashing_leaf_func(void) { __attribute__((noinline)) void crashing_leaf_func(void) {
// libunwind searches for the address before the return address which points // libunwind searches for the address before the return address which points
// to the trap instruction. NOP guarantees the trap instruction is not the // to the trap instruction. NOP guarantees the trap instruction is not the
// first instruction of the function. // first instruction of the function.
// We should keep this here for other unwinders that also decrement pc. // We should keep this here for other unwinders that also decrement pc.
Show All 10 Lines