This is an archive of the discontinued LLVM Phabricator instance.

Differential D66104

libcxx: Rename .hpp files in libcxx/test/support to .h
ClosedPublic

Authored by thakis on Aug 12 2019, 12:38 PM.

Details

Reviewers
EricWF
Commits
rGcc89063bff0f: libcxx: Rename .hpp files in libcxx/test/support to .h
rCXX369481: libcxx: Rename .hpp files in libcxx/test/support to .h
rL369481: libcxx: Rename .hpp files in libcxx/test/support to .h
Summary

LLVM uses .h as its extension for header files.

Files renamed using:

for f in libcxx/test/support/*.hpp; do git mv $f ${f%.hpp}.h; don

References to the files updated using:

for f in $(git diff master | grep 'rename from' | cut -f 3 -d ' '); do
    a=$(basename $f);
    echo $a;
    rg -l $a libcxx | xargs sed -i '' "s/$a/${a%.hpp}.h/";
done

HPP include guards updated manually using:

for f in $(git diff master | grep 'rename from' | cut -f 3 -d ' '); do
  echo ${f%.hpp}.h ;
done | xargs mvim

Diff Detail

Repository
rL LLVM

Event Timeline

thakis created this revision.Aug 12 2019, 12:38 PM
Herald added subscribers: arphaman, christof. · View Herald TranscriptAug 12 2019, 12:38 PM
thakis added a comment.Aug 14 2019, 5:21 AM

EricWF: ping. This patch looks scary in Phab, but if you click on "Download raw diff" it's not that large.

EricWF accepted this revision.Aug 20 2019, 4:58 PM
This revision is now accepted and ready to land.Aug 20 2019, 4:58 PM
Closed by commit rL369481: libcxx: Rename .hpp files in libcxx/test/support to .h (authored by nico). · Explain WhyAug 20 2019, 5:17 PM
This revision was automatically updated to reflect the committed changes.
Herald added a project: Restricted Project. · View Herald TranscriptAug 20 2019, 5:17 PM
Herald added subscribers: mstorsjo, jfb, krytarowski. · View Herald Transcript

Revision Contents

PathSize
libcxx/
trunk/
benchmarks/
2 lines
test/
libcxx/
algorithms/
2 lines
containers/
gnu_cxx/
2 lines
2 lines
sequences/
deque/
2 lines
debug/
containers/
2 lines
2 lines
2 lines
2 lines
2 lines
experimental/
memory/
memory.polymorphic.allocator.class/
memory.polymorphic.allocator.mem/
2 lines
2 lines
memory.resource.adaptor/
memory.resource.adaptor.mem/
2 lines
input.output/
filesystems/
class.directory_entry/
directory_entry.mods/
6 lines
class.path/
path.itr/
4 lines
2 lines
path.req/
4 lines
type_traits/
2 lines
utilities/
optional/
optional.object/
2 lines
tuple/
tuple.tuple/
tuple.cnstr/
2 lines
2 lines
utility/
pairs/
pairs.pair/
2 lines
2 lines
std/
algorithms/
alg.modifying.operations/
alg.copy/
2 lines
2 lines
alg.fill/
2 lines
alg.generate/
2 lines
alg.partitions/
2 lines
alg.remove/
2 lines
alg.nonmodifying/
alg.search/
2 lines
2 lines
mismatch/
2 lines
alg.sorting/
alg.heap.operations/
make.heap/
2 lines
alg.merge/
2 lines
2 lines
alg.min.max/
2 lines
containers/
associative/
map/
map.access/
4 lines
2 lines
map.ops/
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
multimap/
multimap.ops/
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
multiset/
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
set/
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
sequences/
forwardlist/
forwardlist.ops/
2 lines
list/
list.modifiers/
2 lines
2 lines
2 lines
list.ops/
2 lines
vector.bool/
2 lines
2 lines
unord/
unord.map/
unord.map.elem/
2 lines
diagnostics/
syserr/
syserr.hash/
2 lines
experimental/
memory/
memory.polymorphic.allocator.class/
memory.polymorphic.allocator.ctor/
2 lines
2 lines
memory.polymorphic.allocator.eq/
2 lines
2 lines
memory.polymorphic.allocator.mem/
2 lines
2 lines
6 lines
6 lines
6 lines
6 lines
6 lines
2 lines
memory.resource.adaptor/
memory.resource.adaptor.ctor/
2 lines
2 lines
2 lines
memory.resource.adaptor.mem/
2 lines
2 lines
memory.resource.aliases/
2 lines
memory.resource.global/
2 lines
2 lines
2 lines
memory.resource/
memory.resource.eq/
2 lines
2 lines
memory.resource.public/
2 lines
2 lines
2 lines
2 lines
input.output/
filesystems/
class.directory_entry/
directory_entry.cons/
8 lines
6 lines
2 lines
2 lines
8 lines
6 lines
8 lines
directory_entry.mods/
6 lines
6 lines
6 lines
directory_entry.obs/
2 lines
6 lines
6 lines
6 lines
6 lines
2 lines
6 lines
6 lines
class.directory_iterator/
directory_iterator.members/
6 lines
6 lines
6 lines
2 lines
6 lines
6 lines
6 lines
directory_iterator.nonmembers/
6 lines
2 lines
class.file_status/
4 lines
2 lines
2 lines
class.filesystem_error/
2 lines
class.path/
path.itr/
4 lines
path.member/
6 lines
path.assign/
4 lines
2 lines
4 lines
6 lines
6 lines
6 lines
path.construct/
2 lines
2 lines
4 lines
4 lines
path.decompose/
2 lines
6 lines
path.gen/
6 lines
6 lines
path.generic.obs/
6 lines
6 lines
path.modifiers/
6 lines
6 lines
6 lines
6 lines
6 lines
6 lines
path.native.obs/
4 lines
6 lines
4 lines
4 lines
6 lines
path.nonmember/
4 lines
4 lines
4 lines
6 lines
6 lines
6 lines
6 lines
2 lines
class.rec.dir.itr/
rec.dir.itr.members/
6 lines
6 lines
6 lines
6 lines
6 lines
6 lines
6 lines
6 lines
6 lines
6 lines
rec.dir.itr.nonmembers/
6 lines
fs.enum/
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
fs.filesystem.synopsis/
2 lines
fs.op.funcs/
fs.op.hard_lk_ct/
6 lines
fs.op.absolute/
6 lines
fs.op.canonical/
6 lines
fs.op.copy/
6 lines
fs.op.copy_file/
6 lines
6 lines
fs.op.copy_symlink/
6 lines
fs.op.create_directories/
6 lines
fs.op.create_directory/
6 lines
6 lines
fs.op.create_directory_symlink/
6 lines
fs.op.create_hard_link/
6 lines
fs.op.create_symlink/
6 lines
fs.op.current_path/
6 lines
fs.op.equivalent/
6 lines
fs.op.exists/
6 lines
fs.op.file_size/
6 lines
fs.op.is_block_file/
6 lines
fs.op.is_char_file/
6 lines
fs.op.is_directory/
6 lines
fs.op.is_empty/
6 lines
fs.op.is_fifo/
6 lines
fs.op.is_other/
6 lines
fs.op.is_regular_file/
6 lines
fs.op.is_socket/
6 lines
fs.op.is_symlink/
6 lines
fs.op.last_write_time/
6 lines
fs.op.permissions/
6 lines
fs.op.proximate/
8 lines
fs.op.read_symlink/
6 lines
fs.op.relative/
8 lines
fs.op.remove/
6 lines
fs.op.remove_all/
6 lines
fs.op.rename/
6 lines
fs.op.resize_file/
6 lines
fs.op.space/
6 lines
fs.op.status/
6 lines
fs.op.status_known/
6 lines
fs.op.symlink_status/
6 lines
fs.op.temp_dir_path/
6 lines
fs.op.weakly_canonical/
6 lines
iterators/
predef.iterators/
insert.iterators/
back.insert.iter.ops/
back.insert.iter.cons/
2 lines
back.insert.iter.op++/
2 lines
2 lines
back.insert.iter.op_astrk/
2 lines
back.inserter/
2 lines
front.insert.iter.ops/
front.insert.iter.cons/
2 lines
front.insert.iter.op++/
2 lines
2 lines
front.insert.iter.op=/
2 lines
front.insert.iter.op_astrk/
2 lines
front.inserter/
2 lines
insert.iter.ops/
insert.iter.cons/
2 lines
insert.iter.op++/
2 lines
2 lines
insert.iter.op=/
2 lines
insert.iter.op_astrk/
2 lines
inserter/
2 lines
language.support/
support.dynamic/
2 lines
localization/
locale.categories/
category.ctype/
facet.ctype.special/
facet.ctype.char.dtor/
2 lines
locale.stdcvt/
2 lines
2 lines
locales/
locale.convenience/
conversions/
conversions.buffer/
2 lines
locale/
locale.cons/
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
locale.members/
2 lines
strings/
basic.string.hash/
2 lines
basic.string/
string.cons/
2 lines
string.view/
string.view.hash/
2 lines
string.view.comparison/
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
string.view.cons/
2 lines
2 lines
string.view.find/
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
string.view.ops/
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
string.view.template/
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
thread/
thread.mutex/
thread.lock/
thread.lock.shared/
thread.lock.shared.cons/
2 lines
2 lines
2 lines
2 lines
thread.lock.unique/
thread.lock.unique.cons/
2 lines
2 lines
2 lines
2 lines
thread.threads/
thread.thread.class/
thread.thread.id/
2 lines
utilities/
allocator.adaptor/
allocator.adaptor.members/
4 lines
4 lines
4 lines
4 lines
4 lines
4 lines
any/
any.class/
any.assign/
2 lines
2 lines
any.cons/
2 lines
2 lines
4 lines
2 lines
2 lines
any.modifiers/
2 lines
any.nonmembers/
any.cast/
2 lines
2 lines
function.objects/
func.wrap/
func.wrap.func/
func.wrap.func.alg/
2 lines
func.wrap.func.con/
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
func.wrap.func.mod/
2 lines
refwrap/
refwrap.helpers/
2 lines
unord.hash/
2 lines
memory/
default.allocator/
allocator.members/
2 lines
2 lines
util.smartptr/
util.smartptr.hash/
2 lines
2 lines
2 lines
util.smartptr.enab/
2 lines
util.smartptr.shared/
util.smartptr.shared.const/
2 lines
2 lines
2 lines
2 lines
2 lines
util.smartptr.shared.create/
2 lines
optional/
optional.hash/
2 lines
2 lines
optional.object/
optional.object.assign/
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
optional.object.ctor/
4 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
optional.object.swap/
2 lines
2 lines
2 lines
optional.specalg/
2 lines
template.bitset/
bitset.hash/
2 lines
tuple/
tuple.tuple/
tuple.cnstr/
2 lines
2 lines
type.index/
type.index.hash/
2 lines
type.index.synopsis/
2 lines
utility/
pairs/
pairs.pair/
4 lines
2 lines
2 lines
4 lines
4 lines
2 lines
2 lines
4 lines
2 lines
variant/
variant.hash/
2 lines
4 lines
variant.helpers/
2 lines
variant.get/
2 lines
2 lines
2 lines
2 lines
variant.variant/
variant.assign/
2 lines
2 lines
2 lines
variant.ctor/
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
variant.mod/
6 lines
4 lines
6 lines
4 lines
variant.status/
4 lines
4 lines
variant.swap/
4 lines
4 lines
2 lines
2 lines
4 lines
variant.visit/
2 lines
support/
393 lines
393 lines
138 lines
138 lines
359 lines
359 lines
501 lines
501 lines
485 lines
485 lines
52 lines
52 lines
13 lines
13 lines
557 lines
557 lines
71 lines
71 lines
92 lines
92 lines
312 lines
312 lines
68 lines
68 lines
242 lines
242 lines
30 lines
30 lines
866 lines
866 lines
test.support/
4 lines
4 lines
41 lines
41 lines
170 lines
170 lines
51 lines
51 lines
390 lines
390 lines
89 lines
89 lines
utils/
libcxx/
test/
4 lines

Diff 216295

libcxx/trunk/benchmarks/filesystem.bench.cpp

#include "benchmark/benchmark.h" #include "benchmark/benchmark.h"
#include "GenerateInput.hpp" #include "GenerateInput.hpp"
#include "test_iterators.h" #include "test_iterators.h"
#include "filesystem_include.hpp" #include "filesystem_include.h"
static const size_t TestNumInputs = 1024; static const size_t TestNumInputs = 1024;
template <class GenInputs> template <class GenInputs>
void BM_PathConstructString(benchmark::State &st, GenInputs gen) { void BM_PathConstructString(benchmark::State &st, GenInputs gen) {
using fs::path; using fs::path;
const auto in = gen(st.range(0)); const auto in = gen(st.range(0));
▲ Show 20 Lines • Show All 151 Lines • Show Last 20 Lines

libcxx/trunk/test/libcxx/algorithms/half_positive.pass.cpp

Show All 11 Lines
// It can be an important optimization for lower bound, for example. // It can be an important optimization for lower bound, for example.
#include <algorithm> #include <algorithm>
#include <cassert> #include <cassert>
#include <limits> #include <limits>
#include <type_traits> #include <type_traits>
#include "test_macros.h" #include "test_macros.h"
#include "user_defined_integral.hpp" #include "user_defined_integral.h"
namespace { namespace {
template <class IntType, class UnderlyingType = IntType> template <class IntType, class UnderlyingType = IntType>
TEST_CONSTEXPR bool test(IntType max_v = IntType(std::numeric_limits<UnderlyingType>::max())) { TEST_CONSTEXPR bool test(IntType max_v = IntType(std::numeric_limits<UnderlyingType>::max())) {
return std::__half_positive(max_v) == max_v / 2; return std::__half_positive(max_v) == max_v / 2;
} }
Show All 29 Lines

libcxx/trunk/test/libcxx/containers/gnu_cxx/hash_map.pass.cpp

Show All 10 Lines
#ifdef __clang__ #ifdef __clang__
#pragma clang diagnostic ignored "-W#warnings" #pragma clang diagnostic ignored "-W#warnings"
#endif #endif
#include <ext/hash_map> #include <ext/hash_map>
#include <cassert> #include <cassert>
#include "test_macros.h" #include "test_macros.h"
#include "count_new.hpp" #include "count_new.h"
void test_default_does_not_allocate() { void test_default_does_not_allocate() {
DisableAllocationGuard g; DisableAllocationGuard g;
((void)g); ((void)g);
{ {
__gnu_cxx::hash_map<int, int> h; __gnu_cxx::hash_map<int, int> h;
assert(h.bucket_count() == 0); assert(h.bucket_count() == 0);
} }
Show All 9 Lines

libcxx/trunk/test/libcxx/containers/gnu_cxx/hash_set.pass.cpp

Show All 10 Lines
#ifdef __clang__ #ifdef __clang__
#pragma clang diagnostic ignored "-W#warnings" #pragma clang diagnostic ignored "-W#warnings"
#endif #endif
#include <ext/hash_set> #include <ext/hash_set>
#include <cassert> #include <cassert>
#include "test_macros.h" #include "test_macros.h"
#include "count_new.hpp" #include "count_new.h"
void test_default_does_not_allocate() { void test_default_does_not_allocate() {
DisableAllocationGuard g; DisableAllocationGuard g;
((void)g); ((void)g);
{ {
__gnu_cxx::hash_set<int> h; __gnu_cxx::hash_set<int> h;
assert(h.bucket_count() == 0); assert(h.bucket_count() == 0);
} }
Show All 9 Lines

libcxx/trunk/test/libcxx/containers/sequences/deque/spare_block_handling.pass.cpp

Show All 15 Lines
#include <deque> #include <deque>
#include <iostream> #include <iostream>
#include <memory> #include <memory>
#include <stack> #include <stack>
#include <queue> #include <queue>
#include "min_allocator.h" #include "min_allocator.h"
#include "rapid-cxx-test.hpp" #include "rapid-cxx-test.h"
template <class Adaptor> template <class Adaptor>
struct ContainerAdaptor : public Adaptor { struct ContainerAdaptor : public Adaptor {
using Adaptor::Adaptor; using Adaptor::Adaptor;
typename Adaptor::container_type& GetContainer() { return Adaptor::c; } typename Adaptor::container_type& GetContainer() { return Adaptor::c; }
}; };
template <class Deque> template <class Deque>
▲ Show 20 Lines • Show All 252 Lines • Show Last 20 Lines

libcxx/trunk/test/libcxx/debug/containers/db_associative_container_tests.pass.cpp

Show All 16 Lines
// test container debugging // test container debugging
#define _LIBCPP_DEBUG 1 #define _LIBCPP_DEBUG 1
#include <map> #include <map>
#include <set> #include <set>
#include <utility> #include <utility>
#include <cassert> #include <cassert>
#include "container_debug_tests.hpp" #include "container_debug_tests.h"
#include "test_macros.h" #include "test_macros.h"
#include "debug_mode_helper.h" #include "debug_mode_helper.h"
using namespace IteratorDebugChecks; using namespace IteratorDebugChecks;
template <class Container, ContainerType CT> template <class Container, ContainerType CT>
struct AssociativeContainerChecks : BasicContainerChecks<Container, CT> { struct AssociativeContainerChecks : BasicContainerChecks<Container, CT> {
using Base = BasicContainerChecks<Container, CT>; using Base = BasicContainerChecks<Container, CT>;
Show All 34 Lines

libcxx/trunk/test/libcxx/debug/containers/db_sequence_container_iterators.multithread.pass.cpp

Show All 18 Lines
#define _LIBCPP_DEBUG 1 #define _LIBCPP_DEBUG 1
#include <cassert> #include <cassert>
#include <cstddef> #include <cstddef>
#include <deque> #include <deque>
#include <list> #include <list>
#include <thread> #include <thread>
#include <vector> #include <vector>
#include "container_debug_tests.hpp" #include "container_debug_tests.h"
#include "test_macros.h" #include "test_macros.h"
template <typename Container> template <typename Container>
Container makeContainer(int size) { Container makeContainer(int size) {
Container c; Container c;
typedef typename Container::value_type ValueType; typedef typename Container::value_type ValueType;
Show All 39 Lines

libcxx/trunk/test/libcxx/debug/containers/db_sequence_container_iterators.pass.cpp

Show All 16 Lines
// test container debugging // test container debugging
#define _LIBCPP_DEBUG 1 #define _LIBCPP_DEBUG 1
#include <forward_list> #include <forward_list>
#include <list> #include <list>
#include <vector> #include <vector>
#include <deque> #include <deque>
#include "container_debug_tests.hpp" #include "container_debug_tests.h"
#include "test_macros.h" #include "test_macros.h"
#include "debug_mode_helper.h" #include "debug_mode_helper.h"
using namespace IteratorDebugChecks; using namespace IteratorDebugChecks;
template <class Container, ContainerType CT> template <class Container, ContainerType CT>
struct SequenceContainerChecks : BasicContainerChecks<Container, CT> { struct SequenceContainerChecks : BasicContainerChecks<Container, CT> {
using Base = BasicContainerChecks<Container, CT>; using Base = BasicContainerChecks<Container, CT>;
▲ Show 20 Lines • Show All 307 Lines • Show Last 20 Lines

libcxx/trunk/test/libcxx/debug/containers/db_string.pass.cpp

Show All 15 Lines
// test container debugging // test container debugging
#define _LIBCPP_DEBUG 1 #define _LIBCPP_DEBUG 1
#include <string> #include <string>
#include <vector> #include <vector>
#include "test_macros.h" #include "test_macros.h"
#include "container_debug_tests.hpp" #include "container_debug_tests.h"
#include "debug_mode_helper.h" #include "debug_mode_helper.h"
using namespace IteratorDebugChecks; using namespace IteratorDebugChecks;
typedef std::basic_string<char, std::char_traits<char>, test_allocator<char>> StringType; typedef std::basic_string<char, std::char_traits<char>, test_allocator<char>> StringType;
template <class Container = StringType, ContainerType CT = CT_String> template <class Container = StringType, ContainerType CT = CT_String>
struct StringContainerChecks : BasicContainerChecks<Container, CT> { struct StringContainerChecks : BasicContainerChecks<Container, CT> {
▲ Show 20 Lines • Show All 66 Lines • Show Last 20 Lines

libcxx/trunk/test/libcxx/debug/containers/db_unord_container_tests.pass.cpp

Show All 15 Lines
// test container debugging // test container debugging
#define _LIBCPP_DEBUG 1 #define _LIBCPP_DEBUG 1
#include <unordered_map> #include <unordered_map>
#include <unordered_set> #include <unordered_set>
#include <utility> #include <utility>
#include <cassert> #include <cassert>
#include "container_debug_tests.hpp" #include "container_debug_tests.h"
#include "test_macros.h" #include "test_macros.h"
#include "debug_mode_helper.h" #include "debug_mode_helper.h"
using namespace IteratorDebugChecks; using namespace IteratorDebugChecks;
template <class Container, ContainerType CT> template <class Container, ContainerType CT>
struct UnorderedContainerChecks : BasicContainerChecks<Container, CT> { struct UnorderedContainerChecks : BasicContainerChecks<Container, CT> {
using Base = BasicContainerChecks<Container, CT>; using Base = BasicContainerChecks<Container, CT>;
Show All 36 Lines

libcxx/trunk/test/libcxx/experimental/memory/memory.polymorphic.allocator.class/memory.polymorphic.allocator.mem/construct_piecewise_pair.pass.cpp

Show All 39 Lines
// 'tuple<Args1...>' and 'tuple<Args2...>'. // 'tuple<Args1...>' and 'tuple<Args2...>'.
#include <experimental/memory_resource> #include <experimental/memory_resource>
#include <type_traits> #include <type_traits>
#include <utility> #include <utility>
#include <tuple> #include <tuple>
#include <cassert> #include <cassert>
#include <cstdlib> #include <cstdlib>
#include "test_memory_resource.hpp" #include "test_memory_resource.h"
#include "test_macros.h" #include "test_macros.h"
namespace ex = std::experimental::pmr; namespace ex = std::experimental::pmr;
template <class T> template <class T>
struct TestHarness { struct TestHarness {
TestResource R; TestResource R;
▲ Show 20 Lines • Show All 118 Lines • Show Last 20 Lines

libcxx/trunk/test/libcxx/experimental/memory/memory.polymorphic.allocator.class/memory.polymorphic.allocator.mem/db_deallocate.pass.cpp

Show All 16 Lines
int AssertCount = 0; int AssertCount = 0;
#define _LIBCPP_ASSERT(x, m) ((x) ? (void)0 : (void)::AssertCount++) #define _LIBCPP_ASSERT(x, m) ((x) ? (void)0 : (void)::AssertCount++)
#define _LIBCPP_DEBUG 0 #define _LIBCPP_DEBUG 0
#include <experimental/memory_resource> #include <experimental/memory_resource>
#include <type_traits> #include <type_traits>
#include <cassert> #include <cassert>
#include "test_memory_resource.hpp" #include "test_memory_resource.h"
#include "test_macros.h" #include "test_macros.h"
namespace ex = std::experimental::pmr; namespace ex = std::experimental::pmr;
int main(int, char**) int main(int, char**)
{ {
using Alloc = ex::polymorphic_allocator<int>; using Alloc = ex::polymorphic_allocator<int>;
Show All 12 Lines

libcxx/trunk/test/libcxx/experimental/memory/memory.resource.adaptor/memory.resource.adaptor.mem/db_deallocate.pass.cpp

Show All 16 Lines
int AssertCount = 0; int AssertCount = 0;
#define _LIBCPP_ASSERT(x, m) ((x) ? (void)0 : (void)::AssertCount++) #define _LIBCPP_ASSERT(x, m) ((x) ? (void)0 : (void)::AssertCount++)
#define _LIBCPP_DEBUG 0 #define _LIBCPP_DEBUG 0
#include <experimental/memory_resource> #include <experimental/memory_resource>
#include <type_traits> #include <type_traits>
#include <cassert> #include <cassert>
#include "test_memory_resource.hpp" #include "test_memory_resource.h"
#include "test_macros.h" #include "test_macros.h"
namespace ex = std::experimental::pmr; namespace ex = std::experimental::pmr;
int main(int, char**) int main(int, char**)
{ {
using Alloc = NullAllocator<char>; using Alloc = NullAllocator<char>;
Show All 15 Lines

libcxx/trunk/test/libcxx/input.output/filesystems/class.directory_entry/directory_entry.mods/last_write_time.sh.cpp

Show All 9 Lines
// <filesystem> // <filesystem>
// class directory_entry // class directory_entry
// RUN: %build -I%libcxx_src_root/src/filesystem // RUN: %build -I%libcxx_src_root/src/filesystem
// RUN: %run // RUN: %run
#include "filesystem_include.hpp" #include "filesystem_include.h"
#include <type_traits> #include <type_traits>
#include <cassert> #include <cassert>
#include "test_macros.h" #include "test_macros.h"
#include "rapid-cxx-test.hpp" #include "rapid-cxx-test.h"
#include "filesystem_test_helper.hpp" #include "filesystem_test_helper.h"
#include "filesystem_common.h" #include "filesystem_common.h"
using namespace fs::detail; using namespace fs::detail;
TEST_SUITE(directory_entry_mods_suite) TEST_SUITE(directory_entry_mods_suite)
TEST_CASE(last_write_time_not_representable_error) { TEST_CASE(last_write_time_not_representable_error) {
▲ Show 20 Lines • Show All 60 Lines • Show Last 20 Lines

libcxx/trunk/test/libcxx/input.output/filesystems/class.path/path.itr/iterator_db.pass.cpp

Show All 10 Lines
// MODULES_DEFINES: _LIBCPP_DEBUG=0 // MODULES_DEFINES: _LIBCPP_DEBUG=0
// <filesystem> // <filesystem>
// class path // class path
#define _LIBCPP_DEBUG 0 #define _LIBCPP_DEBUG 0
#include "filesystem_include.hpp" #include "filesystem_include.h"
#include <iterator> #include <iterator>
#include <type_traits> #include <type_traits>
#include <cassert> #include <cassert>
#include "test_macros.h" #include "test_macros.h"
#include "filesystem_test_helper.hpp" #include "filesystem_test_helper.h"
#include "debug_mode_helper.h" #include "debug_mode_helper.h"
int main(int, char**) { int main(int, char**) {
using namespace fs; using namespace fs;
// Test incrementing/decrementing a singular iterator // Test incrementing/decrementing a singular iterator
{ {
path::iterator singular; path::iterator singular;
EXPECT_DEATH( ++singular ); EXPECT_DEATH( ++singular );
Show All 22 Lines

libcxx/trunk/test/libcxx/input.output/filesystems/class.path/path.itr/reverse_iterator_produces_diagnostic.fail.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++98, c++03 // UNSUPPORTED: c++98, c++03
// <filesystem> // <filesystem>
// class path // class path
#include "filesystem_include.hpp" #include "filesystem_include.h"
#include <iterator> #include <iterator>
int main(int, char**) { int main(int, char**) {
using namespace fs; using namespace fs;
using RIt = std::reverse_iterator<path::iterator>; using RIt = std::reverse_iterator<path::iterator>;
// expected-error-re@iterator:* {{static_assert failed{{.*}} "The specified iterator type cannot be used with reverse_iterator; Using stashing iterators with reverse_iterator causes undefined behavior"}} // expected-error-re@iterator:* {{static_assert failed{{.*}} "The specified iterator type cannot be used with reverse_iterator; Using stashing iterators with reverse_iterator causes undefined behavior"}}
{ {
RIt r; RIt r;
((void)r); ((void)r);
} }
return 0; return 0;
} }

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

Show All 14 Lines
// [path.req] // [path.req]
// In addition to the requirements (5), function template parameters named // In addition to the requirements (5), function template parameters named
// `Source` shall be one of: // `Source` shall be one of:
// * basic_string<_ECharT, _Traits, _Alloc> // * basic_string<_ECharT, _Traits, _Alloc>
// * InputIterator with a value_type of _ECharT // * InputIterator with a value_type of _ECharT
// * A character array, which points to a NTCTS after array-to-pointer decay. // * A character array, which points to a NTCTS after array-to-pointer decay.
#include "filesystem_include.hpp" #include "filesystem_include.h"
#include <type_traits> #include <type_traits>
#include <cassert> #include <cassert>
#include "test_macros.h" #include "test_macros.h"
#include "test_iterators.h" #include "test_iterators.h"
#include "min_allocator.h" #include "min_allocator.h"
#include "constexpr_char_traits.hpp" #include "constexpr_char_traits.h"
using fs::__is_pathable; using fs::__is_pathable;
template <class Tp> template <class Tp>
struct Identity { typedef Tp type; }; struct Identity { typedef Tp type; };
template <class Source> template <class Source>
Identity<Source> CheckSourceType(Source const&); Identity<Source> CheckSourceType(Source const&);
▲ Show 20 Lines • Show All 67 Lines • Show Last 20 Lines

libcxx/trunk/test/libcxx/type_traits/convert_to_integral.pass.cpp

Show All 15 Lines
// Test that the __convert_to_integral functions properly converts Tp to the // Test that the __convert_to_integral functions properly converts Tp to the
// correct type and value for integral, enum and user defined types. // correct type and value for integral, enum and user defined types.
#include <limits> #include <limits>
#include <type_traits> #include <type_traits>
#include <cstdint> #include <cstdint>
#include <cassert> #include <cassert>
#include "user_defined_integral.hpp" #include "user_defined_integral.h"
#include "test_macros.h" #include "test_macros.h"
template <class T> template <class T>
struct EnumType struct EnumType
{ {
enum type : T {E_zero, E_one}; enum type : T {E_zero, E_one};
}; };
▲ Show 20 Lines • Show All 87 Lines • Show Last 20 Lines

libcxx/trunk/test/libcxx/utilities/optional/optional.object/triviality.abi.pass.cpp

Show All 18 Lines
// constexpr optional(optional&& rhs) noexcept(see below); // constexpr optional(optional&& rhs) noexcept(see below);
// constexpr optional<T>& operator=(const optional& rhs); // constexpr optional<T>& operator=(const optional& rhs);
// constexpr optional<T>& operator=(optional&& rhs) noexcept(see below); // constexpr optional<T>& operator=(optional&& rhs) noexcept(see below);
#include <optional> #include <optional>
#include <type_traits> #include <type_traits>
#include <cassert> #include <cassert>
#include "archetypes.hpp" #include "archetypes.h"
#include "test_macros.h" #include "test_macros.h"
template <class T> template <class T>
struct SpecialMemberTest { struct SpecialMemberTest {
using O = std::optional<T>; using O = std::optional<T>;
static_assert(std::is_trivially_destructible_v<O> == static_assert(std::is_trivially_destructible_v<O> ==
▲ Show 20 Lines • Show All 66 Lines • Show Last 20 Lines

libcxx/trunk/test/libcxx/utilities/tuple/tuple.tuple/tuple.cnstr/disable_reduced_arity_initialization_extension.pass.cpp

Show All 16 Lines
#include <tuple> #include <tuple>
#include <cassert> #include <cassert>
#include <type_traits> #include <type_traits>
#include <string> #include <string>
#include <system_error> #include <system_error>
#include "test_macros.h" #include "test_macros.h"
#include "test_convertible.hpp" #include "test_convertible.h"
#include "MoveOnly.h" #include "MoveOnly.h"
#if defined(_LIBCPP_ENABLE_TUPLE_IMPLICIT_REDUCED_ARITY_EXTENSION) #if defined(_LIBCPP_ENABLE_TUPLE_IMPLICIT_REDUCED_ARITY_EXTENSION)
#error This macro should not be defined by default #error This macro should not be defined by default
#endif #endif
struct NoDefault { NoDefault() = delete; }; struct NoDefault { NoDefault() = delete; };
▲ Show 20 Lines • Show All 76 Lines • Show Last 20 Lines

libcxx/trunk/test/libcxx/utilities/tuple/tuple.tuple/tuple.cnstr/enable_reduced_arity_initialization_extension.pass.cpp

Show All 18 Lines
#define _LIBCPP_ENABLE_TUPLE_IMPLICIT_REDUCED_ARITY_EXTENSION #define _LIBCPP_ENABLE_TUPLE_IMPLICIT_REDUCED_ARITY_EXTENSION
#include <tuple> #include <tuple>
#include <cassert> #include <cassert>
#include <type_traits> #include <type_traits>
#include <string> #include <string>
#include <system_error> #include <system_error>
#include "test_macros.h" #include "test_macros.h"
#include "test_convertible.hpp" #include "test_convertible.h"
#include "MoveOnly.h" #include "MoveOnly.h"
struct NoDefault { NoDefault() = delete; }; struct NoDefault { NoDefault() = delete; };
// Make sure the _Up... constructor SFINAEs out when the types that // Make sure the _Up... constructor SFINAEs out when the types that
// are not explicitly initialized are not all default constructible. // are not explicitly initialized are not all default constructible.
▲ Show 20 Lines • Show All 83 Lines • Show Last 20 Lines

libcxx/trunk/test/libcxx/utilities/utility/pairs/pairs.pair/assign_tuple_like.pass.cpp

Show All 14 Lines
// template<class U, class V> pair& operator=(tuple<U, V>&& p); // template<class U, class V> pair& operator=(tuple<U, V>&& p);
#include <utility> #include <utility>
#include <tuple> #include <tuple>
#include <array> #include <array>
#include <memory> #include <memory>
#include <cassert> #include <cassert>
#include "archetypes.hpp" #include "archetypes.h"
#include "test_macros.h" #include "test_macros.h"
// Clang warns about missing braces when initializing std::array. // Clang warns about missing braces when initializing std::array.
#if defined(__clang__) #if defined(__clang__)
#pragma clang diagnostic ignored "-Wmissing-braces" #pragma clang diagnostic ignored "-Wmissing-braces"
#endif #endif
▲ Show 20 Lines • Show All 76 Lines • Show Last 20 Lines

libcxx/trunk/test/libcxx/utilities/utility/pairs/pairs.pair/piecewise.pass.cpp

Show All 14 Lines
// template <class... Args1, class... Args2> // template <class... Args1, class... Args2>
// pair(piecewise_construct_t, tuple<Args1...> first_args, // pair(piecewise_construct_t, tuple<Args1...> first_args,
// tuple<Args2...> second_args); // tuple<Args2...> second_args);
#include <tuple> #include <tuple>
#include <type_traits> #include <type_traits>
#include <utility> #include <utility>
#include "archetypes.hpp" #include "archetypes.h"
#include "test_macros.h" #include "test_macros.h"
int main(int, char**) { int main(int, char**) {
using NonThrowingConvert = NonThrowingTypes::ConvertingType; using NonThrowingConvert = NonThrowingTypes::ConvertingType;
using ThrowingConvert = NonTrivialTypes::ConvertingType; using ThrowingConvert = NonTrivialTypes::ConvertingType;
static_assert(!std::is_nothrow_constructible<std::pair<ThrowingConvert, ThrowingConvert>, static_assert(!std::is_nothrow_constructible<std::pair<ThrowingConvert, ThrowingConvert>,
Show All 10 Lines

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

Show All 12 Lines
// constexpr OutIter // constexpr after C++17 // constexpr OutIter // constexpr after C++17
// copy_backward(InIter first, InIter last, OutIter result); // copy_backward(InIter first, InIter last, OutIter result);
#include <algorithm> #include <algorithm>
#include <cassert> #include <cassert>
#include "test_macros.h" #include "test_macros.h"
#include "test_iterators.h" #include "test_iterators.h"
#include "user_defined_integral.hpp" #include "user_defined_integral.h"
// #if TEST_STD_VER > 17 // #if TEST_STD_VER > 17
// TEST_CONSTEXPR bool test_constexpr() { // TEST_CONSTEXPR bool test_constexpr() {
// int ia[] = {1, 2, 3, 4, 5}; // int ia[] = {1, 2, 3, 4, 5};
// int ic[] = {6, 6, 6, 6, 6, 6, 6}; // int ic[] = {6, 6, 6, 6, 6, 6, 6};
// //
// size_t N = std::size(ia); // size_t N = std::size(ia);
// auto p = std::copy_backward(std::begin(ia), std::end(ia), std::begin(ic) + N); // auto p = std::copy_backward(std::begin(ia), std::end(ia), std::begin(ic) + N);
▲ Show 20 Lines • Show All 42 Lines • Show Last 20 Lines

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

Show All 11 Lines
// constexpr OutIter // constexpr after C++17 // constexpr OutIter // constexpr after C++17
// copy_n(InIter first, InIter::difference_type n, OutIter result); // copy_n(InIter first, InIter::difference_type n, OutIter result);
#include <algorithm> #include <algorithm>
#include <cassert> #include <cassert>
#include "test_macros.h" #include "test_macros.h"
#include "test_iterators.h" #include "test_iterators.h"
#include "user_defined_integral.hpp" #include "user_defined_integral.h"
// #if TEST_STD_VER > 17 // #if TEST_STD_VER > 17
// TEST_CONSTEXPR bool test_constexpr() { // TEST_CONSTEXPR bool test_constexpr() {
// int ia[] = {1, 2, 3, 4, 5}; // int ia[] = {1, 2, 3, 4, 5};
// int ic[] = {6, 6, 6, 6, 6, 6, 6}; // int ic[] = {6, 6, 6, 6, 6, 6, 6};
// //
// auto p = std::copy_n(std::begin(ia), 4, std::begin(ic)); // auto p = std::copy_n(std::begin(ia), 4, std::begin(ic));
// return std::equal(std::begin(ic), p, std::begin(ia)) // return std::equal(std::begin(ic), p, std::begin(ia))
▲ Show 20 Lines • Show All 66 Lines • Show Last 20 Lines

libcxx/trunk/test/std/algorithms/alg.modifying.operations/alg.fill/fill_n.pass.cpp

Show All 12 Lines
// constexpr OutputIterator // constexpr after C++17 // constexpr OutputIterator // constexpr after C++17
// fill_n(Iter first, Size n, const T& value); // fill_n(Iter first, Size n, const T& value);
#include <algorithm> #include <algorithm>
#include <cassert> #include <cassert>
#include "test_macros.h" #include "test_macros.h"
#include "test_iterators.h" #include "test_iterators.h"
#include "user_defined_integral.hpp" #include "user_defined_integral.h"
#if TEST_STD_VER > 17 #if TEST_STD_VER > 17
TEST_CONSTEXPR bool test_constexpr() { TEST_CONSTEXPR bool test_constexpr() {
const size_t N = 5; const size_t N = 5;
int ib[] = {0, 0, 0, 0, 0, 0}; // one bigger than N int ib[] = {0, 0, 0, 0, 0, 0}; // one bigger than N
auto it = std::fill_n(std::begin(ib), N, 5); auto it = std::fill_n(std::begin(ib), N, 5);
return it == (std::begin(ib) + N) return it == (std::begin(ib) + N)
▲ Show 20 Lines • Show All 146 Lines • Show Last 20 Lines

libcxx/trunk/test/std/algorithms/alg.modifying.operations/alg.generate/generate_n.pass.cpp

Show All 18 Lines
#ifdef TEST_COMPILER_C1XX #ifdef TEST_COMPILER_C1XX
#pragma warning(disable: 4244) // conversion from 'const double' to 'int', possible loss of data #pragma warning(disable: 4244) // conversion from 'const double' to 'int', possible loss of data
#endif #endif
#include <algorithm> #include <algorithm>
#include <cassert> #include <cassert>
#include "test_iterators.h" #include "test_iterators.h"
#include "user_defined_integral.hpp" #include "user_defined_integral.h"
struct gen_test struct gen_test
{ {
TEST_CONSTEXPR int operator()() const {return 2;} TEST_CONSTEXPR int operator()() const {return 2;}
}; };
#if TEST_STD_VER > 17 #if TEST_STD_VER > 17
▲ Show 20 Lines • Show All 54 Lines • Show Last 20 Lines

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

Show All 13 Lines
#include <algorithm> #include <algorithm>
#include <functional> #include <functional>
#include <cstddef> #include <cstddef>
#include <cassert> #include <cassert>
#include "test_macros.h" #include "test_macros.h"
#include "test_iterators.h" #include "test_iterators.h"
#include "counting_predicates.hpp" #include "counting_predicates.h"
struct is_odd { struct is_odd {
TEST_CONSTEXPR bool operator()(const int &i) const { return i & 1; } TEST_CONSTEXPR bool operator()(const int &i) const { return i & 1; }
}; };
#if TEST_STD_VER > 17 #if TEST_STD_VER > 17
TEST_CONSTEXPR bool test_constexpr() { TEST_CONSTEXPR bool test_constexpr() {
int ia[] = {1, 3, 5, 2, 4, 6}; int ia[] = {1, 3, 5, 2, 4, 6};
▲ Show 20 Lines • Show All 69 Lines • Show Last 20 Lines

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

Show All 15 Lines
#include <algorithm> #include <algorithm>
#include <functional> #include <functional>
#include <cassert> #include <cassert>
#include <memory> #include <memory>
#include "test_macros.h" #include "test_macros.h"
#include "test_iterators.h" #include "test_iterators.h"
#include "counting_predicates.hpp" #include "counting_predicates.h"
TEST_CONSTEXPR bool equal2 ( int i ) { return i == 2; } TEST_CONSTEXPR bool equal2 ( int i ) { return i == 2; }
#if TEST_STD_VER > 17 #if TEST_STD_VER > 17
TEST_CONSTEXPR bool test_constexpr() { TEST_CONSTEXPR bool test_constexpr() {
int ia[] = {1, 3, 5, 2, 5, 6}; int ia[] = {1, 3, 5, 2, 5, 6};
auto it = std::remove_if(std::begin(ia), std::end(ia), equal2); auto it = std::remove_if(std::begin(ia), std::end(ia), equal2);
▲ Show 20 Lines • Show All 78 Lines • Show Last 20 Lines

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

Show All 12 Lines
// search_n(ForwardIterator first, ForwardIterator last, Size count, // search_n(ForwardIterator first, ForwardIterator last, Size count,
// const T& value); // const T& value);
#include <algorithm> #include <algorithm>
#include <cassert> #include <cassert>
#include "test_macros.h" #include "test_macros.h"
#include "test_iterators.h" #include "test_iterators.h"
#include "user_defined_integral.hpp" #include "user_defined_integral.h"
#if TEST_STD_VER > 17 #if TEST_STD_VER > 17
TEST_CONSTEXPR bool test_constexpr() { TEST_CONSTEXPR bool test_constexpr() {
int ia[] = {0, 0, 1, 1, 2, 2}; int ia[] = {0, 0, 1, 1, 2, 2};
return (std::search_n(std::begin(ia), std::end(ia), 1, 0) == ia) return (std::search_n(std::begin(ia), std::end(ia), 1, 0) == ia)
&& (std::search_n(std::begin(ia), std::end(ia), 2, 1) == ia+2) && (std::search_n(std::begin(ia), std::end(ia), 2, 1) == ia+2)
&& (std::search_n(std::begin(ia), std::end(ia), 1, 3) == std::end(ia)) && (std::search_n(std::begin(ia), std::end(ia), 1, 3) == std::end(ia))
; ;
▲ Show 20 Lines • Show All 64 Lines • Show Last 20 Lines

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

Show All 12 Lines
// search_n(ForwardIterator first, ForwardIterator last, Size count, // search_n(ForwardIterator first, ForwardIterator last, Size count,
// const T& value, BinaryPredicate pred); // const T& value, BinaryPredicate pred);
#include <algorithm> #include <algorithm>
#include <cassert> #include <cassert>
#include "test_macros.h" #include "test_macros.h"
#include "test_iterators.h" #include "test_iterators.h"
#include "user_defined_integral.hpp" #include "user_defined_integral.h"
#if TEST_STD_VER > 17 #if TEST_STD_VER > 17
TEST_CONSTEXPR bool eq(int a, int b) { return a == b; } TEST_CONSTEXPR bool eq(int a, int b) { return a == b; }
TEST_CONSTEXPR bool test_constexpr() { TEST_CONSTEXPR bool test_constexpr() {
int ia[] = {0, 0, 1, 1, 2, 2}; int ia[] = {0, 0, 1, 1, 2, 2};
return (std::search_n(std::begin(ia), std::end(ia), 1, 0, eq) == ia) return (std::search_n(std::begin(ia), std::end(ia), 1, 0, eq) == ia)
&& (std::search_n(std::begin(ia), std::end(ia), 2, 1, eq) == ia+2) && (std::search_n(std::begin(ia), std::end(ia), 2, 1, eq) == ia+2)
▲ Show 20 Lines • Show All 143 Lines • Show Last 20 Lines

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

Show All 18 Lines
// mismatch(Iter1 first1, Iter1 last1, Iter2 first2, Iter2 last2, Pred pred); // C++14 // mismatch(Iter1 first1, Iter1 last1, Iter2 first2, Iter2 last2, Pred pred); // C++14
#include <algorithm> #include <algorithm>
#include <functional> #include <functional>
#include <cassert> #include <cassert>
#include "test_macros.h" #include "test_macros.h"
#include "test_iterators.h" #include "test_iterators.h"
#include "counting_predicates.hpp" #include "counting_predicates.h"
#if TEST_STD_VER > 17 #if TEST_STD_VER > 17
TEST_CONSTEXPR bool eq(int a, int b) { return a == b; } TEST_CONSTEXPR bool eq(int a, int b) { return a == b; }
TEST_CONSTEXPR bool test_constexpr() { TEST_CONSTEXPR bool test_constexpr() {
int ia[] = {1, 3, 6, 7}; int ia[] = {1, 3, 6, 7};
int ib[] = {1, 3}; int ib[] = {1, 3};
int ic[] = {1, 3, 5, 7}; int ic[] = {1, 3, 5, 7};
▲ Show 20 Lines • Show All 84 Lines • Show Last 20 Lines

libcxx/trunk/test/std/algorithms/alg.sorting/alg.heap.operations/make.heap/make_heap_comp.pass.cpp

Show All 14 Lines
#include <algorithm> #include <algorithm>
#include <functional> #include <functional>
#include <memory> #include <memory>
#include <random> #include <random>
#include <cassert> #include <cassert>
#include "test_macros.h" #include "test_macros.h"
#include "counting_predicates.hpp" #include "counting_predicates.h"
#include "test_iterators.h" #include "test_iterators.h"
struct indirect_less struct indirect_less
{ {
template <class P> template <class P>
bool operator()(const P& x, const P& y) bool operator()(const P& x, const P& y)
{return *x < *y;} {return *x < *y;}
}; };
▲ Show 20 Lines • Show All 77 Lines • Show Last 20 Lines

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

Show First 20 Lines • Show All 50 Lines • ▼ Show 20 Linesstruct S {
int i_; int i_;
}; };
#endif // TEST_STD_VER >= 11 #endif // TEST_STD_VER >= 11
#include "test_iterators.h" #include "test_iterators.h"
#include "counting_predicates.hpp" #include "counting_predicates.h"
std::mt19937 randomness; std::mt19937 randomness;
template <class Iter> template <class Iter>
void void
test_one(unsigned N, unsigned M) test_one(unsigned N, unsigned M)
{ {
assert(M <= N); assert(M <= N);
▲ Show 20 Lines • Show All 105 Lines • Show Last 20 Lines

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

Show All 20 Lines
#include <algorithm> #include <algorithm>
#include <functional> #include <functional>
#include <random> #include <random>
#include <cassert> #include <cassert>
#include "test_macros.h" #include "test_macros.h"
#include "test_iterators.h" #include "test_iterators.h"
#include "counting_predicates.hpp" #include "counting_predicates.h"
// #if TEST_STD_VER > 17 // #if TEST_STD_VER > 17
// TEST_CONSTEXPR bool test_constexpr() { // TEST_CONSTEXPR bool test_constexpr() {
// int ia[] = {0, 1, 2, 3, 4}; // int ia[] = {0, 1, 2, 3, 4};
// int ib[] = {2, 4, 6, 8}; // int ib[] = {2, 4, 6, 8};
// int ic[] = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0}; // int ic[] = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
// const int expected[] = {0, 1, 2, 2, 3, 4, 4, 6, 8}; // const int expected[] = {0, 1, 2, 2, 3, 4, 4, 6, 8};
// //
▲ Show 20 Lines • Show All 224 Lines • Show Last 20 Lines

libcxx/trunk/test/std/algorithms/alg.sorting/alg.min.max/minmax_init_list_comp.pass.cpp

Show All 15 Lines
// //
// Complexity: At most (3/2) * t.size() applications of the corresponding predicate. // Complexity: At most (3/2) * t.size() applications of the corresponding predicate.
#include <algorithm> #include <algorithm>
#include <functional> #include <functional>
#include <cassert> #include <cassert>
#include "test_macros.h" #include "test_macros.h"
#include "counting_predicates.hpp" #include "counting_predicates.h"
bool all_equal(int, int) { return false; } // everything is equal bool all_equal(int, int) { return false; } // everything is equal
void test_all_equal(std::initializer_list<int> il) void test_all_equal(std::initializer_list<int> il)
{ {
binary_counting_predicate<bool(*)(int, int), int, int> pred (all_equal); binary_counting_predicate<bool(*)(int, int), int, int> pred (all_equal);
std::pair<int, int> p = std::minmax(il, std::ref(pred)); std::pair<int, int> p = std::minmax(il, std::ref(pred));
const int *ptr = il.end(); const int *ptr = il.end();
▲ Show 20 Lines • Show All 45 Lines • Show Last 20 Lines

libcxx/trunk/test/std/containers/associative/map/map.access/index_key.pass.cpp

Show All 10 Lines
// class map // class map
// mapped_type& operator[](const key_type& k); // mapped_type& operator[](const key_type& k);
#include <map> #include <map>
#include <cassert> #include <cassert>
#include "test_macros.h" #include "test_macros.h"
#include "count_new.hpp" #include "count_new.h"
#include "min_allocator.h" #include "min_allocator.h"
#include "private_constructor.hpp" #include "private_constructor.h"
#if TEST_STD_VER >= 11 #if TEST_STD_VER >= 11
#include "container_test_types.h" #include "container_test_types.h"
#endif #endif
int main(int, char**) int main(int, char**)
{ {
{ {
typedef std::pair<const int, double> V; typedef std::pair<const int, double> V;
▲ Show 20 Lines • Show All 115 Lines • Show Last 20 Lines

libcxx/trunk/test/std/containers/associative/map/map.access/index_rv_key.pass.cpp

Show All 12 Lines
// class map // class map
// mapped_type& operator[](key_type&& k); // mapped_type& operator[](key_type&& k);
#include <map> #include <map>
#include <cassert> #include <cassert>
#include "test_macros.h" #include "test_macros.h"
#include "count_new.hpp" #include "count_new.h"
#include "MoveOnly.h" #include "MoveOnly.h"
#include "min_allocator.h" #include "min_allocator.h"
#include "container_test_types.h" #include "container_test_types.h"
int main(int, char**) int main(int, char**)
{ {
{ {
std::map<MoveOnly, double> m; std::map<MoveOnly, double> m;
▲ Show 20 Lines • Show All 52 Lines • Show Last 20 Lines

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

Show All 11 Lines
// size_type count(const key_type& k) const; // size_type count(const key_type& k) const;
#include <map> #include <map>
#include <cassert> #include <cassert>
#include "test_macros.h" #include "test_macros.h"
#include "min_allocator.h" #include "min_allocator.h"
#include "private_constructor.hpp" #include "private_constructor.h"
#include "is_transparent.h" #include "is_transparent.h"
int main(int, char**) int main(int, char**)
{ {
{ {
typedef std::pair<const int, double> V; typedef std::pair<const int, double> V;
typedef std::map<int, double> M; typedef std::map<int, double> M;
{ {
▲ Show 20 Lines • Show All 167 Lines • Show Last 20 Lines

libcxx/trunk/test/std/containers/associative/map/map.ops/count_transparent.pass.cpp

Show All 14 Lines
// template<typename K> // template<typename K>
// size_type count(const K& x) const; // C++14 // size_type count(const K& x) const; // C++14
#include <cassert> #include <cassert>
#include <map> #include <map>
#include <utility> #include <utility>
#include "min_allocator.h" #include "min_allocator.h"
#include "private_constructor.hpp" #include "private_constructor.h"
#include "test_macros.h" #include "test_macros.h"
struct Comp { struct Comp {
using is_transparent = void; using is_transparent = void;
bool operator()(const std::pair<int, int> &lhs, bool operator()(const std::pair<int, int> &lhs,
const std::pair<int, int> &rhs) const { const std::pair<int, int> &rhs) const {
return lhs < rhs; return lhs < rhs;
Show All 20 Lines

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

Show All 12 Lines
// pair<iterator,iterator> equal_range(const key_type& k); // pair<iterator,iterator> equal_range(const key_type& k);
// pair<const_iterator,const_iterator> equal_range(const key_type& k) const; // pair<const_iterator,const_iterator> equal_range(const key_type& k) const;
#include <map> #include <map>
#include <cassert> #include <cassert>
#include "test_macros.h" #include "test_macros.h"
#include "min_allocator.h" #include "min_allocator.h"
#include "private_constructor.hpp" #include "private_constructor.h"
#include "is_transparent.h" #include "is_transparent.h"
int main(int, char**) int main(int, char**)
{ {
{ {
typedef std::pair<const int, double> V; typedef std::pair<const int, double> V;
typedef std::map<int, double> M; typedef std::map<int, double> M;
{ {
▲ Show 20 Lines • Show All 463 Lines • Show Last 20 Lines

libcxx/trunk/test/std/containers/associative/map/map.ops/equal_range_transparent.pass.cpp

Show All 17 Lines
// pair<const_iterator,const_iterator> equal_range(const K& x) const; // pair<const_iterator,const_iterator> equal_range(const K& x) const;
// // C++14 // // C++14
#include <cassert> #include <cassert>
#include <map> #include <map>
#include <utility> #include <utility>
#include "min_allocator.h" #include "min_allocator.h"
#include "private_constructor.hpp" #include "private_constructor.h"
#include "test_macros.h" #include "test_macros.h"
struct Comp { struct Comp {
using is_transparent = void; using is_transparent = void;
bool operator()(const std::pair<int, int> &lhs, bool operator()(const std::pair<int, int> &lhs,
const std::pair<int, int> &rhs) const { const std::pair<int, int> &rhs) const {
return lhs < rhs; return lhs < rhs;
Show All 27 Lines

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

Show All 12 Lines
// iterator find(const key_type& k); // iterator find(const key_type& k);
// const_iterator find(const key_type& k) const; // const_iterator find(const key_type& k) const;
#include <map> #include <map>
#include <cassert> #include <cassert>
#include "test_macros.h" #include "test_macros.h"
#include "min_allocator.h" #include "min_allocator.h"
#include "private_constructor.hpp" #include "private_constructor.h"
#include "is_transparent.h" #include "is_transparent.h"
int main(int, char**) int main(int, char**)
{ {
{ {
typedef std::pair<const int, double> V; typedef std::pair<const int, double> V;
typedef std::map<int, double> M; typedef std::map<int, double> M;
{ {
▲ Show 20 Lines • Show All 233 Lines • Show Last 20 Lines

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

Show All 12 Lines
// iterator lower_bound(const key_type& k); // iterator lower_bound(const key_type& k);
// const_iterator lower_bound(const key_type& k) const; // const_iterator lower_bound(const key_type& k) const;
#include <map> #include <map>
#include <cassert> #include <cassert>
#include "test_macros.h" #include "test_macros.h"
#include "min_allocator.h" #include "min_allocator.h"
#include "private_constructor.hpp" #include "private_constructor.h"
#include "is_transparent.h" #include "is_transparent.h"
int main(int, char**) int main(int, char**)
{ {
{ {
typedef std::pair<const int, double> V; typedef std::pair<const int, double> V;
typedef std::map<int, double> M; typedef std::map<int, double> M;
{ {
▲ Show 20 Lines • Show All 345 Lines • Show Last 20 Lines

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

Show All 12 Lines
// iterator upper_bound(const key_type& k); // iterator upper_bound(const key_type& k);
// const_iterator upper_bound(const key_type& k) const; // const_iterator upper_bound(const key_type& k) const;
#include <map> #include <map>
#include <cassert> #include <cassert>
#include "test_macros.h" #include "test_macros.h"
#include "min_allocator.h" #include "min_allocator.h"
#include "private_constructor.hpp" #include "private_constructor.h"
int main(int, char**) int main(int, char**)
{ {
{ {
typedef std::pair<const int, double> V; typedef std::pair<const int, double> V;
typedef std::map<int, double> M; typedef std::map<int, double> M;
{ {
typedef M::iterator R; typedef M::iterator R;
▲ Show 20 Lines • Show All 308 Lines • Show Last 20 Lines

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

Show All 11 Lines
// size_type count(const key_type& k) const; // size_type count(const key_type& k) const;
#include <map> #include <map>
#include <cassert> #include <cassert>
#include "test_macros.h" #include "test_macros.h"
#include "min_allocator.h" #include "min_allocator.h"
#include "private_constructor.hpp" #include "private_constructor.h"
#include "is_transparent.h" #include "is_transparent.h"
int main(int, char**) int main(int, char**)
{ {
typedef std::pair<const int, double> V; typedef std::pair<const int, double> V;
{ {
typedef std::multimap<int, double> M; typedef std::multimap<int, double> M;
{ {
▲ Show 20 Lines • Show All 149 Lines • Show Last 20 Lines

libcxx/trunk/test/std/containers/associative/multimap/multimap.ops/count_transparent.pass.cpp

Show All 14 Lines
// template<typename K> // template<typename K>
// size_type count(const K& x) const; // C++14 // size_type count(const K& x) const; // C++14
#include <cassert> #include <cassert>
#include <map> #include <map>
#include <utility> #include <utility>
#include "min_allocator.h" #include "min_allocator.h"
#include "private_constructor.hpp" #include "private_constructor.h"
#include "test_macros.h" #include "test_macros.h"
struct Comp { struct Comp {
using is_transparent = void; using is_transparent = void;
bool operator()(const std::pair<int, int> &lhs, bool operator()(const std::pair<int, int> &lhs,
const std::pair<int, int> &rhs) const { const std::pair<int, int> &rhs) const {
return lhs < rhs; return lhs < rhs;
Show All 20 Lines

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

Show All 12 Lines
// pair<iterator, iterator> equal_range(const key_type& k); // pair<iterator, iterator> equal_range(const key_type& k);
// pair<const_iterator, const_iterator> equal_range(const key_type& k) const; // pair<const_iterator, const_iterator> equal_range(const key_type& k) const;
#include <map> #include <map>
#include <cassert> #include <cassert>
#include "test_macros.h" #include "test_macros.h"
#include "min_allocator.h" #include "min_allocator.h"
#include "private_constructor.hpp" #include "private_constructor.h"
#include "is_transparent.h" #include "is_transparent.h"
int main(int, char**) int main(int, char**)
{ {
typedef std::pair<const int, double> V; typedef std::pair<const int, double> V;
{ {
typedef std::multimap<int, double> M; typedef std::multimap<int, double> M;
{ {
▲ Show 20 Lines • Show All 259 Lines • Show Last 20 Lines

libcxx/trunk/test/std/containers/associative/multimap/multimap.ops/equal_range_transparent.pass.cpp

Show All 17 Lines
// pair<const_iterator,const_iterator> equal_range(const K& x) const; // pair<const_iterator,const_iterator> equal_range(const K& x) const;
// // C++14 // // C++14
#include <cassert> #include <cassert>
#include <map> #include <map>
#include <utility> #include <utility>
#include "min_allocator.h" #include "min_allocator.h"
#include "private_constructor.hpp" #include "private_constructor.h"
#include "test_macros.h" #include "test_macros.h"
struct Comp { struct Comp {
using is_transparent = void; using is_transparent = void;
bool operator()(const std::pair<int, int> &lhs, bool operator()(const std::pair<int, int> &lhs,
const std::pair<int, int> &rhs) const { const std::pair<int, int> &rhs) const {
return lhs < rhs; return lhs < rhs;
Show All 27 Lines

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

Show All 12 Lines
// iterator find(const key_type& k); // iterator find(const key_type& k);
// const_iterator find(const key_type& k) const; // const_iterator find(const key_type& k) const;
#include <map> #include <map>
#include <cassert> #include <cassert>
#include "test_macros.h" #include "test_macros.h"
#include "min_allocator.h" #include "min_allocator.h"
#include "private_constructor.hpp" #include "private_constructor.h"
#include "is_transparent.h" #include "is_transparent.h"
int main(int, char**) int main(int, char**)
{ {
typedef std::pair<const int, double> V; typedef std::pair<const int, double> V;
{ {
typedef std::multimap<int, double> M; typedef std::multimap<int, double> M;
{ {
▲ Show 20 Lines • Show All 195 Lines • Show Last 20 Lines

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

Show All 12 Lines
// iterator lower_bound(const key_type& k); // iterator lower_bound(const key_type& k);
// const_iterator lower_bound(const key_type& k) const; // const_iterator lower_bound(const key_type& k) const;
#include <map> #include <map>
#include <cassert> #include <cassert>
#include "test_macros.h" #include "test_macros.h"
#include "min_allocator.h" #include "min_allocator.h"
#include "private_constructor.hpp" #include "private_constructor.h"
#include "is_transparent.h" #include "is_transparent.h"
int main(int, char**) int main(int, char**)
{ {
typedef std::pair<const int, double> V; typedef std::pair<const int, double> V;
{ {
typedef std::multimap<int, double> M; typedef std::multimap<int, double> M;
{ {
▲ Show 20 Lines • Show All 209 Lines • Show Last 20 Lines

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

Show All 12 Lines
// iterator upper_bound(const key_type& k); // iterator upper_bound(const key_type& k);
// const_iterator upper_bound(const key_type& k) const; // const_iterator upper_bound(const key_type& k) const;
#include <map> #include <map>
#include <cassert> #include <cassert>
#include "test_macros.h" #include "test_macros.h"
#include "min_allocator.h" #include "min_allocator.h"
#include "private_constructor.hpp" #include "private_constructor.h"
#include "is_transparent.h" #include "is_transparent.h"
int main(int, char**) int main(int, char**)
{ {
typedef std::pair<const int, double> V; typedef std::pair<const int, double> V;
{ {
typedef std::multimap<int, double> M; typedef std::multimap<int, double> M;
{ {
▲ Show 20 Lines • Show All 208 Lines • Show Last 20 Lines

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

Show All 11 Lines
// size_type count(const key_type& k) const; // size_type count(const key_type& k) const;
#include <set> #include <set>
#include <cassert> #include <cassert>
#include "test_macros.h" #include "test_macros.h"
#include "min_allocator.h" #include "min_allocator.h"
#include "private_constructor.hpp" #include "private_constructor.h"
int main(int, char**) int main(int, char**)
{ {
{ {
typedef int V; typedef int V;
typedef std::multiset<int> M; typedef std::multiset<int> M;
{ {
typedef M::size_type R; typedef M::size_type R;
▲ Show 20 Lines • Show All 134 Lines • Show Last 20 Lines

libcxx/trunk/test/std/containers/associative/multiset/count_transparent.pass.cpp

Show All 16 Lines
// template<typename K> // template<typename K>
// const_iterator lower_bound(const K& x) const; // C++14 // const_iterator lower_bound(const K& x) const; // C++14
#include <cassert> #include <cassert>
#include <set> #include <set>
#include <utility> #include <utility>
#include "min_allocator.h" #include "min_allocator.h"
#include "private_constructor.hpp" #include "private_constructor.h"
#include "test_macros.h" #include "test_macros.h"
struct Comp { struct Comp {
using is_transparent = void; using is_transparent = void;
bool operator()(const std::pair<int, int> &lhs, bool operator()(const std::pair<int, int> &lhs,
const std::pair<int, int> &rhs) const { const std::pair<int, int> &rhs) const {
return lhs < rhs; return lhs < rhs;
Show All 19 Lines

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

Show All 12 Lines
// pair<iterator,iterator> equal_range(const key_type& k); // pair<iterator,iterator> equal_range(const key_type& k);
// pair<const_iterator,const_iterator> equal_range(const key_type& k) const; // pair<const_iterator,const_iterator> equal_range(const key_type& k) const;
#include <set> #include <set>
#include <cassert> #include <cassert>
#include "test_macros.h" #include "test_macros.h"
#include "min_allocator.h" #include "min_allocator.h"
#include "private_constructor.hpp" #include "private_constructor.h"
int main(int, char**) int main(int, char**)
{ {
{ {
typedef int V; typedef int V;
typedef std::multiset<int> M; typedef std::multiset<int> M;
{ {
typedef std::pair<M::iterator, M::iterator> R; typedef std::pair<M::iterator, M::iterator> R;
▲ Show 20 Lines • Show All 236 Lines • Show Last 20 Lines

libcxx/trunk/test/std/containers/associative/multiset/equal_range_transparent.pass.cpp

Show All 18 Lines
// pair<const_iterator,const_iterator> equal_range(const K& x) const; // // pair<const_iterator,const_iterator> equal_range(const K& x) const; //
// C++14 // C++14
#include <cassert> #include <cassert>
#include <set> #include <set>
#include <utility> #include <utility>
#include "min_allocator.h" #include "min_allocator.h"
#include "private_constructor.hpp" #include "private_constructor.h"
#include "test_macros.h" #include "test_macros.h"
struct Comp { struct Comp {
using is_transparent = void; using is_transparent = void;
bool operator()(const std::pair<int, int> &lhs, bool operator()(const std::pair<int, int> &lhs,
const std::pair<int, int> &rhs) const { const std::pair<int, int> &rhs) const {
return lhs < rhs; return lhs < rhs;
Show All 26 Lines

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

Show All 12 Lines
// iterator find(const key_type& k); // iterator find(const key_type& k);
// const_iterator find(const key_type& k) const; // const_iterator find(const key_type& k) const;
#include <set> #include <set>
#include <cassert> #include <cassert>
#include "test_macros.h" #include "test_macros.h"
#include "min_allocator.h" #include "min_allocator.h"
#include "private_constructor.hpp" #include "private_constructor.h"
int main(int, char**) int main(int, char**)
{ {
{ {
typedef int V; typedef int V;
typedef std::multiset<int> M; typedef std::multiset<int> M;
{ {
typedef M::iterator R; typedef M::iterator R;
▲ Show 20 Lines • Show All 213 Lines • Show Last 20 Lines

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

Show All 12 Lines
// iterator lower_bound(const key_type& k); // iterator lower_bound(const key_type& k);
// const_iterator lower_bound(const key_type& k) const; // const_iterator lower_bound(const key_type& k) const;
#include <set> #include <set>
#include <cassert> #include <cassert>
#include "test_macros.h" #include "test_macros.h"
#include "min_allocator.h" #include "min_allocator.h"
#include "private_constructor.hpp" #include "private_constructor.h"
int main(int, char**) int main(int, char**)
{ {
{ {
typedef int V; typedef int V;
typedef std::multiset<int> M; typedef std::multiset<int> M;
{ {
typedef M::iterator R; typedef M::iterator R;
▲ Show 20 Lines • Show All 196 Lines • Show Last 20 Lines

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

Show All 12 Lines
// iterator upper_bound(const key_type& k); // iterator upper_bound(const key_type& k);
// const_iterator upper_bound(const key_type& k) const; // const_iterator upper_bound(const key_type& k) const;
#include <set> #include <set>
#include <cassert> #include <cassert>
#include "test_macros.h" #include "test_macros.h"
#include "min_allocator.h" #include "min_allocator.h"
#include "private_constructor.hpp" #include "private_constructor.h"
int main(int, char**) int main(int, char**)
{ {
{ {
typedef int V; typedef int V;
typedef std::multiset<int> M; typedef std::multiset<int> M;
{ {
typedef M::iterator R; typedef M::iterator R;
▲ Show 20 Lines • Show All 195 Lines • Show Last 20 Lines

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

Show All 11 Lines
// size_type count(const key_type& k) const; // size_type count(const key_type& k) const;
#include <set> #include <set>
#include <cassert> #include <cassert>
#include "test_macros.h" #include "test_macros.h"
#include "min_allocator.h" #include "min_allocator.h"
#include "private_constructor.hpp" #include "private_constructor.h"
int main(int, char**) int main(int, char**)
{ {
{ {
typedef int V; typedef int V;
typedef std::set<int> M; typedef std::set<int> M;
typedef M::size_type R; typedef M::size_type R;
V ar[] = V ar[] =
▲ Show 20 Lines • Show All 144 Lines • Show Last 20 Lines

libcxx/trunk/test/std/containers/associative/set/count_transparent.pass.cpp

Show All 16 Lines
// template<typename K> // template<typename K>
// const_iterator lower_bound(const K& x) const; // C++14 // const_iterator lower_bound(const K& x) const; // C++14
#include <cassert> #include <cassert>
#include <set> #include <set>
#include <utility> #include <utility>
#include "min_allocator.h" #include "min_allocator.h"
#include "private_constructor.hpp" #include "private_constructor.h"
#include "test_macros.h" #include "test_macros.h"
struct Comp { struct Comp {
using is_transparent = void; using is_transparent = void;
bool operator()(const std::pair<int, int> &lhs, bool operator()(const std::pair<int, int> &lhs,
const std::pair<int, int> &rhs) const { const std::pair<int, int> &rhs) const {
return lhs < rhs; return lhs < rhs;
Show All 19 Lines

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

Show All 12 Lines
// pair<iterator,iterator> equal_range(const key_type& k); // pair<iterator,iterator> equal_range(const key_type& k);
// pair<const_iterator,const_iterator> equal_range(const key_type& k) const; // pair<const_iterator,const_iterator> equal_range(const key_type& k) const;
#include <set> #include <set>
#include <cassert> #include <cassert>
#include "test_macros.h" #include "test_macros.h"
#include "min_allocator.h" #include "min_allocator.h"
#include "private_constructor.hpp" #include "private_constructor.h"
int main(int, char**) int main(int, char**)
{ {
{ {
typedef int V; typedef int V;
typedef std::set<int> M; typedef std::set<int> M;
{ {
typedef std::pair<M::iterator, M::iterator> R; typedef std::pair<M::iterator, M::iterator> R;
▲ Show 20 Lines • Show All 343 Lines • Show Last 20 Lines

libcxx/trunk/test/std/containers/associative/set/equal_range_transparent.pass.cpp

Show All 18 Lines
// pair<const_iterator,const_iterator> equal_range(const K& x) const; // // pair<const_iterator,const_iterator> equal_range(const K& x) const; //
// C++14 // C++14
#include <cassert> #include <cassert>
#include <set> #include <set>
#include <utility> #include <utility>
#include "min_allocator.h" #include "min_allocator.h"
#include "private_constructor.hpp" #include "private_constructor.h"
#include "test_macros.h" #include "test_macros.h"
struct Comp { struct Comp {
using is_transparent = void; using is_transparent = void;
bool operator()(const std::pair<int, int> &lhs, bool operator()(const std::pair<int, int> &lhs,
const std::pair<int, int> &rhs) const { const std::pair<int, int> &rhs) const {
return lhs < rhs; return lhs < rhs;
Show All 26 Lines

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

Show All 12 Lines
// iterator find(const key_type& k); // iterator find(const key_type& k);
// const_iterator find(const key_type& k) const; // const_iterator find(const key_type& k) const;
#include <set> #include <set>
#include <cassert> #include <cassert>
#include "test_macros.h" #include "test_macros.h"
#include "min_allocator.h" #include "min_allocator.h"
#include "private_constructor.hpp" #include "private_constructor.h"
int main(int, char**) int main(int, char**)
{ {
{ {
typedef int V; typedef int V;
typedef std::set<int> M; typedef std::set<int> M;
{ {
typedef M::iterator R; typedef M::iterator R;
▲ Show 20 Lines • Show All 213 Lines • Show Last 20 Lines

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

Show All 12 Lines
// iterator lower_bound(const key_type& k); // iterator lower_bound(const key_type& k);
// const_iterator lower_bound(const key_type& k) const; // const_iterator lower_bound(const key_type& k) const;
#include <set> #include <set>
#include <cassert> #include <cassert>
#include "test_macros.h" #include "test_macros.h"
#include "min_allocator.h" #include "min_allocator.h"
#include "private_constructor.hpp" #include "private_constructor.h"
int main(int, char**) int main(int, char**)
{ {
{ {
typedef int V; typedef int V;
typedef std::set<int> M; typedef std::set<int> M;
{ {
typedef M::iterator R; typedef M::iterator R;
▲ Show 20 Lines • Show All 310 Lines • Show Last 20 Lines

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

Show All 12 Lines
// iterator upper_bound(const key_type& k); // iterator upper_bound(const key_type& k);
// const_iterator upper_bound(const key_type& k) const; // const_iterator upper_bound(const key_type& k) const;
#include <set> #include <set>
#include <cassert> #include <cassert>
#include "test_macros.h" #include "test_macros.h"
#include "min_allocator.h" #include "min_allocator.h"
#include "private_constructor.hpp" #include "private_constructor.h"
int main(int, char**) int main(int, char**)
{ {
{ {
typedef int V; typedef int V;
typedef std::set<int> M; typedef std::set<int> M;
{ {
typedef M::iterator R; typedef M::iterator R;
▲ Show 20 Lines • Show All 309 Lines • Show Last 20 Lines

libcxx/trunk/test/std/containers/map_allocator_requirement_test_templates.h

Show All 17 Lines
// emplace(...); // emplace(...);
// emplace_hint(...); // emplace_hint(...);
// UNSUPPORTED: c++98, c++03 // UNSUPPORTED: c++98, c++03
#include <cassert> #include <cassert>
#include "test_macros.h" #include "test_macros.h"
#include "count_new.hpp" #include "count_new.h"
#include "container_test_types.h" #include "container_test_types.h"
#include "assert_checkpoint.h" #include "assert_checkpoint.h"
template <class Container> template <class Container>
void testMapInsert() void testMapInsert()
{ {
typedef typename Container::value_type ValueTp; typedef typename Container::value_type ValueTp;
▲ Show 20 Lines • Show All 700 Lines • Show Last 20 Lines

libcxx/trunk/test/std/containers/sequences/forwardlist/forwardlist.ops/remove_if.pass.cpp

Show All 12 Lines
#include <forward_list> #include <forward_list>
#include <iterator> #include <iterator>
#include <cassert> #include <cassert>
#include <cstddef> #include <cstddef>
#include "test_macros.h" #include "test_macros.h"
#include "min_allocator.h" #include "min_allocator.h"
#include "counting_predicates.hpp" #include "counting_predicates.h"
template <class L, class Predicate> template <class L, class Predicate>
void do_remove_if(L &l, Predicate pred, typename L::size_type expected) void do_remove_if(L &l, Predicate pred, typename L::size_type expected)
{ {
typename L::size_type old_size = std::distance(l.begin(), l.end()); typename L::size_type old_size = std::distance(l.begin(), l.end());
#if TEST_STD_VER > 17 #if TEST_STD_VER > 17
ASSERT_SAME_TYPE(decltype(l.remove_if(pred)), typename L::size_type); ASSERT_SAME_TYPE(decltype(l.remove_if(pred)), typename L::size_type);
▲ Show 20 Lines • Show All 168 Lines • Show Last 20 Lines

libcxx/trunk/test/std/containers/sequences/list/list.modifiers/insert_iter_iter_iter.pass.cpp

Show All 12 Lines
#include <list> #include <list>
#include <cstdlib> #include <cstdlib>
#include <cassert> #include <cassert>
#include "test_macros.h" #include "test_macros.h"
#include "test_iterators.h" #include "test_iterators.h"
#include "min_allocator.h" #include "min_allocator.h"
#include "count_new.hpp" #include "count_new.h"
template <class List> template <class List>
void test() { void test() {
int a1[] = {1, 2, 3}; int a1[] = {1, 2, 3};
List l1; List l1;
typename List::iterator i = l1.insert(l1.begin(), a1, a1+3); typename List::iterator i = l1.insert(l1.begin(), a1, a1+3);
assert(i == l1.begin()); assert(i == l1.begin());
assert(l1.size() == 3); assert(l1.size() == 3);
▲ Show 20 Lines • Show All 63 Lines • Show Last 20 Lines

libcxx/trunk/test/std/containers/sequences/list/list.modifiers/insert_iter_size_value.pass.cpp

Show All 11 Lines
// UNSUPPORTED: sanitizer-new-delete // UNSUPPORTED: sanitizer-new-delete
#include <list> #include <list>
#include <cstdlib> #include <cstdlib>
#include <cassert> #include <cassert>
#include "min_allocator.h" #include "min_allocator.h"
#include "count_new.hpp" #include "count_new.h"
#include "test_macros.h" #include "test_macros.h"
template <class List> template <class List>
void test() { void test() {
int a1[] = {1, 2, 3}; int a1[] = {1, 2, 3};
int a2[] = {1, 4, 4, 4, 4, 4, 2, 3}; int a2[] = {1, 4, 4, 4, 4, 4, 2, 3};
List l1(a1, a1+3); List l1(a1, a1+3);
typename List::iterator i = l1.insert(next(l1.cbegin()), 5, 4); typename List::iterator i = l1.insert(next(l1.cbegin()), 5, 4);
Show All 27 Lines

libcxx/trunk/test/std/containers/sequences/list/list.modifiers/insert_iter_value.pass.cpp

Show All 10 Lines
// iterator insert(const_iterator position, const value_type& x); // iterator insert(const_iterator position, const value_type& x);
#include <list> #include <list>
#include <cstdlib> #include <cstdlib>
#include <cassert> #include <cassert>
#include "test_macros.h" #include "test_macros.h"
#include "min_allocator.h" #include "min_allocator.h"
#include "count_new.hpp" #include "count_new.h"
template <class List> template <class List>
void test() void test()
{ {
int a1[] = {1, 2, 3}; int a1[] = {1, 2, 3};
int a2[] = {1, 4, 2, 3}; int a2[] = {1, 4, 2, 3};
List l1(a1, a1+3); List l1(a1, a1+3);
typename List::iterator i = l1.insert(next(l1.cbegin()), 4); typename List::iterator i = l1.insert(next(l1.cbegin()), 4);
Show All 30 Lines

libcxx/trunk/test/std/containers/sequences/list/list.ops/remove_if.pass.cpp

Show All 11 Lines
// template <class Pred> size_type remove_if(Pred pred); // c++20 and later // template <class Pred> size_type remove_if(Pred pred); // c++20 and later
#include <list> #include <list>
#include <cassert> #include <cassert>
#include <functional> #include <functional>
#include "test_macros.h" #include "test_macros.h"
#include "min_allocator.h" #include "min_allocator.h"
#include "counting_predicates.hpp" #include "counting_predicates.h"
bool even(int i) bool even(int i)
{ {
return i % 2 == 0; return i % 2 == 0;
} }
bool g(int i) bool g(int i)
{ {
▲ Show 20 Lines • Show All 76 Lines • Show Last 20 Lines

libcxx/trunk/test/std/containers/sequences/vector.bool/enabled_hash.pass.cpp

Show All 9 Lines
// <vector> // <vector>
// Test that <vector> provides all of the arithmetic, enum, and pointer // Test that <vector> provides all of the arithmetic, enum, and pointer
// hash specializations. // hash specializations.
#include <vector> #include <vector>
#include "poisoned_hash_helper.hpp" #include "poisoned_hash_helper.h"
#include "test_macros.h" #include "test_macros.h"
#include "min_allocator.h" #include "min_allocator.h"
int main(int, char**) { int main(int, char**) {
test_library_hash_specializations_available(); test_library_hash_specializations_available();
{ {
test_hash_enabled_for_type<std::vector<bool> >(); test_hash_enabled_for_type<std::vector<bool> >();
test_hash_enabled_for_type<std::vector<bool, min_allocator<bool>>>(); test_hash_enabled_for_type<std::vector<bool, min_allocator<bool>>>();
} }
return 0; return 0;
} }

libcxx/trunk/test/std/containers/set_allocator_requirement_test_templates.h

Show All 16 Lines
// insert(...); // insert(...);
// emplace(...); // emplace(...);
// emplace_hint(...); // emplace_hint(...);
#include <cassert> #include <cassert>
#include "test_macros.h" #include "test_macros.h"
#include "count_new.hpp" #include "count_new.h"
#include "container_test_types.h" #include "container_test_types.h"
#include "assert_checkpoint.h" #include "assert_checkpoint.h"
template <class Container> template <class Container>
void testSetInsert() void testSetInsert()
{ {
typedef typename Container::value_type ValueTp; typedef typename Container::value_type ValueTp;
▲ Show 20 Lines • Show All 355 Lines • Show Last 20 Lines

libcxx/trunk/test/std/containers/unord/unord.map/unord.map.elem/index.pass.cpp

Show All 16 Lines
#include <unordered_map> #include <unordered_map>
#include <string> #include <string>
#include <cassert> #include <cassert>
#include "test_macros.h" #include "test_macros.h"
#include "MoveOnly.h" #include "MoveOnly.h"
#include "min_allocator.h" #include "min_allocator.h"
#include "count_new.hpp" #include "count_new.h"
#if TEST_STD_VER >= 11 #if TEST_STD_VER >= 11
#include "container_test_types.h" #include "container_test_types.h"
#endif #endif
int main(int, char**) int main(int, char**)
{ {
{ {
▲ Show 20 Lines • Show All 131 Lines • Show Last 20 Lines

libcxx/trunk/test/std/diagnostics/syserr/syserr.hash/enabled_hash.pass.cpp

Show All 9 Lines
// <system_error> // <system_error>
// Test that <system_error> provides all of the arithmetic, enum, and pointer // Test that <system_error> provides all of the arithmetic, enum, and pointer
// hash specializations. // hash specializations.
#include <system_error> #include <system_error>
#include "poisoned_hash_helper.hpp" #include "poisoned_hash_helper.h"
#include "test_macros.h" #include "test_macros.h"
int main(int, char**) { int main(int, char**) {
test_library_hash_specializations_available(); test_library_hash_specializations_available();
{ {
test_hash_enabled_for_type<std::error_code>(); test_hash_enabled_for_type<std::error_code>();
test_hash_enabled_for_type<std::error_condition>(); test_hash_enabled_for_type<std::error_condition>();
} }
return 0; return 0;
} }

libcxx/trunk/test/std/experimental/memory/memory.polymorphic.allocator.class/memory.polymorphic.allocator.ctor/default.pass.cpp

Show All 12 Lines
// template <class T> class polymorphic_allocator // template <class T> class polymorphic_allocator
// polymorphic_allocator<T>::polymorphic_allocator() noexcept // polymorphic_allocator<T>::polymorphic_allocator() noexcept
#include <experimental/memory_resource> #include <experimental/memory_resource>
#include <type_traits> #include <type_traits>
#include <cassert> #include <cassert>
#include "test_memory_resource.hpp" #include "test_memory_resource.h"
#include "test_macros.h" #include "test_macros.h"
namespace ex = std::experimental::pmr; namespace ex = std::experimental::pmr;
int main(int, char**) int main(int, char**)
{ {
{ {
Show All 22 Lines

libcxx/trunk/test/std/experimental/memory/memory.polymorphic.allocator.class/memory.polymorphic.allocator.ctor/memory_resource_convert.pass.cpp

Show All 12 Lines
// template <class T> class polymorphic_allocator // template <class T> class polymorphic_allocator
// polymorphic_allocator<T>::polymorphic_allocator(memory_resource *) // polymorphic_allocator<T>::polymorphic_allocator(memory_resource *)
#include <experimental/memory_resource> #include <experimental/memory_resource>
#include <type_traits> #include <type_traits>
#include <cassert> #include <cassert>
#include "test_memory_resource.hpp" #include "test_memory_resource.h"
#include "test_macros.h" #include "test_macros.h"
namespace ex = std::experimental::pmr; namespace ex = std::experimental::pmr;
int main(int, char**) int main(int, char**)
{ {
{ {
Show All 19 Lines

libcxx/trunk/test/std/experimental/memory/memory.polymorphic.allocator.class/memory.polymorphic.allocator.eq/equal.pass.cpp

Show All 15 Lines
// bool operator==( // bool operator==(
// polymorphic_allocator<T> const & // polymorphic_allocator<T> const &
// , polymorphic_allocator<U> const &) noexcept // , polymorphic_allocator<U> const &) noexcept
#include <experimental/memory_resource> #include <experimental/memory_resource>
#include <type_traits> #include <type_traits>
#include <cassert> #include <cassert>
#include "test_memory_resource.hpp" #include "test_memory_resource.h"
#include "test_macros.h" #include "test_macros.h"
namespace ex = std::experimental::pmr; namespace ex = std::experimental::pmr;
int main(int, char**) int main(int, char**)
{ {
typedef ex::polymorphic_allocator<void> A1; typedef ex::polymorphic_allocator<void> A1;
▲ Show 20 Lines • Show All 104 Lines • Show Last 20 Lines

libcxx/trunk/test/std/experimental/memory/memory.polymorphic.allocator.class/memory.polymorphic.allocator.eq/not_equal.pass.cpp

Show All 15 Lines
// bool operator!=( // bool operator!=(
// polymorphic_allocator<T> const & // polymorphic_allocator<T> const &
// , polymorphic_allocator<T> const &) noexcept // , polymorphic_allocator<T> const &) noexcept
#include <experimental/memory_resource> #include <experimental/memory_resource>
#include <type_traits> #include <type_traits>
#include <cassert> #include <cassert>
#include "test_memory_resource.hpp" #include "test_memory_resource.h"
#include "test_macros.h" #include "test_macros.h"
namespace ex = std::experimental::pmr; namespace ex = std::experimental::pmr;
int main(int, char**) int main(int, char**)
{ {
typedef ex::polymorphic_allocator<void> A1; typedef ex::polymorphic_allocator<void> A1;
▲ Show 20 Lines • Show All 75 Lines • Show Last 20 Lines

libcxx/trunk/test/std/experimental/memory/memory.polymorphic.allocator.class/memory.polymorphic.allocator.mem/allocate.pass.cpp

Show All 16 Lines
#include <experimental/memory_resource> #include <experimental/memory_resource>
#include <limits> #include <limits>
#include <memory> #include <memory>
#include <exception> #include <exception>
#include <type_traits> #include <type_traits>
#include <cassert> #include <cassert>
#include "test_macros.h" #include "test_macros.h"
#include "test_memory_resource.hpp" #include "test_memory_resource.h"
namespace ex = std::experimental::pmr; namespace ex = std::experimental::pmr;
template <size_t S, size_t Align> template <size_t S, size_t Align>
void testForSizeAndAlign() { void testForSizeAndAlign() {
using T = typename std::aligned_storage<S, Align>::type; using T = typename std::aligned_storage<S, Align>::type;
TestResource R; TestResource R;
ex::polymorphic_allocator<T> a(&R); ex::polymorphic_allocator<T> a(&R);
▲ Show 20 Lines • Show All 79 Lines • Show Last 20 Lines

libcxx/trunk/test/std/experimental/memory/memory.polymorphic.allocator.class/memory.polymorphic.allocator.mem/construct_pair.pass.cpp

Show All 15 Lines
// void polymorphic_allocator<T>::construct(pair<U1, U2>*) // void polymorphic_allocator<T>::construct(pair<U1, U2>*)
#include <experimental/memory_resource> #include <experimental/memory_resource>
#include <type_traits> #include <type_traits>
#include <utility> #include <utility>
#include <tuple> #include <tuple>
#include <cassert> #include <cassert>
#include <cstdlib> #include <cstdlib>
#include "uses_alloc_types.hpp" #include "uses_alloc_types.h"
#include "test_macros.h" #include "test_macros.h"
namespace ex = std::experimental::pmr; namespace ex = std::experimental::pmr;
int constructed = 0; int constructed = 0;
struct default_constructible struct default_constructible
Show All 23 Lines

libcxx/trunk/test/std/experimental/memory/memory.polymorphic.allocator.class/memory.polymorphic.allocator.mem/construct_pair_const_lvalue_pair.pass.cpp

Show All 17 Lines
#include <experimental/memory_resource> #include <experimental/memory_resource>
#include <type_traits> #include <type_traits>
#include <utility> #include <utility>
#include <tuple> #include <tuple>
#include <cassert> #include <cassert>
#include <cstdlib> #include <cstdlib>
#include "test_macros.h" #include "test_macros.h"
#include "test_memory_resource.hpp" #include "test_memory_resource.h"
#include "uses_alloc_types.hpp" #include "uses_alloc_types.h"
#include "controlled_allocators.hpp" #include "controlled_allocators.h"
#include "test_allocator.h" #include "test_allocator.h"
namespace ex = std::experimental::pmr; namespace ex = std::experimental::pmr;
template <class UA1, class UA2, class TT, class UU> template <class UA1, class UA2, class TT, class UU>
bool doTest(UsesAllocatorType TExpect, UsesAllocatorType UExpect, bool doTest(UsesAllocatorType TExpect, UsesAllocatorType UExpect,
std::pair<TT, UU> const& p) std::pair<TT, UU> const& p)
▲ Show 20 Lines • Show All 107 Lines • Show Last 20 Lines

libcxx/trunk/test/std/experimental/memory/memory.polymorphic.allocator.class/memory.polymorphic.allocator.mem/construct_pair_rvalue.pass.cpp

Show All 17 Lines
#include <experimental/memory_resource> #include <experimental/memory_resource>
#include <type_traits> #include <type_traits>
#include <utility> #include <utility>
#include <tuple> #include <tuple>
#include <cassert> #include <cassert>
#include <cstdlib> #include <cstdlib>
#include "test_macros.h" #include "test_macros.h"
#include "test_memory_resource.hpp" #include "test_memory_resource.h"
#include "uses_alloc_types.hpp" #include "uses_alloc_types.h"
#include "controlled_allocators.hpp" #include "controlled_allocators.h"
#include "test_allocator.h" #include "test_allocator.h"
namespace ex = std::experimental::pmr; namespace ex = std::experimental::pmr;
template <class UA1, class UA2, class TT, class UU> template <class UA1, class UA2, class TT, class UU>
bool doTest(UsesAllocatorType TExpect, UsesAllocatorType UExpect, bool doTest(UsesAllocatorType TExpect, UsesAllocatorType UExpect,
▲ Show 20 Lines • Show All 103 Lines • Show Last 20 Lines

libcxx/trunk/test/std/experimental/memory/memory.polymorphic.allocator.class/memory.polymorphic.allocator.mem/construct_pair_values.pass.cpp

Show All 17 Lines
#include <experimental/memory_resource> #include <experimental/memory_resource>
#include <type_traits> #include <type_traits>
#include <utility> #include <utility>
#include <tuple> #include <tuple>
#include <cassert> #include <cassert>
#include <cstdlib> #include <cstdlib>
#include "test_macros.h" #include "test_macros.h"
#include "test_memory_resource.hpp" #include "test_memory_resource.h"
#include "uses_alloc_types.hpp" #include "uses_alloc_types.h"
#include "controlled_allocators.hpp" #include "controlled_allocators.h"
#include "test_allocator.h" #include "test_allocator.h"
namespace ex = std::experimental::pmr; namespace ex = std::experimental::pmr;
template <class UA1, class UA2, class TT, class UU> template <class UA1, class UA2, class TT, class UU>
bool doTest(UsesAllocatorType TExpect, UsesAllocatorType UExpect, bool doTest(UsesAllocatorType TExpect, UsesAllocatorType UExpect,
TT&& t, UU&& u) TT&& t, UU&& u)
▲ Show 20 Lines • Show All 108 Lines • Show Last 20 Lines

libcxx/trunk/test/std/experimental/memory/memory.polymorphic.allocator.class/memory.polymorphic.allocator.mem/construct_piecewise_pair.pass.cpp

Show All 18 Lines
#include <experimental/memory_resource> #include <experimental/memory_resource>
#include <type_traits> #include <type_traits>
#include <utility> #include <utility>
#include <tuple> #include <tuple>
#include <cassert> #include <cassert>
#include <cstdlib> #include <cstdlib>
#include "test_macros.h" #include "test_macros.h"
#include "test_memory_resource.hpp" #include "test_memory_resource.h"
#include "uses_alloc_types.hpp" #include "uses_alloc_types.h"
#include "controlled_allocators.hpp" #include "controlled_allocators.h"
#include "test_allocator.h" #include "test_allocator.h"
namespace ex = std::experimental::pmr; namespace ex = std::experimental::pmr;
template <class T, class U, class ...TTuple, class ...UTuple> template <class T, class U, class ...TTuple, class ...UTuple>
bool doTest(UsesAllocatorType TExpect, UsesAllocatorType UExpect, bool doTest(UsesAllocatorType TExpect, UsesAllocatorType UExpect,
std::tuple<TTuple...> ttuple, std::tuple<UTuple...> utuple) std::tuple<TTuple...> ttuple, std::tuple<UTuple...> utuple)
{ {
▲ Show 20 Lines • Show All 126 Lines • Show Last 20 Lines

libcxx/trunk/test/std/experimental/memory/memory.polymorphic.allocator.class/memory.polymorphic.allocator.mem/construct_types.pass.cpp

Show All 15 Lines
// void polymorphic_allocator<T>::construct(U *, Args &&...) // void polymorphic_allocator<T>::construct(U *, Args &&...)
#include <experimental/memory_resource> #include <experimental/memory_resource>
#include <type_traits> #include <type_traits>
#include <cassert> #include <cassert>
#include <cstdlib> #include <cstdlib>
#include "test_macros.h" #include "test_macros.h"
#include "test_memory_resource.hpp" #include "test_memory_resource.h"
#include "uses_alloc_types.hpp" #include "uses_alloc_types.h"
#include "controlled_allocators.hpp" #include "controlled_allocators.h"
#include "test_allocator.h" #include "test_allocator.h"
namespace ex = std::experimental::pmr; namespace ex = std::experimental::pmr;
template <class T> template <class T>
struct PMATest { struct PMATest {
TestResource R; TestResource R;
ex::polymorphic_allocator<T> A; ex::polymorphic_allocator<T> A;
▲ Show 20 Lines • Show All 193 Lines • Show Last 20 Lines

libcxx/trunk/test/std/experimental/memory/memory.polymorphic.allocator.class/memory.polymorphic.allocator.mem/deallocate.pass.cpp

Show All 12 Lines
// template <class T> class polymorphic_allocator // template <class T> class polymorphic_allocator
// T* polymorphic_allocator<T>::deallocate(T*, size_t size) // T* polymorphic_allocator<T>::deallocate(T*, size_t size)
#include <experimental/memory_resource> #include <experimental/memory_resource>
#include <type_traits> #include <type_traits>
#include <cassert> #include <cassert>
#include "test_memory_resource.hpp" #include "test_memory_resource.h"
#include "test_macros.h" #include "test_macros.h"
namespace ex = std::experimental::pmr; namespace ex = std::experimental::pmr;
template <size_t S, size_t Align> template <size_t S, size_t Align>
void testForSizeAndAlign() { void testForSizeAndAlign() {
using T = typename std::aligned_storage<S, Align>::type; using T = typename std::aligned_storage<S, Align>::type;
Show All 35 Lines

libcxx/trunk/test/std/experimental/memory/memory.resource.adaptor/memory.resource.adaptor.ctor/alloc_copy.pass.cpp

Show All 11 Lines
// template <class Alloc> class resource_adaptor_imp; // template <class Alloc> class resource_adaptor_imp;
// resource_adaptor_imp<Alloc>::resource_adaptor_imp(Alloc const &) // resource_adaptor_imp<Alloc>::resource_adaptor_imp(Alloc const &)
#include <experimental/memory_resource> #include <experimental/memory_resource>
#include <cassert> #include <cassert>
#include "test_memory_resource.hpp" #include "test_memory_resource.h"
#include "test_macros.h" #include "test_macros.h"
namespace ex = std::experimental::pmr; namespace ex = std::experimental::pmr;
int main(int, char**) int main(int, char**)
{ {
typedef CountingAllocator<char> AllocT; typedef CountingAllocator<char> AllocT;
Show All 28 Lines

libcxx/trunk/test/std/experimental/memory/memory.resource.adaptor/memory.resource.adaptor.ctor/alloc_move.pass.cpp

Show All 11 Lines
// template <class Alloc> class resource_adaptor_imp; // template <class Alloc> class resource_adaptor_imp;
// resource_adaptor_imp<Alloc>::resource_adaptor_imp(Alloc &&) // resource_adaptor_imp<Alloc>::resource_adaptor_imp(Alloc &&)
#include <experimental/memory_resource> #include <experimental/memory_resource>
#include <cassert> #include <cassert>
#include "test_memory_resource.hpp" #include "test_memory_resource.h"
#include "test_macros.h" #include "test_macros.h"
namespace ex = std::experimental::pmr; namespace ex = std::experimental::pmr;
int main(int, char**) int main(int, char**)
{ {
typedef CountingAllocator<char> AllocT; typedef CountingAllocator<char> AllocT;
Show All 19 Lines

libcxx/trunk/test/std/experimental/memory/memory.resource.adaptor/memory.resource.adaptor.ctor/default.pass.cpp

Show All 13 Lines
// resource_adaptor_imp<Alloc>::resource_adaptor_imp() = default; // resource_adaptor_imp<Alloc>::resource_adaptor_imp() = default;
#include <experimental/memory_resource> #include <experimental/memory_resource>
#include <memory> #include <memory>
#include <type_traits> #include <type_traits>
#include <cassert> #include <cassert>
#include "test_memory_resource.hpp" #include "test_memory_resource.h"
#include "test_macros.h" #include "test_macros.h"
namespace ex = std::experimental::pmr; namespace ex = std::experimental::pmr;
int main(int, char**) int main(int, char**)
{ {
{ {
Show All 13 Lines

libcxx/trunk/test/std/experimental/memory/memory.resource.adaptor/memory.resource.adaptor.mem/do_allocate_and_deallocate.pass.cpp

Show All 21 Lines
#include <experimental/memory_resource> #include <experimental/memory_resource>
#include <type_traits> #include <type_traits>
#include <memory> #include <memory>
#include <exception> #include <exception>
#include <cassert> #include <cassert>
#include "test_macros.h" #include "test_macros.h"
#include "test_memory_resource.hpp" #include "test_memory_resource.h"
namespace ex = std::experimental::pmr; namespace ex = std::experimental::pmr;
template <class Alloc> template <class Alloc>
void check_allocate_deallocate() void check_allocate_deallocate()
{ {
typedef ex::resource_adaptor<Alloc> R1; typedef ex::resource_adaptor<Alloc> R1;
const std::size_t max_align = alignof(std::max_align_t); const std::size_t max_align = alignof(std::max_align_t);
▲ Show 20 Lines • Show All 82 Lines • Show Last 20 Lines

libcxx/trunk/test/std/experimental/memory/memory.resource.adaptor/memory.resource.adaptor.mem/do_is_equal.pass.cpp

Show All 12 Lines
// template <class Alloc> class resource_adaptor_imp; // template <class Alloc> class resource_adaptor_imp;
// bool do_is_equal(memory_resource const &) const noexcept; // bool do_is_equal(memory_resource const &) const noexcept;
#include <experimental/memory_resource> #include <experimental/memory_resource>
#include <type_traits> #include <type_traits>
#include <memory> #include <memory>
#include <cassert> #include <cassert>
#include "test_memory_resource.hpp" #include "test_memory_resource.h"
#include "test_macros.h" #include "test_macros.h"
using std::size_t; using std::size_t;
namespace ex = std::experimental::pmr; namespace ex = std::experimental::pmr;
int main(int, char**) int main(int, char**)
{ {
▲ Show 20 Lines • Show All 57 Lines • Show Last 20 Lines

libcxx/trunk/test/std/experimental/memory/memory.resource.aliases/header_string_synop.pass.cpp

Show All 22 Lines
// //
// }}} // namespace std::experimental::pmr // }}} // namespace std::experimental::pmr
#include <experimental/string> #include <experimental/string>
#include <experimental/memory_resource> #include <experimental/memory_resource>
#include <type_traits> #include <type_traits>
#include <cassert> #include <cassert>
#include "constexpr_char_traits.hpp" #include "constexpr_char_traits.h"
#include "test_macros.h" #include "test_macros.h"
namespace pmr = std::experimental::pmr; namespace pmr = std::experimental::pmr;
template <class Char, class PmrTypedef> template <class Char, class PmrTypedef>
void test_string_typedef() { void test_string_typedef() {
using StdStr = std::basic_string<Char, std::char_traits<Char>, using StdStr = std::basic_string<Char, std::char_traits<Char>,
Show All 36 Lines

libcxx/trunk/test/std/experimental/memory/memory.resource.global/default_resource.pass.cpp

Show All 25 Lines
// E) 'set_default_resource(null)' sets the default resource to // E) 'set_default_resource(null)' sets the default resource to
// 'new_delete_resource()'. // 'new_delete_resource()'.
// F) 'get_default_resource' and 'set_default_resource' are noexcept. // F) 'get_default_resource' and 'set_default_resource' are noexcept.
#include <experimental/memory_resource> #include <experimental/memory_resource>
#include <cassert> #include <cassert>
#include "test_memory_resource.hpp" #include "test_memory_resource.h"
#include "test_macros.h" #include "test_macros.h"
using namespace std::experimental::pmr; using namespace std::experimental::pmr;
int main(int, char**) { int main(int, char**) {
TestResource R; TestResource R;
{ // Test (A) and (B) { // Test (A) and (B)
Show All 34 Lines

libcxx/trunk/test/std/experimental/memory/memory.resource.global/new_delete_resource.pass.cpp

Show All 10 Lines
// <experimental/memory_resource> // <experimental/memory_resource>
// memory_resource * new_delete_resource() // memory_resource * new_delete_resource()
#include <experimental/memory_resource> #include <experimental/memory_resource>
#include <type_traits> #include <type_traits>
#include <cassert> #include <cassert>
#include "count_new.hpp" #include "count_new.h"
#include "test_macros.h" #include "test_macros.h"
namespace ex = std::experimental::pmr; namespace ex = std::experimental::pmr;
struct assert_on_compare : public ex::memory_resource struct assert_on_compare : public ex::memory_resource
{ {
protected: protected:
▲ Show 20 Lines • Show All 77 Lines • Show Last 20 Lines

libcxx/trunk/test/std/experimental/memory/memory.resource.global/null_memory_resource.pass.cpp

Show All 12 Lines
// memory_resource * null_memory_resource() // memory_resource * null_memory_resource()
#include <experimental/memory_resource> #include <experimental/memory_resource>
#include <new> #include <new>
#include <type_traits> #include <type_traits>
#include <cassert> #include <cassert>
#include "test_macros.h" #include "test_macros.h"
#include "count_new.hpp" #include "count_new.h"
namespace ex = std::experimental::pmr; namespace ex = std::experimental::pmr;
struct assert_on_compare : public ex::memory_resource struct assert_on_compare : public ex::memory_resource
{ {
protected: protected:
virtual void * do_allocate(size_t, size_t) virtual void * do_allocate(size_t, size_t)
{ assert(false); } { assert(false); }
▲ Show 20 Lines • Show All 89 Lines • Show Last 20 Lines

libcxx/trunk/test/std/experimental/memory/memory.resource/memory.resource.eq/equal.pass.cpp

Show All 11 Lines
// bool operator==(memory_resource const &, memory_resource const &) noexcept; // bool operator==(memory_resource const &, memory_resource const &) noexcept;
#include <experimental/memory_resource> #include <experimental/memory_resource>
#include <type_traits> #include <type_traits>
#include <cassert> #include <cassert>
#include "test_macros.h" #include "test_macros.h"
#include "test_memory_resource.hpp" #include "test_memory_resource.h"
namespace ex = std::experimental::pmr; namespace ex = std::experimental::pmr;
int main(int, char**) int main(int, char**)
{ {
// check return types // check return types
{ {
ex::memory_resource const * mr1(nullptr); ex::memory_resource const * mr1(nullptr);
▲ Show 20 Lines • Show All 49 Lines • Show Last 20 Lines

libcxx/trunk/test/std/experimental/memory/memory.resource/memory.resource.eq/not_equal.pass.cpp

Show All 10 Lines
// <experimental/memory_resource> // <experimental/memory_resource>
// bool operator!=(memory_resource const &, memory_resource const &) noexcept; // bool operator!=(memory_resource const &, memory_resource const &) noexcept;
#include <experimental/memory_resource> #include <experimental/memory_resource>
#include <type_traits> #include <type_traits>
#include <cassert> #include <cassert>
#include "test_memory_resource.hpp" #include "test_memory_resource.h"
#include "test_macros.h" #include "test_macros.h"
namespace ex = std::experimental::pmr; namespace ex = std::experimental::pmr;
int main(int, char**) int main(int, char**)
{ {
// check return types // check return types
▲ Show 20 Lines • Show All 51 Lines • Show Last 20 Lines

libcxx/trunk/test/std/experimental/memory/memory.resource/memory.resource.public/allocate.pass.cpp

Show All 21 Lines
// E) If 'do_allocate' throws then 'allocate' propagates that exception. // E) If 'do_allocate' throws then 'allocate' propagates that exception.
#include <experimental/memory_resource> #include <experimental/memory_resource>
#include <type_traits> #include <type_traits>
#include <cstddef> #include <cstddef>
#include <cassert> #include <cassert>
#include "test_macros.h" #include "test_macros.h"
#include "test_memory_resource.hpp" #include "test_memory_resource.h"
using std::experimental::pmr::memory_resource; using std::experimental::pmr::memory_resource;
int main(int, char**) int main(int, char**)
{ {
TestResource R(42); TestResource R(42);
auto& P = R.getController(); auto& P = R.getController();
memory_resource& M = R; memory_resource& M = R;
▲ Show 20 Lines • Show All 52 Lines • Show Last 20 Lines

libcxx/trunk/test/std/experimental/memory/memory.resource/memory.resource.public/deallocate.pass.cpp

Show All 20 Lines
// D) Invoking 'deallocate' invokes 'do_deallocate' with the same arguments. // D) Invoking 'deallocate' invokes 'do_deallocate' with the same arguments.
#include <experimental/memory_resource> #include <experimental/memory_resource>
#include <type_traits> #include <type_traits>
#include <cstddef> #include <cstddef>
#include <cassert> #include <cassert>
#include "test_memory_resource.hpp" #include "test_memory_resource.h"
#include "test_macros.h" #include "test_macros.h"
using std::experimental::pmr::memory_resource; using std::experimental::pmr::memory_resource;
int main(int, char**) int main(int, char**)
{ {
NullResource R(42); NullResource R(42);
Show All 40 Lines

libcxx/trunk/test/std/experimental/memory/memory.resource/memory.resource.public/dtor.pass.cpp

Show All 16 Lines
// A) 'memory_resource' is destructible. // A) 'memory_resource' is destructible.
// B) The destructor is implicitly marked noexcept. // B) The destructor is implicitly marked noexcept.
// C) The destructor is marked virtual. // C) The destructor is marked virtual.
#include <experimental/memory_resource> #include <experimental/memory_resource>
#include <type_traits> #include <type_traits>
#include <cassert> #include <cassert>
#include "test_memory_resource.hpp" #include "test_memory_resource.h"
#include "test_macros.h" #include "test_macros.h"
using std::experimental::pmr::memory_resource; using std::experimental::pmr::memory_resource;
int main(int, char**) int main(int, char**)
{ {
static_assert( static_assert(
Show All 29 Lines

libcxx/trunk/test/std/experimental/memory/memory.resource/memory.resource.public/is_equal.pass.cpp

Show All 18 Lines
// B) 'is_equal' is noexcept. // B) 'is_equal' is noexcept.
// C) 'do_is_equal' is called using the same arguments passed to 'is_equal' // C) 'do_is_equal' is called using the same arguments passed to 'is_equal'
// and the resulting value is returned. // and the resulting value is returned.
// D) 'do_is_equal' is called on the LHS object and not the RHS object. // D) 'do_is_equal' is called on the LHS object and not the RHS object.
#include <experimental/memory_resource> #include <experimental/memory_resource>
#include <type_traits> #include <type_traits>
#include <cassert> #include <cassert>
#include "test_memory_resource.hpp" #include "test_memory_resource.h"
#include "test_macros.h" #include "test_macros.h"
using std::experimental::pmr::memory_resource; using std::experimental::pmr::memory_resource;
int main(int, char**) int main(int, char**)
{ {
{ {
▲ Show 20 Lines • Show All 61 Lines • Show Last 20 Lines

libcxx/trunk/test/std/input.output/filesystems/class.directory_entry/directory_entry.cons/copy.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++98, c++03 // UNSUPPORTED: c++98, c++03
// <filesystem> // <filesystem>
// class directory_entry // class directory_entry
// directory_entry(const directory_entry&) = default; // directory_entry(const directory_entry&) = default;
#include "filesystem_include.hpp" #include "filesystem_include.h"
#include <type_traits> #include <type_traits>
#include <cassert> #include <cassert>
#include "test_macros.h" #include "test_macros.h"
#include "rapid-cxx-test.hpp" #include "rapid-cxx-test.h"
#include "filesystem_test_helper.hpp" #include "filesystem_test_helper.h"
#include "test_convertible.hpp" #include "test_convertible.h"
TEST_SUITE(directory_entry_path_ctor_suite) TEST_SUITE(directory_entry_path_ctor_suite)
TEST_CASE(copy_ctor) { TEST_CASE(copy_ctor) {
using namespace fs; using namespace fs;
// Copy // Copy
{ {
static_assert(std::is_copy_constructible<directory_entry>::value, static_assert(std::is_copy_constructible<directory_entry>::value,
▲ Show 20 Lines • Show All 41 Lines • Show Last 20 Lines

libcxx/trunk/test/std/input.output/filesystems/class.directory_entry/directory_entry.cons/copy_assign.pass.cpp

Show All 11 Lines
// class directory_entry // class directory_entry
// directory_entry& operator=(directory_entry const&) = default; // directory_entry& operator=(directory_entry const&) = default;
// directory_entry& operator=(directory_entry&&) noexcept = default; // directory_entry& operator=(directory_entry&&) noexcept = default;
// void assign(path const&); // void assign(path const&);
// void replace_filename(path const&); // void replace_filename(path const&);
#include "filesystem_include.hpp" #include "filesystem_include.h"
#include <type_traits> #include <type_traits>
#include <cassert> #include <cassert>
#include "test_macros.h" #include "test_macros.h"
#include "rapid-cxx-test.hpp" #include "rapid-cxx-test.h"
#include "filesystem_test_helper.hpp" #include "filesystem_test_helper.h"
TEST_SUITE(directory_entry_ctor_suite) TEST_SUITE(directory_entry_ctor_suite)
TEST_CASE(test_copy_assign_operator) { TEST_CASE(test_copy_assign_operator) {
using namespace fs; using namespace fs;
// Copy // Copy
{ {
static_assert(std::is_copy_assignable<directory_entry>::value, static_assert(std::is_copy_assignable<directory_entry>::value,
▲ Show 20 Lines • Show All 47 Lines • Show Last 20 Lines

libcxx/trunk/test/std/input.output/filesystems/class.directory_entry/directory_entry.cons/default.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++98, c++03 // UNSUPPORTED: c++98, c++03
// <filesystem> // <filesystem>
// class directory_entry // class directory_entry
// directory_entry() noexcept = default; // directory_entry() noexcept = default;
#include "filesystem_include.hpp" #include "filesystem_include.h"
#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**) {
using namespace fs; using namespace fs;
// Default // Default
Show All 9 Lines

libcxx/trunk/test/std/input.output/filesystems/class.directory_entry/directory_entry.cons/default_const.pass.cpp

Show All 9 Lines
// XFAIL: apple-clang-7, clang-3.7, clang-3.8 // XFAIL: apple-clang-7, clang-3.7, clang-3.8
// <filesystem> // <filesystem>
// class directory_entry // class directory_entry
// directory_entry() noexcept = default; // directory_entry() noexcept = default;
#include "filesystem_include.hpp" #include "filesystem_include.h"
#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**) {
using namespace fs; using namespace fs;
// Default // Default
Show All 9 Lines

libcxx/trunk/test/std/input.output/filesystems/class.directory_entry/directory_entry.cons/move.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++98, c++03 // UNSUPPORTED: c++98, c++03
// <filesystem> // <filesystem>
// class directory_entry // class directory_entry
// directory_entry(directory_entry&&) noexcept = default; // directory_entry(directory_entry&&) noexcept = default;
#include "filesystem_include.hpp" #include "filesystem_include.h"
#include <type_traits> #include <type_traits>
#include <cassert> #include <cassert>
#include "test_macros.h" #include "test_macros.h"
#include "rapid-cxx-test.hpp" #include "rapid-cxx-test.h"
#include "filesystem_test_helper.hpp" #include "filesystem_test_helper.h"
#include "test_convertible.hpp" #include "test_convertible.h"
TEST_SUITE(directory_entry_path_ctor_suite) TEST_SUITE(directory_entry_path_ctor_suite)
TEST_CASE(move_ctor) { TEST_CASE(move_ctor) {
using namespace fs; using namespace fs;
// Move // Move
{ {
static_assert(std::is_nothrow_move_constructible<directory_entry>::value, static_assert(std::is_nothrow_move_constructible<directory_entry>::value,
Show All 39 Lines

libcxx/trunk/test/std/input.output/filesystems/class.directory_entry/directory_entry.cons/move_assign.pass.cpp

Show All 11 Lines
// class directory_entry // class directory_entry
// directory_entry& operator=(directory_entry const&) = default; // directory_entry& operator=(directory_entry const&) = default;
// directory_entry& operator=(directory_entry&&) noexcept = default; // directory_entry& operator=(directory_entry&&) noexcept = default;
// void assign(path const&); // void assign(path const&);
// void replace_filename(path const&); // void replace_filename(path const&);
#include "filesystem_include.hpp" #include "filesystem_include.h"
#include <type_traits> #include <type_traits>
#include <cassert> #include <cassert>
#include "test_macros.h" #include "test_macros.h"
#include "rapid-cxx-test.hpp" #include "rapid-cxx-test.h"
#include "filesystem_test_helper.hpp" #include "filesystem_test_helper.h"
TEST_SUITE(directory_entry_ctor_suite) TEST_SUITE(directory_entry_ctor_suite)
TEST_CASE(test_move_assign_operator) { TEST_CASE(test_move_assign_operator) {
using namespace fs; using namespace fs;
// Copy // Copy
{ {
static_assert(std::is_nothrow_move_assignable<directory_entry>::value, static_assert(std::is_nothrow_move_assignable<directory_entry>::value,
▲ Show 20 Lines • Show All 43 Lines • Show Last 20 Lines

libcxx/trunk/test/std/input.output/filesystems/class.directory_entry/directory_entry.cons/path.pass.cpp

Show All 9 Lines
// <filesystem> // <filesystem>
// class directory_entry // class directory_entry
// explicit directory_entry(const path); // explicit directory_entry(const path);
// directory_entry(const path&, error_code& ec); // directory_entry(const path&, error_code& ec);
#include "filesystem_include.hpp" #include "filesystem_include.h"
#include <type_traits> #include <type_traits>
#include <cassert> #include <cassert>
#include "test_macros.h" #include "test_macros.h"
#include "rapid-cxx-test.hpp" #include "rapid-cxx-test.h"
#include "filesystem_test_helper.hpp" #include "filesystem_test_helper.h"
#include "test_convertible.hpp" #include "test_convertible.h"
TEST_SUITE(directory_entry_path_ctor_suite) TEST_SUITE(directory_entry_path_ctor_suite)
TEST_CASE(path_ctor) { TEST_CASE(path_ctor) {
using namespace fs; using namespace fs;
{ {
static_assert(std::is_constructible<directory_entry, const path&>::value, static_assert(std::is_constructible<directory_entry, const path&>::value,
"directory_entry must be constructible from path"); "directory_entry must be constructible from path");
▲ Show 20 Lines • Show All 148 Lines • Show Last 20 Lines

libcxx/trunk/test/std/input.output/filesystems/class.directory_entry/directory_entry.mods/assign.pass.cpp

Show All 11 Lines
// class directory_entry // class directory_entry
// directory_entry& operator=(directory_entry const&) = default; // directory_entry& operator=(directory_entry const&) = default;
// directory_entry& operator=(directory_entry&&) noexcept = default; // directory_entry& operator=(directory_entry&&) noexcept = default;
// void assign(path const&); // void assign(path const&);
// void replace_filename(path const&); // void replace_filename(path const&);
#include "filesystem_include.hpp" #include "filesystem_include.h"
#include <type_traits> #include <type_traits>
#include <cassert> #include <cassert>
#include "test_macros.h" #include "test_macros.h"
#include "rapid-cxx-test.hpp" #include "rapid-cxx-test.h"
#include "filesystem_test_helper.hpp" #include "filesystem_test_helper.h"
TEST_SUITE(directory_entry_mods_suite) TEST_SUITE(directory_entry_mods_suite)
TEST_CASE(test_path_assign_method) { TEST_CASE(test_path_assign_method) {
using namespace fs; using namespace fs;
const path p("foo/bar/baz"); const path p("foo/bar/baz");
const path p2("abc"); const path p2("abc");
directory_entry e(p); directory_entry e(p);
▲ Show 20 Lines • Show All 97 Lines • Show Last 20 Lines

libcxx/trunk/test/std/input.output/filesystems/class.directory_entry/directory_entry.mods/refresh.pass.cpp

Show All 11 Lines
// class directory_entry // class directory_entry
// directory_entry& operator=(directory_entry const&) = default; // directory_entry& operator=(directory_entry const&) = default;
// directory_entry& operator=(directory_entry&&) noexcept = default; // directory_entry& operator=(directory_entry&&) noexcept = default;
// void assign(path const&); // void assign(path const&);
// void replace_filename(path const&); // void replace_filename(path const&);
#include "filesystem_include.hpp" #include "filesystem_include.h"
#include <type_traits> #include <type_traits>
#include <cassert> #include <cassert>
#include "test_macros.h" #include "test_macros.h"
#include "rapid-cxx-test.hpp" #include "rapid-cxx-test.h"
#include "filesystem_test_helper.hpp" #include "filesystem_test_helper.h"
TEST_SUITE(directory_entry_mods_suite) TEST_SUITE(directory_entry_mods_suite)
TEST_CASE(test_refresh_method) { TEST_CASE(test_refresh_method) {
using namespace fs; using namespace fs;
{ {
directory_entry e; directory_entry e;
static_assert(noexcept(e.refresh()) == false, static_assert(noexcept(e.refresh()) == false,
▲ Show 20 Lines • Show All 306 Lines • Show Last 20 Lines

libcxx/trunk/test/std/input.output/filesystems/class.directory_entry/directory_entry.mods/replace_filename.pass.cpp

Show All 11 Lines
// class directory_entry // class directory_entry
// directory_entry& operator=(directory_entry const&) = default; // directory_entry& operator=(directory_entry const&) = default;
// directory_entry& operator=(directory_entry&&) noexcept = default; // directory_entry& operator=(directory_entry&&) noexcept = default;
// void assign(path const&); // void assign(path const&);
// void replace_filename(path const&); // void replace_filename(path const&);
#include "filesystem_include.hpp" #include "filesystem_include.h"
#include <type_traits> #include <type_traits>
#include <cassert> #include <cassert>
#include "test_macros.h" #include "test_macros.h"
#include "rapid-cxx-test.hpp" #include "rapid-cxx-test.h"
#include "filesystem_test_helper.hpp" #include "filesystem_test_helper.h"
TEST_SUITE(directory_entry_mods_suite) TEST_SUITE(directory_entry_mods_suite)
TEST_CASE(test_replace_filename_method) { TEST_CASE(test_replace_filename_method) {
using namespace fs; using namespace fs;
{ {
directory_entry e; directory_entry e;
▲ Show 20 Lines • Show All 134 Lines • Show Last 20 Lines

libcxx/trunk/test/std/input.output/filesystems/class.directory_entry/directory_entry.obs/comparisons.pass.cpp

Show All 14 Lines
// bool operator==(directory_entry const&) const noexcept; // bool operator==(directory_entry const&) const noexcept;
// bool operator!=(directory_entry const&) const noexcept; // bool operator!=(directory_entry const&) const noexcept;
// bool operator< (directory_entry const&) const noexcept; // bool operator< (directory_entry const&) const noexcept;
// bool operator<=(directory_entry const&) const noexcept; // bool operator<=(directory_entry const&) const noexcept;
// bool operator> (directory_entry const&) const noexcept; // bool operator> (directory_entry const&) const noexcept;
// bool operator>=(directory_entry const&) const noexcept; // bool operator>=(directory_entry const&) const noexcept;
#include "filesystem_include.hpp" #include "filesystem_include.h"
#include <type_traits> #include <type_traits>
#include <cassert> #include <cassert>
#include "test_macros.h" #include "test_macros.h"
#define CHECK_OP(Op) \ #define CHECK_OP(Op) \
static_assert(std::is_same<decltype(ce. operator Op (ce)), bool>::value, ""); \ static_assert(std::is_same<decltype(ce. operator Op (ce)), bool>::value, ""); \
▲ Show 20 Lines • Show All 53 Lines • Show Last 20 Lines

libcxx/trunk/test/std/input.output/filesystems/class.directory_entry/directory_entry.obs/file_size.pass.cpp

Show All 9 Lines
// <filesystem> // <filesystem>
// class directory_entry // class directory_entry
// uintmax_t file_size() const; // uintmax_t file_size() const;
// uintmax_t file_size(error_code const&) const noexcept; // uintmax_t file_size(error_code const&) const noexcept;
#include "filesystem_include.hpp" #include "filesystem_include.h"
#include <type_traits> #include <type_traits>
#include <cassert> #include <cassert>
#include "filesystem_test_helper.hpp" #include "filesystem_test_helper.h"
#include "rapid-cxx-test.hpp" #include "rapid-cxx-test.h"
#include <iostream> #include <iostream>
#include "test_macros.h" #include "test_macros.h"
TEST_SUITE(directory_entry_obs_testsuite) TEST_SUITE(directory_entry_obs_testsuite)
TEST_CASE(signatures) { TEST_CASE(signatures) {
▲ Show 20 Lines • Show All 212 Lines • Show Last 20 Lines

libcxx/trunk/test/std/input.output/filesystems/class.directory_entry/directory_entry.obs/file_type_obs.pass.cpp

Show All 9 Lines
// <filesystem> // <filesystem>
// class directory_entry // class directory_entry
// file_status status() const; // file_status status() const;
// file_status status(error_code const&) const noexcept; // file_status status(error_code const&) const noexcept;
#include "filesystem_include.hpp" #include "filesystem_include.h"
#include <type_traits> #include <type_traits>
#include <cassert> #include <cassert>
#include "filesystem_test_helper.hpp" #include "filesystem_test_helper.h"
#include "rapid-cxx-test.hpp" #include "rapid-cxx-test.h"
#include "test_macros.h" #include "test_macros.h"
TEST_SUITE(directory_entry_obs_testsuite) TEST_SUITE(directory_entry_obs_testsuite)
TEST_CASE(file_dne) { TEST_CASE(file_dne) {
using namespace fs; using namespace fs;
directory_entry p("dne"); directory_entry p("dne");
▲ Show 20 Lines • Show All 228 Lines • Show Last 20 Lines

libcxx/trunk/test/std/input.output/filesystems/class.directory_entry/directory_entry.obs/hard_link_count.pass.cpp

Show All 9 Lines
// <filesystem> // <filesystem>
// class directory_entry // class directory_entry
// uintmax_t hard_link_count() const; // uintmax_t hard_link_count() const;
// uintmax_t hard_link_count(error_code const&) const noexcept; // uintmax_t hard_link_count(error_code const&) const noexcept;
#include "filesystem_include.hpp" #include "filesystem_include.h"
#include <type_traits> #include <type_traits>
#include <cassert> #include <cassert>
#include "filesystem_test_helper.hpp" #include "filesystem_test_helper.h"
#include "rapid-cxx-test.hpp" #include "rapid-cxx-test.h"
#include "test_macros.h" #include "test_macros.h"
TEST_SUITE(directory_entry_obs_testsuite) TEST_SUITE(directory_entry_obs_testsuite)
TEST_CASE(signatures) { TEST_CASE(signatures) {
using namespace fs; using namespace fs;
{ {
▲ Show 20 Lines • Show All 212 Lines • Show Last 20 Lines

libcxx/trunk/test/std/input.output/filesystems/class.directory_entry/directory_entry.obs/last_write_time.pass.cpp

Show All 9 Lines
// <filesystem> // <filesystem>
// class directory_entry // class directory_entry
// file_time_type last_write_time() const; // file_time_type last_write_time() const;
// file_time_type last_write_time(error_code const&) const noexcept; // file_time_type last_write_time(error_code const&) const noexcept;
#include "filesystem_include.hpp" #include "filesystem_include.h"
#include <type_traits> #include <type_traits>
#include <cassert> #include <cassert>
#include "filesystem_test_helper.hpp" #include "filesystem_test_helper.h"
#include "rapid-cxx-test.hpp" #include "rapid-cxx-test.h"
#include "test_macros.h" #include "test_macros.h"
TEST_SUITE(directory_entry_obs_testsuite) TEST_SUITE(directory_entry_obs_testsuite)
TEST_CASE(signatures) { TEST_CASE(signatures) {
using namespace fs; using namespace fs;
{ {
▲ Show 20 Lines • Show All 185 Lines • Show Last 20 Lines

libcxx/trunk/test/std/input.output/filesystems/class.directory_entry/directory_entry.obs/path.pass.cpp

Show All 9 Lines
// <filesystem> // <filesystem>
// class directory_entry // class directory_entry
// const path& path() const noexcept; // const path& path() const noexcept;
// operator const path&() const noexcept; // operator const path&() const noexcept;
#include "filesystem_include.hpp" #include "filesystem_include.h"
#include <type_traits> #include <type_traits>
#include <cassert> #include <cassert>
#include "test_macros.h" #include "test_macros.h"
void test_path_method() { void test_path_method() {
using namespace fs; using namespace fs;
▲ Show 20 Lines • Show All 65 Lines • Show Last 20 Lines

libcxx/trunk/test/std/input.output/filesystems/class.directory_entry/directory_entry.obs/status.pass.cpp

Show All 9 Lines
// <filesystem> // <filesystem>
// class directory_entry // class directory_entry
// file_status status() const; // file_status status() const;
// file_status status(error_code const&) const noexcept; // file_status status(error_code const&) const noexcept;
#include "filesystem_include.hpp" #include "filesystem_include.h"
#include <type_traits> #include <type_traits>
#include <cassert> #include <cassert>
#include "filesystem_test_helper.hpp" #include "filesystem_test_helper.h"
#include "rapid-cxx-test.hpp" #include "rapid-cxx-test.h"
#include "test_macros.h" #include "test_macros.h"
TEST_SUITE(directory_entry_status_testsuite) TEST_SUITE(directory_entry_status_testsuite)
TEST_CASE(test_basic) { TEST_CASE(test_basic) {
using namespace fs; using namespace fs;
{ {
Show All 28 Lines

libcxx/trunk/test/std/input.output/filesystems/class.directory_entry/directory_entry.obs/symlink_status.pass.cpp

Show All 9 Lines
// <filesystem> // <filesystem>
// class directory_entry // class directory_entry
// file_status symlink_status() const; // file_status symlink_status() const;
// file_status symlink_status(error_code&) const noexcept; // file_status symlink_status(error_code&) const noexcept;
#include "filesystem_include.hpp" #include "filesystem_include.h"
#include <type_traits> #include <type_traits>
#include <cassert> #include <cassert>
#include "filesystem_test_helper.hpp" #include "filesystem_test_helper.h"
#include "rapid-cxx-test.hpp" #include "rapid-cxx-test.h"
#include "test_macros.h" #include "test_macros.h"
TEST_SUITE(directory_entry_obs_suite) TEST_SUITE(directory_entry_obs_suite)
TEST_CASE(test_signature) { TEST_CASE(test_signature) {
using namespace fs; using namespace fs;
{ {
Show All 28 Lines

libcxx/trunk/test/std/input.output/filesystems/class.directory_iterator/directory_iterator.members/copy.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++98, c++03 // UNSUPPORTED: c++98, c++03
// <filesystem> // <filesystem>
// class directory_iterator // class directory_iterator
// directory_iterator(directory_iterator const&); // directory_iterator(directory_iterator const&);
#include "filesystem_include.hpp" #include "filesystem_include.h"
#include <type_traits> #include <type_traits>
#include <set> #include <set>
#include <cassert> #include <cassert>
#include "test_macros.h" #include "test_macros.h"
#include "rapid-cxx-test.hpp" #include "rapid-cxx-test.h"
#include "filesystem_test_helper.hpp" #include "filesystem_test_helper.h"
using namespace fs; using namespace fs;
TEST_SUITE(directory_iterator_copy_construct_tests) TEST_SUITE(directory_iterator_copy_construct_tests)
TEST_CASE(test_constructor_signature) TEST_CASE(test_constructor_signature)
{ {
using D = directory_iterator; using D = directory_iterator;
Show All 26 Lines

libcxx/trunk/test/std/input.output/filesystems/class.directory_iterator/directory_iterator.members/copy_assign.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++98, c++03 // UNSUPPORTED: c++98, c++03
// <filesystem> // <filesystem>
// class directory_iterator // class directory_iterator
// directory_iterator& operator=(directory_iterator const&); // directory_iterator& operator=(directory_iterator const&);
#include "filesystem_include.hpp" #include "filesystem_include.h"
#include <type_traits> #include <type_traits>
#include <set> #include <set>
#include <cassert> #include <cassert>
#include "test_macros.h" #include "test_macros.h"
#include "rapid-cxx-test.hpp" #include "rapid-cxx-test.h"
#include "filesystem_test_helper.hpp" #include "filesystem_test_helper.h"
using namespace fs; using namespace fs;
TEST_SUITE(directory_iterator_copy_assign_tests) TEST_SUITE(directory_iterator_copy_assign_tests)
TEST_CASE(test_assignment_signature) TEST_CASE(test_assignment_signature)
{ {
using D = directory_iterator; using D = directory_iterator;
▲ Show 20 Lines • Show All 65 Lines • Show Last 20 Lines

libcxx/trunk/test/std/input.output/filesystems/class.directory_iterator/directory_iterator.members/ctor.pass.cpp

Show All 11 Lines
// class directory_iterator // class directory_iterator
// explicit directory_iterator(const path& p); // explicit directory_iterator(const path& p);
// directory_iterator(const path& p, directory_options options); // directory_iterator(const path& p, directory_options options);
// directory_iterator(const path& p, error_code& ec); // directory_iterator(const path& p, error_code& ec);
// directory_iterator(const path& p, directory_options options, error_code& ec); // directory_iterator(const path& p, directory_options options, error_code& ec);
#include "filesystem_include.hpp" #include "filesystem_include.h"
#include <type_traits> #include <type_traits>
#include <set> #include <set>
#include <cassert> #include <cassert>
#include "test_macros.h" #include "test_macros.h"
#include "rapid-cxx-test.hpp" #include "rapid-cxx-test.h"
#include "filesystem_test_helper.hpp" #include "filesystem_test_helper.h"
using namespace fs; using namespace fs;
TEST_SUITE(directory_iterator_constructor_tests) TEST_SUITE(directory_iterator_constructor_tests)
TEST_CASE(test_constructor_signatures) TEST_CASE(test_constructor_signatures)
{ {
using D = directory_iterator; using D = directory_iterator;
▲ Show 20 Lines • Show All 218 Lines • Show Last 20 Lines

libcxx/trunk/test/std/input.output/filesystems/class.directory_iterator/directory_iterator.members/default_ctor.pass.cpp

Show All 9 Lines
// <filesystem> // <filesystem>
// class directory_iterator // class directory_iterator
// directory_iterator::directory_iterator() noexcept // directory_iterator::directory_iterator() noexcept
#include "filesystem_include.hpp" #include "filesystem_include.h"
#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**) {
{ {
Show All 10 Lines

libcxx/trunk/test/std/input.output/filesystems/class.directory_iterator/directory_iterator.members/increment.pass.cpp

Show All 9 Lines
// <filesystem> // <filesystem>
// class directory_iterator // class directory_iterator
// directory_iterator& operator++(); // directory_iterator& operator++();
// directory_iterator& increment(error_code& ec); // directory_iterator& increment(error_code& ec);
#include "filesystem_include.hpp" #include "filesystem_include.h"
#include <type_traits> #include <type_traits>
#include <set> #include <set>
#include <cassert> #include <cassert>
#include "test_macros.h" #include "test_macros.h"
#include "rapid-cxx-test.hpp" #include "rapid-cxx-test.h"
#include "filesystem_test_helper.hpp" #include "filesystem_test_helper.h"
#include <iostream> #include <iostream>
using namespace fs; using namespace fs;
TEST_SUITE(directory_iterator_increment_tests) TEST_SUITE(directory_iterator_increment_tests)
TEST_CASE(test_increment_signatures) TEST_CASE(test_increment_signatures)
{ {
▲ Show 20 Lines • Show All 82 Lines • Show Last 20 Lines

libcxx/trunk/test/std/input.output/filesystems/class.directory_iterator/directory_iterator.members/move.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++98, c++03 // UNSUPPORTED: c++98, c++03
// <filesystem> // <filesystem>
// class directory_iterator // class directory_iterator
// directory_iterator(directory_iterator&&) noexcept; // directory_iterator(directory_iterator&&) noexcept;
#include "filesystem_include.hpp" #include "filesystem_include.h"
#include <type_traits> #include <type_traits>
#include <set> #include <set>
#include <cassert> #include <cassert>
#include "test_macros.h" #include "test_macros.h"
#include "rapid-cxx-test.hpp" #include "rapid-cxx-test.h"
#include "filesystem_test_helper.hpp" #include "filesystem_test_helper.h"
using namespace fs; using namespace fs;
TEST_SUITE(directory_iterator_move_construct_tests) TEST_SUITE(directory_iterator_move_construct_tests)
TEST_CASE(test_constructor_signature) TEST_CASE(test_constructor_signature)
{ {
using D = directory_iterator; using D = directory_iterator;
Show All 29 Lines

libcxx/trunk/test/std/input.output/filesystems/class.directory_iterator/directory_iterator.members/move_assign.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++98, c++03 // UNSUPPORTED: c++98, c++03
// <filesystem> // <filesystem>
// class directory_iterator // class directory_iterator
// directory_iterator& operator=(directory_iterator const&); // directory_iterator& operator=(directory_iterator const&);
#include "filesystem_include.hpp" #include "filesystem_include.h"
#include <type_traits> #include <type_traits>
#include <set> #include <set>
#include <cassert> #include <cassert>
#include "test_macros.h" #include "test_macros.h"
#include "rapid-cxx-test.hpp" #include "rapid-cxx-test.h"
#include "filesystem_test_helper.hpp" #include "filesystem_test_helper.h"
// The filesystem specification explicitly allows for self-move on // The filesystem specification explicitly allows for self-move on
// the directory iterators. Turn off this warning so we can test it. // the directory iterators. Turn off this warning so we can test it.
#if defined(__clang__) #if defined(__clang__)
#pragma clang diagnostic ignored "-Wself-move" #pragma clang diagnostic ignored "-Wself-move"
#endif #endif
using namespace fs; using namespace fs;
▲ Show 20 Lines • Show All 83 Lines • Show Last 20 Lines

libcxx/trunk/test/std/input.output/filesystems/class.directory_iterator/directory_iterator.nonmembers/begin_end.pass.cpp

Show All 9 Lines
// <filesystem> // <filesystem>
// class directory_iterator // class directory_iterator
// directory_iterator begin(directory_iterator iter) noexcept; // directory_iterator begin(directory_iterator iter) noexcept;
// directory_iterator end(directory_iterator iter) noexcept; // directory_iterator end(directory_iterator iter) noexcept;
#include "filesystem_include.hpp" #include "filesystem_include.h"
#include <type_traits> #include <type_traits>
#include <set> #include <set>
#include <cassert> #include <cassert>
#include "test_macros.h" #include "test_macros.h"
#include "rapid-cxx-test.hpp" #include "rapid-cxx-test.h"
#include "filesystem_test_helper.hpp" #include "filesystem_test_helper.h"
#include <iostream> #include <iostream>
using namespace fs; using namespace fs;
TEST_SUITE(directory_iterator_begin_end_tests) TEST_SUITE(directory_iterator_begin_end_tests)
TEST_CASE(test_function_signatures) TEST_CASE(test_function_signatures)
{ {
Show All 26 Lines

libcxx/trunk/test/std/input.output/filesystems/class.directory_iterator/types.pass.cpp

Show All 12 Lines
// class directory_iterator // class directory_iterator
// typedef ... value_type; // typedef ... value_type;
// typedef ... difference_type; // typedef ... difference_type;
// typedef ... pointer; // typedef ... pointer;
// typedef ... reference; // typedef ... reference;
// typedef ... iterator_category // typedef ... iterator_category
#include "filesystem_include.hpp" #include "filesystem_include.h"
#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**) {
using namespace fs; using namespace fs;
Show All 9 Lines

libcxx/trunk/test/std/input.output/filesystems/class.file_status/file_status.cons.pass.cpp

Show All 9 Lines
// <filesystem> // <filesystem>
// class file_status // class file_status
// explicit file_status() noexcept; // explicit file_status() noexcept;
// explicit file_status(file_type, perms prms = perms::unknown) noexcept; // explicit file_status(file_type, perms prms = perms::unknown) noexcept;
#include "filesystem_include.hpp" #include "filesystem_include.h"
#include <type_traits> #include <type_traits>
#include <cassert> #include <cassert>
#include "test_convertible.hpp" #include "test_convertible.h"
#include "test_macros.h" #include "test_macros.h"
int main(int, char**) { int main(int, char**) {
using namespace fs; using namespace fs;
// Default ctor // Default ctor
{ {
Show All 33 Lines

libcxx/trunk/test/std/input.output/filesystems/class.file_status/file_status.mods.pass.cpp

Show All 9 Lines
// <filesystem> // <filesystem>
// class file_status // class file_status
// void type(file_type) noexcept; // void type(file_type) noexcept;
// void permissions(perms) noexcept; // void permissions(perms) noexcept;
#include "filesystem_include.hpp" #include "filesystem_include.h"
#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**) {
using namespace fs; using namespace fs;
Show All 26 Lines

libcxx/trunk/test/std/input.output/filesystems/class.file_status/file_status.obs.pass.cpp

Show All 9 Lines
// <filesystem> // <filesystem>
// class file_status // class file_status
// file_type type() const noexcept; // file_type type() const noexcept;
// perms permissions(p) const noexcept; // perms permissions(p) const noexcept;
#include "filesystem_include.hpp" #include "filesystem_include.h"
#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**) {
using namespace fs; using namespace fs;
Show All 22 Lines

libcxx/trunk/test/std/input.output/filesystems/class.filesystem_error/filesystem_error.members.pass.cpp

Show All 14 Lines
// filesystem_error(const string& what_arg, error_code ec); // filesystem_error(const string& what_arg, error_code ec);
// filesystem_error(const string& what_arg, const path& p1, error_code ec); // filesystem_error(const string& what_arg, const path& p1, error_code ec);
// filesystem_error(const string& what_arg, const path& p1, const path& p2, error_code ec); // filesystem_error(const string& what_arg, const path& p1, const path& p2, error_code ec);
// const std::error_code& code() const; // const std::error_code& code() const;
// const char* what() const noexcept; // const char* what() const noexcept;
// const path& path1() const noexcept; // const path& path1() const noexcept;
// const path& path2() const noexcept; // const path& path2() const noexcept;
#include "filesystem_include.hpp" #include "filesystem_include.h"
#include <type_traits> #include <type_traits>
#include <cassert> #include <cassert>
#include "test_macros.h" #include "test_macros.h"
void test_constructors() { void test_constructors() {
using namespace fs; using namespace fs;
▲ Show 20 Lines • Show All 72 Lines • Show Last 20 Lines

libcxx/trunk/test/std/input.output/filesystems/class.path/path.itr/iterator.pass.cpp

Show All 12 Lines
// class path // class path
// template <class Source> // template <class Source>
// path(const Source& source); // path(const Source& source);
// template <class InputIterator> // template <class InputIterator>
// path(InputIterator first, InputIterator last); // path(InputIterator first, InputIterator last);
#include "filesystem_include.hpp" #include "filesystem_include.h"
#include <iterator> #include <iterator>
#include <type_traits> #include <type_traits>
#include <cassert> #include <cassert>
#include "test_macros.h" #include "test_macros.h"
#include "filesystem_test_helper.hpp" #include "filesystem_test_helper.h"
template <class It> template <class It>
std::reverse_iterator<It> mkRev(It it) { std::reverse_iterator<It> mkRev(It it) {
return std::reverse_iterator<It>(it); return std::reverse_iterator<It>(it);
} }
▲ Show 20 Lines • Show All 71 Lines • Show Last 20 Lines

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

Show All 15 Lines
// template <class Source> // template <class Source>
// path& operator/=(Source const&); // path& operator/=(Source const&);
// template <class Source> // template <class Source>
// path& append(Source const&); // path& append(Source const&);
// template <class InputIterator> // template <class InputIterator>
// path& append(InputIterator first, InputIterator last); // path& append(InputIterator first, InputIterator last);
#include "filesystem_include.hpp" #include "filesystem_include.h"
#include <type_traits> #include <type_traits>
#include <string_view> #include <string_view>
#include <cassert> #include <cassert>
#include "test_macros.h" #include "test_macros.h"
#include "test_iterators.h" #include "test_iterators.h"
#include "count_new.hpp" #include "count_new.h"
#include "filesystem_test_helper.hpp" #include "filesystem_test_helper.h"
#include "verbose_assert.h" #include "verbose_assert.h"
struct AppendOperatorTestcase { struct AppendOperatorTestcase {
MultiStringType lhs; MultiStringType lhs;
MultiStringType rhs; MultiStringType rhs;
MultiStringType expect; MultiStringType expect;
}; };
▲ Show 20 Lines • Show All 300 Lines • Show Last 20 Lines

libcxx/trunk/test/std/input.output/filesystems/class.path/path.member/path.assign/braced_init.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++98, c++03 // UNSUPPORTED: c++98, c++03
// <filesystem> // <filesystem>
// class path // class path
// path& operator=(path const&); // path& operator=(path const&);
#include "filesystem_include.hpp" #include "filesystem_include.h"
#include <type_traits> #include <type_traits>
#include <cassert> #include <cassert>
#include "test_macros.h" #include "test_macros.h"
#include "count_new.hpp" #include "count_new.h"
int main(int, char**) { int main(int, char**) {
using namespace fs; using namespace fs;
path p("abc"); path p("abc");
p = {}; p = {};
assert(p.native() == ""); assert(p.native() == "");
return 0; return 0;
} }

libcxx/trunk/test/std/input.output/filesystems/class.path/path.member/path.assign/copy.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++98, c++03 // UNSUPPORTED: c++98, c++03
// <filesystem> // <filesystem>
// class path // class path
// path& operator=(path const&); // path& operator=(path const&);
#include "filesystem_include.hpp" #include "filesystem_include.h"
#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**) {
using namespace fs; using namespace fs;
Show All 12 Lines

libcxx/trunk/test/std/input.output/filesystems/class.path/path.member/path.assign/move.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++98, c++03 // UNSUPPORTED: c++98, c++03
// <filesystem> // <filesystem>
// class path // class path
// path& operator=(path&&) noexcept // path& operator=(path&&) noexcept
#include "filesystem_include.hpp" #include "filesystem_include.h"
#include <type_traits> #include <type_traits>
#include <cassert> #include <cassert>
#include "test_macros.h" #include "test_macros.h"
#include "count_new.hpp" #include "count_new.h"
int main(int, char**) { int main(int, char**) {
using namespace fs; using namespace fs;
static_assert(std::is_nothrow_move_assignable<path>::value, ""); static_assert(std::is_nothrow_move_assignable<path>::value, "");
assert(globalMemCounter.checkOutstandingNewEq(0)); assert(globalMemCounter.checkOutstandingNewEq(0));
const std::string s("we really really really really really really really " const std::string s("we really really really really really really really "
"really really long string so that we allocate"); "really really long string so that we allocate");
Show All 13 Lines

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

Show All 15 Lines
// path& operator=(Source const&); // path& operator=(Source const&);
// path& operator=(string_type&&); // path& operator=(string_type&&);
// template <class Source> // template <class Source>
// path& assign(Source const&); // path& assign(Source const&);
// template <class InputIterator> // template <class InputIterator>
// path& assign(InputIterator first, InputIterator last); // path& assign(InputIterator first, InputIterator last);
#include "filesystem_include.hpp" #include "filesystem_include.h"
#include <type_traits> #include <type_traits>
#include <string_view> #include <string_view>
#include <cassert> #include <cassert>
#include "test_macros.h" #include "test_macros.h"
#include "test_iterators.h" #include "test_iterators.h"
#include "count_new.hpp" #include "count_new.h"
#include "filesystem_test_helper.hpp" #include "filesystem_test_helper.h"
#include <iostream> #include <iostream>
template <class CharT> template <class CharT>
void RunTestCase(MultiStringType const& MS) { void RunTestCase(MultiStringType const& MS) {
using namespace fs; using namespace fs;
const char* Expect = MS; const char* Expect = MS;
const CharT* TestPath = MS; const CharT* TestPath = MS;
▲ Show 20 Lines • Show All 202 Lines • Show Last 20 Lines

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

Show All 20 Lines
// bool operator< (path const&, path const&) noexcept; // bool operator< (path const&, path const&) noexcept;
// bool operator<=(path const&, path const&) noexcept; // bool operator<=(path const&, path const&) noexcept;
// bool operator> (path const&, path const&) noexcept; // bool operator> (path const&, path const&) noexcept;
// bool operator>=(path const&, path const&) noexcept; // bool operator>=(path const&, path const&) noexcept;
// //
// size_t hash_value(path const&) noexcept; // size_t hash_value(path const&) noexcept;
#include "filesystem_include.hpp" #include "filesystem_include.h"
#include <type_traits> #include <type_traits>
#include <vector> #include <vector>
#include <cassert> #include <cassert>
#include "test_macros.h" #include "test_macros.h"
#include "test_iterators.h" #include "test_iterators.h"
#include "count_new.hpp" #include "count_new.h"
#include "filesystem_test_helper.hpp" #include "filesystem_test_helper.h"
#include "verbose_assert.h" #include "verbose_assert.h"
struct PathCompareTest { struct PathCompareTest {
const char* LHS; const char* LHS;
const char* RHS; const char* RHS;
int expect; int expect;
}; };
▲ Show 20 Lines • Show All 147 Lines • Show Last 20 Lines

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

Show All 21 Lines
// template <class EcharT> // template <class EcharT>
// path& operator+=(EcharT x); // path& operator+=(EcharT x);
// template <class Source> // template <class Source>
// path& concat(const Source& x); // path& concat(const Source& x);
// template <class InputIterator> // template <class InputIterator>
// path& concat(InputIterator first, InputIterator last); // path& concat(InputIterator first, InputIterator last);
#include "filesystem_include.hpp" #include "filesystem_include.h"
#include <type_traits> #include <type_traits>
#include <string> #include <string>
#include <string_view> #include <string_view>
#include <cassert> #include <cassert>
#include "test_macros.h" #include "test_macros.h"
#include "test_iterators.h" #include "test_iterators.h"
#include "count_new.hpp" #include "count_new.h"
#include "filesystem_test_helper.hpp" #include "filesystem_test_helper.h"
struct ConcatOperatorTestcase { struct ConcatOperatorTestcase {
MultiStringType lhs; MultiStringType lhs;
MultiStringType rhs; MultiStringType rhs;
MultiStringType expect; MultiStringType expect;
}; };
▲ Show 20 Lines • Show All 342 Lines • Show Last 20 Lines

libcxx/trunk/test/std/input.output/filesystems/class.path/path.member/path.construct/copy.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++98, c++03 // UNSUPPORTED: c++98, c++03
// <filesystem> // <filesystem>
// class path // class path
// path(path const&) // path(path const&)
#include "filesystem_include.hpp" #include "filesystem_include.h"
#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**) {
using namespace fs; using namespace fs;
Show All 10 Lines

libcxx/trunk/test/std/input.output/filesystems/class.path/path.member/path.construct/default.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++98, c++03 // UNSUPPORTED: c++98, c++03
// <filesystem> // <filesystem>
// class path // class path
// path() noexcept // path() noexcept
#include "filesystem_include.hpp" #include "filesystem_include.h"
#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**) {
using namespace fs; using namespace fs;
static_assert(std::is_nothrow_default_constructible<path>::value, ""); static_assert(std::is_nothrow_default_constructible<path>::value, "");
const path p; const path p;
assert(p.empty()); assert(p.empty());
return 0; return 0;
} }

libcxx/trunk/test/std/input.output/filesystems/class.path/path.member/path.construct/move.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++98, c++03 // UNSUPPORTED: c++98, c++03
// <filesystem> // <filesystem>
// class path // class path
// path(path&&) noexcept // path(path&&) noexcept
#include "filesystem_include.hpp" #include "filesystem_include.h"
#include <type_traits> #include <type_traits>
#include <cassert> #include <cassert>
#include "test_macros.h" #include "test_macros.h"
#include "count_new.hpp" #include "count_new.h"
int main(int, char**) { int main(int, char**) {
using namespace fs; using namespace fs;
static_assert(std::is_nothrow_move_constructible<path>::value, ""); static_assert(std::is_nothrow_move_constructible<path>::value, "");
assert(globalMemCounter.checkOutstandingNewEq(0)); assert(globalMemCounter.checkOutstandingNewEq(0));
const std::string s("we really really really really really really really " const std::string s("we really really really really really really really "
"really really long string so that we allocate"); "really really long string so that we allocate");
Show All 11 Lines

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

Show All 12 Lines
// class path // class path
// template <class Source> // template <class Source>
// path(const Source& source); // path(const Source& source);
// template <class InputIterator> // template <class InputIterator>
// path(InputIterator first, InputIterator last); // path(InputIterator first, InputIterator last);
#include "filesystem_include.hpp" #include "filesystem_include.h"
#include <type_traits> #include <type_traits>
#include <cassert> #include <cassert>
#include "test_macros.h" #include "test_macros.h"
#include "test_iterators.h" #include "test_iterators.h"
#include "min_allocator.h" #include "min_allocator.h"
#include "filesystem_test_helper.hpp" #include "filesystem_test_helper.h"
template <class CharT, class ...Args> template <class CharT, class ...Args>
void RunTestCaseImpl(MultiStringType const& MS, Args... args) { void RunTestCaseImpl(MultiStringType const& MS, Args... args) {
using namespace fs; using namespace fs;
const char* Expect = MS; const char* Expect = MS;
const CharT* TestPath = MS; const CharT* TestPath = MS;
const CharT* TestPathEnd = StrEnd(TestPath); const CharT* TestPathEnd = StrEnd(TestPath);
▲ Show 20 Lines • Show All 94 Lines • Show Last 20 Lines

libcxx/trunk/test/std/input.output/filesystems/class.path/path.member/path.decompose/empty.fail.cpp

Show All 10 Lines
// class path // class path
// bool empty() const noexcept; // bool empty() const noexcept;
// UNSUPPORTED: c++98, c++03, c++11, c++14, c++17 // UNSUPPORTED: c++98, c++03, c++11, c++14, c++17
// UNSUPPORTED: clang-3.3, clang-3.4, clang-3.5, clang-3.6, clang-3.7, clang-3.8 // UNSUPPORTED: clang-3.3, clang-3.4, clang-3.5, clang-3.6, clang-3.7, clang-3.8
#include "filesystem_include.hpp" #include "filesystem_include.h"
#include "test_macros.h" #include "test_macros.h"
int main(int, char**) int main(int, char**)
{ {
fs::path c; fs::path c;
c.empty(); // expected-error {{ignoring return value of function declared with 'nodiscard' attribute}} c.empty(); // expected-error {{ignoring return value of function declared with 'nodiscard' attribute}}
return 0; return 0;
} }

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

Show All 37 Lines
// bool is_relative() const; // bool is_relative() const;
//------------------------------- //-------------------------------
// 8.5 path iterators [path.itr] // 8.5 path iterators [path.itr]
//------------------------------- //-------------------------------
// iterator begin() const; // iterator begin() const;
// iterator end() const; // iterator end() const;
#include "filesystem_include.hpp" #include "filesystem_include.h"
#include <type_traits> #include <type_traits>
#include <vector> #include <vector>
#include <cassert> #include <cassert>
#include "test_macros.h" #include "test_macros.h"
#include "test_iterators.h" #include "test_iterators.h"
#include "count_new.hpp" #include "count_new.h"
#include "filesystem_test_helper.hpp" #include "filesystem_test_helper.h"
#include "assert_checkpoint.h" #include "assert_checkpoint.h"
#include "verbose_assert.h" #include "verbose_assert.h"
struct ComparePathExact { struct ComparePathExact {
bool operator()(std::string const& LHS, std::string const& RHS) const { bool operator()(std::string const& LHS, std::string const& RHS) const {
return LHS == RHS; return LHS == RHS;
} }
}; };
▲ Show 20 Lines • Show All 155 Lines • Show Last 20 Lines

libcxx/trunk/test/std/input.output/filesystems/class.path/path.member/path.gen/lexically_normal.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++98, c++03 // UNSUPPORTED: c++98, c++03
// <filesystem> // <filesystem>
// class path // class path
// path lexically_normal() const; // path lexically_normal() const;
#include "filesystem_include.hpp" #include "filesystem_include.h"
#include <type_traits> #include <type_traits>
#include <vector> #include <vector>
#include <iostream> #include <iostream>
#include <cassert> #include <cassert>
#include "test_macros.h" #include "test_macros.h"
#include "test_iterators.h" #include "test_iterators.h"
#include "count_new.hpp" #include "count_new.h"
#include "filesystem_test_helper.hpp" #include "filesystem_test_helper.h"
int main(int, char**) { int main(int, char**) {
// clang-format off // clang-format off
struct { struct {
std::string input; std::string input;
std::string expect; std::string expect;
} TestCases[] = { } TestCases[] = {
▲ Show 20 Lines • Show All 107 Lines • Show Last 20 Lines

libcxx/trunk/test/std/input.output/filesystems/class.path/path.member/path.gen/lexically_relative_and_proximate.pass.cpp

Show All 9 Lines
// <filesystem> // <filesystem>
// class path // class path
// path lexically_relative(const path& p) const; // path lexically_relative(const path& p) const;
// path lexically_proximate(const path& p) const; // path lexically_proximate(const path& p) const;
#include "filesystem_include.hpp" #include "filesystem_include.h"
#include <type_traits> #include <type_traits>
#include <vector> #include <vector>
#include <iostream> #include <iostream>
#include <cassert> #include <cassert>
#include "test_macros.h" #include "test_macros.h"
#include "test_iterators.h" #include "test_iterators.h"
#include "count_new.hpp" #include "count_new.h"
#include "filesystem_test_helper.hpp" #include "filesystem_test_helper.h"
int main(int, char**) { int main(int, char**) {
// clang-format off // clang-format off
struct { struct {
std::string input; std::string input;
std::string base; std::string base;
std::string expect; std::string expect;
▲ Show 20 Lines • Show All 53 Lines • Show Last 20 Lines

libcxx/trunk/test/std/input.output/filesystems/class.path/path.member/path.generic.obs/generic_string_alloc.pass.cpp

Show All 11 Lines
// class path // class path
// template <class ECharT, class Traits = char_traits<ECharT>, // template <class ECharT, class Traits = char_traits<ECharT>,
// class Allocator = allocator<ECharT>> // class Allocator = allocator<ECharT>>
// basic_string<ECharT, Traits, Allocator> // basic_string<ECharT, Traits, Allocator>
// generic_string(const Allocator& a = Allocator()) const; // generic_string(const Allocator& a = Allocator()) const;
#include "filesystem_include.hpp" #include "filesystem_include.h"
#include <type_traits> #include <type_traits>
#include <cassert> #include <cassert>
#include "test_macros.h" #include "test_macros.h"
#include "test_iterators.h" #include "test_iterators.h"
#include "count_new.hpp" #include "count_new.h"
#include "min_allocator.h" #include "min_allocator.h"
#include "filesystem_test_helper.hpp" #include "filesystem_test_helper.h"
MultiStringType longString = MKSTR("abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ/123456789/abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ"); MultiStringType longString = MKSTR("abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ/123456789/abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ");
// generic_string<C, T, A> forwards to string<C, T, A>. Tests for // generic_string<C, T, A> forwards to string<C, T, A>. Tests for
// string<C, T, A>() are in "path.native.op/string_alloc.pass.cpp". // string<C, T, A>() are in "path.native.op/string_alloc.pass.cpp".
// generic_string is minimally tested here. // generic_string is minimally tested here.
int main(int, char**) int main(int, char**)
Show All 20 Lines

libcxx/trunk/test/std/input.output/filesystems/class.path/path.member/path.generic.obs/named_overloads.pass.cpp

Show All 13 Lines
// std::string generic_string() const; // std::string generic_string() const;
// std::wstring generic_wstring() const; // std::wstring generic_wstring() const;
// std::u8string generic_u8string() const; // std::u8string generic_u8string() const;
// std::u16string generic_u16string() const; // std::u16string generic_u16string() const;
// std::u32string generic_u32string() const; // std::u32string generic_u32string() const;
#include "filesystem_include.hpp" #include "filesystem_include.h"
#include <type_traits> #include <type_traits>
#include <cassert> #include <cassert>
#include "test_macros.h" #include "test_macros.h"
#include "test_iterators.h" #include "test_iterators.h"
#include "count_new.hpp" #include "count_new.h"
#include "min_allocator.h" #include "min_allocator.h"
#include "filesystem_test_helper.hpp" #include "filesystem_test_helper.h"
MultiStringType longString = MKSTR("abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ/123456789/abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ"); MultiStringType longString = MKSTR("abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ/123456789/abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ");
int main(int, char**) int main(int, char**)
{ {
using namespace fs; using namespace fs;
auto const& MS = longString; auto const& MS = longString;
const char* value = longString; const char* value = longString;
Show All 24 Lines

libcxx/trunk/test/std/input.output/filesystems/class.path/path.member/path.modifiers/clear.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++98, c++03 // UNSUPPORTED: c++98, c++03
// <filesystem> // <filesystem>
// class path // class path
// void clear() noexcept // void clear() noexcept
#include "filesystem_include.hpp" #include "filesystem_include.h"
#include <type_traits> #include <type_traits>
#include <cassert> #include <cassert>
#include "test_macros.h" #include "test_macros.h"
#include "test_iterators.h" #include "test_iterators.h"
#include "count_new.hpp" #include "count_new.h"
#include "filesystem_test_helper.hpp" #include "filesystem_test_helper.h"
int main(int, char**) { int main(int, char**) {
using namespace fs; using namespace fs;
{ {
path p; path p;
ASSERT_NOEXCEPT(p.clear()); ASSERT_NOEXCEPT(p.clear());
ASSERT_SAME_TYPE(void, decltype(p.clear())); ASSERT_SAME_TYPE(void, decltype(p.clear()));
Show All 13 Lines

libcxx/trunk/test/std/input.output/filesystems/class.path/path.member/path.modifiers/make_preferred.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++98, c++03 // UNSUPPORTED: c++98, c++03
// <filesystem> // <filesystem>
// class path // class path
// path& make_preferred() // path& make_preferred()
#include "filesystem_include.hpp" #include "filesystem_include.h"
#include <type_traits> #include <type_traits>
#include <cassert> #include <cassert>
#include "test_macros.h" #include "test_macros.h"
#include "test_iterators.h" #include "test_iterators.h"
#include "count_new.hpp" #include "count_new.h"
#include "filesystem_test_helper.hpp" #include "filesystem_test_helper.h"
struct MakePreferredTestcase { struct MakePreferredTestcase {
const char* value; const char* value;
}; };
const MakePreferredTestcase TestCases[] = const MakePreferredTestcase TestCases[] =
{ {
Show All 23 Lines

libcxx/trunk/test/std/input.output/filesystems/class.path/path.member/path.modifiers/remove_filename.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++98, c++03 // UNSUPPORTED: c++98, c++03
// <filesystem> // <filesystem>
// class path // class path
// path& remove_filename() // path& remove_filename()
#include "filesystem_include.hpp" #include "filesystem_include.h"
#include <type_traits> #include <type_traits>
#include <cassert> #include <cassert>
#include "test_macros.h" #include "test_macros.h"
#include "test_iterators.h" #include "test_iterators.h"
#include "count_new.hpp" #include "count_new.h"
#include "filesystem_test_helper.hpp" #include "filesystem_test_helper.h"
#include "verbose_assert.h" #include "verbose_assert.h"
struct RemoveFilenameTestcase { struct RemoveFilenameTestcase {
const char* value; const char* value;
const char* expect; const char* expect;
}; };
const RemoveFilenameTestcase TestCases[] = const RemoveFilenameTestcase TestCases[] =
▲ Show 20 Lines • Show All 42 Lines • Show Last 20 Lines

libcxx/trunk/test/std/input.output/filesystems/class.path/path.member/path.modifiers/replace_extension.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++98, c++03 // UNSUPPORTED: c++98, c++03
// <filesystem> // <filesystem>
// class path // class path
// path& replace_extension(path const& p = path()) // path& replace_extension(path const& p = path())
#include "filesystem_include.hpp" #include "filesystem_include.h"
#include <type_traits> #include <type_traits>
#include <cassert> #include <cassert>
#include "test_macros.h" #include "test_macros.h"
#include "test_iterators.h" #include "test_iterators.h"
#include "count_new.hpp" #include "count_new.h"
#include "filesystem_test_helper.hpp" #include "filesystem_test_helper.h"
struct ReplaceExtensionTestcase { struct ReplaceExtensionTestcase {
const char* value; const char* value;
const char* expect; const char* expect;
const char* extension; const char* extension;
}; };
▲ Show 20 Lines • Show All 41 Lines • Show Last 20 Lines

libcxx/trunk/test/std/input.output/filesystems/class.path/path.member/path.modifiers/replace_filename.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++98, c++03 // UNSUPPORTED: c++98, c++03
// <filesystem> // <filesystem>
// class path // class path
// path& replace_filename() // path& replace_filename()
#include "filesystem_include.hpp" #include "filesystem_include.h"
#include <type_traits> #include <type_traits>
#include <cassert> #include <cassert>
#include "test_macros.h" #include "test_macros.h"
#include "test_iterators.h" #include "test_iterators.h"
#include "count_new.hpp" #include "count_new.h"
#include "filesystem_test_helper.hpp" #include "filesystem_test_helper.h"
#include "assert_checkpoint.h" #include "assert_checkpoint.h"
#include "verbose_assert.h" #include "verbose_assert.h"
struct ReplaceFilenameTestcase { struct ReplaceFilenameTestcase {
const char* value; const char* value;
const char* expect; const char* expect;
const char* filename; const char* filename;
}; };
Show All 40 Lines

libcxx/trunk/test/std/input.output/filesystems/class.path/path.member/path.modifiers/swap.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++98, c++03 // UNSUPPORTED: c++98, c++03
// <filesystem> // <filesystem>
// class path // class path
// void swap(path& rhs) noexcept; // void swap(path& rhs) noexcept;
#include "filesystem_include.hpp" #include "filesystem_include.h"
#include <type_traits> #include <type_traits>
#include <cassert> #include <cassert>
#include "test_macros.h" #include "test_macros.h"
#include "test_iterators.h" #include "test_iterators.h"
#include "count_new.hpp" #include "count_new.h"
#include "filesystem_test_helper.hpp" #include "filesystem_test_helper.h"
struct SwapTestcase { struct SwapTestcase {
const char* value1; const char* value1;
const char* value2; const char* value2;
}; };
#define LONG_STR1 "_THIS_IS_LONG_THIS_IS_LONG_THIS_IS_LONG_THIS_IS_LONG_THIS_IS_LONG_THIS_IS_LONG_THIS_IS_LONG" #define LONG_STR1 "_THIS_IS_LONG_THIS_IS_LONG_THIS_IS_LONG_THIS_IS_LONG_THIS_IS_LONG_THIS_IS_LONG_THIS_IS_LONG"
▲ Show 20 Lines • Show All 49 Lines • Show Last 20 Lines

libcxx/trunk/test/std/input.output/filesystems/class.path/path.member/path.native.obs/c_str.pass.cpp

Show All 9 Lines
// UNSUPPORTED: c++98, c++03 // UNSUPPORTED: c++98, c++03
// <filesystem> // <filesystem>
// class path // class path
// const value_type* c_str() const noexcept; // const value_type* c_str() const noexcept;
#include "filesystem_include.hpp" #include "filesystem_include.h"
#include <type_traits> #include <type_traits>
#include <cassert> #include <cassert>
#include "test_macros.h" #include "test_macros.h"
#include "filesystem_test_helper.hpp" #include "filesystem_test_helper.h"
int main(int, char**) int main(int, char**)
{ {
using namespace fs; using namespace fs;
const char* const value = "hello world"; const char* const value = "hello world";
const std::string str_value = value; const std::string str_value = value;
{ // Check signature { // Check signature
Show All 12 Lines

libcxx/trunk/test/std/input.output/filesystems/class.path/path.member/path.native.obs/named_overloads.pass.cpp

Show All 13 Lines
// std::string string() const; // std::string string() const;
// std::wstring wstring() const; // std::wstring wstring() const;
// std::u8string u8string() const; // std::u8string u8string() const;
// std::u16string u16string() const; // std::u16string u16string() const;
// std::u32string u32string() const; // std::u32string u32string() const;
#include "filesystem_include.hpp" #include "filesystem_include.h"
#include <type_traits> #include <type_traits>
#include <cassert> #include <cassert>
#include "test_macros.h" #include "test_macros.h"
#include "test_iterators.h" #include "test_iterators.h"
#include "count_new.hpp" #include "count_new.h"
#include "min_allocator.h" #include "min_allocator.h"
#include "filesystem_test_helper.hpp" #include "filesystem_test_helper.h"
MultiStringType longString = MKSTR("abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ/123456789/abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ"); MultiStringType longString = MKSTR("abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ/123456789/abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ");
int main(int, char**) int main(int, char**)
{ {
using namespace fs; using namespace fs;
auto const& MS = longString; auto const& MS = longString;
Show All 25 Lines

libcxx/trunk/test/std/input.output/filesystems/class.path/path.member/path.native.obs/native.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++98, c++03 // UNSUPPORTED: c++98, c++03
// <filesystem> // <filesystem>
// class path // class path
// const string_type& native() const noexcept; // const string_type& native() const noexcept;
#include "filesystem_include.hpp" #include "filesystem_include.h"
#include <type_traits> #include <type_traits>
#include <cassert> #include <cassert>
#include "test_macros.h" #include "test_macros.h"
#include "filesystem_test_helper.hpp" #include "filesystem_test_helper.h"
int main(int, char**) int main(int, char**)
{ {
using namespace fs; using namespace fs;
const char* const value = "hello world"; const char* const value = "hello world";
{ // Check signature { // Check signature
path p(value); path p(value);
Show All 10 Lines

libcxx/trunk/test/std/input.output/filesystems/class.path/path.member/path.native.obs/operator_string.pass.cpp

Show All 9 Lines
// UNSUPPORTED: c++98, c++03 // UNSUPPORTED: c++98, c++03
// <filesystem> // <filesystem>
// class path // class path
// operator string_type() const; // operator string_type() const;
#include "filesystem_include.hpp" #include "filesystem_include.h"
#include <type_traits> #include <type_traits>
#include <cassert> #include <cassert>
#include "test_macros.h" #include "test_macros.h"
#include "filesystem_test_helper.hpp" #include "filesystem_test_helper.h"
int main(int, char**) int main(int, char**)
{ {
using namespace fs; using namespace fs;
using string_type = path::string_type; using string_type = path::string_type;
const char* const value = "hello world"; const char* const value = "hello world";
{ // Check signature { // Check signature
Show All 16 Lines

libcxx/trunk/test/std/input.output/filesystems/class.path/path.member/path.native.obs/string_alloc.pass.cpp

Show All 11 Lines
// class path // class path
// template <class ECharT, class Traits = char_traits<ECharT>, // template <class ECharT, class Traits = char_traits<ECharT>,
// class Allocator = allocator<ECharT>> // class Allocator = allocator<ECharT>>
// basic_string<ECharT, Traits, Allocator> // basic_string<ECharT, Traits, Allocator>
// string(const Allocator& a = Allocator()) const; // string(const Allocator& a = Allocator()) const;
#include "filesystem_include.hpp" #include "filesystem_include.h"
#include <type_traits> #include <type_traits>
#include <cassert> #include <cassert>
#include "test_macros.h" #include "test_macros.h"
#include "test_iterators.h" #include "test_iterators.h"
#include "count_new.hpp" #include "count_new.h"
#include "min_allocator.h" #include "min_allocator.h"
#include "filesystem_test_helper.hpp" #include "filesystem_test_helper.h"
// the SSO is always triggered for strings of size 2. // the SSO is always triggered for strings of size 2.
MultiStringType shortString = MKSTR("a"); MultiStringType shortString = MKSTR("a");
MultiStringType longString = MKSTR("abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ/123456789/abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ"); MultiStringType longString = MKSTR("abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ/123456789/abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ");
template <class CharT> template <class CharT>
void doShortStringTest(MultiStringType const& MS) { void doShortStringTest(MultiStringType const& MS) {
▲ Show 20 Lines • Show All 102 Lines • Show Last 20 Lines

libcxx/trunk/test/std/input.output/filesystems/class.path/path.nonmember/append_op.fail.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++98, c++03 // UNSUPPORTED: c++98, c++03
// <filesystem> // <filesystem>
#include "filesystem_include.hpp" #include "filesystem_include.h"
using namespace fs; using namespace fs;
struct ConvToPath { struct ConvToPath {
operator fs::path() const { operator fs::path() const {
return ""; return "";
} }
}; };
int main(int, char**) { int main(int, char**) {
ConvToPath LHS, RHS; ConvToPath LHS, RHS;
(void)(LHS / RHS); // expected-error {{invalid operands to binary expression}} (void)(LHS / RHS); // expected-error {{invalid operands to binary expression}}
return 0; return 0;
} }
No newline at end of file

libcxx/trunk/test/std/input.output/filesystems/class.path/path.nonmember/append_op.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++98, c++03 // UNSUPPORTED: c++98, c++03
// <filesystem> // <filesystem>
// path operator/(path const&, path const&); // path operator/(path const&, path const&);
#include "filesystem_include.hpp" #include "filesystem_include.h"
#include <type_traits> #include <type_traits>
#include <cassert> #include <cassert>
#include "test_macros.h" #include "test_macros.h"
#include "filesystem_test_helper.hpp" #include "filesystem_test_helper.h"
// This is mainly tested via the member append functions. // This is mainly tested via the member append functions.
int main(int, char**) int main(int, char**)
{ {
using namespace fs; using namespace fs;
path p1("abc"); path p1("abc");
path p2("def"); path p2("def");
path p3 = p1 / p2; path p3 = p1 / p2;
assert(p3 == "abc/def"); assert(p3 == "abc/def");
path p4 = p1 / "def"; path p4 = p1 / "def";
assert(p4 == "abc/def"); assert(p4 == "abc/def");
return 0; return 0;
} }

libcxx/trunk/test/std/input.output/filesystems/class.path/path.nonmember/comparison_ops.fail.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++98, c++03 // UNSUPPORTED: c++98, c++03
// <filesystem> // <filesystem>
#include "filesystem_include.hpp" #include "filesystem_include.h"
using namespace fs; using namespace fs;
struct ConvToPath { struct ConvToPath {
operator fs::path() const { operator fs::path() const {
return ""; return "";
} }
}; };
int main(int, char**) { int main(int, char**) {
ConvToPath LHS, RHS; ConvToPath LHS, RHS;
(void)(LHS == RHS); // expected-error {{invalid operands to binary expression}} (void)(LHS == RHS); // expected-error {{invalid operands to binary expression}}
(void)(LHS != RHS); // expected-error {{invalid operands to binary expression}} (void)(LHS != RHS); // expected-error {{invalid operands to binary expression}}
(void)(LHS < RHS); // expected-error {{invalid operands to binary expression}} (void)(LHS < RHS); // expected-error {{invalid operands to binary expression}}
(void)(LHS <= RHS); // expected-error {{invalid operands to binary expression}} (void)(LHS <= RHS); // expected-error {{invalid operands to binary expression}}
(void)(LHS > RHS); // expected-error {{invalid operands to binary expression}} (void)(LHS > RHS); // expected-error {{invalid operands to binary expression}}
(void)(LHS >= RHS); // expected-error {{invalid operands to binary expression}} (void)(LHS >= RHS); // expected-error {{invalid operands to binary expression}}
return 0; return 0;
} }
No newline at end of file

libcxx/trunk/test/std/input.output/filesystems/class.path/path.nonmember/path.factory.pass.cpp

Show All 9 Lines
// <filesystem> // <filesystem>
// template <class Source> // template <class Source>
// path u8path(Source const&); // path u8path(Source const&);
// template <class InputIter> // template <class InputIter>
// path u8path(InputIter, InputIter); // path u8path(InputIter, InputIter);
#include "filesystem_include.hpp" #include "filesystem_include.h"
#include <type_traits> #include <type_traits>
#include <cassert> #include <cassert>
#include "test_macros.h" #include "test_macros.h"
#include "test_iterators.h" #include "test_iterators.h"
#include "count_new.hpp" #include "count_new.h"
#include "filesystem_test_helper.hpp" #include "filesystem_test_helper.h"
int main(int, char**) int main(int, char**)
{ {
using namespace fs; using namespace fs;
const char* In1 = "abcd/efg"; const char* In1 = "abcd/efg";
const std::string In2(In1); const std::string In2(In1);
const auto In3 = In2.begin(); const auto In3 = In2.begin();
Show All 20 Lines

libcxx/trunk/test/std/input.output/filesystems/class.path/path.nonmember/path.io.pass.cpp

Show All 15 Lines
// basic_ostream<charT, traits>& // basic_ostream<charT, traits>&
// operator<<(basic_ostream<charT, traits>& os, const path& p); // operator<<(basic_ostream<charT, traits>& os, const path& p);
// //
// template <class charT, class traits> // template <class charT, class traits>
// basic_istream<charT, traits>& // basic_istream<charT, traits>&
// operator>>(basic_istream<charT, traits>& is, path& p) // operator>>(basic_istream<charT, traits>& is, path& p)
// //
#include "filesystem_include.hpp" #include "filesystem_include.h"
#include <type_traits> #include <type_traits>
#include <sstream> #include <sstream>
#include <cassert> #include <cassert>
#include <iostream> #include <iostream>
#include "test_macros.h" #include "test_macros.h"
#include "test_iterators.h" #include "test_iterators.h"
#include "count_new.hpp" #include "count_new.h"
#include "filesystem_test_helper.hpp" #include "filesystem_test_helper.h"
MultiStringType InStr = MKSTR("abcdefg/\"hijklmnop\"/qrstuvwxyz/123456789"); MultiStringType InStr = MKSTR("abcdefg/\"hijklmnop\"/qrstuvwxyz/123456789");
MultiStringType OutStr = MKSTR("\"abcdefg/\\\"hijklmnop\\\"/qrstuvwxyz/123456789\""); MultiStringType OutStr = MKSTR("\"abcdefg/\\\"hijklmnop\\\"/qrstuvwxyz/123456789\"");
template <class CharT> template <class CharT>
void doIOTest() { void doIOTest() {
▲ Show 20 Lines • Show All 58 Lines • Show Last 20 Lines

libcxx/trunk/test/std/input.output/filesystems/class.path/path.nonmember/path.io.unicode_bug.pass.cpp

Show All 20 Lines
// operator>>(basic_istream<charT, traits>& is, path& p) // operator>>(basic_istream<charT, traits>& is, path& p)
// //
// TODO(EricWF) This test fails because "std::quoted" fails to compile // TODO(EricWF) This test fails because "std::quoted" fails to compile
// for char16_t and char32_t types. Combine with path.io.pass.cpp when this // for char16_t and char32_t types. Combine with path.io.pass.cpp when this
// passes. // passes.
// XFAIL: * // XFAIL: *
#include "filesystem_include.hpp" #include "filesystem_include.h"
#include <type_traits> #include <type_traits>
#include <sstream> #include <sstream>
#include <cassert> #include <cassert>
#include "test_macros.h" #include "test_macros.h"
#include "test_iterators.h" #include "test_iterators.h"
#include "count_new.hpp" #include "count_new.h"
#include "filesystem_test_helper.hpp" #include "filesystem_test_helper.h"
MultiStringType InStr = MKSTR("abcdefg/\"hijklmnop\"/qrstuvwxyz/123456789"); MultiStringType InStr = MKSTR("abcdefg/\"hijklmnop\"/qrstuvwxyz/123456789");
MultiStringType OutStr = MKSTR("\"abcdefg/\\\"hijklmnop\\\"/qrstuvwxyz/123456789\""); MultiStringType OutStr = MKSTR("\"abcdefg/\\\"hijklmnop\\\"/qrstuvwxyz/123456789\"");
template <class CharT> template <class CharT>
void doIOTest() { void doIOTest() {
using namespace fs; using namespace fs;
using Ptr = const CharT*; using Ptr = const CharT*;
Show All 25 Lines

libcxx/trunk/test/std/input.output/filesystems/class.path/path.nonmember/swap.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++98, c++03 // UNSUPPORTED: c++98, c++03
// <filesystem> // <filesystem>
// void swap(path& lhs, path& rhs) noexcept; // void swap(path& lhs, path& rhs) noexcept;
#include "filesystem_include.hpp" #include "filesystem_include.h"
#include <type_traits> #include <type_traits>
#include <cassert> #include <cassert>
#include "test_macros.h" #include "test_macros.h"
#include "count_new.hpp" #include "count_new.h"
#include "filesystem_test_helper.hpp" #include "filesystem_test_helper.h"
// NOTE: this is tested in path.members/path.modifiers via the member swap. // NOTE: this is tested in path.members/path.modifiers via the member swap.
int main(int, char**) int main(int, char**)
{ {
using namespace fs; using namespace fs;
const char* value1 = "foo/bar/baz"; const char* value1 = "foo/bar/baz";
const char* value2 = "_THIS_IS_LONG_THIS_IS_LONG_THIS_IS_LONG_THIS_IS_LONG_THIS_IS_LONG_THIS_IS_LONG_THIS_IS_LONG"; const char* value2 = "_THIS_IS_LONG_THIS_IS_LONG_THIS_IS_LONG_THIS_IS_LONG_THIS_IS_LONG_THIS_IS_LONG_THIS_IS_LONG";
Show All 21 Lines

libcxx/trunk/test/std/input.output/filesystems/class.path/synop.pass.cpp

Show All 10 Lines
// <filesystem> // <filesystem>
// class path // class path
// typedef ... value_type; // typedef ... value_type;
// typedef basic_string<value_type> string_type; // typedef basic_string<value_type> string_type;
// static constexpr value_type preferred_separator = ...; // static constexpr value_type preferred_separator = ...;
#include "filesystem_include.hpp" #include "filesystem_include.h"
#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**) {
using namespace fs; using namespace fs;
Show All 12 Lines

libcxx/trunk/test/std/input.output/filesystems/class.rec.dir.itr/rec.dir.itr.members/copy.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++98, c++03 // UNSUPPORTED: c++98, c++03
// <filesystem> // <filesystem>
// class recursive_directory_iterator // class recursive_directory_iterator
// recursive_recursive_directory_iterator(recursive_recursive_directory_iterator const&); // recursive_recursive_directory_iterator(recursive_recursive_directory_iterator const&);
#include "filesystem_include.hpp" #include "filesystem_include.h"
#include <type_traits> #include <type_traits>
#include <set> #include <set>
#include <cassert> #include <cassert>
#include "test_macros.h" #include "test_macros.h"
#include "rapid-cxx-test.hpp" #include "rapid-cxx-test.h"
#include "filesystem_test_helper.hpp" #include "filesystem_test_helper.h"
using namespace fs; using namespace fs;
TEST_SUITE(recursive_directory_iterator_copy_construct_tests) TEST_SUITE(recursive_directory_iterator_copy_construct_tests)
TEST_CASE(test_constructor_signature) TEST_CASE(test_constructor_signature)
{ {
using D = recursive_directory_iterator; using D = recursive_directory_iterator;
▲ Show 20 Lines • Show All 46 Lines • Show Last 20 Lines

libcxx/trunk/test/std/input.output/filesystems/class.rec.dir.itr/rec.dir.itr.members/copy_assign.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++98, c++03 // UNSUPPORTED: c++98, c++03
// <filesystem> // <filesystem>
// class recursive_directory_iterator // class recursive_directory_iterator
// recursive_directory_iterator& operator=(recursive_directory_iterator const&); // recursive_directory_iterator& operator=(recursive_directory_iterator const&);
#include "filesystem_include.hpp" #include "filesystem_include.h"
#include <type_traits> #include <type_traits>
#include <set> #include <set>
#include <cassert> #include <cassert>
#include "test_macros.h" #include "test_macros.h"
#include "rapid-cxx-test.hpp" #include "rapid-cxx-test.h"
#include "filesystem_test_helper.hpp" #include "filesystem_test_helper.h"
using namespace fs; using namespace fs;
TEST_SUITE(recursive_directory_iterator_copy_assign_tests) TEST_SUITE(recursive_directory_iterator_copy_assign_tests)
recursive_directory_iterator createInterestingIterator() recursive_directory_iterator createInterestingIterator()
// Create an "interesting" iterator where all fields are // Create an "interesting" iterator where all fields are
// in a non-default state. The returned 'it' is in a // in a non-default state. The returned 'it' is in a
▲ Show 20 Lines • Show All 125 Lines • Show Last 20 Lines

libcxx/trunk/test/std/input.output/filesystems/class.rec.dir.itr/rec.dir.itr.members/ctor.pass.cpp

Show All 13 Lines
// //
// explicit recursive_directory_iterator(const path& p); // explicit recursive_directory_iterator(const path& p);
// recursive_directory_iterator(const path& p, directory_options options); // recursive_directory_iterator(const path& p, directory_options options);
// recursive_directory_iterator(const path& p, error_code& ec); // recursive_directory_iterator(const path& p, error_code& ec);
// recursive_directory_iterator(const path& p, directory_options options, error_code& ec); // recursive_directory_iterator(const path& p, directory_options options, error_code& ec);
#include "filesystem_include.hpp" #include "filesystem_include.h"
#include <type_traits> #include <type_traits>
#include <set> #include <set>
#include <cassert> #include <cassert>
#include "test_macros.h" #include "test_macros.h"
#include "rapid-cxx-test.hpp" #include "rapid-cxx-test.h"
#include "filesystem_test_helper.hpp" #include "filesystem_test_helper.h"
using namespace fs; using namespace fs;
using RDI = recursive_directory_iterator; using RDI = recursive_directory_iterator;
TEST_SUITE(recursive_directory_iterator_constructor_tests) TEST_SUITE(recursive_directory_iterator_constructor_tests)
TEST_CASE(test_constructor_signatures) TEST_CASE(test_constructor_signatures)
▲ Show 20 Lines • Show All 208 Lines • Show Last 20 Lines

libcxx/trunk/test/std/input.output/filesystems/class.rec.dir.itr/rec.dir.itr.members/depth.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++98, c++03 // UNSUPPORTED: c++98, c++03
// <filesystem> // <filesystem>
// class recursive_directory_iterator // class recursive_directory_iterator
// int depth() const // int depth() const
#include "filesystem_include.hpp" #include "filesystem_include.h"
#include <type_traits> #include <type_traits>
#include <set> #include <set>
#include <cassert> #include <cassert>
#include "test_macros.h" #include "test_macros.h"
#include "rapid-cxx-test.hpp" #include "rapid-cxx-test.h"
#include "filesystem_test_helper.hpp" #include "filesystem_test_helper.h"
using namespace fs; using namespace fs;
TEST_SUITE(recursive_directory_iterator_depth_tests) TEST_SUITE(recursive_directory_iterator_depth_tests)
TEST_CASE(test_depth) TEST_CASE(test_depth)
{ {
const path testDir = StaticEnv::Dir; const path testDir = StaticEnv::Dir;
Show All 33 Lines

libcxx/trunk/test/std/input.output/filesystems/class.rec.dir.itr/rec.dir.itr.members/disable_recursion_pending.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++98, c++03 // UNSUPPORTED: c++98, c++03
// <filesystem> // <filesystem>
// class recursive_directory_iterator // class recursive_directory_iterator
// void disable_recursion_pending(); // void disable_recursion_pending();
#include "filesystem_include.hpp" #include "filesystem_include.h"
#include <type_traits> #include <type_traits>
#include <set> #include <set>
#include <cassert> #include <cassert>
#include "test_macros.h" #include "test_macros.h"
#include "rapid-cxx-test.hpp" #include "rapid-cxx-test.h"
#include "filesystem_test_helper.hpp" #include "filesystem_test_helper.h"
using namespace fs; using namespace fs;
TEST_SUITE(recursive_directory_iterator_disable_recursion_pending_tests) TEST_SUITE(recursive_directory_iterator_disable_recursion_pending_tests)
// NOTE: The main semantics of disable_recursion_pending are tested // NOTE: The main semantics of disable_recursion_pending are tested
// in the 'recursion_pending()' tests. // in the 'recursion_pending()' tests.
TEST_CASE(basic_test) TEST_CASE(basic_test)
Show All 10 Lines

libcxx/trunk/test/std/input.output/filesystems/class.rec.dir.itr/rec.dir.itr.members/increment.pass.cpp

Show All 9 Lines
// <filesystem> // <filesystem>
// class recursive_directory_iterator // class recursive_directory_iterator
// recursive_directory_iterator& operator++(); // recursive_directory_iterator& operator++();
// recursive_directory_iterator& increment(error_code& ec) noexcept; // recursive_directory_iterator& increment(error_code& ec) noexcept;
#include "filesystem_include.hpp" #include "filesystem_include.h"
#include <type_traits> #include <type_traits>
#include <set> #include <set>
#include <cassert> #include <cassert>
#include "test_macros.h" #include "test_macros.h"
#include "rapid-cxx-test.hpp" #include "rapid-cxx-test.h"
#include "filesystem_test_helper.hpp" #include "filesystem_test_helper.h"
using namespace fs; using namespace fs;
TEST_SUITE(recursive_directory_iterator_increment_tests) TEST_SUITE(recursive_directory_iterator_increment_tests)
TEST_CASE(test_increment_signatures) TEST_CASE(test_increment_signatures)
{ {
recursive_directory_iterator d; ((void)d); recursive_directory_iterator d; ((void)d);
▲ Show 20 Lines • Show All 461 Lines • Show Last 20 Lines

libcxx/trunk/test/std/input.output/filesystems/class.rec.dir.itr/rec.dir.itr.members/move.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++98, c++03 // UNSUPPORTED: c++98, c++03
// <filesystem> // <filesystem>
// class recursive_directory_iterator // class recursive_directory_iterator
// recursive_directory_iterator(recursive_directory_iterator&&) noexcept; // recursive_directory_iterator(recursive_directory_iterator&&) noexcept;
#include "filesystem_include.hpp" #include "filesystem_include.h"
#include <type_traits> #include <type_traits>
#include <set> #include <set>
#include <cassert> #include <cassert>
#include "test_macros.h" #include "test_macros.h"
#include "rapid-cxx-test.hpp" #include "rapid-cxx-test.h"
#include "filesystem_test_helper.hpp" #include "filesystem_test_helper.h"
using namespace fs; using namespace fs;
TEST_SUITE(recursive_directory_iterator_move_construct_tests) TEST_SUITE(recursive_directory_iterator_move_construct_tests)
TEST_CASE(test_constructor_signature) TEST_CASE(test_constructor_signature)
{ {
using D = recursive_directory_iterator; using D = recursive_directory_iterator;
▲ Show 20 Lines • Show All 47 Lines • Show Last 20 Lines

libcxx/trunk/test/std/input.output/filesystems/class.rec.dir.itr/rec.dir.itr.members/move_assign.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++98, c++03 // UNSUPPORTED: c++98, c++03
// <filesystem> // <filesystem>
// class recursive_directory_iterator // class recursive_directory_iterator
// recursive_directory_iterator& operator=(recursive_directory_iterator const&); // recursive_directory_iterator& operator=(recursive_directory_iterator const&);
#include "filesystem_include.hpp" #include "filesystem_include.h"
#include <type_traits> #include <type_traits>
#include <set> #include <set>
#include <cassert> #include <cassert>
#include "test_macros.h" #include "test_macros.h"
#include "rapid-cxx-test.hpp" #include "rapid-cxx-test.h"
#include "filesystem_test_helper.hpp" #include "filesystem_test_helper.h"
// The filesystem specification explicitly allows for self-move on // The filesystem specification explicitly allows for self-move on
// the directory iterators. Turn off this warning so we can test it. // the directory iterators. Turn off this warning so we can test it.
#if defined(__clang__) #if defined(__clang__)
#pragma clang diagnostic ignored "-Wself-move" #pragma clang diagnostic ignored "-Wself-move"
#endif #endif
using namespace fs; using namespace fs;
▲ Show 20 Lines • Show All 136 Lines • Show Last 20 Lines

libcxx/trunk/test/std/input.output/filesystems/class.rec.dir.itr/rec.dir.itr.members/pop.pass.cpp

Show All 9 Lines
// <filesystem> // <filesystem>
// class recursive_directory_iterator // class recursive_directory_iterator
// void pop(); // void pop();
// void pop(error_code& ec); // void pop(error_code& ec);
#include "filesystem_include.hpp" #include "filesystem_include.h"
#include <set> #include <set>
#include <cassert> #include <cassert>
#include "test_macros.h" #include "test_macros.h"
#include "rapid-cxx-test.hpp" #include "rapid-cxx-test.h"
#include "filesystem_test_helper.hpp" #include "filesystem_test_helper.h"
using namespace fs; using namespace fs;
TEST_SUITE(recursive_directory_iterator_pop_tests) TEST_SUITE(recursive_directory_iterator_pop_tests)
TEST_CASE(signature_tests) TEST_CASE(signature_tests)
{ {
recursive_directory_iterator it{}; ((void)it); recursive_directory_iterator it{}; ((void)it);
▲ Show 20 Lines • Show All 60 Lines • Show Last 20 Lines

libcxx/trunk/test/std/input.output/filesystems/class.rec.dir.itr/rec.dir.itr.members/recursion_pending.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++98, c++03 // UNSUPPORTED: c++98, c++03
// <filesystem> // <filesystem>
// class recursive_directory_iterator // class recursive_directory_iterator
// bool recursion_pending() const; // bool recursion_pending() const;
#include "filesystem_include.hpp" #include "filesystem_include.h"
#include <type_traits> #include <type_traits>
#include <set> #include <set>
#include <cassert> #include <cassert>
#include "test_macros.h" #include "test_macros.h"
#include "rapid-cxx-test.hpp" #include "rapid-cxx-test.h"
#include "filesystem_test_helper.hpp" #include "filesystem_test_helper.h"
using namespace fs; using namespace fs;
TEST_SUITE(recursive_directory_iterator_recursion_pending_tests) TEST_SUITE(recursive_directory_iterator_recursion_pending_tests)
TEST_CASE(initial_value_test) TEST_CASE(initial_value_test)
{ {
recursive_directory_iterator it(StaticEnv::Dir); recursive_directory_iterator it(StaticEnv::Dir);
▲ Show 20 Lines • Show All 129 Lines • Show Last 20 Lines

libcxx/trunk/test/std/input.output/filesystems/class.rec.dir.itr/rec.dir.itr.nonmembers/begin_end.pass.cpp

Show All 9 Lines
// <filesystem> // <filesystem>
// class recursive_directory_iterator // class recursive_directory_iterator
// recursive_directory_iterator begin(recursive_directory_iterator iter) noexcept; // recursive_directory_iterator begin(recursive_directory_iterator iter) noexcept;
// recursive_directory_iterator end(recursive_directory_iterator iter) noexcept; // recursive_directory_iterator end(recursive_directory_iterator iter) noexcept;
#include "filesystem_include.hpp" #include "filesystem_include.h"
#include <type_traits> #include <type_traits>
#include <set> #include <set>
#include <cassert> #include <cassert>
#include "test_macros.h" #include "test_macros.h"
#include "rapid-cxx-test.hpp" #include "rapid-cxx-test.h"
#include "filesystem_test_helper.hpp" #include "filesystem_test_helper.h"
#include <iostream> #include <iostream>
using namespace fs; using namespace fs;
TEST_SUITE(recursive_directory_iterator_begin_end_tests) TEST_SUITE(recursive_directory_iterator_begin_end_tests)
TEST_CASE(test_function_signatures) TEST_CASE(test_function_signatures)
{ {
Show All 26 Lines

libcxx/trunk/test/std/input.output/filesystems/fs.enum/enum.copy_options.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++98, c++03 // UNSUPPORTED: c++98, c++03
// <filesystem> // <filesystem>
// enum class copy_options; // enum class copy_options;
#include "filesystem_include.hpp" #include "filesystem_include.h"
#include <type_traits> #include <type_traits>
#include <cassert> #include <cassert>
#include "check_bitmask_types.hpp" #include "check_bitmask_types.hpp"
#include "test_macros.h" #include "test_macros.h"
constexpr fs::copy_options ME(int val) { return static_cast<fs::copy_options>(val); } constexpr fs::copy_options ME(int val) { return static_cast<fs::copy_options>(val); }
▲ Show 20 Lines • Show All 41 Lines • Show Last 20 Lines

libcxx/trunk/test/std/input.output/filesystems/fs.enum/enum.directory_options.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++98, c++03 // UNSUPPORTED: c++98, c++03
// <filesystem> // <filesystem>
// enum class directory_options; // enum class directory_options;
#include "filesystem_include.hpp" #include "filesystem_include.h"
#include <type_traits> #include <type_traits>
#include <cassert> #include <cassert>
#include <sys/stat.h> #include <sys/stat.h>
#include "test_macros.h" #include "test_macros.h"
#include "check_bitmask_types.hpp" #include "check_bitmask_types.hpp"
Show All 23 Lines

libcxx/trunk/test/std/input.output/filesystems/fs.enum/enum.file_type.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++98, c++03 // UNSUPPORTED: c++98, c++03
// <filesystem> // <filesystem>
// enum class file_type; // enum class file_type;
#include "filesystem_include.hpp" #include "filesystem_include.h"
#include <type_traits> #include <type_traits>
#include <cassert> #include <cassert>
#include "test_macros.h" #include "test_macros.h"
constexpr fs::file_type ME(int val) { return static_cast<fs::file_type>(val); } constexpr fs::file_type ME(int val) { return static_cast<fs::file_type>(val); }
Show All 25 Lines

libcxx/trunk/test/std/input.output/filesystems/fs.enum/enum.path.format.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++98, c++03 // UNSUPPORTED: c++98, c++03
// <filesystem> // <filesystem>
// class path; // class path;
// enum class format; // enum class format;
#include "filesystem_include.hpp" #include "filesystem_include.h"
#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**) {
typedef fs::path::format E; typedef fs::path::format E;
static_assert(std::is_enum<E>::value, ""); static_assert(std::is_enum<E>::value, "");
Show All 15 Lines

libcxx/trunk/test/std/input.output/filesystems/fs.enum/enum.perm_options.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++98, c++03 // UNSUPPORTED: c++98, c++03
// <filesystem> // <filesystem>
// enum class perm_options; // enum class perm_options;
#include "filesystem_include.hpp" #include "filesystem_include.h"
#include <type_traits> #include <type_traits>
#include <cassert> #include <cassert>
#include <sys/stat.h> #include <sys/stat.h>
#include "test_macros.h" #include "test_macros.h"
#include "check_bitmask_types.hpp" #include "check_bitmask_types.hpp"
Show All 26 Lines

libcxx/trunk/test/std/input.output/filesystems/fs.enum/enum.perms.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++98, c++03 // UNSUPPORTED: c++98, c++03
// <filesystem> // <filesystem>
// enum class perms; // enum class perms;
#include "filesystem_include.hpp" #include "filesystem_include.h"
#include <type_traits> #include <type_traits>
#include <cassert> #include <cassert>
#include <sys/stat.h> #include <sys/stat.h>
#include "test_macros.h" #include "test_macros.h"
#include "check_bitmask_types.hpp" #include "check_bitmask_types.hpp"
▲ Show 20 Lines • Show All 42 Lines • Show Last 20 Lines

libcxx/trunk/test/std/input.output/filesystems/fs.filesystem.synopsis/file_time_type.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++98, c++03 // UNSUPPORTED: c++98, c++03
// <filesystem> // <filesystem>
// typedef TrivialClock file_time_type; // typedef TrivialClock file_time_type;
#include "filesystem_include.hpp" #include "filesystem_include.h"
#include <chrono> #include <chrono>
#include <type_traits> #include <type_traits>
#include "test_macros.h" #include "test_macros.h"
// system_clock is used because it meets the requirements of TrivialClock, // system_clock is used because it meets the requirements of TrivialClock,
// and the resolution and range of system_clock should match the operating // and the resolution and range of system_clock should match the operating
// system's file time type. // system's file time type.
Show All 24 Lines

libcxx/trunk/test/std/input.output/filesystems/fs.op.funcs/fs.op.hard_lk_ct/hard_link_count.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++98, c++03 // UNSUPPORTED: c++98, c++03
// <filesystem> // <filesystem>
// uintmax_t hard_link_count(const path& p); // uintmax_t hard_link_count(const path& p);
// uintmax_t hard_link_count(const path& p, std::error_code& ec) noexcept; // uintmax_t hard_link_count(const path& p, std::error_code& ec) noexcept;
#include "filesystem_include.hpp" #include "filesystem_include.h"
#include <type_traits> #include <type_traits>
#include <cassert> #include <cassert>
#include "test_macros.h" #include "test_macros.h"
#include "rapid-cxx-test.hpp" #include "rapid-cxx-test.h"
#include "filesystem_test_helper.hpp" #include "filesystem_test_helper.h"
using namespace fs; using namespace fs;
TEST_SUITE(hard_link_count_test_suite) TEST_SUITE(hard_link_count_test_suite)
TEST_CASE(signature_test) TEST_CASE(signature_test)
{ {
const path p; ((void)p); const path p; ((void)p);
▲ Show 20 Lines • Show All 68 Lines • Show Last 20 Lines

libcxx/trunk/test/std/input.output/filesystems/fs.op.funcs/fs.op.absolute/absolute.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++98, c++03 // UNSUPPORTED: c++98, c++03
// <filesystem> // <filesystem>
// path absolute(const path& p, const path& base=current_path()); // path absolute(const path& p, const path& base=current_path());
#include "filesystem_include.hpp" #include "filesystem_include.h"
#include <type_traits> #include <type_traits>
#include <cassert> #include <cassert>
#include "test_macros.h" #include "test_macros.h"
#include "rapid-cxx-test.hpp" #include "rapid-cxx-test.h"
#include "filesystem_test_helper.hpp" #include "filesystem_test_helper.h"
using namespace fs; using namespace fs;
TEST_SUITE(filesystem_absolute_path_test_suite) TEST_SUITE(filesystem_absolute_path_test_suite)
TEST_CASE(absolute_signature_test) TEST_CASE(absolute_signature_test)
{ {
const path p; ((void)p); const path p; ((void)p);
Show All 28 Lines

libcxx/trunk/test/std/input.output/filesystems/fs.op.funcs/fs.op.canonical/canonical.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++98, c++03 // UNSUPPORTED: c++98, c++03
// <filesystem> // <filesystem>
// path canonical(const path& p); // path canonical(const path& p);
// path canonical(const path& p, error_code& ec); // path canonical(const path& p, error_code& ec);
#include "filesystem_include.hpp" #include "filesystem_include.h"
#include <type_traits> #include <type_traits>
#include <cassert> #include <cassert>
#include "test_macros.h" #include "test_macros.h"
#include "rapid-cxx-test.hpp" #include "rapid-cxx-test.h"
#include "filesystem_test_helper.hpp" #include "filesystem_test_helper.h"
using namespace fs; using namespace fs;
struct CWDGuard { struct CWDGuard {
path OldCWD; path OldCWD;
CWDGuard() : OldCWD(fs::current_path()) { } CWDGuard() : OldCWD(fs::current_path()) { }
~CWDGuard() { fs::current_path(OldCWD); } ~CWDGuard() { fs::current_path(OldCWD); }
▲ Show 20 Lines • Show All 93 Lines • Show Last 20 Lines

libcxx/trunk/test/std/input.output/filesystems/fs.op.funcs/fs.op.copy/copy.pass.cpp

Show All 10 Lines
// <filesystem> // <filesystem>
// void copy(const path& from, const path& to); // void copy(const path& from, const path& to);
// void copy(const path& from, const path& to, error_code& ec); // void copy(const path& from, const path& to, error_code& ec);
// void copy(const path& from, const path& to, copy_options options); // void copy(const path& from, const path& to, copy_options options);
// void copy(const path& from, const path& to, copy_options options, // void copy(const path& from, const path& to, copy_options options,
// error_code& ec); // error_code& ec);
#include "filesystem_include.hpp" #include "filesystem_include.h"
#include <type_traits> #include <type_traits>
#include <cstddef> #include <cstddef>
#include <cassert> #include <cassert>
#include "test_macros.h" #include "test_macros.h"
#include "rapid-cxx-test.hpp" #include "rapid-cxx-test.h"
#include "filesystem_test_helper.hpp" #include "filesystem_test_helper.h"
using namespace fs; using namespace fs;
using CO = fs::copy_options; using CO = fs::copy_options;
TEST_SUITE(filesystem_copy_test_suite) TEST_SUITE(filesystem_copy_test_suite)
TEST_CASE(signature_test) TEST_CASE(signature_test)
▲ Show 20 Lines • Show All 280 Lines • Show Last 20 Lines

libcxx/trunk/test/std/input.output/filesystems/fs.op.funcs/fs.op.copy_file/copy_file.pass.cpp

Show All 10 Lines
// <filesystem> // <filesystem>
// bool copy_file(const path& from, const path& to); // bool copy_file(const path& from, const path& to);
// bool copy_file(const path& from, const path& to, error_code& ec) noexcept; // bool copy_file(const path& from, const path& to, error_code& ec) noexcept;
// bool copy_file(const path& from, const path& to, copy_options options); // bool copy_file(const path& from, const path& to, copy_options options);
// bool copy_file(const path& from, const path& to, copy_options options, // bool copy_file(const path& from, const path& to, copy_options options,
// error_code& ec) noexcept; // error_code& ec) noexcept;
#include "filesystem_include.hpp" #include "filesystem_include.h"
#include <type_traits> #include <type_traits>
#include <chrono> #include <chrono>
#include <cassert> #include <cassert>
#include "test_macros.h" #include "test_macros.h"
#include "rapid-cxx-test.hpp" #include "rapid-cxx-test.h"
#include "filesystem_test_helper.hpp" #include "filesystem_test_helper.h"
#include <iostream> #include <iostream>
using namespace fs; using namespace fs;
using CO = fs::copy_options; using CO = fs::copy_options;
TEST_SUITE(filesystem_copy_file_test_suite) TEST_SUITE(filesystem_copy_file_test_suite)
▲ Show 20 Lines • Show All 154 Lines • Show Last 20 Lines

libcxx/trunk/test/std/input.output/filesystems/fs.op.funcs/fs.op.copy_file/copy_file_large.pass.cpp

Show All 11 Lines
// <filesystem> // <filesystem>
// bool copy_file(const path& from, const path& to); // bool copy_file(const path& from, const path& to);
// bool copy_file(const path& from, const path& to, error_code& ec) noexcept; // bool copy_file(const path& from, const path& to, error_code& ec) noexcept;
// bool copy_file(const path& from, const path& to, copy_options options); // bool copy_file(const path& from, const path& to, copy_options options);
// bool copy_file(const path& from, const path& to, copy_options options, // bool copy_file(const path& from, const path& to, copy_options options,
// error_code& ec) noexcept; // error_code& ec) noexcept;
#include "filesystem_include.hpp" #include "filesystem_include.h"
#include <type_traits> #include <type_traits>
#include <chrono> #include <chrono>
#include <cassert> #include <cassert>
#include "test_macros.h" #include "test_macros.h"
#include "rapid-cxx-test.hpp" #include "rapid-cxx-test.h"
#include "filesystem_test_helper.hpp" #include "filesystem_test_helper.h"
using namespace fs; using namespace fs;
TEST_SUITE(filesystem_copy_file_test_suite) TEST_SUITE(filesystem_copy_file_test_suite)
static std::string random_hex_chars(uintmax_t size) { static std::string random_hex_chars(uintmax_t size) {
std::string data; std::string data;
data.reserve(size); data.reserve(size);
▲ Show 20 Lines • Show All 63 Lines • Show Last 20 Lines

libcxx/trunk/test/std/input.output/filesystems/fs.op.funcs/fs.op.copy_symlink/copy_symlink.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++98, c++03 // UNSUPPORTED: c++98, c++03
// <filesystem> // <filesystem>
// void copy_symlink(const path& existing_symlink, const path& new_symlink); // void copy_symlink(const path& existing_symlink, const path& new_symlink);
// void copy_symlink(const path& existing_symlink, const path& new_symlink, // void copy_symlink(const path& existing_symlink, const path& new_symlink,
// error_code& ec) noexcept; // error_code& ec) noexcept;
#include "filesystem_include.hpp" #include "filesystem_include.h"
#include <type_traits> #include <type_traits>
#include <cassert> #include <cassert>
#include "test_macros.h" #include "test_macros.h"
#include "rapid-cxx-test.hpp" #include "rapid-cxx-test.h"
#include "filesystem_test_helper.hpp" #include "filesystem_test_helper.h"
using namespace fs; using namespace fs;
TEST_SUITE(filesystem_copy_symlink_test_suite) TEST_SUITE(filesystem_copy_symlink_test_suite)
TEST_CASE(test_signatures) TEST_CASE(test_signatures)
{ {
const path p; ((void)p); const path p; ((void)p);
▲ Show 20 Lines • Show All 76 Lines • Show Last 20 Lines

libcxx/trunk/test/std/input.output/filesystems/fs.op.funcs/fs.op.create_directories/create_directories.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++98, c++03 // UNSUPPORTED: c++98, c++03
// <filesystem> // <filesystem>
// bool create_directories(const path& p); // bool create_directories(const path& p);
// bool create_directories(const path& p, error_code& ec) noexcept; // bool create_directories(const path& p, error_code& ec) noexcept;
#include "filesystem_include.hpp" #include "filesystem_include.h"
#include <type_traits> #include <type_traits>
#include <cassert> #include <cassert>
#include "test_macros.h" #include "test_macros.h"
#include "rapid-cxx-test.hpp" #include "rapid-cxx-test.h"
#include "filesystem_test_helper.hpp" #include "filesystem_test_helper.h"
using namespace fs; using namespace fs;
TEST_SUITE(filesystem_create_directories_test_suite) TEST_SUITE(filesystem_create_directories_test_suite)
TEST_CASE(test_signatures) TEST_CASE(test_signatures)
{ {
const path p; ((void)p); const path p; ((void)p);
▲ Show 20 Lines • Show All 70 Lines • Show Last 20 Lines

libcxx/trunk/test/std/input.output/filesystems/fs.op.funcs/fs.op.create_directory/create_directory.pass.cpp

Show All 9 Lines
// <filesystem> // <filesystem>
// bool create_directory(const path& p); // bool create_directory(const path& p);
// bool create_directory(const path& p, error_code& ec) noexcept; // bool create_directory(const path& p, error_code& ec) noexcept;
// bool create_directory(const path& p, const path& attr); // bool create_directory(const path& p, const path& attr);
// bool create_directory(const path& p, const path& attr, error_code& ec) noexcept; // bool create_directory(const path& p, const path& attr, error_code& ec) noexcept;
#include "filesystem_include.hpp" #include "filesystem_include.h"
#include <type_traits> #include <type_traits>
#include <cassert> #include <cassert>
#include "test_macros.h" #include "test_macros.h"
#include "rapid-cxx-test.hpp" #include "rapid-cxx-test.h"
#include "filesystem_test_helper.hpp" #include "filesystem_test_helper.h"
#include <sys/types.h> #include <sys/types.h>
#include <sys/stat.h> #include <sys/stat.h>
using namespace fs; using namespace fs;
fs::perms read_umask() { fs::perms read_umask() {
mode_t old_mask = umask(0); mode_t old_mask = umask(0);
▲ Show 20 Lines • Show All 70 Lines • Show Last 20 Lines

libcxx/trunk/test/std/input.output/filesystems/fs.op.funcs/fs.op.create_directory/create_directory_with_attributes.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++98, c++03 // UNSUPPORTED: c++98, c++03
// <filesystem> // <filesystem>
// bool create_directory(const path& p, const path& attr); // bool create_directory(const path& p, const path& attr);
// bool create_directory(const path& p, const path& attr, error_code& ec) noexcept; // bool create_directory(const path& p, const path& attr, error_code& ec) noexcept;
#include "filesystem_include.hpp" #include "filesystem_include.h"
#include <type_traits> #include <type_traits>
#include <cassert> #include <cassert>
#include "test_macros.h" #include "test_macros.h"
#include "rapid-cxx-test.hpp" #include "rapid-cxx-test.h"
#include "filesystem_test_helper.hpp" #include "filesystem_test_helper.h"
using namespace fs; using namespace fs;
TEST_SUITE(filesystem_create_directory_test_suite) TEST_SUITE(filesystem_create_directory_test_suite)
TEST_CASE(test_signatures) TEST_CASE(test_signatures)
{ {
const path p; ((void)p); const path p; ((void)p);
▲ Show 20 Lines • Show All 101 Lines • Show Last 20 Lines

libcxx/trunk/test/std/input.output/filesystems/fs.op.funcs/fs.op.create_directory_symlink/create_directory_symlink.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++98, c++03 // UNSUPPORTED: c++98, c++03
// <filesystem> // <filesystem>
// void create_directory_symlink(const path& existing_symlink, const path& new_symlink); // void create_directory_symlink(const path& existing_symlink, const path& new_symlink);
// void create_directory_symlink(const path& existing_symlink, const path& new_symlink, // void create_directory_symlink(const path& existing_symlink, const path& new_symlink,
// error_code& ec) noexcept; // error_code& ec) noexcept;
#include "filesystem_include.hpp" #include "filesystem_include.h"
#include <cassert> #include <cassert>
#include "test_macros.h" #include "test_macros.h"
#include "rapid-cxx-test.hpp" #include "rapid-cxx-test.h"
#include "filesystem_test_helper.hpp" #include "filesystem_test_helper.h"
using namespace fs; using namespace fs;
TEST_SUITE(filesystem_create_directory_symlink_test_suite) TEST_SUITE(filesystem_create_directory_symlink_test_suite)
TEST_CASE(test_signatures) TEST_CASE(test_signatures)
{ {
const path p; ((void)p); const path p; ((void)p);
Show All 34 Lines

libcxx/trunk/test/std/input.output/filesystems/fs.op.funcs/fs.op.create_hard_link/create_hard_link.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++98, c++03 // UNSUPPORTED: c++98, c++03
// <filesystem> // <filesystem>
// void create_hard_link(const path& existing_symlink, const path& new_symlink); // void create_hard_link(const path& existing_symlink, const path& new_symlink);
// void create_hard_link(const path& existing_symlink, const path& new_symlink, // void create_hard_link(const path& existing_symlink, const path& new_symlink,
// error_code& ec) noexcept; // error_code& ec) noexcept;
#include "filesystem_include.hpp" #include "filesystem_include.h"
#include "test_macros.h" #include "test_macros.h"
#include "rapid-cxx-test.hpp" #include "rapid-cxx-test.h"
#include "filesystem_test_helper.hpp" #include "filesystem_test_helper.h"
using namespace fs; using namespace fs;
TEST_SUITE(filesystem_create_hard_link_test_suite) TEST_SUITE(filesystem_create_hard_link_test_suite)
TEST_CASE(test_signatures) TEST_CASE(test_signatures)
{ {
const path p; ((void)p); const path p; ((void)p);
▲ Show 20 Lines • Show All 44 Lines • Show Last 20 Lines

libcxx/trunk/test/std/input.output/filesystems/fs.op.funcs/fs.op.create_symlink/create_symlink.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++98, c++03 // UNSUPPORTED: c++98, c++03
// <filesystem> // <filesystem>
// void create_symlink(const path& existing_symlink, const path& new_symlink); // void create_symlink(const path& existing_symlink, const path& new_symlink);
// void create_symlink(const path& existing_symlink, const path& new_symlink, // void create_symlink(const path& existing_symlink, const path& new_symlink,
// error_code& ec) noexcept; // error_code& ec) noexcept;
#include "filesystem_include.hpp" #include "filesystem_include.h"
#include <cassert> #include <cassert>
#include "test_macros.h" #include "test_macros.h"
#include "rapid-cxx-test.hpp" #include "rapid-cxx-test.h"
#include "filesystem_test_helper.hpp" #include "filesystem_test_helper.h"
using namespace fs; using namespace fs;
TEST_SUITE(filesystem_create_symlink_test_suite) TEST_SUITE(filesystem_create_symlink_test_suite)
TEST_CASE(test_signatures) TEST_CASE(test_signatures)
{ {
const path p; ((void)p); const path p; ((void)p);
▲ Show 20 Lines • Show All 45 Lines • Show Last 20 Lines

libcxx/trunk/test/std/input.output/filesystems/fs.op.funcs/fs.op.current_path/current_path.pass.cpp

Show All 9 Lines
// <filesystem> // <filesystem>
// path current_path(); // path current_path();
// path current_path(error_code& ec); // path current_path(error_code& ec);
// void current_path(path const&); // void current_path(path const&);
// void current_path(path const&, std::error_code& ec) noexcept; // void current_path(path const&, std::error_code& ec) noexcept;
#include "filesystem_include.hpp" #include "filesystem_include.h"
#include <type_traits> #include <type_traits>
#include <cassert> #include <cassert>
#include "test_macros.h" #include "test_macros.h"
#include "rapid-cxx-test.hpp" #include "rapid-cxx-test.h"
#include "filesystem_test_helper.hpp" #include "filesystem_test_helper.h"
using namespace fs; using namespace fs;
TEST_SUITE(filesystem_current_path_path_test_suite) TEST_SUITE(filesystem_current_path_path_test_suite)
TEST_CASE(current_path_signature_test) TEST_CASE(current_path_signature_test)
{ {
const path p; ((void)p); const path p; ((void)p);
▲ Show 20 Lines • Show All 60 Lines • Show Last 20 Lines

libcxx/trunk/test/std/input.output/filesystems/fs.op.funcs/fs.op.equivalent/equivalent.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++98, c++03 // UNSUPPORTED: c++98, c++03
// <filesystem> // <filesystem>
// bool equivalent(path const& lhs, path const& rhs); // bool equivalent(path const& lhs, path const& rhs);
// bool equivalent(path const& lhs, path const& rhs, std::error_code& ec) noexcept; // bool equivalent(path const& lhs, path const& rhs, std::error_code& ec) noexcept;
#include "filesystem_include.hpp" #include "filesystem_include.h"
#include <type_traits> #include <type_traits>
#include <cassert> #include <cassert>
#include "test_macros.h" #include "test_macros.h"
#include "rapid-cxx-test.hpp" #include "rapid-cxx-test.h"
#include "filesystem_test_helper.hpp" #include "filesystem_test_helper.h"
using namespace fs; using namespace fs;
TEST_SUITE(equivalent_test_suite) TEST_SUITE(equivalent_test_suite)
TEST_CASE(signature_test) { TEST_CASE(signature_test) {
const path p; const path p;
((void)p); ((void)p);
▲ Show 20 Lines • Show All 81 Lines • Show Last 20 Lines

libcxx/trunk/test/std/input.output/filesystems/fs.op.funcs/fs.op.exists/exists.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++98, c++03 // UNSUPPORTED: c++98, c++03
// <filesystem> // <filesystem>
// bool exists(file_status s) noexcept // bool exists(file_status s) noexcept
// bool exists(path const& p); // bool exists(path const& p);
// bool exists(path const& p, std::error_code& ec) noexcept; // bool exists(path const& p, std::error_code& ec) noexcept;
#include "filesystem_include.hpp" #include "filesystem_include.h"
#include <type_traits> #include <type_traits>
#include <cassert> #include <cassert>
#include "test_macros.h" #include "test_macros.h"
#include "rapid-cxx-test.hpp" #include "rapid-cxx-test.h"
#include "filesystem_test_helper.hpp" #include "filesystem_test_helper.h"
using namespace fs; using namespace fs;
TEST_SUITE(exists_test_suite) TEST_SUITE(exists_test_suite)
TEST_CASE(signature_test) TEST_CASE(signature_test)
{ {
file_status s; ((void)s); file_status s; ((void)s);
▲ Show 20 Lines • Show All 65 Lines • Show Last 20 Lines

libcxx/trunk/test/std/input.output/filesystems/fs.op.funcs/fs.op.file_size/file_size.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++98, c++03 // UNSUPPORTED: c++98, c++03
// <filesystem> // <filesystem>
// uintmax_t file_size(const path& p); // uintmax_t file_size(const path& p);
// uintmax_t file_size(const path& p, std::error_code& ec) noexcept; // uintmax_t file_size(const path& p, std::error_code& ec) noexcept;
#include "filesystem_include.hpp" #include "filesystem_include.h"
#include <type_traits> #include <type_traits>
#include <cassert> #include <cassert>
#include "test_macros.h" #include "test_macros.h"
#include "rapid-cxx-test.hpp" #include "rapid-cxx-test.h"
#include "filesystem_test_helper.hpp" #include "filesystem_test_helper.h"
using namespace fs; using namespace fs;
TEST_SUITE(file_size_test_suite) TEST_SUITE(file_size_test_suite)
TEST_CASE(signature_test) TEST_CASE(signature_test)
{ {
const path p; ((void)p); const path p; ((void)p);
▲ Show 20 Lines • Show All 54 Lines • Show Last 20 Lines

libcxx/trunk/test/std/input.output/filesystems/fs.op.funcs/fs.op.is_block_file/is_block_file.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++98, c++03 // UNSUPPORTED: c++98, c++03
// <filesystem> // <filesystem>
// bool is_block_file(file_status s) noexcept // bool is_block_file(file_status s) noexcept
// bool is_block_file(path const& p); // bool is_block_file(path const& p);
// bool is_block_file(path const& p, std::error_code& ec) noexcept; // bool is_block_file(path const& p, std::error_code& ec) noexcept;
#include "filesystem_include.hpp" #include "filesystem_include.h"
#include <type_traits> #include <type_traits>
#include <cassert> #include <cassert>
#include "test_macros.h" #include "test_macros.h"
#include "rapid-cxx-test.hpp" #include "rapid-cxx-test.h"
#include "filesystem_test_helper.hpp" #include "filesystem_test_helper.h"
using namespace fs; using namespace fs;
TEST_SUITE(is_block_file_test_suite) TEST_SUITE(is_block_file_test_suite)
TEST_CASE(signature_test) TEST_CASE(signature_test)
{ {
file_status s; ((void)s); file_status s; ((void)s);
▲ Show 20 Lines • Show All 52 Lines • Show Last 20 Lines

libcxx/trunk/test/std/input.output/filesystems/fs.op.funcs/fs.op.is_char_file/is_character_file.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++98, c++03 // UNSUPPORTED: c++98, c++03
// <filesystem> // <filesystem>
// bool is_character_file(file_status s) noexcept // bool is_character_file(file_status s) noexcept
// bool is_character_file(path const& p); // bool is_character_file(path const& p);
// bool is_character_file(path const& p, std::error_code& ec) noexcept; // bool is_character_file(path const& p, std::error_code& ec) noexcept;
#include "filesystem_include.hpp" #include "filesystem_include.h"
#include <type_traits> #include <type_traits>
#include <cassert> #include <cassert>
#include "test_macros.h" #include "test_macros.h"
#include "rapid-cxx-test.hpp" #include "rapid-cxx-test.h"
#include "filesystem_test_helper.hpp" #include "filesystem_test_helper.h"
using namespace fs; using namespace fs;
TEST_SUITE(is_character_file_test_suite) TEST_SUITE(is_character_file_test_suite)
TEST_CASE(signature_test) TEST_CASE(signature_test)
{ {
file_status s; ((void)s); file_status s; ((void)s);
▲ Show 20 Lines • Show All 52 Lines • Show Last 20 Lines

libcxx/trunk/test/std/input.output/filesystems/fs.op.funcs/fs.op.is_directory/is_directory.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++98, c++03 // UNSUPPORTED: c++98, c++03
// <filesystem> // <filesystem>
// bool is_directory(file_status s) noexcept // bool is_directory(file_status s) noexcept
// bool is_directory(path const& p); // bool is_directory(path const& p);
// bool is_directory(path const& p, std::error_code& ec) noexcept; // bool is_directory(path const& p, std::error_code& ec) noexcept;
#include "filesystem_include.hpp" #include "filesystem_include.h"
#include <type_traits> #include <type_traits>
#include <cassert> #include <cassert>
#include "test_macros.h" #include "test_macros.h"
#include "rapid-cxx-test.hpp" #include "rapid-cxx-test.h"
#include "filesystem_test_helper.hpp" #include "filesystem_test_helper.h"
using namespace fs; using namespace fs;
TEST_SUITE(is_directory_test_suite) TEST_SUITE(is_directory_test_suite)
TEST_CASE(signature_test) TEST_CASE(signature_test)
{ {
file_status s; ((void)s); file_status s; ((void)s);
▲ Show 20 Lines • Show All 59 Lines • Show Last 20 Lines

libcxx/trunk/test/std/input.output/filesystems/fs.op.funcs/fs.op.is_empty/is_empty.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++98, c++03 // UNSUPPORTED: c++98, c++03
// <filesystem> // <filesystem>
// bool is_empty(path const& p); // bool is_empty(path const& p);
// bool is_empty(path const& p, std::error_code& ec); // bool is_empty(path const& p, std::error_code& ec);
#include "filesystem_include.hpp" #include "filesystem_include.h"
#include <type_traits> #include <type_traits>
#include <cassert> #include <cassert>
#include "test_macros.h" #include "test_macros.h"
#include "rapid-cxx-test.hpp" #include "rapid-cxx-test.h"
#include "filesystem_test_helper.hpp" #include "filesystem_test_helper.h"
using namespace fs; using namespace fs;
TEST_SUITE(is_empty_test_suite) TEST_SUITE(is_empty_test_suite)
TEST_CASE(signature_test) TEST_CASE(signature_test)
{ {
const path p; ((void)p); const path p; ((void)p);
▲ Show 20 Lines • Show All 78 Lines • Show Last 20 Lines

libcxx/trunk/test/std/input.output/filesystems/fs.op.funcs/fs.op.is_fifo/is_fifo.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++98, c++03 // UNSUPPORTED: c++98, c++03
// <filesystem> // <filesystem>
// bool is_fifo(file_status s) noexcept // bool is_fifo(file_status s) noexcept
// bool is_fifo(path const& p); // bool is_fifo(path const& p);
// bool is_fifo(path const& p, std::error_code& ec) noexcept; // bool is_fifo(path const& p, std::error_code& ec) noexcept;
#include "filesystem_include.hpp" #include "filesystem_include.h"
#include <type_traits> #include <type_traits>
#include <cassert> #include <cassert>
#include "test_macros.h" #include "test_macros.h"
#include "rapid-cxx-test.hpp" #include "rapid-cxx-test.h"
#include "filesystem_test_helper.hpp" #include "filesystem_test_helper.h"
using namespace fs; using namespace fs;
TEST_SUITE(is_fifo_test_suite) TEST_SUITE(is_fifo_test_suite)
TEST_CASE(signature_test) TEST_CASE(signature_test)
{ {
file_status s; ((void)s); file_status s; ((void)s);
▲ Show 20 Lines • Show All 52 Lines • Show Last 20 Lines

libcxx/trunk/test/std/input.output/filesystems/fs.op.funcs/fs.op.is_other/is_other.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++98, c++03 // UNSUPPORTED: c++98, c++03
// <filesystem> // <filesystem>
// bool is_other(file_status s) noexcept // bool is_other(file_status s) noexcept
// bool is_other(path const& p); // bool is_other(path const& p);
// bool is_other(path const& p, std::error_code& ec) noexcept; // bool is_other(path const& p, std::error_code& ec) noexcept;
#include "filesystem_include.hpp" #include "filesystem_include.h"
#include <type_traits> #include <type_traits>
#include <cassert> #include <cassert>
#include "test_macros.h" #include "test_macros.h"
#include "rapid-cxx-test.hpp" #include "rapid-cxx-test.h"
#include "filesystem_test_helper.hpp" #include "filesystem_test_helper.h"
using namespace fs; using namespace fs;
TEST_SUITE(is_other_test_suite) TEST_SUITE(is_other_test_suite)
TEST_CASE(signature_test) TEST_CASE(signature_test)
{ {
file_status s; ((void)s); file_status s; ((void)s);
▲ Show 20 Lines • Show All 52 Lines • Show Last 20 Lines

libcxx/trunk/test/std/input.output/filesystems/fs.op.funcs/fs.op.is_regular_file/is_regular_file.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++98, c++03 // UNSUPPORTED: c++98, c++03
// <filesystem> // <filesystem>
// bool is_regular_file(file_status s) noexcept // bool is_regular_file(file_status s) noexcept
// bool is_regular_file(path const& p); // bool is_regular_file(path const& p);
// bool is_regular_file(path const& p, std::error_code& ec) noexcept; // bool is_regular_file(path const& p, std::error_code& ec) noexcept;
#include "filesystem_include.hpp" #include "filesystem_include.h"
#include <type_traits> #include <type_traits>
#include <cassert> #include <cassert>
#include "test_macros.h" #include "test_macros.h"
#include "rapid-cxx-test.hpp" #include "rapid-cxx-test.h"
#include "filesystem_test_helper.hpp" #include "filesystem_test_helper.h"
using namespace fs; using namespace fs;
TEST_SUITE(is_regular_file_test_suite) TEST_SUITE(is_regular_file_test_suite)
TEST_CASE(signature_test) TEST_CASE(signature_test)
{ {
file_status s; ((void)s); file_status s; ((void)s);
▲ Show 20 Lines • Show All 55 Lines • Show Last 20 Lines

libcxx/trunk/test/std/input.output/filesystems/fs.op.funcs/fs.op.is_socket/is_socket.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++98, c++03 // UNSUPPORTED: c++98, c++03
// <filesystem> // <filesystem>
// bool is_socket(file_status s) noexcept // bool is_socket(file_status s) noexcept
// bool is_socket(path const& p); // bool is_socket(path const& p);
// bool is_socket(path const& p, std::error_code& ec) noexcept; // bool is_socket(path const& p, std::error_code& ec) noexcept;
#include "filesystem_include.hpp" #include "filesystem_include.h"
#include <type_traits> #include <type_traits>
#include <cassert> #include <cassert>
#include "test_macros.h" #include "test_macros.h"
#include "rapid-cxx-test.hpp" #include "rapid-cxx-test.h"
#include "filesystem_test_helper.hpp" #include "filesystem_test_helper.h"
using namespace fs; using namespace fs;
TEST_SUITE(is_socket_test_suite) TEST_SUITE(is_socket_test_suite)
TEST_CASE(signature_test) TEST_CASE(signature_test)
{ {
file_status s; ((void)s); file_status s; ((void)s);
▲ Show 20 Lines • Show All 52 Lines • Show Last 20 Lines

libcxx/trunk/test/std/input.output/filesystems/fs.op.funcs/fs.op.is_symlink/is_symlink.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++98, c++03 // UNSUPPORTED: c++98, c++03
// <filesystem> // <filesystem>
// bool is_symlink(file_status s) noexcept // bool is_symlink(file_status s) noexcept
// bool is_symlink(path const& p); // bool is_symlink(path const& p);
// bool is_symlink(path const& p, std::error_code& ec) noexcept; // bool is_symlink(path const& p, std::error_code& ec) noexcept;
#include "filesystem_include.hpp" #include "filesystem_include.h"
#include <type_traits> #include <type_traits>
#include <cassert> #include <cassert>
#include "test_macros.h" #include "test_macros.h"
#include "rapid-cxx-test.hpp" #include "rapid-cxx-test.h"
#include "filesystem_test_helper.hpp" #include "filesystem_test_helper.h"
using namespace fs; using namespace fs;
TEST_SUITE(is_symlink_test_suite) TEST_SUITE(is_symlink_test_suite)
TEST_CASE(signature_test) TEST_CASE(signature_test)
{ {
file_status s; ((void)s); file_status s; ((void)s);
▲ Show 20 Lines • Show All 73 Lines • Show Last 20 Lines

libcxx/trunk/test/std/input.output/filesystems/fs.op.funcs/fs.op.last_write_time/last_write_time.pass.cpp

Show All 10 Lines
// <filesystem> // <filesystem>
// file_time_type last_write_time(const path& p); // file_time_type last_write_time(const path& p);
// file_time_type last_write_time(const path& p, std::error_code& ec) noexcept; // file_time_type last_write_time(const path& p, std::error_code& ec) noexcept;
// void last_write_time(const path& p, file_time_type new_time); // void last_write_time(const path& p, file_time_type new_time);
// void last_write_time(const path& p, file_time_type new_type, // void last_write_time(const path& p, file_time_type new_type,
// std::error_code& ec) noexcept; // std::error_code& ec) noexcept;
#include "filesystem_include.hpp" #include "filesystem_include.h"
#include <type_traits> #include <type_traits>
#include <chrono> #include <chrono>
#include <fstream> #include <fstream>
#include <cstdlib> #include <cstdlib>
#include "test_macros.h" #include "test_macros.h"
#include "rapid-cxx-test.hpp" #include "rapid-cxx-test.h"
#include "filesystem_test_helper.hpp" #include "filesystem_test_helper.h"
#include <sys/stat.h> #include <sys/stat.h>
#include <iostream> #include <iostream>
#include <fcntl.h> #include <fcntl.h>
#include <sys/time.h> #include <sys/time.h>
using namespace fs; using namespace fs;
▲ Show 20 Lines • Show All 553 Lines • Show Last 20 Lines

libcxx/trunk/test/std/input.output/filesystems/fs.op.funcs/fs.op.permissions/permissions.pass.cpp

Show All 11 Lines
// void permissions(const path& p, perms prms, // void permissions(const path& p, perms prms,
// perm_options opts = perm_options::replace); // perm_options opts = perm_options::replace);
// void permissions(const path& p, perms prms, std::error_code& ec) noexcept; // void permissions(const path& p, perms prms, std::error_code& ec) noexcept;
// void permissions(const path& p, perms prms, perm_options opts, std::error_code); // void permissions(const path& p, perms prms, perm_options opts, std::error_code);
#include "filesystem_include.hpp" #include "filesystem_include.h"
#include "test_macros.h" #include "test_macros.h"
#include "rapid-cxx-test.hpp" #include "rapid-cxx-test.h"
#include "filesystem_test_helper.hpp" #include "filesystem_test_helper.h"
using namespace fs; using namespace fs;
using PR = fs::perms; using PR = fs::perms;
TEST_SUITE(filesystem_permissions_test_suite) TEST_SUITE(filesystem_permissions_test_suite)
TEST_CASE(test_signatures) TEST_CASE(test_signatures)
▲ Show 20 Lines • Show All 149 Lines • Show Last 20 Lines

libcxx/trunk/test/std/input.output/filesystems/fs.op.funcs/fs.op.proximate/proximate.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++98, c++03 // UNSUPPORTED: c++98, c++03
// <filesystem> // <filesystem>
// path proximate(const path& p, error_code &ec) // path proximate(const path& p, error_code &ec)
// path proximate(const path& p, const path& base = current_path()) // path proximate(const path& p, const path& base = current_path())
// path proximate(const path& p, const path& base, error_code& ec); // path proximate(const path& p, const path& base, error_code& ec);
#include "filesystem_include.hpp" #include "filesystem_include.h"
#include <type_traits> #include <type_traits>
#include <vector> #include <vector>
#include <iostream> #include <iostream>
#include <cassert> #include <cassert>
#include "test_macros.h" #include "test_macros.h"
#include "test_iterators.h" #include "test_iterators.h"
#include "count_new.hpp" #include "count_new.h"
#include "rapid-cxx-test.hpp" #include "rapid-cxx-test.h"
#include "filesystem_test_helper.hpp" #include "filesystem_test_helper.h"
static int count_path_elems(const fs::path& p) { static int count_path_elems(const fs::path& p) {
int count = 0; int count = 0;
for (auto& elem : p) { for (auto& elem : p) {
if (elem != "/" && elem != "") if (elem != "/" && elem != "")
++count; ++count;
} }
▲ Show 20 Lines • Show All 97 Lines • Show Last 20 Lines

libcxx/trunk/test/std/input.output/filesystems/fs.op.funcs/fs.op.read_symlink/read_symlink.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++98, c++03 // UNSUPPORTED: c++98, c++03
// <filesystem> // <filesystem>
// path read_symlink(const path& p); // path read_symlink(const path& p);
// path read_symlink(const path& p, error_code& ec); // path read_symlink(const path& p, error_code& ec);
#include "filesystem_include.hpp" #include "filesystem_include.h"
#include "test_macros.h" #include "test_macros.h"
#include "rapid-cxx-test.hpp" #include "rapid-cxx-test.h"
#include "filesystem_test_helper.hpp" #include "filesystem_test_helper.h"
using namespace fs; using namespace fs;
TEST_SUITE(filesystem_read_symlink_test_suite) TEST_SUITE(filesystem_read_symlink_test_suite)
TEST_CASE(test_signatures) TEST_CASE(test_signatures)
{ {
const path p; ((void)p); const path p; ((void)p);
▲ Show 20 Lines • Show All 71 Lines • Show Last 20 Lines

libcxx/trunk/test/std/input.output/filesystems/fs.op.funcs/fs.op.relative/relative.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++98, c++03 // UNSUPPORTED: c++98, c++03
// <filesystem> // <filesystem>
// path proximate(const path& p, error_code &ec) // path proximate(const path& p, error_code &ec)
// path proximate(const path& p, const path& base = current_path()) // path proximate(const path& p, const path& base = current_path())
// path proximate(const path& p, const path& base, error_code& ec); // path proximate(const path& p, const path& base, error_code& ec);
#include "filesystem_include.hpp" #include "filesystem_include.h"
#include <string> #include <string>
#include <type_traits> #include <type_traits>
#include <cassert> #include <cassert>
#include "test_macros.h" #include "test_macros.h"
#include "test_iterators.h" #include "test_iterators.h"
#include "count_new.hpp" #include "count_new.h"
#include "rapid-cxx-test.hpp" #include "rapid-cxx-test.h"
#include "filesystem_test_helper.hpp" #include "filesystem_test_helper.h"
TEST_SUITE(filesystem_proximate_path_test_suite) TEST_SUITE(filesystem_proximate_path_test_suite)
TEST_CASE(test_signature_0) { TEST_CASE(test_signature_0) {
fs::path p(""); fs::path p("");
const fs::path output = fs::weakly_canonical(p); const fs::path output = fs::weakly_canonical(p);
TEST_CHECK(output == std::string(fs::current_path())); TEST_CHECK(output == std::string(fs::current_path()));
▲ Show 20 Lines • Show All 83 Lines • Show Last 20 Lines

libcxx/trunk/test/std/input.output/filesystems/fs.op.funcs/fs.op.remove/remove.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++98, c++03 // UNSUPPORTED: c++98, c++03
// <filesystem> // <filesystem>
// bool remove(const path& p); // bool remove(const path& p);
// bool remove(const path& p, error_code& ec) noexcept; // bool remove(const path& p, error_code& ec) noexcept;
#include "filesystem_include.hpp" #include "filesystem_include.h"
#include "test_macros.h" #include "test_macros.h"
#include "rapid-cxx-test.hpp" #include "rapid-cxx-test.h"
#include "filesystem_test_helper.hpp" #include "filesystem_test_helper.h"
using namespace fs; using namespace fs;
TEST_SUITE(filesystem_remove_test_suite) TEST_SUITE(filesystem_remove_test_suite)
TEST_CASE(test_signatures) TEST_CASE(test_signatures)
{ {
const path p; ((void)p); const path p; ((void)p);
▲ Show 20 Lines • Show All 80 Lines • Show Last 20 Lines

libcxx/trunk/test/std/input.output/filesystems/fs.op.funcs/fs.op.remove_all/remove_all.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++98, c++03 // UNSUPPORTED: c++98, c++03
// <filesystem> // <filesystem>
// uintmax_t remove_all(const path& p); // uintmax_t remove_all(const path& p);
// uintmax_t remove_all(const path& p, error_code& ec) noexcept; // uintmax_t remove_all(const path& p, error_code& ec) noexcept;
#include "filesystem_include.hpp" #include "filesystem_include.h"
#include "test_macros.h" #include "test_macros.h"
#include "rapid-cxx-test.hpp" #include "rapid-cxx-test.h"
#include "filesystem_test_helper.hpp" #include "filesystem_test_helper.h"
using namespace fs; using namespace fs;
TEST_SUITE(filesystem_remove_all_test_suite) TEST_SUITE(filesystem_remove_all_test_suite)
TEST_CASE(test_signatures) TEST_CASE(test_signatures)
{ {
const path p; ((void)p); const path p; ((void)p);
▲ Show 20 Lines • Show All 124 Lines • Show Last 20 Lines

libcxx/trunk/test/std/input.output/filesystems/fs.op.funcs/fs.op.rename/rename.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++98, c++03 // UNSUPPORTED: c++98, c++03
// <filesystem> // <filesystem>
// void rename(const path& old_p, const path& new_p); // void rename(const path& old_p, const path& new_p);
// void rename(const path& old_p, const path& new_p, error_code& ec) noexcept; // void rename(const path& old_p, const path& new_p, error_code& ec) noexcept;
#include "filesystem_include.hpp" #include "filesystem_include.h"
#include "test_macros.h" #include "test_macros.h"
#include "rapid-cxx-test.hpp" #include "rapid-cxx-test.h"
#include "filesystem_test_helper.hpp" #include "filesystem_test_helper.h"
using namespace fs; using namespace fs;
TEST_SUITE(filesystem_rename_test_suite) TEST_SUITE(filesystem_rename_test_suite)
TEST_CASE(test_signatures) TEST_CASE(test_signatures)
{ {
const path p; ((void)p); const path p; ((void)p);
▲ Show 20 Lines • Show All 96 Lines • Show Last 20 Lines

libcxx/trunk/test/std/input.output/filesystems/fs.op.funcs/fs.op.resize_file/resize_file.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++98, c++03 // UNSUPPORTED: c++98, c++03
// <filesystem> // <filesystem>
// void resize_file(const path& p, uintmax_t new_size); // void resize_file(const path& p, uintmax_t new_size);
// void resize_file(const path& p, uintmax_t new_size, error_code& ec) noexcept; // void resize_file(const path& p, uintmax_t new_size, error_code& ec) noexcept;
#include "filesystem_include.hpp" #include "filesystem_include.h"
#include "test_macros.h" #include "test_macros.h"
#include "rapid-cxx-test.hpp" #include "rapid-cxx-test.h"
#include "filesystem_test_helper.hpp" #include "filesystem_test_helper.h"
using namespace fs; using namespace fs;
TEST_SUITE(filesystem_resize_file_test_suite) TEST_SUITE(filesystem_resize_file_test_suite)
TEST_CASE(test_signatures) TEST_CASE(test_signatures)
{ {
const path p; ((void)p); const path p; ((void)p);
▲ Show 20 Lines • Show All 80 Lines • Show Last 20 Lines

libcxx/trunk/test/std/input.output/filesystems/fs.op.funcs/fs.op.space/space.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++98, c++03 // UNSUPPORTED: c++98, c++03
// <filesystem> // <filesystem>
// space_info space(const path& p); // space_info space(const path& p);
// space_info space(const path& p, error_code& ec) noexcept; // space_info space(const path& p, error_code& ec) noexcept;
#include "filesystem_include.hpp" #include "filesystem_include.h"
#include <sys/statvfs.h> #include <sys/statvfs.h>
#include "test_macros.h" #include "test_macros.h"
#include "rapid-cxx-test.hpp" #include "rapid-cxx-test.h"
#include "filesystem_test_helper.hpp" #include "filesystem_test_helper.h"
using namespace fs; using namespace fs;
bool EqualDelta(std::uintmax_t x, std::uintmax_t y, std::uintmax_t delta) { bool EqualDelta(std::uintmax_t x, std::uintmax_t y, std::uintmax_t delta) {
if (x >= y) { if (x >= y) {
return (x - y) <= delta; return (x - y) <= delta;
} else { } else {
return (y - x) <= delta; return (y - x) <= delta;
▲ Show 20 Lines • Show All 98 Lines • Show Last 20 Lines

libcxx/trunk/test/std/input.output/filesystems/fs.op.funcs/fs.op.status/status.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++98, c++03 // UNSUPPORTED: c++98, c++03
// <filesystem> // <filesystem>
// file_status status(const path& p); // file_status status(const path& p);
// file_status status(const path& p, error_code& ec) noexcept; // file_status status(const path& p, error_code& ec) noexcept;
#include "filesystem_include.hpp" #include "filesystem_include.h"
#include "test_macros.h" #include "test_macros.h"
#include "rapid-cxx-test.hpp" #include "rapid-cxx-test.h"
#include "filesystem_test_helper.hpp" #include "filesystem_test_helper.h"
using namespace fs; using namespace fs;
TEST_SUITE(filesystem_status_test_suite) TEST_SUITE(filesystem_status_test_suite)
TEST_CASE(signature_test) TEST_CASE(signature_test)
{ {
const path p; ((void)p); const path p; ((void)p);
▲ Show 20 Lines • Show All 137 Lines • Show Last 20 Lines

libcxx/trunk/test/std/input.output/filesystems/fs.op.funcs/fs.op.status_known/status_known.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++98, c++03 // UNSUPPORTED: c++98, c++03
// <filesystem> // <filesystem>
// bool status_known(file_status s) noexcept; // bool status_known(file_status s) noexcept;
#include "filesystem_include.hpp" #include "filesystem_include.h"
#include <type_traits> #include <type_traits>
#include <cassert> #include <cassert>
#include "test_macros.h" #include "test_macros.h"
#include "rapid-cxx-test.hpp" #include "rapid-cxx-test.h"
#include "filesystem_test_helper.hpp" #include "filesystem_test_helper.h"
using namespace fs; using namespace fs;
TEST_SUITE(status_known_test_suite) TEST_SUITE(status_known_test_suite)
TEST_CASE(signature_test) TEST_CASE(signature_test)
{ {
file_status s; ((void)s); file_status s; ((void)s);
Show All 29 Lines

libcxx/trunk/test/std/input.output/filesystems/fs.op.funcs/fs.op.symlink_status/symlink_status.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++98, c++03 // UNSUPPORTED: c++98, c++03
// <filesystem> // <filesystem>
// file_status symlink_status(const path& p); // file_status symlink_status(const path& p);
// file_status symlink_status(const path& p, error_code& ec) noexcept; // file_status symlink_status(const path& p, error_code& ec) noexcept;
#include "filesystem_include.hpp" #include "filesystem_include.h"
#include "test_macros.h" #include "test_macros.h"
#include "rapid-cxx-test.hpp" #include "rapid-cxx-test.h"
#include "filesystem_test_helper.hpp" #include "filesystem_test_helper.h"
using namespace fs; using namespace fs;
TEST_SUITE(filesystem_symlink_status_test_suite) TEST_SUITE(filesystem_symlink_status_test_suite)
TEST_CASE(signature_test) TEST_CASE(signature_test)
{ {
const path p; ((void)p); const path p; ((void)p);
▲ Show 20 Lines • Show All 163 Lines • Show Last 20 Lines

libcxx/trunk/test/std/input.output/filesystems/fs.op.funcs/fs.op.temp_dir_path/temp_directory_path.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++98, c++03 // UNSUPPORTED: c++98, c++03
// <filesystem> // <filesystem>
// path temp_directory_path(); // path temp_directory_path();
// path temp_directory_path(error_code& ec); // path temp_directory_path(error_code& ec);
#include "filesystem_include.hpp" #include "filesystem_include.h"
#include <memory> #include <memory>
#include <cstdlib> #include <cstdlib>
#include <cstring> #include <cstring>
#include <cassert> #include <cassert>
#include "test_macros.h" #include "test_macros.h"
#include "rapid-cxx-test.hpp" #include "rapid-cxx-test.h"
#include "filesystem_test_helper.hpp" #include "filesystem_test_helper.h"
using namespace fs; using namespace fs;
void PutEnv(std::string var, std::string value) { void PutEnv(std::string var, std::string value) {
assert(::setenv(var.c_str(), value.c_str(), /* overwrite */ 1) == 0); assert(::setenv(var.c_str(), value.c_str(), /* overwrite */ 1) == 0);
} }
void UnsetEnv(std::string var) { void UnsetEnv(std::string var) {
▲ Show 20 Lines • Show All 88 Lines • Show Last 20 Lines

libcxx/trunk/test/std/input.output/filesystems/fs.op.funcs/fs.op.weakly_canonical/weakly_canonical.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++98, c++03 // UNSUPPORTED: c++98, c++03
// <filesystem> // <filesystem>
// path weakly_canonical(const path& p); // path weakly_canonical(const path& p);
// path weakly_canonical(const path& p, error_code& ec); // path weakly_canonical(const path& p, error_code& ec);
#include "filesystem_include.hpp" #include "filesystem_include.h"
#include <type_traits> #include <type_traits>
#include <vector> #include <vector>
#include <iostream> #include <iostream>
#include <cassert> #include <cassert>
#include "test_macros.h" #include "test_macros.h"
#include "test_iterators.h" #include "test_iterators.h"
#include "count_new.hpp" #include "count_new.h"
#include "filesystem_test_helper.hpp" #include "filesystem_test_helper.h"
int main(int, char**) { int main(int, char**) {
// clang-format off // clang-format off
struct { struct {
std::string input; std::string input;
std::string expect; std::string expect;
} TestCases[] = { } TestCases[] = {
▲ Show 20 Lines • Show All 42 Lines • Show Last 20 Lines

libcxx/trunk/test/std/iterators/predef.iterators/insert.iterators/back.insert.iter.ops/back.insert.iter.cons/container.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
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// <iterator> // <iterator>
// back_insert_iterator // back_insert_iterator
// explicit back_insert_iterator(Cont& x); // explicit back_insert_iterator(Cont& x);
#include <iterator> #include <iterator>
#include <vector> #include <vector>
#include "nasty_containers.hpp" #include "nasty_containers.h"
#include "test_macros.h" #include "test_macros.h"
template <class C> template <class C>
void void
test(C c) test(C c)
{ {
std::back_insert_iterator<C> i(c); std::back_insert_iterator<C> i(c);
Show All 9 Lines

libcxx/trunk/test/std/iterators/predef.iterators/insert.iterators/back.insert.iter.ops/back.insert.iter.op++/post.pass.cpp

Show All 9 Lines
// back_insert_iterator // back_insert_iterator
// back_insert_iterator<Cont> operator++(int); // back_insert_iterator<Cont> operator++(int);
#include <iterator> #include <iterator>
#include <vector> #include <vector>
#include <cassert> #include <cassert>
#include "nasty_containers.hpp" #include "nasty_containers.h"
#include "test_macros.h" #include "test_macros.h"
template <class C> template <class C>
void void
test(C c) test(C c)
{ {
std::back_insert_iterator<C> i(c); std::back_insert_iterator<C> i(c);
Show All 13 Lines

libcxx/trunk/test/std/iterators/predef.iterators/insert.iterators/back.insert.iter.ops/back.insert.iter.op++/pre.pass.cpp

Show All 9 Lines
// back_insert_iterator // back_insert_iterator
// back_insert_iterator<Cont>& operator++(); // back_insert_iterator<Cont>& operator++();
#include <iterator> #include <iterator>
#include <vector> #include <vector>
#include <cassert> #include <cassert>
#include "nasty_containers.hpp" #include "nasty_containers.h"
#include "test_macros.h" #include "test_macros.h"
template <class C> template <class C>
void void
test(C c) test(C c)
{ {
std::back_insert_iterator<C> i(c); std::back_insert_iterator<C> i(c);
Show All 11 Lines

libcxx/trunk/test/std/iterators/predef.iterators/insert.iterators/back.insert.iter.ops/back.insert.iter.op_astrk/test.pass.cpp

Show All 9 Lines
// back_insert_iterator // back_insert_iterator
// back_insert_iterator<Cont>& operator*(); // back_insert_iterator<Cont>& operator*();
#include <iterator> #include <iterator>
#include <vector> #include <vector>
#include <cassert> #include <cassert>
#include "nasty_containers.hpp" #include "nasty_containers.h"
#include "test_macros.h" #include "test_macros.h"
template <class C> template <class C>
void void
test(C c) test(C c)
{ {
std::back_insert_iterator<C> i(c); std::back_insert_iterator<C> i(c);
Show All 11 Lines

libcxx/trunk/test/std/iterators/predef.iterators/insert.iterators/back.insert.iter.ops/back.inserter/test.pass.cpp

Show All 9 Lines
// template <BackInsertionContainer Cont> // template <BackInsertionContainer Cont>
// back_insert_iterator<Cont> // back_insert_iterator<Cont>
// back_inserter(Cont& x); // back_inserter(Cont& x);
#include <iterator> #include <iterator>
#include <vector> #include <vector>
#include <cassert> #include <cassert>
#include "nasty_containers.hpp" #include "nasty_containers.h"
#include "test_macros.h" #include "test_macros.h"
template <class C> template <class C>
void void
test(C c) test(C c)
{ {
std::back_insert_iterator<C> i = std::back_inserter(c); std::back_insert_iterator<C> i = std::back_inserter(c);
Show All 12 Lines

libcxx/trunk/test/std/iterators/predef.iterators/insert.iterators/front.insert.iter.ops/front.insert.iter.cons/container.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
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// <iterator> // <iterator>
// front_insert_iterator // front_insert_iterator
// explicit front_insert_iterator(Cont& x); // explicit front_insert_iterator(Cont& x);
#include <iterator> #include <iterator>
#include <list> #include <list>
#include "nasty_containers.hpp" #include "nasty_containers.h"
#include "test_macros.h" #include "test_macros.h"
template <class C> template <class C>
void void
test(C c) test(C c)
{ {
std::front_insert_iterator<C> i(c); std::front_insert_iterator<C> i(c);
Show All 9 Lines

libcxx/trunk/test/std/iterators/predef.iterators/insert.iterators/front.insert.iter.ops/front.insert.iter.op++/post.pass.cpp

Show All 9 Lines
// front_insert_iterator // front_insert_iterator
// front_insert_iterator<Cont> operator++(int); // front_insert_iterator<Cont> operator++(int);
#include <iterator> #include <iterator>
#include <list> #include <list>
#include <cassert> #include <cassert>
#include "nasty_containers.hpp" #include "nasty_containers.h"
#include "test_macros.h" #include "test_macros.h"
template <class C> template <class C>
void void
test(C c) test(C c)
{ {
std::front_insert_iterator<C> i(c); std::front_insert_iterator<C> i(c);
Show All 13 Lines

libcxx/trunk/test/std/iterators/predef.iterators/insert.iterators/front.insert.iter.ops/front.insert.iter.op++/pre.pass.cpp

Show All 9 Lines
// front_insert_iterator // front_insert_iterator
// front_insert_iterator<Cont>& operator++(); // front_insert_iterator<Cont>& operator++();
#include <iterator> #include <iterator>
#include <list> #include <list>
#include <cassert> #include <cassert>
#include "nasty_containers.hpp" #include "nasty_containers.h"
#include "test_macros.h" #include "test_macros.h"
template <class C> template <class C>
void void
test(C c) test(C c)
{ {
std::front_insert_iterator<C> i(c); std::front_insert_iterator<C> i(c);
Show All 11 Lines

libcxx/trunk/test/std/iterators/predef.iterators/insert.iterators/front.insert.iter.ops/front.insert.iter.op=/lv_value.pass.cpp

Show All 10 Lines
// front_insert_iterator // front_insert_iterator
// front_insert_iterator<Cont>& // front_insert_iterator<Cont>&
// operator=(const Cont::value_type& value); // operator=(const Cont::value_type& value);
#include <iterator> #include <iterator>
#include <list> #include <list>
#include <cassert> #include <cassert>
#include "nasty_containers.hpp" #include "nasty_containers.h"
#include "test_macros.h" #include "test_macros.h"
template <class C> template <class C>
void void
test(C c) test(C c)
{ {
const typename C::value_type v = typename C::value_type(); const typename C::value_type v = typename C::value_type();
Show All 23 Lines

libcxx/trunk/test/std/iterators/predef.iterators/insert.iterators/front.insert.iter.ops/front.insert.iter.op_astrk/test.pass.cpp

Show All 9 Lines
// front_insert_iterator // front_insert_iterator
// front_insert_iterator<Cont>& operator*(); // front_insert_iterator<Cont>& operator*();
#include <iterator> #include <iterator>
#include <list> #include <list>
#include <cassert> #include <cassert>
#include "nasty_containers.hpp" #include "nasty_containers.h"
#include "test_macros.h" #include "test_macros.h"
template <class C> template <class C>
void void
test(C c) test(C c)
{ {
std::front_insert_iterator<C> i(c); std::front_insert_iterator<C> i(c);
Show All 11 Lines

libcxx/trunk/test/std/iterators/predef.iterators/insert.iterators/front.insert.iter.ops/front.inserter/test.pass.cpp

Show All 9 Lines
// template <BackInsertionContainer Cont> // template <BackInsertionContainer Cont>
// front_insert_iterator<Cont> // front_insert_iterator<Cont>
// front_inserter(Cont& x); // front_inserter(Cont& x);
#include <iterator> #include <iterator>
#include <list> #include <list>
#include <cassert> #include <cassert>
#include "nasty_containers.hpp" #include "nasty_containers.h"
#include "test_macros.h" #include "test_macros.h"
template <class C> template <class C>
void void
test(C c) test(C c)
{ {
std::front_insert_iterator<C> i = std::front_inserter(c); std::front_insert_iterator<C> i = std::front_inserter(c);
Show All 12 Lines

libcxx/trunk/test/std/iterators/predef.iterators/insert.iterators/insert.iter.ops/insert.iter.cons/test.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
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// <iterator> // <iterator>
// insert_iterator // insert_iterator
// insert_iterator(Cont& x, Cont::iterator i); // insert_iterator(Cont& x, Cont::iterator i);
#include <iterator> #include <iterator>
#include <vector> #include <vector>
#include "nasty_containers.hpp" #include "nasty_containers.h"
#include "test_macros.h" #include "test_macros.h"
template <class C> template <class C>
void void
test(C c) test(C c)
{ {
std::insert_iterator<C> i(c, c.begin()); std::insert_iterator<C> i(c, c.begin());
Show All 9 Lines

libcxx/trunk/test/std/iterators/predef.iterators/insert.iterators/insert.iter.ops/insert.iter.op++/post.pass.cpp

Show All 9 Lines
// insert_iterator // insert_iterator
// insert_iterator<Cont> operator++(int); // insert_iterator<Cont> operator++(int);
#include <iterator> #include <iterator>
#include <vector> #include <vector>
#include <cassert> #include <cassert>
#include "nasty_containers.hpp" #include "nasty_containers.h"
#include "test_macros.h" #include "test_macros.h"
template <class C> template <class C>
void void
test(C c) test(C c)
{ {
std::insert_iterator<C> i(c, c.end()); std::insert_iterator<C> i(c, c.end());
Show All 13 Lines

libcxx/trunk/test/std/iterators/predef.iterators/insert.iterators/insert.iter.ops/insert.iter.op++/pre.pass.cpp

Show All 9 Lines
// insert_iterator // insert_iterator
// insert_iterator<Cont>& operator++(); // insert_iterator<Cont>& operator++();
#include <iterator> #include <iterator>
#include <vector> #include <vector>
#include <cassert> #include <cassert>
#include "nasty_containers.hpp" #include "nasty_containers.h"
#include "test_macros.h" #include "test_macros.h"
template <class C> template <class C>
void void
test(C c) test(C c)
{ {
std::insert_iterator<C> i(c, c.end()); std::insert_iterator<C> i(c, c.end());
Show All 11 Lines

libcxx/trunk/test/std/iterators/predef.iterators/insert.iterators/insert.iter.ops/insert.iter.op=/lv_value.pass.cpp

Show All 11 Lines
// requires CopyConstructible<Cont::value_type> // requires CopyConstructible<Cont::value_type>
// insert_iterator<Cont>& // insert_iterator<Cont>&
// operator=(const Cont::value_type& value); // operator=(const Cont::value_type& value);
#include <iterator> #include <iterator>
#include <vector> #include <vector>
#include <cassert> #include <cassert>
#include "nasty_containers.hpp" #include "nasty_containers.h"
#include "test_macros.h" #include "test_macros.h"
template <class C> template <class C>
void void
test(C c1, typename C::difference_type j, test(C c1, typename C::difference_type j,
typename C::value_type x1, typename C::value_type x2, typename C::value_type x1, typename C::value_type x2,
typename C::value_type x3, const C& c2) typename C::value_type x3, const C& c2)
▲ Show 20 Lines • Show All 60 Lines • Show Last 20 Lines

libcxx/trunk/test/std/iterators/predef.iterators/insert.iterators/insert.iter.ops/insert.iter.op_astrk/test.pass.cpp

Show All 9 Lines
// insert_iterator // insert_iterator
// insert_iterator<Cont>& operator*(); // insert_iterator<Cont>& operator*();
#include <iterator> #include <iterator>
#include <vector> #include <vector>
#include <cassert> #include <cassert>
#include "nasty_containers.hpp" #include "nasty_containers.h"
#include "test_macros.h" #include "test_macros.h"
template <class C> template <class C>
void void
test(C c) test(C c)
{ {
std::insert_iterator<C> i(c, c.end()); std::insert_iterator<C> i(c, c.end());
Show All 11 Lines

libcxx/trunk/test/std/iterators/predef.iterators/insert.iterators/insert.iter.ops/inserter/test.pass.cpp

Show All 9 Lines
// template <InsertionContainer Cont> // template <InsertionContainer Cont>
// insert_iterator<Cont> // insert_iterator<Cont>
// inserter(Cont& x, Cont::iterator i); // inserter(Cont& x, Cont::iterator i);
#include <iterator> #include <iterator>
#include <vector> #include <vector>
#include <cassert> #include <cassert>
#include "nasty_containers.hpp" #include "nasty_containers.h"
#include "test_macros.h" #include "test_macros.h"
template <class C> template <class C>
void void
test(C c) test(C c)
{ {
std::insert_iterator<C> i = std::inserter(c, c.end()); std::insert_iterator<C> i = std::inserter(c, c.end());
Show All 12 Lines

libcxx/trunk/test/std/language.support/support.dynamic/destroying_delete_t_declaration.pass.cpp

Show All 18 Lines
// //
// Other tests will check the language side of things -- but those are // Other tests will check the language side of things -- but those are
// limited to newer compilers. // limited to newer compilers.
#include <new> #include <new>
#include <cassert> #include <cassert>
#include "test_macros.h" #include "test_macros.h"
#include "test_convertible.hpp" #include "test_convertible.h"
#ifdef __cpp_impl_destroying_delete #ifdef __cpp_impl_destroying_delete
# ifndef __cpp_lib_destroying_delete # ifndef __cpp_lib_destroying_delete
# error "Expected __cpp_lib_destroying_delete to be defined" # error "Expected __cpp_lib_destroying_delete to be defined"
# elif __cpp_lib_destroying_delete < 201806L # elif __cpp_lib_destroying_delete < 201806L
# error "Unexpected value of __cpp_lib_destroying_delete" # error "Unexpected value of __cpp_lib_destroying_delete"
# endif # endif
#else #else
Show All 17 Lines

libcxx/trunk/test/std/localization/locale.categories/category.ctype/facet.ctype.special/facet.ctype.char.dtor/dtor.pass.cpp

Show All 9 Lines
// template <> class ctype<char> // template <> class ctype<char>
// ~ctype(); // ~ctype();
#include <locale> #include <locale>
#include <cassert> #include <cassert>
#include "count_new.hpp" #include "count_new.h"
#include "test_macros.h" #include "test_macros.h"
int main(int, char**) int main(int, char**)
{ {
{ {
std::locale l(std::locale::classic(), new std::ctype<char>); std::locale l(std::locale::classic(), new std::ctype<char>);
assert(globalMemCounter.checkDeleteArrayCalledEq(0)); assert(globalMemCounter.checkDeleteArrayCalledEq(0));
Show All 17 Lines

libcxx/trunk/test/std/localization/locale.stdcvt/codecvt_utf16.pass.cpp

Show All 16 Lines
// }; // };
// Not a portable test // Not a portable test
#include <codecvt> #include <codecvt>
#include <cstdlib> #include <cstdlib>
#include <cassert> #include <cassert>
#include "count_new.hpp" #include "count_new.h"
#include "test_macros.h" #include "test_macros.h"
int main(int, char**) int main(int, char**)
{ {
assert(globalMemCounter.checkOutstandingNewEq(0)); assert(globalMemCounter.checkOutstandingNewEq(0));
{ {
typedef std::codecvt_utf16<wchar_t> C; typedef std::codecvt_utf16<wchar_t> C;
Show All 12 Lines

libcxx/trunk/test/std/localization/locale.stdcvt/codecvt_utf8.pass.cpp

Show All 16 Lines
// }; // };
// Not a portable test // Not a portable test
#include <codecvt> #include <codecvt>
#include <cstdlib> #include <cstdlib>
#include <cassert> #include <cassert>
#include "count_new.hpp" #include "count_new.h"
#include "test_macros.h" #include "test_macros.h"
int main(int, char**) int main(int, char**)
{ {
assert(globalMemCounter.checkOutstandingNewEq(0)); assert(globalMemCounter.checkOutstandingNewEq(0));
{ {
typedef std::codecvt_utf8<wchar_t> C; typedef std::codecvt_utf8<wchar_t> C;
Show All 12 Lines

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

Show All 13 Lines
// state_type state = state_type()); // state_type state = state_type());
#include <locale> #include <locale>
#include <codecvt> #include <codecvt>
#include <sstream> #include <sstream>
#include <cassert> #include <cassert>
#include "test_macros.h" #include "test_macros.h"
#include "count_new.hpp" #include "count_new.h"
int main(int, char**) int main(int, char**)
{ {
typedef std::wbuffer_convert<std::codecvt_utf8<wchar_t> > B; typedef std::wbuffer_convert<std::codecvt_utf8<wchar_t> > B;
#if TEST_STD_VER > 11 #if TEST_STD_VER > 11
static_assert(!std::is_convertible<std::streambuf*, B>::value, ""); static_assert(!std::is_convertible<std::streambuf*, B>::value, "");
static_assert( std::is_constructible<B, std::streambuf*>::value, ""); static_assert( std::is_constructible<B, std::streambuf*>::value, "");
#endif #endif
Show All 30 Lines

libcxx/trunk/test/std/localization/locales/locale/locale.cons/assign.pass.cpp

Show All 10 Lines
// <locale> // <locale>
// const locale& operator=(const locale& other) throw(); // const locale& operator=(const locale& other) throw();
#include <locale> #include <locale>
#include <cassert> #include <cassert>
#include <new> #include <new>
#include "count_new.hpp" #include "count_new.h"
#include "test_macros.h" #include "test_macros.h"
#include "platform_support.h" // locale name macros #include "platform_support.h" // locale name macros
void check(const std::locale& loc) void check(const std::locale& loc)
{ {
assert(std::has_facet<std::collate<char> >(loc)); assert(std::has_facet<std::collate<char> >(loc));
▲ Show 20 Lines • Show All 46 Lines • Show Last 20 Lines

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

Show All 14 Lines
// <locale> // <locale>
// explicit locale(const char* std_name); // explicit locale(const char* std_name);
#include <locale> #include <locale>
#include <new> #include <new>
#include <cassert> #include <cassert>
#include "count_new.hpp" #include "count_new.h"
#include "platform_support.h" // locale name macros #include "platform_support.h" // locale name macros
#include "test_macros.h" #include "test_macros.h"
void check(const std::locale& loc) void check(const std::locale& loc)
{ {
assert(std::has_facet<std::collate<char> >(loc)); assert(std::has_facet<std::collate<char> >(loc));
▲ Show 20 Lines • Show All 68 Lines • Show Last 20 Lines

libcxx/trunk/test/std/localization/locales/locale/locale.cons/copy.pass.cpp

Show All 10 Lines
// <locale> // <locale>
// locale(const locale& other) throw(); // locale(const locale& other) throw();
#include <locale> #include <locale>
#include <cassert> #include <cassert>
#include <new> #include <new>
#include "count_new.hpp" #include "count_new.h"
#include "test_macros.h" #include "test_macros.h"
#include "platform_support.h" // locale name macros #include "platform_support.h" // locale name macros
void check(const std::locale& loc) void check(const std::locale& loc)
{ {
assert(std::has_facet<std::collate<char> >(loc)); assert(std::has_facet<std::collate<char> >(loc));
assert(std::has_facet<std::collate<wchar_t> >(loc)); assert(std::has_facet<std::collate<wchar_t> >(loc));
▲ Show 20 Lines • Show All 43 Lines • Show Last 20 Lines

libcxx/trunk/test/std/localization/locales/locale/locale.cons/default.pass.cpp

Show All 11 Lines
// locale() throw(); // locale() throw();
#include <locale> #include <locale>
#include <cassert> #include <cassert>
#include "test_macros.h" #include "test_macros.h"
#include "platform_support.h" // locale name macros #include "platform_support.h" // locale name macros
#include "count_new.hpp" #include "count_new.h"
void check(const std::locale& loc) void check(const std::locale& loc)
{ {
assert(std::has_facet<std::collate<char> >(loc)); assert(std::has_facet<std::collate<char> >(loc));
assert(std::has_facet<std::collate<wchar_t> >(loc)); assert(std::has_facet<std::collate<wchar_t> >(loc));
assert(std::has_facet<std::ctype<char> >(loc)); assert(std::has_facet<std::ctype<char> >(loc));
assert(std::has_facet<std::ctype<wchar_t> >(loc)); assert(std::has_facet<std::ctype<wchar_t> >(loc));
▲ Show 20 Lines • Show All 51 Lines • Show Last 20 Lines

libcxx/trunk/test/std/localization/locales/locale/locale.cons/locale_char_pointer_cat.pass.cpp

Show All 15 Lines
// <locale> // <locale>
// locale(const locale& other, const char* std_name, category); // locale(const locale& other, const char* std_name, category);
#include <locale> #include <locale>
#include <new> #include <new>
#include <cassert> #include <cassert>
#include "count_new.hpp" #include "count_new.h"
#include "test_macros.h" #include "test_macros.h"
#include "platform_support.h" // locale name macros #include "platform_support.h" // locale name macros
void check(const std::locale& loc) void check(const std::locale& loc)
{ {
assert(std::has_facet<std::collate<char> >(loc)); assert(std::has_facet<std::collate<char> >(loc));
assert(std::has_facet<std::collate<wchar_t> >(loc)); assert(std::has_facet<std::collate<wchar_t> >(loc));
▲ Show 20 Lines • Show All 42 Lines • Show Last 20 Lines

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

Show All 10 Lines
// <locale> // <locale>
// template <class Facet> locale(const locale& other, Facet* f); // template <class Facet> locale(const locale& other, Facet* f);
#include <locale> #include <locale>
#include <new> #include <new>
#include <cassert> #include <cassert>
#include "count_new.hpp" #include "count_new.h"
#include "test_macros.h" #include "test_macros.h"
#include "platform_support.h" // locale name macros #include "platform_support.h" // locale name macros
void check(const std::locale& loc) void check(const std::locale& loc)
{ {
assert(std::has_facet<std::collate<char> >(loc)); assert(std::has_facet<std::collate<char> >(loc));
assert(std::has_facet<std::collate<wchar_t> >(loc)); assert(std::has_facet<std::collate<wchar_t> >(loc));
▲ Show 20 Lines • Show All 64 Lines • Show Last 20 Lines

libcxx/trunk/test/std/localization/locales/locale/locale.cons/locale_locale_cat.pass.cpp

Show All 15 Lines
// <locale> // <locale>
// locale(const locale& other, const locale& one, category cats); // locale(const locale& other, const locale& one, category cats);
#include <locale> #include <locale>
#include <new> #include <new>
#include <cassert> #include <cassert>
#include "count_new.hpp" #include "count_new.h"
#include "test_macros.h" #include "test_macros.h"
#include "platform_support.h" // locale name macros #include "platform_support.h" // locale name macros
void check(const std::locale& loc) void check(const std::locale& loc)
{ {
assert(std::has_facet<std::collate<char> >(loc)); assert(std::has_facet<std::collate<char> >(loc));
assert(std::has_facet<std::collate<wchar_t> >(loc)); assert(std::has_facet<std::collate<wchar_t> >(loc));
▲ Show 20 Lines • Show All 42 Lines • Show Last 20 Lines

libcxx/trunk/test/std/localization/locales/locale/locale.cons/locale_string_cat.pass.cpp

Show All 15 Lines
// <locale> // <locale>
// locale(const locale& other, const string& std_name, category cat); // locale(const locale& other, const string& std_name, category cat);
#include <locale> #include <locale>
#include <new> #include <new>
#include <cassert> #include <cassert>
#include "count_new.hpp" #include "count_new.h"
#include "test_macros.h" #include "test_macros.h"
#include "platform_support.h" // locale name macros #include "platform_support.h" // locale name macros
void check(const std::locale& loc) void check(const std::locale& loc)
{ {
assert(std::has_facet<std::collate<char> >(loc)); assert(std::has_facet<std::collate<char> >(loc));
assert(std::has_facet<std::collate<wchar_t> >(loc)); assert(std::has_facet<std::collate<wchar_t> >(loc));
▲ Show 20 Lines • Show All 43 Lines • Show Last 20 Lines

libcxx/trunk/test/std/localization/locales/locale/locale.cons/string.pass.cpp

Show All 11 Lines
// <locale> // <locale>
// explicit locale(const string& std_name); // explicit locale(const string& std_name);
#include <locale> #include <locale>
#include <new> #include <new>
#include <cassert> #include <cassert>
#include "count_new.hpp" #include "count_new.h"
#include "test_macros.h" #include "test_macros.h"
#include "platform_support.h" // locale name macros #include "platform_support.h" // locale name macros
void check(const std::locale& loc) void check(const std::locale& loc)
{ {
assert(std::has_facet<std::collate<char> >(loc)); assert(std::has_facet<std::collate<char> >(loc));
assert(std::has_facet<std::collate<wchar_t> >(loc)); assert(std::has_facet<std::collate<wchar_t> >(loc));
▲ Show 20 Lines • Show All 47 Lines • Show Last 20 Lines

libcxx/trunk/test/std/localization/locales/locale/locale.members/combine.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
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// <locale> // <locale>
// template <class Facet> locale combine(const locale& other) const; // template <class Facet> locale combine(const locale& other) const;
#include <locale> #include <locale>
#include <stdexcept> #include <stdexcept>
#include <cassert> #include <cassert>
#include "count_new.hpp" #include "count_new.h"
#include "test_macros.h" #include "test_macros.h"
void check(const std::locale& loc) void check(const std::locale& loc)
{ {
assert(std::has_facet<std::collate<char> >(loc)); assert(std::has_facet<std::collate<char> >(loc));
assert(std::has_facet<std::collate<wchar_t> >(loc)); assert(std::has_facet<std::collate<wchar_t> >(loc));
▲ Show 20 Lines • Show All 75 Lines • Show Last 20 Lines

libcxx/trunk/test/std/strings/basic.string.hash/enabled_hashes.pass.cpp

Show All 9 Lines
// <string> // <string>
// Test that <string> provides all of the arithmetic, enum, and pointer // Test that <string> provides all of the arithmetic, enum, and pointer
// hash specializations. // hash specializations.
#include <string> #include <string>
#include "poisoned_hash_helper.hpp" #include "poisoned_hash_helper.h"
#include "test_macros.h" #include "test_macros.h"
int main(int, char**) { int main(int, char**) {
test_library_hash_specializations_available(); test_library_hash_specializations_available();
{ {
test_hash_enabled_for_type<std::string>(); test_hash_enabled_for_type<std::string>();
test_hash_enabled_for_type<std::wstring>(); test_hash_enabled_for_type<std::wstring>();
Show All 11 Lines

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

Show All 15 Lines
#include <string> #include <string>
#include <string_view> #include <string_view>
#include <cassert> #include <cassert>
#include "test_macros.h" #include "test_macros.h"
#include "test_allocator.h" #include "test_allocator.h"
#include "test_iterators.h" #include "test_iterators.h"
#include "constexpr_char_traits.hpp" #include "constexpr_char_traits.h"
template <class T, class Alloc = std::allocator<T>> template <class T, class Alloc = std::allocator<T>>
using BStr = std::basic_string<T, std::char_traits<T>, Alloc>; using BStr = std::basic_string<T, std::char_traits<T>, Alloc>;
// Overloads // Overloads
// using A = Allocator; // using A = Allocator;
// using BS = basic_string // using BS = basic_string
// using BSV = basic_string_view // using BSV = basic_string_view
▲ Show 20 Lines • Show All 286 Lines • Show Last 20 Lines

libcxx/trunk/test/std/strings/string.view/string.view.hash/enabled_hashes.pass.cpp

Show All 9 Lines
// <string_view> // <string_view>
// Test that <string_view> provides all of the arithmetic, enum, and pointer // Test that <string_view> provides all of the arithmetic, enum, and pointer
// hash specializations. // hash specializations.
#include <string_view> #include <string_view>
#include "poisoned_hash_helper.hpp" #include "poisoned_hash_helper.h"
#include "test_macros.h" #include "test_macros.h"
int main(int, char**) { int main(int, char**) {
test_library_hash_specializations_available(); test_library_hash_specializations_available();
{ {
test_hash_enabled_for_type<std::string_view>(); test_hash_enabled_for_type<std::string_view>();
test_hash_enabled_for_type<std::wstring_view>(); test_hash_enabled_for_type<std::wstring_view>();
Show All 11 Lines

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

Show All 11 Lines
// constexpr bool operator==(basic_string_view<charT,traits> lhs, const charT* rhs); // constexpr bool operator==(basic_string_view<charT,traits> lhs, const charT* rhs);
// template<class charT, class traits> // template<class charT, class traits>
// constexpr bool operator==(const charT* lhs, basic_string_view<charT,traits> rhs); // constexpr bool operator==(const charT* lhs, basic_string_view<charT,traits> rhs);
#include <string_view> #include <string_view>
#include <cassert> #include <cassert>
#include "test_macros.h" #include "test_macros.h"
#include "constexpr_char_traits.hpp" #include "constexpr_char_traits.h"
template <class S> template <class S>
void void
test(S lhs, const typename S::value_type* rhs, bool x) test(S lhs, const typename S::value_type* rhs, bool x)
{ {
assert((lhs == rhs) == x); assert((lhs == rhs) == x);
assert((rhs == lhs) == x); assert((rhs == lhs) == x);
} }
▲ Show 20 Lines • Show All 42 Lines • Show Last 20 Lines

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

Show All 10 Lines
// template<class charT, class traits, class Allocator> // template<class charT, class traits, class Allocator>
// constexpr bool operator==(const basic_string_view<charT,traits> lhs, // constexpr bool operator==(const basic_string_view<charT,traits> lhs,
// const basic_string_view<charT,traits> rhs); // const basic_string_view<charT,traits> rhs);
#include <string_view> #include <string_view>
#include <cassert> #include <cassert>
#include "test_macros.h" #include "test_macros.h"
#include "constexpr_char_traits.hpp" #include "constexpr_char_traits.h"
template <class S> template <class S>
void void
test(S lhs, S rhs, bool x) test(S lhs, S rhs, bool x)
{ {
assert((lhs == rhs) == x); assert((lhs == rhs) == x);
assert((rhs == lhs) == x); assert((rhs == lhs) == x);
} }
Show All 36 Lines

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

Show All 11 Lines
// constexpr bool operator>=(const charT* lhs, basic_string_wiew<charT,traits> rhs); // constexpr bool operator>=(const charT* lhs, basic_string_wiew<charT,traits> rhs);
// template<class charT, class traits, class Allocator> // template<class charT, class traits, class Allocator>
// constexpr bool operator>=(basic_string_wiew<charT,traits> lhs, const charT* rhs); // constexpr bool operator>=(basic_string_wiew<charT,traits> lhs, const charT* rhs);
#include <string_view> #include <string_view>
#include <cassert> #include <cassert>
#include "test_macros.h" #include "test_macros.h"
#include "constexpr_char_traits.hpp" #include "constexpr_char_traits.h"
template <class S> template <class S>
void void
test(const typename S::value_type* lhs, const S& rhs, bool x, bool y) test(const typename S::value_type* lhs, const S& rhs, bool x, bool y)
{ {
assert((lhs >= rhs) == x); assert((lhs >= rhs) == x);
assert((rhs >= lhs) == y); assert((rhs >= lhs) == y);
} }
▲ Show 20 Lines • Show All 45 Lines • Show Last 20 Lines

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

Show All 10 Lines
// template<class charT, class traits> // template<class charT, class traits>
// constexpr bool operator>=(basic_string_view<charT,traits> lhs, // constexpr bool operator>=(basic_string_view<charT,traits> lhs,
// basic_string_view<charT,traits> rhs); // basic_string_view<charT,traits> rhs);
#include <string_view> #include <string_view>
#include <cassert> #include <cassert>
#include "test_macros.h" #include "test_macros.h"
#include "constexpr_char_traits.hpp" #include "constexpr_char_traits.h"
template <class S> template <class S>
void void
test(const S& lhs, const S& rhs, bool x, bool y) test(const S& lhs, const S& rhs, bool x, bool y)
{ {
assert((lhs >= rhs) == x); assert((lhs >= rhs) == x);
assert((rhs >= lhs) == y); assert((rhs >= lhs) == y);
} }
Show All 39 Lines

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

Show All 11 Lines
// bool operator>(const charT* lhs, basic_string_wiew<charT,traits> rhs); // bool operator>(const charT* lhs, basic_string_wiew<charT,traits> rhs);
// constexpr template<class charT, class traits, class Allocator> // constexpr template<class charT, class traits, class Allocator>
// bool operator>(basic_string_wiew<charT,traits> lhs, const charT* rhs); // bool operator>(basic_string_wiew<charT,traits> lhs, const charT* rhs);
#include <string_view> #include <string_view>
#include <cassert> #include <cassert>
#include "test_macros.h" #include "test_macros.h"
#include "constexpr_char_traits.hpp" #include "constexpr_char_traits.h"
template <class S> template <class S>
void void
test(const typename S::value_type* lhs, const S& rhs, bool x, bool y) test(const typename S::value_type* lhs, const S& rhs, bool x, bool y)
{ {
assert((lhs > rhs) == x); assert((lhs > rhs) == x);
assert((rhs > lhs) == y); assert((rhs > lhs) == y);
} }
▲ Show 20 Lines • Show All 45 Lines • Show Last 20 Lines

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

Show All 10 Lines
// template<class charT, class traits> // template<class charT, class traits>
// constexpr bool operator>(basic_string_view<charT,traits> lhs, // constexpr bool operator>(basic_string_view<charT,traits> lhs,
// basic_string_view<charT,traits> rhs); // basic_string_view<charT,traits> rhs);
#include <string_view> #include <string_view>
#include <cassert> #include <cassert>
#include "test_macros.h" #include "test_macros.h"
#include "constexpr_char_traits.hpp" #include "constexpr_char_traits.h"
template <class S> template <class S>
void void
test(const S& lhs, const S& rhs, bool x, bool y) test(const S& lhs, const S& rhs, bool x, bool y)
{ {
assert((lhs > rhs) == x); assert((lhs > rhs) == x);
assert((rhs > lhs) == y); assert((rhs > lhs) == y);
} }
Show All 39 Lines

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

Show All 11 Lines
// constexpr bool operator<=(const charT* lhs, basic_string_wiew<charT,traits> rhs); // constexpr bool operator<=(const charT* lhs, basic_string_wiew<charT,traits> rhs);
// template<class charT, class traits, class Allocator> // template<class charT, class traits, class Allocator>
// constexpr bool operator<=(basic_string_wiew<charT,traits> lhs, const charT* rhs); // constexpr bool operator<=(basic_string_wiew<charT,traits> lhs, const charT* rhs);
#include <string_view> #include <string_view>
#include <cassert> #include <cassert>
#include "test_macros.h" #include "test_macros.h"
#include "constexpr_char_traits.hpp" #include "constexpr_char_traits.h"
template <class S> template <class S>
void void
test(const typename S::value_type* lhs, const S& rhs, bool x, bool y) test(const typename S::value_type* lhs, const S& rhs, bool x, bool y)
{ {
assert((lhs <= rhs) == x); assert((lhs <= rhs) == x);
assert((rhs <= lhs) == y); assert((rhs <= lhs) == y);
} }
▲ Show 20 Lines • Show All 45 Lines • Show Last 20 Lines

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

Show All 10 Lines
// template<class charT, class traits> // template<class charT, class traits>
// constexpr bool operator<=(basic_string_view<charT,traits> lhs, // constexpr bool operator<=(basic_string_view<charT,traits> lhs,
// basic_string_view<charT,traits> rhs); // basic_string_view<charT,traits> rhs);
#include <string_view> #include <string_view>
#include <cassert> #include <cassert>
#include "test_macros.h" #include "test_macros.h"
#include "constexpr_char_traits.hpp" #include "constexpr_char_traits.h"
template <class S> template <class S>
void void
test(const S& lhs, const S& rhs, bool x, bool y) test(const S& lhs, const S& rhs, bool x, bool y)
{ {
assert((lhs <= rhs) == x); assert((lhs <= rhs) == x);
assert((rhs <= lhs) == y); assert((rhs <= lhs) == y);
} }
Show All 39 Lines

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

Show All 11 Lines
// constexpr bool operator<(const charT* lhs, basic_string_wiew<charT,traits> rhs); // constexpr bool operator<(const charT* lhs, basic_string_wiew<charT,traits> rhs);
// template<class charT, class traits, class Allocator> // template<class charT, class traits, class Allocator>
// constexpr bool operator<(basic_string_wiew<charT,traits> lhs, const charT* rhs); // constexpr bool operator<(basic_string_wiew<charT,traits> lhs, const charT* rhs);
#include <string_view> #include <string_view>
#include <cassert> #include <cassert>
#include "test_macros.h" #include "test_macros.h"
#include "constexpr_char_traits.hpp" #include "constexpr_char_traits.h"
template <class S> template <class S>
void void
test(const typename S::value_type* lhs, const S& rhs, bool x, bool y) test(const typename S::value_type* lhs, const S& rhs, bool x, bool y)
{ {
assert((lhs < rhs) == x); assert((lhs < rhs) == x);
assert((rhs < lhs) == y); assert((rhs < lhs) == y);
} }
▲ Show 20 Lines • Show All 45 Lines • Show Last 20 Lines

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

Show All 10 Lines
// template<class charT, class traits> // template<class charT, class traits>
// constexpr bool operator<(basic_string_view<charT,traits> lhs, // constexpr bool operator<(basic_string_view<charT,traits> lhs,
// basic_string_view<charT,traits> rhs); // basic_string_view<charT,traits> rhs);
#include <string_view> #include <string_view>
#include <cassert> #include <cassert>
#include "test_macros.h" #include "test_macros.h"
#include "constexpr_char_traits.hpp" #include "constexpr_char_traits.h"
template <class S> template <class S>
void void
test(const S& lhs, const S& rhs, bool x, bool y) test(const S& lhs, const S& rhs, bool x, bool y)
{ {
assert((lhs < rhs) == x); assert((lhs < rhs) == x);
assert((rhs < lhs) == y); assert((rhs < lhs) == y);
} }
Show All 39 Lines

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

Show All 11 Lines
// constexpr bool operator!=(basic_string_view<charT,traits> lhs, const charT* rhs); // constexpr bool operator!=(basic_string_view<charT,traits> lhs, const charT* rhs);
// template<class charT, class traits> // template<class charT, class traits>
// constexpr bool operator!=(const charT* lhs, basic_string_view<charT,traits> rhs); // constexpr bool operator!=(const charT* lhs, basic_string_view<charT,traits> rhs);
#include <string_view> #include <string_view>
#include <cassert> #include <cassert>
#include "test_macros.h" #include "test_macros.h"
#include "constexpr_char_traits.hpp" #include "constexpr_char_traits.h"
template <class S> template <class S>
void void
test(S lhs, const typename S::value_type* rhs, bool x) test(S lhs, const typename S::value_type* rhs, bool x)
{ {
assert((lhs != rhs) == x); assert((lhs != rhs) == x);
assert((rhs != lhs) == x); assert((rhs != lhs) == x);
} }
▲ Show 20 Lines • Show All 43 Lines • Show Last 20 Lines

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

Show All 10 Lines
// template<class charT, class traits, class Allocator> // template<class charT, class traits, class Allocator>
// constexpr bool operator!=(const basic_string_view<charT,traits> lhs, // constexpr bool operator!=(const basic_string_view<charT,traits> lhs,
// const basic_string_view<charT,traits> rhs); // const basic_string_view<charT,traits> rhs);
#include <string_view> #include <string_view>
#include <cassert> #include <cassert>
#include "test_macros.h" #include "test_macros.h"
#include "constexpr_char_traits.hpp" #include "constexpr_char_traits.h"
template <class S> template <class S>
void void
test(S lhs, S rhs, bool x) test(S lhs, S rhs, bool x)
{ {
assert((lhs != rhs) == x); assert((lhs != rhs) == x);
assert((rhs != lhs) == x); assert((rhs != lhs) == x);
} }
Show All 36 Lines

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

Show All 12 Lines
// : __data (_s), __size(_Traits::length(_s)) {} // : __data (_s), __size(_Traits::length(_s)) {}
#include <string_view> #include <string_view>
#include <string> #include <string>
#include <cassert> #include <cassert>
#include "test_macros.h" #include "test_macros.h"
#include "constexpr_char_traits.hpp" #include "constexpr_char_traits.h"
template<typename CharT> template<typename CharT>
size_t StrLen ( const CharT *s ) { size_t StrLen ( const CharT *s ) {
size_t retVal = 0; size_t retVal = 0;
while ( *s != 0 ) { ++retVal; ++s; } while ( *s != 0 ) { ++retVal; ++s; }
return retVal; return retVal;
} }
▲ Show 20 Lines • Show All 41 Lines • Show Last 20 Lines

libcxx/trunk/test/std/strings/string.view/string.view.cons/implicit_deduction_guides.pass.cpp

Show All 12 Lines
// Test that the constructors offered by std::basic_string_view are formulated // Test that the constructors offered by std::basic_string_view are formulated
// so they're compatible with implicit deduction guides. // so they're compatible with implicit deduction guides.
#include <string_view> #include <string_view>
#include <cassert> #include <cassert>
#include "test_macros.h" #include "test_macros.h"
#include "constexpr_char_traits.hpp" #include "constexpr_char_traits.h"
// Overloads // Overloads
// --------------- // ---------------
// (1) basic_string_view() - NOT TESTED // (1) basic_string_view() - NOT TESTED
// (2) basic_string_view(const basic_string_view&) // (2) basic_string_view(const basic_string_view&)
// (3) basic_string_view(const CharT*, size_type) // (3) basic_string_view(const CharT*, size_type)
// (4) basic_string_view(const CharT*) // (4) basic_string_view(const CharT*)
int main(int, char**) int main(int, char**)
Show All 37 Lines

libcxx/trunk/test/std/strings/string.view/string.view.find/find_char_size.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
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// <string_view> // <string_view>
// constexpr size_type find(charT c, size_type pos = 0) const; // constexpr size_type find(charT c, size_type pos = 0) const;
#include <string_view> #include <string_view>
#include <cassert> #include <cassert>
#include "test_macros.h" #include "test_macros.h"
#include "constexpr_char_traits.hpp" #include "constexpr_char_traits.h"
template <class S> template <class S>
void void
test(const S& s, typename S::value_type c, typename S::size_type pos, test(const S& s, typename S::value_type c, typename S::size_type pos,
typename S::size_type x) typename S::size_type x)
{ {
assert(s.find(c, pos) == x); assert(s.find(c, pos) == x);
if (x != S::npos) if (x != S::npos)
▲ Show 20 Lines • Show All 61 Lines • Show Last 20 Lines

libcxx/trunk/test/std/strings/string.view/string.view.find/find_first_not_of_char_size.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
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// <string_view> // <string_view>
// constexpr size_type find_first_not_of(charT c, size_type pos = 0) const; // constexpr size_type find_first_not_of(charT c, size_type pos = 0) const;
#include <string_view> #include <string_view>
#include <cassert> #include <cassert>
#include "test_macros.h" #include "test_macros.h"
#include "constexpr_char_traits.hpp" #include "constexpr_char_traits.h"
template <class S> template <class S>
void void
test(const S& s, typename S::value_type c, typename S::size_type pos, test(const S& s, typename S::value_type c, typename S::size_type pos,
typename S::size_type x) typename S::size_type x)
{ {
assert(s.find_first_not_of(c, pos) == x); assert(s.find_first_not_of(c, pos) == x);
if (x != S::npos) if (x != S::npos)
▲ Show 20 Lines • Show All 61 Lines • Show Last 20 Lines

libcxx/trunk/test/std/strings/string.view/string.view.find/find_first_not_of_pointer_size.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
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// <string_view> // <string_view>
// constexpr size_type find_first_not_of(const charT* s, size_type pos = 0) const; // constexpr size_type find_first_not_of(const charT* s, size_type pos = 0) const;
#include <string_view> #include <string_view>
#include <cassert> #include <cassert>
#include "test_macros.h" #include "test_macros.h"
#include "constexpr_char_traits.hpp" #include "constexpr_char_traits.h"
template <class S> template <class S>
void void
test(const S& s, const typename S::value_type* str, typename S::size_type pos, test(const S& s, const typename S::value_type* str, typename S::size_type pos,
typename S::size_type x) typename S::size_type x)
{ {
assert(s.find_first_not_of(str, pos) == x); assert(s.find_first_not_of(str, pos) == x);
if (x != S::npos) if (x != S::npos)
▲ Show 20 Lines • Show All 142 Lines • Show Last 20 Lines

libcxx/trunk/test/std/strings/string.view/string.view.find/find_first_not_of_pointer_size_size.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
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// <string_view> // <string_view>
// constexpr size_type find_first_not_of(const charT* s, size_type pos, size_type n) const; // constexpr size_type find_first_not_of(const charT* s, size_type pos, size_type n) const;
#include <string_view> #include <string_view>
#include <cassert> #include <cassert>
#include "test_macros.h" #include "test_macros.h"
#include "constexpr_char_traits.hpp" #include "constexpr_char_traits.h"
template <class S> template <class S>
void void
test(const S& s, const typename S::value_type* str, typename S::size_type pos, test(const S& s, const typename S::value_type* str, typename S::size_type pos,
typename S::size_type n, typename S::size_type x) typename S::size_type n, typename S::size_type x)
{ {
assert(s.find_first_not_of(str, pos, n) == x); assert(s.find_first_not_of(str, pos, n) == x);
if (x != S::npos) if (x != S::npos)
▲ Show 20 Lines • Show All 369 Lines • Show Last 20 Lines

libcxx/trunk/test/std/strings/string.view/string.view.find/find_first_of_char_size.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
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// <string> // <string>
// constexpr size_type find_first_of(charT c, size_type pos = 0) const; // constexpr size_type find_first_of(charT c, size_type pos = 0) const;
#include <string_view> #include <string_view>
#include <cassert> #include <cassert>
#include "test_macros.h" #include "test_macros.h"
#include "constexpr_char_traits.hpp" #include "constexpr_char_traits.h"
template <class S> template <class S>
void void
test(const S& s, typename S::value_type c, typename S::size_type pos, test(const S& s, typename S::value_type c, typename S::size_type pos,
typename S::size_type x) typename S::size_type x)
{ {
assert(s.find_first_of(c, pos) == x); assert(s.find_first_of(c, pos) == x);
if (x != S::npos) if (x != S::npos)
▲ Show 20 Lines • Show All 59 Lines • Show Last 20 Lines

libcxx/trunk/test/std/strings/string.view/string.view.find/find_first_of_pointer_size.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
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// <string> // <string>
// constexpr size_type find_first_of(const charT* s, size_type pos = 0) const; // constexpr size_type find_first_of(const charT* s, size_type pos = 0) const;
#include <string_view> #include <string_view>
#include <cassert> #include <cassert>
#include "test_macros.h" #include "test_macros.h"
#include "constexpr_char_traits.hpp" #include "constexpr_char_traits.h"
template <class S> template <class S>
void void
test(const S& s, const typename S::value_type* str, typename S::size_type pos, test(const S& s, const typename S::value_type* str, typename S::size_type pos,
typename S::size_type x) typename S::size_type x)
{ {
assert(s.find_first_of(str, pos) == x); assert(s.find_first_of(str, pos) == x);
if (x != S::npos) if (x != S::npos)
▲ Show 20 Lines • Show All 142 Lines • Show Last 20 Lines

libcxx/trunk/test/std/strings/string.view/string.view.find/find_first_of_pointer_size_size.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
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// <string> // <string>
// constexpr size_type find_first_of(const charT* s, size_type pos, size_type n) const; // constexpr size_type find_first_of(const charT* s, size_type pos, size_type n) const;
#include <string_view> #include <string_view>
#include <cassert> #include <cassert>
#include "test_macros.h" #include "test_macros.h"
#include "constexpr_char_traits.hpp" #include "constexpr_char_traits.h"
template <class S> template <class S>
void void
test(const S& s, const typename S::value_type* str, typename S::size_type pos, test(const S& s, const typename S::value_type* str, typename S::size_type pos,
typename S::size_type n, typename S::size_type x) typename S::size_type n, typename S::size_type x)
{ {
assert(s.find_first_of(str, pos, n) == x); assert(s.find_first_of(str, pos, n) == x);
if (x != S::npos) if (x != S::npos)
▲ Show 20 Lines • Show All 369 Lines • Show Last 20 Lines

libcxx/trunk/test/std/strings/string.view/string.view.find/find_last_not_of_char_size.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
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// <string_view> // <string_view>
// const size_type find_last_not_of(charT c, size_type pos = npos) const; // const size_type find_last_not_of(charT c, size_type pos = npos) const;
#include <string_view> #include <string_view>
#include <cassert> #include <cassert>
#include "test_macros.h" #include "test_macros.h"
#include "constexpr_char_traits.hpp" #include "constexpr_char_traits.h"
template <class S> template <class S>
void void
test(const S& s, typename S::value_type c, typename S::size_type pos, test(const S& s, typename S::value_type c, typename S::size_type pos,
typename S::size_type x) typename S::size_type x)
{ {
assert(s.find_last_not_of(c, pos) == x); assert(s.find_last_not_of(c, pos) == x);
if (x != S::npos) if (x != S::npos)
▲ Show 20 Lines • Show All 59 Lines • Show Last 20 Lines

libcxx/trunk/test/std/strings/string.view/string.view.find/find_last_not_of_pointer_size.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
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// <string_view> // <string_view>
// constexpr size_type find_last_not_of(const charT* s, size_type pos = npos) const; // constexpr size_type find_last_not_of(const charT* s, size_type pos = npos) const;
#include <string_view> #include <string_view>
#include <cassert> #include <cassert>
#include "test_macros.h" #include "test_macros.h"
#include "constexpr_char_traits.hpp" #include "constexpr_char_traits.h"
template <class S> template <class S>
void void
test(const S& s, const typename S::value_type* str, typename S::size_type pos, test(const S& s, const typename S::value_type* str, typename S::size_type pos,
typename S::size_type x) typename S::size_type x)
{ {
assert(s.find_last_not_of(str, pos) == x); assert(s.find_last_not_of(str, pos) == x);
if (x != S::npos) if (x != S::npos)
▲ Show 20 Lines • Show All 142 Lines • Show Last 20 Lines

libcxx/trunk/test/std/strings/string.view/string.view.find/find_last_not_of_pointer_size_size.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
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// <string> // <string>
// constexpr size_type find_last_not_of(const charT* s, size_type pos, size_type n) const; // constexpr size_type find_last_not_of(const charT* s, size_type pos, size_type n) const;
#include <string_view> #include <string_view>
#include <cassert> #include <cassert>
#include "test_macros.h" #include "test_macros.h"
#include "constexpr_char_traits.hpp" #include "constexpr_char_traits.h"
template <class S> template <class S>
void void
test(const S& s, const typename S::value_type* str, typename S::size_type pos, test(const S& s, const typename S::value_type* str, typename S::size_type pos,
typename S::size_type n, typename S::size_type x) typename S::size_type n, typename S::size_type x)
{ {
assert(s.find_last_not_of(str, pos, n) == x); assert(s.find_last_not_of(str, pos, n) == x);
if (x != S::npos) if (x != S::npos)
▲ Show 20 Lines • Show All 369 Lines • Show Last 20 Lines

libcxx/trunk/test/std/strings/string.view/string.view.find/find_last_of_char_size.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
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// <string_view> // <string_view>
// constexpr size_type find_last_of(charT c, size_type pos = npos) const; // constexpr size_type find_last_of(charT c, size_type pos = npos) const;
#include <string_view> #include <string_view>
#include <cassert> #include <cassert>
#include "test_macros.h" #include "test_macros.h"
#include "constexpr_char_traits.hpp" #include "constexpr_char_traits.h"
template <class S> template <class S>
void void
test(const S& s, typename S::value_type c, typename S::size_type pos, test(const S& s, typename S::value_type c, typename S::size_type pos,
typename S::size_type x) typename S::size_type x)
{ {
assert(s.find_last_of(c, pos) == x); assert(s.find_last_of(c, pos) == x);
if (x != S::npos) if (x != S::npos)
▲ Show 20 Lines • Show All 59 Lines • Show Last 20 Lines

libcxx/trunk/test/std/strings/string.view/string.view.find/find_last_of_pointer_size.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
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// <string_view> // <string_view>
// constexpr size_type find_last_of(const charT* s, size_type pos = npos) const; // constexpr size_type find_last_of(const charT* s, size_type pos = npos) const;
#include <string_view> #include <string_view>
#include <cassert> #include <cassert>
#include "test_macros.h" #include "test_macros.h"
#include "constexpr_char_traits.hpp" #include "constexpr_char_traits.h"
template <class S> template <class S>
void void
test(const S& s, const typename S::value_type* str, typename S::size_type pos, test(const S& s, const typename S::value_type* str, typename S::size_type pos,
typename S::size_type x) typename S::size_type x)
{ {
assert(s.find_last_of(str, pos) == x); assert(s.find_last_of(str, pos) == x);
if (x != S::npos) if (x != S::npos)
▲ Show 20 Lines • Show All 142 Lines • Show Last 20 Lines

libcxx/trunk/test/std/strings/string.view/string.view.find/find_last_of_pointer_size_size.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
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// <string_view> // <string_view>
// constexpr size_type find_last_of(const charT* s, size_type pos, size_type n) const; // constexpr size_type find_last_of(const charT* s, size_type pos, size_type n) const;
#include <string_view> #include <string_view>
#include <cassert> #include <cassert>
#include "test_macros.h" #include "test_macros.h"
#include "constexpr_char_traits.hpp" #include "constexpr_char_traits.h"
template <class S> template <class S>
void void
test(const S& s, const typename S::value_type* str, typename S::size_type pos, test(const S& s, const typename S::value_type* str, typename S::size_type pos,
typename S::size_type n, typename S::size_type x) typename S::size_type n, typename S::size_type x)
{ {
assert(s.find_last_of(str, pos, n) == x); assert(s.find_last_of(str, pos, n) == x);
if (x != S::npos) if (x != S::npos)
▲ Show 20 Lines • Show All 369 Lines • Show Last 20 Lines

libcxx/trunk/test/std/strings/string.view/string.view.find/find_pointer_size.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
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// <string> // <string>
// constexpr size_type find(const charT* s, size_type pos = 0) const; // constexpr size_type find(const charT* s, size_type pos = 0) const;
#include <string_view> #include <string_view>
#include <cassert> #include <cassert>
#include "test_macros.h" #include "test_macros.h"
#include "constexpr_char_traits.hpp" #include "constexpr_char_traits.h"
template <class S> template <class S>
void void
test(const S& s, const typename S::value_type* str, typename S::size_type pos, test(const S& s, const typename S::value_type* str, typename S::size_type pos,
typename S::size_type x) typename S::size_type x)
{ {
assert(s.find(str, pos) == x); assert(s.find(str, pos) == x);
if (x != S::npos) if (x != S::npos)
▲ Show 20 Lines • Show All 148 Lines • Show Last 20 Lines

libcxx/trunk/test/std/strings/string.view/string.view.find/find_pointer_size_size.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
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// <string_view> // <string_view>
// constexpr size_type find(const charT* s, size_type pos, size_type n) const; // constexpr size_type find(const charT* s, size_type pos, size_type n) const;
#include <string_view> #include <string_view>
#include <cassert> #include <cassert>
#include "test_macros.h" #include "test_macros.h"
#include "constexpr_char_traits.hpp" #include "constexpr_char_traits.h"
template <class S> template <class S>
void void
test(const S& s, const typename S::value_type* str, typename S::size_type pos, test(const S& s, const typename S::value_type* str, typename S::size_type pos,
typename S::size_type n, typename S::size_type x) typename S::size_type n, typename S::size_type x)
{ {
assert(s.find(str, pos, n) == x); assert(s.find(str, pos, n) == x);
if (x != S::npos) if (x != S::npos)
▲ Show 20 Lines • Show All 370 Lines • Show Last 20 Lines

libcxx/trunk/test/std/strings/string.view/string.view.find/find_string_view_size.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
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// <string_view> // <string_view>
// constexpr size_type find(const basic_string_view& str, size_type pos = 0) const; // constexpr size_type find(const basic_string_view& str, size_type pos = 0) const;
#include <string_view> #include <string_view>
#include <cassert> #include <cassert>
#include "test_macros.h" #include "test_macros.h"
#include "constexpr_char_traits.hpp" #include "constexpr_char_traits.h"
template <class S> template <class S>
void void
test(const S& s, const S& str, typename S::size_type pos, typename S::size_type x) test(const S& s, const S& str, typename S::size_type pos, typename S::size_type x)
{ {
assert(s.find(str, pos) == x); assert(s.find(str, pos) == x);
if (x != S::npos) if (x != S::npos)
assert(pos <= x && x + str.size() <= s.size()); assert(pos <= x && x + str.size() <= s.size());
▲ Show 20 Lines • Show All 141 Lines • Show Last 20 Lines

libcxx/trunk/test/std/strings/string.view/string.view.find/rfind_char_size.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
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// <string_view> // <string_view>
// constexpr size_type rfind(charT c, size_type pos = npos) const; // constexpr size_type rfind(charT c, size_type pos = npos) const;
#include <string_view> #include <string_view>
#include <cassert> #include <cassert>
#include "test_macros.h" #include "test_macros.h"
#include "constexpr_char_traits.hpp" #include "constexpr_char_traits.h"
template <class S> template <class S>
void void
test(const S& s, typename S::value_type c, typename S::size_type pos, test(const S& s, typename S::value_type c, typename S::size_type pos,
typename S::size_type x) typename S::size_type x)
{ {
assert(s.rfind(c, pos) == x); assert(s.rfind(c, pos) == x);
if (x != S::npos) if (x != S::npos)
▲ Show 20 Lines • Show All 61 Lines • Show Last 20 Lines

libcxx/trunk/test/std/strings/string.view/string.view.find/rfind_pointer_size.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
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// <string_view> // <string_view>
// constexpr size_type rfind(const charT* s, size_type pos = npos) const; // constexpr size_type rfind(const charT* s, size_type pos = npos) const;
#include <string_view> #include <string_view>
#include <cassert> #include <cassert>
#include "test_macros.h" #include "test_macros.h"
#include "constexpr_char_traits.hpp" #include "constexpr_char_traits.h"
template <class S> template <class S>
void void
test(const S& s, const typename S::value_type* str, typename S::size_type pos, test(const S& s, const typename S::value_type* str, typename S::size_type pos,
typename S::size_type x) typename S::size_type x)
{ {
assert(s.rfind(str, pos) == x); assert(s.rfind(str, pos) == x);
if (x != S::npos) if (x != S::npos)
▲ Show 20 Lines • Show All 149 Lines • Show Last 20 Lines

libcxx/trunk/test/std/strings/string.view/string.view.find/rfind_pointer_size_size.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
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// <string_view> // <string_view>
// constexpr size_type rfind(const charT* s, size_type pos, size_type n) const; // constexpr size_type rfind(const charT* s, size_type pos, size_type n) const;
#include <string_view> #include <string_view>
#include <cassert> #include <cassert>
#include "test_macros.h" #include "test_macros.h"
#include "constexpr_char_traits.hpp" #include "constexpr_char_traits.h"
template <class S> template <class S>
void void
test(const S& s, const typename S::value_type* str, typename S::size_type pos, test(const S& s, const typename S::value_type* str, typename S::size_type pos,
typename S::size_type n, typename S::size_type x) typename S::size_type n, typename S::size_type x)
{ {
assert(s.rfind(str, pos, n) == x); assert(s.rfind(str, pos, n) == x);
if (x != S::npos) if (x != S::npos)
▲ Show 20 Lines • Show All 370 Lines • Show Last 20 Lines

libcxx/trunk/test/std/strings/string.view/string.view.find/rfind_string_view_size.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
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// <string_view> // <string_view>
// constexpr size_type rfind(const basic_string& str, size_type pos = npos) const; // constexpr size_type rfind(const basic_string& str, size_type pos = npos) const;
#include <string_view> #include <string_view>
#include <cassert> #include <cassert>
#include "test_macros.h" #include "test_macros.h"
#include "constexpr_char_traits.hpp" #include "constexpr_char_traits.h"
template <class S> template <class S>
void void
test(const S& s, const S& str, typename S::size_type pos, typename S::size_type x) test(const S& s, const S& str, typename S::size_type pos, typename S::size_type x)
{ {
assert(s.rfind(str, pos) == x); assert(s.rfind(str, pos) == x);
if (x != S::npos) if (x != S::npos)
assert(x <= pos && x + str.size() <= s.size()); assert(x <= pos && x + str.size() <= s.size());
▲ Show 20 Lines • Show All 141 Lines • Show Last 20 Lines

libcxx/trunk/test/std/strings/string.view/string.view.ops/compare.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
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// <string_view> // <string_view>
// constexpr int compare(const charT* s) const; // constexpr int compare(const charT* s) const;
#include <string_view> #include <string_view>
#include <cassert> #include <cassert>
#include "test_macros.h" #include "test_macros.h"
#include "constexpr_char_traits.hpp" #include "constexpr_char_traits.h"
int sign ( int x ) { return x > 0 ? 1 : ( x < 0 ? -1 : 0 ); } int sign ( int x ) { return x > 0 ? 1 : ( x < 0 ? -1 : 0 ); }
template<typename CharT> template<typename CharT>
void test1 ( std::basic_string_view<CharT> sv1, const CharT *s, int expected ) { void test1 ( std::basic_string_view<CharT> sv1, const CharT *s, int expected ) {
assert ( sign( sv1.compare(s)) == sign(expected)); assert ( sign( sv1.compare(s)) == sign(expected));
} }
▲ Show 20 Lines • Show All 103 Lines • Show Last 20 Lines

libcxx/trunk/test/std/strings/string.view/string.view.ops/compare.pointer_size.pass.cpp

Show All 9 Lines
// constexpr int compare(size_type pos1, size_type n1, const charT* s) const; // constexpr int compare(size_type pos1, size_type n1, const charT* s) const;
#include <string_view> #include <string_view>
#include <cassert> #include <cassert>
#include <stdexcept> #include <stdexcept>
#include "test_macros.h" #include "test_macros.h"
#include "constexpr_char_traits.hpp" #include "constexpr_char_traits.h"
int sign ( int x ) { return x > 0 ? 1 : ( x < 0 ? -1 : 0 ); } int sign ( int x ) { return x > 0 ? 1 : ( x < 0 ? -1 : 0 ); }
template<typename CharT> template<typename CharT>
void test1 ( std::basic_string_view<CharT> sv1, void test1 ( std::basic_string_view<CharT> sv1,
size_t pos1, size_t n1, const CharT *s, int expected ) { size_t pos1, size_t n1, const CharT *s, int expected ) {
#ifdef TEST_HAS_NO_EXCEPTIONS #ifdef TEST_HAS_NO_EXCEPTIONS
if (pos1 <= sv1.size()) if (pos1 <= sv1.size())
▲ Show 20 Lines • Show All 428 Lines • Show Last 20 Lines

libcxx/trunk/test/std/strings/string.view/string.view.ops/compare.size_size_sv.pass.cpp

Show All 9 Lines
// constexpr int compare(size_type pos1, size_type n1, basic_string_view str) const; // constexpr int compare(size_type pos1, size_type n1, basic_string_view str) const;
#include <string_view> #include <string_view>
#include <cassert> #include <cassert>
#include <stdexcept> #include <stdexcept>
#include "test_macros.h" #include "test_macros.h"
#include "constexpr_char_traits.hpp" #include "constexpr_char_traits.h"
int sign ( int x ) { return x > 0 ? 1 : ( x < 0 ? -1 : 0 ); } int sign ( int x ) { return x > 0 ? 1 : ( x < 0 ? -1 : 0 ); }
template<typename CharT> template<typename CharT>
void test1 ( std::basic_string_view<CharT> sv1, size_t pos1, size_t n1, void test1 ( std::basic_string_view<CharT> sv1, size_t pos1, size_t n1,
std::basic_string_view<CharT> sv2, int expected ) { std::basic_string_view<CharT> sv2, int expected ) {
#ifdef TEST_HAS_NO_EXCEPTIONS #ifdef TEST_HAS_NO_EXCEPTIONS
if (pos1 <= sv1.size()) if (pos1 <= sv1.size())
▲ Show 20 Lines • Show All 377 Lines • Show Last 20 Lines

libcxx/trunk/test/std/strings/string.view/string.view.ops/compare.size_size_sv_pointer_size.pass.cpp

Show All 10 Lines
// constexpr int compare(size_type pos1, size_type n1, // constexpr int compare(size_type pos1, size_type n1,
// const charT* s, size_type n2) const; // const charT* s, size_type n2) const;
#include <string_view> #include <string_view>
#include <cassert> #include <cassert>
#include <stdexcept> #include <stdexcept>
#include "test_macros.h" #include "test_macros.h"
#include "constexpr_char_traits.hpp" #include "constexpr_char_traits.h"
int sign ( int x ) { return x > 0 ? 1 : ( x < 0 ? -1 : 0 ); } int sign ( int x ) { return x > 0 ? 1 : ( x < 0 ? -1 : 0 ); }
template<typename CharT> template<typename CharT>
void test1 ( std::basic_string_view<CharT> sv1, size_t pos1, size_t n1, void test1 ( std::basic_string_view<CharT> sv1, size_t pos1, size_t n1,
const CharT *s2, size_t n2, int expected ) { const CharT *s2, size_t n2, int expected ) {
#ifdef TEST_HAS_NO_EXCEPTIONS #ifdef TEST_HAS_NO_EXCEPTIONS
if (pos1 <= sv1.size()) if (pos1 <= sv1.size())
▲ Show 20 Lines • Show All 1,327 Lines • Show Last 20 Lines

libcxx/trunk/test/std/strings/string.view/string.view.ops/compare.size_size_sv_size_size.pass.cpp

  • This file is larger than 256 KB, so syntax highlighting is disabled by default.
Show All 10 Lines
// constexpr int compare(size_type pos1, size_type n1, basic_string_view str, // constexpr int compare(size_type pos1, size_type n1, basic_string_view str,
// size_type pos2, size_type n2) const; // size_type pos2, size_type n2) const;
#include <string_view> #include <string_view>
#include <cassert> #include <cassert>
#include <stdexcept> #include <stdexcept>
#include "test_macros.h" #include "test_macros.h"
#include "constexpr_char_traits.hpp" #include "constexpr_char_traits.h"
int sign ( int x ) { return x > 0 ? 1 : ( x < 0 ? -1 : 0 ); } int sign ( int x ) { return x > 0 ? 1 : ( x < 0 ? -1 : 0 ); }
template<typename CharT> template<typename CharT>
void test1 ( std::basic_string_view<CharT> sv1, size_t pos1, size_t n1, void test1 ( std::basic_string_view<CharT> sv1, size_t pos1, size_t n1,
std::basic_string_view<CharT> sv2, size_t pos2, size_t n2, std::basic_string_view<CharT> sv2, size_t pos2, size_t n2,
int expected ) { int expected ) {
#ifdef TEST_HAS_NO_EXCEPTIONS #ifdef TEST_HAS_NO_EXCEPTIONS
▲ Show 20 Lines • Show All 5,822 Lines • Show Last 20 Lines

libcxx/trunk/test/std/strings/string.view/string.view.ops/compare.sv.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
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// <string_view> // <string_view>
// constexpr int compare(basic_string_view str) const noexcept; // constexpr int compare(basic_string_view str) const noexcept;
#include <string_view> #include <string_view>
#include <cassert> #include <cassert>
#include "test_macros.h" #include "test_macros.h"
#include "constexpr_char_traits.hpp" #include "constexpr_char_traits.h"
int sign ( int x ) { return x > 0 ? 1 : ( x < 0 ? -1 : 0 ); } int sign ( int x ) { return x > 0 ? 1 : ( x < 0 ? -1 : 0 ); }
template<typename CharT> template<typename CharT>
void test1 ( std::basic_string_view<CharT> sv1, void test1 ( std::basic_string_view<CharT> sv1,
std::basic_string_view<CharT> sv2, int expected ) { std::basic_string_view<CharT> sv2, int expected ) {
assert ( sign( sv1.compare(sv2)) == sign(expected)); assert ( sign( sv1.compare(sv2)) == sign(expected));
} }
▲ Show 20 Lines • Show All 98 Lines • Show Last 20 Lines

libcxx/trunk/test/std/strings/string.view/string.view.template/ends_with.char.pass.cpp

Show All 9 Lines
// <string_view> // <string_view>
// constexpr bool ends_with(charT x) const noexcept; // constexpr bool ends_with(charT x) const noexcept;
#include <string_view> #include <string_view>
#include <cassert> #include <cassert>
#include "test_macros.h" #include "test_macros.h"
#include "constexpr_char_traits.hpp" #include "constexpr_char_traits.h"
int main(int, char**) int main(int, char**)
{ {
{ {
typedef std::string_view SV; typedef std::string_view SV;
SV sv1 {}; SV sv1 {};
SV sv2 { "abcde", 5 }; SV sv2 { "abcde", 5 };
Show All 22 Lines

libcxx/trunk/test/std/strings/string.view/string.view.template/ends_with.ptr.pass.cpp

Show All 9 Lines
// <string_view> // <string_view>
// constexpr bool starts_with(const CharT *x) const; // constexpr bool starts_with(const CharT *x) const;
#include <string_view> #include <string_view>
#include <cassert> #include <cassert>
#include "test_macros.h" #include "test_macros.h"
#include "constexpr_char_traits.hpp" #include "constexpr_char_traits.h"
int main(int, char**) int main(int, char**)
{ {
{ {
typedef std::string_view SV; typedef std::string_view SV;
const char *s = "abcde"; const char *s = "abcde";
SV sv0 {}; SV sv0 {};
SV sv1 { s + 4, 1 }; SV sv1 { s + 4, 1 };
▲ Show 20 Lines • Show All 79 Lines • Show Last 20 Lines

libcxx/trunk/test/std/strings/string.view/string.view.template/ends_with.string_view.pass.cpp

Show All 9 Lines
// <string_view> // <string_view>
// constexpr bool ends_with(string_view x) const noexcept; // constexpr bool ends_with(string_view x) const noexcept;
#include <string_view> #include <string_view>
#include <cassert> #include <cassert>
#include "test_macros.h" #include "test_macros.h"
#include "constexpr_char_traits.hpp" #include "constexpr_char_traits.h"
int main(int, char**) int main(int, char**)
{ {
{ {
typedef std::string_view SV; typedef std::string_view SV;
const char *s = "abcde"; const char *s = "abcde";
SV sv0; SV sv0;
SV sv1 { s + 4, 1 }; SV sv1 { s + 4, 1 };
▲ Show 20 Lines • Show All 79 Lines • Show Last 20 Lines

libcxx/trunk/test/std/strings/string.view/string.view.template/starts_with.char.pass.cpp

Show All 9 Lines
// <string_view> // <string_view>
// constexpr bool starts_with(charT x) const noexcept; // constexpr bool starts_with(charT x) const noexcept;
#include <string_view> #include <string_view>
#include <cassert> #include <cassert>
#include "test_macros.h" #include "test_macros.h"
#include "constexpr_char_traits.hpp" #include "constexpr_char_traits.h"
int main(int, char**) int main(int, char**)
{ {
{ {
typedef std::string_view SV; typedef std::string_view SV;
SV sv1 {}; SV sv1 {};
SV sv2 { "abcde", 5 }; SV sv2 { "abcde", 5 };
Show All 22 Lines

libcxx/trunk/test/std/strings/string.view/string.view.template/starts_with.ptr.pass.cpp

Show All 9 Lines
// <string_view> // <string_view>
// constexpr bool starts_with(string_view x) const noexcept; // constexpr bool starts_with(string_view x) const noexcept;
#include <string_view> #include <string_view>
#include <cassert> #include <cassert>
#include "test_macros.h" #include "test_macros.h"
#include "constexpr_char_traits.hpp" #include "constexpr_char_traits.h"
int main(int, char**) int main(int, char**)
{ {
{ {
typedef std::string_view SV; typedef std::string_view SV;
const char *s = "abcde"; const char *s = "abcde";
SV sv0 {}; SV sv0 {};
SV sv1 { s, 1 }; SV sv1 { s, 1 };
▲ Show 20 Lines • Show All 79 Lines • Show Last 20 Lines

libcxx/trunk/test/std/strings/string.view/string.view.template/starts_with.string_view.pass.cpp

Show All 9 Lines
// <string_view> // <string_view>
// constexpr bool starts_with(string_view x) const noexcept; // constexpr bool starts_with(string_view x) const noexcept;
#include <string_view> #include <string_view>
#include <cassert> #include <cassert>
#include "test_macros.h" #include "test_macros.h"
#include "constexpr_char_traits.hpp" #include "constexpr_char_traits.h"
int main(int, char**) int main(int, char**)
{ {
{ {
typedef std::string_view SV; typedef std::string_view SV;
const char *s = "abcde"; const char *s = "abcde";
SV sv0 {}; SV sv0 {};
SV sv1 { s, 1 }; SV sv1 { s, 1 };
▲ Show 20 Lines • Show All 79 Lines • Show Last 20 Lines

libcxx/trunk/test/std/thread/thread.mutex/thread.lock/thread.lock.shared/thread.lock.shared.cons/move_assign.pass.cpp

Show All 12 Lines
// <shared_mutex> // <shared_mutex>
// template <class Mutex> class shared_lock; // template <class Mutex> class shared_lock;
// shared_lock& operator=(shared_lock&& u); // shared_lock& operator=(shared_lock&& u);
#include <shared_mutex> #include <shared_mutex>
#include <cassert> #include <cassert>
#include "nasty_containers.hpp" #include "nasty_containers.h"
#include "test_macros.h" #include "test_macros.h"
int main(int, char**) int main(int, char**)
{ {
{ {
typedef std::shared_timed_mutex M; typedef std::shared_timed_mutex M;
Show All 25 Lines

libcxx/trunk/test/std/thread/thread.mutex/thread.lock/thread.lock.shared/thread.lock.shared.cons/move_ctor.pass.cpp

Show All 12 Lines
// <shared_mutex> // <shared_mutex>
// template <class Mutex> class shared_lock; // template <class Mutex> class shared_lock;
// shared_lock(shared_lock&& u); // shared_lock(shared_lock&& u);
#include <shared_mutex> #include <shared_mutex>
#include <cassert> #include <cassert>
#include "nasty_containers.hpp" #include "nasty_containers.h"
#include "test_macros.h" #include "test_macros.h"
int main(int, char**) int main(int, char**)
{ {
{ {
typedef std::shared_timed_mutex M; typedef std::shared_timed_mutex M;
M m; M m;
Show All 20 Lines

libcxx/trunk/test/std/thread/thread.mutex/thread.lock/thread.lock.shared/thread.lock.shared.cons/mutex_adopt_lock.pass.cpp

Show All 12 Lines
// <shared_mutex> // <shared_mutex>
// template <class Mutex> class shared_lock; // template <class Mutex> class shared_lock;
// shared_lock(mutex_type& m, adopt_lock_t); // shared_lock(mutex_type& m, adopt_lock_t);
#include <shared_mutex> #include <shared_mutex>
#include <cassert> #include <cassert>
#include "nasty_containers.hpp" #include "nasty_containers.h"
#include "test_macros.h" #include "test_macros.h"
int main(int, char**) int main(int, char**)
{ {
{ {
typedef std::shared_timed_mutex M; typedef std::shared_timed_mutex M;
M m; M m;
Show All 16 Lines

libcxx/trunk/test/std/thread/thread.mutex/thread.lock/thread.lock.shared/thread.lock.shared.cons/mutex_defer_lock.pass.cpp

Show All 12 Lines
// <shared_mutex> // <shared_mutex>
// template <class Mutex> class shared_lock; // template <class Mutex> class shared_lock;
// shared_lock(mutex_type& m, defer_lock_t); // shared_lock(mutex_type& m, defer_lock_t);
#include <shared_mutex> #include <shared_mutex>
#include <cassert> #include <cassert>
#include "nasty_containers.hpp" #include "nasty_containers.h"
#include "test_macros.h" #include "test_macros.h"
int main(int, char**) int main(int, char**)
{ {
{ {
typedef std::shared_timed_mutex M; typedef std::shared_timed_mutex M;
M m; M m;
Show All 14 Lines

libcxx/trunk/test/std/thread/thread.mutex/thread.lock/thread.lock.unique/thread.lock.unique.cons/move_assign.pass.cpp

Show All 10 Lines
// <mutex> // <mutex>
// template <class Mutex> class unique_lock; // template <class Mutex> class unique_lock;
// unique_lock& operator=(unique_lock&& u); // unique_lock& operator=(unique_lock&& u);
#include <mutex> #include <mutex>
#include <cassert> #include <cassert>
#include "nasty_containers.hpp" #include "nasty_containers.h"
#include "test_macros.h" #include "test_macros.h"
int main(int, char**) int main(int, char**)
{ {
{ {
typedef std::mutex M; typedef std::mutex M;
M m0; M m0;
Show All 24 Lines

libcxx/trunk/test/std/thread/thread.mutex/thread.lock/thread.lock.unique/thread.lock.unique.cons/move_ctor.pass.cpp

Show All 10 Lines
// <mutex> // <mutex>
// template <class Mutex> class unique_lock; // template <class Mutex> class unique_lock;
// unique_lock(unique_lock&& u); // unique_lock(unique_lock&& u);
#include <mutex> #include <mutex>
#include <cassert> #include <cassert>
#include "nasty_containers.hpp" #include "nasty_containers.h"
#include "test_macros.h" #include "test_macros.h"
int main(int, char**) int main(int, char**)
{ {
{ {
typedef std::mutex M; typedef std::mutex M;
M m; M m;
Show All 20 Lines

libcxx/trunk/test/std/thread/thread.mutex/thread.lock/thread.lock.unique/thread.lock.unique.cons/mutex_adopt_lock.pass.cpp

Show All 10 Lines
// <mutex> // <mutex>
// template <class Mutex> class unique_lock; // template <class Mutex> class unique_lock;
// unique_lock(mutex_type& m, adopt_lock_t); // unique_lock(mutex_type& m, adopt_lock_t);
#include <mutex> #include <mutex>
#include <cassert> #include <cassert>
#include "nasty_containers.hpp" #include "nasty_containers.h"
#include "test_macros.h" #include "test_macros.h"
int main(int, char**) int main(int, char**)
{ {
{ {
typedef std::mutex M; typedef std::mutex M;
M m; M m;
Show All 16 Lines

libcxx/trunk/test/std/thread/thread.mutex/thread.lock/thread.lock.unique/thread.lock.unique.cons/mutex_defer_lock.pass.cpp

Show All 10 Lines
// <mutex> // <mutex>
// template <class Mutex> class unique_lock; // template <class Mutex> class unique_lock;
// unique_lock(mutex_type& m, defer_lock_t); // unique_lock(mutex_type& m, defer_lock_t);
#include <mutex> #include <mutex>
#include <cassert> #include <cassert>
#include "nasty_containers.hpp" #include "nasty_containers.h"
#include "test_macros.h" #include "test_macros.h"
int main(int, char**) int main(int, char**)
{ {
{ {
typedef std::mutex M; typedef std::mutex M;
M m; M m;
Show All 14 Lines

libcxx/trunk/test/std/thread/thread.threads/thread.thread.class/thread.thread.id/enabled_hashes.pass.cpp

Show All 10 Lines
// <thread> // <thread>
// Test that <thread> provides all of the arithmetic, enum, and pointer // Test that <thread> provides all of the arithmetic, enum, and pointer
// hash specializations. // hash specializations.
#include <thread> #include <thread>
#include "poisoned_hash_helper.hpp" #include "poisoned_hash_helper.h"
#include "test_macros.h" #include "test_macros.h"
int main(int, char**) { int main(int, char**) {
test_library_hash_specializations_available(); test_library_hash_specializations_available();
{ {
test_hash_enabled_for_type<std::thread::id>(); test_hash_enabled_for_type<std::thread::id>();
} }
return 0; return 0;
} }

libcxx/trunk/test/std/utilities/allocator.adaptor/allocator.adaptor.members/construct_pair.pass.cpp

Show All 16 Lines
// void scoped_allocator_adaptor::construct(pair<U1, U2>*) // void scoped_allocator_adaptor::construct(pair<U1, U2>*)
#include <scoped_allocator> #include <scoped_allocator>
#include <type_traits> #include <type_traits>
#include <utility> #include <utility>
#include <tuple> #include <tuple>
#include <cassert> #include <cassert>
#include <cstdlib> #include <cstdlib>
#include "uses_alloc_types.hpp" #include "uses_alloc_types.h"
#include "controlled_allocators.hpp" #include "controlled_allocators.h"
#include "test_macros.h" #include "test_macros.h"
void test_no_inner_alloc() void test_no_inner_alloc()
{ {
using VoidAlloc = CountingAllocator<void>; using VoidAlloc = CountingAllocator<void>;
AllocController P; AllocController P;
▲ Show 20 Lines • Show All 111 Lines • Show Last 20 Lines

libcxx/trunk/test/std/utilities/allocator.adaptor/allocator.adaptor.members/construct_pair_const_lvalue_pair.pass.cpp

Show All 16 Lines
// void scoped_allocator_adaptor::construct(pair<U1, U2>*, pair<T1, T2>const&) // void scoped_allocator_adaptor::construct(pair<U1, U2>*, pair<T1, T2>const&)
#include <scoped_allocator> #include <scoped_allocator>
#include <type_traits> #include <type_traits>
#include <utility> #include <utility>
#include <tuple> #include <tuple>
#include <cassert> #include <cassert>
#include <cstdlib> #include <cstdlib>
#include "uses_alloc_types.hpp" #include "uses_alloc_types.h"
#include "controlled_allocators.hpp" #include "controlled_allocators.h"
#include "test_macros.h" #include "test_macros.h"
void test_no_inner_alloc() void test_no_inner_alloc()
{ {
using VoidAlloc = CountingAllocator<void>; using VoidAlloc = CountingAllocator<void>;
AllocController P; AllocController P;
▲ Show 20 Lines • Show All 127 Lines • Show Last 20 Lines

libcxx/trunk/test/std/utilities/allocator.adaptor/allocator.adaptor.members/construct_pair_piecewise.pass.cpp

Show All 17 Lines
// piecewise_construct_t, tuple<Args1...>, tuple<Args2...>) // piecewise_construct_t, tuple<Args1...>, tuple<Args2...>)
#include <scoped_allocator> #include <scoped_allocator>
#include <type_traits> #include <type_traits>
#include <utility> #include <utility>
#include <tuple> #include <tuple>
#include <cassert> #include <cassert>
#include <cstdlib> #include <cstdlib>
#include "uses_alloc_types.hpp" #include "uses_alloc_types.h"
#include "controlled_allocators.hpp" #include "controlled_allocators.h"
#include "test_macros.h" #include "test_macros.h"
void test_no_inner_alloc() void test_no_inner_alloc()
{ {
using VoidAlloc = CountingAllocator<void>; using VoidAlloc = CountingAllocator<void>;
AllocController P; AllocController P;
▲ Show 20 Lines • Show All 127 Lines • Show Last 20 Lines

libcxx/trunk/test/std/utilities/allocator.adaptor/allocator.adaptor.members/construct_pair_rvalue.pass.cpp

Show All 16 Lines
// void scoped_allocator_adaptor::construct(pair<U1, U2>*, pair<T1, T2>&&) // void scoped_allocator_adaptor::construct(pair<U1, U2>*, pair<T1, T2>&&)
#include <scoped_allocator> #include <scoped_allocator>
#include <type_traits> #include <type_traits>
#include <utility> #include <utility>
#include <tuple> #include <tuple>
#include <cassert> #include <cassert>
#include <cstdlib> #include <cstdlib>
#include "uses_alloc_types.hpp" #include "uses_alloc_types.h"
#include "controlled_allocators.hpp" #include "controlled_allocators.h"
#include "test_macros.h" #include "test_macros.h"
void test_no_inner_alloc() void test_no_inner_alloc()
{ {
using VoidAlloc = CountingAllocator<void>; using VoidAlloc = CountingAllocator<void>;
AllocController P; AllocController P;
▲ Show 20 Lines • Show All 127 Lines • Show Last 20 Lines

libcxx/trunk/test/std/utilities/allocator.adaptor/allocator.adaptor.members/construct_pair_values.pass.cpp

Show All 16 Lines
// void scoped_allocator_adaptor::construct(pair<U1, U2>*, Tp&&, Up&&) // void scoped_allocator_adaptor::construct(pair<U1, U2>*, Tp&&, Up&&)
#include <scoped_allocator> #include <scoped_allocator>
#include <type_traits> #include <type_traits>
#include <utility> #include <utility>
#include <tuple> #include <tuple>
#include <cassert> #include <cassert>
#include <cstdlib> #include <cstdlib>
#include "uses_alloc_types.hpp" #include "uses_alloc_types.h"
#include "controlled_allocators.hpp" #include "controlled_allocators.h"
#include "test_macros.h" #include "test_macros.h"
void test_no_inner_alloc() void test_no_inner_alloc()
{ {
using VoidAlloc = CountingAllocator<void>; using VoidAlloc = CountingAllocator<void>;
AllocController P; AllocController P;
▲ Show 20 Lines • Show All 119 Lines • Show Last 20 Lines

libcxx/trunk/test/std/utilities/allocator.adaptor/allocator.adaptor.members/construct_type.pass.cpp

Show All 16 Lines
// void scoped_allocator_adaptor::construct(T*, Args&&...) // void scoped_allocator_adaptor::construct(T*, Args&&...)
#include <scoped_allocator> #include <scoped_allocator>
#include <type_traits> #include <type_traits>
#include <utility> #include <utility>
#include <tuple> #include <tuple>
#include <cassert> #include <cassert>
#include <cstdlib> #include <cstdlib>
#include "uses_alloc_types.hpp" #include "uses_alloc_types.h"
#include "controlled_allocators.hpp" #include "controlled_allocators.h"
#include "test_macros.h" #include "test_macros.h"
// - If uses_allocator_v<T, inner_allocator_type> is false and // - If uses_allocator_v<T, inner_allocator_type> is false and
// is_constructible_v<T, Args...> is true, calls // is_constructible_v<T, Args...> is true, calls
// OUTERMOST_ALLOC_TRAITS(*this)::construct( // OUTERMOST_ALLOC_TRAITS(*this)::construct(
// OUTERMOST (*this), p, std::forward<Args>(args)...). // OUTERMOST (*this), p, std::forward<Args>(args)...).
void test_bullet_one() { void test_bullet_one() {
▲ Show 20 Lines • Show All 102 Lines • Show Last 20 Lines

libcxx/trunk/test/std/utilities/any/any.class/any.assign/copy.pass.cpp

Show All 14 Lines
// any& operator=(any const &); // any& operator=(any const &);
// Test copy assignment // Test copy assignment
#include <any> #include <any>
#include <cassert> #include <cassert>
#include "any_helpers.h" #include "any_helpers.h"
#include "count_new.hpp" #include "count_new.h"
#include "test_macros.h" #include "test_macros.h"
using std::any; using std::any;
using std::any_cast; using std::any_cast;
template <class LHS, class RHS> template <class LHS, class RHS>
void test_copy_assign() { void test_copy_assign() {
assert(LHS::count == 0); assert(LHS::count == 0);
▲ Show 20 Lines • Show All 169 Lines • Show Last 20 Lines

libcxx/trunk/test/std/utilities/any/any.class/any.assign/value.pass.cpp

Show All 15 Lines
// any& operator=(ValueType&&); // any& operator=(ValueType&&);
// Test value copy and move assignment. // Test value copy and move assignment.
#include <any> #include <any>
#include <cassert> #include <cassert>
#include "any_helpers.h" #include "any_helpers.h"
#include "count_new.hpp" #include "count_new.h"
#include "test_macros.h" #include "test_macros.h"
using std::any; using std::any;
using std::any_cast; using std::any_cast;
template <class LHS, class RHS> template <class LHS, class RHS>
void test_assign_value() { void test_assign_value() {
assert(LHS::count == 0); assert(LHS::count == 0);
▲ Show 20 Lines • Show All 180 Lines • Show Last 20 Lines

libcxx/trunk/test/std/utilities/any/any.class/any.cons/copy.pass.cpp

Show All 12 Lines
// <any> // <any>
// any(any const &); // any(any const &);
#include <any> #include <any>
#include <cassert> #include <cassert>
#include "any_helpers.h" #include "any_helpers.h"
#include "count_new.hpp" #include "count_new.h"
#include "test_macros.h" #include "test_macros.h"
using std::any; using std::any;
using std::any_cast; using std::any_cast;
template <class Type> template <class Type>
void test_copy_throws() { void test_copy_throws() {
#if !defined(TEST_HAS_NO_EXCEPTIONS) #if !defined(TEST_HAS_NO_EXCEPTIONS)
▲ Show 20 Lines • Show All 74 Lines • Show Last 20 Lines

libcxx/trunk/test/std/utilities/any/any.class/any.cons/default.pass.cpp

Show All 12 Lines
// any() noexcept; // any() noexcept;
#include <any> #include <any>
#include <type_traits> #include <type_traits>
#include <cassert> #include <cassert>
#include "test_macros.h" #include "test_macros.h"
#include "any_helpers.h" #include "any_helpers.h"
#include "count_new.hpp" #include "count_new.h"
int main(int, char**) int main(int, char**)
{ {
using std::any; using std::any;
{ {
static_assert( static_assert(
std::is_nothrow_default_constructible<any>::value std::is_nothrow_default_constructible<any>::value
, "Must be default constructible" , "Must be default constructible"
Show All 19 Lines

libcxx/trunk/test/std/utilities/any/any.class/any.cons/in_place_type.pass.cpp

Show All 21 Lines
// 1. The value is properly move/copied depending on the value category. // 1. The value is properly move/copied depending on the value category.
// 2. Both small and large values are properly handled. // 2. Both small and large values are properly handled.
#include <any> #include <any>
#include <cassert> #include <cassert>
#include "any_helpers.h" #include "any_helpers.h"
#include "count_new.hpp" #include "count_new.h"
#include "test_macros.h" #include "test_macros.h"
#include "test_convertible.hpp" #include "test_convertible.h"
using std::any; using std::any;
using std::any_cast; using std::any_cast;
template <class Type> template <class Type>
void test_in_place_type() { void test_in_place_type() {
// constructing from a small type should perform no allocations. // constructing from a small type should perform no allocations.
DisableAllocationGuard g(isSmallType<Type>()); ((void)g); DisableAllocationGuard g(isSmallType<Type>()); ((void)g);
▲ Show 20 Lines • Show All 157 Lines • Show Last 20 Lines

libcxx/trunk/test/std/utilities/any/any.class/any.cons/move.pass.cpp

Show All 14 Lines
// any(any &&) noexcept; // any(any &&) noexcept;
#include <any> #include <any>
#include <utility> #include <utility>
#include <type_traits> #include <type_traits>
#include <cassert> #include <cassert>
#include "any_helpers.h" #include "any_helpers.h"
#include "count_new.hpp" #include "count_new.h"
#include "test_macros.h" #include "test_macros.h"
using std::any; using std::any;
using std::any_cast; using std::any_cast;
// Moves are always noexcept. The throws_on_move object // Moves are always noexcept. The throws_on_move object
// must be stored dynamically so the pointer is moved and // must be stored dynamically so the pointer is moved and
// not the stored object. // not the stored object.
▲ Show 20 Lines • Show All 76 Lines • Show Last 20 Lines

libcxx/trunk/test/std/utilities/any/any.class/any.cons/value.pass.cpp

Show All 19 Lines
// 1. The value is properly move/copied depending on the value category. // 1. The value is properly move/copied depending on the value category.
// 2. Both small and large values are properly handled. // 2. Both small and large values are properly handled.
#include <any> #include <any>
#include <cassert> #include <cassert>
#include "any_helpers.h" #include "any_helpers.h"
#include "count_new.hpp" #include "count_new.h"
#include "test_macros.h" #include "test_macros.h"
using std::any; using std::any;
using std::any_cast; using std::any_cast;
template <class Type> template <class Type>
void test_copy_value_throws() void test_copy_value_throws()
{ {
▲ Show 20 Lines • Show All 121 Lines • Show Last 20 Lines

libcxx/trunk/test/std/utilities/any/any.class/any.modifiers/emplace.pass.cpp

Show All 14 Lines
// template <class T, class ...Args> T& emplace(Args&&...); // template <class T, class ...Args> T& emplace(Args&&...);
// template <class T, class U, class ...Args> // template <class T, class U, class ...Args>
// T& emplace(initializer_list<U>, Args&&...); // T& emplace(initializer_list<U>, Args&&...);
#include <any> #include <any>
#include <cassert> #include <cassert>
#include "any_helpers.h" #include "any_helpers.h"
#include "count_new.hpp" #include "count_new.h"
#include "test_macros.h" #include "test_macros.h"
using std::any; using std::any;
using std::any_cast; using std::any_cast;
struct Tracked { struct Tracked {
static int count; static int count;
Tracked() {++count;} Tracked() {++count;}
▲ Show 20 Lines • Show All 256 Lines • Show Last 20 Lines

libcxx/trunk/test/std/utilities/any/any.nonmembers/any.cast/any_cast_reference.pass.cpp

Show All 20 Lines
// template <class ValueType> // template <class ValueType>
// ValueType any_cast(any &&); // ValueType any_cast(any &&);
#include <any> #include <any>
#include <type_traits> #include <type_traits>
#include <cassert> #include <cassert>
#include "any_helpers.h" #include "any_helpers.h"
#include "count_new.hpp" #include "count_new.h"
#include "test_macros.h" #include "test_macros.h"
using std::any; using std::any;
using std::any_cast; using std::any_cast;
using std::bad_any_cast; using std::bad_any_cast;
// Test that the operators are NOT marked noexcept. // Test that the operators are NOT marked noexcept.
▲ Show 20 Lines • Show All 279 Lines • Show Last 20 Lines

libcxx/trunk/test/std/utilities/any/any.nonmembers/make_any.pass.cpp

Show All 14 Lines
// template <class T, class ...Args> any make_any(Args&&...); // template <class T, class ...Args> any make_any(Args&&...);
// template <class T, class U, class ...Args> // template <class T, class U, class ...Args>
// any make_any(initializer_list<U>, Args&&...); // any make_any(initializer_list<U>, Args&&...);
#include <any> #include <any>
#include <cassert> #include <cassert>
#include "any_helpers.h" #include "any_helpers.h"
#include "count_new.hpp" #include "count_new.h"
#include "test_macros.h" #include "test_macros.h"
using std::any; using std::any;
using std::any_cast; using std::any_cast;
template <class Type> template <class Type>
void test_make_any_type() { void test_make_any_type() {
▲ Show 20 Lines • Show All 112 Lines • Show Last 20 Lines

libcxx/trunk/test/std/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.alg/swap.pass.cpp

Show All 13 Lines
// void swap(function<R(ArgTypes...)>&, function<R(ArgTypes...)>&) noexcept; // void swap(function<R(ArgTypes...)>&, function<R(ArgTypes...)>&) noexcept;
#include <functional> #include <functional>
#include <cstdlib> #include <cstdlib>
#include <cassert> #include <cassert>
#include "test_macros.h" #include "test_macros.h"
#include "count_new.hpp" #include "count_new.h"
class A class A
{ {
int data_[10]; int data_[10];
public: public:
static int count; static int count;
explicit A(int j) explicit A(int j)
▲ Show 20 Lines • Show All 107 Lines • Show Last 20 Lines

libcxx/trunk/test/std/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.con/F.pass.cpp

Show All 10 Lines
// class function<R(ArgTypes...)> // class function<R(ArgTypes...)>
// function(F); // function(F);
#include <functional> #include <functional>
#include <cassert> #include <cassert>
#include "test_macros.h" #include "test_macros.h"
#include "count_new.hpp" #include "count_new.h"
class A class A
{ {
int data_[10]; int data_[10];
public: public:
static int count; static int count;
A() A()
▲ Show 20 Lines • Show All 89 Lines • Show Last 20 Lines

libcxx/trunk/test/std/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.con/F_assign.pass.cpp

Show All 13 Lines
// requires CopyConstructible<F> && Callable<F, ArgTypes..> // requires CopyConstructible<F> && Callable<F, ArgTypes..>
// && Convertible<Callable<F, ArgTypes...>::result_type // && Convertible<Callable<F, ArgTypes...>::result_type
// operator=(F f); // operator=(F f);
#include <functional> #include <functional>
#include <cassert> #include <cassert>
#include "test_macros.h" #include "test_macros.h"
#include "count_new.hpp" #include "count_new.h"
class A class A
{ {
int data_[10]; int data_[10];
public: public:
static int count; static int count;
A() A()
▲ Show 20 Lines • Show All 90 Lines • Show Last 20 Lines

libcxx/trunk/test/std/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.con/alloc_F.pass.cpp

Show All 13 Lines
// template<class F, class A> function(allocator_arg_t, const A&, F); // template<class F, class A> function(allocator_arg_t, const A&, F);
#include <functional> #include <functional>
#include <cassert> #include <cassert>
#include "test_macros.h" #include "test_macros.h"
#include "min_allocator.h" #include "min_allocator.h"
#include "test_allocator.h" #include "test_allocator.h"
#include "count_new.hpp" #include "count_new.h"
#include "../function_types.h" #include "../function_types.h"
#if TEST_STD_VER >= 11 #if TEST_STD_VER >= 11
struct RValueCallable { struct RValueCallable {
template <class ...Args> template <class ...Args>
void operator()(Args&&...) && {} void operator()(Args&&...) && {}
}; };
▲ Show 20 Lines • Show All 103 Lines • Show Last 20 Lines

libcxx/trunk/test/std/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.con/alloc_function.pass.cpp

Show All 14 Lines
#include <functional> #include <functional>
#include <cassert> #include <cassert>
#include "test_macros.h" #include "test_macros.h"
#include "min_allocator.h" #include "min_allocator.h"
#include "test_allocator.h" #include "test_allocator.h"
#include "count_new.hpp" #include "count_new.h"
#include "../function_types.h" #include "../function_types.h"
class DummyClass {}; class DummyClass {};
template <class FuncType, class AllocType> template <class FuncType, class AllocType>
void test_FunctionObject(AllocType& alloc) void test_FunctionObject(AllocType& alloc)
{ {
assert(globalMemCounter.checkOutstandingNewEq(0)); assert(globalMemCounter.checkOutstandingNewEq(0));
▲ Show 20 Lines • Show All 96 Lines • Show Last 20 Lines

libcxx/trunk/test/std/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.con/alloc_rfunction.pass.cpp

Show All 17 Lines
// This signature was removed in C++17 // This signature was removed in C++17
#include <functional> #include <functional>
#include <memory> #include <memory>
#include <cassert> #include <cassert>
#include "test_macros.h" #include "test_macros.h"
#include "min_allocator.h" #include "min_allocator.h"
#include "count_new.hpp" #include "count_new.h"
class A class A
{ {
int data_[10]; int data_[10];
public: public:
static int count; static int count;
A() A()
▲ Show 20 Lines • Show All 76 Lines • Show Last 20 Lines

libcxx/trunk/test/std/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.con/copy_assign.pass.cpp

Show All 10 Lines
// class function<R(ArgTypes...)> // class function<R(ArgTypes...)>
// function& operator=(const function& f); // function& operator=(const function& f);
#include <functional> #include <functional>
#include <cassert> #include <cassert>
#include "test_macros.h" #include "test_macros.h"
#include "count_new.hpp" #include "count_new.h"
class A { class A {
int data_[10]; int data_[10];
public: public:
static int count; static int count;
A() { A() {
▲ Show 20 Lines • Show All 112 Lines • Show Last 20 Lines

libcxx/trunk/test/std/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.con/copy_move.pass.cpp

Show All 13 Lines
// function(function&& f); // noexcept in C++20 // function(function&& f); // noexcept in C++20
#include <functional> #include <functional>
#include <memory> #include <memory>
#include <cstdlib> #include <cstdlib>
#include <cassert> #include <cassert>
#include "test_macros.h" #include "test_macros.h"
#include "count_new.hpp" #include "count_new.h"
class A class A
{ {
int data_[10]; int data_[10];
public: public:
static int count; static int count;
A() A()
▲ Show 20 Lines • Show All 136 Lines • Show Last 20 Lines

libcxx/trunk/test/std/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.con/nullptr_t_assign.pass.cpp

Show All 9 Lines
// class function<R(ArgTypes...)> // class function<R(ArgTypes...)>
// function& operator=(nullptr_t); // function& operator=(nullptr_t);
#include <functional> #include <functional>
#include <cassert> #include <cassert>
#include "count_new.hpp" #include "count_new.h"
#include "test_macros.h" #include "test_macros.h"
class A class A
{ {
int data_[10]; int data_[10];
public: public:
static int count; static int count;
▲ Show 20 Lines • Show All 49 Lines • Show Last 20 Lines

libcxx/trunk/test/std/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.mod/swap.pass.cpp

Show All 9 Lines
// class function<R(ArgTypes...)> // class function<R(ArgTypes...)>
// void swap(function& other); // void swap(function& other);
#include <functional> #include <functional>
#include <cassert> #include <cassert>
#include "count_new.hpp" #include "count_new.h"
#include "test_macros.h" #include "test_macros.h"
class A { class A {
int data_[10]; int data_[10];
public: public:
static int count; static int count;
▲ Show 20 Lines • Show All 170 Lines • Show Last 20 Lines

libcxx/trunk/test/std/utilities/function.objects/refwrap/refwrap.helpers/ref_2.pass.cpp

Show All 9 Lines
// reference_wrapper // reference_wrapper
// template <ObjectType T> reference_wrapper<T> ref(reference_wrapper<T>t); // template <ObjectType T> reference_wrapper<T> ref(reference_wrapper<T>t);
#include <functional> #include <functional>
#include <cassert> #include <cassert>
#include "counting_predicates.hpp" #include "counting_predicates.h"
#include "test_macros.h" #include "test_macros.h"
bool is5 ( int i ) { return i == 5; } bool is5 ( int i ) { return i == 5; }
template <typename T> template <typename T>
bool call_pred ( T pred ) { return pred(5); } bool call_pred ( T pred ) { return pred(5); }
Show All 20 Lines

libcxx/trunk/test/std/utilities/function.objects/unord.hash/enabled_hashes.pass.cpp

Show All 9 Lines
// <functional> // <functional>
// Test that <functional> provides all of the arithmetic, enum, and pointer // Test that <functional> provides all of the arithmetic, enum, and pointer
// hash specializations. // hash specializations.
#include <functional> #include <functional>
#include "poisoned_hash_helper.hpp" #include "poisoned_hash_helper.h"
#include "test_macros.h" #include "test_macros.h"
int main(int, char**) { int main(int, char**) {
test_library_hash_specializations_available(); test_library_hash_specializations_available();
return 0; return 0;
} }

libcxx/trunk/test/std/utilities/memory/default.allocator/allocator.members/allocate.pass.cpp

Show All 10 Lines
// allocator: // allocator:
// pointer allocate(size_type n, allocator<void>::const_pointer hint=0); // pointer allocate(size_type n, allocator<void>::const_pointer hint=0);
#include <memory> #include <memory>
#include <cassert> #include <cassert>
#include <cstddef> // for std::max_align_t #include <cstddef> // for std::max_align_t
#include "test_macros.h" #include "test_macros.h"
#include "count_new.hpp" #include "count_new.h"
#ifdef TEST_HAS_NO_ALIGNED_ALLOCATION #ifdef TEST_HAS_NO_ALIGNED_ALLOCATION
static const bool UsingAlignedNew = false; static const bool UsingAlignedNew = false;
#else #else
static const bool UsingAlignedNew = true; static const bool UsingAlignedNew = true;
#endif #endif
▲ Show 20 Lines • Show All 85 Lines • Show Last 20 Lines

libcxx/trunk/test/std/utilities/memory/default.allocator/allocator.members/construct.pass.cpp

Show All 9 Lines
// allocator: // allocator:
// template <class... Args> void construct(pointer p, Args&&... args); // template <class... Args> void construct(pointer p, Args&&... args);
#include <memory> #include <memory>
#include <cassert> #include <cassert>
#include "test_macros.h" #include "test_macros.h"
#include "count_new.hpp" #include "count_new.h"
int A_constructed = 0; int A_constructed = 0;
struct A struct A
{ {
int data; int data;
A() {++A_constructed;} A() {++A_constructed;}
▲ Show 20 Lines • Show All 118 Lines • Show Last 20 Lines

libcxx/trunk/test/std/utilities/memory/util.smartptr/util.smartptr.hash/enabled_hash.pass.cpp

Show All 9 Lines
// <memory> // <memory>
// Test that <memory> provides all of the arithmetic, enum, and pointer // Test that <memory> provides all of the arithmetic, enum, and pointer
// hash specializations. // hash specializations.
#include <memory> #include <memory>
#include "poisoned_hash_helper.hpp" #include "poisoned_hash_helper.h"
#include "test_macros.h" #include "test_macros.h"
int main(int, char**) { int main(int, char**) {
test_library_hash_specializations_available(); test_library_hash_specializations_available();
return 0; return 0;
} }

libcxx/trunk/test/std/utilities/memory/util.smartptr/util.smartptr.hash/hash_shared_ptr.pass.cpp

Show All 14 Lines
// typedef size_t result_type; // typedef size_t result_type;
// size_t operator()(const shared_ptr<T>& p) const; // size_t operator()(const shared_ptr<T>& p) const;
// }; // };
#include <memory> #include <memory>
#include <cassert> #include <cassert>
#if TEST_STD_VER >= 11 #if TEST_STD_VER >= 11
#include "poisoned_hash_helper.hpp" #include "poisoned_hash_helper.h"
#include "test_macros.h" #include "test_macros.h"
struct A {}; struct A {};
#endif #endif
int main(int, char**) int main(int, char**)
{ {
Show All 16 Lines

libcxx/trunk/test/std/utilities/memory/util.smartptr/util.smartptr.hash/hash_unique_ptr.pass.cpp

Show All 16 Lines
// }; // };
#include <memory> #include <memory>
#include <cassert> #include <cassert>
#include "test_macros.h" #include "test_macros.h"
#if TEST_STD_VER >= 11 #if TEST_STD_VER >= 11
#include "poisoned_hash_helper.hpp" #include "poisoned_hash_helper.h"
#include "deleter_types.h" #include "deleter_types.h"
#include "min_allocator.h" #include "min_allocator.h"
template <class ValueT, class Del> template <class ValueT, class Del>
void test_enabled_with_deleter() { void test_enabled_with_deleter() {
using UPtr = std::unique_ptr<ValueT, Del>; using UPtr = std::unique_ptr<ValueT, Del>;
using pointer = typename UPtr::pointer; using pointer = typename UPtr::pointer;
using RawDel = typename std::decay<Del>::type; using RawDel = typename std::decay<Del>::type;
▲ Show 20 Lines • Show All 71 Lines • Show Last 20 Lines

libcxx/trunk/test/std/utilities/memory/util.smartptr/util.smartptr.enab/enable_shared_from_this.pass.cpp

Show All 19 Lines
// weak_ptr<T> weak_from_this() noexcept; // C++17 // weak_ptr<T> weak_from_this() noexcept; // C++17
// weak_ptr<T const> weak_from_this() const noexecpt; // C++17 // weak_ptr<T const> weak_from_this() const noexecpt; // C++17
// }; // };
#include <memory> #include <memory>
#include <cassert> #include <cassert>
#include "test_macros.h" #include "test_macros.h"
#include "count_new.hpp" #include "count_new.h"
struct T struct T
: public std::enable_shared_from_this<T> : public std::enable_shared_from_this<T>
{ {
}; };
struct Y : T {}; struct Y : T {};
▲ Show 20 Lines • Show All 136 Lines • Show Last 20 Lines

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

Show All 13 Lines
#define _LIBCPP_DISABLE_DEPRECATION_WARNINGS #define _LIBCPP_DISABLE_DEPRECATION_WARNINGS
#include <memory> #include <memory>
#include <new> #include <new>
#include <cstdlib> #include <cstdlib>
#include <cassert> #include <cassert>
#include "test_macros.h" #include "test_macros.h"
#include "count_new.hpp" #include "count_new.h"
struct B struct B
{ {
static int count; static int count;
B() {++count;} B() {++count;}
B(const B&) {++count;} B(const B&) {++count;}
virtual ~B() {--count;} virtual ~B() {--count;}
▲ Show 20 Lines • Show All 70 Lines • Show Last 20 Lines

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

Show All 15 Lines
// template<class D> shared_ptr(nullptr_t, D d); // template<class D> shared_ptr(nullptr_t, D d);
#include <memory> #include <memory>
#include <cassert> #include <cassert>
#include <new> #include <new>
#include <cstdlib> #include <cstdlib>
#include "test_macros.h" #include "test_macros.h"
#include "count_new.hpp" #include "count_new.h"
#include "deleter_types.h" #include "deleter_types.h"
struct A struct A
{ {
static int count; static int count;
A() {++count;} A() {++count;}
Show All 24 Lines

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

Show All 14 Lines
// template<class Y, class D> shared_ptr(Y* p, D d); // template<class Y, class D> shared_ptr(Y* p, D d);
#include <memory> #include <memory>
#include <cassert> #include <cassert>
#include <new> #include <new>
#include <cstdlib> #include <cstdlib>
#include "count_new.hpp" #include "count_new.h"
#include "test_macros.h" #include "test_macros.h"
#include "deleter_types.h" #include "deleter_types.h"
struct A struct A
{ {
static int count; static int count;
A() {++count;} A() {++count;}
Show All 25 Lines

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

Show All 13 Lines
// template<class Y> explicit shared_ptr(Y* p); // template<class Y> explicit shared_ptr(Y* p);
#include <memory> #include <memory>
#include <new> #include <new>
#include <cstdlib> #include <cstdlib>
#include <cassert> #include <cassert>
#include "count_new.hpp" #include "count_new.h"
#include "test_macros.h" #include "test_macros.h"
struct A struct A
{ {
static int count; static int count;
A() {++count;} A() {++count;}
Show All 25 Lines

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

Show All 12 Lines
// template <class Y, class D> explicit shared_ptr(unique_ptr<Y, D>&&r); // template <class Y, class D> explicit shared_ptr(unique_ptr<Y, D>&&r);
#include <memory> #include <memory>
#include <new> #include <new>
#include <cstdlib> #include <cstdlib>
#include <cassert> #include <cassert>
#include "test_macros.h" #include "test_macros.h"
#include "count_new.hpp" #include "count_new.h"
struct B struct B
{ {
static int count; static int count;
B() {++count;} B() {++count;}
B(const B&) {++count;} B(const B&) {++count;}
virtual ~B() {--count;} virtual ~B() {--count;}
▲ Show 20 Lines • Show All 73 Lines • Show Last 20 Lines

libcxx/trunk/test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.create/make_shared.pass.cpp

Show All 10 Lines
// shared_ptr // shared_ptr
// template<class T, class... Args> shared_ptr<T> make_shared(Args&&... args); // template<class T, class... Args> shared_ptr<T> make_shared(Args&&... args);
#include <memory> #include <memory>
#include <cassert> #include <cassert>
#include "test_macros.h" #include "test_macros.h"
#include "count_new.hpp" #include "count_new.h"
#if TEST_STD_VER >= 11 #if TEST_STD_VER >= 11
#define DELETE_FUNCTION = delete #define DELETE_FUNCTION = delete
#else #else
#define DELETE_FUNCTION #define DELETE_FUNCTION
#endif #endif
struct A struct A
▲ Show 20 Lines • Show All 85 Lines • Show Last 20 Lines

libcxx/trunk/test/std/utilities/optional/optional.hash/enabled_hash.pass.cpp

Show All 9 Lines
// <optional> // <optional>
// Test that <optional> provides all of the arithmetic, enum, and pointer // Test that <optional> provides all of the arithmetic, enum, and pointer
// hash specializations. // hash specializations.
#include <optional> #include <optional>
#include "poisoned_hash_helper.hpp" #include "poisoned_hash_helper.h"
#include "test_macros.h" #include "test_macros.h"
int main(int, char**) { int main(int, char**) {
test_library_hash_specializations_available(); test_library_hash_specializations_available();
{ {
} }
return 0; return 0;
} }

libcxx/trunk/test/std/utilities/optional/optional.hash/hash.pass.cpp

Show All 10 Lines
// template <class T> struct hash<optional<T>>; // template <class T> struct hash<optional<T>>;
#include <optional> #include <optional>
#include <string> #include <string>
#include <memory> #include <memory>
#include <cassert> #include <cassert>
#include "poisoned_hash_helper.hpp" #include "poisoned_hash_helper.h"
#include "test_macros.h" #include "test_macros.h"
struct A {}; struct A {};
struct B {}; struct B {};
namespace std { namespace std {
▲ Show 20 Lines • Show All 56 Lines • Show Last 20 Lines

libcxx/trunk/test/std/utilities/optional/optional.object/optional.object.assign/assign_value.pass.cpp

Show All 11 Lines
// template <class U> optional<T>& operator=(U&& v); // template <class U> optional<T>& operator=(U&& v);
#include <optional> #include <optional>
#include <type_traits> #include <type_traits>
#include <cassert> #include <cassert>
#include <memory> #include <memory>
#include "test_macros.h" #include "test_macros.h"
#include "archetypes.hpp" #include "archetypes.h"
using std::optional; using std::optional;
struct ThrowAssign { struct ThrowAssign {
static int dtor_called; static int dtor_called;
ThrowAssign() = default; ThrowAssign() = default;
ThrowAssign(int) { TEST_THROW(42); } ThrowAssign(int) { TEST_THROW(42); }
ThrowAssign& operator=(int) { ThrowAssign& operator=(int) {
▲ Show 20 Lines • Show All 257 Lines • Show Last 20 Lines

libcxx/trunk/test/std/utilities/optional/optional.object/optional.object.assign/const_optional_U.pass.cpp

Show All 12 Lines
// template<class U> // template<class U>
// optional<T>& operator=(const optional<U>& rhs); // optional<T>& operator=(const optional<U>& rhs);
#include <optional> #include <optional>
#include <type_traits> #include <type_traits>
#include <cassert> #include <cassert>
#include "test_macros.h" #include "test_macros.h"
#include "archetypes.hpp" #include "archetypes.h"
using std::optional; using std::optional;
struct X struct X
{ {
static bool throw_now; static bool throw_now;
X() = default; X() = default;
▲ Show 20 Lines • Show All 226 Lines • Show Last 20 Lines

libcxx/trunk/test/std/utilities/optional/optional.object/optional.object.assign/copy.pass.cpp

Show All 10 Lines
// optional<T>& operator=(const optional<T>& rhs); // constexpr in C++20 // optional<T>& operator=(const optional<T>& rhs); // constexpr in C++20
#include <optional> #include <optional>
#include <type_traits> #include <type_traits>
#include <cassert> #include <cassert>
#include "test_macros.h" #include "test_macros.h"
#include "archetypes.hpp" #include "archetypes.h"
using std::optional; using std::optional;
struct X struct X
{ {
static bool throw_now; static bool throw_now;
X() = default; X() = default;
▲ Show 20 Lines • Show All 80 Lines • Show Last 20 Lines

libcxx/trunk/test/std/utilities/optional/optional.object/optional.object.assign/emplace.pass.cpp

Show All 11 Lines
// template <class... Args> T& optional<T>::emplace(Args&&... args); // template <class... Args> T& optional<T>::emplace(Args&&... args);
#include <optional> #include <optional>
#include <type_traits> #include <type_traits>
#include <cassert> #include <cassert>
#include <memory> #include <memory>
#include "test_macros.h" #include "test_macros.h"
#include "archetypes.hpp" #include "archetypes.h"
using std::optional; using std::optional;
class X class X
{ {
int i_; int i_;
int j_ = 0; int j_ = 0;
public: public:
▲ Show 20 Lines • Show All 242 Lines • Show Last 20 Lines

libcxx/trunk/test/std/utilities/optional/optional.object/optional.object.assign/move.pass.cpp

Show All 13 Lines
// is_nothrow_move_constructible<T>::value); // constexpr in C++20 // is_nothrow_move_constructible<T>::value); // constexpr in C++20
#include <optional> #include <optional>
#include <cassert> #include <cassert>
#include <type_traits> #include <type_traits>
#include <utility> #include <utility>
#include "test_macros.h" #include "test_macros.h"
#include "archetypes.hpp" #include "archetypes.h"
using std::optional; using std::optional;
struct X struct X
{ {
static bool throw_now; static bool throw_now;
static int alive; static int alive;
▲ Show 20 Lines • Show All 178 Lines • Show Last 20 Lines

libcxx/trunk/test/std/utilities/optional/optional.object/optional.object.assign/nullopt_t.pass.cpp

Show All 10 Lines
// optional<T>& operator=(nullopt_t) noexcept; // optional<T>& operator=(nullopt_t) noexcept;
#include <optional> #include <optional>
#include <type_traits> #include <type_traits>
#include <cassert> #include <cassert>
#include "test_macros.h" #include "test_macros.h"
#include "archetypes.hpp" #include "archetypes.h"
using std::optional; using std::optional;
using std::nullopt_t; using std::nullopt_t;
using std::nullopt; using std::nullopt;
int main(int, char**) int main(int, char**)
{ {
{ {
▲ Show 20 Lines • Show All 41 Lines • Show Last 20 Lines

libcxx/trunk/test/std/utilities/optional/optional.object/optional.object.assign/optional_U.pass.cpp

Show All 13 Lines
// optional<T>& operator=(optional<U>&& rhs); // optional<T>& operator=(optional<U>&& rhs);
#include <optional> #include <optional>
#include <type_traits> #include <type_traits>
#include <memory> #include <memory>
#include <cassert> #include <cassert>
#include "test_macros.h" #include "test_macros.h"
#include "archetypes.hpp" #include "archetypes.h"
using std::optional; using std::optional;
struct X struct X
{ {
static bool throw_now; static bool throw_now;
X() = default; X() = default;
▲ Show 20 Lines • Show All 239 Lines • Show Last 20 Lines

libcxx/trunk/test/std/utilities/optional/optional.object/optional.object.ctor/U.pass.cpp

Show All 14 Lines
// template <class U> // template <class U>
// constexpr EXPLICIT optional(U&& u); // constexpr EXPLICIT optional(U&& u);
#include <optional> #include <optional>
#include <type_traits> #include <type_traits>
#include <cassert> #include <cassert>
#include "test_macros.h" #include "test_macros.h"
#include "archetypes.hpp" #include "archetypes.h"
#include "test_convertible.hpp" #include "test_convertible.h"
using std::optional; using std::optional;
struct ImplicitThrow struct ImplicitThrow
{ {
constexpr ImplicitThrow(int x) { if (x != -1) TEST_THROW(6);} constexpr ImplicitThrow(int x) { if (x != -1) TEST_THROW(6);}
}; };
▲ Show 20 Lines • Show All 123 Lines • Show Last 20 Lines

libcxx/trunk/test/std/utilities/optional/optional.object/optional.object.ctor/const_T.pass.cpp

Show All 13 Lines
// constexpr optional(const T& v); // constexpr optional(const T& v);
#include <optional> #include <optional>
#include <type_traits> #include <type_traits>
#include <cassert> #include <cassert>
#include "test_macros.h" #include "test_macros.h"
#include "archetypes.hpp" #include "archetypes.h"
using std::optional; using std::optional;
int main(int, char**) int main(int, char**)
{ {
{ {
typedef int T; typedef int T;
constexpr T t(5); constexpr T t(5);
▲ Show 20 Lines • Show All 101 Lines • Show Last 20 Lines

libcxx/trunk/test/std/utilities/optional/optional.object/optional.object.ctor/copy.pass.cpp

Show All 10 Lines
// constexpr optional(const optional<T>& rhs); // constexpr optional(const optional<T>& rhs);
#include <optional> #include <optional>
#include <type_traits> #include <type_traits>
#include <cassert> #include <cassert>
#include "test_macros.h" #include "test_macros.h"
#include "archetypes.hpp" #include "archetypes.h"
using std::optional; using std::optional;
template <class T, class ...InitArgs> template <class T, class ...InitArgs>
void test(InitArgs&&... args) void test(InitArgs&&... args)
{ {
const optional<T> rhs(std::forward<InitArgs>(args)...); const optional<T> rhs(std::forward<InitArgs>(args)...);
bool rhs_engaged = static_cast<bool>(rhs); bool rhs_engaged = static_cast<bool>(rhs);
▲ Show 20 Lines • Show All 147 Lines • Show Last 20 Lines

libcxx/trunk/test/std/utilities/optional/optional.object/optional.object.ctor/default.pass.cpp

Show All 10 Lines
// constexpr optional() noexcept; // constexpr optional() noexcept;
#include <optional> #include <optional>
#include <type_traits> #include <type_traits>
#include <cassert> #include <cassert>
#include "test_macros.h" #include "test_macros.h"
#include "archetypes.hpp" #include "archetypes.h"
using std::optional; using std::optional;
template <class Opt> template <class Opt>
void void
test_constexpr() test_constexpr()
{ {
static_assert(std::is_nothrow_default_constructible<Opt>::value, ""); static_assert(std::is_nothrow_default_constructible<Opt>::value, "");
▲ Show 20 Lines • Show All 55 Lines • Show Last 20 Lines

libcxx/trunk/test/std/utilities/optional/optional.object/optional.object.ctor/empty_in_place_t_does_not_clobber.pass.cpp

Show All 14 Lines
// in_place_t constructor with no arguments when the Clang is trying to check // in_place_t constructor with no arguments when the Clang is trying to check
// copy constructor. // copy constructor.
#include <optional> #include <optional>
#include <type_traits> #include <type_traits>
#include <cassert> #include <cassert>
#include "test_macros.h" #include "test_macros.h"
#include "archetypes.hpp" #include "archetypes.h"
using std::optional; using std::optional;
struct Wrapped { struct Wrapped {
struct Inner { struct Inner {
bool Dummy = true; bool Dummy = true;
}; };
std::optional<Inner> inner; std::optional<Inner> inner;
Show All 10 Lines

libcxx/trunk/test/std/utilities/optional/optional.object/optional.object.ctor/move.pass.cpp

Show All 13 Lines
// constexpr optional(optional<T>&& rhs); // constexpr optional(optional<T>&& rhs);
#include <optional> #include <optional>
#include <type_traits> #include <type_traits>
#include <cassert> #include <cassert>
#include "test_macros.h" #include "test_macros.h"
#include "archetypes.hpp" #include "archetypes.h"
using std::optional; using std::optional;
template <class T, class ...InitArgs> template <class T, class ...InitArgs>
void test(InitArgs&&... args) void test(InitArgs&&... args)
{ {
const optional<T> orig(std::forward<InitArgs>(args)...); const optional<T> orig(std::forward<InitArgs>(args)...);
optional<T> rhs(orig); optional<T> rhs(orig);
▲ Show 20 Lines • Show All 194 Lines • Show Last 20 Lines

libcxx/trunk/test/std/utilities/optional/optional.object/optional.object.ctor/nullopt_t.pass.cpp

Show All 9 Lines
// <optional> // <optional>
// constexpr optional(nullopt_t) noexcept; // constexpr optional(nullopt_t) noexcept;
#include <optional> #include <optional>
#include <type_traits> #include <type_traits>
#include <cassert> #include <cassert>
#include "archetypes.hpp" #include "archetypes.h"
#include "test_macros.h" #include "test_macros.h"
using std::optional; using std::optional;
using std::nullopt_t; using std::nullopt_t;
using std::nullopt; using std::nullopt;
template <class Opt> template <class Opt>
▲ Show 20 Lines • Show All 50 Lines • Show Last 20 Lines

libcxx/trunk/test/std/utilities/optional/optional.object/optional.object.ctor/rvalue_T.pass.cpp

Show All 13 Lines
// constexpr optional(T&& v); // constexpr optional(T&& v);
#include <optional> #include <optional>
#include <type_traits> #include <type_traits>
#include <cassert> #include <cassert>
#include "test_macros.h" #include "test_macros.h"
#include "archetypes.hpp" #include "archetypes.h"
using std::optional; using std::optional;
class Z class Z
{ {
public: public:
▲ Show 20 Lines • Show All 126 Lines • Show Last 20 Lines

libcxx/trunk/test/std/utilities/optional/optional.object/optional.object.swap/swap.pass.cpp

Show All 12 Lines
// noexcept(is_nothrow_move_constructible<T>::value && // noexcept(is_nothrow_move_constructible<T>::value &&
// is_nothrow_swappable<T>::value) // is_nothrow_swappable<T>::value)
#include <optional> #include <optional>
#include <type_traits> #include <type_traits>
#include <cassert> #include <cassert>
#include "test_macros.h" #include "test_macros.h"
#include "archetypes.hpp" #include "archetypes.h"
using std::optional; using std::optional;
class X class X
{ {
int i_; int i_;
public: public:
static unsigned dtor_called; static unsigned dtor_called;
▲ Show 20 Lines • Show All 278 Lines • Show Last 20 Lines

libcxx/trunk/test/std/utilities/optional/optional.object/special_members.pass.cpp

Show All 10 Lines
// <optional> // <optional>
// Make sure we properly generate special member functions for optional<T> // Make sure we properly generate special member functions for optional<T>
// based on the properties of T itself. // based on the properties of T itself.
#include <optional> #include <optional>
#include <type_traits> #include <type_traits>
#include "archetypes.hpp" #include "archetypes.h"
#include "test_macros.h" #include "test_macros.h"
template <class T> template <class T>
struct SpecialMemberTest { struct SpecialMemberTest {
using O = std::optional<T>; using O = std::optional<T>;
Show All 38 Lines

libcxx/trunk/test/std/utilities/optional/optional.object/triviality.pass.cpp

Show All 16 Lines
// constexpr optional(optional&& rhs) noexcept(see below); // constexpr optional(optional&& rhs) noexcept(see below);
// constexpr optional<T>& operator=(const optional& rhs); // constexpr optional<T>& operator=(const optional& rhs);
// constexpr optional<T>& operator=(optional&& rhs) noexcept(see below); // constexpr optional<T>& operator=(optional&& rhs) noexcept(see below);
#include <optional> #include <optional>
#include <type_traits> #include <type_traits>
#include "archetypes.hpp" #include "archetypes.h"
#include "test_macros.h" #include "test_macros.h"
constexpr bool implies(bool p, bool q) { constexpr bool implies(bool p, bool q) {
return !p || q; return !p || q;
} }
▲ Show 20 Lines • Show All 66 Lines • Show Last 20 Lines

libcxx/trunk/test/std/utilities/optional/optional.specalg/swap.pass.cpp

Show All 11 Lines
// template <class T> void swap(optional<T>& x, optional<T>& y) // template <class T> void swap(optional<T>& x, optional<T>& y)
// noexcept(noexcept(x.swap(y))); // noexcept(noexcept(x.swap(y)));
#include <optional> #include <optional>
#include <type_traits> #include <type_traits>
#include <cassert> #include <cassert>
#include "test_macros.h" #include "test_macros.h"
#include "archetypes.hpp" #include "archetypes.h"
using std::optional; using std::optional;
class X class X
{ {
int i_; int i_;
public: public:
static unsigned dtor_called; static unsigned dtor_called;
▲ Show 20 Lines • Show All 325 Lines • Show Last 20 Lines

libcxx/trunk/test/std/utilities/template.bitset/bitset.hash/enabled_hash.pass.cpp

Show All 9 Lines
// <bitset> // <bitset>
// Test that <bitset> provides all of the arithmetic, enum, and pointer // Test that <bitset> provides all of the arithmetic, enum, and pointer
// hash specializations. // hash specializations.
#include <bitset> #include <bitset>
#include "poisoned_hash_helper.hpp" #include "poisoned_hash_helper.h"
#include "test_macros.h" #include "test_macros.h"
int main(int, char**) { int main(int, char**) {
test_library_hash_specializations_available(); test_library_hash_specializations_available();
{ {
test_hash_enabled_for_type<std::bitset<0> >(); test_hash_enabled_for_type<std::bitset<0> >();
test_hash_enabled_for_type<std::bitset<1> >(); test_hash_enabled_for_type<std::bitset<1> >();
test_hash_enabled_for_type<std::bitset<1024> >(); test_hash_enabled_for_type<std::bitset<1024> >();
test_hash_enabled_for_type<std::bitset<100000> >(); test_hash_enabled_for_type<std::bitset<100000> >();
} }
return 0; return 0;
} }

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

Show All 14 Lines
// UNSUPPORTED: c++98, c++03 // UNSUPPORTED: c++98, c++03
#include <tuple> #include <tuple>
#include <cassert> #include <cassert>
#include <type_traits> #include <type_traits>
#include "test_macros.h" #include "test_macros.h"
#include "test_convertible.hpp" #include "test_convertible.h"
#include "MoveOnly.h" #include "MoveOnly.h"
#if TEST_STD_VER > 11 #if TEST_STD_VER > 11
struct Empty {}; struct Empty {};
struct A struct A
{ {
int id_; int id_;
▲ Show 20 Lines • Show All 130 Lines • Show Last 20 Lines

libcxx/trunk/test/std/utilities/tuple/tuple.tuple/tuple.cnstr/deduct.pass.cpp

Show All 20 Lines
// so they're compatible with implicit deduction guides, or if that's not // so they're compatible with implicit deduction guides, or if that's not
// possible that they provide explicit guides to make it work. // possible that they provide explicit guides to make it work.
#include <tuple> #include <tuple>
#include <memory> #include <memory>
#include <cassert> #include <cassert>
#include "test_macros.h" #include "test_macros.h"
#include "archetypes.hpp" #include "archetypes.h"
// Overloads // Overloads
// using A = Allocator // using A = Allocator
// using AT = std::allocator_arg_t // using AT = std::allocator_arg_t
// --------------- // ---------------
// (1) tuple(const Types&...) -> tuple<Types...> // (1) tuple(const Types&...) -> tuple<Types...>
// (2) tuple(pair<T1, T2>) -> tuple<T1, T2>; // (2) tuple(pair<T1, T2>) -> tuple<T1, T2>;
▲ Show 20 Lines • Show All 165 Lines • Show Last 20 Lines

libcxx/trunk/test/std/utilities/type.index/type.index.hash/enabled_hash.pass.cpp

Show All 9 Lines
// <typeindex> // <typeindex>
// Test that <typeindex> provides all of the arithmetic, enum, and pointer // Test that <typeindex> provides all of the arithmetic, enum, and pointer
// hash specializations. // hash specializations.
#include <typeindex> #include <typeindex>
#include "poisoned_hash_helper.hpp" #include "poisoned_hash_helper.h"
#include "test_macros.h" #include "test_macros.h"
int main(int, char**) { int main(int, char**) {
test_library_hash_specializations_available(); test_library_hash_specializations_available();
return 0; return 0;
} }

libcxx/trunk/test/std/utilities/type.index/type.index.synopsis/hash_type_index.pass.cpp

Show All 13 Lines
// size_t operator()(type_index index) const; // size_t operator()(type_index index) const;
// }; // };
#include <typeindex> #include <typeindex>
#include <type_traits> #include <type_traits>
#include "test_macros.h" #include "test_macros.h"
#if TEST_STD_VER >= 11 #if TEST_STD_VER >= 11
#include "poisoned_hash_helper.hpp" #include "poisoned_hash_helper.h"
#endif #endif
int main(int, char**) int main(int, char**)
{ {
{ {
typedef std::hash<std::type_index> H; typedef std::hash<std::type_index> H;
static_assert((std::is_same<typename H::argument_type, std::type_index>::value), "" ); static_assert((std::is_same<typename H::argument_type, std::type_index>::value), "" );
static_assert((std::is_same<typename H::result_type, std::size_t>::value), "" ); static_assert((std::is_same<typename H::result_type, std::size_t>::value), "" );
Show All 9 Lines

libcxx/trunk/test/std/utilities/utility/pairs/pairs.pair/U_V.pass.cpp

Show All 13 Lines
// template<class U, class V> pair(U&& x, V&& y); // template<class U, class V> pair(U&& x, V&& y);
#include <utility> #include <utility>
#include <memory> #include <memory>
#include <cassert> #include <cassert>
#include "archetypes.hpp" #include "archetypes.h"
#include "test_convertible.hpp" #include "test_convertible.h"
#include "test_macros.h" #include "test_macros.h"
using namespace ImplicitTypes; // Get implicitly archetypes using namespace ImplicitTypes; // Get implicitly archetypes
template <class T1, class T1Arg, template <class T1, class T1Arg,
bool CanCopy = true, bool CanConvert = CanCopy> bool CanCopy = true, bool CanConvert = CanCopy>
void test_sfinae() { void test_sfinae() {
using P1 = std::pair<T1, int>; using P1 = std::pair<T1, int>;
▲ Show 20 Lines • Show All 72 Lines • Show Last 20 Lines

libcxx/trunk/test/std/utilities/utility/pairs/pairs.pair/assign_const_pair_U_V.pass.cpp

Show All 11 Lines
// template<class U, class V> pair& operator=(const pair<U, V>& p); // template<class U, class V> pair& operator=(const pair<U, V>& p);
#include <utility> #include <utility>
#include <cassert> #include <cassert>
#include "test_macros.h" #include "test_macros.h"
#if TEST_STD_VER >= 11 #if TEST_STD_VER >= 11
#include "archetypes.hpp" #include "archetypes.h"
#endif #endif
int main(int, char**) int main(int, char**)
{ {
{ {
typedef std::pair<int, short> P1; typedef std::pair<int, short> P1;
typedef std::pair<double, long> P2; typedef std::pair<double, long> P2;
P1 p1(3, static_cast<short>(4)); P1 p1(3, static_cast<short>(4));
Show All 25 Lines

libcxx/trunk/test/std/utilities/utility/pairs/pairs.pair/assign_rv_pair_U_V.pass.cpp

Show All 11 Lines
// template <class T1, class T2> struct pair // template <class T1, class T2> struct pair
// template<class U, class V> pair& operator=(pair<U, V>&& p); // template<class U, class V> pair& operator=(pair<U, V>&& p);
#include <utility> #include <utility>
#include <memory> #include <memory>
#include <cassert> #include <cassert>
#include <archetypes.hpp> #include <archetypes.h>
#include "test_macros.h" #include "test_macros.h"
struct Base struct Base
{ {
virtual ~Base() {} virtual ~Base() {}
}; };
Show All 34 Lines

libcxx/trunk/test/std/utilities/utility/pairs/pairs.pair/const_first_const_second.pass.cpp

Show All 11 Lines
// template <class T1, class T2> struct pair // template <class T1, class T2> struct pair
// pair(const T1& x, const T2& y); // pair(const T1& x, const T2& y);
#include <utility> #include <utility>
#include <cassert> #include <cassert>
#include "archetypes.hpp" #include "archetypes.h"
#include "test_convertible.hpp" #include "test_convertible.h"
#include "test_macros.h" #include "test_macros.h"
using namespace ImplicitTypes; // Get implicitly archetypes using namespace ImplicitTypes; // Get implicitly archetypes
struct ExplicitT { struct ExplicitT {
constexpr explicit ExplicitT(int x) : value(x) {} constexpr explicit ExplicitT(int x) : value(x) {}
constexpr explicit ExplicitT(ExplicitT const& o) : value(o.value) {} constexpr explicit ExplicitT(ExplicitT const& o) : value(o.value) {}
int value; int value;
▲ Show 20 Lines • Show All 72 Lines • Show Last 20 Lines

libcxx/trunk/test/std/utilities/utility/pairs/pairs.pair/const_pair_U_V.pass.cpp

Show All 11 Lines
// template <class T1, class T2> struct pair // template <class T1, class T2> struct pair
// template <class U, class V> EXPLICIT constexpr pair(const pair<U, V>& p); // template <class U, class V> EXPLICIT constexpr pair(const pair<U, V>& p);
#include <utility> #include <utility>
#include <cassert> #include <cassert>
#include "archetypes.hpp" #include "archetypes.h"
#include "test_convertible.hpp" #include "test_convertible.h"
#include "test_macros.h" #include "test_macros.h"
using namespace ImplicitTypes; // Get implicitly archetypes using namespace ImplicitTypes; // Get implicitly archetypes
template <class T1, class U1, template <class T1, class U1,
bool CanCopy = true, bool CanConvert = CanCopy> bool CanCopy = true, bool CanConvert = CanCopy>
void test_pair_const() void test_pair_const()
{ {
▲ Show 20 Lines • Show All 155 Lines • Show Last 20 Lines

libcxx/trunk/test/std/utilities/utility/pairs/pairs.pair/default.pass.cpp

Show All 20 Lines
// default-sfinae.pass.cpp // default-sfinae.pass.cpp
#include <utility> #include <utility>
#include <type_traits> #include <type_traits>
#include <cassert> #include <cassert>
#include "test_macros.h" #include "test_macros.h"
#include "archetypes.hpp" #include "archetypes.h"
int main(int, char**) int main(int, char**)
{ {
{ {
typedef std::pair<float, short*> P; typedef std::pair<float, short*> P;
P p; P p;
assert(p.first == 0.0f); assert(p.first == 0.0f);
assert(p.second == nullptr); assert(p.second == nullptr);
Show All 19 Lines

libcxx/trunk/test/std/utilities/utility/pairs/pairs.pair/implicit_deduction_guides.pass.cpp

Show All 20 Lines
// possible that they provide explicit guides to make it work. // possible that they provide explicit guides to make it work.
#include <utility> #include <utility>
#include <memory> #include <memory>
#include <string> #include <string>
#include <cassert> #include <cassert>
#include "test_macros.h" #include "test_macros.h"
#include "archetypes.hpp" #include "archetypes.h"
// Overloads // Overloads
// --------------- // ---------------
// (1) pair(const T1&, const T2&) -> pair<T1, T2> // (1) pair(const T1&, const T2&) -> pair<T1, T2>
// (2) explicit pair(const T1&, const T2&) -> pair<T1, T2> // (2) explicit pair(const T1&, const T2&) -> pair<T1, T2>
// (3) pair(pair const& t) -> decltype(t) // (3) pair(pair const& t) -> decltype(t)
// (4) pair(pair&& t) -> decltype(t) // (4) pair(pair&& t) -> decltype(t)
▲ Show 20 Lines • Show All 44 Lines • Show Last 20 Lines

libcxx/trunk/test/std/utilities/utility/pairs/pairs.pair/rv_pair_U_V.pass.cpp

Show All 12 Lines
// template <class T1, class T2> struct pair // template <class T1, class T2> struct pair
// template <class U, class V> pair(pair<U, V>&& p); // template <class U, class V> pair(pair<U, V>&& p);
#include <utility> #include <utility>
#include <memory> #include <memory>
#include <cassert> #include <cassert>
#include "archetypes.hpp" #include "archetypes.h"
#include "test_convertible.hpp" #include "test_convertible.h"
#include "test_macros.h" #include "test_macros.h"
using namespace ImplicitTypes; // Get implicitly archetypes using namespace ImplicitTypes; // Get implicitly archetypes
template <class T1, class U1, template <class T1, class U1,
bool CanCopy = true, bool CanConvert = CanCopy> bool CanCopy = true, bool CanConvert = CanCopy>
void test_pair_rv() void test_pair_rv()
{ {
▲ Show 20 Lines • Show All 150 Lines • Show Last 20 Lines

libcxx/trunk/test/std/utilities/utility/pairs/pairs.pair/special_member_generation_test.pass.cpp

Show All 18 Lines
// Test that the copy/move constructors and assignment operators are // Test that the copy/move constructors and assignment operators are
// correctly defined or deleted based on the properties of `T` and `U`. // correctly defined or deleted based on the properties of `T` and `U`.
#include <cassert> #include <cassert>
#include <string> #include <string>
#include <tuple> #include <tuple>
#include "archetypes.hpp" #include "archetypes.h"
#include "test_macros.h" #include "test_macros.h"
using namespace ImplicitTypes; // Get implicitly archetypes using namespace ImplicitTypes; // Get implicitly archetypes
namespace ConstructorTest { namespace ConstructorTest {
template <class T1, bool CanCopy = true, bool CanMove = CanCopy> void test() { template <class T1, bool CanCopy = true, bool CanMove = CanCopy> void test() {
using P1 = std::pair<T1, int>; using P1 = std::pair<T1, int>;
▲ Show 20 Lines • Show All 95 Lines • Show Last 20 Lines

libcxx/trunk/test/std/utilities/variant/variant.hash/enabled_hash.pass.cpp

Show All 9 Lines
// <variant> // <variant>
// Test that <variant> provides all of the arithmetic, enum, and pointer // Test that <variant> provides all of the arithmetic, enum, and pointer
// hash specializations. // hash specializations.
#include <variant> #include <variant>
#include "poisoned_hash_helper.hpp" #include "poisoned_hash_helper.h"
#include "test_macros.h" #include "test_macros.h"
int main(int, char**) { int main(int, char**) {
test_library_hash_specializations_available(); test_library_hash_specializations_available();
return 0; return 0;
} }

libcxx/trunk/test/std/utilities/variant/variant.hash/hash.pass.cpp

Show All 13 Lines
// template <class... Types> struct hash<variant<Types...>>; // template <class... Types> struct hash<variant<Types...>>;
// template <> struct hash<monostate>; // template <> struct hash<monostate>;
#include <cassert> #include <cassert>
#include <type_traits> #include <type_traits>
#include <variant> #include <variant>
#include "test_macros.h" #include "test_macros.h"
#include "variant_test_helpers.hpp" #include "variant_test_helpers.h"
#include "poisoned_hash_helper.hpp" #include "poisoned_hash_helper.h"
#ifndef TEST_HAS_NO_EXCEPTIONS #ifndef TEST_HAS_NO_EXCEPTIONS
namespace std { namespace std {
template <> struct hash<::MakeEmptyT> { template <> struct hash<::MakeEmptyT> {
size_t operator()(const ::MakeEmptyT &) const { size_t operator()(const ::MakeEmptyT &) const {
assert(false); assert(false);
return 0; return 0;
} }
▲ Show 20 Lines • Show All 129 Lines • Show Last 20 Lines

libcxx/trunk/test/std/utilities/variant/variant.helpers/variant_alternative.pass.cpp

Show All 20 Lines
// template <size_t I, class... Types> // template <size_t I, class... Types>
// struct variant_alternative<I, variant<Types...>>; // struct variant_alternative<I, variant<Types...>>;
#include <memory> #include <memory>
#include <type_traits> #include <type_traits>
#include <variant> #include <variant>
#include "test_macros.h" #include "test_macros.h"
#include "variant_test_helpers.hpp" #include "variant_test_helpers.h"
template <class V, size_t I, class E> void test() { template <class V, size_t I, class E> void test() {
static_assert( static_assert(
std::is_same_v<typename std::variant_alternative<I, V>::type, E>, ""); std::is_same_v<typename std::variant_alternative<I, V>::type, E>, "");
static_assert( static_assert(
std::is_same_v<typename std::variant_alternative<I, const V>::type, std::is_same_v<typename std::variant_alternative<I, const V>::type,
const E>, const E>,
""); "");
▲ Show 20 Lines • Show All 41 Lines • Show Last 20 Lines

libcxx/trunk/test/std/utilities/variant/variant.get/get_if_index.pass.cpp

Show All 13 Lines
// template <size_t I, class... Types> // template <size_t I, class... Types>
// constexpr add_pointer_t<variant_alternative_t<I, variant<Types...>>> // constexpr add_pointer_t<variant_alternative_t<I, variant<Types...>>>
// get_if(variant<Types...>* v) noexcept; // get_if(variant<Types...>* v) noexcept;
// template <size_t I, class... Types> // template <size_t I, class... Types>
// constexpr add_pointer_t<const variant_alternative_t<I, variant<Types...>>> // constexpr add_pointer_t<const variant_alternative_t<I, variant<Types...>>>
// get_if(const variant<Types...>* v) noexcept; // get_if(const variant<Types...>* v) noexcept;
#include "test_macros.h" #include "test_macros.h"
#include "variant_test_helpers.hpp" #include "variant_test_helpers.h"
#include <cassert> #include <cassert>
#include <memory> #include <memory>
#include <variant> #include <variant>
void test_const_get_if() { void test_const_get_if() {
{ {
using V = std::variant<int>; using V = std::variant<int>;
constexpr const V *v = nullptr; constexpr const V *v = nullptr;
▲ Show 20 Lines • Show All 103 Lines • Show Last 20 Lines

libcxx/trunk/test/std/utilities/variant/variant.get/get_if_type.pass.cpp

Show All 12 Lines
// template <class T, class... Types> // template <class T, class... Types>
// constexpr add_pointer_t<T> get_if(variant<Types...>* v) noexcept; // constexpr add_pointer_t<T> get_if(variant<Types...>* v) noexcept;
// template <class T, class... Types> // template <class T, class... Types>
// constexpr add_pointer_t<const T> get_if(const variant<Types...>* v) // constexpr add_pointer_t<const T> get_if(const variant<Types...>* v)
// noexcept; // noexcept;
#include "test_macros.h" #include "test_macros.h"
#include "variant_test_helpers.hpp" #include "variant_test_helpers.h"
#include <cassert> #include <cassert>
#include <variant> #include <variant>
void test_const_get_if() { void test_const_get_if() {
{ {
using V = std::variant<int>; using V = std::variant<int>;
constexpr const V *v = nullptr; constexpr const V *v = nullptr;
static_assert(std::get_if<int>(v) == nullptr, ""); static_assert(std::get_if<int>(v) == nullptr, "");
▲ Show 20 Lines • Show All 102 Lines • Show Last 20 Lines

libcxx/trunk/test/std/utilities/variant/variant.get/get_index.pass.cpp

Show All 22 Lines
// constexpr variant_alternative_t<I, variant<Types...>> const& get(const // constexpr variant_alternative_t<I, variant<Types...>> const& get(const
// variant<Types...>& v); // variant<Types...>& v);
// template <size_t I, class... Types> // template <size_t I, class... Types>
// constexpr variant_alternative_t<I, variant<Types...>> const&& get(const // constexpr variant_alternative_t<I, variant<Types...>> const&& get(const
// variant<Types...>&& v); // variant<Types...>&& v);
#include "test_macros.h" #include "test_macros.h"
#include "test_workarounds.h" #include "test_workarounds.h"
#include "variant_test_helpers.hpp" #include "variant_test_helpers.h"
#include <cassert> #include <cassert>
#include <type_traits> #include <type_traits>
#include <utility> #include <utility>
#include <variant> #include <variant>
void test_const_lvalue_get() { void test_const_lvalue_get() {
{ {
using V = std::variant<int, const long>; using V = std::variant<int, const long>;
▲ Show 20 Lines • Show All 256 Lines • Show Last 20 Lines

libcxx/trunk/test/std/utilities/variant/variant.get/get_type.pass.cpp

Show All 16 Lines
// template <class T, class... Types> constexpr T&& get(variant<Types...>&& v); // template <class T, class... Types> constexpr T&& get(variant<Types...>&& v);
// template <class T, class... Types> constexpr const T& get(const // template <class T, class... Types> constexpr const T& get(const
// variant<Types...>& v); // variant<Types...>& v);
// template <class T, class... Types> constexpr const T&& get(const // template <class T, class... Types> constexpr const T&& get(const
// variant<Types...>&& v); // variant<Types...>&& v);
#include "test_macros.h" #include "test_macros.h"
#include "test_workarounds.h" #include "test_workarounds.h"
#include "variant_test_helpers.hpp" #include "variant_test_helpers.h"
#include <cassert> #include <cassert>
#include <type_traits> #include <type_traits>
#include <utility> #include <utility>
#include <variant> #include <variant>
void test_const_lvalue_get() { void test_const_lvalue_get() {
{ {
using V = std::variant<int, const long>; using V = std::variant<int, const long>;
▲ Show 20 Lines • Show All 262 Lines • Show Last 20 Lines

libcxx/trunk/test/std/utilities/variant/variant.variant/variant.assign/T.pass.cpp

Show All 19 Lines
#include <cassert> #include <cassert>
#include <string> #include <string>
#include <type_traits> #include <type_traits>
#include <variant> #include <variant>
#include <memory> #include <memory>
#include "test_macros.h" #include "test_macros.h"
#include "variant_test_helpers.hpp" #include "variant_test_helpers.h"
namespace MetaHelpers { namespace MetaHelpers {
struct Dummy { struct Dummy {
Dummy() = default; Dummy() = default;
}; };
struct ThrowsCtorT { struct ThrowsCtorT {
▲ Show 20 Lines • Show All 283 Lines • Show Last 20 Lines

libcxx/trunk/test/std/utilities/variant/variant.variant/variant.assign/conv.pass.cpp

Show All 14 Lines
// template <class T> // template <class T>
// variant& operator=(T&&) noexcept(see below); // variant& operator=(T&&) noexcept(see below);
#include <variant> #include <variant>
#include <string> #include <string>
#include <memory> #include <memory>
#include "variant_test_helpers.hpp" #include "variant_test_helpers.h"
int main(int, char**) int main(int, char**)
{ {
static_assert(!std::is_assignable<std::variant<int, int>, int>::value, ""); static_assert(!std::is_assignable<std::variant<int, int>, int>::value, "");
static_assert(!std::is_assignable<std::variant<long, long long>, int>::value, ""); static_assert(!std::is_assignable<std::variant<long, long long>, int>::value, "");
static_assert(std::is_assignable<std::variant<char>, int>::value == VariantAllowsNarrowingConversions, ""); static_assert(std::is_assignable<std::variant<char>, int>::value == VariantAllowsNarrowingConversions, "");
static_assert(std::is_assignable<std::variant<std::string, float>, int>::value == VariantAllowsNarrowingConversions, ""); static_assert(std::is_assignable<std::variant<std::string, float>, int>::value == VariantAllowsNarrowingConversions, "");
Show All 12 Lines

libcxx/trunk/test/std/utilities/variant/variant.variant/variant.assign/move.pass.cpp

Show All 23 Lines
#include <cassert> #include <cassert>
#include <string> #include <string>
#include <type_traits> #include <type_traits>
#include <utility> #include <utility>
#include <variant> #include <variant>
#include "test_macros.h" #include "test_macros.h"
#include "variant_test_helpers.hpp" #include "variant_test_helpers.h"
struct NoCopy { struct NoCopy {
NoCopy(const NoCopy &) = delete; NoCopy(const NoCopy &) = delete;
NoCopy &operator=(const NoCopy &) = default; NoCopy &operator=(const NoCopy &) = default;
}; };
struct CopyOnly { struct CopyOnly {
CopyOnly(const CopyOnly &) = default; CopyOnly(const CopyOnly &) = default;
▲ Show 20 Lines • Show All 474 Lines • Show Last 20 Lines

libcxx/trunk/test/std/utilities/variant/variant.variant/variant.ctor/T.pass.cpp

Show All 17 Lines
#include <cassert> #include <cassert>
#include <string> #include <string>
#include <type_traits> #include <type_traits>
#include <variant> #include <variant>
#include <memory> #include <memory>
#include "test_macros.h" #include "test_macros.h"
#include "variant_test_helpers.hpp" #include "variant_test_helpers.h"
struct Dummy { struct Dummy {
Dummy() = default; Dummy() = default;
}; };
struct ThrowsT { struct ThrowsT {
ThrowsT(int) noexcept(false) {} ThrowsT(int) noexcept(false) {}
}; };
▲ Show 20 Lines • Show All 176 Lines • Show Last 20 Lines

libcxx/trunk/test/std/utilities/variant/variant.variant/variant.ctor/conv.pass.cpp

Show All 13 Lines
// template <class ...Types> class variant; // template <class ...Types> class variant;
// template <class T> constexpr variant(T&&) noexcept(see below); // template <class T> constexpr variant(T&&) noexcept(see below);
#include <variant> #include <variant>
#include <string> #include <string>
#include <memory> #include <memory>
#include "variant_test_helpers.hpp" #include "variant_test_helpers.h"
int main(int, char**) int main(int, char**)
{ {
static_assert(!std::is_constructible<std::variant<int, int>, int>::value, ""); static_assert(!std::is_constructible<std::variant<int, int>, int>::value, "");
static_assert(!std::is_constructible<std::variant<long, long long>, int>::value, ""); static_assert(!std::is_constructible<std::variant<long, long long>, int>::value, "");
static_assert(std::is_constructible<std::variant<char>, int>::value == VariantAllowsNarrowingConversions, ""); static_assert(std::is_constructible<std::variant<char>, int>::value == VariantAllowsNarrowingConversions, "");
static_assert(std::is_constructible<std::variant<std::string, float>, int>::value == VariantAllowsNarrowingConversions, ""); static_assert(std::is_constructible<std::variant<std::string, float>, int>::value == VariantAllowsNarrowingConversions, "");
Show All 12 Lines

libcxx/trunk/test/std/utilities/variant/variant.variant/variant.ctor/default.pass.cpp

Show All 16 Lines
// constexpr variant() noexcept(see below); // constexpr variant() noexcept(see below);
#include <cassert> #include <cassert>
#include <type_traits> #include <type_traits>
#include <variant> #include <variant>
#include "test_macros.h" #include "test_macros.h"
#include "variant_test_helpers.hpp" #include "variant_test_helpers.h"
struct NonDefaultConstructible { struct NonDefaultConstructible {
constexpr NonDefaultConstructible(int) {} constexpr NonDefaultConstructible(int) {}
}; };
struct NotNoexcept { struct NotNoexcept {
NotNoexcept() noexcept(false) {} NotNoexcept() noexcept(false) {}
}; };
▲ Show 20 Lines • Show All 93 Lines • Show Last 20 Lines

libcxx/trunk/test/std/utilities/variant/variant.variant/variant.ctor/in_place_index_args.pass.cpp

Show All 17 Lines
// template <size_t I, class ...Args> // template <size_t I, class ...Args>
// constexpr explicit variant(in_place_index_t<I>, Args&&...); // constexpr explicit variant(in_place_index_t<I>, Args&&...);
#include <cassert> #include <cassert>
#include <string> #include <string>
#include <type_traits> #include <type_traits>
#include <variant> #include <variant>
#include "test_convertible.hpp" #include "test_convertible.h"
#include "test_macros.h" #include "test_macros.h"
void test_ctor_sfinae() { void test_ctor_sfinae() {
{ {
using V = std::variant<int>; using V = std::variant<int>;
static_assert( static_assert(
std::is_constructible<V, std::in_place_index_t<0>, int>::value, ""); std::is_constructible<V, std::in_place_index_t<0>, int>::value, "");
static_assert(!test_convertible<V, std::in_place_index_t<0>, int>(), ""); static_assert(!test_convertible<V, std::in_place_index_t<0>, int>(), "");
▲ Show 20 Lines • Show All 72 Lines • Show Last 20 Lines

libcxx/trunk/test/std/utilities/variant/variant.variant/variant.ctor/in_place_index_init_list_args.pass.cpp

Show All 17 Lines
// constexpr explicit // constexpr explicit
// variant(in_place_index_t<I>, initializer_list<Up>, Args&&...); // variant(in_place_index_t<I>, initializer_list<Up>, Args&&...);
#include <cassert> #include <cassert>
#include <string> #include <string>
#include <type_traits> #include <type_traits>
#include <variant> #include <variant>
#include "test_convertible.hpp" #include "test_convertible.h"
#include "test_macros.h" #include "test_macros.h"
struct InitList { struct InitList {
std::size_t size; std::size_t size;
constexpr InitList(std::initializer_list<int> il) : size(il.size()) {} constexpr InitList(std::initializer_list<int> il) : size(il.size()) {}
}; };
struct InitListArg { struct InitListArg {
▲ Show 20 Lines • Show All 77 Lines • Show Last 20 Lines

libcxx/trunk/test/std/utilities/variant/variant.variant/variant.ctor/in_place_type_args.pass.cpp

Show All 16 Lines
// template <class Tp, class ...Args> // template <class Tp, class ...Args>
// constexpr explicit variant(in_place_type_t<Tp>, Args&&...); // constexpr explicit variant(in_place_type_t<Tp>, Args&&...);
#include <cassert> #include <cassert>
#include <type_traits> #include <type_traits>
#include <variant> #include <variant>
#include "test_convertible.hpp" #include "test_convertible.h"
#include "test_macros.h" #include "test_macros.h"
void test_ctor_sfinae() { void test_ctor_sfinae() {
{ {
using V = std::variant<int>; using V = std::variant<int>;
static_assert( static_assert(
std::is_constructible<V, std::in_place_type_t<int>, int>::value, ""); std::is_constructible<V, std::in_place_type_t<int>, int>::value, "");
static_assert(!test_convertible<V, std::in_place_type_t<int>, int>(), ""); static_assert(!test_convertible<V, std::in_place_type_t<int>, int>(), "");
▲ Show 20 Lines • Show All 83 Lines • Show Last 20 Lines

libcxx/trunk/test/std/utilities/variant/variant.variant/variant.ctor/in_place_type_init_list_args.pass.cpp

Show All 17 Lines
// constexpr explicit // constexpr explicit
// variant(in_place_type_t<Tp>, initializer_list<Up>, Args&&...); // variant(in_place_type_t<Tp>, initializer_list<Up>, Args&&...);
#include <cassert> #include <cassert>
#include <string> #include <string>
#include <type_traits> #include <type_traits>
#include <variant> #include <variant>
#include "test_convertible.hpp" #include "test_convertible.h"
#include "test_macros.h" #include "test_macros.h"
struct InitList { struct InitList {
std::size_t size; std::size_t size;
constexpr InitList(std::initializer_list<int> il) : size(il.size()) {} constexpr InitList(std::initializer_list<int> il) : size(il.size()) {}
}; };
struct InitListArg { struct InitListArg {
▲ Show 20 Lines • Show All 78 Lines • Show Last 20 Lines

libcxx/trunk/test/std/utilities/variant/variant.variant/variant.mod/emplace_index_args.pass.cpp

Show All 17 Lines
// template <size_t I, class ...Args> // template <size_t I, class ...Args>
// variant_alternative_t<I, variant<Types...>>& emplace(Args&&... args); // variant_alternative_t<I, variant<Types...>>& emplace(Args&&... args);
#include <cassert> #include <cassert>
#include <string> #include <string>
#include <type_traits> #include <type_traits>
#include <variant> #include <variant>
#include "archetypes.hpp" #include "archetypes.h"
#include "test_convertible.hpp" #include "test_convertible.h"
#include "test_macros.h" #include "test_macros.h"
#include "variant_test_helpers.hpp" #include "variant_test_helpers.h"
template <class Var, size_t I, class... Args> template <class Var, size_t I, class... Args>
constexpr auto test_emplace_exists_imp(int) -> decltype( constexpr auto test_emplace_exists_imp(int) -> decltype(
std::declval<Var>().template emplace<I>(std::declval<Args>()...), true) { std::declval<Var>().template emplace<I>(std::declval<Args>()...), true) {
return true; return true;
} }
template <class, size_t, class...> template <class, size_t, class...>
▲ Show 20 Lines • Show All 124 Lines • Show Last 20 Lines

libcxx/trunk/test/std/utilities/variant/variant.variant/variant.mod/emplace_index_init_list_args.pass.cpp

Show All 17 Lines
// template <size_t I, class U, class ...Args> // template <size_t I, class U, class ...Args>
// variant_alternative_t<I, variant<Types...>>& emplace(initializer_list<U> il,Args&&... args); // variant_alternative_t<I, variant<Types...>>& emplace(initializer_list<U> il,Args&&... args);
#include <cassert> #include <cassert>
#include <string> #include <string>
#include <type_traits> #include <type_traits>
#include <variant> #include <variant>
#include "archetypes.hpp" #include "archetypes.h"
#include "test_convertible.hpp" #include "test_convertible.h"
#include "test_macros.h" #include "test_macros.h"
struct InitList { struct InitList {
std::size_t size; std::size_t size;
constexpr InitList(std::initializer_list<int> il) : size(il.size()) {} constexpr InitList(std::initializer_list<int> il) : size(il.size()) {}
}; };
struct InitListArg { struct InitListArg {
▲ Show 20 Lines • Show All 59 Lines • Show Last 20 Lines

libcxx/trunk/test/std/utilities/variant/variant.variant/variant.mod/emplace_type_args.pass.cpp

Show All 16 Lines
// template <class T, class ...Args> T& emplace(Args&&... args); // template <class T, class ...Args> T& emplace(Args&&... args);
#include <cassert> #include <cassert>
#include <string> #include <string>
#include <type_traits> #include <type_traits>
#include <variant> #include <variant>
#include "archetypes.hpp" #include "archetypes.h"
#include "test_convertible.hpp" #include "test_convertible.h"
#include "test_macros.h" #include "test_macros.h"
#include "variant_test_helpers.hpp" #include "variant_test_helpers.h"
template <class Var, class T, class... Args> template <class Var, class T, class... Args>
constexpr auto test_emplace_exists_imp(int) -> decltype( constexpr auto test_emplace_exists_imp(int) -> decltype(
std::declval<Var>().template emplace<T>(std::declval<Args>()...), true) { std::declval<Var>().template emplace<T>(std::declval<Args>()...), true) {
return true; return true;
} }
template <class, class, class...> template <class, class, class...>
▲ Show 20 Lines • Show All 125 Lines • Show Last 20 Lines

libcxx/trunk/test/std/utilities/variant/variant.variant/variant.mod/emplace_type_init_list_args.pass.cpp

Show All 17 Lines
// template <class T, class U, class ...Args> // template <class T, class U, class ...Args>
// T& emplace(initializer_list<U> il,Args&&... args); // T& emplace(initializer_list<U> il,Args&&... args);
#include <cassert> #include <cassert>
#include <string> #include <string>
#include <type_traits> #include <type_traits>
#include <variant> #include <variant>
#include "archetypes.hpp" #include "archetypes.h"
#include "test_convertible.hpp" #include "test_convertible.h"
#include "test_macros.h" #include "test_macros.h"
struct InitList { struct InitList {
std::size_t size; std::size_t size;
constexpr InitList(std::initializer_list<int> il) : size(il.size()) {} constexpr InitList(std::initializer_list<int> il) : size(il.size()) {}
}; };
struct InitListArg { struct InitListArg {
▲ Show 20 Lines • Show All 59 Lines • Show Last 20 Lines

libcxx/trunk/test/std/utilities/variant/variant.variant/variant.status/index.pass.cpp

Show All 14 Lines
// constexpr size_t index() const noexcept; // constexpr size_t index() const noexcept;
#include <cassert> #include <cassert>
#include <string> #include <string>
#include <type_traits> #include <type_traits>
#include <variant> #include <variant>
#include "archetypes.hpp" #include "archetypes.h"
#include "test_macros.h" #include "test_macros.h"
#include "variant_test_helpers.hpp" #include "variant_test_helpers.h"
int main(int, char**) { int main(int, char**) {
{ {
using V = std::variant<int, long>; using V = std::variant<int, long>;
constexpr V v; constexpr V v;
static_assert(v.index() == 0, ""); static_assert(v.index() == 0, "");
} }
Show All 29 Lines

libcxx/trunk/test/std/utilities/variant/variant.variant/variant.status/valueless_by_exception.pass.cpp

Show All 14 Lines
// constexpr bool valueless_by_exception() const noexcept; // constexpr bool valueless_by_exception() const noexcept;
#include <cassert> #include <cassert>
#include <string> #include <string>
#include <type_traits> #include <type_traits>
#include <variant> #include <variant>
#include "archetypes.hpp" #include "archetypes.h"
#include "test_macros.h" #include "test_macros.h"
#include "variant_test_helpers.hpp" #include "variant_test_helpers.h"
int main(int, char**) { int main(int, char**) {
{ {
using V = std::variant<int, long>; using V = std::variant<int, long>;
constexpr V v; constexpr V v;
static_assert(!v.valueless_by_exception(), ""); static_assert(!v.valueless_by_exception(), "");
} }
Show All 22 Lines

libcxx/trunk/test/std/utilities/variant/variant.variant/variant.swap/swap.pass.cpp

Show All 16 Lines
// void swap(variant& rhs) noexcept(see below) // void swap(variant& rhs) noexcept(see below)
#include <cassert> #include <cassert>
#include <string> #include <string>
#include <type_traits> #include <type_traits>
#include <variant> #include <variant>
#include "test_convertible.hpp" #include "test_convertible.h"
#include "test_macros.h" #include "test_macros.h"
#include "variant_test_helpers.hpp" #include "variant_test_helpers.h"
struct NotSwappable {}; struct NotSwappable {};
void swap(NotSwappable &, NotSwappable &) = delete; void swap(NotSwappable &, NotSwappable &) = delete;
struct NotCopyable { struct NotCopyable {
NotCopyable() = default; NotCopyable() = default;
NotCopyable(const NotCopyable &) = delete; NotCopyable(const NotCopyable &) = delete;
NotCopyable &operator=(const NotCopyable &) = delete; NotCopyable &operator=(const NotCopyable &) = delete;
▲ Show 20 Lines • Show All 559 Lines • Show Last 20 Lines

libcxx/trunk/test/std/utilities/variant/variant.variant/variant_array.fail.cpp

Show All 14 Lines
#include <variant> #include <variant>
#include <type_traits> #include <type_traits>
#include <string> #include <string>
#include <cassert> #include <cassert>
#include "test_macros.h" #include "test_macros.h"
#include "variant_test_helpers.hpp" #include "variant_test_helpers.h"
#include "test_convertible.hpp" #include "test_convertible.h"
int main(int, char**) int main(int, char**)
{ {
// expected-error@variant:* 3 {{static_assert failed}} // expected-error@variant:* 3 {{static_assert failed}}
std::variant<int, int[]> v; // expected-note {{requested here}} std::variant<int, int[]> v; // expected-note {{requested here}}
std::variant<int, int[42]> v2; // expected-note {{requested here}} std::variant<int, int[42]> v2; // expected-note {{requested here}}
std::variant<int, int[][42]> v3; // expected-note {{requested here}} std::variant<int, int[][42]> v3; // expected-note {{requested here}}
return 0; return 0;
} }

libcxx/trunk/test/std/utilities/variant/variant.variant/variant_empty.fail.cpp

Show All 10 Lines
// <variant> // <variant>
// template <class ...Types> class variant; // template <class ...Types> class variant;
#include <variant> #include <variant>
#include "test_macros.h" #include "test_macros.h"
#include "variant_test_helpers.hpp" #include "variant_test_helpers.h"
int main(int, char**) int main(int, char**)
{ {
// expected-error@variant:* 1 {{static_assert failed}} // expected-error@variant:* 1 {{static_assert failed}}
std::variant<> v; // expected-note {{requested here}} std::variant<> v; // expected-note {{requested here}}
return 0; return 0;
} }

libcxx/trunk/test/std/utilities/variant/variant.variant/variant_reference.fail.cpp

Show All 10 Lines
// <variant> // <variant>
// template <class ...Types> class variant; // template <class ...Types> class variant;
#include <variant> #include <variant>
#include "test_macros.h" #include "test_macros.h"
#include "variant_test_helpers.hpp" #include "variant_test_helpers.h"
int main(int, char**) int main(int, char**)
{ {
// expected-error@variant:* 3 {{static_assert failed}} // expected-error@variant:* 3 {{static_assert failed}}
std::variant<int, int&> v; // expected-note {{requested here}} std::variant<int, int&> v; // expected-note {{requested here}}
std::variant<int, const int &> v2; // expected-note {{requested here}} std::variant<int, const int &> v2; // expected-note {{requested here}}
std::variant<int, int&&> v3; // expected-note {{requested here}} std::variant<int, int&&> v3; // expected-note {{requested here}}
return 0; return 0;
} }

libcxx/trunk/test/std/utilities/variant/variant.variant/variant_void.fail.cpp

Show All 14 Lines
#include <variant> #include <variant>
#include <type_traits> #include <type_traits>
#include <string> #include <string>
#include <cassert> #include <cassert>
#include "test_macros.h" #include "test_macros.h"
#include "variant_test_helpers.hpp" #include "variant_test_helpers.h"
#include "test_convertible.hpp" #include "test_convertible.h"
int main(int, char**) int main(int, char**)
{ {
// expected-error@variant:* 3 {{static_assert failed}} // expected-error@variant:* 3 {{static_assert failed}}
std::variant<int, void> v; // expected-note {{requested here}} std::variant<int, void> v; // expected-note {{requested here}}
std::variant<int, const void> v2; // expected-note {{requested here}} std::variant<int, const void> v2; // expected-note {{requested here}}
std::variant<const volatile void, int> v3; // expected-note {{requested here}} std::variant<const volatile void, int> v3; // expected-note {{requested here}}
return 0; return 0;
} }

libcxx/trunk/test/std/utilities/variant/variant.visit/visit.pass.cpp

Show All 18 Lines
#include <memory> #include <memory>
#include <string> #include <string>
#include <type_traits> #include <type_traits>
#include <utility> #include <utility>
#include <variant> #include <variant>
#include "test_macros.h" #include "test_macros.h"
#include "type_id.h" #include "type_id.h"
#include "variant_test_helpers.hpp" #include "variant_test_helpers.h"
enum CallType : unsigned { enum CallType : unsigned {
CT_None, CT_None,
CT_NonConst = 1, CT_NonConst = 1,
CT_Const = 2, CT_Const = 2,
CT_LValue = 4, CT_LValue = 4,
CT_RValue = 8 CT_RValue = 8
}; };
▲ Show 20 Lines • Show All 280 Lines • Show Last 20 Lines

libcxx/trunk/test/support/archetypes.h

#ifndef TEST_SUPPORT_ARCHETYPES_H
#define TEST_SUPPORT_ARCHETYPES_H
#include <type_traits>
#include <cassert>
#include "test_macros.h"
#include "test_workarounds.h"
#if TEST_STD_VER >= 11
namespace ArchetypeBases {
template <bool, class T>
struct DepType : T {};
struct NullBase {
#ifndef TEST_WORKAROUND_C1XX_BROKEN_ZA_CTOR_CHECK
protected:
#endif // !TEST_WORKAROUND_C1XX_BROKEN_ZA_CTOR_CHECK
NullBase() = default;
NullBase(NullBase const&) = default;
NullBase& operator=(NullBase const&) = default;
NullBase(NullBase &&) = default;
NullBase& operator=(NullBase &&) = default;
};
template <class Derived, bool Explicit = false>
struct TestBase {
static int alive;
static int constructed;
static int value_constructed;
static int default_constructed;
static int copy_constructed;
static int move_constructed;
static int assigned;
static int value_assigned;
static int copy_assigned;
static int move_assigned;
static int destroyed;
static void reset() {
assert(alive == 0);
alive = 0;
reset_constructors();
}
static void reset_constructors() {
constructed = value_constructed = default_constructed =
copy_constructed = move_constructed = 0;
assigned = value_assigned = copy_assigned = move_assigned = destroyed = 0;
}
TestBase() noexcept : value(0) {
++alive; ++constructed; ++default_constructed;
}
template <bool Dummy = true, typename std::enable_if<Dummy && Explicit, bool>::type = true>
explicit TestBase(int x) noexcept : value(x) {
++alive; ++constructed; ++value_constructed;
}
template <bool Dummy = true, typename std::enable_if<Dummy && !Explicit, bool>::type = true>
TestBase(int x) noexcept : value(x) {
++alive; ++constructed; ++value_constructed;
}
template <bool Dummy = true, typename std::enable_if<Dummy && Explicit, bool>::type = true>
explicit TestBase(int, int y) noexcept : value(y) {
++alive; ++constructed; ++value_constructed;
}
template <bool Dummy = true, typename std::enable_if<Dummy && !Explicit, bool>::type = true>
TestBase(int, int y) noexcept : value(y) {
++alive; ++constructed; ++value_constructed;
}
template <bool Dummy = true, typename std::enable_if<Dummy && Explicit, bool>::type = true>
explicit TestBase(std::initializer_list<int>& il, int = 0) noexcept
: value(static_cast<int>(il.size())) {
++alive; ++constructed; ++value_constructed;
}
template <bool Dummy = true, typename std::enable_if<Dummy && !Explicit, bool>::type = true>
explicit TestBase(std::initializer_list<int>& il, int = 0) noexcept : value(static_cast<int>(il.size())) {
++alive; ++constructed; ++value_constructed;
}
TestBase& operator=(int xvalue) noexcept {
value = xvalue;
++assigned; ++value_assigned;
return *this;
}
#ifndef TEST_WORKAROUND_C1XX_BROKEN_ZA_CTOR_CHECK
protected:
#endif // !TEST_WORKAROUND_C1XX_BROKEN_ZA_CTOR_CHECK
~TestBase() {
assert(value != -999); assert(alive > 0);
--alive; ++destroyed; value = -999;
}
explicit TestBase(TestBase const& o) noexcept : value(o.value) {
assert(o.value != -1); assert(o.value != -999);
++alive; ++constructed; ++copy_constructed;
}
explicit TestBase(TestBase && o) noexcept : value(o.value) {
assert(o.value != -1); assert(o.value != -999);
++alive; ++constructed; ++move_constructed;
o.value = -1;
}
TestBase& operator=(TestBase const& o) noexcept {
assert(o.value != -1); assert(o.value != -999);
++assigned; ++copy_assigned;
value = o.value;
return *this;
}
TestBase& operator=(TestBase&& o) noexcept {
assert(o.value != -1); assert(o.value != -999);
++assigned; ++move_assigned;
value = o.value;
o.value = -1;
return *this;
}
public:
int value;
};
template <class D, bool E> int TestBase<D, E>::alive = 0;
template <class D, bool E> int TestBase<D, E>::constructed = 0;
template <class D, bool E> int TestBase<D, E>::value_constructed = 0;
template <class D, bool E> int TestBase<D, E>::default_constructed = 0;
template <class D, bool E> int TestBase<D, E>::copy_constructed = 0;
template <class D, bool E> int TestBase<D, E>::move_constructed = 0;
template <class D, bool E> int TestBase<D, E>::assigned = 0;
template <class D, bool E> int TestBase<D, E>::value_assigned = 0;
template <class D, bool E> int TestBase<D, E>::copy_assigned = 0;
template <class D, bool E> int TestBase<D, E>::move_assigned = 0;
template <class D, bool E> int TestBase<D, E>::destroyed = 0;
template <bool Explicit = false>
struct ValueBase {
template <bool Dummy = true, typename std::enable_if<Dummy && Explicit, bool>::type = true>
explicit constexpr ValueBase(int x) : value(x) {}
template <bool Dummy = true, typename std::enable_if<Dummy && !Explicit, bool>::type = true>
constexpr ValueBase(int x) : value(x) {}
template <bool Dummy = true, typename std::enable_if<Dummy && Explicit, bool>::type = true>
explicit constexpr ValueBase(int, int y) : value(y) {}
template <bool Dummy = true, typename std::enable_if<Dummy && !Explicit, bool>::type = true>
constexpr ValueBase(int, int y) : value(y) {}
template <bool Dummy = true, typename std::enable_if<Dummy && Explicit, bool>::type = true>
explicit constexpr ValueBase(std::initializer_list<int>& il, int = 0) : value(static_cast<int>(il.size())) {}
template <bool Dummy = true, typename std::enable_if<Dummy && !Explicit, bool>::type = true>
constexpr ValueBase(std::initializer_list<int>& il, int = 0) : value(static_cast<int>(il.size())) {}
TEST_CONSTEXPR_CXX14 ValueBase& operator=(int xvalue) noexcept {
value = xvalue;
return *this;
}
//~ValueBase() { assert(value != -999); value = -999; }
int value;
#ifndef TEST_WORKAROUND_C1XX_BROKEN_ZA_CTOR_CHECK
protected:
#endif // !TEST_WORKAROUND_C1XX_BROKEN_ZA_CTOR_CHECK
constexpr static int check_value(int const& val) {
#if TEST_STD_VER < 14
return val == -1 || val == 999 ? (TEST_THROW(42), 0) : val;
#else
assert(val != -1); assert(val != 999);
return val;
#endif
}
constexpr static int check_value(int& val, int val_cp = 0) {
#if TEST_STD_VER < 14
return val_cp = val, val = -1, (val_cp == -1 || val_cp == 999 ? (TEST_THROW(42), 0) : val_cp);
#else
assert(val != -1); assert(val != 999);
val_cp = val;
val = -1;
return val_cp;
#endif
}
constexpr ValueBase() noexcept : value(0) {}
constexpr ValueBase(ValueBase const& o) noexcept : value(check_value(o.value)) {
}
constexpr ValueBase(ValueBase && o) noexcept : value(check_value(o.value)) {
}
TEST_CONSTEXPR_CXX14 ValueBase& operator=(ValueBase const& o) noexcept {
assert(o.value != -1); assert(o.value != -999);
value = o.value;
return *this;
}
TEST_CONSTEXPR_CXX14 ValueBase& operator=(ValueBase&& o) noexcept {
assert(o.value != -1); assert(o.value != -999);
value = o.value;
o.value = -1;
return *this;
}
};
template <bool Explicit = false>
struct TrivialValueBase {
template <bool Dummy = true, typename std::enable_if<Dummy && Explicit, bool>::type = true>
explicit constexpr TrivialValueBase(int x) : value(x) {}
template <bool Dummy = true, typename std::enable_if<Dummy && !Explicit, bool>::type = true>
constexpr TrivialValueBase(int x) : value(x) {}
template <bool Dummy = true, typename std::enable_if<Dummy && Explicit, bool>::type = true>
explicit constexpr TrivialValueBase(int, int y) : value(y) {}
template <bool Dummy = true, typename std::enable_if<Dummy && !Explicit, bool>::type = true>
constexpr TrivialValueBase(int, int y) : value(y) {}
template <bool Dummy = true, typename std::enable_if<Dummy && Explicit, bool>::type = true>
explicit constexpr TrivialValueBase(std::initializer_list<int>& il, int = 0) : value(static_cast<int>(il.size())) {}
template <bool Dummy = true, typename std::enable_if<Dummy && !Explicit, bool>::type = true>
constexpr TrivialValueBase(std::initializer_list<int>& il, int = 0) : value(static_cast<int>(il.size())) {}
int value;
#ifndef TEST_WORKAROUND_C1XX_BROKEN_ZA_CTOR_CHECK
protected:
#endif // !TEST_WORKAROUND_C1XX_BROKEN_ZA_CTOR_CHECK
constexpr TrivialValueBase() noexcept : value(0) {}
};
}
//============================================================================//
// Trivial Implicit Test Types
namespace ImplicitTypes {
#include "archetypes.ipp"
}
//============================================================================//
// Trivial Explicit Test Types
namespace ExplicitTypes {
#define DEFINE_EXPLICIT explicit
#include "archetypes.ipp"
}
//============================================================================//
//
namespace NonConstexprTypes {
#define DEFINE_CONSTEXPR
#include "archetypes.ipp"
}
//============================================================================//
// Non-literal implicit test types
namespace NonLiteralTypes {
#define DEFINE_ASSIGN_CONSTEXPR
#define DEFINE_DTOR(Name) ~Name() {}
#include "archetypes.ipp"
}
//============================================================================//
// Non-throwing implicit test types
namespace NonThrowingTypes {
#define DEFINE_NOEXCEPT noexcept
#include "archetypes.ipp"
}
//============================================================================//
// Non-Trivially Copyable Implicit Test Types
namespace NonTrivialTypes {
#define DEFINE_CTOR {}
#define DEFINE_ASSIGN { return *this; }
#include "archetypes.ipp"
}
//============================================================================//
// Implicit counting types
namespace TestTypes {
#define DEFINE_CONSTEXPR
#define DEFINE_BASE(Name) ::ArchetypeBases::TestBase<Name>
#include "archetypes.ipp"
using TestType = AllCtors;
// Add equality operators
template <class Tp>
constexpr bool operator==(Tp const& L, Tp const& R) noexcept {
return L.value == R.value;
}
template <class Tp>
constexpr bool operator!=(Tp const& L, Tp const& R) noexcept {
return L.value != R.value;
}
}
//============================================================================//
// Implicit counting types
namespace ExplicitTestTypes {
#define DEFINE_CONSTEXPR
#define DEFINE_EXPLICIT explicit
#define DEFINE_BASE(Name) ::ArchetypeBases::TestBase<Name, true>
#include "archetypes.ipp"
using TestType = AllCtors;
// Add equality operators
template <class Tp>
constexpr bool operator==(Tp const& L, Tp const& R) noexcept {
return L.value == R.value;
}
template <class Tp>
constexpr bool operator!=(Tp const& L, Tp const& R) noexcept {
return L.value != R.value;
}
}
//============================================================================//
// Implicit value types
namespace ConstexprTestTypes {
#define DEFINE_BASE(Name) ::ArchetypeBases::ValueBase<>
#include "archetypes.ipp"
using TestType = AllCtors;
// Add equality operators
template <class Tp>
constexpr bool operator==(Tp const& L, Tp const& R) noexcept {
return L.value == R.value;
}
template <class Tp>
constexpr bool operator!=(Tp const& L, Tp const& R) noexcept {
return L.value != R.value;
}
} // end namespace ConstexprTestTypes
//============================================================================//
//
namespace ExplicitConstexprTestTypes {
#define DEFINE_EXPLICIT explicit
#define DEFINE_BASE(Name) ::ArchetypeBases::ValueBase<true>
#include "archetypes.ipp"
using TestType = AllCtors;
// Add equality operators
template <class Tp>
constexpr bool operator==(Tp const& L, Tp const& R) noexcept {
return L.value == R.value;
}
template <class Tp>
constexpr bool operator!=(Tp const& L, Tp const& R) noexcept {
return L.value != R.value;
}
} // end namespace ExplicitConstexprTestTypes
//============================================================================//
//
namespace TrivialTestTypes {
#define DEFINE_BASE(Name) ::ArchetypeBases::TrivialValueBase<false>
#include "archetypes.ipp"
using TestType = AllCtors;
// Add equality operators
template <class Tp>
constexpr bool operator==(Tp const& L, Tp const& R) noexcept {
return L.value == R.value;
}
template <class Tp>
constexpr bool operator!=(Tp const& L, Tp const& R) noexcept {
return L.value != R.value;
}
} // end namespace TrivialTestTypes
//============================================================================//
//
namespace ExplicitTrivialTestTypes {
#define DEFINE_EXPLICIT explicit
#define DEFINE_BASE(Name) ::ArchetypeBases::TrivialValueBase<true>
#include "archetypes.ipp"
using TestType = AllCtors;
// Add equality operators
template <class Tp>
constexpr bool operator==(Tp const& L, Tp const& R) noexcept {
return L.value == R.value;
}
template <class Tp>
constexpr bool operator!=(Tp const& L, Tp const& R) noexcept {
return L.value != R.value;
}
} // end namespace ExplicitTrivialTestTypes
#endif // TEST_STD_VER >= 11
#endif // TEST_SUPPORT_ARCHETYPES_H

libcxx/trunk/test/support/archetypes.hpp

#ifndef TEST_SUPPORT_ARCHETYPES_HPP
#define TEST_SUPPORT_ARCHETYPES_HPP
#include <type_traits>
#include <cassert>
#include "test_macros.h"
#include "test_workarounds.h"
#if TEST_STD_VER >= 11
namespace ArchetypeBases {
template <bool, class T>
struct DepType : T {};
struct NullBase {
#ifndef TEST_WORKAROUND_C1XX_BROKEN_ZA_CTOR_CHECK
protected:
#endif // !TEST_WORKAROUND_C1XX_BROKEN_ZA_CTOR_CHECK
NullBase() = default;
NullBase(NullBase const&) = default;
NullBase& operator=(NullBase const&) = default;
NullBase(NullBase &&) = default;
NullBase& operator=(NullBase &&) = default;
};
template <class Derived, bool Explicit = false>
struct TestBase {
static int alive;
static int constructed;
static int value_constructed;
static int default_constructed;
static int copy_constructed;
static int move_constructed;
static int assigned;
static int value_assigned;
static int copy_assigned;
static int move_assigned;
static int destroyed;
static void reset() {
assert(alive == 0);
alive = 0;
reset_constructors();
}
static void reset_constructors() {
constructed = value_constructed = default_constructed =
copy_constructed = move_constructed = 0;
assigned = value_assigned = copy_assigned = move_assigned = destroyed = 0;
}
TestBase() noexcept : value(0) {
++alive; ++constructed; ++default_constructed;
}
template <bool Dummy = true, typename std::enable_if<Dummy && Explicit, bool>::type = true>
explicit TestBase(int x) noexcept : value(x) {
++alive; ++constructed; ++value_constructed;
}
template <bool Dummy = true, typename std::enable_if<Dummy && !Explicit, bool>::type = true>
TestBase(int x) noexcept : value(x) {
++alive; ++constructed; ++value_constructed;
}
template <bool Dummy = true, typename std::enable_if<Dummy && Explicit, bool>::type = true>
explicit TestBase(int, int y) noexcept : value(y) {
++alive; ++constructed; ++value_constructed;
}
template <bool Dummy = true, typename std::enable_if<Dummy && !Explicit, bool>::type = true>
TestBase(int, int y) noexcept : value(y) {
++alive; ++constructed; ++value_constructed;
}
template <bool Dummy = true, typename std::enable_if<Dummy && Explicit, bool>::type = true>
explicit TestBase(std::initializer_list<int>& il, int = 0) noexcept
: value(static_cast<int>(il.size())) {
++alive; ++constructed; ++value_constructed;
}
template <bool Dummy = true, typename std::enable_if<Dummy && !Explicit, bool>::type = true>
explicit TestBase(std::initializer_list<int>& il, int = 0) noexcept : value(static_cast<int>(il.size())) {
++alive; ++constructed; ++value_constructed;
}
TestBase& operator=(int xvalue) noexcept {
value = xvalue;
++assigned; ++value_assigned;
return *this;
}
#ifndef TEST_WORKAROUND_C1XX_BROKEN_ZA_CTOR_CHECK
protected:
#endif // !TEST_WORKAROUND_C1XX_BROKEN_ZA_CTOR_CHECK
~TestBase() {
assert(value != -999); assert(alive > 0);
--alive; ++destroyed; value = -999;
}
explicit TestBase(TestBase const& o) noexcept : value(o.value) {
assert(o.value != -1); assert(o.value != -999);
++alive; ++constructed; ++copy_constructed;
}
explicit TestBase(TestBase && o) noexcept : value(o.value) {
assert(o.value != -1); assert(o.value != -999);
++alive; ++constructed; ++move_constructed;
o.value = -1;
}
TestBase& operator=(TestBase const& o) noexcept {
assert(o.value != -1); assert(o.value != -999);
++assigned; ++copy_assigned;
value = o.value;
return *this;
}
TestBase& operator=(TestBase&& o) noexcept {
assert(o.value != -1); assert(o.value != -999);
++assigned; ++move_assigned;
value = o.value;
o.value = -1;
return *this;
}
public:
int value;
};
template <class D, bool E> int TestBase<D, E>::alive = 0;
template <class D, bool E> int TestBase<D, E>::constructed = 0;
template <class D, bool E> int TestBase<D, E>::value_constructed = 0;
template <class D, bool E> int TestBase<D, E>::default_constructed = 0;
template <class D, bool E> int TestBase<D, E>::copy_constructed = 0;
template <class D, bool E> int TestBase<D, E>::move_constructed = 0;
template <class D, bool E> int TestBase<D, E>::assigned = 0;
template <class D, bool E> int TestBase<D, E>::value_assigned = 0;
template <class D, bool E> int TestBase<D, E>::copy_assigned = 0;
template <class D, bool E> int TestBase<D, E>::move_assigned = 0;
template <class D, bool E> int TestBase<D, E>::destroyed = 0;
template <bool Explicit = false>
struct ValueBase {
template <bool Dummy = true, typename std::enable_if<Dummy && Explicit, bool>::type = true>
explicit constexpr ValueBase(int x) : value(x) {}
template <bool Dummy = true, typename std::enable_if<Dummy && !Explicit, bool>::type = true>
constexpr ValueBase(int x) : value(x) {}
template <bool Dummy = true, typename std::enable_if<Dummy && Explicit, bool>::type = true>
explicit constexpr ValueBase(int, int y) : value(y) {}
template <bool Dummy = true, typename std::enable_if<Dummy && !Explicit, bool>::type = true>
constexpr ValueBase(int, int y) : value(y) {}
template <bool Dummy = true, typename std::enable_if<Dummy && Explicit, bool>::type = true>
explicit constexpr ValueBase(std::initializer_list<int>& il, int = 0) : value(static_cast<int>(il.size())) {}
template <bool Dummy = true, typename std::enable_if<Dummy && !Explicit, bool>::type = true>
constexpr ValueBase(std::initializer_list<int>& il, int = 0) : value(static_cast<int>(il.size())) {}
TEST_CONSTEXPR_CXX14 ValueBase& operator=(int xvalue) noexcept {
value = xvalue;
return *this;
}
//~ValueBase() { assert(value != -999); value = -999; }
int value;
#ifndef TEST_WORKAROUND_C1XX_BROKEN_ZA_CTOR_CHECK
protected:
#endif // !TEST_WORKAROUND_C1XX_BROKEN_ZA_CTOR_CHECK
constexpr static int check_value(int const& val) {
#if TEST_STD_VER < 14
return val == -1 || val == 999 ? (TEST_THROW(42), 0) : val;
#else
assert(val != -1); assert(val != 999);
return val;
#endif
}
constexpr static int check_value(int& val, int val_cp = 0) {
#if TEST_STD_VER < 14
return val_cp = val, val = -1, (val_cp == -1 || val_cp == 999 ? (TEST_THROW(42), 0) : val_cp);
#else
assert(val != -1); assert(val != 999);
val_cp = val;
val = -1;
return val_cp;
#endif
}
constexpr ValueBase() noexcept : value(0) {}
constexpr ValueBase(ValueBase const& o) noexcept : value(check_value(o.value)) {
}
constexpr ValueBase(ValueBase && o) noexcept : value(check_value(o.value)) {
}
TEST_CONSTEXPR_CXX14 ValueBase& operator=(ValueBase const& o) noexcept {
assert(o.value != -1); assert(o.value != -999);
value = o.value;
return *this;
}
TEST_CONSTEXPR_CXX14 ValueBase& operator=(ValueBase&& o) noexcept {
assert(o.value != -1); assert(o.value != -999);
value = o.value;
o.value = -1;
return *this;
}
};
template <bool Explicit = false>
struct TrivialValueBase {
template <bool Dummy = true, typename std::enable_if<Dummy && Explicit, bool>::type = true>
explicit constexpr TrivialValueBase(int x) : value(x) {}
template <bool Dummy = true, typename std::enable_if<Dummy && !Explicit, bool>::type = true>
constexpr TrivialValueBase(int x) : value(x) {}
template <bool Dummy = true, typename std::enable_if<Dummy && Explicit, bool>::type = true>
explicit constexpr TrivialValueBase(int, int y) : value(y) {}
template <bool Dummy = true, typename std::enable_if<Dummy && !Explicit, bool>::type = true>
constexpr TrivialValueBase(int, int y) : value(y) {}
template <bool Dummy = true, typename std::enable_if<Dummy && Explicit, bool>::type = true>
explicit constexpr TrivialValueBase(std::initializer_list<int>& il, int = 0) : value(static_cast<int>(il.size())) {}
template <bool Dummy = true, typename std::enable_if<Dummy && !Explicit, bool>::type = true>
constexpr TrivialValueBase(std::initializer_list<int>& il, int = 0) : value(static_cast<int>(il.size())) {}
int value;
#ifndef TEST_WORKAROUND_C1XX_BROKEN_ZA_CTOR_CHECK
protected:
#endif // !TEST_WORKAROUND_C1XX_BROKEN_ZA_CTOR_CHECK
constexpr TrivialValueBase() noexcept : value(0) {}
};
}
//============================================================================//
// Trivial Implicit Test Types
namespace ImplicitTypes {
#include "archetypes.ipp"
}
//============================================================================//
// Trivial Explicit Test Types
namespace ExplicitTypes {
#define DEFINE_EXPLICIT explicit
#include "archetypes.ipp"
}
//============================================================================//
//
namespace NonConstexprTypes {
#define DEFINE_CONSTEXPR
#include "archetypes.ipp"
}
//============================================================================//
// Non-literal implicit test types
namespace NonLiteralTypes {
#define DEFINE_ASSIGN_CONSTEXPR
#define DEFINE_DTOR(Name) ~Name() {}
#include "archetypes.ipp"
}
//============================================================================//
// Non-throwing implicit test types
namespace NonThrowingTypes {
#define DEFINE_NOEXCEPT noexcept
#include "archetypes.ipp"
}
//============================================================================//
// Non-Trivially Copyable Implicit Test Types
namespace NonTrivialTypes {
#define DEFINE_CTOR {}
#define DEFINE_ASSIGN { return *this; }
#include "archetypes.ipp"
}
//============================================================================//
// Implicit counting types
namespace TestTypes {
#define DEFINE_CONSTEXPR
#define DEFINE_BASE(Name) ::ArchetypeBases::TestBase<Name>
#include "archetypes.ipp"
using TestType = AllCtors;
// Add equality operators
template <class Tp>
constexpr bool operator==(Tp const& L, Tp const& R) noexcept {
return L.value == R.value;
}
template <class Tp>
constexpr bool operator!=(Tp const& L, Tp const& R) noexcept {
return L.value != R.value;
}
}
//============================================================================//
// Implicit counting types
namespace ExplicitTestTypes {
#define DEFINE_CONSTEXPR
#define DEFINE_EXPLICIT explicit
#define DEFINE_BASE(Name) ::ArchetypeBases::TestBase<Name, true>
#include "archetypes.ipp"
using TestType = AllCtors;
// Add equality operators
template <class Tp>
constexpr bool operator==(Tp const& L, Tp const& R) noexcept {
return L.value == R.value;
}
template <class Tp>
constexpr bool operator!=(Tp const& L, Tp const& R) noexcept {
return L.value != R.value;
}
}
//============================================================================//
// Implicit value types
namespace ConstexprTestTypes {
#define DEFINE_BASE(Name) ::ArchetypeBases::ValueBase<>
#include "archetypes.ipp"
using TestType = AllCtors;
// Add equality operators
template <class Tp>
constexpr bool operator==(Tp const& L, Tp const& R) noexcept {
return L.value == R.value;
}
template <class Tp>
constexpr bool operator!=(Tp const& L, Tp const& R) noexcept {
return L.value != R.value;
}
} // end namespace ConstexprTestTypes
//============================================================================//
//
namespace ExplicitConstexprTestTypes {
#define DEFINE_EXPLICIT explicit
#define DEFINE_BASE(Name) ::ArchetypeBases::ValueBase<true>
#include "archetypes.ipp"
using TestType = AllCtors;
// Add equality operators
template <class Tp>
constexpr bool operator==(Tp const& L, Tp const& R) noexcept {
return L.value == R.value;
}
template <class Tp>
constexpr bool operator!=(Tp const& L, Tp const& R) noexcept {
return L.value != R.value;
}
} // end namespace ExplicitConstexprTestTypes
//============================================================================//
//
namespace TrivialTestTypes {
#define DEFINE_BASE(Name) ::ArchetypeBases::TrivialValueBase<false>
#include "archetypes.ipp"
using TestType = AllCtors;
// Add equality operators
template <class Tp>
constexpr bool operator==(Tp const& L, Tp const& R) noexcept {
return L.value == R.value;
}
template <class Tp>
constexpr bool operator!=(Tp const& L, Tp const& R) noexcept {
return L.value != R.value;
}
} // end namespace TrivialTestTypes
//============================================================================//
//
namespace ExplicitTrivialTestTypes {
#define DEFINE_EXPLICIT explicit
#define DEFINE_BASE(Name) ::ArchetypeBases::TrivialValueBase<true>
#include "archetypes.ipp"
using TestType = AllCtors;
// Add equality operators
template <class Tp>
constexpr bool operator==(Tp const& L, Tp const& R) noexcept {
return L.value == R.value;
}
template <class Tp>
constexpr bool operator!=(Tp const& L, Tp const& R) noexcept {
return L.value != R.value;
}
} // end namespace ExplicitTrivialTestTypes
#endif // TEST_STD_VER >= 11
#endif // TEST_SUPPORT_ARCHETYPES_HPP

libcxx/trunk/test/support/constexpr_char_traits.h

// -*- C++ -*-
//===-------------------- constexpr_char_traits ---------------------------===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
#ifndef _CONSTEXPR_CHAR_TRAITS
#define _CONSTEXPR_CHAR_TRAITS
#include <string>
#include <cassert>
#include "test_macros.h"
template <class _CharT>
struct constexpr_char_traits
{
typedef _CharT char_type;
typedef int int_type;
typedef std::streamoff off_type;
typedef std::streampos pos_type;
typedef std::mbstate_t state_type;
static TEST_CONSTEXPR_CXX14 void assign(char_type& __c1, const char_type& __c2) TEST_NOEXCEPT
{__c1 = __c2;}
static TEST_CONSTEXPR bool eq(char_type __c1, char_type __c2) TEST_NOEXCEPT
{return __c1 == __c2;}
static TEST_CONSTEXPR bool lt(char_type __c1, char_type __c2) TEST_NOEXCEPT
{return __c1 < __c2;}
static TEST_CONSTEXPR_CXX14 int compare(const char_type* __s1, const char_type* __s2, size_t __n);
static TEST_CONSTEXPR_CXX14 size_t length(const char_type* __s);
static TEST_CONSTEXPR_CXX14 const char_type* find(const char_type* __s, size_t __n, const char_type& __a);
static TEST_CONSTEXPR_CXX14 char_type* move(char_type* __s1, const char_type* __s2, size_t __n);
static TEST_CONSTEXPR_CXX14 char_type* copy(char_type* __s1, const char_type* __s2, size_t __n);
static TEST_CONSTEXPR_CXX14 char_type* assign(char_type* __s, size_t __n, char_type __a);
static TEST_CONSTEXPR int_type not_eof(int_type __c) TEST_NOEXCEPT
{return eq_int_type(__c, eof()) ? ~eof() : __c;}
static TEST_CONSTEXPR char_type to_char_type(int_type __c) TEST_NOEXCEPT
{return char_type(__c);}
static TEST_CONSTEXPR int_type to_int_type(char_type __c) TEST_NOEXCEPT
{return int_type(__c);}
static TEST_CONSTEXPR bool eq_int_type(int_type __c1, int_type __c2) TEST_NOEXCEPT
{return __c1 == __c2;}
static TEST_CONSTEXPR int_type eof() TEST_NOEXCEPT
{return int_type(EOF);}
};
template <class _CharT>
TEST_CONSTEXPR_CXX14 int
constexpr_char_traits<_CharT>::compare(const char_type* __s1, const char_type* __s2, size_t __n)
{
for (; __n; --__n, ++__s1, ++__s2)
{
if (lt(*__s1, *__s2))
return -1;
if (lt(*__s2, *__s1))
return 1;
}
return 0;
}
template <class _CharT>
TEST_CONSTEXPR_CXX14 size_t
constexpr_char_traits<_CharT>::length(const char_type* __s)
{
size_t __len = 0;
for (; !eq(*__s, char_type(0)); ++__s)
++__len;
return __len;
}
template <class _CharT>
TEST_CONSTEXPR_CXX14 const _CharT*
constexpr_char_traits<_CharT>::find(const char_type* __s, size_t __n, const char_type& __a)
{
for (; __n; --__n)
{
if (eq(*__s, __a))
return __s;
++__s;
}
return 0;
}
template <class _CharT>
TEST_CONSTEXPR_CXX14 _CharT*
constexpr_char_traits<_CharT>::move(char_type* __s1, const char_type* __s2, size_t __n)
{
char_type* __r = __s1;
if (__s1 < __s2)
{
for (; __n; --__n, ++__s1, ++__s2)
assign(*__s1, *__s2);
}
else if (__s2 < __s1)
{
__s1 += __n;
__s2 += __n;
for (; __n; --__n)
assign(*--__s1, *--__s2);
}
return __r;
}
template <class _CharT>
TEST_CONSTEXPR_CXX14 _CharT*
constexpr_char_traits<_CharT>::copy(char_type* __s1, const char_type* __s2, size_t __n)
{
assert(__s2 < __s1 || __s2 >= __s1+__n);
char_type* __r = __s1;
for (; __n; --__n, ++__s1, ++__s2)
assign(*__s1, *__s2);
return __r;
}
template <class _CharT>
TEST_CONSTEXPR_CXX14 _CharT*
constexpr_char_traits<_CharT>::assign(char_type* __s, size_t __n, char_type __a)
{
char_type* __r = __s;
for (; __n; --__n, ++__s)
assign(*__s, __a);
return __r;
}
#endif // _CONSTEXPR_CHAR_TRAITS

libcxx/trunk/test/support/constexpr_char_traits.hpp

// -*- C++ -*-
//===-------------------- constexpr_char_traits ---------------------------===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
#ifndef _CONSTEXPR_CHAR_TRAITS
#define _CONSTEXPR_CHAR_TRAITS
#include <string>
#include <cassert>
#include "test_macros.h"
template <class _CharT>
struct constexpr_char_traits
{
typedef _CharT char_type;
typedef int int_type;
typedef std::streamoff off_type;
typedef std::streampos pos_type;
typedef std::mbstate_t state_type;
static TEST_CONSTEXPR_CXX14 void assign(char_type& __c1, const char_type& __c2) TEST_NOEXCEPT
{__c1 = __c2;}
static TEST_CONSTEXPR bool eq(char_type __c1, char_type __c2) TEST_NOEXCEPT
{return __c1 == __c2;}
static TEST_CONSTEXPR bool lt(char_type __c1, char_type __c2) TEST_NOEXCEPT
{return __c1 < __c2;}
static TEST_CONSTEXPR_CXX14 int compare(const char_type* __s1, const char_type* __s2, size_t __n);
static TEST_CONSTEXPR_CXX14 size_t length(const char_type* __s);
static TEST_CONSTEXPR_CXX14 const char_type* find(const char_type* __s, size_t __n, const char_type& __a);
static TEST_CONSTEXPR_CXX14 char_type* move(char_type* __s1, const char_type* __s2, size_t __n);
static TEST_CONSTEXPR_CXX14 char_type* copy(char_type* __s1, const char_type* __s2, size_t __n);
static TEST_CONSTEXPR_CXX14 char_type* assign(char_type* __s, size_t __n, char_type __a);
static TEST_CONSTEXPR int_type not_eof(int_type __c) TEST_NOEXCEPT
{return eq_int_type(__c, eof()) ? ~eof() : __c;}
static TEST_CONSTEXPR char_type to_char_type(int_type __c) TEST_NOEXCEPT
{return char_type(__c);}
static TEST_CONSTEXPR int_type to_int_type(char_type __c) TEST_NOEXCEPT
{return int_type(__c);}
static TEST_CONSTEXPR bool eq_int_type(int_type __c1, int_type __c2) TEST_NOEXCEPT
{return __c1 == __c2;}
static TEST_CONSTEXPR int_type eof() TEST_NOEXCEPT
{return int_type(EOF);}
};
template <class _CharT>
TEST_CONSTEXPR_CXX14 int
constexpr_char_traits<_CharT>::compare(const char_type* __s1, const char_type* __s2, size_t __n)
{
for (; __n; --__n, ++__s1, ++__s2)
{
if (lt(*__s1, *__s2))
return -1;
if (lt(*__s2, *__s1))
return 1;
}
return 0;
}
template <class _CharT>
TEST_CONSTEXPR_CXX14 size_t
constexpr_char_traits<_CharT>::length(const char_type* __s)
{
size_t __len = 0;
for (; !eq(*__s, char_type(0)); ++__s)
++__len;
return __len;
}
template <class _CharT>
TEST_CONSTEXPR_CXX14 const _CharT*
constexpr_char_traits<_CharT>::find(const char_type* __s, size_t __n, const char_type& __a)
{
for (; __n; --__n)
{
if (eq(*__s, __a))
return __s;
++__s;
}
return 0;
}
template <class _CharT>
TEST_CONSTEXPR_CXX14 _CharT*
constexpr_char_traits<_CharT>::move(char_type* __s1, const char_type* __s2, size_t __n)
{
char_type* __r = __s1;
if (__s1 < __s2)
{
for (; __n; --__n, ++__s1, ++__s2)
assign(*__s1, *__s2);
}
else if (__s2 < __s1)
{
__s1 += __n;
__s2 += __n;
for (; __n; --__n)
assign(*--__s1, *--__s2);
}
return __r;
}
template <class _CharT>
TEST_CONSTEXPR_CXX14 _CharT*
constexpr_char_traits<_CharT>::copy(char_type* __s1, const char_type* __s2, size_t __n)
{
assert(__s2 < __s1 || __s2 >= __s1+__n);
char_type* __r = __s1;
for (; __n; --__n, ++__s1, ++__s2)
assign(*__s1, *__s2);
return __r;
}
template <class _CharT>
TEST_CONSTEXPR_CXX14 _CharT*
constexpr_char_traits<_CharT>::assign(char_type* __s, size_t __n, char_type __a)
{
char_type* __r = __s;
for (; __n; --__n, ++__s)
assign(*__s, __a);
return __r;
}
#endif // _CONSTEXPR_CHAR_TRAITS

libcxx/trunk/test/support/container_debug_tests.h

//===----------------------------------------------------------------------===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
#ifndef TEST_SUPPORT_CONTAINER_DEBUG_TESTS_H
#define TEST_SUPPORT_CONTAINER_DEBUG_TESTS_H
#include <ciso646>
#ifndef _LIBCPP_VERSION
#error This header may only be used for libc++ tests"
#endif
#ifndef _LIBCPP_DEBUG
#error _LIBCPP_DEBUG must be defined before including this header
#endif
#include <__debug>
#include <utility>
#include <cstddef>
#include <cstdlib>
#include <cassert>
#include <string>
#include <sstream>
#include <iostream>
#include "test_macros.h"
#include "debug_mode_helper.h"
#include "assert_checkpoint.h"
#include "test_allocator.h"
// These test make use of 'if constexpr'.
#if TEST_STD_VER <= 14
#error This header may only be used in C++17 and greater
#endif
#ifndef __cpp_if_constexpr
#error These tests require if constexpr
#endif
namespace IteratorDebugChecks {
enum ContainerType {
CT_None,
CT_String,
CT_Vector,
CT_VectorBool,
CT_List,
CT_Deque,
CT_ForwardList,
CT_Map,
CT_Set,
CT_MultiMap,
CT_MultiSet,
CT_UnorderedMap,
CT_UnorderedSet,
CT_UnorderedMultiMap,
CT_UnorderedMultiSet
};
constexpr bool isSequential(ContainerType CT) {
return CT_Vector >= CT && CT_ForwardList <= CT;
}
constexpr bool isAssociative(ContainerType CT) {
return CT_Map >= CT && CT_MultiSet <= CT;
}
constexpr bool isUnordered(ContainerType CT) {
return CT_UnorderedMap >= CT && CT_UnorderedMultiSet <= CT;
}
constexpr bool isSet(ContainerType CT) {
return CT == CT_Set
|| CT == CT_MultiSet
|| CT == CT_UnorderedSet
|| CT == CT_UnorderedMultiSet;
}
constexpr bool isMap(ContainerType CT) {
return CT == CT_Map
|| CT == CT_MultiMap
|| CT == CT_UnorderedMap
|| CT == CT_UnorderedMultiMap;
}
constexpr bool isMulti(ContainerType CT) {
return CT == CT_MultiMap
|| CT == CT_MultiSet
|| CT == CT_UnorderedMultiMap
|| CT == CT_UnorderedMultiSet;
}
template <class Container, class ValueType = typename Container::value_type>
struct ContainerDebugHelper {
static_assert(std::is_constructible<ValueType, int>::value,
"must be constructible from int");
static ValueType makeValueType(int val = 0, int = 0) {
return ValueType(val);
}
};
template <class Container>
struct ContainerDebugHelper<Container, char> {
static char makeValueType(int = 0, int = 0) {
return 'A';
}
};
template <class Container, class Key, class Value>
struct ContainerDebugHelper<Container, std::pair<const Key, Value> > {
using ValueType = std::pair<const Key, Value>;
static_assert(std::is_constructible<Key, int>::value,
"must be constructible from int");
static_assert(std::is_constructible<Value, int>::value,
"must be constructible from int");
static ValueType makeValueType(int key = 0, int val = 0) {
return ValueType(key, val);
}
};
template <class Container, ContainerType CT,
class Helper = ContainerDebugHelper<Container> >
struct BasicContainerChecks {
using value_type = typename Container::value_type;
using iterator = typename Container::iterator;
using const_iterator = typename Container::const_iterator;
using allocator_type = typename Container::allocator_type;
using traits = std::iterator_traits<iterator>;
using category = typename traits::iterator_category;
static_assert(std::is_same<test_allocator<value_type>, allocator_type>::value,
"the container must use a test allocator");
static constexpr bool IsBiDir =
std::is_convertible<category, std::bidirectional_iterator_tag>::value;
public:
static void run() {
run_iterator_tests();
run_container_tests();
run_allocator_aware_tests();
}
static void run_iterator_tests() {
TestNullIterators<iterator>();
TestNullIterators<const_iterator>();
if constexpr (IsBiDir) { DecrementBegin(); }
IncrementEnd();
DerefEndIterator();
}
static void run_container_tests() {
CopyInvalidatesIterators();
MoveInvalidatesIterators();
if constexpr (CT != CT_ForwardList) {
EraseIter();
EraseIterIter();
}
}
static void run_allocator_aware_tests() {
SwapNonEqualAllocators();
if constexpr (CT != CT_ForwardList ) {
// FIXME: This should work for both forward_list and string
SwapInvalidatesIterators();
}
}
static Container makeContainer(int size, allocator_type A = allocator_type()) {
Container C(A);
if constexpr (CT == CT_ForwardList) {
for (int i = 0; i < size; ++i)
C.insert_after(C.before_begin(), Helper::makeValueType(i));
} else {
for (int i = 0; i < size; ++i)
C.insert(C.end(), Helper::makeValueType(i));
assert(C.size() == static_cast<std::size_t>(size));
}
return C;
}
static value_type makeValueType(int value) {
return Helper::makeValueType(value);
}
private:
// Iterator tests
template <class Iter>
static void TestNullIterators() {
CHECKPOINT("testing null iterator");
Iter it;
EXPECT_DEATH( ++it );
EXPECT_DEATH( it++ );
EXPECT_DEATH( *it );
if constexpr (CT != CT_VectorBool) {
EXPECT_DEATH( it.operator->() );
}
if constexpr (IsBiDir) {
EXPECT_DEATH( --it );
EXPECT_DEATH( it-- );
}
}
static void DecrementBegin() {
CHECKPOINT("testing decrement on begin");
Container C = makeContainer(1);
iterator i = C.end();
const_iterator ci = C.cend();
--i;
--ci;
assert(i == C.begin());
EXPECT_DEATH( --i );
EXPECT_DEATH( i-- );
EXPECT_DEATH( --ci );
EXPECT_DEATH( ci-- );
}
static void IncrementEnd() {
CHECKPOINT("testing increment on end");
Container C = makeContainer(1);
iterator i = C.begin();
const_iterator ci = C.begin();
++i;
++ci;
assert(i == C.end());
EXPECT_DEATH( ++i );
EXPECT_DEATH( i++ );
EXPECT_DEATH( ++ci );
EXPECT_DEATH( ci++ );
}
static void DerefEndIterator() {
CHECKPOINT("testing deref end iterator");
Container C = makeContainer(1);
iterator i = C.begin();
const_iterator ci = C.cbegin();
(void)*i; (void)*ci;
if constexpr (CT != CT_VectorBool) {
i.operator->();
ci.operator->();
}
++i; ++ci;
assert(i == C.end());
EXPECT_DEATH( *i );
EXPECT_DEATH( *ci );
if constexpr (CT != CT_VectorBool) {
EXPECT_DEATH( i.operator->() );
EXPECT_DEATH( ci.operator->() );
}
}
// Container tests
static void CopyInvalidatesIterators() {
CHECKPOINT("copy invalidates iterators");
Container C1 = makeContainer(3);
iterator i = C1.begin();
Container C2 = C1;
if constexpr (CT == CT_ForwardList) {
iterator i_next = i;
++i_next;
(void)*i_next;
EXPECT_DEATH( C2.erase_after(i) );
C1.erase_after(i);
EXPECT_DEATH( *i_next );
} else {
EXPECT_DEATH( C2.erase(i) );
(void)*i;
C1.erase(i);
EXPECT_DEATH( *i );
}
}
static void MoveInvalidatesIterators() {
CHECKPOINT("copy move invalidates iterators");
Container C1 = makeContainer(3);
iterator i = C1.begin();
Container C2 = std::move(C1);
(void) *i;
if constexpr (CT == CT_ForwardList) {
EXPECT_DEATH( C1.erase_after(i) );
C2.erase_after(i);
} else {
EXPECT_DEATH( C1.erase(i) );
C2.erase(i);
EXPECT_DEATH(*i);
}
}
static void EraseIter() {
CHECKPOINT("testing erase invalidation");
Container C1 = makeContainer(2);
iterator it1 = C1.begin();
iterator it1_next = it1;
++it1_next;
Container C2 = C1;
EXPECT_DEATH( C2.erase(it1) ); // wrong container
EXPECT_DEATH( C2.erase(C2.end()) ); // erase with end
C1.erase(it1_next);
EXPECT_DEATH( C1.erase(it1_next) ); // invalidated iterator
C1.erase(it1);
EXPECT_DEATH( C1.erase(it1) ); // invalidated iterator
}
static void EraseIterIter() {
CHECKPOINT("testing erase iter iter invalidation");
Container C1 = makeContainer(2);
iterator it1 = C1.begin();
iterator it1_next = it1;
++it1_next;
Container C2 = C1;
iterator it2 = C2.begin();
iterator it2_next = it2;
++it2_next;
EXPECT_DEATH( C2.erase(it1, it1_next) ); // begin from wrong container
EXPECT_DEATH( C2.erase(it1, it2_next) ); // end from wrong container
EXPECT_DEATH( C2.erase(it2, it1_next) ); // both from wrong container
C2.erase(it2, it2_next);
}
// Allocator aware tests
static void SwapInvalidatesIterators() {
CHECKPOINT("testing swap invalidates iterators");
Container C1 = makeContainer(3);
Container C2 = makeContainer(3);
iterator it1 = C1.begin();
iterator it2 = C2.begin();
swap(C1, C2);
EXPECT_DEATH( C1.erase(it1) );
if (CT == CT_String) {
EXPECT_DEATH(C1.erase(it2));
} else
C1.erase(it2);
//C2.erase(it1);
EXPECT_DEATH( C1.erase(it1) );
}
static void SwapNonEqualAllocators() {
CHECKPOINT("testing swap with non-equal allocators");
Container C1 = makeContainer(3, allocator_type(1));
Container C2 = makeContainer(1, allocator_type(2));
Container C3 = makeContainer(2, allocator_type(2));
swap(C2, C3);
EXPECT_DEATH( swap(C1, C2) );
}
private:
BasicContainerChecks() = delete;
};
} // namespace IteratorDebugChecks
#endif // TEST_SUPPORT_CONTAINER_DEBUG_TESTS_H

libcxx/trunk/test/support/container_debug_tests.hpp

//===----------------------------------------------------------------------===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
#ifndef TEST_SUPPORT_CONTAINER_DEBUG_TESTS_H
#define TEST_SUPPORT_CONTAINER_DEBUG_TESTS_H
#include <ciso646>
#ifndef _LIBCPP_VERSION
#error This header may only be used for libc++ tests"
#endif
#ifndef _LIBCPP_DEBUG
#error _LIBCPP_DEBUG must be defined before including this header
#endif
#include <__debug>
#include <utility>
#include <cstddef>
#include <cstdlib>
#include <cassert>
#include <string>
#include <sstream>
#include <iostream>
#include "test_macros.h"
#include "debug_mode_helper.h"
#include "assert_checkpoint.h"
#include "test_allocator.h"
// These test make use of 'if constexpr'.
#if TEST_STD_VER <= 14
#error This header may only be used in C++17 and greater
#endif
#ifndef __cpp_if_constexpr
#error These tests require if constexpr
#endif
namespace IteratorDebugChecks {
enum ContainerType {
CT_None,
CT_String,
CT_Vector,
CT_VectorBool,
CT_List,
CT_Deque,
CT_ForwardList,
CT_Map,
CT_Set,
CT_MultiMap,
CT_MultiSet,
CT_UnorderedMap,
CT_UnorderedSet,
CT_UnorderedMultiMap,
CT_UnorderedMultiSet
};
constexpr bool isSequential(ContainerType CT) {
return CT_Vector >= CT && CT_ForwardList <= CT;
}
constexpr bool isAssociative(ContainerType CT) {
return CT_Map >= CT && CT_MultiSet <= CT;
}
constexpr bool isUnordered(ContainerType CT) {
return CT_UnorderedMap >= CT && CT_UnorderedMultiSet <= CT;
}
constexpr bool isSet(ContainerType CT) {
return CT == CT_Set
|| CT == CT_MultiSet
|| CT == CT_UnorderedSet
|| CT == CT_UnorderedMultiSet;
}
constexpr bool isMap(ContainerType CT) {
return CT == CT_Map
|| CT == CT_MultiMap
|| CT == CT_UnorderedMap
|| CT == CT_UnorderedMultiMap;
}
constexpr bool isMulti(ContainerType CT) {
return CT == CT_MultiMap
|| CT == CT_MultiSet
|| CT == CT_UnorderedMultiMap
|| CT == CT_UnorderedMultiSet;
}
template <class Container, class ValueType = typename Container::value_type>
struct ContainerDebugHelper {
static_assert(std::is_constructible<ValueType, int>::value,
"must be constructible from int");
static ValueType makeValueType(int val = 0, int = 0) {
return ValueType(val);
}
};
template <class Container>
struct ContainerDebugHelper<Container, char> {
static char makeValueType(int = 0, int = 0) {
return 'A';
}
};
template <class Container, class Key, class Value>
struct ContainerDebugHelper<Container, std::pair<const Key, Value> > {
using ValueType = std::pair<const Key, Value>;
static_assert(std::is_constructible<Key, int>::value,
"must be constructible from int");
static_assert(std::is_constructible<Value, int>::value,
"must be constructible from int");
static ValueType makeValueType(int key = 0, int val = 0) {
return ValueType(key, val);
}
};
template <class Container, ContainerType CT,
class Helper = ContainerDebugHelper<Container> >
struct BasicContainerChecks {
using value_type = typename Container::value_type;
using iterator = typename Container::iterator;
using const_iterator = typename Container::const_iterator;
using allocator_type = typename Container::allocator_type;
using traits = std::iterator_traits<iterator>;
using category = typename traits::iterator_category;
static_assert(std::is_same<test_allocator<value_type>, allocator_type>::value,
"the container must use a test allocator");
static constexpr bool IsBiDir =
std::is_convertible<category, std::bidirectional_iterator_tag>::value;
public:
static void run() {
run_iterator_tests();
run_container_tests();
run_allocator_aware_tests();
}
static void run_iterator_tests() {
TestNullIterators<iterator>();
TestNullIterators<const_iterator>();
if constexpr (IsBiDir) { DecrementBegin(); }
IncrementEnd();
DerefEndIterator();
}
static void run_container_tests() {
CopyInvalidatesIterators();
MoveInvalidatesIterators();
if constexpr (CT != CT_ForwardList) {
EraseIter();
EraseIterIter();
}
}
static void run_allocator_aware_tests() {
SwapNonEqualAllocators();
if constexpr (CT != CT_ForwardList ) {
// FIXME: This should work for both forward_list and string
SwapInvalidatesIterators();
}
}
static Container makeContainer(int size, allocator_type A = allocator_type()) {
Container C(A);
if constexpr (CT == CT_ForwardList) {
for (int i = 0; i < size; ++i)
C.insert_after(C.before_begin(), Helper::makeValueType(i));
} else {
for (int i = 0; i < size; ++i)
C.insert(C.end(), Helper::makeValueType(i));
assert(C.size() == static_cast<std::size_t>(size));
}
return C;
}
static value_type makeValueType(int value) {
return Helper::makeValueType(value);
}
private:
// Iterator tests
template <class Iter>
static void TestNullIterators() {
CHECKPOINT("testing null iterator");
Iter it;
EXPECT_DEATH( ++it );
EXPECT_DEATH( it++ );
EXPECT_DEATH( *it );
if constexpr (CT != CT_VectorBool) {
EXPECT_DEATH( it.operator->() );
}
if constexpr (IsBiDir) {
EXPECT_DEATH( --it );
EXPECT_DEATH( it-- );
}
}
static void DecrementBegin() {
CHECKPOINT("testing decrement on begin");
Container C = makeContainer(1);
iterator i = C.end();
const_iterator ci = C.cend();
--i;
--ci;
assert(i == C.begin());
EXPECT_DEATH( --i );
EXPECT_DEATH( i-- );
EXPECT_DEATH( --ci );
EXPECT_DEATH( ci-- );
}
static void IncrementEnd() {
CHECKPOINT("testing increment on end");
Container C = makeContainer(1);
iterator i = C.begin();
const_iterator ci = C.begin();
++i;
++ci;
assert(i == C.end());
EXPECT_DEATH( ++i );
EXPECT_DEATH( i++ );
EXPECT_DEATH( ++ci );
EXPECT_DEATH( ci++ );
}
static void DerefEndIterator() {
CHECKPOINT("testing deref end iterator");
Container C = makeContainer(1);
iterator i = C.begin();
const_iterator ci = C.cbegin();
(void)*i; (void)*ci;
if constexpr (CT != CT_VectorBool) {
i.operator->();
ci.operator->();
}
++i; ++ci;
assert(i == C.end());
EXPECT_DEATH( *i );
EXPECT_DEATH( *ci );
if constexpr (CT != CT_VectorBool) {
EXPECT_DEATH( i.operator->() );
EXPECT_DEATH( ci.operator->() );
}
}
// Container tests
static void CopyInvalidatesIterators() {
CHECKPOINT("copy invalidates iterators");
Container C1 = makeContainer(3);
iterator i = C1.begin();
Container C2 = C1;
if constexpr (CT == CT_ForwardList) {
iterator i_next = i;
++i_next;
(void)*i_next;
EXPECT_DEATH( C2.erase_after(i) );
C1.erase_after(i);
EXPECT_DEATH( *i_next );
} else {
EXPECT_DEATH( C2.erase(i) );
(void)*i;
C1.erase(i);
EXPECT_DEATH( *i );
}
}
static void MoveInvalidatesIterators() {
CHECKPOINT("copy move invalidates iterators");
Container C1 = makeContainer(3);
iterator i = C1.begin();
Container C2 = std::move(C1);
(void) *i;
if constexpr (CT == CT_ForwardList) {
EXPECT_DEATH( C1.erase_after(i) );
C2.erase_after(i);
} else {
EXPECT_DEATH( C1.erase(i) );
C2.erase(i);
EXPECT_DEATH(*i);
}
}
static void EraseIter() {
CHECKPOINT("testing erase invalidation");
Container C1 = makeContainer(2);
iterator it1 = C1.begin();
iterator it1_next = it1;
++it1_next;
Container C2 = C1;
EXPECT_DEATH( C2.erase(it1) ); // wrong container
EXPECT_DEATH( C2.erase(C2.end()) ); // erase with end
C1.erase(it1_next);
EXPECT_DEATH( C1.erase(it1_next) ); // invalidated iterator
C1.erase(it1);
EXPECT_DEATH( C1.erase(it1) ); // invalidated iterator
}
static void EraseIterIter() {
CHECKPOINT("testing erase iter iter invalidation");
Container C1 = makeContainer(2);
iterator it1 = C1.begin();
iterator it1_next = it1;
++it1_next;
Container C2 = C1;
iterator it2 = C2.begin();
iterator it2_next = it2;
++it2_next;
EXPECT_DEATH( C2.erase(it1, it1_next) ); // begin from wrong container
EXPECT_DEATH( C2.erase(it1, it2_next) ); // end from wrong container
EXPECT_DEATH( C2.erase(it2, it1_next) ); // both from wrong container
C2.erase(it2, it2_next);
}
// Allocator aware tests
static void SwapInvalidatesIterators() {
CHECKPOINT("testing swap invalidates iterators");
Container C1 = makeContainer(3);
Container C2 = makeContainer(3);
iterator it1 = C1.begin();
iterator it2 = C2.begin();
swap(C1, C2);
EXPECT_DEATH( C1.erase(it1) );
if (CT == CT_String) {
EXPECT_DEATH(C1.erase(it2));
} else
C1.erase(it2);
//C2.erase(it1);
EXPECT_DEATH( C1.erase(it1) );
}
static void SwapNonEqualAllocators() {
CHECKPOINT("testing swap with non-equal allocators");
Container C1 = makeContainer(3, allocator_type(1));
Container C2 = makeContainer(1, allocator_type(2));
Container C3 = makeContainer(2, allocator_type(2));
swap(C2, C3);
EXPECT_DEATH( swap(C1, C2) );
}
private:
BasicContainerChecks() = delete;
};
} // namespace IteratorDebugChecks
#endif // TEST_SUPPORT_CONTAINER_DEBUG_TESTS_H

libcxx/trunk/test/support/controlled_allocators.h

//===----------------------------------------------------------------------===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
#ifndef SUPPORT_CONTROLLED_ALLOCATORS_H
#define SUPPORT_CONTROLLED_ALLOCATORS_H
#include <memory>
#include <type_traits>
#include <cstddef>
#include <cstdlib>
#include <cstring>
#include <cstdint>
#include <cassert>
#include "test_macros.h"
#include "type_id.h"
#if TEST_STD_VER < 11
#error This header requires C++11 or greater
#endif
struct AllocController;
// 'AllocController' is a concrete type that instruments and controls the
// behavior of test allocators.
template <class T, size_t ID = 0>
class CountingAllocator;
// 'CountingAllocator' is an basic implementation of the 'Allocator'
// requirements that use the 'AllocController' interface.
template <class T>
class MinAlignAllocator;
// 'MinAlignAllocator' is an instrumented test type which implements the
// 'Allocator' requirements. 'MinAlignAllocator' ensures that it *never*
// returns a pointer to over-aligned storage. For example
// 'MinAlignPointer<char>{}.allocate(...)' will never a 2-byte aligned
// pointer.
template <class T>
class NullAllocator;
// 'NullAllocator' is an instrumented test type which implements the
// 'Allocator' requirements except that 'allocator' and 'deallocate' are
// nops.
#define DISALLOW_COPY(Type) \
Type(Type const&) = delete; \
Type& operator=(Type const&) = delete
constexpr std::size_t MaxAlignV = alignof(std::max_align_t);
struct TestException {};
struct AllocController {
int copy_constructed = 0;
int move_constructed = 0;
int alive = 0;
int alloc_count = 0;
int dealloc_count = 0;
int is_equal_count = 0;
std::size_t alive_size;
std::size_t allocated_size;
std::size_t deallocated_size;
std::size_t last_size = 0;
std::size_t last_align = 0;
void * last_pointer = 0;
std::size_t last_alloc_size = 0;
std::size_t last_alloc_align = 0;
void * last_alloc_pointer = nullptr;
std::size_t last_dealloc_size = 0;
std::size_t last_dealloc_align = 0;
void * last_dealloc_pointer = nullptr;
bool throw_on_alloc = false;
int construct_called = 0;
void *last_construct_pointer = nullptr;
TypeID const* last_construct_alloc = nullptr;
TypeID const* last_construct_type = nullptr;
TypeID const* last_construct_args = nullptr;
int destroy_called = 0;
void *last_destroy_pointer = nullptr;
TypeID const* last_destroy_alloc = nullptr;
TypeID const* last_destroy_type = nullptr;
AllocController() = default;
void countAlloc(void* p, size_t s, size_t a) {
++alive;
++alloc_count;
alive_size += s;
allocated_size += s;
last_pointer = last_alloc_pointer = p;
last_size = last_alloc_size = s;
last_align = last_alloc_align = a;
}
void countDealloc(void* p, size_t s, size_t a) {
--alive;
++dealloc_count;
alive_size -= s;
deallocated_size += s;
last_pointer = last_dealloc_pointer = p;
last_size = last_dealloc_size = s;
last_align = last_dealloc_align = a;
}
template <class ...Args, class Alloc, class Tp>
void countConstruct(Alloc const&, Tp *p) {
++construct_called;
last_construct_pointer = p;
last_construct_alloc = &makeTypeID<Alloc>();
last_construct_type = &makeTypeID<Tp>();
last_construct_args = &makeArgumentID<Args...>();
}
template <class Alloc, class Tp>
void countDestroy(Alloc const&, Tp *p) {
++destroy_called;
last_destroy_alloc = &makeTypeID<Alloc>();
last_destroy_type = &makeTypeID<Tp>();
last_destroy_pointer = p;
}
void reset() { std::memset(this, 0, sizeof(*this)); }
void resetConstructDestroy() {
construct_called = 0;
last_construct_pointer = nullptr;
last_construct_alloc = last_construct_args = last_construct_type = nullptr;
destroy_called = 0;
last_destroy_alloc = nullptr;
last_destroy_pointer = nullptr;
}
public:
bool checkAlloc(void* p, size_t s, size_t a) const {
return p == last_alloc_pointer &&
s == last_alloc_size &&
a == last_alloc_align;
}
bool checkAlloc(void* p, size_t s) const {
return p == last_alloc_pointer &&
s == last_alloc_size;
}
bool checkAllocAtLeast(void* p, size_t s, size_t a) const {
return p == last_alloc_pointer &&
s <= last_alloc_size &&
a <= last_alloc_align;
}
bool checkAllocAtLeast(void* p, size_t s) const {
return p == last_alloc_pointer &&
s <= last_alloc_size;
}
bool checkDealloc(void* p, size_t s, size_t a) const {
return p == last_dealloc_pointer &&
s == last_dealloc_size &&
a == last_dealloc_align;
}
bool checkDealloc(void* p, size_t s) const {
return p == last_dealloc_pointer &&
s == last_dealloc_size;
}
bool checkDeallocMatchesAlloc() const {
return last_dealloc_pointer == last_alloc_pointer &&
last_dealloc_size == last_alloc_size &&
last_dealloc_align == last_alloc_align;
}
template <class ...Args, class Alloc, class Tp>
bool checkConstruct(Alloc const&, Tp *p) const {
auto expectAlloc = &makeTypeID<Alloc>();
auto expectTp = &makeTypeID<Tp>();
auto expectArgs = &makeArgumentID<Args...>();
return last_construct_pointer == p &&
COMPARE_TYPEID(last_construct_alloc, expectAlloc) &&
COMPARE_TYPEID(last_construct_type, expectTp) &&
COMPARE_TYPEID(last_construct_args, expectArgs);
}
template <class Alloc, class Tp>
bool checkDestroy(Alloc const&, Tp *p) const {
return last_destroy_pointer == p &&
last_destroy_alloc == &makeTypeID<Alloc>() &&
last_destroy_type == &makeTypeID<Tp>();
}
bool checkDestroyMatchesConstruct() const {
return last_destroy_pointer == last_construct_pointer &&
last_destroy_type == last_construct_type;
}
void countIsEqual() {
++is_equal_count;
}
bool checkIsEqualCalledEq(int n) const {
return is_equal_count == n;
}
private:
DISALLOW_COPY(AllocController);
};
template <class T, size_t ID>
class CountingAllocator
{
public:
typedef T value_type;
typedef T* pointer;
template <class U>
struct rebind { using other = CountingAllocator<U, ID>; };
CountingAllocator() = delete;
explicit CountingAllocator(AllocController& PP) : P(&PP) {}
CountingAllocator(CountingAllocator const& other) : P(other.P) {
P->copy_constructed += 1;
}
CountingAllocator(CountingAllocator&& other) : P(other.P) {
P->move_constructed += 1;
}
template <class U>
CountingAllocator(CountingAllocator<U, ID> const& other) TEST_NOEXCEPT : P(other.P) {
P->copy_constructed += 1;
}
template <class U>
CountingAllocator(CountingAllocator<U, ID>&& other) TEST_NOEXCEPT : P(other.P) {
P->move_constructed += 1;
}
T* allocate(std::size_t n)
{
void* ret = ::operator new(n*sizeof(T));
P->countAlloc(ret, n*sizeof(T), alignof(T));
return static_cast<T*>(ret);
}
void deallocate(T* p, std::size_t n)
{
void* vp = static_cast<void*>(p);
P->countDealloc(vp, n*sizeof(T), alignof(T));
::operator delete(vp);
}
template <class U, class ...Args>
void construct(U *p, Args&&... args) {
::new ((void*)p) U(std::forward<Args>(args)...);
P->countConstruct<Args&&...>(*this, p);
}
template <class U>
void destroy(U* p) {
p->~U();
P->countDestroy(*this, p);
}
AllocController& getController() const { return *P; }
private:
template <class Tp, size_t XID> friend class CountingAllocator;
AllocController *P;
};
template <size_t ID>
class CountingAllocator<void, ID>
{
public:
typedef void* pointer;
typedef const void* const_pointer;
typedef void value_type;
template <class U>
struct rebind { using other = CountingAllocator<U, ID>; };
CountingAllocator() = delete;
explicit CountingAllocator(AllocController& PP) : P(&PP) {}
CountingAllocator(CountingAllocator const& other) : P(other.P) {
P->copy_constructed += 1;
}
CountingAllocator(CountingAllocator&& other) : P(other.P) {
P->move_constructed += 1;
}
template <class U>
CountingAllocator(CountingAllocator<U, ID> const& other) TEST_NOEXCEPT : P(other.P) {
P->copy_constructed += 1;
}
template <class U>
CountingAllocator(CountingAllocator<U, ID>&& other) TEST_NOEXCEPT : P(other.P) {
P->move_constructed += 1;
}
void construct(...) = delete;
void destroy(void*) = delete;
AllocController& getController() const { return *P; }
private:
template <class Tp, size_t> friend class CountingAllocator;
AllocController *P;
};
template <class T, class U, size_t ID>
inline bool operator==(CountingAllocator<T, ID> const& x,
CountingAllocator<U, ID> const& y) {
return &x.getController() == &y.getController();
}
template <class T, class U, size_t ID>
inline bool operator!=(CountingAllocator<T, ID> const& x,
CountingAllocator<U, ID> const& y) {
return !(x == y);
}
template <class T>
class MinAlignedAllocator
{
public:
typedef T value_type;
typedef T* pointer;
MinAlignedAllocator() = delete;
explicit MinAlignedAllocator(AllocController& R) : P(&R) {}
MinAlignedAllocator(MinAlignedAllocator const& other) : P(other.P) {
P->copy_constructed += 1;
}
MinAlignedAllocator(MinAlignedAllocator&& other) : P(other.P) {
P->move_constructed += 1;
}
template <class U>
MinAlignedAllocator(MinAlignedAllocator<U> const& other) TEST_NOEXCEPT : P(other.P) {
P->copy_constructed += 1;
}
template <class U>
MinAlignedAllocator(MinAlignedAllocator<U>&& other) TEST_NOEXCEPT : P(other.P) {
P->move_constructed += 1;
}
T* allocate(std::size_t n) {
char* aligned_ptr = (char*)::operator new(alloc_size(n*sizeof(T)));
assert(is_max_aligned(aligned_ptr));
char* unaligned_ptr = aligned_ptr + alignof(T);
assert(is_min_aligned(unaligned_ptr));
P->countAlloc(unaligned_ptr, n * sizeof(T), alignof(T));
return ((T*)unaligned_ptr);
}
void deallocate(T* p, std::size_t n) {
assert(is_min_aligned(p));
char* aligned_ptr = ((char*)p) - alignof(T);
assert(is_max_aligned(aligned_ptr));
P->countDealloc(p, n*sizeof(T), alignof(T));
return ::operator delete(static_cast<void*>(aligned_ptr));
}
template <class U, class ...Args>
void construct(U *p, Args&&... args) {
auto *c = ::new ((void*)p) U(std::forward<Args>(args)...);
P->countConstruct<Args&&...>(*this, p);
}
template <class U>
void destroy(U* p) {
p->~U();
P->countDestroy(*this, p);
}
AllocController& getController() const { return *P; }
private:
static const std::size_t BlockSize = alignof(std::max_align_t);
static std::size_t alloc_size(std::size_t s) {
std::size_t bytes = (s + BlockSize - 1) & ~(BlockSize - 1);
bytes += BlockSize;
assert(bytes % BlockSize == 0);
return bytes;
}
static bool is_max_aligned(void* p) {
return reinterpret_cast<std::uintptr_t>(p) % BlockSize == 0;
}
static bool is_min_aligned(void* p) {
if (alignof(T) == BlockSize) {
return is_max_aligned(p);
} else {
return reinterpret_cast<std::uintptr_t>(p) % BlockSize == alignof(T);
}
}
template <class Tp> friend class MinAlignedAllocator;
mutable AllocController *P;
};
template <class T, class U>
inline bool operator==(MinAlignedAllocator<T> const& x,
MinAlignedAllocator<U> const& y) {
return &x.getController() == &y.getController();
}
template <class T, class U>
inline bool operator!=(MinAlignedAllocator<T> const& x,
MinAlignedAllocator<U> const& y) {
return !(x == y);
}
template <class T>
class NullAllocator
{
public:
typedef T value_type;
typedef T* pointer;
NullAllocator() = delete;
explicit NullAllocator(AllocController& PP) : P(&PP) {}
NullAllocator(NullAllocator const& other) : P(other.P) {
P->copy_constructed += 1;
}
NullAllocator(NullAllocator&& other) : P(other.P) {
P->move_constructed += 1;
}
template <class U>
NullAllocator(NullAllocator<U> const& other) TEST_NOEXCEPT : P(other.P) {
P->copy_constructed += 1;
}
template <class U>
NullAllocator(NullAllocator<U>&& other) TEST_NOEXCEPT : P(other.P) {
P->move_constructed += 1;
}
T* allocate(std::size_t n)
{
P->countAlloc(nullptr, n*sizeof(T), alignof(T));
return nullptr;
}
void deallocate(T* p, std::size_t n)
{
void* vp = static_cast<void*>(p);
P->countDealloc(vp, n*sizeof(T), alignof(T));
}
AllocController& getController() const { return *P; }
private:
template <class Tp> friend class NullAllocator;
AllocController *P;
};
template <class T, class U>
inline bool operator==(NullAllocator<T> const& x,
NullAllocator<U> const& y) {
return &x.getController() == &y.getController();
}
template <class T, class U>
inline bool operator!=(NullAllocator<T> const& x,
NullAllocator<U> const& y) {
return !(x == y);
}
#endif /* SUPPORT_CONTROLLED_ALLOCATORS_H */

libcxx/trunk/test/support/controlled_allocators.hpp

//===----------------------------------------------------------------------===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
#ifndef SUPPORT_CONTROLLED_ALLOCATORS_HPP
#define SUPPORT_CONTROLLED_ALLOCATORS_HPP
#include <memory>
#include <type_traits>
#include <cstddef>
#include <cstdlib>
#include <cstring>
#include <cstdint>
#include <cassert>
#include "test_macros.h"
#include "type_id.h"
#if TEST_STD_VER < 11
#error This header requires C++11 or greater
#endif
struct AllocController;
// 'AllocController' is a concrete type that instruments and controls the
// behavior of test allocators.
template <class T, size_t ID = 0>
class CountingAllocator;
// 'CountingAllocator' is an basic implementation of the 'Allocator'
// requirements that use the 'AllocController' interface.
template <class T>
class MinAlignAllocator;
// 'MinAlignAllocator' is an instrumented test type which implements the
// 'Allocator' requirements. 'MinAlignAllocator' ensures that it *never*
// returns a pointer to over-aligned storage. For example
// 'MinAlignPointer<char>{}.allocate(...)' will never a 2-byte aligned
// pointer.
template <class T>
class NullAllocator;
// 'NullAllocator' is an instrumented test type which implements the
// 'Allocator' requirements except that 'allocator' and 'deallocate' are
// nops.
#define DISALLOW_COPY(Type) \
Type(Type const&) = delete; \
Type& operator=(Type const&) = delete
constexpr std::size_t MaxAlignV = alignof(std::max_align_t);
struct TestException {};
struct AllocController {
int copy_constructed = 0;
int move_constructed = 0;
int alive = 0;
int alloc_count = 0;
int dealloc_count = 0;
int is_equal_count = 0;
std::size_t alive_size;
std::size_t allocated_size;
std::size_t deallocated_size;
std::size_t last_size = 0;
std::size_t last_align = 0;
void * last_pointer = 0;
std::size_t last_alloc_size = 0;
std::size_t last_alloc_align = 0;
void * last_alloc_pointer = nullptr;
std::size_t last_dealloc_size = 0;
std::size_t last_dealloc_align = 0;
void * last_dealloc_pointer = nullptr;
bool throw_on_alloc = false;
int construct_called = 0;
void *last_construct_pointer = nullptr;
TypeID const* last_construct_alloc = nullptr;
TypeID const* last_construct_type = nullptr;
TypeID const* last_construct_args = nullptr;
int destroy_called = 0;
void *last_destroy_pointer = nullptr;
TypeID const* last_destroy_alloc = nullptr;
TypeID const* last_destroy_type = nullptr;
AllocController() = default;
void countAlloc(void* p, size_t s, size_t a) {
++alive;
++alloc_count;
alive_size += s;
allocated_size += s;
last_pointer = last_alloc_pointer = p;
last_size = last_alloc_size = s;
last_align = last_alloc_align = a;
}
void countDealloc(void* p, size_t s, size_t a) {
--alive;
++dealloc_count;
alive_size -= s;
deallocated_size += s;
last_pointer = last_dealloc_pointer = p;
last_size = last_dealloc_size = s;
last_align = last_dealloc_align = a;
}
template <class ...Args, class Alloc, class Tp>
void countConstruct(Alloc const&, Tp *p) {
++construct_called;
last_construct_pointer = p;
last_construct_alloc = &makeTypeID<Alloc>();
last_construct_type = &makeTypeID<Tp>();
last_construct_args = &makeArgumentID<Args...>();
}
template <class Alloc, class Tp>
void countDestroy(Alloc const&, Tp *p) {
++destroy_called;
last_destroy_alloc = &makeTypeID<Alloc>();
last_destroy_type = &makeTypeID<Tp>();
last_destroy_pointer = p;
}
void reset() { std::memset(this, 0, sizeof(*this)); }
void resetConstructDestroy() {
construct_called = 0;
last_construct_pointer = nullptr;
last_construct_alloc = last_construct_args = last_construct_type = nullptr;
destroy_called = 0;
last_destroy_alloc = nullptr;
last_destroy_pointer = nullptr;
}
public:
bool checkAlloc(void* p, size_t s, size_t a) const {
return p == last_alloc_pointer &&
s == last_alloc_size &&
a == last_alloc_align;
}
bool checkAlloc(void* p, size_t s) const {
return p == last_alloc_pointer &&
s == last_alloc_size;
}
bool checkAllocAtLeast(void* p, size_t s, size_t a) const {
return p == last_alloc_pointer &&
s <= last_alloc_size &&
a <= last_alloc_align;
}
bool checkAllocAtLeast(void* p, size_t s) const {
return p == last_alloc_pointer &&
s <= last_alloc_size;
}
bool checkDealloc(void* p, size_t s, size_t a) const {
return p == last_dealloc_pointer &&
s == last_dealloc_size &&
a == last_dealloc_align;
}
bool checkDealloc(void* p, size_t s) const {
return p == last_dealloc_pointer &&
s == last_dealloc_size;
}
bool checkDeallocMatchesAlloc() const {
return last_dealloc_pointer == last_alloc_pointer &&
last_dealloc_size == last_alloc_size &&
last_dealloc_align == last_alloc_align;
}
template <class ...Args, class Alloc, class Tp>
bool checkConstruct(Alloc const&, Tp *p) const {
auto expectAlloc = &makeTypeID<Alloc>();
auto expectTp = &makeTypeID<Tp>();
auto expectArgs = &makeArgumentID<Args...>();
return last_construct_pointer == p &&
COMPARE_TYPEID(last_construct_alloc, expectAlloc) &&
COMPARE_TYPEID(last_construct_type, expectTp) &&
COMPARE_TYPEID(last_construct_args, expectArgs);
}
template <class Alloc, class Tp>
bool checkDestroy(Alloc const&, Tp *p) const {
return last_destroy_pointer == p &&
last_destroy_alloc == &makeTypeID<Alloc>() &&
last_destroy_type == &makeTypeID<Tp>();
}
bool checkDestroyMatchesConstruct() const {
return last_destroy_pointer == last_construct_pointer &&
last_destroy_type == last_construct_type;
}
void countIsEqual() {
++is_equal_count;
}
bool checkIsEqualCalledEq(int n) const {
return is_equal_count == n;
}
private:
DISALLOW_COPY(AllocController);
};
template <class T, size_t ID>
class CountingAllocator
{
public:
typedef T value_type;
typedef T* pointer;
template <class U>
struct rebind { using other = CountingAllocator<U, ID>; };
CountingAllocator() = delete;
explicit CountingAllocator(AllocController& PP) : P(&PP) {}
CountingAllocator(CountingAllocator const& other) : P(other.P) {
P->copy_constructed += 1;
}
CountingAllocator(CountingAllocator&& other) : P(other.P) {
P->move_constructed += 1;
}
template <class U>
CountingAllocator(CountingAllocator<U, ID> const& other) TEST_NOEXCEPT : P(other.P) {
P->copy_constructed += 1;
}
template <class U>
CountingAllocator(CountingAllocator<U, ID>&& other) TEST_NOEXCEPT : P(other.P) {
P->move_constructed += 1;
}
T* allocate(std::size_t n)
{
void* ret = ::operator new(n*sizeof(T));
P->countAlloc(ret, n*sizeof(T), alignof(T));
return static_cast<T*>(ret);
}
void deallocate(T* p, std::size_t n)
{
void* vp = static_cast<void*>(p);
P->countDealloc(vp, n*sizeof(T), alignof(T));
::operator delete(vp);
}
template <class U, class ...Args>
void construct(U *p, Args&&... args) {
::new ((void*)p) U(std::forward<Args>(args)...);
P->countConstruct<Args&&...>(*this, p);
}
template <class U>
void destroy(U* p) {
p->~U();
P->countDestroy(*this, p);
}
AllocController& getController() const { return *P; }
private:
template <class Tp, size_t XID> friend class CountingAllocator;
AllocController *P;
};
template <size_t ID>
class CountingAllocator<void, ID>
{
public:
typedef void* pointer;
typedef const void* const_pointer;
typedef void value_type;
template <class U>
struct rebind { using other = CountingAllocator<U, ID>; };
CountingAllocator() = delete;
explicit CountingAllocator(AllocController& PP) : P(&PP) {}
CountingAllocator(CountingAllocator const& other) : P(other.P) {
P->copy_constructed += 1;
}
CountingAllocator(CountingAllocator&& other) : P(other.P) {
P->move_constructed += 1;
}
template <class U>
CountingAllocator(CountingAllocator<U, ID> const& other) TEST_NOEXCEPT : P(other.P) {
P->copy_constructed += 1;
}
template <class U>
CountingAllocator(CountingAllocator<U, ID>&& other) TEST_NOEXCEPT : P(other.P) {
P->move_constructed += 1;
}
void construct(...) = delete;
void destroy(void*) = delete;
AllocController& getController() const { return *P; }
private:
template <class Tp, size_t> friend class CountingAllocator;
AllocController *P;
};
template <class T, class U, size_t ID>
inline bool operator==(CountingAllocator<T, ID> const& x,
CountingAllocator<U, ID> const& y) {
return &x.getController() == &y.getController();
}
template <class T, class U, size_t ID>
inline bool operator!=(CountingAllocator<T, ID> const& x,
CountingAllocator<U, ID> const& y) {
return !(x == y);
}
template <class T>
class MinAlignedAllocator
{
public:
typedef T value_type;
typedef T* pointer;
MinAlignedAllocator() = delete;
explicit MinAlignedAllocator(AllocController& R) : P(&R) {}
MinAlignedAllocator(MinAlignedAllocator const& other) : P(other.P) {
P->copy_constructed += 1;
}
MinAlignedAllocator(MinAlignedAllocator&& other) : P(other.P) {
P->move_constructed += 1;
}
template <class U>
MinAlignedAllocator(MinAlignedAllocator<U> const& other) TEST_NOEXCEPT : P(other.P) {
P->copy_constructed += 1;
}
template <class U>
MinAlignedAllocator(MinAlignedAllocator<U>&& other) TEST_NOEXCEPT : P(other.P) {
P->move_constructed += 1;
}
T* allocate(std::size_t n) {
char* aligned_ptr = (char*)::operator new(alloc_size(n*sizeof(T)));
assert(is_max_aligned(aligned_ptr));
char* unaligned_ptr = aligned_ptr + alignof(T);
assert(is_min_aligned(unaligned_ptr));
P->countAlloc(unaligned_ptr, n * sizeof(T), alignof(T));
return ((T*)unaligned_ptr);
}
void deallocate(T* p, std::size_t n) {
assert(is_min_aligned(p));
char* aligned_ptr = ((char*)p) - alignof(T);
assert(is_max_aligned(aligned_ptr));
P->countDealloc(p, n*sizeof(T), alignof(T));
return ::operator delete(static_cast<void*>(aligned_ptr));
}
template <class U, class ...Args>
void construct(U *p, Args&&... args) {
auto *c = ::new ((void*)p) U(std::forward<Args>(args)...);
P->countConstruct<Args&&...>(*this, p);
}
template <class U>
void destroy(U* p) {
p->~U();
P->countDestroy(*this, p);
}
AllocController& getController() const { return *P; }
private:
static const std::size_t BlockSize = alignof(std::max_align_t);
static std::size_t alloc_size(std::size_t s) {
std::size_t bytes = (s + BlockSize - 1) & ~(BlockSize - 1);
bytes += BlockSize;
assert(bytes % BlockSize == 0);
return bytes;
}
static bool is_max_aligned(void* p) {
return reinterpret_cast<std::uintptr_t>(p) % BlockSize == 0;
}
static bool is_min_aligned(void* p) {
if (alignof(T) == BlockSize) {
return is_max_aligned(p);
} else {
return reinterpret_cast<std::uintptr_t>(p) % BlockSize == alignof(T);
}
}
template <class Tp> friend class MinAlignedAllocator;
mutable AllocController *P;
};
template <class T, class U>
inline bool operator==(MinAlignedAllocator<T> const& x,
MinAlignedAllocator<U> const& y) {
return &x.getController() == &y.getController();
}
template <class T, class U>
inline bool operator!=(MinAlignedAllocator<T> const& x,
MinAlignedAllocator<U> const& y) {
return !(x == y);
}
template <class T>
class NullAllocator
{
public:
typedef T value_type;
typedef T* pointer;
NullAllocator() = delete;
explicit NullAllocator(AllocController& PP) : P(&PP) {}
NullAllocator(NullAllocator const& other) : P(other.P) {
P->copy_constructed += 1;
}
NullAllocator(NullAllocator&& other) : P(other.P) {
P->move_constructed += 1;
}
template <class U>
NullAllocator(NullAllocator<U> const& other) TEST_NOEXCEPT : P(other.P) {
P->copy_constructed += 1;
}
template <class U>
NullAllocator(NullAllocator<U>&& other) TEST_NOEXCEPT : P(other.P) {
P->move_constructed += 1;
}
T* allocate(std::size_t n)
{
P->countAlloc(nullptr, n*sizeof(T), alignof(T));
return nullptr;
}
void deallocate(T* p, std::size_t n)
{
void* vp = static_cast<void*>(p);
P->countDealloc(vp, n*sizeof(T), alignof(T));
}
AllocController& getController() const { return *P; }
private:
template <class Tp> friend class NullAllocator;
AllocController *P;
};
template <class T, class U>
inline bool operator==(NullAllocator<T> const& x,
NullAllocator<U> const& y) {
return &x.getController() == &y.getController();
}
template <class T, class U>
inline bool operator!=(NullAllocator<T> const& x,
NullAllocator<U> const& y) {
return !(x == y);
}
#endif /* SUPPORT_CONTROLLED_ALLOCATORS_HPP */

libcxx/trunk/test/support/count_new.h

//===----------------------------------------------------------------------===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
#ifndef COUNT_NEW_H
#define COUNT_NEW_H
# include <cstdlib>
# include <cassert>
# include <new>
#include "test_macros.h"
#if defined(TEST_HAS_SANITIZERS)
#define DISABLE_NEW_COUNT
#endif
namespace detail
{
TEST_NORETURN
inline void throw_bad_alloc_helper() {
#ifndef TEST_HAS_NO_EXCEPTIONS
throw std::bad_alloc();
#else
std::abort();
#endif
}
}
class MemCounter
{
public:
// Make MemCounter super hard to accidentally construct or copy.
class MemCounterCtorArg_ {};
explicit MemCounter(MemCounterCtorArg_) { reset(); }
private:
MemCounter(MemCounter const &);
MemCounter & operator=(MemCounter const &);
public:
// All checks return true when disable_checking is enabled.
static const bool disable_checking;
// Disallow any allocations from occurring. Useful for testing that
// code doesn't perform any allocations.
bool disable_allocations;
// number of allocations to throw after. Default (unsigned)-1. If
// throw_after has the default value it will never be decremented.
static const unsigned never_throw_value = static_cast<unsigned>(-1);
unsigned throw_after;
int outstanding_new;
int new_called;
int delete_called;
int aligned_new_called;
int aligned_delete_called;
std::size_t last_new_size;
std::size_t last_new_align;
std::size_t last_delete_align;
int outstanding_array_new;
int new_array_called;
int delete_array_called;
int aligned_new_array_called;
int aligned_delete_array_called;
std::size_t last_new_array_size;
std::size_t last_new_array_align;
std::size_t last_delete_array_align;
public:
void newCalled(std::size_t s)
{
assert(disable_allocations == false);
assert(s);
if (throw_after == 0) {
throw_after = never_throw_value;
detail::throw_bad_alloc_helper();
} else if (throw_after != never_throw_value) {
--throw_after;
}
++new_called;
++outstanding_new;
last_new_size = s;
}
void alignedNewCalled(std::size_t s, std::size_t a) {
newCalled(s);
++aligned_new_called;
last_new_align = a;
}
void deleteCalled(void * p)
{
assert(p);
--outstanding_new;
++delete_called;
}
void alignedDeleteCalled(void *p, std::size_t a) {
deleteCalled(p);
++aligned_delete_called;
last_delete_align = a;
}
void newArrayCalled(std::size_t s)
{
assert(disable_allocations == false);
assert(s);
if (throw_after == 0) {
throw_after = never_throw_value;
detail::throw_bad_alloc_helper();
} else {
// don't decrement throw_after here. newCalled will end up doing that.
}
++outstanding_array_new;
++new_array_called;
last_new_array_size = s;
}
void alignedNewArrayCalled(std::size_t s, std::size_t a) {
newArrayCalled(s);
++aligned_new_array_called;
last_new_array_align = a;
}
void deleteArrayCalled(void * p)
{
assert(p);
--outstanding_array_new;
++delete_array_called;
}
void alignedDeleteArrayCalled(void * p, std::size_t a) {
deleteArrayCalled(p);
++aligned_delete_array_called;
last_delete_array_align = a;
}
void disableAllocations()
{
disable_allocations = true;
}
void enableAllocations()
{
disable_allocations = false;
}
void reset()
{
disable_allocations = false;
throw_after = never_throw_value;
outstanding_new = 0;
new_called = 0;
delete_called = 0;
aligned_new_called = 0;
aligned_delete_called = 0;
last_new_size = 0;
last_new_align = 0;
outstanding_array_new = 0;
new_array_called = 0;
delete_array_called = 0;
aligned_new_array_called = 0;
aligned_delete_array_called = 0;
last_new_array_size = 0;
last_new_array_align = 0;
}
public:
bool checkOutstandingNewEq(int n) const
{
return disable_checking || n == outstanding_new;
}
bool checkOutstandingNewNotEq(int n) const
{
return disable_checking || n != outstanding_new;
}
bool checkNewCalledEq(int n) const
{
return disable_checking || n == new_called;
}
bool checkNewCalledNotEq(int n) const
{
return disable_checking || n != new_called;
}
bool checkNewCalledGreaterThan(int n) const
{
return disable_checking || new_called > n;
}
bool checkDeleteCalledEq(int n) const
{
return disable_checking || n == delete_called;
}
bool checkDeleteCalledNotEq(int n) const
{
return disable_checking || n != delete_called;
}
bool checkAlignedNewCalledEq(int n) const
{
return disable_checking || n == aligned_new_called;
}
bool checkAlignedNewCalledNotEq(int n) const
{
return disable_checking || n != aligned_new_called;
}
bool checkAlignedNewCalledGreaterThan(int n) const
{
return disable_checking || aligned_new_called > n;
}
bool checkAlignedDeleteCalledEq(int n) const
{
return disable_checking || n == aligned_delete_called;
}
bool checkAlignedDeleteCalledNotEq(int n) const
{
return disable_checking || n != aligned_delete_called;
}
bool checkLastNewSizeEq(std::size_t n) const
{
return disable_checking || n == last_new_size;
}
bool checkLastNewSizeNotEq(std::size_t n) const
{
return disable_checking || n != last_new_size;
}
bool checkLastNewAlignEq(std::size_t n) const
{
return disable_checking || n == last_new_align;
}
bool checkLastNewAlignNotEq(std::size_t n) const
{
return disable_checking || n != last_new_align;
}
bool checkLastDeleteAlignEq(std::size_t n) const
{
return disable_checking || n == last_delete_align;
}
bool checkLastDeleteAlignNotEq(std::size_t n) const
{
return disable_checking || n != last_delete_align;
}
bool checkOutstandingArrayNewEq(int n) const
{
return disable_checking || n == outstanding_array_new;
}
bool checkOutstandingArrayNewNotEq(int n) const
{
return disable_checking || n != outstanding_array_new;
}
bool checkNewArrayCalledEq(int n) const
{
return disable_checking || n == new_array_called;
}
bool checkNewArrayCalledNotEq(int n) const
{
return disable_checking || n != new_array_called;
}
bool checkDeleteArrayCalledEq(int n) const
{
return disable_checking || n == delete_array_called;
}
bool checkDeleteArrayCalledNotEq(int n) const
{
return disable_checking || n != delete_array_called;
}
bool checkAlignedNewArrayCalledEq(int n) const
{
return disable_checking || n == aligned_new_array_called;
}
bool checkAlignedNewArrayCalledNotEq(int n) const
{
return disable_checking || n != aligned_new_array_called;
}
bool checkAlignedNewArrayCalledGreaterThan(int n) const
{
return disable_checking || aligned_new_array_called > n;
}
bool checkAlignedDeleteArrayCalledEq(int n) const
{
return disable_checking || n == aligned_delete_array_called;
}
bool checkAlignedDeleteArrayCalledNotEq(int n) const
{
return disable_checking || n != aligned_delete_array_called;
}
bool checkLastNewArraySizeEq(std::size_t n) const
{
return disable_checking || n == last_new_array_size;
}
bool checkLastNewArraySizeNotEq(std::size_t n) const
{
return disable_checking || n != last_new_array_size;
}
bool checkLastNewArrayAlignEq(std::size_t n) const
{
return disable_checking || n == last_new_array_align;
}
bool checkLastNewArrayAlignNotEq(std::size_t n) const
{
return disable_checking || n != last_new_array_align;
}
};
#ifdef DISABLE_NEW_COUNT
const bool MemCounter::disable_checking = true;
#else
const bool MemCounter::disable_checking = false;
#endif
inline MemCounter* getGlobalMemCounter() {
static MemCounter counter((MemCounter::MemCounterCtorArg_()));
return &counter;
}
MemCounter &globalMemCounter = *getGlobalMemCounter();
#ifndef DISABLE_NEW_COUNT
void* operator new(std::size_t s) TEST_THROW_SPEC(std::bad_alloc)
{
getGlobalMemCounter()->newCalled(s);
void* ret = std::malloc(s);
if (ret == nullptr)
detail::throw_bad_alloc_helper();
return ret;
}
void operator delete(void* p) TEST_NOEXCEPT
{
getGlobalMemCounter()->deleteCalled(p);
std::free(p);
}
void* operator new[](std::size_t s) TEST_THROW_SPEC(std::bad_alloc)
{
getGlobalMemCounter()->newArrayCalled(s);
return operator new(s);
}
void operator delete[](void* p) TEST_NOEXCEPT
{
getGlobalMemCounter()->deleteArrayCalled(p);
operator delete(p);
}
#ifndef TEST_HAS_NO_ALIGNED_ALLOCATION
#if defined(_LIBCPP_MSVCRT_LIKE) || \
(!defined(_LIBCPP_VERSION) && defined(_WIN32))
#define USE_ALIGNED_ALLOC
#endif
void* operator new(std::size_t s, std::align_val_t av) TEST_THROW_SPEC(std::bad_alloc) {
const std::size_t a = static_cast<std::size_t>(av);
getGlobalMemCounter()->alignedNewCalled(s, a);
void *ret;
#ifdef USE_ALIGNED_ALLOC
ret = _aligned_malloc(s, a);
#else
posix_memalign(&ret, a, s);
#endif
if (ret == nullptr)
detail::throw_bad_alloc_helper();
return ret;
}
void operator delete(void *p, std::align_val_t av) TEST_NOEXCEPT {
const std::size_t a = static_cast<std::size_t>(av);
getGlobalMemCounter()->alignedDeleteCalled(p, a);
if (p) {
#ifdef USE_ALIGNED_ALLOC
::_aligned_free(p);
#else
::free(p);
#endif
}
}
void* operator new[](std::size_t s, std::align_val_t av) TEST_THROW_SPEC(std::bad_alloc) {
const std::size_t a = static_cast<std::size_t>(av);
getGlobalMemCounter()->alignedNewArrayCalled(s, a);
return operator new(s, av);
}
void operator delete[](void *p, std::align_val_t av) TEST_NOEXCEPT {
const std::size_t a = static_cast<std::size_t>(av);
getGlobalMemCounter()->alignedDeleteArrayCalled(p, a);
return operator delete(p, av);
}
#endif // TEST_HAS_NO_ALIGNED_ALLOCATION
#endif // DISABLE_NEW_COUNT
struct DisableAllocationGuard {
explicit DisableAllocationGuard(bool disable = true) : m_disabled(disable)
{
// Don't re-disable if already disabled.
if (globalMemCounter.disable_allocations == true) m_disabled = false;
if (m_disabled) globalMemCounter.disableAllocations();
}
void release() {
if (m_disabled) globalMemCounter.enableAllocations();
m_disabled = false;
}
~DisableAllocationGuard() {
release();
}
private:
bool m_disabled;
DisableAllocationGuard(DisableAllocationGuard const&);
DisableAllocationGuard& operator=(DisableAllocationGuard const&);
};
struct RequireAllocationGuard {
explicit RequireAllocationGuard(std::size_t RequireAtLeast = 1)
: m_req_alloc(RequireAtLeast),
m_new_count_on_init(globalMemCounter.new_called),
m_outstanding_new_on_init(globalMemCounter.outstanding_new),
m_exactly(false)
{
}
void requireAtLeast(std::size_t N) { m_req_alloc = N; m_exactly = false; }
void requireExactly(std::size_t N) { m_req_alloc = N; m_exactly = true; }
~RequireAllocationGuard() {
assert(globalMemCounter.checkOutstandingNewEq(static_cast<int>(m_outstanding_new_on_init)));
std::size_t Expect = m_new_count_on_init + m_req_alloc;
assert(globalMemCounter.checkNewCalledEq(static_cast<int>(Expect)) ||
(!m_exactly && globalMemCounter.checkNewCalledGreaterThan(static_cast<int>(Expect))));
}
private:
std::size_t m_req_alloc;
const std::size_t m_new_count_on_init;
const std::size_t m_outstanding_new_on_init;
bool m_exactly;
RequireAllocationGuard(RequireAllocationGuard const&);
RequireAllocationGuard& operator=(RequireAllocationGuard const&);
};
#endif /* COUNT_NEW_H */

libcxx/trunk/test/support/count_new.hpp

//===----------------------------------------------------------------------===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
#ifndef COUNT_NEW_HPP
#define COUNT_NEW_HPP
# include <cstdlib>
# include <cassert>
# include <new>
#include "test_macros.h"
#if defined(TEST_HAS_SANITIZERS)
#define DISABLE_NEW_COUNT
#endif
namespace detail
{
TEST_NORETURN
inline void throw_bad_alloc_helper() {
#ifndef TEST_HAS_NO_EXCEPTIONS
throw std::bad_alloc();
#else
std::abort();
#endif
}
}
class MemCounter
{
public:
// Make MemCounter super hard to accidentally construct or copy.
class MemCounterCtorArg_ {};
explicit MemCounter(MemCounterCtorArg_) { reset(); }
private:
MemCounter(MemCounter const &);
MemCounter & operator=(MemCounter const &);
public:
// All checks return true when disable_checking is enabled.
static const bool disable_checking;
// Disallow any allocations from occurring. Useful for testing that
// code doesn't perform any allocations.
bool disable_allocations;
// number of allocations to throw after. Default (unsigned)-1. If
// throw_after has the default value it will never be decremented.
static const unsigned never_throw_value = static_cast<unsigned>(-1);
unsigned throw_after;
int outstanding_new;
int new_called;
int delete_called;
int aligned_new_called;
int aligned_delete_called;
std::size_t last_new_size;
std::size_t last_new_align;
std::size_t last_delete_align;
int outstanding_array_new;
int new_array_called;
int delete_array_called;
int aligned_new_array_called;
int aligned_delete_array_called;
std::size_t last_new_array_size;
std::size_t last_new_array_align;
std::size_t last_delete_array_align;
public:
void newCalled(std::size_t s)
{
assert(disable_allocations == false);
assert(s);
if (throw_after == 0) {
throw_after = never_throw_value;
detail::throw_bad_alloc_helper();
} else if (throw_after != never_throw_value) {
--throw_after;
}
++new_called;
++outstanding_new;
last_new_size = s;
}
void alignedNewCalled(std::size_t s, std::size_t a) {
newCalled(s);
++aligned_new_called;
last_new_align = a;
}
void deleteCalled(void * p)
{
assert(p);
--outstanding_new;
++delete_called;
}
void alignedDeleteCalled(void *p, std::size_t a) {
deleteCalled(p);
++aligned_delete_called;
last_delete_align = a;
}
void newArrayCalled(std::size_t s)
{
assert(disable_allocations == false);
assert(s);
if (throw_after == 0) {
throw_after = never_throw_value;
detail::throw_bad_alloc_helper();
} else {
// don't decrement throw_after here. newCalled will end up doing that.
}
++outstanding_array_new;
++new_array_called;
last_new_array_size = s;
}
void alignedNewArrayCalled(std::size_t s, std::size_t a) {
newArrayCalled(s);
++aligned_new_array_called;
last_new_array_align = a;
}
void deleteArrayCalled(void * p)
{
assert(p);
--outstanding_array_new;
++delete_array_called;
}
void alignedDeleteArrayCalled(void * p, std::size_t a) {
deleteArrayCalled(p);
++aligned_delete_array_called;
last_delete_array_align = a;
}
void disableAllocations()
{
disable_allocations = true;
}
void enableAllocations()
{
disable_allocations = false;
}
void reset()
{
disable_allocations = false;
throw_after = never_throw_value;
outstanding_new = 0;
new_called = 0;
delete_called = 0;
aligned_new_called = 0;
aligned_delete_called = 0;
last_new_size = 0;
last_new_align = 0;
outstanding_array_new = 0;
new_array_called = 0;
delete_array_called = 0;
aligned_new_array_called = 0;
aligned_delete_array_called = 0;
last_new_array_size = 0;
last_new_array_align = 0;
}
public:
bool checkOutstandingNewEq(int n) const
{
return disable_checking || n == outstanding_new;
}
bool checkOutstandingNewNotEq(int n) const
{
return disable_checking || n != outstanding_new;
}
bool checkNewCalledEq(int n) const
{
return disable_checking || n == new_called;
}
bool checkNewCalledNotEq(int n) const
{
return disable_checking || n != new_called;
}
bool checkNewCalledGreaterThan(int n) const
{
return disable_checking || new_called > n;
}
bool checkDeleteCalledEq(int n) const
{
return disable_checking || n == delete_called;
}
bool checkDeleteCalledNotEq(int n) const
{
return disable_checking || n != delete_called;
}
bool checkAlignedNewCalledEq(int n) const
{
return disable_checking || n == aligned_new_called;
}
bool checkAlignedNewCalledNotEq(int n) const
{
return disable_checking || n != aligned_new_called;
}
bool checkAlignedNewCalledGreaterThan(int n) const
{
return disable_checking || aligned_new_called > n;
}
bool checkAlignedDeleteCalledEq(int n) const
{
return disable_checking || n == aligned_delete_called;
}
bool checkAlignedDeleteCalledNotEq(int n) const
{
return disable_checking || n != aligned_delete_called;
}
bool checkLastNewSizeEq(std::size_t n) const
{
return disable_checking || n == last_new_size;
}
bool checkLastNewSizeNotEq(std::size_t n) const
{
return disable_checking || n != last_new_size;
}
bool checkLastNewAlignEq(std::size_t n) const
{
return disable_checking || n == last_new_align;
}
bool checkLastNewAlignNotEq(std::size_t n) const
{
return disable_checking || n != last_new_align;
}
bool checkLastDeleteAlignEq(std::size_t n) const
{
return disable_checking || n == last_delete_align;
}
bool checkLastDeleteAlignNotEq(std::size_t n) const
{
return disable_checking || n != last_delete_align;
}
bool checkOutstandingArrayNewEq(int n) const
{
return disable_checking || n == outstanding_array_new;
}
bool checkOutstandingArrayNewNotEq(int n) const
{
return disable_checking || n != outstanding_array_new;
}
bool checkNewArrayCalledEq(int n) const
{
return disable_checking || n == new_array_called;
}
bool checkNewArrayCalledNotEq(int n) const
{
return disable_checking || n != new_array_called;
}
bool checkDeleteArrayCalledEq(int n) const
{
return disable_checking || n == delete_array_called;
}
bool checkDeleteArrayCalledNotEq(int n) const
{
return disable_checking || n != delete_array_called;
}
bool checkAlignedNewArrayCalledEq(int n) const
{
return disable_checking || n == aligned_new_array_called;
}
bool checkAlignedNewArrayCalledNotEq(int n) const
{
return disable_checking || n != aligned_new_array_called;
}
bool checkAlignedNewArrayCalledGreaterThan(int n) const
{
return disable_checking || aligned_new_array_called > n;
}
bool checkAlignedDeleteArrayCalledEq(int n) const
{
return disable_checking || n == aligned_delete_array_called;
}
bool checkAlignedDeleteArrayCalledNotEq(int n) const
{
return disable_checking || n != aligned_delete_array_called;
}
bool checkLastNewArraySizeEq(std::size_t n) const
{
return disable_checking || n == last_new_array_size;
}
bool checkLastNewArraySizeNotEq(std::size_t n) const
{
return disable_checking || n != last_new_array_size;
}
bool checkLastNewArrayAlignEq(std::size_t n) const
{
return disable_checking || n == last_new_array_align;
}
bool checkLastNewArrayAlignNotEq(std::size_t n) const
{
return disable_checking || n != last_new_array_align;
}
};
#ifdef DISABLE_NEW_COUNT
const bool MemCounter::disable_checking = true;
#else
const bool MemCounter::disable_checking = false;
#endif
inline MemCounter* getGlobalMemCounter() {
static MemCounter counter((MemCounter::MemCounterCtorArg_()));
return &counter;
}
MemCounter &globalMemCounter = *getGlobalMemCounter();
#ifndef DISABLE_NEW_COUNT
void* operator new(std::size_t s) TEST_THROW_SPEC(std::bad_alloc)
{
getGlobalMemCounter()->newCalled(s);
void* ret = std::malloc(s);
if (ret == nullptr)
detail::throw_bad_alloc_helper();
return ret;
}
void operator delete(void* p) TEST_NOEXCEPT
{
getGlobalMemCounter()->deleteCalled(p);
std::free(p);
}
void* operator new[](std::size_t s) TEST_THROW_SPEC(std::bad_alloc)
{
getGlobalMemCounter()->newArrayCalled(s);
return operator new(s);
}
void operator delete[](void* p) TEST_NOEXCEPT
{
getGlobalMemCounter()->deleteArrayCalled(p);
operator delete(p);
}
#ifndef TEST_HAS_NO_ALIGNED_ALLOCATION
#if defined(_LIBCPP_MSVCRT_LIKE) || \
(!defined(_LIBCPP_VERSION) && defined(_WIN32))
#define USE_ALIGNED_ALLOC
#endif
void* operator new(std::size_t s, std::align_val_t av) TEST_THROW_SPEC(std::bad_alloc) {
const std::size_t a = static_cast<std::size_t>(av);
getGlobalMemCounter()->alignedNewCalled(s, a);
void *ret;
#ifdef USE_ALIGNED_ALLOC
ret = _aligned_malloc(s, a);
#else
posix_memalign(&ret, a, s);
#endif
if (ret == nullptr)
detail::throw_bad_alloc_helper();
return ret;
}
void operator delete(void *p, std::align_val_t av) TEST_NOEXCEPT {
const std::size_t a = static_cast<std::size_t>(av);
getGlobalMemCounter()->alignedDeleteCalled(p, a);
if (p) {
#ifdef USE_ALIGNED_ALLOC
::_aligned_free(p);
#else
::free(p);
#endif
}
}
void* operator new[](std::size_t s, std::align_val_t av) TEST_THROW_SPEC(std::bad_alloc) {
const std::size_t a = static_cast<std::size_t>(av);
getGlobalMemCounter()->alignedNewArrayCalled(s, a);
return operator new(s, av);
}
void operator delete[](void *p, std::align_val_t av) TEST_NOEXCEPT {
const std::size_t a = static_cast<std::size_t>(av);
getGlobalMemCounter()->alignedDeleteArrayCalled(p, a);
return operator delete(p, av);
}
#endif // TEST_HAS_NO_ALIGNED_ALLOCATION
#endif // DISABLE_NEW_COUNT
struct DisableAllocationGuard {
explicit DisableAllocationGuard(bool disable = true) : m_disabled(disable)
{
// Don't re-disable if already disabled.
if (globalMemCounter.disable_allocations == true) m_disabled = false;
if (m_disabled) globalMemCounter.disableAllocations();
}
void release() {
if (m_disabled) globalMemCounter.enableAllocations();
m_disabled = false;
}
~DisableAllocationGuard() {
release();
}
private:
bool m_disabled;
DisableAllocationGuard(DisableAllocationGuard const&);
DisableAllocationGuard& operator=(DisableAllocationGuard const&);
};
struct RequireAllocationGuard {
explicit RequireAllocationGuard(std::size_t RequireAtLeast = 1)
: m_req_alloc(RequireAtLeast),
m_new_count_on_init(globalMemCounter.new_called),
m_outstanding_new_on_init(globalMemCounter.outstanding_new),
m_exactly(false)
{
}
void requireAtLeast(std::size_t N) { m_req_alloc = N; m_exactly = false; }
void requireExactly(std::size_t N) { m_req_alloc = N; m_exactly = true; }
~RequireAllocationGuard() {
assert(globalMemCounter.checkOutstandingNewEq(static_cast<int>(m_outstanding_new_on_init)));
std::size_t Expect = m_new_count_on_init + m_req_alloc;
assert(globalMemCounter.checkNewCalledEq(static_cast<int>(Expect)) ||
(!m_exactly && globalMemCounter.checkNewCalledGreaterThan(static_cast<int>(Expect))));
}
private:
std::size_t m_req_alloc;
const std::size_t m_new_count_on_init;
const std::size_t m_outstanding_new_on_init;
bool m_exactly;
RequireAllocationGuard(RequireAllocationGuard const&);
RequireAllocationGuard& operator=(RequireAllocationGuard const&);
};
#endif /* COUNT_NEW_HPP */

libcxx/trunk/test/support/counting_predicates.h

//===----------------------------------------------------------------------===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
#ifndef TEST_SUPPORT_COUNTING_PREDICATES_H
#define TEST_SUPPORT_COUNTING_PREDICATES_H
#include <cstddef>
template <typename Predicate, typename Arg>
struct unary_counting_predicate {
public:
typedef Arg argument_type;
typedef bool result_type;
unary_counting_predicate(Predicate p) : p_(p), count_(0) {}
~unary_counting_predicate() {}
bool operator () (const Arg &a) const { ++count_; return p_(a); }
size_t count() const { return count_; }
void reset() { count_ = 0; }
private:
Predicate p_;
mutable size_t count_;
};
template <typename Predicate, typename Arg1, typename Arg2=Arg1>
struct binary_counting_predicate {
public:
typedef Arg1 first_argument_type;
typedef Arg2 second_argument_type;
typedef bool result_type;
binary_counting_predicate ( Predicate p ) : p_(p), count_(0) {}
~binary_counting_predicate() {}
bool operator () (const Arg1 &a1, const Arg2 &a2) const { ++count_; return p_(a1, a2); }
size_t count() const { return count_; }
void reset() { count_ = 0; }
private:
Predicate p_;
mutable size_t count_;
};
#endif // TEST_SUPPORT_COUNTING_PREDICATES_H

libcxx/trunk/test/support/counting_predicates.hpp

//===----------------------------------------------------------------------===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
#ifndef TEST_SUPPORT_COUNTING_PREDICATES_H
#define TEST_SUPPORT_COUNTING_PREDICATES_H
#include <cstddef>
template <typename Predicate, typename Arg>
struct unary_counting_predicate {
public:
typedef Arg argument_type;
typedef bool result_type;
unary_counting_predicate(Predicate p) : p_(p), count_(0) {}
~unary_counting_predicate() {}
bool operator () (const Arg &a) const { ++count_; return p_(a); }
size_t count() const { return count_; }
void reset() { count_ = 0; }
private:
Predicate p_;
mutable size_t count_;
};
template <typename Predicate, typename Arg1, typename Arg2=Arg1>
struct binary_counting_predicate {
public:
typedef Arg1 first_argument_type;
typedef Arg2 second_argument_type;
typedef bool result_type;
binary_counting_predicate ( Predicate p ) : p_(p), count_(0) {}
~binary_counting_predicate() {}
bool operator () (const Arg1 &a1, const Arg2 &a2) const { ++count_; return p_(a1, a2); }
size_t count() const { return count_; }
void reset() { count_ = 0; }
private:
Predicate p_;
mutable size_t count_;
};
#endif // TEST_SUPPORT_COUNTING_PREDICATES_H

libcxx/trunk/test/support/filesystem_include.h

#ifndef TEST_SUPPORT_FILESYSTEM_INCLUDE_H
#define TEST_SUPPORT_FILESYSTEM_INCLUDE_H
#include <filesystem>
#include "test_macros.h"
#if defined(_LIBCPP_VERSION) && TEST_STD_VER < 17
namespace fs = std::__fs::filesystem;
#else
namespace fs = std::filesystem;
#endif
#endif

libcxx/trunk/test/support/filesystem_include.hpp

#ifndef TEST_SUPPORT_FILESYSTEM_INCLUDE_HPP
#define TEST_SUPPORT_FILESYSTEM_INCLUDE_HPP
#include <filesystem>
#include "test_macros.h"
#if defined(_LIBCPP_VERSION) && TEST_STD_VER < 17
namespace fs = std::__fs::filesystem;
#else
namespace fs = std::filesystem;
#endif
#endif

libcxx/trunk/test/support/filesystem_test_helper.h

#ifndef FILESYSTEM_TEST_HELPER_H
#define FILESYSTEM_TEST_HELPER_H
#include "filesystem_include.h"
#include <unistd.h> // for ftruncate
#include <cassert>
#include <cstdio> // for printf
#include <string>
#include <fstream>
#include <random>
#include <chrono>
#include <vector>
#include <regex>
#include "test_macros.h"
#include "rapid-cxx-test.h"
#include "format_string.h"
// static test helpers
#ifndef LIBCXX_FILESYSTEM_STATIC_TEST_ROOT
#warning "STATIC TESTS DISABLED"
#else // LIBCXX_FILESYSTEM_STATIC_TEST_ROOT
namespace StaticEnv {
inline fs::path makePath(fs::path const& p) {
// env_path is expected not to contain symlinks.
static const fs::path env_path = LIBCXX_FILESYSTEM_STATIC_TEST_ROOT;
return env_path / p;
}
static const fs::path Root = LIBCXX_FILESYSTEM_STATIC_TEST_ROOT;
static const fs::path TestFileList[] = {
makePath("empty_file"),
makePath("non_empty_file"),
makePath("dir1/file1"),
makePath("dir1/file2")
};
const std::size_t TestFileListSize = sizeof(TestFileList) / sizeof(fs::path);
static const fs::path TestDirList[] = {
makePath("dir1"),
makePath("dir1/dir2"),
makePath("dir1/dir2/dir3")
};
const std::size_t TestDirListSize = sizeof(TestDirList) / sizeof(fs::path);
static const fs::path File = TestFileList[0];
static const fs::path Dir = TestDirList[0];
static const fs::path Dir2 = TestDirList[1];
static const fs::path Dir3 = TestDirList[2];
static const fs::path SymlinkToFile = makePath("symlink_to_empty_file");
static const fs::path SymlinkToDir = makePath("symlink_to_dir");
static const fs::path BadSymlink = makePath("bad_symlink");
static const fs::path DNE = makePath("DNE");
static const fs::path EmptyFile = TestFileList[0];
static const fs::path NonEmptyFile = TestFileList[1];
static const fs::path CharFile = "/dev/null"; // Hopefully this exists
static const fs::path DirIterationList[] = {
makePath("dir1/dir2"),
makePath("dir1/file1"),
makePath("dir1/file2")
};
const std::size_t DirIterationListSize = sizeof(DirIterationList)
/ sizeof(fs::path);
static const fs::path DirIterationListDepth1[] = {
makePath("dir1/dir2/afile3"),
makePath("dir1/dir2/dir3"),
makePath("dir1/dir2/symlink_to_dir3"),
makePath("dir1/dir2/file4"),
};
static const fs::path RecDirIterationList[] = {
makePath("dir1/dir2"),
makePath("dir1/file1"),
makePath("dir1/file2"),
makePath("dir1/dir2/afile3"),
makePath("dir1/dir2/dir3"),
makePath("dir1/dir2/symlink_to_dir3"),
makePath("dir1/dir2/file4"),
makePath("dir1/dir2/dir3/file5")
};
static const fs::path RecDirFollowSymlinksIterationList[] = {
makePath("dir1/dir2"),
makePath("dir1/file1"),
makePath("dir1/file2"),
makePath("dir1/dir2/afile3"),
makePath("dir1/dir2/dir3"),
makePath("dir1/dir2/file4"),
makePath("dir1/dir2/dir3/file5"),
makePath("dir1/dir2/symlink_to_dir3"),
makePath("dir1/dir2/symlink_to_dir3/file5"),
};
} // namespace StaticEnv
#endif // LIBCXX_FILESYSTEM_STATIC_TEST_ROOT
#ifndef LIBCXX_FILESYSTEM_DYNAMIC_TEST_ROOT
#warning LIBCXX_FILESYSTEM_DYNAMIC_TEST_ROOT must be defined
#else // LIBCXX_FILESYSTEM_DYNAMIC_TEST_ROOT
#ifndef LIBCXX_FILESYSTEM_DYNAMIC_TEST_HELPER
#error LIBCXX_FILESYSTEM_DYNAMIC_TEST_HELPER must be defined
#endif
namespace random_utils {
inline char to_hex(int ch) {
return ch < 10 ? static_cast<char>('0' + ch)
: static_cast<char>('a' + (ch - 10));
}
inline char random_hex_char() {
static std::mt19937 rd{std::random_device{}()};
static std::uniform_int_distribution<int> mrand{0, 15};
return to_hex(mrand(rd));
}
} // namespace random_utils
struct scoped_test_env
{
scoped_test_env() : test_root(random_env_path())
{ fs_helper_run(fs_make_cmd("init_test_directory", test_root)); }
~scoped_test_env()
{ fs_helper_run(fs_make_cmd("destroy_test_directory", test_root)); }
scoped_test_env(scoped_test_env const &) = delete;
scoped_test_env & operator=(scoped_test_env const &) = delete;
fs::path make_env_path(std::string p) { return sanitize_path(p); }
std::string sanitize_path(std::string raw) {
assert(raw.find("..") == std::string::npos);
std::string const& root = test_root.native();
if (root.compare(0, root.size(), raw, 0, root.size()) != 0) {
assert(raw.front() != '\\');
fs::path tmp(test_root);
tmp /= raw;
return std::move(const_cast<std::string&>(tmp.native()));
}
return raw;
}
// Purposefully using a size potentially larger than off_t here so we can
// test the behavior of libc++fs when it is built with _FILE_OFFSET_BITS=64
// but the caller is not (std::filesystem also uses uintmax_t rather than
// off_t). On a 32-bit system this allows us to create a file larger than
// 2GB.
std::string create_file(std::string filename, uintmax_t size = 0) {
#if defined(__LP64__)
auto large_file_fopen = fopen;
auto large_file_ftruncate = ftruncate;
using large_file_offset_t = off_t;
#else
auto large_file_fopen = fopen64;
auto large_file_ftruncate = ftruncate64;
using large_file_offset_t = off64_t;
#endif
filename = sanitize_path(std::move(filename));
if (size > std::numeric_limits<large_file_offset_t>::max()) {
fprintf(stderr, "create_file(%s, %ju) too large\n",
filename.c_str(), size);
abort();
}
FILE* file = large_file_fopen(filename.c_str(), "we");
if (file == nullptr) {
fprintf(stderr, "fopen %s failed: %s\n", filename.c_str(),
strerror(errno));
abort();
}
if (large_file_ftruncate(
fileno(file), static_cast<large_file_offset_t>(size)) == -1) {
fprintf(stderr, "ftruncate %s %ju failed: %s\n", filename.c_str(),
size, strerror(errno));
fclose(file);
abort();
}
fclose(file);
return filename;
}
std::string create_dir(std::string filename) {
filename = sanitize_path(std::move(filename));
fs_helper_run(fs_make_cmd("create_dir", filename));
return filename;
}
std::string create_symlink(std::string source, std::string to) {
source = sanitize_path(std::move(source));
to = sanitize_path(std::move(to));
fs_helper_run(fs_make_cmd("create_symlink", source, to));
return to;
}
std::string create_hardlink(std::string source, std::string to) {
source = sanitize_path(std::move(source));
to = sanitize_path(std::move(to));
fs_helper_run(fs_make_cmd("create_hardlink", source, to));
return to;
}
std::string create_fifo(std::string file) {
file = sanitize_path(std::move(file));
fs_helper_run(fs_make_cmd("create_fifo", file));
return file;
}
// OS X and FreeBSD doesn't support socket files so we shouldn't even
// allow tests to call this unguarded.
#if !defined(__FreeBSD__) && !defined(__APPLE__)
std::string create_socket(std::string file) {
file = sanitize_path(std::move(file));
fs_helper_run(fs_make_cmd("create_socket", file));
return file;
}
#endif
fs::path const test_root;
private:
static std::string unique_path_suffix() {
std::string model = "test.%%%%%%";
for (auto & ch : model) {
if (ch == '%')
ch = random_utils::random_hex_char();
}
return model;
}
// This could potentially introduce a filesystem race with other tests
// running at the same time, but oh well, it's just test code.
static inline fs::path random_env_path() {
static const char* env_path = LIBCXX_FILESYSTEM_DYNAMIC_TEST_ROOT;
fs::path p = fs::path(env_path) / unique_path_suffix();
assert(p.parent_path() == env_path);
return p;
}
static inline std::string make_arg(std::string const& arg) {
return "'" + arg + "'";
}
static inline std::string make_arg(std::size_t arg) {
return std::to_string(arg);
}
template <class T>
static inline std::string
fs_make_cmd(std::string const& cmd_name, T const& arg) {
return cmd_name + "(" + make_arg(arg) + ")";
}
template <class T, class U>
static inline std::string
fs_make_cmd(std::string const& cmd_name, T const& arg1, U const& arg2) {
return cmd_name + "(" + make_arg(arg1) + ", " + make_arg(arg2) + ")";
}
static inline void fs_helper_run(std::string const& raw_cmd) {
// check that the fs test root in the environment matches what we were
// compiled with.
static bool checked = checkDynamicTestRoot();
((void)checked);
std::string cmd = LIBCXX_FILESYSTEM_DYNAMIC_TEST_HELPER;
cmd += " \"" + raw_cmd + "\"";
int ret = std::system(cmd.c_str());
assert(ret == 0);
}
static bool checkDynamicTestRoot() {
// LIBCXX_FILESYSTEM_DYNAMIC_TEST_ROOT is expected not to contain symlinks.
char* fs_root = std::getenv("LIBCXX_FILESYSTEM_DYNAMIC_TEST_ROOT");
if (!fs_root) {
std::printf("ERROR: LIBCXX_FILESYSTEM_DYNAMIC_TEST_ROOT must be a defined "
"environment variable when running the test.\n");
std::abort();
}
if (std::string(fs_root) != LIBCXX_FILESYSTEM_DYNAMIC_TEST_ROOT) {
std::printf("ERROR: LIBCXX_FILESYSTEM_DYNAMIC_TEST_ROOT environment variable"
" must have the same value as when the test was compiled.\n");
std::printf(" Current Value: '%s'\n", fs_root);
std::printf(" Expected Value: '%s'\n", LIBCXX_FILESYSTEM_DYNAMIC_TEST_ROOT);
std::abort();
}
return true;
}
};
#endif // LIBCXX_FILESYSTEM_DYNAMIC_TEST_ROOT
// Misc test types
#define CONCAT2(LHS, RHS) LHS##RHS
#define CONCAT(LHS, RHS) CONCAT2(LHS, RHS)
#define MKSTR(Str) {Str, CONCAT(L, Str), CONCAT(u, Str), CONCAT(U, Str)}
struct MultiStringType {
const char* s;
const wchar_t* w;
const char16_t* u16;
const char32_t* u32;
operator const char* () const { return s; }
operator const wchar_t* () const { return w; }
operator const char16_t* () const { return u16; }
operator const char32_t* () const { return u32; }
};
const MultiStringType PathList[] = {
MKSTR(""),
MKSTR(" "),
MKSTR("//"),
MKSTR("."),
MKSTR(".."),
MKSTR("foo"),
MKSTR("/"),
MKSTR("/foo"),
MKSTR("foo/"),
MKSTR("/foo/"),
MKSTR("foo/bar"),
MKSTR("/foo/bar"),
MKSTR("//net"),
MKSTR("//net/foo"),
MKSTR("///foo///"),
MKSTR("///foo///bar"),
MKSTR("/."),
MKSTR("./"),
MKSTR("/.."),
MKSTR("../"),
MKSTR("foo/."),
MKSTR("foo/.."),
MKSTR("foo/./"),
MKSTR("foo/./bar"),
MKSTR("foo/../"),
MKSTR("foo/../bar"),
MKSTR("c:"),
MKSTR("c:/"),
MKSTR("c:foo"),
MKSTR("c:/foo"),
MKSTR("c:foo/"),
MKSTR("c:/foo/"),
MKSTR("c:/foo/bar"),
MKSTR("prn:"),
MKSTR("c:\\"),
MKSTR("c:\\foo"),
MKSTR("c:foo\\"),
MKSTR("c:\\foo\\"),
MKSTR("c:\\foo/"),
MKSTR("c:/foo\\bar"),
MKSTR("//"),
MKSTR("/finally/we/need/one/really/really/really/really/really/really/really/long/string")
};
const unsigned PathListSize = sizeof(PathList) / sizeof(MultiStringType);
template <class Iter>
Iter IterEnd(Iter B) {
using VT = typename std::iterator_traits<Iter>::value_type;
for (; *B != VT{}; ++B)
;
return B;
}
template <class CharT>
const CharT* StrEnd(CharT const* P) {
return IterEnd(P);
}
template <class CharT>
std::size_t StrLen(CharT const* P) {
return StrEnd(P) - P;
}
// Testing the allocation behavior of the code_cvt functions requires
// *knowing* that the allocation was not done by "path::__str_".
// This hack forces path to allocate enough memory.
inline void PathReserve(fs::path& p, std::size_t N) {
auto const& native_ref = p.native();
const_cast<std::string&>(native_ref).reserve(N);
}
template <class Iter1, class Iter2>
bool checkCollectionsEqual(
Iter1 start1, Iter1 const end1
, Iter2 start2, Iter2 const end2
)
{
while (start1 != end1 && start2 != end2) {
if (*start1 != *start2) {
return false;
}
++start1; ++start2;
}
return (start1 == end1 && start2 == end2);
}
template <class Iter1, class Iter2>
bool checkCollectionsEqualBackwards(
Iter1 const start1, Iter1 end1
, Iter2 const start2, Iter2 end2
)
{
while (start1 != end1 && start2 != end2) {
--end1; --end2;
if (*end1 != *end2) {
return false;
}
}
return (start1 == end1 && start2 == end2);
}
// We often need to test that the error_code was cleared if no error occurs
// this function returns an error_code which is set to an error that will
// never be returned by the filesystem functions.
inline std::error_code GetTestEC(unsigned Idx = 0) {
using std::errc;
auto GetErrc = [&]() {
switch (Idx) {
case 0:
return errc::address_family_not_supported;
case 1:
return errc::address_not_available;
case 2:
return errc::address_in_use;
case 3:
return errc::argument_list_too_long;
default:
assert(false && "Idx out of range");
std::abort();
}
};
return std::make_error_code(GetErrc());
}
inline bool ErrorIsImp(const std::error_code& ec,
std::vector<std::errc> const& errors) {
for (auto errc : errors) {
if (ec == std::make_error_code(errc))
return true;
}
return false;
}
template <class... ErrcT>
inline bool ErrorIs(const std::error_code& ec, std::errc First, ErrcT... Rest) {
std::vector<std::errc> errors = {First, Rest...};
return ErrorIsImp(ec, errors);
}
// Provide our own Sleep routine since std::this_thread::sleep_for is not
// available in single-threaded mode.
void SleepFor(std::chrono::seconds dur) {
using namespace std::chrono;
#if defined(_LIBCPP_HAS_NO_MONOTONIC_CLOCK)
using Clock = system_clock;
#else
using Clock = steady_clock;
#endif
const auto wake_time = Clock::now() + dur;
while (Clock::now() < wake_time)
;
}
inline bool PathEq(fs::path const& LHS, fs::path const& RHS) {
return LHS.native() == RHS.native();
}
struct ExceptionChecker {
std::errc expected_err;
fs::path expected_path1;
fs::path expected_path2;
unsigned num_paths;
const char* func_name;
std::string opt_message;
explicit ExceptionChecker(std::errc first_err, const char* func_name,
std::string opt_msg = {})
: expected_err{first_err}, num_paths(0), func_name(func_name),
opt_message(opt_msg) {}
explicit ExceptionChecker(fs::path p, std::errc first_err,
const char* func_name, std::string opt_msg = {})
: expected_err(first_err), expected_path1(p), num_paths(1),
func_name(func_name), opt_message(opt_msg) {}
explicit ExceptionChecker(fs::path p1, fs::path p2, std::errc first_err,
const char* func_name, std::string opt_msg = {})
: expected_err(first_err), expected_path1(p1), expected_path2(p2),
num_paths(2), func_name(func_name), opt_message(opt_msg) {}
void operator()(fs::filesystem_error const& Err) {
TEST_CHECK(ErrorIsImp(Err.code(), {expected_err}));
TEST_CHECK(Err.path1() == expected_path1);
TEST_CHECK(Err.path2() == expected_path2);
LIBCPP_ONLY(check_libcxx_string(Err));
}
void check_libcxx_string(fs::filesystem_error const& Err) {
std::string message = std::make_error_code(expected_err).message();
std::string additional_msg = "";
if (!opt_message.empty()) {
additional_msg = opt_message + ": ";
}
auto transform_path = [](const fs::path& p) {
if (p.native().empty())
return "\"\"";
return p.c_str();
};
std::string format = [&]() -> std::string {
switch (num_paths) {
case 0:
return format_string("filesystem error: in %s: %s%s", func_name,
additional_msg, message);
case 1:
return format_string("filesystem error: in %s: %s%s [%s]", func_name,
additional_msg, message,
transform_path(expected_path1));
case 2:
return format_string("filesystem error: in %s: %s%s [%s] [%s]",
func_name, additional_msg, message,
transform_path(expected_path1),
transform_path(expected_path2));
default:
TEST_CHECK(false && "unexpected case");
return "";
}
}();
TEST_CHECK(format == Err.what());
if (format != Err.what()) {
fprintf(stderr,
"filesystem_error::what() does not match expected output:\n");
fprintf(stderr, " expected: \"%s\"\n", format.c_str());
fprintf(stderr, " actual: \"%s\"\n\n", Err.what());
}
}
ExceptionChecker(ExceptionChecker const&) = delete;
ExceptionChecker& operator=(ExceptionChecker const&) = delete;
};
#endif /* FILESYSTEM_TEST_HELPER_HPP */

libcxx/trunk/test/support/filesystem_test_helper.hpp

#ifndef FILESYSTEM_TEST_HELPER_HPP
#define FILESYSTEM_TEST_HELPER_HPP
#include "filesystem_include.hpp"
#include <unistd.h> // for ftruncate
#include <cassert>
#include <cstdio> // for printf
#include <string>
#include <fstream>
#include <random>
#include <chrono>
#include <vector>
#include <regex>
#include "test_macros.h"
#include "rapid-cxx-test.hpp"
#include "format_string.hpp"
// static test helpers
#ifndef LIBCXX_FILESYSTEM_STATIC_TEST_ROOT
#warning "STATIC TESTS DISABLED"
#else // LIBCXX_FILESYSTEM_STATIC_TEST_ROOT
namespace StaticEnv {
inline fs::path makePath(fs::path const& p) {
// env_path is expected not to contain symlinks.
static const fs::path env_path = LIBCXX_FILESYSTEM_STATIC_TEST_ROOT;
return env_path / p;
}
static const fs::path Root = LIBCXX_FILESYSTEM_STATIC_TEST_ROOT;
static const fs::path TestFileList[] = {
makePath("empty_file"),
makePath("non_empty_file"),
makePath("dir1/file1"),
makePath("dir1/file2")
};
const std::size_t TestFileListSize = sizeof(TestFileList) / sizeof(fs::path);
static const fs::path TestDirList[] = {
makePath("dir1"),
makePath("dir1/dir2"),
makePath("dir1/dir2/dir3")
};
const std::size_t TestDirListSize = sizeof(TestDirList) / sizeof(fs::path);
static const fs::path File = TestFileList[0];
static const fs::path Dir = TestDirList[0];
static const fs::path Dir2 = TestDirList[1];
static const fs::path Dir3 = TestDirList[2];
static const fs::path SymlinkToFile = makePath("symlink_to_empty_file");
static const fs::path SymlinkToDir = makePath("symlink_to_dir");
static const fs::path BadSymlink = makePath("bad_symlink");
static const fs::path DNE = makePath("DNE");
static const fs::path EmptyFile = TestFileList[0];
static const fs::path NonEmptyFile = TestFileList[1];
static const fs::path CharFile = "/dev/null"; // Hopefully this exists
static const fs::path DirIterationList[] = {
makePath("dir1/dir2"),
makePath("dir1/file1"),
makePath("dir1/file2")
};
const std::size_t DirIterationListSize = sizeof(DirIterationList)
/ sizeof(fs::path);
static const fs::path DirIterationListDepth1[] = {
makePath("dir1/dir2/afile3"),
makePath("dir1/dir2/dir3"),
makePath("dir1/dir2/symlink_to_dir3"),
makePath("dir1/dir2/file4"),
};
static const fs::path RecDirIterationList[] = {
makePath("dir1/dir2"),
makePath("dir1/file1"),
makePath("dir1/file2"),
makePath("dir1/dir2/afile3"),
makePath("dir1/dir2/dir3"),
makePath("dir1/dir2/symlink_to_dir3"),
makePath("dir1/dir2/file4"),
makePath("dir1/dir2/dir3/file5")
};
static const fs::path RecDirFollowSymlinksIterationList[] = {
makePath("dir1/dir2"),
makePath("dir1/file1"),
makePath("dir1/file2"),
makePath("dir1/dir2/afile3"),
makePath("dir1/dir2/dir3"),
makePath("dir1/dir2/file4"),
makePath("dir1/dir2/dir3/file5"),
makePath("dir1/dir2/symlink_to_dir3"),
makePath("dir1/dir2/symlink_to_dir3/file5"),
};
} // namespace StaticEnv
#endif // LIBCXX_FILESYSTEM_STATIC_TEST_ROOT
#ifndef LIBCXX_FILESYSTEM_DYNAMIC_TEST_ROOT
#warning LIBCXX_FILESYSTEM_DYNAMIC_TEST_ROOT must be defined
#else // LIBCXX_FILESYSTEM_DYNAMIC_TEST_ROOT
#ifndef LIBCXX_FILESYSTEM_DYNAMIC_TEST_HELPER
#error LIBCXX_FILESYSTEM_DYNAMIC_TEST_HELPER must be defined
#endif
namespace random_utils {
inline char to_hex(int ch) {
return ch < 10 ? static_cast<char>('0' + ch)
: static_cast<char>('a' + (ch - 10));
}
inline char random_hex_char() {
static std::mt19937 rd{std::random_device{}()};
static std::uniform_int_distribution<int> mrand{0, 15};
return to_hex(mrand(rd));
}
} // namespace random_utils
struct scoped_test_env
{
scoped_test_env() : test_root(random_env_path())
{ fs_helper_run(fs_make_cmd("init_test_directory", test_root)); }
~scoped_test_env()
{ fs_helper_run(fs_make_cmd("destroy_test_directory", test_root)); }
scoped_test_env(scoped_test_env const &) = delete;
scoped_test_env & operator=(scoped_test_env const &) = delete;
fs::path make_env_path(std::string p) { return sanitize_path(p); }
std::string sanitize_path(std::string raw) {
assert(raw.find("..") == std::string::npos);
std::string const& root = test_root.native();
if (root.compare(0, root.size(), raw, 0, root.size()) != 0) {
assert(raw.front() != '\\');
fs::path tmp(test_root);
tmp /= raw;
return std::move(const_cast<std::string&>(tmp.native()));
}
return raw;
}
// Purposefully using a size potentially larger than off_t here so we can
// test the behavior of libc++fs when it is built with _FILE_OFFSET_BITS=64
// but the caller is not (std::filesystem also uses uintmax_t rather than
// off_t). On a 32-bit system this allows us to create a file larger than
// 2GB.
std::string create_file(std::string filename, uintmax_t size = 0) {
#if defined(__LP64__)
auto large_file_fopen = fopen;
auto large_file_ftruncate = ftruncate;
using large_file_offset_t = off_t;
#else
auto large_file_fopen = fopen64;
auto large_file_ftruncate = ftruncate64;
using large_file_offset_t = off64_t;
#endif
filename = sanitize_path(std::move(filename));
if (size > std::numeric_limits<large_file_offset_t>::max()) {
fprintf(stderr, "create_file(%s, %ju) too large\n",
filename.c_str(), size);
abort();
}
FILE* file = large_file_fopen(filename.c_str(), "we");
if (file == nullptr) {
fprintf(stderr, "fopen %s failed: %s\n", filename.c_str(),
strerror(errno));
abort();
}
if (large_file_ftruncate(
fileno(file), static_cast<large_file_offset_t>(size)) == -1) {
fprintf(stderr, "ftruncate %s %ju failed: %s\n", filename.c_str(),
size, strerror(errno));
fclose(file);
abort();
}
fclose(file);
return filename;
}
std::string create_dir(std::string filename) {
filename = sanitize_path(std::move(filename));
fs_helper_run(fs_make_cmd("create_dir", filename));
return filename;
}
std::string create_symlink(std::string source, std::string to) {
source = sanitize_path(std::move(source));
to = sanitize_path(std::move(to));
fs_helper_run(fs_make_cmd("create_symlink", source, to));
return to;
}
std::string create_hardlink(std::string source, std::string to) {
source = sanitize_path(std::move(source));
to = sanitize_path(std::move(to));
fs_helper_run(fs_make_cmd("create_hardlink", source, to));
return to;
}
std::string create_fifo(std::string file) {
file = sanitize_path(std::move(file));
fs_helper_run(fs_make_cmd("create_fifo", file));
return file;
}
// OS X and FreeBSD doesn't support socket files so we shouldn't even
// allow tests to call this unguarded.
#if !defined(__FreeBSD__) && !defined(__APPLE__)
std::string create_socket(std::string file) {
file = sanitize_path(std::move(file));
fs_helper_run(fs_make_cmd("create_socket", file));
return file;
}
#endif
fs::path const test_root;
private:
static std::string unique_path_suffix() {
std::string model = "test.%%%%%%";
for (auto & ch : model) {
if (ch == '%')
ch = random_utils::random_hex_char();
}
return model;
}
// This could potentially introduce a filesystem race with other tests
// running at the same time, but oh well, it's just test code.
static inline fs::path random_env_path() {
static const char* env_path = LIBCXX_FILESYSTEM_DYNAMIC_TEST_ROOT;
fs::path p = fs::path(env_path) / unique_path_suffix();
assert(p.parent_path() == env_path);
return p;
}
static inline std::string make_arg(std::string const& arg) {
return "'" + arg + "'";
}
static inline std::string make_arg(std::size_t arg) {
return std::to_string(arg);
}
template <class T>
static inline std::string
fs_make_cmd(std::string const& cmd_name, T const& arg) {
return cmd_name + "(" + make_arg(arg) + ")";
}
template <class T, class U>
static inline std::string
fs_make_cmd(std::string const& cmd_name, T const& arg1, U const& arg2) {
return cmd_name + "(" + make_arg(arg1) + ", " + make_arg(arg2) + ")";
}
static inline void fs_helper_run(std::string const& raw_cmd) {
// check that the fs test root in the environment matches what we were
// compiled with.
static bool checked = checkDynamicTestRoot();
((void)checked);
std::string cmd = LIBCXX_FILESYSTEM_DYNAMIC_TEST_HELPER;
cmd += " \"" + raw_cmd + "\"";
int ret = std::system(cmd.c_str());
assert(ret == 0);
}
static bool checkDynamicTestRoot() {
// LIBCXX_FILESYSTEM_DYNAMIC_TEST_ROOT is expected not to contain symlinks.
char* fs_root = std::getenv("LIBCXX_FILESYSTEM_DYNAMIC_TEST_ROOT");
if (!fs_root) {
std::printf("ERROR: LIBCXX_FILESYSTEM_DYNAMIC_TEST_ROOT must be a defined "
"environment variable when running the test.\n");
std::abort();
}
if (std::string(fs_root) != LIBCXX_FILESYSTEM_DYNAMIC_TEST_ROOT) {
std::printf("ERROR: LIBCXX_FILESYSTEM_DYNAMIC_TEST_ROOT environment variable"
" must have the same value as when the test was compiled.\n");
std::printf(" Current Value: '%s'\n", fs_root);
std::printf(" Expected Value: '%s'\n", LIBCXX_FILESYSTEM_DYNAMIC_TEST_ROOT);
std::abort();
}
return true;
}
};
#endif // LIBCXX_FILESYSTEM_DYNAMIC_TEST_ROOT
// Misc test types
#define CONCAT2(LHS, RHS) LHS##RHS
#define CONCAT(LHS, RHS) CONCAT2(LHS, RHS)
#define MKSTR(Str) {Str, CONCAT(L, Str), CONCAT(u, Str), CONCAT(U, Str)}
struct MultiStringType {
const char* s;
const wchar_t* w;
const char16_t* u16;
const char32_t* u32;
operator const char* () const { return s; }
operator const wchar_t* () const { return w; }
operator const char16_t* () const { return u16; }
operator const char32_t* () const { return u32; }
};
const MultiStringType PathList[] = {
MKSTR(""),
MKSTR(" "),
MKSTR("//"),
MKSTR("."),
MKSTR(".."),
MKSTR("foo"),
MKSTR("/"),
MKSTR("/foo"),
MKSTR("foo/"),
MKSTR("/foo/"),
MKSTR("foo/bar"),
MKSTR("/foo/bar"),
MKSTR("//net"),
MKSTR("//net/foo"),
MKSTR("///foo///"),
MKSTR("///foo///bar"),
MKSTR("/."),
MKSTR("./"),
MKSTR("/.."),
MKSTR("../"),
MKSTR("foo/."),
MKSTR("foo/.."),
MKSTR("foo/./"),
MKSTR("foo/./bar"),
MKSTR("foo/../"),
MKSTR("foo/../bar"),
MKSTR("c:"),
MKSTR("c:/"),
MKSTR("c:foo"),
MKSTR("c:/foo"),
MKSTR("c:foo/"),
MKSTR("c:/foo/"),
MKSTR("c:/foo/bar"),
MKSTR("prn:"),
MKSTR("c:\\"),
MKSTR("c:\\foo"),
MKSTR("c:foo\\"),
MKSTR("c:\\foo\\"),
MKSTR("c:\\foo/"),
MKSTR("c:/foo\\bar"),
MKSTR("//"),
MKSTR("/finally/we/need/one/really/really/really/really/really/really/really/long/string")
};
const unsigned PathListSize = sizeof(PathList) / sizeof(MultiStringType);
template <class Iter>
Iter IterEnd(Iter B) {
using VT = typename std::iterator_traits<Iter>::value_type;
for (; *B != VT{}; ++B)
;
return B;
}
template <class CharT>
const CharT* StrEnd(CharT const* P) {
return IterEnd(P);
}
template <class CharT>
std::size_t StrLen(CharT const* P) {
return StrEnd(P) - P;
}
// Testing the allocation behavior of the code_cvt functions requires
// *knowing* that the allocation was not done by "path::__str_".
// This hack forces path to allocate enough memory.
inline void PathReserve(fs::path& p, std::size_t N) {
auto const& native_ref = p.native();
const_cast<std::string&>(native_ref).reserve(N);
}
template <class Iter1, class Iter2>
bool checkCollectionsEqual(
Iter1 start1, Iter1 const end1
, Iter2 start2, Iter2 const end2
)
{
while (start1 != end1 && start2 != end2) {
if (*start1 != *start2) {
return false;
}
++start1; ++start2;
}
return (start1 == end1 && start2 == end2);
}
template <class Iter1, class Iter2>
bool checkCollectionsEqualBackwards(
Iter1 const start1, Iter1 end1
, Iter2 const start2, Iter2 end2
)
{
while (start1 != end1 && start2 != end2) {
--end1; --end2;
if (*end1 != *end2) {
return false;
}
}
return (start1 == end1 && start2 == end2);
}
// We often need to test that the error_code was cleared if no error occurs
// this function returns an error_code which is set to an error that will
// never be returned by the filesystem functions.
inline std::error_code GetTestEC(unsigned Idx = 0) {
using std::errc;
auto GetErrc = [&]() {
switch (Idx) {
case 0:
return errc::address_family_not_supported;
case 1:
return errc::address_not_available;
case 2:
return errc::address_in_use;
case 3:
return errc::argument_list_too_long;
default:
assert(false && "Idx out of range");
std::abort();
}
};
return std::make_error_code(GetErrc());
}
inline bool ErrorIsImp(const std::error_code& ec,
std::vector<std::errc> const& errors) {
for (auto errc : errors) {
if (ec == std::make_error_code(errc))
return true;
}
return false;
}
template <class... ErrcT>
inline bool ErrorIs(const std::error_code& ec, std::errc First, ErrcT... Rest) {
std::vector<std::errc> errors = {First, Rest...};
return ErrorIsImp(ec, errors);
}
// Provide our own Sleep routine since std::this_thread::sleep_for is not
// available in single-threaded mode.
void SleepFor(std::chrono::seconds dur) {
using namespace std::chrono;
#if defined(_LIBCPP_HAS_NO_MONOTONIC_CLOCK)
using Clock = system_clock;
#else
using Clock = steady_clock;
#endif
const auto wake_time = Clock::now() + dur;
while (Clock::now() < wake_time)
;
}
inline bool PathEq(fs::path const& LHS, fs::path const& RHS) {
return LHS.native() == RHS.native();
}
struct ExceptionChecker {
std::errc expected_err;
fs::path expected_path1;
fs::path expected_path2;
unsigned num_paths;
const char* func_name;
std::string opt_message;
explicit ExceptionChecker(std::errc first_err, const char* func_name,
std::string opt_msg = {})
: expected_err{first_err}, num_paths(0), func_name(func_name),
opt_message(opt_msg) {}
explicit ExceptionChecker(fs::path p, std::errc first_err,
const char* func_name, std::string opt_msg = {})
: expected_err(first_err), expected_path1(p), num_paths(1),
func_name(func_name), opt_message(opt_msg) {}
explicit ExceptionChecker(fs::path p1, fs::path p2, std::errc first_err,
const char* func_name, std::string opt_msg = {})
: expected_err(first_err), expected_path1(p1), expected_path2(p2),
num_paths(2), func_name(func_name), opt_message(opt_msg) {}
void operator()(fs::filesystem_error const& Err) {
TEST_CHECK(ErrorIsImp(Err.code(), {expected_err}));
TEST_CHECK(Err.path1() == expected_path1);
TEST_CHECK(Err.path2() == expected_path2);
LIBCPP_ONLY(check_libcxx_string(Err));
}
void check_libcxx_string(fs::filesystem_error const& Err) {
std::string message = std::make_error_code(expected_err).message();
std::string additional_msg = "";
if (!opt_message.empty()) {
additional_msg = opt_message + ": ";
}
auto transform_path = [](const fs::path& p) {
if (p.native().empty())
return "\"\"";
return p.c_str();
};
std::string format = [&]() -> std::string {
switch (num_paths) {
case 0:
return format_string("filesystem error: in %s: %s%s", func_name,
additional_msg, message);
case 1:
return format_string("filesystem error: in %s: %s%s [%s]", func_name,
additional_msg, message,
transform_path(expected_path1));
case 2:
return format_string("filesystem error: in %s: %s%s [%s] [%s]",
func_name, additional_msg, message,
transform_path(expected_path1),
transform_path(expected_path2));
default:
TEST_CHECK(false && "unexpected case");
return "";
}
}();
TEST_CHECK(format == Err.what());
if (format != Err.what()) {
fprintf(stderr,
"filesystem_error::what() does not match expected output:\n");
fprintf(stderr, " expected: \"%s\"\n", format.c_str());
fprintf(stderr, " actual: \"%s\"\n\n", Err.what());
}
}
ExceptionChecker(ExceptionChecker const&) = delete;
ExceptionChecker& operator=(ExceptionChecker const&) = delete;
};
#endif /* FILESYSTEM_TEST_HELPER_HPP */

libcxx/trunk/test/support/format_string.h

#ifndef TEST_SUPPORT_FORMAT_STRING_H
#define TEST_SUPPORT_FORMAT_STRING_H
#include <cstdio>
#include <string>
#include <memory>
#include <array>
#include <cstdarg>
namespace format_string_detail {
inline std::string format_string_imp(const char* msg, ...) {
// we might need a second shot at this, so pre-emptivly make a copy
struct GuardVAList {
va_list& xtarget;
bool active;
GuardVAList(va_list& val) : xtarget(val), active(true) {}
void clear() {
if (active)
va_end(xtarget);
active = false;
}
~GuardVAList() {
if (active)
va_end(xtarget);
}
};
va_list args;
va_start(args, msg);
GuardVAList args_guard(args);
va_list args_cp;
va_copy(args_cp, args);
GuardVAList args_copy_guard(args_cp);
std::array<char, 256> local_buff;
std::size_t size = local_buff.size();
auto ret = ::vsnprintf(local_buff.data(), size, msg, args_cp);
args_copy_guard.clear();
// handle empty expansion
if (ret == 0)
return std::string{};
if (static_cast<std::size_t>(ret) < size)
return std::string(local_buff.data());
// we did not provide a long enough buffer on our first attempt.
// add 1 to size to account for null-byte in size cast to prevent overflow
size = static_cast<std::size_t>(ret) + 1;
auto buff_ptr = std::unique_ptr<char[]>(new char[size]);
ret = ::vsnprintf(buff_ptr.get(), size, msg, args);
return std::string(buff_ptr.get());
}
const char* unwrap(std::string& s) { return s.c_str(); }
template <class Arg>
Arg const& unwrap(Arg& a) {
static_assert(!std::is_class<Arg>::value, "cannot pass class here");
return a;
}
} // namespace format_string_detail
template <class... Args>
std::string format_string(const char* fmt, Args const&... args) {
return format_string_detail::format_string_imp(
fmt, format_string_detail::unwrap(const_cast<Args&>(args))...);
}
#endif // TEST_SUPPORT_FORMAT_STRING_HPP

libcxx/trunk/test/support/format_string.hpp

#ifndef TEST_SUPPORT_FORMAT_STRING_HPP
#define TEST_SUPPORT_FORMAT_STRING_HPP
#include <cstdio>
#include <string>
#include <memory>
#include <array>
#include <cstdarg>
namespace format_string_detail {
inline std::string format_string_imp(const char* msg, ...) {
// we might need a second shot at this, so pre-emptivly make a copy
struct GuardVAList {
va_list& xtarget;
bool active;
GuardVAList(va_list& val) : xtarget(val), active(true) {}
void clear() {
if (active)
va_end(xtarget);
active = false;
}
~GuardVAList() {
if (active)
va_end(xtarget);
}
};
va_list args;
va_start(args, msg);
GuardVAList args_guard(args);
va_list args_cp;
va_copy(args_cp, args);
GuardVAList args_copy_guard(args_cp);
std::array<char, 256> local_buff;
std::size_t size = local_buff.size();
auto ret = ::vsnprintf(local_buff.data(), size, msg, args_cp);
args_copy_guard.clear();
// handle empty expansion
if (ret == 0)
return std::string{};
if (static_cast<std::size_t>(ret) < size)
return std::string(local_buff.data());
// we did not provide a long enough buffer on our first attempt.
// add 1 to size to account for null-byte in size cast to prevent overflow
size = static_cast<std::size_t>(ret) + 1;
auto buff_ptr = std::unique_ptr<char[]>(new char[size]);
ret = ::vsnprintf(buff_ptr.get(), size, msg, args);
return std::string(buff_ptr.get());
}
const char* unwrap(std::string& s) { return s.c_str(); }
template <class Arg>
Arg const& unwrap(Arg& a) {
static_assert(!std::is_class<Arg>::value, "cannot pass class here");
return a;
}
} // namespace format_string_detail
template <class... Args>
std::string format_string(const char* fmt, Args const&... args) {
return format_string_detail::format_string_imp(
fmt, format_string_detail::unwrap(const_cast<Args&>(args))...);
}
#endif // TEST_SUPPORT_FORMAT_STRING_HPP

libcxx/trunk/test/support/msvc_stdlib_force_include.h

//===----------------------------------------------------------------------===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
#ifndef SUPPORT_MSVC_STDLIB_FORCE_INCLUDE_H
#define SUPPORT_MSVC_STDLIB_FORCE_INCLUDE_H
// This header is force-included when running the libc++ tests against the
// MSVC standard library.
#ifndef _LIBCXX_IN_DEVCRT
// Silence warnings about CRT machinery.
#define _CRT_SECURE_NO_WARNINGS
// Avoid assertion dialogs.
#define _CRT_SECURE_INVALID_PARAMETER(EXPR) ::abort()
#endif // _LIBCXX_IN_DEVCRT
#include <crtdbg.h>
#include <stdlib.h>
#if defined(_LIBCPP_VERSION)
#error This header may not be used when targeting libc++
#endif
#ifndef _LIBCXX_IN_DEVCRT
struct AssertionDialogAvoider {
AssertionDialogAvoider() {
_CrtSetReportMode(_CRT_ASSERT, _CRTDBG_MODE_FILE);
_CrtSetReportFile(_CRT_ASSERT, _CRTDBG_FILE_STDERR);
_CrtSetReportMode(_CRT_ERROR, _CRTDBG_MODE_FILE);
_CrtSetReportFile(_CRT_ERROR, _CRTDBG_FILE_STDERR);
}
};
const AssertionDialogAvoider assertion_dialog_avoider{};
#endif // _LIBCXX_IN_DEVCRT
// MSVC frontend only configurations
#if !defined(__clang__)
// Simulate feature-test macros.
#define __has_feature(X) _MSVC_HAS_FEATURE_ ## X
#define _MSVC_HAS_FEATURE_cxx_exceptions 1
#define _MSVC_HAS_FEATURE_cxx_rtti 1
#define _MSVC_HAS_FEATURE_address_sanitizer 0
#define _MSVC_HAS_FEATURE_memory_sanitizer 0
#define _MSVC_HAS_FEATURE_thread_sanitizer 0
#define __has_attribute(X) _MSVC_HAS_ATTRIBUTE_ ## X
#define _MSVC_HAS_ATTRIBUTE_vector_size 0
// Silence compiler warnings.
#pragma warning(disable: 4180) // qualifier applied to function type has no meaning; ignored
#pragma warning(disable: 4324) // structure was padded due to alignment specifier
#pragma warning(disable: 4521) // multiple copy constructors specified
#pragma warning(disable: 4702) // unreachable code
#pragma warning(disable: 28251) // Inconsistent annotation for 'new': this instance has no annotations.
#endif // !defined(__clang__)
// MSVC doesn't have __int128_t.
#define _LIBCPP_HAS_NO_INT128
// MSVC has quick_exit() and at_quick_exit().
#define _LIBCPP_HAS_QUICK_EXIT
#ifndef _LIBCXX_IN_DEVCRT
// atomic_is_lock_free.pass.cpp needs this VS 2015 Update 2 fix.
#define _ENABLE_ATOMIC_ALIGNMENT_FIX
// Silence warnings about features that are deprecated in C++17 and C++20.
#define _SILENCE_ALL_CXX17_DEPRECATION_WARNINGS
#define _SILENCE_ALL_CXX20_DEPRECATION_WARNINGS
#endif // _LIBCXX_IN_DEVCRT
#include <ciso646>
#if _HAS_CXX20
#define TEST_STD_VER 99
#elif _HAS_CXX17
#define TEST_STD_VER 17
#else // !(_HAS_CXX20 || _HAS_CXX17)
#define TEST_STD_VER 14
#endif
#define _LIBCPP_AVAILABILITY_THROW_BAD_ANY_CAST
#endif // SUPPORT_MSVC_STDLIB_FORCE_INCLUDE_H

libcxx/trunk/test/support/msvc_stdlib_force_include.hpp

//===----------------------------------------------------------------------===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
#ifndef SUPPORT_MSVC_STDLIB_FORCE_INCLUDE_HPP
#define SUPPORT_MSVC_STDLIB_FORCE_INCLUDE_HPP
// This header is force-included when running the libc++ tests against the
// MSVC standard library.
#ifndef _LIBCXX_IN_DEVCRT
// Silence warnings about CRT machinery.
#define _CRT_SECURE_NO_WARNINGS
// Avoid assertion dialogs.
#define _CRT_SECURE_INVALID_PARAMETER(EXPR) ::abort()
#endif // _LIBCXX_IN_DEVCRT
#include <crtdbg.h>
#include <stdlib.h>
#if defined(_LIBCPP_VERSION)
#error This header may not be used when targeting libc++
#endif
#ifndef _LIBCXX_IN_DEVCRT
struct AssertionDialogAvoider {
AssertionDialogAvoider() {
_CrtSetReportMode(_CRT_ASSERT, _CRTDBG_MODE_FILE);
_CrtSetReportFile(_CRT_ASSERT, _CRTDBG_FILE_STDERR);
_CrtSetReportMode(_CRT_ERROR, _CRTDBG_MODE_FILE);
_CrtSetReportFile(_CRT_ERROR, _CRTDBG_FILE_STDERR);
}
};
const AssertionDialogAvoider assertion_dialog_avoider{};
#endif // _LIBCXX_IN_DEVCRT
// MSVC frontend only configurations
#if !defined(__clang__)
// Simulate feature-test macros.
#define __has_feature(X) _MSVC_HAS_FEATURE_ ## X
#define _MSVC_HAS_FEATURE_cxx_exceptions 1
#define _MSVC_HAS_FEATURE_cxx_rtti 1
#define _MSVC_HAS_FEATURE_address_sanitizer 0
#define _MSVC_HAS_FEATURE_memory_sanitizer 0
#define _MSVC_HAS_FEATURE_thread_sanitizer 0
#define __has_attribute(X) _MSVC_HAS_ATTRIBUTE_ ## X
#define _MSVC_HAS_ATTRIBUTE_vector_size 0
// Silence compiler warnings.
#pragma warning(disable: 4180) // qualifier applied to function type has no meaning; ignored
#pragma warning(disable: 4324) // structure was padded due to alignment specifier
#pragma warning(disable: 4521) // multiple copy constructors specified
#pragma warning(disable: 4702) // unreachable code
#pragma warning(disable: 28251) // Inconsistent annotation for 'new': this instance has no annotations.
#endif // !defined(__clang__)
// MSVC doesn't have __int128_t.
#define _LIBCPP_HAS_NO_INT128
// MSVC has quick_exit() and at_quick_exit().
#define _LIBCPP_HAS_QUICK_EXIT
#ifndef _LIBCXX_IN_DEVCRT
// atomic_is_lock_free.pass.cpp needs this VS 2015 Update 2 fix.
#define _ENABLE_ATOMIC_ALIGNMENT_FIX
// Silence warnings about features that are deprecated in C++17 and C++20.
#define _SILENCE_ALL_CXX17_DEPRECATION_WARNINGS
#define _SILENCE_ALL_CXX20_DEPRECATION_WARNINGS
#endif // _LIBCXX_IN_DEVCRT
#include <ciso646>
#if _HAS_CXX20
#define TEST_STD_VER 99
#elif _HAS_CXX17
#define TEST_STD_VER 17
#else // !(_HAS_CXX20 || _HAS_CXX17)
#define TEST_STD_VER 14
#endif
#define _LIBCPP_AVAILABILITY_THROW_BAD_ANY_CAST
#endif // SUPPORT_MSVC_STDLIB_FORCE_INCLUDE_HPP

libcxx/trunk/test/support/nasty_containers.h

//===----------------------------------------------------------------------===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
#ifndef NASTY_CONTAINERS_H
#define NASTY_CONTAINERS_H
#include <cassert>
#include <vector>
#include <list>
#include "test_macros.h"
template <class T>
class nasty_vector
{
public:
typedef typename std::vector<T> nested_container;
typedef typename nested_container::value_type value_type;
typedef typename nested_container::reference reference;
typedef typename nested_container::const_reference const_reference;
typedef typename nested_container::iterator iterator;
typedef typename nested_container::const_iterator const_iterator;
typedef typename nested_container::size_type size_type;
typedef typename nested_container::difference_type difference_type;
typedef typename nested_container::pointer pointer;
typedef typename nested_container::const_pointer const_pointer;
typedef typename nested_container::reverse_iterator reverse_iterator;
typedef typename nested_container::const_reverse_iterator const_reverse_iterator;
nasty_vector() : v_() {}
explicit nasty_vector(size_type n) : v_(n) {}
nasty_vector(size_type n, const value_type& value) : v_(n, value) {}
template <class InputIterator> nasty_vector(InputIterator first, InputIterator last) : v_(first, last) {}
#if TEST_STD_VER >= 11
nasty_vector(std::initializer_list<value_type> il) : v_(il) {}
#endif
~nasty_vector() {}
template <class InputIterator>
void assign(InputIterator first, InputIterator last) { v_.assign(first, last); }
void assign(size_type n, const value_type& u) { v_.assign(n, u); }
#if TEST_STD_VER >= 11
void assign(std::initializer_list<value_type> il) { v_.assign(il); }
#endif
iterator begin() TEST_NOEXCEPT { return v_.begin(); }
const_iterator begin() const TEST_NOEXCEPT { return v_.begin(); }
iterator end() TEST_NOEXCEPT { return v_.end(); }
const_iterator end() const TEST_NOEXCEPT { return v_.end(); }
reverse_iterator rbegin() TEST_NOEXCEPT { return v_.rbegin(); }
const_reverse_iterator rbegin() const TEST_NOEXCEPT { return v_.rbegin(); }
reverse_iterator rend() TEST_NOEXCEPT { return v_.rend(); }
const_reverse_iterator rend() const TEST_NOEXCEPT { return v_.rend(); }
const_iterator cbegin() const TEST_NOEXCEPT { return v_.cbegin(); }
const_iterator cend() const TEST_NOEXCEPT { return v_.cend(); }
const_reverse_iterator crbegin() const TEST_NOEXCEPT { return v_.crbegin(); }
const_reverse_iterator crend() const TEST_NOEXCEPT { return v_.crend(); }
size_type size() const TEST_NOEXCEPT { return v_.size(); }
size_type max_size() const TEST_NOEXCEPT { return v_.max_size(); }
size_type capacity() const TEST_NOEXCEPT { return v_.capacity(); }
bool empty() const TEST_NOEXCEPT { return v_.empty(); }
void reserve(size_type n) { v_.reserve(n); };
void shrink_to_fit() TEST_NOEXCEPT { v_.shrink_to_fit(); }
reference operator[](size_type n) { return v_[n]; }
const_reference operator[](size_type n) const { return v_[n]; }
reference at(size_type n) { return v_.at(n); }
const_reference at(size_type n) const { return v_.at(n); }
reference front() { return v_.front(); }
const_reference front() const { return v_.front(); }
reference back() { return v_.back(); }
const_reference back() const { return v_.back(); }
value_type* data() TEST_NOEXCEPT { return v_.data(); }
const value_type* data() const TEST_NOEXCEPT { return v_.data(); }
void push_back(const value_type& x) { v_.push_back(x); }
#if TEST_STD_VER >= 11
void push_back(value_type&& x) { v_.push_back(std::forward<value_type&&>(x)); }
template <class... Args>
void emplace_back(Args&&... args) { v_.emplace_back(std::forward<Args>(args)...); }
#endif
void pop_back() { v_.pop_back(); }
#if TEST_STD_VER >= 11
template <class... Args> iterator emplace(const_iterator pos, Args&&... args)
{ return v_.emplace(pos, std::forward<Args>(args)...); }
#endif
iterator insert(const_iterator pos, const value_type& x) { return v_.insert(pos, x); }
#if TEST_STD_VER >= 11
iterator insert(const_iterator pos, value_type&& x) { return v_.insert(pos, std::forward<value_type>(x)); }
#endif
iterator insert(const_iterator pos, size_type n, const value_type& x) { return v_.insert(pos, n, x); }
template <class InputIterator>
iterator insert(const_iterator pos, InputIterator first, InputIterator last)
{ return v_.insert(pos, first, last); }
#if TEST_STD_VER >= 11
iterator insert(const_iterator pos, std::initializer_list<value_type> il) { return v_.insert(pos, il); }
#endif
iterator erase(const_iterator pos) { return v_.erase(pos); }
iterator erase(const_iterator first, const_iterator last) { return v_.erase(first, last); }
void clear() TEST_NOEXCEPT { v_.clear(); }
void resize(size_type sz) { v_.resize(sz); }
void resize(size_type sz, const value_type& c) { v_.resize(sz, c); }
void swap(nasty_vector &nv)
#if TEST_STD_VER > 14
noexcept(std::is_nothrow_swappable<nested_container>::value)
#elif defined(_LIBCPP_VERSION)
TEST_NOEXCEPT_COND(std::__is_nothrow_swappable<nested_container>::value)
#endif
{ v_.swap(nv.v_); }
nasty_vector *operator &() { assert(false); return nullptr; } // nasty
const nasty_vector *operator &() const { assert(false); return nullptr; } // nasty
nested_container v_;
};
template <class T>
bool operator==(const nasty_vector<T>& x, const nasty_vector<T>& y) { return x.v_ == y.v_; }
template <class T>
class nasty_list
{
public:
typedef typename std::list<T> nested_container;
typedef typename nested_container::value_type value_type;
typedef typename nested_container::reference reference;
typedef typename nested_container::const_reference const_reference;
typedef typename nested_container::iterator iterator;
typedef typename nested_container::const_iterator const_iterator;
typedef typename nested_container::size_type size_type;
typedef typename nested_container::difference_type difference_type;
typedef typename nested_container::pointer pointer;
typedef typename nested_container::const_pointer const_pointer;
typedef typename nested_container::reverse_iterator reverse_iterator;
typedef typename nested_container::const_reverse_iterator const_reverse_iterator;
nasty_list() : l_() {}
explicit nasty_list(size_type n) : l_(n) {}
nasty_list(size_type n, const value_type& value) : l_(n,value) {}
template <class Iter>
nasty_list(Iter first, Iter last) : l_(first, last) {}
#if TEST_STD_VER >= 11
nasty_list(std::initializer_list<value_type> il) : l_(il) {}
#endif
~nasty_list() {}
#if TEST_STD_VER >= 11
nasty_list& operator=(std::initializer_list<value_type> il) { l_ = il; return *this; }
#endif
template <class Iter>
void assign(Iter first, Iter last) { l_.assign(first, last); }
void assign(size_type n, const value_type& t) { l_.assign(n, t); }
#if TEST_STD_VER >= 11
void assign(std::initializer_list<value_type> il) { l_.assign(il); }
#endif
iterator begin() TEST_NOEXCEPT { return l_.begin(); }
const_iterator begin() const TEST_NOEXCEPT { return l_.begin(); }
iterator end() TEST_NOEXCEPT { return l_.end(); }
const_iterator end() const TEST_NOEXCEPT { return l_.end(); }
reverse_iterator rbegin() TEST_NOEXCEPT { return l_.rbegin(); }
const_reverse_iterator rbegin() const TEST_NOEXCEPT { return l_.rbegin(); }
reverse_iterator rend() TEST_NOEXCEPT { return l_.rend(); }
const_reverse_iterator rend() const TEST_NOEXCEPT { return l_.rend(); }
const_iterator cbegin() const TEST_NOEXCEPT { return l_.cbegin(); }
const_iterator cend() const TEST_NOEXCEPT { return l_.cend(); }
const_reverse_iterator crbegin() const TEST_NOEXCEPT { return l_.crbegin(); }
const_reverse_iterator crend() const TEST_NOEXCEPT { return l_.crend(); }
reference front() { return l_.front(); }
const_reference front() const { return l_.front(); }
reference back() { return l_.back(); }
const_reference back() const { return l_.back(); }
size_type size() const TEST_NOEXCEPT { return l_.size(); }
size_type max_size() const TEST_NOEXCEPT { return l_.max_size(); }
bool empty() const TEST_NOEXCEPT { return l_.empty(); }
void push_front(const value_type& x) { l_.push_front(x); }
void push_back(const value_type& x) { l_.push_back(x); }
#if TEST_STD_VER >= 11
void push_back(value_type&& x) { l_.push_back(std::forward<value_type&&>(x)); }
void push_front(value_type&& x) { l_.push_back(std::forward<value_type&&>(x)); }
template <class... Args>
void emplace_back(Args&&... args) { l_.emplace_back(std::forward<Args>(args)...); }
template <class... Args>
void emplace_front(Args&&... args) { l_.emplace_front(std::forward<Args>(args)...); }
#endif
void pop_front() { l_.pop_front(); }
void pop_back() { l_.pop_back(); }
#if TEST_STD_VER >= 11
template <class... Args> iterator emplace(const_iterator pos, Args&&... args)
{ return l_.emplace(pos, std::forward<Args>(args)...); }
#endif
iterator insert(const_iterator pos, const value_type& x) { return l_.insert(pos, x); }
#if TEST_STD_VER >= 11
iterator insert(const_iterator pos, value_type&& x) { return l_.insert(pos, std::forward<value_type>(x)); }
#endif
iterator insert(const_iterator pos, size_type n, const value_type& x) { return l_.insert(pos, n, x); }
template <class InputIterator>
iterator insert(const_iterator pos, InputIterator first, InputIterator last)
{ return l_.insert(pos, first, last); }
#if TEST_STD_VER >= 11
iterator insert(const_iterator pos, std::initializer_list<value_type> il) { return l_.insert(pos, il); }
#endif
iterator erase(const_iterator pos) { return l_.erase(pos); }
iterator erase(const_iterator pos, const_iterator last) { return l_.erase(pos, last); }
void resize(size_type) { l_.resize(); }
void resize(size_type, const value_type& c) { l_.resize(c); }
void swap(nasty_list &nl)
#if TEST_STD_VER > 14
noexcept(std::is_nothrow_swappable<nested_container>::value)
#elif defined(_LIBCPP_VERSION)
TEST_NOEXCEPT_COND(std::__is_nothrow_swappable<nested_container>::value)
#endif
{ l_.swap(nl.l_); }
void clear() TEST_NOEXCEPT { l_.clear(); }
// void splice(const_iterator position, list& x);
// void splice(const_iterator position, list&& x);
// void splice(const_iterator position, list& x, const_iterator i);
// void splice(const_iterator position, list&& x, const_iterator i);
// void splice(const_iterator position, list& x, const_iterator first,
// const_iterator last);
// void splice(const_iterator position, list&& x, const_iterator first,
// const_iterator last);
//
// void remove(const value_type& value);
// template <class Pred> void remove_if(Pred pred);
// void unique();
// template <class BinaryPredicate>
// void unique(BinaryPredicate binary_pred);
// void merge(list& x);
// void merge(list&& x);
// template <class Compare>
// void merge(list& x, Compare comp);
// template <class Compare>
// void merge(list&& x, Compare comp);
// void sort();
// template <class Compare>
// void sort(Compare comp);
// void reverse() noexcept;
nasty_list *operator &() { assert(false); return nullptr; } // nasty
const nasty_list *operator &() const { assert(false); return nullptr; } // nasty
nested_container l_;
};
template <class T>
bool operator==(const nasty_list<T>& x, const nasty_list<T>& y) { return x.l_ == y.l_; }
// Not really a mutex, but can play one in tests
class nasty_mutex
{
public:
nasty_mutex() TEST_NOEXCEPT {}
~nasty_mutex() {}
nasty_mutex *operator& () { assert(false); return nullptr; }
template <typename T>
void operator, (const T &) { assert(false); }
private:
nasty_mutex(const nasty_mutex&) { assert(false); }
nasty_mutex& operator=(const nasty_mutex&) { assert(false); return *this; }
public:
void lock() {}
bool try_lock() TEST_NOEXCEPT { return true; }
void unlock() TEST_NOEXCEPT {}
// Shared ownership
void lock_shared() {}
bool try_lock_shared() { return true; }
void unlock_shared() {}
};
#endif

libcxx/trunk/test/support/nasty_containers.hpp

//===----------------------------------------------------------------------===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
#ifndef NASTY_CONTAINERS_H
#define NASTY_CONTAINERS_H
#include <cassert>
#include <vector>
#include <list>
#include "test_macros.h"
template <class T>
class nasty_vector
{
public:
typedef typename std::vector<T> nested_container;
typedef typename nested_container::value_type value_type;
typedef typename nested_container::reference reference;
typedef typename nested_container::const_reference const_reference;
typedef typename nested_container::iterator iterator;
typedef typename nested_container::const_iterator const_iterator;
typedef typename nested_container::size_type size_type;
typedef typename nested_container::difference_type difference_type;
typedef typename nested_container::pointer pointer;
typedef typename nested_container::const_pointer const_pointer;
typedef typename nested_container::reverse_iterator reverse_iterator;
typedef typename nested_container::const_reverse_iterator const_reverse_iterator;
nasty_vector() : v_() {}
explicit nasty_vector(size_type n) : v_(n) {}
nasty_vector(size_type n, const value_type& value) : v_(n, value) {}
template <class InputIterator> nasty_vector(InputIterator first, InputIterator last) : v_(first, last) {}
#if TEST_STD_VER >= 11
nasty_vector(std::initializer_list<value_type> il) : v_(il) {}
#endif
~nasty_vector() {}
template <class InputIterator>
void assign(InputIterator first, InputIterator last) { v_.assign(first, last); }
void assign(size_type n, const value_type& u) { v_.assign(n, u); }
#if TEST_STD_VER >= 11
void assign(std::initializer_list<value_type> il) { v_.assign(il); }
#endif
iterator begin() TEST_NOEXCEPT { return v_.begin(); }
const_iterator begin() const TEST_NOEXCEPT { return v_.begin(); }
iterator end() TEST_NOEXCEPT { return v_.end(); }
const_iterator end() const TEST_NOEXCEPT { return v_.end(); }
reverse_iterator rbegin() TEST_NOEXCEPT { return v_.rbegin(); }
const_reverse_iterator rbegin() const TEST_NOEXCEPT { return v_.rbegin(); }
reverse_iterator rend() TEST_NOEXCEPT { return v_.rend(); }
const_reverse_iterator rend() const TEST_NOEXCEPT { return v_.rend(); }
const_iterator cbegin() const TEST_NOEXCEPT { return v_.cbegin(); }
const_iterator cend() const TEST_NOEXCEPT { return v_.cend(); }
const_reverse_iterator crbegin() const TEST_NOEXCEPT { return v_.crbegin(); }
const_reverse_iterator crend() const TEST_NOEXCEPT { return v_.crend(); }
size_type size() const TEST_NOEXCEPT { return v_.size(); }
size_type max_size() const TEST_NOEXCEPT { return v_.max_size(); }
size_type capacity() const TEST_NOEXCEPT { return v_.capacity(); }
bool empty() const TEST_NOEXCEPT { return v_.empty(); }
void reserve(size_type n) { v_.reserve(n); };
void shrink_to_fit() TEST_NOEXCEPT { v_.shrink_to_fit(); }
reference operator[](size_type n) { return v_[n]; }
const_reference operator[](size_type n) const { return v_[n]; }
reference at(size_type n) { return v_.at(n); }
const_reference at(size_type n) const { return v_.at(n); }
reference front() { return v_.front(); }
const_reference front() const { return v_.front(); }
reference back() { return v_.back(); }
const_reference back() const { return v_.back(); }
value_type* data() TEST_NOEXCEPT { return v_.data(); }
const value_type* data() const TEST_NOEXCEPT { return v_.data(); }
void push_back(const value_type& x) { v_.push_back(x); }
#if TEST_STD_VER >= 11
void push_back(value_type&& x) { v_.push_back(std::forward<value_type&&>(x)); }
template <class... Args>
void emplace_back(Args&&... args) { v_.emplace_back(std::forward<Args>(args)...); }
#endif
void pop_back() { v_.pop_back(); }
#if TEST_STD_VER >= 11
template <class... Args> iterator emplace(const_iterator pos, Args&&... args)
{ return v_.emplace(pos, std::forward<Args>(args)...); }
#endif
iterator insert(const_iterator pos, const value_type& x) { return v_.insert(pos, x); }
#if TEST_STD_VER >= 11
iterator insert(const_iterator pos, value_type&& x) { return v_.insert(pos, std::forward<value_type>(x)); }
#endif
iterator insert(const_iterator pos, size_type n, const value_type& x) { return v_.insert(pos, n, x); }
template <class InputIterator>
iterator insert(const_iterator pos, InputIterator first, InputIterator last)
{ return v_.insert(pos, first, last); }
#if TEST_STD_VER >= 11
iterator insert(const_iterator pos, std::initializer_list<value_type> il) { return v_.insert(pos, il); }
#endif
iterator erase(const_iterator pos) { return v_.erase(pos); }
iterator erase(const_iterator first, const_iterator last) { return v_.erase(first, last); }
void clear() TEST_NOEXCEPT { v_.clear(); }
void resize(size_type sz) { v_.resize(sz); }
void resize(size_type sz, const value_type& c) { v_.resize(sz, c); }
void swap(nasty_vector &nv)
#if TEST_STD_VER > 14
noexcept(std::is_nothrow_swappable<nested_container>::value)
#elif defined(_LIBCPP_VERSION)
TEST_NOEXCEPT_COND(std::__is_nothrow_swappable<nested_container>::value)
#endif
{ v_.swap(nv.v_); }
nasty_vector *operator &() { assert(false); return nullptr; } // nasty
const nasty_vector *operator &() const { assert(false); return nullptr; } // nasty
nested_container v_;
};
template <class T>
bool operator==(const nasty_vector<T>& x, const nasty_vector<T>& y) { return x.v_ == y.v_; }
template <class T>
class nasty_list
{
public:
typedef typename std::list<T> nested_container;
typedef typename nested_container::value_type value_type;
typedef typename nested_container::reference reference;
typedef typename nested_container::const_reference const_reference;
typedef typename nested_container::iterator iterator;
typedef typename nested_container::const_iterator const_iterator;
typedef typename nested_container::size_type size_type;
typedef typename nested_container::difference_type difference_type;
typedef typename nested_container::pointer pointer;
typedef typename nested_container::const_pointer const_pointer;
typedef typename nested_container::reverse_iterator reverse_iterator;
typedef typename nested_container::const_reverse_iterator const_reverse_iterator;
nasty_list() : l_() {}
explicit nasty_list(size_type n) : l_(n) {}
nasty_list(size_type n, const value_type& value) : l_(n,value) {}
template <class Iter>
nasty_list(Iter first, Iter last) : l_(first, last) {}
#if TEST_STD_VER >= 11
nasty_list(std::initializer_list<value_type> il) : l_(il) {}
#endif
~nasty_list() {}
#if TEST_STD_VER >= 11
nasty_list& operator=(std::initializer_list<value_type> il) { l_ = il; return *this; }
#endif
template <class Iter>
void assign(Iter first, Iter last) { l_.assign(first, last); }
void assign(size_type n, const value_type& t) { l_.assign(n, t); }
#if TEST_STD_VER >= 11
void assign(std::initializer_list<value_type> il) { l_.assign(il); }
#endif
iterator begin() TEST_NOEXCEPT { return l_.begin(); }
const_iterator begin() const TEST_NOEXCEPT { return l_.begin(); }
iterator end() TEST_NOEXCEPT { return l_.end(); }
const_iterator end() const TEST_NOEXCEPT { return l_.end(); }
reverse_iterator rbegin() TEST_NOEXCEPT { return l_.rbegin(); }
const_reverse_iterator rbegin() const TEST_NOEXCEPT { return l_.rbegin(); }
reverse_iterator rend() TEST_NOEXCEPT { return l_.rend(); }
const_reverse_iterator rend() const TEST_NOEXCEPT { return l_.rend(); }
const_iterator cbegin() const TEST_NOEXCEPT { return l_.cbegin(); }
const_iterator cend() const TEST_NOEXCEPT { return l_.cend(); }
const_reverse_iterator crbegin() const TEST_NOEXCEPT { return l_.crbegin(); }
const_reverse_iterator crend() const TEST_NOEXCEPT { return l_.crend(); }
reference front() { return l_.front(); }
const_reference front() const { return l_.front(); }
reference back() { return l_.back(); }
const_reference back() const { return l_.back(); }
size_type size() const TEST_NOEXCEPT { return l_.size(); }
size_type max_size() const TEST_NOEXCEPT { return l_.max_size(); }
bool empty() const TEST_NOEXCEPT { return l_.empty(); }
void push_front(const value_type& x) { l_.push_front(x); }
void push_back(const value_type& x) { l_.push_back(x); }
#if TEST_STD_VER >= 11
void push_back(value_type&& x) { l_.push_back(std::forward<value_type&&>(x)); }
void push_front(value_type&& x) { l_.push_back(std::forward<value_type&&>(x)); }
template <class... Args>
void emplace_back(Args&&... args) { l_.emplace_back(std::forward<Args>(args)...); }
template <class... Args>
void emplace_front(Args&&... args) { l_.emplace_front(std::forward<Args>(args)...); }
#endif
void pop_front() { l_.pop_front(); }
void pop_back() { l_.pop_back(); }
#if TEST_STD_VER >= 11
template <class... Args> iterator emplace(const_iterator pos, Args&&... args)
{ return l_.emplace(pos, std::forward<Args>(args)...); }
#endif
iterator insert(const_iterator pos, const value_type& x) { return l_.insert(pos, x); }
#if TEST_STD_VER >= 11
iterator insert(const_iterator pos, value_type&& x) { return l_.insert(pos, std::forward<value_type>(x)); }
#endif
iterator insert(const_iterator pos, size_type n, const value_type& x) { return l_.insert(pos, n, x); }
template <class InputIterator>
iterator insert(const_iterator pos, InputIterator first, InputIterator last)
{ return l_.insert(pos, first, last); }
#if TEST_STD_VER >= 11
iterator insert(const_iterator pos, std::initializer_list<value_type> il) { return l_.insert(pos, il); }
#endif
iterator erase(const_iterator pos) { return l_.erase(pos); }
iterator erase(const_iterator pos, const_iterator last) { return l_.erase(pos, last); }
void resize(size_type) { l_.resize(); }
void resize(size_type, const value_type& c) { l_.resize(c); }
void swap(nasty_list &nl)
#if TEST_STD_VER > 14
noexcept(std::is_nothrow_swappable<nested_container>::value)
#elif defined(_LIBCPP_VERSION)
TEST_NOEXCEPT_COND(std::__is_nothrow_swappable<nested_container>::value)
#endif
{ l_.swap(nl.l_); }
void clear() TEST_NOEXCEPT { l_.clear(); }
// void splice(const_iterator position, list& x);
// void splice(const_iterator position, list&& x);
// void splice(const_iterator position, list& x, const_iterator i);
// void splice(const_iterator position, list&& x, const_iterator i);
// void splice(const_iterator position, list& x, const_iterator first,
// const_iterator last);
// void splice(const_iterator position, list&& x, const_iterator first,
// const_iterator last);
//
// void remove(const value_type& value);
// template <class Pred> void remove_if(Pred pred);
// void unique();
// template <class BinaryPredicate>
// void unique(BinaryPredicate binary_pred);
// void merge(list& x);
// void merge(list&& x);
// template <class Compare>
// void merge(list& x, Compare comp);
// template <class Compare>
// void merge(list&& x, Compare comp);
// void sort();
// template <class Compare>
// void sort(Compare comp);
// void reverse() noexcept;
nasty_list *operator &() { assert(false); return nullptr; } // nasty
const nasty_list *operator &() const { assert(false); return nullptr; } // nasty
nested_container l_;
};
template <class T>
bool operator==(const nasty_list<T>& x, const nasty_list<T>& y) { return x.l_ == y.l_; }
// Not really a mutex, but can play one in tests
class nasty_mutex
{
public:
nasty_mutex() TEST_NOEXCEPT {}
~nasty_mutex() {}
nasty_mutex *operator& () { assert(false); return nullptr; }
template <typename T>
void operator, (const T &) { assert(false); }
private:
nasty_mutex(const nasty_mutex&) { assert(false); }
nasty_mutex& operator=(const nasty_mutex&) { assert(false); return *this; }
public:
void lock() {}
bool try_lock() TEST_NOEXCEPT { return true; }
void unlock() TEST_NOEXCEPT {}
// Shared ownership
void lock_shared() {}
bool try_lock_shared() { return true; }
void unlock_shared() {}
};
#endif

libcxx/trunk/test/support/nasty_macros.h

//===----------------------------------------------------------------------===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
#ifndef SUPPORT_NASTY_MACROS_H
#define SUPPORT_NASTY_MACROS_H
#define NASTY_MACRO This should not be expanded!!!
#define _A NASTY_MACRO
#define _B NASTY_MACRO
#define _C NASTY_MACRO
#define _D NASTY_MACRO
#define _E NASTY_MACRO
#define _F NASTY_MACRO
#define _G NASTY_MACRO
#define _H NASTY_MACRO
#define _I NASTY_MACRO
#define _J NASTY_MACRO
#define _K NASTY_MACRO
#define _L NASTY_MACRO
// Because FreeBSD uses _M in its <sys/types.h>, and it is hard to avoid
// including that header, only define _M for other operating systems.
#ifndef __FreeBSD__
#define _M NASTY_MACRO
#endif
#define _N NASTY_MACRO
#define _O NASTY_MACRO
#define _P NASTY_MACRO
#define _Q NASTY_MACRO
#define _R NASTY_MACRO
#define _S NASTY_MACRO
#define _T NASTY_MACRO
#define _U NASTY_MACRO
#define _V NASTY_MACRO
#define _W NASTY_MACRO
#define _X NASTY_MACRO
#define _Y NASTY_MACRO
#define _Z NASTY_MACRO
// tchar.h defines these macros on Windows.
#define _UI NASTY_MACRO
#define _PUC NASTY_MACRO
#define _CPUC NASTY_MACRO
#define _PC NASTY_MACRO
#define _CRPC NASTY_MACRO
#define _CPC NASTY_MACRO
// yvals.h on MINGW defines this macro
#define _C2 NASTY_MACRO
// Test that libc++ doesn't use names reserved by WIN32 API Macros.
// NOTE: Obviously we can only define these on non-windows platforms.
#ifndef _WIN32
#define __allocator NASTY_MACRO
#define __deallocate NASTY_MACRO
#define __out NASTY_MACRO
#endif
#define __output NASTY_MACRO
#define __input NASTY_MACRO
#define __acquire NASTY_MACRO
#define __release NASTY_MACRO
#endif // SUPPORT_NASTY_MACROS_H

libcxx/trunk/test/support/nasty_macros.hpp

//===----------------------------------------------------------------------===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
#ifndef SUPPORT_NASTY_MACROS_HPP
#define SUPPORT_NASTY_MACROS_HPP
#define NASTY_MACRO This should not be expanded!!!
#define _A NASTY_MACRO
#define _B NASTY_MACRO
#define _C NASTY_MACRO
#define _D NASTY_MACRO
#define _E NASTY_MACRO
#define _F NASTY_MACRO
#define _G NASTY_MACRO
#define _H NASTY_MACRO
#define _I NASTY_MACRO
#define _J NASTY_MACRO
#define _K NASTY_MACRO
#define _L NASTY_MACRO
// Because FreeBSD uses _M in its <sys/types.h>, and it is hard to avoid
// including that header, only define _M for other operating systems.
#ifndef __FreeBSD__
#define _M NASTY_MACRO
#endif
#define _N NASTY_MACRO
#define _O NASTY_MACRO
#define _P NASTY_MACRO
#define _Q NASTY_MACRO
#define _R NASTY_MACRO
#define _S NASTY_MACRO
#define _T NASTY_MACRO
#define _U NASTY_MACRO
#define _V NASTY_MACRO
#define _W NASTY_MACRO
#define _X NASTY_MACRO
#define _Y NASTY_MACRO
#define _Z NASTY_MACRO
// tchar.h defines these macros on Windows.
#define _UI NASTY_MACRO
#define _PUC NASTY_MACRO
#define _CPUC NASTY_MACRO
#define _PC NASTY_MACRO
#define _CRPC NASTY_MACRO
#define _CPC NASTY_MACRO
// yvals.h on MINGW defines this macro
#define _C2 NASTY_MACRO
// Test that libc++ doesn't use names reserved by WIN32 API Macros.
// NOTE: Obviously we can only define these on non-windows platforms.
#ifndef _WIN32
#define __allocator NASTY_MACRO
#define __deallocate NASTY_MACRO
#define __out NASTY_MACRO
#endif
#define __output NASTY_MACRO
#define __input NASTY_MACRO
#define __acquire NASTY_MACRO
#define __release NASTY_MACRO
#endif // SUPPORT_NASTY_MACROS_HPP

libcxx/trunk/test/support/poisoned_hash_helper.h

// -*- C++ -*-
//===----------------------------------------------------------------------===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
#ifndef SUPPORT_POISONED_HASH_HELPER_H
#define SUPPORT_POISONED_HASH_HELPER_H
#include <type_traits>
#include <cassert>
#include "test_macros.h"
#include "test_workarounds.h"
#if TEST_STD_VER < 11
#error this header may only be used in C++11 or newer
#endif
template <class ...Args> struct TypeList;
// Test that the specified Hash meets the requirements of an enabled hash
template <class Hash, class Key, class InputKey = Key>
void test_hash_enabled(InputKey const& key = InputKey{});
template <class T, class InputKey = T>
void test_hash_enabled_for_type(InputKey const& key = InputKey{}) {
return test_hash_enabled<std::hash<T>, T, InputKey>(key);
}
// Test that the specified Hash meets the requirements of a disabled hash.
template <class Hash, class Key>
void test_hash_disabled();
template <class T>
void test_hash_disabled_for_type() {
return test_hash_disabled<std::hash<T>, T>();
}
namespace PoisonedHashDetail {
enum Enum {};
enum EnumClass : bool {};
struct Class {};
}
// Each header that declares the template hash provides enabled
// specializations of hash for nullptr t and all cv-unqualified
// arithmetic, enumeration, and pointer types.
using LibraryHashTypes = TypeList<
#if TEST_STD_VER > 14
decltype(nullptr),
#endif
bool,
char,
signed char,
unsigned char,
wchar_t,
#ifndef _LIBCPP_HAS_NO_UNICODE_CHARS
char16_t,
char32_t,
#endif
short,
unsigned short,
int,
unsigned int,
long,
unsigned long,
long long,
unsigned long long,
#ifndef _LIBCPP_HAS_NO_INT128
__int128_t,
__uint128_t,
#endif
float,
double,
long double,
#if TEST_STD_VER >= 14
// Enum types
PoisonedHashDetail::Enum,
PoisonedHashDetail::EnumClass,
#endif
// pointer types
void*,
void const*,
PoisonedHashDetail::Class*
>;
// Test that each of the library hash specializations for arithmetic types,
// enum types, and pointer types are available and enabled.
template <class Types = LibraryHashTypes>
void test_library_hash_specializations_available(Types = Types{});
namespace PoisonedHashDetail {
template <class T, class = typename T::foo_bar_baz>
constexpr bool instantiate(int) { return true; }
template <class> constexpr bool instantiate(long) { return true; }
template <class T> constexpr bool instantiate() { return instantiate<T>(0); }
template <class To>
struct ConvertibleToSimple {
operator To() const {
return To{};
}
};
template <class To>
struct ConvertibleTo {
To to{};
operator To&() & { return to; }
operator To const&() const & { return to; }
operator To&&() && { return std::move(to); }
operator To const&&() const && { return std::move(to); }
};
template <class HashExpr,
class Res = typename std::result_of<HashExpr>::type>
constexpr bool can_hash(int) {
return std::is_same<Res, size_t>::value;
}
template <class> constexpr bool can_hash(long) { return false; }
template <class T> constexpr bool can_hash() { return can_hash<T>(0); }
} // namespace PoisonedHashDetail
template <class Hash, class Key, class InputKey>
void test_hash_enabled(InputKey const& key) {
using namespace PoisonedHashDetail;
static_assert(std::is_destructible<Hash>::value, "");
// Enabled hash requirements
static_assert(std::is_default_constructible<Hash>::value, "");
static_assert(std::is_copy_constructible<Hash>::value, "");
static_assert(std::is_move_constructible<Hash>::value, "");
static_assert(std::is_copy_assignable<Hash>::value, "");
static_assert(std::is_move_assignable<Hash>::value, "");
#if TEST_STD_VER > 14
static_assert(std::is_swappable<Hash>::value, "");
#elif defined(_LIBCPP_VERSION)
static_assert(std::__is_swappable<Hash>::value, "");
#endif
// Hashable requirements
static_assert(can_hash<Hash(Key&)>(), "");
static_assert(can_hash<Hash(Key const&)>(), "");
static_assert(can_hash<Hash(Key&&)>(), "");
static_assert(can_hash<Hash const&(Key&)>(), "");
static_assert(can_hash<Hash const&(Key const&)>(), "");
static_assert(can_hash<Hash const&(Key&&)>(), "");
static_assert(can_hash<Hash(ConvertibleToSimple<Key>&)>(), "");
static_assert(can_hash<Hash(ConvertibleToSimple<Key> const&)>(), "");
static_assert(can_hash<Hash(ConvertibleToSimple<Key>&&)>(), "");
static_assert(can_hash<Hash(ConvertibleTo<Key>&)>(), "");
static_assert(can_hash<Hash(ConvertibleTo<Key> const&)>(), "");
static_assert(can_hash<Hash(ConvertibleTo<Key> &&)>(), "");
static_assert(can_hash<Hash(ConvertibleTo<Key> const&&)>(), "");
const Hash h{};
assert(h(key) == h(key));
}
template <class Hash, class Key>
void test_hash_disabled() {
using namespace PoisonedHashDetail;
// Disabled hash requirements
static_assert(!std::is_default_constructible<Hash>::value, "");
static_assert(!std::is_copy_constructible<Hash>::value, "");
static_assert(!std::is_move_constructible<Hash>::value, "");
static_assert(!std::is_copy_assignable<Hash>::value, "");
static_assert(!std::is_move_assignable<Hash>::value, "");
static_assert(!std::is_function<
typename std::remove_pointer<
typename std::remove_reference<Hash>::type
>::type
>::value, "");
// Hashable requirements
static_assert(!can_hash<Hash(Key&)>(), "");
static_assert(!can_hash<Hash(Key const&)>(), "");
static_assert(!can_hash<Hash(Key&&)>(), "");
static_assert(!can_hash<Hash const&(Key&)>(), "");
static_assert(!can_hash<Hash const&(Key const&)>(), "");
static_assert(!can_hash<Hash const&(Key&&)>(), "");
static_assert(!can_hash<Hash(ConvertibleToSimple<Key>&)>(), "");
static_assert(!can_hash<Hash(ConvertibleToSimple<Key> const&)>(), "");
static_assert(!can_hash<Hash(ConvertibleToSimple<Key>&&)>(), "");
static_assert(!can_hash<Hash(ConvertibleTo<Key>&)>(), "");
static_assert(!can_hash<Hash(ConvertibleTo<Key> const&)>(), "");
static_assert(!can_hash<Hash(ConvertibleTo<Key> &&)>(), "");
static_assert(!can_hash<Hash(ConvertibleTo<Key> const&&)>(), "");
}
template <class First, class ...Rest>
struct TypeList<First, Rest...> {
template <template <class> class Trait, bool Expect = true>
static constexpr bool assertTrait() {
static_assert(Trait<First>::value == Expect, "");
return TypeList<Rest...>::template assertTrait<Trait, Expect>();
}
template <class Trait>
static void applyTrait() {
Trait::template apply<First>();
TypeList<Rest...>::template applyTrait<Trait>();
}
};
template <>
struct TypeList<> {
template <template <class> class Trait, bool Expect = true>
static constexpr bool assertTrait() {
return true;
}
template <class Trait>
static void applyTrait() {}
};
struct TestLibraryTrait {
template <class Type>
static void apply() { test_hash_enabled<std::hash<Type>, Type>(); }
};
template <class Types>
void test_library_hash_specializations_available(Types) {
Types::template applyTrait<TestLibraryTrait >();
}
#endif // SUPPORT_POISONED_HASH_HELPER_H

libcxx/trunk/test/support/poisoned_hash_helper.hpp

// -*- C++ -*-
//===----------------------------------------------------------------------===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
#ifndef SUPPORT_POISONED_HASH_HELPER_HPP
#define SUPPORT_POISONED_HASH_HELPER_HPP
#include <type_traits>
#include <cassert>
#include "test_macros.h"
#include "test_workarounds.h"
#if TEST_STD_VER < 11
#error this header may only be used in C++11 or newer
#endif
template <class ...Args> struct TypeList;
// Test that the specified Hash meets the requirements of an enabled hash
template <class Hash, class Key, class InputKey = Key>
void test_hash_enabled(InputKey const& key = InputKey{});
template <class T, class InputKey = T>
void test_hash_enabled_for_type(InputKey const& key = InputKey{}) {
return test_hash_enabled<std::hash<T>, T, InputKey>(key);
}
// Test that the specified Hash meets the requirements of a disabled hash.
template <class Hash, class Key>
void test_hash_disabled();
template <class T>
void test_hash_disabled_for_type() {
return test_hash_disabled<std::hash<T>, T>();
}
namespace PoisonedHashDetail {
enum Enum {};
enum EnumClass : bool {};
struct Class {};
}
// Each header that declares the template hash provides enabled
// specializations of hash for nullptr t and all cv-unqualified
// arithmetic, enumeration, and pointer types.
using LibraryHashTypes = TypeList<
#if TEST_STD_VER > 14
decltype(nullptr),
#endif
bool,
char,
signed char,
unsigned char,
wchar_t,
#ifndef _LIBCPP_HAS_NO_UNICODE_CHARS
char16_t,
char32_t,
#endif
short,
unsigned short,
int,
unsigned int,
long,
unsigned long,
long long,
unsigned long long,
#ifndef _LIBCPP_HAS_NO_INT128
__int128_t,
__uint128_t,
#endif
float,
double,
long double,
#if TEST_STD_VER >= 14
// Enum types
PoisonedHashDetail::Enum,
PoisonedHashDetail::EnumClass,
#endif
// pointer types
void*,
void const*,
PoisonedHashDetail::Class*
>;
// Test that each of the library hash specializations for arithmetic types,
// enum types, and pointer types are available and enabled.
template <class Types = LibraryHashTypes>
void test_library_hash_specializations_available(Types = Types{});
namespace PoisonedHashDetail {
template <class T, class = typename T::foo_bar_baz>
constexpr bool instantiate(int) { return true; }
template <class> constexpr bool instantiate(long) { return true; }
template <class T> constexpr bool instantiate() { return instantiate<T>(0); }
template <class To>
struct ConvertibleToSimple {
operator To() const {
return To{};
}
};
template <class To>
struct ConvertibleTo {
To to{};
operator To&() & { return to; }
operator To const&() const & { return to; }
operator To&&() && { return std::move(to); }
operator To const&&() const && { return std::move(to); }
};
template <class HashExpr,
class Res = typename std::result_of<HashExpr>::type>
constexpr bool can_hash(int) {
return std::is_same<Res, size_t>::value;
}
template <class> constexpr bool can_hash(long) { return false; }
template <class T> constexpr bool can_hash() { return can_hash<T>(0); }
} // namespace PoisonedHashDetail
template <class Hash, class Key, class InputKey>
void test_hash_enabled(InputKey const& key) {
using namespace PoisonedHashDetail;
static_assert(std::is_destructible<Hash>::value, "");
// Enabled hash requirements
static_assert(std::is_default_constructible<Hash>::value, "");
static_assert(std::is_copy_constructible<Hash>::value, "");
static_assert(std::is_move_constructible<Hash>::value, "");
static_assert(std::is_copy_assignable<Hash>::value, "");
static_assert(std::is_move_assignable<Hash>::value, "");
#if TEST_STD_VER > 14
static_assert(std::is_swappable<Hash>::value, "");
#elif defined(_LIBCPP_VERSION)
static_assert(std::__is_swappable<Hash>::value, "");
#endif
// Hashable requirements
static_assert(can_hash<Hash(Key&)>(), "");
static_assert(can_hash<Hash(Key const&)>(), "");
static_assert(can_hash<Hash(Key&&)>(), "");
static_assert(can_hash<Hash const&(Key&)>(), "");
static_assert(can_hash<Hash const&(Key const&)>(), "");
static_assert(can_hash<Hash const&(Key&&)>(), "");
static_assert(can_hash<Hash(ConvertibleToSimple<Key>&)>(), "");
static_assert(can_hash<Hash(ConvertibleToSimple<Key> const&)>(), "");
static_assert(can_hash<Hash(ConvertibleToSimple<Key>&&)>(), "");
static_assert(can_hash<Hash(ConvertibleTo<Key>&)>(), "");
static_assert(can_hash<Hash(ConvertibleTo<Key> const&)>(), "");
static_assert(can_hash<Hash(ConvertibleTo<Key> &&)>(), "");
static_assert(can_hash<Hash(ConvertibleTo<Key> const&&)>(), "");
const Hash h{};
assert(h(key) == h(key));
}
template <class Hash, class Key>
void test_hash_disabled() {
using namespace PoisonedHashDetail;
// Disabled hash requirements
static_assert(!std::is_default_constructible<Hash>::value, "");
static_assert(!std::is_copy_constructible<Hash>::value, "");
static_assert(!std::is_move_constructible<Hash>::value, "");
static_assert(!std::is_copy_assignable<Hash>::value, "");
static_assert(!std::is_move_assignable<Hash>::value, "");
static_assert(!std::is_function<
typename std::remove_pointer<
typename std::remove_reference<Hash>::type
>::type
>::value, "");
// Hashable requirements
static_assert(!can_hash<Hash(Key&)>(), "");
static_assert(!can_hash<Hash(Key const&)>(), "");
static_assert(!can_hash<Hash(Key&&)>(), "");
static_assert(!can_hash<Hash const&(Key&)>(), "");
static_assert(!can_hash<Hash const&(Key const&)>(), "");
static_assert(!can_hash<Hash const&(Key&&)>(), "");
static_assert(!can_hash<Hash(ConvertibleToSimple<Key>&)>(), "");
static_assert(!can_hash<Hash(ConvertibleToSimple<Key> const&)>(), "");
static_assert(!can_hash<Hash(ConvertibleToSimple<Key>&&)>(), "");
static_assert(!can_hash<Hash(ConvertibleTo<Key>&)>(), "");
static_assert(!can_hash<Hash(ConvertibleTo<Key> const&)>(), "");
static_assert(!can_hash<Hash(ConvertibleTo<Key> &&)>(), "");
static_assert(!can_hash<Hash(ConvertibleTo<Key> const&&)>(), "");
}
template <class First, class ...Rest>
struct TypeList<First, Rest...> {
template <template <class> class Trait, bool Expect = true>
static constexpr bool assertTrait() {
static_assert(Trait<First>::value == Expect, "");
return TypeList<Rest...>::template assertTrait<Trait, Expect>();
}
template <class Trait>
static void applyTrait() {
Trait::template apply<First>();
TypeList<Rest...>::template applyTrait<Trait>();
}
};
template <>
struct TypeList<> {
template <template <class> class Trait, bool Expect = true>
static constexpr bool assertTrait() {
return true;
}
template <class Trait>
static void applyTrait() {}
};
struct TestLibraryTrait {
template <class Type>
static void apply() { test_hash_enabled<std::hash<Type>, Type>(); }
};
template <class Types>
void test_library_hash_specializations_available(Types) {
Types::template applyTrait<TestLibraryTrait >();
}
#endif // SUPPORT_POISONED_HASH_HELPER_HPP

libcxx/trunk/test/support/private_constructor.h

//===----------------------------------------------------------------------===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
#ifndef __PRIVATE_CONSTRUCTOR__H
#define __PRIVATE_CONSTRUCTOR__H
#include <iostream>
struct PrivateConstructor {
PrivateConstructor static make ( int v ) { return PrivateConstructor(v); }
int get () const { return val; }
private:
PrivateConstructor ( int v ) : val(v) {}
int val;
};
bool operator < ( const PrivateConstructor &lhs, const PrivateConstructor &rhs ) { return lhs.get() < rhs.get(); }
bool operator < ( const PrivateConstructor &lhs, int rhs ) { return lhs.get() < rhs; }
bool operator < ( int lhs, const PrivateConstructor &rhs ) { return lhs < rhs.get(); }
std::ostream & operator << ( std::ostream &os, const PrivateConstructor &foo ) { return os << foo.get (); }
#endif

libcxx/trunk/test/support/private_constructor.hpp

//===----------------------------------------------------------------------===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
#ifndef __PRIVATE_CONSTRUCTOR__H
#define __PRIVATE_CONSTRUCTOR__H
#include <iostream>
struct PrivateConstructor {
PrivateConstructor static make ( int v ) { return PrivateConstructor(v); }
int get () const { return val; }
private:
PrivateConstructor ( int v ) : val(v) {}
int val;
};
bool operator < ( const PrivateConstructor &lhs, const PrivateConstructor &rhs ) { return lhs.get() < rhs.get(); }
bool operator < ( const PrivateConstructor &lhs, int rhs ) { return lhs.get() < rhs; }
bool operator < ( int lhs, const PrivateConstructor &rhs ) { return lhs < rhs.get(); }
std::ostream & operator << ( std::ostream &os, const PrivateConstructor &foo ) { return os << foo.get (); }
#endif

libcxx/trunk/test/support/rapid-cxx-test.h

#ifndef RAPID_CXX_TEST_H
#define RAPID_CXX_TEST_H
# include <cstddef>
# include <cstdlib>
# include <cstdio>
# include <cstring>
# include <cassert>
#include "test_macros.h"
#if !defined(RAPID_CXX_TEST_NO_SYSTEM_HEADER) || !defined(__GNUC__)
#pragma GCC system_header
#endif
# define RAPID_CXX_TEST_PP_CAT(x, y) RAPID_CXX_TEST_PP_CAT_2(x, y)
# define RAPID_CXX_TEST_PP_CAT_2(x, y) x##y
# define RAPID_CXX_TEST_PP_STR(...) RAPID_CXX_TEST_PP_STR_2(__VA_ARGS__)
# define RAPID_CXX_TEST_PP_STR_2(...) #__VA_ARGS__
# if defined(__GNUC__)
# define TEST_FUNC_NAME() __PRETTY_FUNCTION__
# define RAPID_CXX_TEST_UNUSED __attribute__((unused))
# else
# define TEST_FUNC_NAME() __func__
# define RAPID_CXX_TEST_UNUSED
# endif
////////////////////////////////////////////////////////////////////////////////
// TEST_SUITE
////////////////////////////////////////////////////////////////////////////////
# define TEST_SUITE(Name) \
namespace Name \
{ \
inline ::rapid_cxx_test::test_suite & get_test_suite() \
{ \
static ::rapid_cxx_test::test_suite m_suite(#Name); \
return m_suite; \
} \
\
inline int unit_test_main(int, char**) \
{ \
::rapid_cxx_test::test_runner runner(get_test_suite()); \
return runner.run(); \
} \
} \
int main(int argc, char **argv) \
{ \
return Name::unit_test_main(argc, argv); \
} \
namespace Name \
{ /* namespace closed in TEST_SUITE_END */
#
////////////////////////////////////////////////////////////////////////////////
// TEST_SUITE_END
////////////////////////////////////////////////////////////////////////////////
# define TEST_SUITE_END() \
} /* namespace opened in TEST_SUITE(...) */
#
////////////////////////////////////////////////////////////////////////////////
// TEST_CASE
////////////////////////////////////////////////////////////////////////////////
# if !defined(__clang__)
#
# define TEST_CASE(Name) \
void Name(); \
static void RAPID_CXX_TEST_PP_CAT(Name, _invoker)() \
{ \
Name(); \
} \
static ::rapid_cxx_test::registrar \
RAPID_CXX_TEST_PP_CAT(rapid_cxx_test_registrar_, Name)( \
get_test_suite() \
, ::rapid_cxx_test::test_case(__FILE__, #Name, __LINE__, & RAPID_CXX_TEST_PP_CAT(Name, _invoker)) \
); \
void Name()
#
# else /* __clang__ */
#
# define TEST_CASE(Name) \
void Name(); \
static void RAPID_CXX_TEST_PP_CAT(Name, _invoker)() \
{ \
Name(); \
} \
_Pragma("clang diagnostic push") \
_Pragma("clang diagnostic ignored \"-Wglobal-constructors\"") \
static ::rapid_cxx_test::registrar \
RAPID_CXX_TEST_PP_CAT(rapid_cxx_test_registrar_, Name)( \
get_test_suite() \
, ::rapid_cxx_test::test_case(__FILE__, #Name, __LINE__, & RAPID_CXX_TEST_PP_CAT(Name, _invoker)) \
); \
_Pragma("clang diagnostic pop") \
void Name()
#
# endif /* !defined(__clang__) */
# define TEST_SET_CHECKPOINT() ::rapid_cxx_test::set_checkpoint(__FILE__, TEST_FUNC_NAME(), __LINE__)
#define RAPID_CXX_TEST_OUTCOME()
////////////////////////////////////////////////////////////////////////////////
// TEST_UNSUPPORTED
////////////////////////////////////////////////////////////////////////////////
# define TEST_UNSUPPORTED() \
do { \
TEST_SET_CHECKPOINT(); \
::rapid_cxx_test::test_outcome m_f( \
::rapid_cxx_test::failure_type::unsupported, __FILE__, TEST_FUNC_NAME(), __LINE__ \
, "", "" \
); \
::rapid_cxx_test::get_reporter().report(m_f); \
return; \
} while (false)
#
////////////////////////////////////////////////////////////////////////////////
// BASIC ASSERTIONS
////////////////////////////////////////////////////////////////////////////////
# define TEST_WARN(...) \
do { \
TEST_SET_CHECKPOINT(); \
::rapid_cxx_test::test_outcome m_f( \
::rapid_cxx_test::failure_type::none, __FILE__, TEST_FUNC_NAME(), __LINE__ \
, "TEST_WARN(" #__VA_ARGS__ ")", "" \
); \
if (not (__VA_ARGS__)) { \
m_f.type = ::rapid_cxx_test::failure_type::warn; \
} \
::rapid_cxx_test::get_reporter().report(m_f); \
} while (false)
#
# define TEST_CHECK(...) \
do { \
TEST_SET_CHECKPOINT(); \
::rapid_cxx_test::test_outcome m_f( \
::rapid_cxx_test::failure_type::none, __FILE__, TEST_FUNC_NAME(), __LINE__ \
, "TEST_CHECK(" #__VA_ARGS__ ")", "" \
); \
if (not (__VA_ARGS__)) { \
m_f.type = ::rapid_cxx_test::failure_type::check; \
} \
::rapid_cxx_test::get_reporter().report(m_f); \
} while (false)
#
# define TEST_REQUIRE(...) \
do { \
TEST_SET_CHECKPOINT(); \
::rapid_cxx_test::test_outcome m_f( \
::rapid_cxx_test::failure_type::none, __FILE__, TEST_FUNC_NAME(), __LINE__ \
, "TEST_REQUIRE(" #__VA_ARGS__ ")", "" \
); \
if (not (__VA_ARGS__)) { \
m_f.type = ::rapid_cxx_test::failure_type::require; \
} \
::rapid_cxx_test::get_reporter().report(m_f); \
if (m_f.type != ::rapid_cxx_test::failure_type::none) { \
return; \
} \
} while (false)
#
# define TEST_ASSERT(...) \
do { \
TEST_SET_CHECKPOINT(); \
::rapid_cxx_test::test_outcome m_f( \
::rapid_cxx_test::failure_type::none, __FILE__, TEST_FUNC_NAME(), __LINE__ \
, "TEST_ASSERT(" #__VA_ARGS__ ")", "" \
); \
if (not (__VA_ARGS__)) { \
m_f.type = ::rapid_cxx_test::failure_type::assert; \
} \
::rapid_cxx_test::get_reporter().report(m_f); \
if (m_f.type != ::rapid_cxx_test::failure_type::none) { \
std::abort(); \
} \
} while (false)
#
////////////////////////////////////////////////////////////////////////////////
// TEST_CHECK_NO_THROW / TEST_CHECK_THROW
////////////////////////////////////////////////////////////////////////////////
#ifndef TEST_HAS_NO_EXCEPTIONS
# define TEST_CHECK_NO_THROW(...) \
do { \
TEST_SET_CHECKPOINT(); \
::rapid_cxx_test::test_outcome m_f( \
::rapid_cxx_test::failure_type::none, __FILE__, TEST_FUNC_NAME(), __LINE__ \
, "TEST_CHECK_NO_THROW(" #__VA_ARGS__ ")", "" \
); \
try { \
(static_cast<void>(__VA_ARGS__)); \
} catch (...) { \
m_f.type = ::rapid_cxx_test::failure_type::check; \
} \
::rapid_cxx_test::get_reporter().report(m_f); \
} while (false)
#
# define TEST_CHECK_THROW(Except, ...) \
do { \
TEST_SET_CHECKPOINT(); \
::rapid_cxx_test::test_outcome m_f( \
::rapid_cxx_test::failure_type::none, __FILE__, TEST_FUNC_NAME(), __LINE__ \
, "TEST_CHECK_THROW(" #Except "," #__VA_ARGS__ ")", "" \
); \
try { \
(static_cast<void>(__VA_ARGS__)); \
m_f.type = ::rapid_cxx_test::failure_type::check; \
} catch (Except const &) {} \
::rapid_cxx_test::get_reporter().report(m_f); \
} while (false)
#
#define TEST_CHECK_THROW_RESULT(Except, Checker, ...) \
do { \
TEST_SET_CHECKPOINT(); \
::rapid_cxx_test::test_outcome m_f(::rapid_cxx_test::failure_type::none, \
__FILE__, TEST_FUNC_NAME(), __LINE__, \
"TEST_CHECK_THROW_RESULT(" #Except \
"," #Checker "," #__VA_ARGS__ ")", \
""); \
try { \
(static_cast<void>(__VA_ARGS__)); \
m_f.type = ::rapid_cxx_test::failure_type::check; \
} catch (Except const& Caught) { \
Checker(Caught); \
} \
::rapid_cxx_test::get_reporter().report(m_f); \
} while (false)
#
#else // TEST_HAS_NO_EXCEPTIONS
# define TEST_CHECK_NO_THROW(...) \
do { \
TEST_SET_CHECKPOINT(); \
::rapid_cxx_test::test_outcome m_f( \
::rapid_cxx_test::failure_type::none, __FILE__, TEST_FUNC_NAME(), __LINE__ \
, "TEST_CHECK_NO_THROW(" #__VA_ARGS__ ")", "" \
); \
(static_cast<void>(__VA_ARGS__)); \
::rapid_cxx_test::get_reporter().report(m_f); \
} while (false)
#
#define TEST_CHECK_THROW(Except, ...) ((void)0)
#define TEST_CHECK_THROW_RESULT(Except, Checker, ...) ((void)0)
#endif // TEST_HAS_NO_EXCEPTIONS
////////////////////////////////////////////////////////////////////////////////
// TEST_REQUIRE_NO_THROW / TEST_REQUIRE_THROWs
////////////////////////////////////////////////////////////////////////////////
#ifndef TEST_HAS_NO_EXCEPTIONS
# define TEST_REQUIRE_NO_THROW(...) \
do { \
TEST_SET_CHECKPOINT(); \
::rapid_cxx_test::test_outcome m_f( \
::rapid_cxx_test::failure_type::none, __FILE__, TEST_FUNC_NAME(), __LINE__ \
, "TEST_REQUIRE_NO_THROW(" #__VA_ARGS__ ")", "" \
); \
try { \
(static_cast<void>(__VA_ARGS__)); \
} catch (...) { \
m_f.type = ::rapid_cxx_test::failure_type::require; \
} \
::rapid_cxx_test::get_reporter().report(m_f); \
if (m_f.type != ::rapid_cxx_test::failure_type::none) { \
return; \
} \
} while (false)
#
# define TEST_REQUIRE_THROW(Except, ...) \
do { \
TEST_SET_CHECKPOINT(); \
::rapid_cxx_test::test_outcome m_f( \
::rapid_cxx_test::failure_type::none, __FILE__, TEST_FUNC_NAME(), __LINE__ \
, "TEST_REQUIRE_THROW(" #Except "," #__VA_ARGS__ ")", "" \
); \
try { \
(static_cast<void>(__VA_ARGS__)); \
m_f.type = ::rapid_cxx_test::failure_type::require; \
} catch (Except const &) {} \
::rapid_cxx_test::get_reporter().report(m_f); \
if (m_f.type != ::rapid_cxx_test::failure_type::none) { \
return; \
} \
} while (false)
#
#else // TEST_HAS_NO_EXCEPTIONS
# define TEST_REQUIRE_NO_THROW(...) \
do { \
TEST_SET_CHECKPOINT(); \
::rapid_cxx_test::test_outcome m_f( \
::rapid_cxx_test::failure_type::none, __FILE__, TEST_FUNC_NAME(), __LINE__ \
, "TEST_REQUIRE_NO_THROW(" #__VA_ARGS__ ")", "" \
); \
(static_cast<void>(__VA_ARGS__)); \
::rapid_cxx_test::get_reporter().report(m_f); \
} while (false)
#
#define TEST_REQUIRE_THROW(Except, ...) ((void)0)
#endif // TEST_HAS_NO_EXCEPTIONS
////////////////////////////////////////////////////////////////////////////////
// TEST_ASSERT_NO_THROW / TEST_ASSERT_THROW
////////////////////////////////////////////////////////////////////////////////
#ifndef TEST_HAS_NO_EXCEPTIONS
# define TEST_ASSERT_NO_THROW(...) \
do { \
TEST_SET_CHECKPOINT(); \
::rapid_cxx_test::test_outcome m_f( \
::rapid_cxx_test::failure_type::none, __FILE__, TEST_FUNC_NAME(), __LINE__ \
, "TEST_ASSERT_NO_THROW(" #__VA_ARGS__ ")", "" \
); \
try { \
(static_cast<void>(__VA_ARGS__)); \
} catch (...) { \
m_f.type = ::rapid_cxx_test::failure_type::assert; \
} \
::rapid_cxx_test::get_reporter().report(m_f); \
if (m_f.type != ::rapid_cxx_test::failure_type::none) { \
std::abort(); \
} \
} while (false)
#
# define TEST_ASSERT_THROW(Except, ...) \
do { \
TEST_SET_CHECKPOINT(); \
::rapid_cxx_test::test_outcome m_f( \
::rapid_cxx_test::failure_type::none, __FILE__, TEST_FUNC_NAME(), __LINE__ \
, "TEST_ASSERT_THROW(" #Except "," #__VA_ARGS__ ")", "" \
); \
try { \
(static_cast<void>(__VA_ARGS__)); \
m_f.type = ::rapid_cxx_test::failure_type::assert; \
} catch (Except const &) {} \
::rapid_cxx_test::get_reporter().report(m_f); \
if (m_f.type != ::rapid_cxx_test::failure_type::none) { \
std::abort(); \
} \
} while (false)
#
#else // TEST_HAS_NO_EXCEPTIONS
# define TEST_ASSERT_NO_THROW(...) \
do { \
TEST_SET_CHECKPOINT(); \
::rapid_cxx_test::test_outcome m_f( \
::rapid_cxx_test::failure_type::none, __FILE__, TEST_FUNC_NAME(), __LINE__ \
, "TEST_ASSERT_NO_THROW(" #__VA_ARGS__ ")", "" \
); \
(static_cast<void>(__VA_ARGS__)); \
::rapid_cxx_test::get_reporter().report(m_f); \
} while (false)
#
#define TEST_ASSERT_THROW(Except, ...) ((void)0)
#endif // TEST_HAS_NO_EXCEPTIONS
////////////////////////////////////////////////////////////////////////////////
//
////////////////////////////////////////////////////////////////////////////////
# define TEST_WARN_EQUAL_COLLECTIONS(...) \
do { \
TEST_SET_CHECKPOINT(); \
::rapid_cxx_test::test_outcome m_f( \
::rapid_cxx_test::failure_type::none, __FILE__, TEST_FUNC_NAME(), __LINE__ \
, "TEST_WARN_EQUAL_COLLECTIONS(" #__VA_ARGS__ ")", "" \
); \
if (not ::rapid_cxx_test::detail::check_equal_collections_impl(__VA_ARGS__)) { \
m_f.type = ::rapid_cxx_test::failure_type::warn; \
} \
::rapid_cxx_test::get_reporter().report(m_f); \
} while (false)
#
# define TEST_CHECK_EQUAL_COLLECTIONS(...) \
do { \
TEST_SET_CHECKPOINT(); \
::rapid_cxx_test::test_outcome m_f( \
::rapid_cxx_test::failure_type::none, __FILE__, TEST_FUNC_NAME(), __LINE__ \
, "TEST_CHECK_EQUAL_COLLECTIONS(" #__VA_ARGS__ ")", "" \
); \
if (not ::rapid_cxx_test::detail::check_equal_collections_impl(__VA_ARGS__)) { \
m_f.type = ::rapid_cxx_test::failure_type::check; \
} \
::rapid_cxx_test::get_reporter().report(m_f); \
} while (false)
#
# define TEST_REQUIRE_EQUAL_COLLECTIONS(...) \
do { \
TEST_SET_CHECKPOINT(); \
::rapid_cxx_test::test_outcome m_f( \
::rapid_cxx_test::failure_type::none, __FILE__, TEST_FUNC_NAME(), __LINE__ \
, "TEST_REQUIRE_EQUAL_COLLECTIONS(" #__VA_ARGS__ ")", "" \
); \
if (not ::rapid_cxx_test::detail::check_equal_collections_impl(__VA_ARGS__)) { \
m_f.type = ::rapid_cxx_test::failure_type::require; \
} \
::rapid_cxx_test::get_reporter().report(m_f); \
if (m_f.type != ::rapid_cxx_test::failure_type::none) { \
return; \
} \
} while (false)
#
# define TEST_ASSERT_EQUAL_COLLECTIONS(...) \
do { \
TEST_SET_CHECKPOINT(); \
::rapid_cxx_test::test_outcome m_f( \
::rapid_cxx_test::failure_type::none, __FILE__, TEST_FUNC_NAME(), __LINE__ \
, "TEST_ASSERT_EQUAL_COLLECTIONS(" #__VA_ARGS__ ")", "" \
); \
if (not ::rapid_cxx_test::detail::check_equal_collections_impl(__VA_ARGS__)) { \
m_f.type = ::rapid_cxx_test::failure_type::assert; \
} \
::rapid_cxx_test::get_reporter().report(m_f); \
if (m_f.type != ::rapid_cxx_test::failure_type::none) { \
::std::abort(); \
} \
} while (false)
#
namespace rapid_cxx_test
{
typedef void (*invoker_t)();
////////////////////////////////////////////////////////////////////////////
struct test_case
{
test_case()
: file(""), func(""), line(0), invoke(NULL)
{}
test_case(const char* file1, const char* func1, std::size_t line1,
invoker_t invoke1)
: file(file1), func(func1), line(line1), invoke(invoke1)
{}
const char *file;
const char *func;
std::size_t line;
invoker_t invoke;
};
////////////////////////////////////////////////////////////////////////////
struct failure_type
{
enum enum_type {
none,
unsupported,
warn,
check,
require,
assert,
uncaught_exception
};
};
typedef failure_type::enum_type failure_type_t;
////////////////////////////////////////////////////////////////////////////
struct test_outcome
{
test_outcome()
: type(failure_type::none),
file(""), func(""), line(0),
expression(""), message("")
{}
test_outcome(failure_type_t type1, const char* file1, const char* func1,
std::size_t line1, const char* expression1,
const char* message1)
: type(type1), file(file1), func(func1), line(line1),
expression(expression1), message(message1)
{
trim_func_string();
}
failure_type_t type;
const char *file;
const char *func;
std::size_t line;
const char *expression;
const char *message;
private:
void trim_file_string() {
const char* f_start = file;
const char* prev_start = f_start;
const char* last_start = f_start;
char last;
while ((last = *f_start) != '\0') {
++f_start;
if (last == '/' && *f_start) {
prev_start = last_start;
last_start = f_start;
}
}
file = prev_start;
}
void trim_func_string() {
const char* void_loc = ::strstr(func, "void ");
if (void_loc == func) {
func += strlen("void ");
}
const char* namespace_loc = ::strstr(func, "::");
if (namespace_loc) {
func = namespace_loc + 2;
}
}
};
////////////////////////////////////////////////////////////////////////////
struct checkpoint
{
const char *file;
const char *func;
std::size_t line;
};
namespace detail
{
inline checkpoint & global_checkpoint()
{
static checkpoint cp = {"", "", 0};
return cp;
}
}
////////////////////////////////////////////////////////////////////////////
inline void set_checkpoint(const char* file, const char* func, std::size_t line)
{
checkpoint& cp = detail::global_checkpoint();
cp.file = file;
cp.func = func;
cp.line = line;
}
////////////////////////////////////////////////////////////////////////////
inline checkpoint const & get_checkpoint()
{
return detail::global_checkpoint();
}
////////////////////////////////////////////////////////////////////////////
class test_suite
{
public:
typedef test_case const* iterator;
typedef iterator const_iterator;
public:
test_suite(const char *xname)
: m_name(xname), m_tests(), m_size(0)
{
assert(xname);
}
public:
const char *name() const { return m_name; }
std::size_t size() const { return m_size; }
test_case const & operator[](std::size_t i) const
{
assert(i < m_size);
return m_tests[i];
}
const_iterator begin() const
{ return m_tests; }
const_iterator end() const
{
return m_tests + m_size;
}
public:
std::size_t register_test(test_case tc)
{
static std::size_t test_case_max = sizeof(m_tests) / sizeof(test_case);
assert(m_size < test_case_max);
m_tests[m_size] = tc;
return m_size++;
}
private:
test_suite(test_suite const &);
test_suite & operator=(test_suite const &);
private:
const char* m_name;
// Since fast compile times in a priority, we use simple containers
// with hard limits.
test_case m_tests[256];
std::size_t m_size;
};
////////////////////////////////////////////////////////////////////////////
class registrar
{
public:
registrar(test_suite & st, test_case tc)
{
st.register_test(tc);
}
};
////////////////////////////////////////////////////////////////////////////
class test_reporter
{
public:
test_reporter()
: m_testcases(0), m_testcase_failures(0), m_unsupported(0),
m_assertions(0), m_warning_failures(0), m_check_failures(0),
m_require_failures(0), m_uncaught_exceptions(0), m_failure()
{
}
void test_case_begin()
{
++m_testcases;
clear_failure();
}
void test_case_end()
{
if (m_failure.type != failure_type::none
&& m_failure.type != failure_type::unsupported) {
++m_testcase_failures;
}
}
# if defined(__GNUC__)
# pragma GCC diagnostic push
# pragma GCC diagnostic ignored "-Wswitch-default"
# endif
// Each assertion and failure is reported through this function.
void report(test_outcome o)
{
++m_assertions;
switch (o.type)
{
case failure_type::none:
break;
case failure_type::unsupported:
++m_unsupported;
m_failure = o;
break;
case failure_type::warn:
++m_warning_failures;
report_error(o);
break;
case failure_type::check:
++m_check_failures;
report_error(o);
m_failure = o;
break;
case failure_type::require:
++m_require_failures;
report_error(o);
m_failure = o;
break;
case failure_type::assert:
report_error(o);
break;
case failure_type::uncaught_exception:
++m_uncaught_exceptions;
std::fprintf(stderr
, "Test case FAILED with uncaught exception:\n"
" last checkpoint near %s::%lu %s\n\n"
, o.file, o.line, o.func
);
m_failure = o;
break;
}
}
# if defined(__GNUC__)
# pragma GCC diagnostic pop
# endif
test_outcome current_failure() const
{
return m_failure;
}
void clear_failure()
{
m_failure.type = failure_type::none;
m_failure.file = "";
m_failure.func = "";
m_failure.line = 0;
m_failure.expression = "";
m_failure.message = "";
}
std::size_t test_case_count() const
{ return m_testcases; }
std::size_t test_case_failure_count() const
{ return m_testcase_failures; }
std::size_t unsupported_count() const
{ return m_unsupported; }
std::size_t assertion_count() const
{ return m_assertions; }
std::size_t warning_failure_count() const
{ return m_warning_failures; }
std::size_t check_failure_count() const
{ return m_check_failures; }
std::size_t require_failure_count() const
{ return m_require_failures; }
std::size_t failure_count() const
{ return m_check_failures + m_require_failures + m_uncaught_exceptions; }
// Print a summary of what was run and the outcome.
void print_summary(const char* suitename) const
{
FILE* out = failure_count() ? stderr : stdout;
std::size_t testcases_run = m_testcases - m_unsupported;
std::fprintf(out, "Summary for testsuite %s:\n", suitename);
std::fprintf(out, " %lu of %lu test cases passed.\n", testcases_run - m_testcase_failures, testcases_run);
std::fprintf(out, " %lu of %lu assertions passed.\n", m_assertions - (m_warning_failures + m_check_failures + m_require_failures), m_assertions);
std::fprintf(out, " %lu unsupported test case%s.\n", m_unsupported, (m_unsupported != 1 ? "s" : ""));
}
private:
test_reporter(test_reporter const &);
test_reporter const & operator=(test_reporter const &);
void report_error(test_outcome o) const
{
std::fprintf(stderr, "In %s:%lu Assertion %s failed.\n in file: %s\n %s\n"
, o.func, o.line, o.expression, o.file, o.message ? o.message : ""
);
}
private:
// counts of testcases, failed testcases, and unsupported testcases.
std::size_t m_testcases;
std::size_t m_testcase_failures;
std::size_t m_unsupported;
// counts of assertions and assertion failures.
std::size_t m_assertions;
std::size_t m_warning_failures;
std::size_t m_check_failures;
std::size_t m_require_failures;
std::size_t m_uncaught_exceptions;
// The last failure. This is cleared between testcases.
test_outcome m_failure;
};
////////////////////////////////////////////////////////////////////////////
inline test_reporter & get_reporter()
{
static test_reporter o;
return o;
}
////////////////////////////////////////////////////////////////////////////
class test_runner
{
public:
test_runner(test_suite & ts)
: m_ts(ts)
{}
public:
int run()
{
// for each testcase
for (test_suite::const_iterator b = m_ts.begin(), e = m_ts.end();
b != e; ++b)
{
test_case const& tc = *b;
set_checkpoint(tc.file, tc.func, tc.line);
get_reporter().test_case_begin();
#ifndef TEST_HAS_NO_EXCEPTIONS
try {
#endif
tc.invoke();
#ifndef TEST_HAS_NO_EXCEPTIONS
} catch (...) {
test_outcome o;
o.type = failure_type::uncaught_exception;
o.file = get_checkpoint().file;
o.func = get_checkpoint().func;
o.line = get_checkpoint().line;
o.expression = "";
o.message = "";
get_reporter().report(o);
}
#endif
get_reporter().test_case_end();
}
auto exit_code = get_reporter().failure_count() ? EXIT_FAILURE : EXIT_SUCCESS;
if (exit_code == EXIT_FAILURE || get_reporter().unsupported_count())
get_reporter().print_summary(m_ts.name());
return exit_code;
}
private:
test_runner(test_runner const &);
test_runner operator=(test_runner const &);
test_suite & m_ts;
};
namespace detail
{
template <class Iter1, class Iter2>
bool check_equal_collections_impl(
Iter1 start1, Iter1 const end1
, Iter2 start2, Iter2 const end2
)
{
while (start1 != end1 && start2 != end2) {
if (*start1 != *start2) {
return false;
}
++start1; ++start2;
}
return (start1 == end1 && start2 == end2);
}
} // namespace detail
} // namespace rapid_cxx_test
# if defined(__GNUC__)
# pragma GCC diagnostic pop
# endif
#endif /* RAPID_CXX_TEST_H */

libcxx/trunk/test/support/rapid-cxx-test.hpp

#ifndef RAPID_CXX_TEST_HPP
#define RAPID_CXX_TEST_HPP
# include <cstddef>
# include <cstdlib>
# include <cstdio>
# include <cstring>
# include <cassert>
#include "test_macros.h"
#if !defined(RAPID_CXX_TEST_NO_SYSTEM_HEADER) || !defined(__GNUC__)
#pragma GCC system_header
#endif
# define RAPID_CXX_TEST_PP_CAT(x, y) RAPID_CXX_TEST_PP_CAT_2(x, y)
# define RAPID_CXX_TEST_PP_CAT_2(x, y) x##y
# define RAPID_CXX_TEST_PP_STR(...) RAPID_CXX_TEST_PP_STR_2(__VA_ARGS__)
# define RAPID_CXX_TEST_PP_STR_2(...) #__VA_ARGS__
# if defined(__GNUC__)
# define TEST_FUNC_NAME() __PRETTY_FUNCTION__
# define RAPID_CXX_TEST_UNUSED __attribute__((unused))
# else
# define TEST_FUNC_NAME() __func__
# define RAPID_CXX_TEST_UNUSED
# endif
////////////////////////////////////////////////////////////////////////////////
// TEST_SUITE
////////////////////////////////////////////////////////////////////////////////
# define TEST_SUITE(Name) \
namespace Name \
{ \
inline ::rapid_cxx_test::test_suite & get_test_suite() \
{ \
static ::rapid_cxx_test::test_suite m_suite(#Name); \
return m_suite; \
} \
\
inline int unit_test_main(int, char**) \
{ \
::rapid_cxx_test::test_runner runner(get_test_suite()); \
return runner.run(); \
} \
} \
int main(int argc, char **argv) \
{ \
return Name::unit_test_main(argc, argv); \
} \
namespace Name \
{ /* namespace closed in TEST_SUITE_END */
#
////////////////////////////////////////////////////////////////////////////////
// TEST_SUITE_END
////////////////////////////////////////////////////////////////////////////////
# define TEST_SUITE_END() \
} /* namespace opened in TEST_SUITE(...) */
#
////////////////////////////////////////////////////////////////////////////////
// TEST_CASE
////////////////////////////////////////////////////////////////////////////////
# if !defined(__clang__)
#
# define TEST_CASE(Name) \
void Name(); \
static void RAPID_CXX_TEST_PP_CAT(Name, _invoker)() \
{ \
Name(); \
} \
static ::rapid_cxx_test::registrar \
RAPID_CXX_TEST_PP_CAT(rapid_cxx_test_registrar_, Name)( \
get_test_suite() \
, ::rapid_cxx_test::test_case(__FILE__, #Name, __LINE__, & RAPID_CXX_TEST_PP_CAT(Name, _invoker)) \
); \
void Name()
#
# else /* __clang__ */
#
# define TEST_CASE(Name) \
void Name(); \
static void RAPID_CXX_TEST_PP_CAT(Name, _invoker)() \
{ \
Name(); \
} \
_Pragma("clang diagnostic push") \
_Pragma("clang diagnostic ignored \"-Wglobal-constructors\"") \
static ::rapid_cxx_test::registrar \
RAPID_CXX_TEST_PP_CAT(rapid_cxx_test_registrar_, Name)( \
get_test_suite() \
, ::rapid_cxx_test::test_case(__FILE__, #Name, __LINE__, & RAPID_CXX_TEST_PP_CAT(Name, _invoker)) \
); \
_Pragma("clang diagnostic pop") \
void Name()
#
# endif /* !defined(__clang__) */
# define TEST_SET_CHECKPOINT() ::rapid_cxx_test::set_checkpoint(__FILE__, TEST_FUNC_NAME(), __LINE__)
#define RAPID_CXX_TEST_OUTCOME()
////////////////////////////////////////////////////////////////////////////////
// TEST_UNSUPPORTED
////////////////////////////////////////////////////////////////////////////////
# define TEST_UNSUPPORTED() \
do { \
TEST_SET_CHECKPOINT(); \
::rapid_cxx_test::test_outcome m_f( \
::rapid_cxx_test::failure_type::unsupported, __FILE__, TEST_FUNC_NAME(), __LINE__ \
, "", "" \
); \
::rapid_cxx_test::get_reporter().report(m_f); \
return; \
} while (false)
#
////////////////////////////////////////////////////////////////////////////////
// BASIC ASSERTIONS
////////////////////////////////////////////////////////////////////////////////
# define TEST_WARN(...) \
do { \
TEST_SET_CHECKPOINT(); \
::rapid_cxx_test::test_outcome m_f( \
::rapid_cxx_test::failure_type::none, __FILE__, TEST_FUNC_NAME(), __LINE__ \
, "TEST_WARN(" #__VA_ARGS__ ")", "" \
); \
if (not (__VA_ARGS__)) { \
m_f.type = ::rapid_cxx_test::failure_type::warn; \
} \
::rapid_cxx_test::get_reporter().report(m_f); \
} while (false)
#
# define TEST_CHECK(...) \
do { \
TEST_SET_CHECKPOINT(); \
::rapid_cxx_test::test_outcome m_f( \
::rapid_cxx_test::failure_type::none, __FILE__, TEST_FUNC_NAME(), __LINE__ \
, "TEST_CHECK(" #__VA_ARGS__ ")", "" \
); \
if (not (__VA_ARGS__)) { \
m_f.type = ::rapid_cxx_test::failure_type::check; \
} \
::rapid_cxx_test::get_reporter().report(m_f); \
} while (false)
#
# define TEST_REQUIRE(...) \
do { \
TEST_SET_CHECKPOINT(); \
::rapid_cxx_test::test_outcome m_f( \
::rapid_cxx_test::failure_type::none, __FILE__, TEST_FUNC_NAME(), __LINE__ \
, "TEST_REQUIRE(" #__VA_ARGS__ ")", "" \
); \
if (not (__VA_ARGS__)) { \
m_f.type = ::rapid_cxx_test::failure_type::require; \
} \
::rapid_cxx_test::get_reporter().report(m_f); \
if (m_f.type != ::rapid_cxx_test::failure_type::none) { \
return; \
} \
} while (false)
#
# define TEST_ASSERT(...) \
do { \
TEST_SET_CHECKPOINT(); \
::rapid_cxx_test::test_outcome m_f( \
::rapid_cxx_test::failure_type::none, __FILE__, TEST_FUNC_NAME(), __LINE__ \
, "TEST_ASSERT(" #__VA_ARGS__ ")", "" \
); \
if (not (__VA_ARGS__)) { \
m_f.type = ::rapid_cxx_test::failure_type::assert; \
} \
::rapid_cxx_test::get_reporter().report(m_f); \
if (m_f.type != ::rapid_cxx_test::failure_type::none) { \
std::abort(); \
} \
} while (false)
#
////////////////////////////////////////////////////////////////////////////////
// TEST_CHECK_NO_THROW / TEST_CHECK_THROW
////////////////////////////////////////////////////////////////////////////////
#ifndef TEST_HAS_NO_EXCEPTIONS
# define TEST_CHECK_NO_THROW(...) \
do { \
TEST_SET_CHECKPOINT(); \
::rapid_cxx_test::test_outcome m_f( \
::rapid_cxx_test::failure_type::none, __FILE__, TEST_FUNC_NAME(), __LINE__ \
, "TEST_CHECK_NO_THROW(" #__VA_ARGS__ ")", "" \
); \
try { \
(static_cast<void>(__VA_ARGS__)); \
} catch (...) { \
m_f.type = ::rapid_cxx_test::failure_type::check; \
} \
::rapid_cxx_test::get_reporter().report(m_f); \
} while (false)
#
# define TEST_CHECK_THROW(Except, ...) \
do { \
TEST_SET_CHECKPOINT(); \
::rapid_cxx_test::test_outcome m_f( \
::rapid_cxx_test::failure_type::none, __FILE__, TEST_FUNC_NAME(), __LINE__ \
, "TEST_CHECK_THROW(" #Except "," #__VA_ARGS__ ")", "" \
); \
try { \
(static_cast<void>(__VA_ARGS__)); \
m_f.type = ::rapid_cxx_test::failure_type::check; \
} catch (Except const &) {} \
::rapid_cxx_test::get_reporter().report(m_f); \
} while (false)
#
#define TEST_CHECK_THROW_RESULT(Except, Checker, ...) \
do { \
TEST_SET_CHECKPOINT(); \
::rapid_cxx_test::test_outcome m_f(::rapid_cxx_test::failure_type::none, \
__FILE__, TEST_FUNC_NAME(), __LINE__, \
"TEST_CHECK_THROW_RESULT(" #Except \
"," #Checker "," #__VA_ARGS__ ")", \
""); \
try { \
(static_cast<void>(__VA_ARGS__)); \
m_f.type = ::rapid_cxx_test::failure_type::check; \
} catch (Except const& Caught) { \
Checker(Caught); \
} \
::rapid_cxx_test::get_reporter().report(m_f); \
} while (false)
#
#else // TEST_HAS_NO_EXCEPTIONS
# define TEST_CHECK_NO_THROW(...) \
do { \
TEST_SET_CHECKPOINT(); \
::rapid_cxx_test::test_outcome m_f( \
::rapid_cxx_test::failure_type::none, __FILE__, TEST_FUNC_NAME(), __LINE__ \
, "TEST_CHECK_NO_THROW(" #__VA_ARGS__ ")", "" \
); \
(static_cast<void>(__VA_ARGS__)); \
::rapid_cxx_test::get_reporter().report(m_f); \
} while (false)
#
#define TEST_CHECK_THROW(Except, ...) ((void)0)
#define TEST_CHECK_THROW_RESULT(Except, Checker, ...) ((void)0)
#endif // TEST_HAS_NO_EXCEPTIONS
////////////////////////////////////////////////////////////////////////////////
// TEST_REQUIRE_NO_THROW / TEST_REQUIRE_THROWs
////////////////////////////////////////////////////////////////////////////////
#ifndef TEST_HAS_NO_EXCEPTIONS
# define TEST_REQUIRE_NO_THROW(...) \
do { \
TEST_SET_CHECKPOINT(); \
::rapid_cxx_test::test_outcome m_f( \
::rapid_cxx_test::failure_type::none, __FILE__, TEST_FUNC_NAME(), __LINE__ \
, "TEST_REQUIRE_NO_THROW(" #__VA_ARGS__ ")", "" \
); \
try { \
(static_cast<void>(__VA_ARGS__)); \
} catch (...) { \
m_f.type = ::rapid_cxx_test::failure_type::require; \
} \
::rapid_cxx_test::get_reporter().report(m_f); \
if (m_f.type != ::rapid_cxx_test::failure_type::none) { \
return; \
} \
} while (false)
#
# define TEST_REQUIRE_THROW(Except, ...) \
do { \
TEST_SET_CHECKPOINT(); \
::rapid_cxx_test::test_outcome m_f( \
::rapid_cxx_test::failure_type::none, __FILE__, TEST_FUNC_NAME(), __LINE__ \
, "TEST_REQUIRE_THROW(" #Except "," #__VA_ARGS__ ")", "" \
); \
try { \
(static_cast<void>(__VA_ARGS__)); \
m_f.type = ::rapid_cxx_test::failure_type::require; \
} catch (Except const &) {} \
::rapid_cxx_test::get_reporter().report(m_f); \
if (m_f.type != ::rapid_cxx_test::failure_type::none) { \
return; \
} \
} while (false)
#
#else // TEST_HAS_NO_EXCEPTIONS
# define TEST_REQUIRE_NO_THROW(...) \
do { \
TEST_SET_CHECKPOINT(); \
::rapid_cxx_test::test_outcome m_f( \
::rapid_cxx_test::failure_type::none, __FILE__, TEST_FUNC_NAME(), __LINE__ \
, "TEST_REQUIRE_NO_THROW(" #__VA_ARGS__ ")", "" \
); \
(static_cast<void>(__VA_ARGS__)); \
::rapid_cxx_test::get_reporter().report(m_f); \
} while (false)
#
#define TEST_REQUIRE_THROW(Except, ...) ((void)0)
#endif // TEST_HAS_NO_EXCEPTIONS
////////////////////////////////////////////////////////////////////////////////
// TEST_ASSERT_NO_THROW / TEST_ASSERT_THROW
////////////////////////////////////////////////////////////////////////////////
#ifndef TEST_HAS_NO_EXCEPTIONS
# define TEST_ASSERT_NO_THROW(...) \
do { \
TEST_SET_CHECKPOINT(); \
::rapid_cxx_test::test_outcome m_f( \
::rapid_cxx_test::failure_type::none, __FILE__, TEST_FUNC_NAME(), __LINE__ \
, "TEST_ASSERT_NO_THROW(" #__VA_ARGS__ ")", "" \
); \
try { \
(static_cast<void>(__VA_ARGS__)); \
} catch (...) { \
m_f.type = ::rapid_cxx_test::failure_type::assert; \
} \
::rapid_cxx_test::get_reporter().report(m_f); \
if (m_f.type != ::rapid_cxx_test::failure_type::none) { \
std::abort(); \
} \
} while (false)
#
# define TEST_ASSERT_THROW(Except, ...) \
do { \
TEST_SET_CHECKPOINT(); \
::rapid_cxx_test::test_outcome m_f( \
::rapid_cxx_test::failure_type::none, __FILE__, TEST_FUNC_NAME(), __LINE__ \
, "TEST_ASSERT_THROW(" #Except "," #__VA_ARGS__ ")", "" \
); \
try { \
(static_cast<void>(__VA_ARGS__)); \
m_f.type = ::rapid_cxx_test::failure_type::assert; \
} catch (Except const &) {} \
::rapid_cxx_test::get_reporter().report(m_f); \
if (m_f.type != ::rapid_cxx_test::failure_type::none) { \
std::abort(); \
} \
} while (false)
#
#else // TEST_HAS_NO_EXCEPTIONS
# define TEST_ASSERT_NO_THROW(...) \
do { \
TEST_SET_CHECKPOINT(); \
::rapid_cxx_test::test_outcome m_f( \
::rapid_cxx_test::failure_type::none, __FILE__, TEST_FUNC_NAME(), __LINE__ \
, "TEST_ASSERT_NO_THROW(" #__VA_ARGS__ ")", "" \
); \
(static_cast<void>(__VA_ARGS__)); \
::rapid_cxx_test::get_reporter().report(m_f); \
} while (false)
#
#define TEST_ASSERT_THROW(Except, ...) ((void)0)
#endif // TEST_HAS_NO_EXCEPTIONS
////////////////////////////////////////////////////////////////////////////////
//
////////////////////////////////////////////////////////////////////////////////
# define TEST_WARN_EQUAL_COLLECTIONS(...) \
do { \
TEST_SET_CHECKPOINT(); \
::rapid_cxx_test::test_outcome m_f( \
::rapid_cxx_test::failure_type::none, __FILE__, TEST_FUNC_NAME(), __LINE__ \
, "TEST_WARN_EQUAL_COLLECTIONS(" #__VA_ARGS__ ")", "" \
); \
if (not ::rapid_cxx_test::detail::check_equal_collections_impl(__VA_ARGS__)) { \
m_f.type = ::rapid_cxx_test::failure_type::warn; \
} \
::rapid_cxx_test::get_reporter().report(m_f); \
} while (false)
#
# define TEST_CHECK_EQUAL_COLLECTIONS(...) \
do { \
TEST_SET_CHECKPOINT(); \
::rapid_cxx_test::test_outcome m_f( \
::rapid_cxx_test::failure_type::none, __FILE__, TEST_FUNC_NAME(), __LINE__ \
, "TEST_CHECK_EQUAL_COLLECTIONS(" #__VA_ARGS__ ")", "" \
); \
if (not ::rapid_cxx_test::detail::check_equal_collections_impl(__VA_ARGS__)) { \
m_f.type = ::rapid_cxx_test::failure_type::check; \
} \
::rapid_cxx_test::get_reporter().report(m_f); \
} while (false)
#
# define TEST_REQUIRE_EQUAL_COLLECTIONS(...) \
do { \
TEST_SET_CHECKPOINT(); \
::rapid_cxx_test::test_outcome m_f( \
::rapid_cxx_test::failure_type::none, __FILE__, TEST_FUNC_NAME(), __LINE__ \
, "TEST_REQUIRE_EQUAL_COLLECTIONS(" #__VA_ARGS__ ")", "" \
); \
if (not ::rapid_cxx_test::detail::check_equal_collections_impl(__VA_ARGS__)) { \
m_f.type = ::rapid_cxx_test::failure_type::require; \
} \
::rapid_cxx_test::get_reporter().report(m_f); \
if (m_f.type != ::rapid_cxx_test::failure_type::none) { \
return; \
} \
} while (false)
#
# define TEST_ASSERT_EQUAL_COLLECTIONS(...) \
do { \
TEST_SET_CHECKPOINT(); \
::rapid_cxx_test::test_outcome m_f( \
::rapid_cxx_test::failure_type::none, __FILE__, TEST_FUNC_NAME(), __LINE__ \
, "TEST_ASSERT_EQUAL_COLLECTIONS(" #__VA_ARGS__ ")", "" \
); \
if (not ::rapid_cxx_test::detail::check_equal_collections_impl(__VA_ARGS__)) { \
m_f.type = ::rapid_cxx_test::failure_type::assert; \
} \
::rapid_cxx_test::get_reporter().report(m_f); \
if (m_f.type != ::rapid_cxx_test::failure_type::none) { \
::std::abort(); \
} \
} while (false)
#
namespace rapid_cxx_test
{
typedef void (*invoker_t)();
////////////////////////////////////////////////////////////////////////////
struct test_case
{
test_case()
: file(""), func(""), line(0), invoke(NULL)
{}
test_case(const char* file1, const char* func1, std::size_t line1,
invoker_t invoke1)
: file(file1), func(func1), line(line1), invoke(invoke1)
{}
const char *file;
const char *func;
std::size_t line;
invoker_t invoke;
};
////////////////////////////////////////////////////////////////////////////
struct failure_type
{
enum enum_type {
none,
unsupported,
warn,
check,
require,
assert,
uncaught_exception
};
};
typedef failure_type::enum_type failure_type_t;
////////////////////////////////////////////////////////////////////////////
struct test_outcome
{
test_outcome()
: type(failure_type::none),
file(""), func(""), line(0),
expression(""), message("")
{}
test_outcome(failure_type_t type1, const char* file1, const char* func1,
std::size_t line1, const char* expression1,
const char* message1)
: type(type1), file(file1), func(func1), line(line1),
expression(expression1), message(message1)
{
trim_func_string();
}
failure_type_t type;
const char *file;
const char *func;
std::size_t line;
const char *expression;
const char *message;
private:
void trim_file_string() {
const char* f_start = file;
const char* prev_start = f_start;
const char* last_start = f_start;
char last;
while ((last = *f_start) != '\0') {
++f_start;
if (last == '/' && *f_start) {
prev_start = last_start;
last_start = f_start;
}
}
file = prev_start;
}
void trim_func_string() {
const char* void_loc = ::strstr(func, "void ");
if (void_loc == func) {
func += strlen("void ");
}
const char* namespace_loc = ::strstr(func, "::");
if (namespace_loc) {
func = namespace_loc + 2;
}
}
};
////////////////////////////////////////////////////////////////////////////
struct checkpoint
{
const char *file;
const char *func;
std::size_t line;
};
namespace detail
{
inline checkpoint & global_checkpoint()
{
static checkpoint cp = {"", "", 0};
return cp;
}
}
////////////////////////////////////////////////////////////////////////////
inline void set_checkpoint(const char* file, const char* func, std::size_t line)
{
checkpoint& cp = detail::global_checkpoint();
cp.file = file;
cp.func = func;
cp.line = line;
}
////////////////////////////////////////////////////////////////////////////
inline checkpoint const & get_checkpoint()
{
return detail::global_checkpoint();
}
////////////////////////////////////////////////////////////////////////////
class test_suite
{
public:
typedef test_case const* iterator;
typedef iterator const_iterator;
public:
test_suite(const char *xname)
: m_name(xname), m_tests(), m_size(0)
{
assert(xname);
}
public:
const char *name() const { return m_name; }
std::size_t size() const { return m_size; }
test_case const & operator[](std::size_t i) const
{
assert(i < m_size);
return m_tests[i];
}
const_iterator begin() const
{ return m_tests; }
const_iterator end() const
{
return m_tests + m_size;
}
public:
std::size_t register_test(test_case tc)
{
static std::size_t test_case_max = sizeof(m_tests) / sizeof(test_case);
assert(m_size < test_case_max);
m_tests[m_size] = tc;
return m_size++;
}
private:
test_suite(test_suite const &);
test_suite & operator=(test_suite const &);
private:
const char* m_name;
// Since fast compile times in a priority, we use simple containers
// with hard limits.
test_case m_tests[256];
std::size_t m_size;
};
////////////////////////////////////////////////////////////////////////////
class registrar
{
public:
registrar(test_suite & st, test_case tc)
{
st.register_test(tc);
}
};
////////////////////////////////////////////////////////////////////////////
class test_reporter
{
public:
test_reporter()
: m_testcases(0), m_testcase_failures(0), m_unsupported(0),
m_assertions(0), m_warning_failures(0), m_check_failures(0),
m_require_failures(0), m_uncaught_exceptions(0), m_failure()
{
}
void test_case_begin()
{
++m_testcases;
clear_failure();
}
void test_case_end()
{
if (m_failure.type != failure_type::none
&& m_failure.type != failure_type::unsupported) {
++m_testcase_failures;
}
}
# if defined(__GNUC__)
# pragma GCC diagnostic push
# pragma GCC diagnostic ignored "-Wswitch-default"
# endif
// Each assertion and failure is reported through this function.
void report(test_outcome o)
{
++m_assertions;
switch (o.type)
{
case failure_type::none:
break;
case failure_type::unsupported:
++m_unsupported;
m_failure = o;
break;
case failure_type::warn:
++m_warning_failures;
report_error(o);
break;
case failure_type::check:
++m_check_failures;
report_error(o);
m_failure = o;
break;
case failure_type::require:
++m_require_failures;
report_error(o);
m_failure = o;
break;
case failure_type::assert:
report_error(o);
break;
case failure_type::uncaught_exception:
++m_uncaught_exceptions;
std::fprintf(stderr
, "Test case FAILED with uncaught exception:\n"
" last checkpoint near %s::%lu %s\n\n"
, o.file, o.line, o.func
);
m_failure = o;
break;
}
}
# if defined(__GNUC__)
# pragma GCC diagnostic pop
# endif
test_outcome current_failure() const
{
return m_failure;
}
void clear_failure()
{
m_failure.type = failure_type::none;
m_failure.file = "";
m_failure.func = "";
m_failure.line = 0;
m_failure.expression = "";
m_failure.message = "";
}
std::size_t test_case_count() const
{ return m_testcases; }
std::size_t test_case_failure_count() const
{ return m_testcase_failures; }
std::size_t unsupported_count() const
{ return m_unsupported; }
std::size_t assertion_count() const
{ return m_assertions; }
std::size_t warning_failure_count() const
{ return m_warning_failures; }
std::size_t check_failure_count() const
{ return m_check_failures; }
std::size_t require_failure_count() const
{ return m_require_failures; }
std::size_t failure_count() const
{ return m_check_failures + m_require_failures + m_uncaught_exceptions; }
// Print a summary of what was run and the outcome.
void print_summary(const char* suitename) const
{
FILE* out = failure_count() ? stderr : stdout;
std::size_t testcases_run = m_testcases - m_unsupported;
std::fprintf(out, "Summary for testsuite %s:\n", suitename);
std::fprintf(out, " %lu of %lu test cases passed.\n", testcases_run - m_testcase_failures, testcases_run);
std::fprintf(out, " %lu of %lu assertions passed.\n", m_assertions - (m_warning_failures + m_check_failures + m_require_failures), m_assertions);
std::fprintf(out, " %lu unsupported test case%s.\n", m_unsupported, (m_unsupported != 1 ? "s" : ""));
}
private:
test_reporter(test_reporter const &);
test_reporter const & operator=(test_reporter const &);
void report_error(test_outcome o) const
{
std::fprintf(stderr, "In %s:%lu Assertion %s failed.\n in file: %s\n %s\n"
, o.func, o.line, o.expression, o.file, o.message ? o.message : ""
);
}
private:
// counts of testcases, failed testcases, and unsupported testcases.
std::size_t m_testcases;
std::size_t m_testcase_failures;
std::size_t m_unsupported;
// counts of assertions and assertion failures.
std::size_t m_assertions;
std::size_t m_warning_failures;
std::size_t m_check_failures;
std::size_t m_require_failures;
std::size_t m_uncaught_exceptions;
// The last failure. This is cleared between testcases.
test_outcome m_failure;
};
////////////////////////////////////////////////////////////////////////////
inline test_reporter & get_reporter()
{
static test_reporter o;
return o;
}
////////////////////////////////////////////////////////////////////////////
class test_runner
{
public:
test_runner(test_suite & ts)
: m_ts(ts)
{}
public:
int run()
{
// for each testcase
for (test_suite::const_iterator b = m_ts.begin(), e = m_ts.end();
b != e; ++b)
{
test_case const& tc = *b;
set_checkpoint(tc.file, tc.func, tc.line);
get_reporter().test_case_begin();
#ifndef TEST_HAS_NO_EXCEPTIONS
try {
#endif
tc.invoke();
#ifndef TEST_HAS_NO_EXCEPTIONS
} catch (...) {
test_outcome o;
o.type = failure_type::uncaught_exception;
o.file = get_checkpoint().file;
o.func = get_checkpoint().func;
o.line = get_checkpoint().line;
o.expression = "";
o.message = "";
get_reporter().report(o);
}
#endif
get_reporter().test_case_end();
}
auto exit_code = get_reporter().failure_count() ? EXIT_FAILURE : EXIT_SUCCESS;
if (exit_code == EXIT_FAILURE || get_reporter().unsupported_count())
get_reporter().print_summary(m_ts.name());
return exit_code;
}
private:
test_runner(test_runner const &);
test_runner operator=(test_runner const &);
test_suite & m_ts;
};
namespace detail
{
template <class Iter1, class Iter2>
bool check_equal_collections_impl(
Iter1 start1, Iter1 const end1
, Iter2 start2, Iter2 const end2
)
{
while (start1 != end1 && start2 != end2) {
if (*start1 != *start2) {
return false;
}
++start1; ++start2;
}
return (start1 == end1 && start2 == end2);
}
} // namespace detail
} // namespace rapid_cxx_test
# if defined(__GNUC__)
# pragma GCC diagnostic pop
# endif
#endif /* RAPID_CXX_TEST_HPP */

libcxx/trunk/test/support/test.support/test_convertible_header.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++98, c++03 // UNSUPPORTED: c++98, c++03
// "support/test_convertible.hpp" // "support/test_convertible.h"
#include "test_convertible.hpp" #include "test_convertible.h"
#include "test_macros.h" #include "test_macros.h"
struct ImplicitDefault { struct ImplicitDefault {
ImplicitDefault() {} ImplicitDefault() {}
}; };
static_assert(test_convertible<ImplicitDefault>(), "Must be convertible"); static_assert(test_convertible<ImplicitDefault>(), "Must be convertible");
▲ Show 20 Lines • Show All 50 Lines • Show Last 20 Lines

libcxx/trunk/test/support/test.support/test_poisoned_hash_helper.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++98, c++03 // UNSUPPORTED: c++98, c++03
// Test that the header `poisoned_hash_helper.hpp` doesn't include any // Test that the header `poisoned_hash_helper.h` doesn't include any
// headers that provide hash<T> specializations. This is required so that the // headers that provide hash<T> specializations. This is required so that the
// 'test_library_hash_specializations_available()' function returns false // 'test_library_hash_specializations_available()' function returns false
// by default, unless a STL header providing hash has already been included. // by default, unless a STL header providing hash has already been included.
#include "poisoned_hash_helper.hpp" #include "poisoned_hash_helper.h"
#include "test_macros.h" #include "test_macros.h"
template <class T, size_t = sizeof(T)> template <class T, size_t = sizeof(T)>
constexpr bool is_complete_imp(int) { return true; } constexpr bool is_complete_imp(int) { return true; }
template <class> constexpr bool is_complete_imp(long) { return false; } template <class> constexpr bool is_complete_imp(long) { return false; }
template <class T> constexpr bool is_complete() { return is_complete_imp<T>(0); } template <class T> constexpr bool is_complete() { return is_complete_imp<T>(0); }
Show All 9 Lines

libcxx/trunk/test/support/test_convertible.h

//===----------------------------------------------------------------------===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
#ifndef SUPPORT_TEST_CONVERTIBLE_H
#define SUPPORT_TEST_CONVERTIBLE_H
// "test_convertible<Tp, Args...>()" is a metafunction used to check if 'Tp'
// is implicitly convertible from 'Args...' for any number of arguments,
// Unlike 'std::is_convertible' which only allows checking for single argument
// conversions.
#include <type_traits>
#include "test_macros.h"
#if TEST_STD_VER < 11
#error test_convertible.h requires C++11 or newer
#endif
namespace detail {
template <class Tp> void eat_type(Tp);
template <class Tp, class ...Args>
constexpr auto test_convertible_imp(int)
-> decltype(eat_type<Tp>({std::declval<Args>()...}), true)
{ return true; }
template <class Tp, class ...Args>
constexpr auto test_convertible_imp(long) -> bool { return false; }
}
template <class Tp, class ...Args>
constexpr bool test_convertible()
{ return detail::test_convertible_imp<Tp, Args...>(0); }
#endif // SUPPORT_TEST_CONVERTIBLE_H

libcxx/trunk/test/support/test_convertible.hpp

//===----------------------------------------------------------------------===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
#ifndef SUPPORT_TEST_CONVERTIBLE_HPP
#define SUPPORT_TEST_CONVERTIBLE_HPP
// "test_convertible<Tp, Args...>()" is a metafunction used to check if 'Tp'
// is implicitly convertible from 'Args...' for any number of arguments,
// Unlike 'std::is_convertible' which only allows checking for single argument
// conversions.
#include <type_traits>
#include "test_macros.h"
#if TEST_STD_VER < 11
#error test_convertible.hpp requires C++11 or newer
#endif
namespace detail {
template <class Tp> void eat_type(Tp);
template <class Tp, class ...Args>
constexpr auto test_convertible_imp(int)
-> decltype(eat_type<Tp>({std::declval<Args>()...}), true)
{ return true; }
template <class Tp, class ...Args>
constexpr auto test_convertible_imp(long) -> bool { return false; }
}
template <class Tp, class ...Args>
constexpr bool test_convertible()
{ return detail::test_convertible_imp<Tp, Args...>(0); }
#endif // SUPPORT_TEST_CONVERTIBLE_HPP

libcxx/trunk/test/support/test_memory_resource.h

//===----------------------------------------------------------------------===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
#ifndef SUPPORT_TEST_MEMORY_RESOURCE_H
#define SUPPORT_TEST_MEMORY_RESOURCE_H
#include <experimental/memory_resource>
#include <experimental/utility>
#include <memory>
#include <type_traits>
#include <cstddef>
#include <cstdlib>
#include <cstring>
#include <cstdint>
#include <cassert>
#include "test_macros.h"
#include "controlled_allocators.h"
#include "uses_alloc_types.h"
// FIXME: This is a hack to allow uses_allocator_types.hpp to work with
// erased_type. However we can't define that behavior directly in the header
// because it can't include <experimental/memory_resource>
template <>
struct TransformErasedTypeAlloc<std::experimental::erased_type> {
using type = std::experimental::pmr::polymorphic_allocator<int>;
};
template <class ProviderT, int = 0>
class TestResourceImp : public std::experimental::pmr::memory_resource
{
public:
static int resource_alive;
static int resource_constructed;
static int resource_destructed;
static void resetStatics() {
assert(resource_alive == 0);
resource_alive = 0;
resource_constructed = 0;
resource_destructed = 0;
}
using memory_resource = std::experimental::pmr::memory_resource;
using Provider = ProviderT;
int value;
explicit TestResourceImp(int val = 0) : value(val) {
++resource_alive;
++resource_constructed;
}
~TestResourceImp() noexcept {
--resource_alive;
++resource_destructed;
}
void reset() { C.reset(); P.reset(); }
AllocController& getController() { return C; }
bool checkAlloc(void* p, std::size_t s, std::size_t a) const
{ return C.checkAlloc(p, s, a); }
bool checkDealloc(void* p, std::size_t s, std::size_t a) const
{ return C.checkDealloc(p, s, a); }
bool checkIsEqualCalledEq(int n) const { return C.checkIsEqualCalledEq(n); }
protected:
virtual void * do_allocate(std::size_t s, std::size_t a) {
if (C.throw_on_alloc) {
#ifndef TEST_HAS_NO_EXCEPTIONS
throw TestException{};
#else
assert(false);
#endif
}
void* ret = P.allocate(s, a);
C.countAlloc(ret, s, a);
return ret;
}
virtual void do_deallocate(void * p, std::size_t s, std::size_t a) {
C.countDealloc(p, s, a);
P.deallocate(p, s, a);
}
virtual bool do_is_equal(memory_resource const & other) const noexcept {
C.countIsEqual();
TestResourceImp const * o = dynamic_cast<TestResourceImp const *>(&other);
return o && o->value == value;
}
private:
mutable AllocController C;
mutable Provider P;
DISALLOW_COPY(TestResourceImp);
};
template <class Provider, int N>
int TestResourceImp<Provider, N>::resource_alive = 0;
template <class Provider, int N>
int TestResourceImp<Provider, N>::resource_constructed = 0;
template <class Provider, int N>
int TestResourceImp<Provider, N>::resource_destructed = 0;
struct NullProvider {
NullProvider() {}
void* allocate(size_t, size_t) { return nullptr; }
void deallocate(void*, size_t, size_t) {}
void reset() {}
private:
DISALLOW_COPY(NullProvider);
};
struct NewDeleteProvider {
NewDeleteProvider() {}
void* allocate(size_t s, size_t) { return ::operator new(s); }
void deallocate(void* p, size_t, size_t) { ::operator delete(p); }
void reset() {}
private:
DISALLOW_COPY(NewDeleteProvider);
};
template <size_t Size = 4096 * 10> // 10 pages worth of memory.
struct BufferProvider {
char buffer[Size];
void* next = &buffer;
size_t space = Size;
BufferProvider() {}
void* allocate(size_t s, size_t a) {
void* ret = std::align(s, a, next, space);
if (ret == nullptr) {
#ifndef TEST_HAS_NO_EXCEPTIONS
throw std::bad_alloc();
#else
assert(false);
#endif
}
return ret;
}
void deallocate(void*, size_t, size_t) {}
void reset() {
next = &buffer;
space = Size;
}
private:
DISALLOW_COPY(BufferProvider);
};
using NullResource = TestResourceImp<NullProvider, 0>;
using NewDeleteResource = TestResourceImp<NewDeleteProvider, 0>;
using TestResource = TestResourceImp<BufferProvider<>, 0>;
using TestResource1 = TestResourceImp<BufferProvider<>, 1>;
using TestResource2 = TestResourceImp<BufferProvider<>, 2>;
#endif /* SUPPORT_TEST_MEMORY_RESOURCE_H */

libcxx/trunk/test/support/test_memory_resource.hpp

//===----------------------------------------------------------------------===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
#ifndef SUPPORT_TEST_MEMORY_RESOURCE_HPP
#define SUPPORT_TEST_MEMORY_RESOURCE_HPP
#include <experimental/memory_resource>
#include <experimental/utility>
#include <memory>
#include <type_traits>
#include <cstddef>
#include <cstdlib>
#include <cstring>
#include <cstdint>
#include <cassert>
#include "test_macros.h"
#include "controlled_allocators.hpp"
#include "uses_alloc_types.hpp"
// FIXME: This is a hack to allow uses_allocator_types.hpp to work with
// erased_type. However we can't define that behavior directly in the header
// because it can't include <experimental/memory_resource>
template <>
struct TransformErasedTypeAlloc<std::experimental::erased_type> {
using type = std::experimental::pmr::polymorphic_allocator<int>;
};
template <class ProviderT, int = 0>
class TestResourceImp : public std::experimental::pmr::memory_resource
{
public:
static int resource_alive;
static int resource_constructed;
static int resource_destructed;
static void resetStatics() {
assert(resource_alive == 0);
resource_alive = 0;
resource_constructed = 0;
resource_destructed = 0;
}
using memory_resource = std::experimental::pmr::memory_resource;
using Provider = ProviderT;
int value;
explicit TestResourceImp(int val = 0) : value(val) {
++resource_alive;
++resource_constructed;
}
~TestResourceImp() noexcept {
--resource_alive;
++resource_destructed;
}
void reset() { C.reset(); P.reset(); }
AllocController& getController() { return C; }
bool checkAlloc(void* p, std::size_t s, std::size_t a) const
{ return C.checkAlloc(p, s, a); }
bool checkDealloc(void* p, std::size_t s, std::size_t a) const
{ return C.checkDealloc(p, s, a); }
bool checkIsEqualCalledEq(int n) const { return C.checkIsEqualCalledEq(n); }
protected:
virtual void * do_allocate(std::size_t s, std::size_t a) {
if (C.throw_on_alloc) {
#ifndef TEST_HAS_NO_EXCEPTIONS
throw TestException{};
#else
assert(false);
#endif
}
void* ret = P.allocate(s, a);
C.countAlloc(ret, s, a);
return ret;
}
virtual void do_deallocate(void * p, std::size_t s, std::size_t a) {
C.countDealloc(p, s, a);
P.deallocate(p, s, a);
}
virtual bool do_is_equal(memory_resource const & other) const noexcept {
C.countIsEqual();
TestResourceImp const * o = dynamic_cast<TestResourceImp const *>(&other);
return o && o->value == value;
}
private:
mutable AllocController C;
mutable Provider P;
DISALLOW_COPY(TestResourceImp);
};
template <class Provider, int N>
int TestResourceImp<Provider, N>::resource_alive = 0;
template <class Provider, int N>
int TestResourceImp<Provider, N>::resource_constructed = 0;
template <class Provider, int N>
int TestResourceImp<Provider, N>::resource_destructed = 0;
struct NullProvider {
NullProvider() {}
void* allocate(size_t, size_t) { return nullptr; }
void deallocate(void*, size_t, size_t) {}
void reset() {}
private:
DISALLOW_COPY(NullProvider);
};
struct NewDeleteProvider {
NewDeleteProvider() {}
void* allocate(size_t s, size_t) { return ::operator new(s); }
void deallocate(void* p, size_t, size_t) { ::operator delete(p); }
void reset() {}
private:
DISALLOW_COPY(NewDeleteProvider);
};
template <size_t Size = 4096 * 10> // 10 pages worth of memory.
struct BufferProvider {
char buffer[Size];
void* next = &buffer;
size_t space = Size;
BufferProvider() {}
void* allocate(size_t s, size_t a) {
void* ret = std::align(s, a, next, space);
if (ret == nullptr) {
#ifndef TEST_HAS_NO_EXCEPTIONS
throw std::bad_alloc();
#else
assert(false);
#endif
}
return ret;
}
void deallocate(void*, size_t, size_t) {}
void reset() {
next = &buffer;
space = Size;
}
private:
DISALLOW_COPY(BufferProvider);
};
using NullResource = TestResourceImp<NullProvider, 0>;
using NewDeleteResource = TestResourceImp<NewDeleteProvider, 0>;
using TestResource = TestResourceImp<BufferProvider<>, 0>;
using TestResource1 = TestResourceImp<BufferProvider<>, 1>;
using TestResource2 = TestResourceImp<BufferProvider<>, 2>;
#endif /* SUPPORT_TEST_MEMORY_RESOURCE_HPP */

libcxx/trunk/test/support/user_defined_integral.h

//===----------------------------------------------------------------------===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
#ifndef SUPPORT_USER_DEFINED_INTEGRAL_H
#define SUPPORT_USER_DEFINED_INTEGRAL_H
template <class T>
struct UserDefinedIntegral
{
UserDefinedIntegral() : value(0) {}
UserDefinedIntegral(T v) : value(v) {}
operator T() const { return value; }
T value;
};
// Poison the arithmetic and comparison operations
template <class T, class U>
void operator+(UserDefinedIntegral<T>, UserDefinedIntegral<U>);
template <class T, class U>
void operator-(UserDefinedIntegral<T>, UserDefinedIntegral<U>);
template <class T, class U>
void operator*(UserDefinedIntegral<T>, UserDefinedIntegral<U>);
template <class T, class U>
void operator/(UserDefinedIntegral<T>, UserDefinedIntegral<U>);
template <class T, class U>
void operator==(UserDefinedIntegral<T>, UserDefinedIntegral<U>);
template <class T, class U>
void operator!=(UserDefinedIntegral<T>, UserDefinedIntegral<U>);
template <class T, class U>
void operator<(UserDefinedIntegral<T>, UserDefinedIntegral<U>);
template <class T, class U>
void operator>(UserDefinedIntegral<T>, UserDefinedIntegral<U>);
template <class T, class U>
void operator<=(UserDefinedIntegral<T>, UserDefinedIntegral<U>);
template <class T, class U>
void operator>=(UserDefinedIntegral<T>, UserDefinedIntegral<U>);
#endif // SUPPORT_USER_DEFINED_INTEGRAL_H

libcxx/trunk/test/support/user_defined_integral.hpp

//===----------------------------------------------------------------------===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
#ifndef SUPPORT_USER_DEFINED_INTEGRAL_HPP
#define SUPPORT_USER_DEFINED_INTEGRAL_HPP
template <class T>
struct UserDefinedIntegral
{
UserDefinedIntegral() : value(0) {}
UserDefinedIntegral(T v) : value(v) {}
operator T() const { return value; }
T value;
};
// Poison the arithmetic and comparison operations
template <class T, class U>
void operator+(UserDefinedIntegral<T>, UserDefinedIntegral<U>);
template <class T, class U>
void operator-(UserDefinedIntegral<T>, UserDefinedIntegral<U>);
template <class T, class U>
void operator*(UserDefinedIntegral<T>, UserDefinedIntegral<U>);
template <class T, class U>
void operator/(UserDefinedIntegral<T>, UserDefinedIntegral<U>);
template <class T, class U>
void operator==(UserDefinedIntegral<T>, UserDefinedIntegral<U>);
template <class T, class U>
void operator!=(UserDefinedIntegral<T>, UserDefinedIntegral<U>);
template <class T, class U>
void operator<(UserDefinedIntegral<T>, UserDefinedIntegral<U>);
template <class T, class U>
void operator>(UserDefinedIntegral<T>, UserDefinedIntegral<U>);
template <class T, class U>
void operator<=(UserDefinedIntegral<T>, UserDefinedIntegral<U>);
template <class T, class U>
void operator>=(UserDefinedIntegral<T>, UserDefinedIntegral<U>);
#endif // SUPPORT_USER_DEFINED_INTEGRAL_HPP

libcxx/trunk/test/support/uses_alloc_types.h

//===----------------------------------------------------------------------===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
#ifndef USES_ALLOC_TYPES_H
#define USES_ALLOC_TYPES_H
# include <memory>
# include <cassert>
#include <cstdlib>
#include "test_macros.h"
#include "test_workarounds.h"
#include "type_id.h"
// There are two forms of uses-allocator construction:
// (1) UA_AllocArg: 'T(allocator_arg_t, Alloc const&, Args&&...)'
// (2) UA_AllocLast: 'T(Args&&..., Alloc const&)'
// 'UA_None' represents non-uses allocator construction.
enum class UsesAllocatorType {
UA_None = 0,
UA_AllocArg = 2,
UA_AllocLast = 4
};
constexpr UsesAllocatorType UA_None = UsesAllocatorType::UA_None;
constexpr UsesAllocatorType UA_AllocArg = UsesAllocatorType::UA_AllocArg;
constexpr UsesAllocatorType UA_AllocLast = UsesAllocatorType::UA_AllocLast;
inline const char* toString(UsesAllocatorType UA) {
switch (UA) {
case UA_None:
return "UA_None";
case UA_AllocArg:
return "UA_AllocArg";
case UA_AllocLast:
return "UA_AllocLast";
default:
std::abort();
}
}
#define COMPARE_ALLOC_TYPE(LHS, RHS) CompareVerbose(#LHS, LHS, #RHS, RHS)
inline bool CompareVerbose(const char* LHSString, UsesAllocatorType LHS,
const char* RHSString, UsesAllocatorType RHS) {
if (LHS == RHS)
return true;
std::printf("UsesAllocatorType's don't match:\n%s %s\n----------\n%s %s\n",
LHSString, toString(LHS), RHSString, toString(RHS));
return false;
}
template <class Alloc, std::size_t N>
class UsesAllocatorV1;
// Implements form (1) of uses-allocator construction from the specified
// 'Alloc' type and exactly 'N' additional arguments. It also provides
// non-uses allocator construction from 'N' arguments. This test type
// blows up when form (2) of uses-allocator is even considered.
template <class Alloc, std::size_t N>
class UsesAllocatorV2;
// Implements form (2) of uses-allocator construction from the specified
// 'Alloc' type and exactly 'N' additional arguments. It also provides
// non-uses allocator construction from 'N' arguments.
template <class Alloc, std::size_t N>
class UsesAllocatorV3;
// Implements both form (1) and (2) of uses-allocator construction from
// the specified 'Alloc' type and exactly 'N' additional arguments. It also
// provides non-uses allocator construction from 'N' arguments.
template <class Alloc, std::size_t>
class NotUsesAllocator;
// Implements both form (1) and (2) of uses-allocator construction from
// the specified 'Alloc' type and exactly 'N' additional arguments. It also
// provides non-uses allocator construction from 'N' arguments. However
// 'NotUsesAllocator' never provides a 'allocator_type' typedef so it is
// never automatically uses-allocator constructed.
template <class ...ArgTypes, class TestType>
bool checkConstruct(TestType& value, UsesAllocatorType form,
typename TestType::CtorAlloc const& alloc)
// Check that 'value' was constructed using the specified 'form' of
// construction and with the specified 'ArgTypes...'. Additionally
// check that 'value' was constructed using the specified 'alloc'.
{
if (form == UA_None) {
return value.template checkConstruct<ArgTypes&&...>(form);
} else {
return value.template checkConstruct<ArgTypes&&...>(form, alloc);
}
}
template <class ...ArgTypes, class TestType>
bool checkConstruct(TestType& value, UsesAllocatorType form) {
return value.template checkConstruct<ArgTypes&&...>(form);
}
template <class TestType>
bool checkConstructionEquiv(TestType& T, TestType& U)
// check that 'T' and 'U' where initialized in the exact same manner.
{
return T.checkConstructEquiv(U);
}
////////////////////////////////////////////////////////////////////////////////
namespace detail {
template <bool IsZero, size_t N, class ArgList, class ...Args>
struct TakeNImp;
template <class ArgList, class ...Args>
struct TakeNImp<true, 0, ArgList, Args...> {
typedef ArgList type;
};
template <size_t N, class ...A1, class F, class ...R>
struct TakeNImp<false, N, ArgumentListID<A1...>, F, R...>
: TakeNImp<N-1 == 0, N - 1, ArgumentListID<A1..., F>, R...> {};
template <size_t N, class ...Args>
struct TakeNArgs : TakeNImp<N == 0, N, ArgumentListID<>, Args...> {};
template <class T>
struct Identity { typedef T type; };
template <class T>
using IdentityT = typename Identity<T>::type;
template <bool Value>
using EnableIfB = typename std::enable_if<Value, bool>::type;
} // end namespace detail
// FIXME: UsesAllocatorTestBase needs some special logic to deal with
// polymorphic allocators. However we don't want to include
// <experimental/memory_resource> in this header. Therefore in order
// to inject this behavior later we use a trait.
// See test_memory_resource.h for more info.
template <class Alloc>
struct TransformErasedTypeAlloc {
using type = Alloc;
};
using detail::EnableIfB;
struct AllocLastTag {};
template <class Alloc, bool = std::is_default_constructible<Alloc>::value>
struct UsesAllocatorTestBaseStorage {
Alloc allocator;
UsesAllocatorTestBaseStorage() = default;
UsesAllocatorTestBaseStorage(Alloc const& a) : allocator(a) {}
const Alloc* get_allocator() const { return &allocator; }
};
template <class Alloc>
struct UsesAllocatorTestBaseStorage<Alloc, false> {
union {
char dummy;
Alloc alloc;
};
bool has_alloc = false;
UsesAllocatorTestBaseStorage() : dummy(), has_alloc(false) {}
UsesAllocatorTestBaseStorage(Alloc const& a) : alloc(a), has_alloc(true) {}
~UsesAllocatorTestBaseStorage() {
if (has_alloc)
alloc.~Alloc();
}
Alloc const* get_allocator() const {
if (!has_alloc)
return nullptr;
return &alloc;
}
};
template <class Self, class Alloc>
struct UsesAllocatorTestBase {
public:
using CtorAlloc = typename TransformErasedTypeAlloc<Alloc>::type;
template <class ...ArgTypes>
bool checkConstruct(UsesAllocatorType expectType) const {
auto expectArgs = &makeArgumentID<ArgTypes...>();
return COMPARE_ALLOC_TYPE(expectType, constructor_called) &&
COMPARE_TYPEID(args_id, expectArgs);
}
template <class ...ArgTypes>
bool checkConstruct(UsesAllocatorType expectType,
CtorAlloc const& expectAlloc) const {
auto ExpectID = &makeArgumentID<ArgTypes...>() ;
return COMPARE_ALLOC_TYPE(expectType, constructor_called) &&
COMPARE_TYPEID(args_id, ExpectID) &&
has_alloc() && expectAlloc == *get_alloc();
}
bool checkConstructEquiv(UsesAllocatorTestBase& O) const {
if (has_alloc() != O.has_alloc())
return false;
return COMPARE_ALLOC_TYPE(constructor_called, O.constructor_called)
&& COMPARE_TYPEID(args_id, O.args_id)
&& (!has_alloc() || *get_alloc() == *O.get_alloc());
}
protected:
explicit UsesAllocatorTestBase(const TypeID* aid)
: args_id(aid), constructor_called(UA_None), alloc_store()
{}
UsesAllocatorTestBase(UsesAllocatorTestBase const&)
: args_id(&makeArgumentID<Self const&>()), constructor_called(UA_None),
alloc_store()
{}
UsesAllocatorTestBase(UsesAllocatorTestBase&&)
: args_id(&makeArgumentID<Self&&>()), constructor_called(UA_None),
alloc_store()
{}
template <class ...Args>
UsesAllocatorTestBase(std::allocator_arg_t, CtorAlloc const& a, Args&&...)
: args_id(&makeArgumentID<Args&&...>()),
constructor_called(UA_AllocArg),
alloc_store(a)
{}
template <class ...Args, class ArgsIDL = detail::TakeNArgs<sizeof...(Args) - 1, Args&&...>>
UsesAllocatorTestBase(AllocLastTag, Args&&... args)
: args_id(&makeTypeIDImp<typename ArgsIDL::type>()),
constructor_called(UA_AllocLast),
alloc_store(UsesAllocatorTestBase::getAllocatorFromPack(
typename ArgsIDL::type{},
std::forward<Args>(args)...))
{
}
private:
template <class ...LArgs, class ...Args>
static CtorAlloc getAllocatorFromPack(ArgumentListID<LArgs...>, Args&&... args) {
return UsesAllocatorTestBase::getAllocatorFromPackImp<LArgs const&...>(args...);
}
template <class ...LArgs>
static CtorAlloc getAllocatorFromPackImp(
typename detail::Identity<LArgs>::type..., CtorAlloc const& alloc) {
return alloc;
}
bool has_alloc() const { return alloc_store.get_allocator() != nullptr; }
const CtorAlloc *get_alloc() const { return alloc_store.get_allocator(); }
public:
const TypeID* args_id;
UsesAllocatorType constructor_called = UA_None;
UsesAllocatorTestBaseStorage<CtorAlloc> alloc_store;
};
template <class Alloc, size_t Arity>
class UsesAllocatorV1 : public UsesAllocatorTestBase<UsesAllocatorV1<Alloc, Arity>, Alloc>
{
public:
typedef Alloc allocator_type;
using Base = UsesAllocatorTestBase<UsesAllocatorV1, Alloc>;
using CtorAlloc = typename Base::CtorAlloc;
UsesAllocatorV1() : Base(&makeArgumentID<>()) {}
UsesAllocatorV1(UsesAllocatorV1 const&)
: Base(&makeArgumentID<UsesAllocatorV1 const&>()) {}
UsesAllocatorV1(UsesAllocatorV1 &&)
: Base(&makeArgumentID<UsesAllocatorV1 &&>()) {}
// Non-Uses Allocator Ctor
template <class ...Args, EnableIfB<sizeof...(Args) == Arity> = false>
UsesAllocatorV1(Args&&...) : Base(&makeArgumentID<Args&&...>()) {}
// Uses Allocator Arg Ctor
template <class ...Args>
UsesAllocatorV1(std::allocator_arg_t tag, CtorAlloc const & a, Args&&... args)
: Base(tag, a, std::forward<Args>(args)...)
{ }
// BLOWS UP: Uses Allocator Last Ctor
template <class First, class ...Args, EnableIfB<sizeof...(Args) == Arity> Dummy = false>
constexpr UsesAllocatorV1(First&&, Args&&...)
{
static_assert(!std::is_same<First, First>::value, "");
}
};
template <class Alloc, size_t Arity>
class UsesAllocatorV2 : public UsesAllocatorTestBase<UsesAllocatorV2<Alloc, Arity>, Alloc>
{
public:
typedef Alloc allocator_type;
using Base = UsesAllocatorTestBase<UsesAllocatorV2, Alloc>;
using CtorAlloc = typename Base::CtorAlloc;
UsesAllocatorV2() : Base(&makeArgumentID<>()) {}
UsesAllocatorV2(UsesAllocatorV2 const&)
: Base(&makeArgumentID<UsesAllocatorV2 const&>()) {}
UsesAllocatorV2(UsesAllocatorV2 &&)
: Base(&makeArgumentID<UsesAllocatorV2 &&>()) {}
// Non-Uses Allocator Ctor
template <class ...Args, EnableIfB<sizeof...(Args) == Arity> = false>
UsesAllocatorV2(Args&&...) : Base(&makeArgumentID<Args&&...>()) {}
// Uses Allocator Last Ctor
template <class ...Args, EnableIfB<sizeof...(Args) == Arity + 1> = false>
UsesAllocatorV2(Args&&... args)
: Base(AllocLastTag{}, std::forward<Args>(args)...)
{}
};
template <class Alloc, size_t Arity>
class UsesAllocatorV3 : public UsesAllocatorTestBase<UsesAllocatorV3<Alloc, Arity>, Alloc>
{
public:
typedef Alloc allocator_type;
using Base = UsesAllocatorTestBase<UsesAllocatorV3, Alloc>;
using CtorAlloc = typename Base::CtorAlloc;
UsesAllocatorV3() : Base(&makeArgumentID<>()) {}
UsesAllocatorV3(UsesAllocatorV3 const&)
: Base(&makeArgumentID<UsesAllocatorV3 const&>()) {}
UsesAllocatorV3(UsesAllocatorV3 &&)
: Base(&makeArgumentID<UsesAllocatorV3 &&>()) {}
// Non-Uses Allocator Ctor
template <class ...Args, EnableIfB<sizeof...(Args) == Arity> = false>
UsesAllocatorV3(Args&&...) : Base(&makeArgumentID<Args&&...>()) {}
// Uses Allocator Arg Ctor
template <class ...Args>
UsesAllocatorV3(std::allocator_arg_t tag, CtorAlloc const& alloc, Args&&... args)
: Base(tag, alloc, std::forward<Args>(args)...)
{}
// Uses Allocator Last Ctor
template <class ...Args, EnableIfB<sizeof...(Args) == Arity + 1> = false>
UsesAllocatorV3(Args&&... args)
: Base(AllocLastTag{}, std::forward<Args>(args)...)
{}
};
template <class Alloc, size_t Arity>
class NotUsesAllocator : public UsesAllocatorTestBase<NotUsesAllocator<Alloc, Arity>, Alloc>
{
public:
// no allocator_type typedef provided
using Base = UsesAllocatorTestBase<NotUsesAllocator, Alloc>;
using CtorAlloc = typename Base::CtorAlloc;
NotUsesAllocator() : Base(&makeArgumentID<>()) {}
NotUsesAllocator(NotUsesAllocator const&)
: Base(&makeArgumentID<NotUsesAllocator const&>()) {}
NotUsesAllocator(NotUsesAllocator &&)
: Base(&makeArgumentID<NotUsesAllocator &&>()) {}
// Non-Uses Allocator Ctor
template <class ...Args, EnableIfB<sizeof...(Args) == Arity> = false>
NotUsesAllocator(Args&&...) : Base(&makeArgumentID<Args&&...>()) {}
// Uses Allocator Arg Ctor
template <class ...Args>
NotUsesAllocator(std::allocator_arg_t tag, CtorAlloc const& alloc, Args&&... args)
: Base(tag, alloc, std::forward<Args>(args)...)
{}
// Uses Allocator Last Ctor
template <class ...Args, EnableIfB<sizeof...(Args) == Arity + 1> = false>
NotUsesAllocator(Args&&... args)
: Base(AllocLastTag{}, std::forward<Args>(args)...)
{}
};
#endif /* USES_ALLOC_TYPES_H */

libcxx/trunk/test/support/uses_alloc_types.hpp

//===----------------------------------------------------------------------===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
#ifndef USES_ALLOC_TYPES_HPP
#define USES_ALLOC_TYPES_HPP
# include <memory>
# include <cassert>
#include <cstdlib>
#include "test_macros.h"
#include "test_workarounds.h"
#include "type_id.h"
// There are two forms of uses-allocator construction:
// (1) UA_AllocArg: 'T(allocator_arg_t, Alloc const&, Args&&...)'
// (2) UA_AllocLast: 'T(Args&&..., Alloc const&)'
// 'UA_None' represents non-uses allocator construction.
enum class UsesAllocatorType {
UA_None = 0,
UA_AllocArg = 2,
UA_AllocLast = 4
};
constexpr UsesAllocatorType UA_None = UsesAllocatorType::UA_None;
constexpr UsesAllocatorType UA_AllocArg = UsesAllocatorType::UA_AllocArg;
constexpr UsesAllocatorType UA_AllocLast = UsesAllocatorType::UA_AllocLast;
inline const char* toString(UsesAllocatorType UA) {
switch (UA) {
case UA_None:
return "UA_None";
case UA_AllocArg:
return "UA_AllocArg";
case UA_AllocLast:
return "UA_AllocLast";
default:
std::abort();
}
}
#define COMPARE_ALLOC_TYPE(LHS, RHS) CompareVerbose(#LHS, LHS, #RHS, RHS)
inline bool CompareVerbose(const char* LHSString, UsesAllocatorType LHS,
const char* RHSString, UsesAllocatorType RHS) {
if (LHS == RHS)
return true;
std::printf("UsesAllocatorType's don't match:\n%s %s\n----------\n%s %s\n",
LHSString, toString(LHS), RHSString, toString(RHS));
return false;
}
template <class Alloc, std::size_t N>
class UsesAllocatorV1;
// Implements form (1) of uses-allocator construction from the specified
// 'Alloc' type and exactly 'N' additional arguments. It also provides
// non-uses allocator construction from 'N' arguments. This test type
// blows up when form (2) of uses-allocator is even considered.
template <class Alloc, std::size_t N>
class UsesAllocatorV2;
// Implements form (2) of uses-allocator construction from the specified
// 'Alloc' type and exactly 'N' additional arguments. It also provides
// non-uses allocator construction from 'N' arguments.
template <class Alloc, std::size_t N>
class UsesAllocatorV3;
// Implements both form (1) and (2) of uses-allocator construction from
// the specified 'Alloc' type and exactly 'N' additional arguments. It also
// provides non-uses allocator construction from 'N' arguments.
template <class Alloc, std::size_t>
class NotUsesAllocator;
// Implements both form (1) and (2) of uses-allocator construction from
// the specified 'Alloc' type and exactly 'N' additional arguments. It also
// provides non-uses allocator construction from 'N' arguments. However
// 'NotUsesAllocator' never provides a 'allocator_type' typedef so it is
// never automatically uses-allocator constructed.
template <class ...ArgTypes, class TestType>
bool checkConstruct(TestType& value, UsesAllocatorType form,
typename TestType::CtorAlloc const& alloc)
// Check that 'value' was constructed using the specified 'form' of
// construction and with the specified 'ArgTypes...'. Additionally
// check that 'value' was constructed using the specified 'alloc'.
{
if (form == UA_None) {
return value.template checkConstruct<ArgTypes&&...>(form);
} else {
return value.template checkConstruct<ArgTypes&&...>(form, alloc);
}
}
template <class ...ArgTypes, class TestType>
bool checkConstruct(TestType& value, UsesAllocatorType form) {
return value.template checkConstruct<ArgTypes&&...>(form);
}
template <class TestType>
bool checkConstructionEquiv(TestType& T, TestType& U)
// check that 'T' and 'U' where initialized in the exact same manner.
{
return T.checkConstructEquiv(U);
}
////////////////////////////////////////////////////////////////////////////////
namespace detail {
template <bool IsZero, size_t N, class ArgList, class ...Args>
struct TakeNImp;
template <class ArgList, class ...Args>
struct TakeNImp<true, 0, ArgList, Args...> {
typedef ArgList type;
};
template <size_t N, class ...A1, class F, class ...R>
struct TakeNImp<false, N, ArgumentListID<A1...>, F, R...>
: TakeNImp<N-1 == 0, N - 1, ArgumentListID<A1..., F>, R...> {};
template <size_t N, class ...Args>
struct TakeNArgs : TakeNImp<N == 0, N, ArgumentListID<>, Args...> {};
template <class T>
struct Identity { typedef T type; };
template <class T>
using IdentityT = typename Identity<T>::type;
template <bool Value>
using EnableIfB = typename std::enable_if<Value, bool>::type;
} // end namespace detail
// FIXME: UsesAllocatorTestBase needs some special logic to deal with
// polymorphic allocators. However we don't want to include
// <experimental/memory_resource> in this header. Therefore in order
// to inject this behavior later we use a trait.
// See test_memory_resource.hpp for more info.
template <class Alloc>
struct TransformErasedTypeAlloc {
using type = Alloc;
};
using detail::EnableIfB;
struct AllocLastTag {};
template <class Alloc, bool = std::is_default_constructible<Alloc>::value>
struct UsesAllocatorTestBaseStorage {
Alloc allocator;
UsesAllocatorTestBaseStorage() = default;
UsesAllocatorTestBaseStorage(Alloc const& a) : allocator(a) {}
const Alloc* get_allocator() const { return &allocator; }
};
template <class Alloc>
struct UsesAllocatorTestBaseStorage<Alloc, false> {
union {
char dummy;
Alloc alloc;
};
bool has_alloc = false;
UsesAllocatorTestBaseStorage() : dummy(), has_alloc(false) {}
UsesAllocatorTestBaseStorage(Alloc const& a) : alloc(a), has_alloc(true) {}
~UsesAllocatorTestBaseStorage() {
if (has_alloc)
alloc.~Alloc();
}
Alloc const* get_allocator() const {
if (!has_alloc)
return nullptr;
return &alloc;
}
};
template <class Self, class Alloc>
struct UsesAllocatorTestBase {
public:
using CtorAlloc = typename TransformErasedTypeAlloc<Alloc>::type;
template <class ...ArgTypes>
bool checkConstruct(UsesAllocatorType expectType) const {
auto expectArgs = &makeArgumentID<ArgTypes...>();
return COMPARE_ALLOC_TYPE(expectType, constructor_called) &&
COMPARE_TYPEID(args_id, expectArgs);
}
template <class ...ArgTypes>
bool checkConstruct(UsesAllocatorType expectType,
CtorAlloc const& expectAlloc) const {
auto ExpectID = &makeArgumentID<ArgTypes...>() ;
return COMPARE_ALLOC_TYPE(expectType, constructor_called) &&
COMPARE_TYPEID(args_id, ExpectID) &&
has_alloc() && expectAlloc == *get_alloc();
}
bool checkConstructEquiv(UsesAllocatorTestBase& O) const {
if (has_alloc() != O.has_alloc())
return false;
return COMPARE_ALLOC_TYPE(constructor_called, O.constructor_called)
&& COMPARE_TYPEID(args_id, O.args_id)
&& (!has_alloc() || *get_alloc() == *O.get_alloc());
}
protected:
explicit UsesAllocatorTestBase(const TypeID* aid)
: args_id(aid), constructor_called(UA_None), alloc_store()
{}
UsesAllocatorTestBase(UsesAllocatorTestBase const&)
: args_id(&makeArgumentID<Self const&>()), constructor_called(UA_None),
alloc_store()
{}
UsesAllocatorTestBase(UsesAllocatorTestBase&&)
: args_id(&makeArgumentID<Self&&>()), constructor_called(UA_None),
alloc_store()
{}
template <class ...Args>
UsesAllocatorTestBase(std::allocator_arg_t, CtorAlloc const& a, Args&&...)
: args_id(&makeArgumentID<Args&&...>()),
constructor_called(UA_AllocArg),
alloc_store(a)
{}
template <class ...Args, class ArgsIDL = detail::TakeNArgs<sizeof...(Args) - 1, Args&&...>>
UsesAllocatorTestBase(AllocLastTag, Args&&... args)
: args_id(&makeTypeIDImp<typename ArgsIDL::type>()),
constructor_called(UA_AllocLast),
alloc_store(UsesAllocatorTestBase::getAllocatorFromPack(
typename ArgsIDL::type{},
std::forward<Args>(args)...))
{
}
private:
template <class ...LArgs, class ...Args>
static CtorAlloc getAllocatorFromPack(ArgumentListID<LArgs...>, Args&&... args) {
return UsesAllocatorTestBase::getAllocatorFromPackImp<LArgs const&...>(args...);
}
template <class ...LArgs>
static CtorAlloc getAllocatorFromPackImp(
typename detail::Identity<LArgs>::type..., CtorAlloc const& alloc) {
return alloc;
}
bool has_alloc() const { return alloc_store.get_allocator() != nullptr; }
const CtorAlloc *get_alloc() const { return alloc_store.get_allocator(); }
public:
const TypeID* args_id;
UsesAllocatorType constructor_called = UA_None;
UsesAllocatorTestBaseStorage<CtorAlloc> alloc_store;
};
template <class Alloc, size_t Arity>
class UsesAllocatorV1 : public UsesAllocatorTestBase<UsesAllocatorV1<Alloc, Arity>, Alloc>
{
public:
typedef Alloc allocator_type;
using Base = UsesAllocatorTestBase<UsesAllocatorV1, Alloc>;
using CtorAlloc = typename Base::CtorAlloc;
UsesAllocatorV1() : Base(&makeArgumentID<>()) {}
UsesAllocatorV1(UsesAllocatorV1 const&)
: Base(&makeArgumentID<UsesAllocatorV1 const&>()) {}
UsesAllocatorV1(UsesAllocatorV1 &&)
: Base(&makeArgumentID<UsesAllocatorV1 &&>()) {}
// Non-Uses Allocator Ctor
template <class ...Args, EnableIfB<sizeof...(Args) == Arity> = false>
UsesAllocatorV1(Args&&...) : Base(&makeArgumentID<Args&&...>()) {}
// Uses Allocator Arg Ctor
template <class ...Args>
UsesAllocatorV1(std::allocator_arg_t tag, CtorAlloc const & a, Args&&... args)
: Base(tag, a, std::forward<Args>(args)...)
{ }
// BLOWS UP: Uses Allocator Last Ctor
template <class First, class ...Args, EnableIfB<sizeof...(Args) == Arity> Dummy = false>
constexpr UsesAllocatorV1(First&&, Args&&...)
{
static_assert(!std::is_same<First, First>::value, "");
}
};
template <class Alloc, size_t Arity>
class UsesAllocatorV2 : public UsesAllocatorTestBase<UsesAllocatorV2<Alloc, Arity>, Alloc>
{
public:
typedef Alloc allocator_type;
using Base = UsesAllocatorTestBase<UsesAllocatorV2, Alloc>;
using CtorAlloc = typename Base::CtorAlloc;
UsesAllocatorV2() : Base(&makeArgumentID<>()) {}
UsesAllocatorV2(UsesAllocatorV2 const&)
: Base(&makeArgumentID<UsesAllocatorV2 const&>()) {}
UsesAllocatorV2(UsesAllocatorV2 &&)
: Base(&makeArgumentID<UsesAllocatorV2 &&>()) {}
// Non-Uses Allocator Ctor
template <class ...Args, EnableIfB<sizeof...(Args) == Arity> = false>
UsesAllocatorV2(Args&&...) : Base(&makeArgumentID<Args&&...>()) {}
// Uses Allocator Last Ctor
template <class ...Args, EnableIfB<sizeof...(Args) == Arity + 1> = false>
UsesAllocatorV2(Args&&... args)
: Base(AllocLastTag{}, std::forward<Args>(args)...)
{}
};
template <class Alloc, size_t Arity>
class UsesAllocatorV3 : public UsesAllocatorTestBase<UsesAllocatorV3<Alloc, Arity>, Alloc>
{
public:
typedef Alloc allocator_type;
using Base = UsesAllocatorTestBase<UsesAllocatorV3, Alloc>;
using CtorAlloc = typename Base::CtorAlloc;
UsesAllocatorV3() : Base(&makeArgumentID<>()) {}
UsesAllocatorV3(UsesAllocatorV3 const&)
: Base(&makeArgumentID<UsesAllocatorV3 const&>()) {}
UsesAllocatorV3(UsesAllocatorV3 &&)
: Base(&makeArgumentID<UsesAllocatorV3 &&>()) {}
// Non-Uses Allocator Ctor
template <class ...Args, EnableIfB<sizeof...(Args) == Arity> = false>
UsesAllocatorV3(Args&&...) : Base(&makeArgumentID<Args&&...>()) {}
// Uses Allocator Arg Ctor
template <class ...Args>
UsesAllocatorV3(std::allocator_arg_t tag, CtorAlloc const& alloc, Args&&... args)
: Base(tag, alloc, std::forward<Args>(args)...)
{}
// Uses Allocator Last Ctor
template <class ...Args, EnableIfB<sizeof...(Args) == Arity + 1> = false>
UsesAllocatorV3(Args&&... args)
: Base(AllocLastTag{}, std::forward<Args>(args)...)
{}
};
template <class Alloc, size_t Arity>
class NotUsesAllocator : public UsesAllocatorTestBase<NotUsesAllocator<Alloc, Arity>, Alloc>
{
public:
// no allocator_type typedef provided
using Base = UsesAllocatorTestBase<NotUsesAllocator, Alloc>;
using CtorAlloc = typename Base::CtorAlloc;
NotUsesAllocator() : Base(&makeArgumentID<>()) {}
NotUsesAllocator(NotUsesAllocator const&)
: Base(&makeArgumentID<NotUsesAllocator const&>()) {}
NotUsesAllocator(NotUsesAllocator &&)
: Base(&makeArgumentID<NotUsesAllocator &&>()) {}
// Non-Uses Allocator Ctor
template <class ...Args, EnableIfB<sizeof...(Args) == Arity> = false>
NotUsesAllocator(Args&&...) : Base(&makeArgumentID<Args&&...>()) {}
// Uses Allocator Arg Ctor
template <class ...Args>
NotUsesAllocator(std::allocator_arg_t tag, CtorAlloc const& alloc, Args&&... args)
: Base(tag, alloc, std::forward<Args>(args)...)
{}
// Uses Allocator Last Ctor
template <class ...Args, EnableIfB<sizeof...(Args) == Arity + 1> = false>
NotUsesAllocator(Args&&... args)
: Base(AllocLastTag{}, std::forward<Args>(args)...)
{}
};
#endif /* USES_ALLOC_TYPES_HPP */

libcxx/trunk/test/support/variant_test_helpers.h

// -*- C++ -*-
//===----------------------------------------------------------------------===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
#ifndef SUPPORT_VARIANT_TEST_HELPERS_H
#define SUPPORT_VARIANT_TEST_HELPERS_H
#include <type_traits>
#include <utility>
#include <cassert>
#include "test_macros.h"
#if TEST_STD_VER <= 14
#error This file requires C++17
#endif
// FIXME: Currently the variant<T&> tests are disabled using this macro.
#define TEST_VARIANT_HAS_NO_REFERENCES
#ifdef _LIBCPP_ENABLE_NARROWING_CONVERSIONS_IN_VARIANT
# define TEST_VARIANT_ALLOWS_NARROWING_CONVERSIONS
#endif
#ifdef TEST_VARIANT_ALLOWS_NARROWING_CONVERSIONS
constexpr bool VariantAllowsNarrowingConversions = true;
#else
constexpr bool VariantAllowsNarrowingConversions = false;
#endif
#ifndef TEST_HAS_NO_EXCEPTIONS
struct CopyThrows {
CopyThrows() = default;
CopyThrows(CopyThrows const&) { throw 42; }
CopyThrows& operator=(CopyThrows const&) { throw 42; }
};
struct MoveThrows {
static int alive;
MoveThrows() { ++alive; }
MoveThrows(MoveThrows const&) {++alive;}
MoveThrows(MoveThrows&&) { throw 42; }
MoveThrows& operator=(MoveThrows const&) { return *this; }
MoveThrows& operator=(MoveThrows&&) { throw 42; }
~MoveThrows() { --alive; }
};
int MoveThrows::alive = 0;
struct MakeEmptyT {
static int alive;
MakeEmptyT() { ++alive; }
MakeEmptyT(MakeEmptyT const&) {
++alive;
// Don't throw from the copy constructor since variant's assignment
// operator performs a copy before committing to the assignment.
}
MakeEmptyT(MakeEmptyT &&) {
throw 42;
}
MakeEmptyT& operator=(MakeEmptyT const&) {
throw 42;
}
MakeEmptyT& operator=(MakeEmptyT&&) {
throw 42;
}
~MakeEmptyT() { --alive; }
};
static_assert(std::is_swappable_v<MakeEmptyT>, ""); // required for test
int MakeEmptyT::alive = 0;
template <class Variant>
void makeEmpty(Variant& v) {
Variant v2(std::in_place_type<MakeEmptyT>);
try {
v = std::move(v2);
assert(false);
} catch (...) {
assert(v.valueless_by_exception());
}
}
#endif // TEST_HAS_NO_EXCEPTIONS
#endif // SUPPORT_VARIANT_TEST_HELPERS_H

libcxx/trunk/test/support/variant_test_helpers.hpp

// -*- C++ -*-
//===----------------------------------------------------------------------===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
#ifndef SUPPORT_VARIANT_TEST_HELPERS_HPP
#define SUPPORT_VARIANT_TEST_HELPERS_HPP
#include <type_traits>
#include <utility>
#include <cassert>
#include "test_macros.h"
#if TEST_STD_VER <= 14
#error This file requires C++17
#endif
// FIXME: Currently the variant<T&> tests are disabled using this macro.
#define TEST_VARIANT_HAS_NO_REFERENCES
#ifdef _LIBCPP_ENABLE_NARROWING_CONVERSIONS_IN_VARIANT
# define TEST_VARIANT_ALLOWS_NARROWING_CONVERSIONS
#endif
#ifdef TEST_VARIANT_ALLOWS_NARROWING_CONVERSIONS
constexpr bool VariantAllowsNarrowingConversions = true;
#else
constexpr bool VariantAllowsNarrowingConversions = false;
#endif
#ifndef TEST_HAS_NO_EXCEPTIONS
struct CopyThrows {
CopyThrows() = default;
CopyThrows(CopyThrows const&) { throw 42; }
CopyThrows& operator=(CopyThrows const&) { throw 42; }
};
struct MoveThrows {
static int alive;
MoveThrows() { ++alive; }
MoveThrows(MoveThrows const&) {++alive;}
MoveThrows(MoveThrows&&) { throw 42; }
MoveThrows& operator=(MoveThrows const&) { return *this; }
MoveThrows& operator=(MoveThrows&&) { throw 42; }
~MoveThrows() { --alive; }
};
int MoveThrows::alive = 0;
struct MakeEmptyT {
static int alive;
MakeEmptyT() { ++alive; }
MakeEmptyT(MakeEmptyT const&) {
++alive;
// Don't throw from the copy constructor since variant's assignment
// operator performs a copy before committing to the assignment.
}
MakeEmptyT(MakeEmptyT &&) {
throw 42;
}
MakeEmptyT& operator=(MakeEmptyT const&) {
throw 42;
}
MakeEmptyT& operator=(MakeEmptyT&&) {
throw 42;
}
~MakeEmptyT() { --alive; }
};
static_assert(std::is_swappable_v<MakeEmptyT>, ""); // required for test
int MakeEmptyT::alive = 0;
template <class Variant>
void makeEmpty(Variant& v) {
Variant v2(std::in_place_type<MakeEmptyT>);
try {
v = std::move(v2);
assert(false);
} catch (...) {
assert(v.valueless_by_exception());
}
}
#endif // TEST_HAS_NO_EXCEPTIONS
#endif // SUPPORT_VARIANT_TEST_HELPERS_HPP

libcxx/trunk/utils/libcxx/test/config.py

Show First 20 Lines • Show All 596 Lines • ▼ Show 20 Lines def configure_default_compile_flags(self):
self.cxx.addFlagIfSupported('-ftemplate-depth=270') self.cxx.addFlagIfSupported('-ftemplate-depth=270')
def configure_compile_flags_header_includes(self): def configure_compile_flags_header_includes(self):
support_path = os.path.join(self.libcxx_src_root, 'test', 'support') support_path = os.path.join(self.libcxx_src_root, 'test', 'support')
self.configure_config_site_header() self.configure_config_site_header()
if self.cxx_stdlib_under_test != 'libstdc++' and \ if self.cxx_stdlib_under_test != 'libstdc++' and \
not self.is_windows: not self.is_windows:
self.cxx.compile_flags += [ self.cxx.compile_flags += [
'-include', os.path.join(support_path, 'nasty_macros.hpp')] '-include', os.path.join(support_path, 'nasty_macros.h')]
if self.cxx_stdlib_under_test == 'msvc': if self.cxx_stdlib_under_test == 'msvc':
self.cxx.compile_flags += [ self.cxx.compile_flags += [
'-include', os.path.join(support_path, '-include', os.path.join(support_path,
'msvc_stdlib_force_include.hpp')] 'msvc_stdlib_force_include.h')]
pass pass
if self.is_windows and self.debug_build and \ if self.is_windows and self.debug_build and \
self.cxx_stdlib_under_test != 'msvc': self.cxx_stdlib_under_test != 'msvc':
self.cxx.compile_flags += [ self.cxx.compile_flags += [
'-include', os.path.join(support_path, '-include', os.path.join(support_path,
'set_windows_crt_report_mode.h') 'set_windows_crt_report_mode.h')
] ]
cxx_headers = self.get_lit_conf('cxx_headers') cxx_headers = self.get_lit_conf('cxx_headers')
▲ Show 20 Lines • Show All 577 Lines • Show Last 20 Lines
libcxx/trunk/test/support/variant_test_helpers.h