This is an archive of the discontinued LLVM Phabricator instance.

Differential D124623

[libc++] Mark tests that use check_assertion.h as requiring unix headers
ClosedPublic

Authored by john.brawn on Apr 28 2022, 9:03 AM.

Details

Reviewers
ldionne
Mordante
michaelplatings
mstorsjo
Group Reviewers
Restricted Project
Commits
rGf3a970a82552: [libc++] Mark tests that use check_assertion.h as requiring unix headers
Summary

On targets without unistd.h or sys/wait.h (such as bare metal targets) any test that uses check_assertion.h will fail, so add REQUIRES: has-unix-headers to them and autodetect whether we have these headers or not.

These tests currently have unsupported on windows, but that's exactly because windows doesn't have these headers so we can remove the specific check for windows.

Diff Detail

Unit TestsFailed

TimeTest
1,660 mslibcxx CI MinGW (DLL) > llvm-libc++-mingw-cfg-in.libcxx/algorithms::debug_less.inconsistent.pass.cpp
1,560 mslibcxx CI MinGW (DLL) > llvm-libc++-mingw-cfg-in.libcxx/algorithms::debug_less.pass.cpp
1,650 mslibcxx CI MinGW (DLL) > llvm-libc++-mingw-cfg-in.libcxx/algorithms/alg_sorting::assert.min.max.pass.cpp
1,300 mslibcxx CI MinGW (DLL) > llvm-libc++-mingw-cfg-in.libcxx/containers/sequences/array/array_zero::assert.back.pass.cpp
1,290 mslibcxx CI MinGW (DLL) > llvm-libc++-mingw-cfg-in.libcxx/containers/sequences/array/array_zero::assert.front.pass.cpp
View Full Test Results (230 Failed)

Event Timeline

john.brawn created this revision.Apr 28 2022, 9:03 AM
Herald added a project: Restricted Project. · View Herald TranscriptApr 28 2022, 9:03 AM
Herald added subscribers: arphaman, arichardson. · View Herald Transcript
john.brawn requested review of this revision.Apr 28 2022, 9:03 AM
Herald added a project: Restricted Project. · View Herald TranscriptApr 28 2022, 9:03 AM
Herald added a reviewer: Restricted Project. · View Herald Transcript
Herald added a subscriber: libcxx-commits. · View Herald Transcript
MarkMurrayARM added a subscriber: MarkMurrayARM.Apr 28 2022, 9:28 AM

This looks sensible for our (ARM's) situation.

Harbormaster completed remote builds in B161814: Diff 425809.Apr 28 2022, 11:01 AM
Mordante added a reviewer: mstorsjo.Apr 29 2022, 8:54 AM

This looks like a nice cleanup in general but it breaks the MinGW builds.

libcxx/utils/libcxx/test/features.py
119

I think this name can be a bit more descriptive, for example has-header-unistd-h.

mstorsjo added a comment.Apr 29 2022, 9:17 AM
In D124623#3482744, @Mordante wrote:

This looks like a nice cleanup in general but it breaks the MinGW builds.

MinGW does provide a unistd.h, but lacks sys/wait.h.

john.brawn updated this revision to Diff 426766.May 3 2022, 10:33 AM
john.brawn retitled this revision from [libc++] Mark tests that use check_assertion.h as requiring unistd.h to [libc++] Mark tests that use check_assertion.h as requiring unix headers.
john.brawn edited the summary of this revision. (Show Details)

Also check for sys/wait.h, and rename the feature to has-unix-headers.

Harbormaster completed remote builds in B162503: Diff 426766.May 3 2022, 11:47 AM
Mordante accepted this revision.May 5 2022, 9:09 AM

LGTM!

libcxx/test/libcxx/debug/containers/associative_containers.pass.cpp
10

Nit maybe merge the two unsupported lines, here and similar tests below.

This revision is now accepted and ready to land.May 5 2022, 9:09 AM
Closed by commit rGf3a970a82552: [libc++] Mark tests that use check_assertion.h as requiring unix headers (authored by john.brawn). · Explain WhyMay 6 2022, 3:03 AM
This revision was automatically updated to reflect the committed changes.
john.brawn added a commit: rGf3a970a82552: [libc++] Mark tests that use check_assertion.h as requiring unix headers.
ldionne added a comment.May 13 2022, 6:01 AM

Thanks for this patch, this is actually really helpful for us downstream too.

Revision Contents

PathSize
libcxx/
test/
libcxx/
algorithms/
alg.sorting/
2 lines
3 lines
3 lines
containers/
sequences/
array/
array.zero/
3 lines
3 lines
3 lines
deque/
3 lines
list/
list.cons/
3 lines
list.modifiers/
3 lines
3 lines
3 lines
3 lines
3 lines
3 lines
3 lines
3 lines
3 lines
list.ops/
3 lines
3 lines
3 lines
vector/
3 lines
3 lines
3 lines
3 lines
3 lines
3 lines
3 lines
3 lines
3 lines
3 lines
3 lines
3 lines
3 lines
3 lines
unord/
unord.map/
3 lines
3 lines
3 lines
3 lines
3 lines
3 lines
3 lines
3 lines
3 lines
3 lines
unord.map.modifiers/
3 lines
3 lines
unord.multimap/
3 lines
3 lines
3 lines
3 lines
3 lines
3 lines
3 lines
3 lines
3 lines
3 lines
unord.multimap.modifiers/
3 lines
3 lines
unord.multiset/
3 lines
3 lines
3 lines
3 lines
3 lines
3 lines
3 lines
3 lines
3 lines
3 lines
3 lines
unord.set/
3 lines
3 lines
3 lines
3 lines
3 lines
3 lines
3 lines
3 lines
3 lines
3 lines
3 lines
debug/
containers/
3 lines
3 lines
3 lines
3 lines
experimental/
memory/
memory.polymorphic.allocator.class/
memory.polymorphic.allocator.mem/
3 lines
memory.resource.adaptor/
memory.resource.adaptor.mem/
3 lines
input.output/
filesystems/
class.path/
path.itr/
3 lines
iterators/
3 lines
3 lines
3 lines
ranges/
range.adaptors/
range.lazy.split/
range.lazy.split.inner/
3 lines
range.lazy.split.outer/
3 lines
strings/
basic.string/
string.access/
3 lines
3 lines
3 lines
3 lines
3 lines
3 lines
string.iterators/
3 lines
3 lines
3 lines
3 lines
3 lines
3 lines
3 lines
string.modifiers/
3 lines
3 lines
3 lines
3 lines
3 lines
3 lines
3 lines
string.view/
3 lines
thread/
futures/
futures.promise/
3 lines
3 lines
utilities/
optional/
optional.object/
optional.object.observe/
3 lines
3 lines
support/
test.support/
3 lines
utils/
libcxx/
test/
8 lines

Diff 425809

libcxx/test/libcxx/algorithms/alg.sorting/assert.min.max.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
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// <algorithm> // <algorithm>
// REQUIRES: has-unistd
// UNSUPPORTED: c++03, c++11, c++14, c++17 // UNSUPPORTED: c++03, c++11, c++14, c++17
// UNSUPPORTED: libcpp-has-no-incomplete-ranges // UNSUPPORTED: libcpp-has-no-incomplete-ranges
// UNSUPPORTED: windows
// ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_ENABLE_ASSERTIONS=1 // ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_ENABLE_ASSERTIONS=1
#include <algorithm> #include <algorithm>
#include <array> #include <array>
#include "check_assertion.h" #include "check_assertion.h"
int main(int, char**) { int main(int, char**) {
Show All 9 Lines

libcxx/test/libcxx/algorithms/debug_less.inconsistent.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
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// <algorithm> // <algorithm>
// template <class _Compare> struct __debug_less // template <class _Compare> struct __debug_less
// Make sure __debug_less asserts when the comparator is not consistent. // Make sure __debug_less asserts when the comparator is not consistent.
// UNSUPPORTED: libcxx-no-debug-mode, c++03, windows // REQUIRES: has-unistd
// UNSUPPORTED: libcxx-no-debug-mode, c++03
// ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DEBUG=1 // ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DEBUG=1
#include <algorithm> #include <algorithm>
#include <iterator> #include <iterator>
#include "check_assertion.h" #include "check_assertion.h"
template <int ID> template <int ID>
Show All 29 Lines

libcxx/test/libcxx/algorithms/debug_less.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
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// <algorithm> // <algorithm>
// template <class _Compare> struct __debug_less // template <class _Compare> struct __debug_less
// __debug_less checks that a comparator actually provides a strict-weak ordering. // __debug_less checks that a comparator actually provides a strict-weak ordering.
// UNSUPPORTED: libcxx-no-debug-mode, c++03, windows // REQUIRES: has-unistd
// UNSUPPORTED: libcxx-no-debug-mode, c++03
// ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DEBUG=1 // ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DEBUG=1
#include <algorithm> #include <algorithm>
#include <iterator> #include <iterator>
#include <cassert> #include <cassert>
#include "test_macros.h" #include "test_macros.h"
#include "check_assertion.h" #include "check_assertion.h"
▲ Show 20 Lines • Show All 236 Lines • Show Last 20 Lines

libcxx/test/libcxx/containers/sequences/array/array.zero/assert.back.pass.cpp

//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// UNSUPPORTED: c++03, windows // REQUIRES: has-unistd
// UNSUPPORTED: c++03
// XFAIL: use_system_cxx_lib && target={{.+}}-apple-macosx{{10.9|10.10|10.11|10.12|10.13|10.14|10.15|11.0|12.0}} // XFAIL: use_system_cxx_lib && target={{.+}}-apple-macosx{{10.9|10.10|10.11|10.12|10.13|10.14|10.15|11.0|12.0}}
// ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_ENABLE_ASSERTIONS=1 // ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_ENABLE_ASSERTIONS=1
// test that array<T, 0>::back() triggers an assertion // test that array<T, 0>::back() triggers an assertion
#include <array> #include <array>
#include "check_assertion.h" #include "check_assertion.h"
Show All 19 Lines

libcxx/test/libcxx/containers/sequences/array/array.zero/assert.front.pass.cpp

//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// UNSUPPORTED: c++03, windows // REQUIRES: has-unistd
// UNSUPPORTED: c++03
// XFAIL: use_system_cxx_lib && target={{.+}}-apple-macosx{{10.9|10.10|10.11|10.12|10.13|10.14|10.15|11.0|12.0}} // XFAIL: use_system_cxx_lib && target={{.+}}-apple-macosx{{10.9|10.10|10.11|10.12|10.13|10.14|10.15|11.0|12.0}}
// ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_ENABLE_ASSERTIONS=1 // ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_ENABLE_ASSERTIONS=1
// test that array<T, 0>::back() triggers an assertion // test that array<T, 0>::back() triggers an assertion
#include <array> #include <array>
#include "check_assertion.h" #include "check_assertion.h"
Show All 19 Lines

libcxx/test/libcxx/containers/sequences/array/array.zero/assert.subscript.pass.cpp

//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// UNSUPPORTED: c++03, windows // REQUIRES: has-unistd
// UNSUPPORTED: c++03
// XFAIL: use_system_cxx_lib && target={{.+}}-apple-macosx{{10.9|10.10|10.11|10.12|10.13|10.14|10.15|11.0|12.0}} // XFAIL: use_system_cxx_lib && target={{.+}}-apple-macosx{{10.9|10.10|10.11|10.12|10.13|10.14|10.15|11.0|12.0}}
// ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_ENABLE_ASSERTIONS=1 // ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_ENABLE_ASSERTIONS=1
// test that array<T, 0>::operator[] triggers an assertion // test that array<T, 0>::operator[] triggers an assertion
#include <array> #include <array>
#include "check_assertion.h" #include "check_assertion.h"
Show All 23 Lines

libcxx/test/libcxx/containers/sequences/deque/assert.pop_back.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
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// <deque> // <deque>
// pop_back() more than the number of elements in a deque // pop_back() more than the number of elements in a deque
// UNSUPPORTED: c++03, windows // REQUIRES: has-unistd
// UNSUPPORTED: c++03
// XFAIL: use_system_cxx_lib && target={{.+}}-apple-macosx{{10.9|10.10|10.11|10.12|10.13|10.14|10.15|11.0|12.0}} // XFAIL: use_system_cxx_lib && target={{.+}}-apple-macosx{{10.9|10.10|10.11|10.12|10.13|10.14|10.15|11.0|12.0}}
// ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_ENABLE_ASSERTIONS=1 // ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_ENABLE_ASSERTIONS=1
#include <deque> #include <deque>
#include "check_assertion.h" #include "check_assertion.h"
int main(int, char**) { int main(int, char**) {
std::deque<int> q; std::deque<int> q;
q.push_back(0); q.push_back(0);
q.pop_back(); q.pop_back();
TEST_LIBCPP_ASSERT_FAILURE(q.pop_back(), "deque::pop_back called on an empty deque"); TEST_LIBCPP_ASSERT_FAILURE(q.pop_back(), "deque::pop_back called on an empty deque");
return 0; return 0;
} }

libcxx/test/libcxx/containers/sequences/list/list.cons/debug.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
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// <list> // <list>
// list(list&& c); // list(list&& c);
// UNSUPPORTED: libcxx-no-debug-mode, c++03, windows // REQUIRES: has-unistd
// UNSUPPORTED: libcxx-no-debug-mode, c++03
// ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DEBUG=1 // ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DEBUG=1
#include <list> #include <list>
#include "check_assertion.h" #include "check_assertion.h"
int main(int, char**) { int main(int, char**) {
std::list<int> l1; std::list<int> l1;
l1.push_back(1); l1.push_back(2); l1.push_back(3); l1.push_back(1); l1.push_back(2); l1.push_back(3);
std::list<int>::iterator i = l1.begin(); std::list<int>::iterator i = l1.begin();
std::list<int> l2 = l1; std::list<int> l2 = l1;
TEST_LIBCPP_ASSERT_FAILURE(l2.erase(i), "list::erase(iterator) called with an iterator not referring to this list"); TEST_LIBCPP_ASSERT_FAILURE(l2.erase(i), "list::erase(iterator) called with an iterator not referring to this list");
return 0; return 0;
} }

libcxx/test/libcxx/containers/sequences/list/list.modifiers/assert.erase_iter.end.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
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// <list> // <list>
// Call erase(const_iterator position) with end() // Call erase(const_iterator position) with end()
// UNSUPPORTED: c++03, windows // REQUIRES: has-unistd
// UNSUPPORTED: c++03
// XFAIL: use_system_cxx_lib && target={{.+}}-apple-macosx{{10.9|10.10|10.11|10.12|10.13|10.14|10.15|11.0|12.0}} // XFAIL: use_system_cxx_lib && target={{.+}}-apple-macosx{{10.9|10.10|10.11|10.12|10.13|10.14|10.15|11.0|12.0}}
// ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_ENABLE_ASSERTIONS=1 // ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_ENABLE_ASSERTIONS=1
#include <list> #include <list>
#include "check_assertion.h" #include "check_assertion.h"
int main(int, char**) { int main(int, char**) {
int a1[] = {1, 2, 3}; int a1[] = {1, 2, 3};
std::list<int> l1(a1, a1+3); std::list<int> l1(a1, a1+3);
std::list<int>::const_iterator i = l1.end(); std::list<int>::const_iterator i = l1.end();
TEST_LIBCPP_ASSERT_FAILURE(l1.erase(i), "list::erase(iterator) called with a non-dereferenceable iterator"); TEST_LIBCPP_ASSERT_FAILURE(l1.erase(i), "list::erase(iterator) called with a non-dereferenceable iterator");
return 0; return 0;
} }

libcxx/test/libcxx/containers/sequences/list/list.modifiers/assert.pop_back.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
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// <list> // <list>
// void pop_back(); // void pop_back();
// UNSUPPORTED: c++03, windows // REQUIRES: has-unistd
// UNSUPPORTED: c++03
// XFAIL: use_system_cxx_lib && target={{.+}}-apple-macosx{{10.9|10.10|10.11|10.12|10.13|10.14|10.15|11.0|12.0}} // XFAIL: use_system_cxx_lib && target={{.+}}-apple-macosx{{10.9|10.10|10.11|10.12|10.13|10.14|10.15|11.0|12.0}}
// ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_ENABLE_ASSERTIONS=1 // ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_ENABLE_ASSERTIONS=1
#include <list> #include <list>
#include <cassert> #include <cassert>
#include "check_assertion.h" #include "check_assertion.h"
Show All 13 Lines

libcxx/test/libcxx/containers/sequences/list/list.modifiers/debug.emplace.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
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// <list> // <list>
// template <class... Args> void emplace(const_iterator p, Args&&... args); // template <class... Args> void emplace(const_iterator p, Args&&... args);
// UNSUPPORTED: libcxx-no-debug-mode, c++03, windows // REQUIRES: has-unistd
// UNSUPPORTED: libcxx-no-debug-mode, c++03
// ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DEBUG=1 // ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DEBUG=1
#include <list> #include <list>
#include "check_assertion.h" #include "check_assertion.h"
struct A { struct A {
explicit A(int i, double d) { explicit A(int i, double d) {
Show All 13 Lines

libcxx/test/libcxx/containers/sequences/list/list.modifiers/debug.erase.iter.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
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// <list> // <list>
// Call erase(const_iterator position) with iterator from another container // Call erase(const_iterator position) with iterator from another container
// UNSUPPORTED: libcxx-no-debug-mode, c++03, windows // REQUIRES: has-unistd
// UNSUPPORTED: libcxx-no-debug-mode, c++03
// ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DEBUG=1 // ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DEBUG=1
#include <list> #include <list>
#include "check_assertion.h" #include "check_assertion.h"
int main(int, char**) { int main(int, char**) {
int a1[] = {1, 2, 3}; int a1[] = {1, 2, 3};
std::list<int> l1(a1, a1+3); std::list<int> l1(a1, a1+3);
std::list<int> l2(a1, a1+3); std::list<int> l2(a1, a1+3);
std::list<int>::const_iterator i = l2.begin(); std::list<int>::const_iterator i = l2.begin();
TEST_LIBCPP_ASSERT_FAILURE(l1.erase(i), "list::erase(iterator) called with an iterator not referring to this list"); TEST_LIBCPP_ASSERT_FAILURE(l1.erase(i), "list::erase(iterator) called with an iterator not referring to this list");
return 0; return 0;
} }

libcxx/test/libcxx/containers/sequences/list/list.modifiers/debug.erase.iter_iter.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
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// <list> // <list>
// Call erase(const_iterator first, const_iterator last); with various invalid iterators // Call erase(const_iterator first, const_iterator last); with various invalid iterators
// UNSUPPORTED: libcxx-no-debug-mode, c++03, windows // REQUIRES: has-unistd
// UNSUPPORTED: libcxx-no-debug-mode, c++03
// ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DEBUG=1 // ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DEBUG=1
#include <list> #include <list>
#include "check_assertion.h" #include "check_assertion.h"
int main(int, char**) { int main(int, char**) {
// First iterator from another container // First iterator from another container
Show All 36 Lines

libcxx/test/libcxx/containers/sequences/list/list.modifiers/debug.insert.iter_iter_iter.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
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// <list> // <list>
// template <InputIterator Iter> // template <InputIterator Iter>
// iterator insert(const_iterator position, Iter first, Iter last); // iterator insert(const_iterator position, Iter first, Iter last);
// UNSUPPORTED: libcxx-no-debug-mode, c++03, windows // REQUIRES: has-unistd
// UNSUPPORTED: libcxx-no-debug-mode, c++03
// ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DEBUG=1 // ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DEBUG=1
#include <list> #include <list>
#include "check_assertion.h" #include "check_assertion.h"
int main(int, char**) { int main(int, char**) {
std::list<int> v(100); std::list<int> v(100);
std::list<int> v2(100); std::list<int> v2(100);
int a[] = {1, 2, 3, 4, 5}; int a[] = {1, 2, 3, 4, 5};
TEST_LIBCPP_ASSERT_FAILURE(v.insert(v2.cbegin(), a, a + 5), TEST_LIBCPP_ASSERT_FAILURE(v.insert(v2.cbegin(), a, a + 5),
"list::insert(iterator, range) called with an iterator not referring to this list"); "list::insert(iterator, range) called with an iterator not referring to this list");
return 0; return 0;
} }

libcxx/test/libcxx/containers/sequences/list/list.modifiers/debug.insert.iter_rvalue.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
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// <list> // <list>
// iterator insert(const_iterator position, value_type&& x); // iterator insert(const_iterator position, value_type&& x);
// UNSUPPORTED: libcxx-no-debug-mode, c++03, windows // REQUIRES: has-unistd
// UNSUPPORTED: libcxx-no-debug-mode, c++03
// ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DEBUG=1 // ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DEBUG=1
#include <list> #include <list>
#include "check_assertion.h" #include "check_assertion.h"
int main(int, char**) { int main(int, char**) {
std::list<int> v1(3); std::list<int> v1(3);
std::list<int> v2(3); std::list<int> v2(3);
TEST_LIBCPP_ASSERT_FAILURE(v1.insert(v2.begin(), 4), TEST_LIBCPP_ASSERT_FAILURE(v1.insert(v2.begin(), 4),
"list::insert(iterator, x) called with an iterator not referring to this list"); "list::insert(iterator, x) called with an iterator not referring to this list");
return 0; return 0;
} }

libcxx/test/libcxx/containers/sequences/list/list.modifiers/debug.insert.iter_size_value.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
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// <list> // <list>
// iterator insert(const_iterator position, size_type n, const value_type& x); // iterator insert(const_iterator position, size_type n, const value_type& x);
// UNSUPPORTED: libcxx-no-debug-mode, c++03, windows // REQUIRES: has-unistd
// UNSUPPORTED: libcxx-no-debug-mode, c++03
// ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DEBUG=1 // ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DEBUG=1
#include <list> #include <list>
#include "check_assertion.h" #include "check_assertion.h"
int main(int, char**) { int main(int, char**) {
std::list<int> c1(100); std::list<int> c1(100);
std::list<int> c2; std::list<int> c2;
TEST_LIBCPP_ASSERT_FAILURE(c1.insert(c2.cbegin(), 5, 1), TEST_LIBCPP_ASSERT_FAILURE(c1.insert(c2.cbegin(), 5, 1),
"list::insert(iterator, n, x) called with an iterator not referring to this list"); "list::insert(iterator, n, x) called with an iterator not referring to this list");
return 0; return 0;
} }

libcxx/test/libcxx/containers/sequences/list/list.modifiers/debug.insert.iter_value.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
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// <list> // <list>
// iterator insert(const_iterator position, const value_type& x); // iterator insert(const_iterator position, const value_type& x);
// UNSUPPORTED: libcxx-no-debug-mode, c++03, windows // REQUIRES: has-unistd
// UNSUPPORTED: libcxx-no-debug-mode, c++03
// ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DEBUG=1 // ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DEBUG=1
#include <list> #include <list>
#include "check_assertion.h" #include "check_assertion.h"
int main(int, char**) { int main(int, char**) {
std::list<int> v1(3); std::list<int> v1(3);
std::list<int> v2(3); std::list<int> v2(3);
int i = 4; int i = 4;
TEST_LIBCPP_ASSERT_FAILURE(v1.insert(v2.begin(), i), TEST_LIBCPP_ASSERT_FAILURE(v1.insert(v2.begin(), i),
"list::insert(iterator, x) called with an iterator not referring to this list"); "list::insert(iterator, x) called with an iterator not referring to this list");
return 0; return 0;
} }

libcxx/test/libcxx/containers/sequences/list/list.ops/debug.splice.pos_list.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
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// <list> // <list>
// void splice(const_iterator position, list& x); // void splice(const_iterator position, list& x);
// UNSUPPORTED: libcxx-no-debug-mode, c++03, windows // REQUIRES: has-unistd
// UNSUPPORTED: libcxx-no-debug-mode, c++03
// ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DEBUG=1 // ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DEBUG=1
#include <list> #include <list>
#include "check_assertion.h" #include "check_assertion.h"
int main(int, char**) { int main(int, char**) {
std::list<int> v1(3); std::list<int> v1(3);
std::list<int> v2(3); std::list<int> v2(3);
TEST_LIBCPP_ASSERT_FAILURE(v1.splice(v2.begin(), v2), TEST_LIBCPP_ASSERT_FAILURE(v1.splice(v2.begin(), v2),
"list::splice(iterator, list) called with an iterator not referring to this list"); "list::splice(iterator, list) called with an iterator not referring to this list");
return 0; return 0;
} }

libcxx/test/libcxx/containers/sequences/list/list.ops/debug.splice.pos_list_iter.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
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// <list> // <list>
// void splice(const_iterator position, list<T,Allocator>& x, iterator i); // void splice(const_iterator position, list<T,Allocator>& x, iterator i);
// UNSUPPORTED: libcxx-no-debug-mode, c++03, windows // REQUIRES: has-unistd
// UNSUPPORTED: libcxx-no-debug-mode, c++03
// ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DEBUG=1 // ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DEBUG=1
#include <list> #include <list>
#include "check_assertion.h" #include "check_assertion.h"
int main(int, char**) { int main(int, char**) {
std::list<int> v1(3); std::list<int> v1(3);
std::list<int> v2(3); std::list<int> v2(3);
TEST_LIBCPP_ASSERT_FAILURE( TEST_LIBCPP_ASSERT_FAILURE(
v1.splice(v1.begin(), v2, v1.begin()), v1.splice(v1.begin(), v2, v1.begin()),
"list::splice(iterator, list, iterator) called with the second iterator not referring to the list argument"); "list::splice(iterator, list, iterator) called with the second iterator not referring to the list argument");
return 0; return 0;
} }

libcxx/test/libcxx/containers/sequences/list/list.ops/debug.splice.pos_list_iter_iter.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
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// <list> // <list>
// void splice(const_iterator position, list& x, iterator first, iterator last); // void splice(const_iterator position, list& x, iterator first, iterator last);
// UNSUPPORTED: libcxx-no-debug-mode, c++03, windows // REQUIRES: has-unistd
// UNSUPPORTED: libcxx-no-debug-mode, c++03
// ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DEBUG=1 // ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DEBUG=1
#include <list> #include <list>
#include "check_assertion.h" #include "check_assertion.h"
int main(int, char**) { int main(int, char**) {
std::list<int> v1(3); std::list<int> v1(3);
std::list<int> v2(3); std::list<int> v2(3);
TEST_LIBCPP_ASSERT_FAILURE( TEST_LIBCPP_ASSERT_FAILURE(
v1.splice(v1.begin(), v2, v2.begin(), v1.end()), v1.splice(v1.begin(), v2, v2.begin(), v1.end()),
"list::splice(iterator, list, iterator, iterator) called with third iterator not referring to the list argument"); "list::splice(iterator, list, iterator, iterator) called with third iterator not referring to the list argument");
return 0; return 0;
} }

libcxx/test/libcxx/containers/sequences/vector/assert.back.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
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// <vector> // <vector>
// Call back() on empty container. // Call back() on empty container.
// UNSUPPORTED: c++03, windows // REQUIRES: has-unistd
// UNSUPPORTED: c++03
// XFAIL: use_system_cxx_lib && target={{.+}}-apple-macosx{{10.9|10.10|10.11|10.12|10.13|10.14|10.15|11.0|12.0}} // XFAIL: use_system_cxx_lib && target={{.+}}-apple-macosx{{10.9|10.10|10.11|10.12|10.13|10.14|10.15|11.0|12.0}}
// ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_ENABLE_ASSERTIONS=1 // ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_ENABLE_ASSERTIONS=1
#include <vector> #include <vector>
#include <cassert> #include <cassert>
#include "check_assertion.h" #include "check_assertion.h"
#include "min_allocator.h" #include "min_allocator.h"
Show All 21 Lines

libcxx/test/libcxx/containers/sequences/vector/assert.cback.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
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// <vector> // <vector>
// Call back() on empty const container. // Call back() on empty const container.
// UNSUPPORTED: c++03, windows // REQUIRES: has-unistd
// UNSUPPORTED: c++03
// XFAIL: use_system_cxx_lib && target={{.+}}-apple-macosx{{10.9|10.10|10.11|10.12|10.13|10.14|10.15|11.0|12.0}} // XFAIL: use_system_cxx_lib && target={{.+}}-apple-macosx{{10.9|10.10|10.11|10.12|10.13|10.14|10.15|11.0|12.0}}
// ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_ENABLE_ASSERTIONS=1 // ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_ENABLE_ASSERTIONS=1
#include <vector> #include <vector>
#include "check_assertion.h" #include "check_assertion.h"
#include "min_allocator.h" #include "min_allocator.h"
Show All 17 Lines

libcxx/test/libcxx/containers/sequences/vector/assert.cfront.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
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// <vector> // <vector>
// Call front() on empty const container. // Call front() on empty const container.
// UNSUPPORTED: c++03, windows // REQUIRES: has-unistd
// UNSUPPORTED: c++03
// XFAIL: use_system_cxx_lib && target={{.+}}-apple-macosx{{10.9|10.10|10.11|10.12|10.13|10.14|10.15|11.0|12.0}} // XFAIL: use_system_cxx_lib && target={{.+}}-apple-macosx{{10.9|10.10|10.11|10.12|10.13|10.14|10.15|11.0|12.0}}
// ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_ENABLE_ASSERTIONS=1 // ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_ENABLE_ASSERTIONS=1
#include <vector> #include <vector>
#include "check_assertion.h" #include "check_assertion.h"
#include "min_allocator.h" #include "min_allocator.h"
Show All 17 Lines

libcxx/test/libcxx/containers/sequences/vector/assert.cindex.oob.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
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// <vector> // <vector>
// Index const vector out of bounds. // Index const vector out of bounds.
// UNSUPPORTED: c++03, windows // REQUIRES: has-unistd
// UNSUPPORTED: c++03
// XFAIL: use_system_cxx_lib && target={{.+}}-apple-macosx{{10.9|10.10|10.11|10.12|10.13|10.14|10.15|11.0|12.0}} // XFAIL: use_system_cxx_lib && target={{.+}}-apple-macosx{{10.9|10.10|10.11|10.12|10.13|10.14|10.15|11.0|12.0}}
// ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_ENABLE_ASSERTIONS=1 // ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_ENABLE_ASSERTIONS=1
#include <vector> #include <vector>
#include <cassert> #include <cassert>
#include "check_assertion.h" #include "check_assertion.h"
#include "min_allocator.h" #include "min_allocator.h"
Show All 20 Lines

libcxx/test/libcxx/containers/sequences/vector/assert.front.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
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// <vector> // <vector>
// Call front() on empty container. // Call front() on empty container.
// UNSUPPORTED: c++03, windows // REQUIRES: has-unistd
// UNSUPPORTED: c++03
// XFAIL: use_system_cxx_lib && target={{.+}}-apple-macosx{{10.9|10.10|10.11|10.12|10.13|10.14|10.15|11.0|12.0}} // XFAIL: use_system_cxx_lib && target={{.+}}-apple-macosx{{10.9|10.10|10.11|10.12|10.13|10.14|10.15|11.0|12.0}}
// ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_ENABLE_ASSERTIONS=1 // ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_ENABLE_ASSERTIONS=1
#include <vector> #include <vector>
#include <cassert> #include <cassert>
#include "check_assertion.h" #include "check_assertion.h"
#include "min_allocator.h" #include "min_allocator.h"
Show All 22 Lines

libcxx/test/libcxx/containers/sequences/vector/assert.index.oob.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
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// <vector> // <vector>
// Index vector out of bounds. // Index vector out of bounds.
// UNSUPPORTED: c++03, windows // REQUIRES: has-unistd
// UNSUPPORTED: c++03
// XFAIL: use_system_cxx_lib && target={{.+}}-apple-macosx{{10.9|10.10|10.11|10.12|10.13|10.14|10.15|11.0|12.0}} // XFAIL: use_system_cxx_lib && target={{.+}}-apple-macosx{{10.9|10.10|10.11|10.12|10.13|10.14|10.15|11.0|12.0}}
// ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_ENABLE_ASSERTIONS=1 // ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_ENABLE_ASSERTIONS=1
#include <vector> #include <vector>
#include <cassert> #include <cassert>
#include "check_assertion.h" #include "check_assertion.h"
#include "min_allocator.h" #include "min_allocator.h"
Show All 20 Lines

libcxx/test/libcxx/containers/sequences/vector/assert.pop_back.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
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// <vector> // <vector>
// pop_back() more than the number of elements in a vector // pop_back() more than the number of elements in a vector
// UNSUPPORTED: c++03, windows // REQUIRES: has-unistd
// UNSUPPORTED: c++03
// XFAIL: use_system_cxx_lib && target={{.+}}-apple-macosx{{10.9|10.10|10.11|10.12|10.13|10.14|10.15|11.0|12.0}} // XFAIL: use_system_cxx_lib && target={{.+}}-apple-macosx{{10.9|10.10|10.11|10.12|10.13|10.14|10.15|11.0|12.0}}
// ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_ENABLE_ASSERTIONS=1 // ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_ENABLE_ASSERTIONS=1
#include <vector> #include <vector>
#include "check_assertion.h" #include "check_assertion.h"
int main(int, char**) { int main(int, char**) {
std::vector<int> v; std::vector<int> v;
v.push_back(0); v.push_back(0);
v.pop_back(); v.pop_back();
TEST_LIBCPP_ASSERT_FAILURE(v.pop_back(), "vector::pop_back called on an empty vector"); TEST_LIBCPP_ASSERT_FAILURE(v.pop_back(), "vector::pop_back called on an empty vector");
return 0; return 0;
} }

libcxx/test/libcxx/containers/sequences/vector/debug.iterator.add.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
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// <vector> // <vector>
// Add to iterator out of bounds. // Add to iterator out of bounds.
// UNSUPPORTED: libcxx-no-debug-mode, c++03, windows // REQUIRES: has-unistd
// UNSUPPORTED: libcxx-no-debug-mode, c++03
// ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DEBUG=1 // ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DEBUG=1
#include <vector> #include <vector>
#include <cassert> #include <cassert>
#include "check_assertion.h" #include "check_assertion.h"
#include "min_allocator.h" #include "min_allocator.h"
Show All 25 Lines

libcxx/test/libcxx/containers/sequences/vector/debug.iterator.compare.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
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// <vector> // <vector>
// Compare iterators from different containers with <. // Compare iterators from different containers with <.
// UNSUPPORTED: libcxx-no-debug-mode, c++03, windows // REQUIRES: has-unistd
// UNSUPPORTED: libcxx-no-debug-mode, c++03
// ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DEBUG=1 // ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DEBUG=1
#include <vector> #include <vector>
#include "check_assertion.h" #include "check_assertion.h"
#include "min_allocator.h" #include "min_allocator.h"
int main(int, char**) { int main(int, char**) {
Show All 18 Lines

libcxx/test/libcxx/containers/sequences/vector/debug.iterator.decrement.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
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// <vector> // <vector>
// Decrement iterator prior to begin. // Decrement iterator prior to begin.
// UNSUPPORTED: libcxx-no-debug-mode, c++03, windows // REQUIRES: has-unistd
// UNSUPPORTED: libcxx-no-debug-mode, c++03
// ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DEBUG=1 // ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DEBUG=1
#include <vector> #include <vector>
#include <cassert> #include <cassert>
#include "check_assertion.h" #include "check_assertion.h"
#include "min_allocator.h" #include "min_allocator.h"
Show All 23 Lines

libcxx/test/libcxx/containers/sequences/vector/debug.iterator.dereference.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
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// <vector> // <vector>
// Dereference non-dereferenceable iterator. // Dereference non-dereferenceable iterator.
// UNSUPPORTED: libcxx-no-debug-mode, c++03, windows // REQUIRES: has-unistd
// UNSUPPORTED: libcxx-no-debug-mode, c++03
// ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DEBUG=1 // ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DEBUG=1
#include <vector> #include <vector>
#include "check_assertion.h" #include "check_assertion.h"
#include "min_allocator.h" #include "min_allocator.h"
int main(int, char**) { int main(int, char**) {
Show All 18 Lines

libcxx/test/libcxx/containers/sequences/vector/debug.iterator.increment.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
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// <vector> // <vector>
// Increment iterator past end. // Increment iterator past end.
// UNSUPPORTED: libcxx-no-debug-mode, c++03, windows // REQUIRES: has-unistd
// UNSUPPORTED: libcxx-no-debug-mode, c++03
// ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DEBUG=1 // ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DEBUG=1
#include <vector> #include <vector>
#include <cassert> #include <cassert>
#include "check_assertion.h" #include "check_assertion.h"
#include "min_allocator.h" #include "min_allocator.h"
Show All 23 Lines

libcxx/test/libcxx/containers/sequences/vector/debug.iterator.index.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
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// <vector> // <vector>
// Index iterator out of bounds. // Index iterator out of bounds.
// UNSUPPORTED: libcxx-no-debug-mode, c++03, windows // REQUIRES: has-unistd
// UNSUPPORTED: libcxx-no-debug-mode, c++03
// ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DEBUG=1 // ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DEBUG=1
#include <vector> #include <vector>
#include <cassert> #include <cassert>
#include "check_assertion.h" #include "check_assertion.h"
#include "min_allocator.h" #include "min_allocator.h"
Show All 21 Lines

libcxx/test/libcxx/containers/sequences/vector/debug.iterator.subtract.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
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// <vector> // <vector>
// Subtract iterators from different containers. // Subtract iterators from different containers.
// UNSUPPORTED: libcxx-no-debug-mode, c++03, windows // REQUIRES: has-unistd
// UNSUPPORTED: libcxx-no-debug-mode, c++03
// ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DEBUG=1 // ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DEBUG=1
#include <vector> #include <vector>
#include "check_assertion.h" #include "check_assertion.h"
#include "min_allocator.h" #include "min_allocator.h"
int main(int, char**) { int main(int, char**) {
Show All 18 Lines

libcxx/test/libcxx/containers/unord/unord.map/assert.bucket.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
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// <unordered_map> // <unordered_map>
// size_type bucket(const key_type& __k) const; // size_type bucket(const key_type& __k) const;
// UNSUPPORTED: c++03, windows // REQUIRES: has-unistd
// UNSUPPORTED: c++03
// XFAIL: use_system_cxx_lib && target={{.+}}-apple-macosx{{10.9|10.10|10.11|10.12|10.13|10.14|10.15|11.0|12.0}} // XFAIL: use_system_cxx_lib && target={{.+}}-apple-macosx{{10.9|10.10|10.11|10.12|10.13|10.14|10.15|11.0|12.0}}
// ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_ENABLE_ASSERTIONS=1 // ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_ENABLE_ASSERTIONS=1
#include <unordered_map> #include <unordered_map>
#include <string> #include <string>
#include "check_assertion.h" #include "check_assertion.h"
int main(int, char**) { int main(int, char**) {
typedef std::unordered_map<int, std::string> C; typedef std::unordered_map<int, std::string> C;
C c; C c;
TEST_LIBCPP_ASSERT_FAILURE(c.bucket(3), "unordered container::bucket(key) called when bucket_count() == 0"); TEST_LIBCPP_ASSERT_FAILURE(c.bucket(3), "unordered container::bucket(key) called when bucket_count() == 0");
return 0; return 0;
} }

libcxx/test/libcxx/containers/unord/unord.map/assert.bucket_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
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// <unordered_map> // <unordered_map>
// template <class Key, class T, class Hash = hash<Key>, class Pred = equal_to<Key>, // template <class Key, class T, class Hash = hash<Key>, class Pred = equal_to<Key>,
// class Alloc = allocator<pair<const Key, T>>> // class Alloc = allocator<pair<const Key, T>>>
// class unordered_map // class unordered_map
// size_type bucket_size(size_type n) const // size_type bucket_size(size_type n) const
// UNSUPPORTED: c++03, windows // REQUIRES: has-unistd
// UNSUPPORTED: c++03
// XFAIL: use_system_cxx_lib && target={{.+}}-apple-macosx{{10.9|10.10|10.11|10.12|10.13|10.14|10.15|11.0|12.0}} // XFAIL: use_system_cxx_lib && target={{.+}}-apple-macosx{{10.9|10.10|10.11|10.12|10.13|10.14|10.15|11.0|12.0}}
// ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_ENABLE_ASSERTIONS=1 // ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_ENABLE_ASSERTIONS=1
#include <unordered_map> #include <unordered_map>
#include <string> #include <string>
#include "check_assertion.h" #include "check_assertion.h"
int main(int, char**) { int main(int, char**) {
typedef std::unordered_map<int, std::string> C; typedef std::unordered_map<int, std::string> C;
C c; C c;
TEST_LIBCPP_ASSERT_FAILURE(c.bucket_size(3), "unordered container::bucket_size(n) called with n >= bucket_count()"); TEST_LIBCPP_ASSERT_FAILURE(c.bucket_size(3), "unordered container::bucket_size(n) called with n >= bucket_count()");
return 0; return 0;
} }

libcxx/test/libcxx/containers/unord/unord.map/assert.max_load_factor.pass.cpp

Show All 9 Lines
// template <class Key, class T, class Hash = hash<Key>, class Pred = equal_to<Key>, // template <class Key, class T, class Hash = hash<Key>, class Pred = equal_to<Key>,
// class Alloc = allocator<pair<const Key, T>>> // class Alloc = allocator<pair<const Key, T>>>
// class unordered_map // class unordered_map
// float max_load_factor() const; // float max_load_factor() const;
// void max_load_factor(float mlf); // void max_load_factor(float mlf);
// UNSUPPORTED: c++03, windows // REQUIRES: has-unistd
// UNSUPPORTED: c++03
// XFAIL: use_system_cxx_lib && target={{.+}}-apple-macosx{{10.9|10.10|10.11|10.12|10.13|10.14|10.15|11.0|12.0}} // XFAIL: use_system_cxx_lib && target={{.+}}-apple-macosx{{10.9|10.10|10.11|10.12|10.13|10.14|10.15|11.0|12.0}}
// ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_ENABLE_ASSERTIONS=1 // ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_ENABLE_ASSERTIONS=1
#include <unordered_map> #include <unordered_map>
#include <string> #include <string>
#include "check_assertion.h" #include "check_assertion.h"
int main(int, char**) { int main(int, char**) {
typedef std::unordered_map<int, std::string> C; typedef std::unordered_map<int, std::string> C;
C c; C c;
TEST_LIBCPP_ASSERT_FAILURE(c.max_load_factor(0), "unordered container::max_load_factor(lf) called with lf <= 0"); TEST_LIBCPP_ASSERT_FAILURE(c.max_load_factor(0), "unordered container::max_load_factor(lf) called with lf <= 0");
return 0; return 0;
} }

libcxx/test/libcxx/containers/unord/unord.map/debug.insert.hint_const_lvalue.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
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// <unordered_map> // <unordered_map>
// iterator insert(const_iterator p, const value_type& x); // iterator insert(const_iterator p, const value_type& x);
// UNSUPPORTED: libcxx-no-debug-mode, c++03, windows // REQUIRES: has-unistd
// UNSUPPORTED: libcxx-no-debug-mode, c++03
// ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DEBUG=1 // ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DEBUG=1
#include <unordered_map> #include <unordered_map>
#include "check_assertion.h" #include "check_assertion.h"
#include "test_macros.h" #include "test_macros.h"
int main(int, char**) { int main(int, char**) {
Show All 18 Lines

libcxx/test/libcxx/containers/unord/unord.map/debug.insert.hint_rvalue.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
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// <unordered_map> // <unordered_map>
// template <class P, // template <class P,
// class = typename enable_if<is_convertible<P, value_type>::value>::type> // class = typename enable_if<is_convertible<P, value_type>::value>::type>
// iterator insert(const_iterator p, P&& x); // iterator insert(const_iterator p, P&& x);
// UNSUPPORTED: libcxx-no-debug-mode, c++03, windows // REQUIRES: has-unistd
// UNSUPPORTED: libcxx-no-debug-mode, c++03
// ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DEBUG=1 // ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DEBUG=1
#include <unordered_map> #include <unordered_map>
#include "check_assertion.h" #include "check_assertion.h"
#include "test_macros.h" #include "test_macros.h"
int main(int, char**) { int main(int, char**) {
Show All 11 Lines

libcxx/test/libcxx/containers/unord/unord.map/debug.iterator.dereference.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
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// <unordered_map> // <unordered_map>
// Dereference non-dereferenceable iterator. // Dereference non-dereferenceable iterator.
// UNSUPPORTED: libcxx-no-debug-mode, c++03, windows // REQUIRES: has-unistd
// UNSUPPORTED: libcxx-no-debug-mode, c++03
// ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DEBUG=1 // ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DEBUG=1
#include <unordered_map> #include <unordered_map>
#include <string> #include <string>
#include "check_assertion.h" #include "check_assertion.h"
#include "min_allocator.h" #include "min_allocator.h"
Show All 20 Lines

libcxx/test/libcxx/containers/unord/unord.map/debug.iterator.increment.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
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// <unordered_map> // <unordered_map>
// Increment iterator past end. // Increment iterator past end.
// UNSUPPORTED: libcxx-no-debug-mode, c++03, windows // REQUIRES: has-unistd
// UNSUPPORTED: libcxx-no-debug-mode, c++03
// ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DEBUG=1 // ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DEBUG=1
#include <unordered_map> #include <unordered_map>
#include <cassert> #include <cassert>
#include <string> #include <string>
#include "check_assertion.h" #include "check_assertion.h"
#include "min_allocator.h" #include "min_allocator.h"
Show All 25 Lines

libcxx/test/libcxx/containers/unord/unord.map/debug.local_iterator.dereference.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
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// <unordered_map> // <unordered_map>
// Dereference non-dereferenceable iterator. // Dereference non-dereferenceable iterator.
// UNSUPPORTED: libcxx-no-debug-mode, c++03, windows // REQUIRES: has-unistd
// UNSUPPORTED: libcxx-no-debug-mode, c++03
// ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DEBUG=1 // ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DEBUG=1
#include <unordered_map> #include <unordered_map>
#include <string> #include <string>
#include "check_assertion.h" #include "check_assertion.h"
#include "min_allocator.h" #include "min_allocator.h"
Show All 18 Lines

libcxx/test/libcxx/containers/unord/unord.map/debug.local_iterator.increment.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
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// <unordered_map> // <unordered_map>
// Increment local_iterator past end. // Increment local_iterator past end.
// UNSUPPORTED: libcxx-no-debug-mode, c++03, windows // REQUIRES: has-unistd
// UNSUPPORTED: libcxx-no-debug-mode, c++03
// ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DEBUG=1 // ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DEBUG=1
#include <unordered_map> #include <unordered_map>
#include <string> #include <string>
#include <cassert> #include <cassert>
#include "check_assertion.h" #include "check_assertion.h"
#include "min_allocator.h" #include "min_allocator.h"
Show All 28 Lines

libcxx/test/libcxx/containers/unord/unord.map/debug.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
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// <unordered_map> // <unordered_map>
// template <class Key, class Value, class Hash = hash<Key>, class Pred = equal_to<Key>, // template <class Key, class Value, class Hash = hash<Key>, class Pred = equal_to<Key>,
// class Alloc = allocator<pair<const Key, Value>>> // class Alloc = allocator<pair<const Key, Value>>>
// class unordered_map // class unordered_map
// void swap(unordered_map& x, unordered_map& y); // void swap(unordered_map& x, unordered_map& y);
// UNSUPPORTED: libcxx-no-debug-mode, c++03, windows // REQUIRES: has-unistd
// UNSUPPORTED: libcxx-no-debug-mode, c++03
// ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DEBUG=1 // ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DEBUG=1
#include <unordered_map> #include <unordered_map>
#include "check_assertion.h" #include "check_assertion.h"
int main(int, char**) { int main(int, char**) {
typedef std::pair<int, int> P; typedef std::pair<int, int> P;
Show All 13 Lines

libcxx/test/libcxx/containers/unord/unord.map/unord.map.modifiers/debug.erase.iter.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
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// <unordered_map> // <unordered_map>
// Call erase(const_iterator position) with invalid iterators // Call erase(const_iterator position) with invalid iterators
// UNSUPPORTED: libcxx-no-debug-mode, c++03, windows // REQUIRES: has-unistd
// UNSUPPORTED: libcxx-no-debug-mode, c++03
// ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DEBUG=1 // ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DEBUG=1
#include <unordered_map> #include <unordered_map>
#include "check_assertion.h" #include "check_assertion.h"
int main(int, char**) { int main(int, char**) {
// With end() // With end()
Show All 22 Lines

libcxx/test/libcxx/containers/unord/unord.map/unord.map.modifiers/debug.erase.iter_iter.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
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// <unordered_map> // <unordered_map>
// Call erase(const_iterator first, const_iterator last); with invalid iterators // Call erase(const_iterator first, const_iterator last); with invalid iterators
// UNSUPPORTED: libcxx-no-debug-mode, c++03, windows // REQUIRES: has-unistd
// UNSUPPORTED: libcxx-no-debug-mode, c++03
// ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DEBUG=1 // ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DEBUG=1
#include <unordered_map> #include <unordered_map>
#include "check_assertion.h" #include "check_assertion.h"
int main(int, char**) { int main(int, char**) {
// First iterator from a different container // First iterator from a different container
▲ Show 20 Lines • Show All 43 Lines • Show Last 20 Lines

libcxx/test/libcxx/containers/unord/unord.multimap/assert.bucket.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
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// <unordered_map> // <unordered_map>
// template <class Key, class T, class Hash = hash<Key>, class Pred = equal_to<Key>, // template <class Key, class T, class Hash = hash<Key>, class Pred = equal_to<Key>,
// class Alloc = allocator<pair<const Key, T>>> // class Alloc = allocator<pair<const Key, T>>>
// class unordered_multimap // class unordered_multimap
// size_type bucket(const key_type& __k) const; // size_type bucket(const key_type& __k) const;
// UNSUPPORTED: c++03, windows // REQUIRES: has-unistd
// UNSUPPORTED: c++03
// XFAIL: use_system_cxx_lib && target={{.+}}-apple-macosx{{10.9|10.10|10.11|10.12|10.13|10.14|10.15|11.0|12.0}} // XFAIL: use_system_cxx_lib && target={{.+}}-apple-macosx{{10.9|10.10|10.11|10.12|10.13|10.14|10.15|11.0|12.0}}
// ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_ENABLE_ASSERTIONS=1 // ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_ENABLE_ASSERTIONS=1
#include <unordered_map> #include <unordered_map>
#include <string> #include <string>
#include "check_assertion.h" #include "check_assertion.h"
int main(int, char**) { int main(int, char**) {
typedef std::unordered_multimap<int, std::string> C; typedef std::unordered_multimap<int, std::string> C;
C c; C c;
TEST_LIBCPP_ASSERT_FAILURE(c.bucket(3), "unordered container::bucket(key) called when bucket_count() == 0"); TEST_LIBCPP_ASSERT_FAILURE(c.bucket(3), "unordered container::bucket(key) called when bucket_count() == 0");
return 0; return 0;
} }

libcxx/test/libcxx/containers/unord/unord.multimap/assert.bucket_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
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// <unordered_map> // <unordered_map>
// template <class Key, class T, class Hash = hash<Key>, class Pred = equal_to<Key>, // template <class Key, class T, class Hash = hash<Key>, class Pred = equal_to<Key>,
// class Alloc = allocator<pair<const Key, T>>> // class Alloc = allocator<pair<const Key, T>>>
// class unordered_multimap // class unordered_multimap
// size_type bucket_size(size_type n) const // size_type bucket_size(size_type n) const
// UNSUPPORTED: c++03, windows // REQUIRES: has-unistd
// UNSUPPORTED: c++03
// XFAIL: use_system_cxx_lib && target={{.+}}-apple-macosx{{10.9|10.10|10.11|10.12|10.13|10.14|10.15|11.0|12.0}} // XFAIL: use_system_cxx_lib && target={{.+}}-apple-macosx{{10.9|10.10|10.11|10.12|10.13|10.14|10.15|11.0|12.0}}
// ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_ENABLE_ASSERTIONS=1 // ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_ENABLE_ASSERTIONS=1
#include <unordered_map> #include <unordered_map>
#include <string> #include <string>
#include "check_assertion.h" #include "check_assertion.h"
int main(int, char**) { int main(int, char**) {
typedef std::unordered_multimap<int, std::string> C; typedef std::unordered_multimap<int, std::string> C;
C c; C c;
TEST_LIBCPP_ASSERT_FAILURE(c.bucket_size(3), "unordered container::bucket_size(n) called with n >= bucket_count()"); TEST_LIBCPP_ASSERT_FAILURE(c.bucket_size(3), "unordered container::bucket_size(n) called with n >= bucket_count()");
return 0; return 0;
} }

libcxx/test/libcxx/containers/unord/unord.multimap/assert.max_load_factor.pass.cpp

Show All 9 Lines
// template <class Key, class T, class Hash = hash<Key>, class Pred = equal_to<Key>, // template <class Key, class T, class Hash = hash<Key>, class Pred = equal_to<Key>,
// class Alloc = allocator<pair<const Key, T>>> // class Alloc = allocator<pair<const Key, T>>>
// class unordered_multimap // class unordered_multimap
// float max_load_factor() const; // float max_load_factor() const;
// void max_load_factor(float mlf); // void max_load_factor(float mlf);
// UNSUPPORTED: c++03, windows // REQUIRES: has-unistd
// UNSUPPORTED: c++03
// XFAIL: use_system_cxx_lib && target={{.+}}-apple-macosx{{10.9|10.10|10.11|10.12|10.13|10.14|10.15|11.0|12.0}} // XFAIL: use_system_cxx_lib && target={{.+}}-apple-macosx{{10.9|10.10|10.11|10.12|10.13|10.14|10.15|11.0|12.0}}
// ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_ENABLE_ASSERTIONS=1 // ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_ENABLE_ASSERTIONS=1
#include <unordered_map> #include <unordered_map>
#include <string> #include <string>
#include "check_assertion.h" #include "check_assertion.h"
int main(int, char**) { int main(int, char**) {
typedef std::unordered_multimap<int, std::string> C; typedef std::unordered_multimap<int, std::string> C;
C c; C c;
TEST_LIBCPP_ASSERT_FAILURE(c.max_load_factor(0), "unordered container::max_load_factor(lf) called with lf <= 0"); TEST_LIBCPP_ASSERT_FAILURE(c.max_load_factor(0), "unordered container::max_load_factor(lf) called with lf <= 0");
return 0; return 0;
} }

libcxx/test/libcxx/containers/unord/unord.multimap/debug.insert.hint_const_lvalue.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
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// <unordered_map> // <unordered_map>
// iterator insert(const_iterator p, const value_type& x); // iterator insert(const_iterator p, const value_type& x);
// UNSUPPORTED: libcxx-no-debug-mode, c++03, windows // REQUIRES: has-unistd
// UNSUPPORTED: libcxx-no-debug-mode, c++03
// ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DEBUG=1 // ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DEBUG=1
#include <unordered_map> #include <unordered_map>
#include "check_assertion.h" #include "check_assertion.h"
int main(int, char**) { int main(int, char**) {
typedef std::unordered_multimap<double, int> C; typedef std::unordered_multimap<double, int> C;
Show All 11 Lines

libcxx/test/libcxx/containers/unord/unord.multimap/debug.insert.hint_rvalue.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
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// <unordered_map> // <unordered_map>
// template <class P, // template <class P,
// class = typename enable_if<is_convertible<P, value_type>::value>::type> // class = typename enable_if<is_convertible<P, value_type>::value>::type>
// iterator insert(const_iterator p, P&& x); // iterator insert(const_iterator p, P&& x);
// UNSUPPORTED: libcxx-no-debug-mode, c++03, windows // REQUIRES: has-unistd
// UNSUPPORTED: libcxx-no-debug-mode, c++03
// ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DEBUG=1 // ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DEBUG=1
#include <unordered_map> #include <unordered_map>
#include "check_assertion.h" #include "check_assertion.h"
int main(int, char**) { int main(int, char**) {
typedef std::unordered_multimap<double, int> C; typedef std::unordered_multimap<double, int> C;
Show All 10 Lines

libcxx/test/libcxx/containers/unord/unord.multimap/debug.iterator.dereference.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
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// <unordered_map> // <unordered_map>
// Dereference non-dereferenceable iterator. // Dereference non-dereferenceable iterator.
// UNSUPPORTED: libcxx-no-debug-mode, c++03, windows // REQUIRES: has-unistd
// UNSUPPORTED: libcxx-no-debug-mode, c++03
// ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DEBUG=1 // ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DEBUG=1
#include <string> #include <string>
#include <unordered_map> #include <unordered_map>
#include "check_assertion.h" #include "check_assertion.h"
#include "min_allocator.h" #include "min_allocator.h"
Show All 20 Lines

libcxx/test/libcxx/containers/unord/unord.multimap/debug.iterator.increment.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
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// <unordered_map> // <unordered_map>
// Increment iterator past end. // Increment iterator past end.
// UNSUPPORTED: libcxx-no-debug-mode, c++03, windows // REQUIRES: has-unistd
// UNSUPPORTED: libcxx-no-debug-mode, c++03
// ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DEBUG=1 // ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DEBUG=1
#include <unordered_map> #include <unordered_map>
#include <cassert> #include <cassert>
#include <string> #include <string>
#include "check_assertion.h" #include "check_assertion.h"
#include "min_allocator.h" #include "min_allocator.h"
Show All 25 Lines

libcxx/test/libcxx/containers/unord/unord.multimap/debug.local_iterator.dereference.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
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// <unordered_map> // <unordered_map>
// Dereference non-dereferenceable iterator. // Dereference non-dereferenceable iterator.
// UNSUPPORTED: libcxx-no-debug-mode, c++03, windows // REQUIRES: has-unistd
// UNSUPPORTED: libcxx-no-debug-mode, c++03
// ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DEBUG=1 // ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DEBUG=1
#include <unordered_map> #include <unordered_map>
#include <string> #include <string>
#include "check_assertion.h" #include "check_assertion.h"
#include "min_allocator.h" #include "min_allocator.h"
Show All 18 Lines

libcxx/test/libcxx/containers/unord/unord.multimap/debug.local_iterator.increment.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
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// <unordered_map> // <unordered_map>
// Increment local_iterator past end. // Increment local_iterator past end.
// UNSUPPORTED: libcxx-no-debug-mode, c++03, windows // REQUIRES: has-unistd
// UNSUPPORTED: libcxx-no-debug-mode, c++03
// ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DEBUG=1 // ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DEBUG=1
#include <unordered_map> #include <unordered_map>
#include <cassert> #include <cassert>
#include <string> #include <string>
#include "check_assertion.h" #include "check_assertion.h"
#include "min_allocator.h" #include "min_allocator.h"
Show All 29 Lines

libcxx/test/libcxx/containers/unord/unord.multimap/debug.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
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// <unordered_map> // <unordered_map>
// template <class Key, class Value, class Hash = hash<Key>, class Pred = equal_to<Key>, // template <class Key, class Value, class Hash = hash<Key>, class Pred = equal_to<Key>,
// class Alloc = allocator<pair<const Key, Value>>> // class Alloc = allocator<pair<const Key, Value>>>
// class unordered_multimap // class unordered_multimap
// void swap(unordered_multimap& x, unordered_multimap& y); // void swap(unordered_multimap& x, unordered_multimap& y);
// UNSUPPORTED: libcxx-no-debug-mode, c++03, windows // REQUIRES: has-unistd
// UNSUPPORTED: libcxx-no-debug-mode, c++03
// ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DEBUG=1 // ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DEBUG=1
#include <unordered_map> #include <unordered_map>
#include "check_assertion.h" #include "check_assertion.h"
int main(int, char**) { int main(int, char**) {
typedef std::pair<int, int> P; typedef std::pair<int, int> P;
Show All 13 Lines

libcxx/test/libcxx/containers/unord/unord.multimap/unord.multimap.modifiers/debug.erase.iter.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
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// <unordered_map> // <unordered_map>
// Call erase(const_iterator position) with invalid iterators // Call erase(const_iterator position) with invalid iterators
// UNSUPPORTED: libcxx-no-debug-mode, c++03, windows // REQUIRES: has-unistd
// UNSUPPORTED: libcxx-no-debug-mode, c++03
// ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DEBUG=1 // ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DEBUG=1
#include <unordered_map> #include <unordered_map>
#include "check_assertion.h" #include "check_assertion.h"
int main(int, char**) { int main(int, char**) {
// With end() // With end()
Show All 22 Lines

libcxx/test/libcxx/containers/unord/unord.multimap/unord.multimap.modifiers/debug.erase.iter_iter.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
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// <unordered_map> // <unordered_map>
// Call erase(const_iterator first, const_iterator last); with invalid iterators // Call erase(const_iterator first, const_iterator last); with invalid iterators
// UNSUPPORTED: libcxx-no-debug-mode, c++03, windows // REQUIRES: has-unistd
// UNSUPPORTED: libcxx-no-debug-mode, c++03
// ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DEBUG=1 // ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DEBUG=1
#include <unordered_map> #include <unordered_map>
#include "check_assertion.h" #include "check_assertion.h"
int main(int, char**) { int main(int, char**) {
// With first iterator from another container // With first iterator from another container
▲ Show 20 Lines • Show All 43 Lines • Show Last 20 Lines

libcxx/test/libcxx/containers/unord/unord.multiset/assert.bucket.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
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// <unordered_set> // <unordered_set>
// template <class Value, class Hash = hash<Value>, class Pred = equal_to<Value>, // template <class Value, class Hash = hash<Value>, class Pred = equal_to<Value>,
// class Alloc = allocator<Value>> // class Alloc = allocator<Value>>
// class unordered_multiset // class unordered_multiset
// size_type bucket(const key_type& __k) const; // size_type bucket(const key_type& __k) const;
// UNSUPPORTED: c++03, windows // REQUIRES: has-unistd
// UNSUPPORTED: c++03
// XFAIL: use_system_cxx_lib && target={{.+}}-apple-macosx{{10.9|10.10|10.11|10.12|10.13|10.14|10.15|11.0|12.0}} // XFAIL: use_system_cxx_lib && target={{.+}}-apple-macosx{{10.9|10.10|10.11|10.12|10.13|10.14|10.15|11.0|12.0}}
// ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_ENABLE_ASSERTIONS=1 // ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_ENABLE_ASSERTIONS=1
#include <unordered_set> #include <unordered_set>
#include "check_assertion.h" #include "check_assertion.h"
int main(int, char**) { int main(int, char**) {
typedef std::unordered_multiset<int> C; typedef std::unordered_multiset<int> C;
C c; C c;
TEST_LIBCPP_ASSERT_FAILURE(c.bucket(3), "unordered container::bucket(key) called when bucket_count() == 0"); TEST_LIBCPP_ASSERT_FAILURE(c.bucket(3), "unordered container::bucket(key) called when bucket_count() == 0");
return 0; return 0;
} }

libcxx/test/libcxx/containers/unord/unord.multiset/assert.bucket_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
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// <unordered_set> // <unordered_set>
// template <class Value, class Hash = hash<Value>, class Pred = equal_to<Value>, // template <class Value, class Hash = hash<Value>, class Pred = equal_to<Value>,
// class Alloc = allocator<Value>> // class Alloc = allocator<Value>>
// class unordered_multiset // class unordered_multiset
// size_type bucket_size(size_type n) const // size_type bucket_size(size_type n) const
// UNSUPPORTED: c++03, windows // REQUIRES: has-unistd
// UNSUPPORTED: c++03
// XFAIL: use_system_cxx_lib && target={{.+}}-apple-macosx{{10.9|10.10|10.11|10.12|10.13|10.14|10.15|11.0|12.0}} // XFAIL: use_system_cxx_lib && target={{.+}}-apple-macosx{{10.9|10.10|10.11|10.12|10.13|10.14|10.15|11.0|12.0}}
// ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_ENABLE_ASSERTIONS=1 // ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_ENABLE_ASSERTIONS=1
#include <unordered_set> #include <unordered_set>
#include "check_assertion.h" #include "check_assertion.h"
int main(int, char**) { int main(int, char**) {
typedef std::unordered_multiset<int> C; typedef std::unordered_multiset<int> C;
C c; C c;
TEST_LIBCPP_ASSERT_FAILURE(c.bucket_size(3), "unordered container::bucket_size(n) called with n >= bucket_count()"); TEST_LIBCPP_ASSERT_FAILURE(c.bucket_size(3), "unordered container::bucket_size(n) called with n >= bucket_count()");
return 0; return 0;
} }

libcxx/test/libcxx/containers/unord/unord.multiset/assert.max_load_factor.pass.cpp

Show All 9 Lines
// template <class Value, class Hash = hash<Value>, class Pred = equal_to<Value>, // template <class Value, class Hash = hash<Value>, class Pred = equal_to<Value>,
// class Alloc = allocator<Value>> // class Alloc = allocator<Value>>
// class unordered_multiset // class unordered_multiset
// float max_load_factor() const; // float max_load_factor() const;
// void max_load_factor(float mlf); // void max_load_factor(float mlf);
// UNSUPPORTED: c++03, windows // REQUIRES: has-unistd
// UNSUPPORTED: c++03
// XFAIL: use_system_cxx_lib && target={{.+}}-apple-macosx{{10.9|10.10|10.11|10.12|10.13|10.14|10.15|11.0|12.0}} // XFAIL: use_system_cxx_lib && target={{.+}}-apple-macosx{{10.9|10.10|10.11|10.12|10.13|10.14|10.15|11.0|12.0}}
// ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_ENABLE_ASSERTIONS=1 // ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_ENABLE_ASSERTIONS=1
#include <unordered_set> #include <unordered_set>
#include "check_assertion.h" #include "check_assertion.h"
int main(int, char**) { int main(int, char**) {
typedef std::unordered_multiset<int> C; typedef std::unordered_multiset<int> C;
C c; C c;
TEST_LIBCPP_ASSERT_FAILURE(c.max_load_factor(0), "unordered container::max_load_factor(lf) called with lf <= 0"); TEST_LIBCPP_ASSERT_FAILURE(c.max_load_factor(0), "unordered container::max_load_factor(lf) called with lf <= 0");
return 0; return 0;
} }

libcxx/test/libcxx/containers/unord/unord.multiset/debug.erase.iter.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
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// <unordered_set> // <unordered_set>
// Call erase(const_iterator position) with invalid iterators // Call erase(const_iterator position) with invalid iterators
// UNSUPPORTED: libcxx-no-debug-mode, c++03, windows // REQUIRES: has-unistd
// UNSUPPORTED: libcxx-no-debug-mode, c++03
// ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DEBUG=1 // ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DEBUG=1
#include <unordered_set> #include <unordered_set>
#include "check_assertion.h" #include "check_assertion.h"
int main(int, char**) { int main(int, char**) {
// With end() // With end()
Show All 20 Lines

libcxx/test/libcxx/containers/unord/unord.multiset/debug.erase.iter_iter.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
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// <unordered_set> // <unordered_set>
// Call erase(const_iterator first, const_iterator last); with invalid iterators // Call erase(const_iterator first, const_iterator last); with invalid iterators
// UNSUPPORTED: libcxx-no-debug-mode, c++03, windows // REQUIRES: has-unistd
// UNSUPPORTED: libcxx-no-debug-mode, c++03
// ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DEBUG=1 // ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DEBUG=1
#include <unordered_set> #include <unordered_set>
#include "check_assertion.h" #include "check_assertion.h"
int main(int, char**) { int main(int, char**) {
// With first iterator from another container // With first iterator from another container
Show All 39 Lines

libcxx/test/libcxx/containers/unord/unord.multiset/debug.insert.hint_const_lvalue.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
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// <unordered_set> // <unordered_set>
// iterator insert(const_iterator p, const value_type& x); // iterator insert(const_iterator p, const value_type& x);
// UNSUPPORTED: libcxx-no-debug-mode, c++03, windows // REQUIRES: has-unistd
// UNSUPPORTED: libcxx-no-debug-mode, c++03
// ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DEBUG=1 // ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DEBUG=1
#include <unordered_set> #include <unordered_set>
#include "check_assertion.h" #include "check_assertion.h"
int main(int, char**) { int main(int, char**) {
typedef std::unordered_multiset<double> C; typedef std::unordered_multiset<double> C;
Show All 11 Lines

libcxx/test/libcxx/containers/unord/unord.multiset/debug.iterator.dereference.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
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// <unordered_set> // <unordered_set>
// Dereference non-dereferenceable iterator. // Dereference non-dereferenceable iterator.
// UNSUPPORTED: libcxx-no-debug-mode, c++03, windows // REQUIRES: has-unistd
// UNSUPPORTED: libcxx-no-debug-mode, c++03
// ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DEBUG=1 // ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DEBUG=1
#include <unordered_set> #include <unordered_set>
#include "check_assertion.h" #include "check_assertion.h"
#include "min_allocator.h" #include "min_allocator.h"
int main(int, char**) { int main(int, char**) {
Show All 18 Lines

libcxx/test/libcxx/containers/unord/unord.multiset/debug.iterator.increment.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
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// <unordered_set> // <unordered_set>
// Increment iterator past end. // Increment iterator past end.
// UNSUPPORTED: libcxx-no-debug-mode, c++03, windows // REQUIRES: has-unistd
// UNSUPPORTED: libcxx-no-debug-mode, c++03
// ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DEBUG=1 // ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DEBUG=1
#include <unordered_set> #include <unordered_set>
#include <cassert> #include <cassert>
#include "check_assertion.h" #include "check_assertion.h"
#include "min_allocator.h" #include "min_allocator.h"
Show All 26 Lines

libcxx/test/libcxx/containers/unord/unord.multiset/debug.local_iterator.dereference.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
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// <unordered_set> // <unordered_set>
// Dereference non-dereferenceable iterator. // Dereference non-dereferenceable iterator.
// UNSUPPORTED: libcxx-no-debug-mode, c++03, windows // REQUIRES: has-unistd
// UNSUPPORTED: libcxx-no-debug-mode, c++03
// ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DEBUG=1 // ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DEBUG=1
#include <unordered_set> #include <unordered_set>
#include "check_assertion.h" #include "check_assertion.h"
#include "min_allocator.h" #include "min_allocator.h"
int main(int, char**) { int main(int, char**) {
Show All 20 Lines

libcxx/test/libcxx/containers/unord/unord.multiset/debug.local_iterator.increment.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
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// <unordered_set> // <unordered_set>
// Increment local_iterator past end. // Increment local_iterator past end.
// UNSUPPORTED: libcxx-no-debug-mode, c++03, windows // REQUIRES: has-unistd
// UNSUPPORTED: libcxx-no-debug-mode, c++03
// ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DEBUG=1 // ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DEBUG=1
#include <unordered_set> #include <unordered_set>
#include <cassert> #include <cassert>
#include "check_assertion.h" #include "check_assertion.h"
#include "min_allocator.h" #include "min_allocator.h"
Show All 30 Lines

libcxx/test/libcxx/containers/unord/unord.multiset/debug.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
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// <unordered_set> // <unordered_set>
// template <class Value, class Hash = hash<Value>, class Pred = equal_to<Value>, // template <class Value, class Hash = hash<Value>, class Pred = equal_to<Value>,
// class Alloc = allocator<Value>> // class Alloc = allocator<Value>>
// class unordered_multiset // class unordered_multiset
// void swap(unordered_multiset& x, unordered_multiset& y); // void swap(unordered_multiset& x, unordered_multiset& y);
// UNSUPPORTED: libcxx-no-debug-mode, c++03, windows // REQUIRES: has-unistd
// UNSUPPORTED: libcxx-no-debug-mode, c++03
// ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DEBUG=1 // ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DEBUG=1
#include <unordered_set> #include <unordered_set>
#include "check_assertion.h" #include "check_assertion.h"
int main(int, char**) { int main(int, char**) {
int a1[] = {1, 3, 7, 9, 10}; int a1[] = {1, 3, 7, 9, 10};
Show All 12 Lines

libcxx/test/libcxx/containers/unord/unord.set/assert.bucket.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
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// <unordered_set> // <unordered_set>
// template <class Value, class Hash = hash<Value>, class Pred = equal_to<Value>, // template <class Value, class Hash = hash<Value>, class Pred = equal_to<Value>,
// class Alloc = allocator<Value>> // class Alloc = allocator<Value>>
// class unordered_set // class unordered_set
// size_type bucket(const key_type& __k) const; // size_type bucket(const key_type& __k) const;
// UNSUPPORTED: c++03, windows // REQUIRES: has-unistd
// UNSUPPORTED: c++03
// XFAIL: use_system_cxx_lib && target={{.+}}-apple-macosx{{10.9|10.10|10.11|10.12|10.13|10.14|10.15|11.0|12.0}} // XFAIL: use_system_cxx_lib && target={{.+}}-apple-macosx{{10.9|10.10|10.11|10.12|10.13|10.14|10.15|11.0|12.0}}
// ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_ENABLE_ASSERTIONS=1 // ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_ENABLE_ASSERTIONS=1
#include <unordered_set> #include <unordered_set>
#include "check_assertion.h" #include "check_assertion.h"
int main(int, char**) { int main(int, char**) {
typedef std::unordered_set<int> C; typedef std::unordered_set<int> C;
C c; C c;
TEST_LIBCPP_ASSERT_FAILURE(c.bucket(3), "unordered container::bucket(key) called when bucket_count() == 0"); TEST_LIBCPP_ASSERT_FAILURE(c.bucket(3), "unordered container::bucket(key) called when bucket_count() == 0");
return 0; return 0;
} }

libcxx/test/libcxx/containers/unord/unord.set/assert.bucket_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
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// <unordered_set> // <unordered_set>
// template <class Value, class Hash = hash<Value>, class Pred = equal_to<Value>, // template <class Value, class Hash = hash<Value>, class Pred = equal_to<Value>,
// class Alloc = allocator<Value>> // class Alloc = allocator<Value>>
// class unordered_set // class unordered_set
// size_type bucket_size(size_type n) const // size_type bucket_size(size_type n) const
// UNSUPPORTED: c++03, windows // REQUIRES: has-unistd
// UNSUPPORTED: c++03
// XFAIL: use_system_cxx_lib && target={{.+}}-apple-macosx{{10.9|10.10|10.11|10.12|10.13|10.14|10.15|11.0|12.0}} // XFAIL: use_system_cxx_lib && target={{.+}}-apple-macosx{{10.9|10.10|10.11|10.12|10.13|10.14|10.15|11.0|12.0}}
// ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_ENABLE_ASSERTIONS=1 // ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_ENABLE_ASSERTIONS=1
#include <unordered_set> #include <unordered_set>
#include "check_assertion.h" #include "check_assertion.h"
int main(int, char**) { int main(int, char**) {
typedef std::unordered_set<int> C; typedef std::unordered_set<int> C;
C c; C c;
TEST_LIBCPP_ASSERT_FAILURE(c.bucket_size(3), "unordered container::bucket_size(n) called with n >= bucket_count()"); TEST_LIBCPP_ASSERT_FAILURE(c.bucket_size(3), "unordered container::bucket_size(n) called with n >= bucket_count()");
return 0; return 0;
} }

libcxx/test/libcxx/containers/unord/unord.set/assert.max_load_factor.pass.cpp

Show All 9 Lines
// template <class Value, class Hash = hash<Value>, class Pred = equal_to<Value>, // template <class Value, class Hash = hash<Value>, class Pred = equal_to<Value>,
// class Alloc = allocator<Value>> // class Alloc = allocator<Value>>
// class unordered_set // class unordered_set
// float max_load_factor() const; // float max_load_factor() const;
// void max_load_factor(float mlf); // void max_load_factor(float mlf);
// UNSUPPORTED: c++03, windows // REQUIRES: has-unistd
// UNSUPPORTED: c++03
// XFAIL: use_system_cxx_lib && target={{.+}}-apple-macosx{{10.9|10.10|10.11|10.12|10.13|10.14|10.15|11.0|12.0}} // XFAIL: use_system_cxx_lib && target={{.+}}-apple-macosx{{10.9|10.10|10.11|10.12|10.13|10.14|10.15|11.0|12.0}}
// ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_ENABLE_ASSERTIONS=1 // ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_ENABLE_ASSERTIONS=1
#include <unordered_set> #include <unordered_set>
#include "check_assertion.h" #include "check_assertion.h"
int main(int, char**) { int main(int, char**) {
typedef std::unordered_set<int> C; typedef std::unordered_set<int> C;
C c; C c;
TEST_LIBCPP_ASSERT_FAILURE(c.max_load_factor(-0.5f), TEST_LIBCPP_ASSERT_FAILURE(c.max_load_factor(-0.5f),
"unordered container::max_load_factor(lf) called with lf <= 0"); "unordered container::max_load_factor(lf) called with lf <= 0");
return 0; return 0;
} }

libcxx/test/libcxx/containers/unord/unord.set/debug.erase.iter.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
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// <unordered_set> // <unordered_set>
// Call erase(const_iterator position) with invalid iterators // Call erase(const_iterator position) with invalid iterators
// UNSUPPORTED: libcxx-no-debug-mode, c++03, windows // REQUIRES: has-unistd
// UNSUPPORTED: libcxx-no-debug-mode, c++03
// ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DEBUG=1 // ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DEBUG=1
#include <unordered_set> #include <unordered_set>
#include "check_assertion.h" #include "check_assertion.h"
int main(int, char**) { int main(int, char**) {
// With end() // With end()
Show All 20 Lines

libcxx/test/libcxx/containers/unord/unord.set/debug.erase.iter_iter.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
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// <unordered_set> // <unordered_set>
// Call erase(const_iterator first, const_iterator last); with first iterator from another container // Call erase(const_iterator first, const_iterator last); with first iterator from another container
// UNSUPPORTED: libcxx-no-debug-mode, c++03, windows // REQUIRES: has-unistd
// UNSUPPORTED: libcxx-no-debug-mode, c++03
// ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DEBUG=1 // ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DEBUG=1
#include <unordered_set> #include <unordered_set>
#include "check_assertion.h" #include "check_assertion.h"
int main(int, char**) { int main(int, char**) {
// With first iterator from another container // With first iterator from another container
Show All 39 Lines

libcxx/test/libcxx/containers/unord/unord.set/debug.insert.hint_const_lvalue.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
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// <unordered_set> // <unordered_set>
// iterator insert(const_iterator p, const value_type& x); // iterator insert(const_iterator p, const value_type& x);
// UNSUPPORTED: libcxx-no-debug-mode, c++03, windows // REQUIRES: has-unistd
// UNSUPPORTED: libcxx-no-debug-mode, c++03
// ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DEBUG=1 // ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DEBUG=1
#include <unordered_set> #include <unordered_set>
#include "check_assertion.h" #include "check_assertion.h"
int main(int, char**) { int main(int, char**) {
typedef std::unordered_set<double> C; typedef std::unordered_set<double> C;
Show All 11 Lines

libcxx/test/libcxx/containers/unord/unord.set/debug.iterator.dereference.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
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// <unordered_set> // <unordered_set>
// Dereference non-dereferenceable iterator. // Dereference non-dereferenceable iterator.
// UNSUPPORTED: libcxx-no-debug-mode, c++03, windows // REQUIRES: has-unistd
// UNSUPPORTED: libcxx-no-debug-mode, c++03
// ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DEBUG=1 // ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DEBUG=1
#include <unordered_set> #include <unordered_set>
#include "check_assertion.h" #include "check_assertion.h"
#include "min_allocator.h" #include "min_allocator.h"
int main(int, char**) { int main(int, char**) {
Show All 18 Lines

libcxx/test/libcxx/containers/unord/unord.set/debug.iterator.increment.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
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// <unordered_set> // <unordered_set>
// Increment iterator past end. // Increment iterator past end.
// UNSUPPORTED: libcxx-no-debug-mode, c++03, windows // REQUIRES: has-unistd
// UNSUPPORTED: libcxx-no-debug-mode, c++03
// ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DEBUG=1 // ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DEBUG=1
#include <unordered_set> #include <unordered_set>
#include <cassert> #include <cassert>
#include "check_assertion.h" #include "check_assertion.h"
#include "min_allocator.h" #include "min_allocator.h"
Show All 26 Lines

libcxx/test/libcxx/containers/unord/unord.set/debug.local_iterator.dereference.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
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// <unordered_set> // <unordered_set>
// Dereference non-dereferenceable iterator. // Dereference non-dereferenceable iterator.
// UNSUPPORTED: libcxx-no-debug-mode, c++03, windows // REQUIRES: has-unistd
// UNSUPPORTED: libcxx-no-debug-mode, c++03
// ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DEBUG=1 // ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DEBUG=1
#include <unordered_set> #include <unordered_set>
#include "check_assertion.h" #include "check_assertion.h"
#include "min_allocator.h" #include "min_allocator.h"
int main(int, char**) { int main(int, char**) {
Show All 20 Lines

libcxx/test/libcxx/containers/unord/unord.set/debug.local_iterator.increment.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
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// <unordered_set> // <unordered_set>
// Increment local_iterator past end. // Increment local_iterator past end.
// UNSUPPORTED: libcxx-no-debug-mode, c++03, windows // REQUIRES: has-unistd
// UNSUPPORTED: libcxx-no-debug-mode, c++03
// ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DEBUG=1 // ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DEBUG=1
#include <unordered_set> #include <unordered_set>
#include <cassert> #include <cassert>
#include "check_assertion.h" #include "check_assertion.h"
#include "min_allocator.h" #include "min_allocator.h"
Show All 28 Lines

libcxx/test/libcxx/containers/unord/unord.set/debug.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
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// <unordered_set> // <unordered_set>
// template <class Value, class Hash = hash<Value>, class Pred = equal_to<Value>, // template <class Value, class Hash = hash<Value>, class Pred = equal_to<Value>,
// class Alloc = allocator<Value>> // class Alloc = allocator<Value>>
// class unordered_set // class unordered_set
// void swap(unordered_set& x, unordered_set& y); // void swap(unordered_set& x, unordered_set& y);
// UNSUPPORTED: libcxx-no-debug-mode, c++03, windows // REQUIRES: has-unistd
// UNSUPPORTED: libcxx-no-debug-mode, c++03
// ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DEBUG=1 // ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DEBUG=1
#include <unordered_set> #include <unordered_set>
#include "check_assertion.h" #include "check_assertion.h"
int main(int, char**) { int main(int, char**) {
int a1[] = {1, 3, 7, 9, 10}; int a1[] = {1, 3, 7, 9, 10};
Show All 12 Lines

libcxx/test/libcxx/debug/containers/associative_containers.pass.cpp

//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// REQUIRES: has-unistd
// UNSUPPORTED: c++11, c++14 // UNSUPPORTED: c++11, c++14
MordanteUnsubmitted
Not Done
ReplyInline Actions

Nit maybe merge the two unsupported lines, here and similar tests below.

Mordante: Nit maybe merge the two unsupported lines, here and similar tests below.
// UNSUPPORTED: libcxx-no-debug-mode, c++03, windows // UNSUPPORTED: libcxx-no-debug-mode, c++03
// ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DEBUG=1 // ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DEBUG=1
// test container debugging // test container debugging
#include <map> #include <map>
#include <set> #include <set>
#include <utility> #include <utility>
#include <cassert> #include <cassert>
▲ Show 20 Lines • Show All 43 Lines • Show Last 20 Lines

libcxx/test/libcxx/debug/containers/sequence_container_iterators.pass.cpp

//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// REQUIRES: has-unistd
// UNSUPPORTED: c++11, c++14 // UNSUPPORTED: c++11, c++14
// UNSUPPORTED: libcxx-no-debug-mode, c++03, windows // UNSUPPORTED: libcxx-no-debug-mode, c++03
// ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DEBUG=1 // ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DEBUG=1
// test container debugging // test container debugging
#include <forward_list> #include <forward_list>
#include <list> #include <list>
#include <vector> #include <vector>
#include <deque> #include <deque>
▲ Show 20 Lines • Show All 316 Lines • Show Last 20 Lines

libcxx/test/libcxx/debug/containers/string.pass.cpp

//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// REQUIRES: has-unistd
// UNSUPPORTED: c++11, c++14 // UNSUPPORTED: c++11, c++14
// UNSUPPORTED: libcxx-no-debug-mode, c++03, windows // UNSUPPORTED: libcxx-no-debug-mode, c++03
// ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DEBUG=1 // ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DEBUG=1
// test container debugging // test container debugging
#include <string> #include <string>
#include <vector> #include <vector>
#include "test_macros.h" #include "test_macros.h"
▲ Show 20 Lines • Show All 75 Lines • Show Last 20 Lines

libcxx/test/libcxx/debug/containers/unord_containers.pass.cpp

//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// REQUIRES: has-unistd
// UNSUPPORTED: c++11, c++14 // UNSUPPORTED: c++11, c++14
// UNSUPPORTED: libcxx-no-debug-mode, c++03, windows // UNSUPPORTED: libcxx-no-debug-mode, c++03
// ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DEBUG=1 // ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DEBUG=1
// test container debugging // test container debugging
#include <unordered_map> #include <unordered_map>
#include <unordered_set> #include <unordered_set>
#include <utility> #include <utility>
#include <cassert> #include <cassert>
▲ Show 20 Lines • Show All 45 Lines • Show Last 20 Lines

libcxx/test/libcxx/experimental/memory/memory.polymorphic.allocator.class/memory.polymorphic.allocator.mem/assert.deallocate.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
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// <experimental/memory_resource> // <experimental/memory_resource>
// 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)
// UNSUPPORTED: c++03, windows // REQUIRES: has-unistd
// UNSUPPORTED: c++03
// XFAIL: use_system_cxx_lib && target={{.+}}-apple-macosx{{10.9|10.10|10.11|10.12|10.13|10.14|10.15|11.0|12.0}} // XFAIL: use_system_cxx_lib && target={{.+}}-apple-macosx{{10.9|10.10|10.11|10.12|10.13|10.14|10.15|11.0|12.0}}
// ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_ENABLE_ASSERTIONS=1 // ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_ENABLE_ASSERTIONS=1
#include <experimental/memory_resource> #include <experimental/memory_resource>
#include <type_traits> #include <type_traits>
#include <cassert> #include <cassert>
#include "check_assertion.h" #include "check_assertion.h"
Show All 16 Lines

libcxx/test/libcxx/experimental/memory/memory.resource.adaptor/memory.resource.adaptor.mem/assert.deallocate.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
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// <experimental/memory_resource> // <experimental/memory_resource>
// 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)
// UNSUPPORTED: c++03, windows // REQUIRES: has-unistd
// UNSUPPORTED: c++03
// XFAIL: use_system_cxx_lib && target={{.+}}-apple-macosx{{10.9|10.10|10.11|10.12|10.13|10.14|10.15|11.0|12.0}} // XFAIL: use_system_cxx_lib && target={{.+}}-apple-macosx{{10.9|10.10|10.11|10.12|10.13|10.14|10.15|11.0|12.0}}
// ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_ENABLE_ASSERTIONS=1 // ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_ENABLE_ASSERTIONS=1
#include <experimental/memory_resource> #include <experimental/memory_resource>
#include <type_traits> #include <type_traits>
#include <cassert> #include <cassert>
#include "check_assertion.h" #include "check_assertion.h"
Show All 19 Lines

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

//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// UNSUPPORTED: c++03, windows // REQUIRES: has-unistd
// UNSUPPORTED: c++03
// XFAIL: use_system_cxx_lib && target={{.+}}-apple-macosx{{10.9|10.10|10.11|10.12|10.13|10.14|10.15|11.0|12.0}} // XFAIL: use_system_cxx_lib && target={{.+}}-apple-macosx{{10.9|10.10|10.11|10.12|10.13|10.14|10.15|11.0|12.0}}
// ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_ENABLE_ASSERTIONS=1 // ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_ENABLE_ASSERTIONS=1
// <filesystem> // <filesystem>
// class path // class path
#include "filesystem_include.h" #include "filesystem_include.h"
Show All 30 Lines

libcxx/test/libcxx/iterators/assert.advance.pass.cpp

//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// UNSUPPORTED: c++03, windows // REQUIRES: has-unistd
// UNSUPPORTED: c++03
// XFAIL: use_system_cxx_lib && target={{.+}}-apple-macosx{{10.9|10.10|10.11|10.12|10.13|10.14|10.15|11.0|12.0}} // XFAIL: use_system_cxx_lib && target={{.+}}-apple-macosx{{10.9|10.10|10.11|10.12|10.13|10.14|10.15|11.0|12.0}}
// ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_ENABLE_ASSERTIONS=1 // ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_ENABLE_ASSERTIONS=1
// <list> // <list>
// Call advance(non-bidi iterator, -1) // Call advance(non-bidi iterator, -1)
#include <iterator> #include <iterator>
Show All 19 Lines

libcxx/test/libcxx/iterators/assert.next.pass.cpp

//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// UNSUPPORTED: c++03, windows // REQUIRES: has-unistd
// UNSUPPORTED: c++03
// XFAIL: use_system_cxx_lib && target={{.+}}-apple-macosx{{10.9|10.10|10.11|10.12|10.13|10.14|10.15|11.0|12.0}} // XFAIL: use_system_cxx_lib && target={{.+}}-apple-macosx{{10.9|10.10|10.11|10.12|10.13|10.14|10.15|11.0|12.0}}
// ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_ENABLE_ASSERTIONS=1 // ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_ENABLE_ASSERTIONS=1
// <list> // <list>
// Call next(non-bidi iterator, -1) // Call next(non-bidi iterator, -1)
#include <iterator> #include <iterator>
Show All 13 Lines

libcxx/test/libcxx/iterators/assert.prev.pass.cpp

//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// UNSUPPORTED: c++03, windows // REQUIRES: has-unistd
// UNSUPPORTED: c++03
// XFAIL: use_system_cxx_lib && target={{.+}}-apple-macosx{{10.9|10.10|10.11|10.12|10.13|10.14|10.15|11.0|12.0}} // XFAIL: use_system_cxx_lib && target={{.+}}-apple-macosx{{10.9|10.10|10.11|10.12|10.13|10.14|10.15|11.0|12.0}}
// ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_ENABLE_ASSERTIONS=1 // ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_ENABLE_ASSERTIONS=1
// <list> // <list>
// Call prev(forward_iterator, -1) // Call prev(forward_iterator, -1)
#include <iterator> #include <iterator>
Show All 19 Lines

libcxx/test/libcxx/ranges/range.adaptors/range.lazy.split/range.lazy.split.inner/assert.equal.pass.cpp

//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// UNSUPPORTED: c++03, c++11, c++14, c++17, windows, libcxx-no-debug-mode // REQUIRES: has-unistd
// UNSUPPORTED: c++03, c++11, c++14, c++17, libcxx-no-debug-mode
// UNSUPPORTED: libcpp-has-no-incomplete-ranges // UNSUPPORTED: libcpp-has-no-incomplete-ranges
// ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_ENABLE_ASSERTIONS=1 // ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_ENABLE_ASSERTIONS=1
// <ranges> // <ranges>
// friend constexpr bool operator==(const inner-iterator& x, default_sentinel_t); // friend constexpr bool operator==(const inner-iterator& x, default_sentinel_t);
// //
// Can't compare a default-constructed `inner-iterator` with the default sentinel. // Can't compare a default-constructed `inner-iterator` with the default sentinel.
Show All 19 Lines

libcxx/test/libcxx/ranges/range.adaptors/range.lazy.split/range.lazy.split.outer/assert.equal.pass.cpp

//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// UNSUPPORTED: c++03, c++11, c++14, c++17, windows, libcxx-no-debug-mode // REQUIRES: has-unistd
// UNSUPPORTED: c++03, c++11, c++14, c++17, libcxx-no-debug-mode
// UNSUPPORTED: libcpp-has-no-incomplete-ranges // UNSUPPORTED: libcpp-has-no-incomplete-ranges
// ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_ENABLE_ASSERTIONS=1 // ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_ENABLE_ASSERTIONS=1
// <ranges> // <ranges>
// friend constexpr bool operator==(const inner-iterator& x, default_sentinel_t); // friend constexpr bool operator==(const inner-iterator& x, default_sentinel_t);
// //
// Can't compare a default-constructed `inner-iterator` with the default sentinel. // Can't compare a default-constructed `inner-iterator` with the default sentinel.
Show All 19 Lines

libcxx/test/libcxx/strings/basic.string/string.access/assert.back.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>
// Call back() on empty container. // Call back() on empty container.
// UNSUPPORTED: c++03, windows // REQUIRES: has-unistd
// UNSUPPORTED: c++03
// XFAIL: use_system_cxx_lib && target={{.+}}-apple-macosx{{10.9|10.10|10.11|10.12|10.13|10.14|10.15|11.0|12.0}} // XFAIL: use_system_cxx_lib && target={{.+}}-apple-macosx{{10.9|10.10|10.11|10.12|10.13|10.14|10.15|11.0|12.0}}
// ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_ENABLE_ASSERTIONS=1 // ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_ENABLE_ASSERTIONS=1
#include <string> #include <string>
#include "check_assertion.h" #include "check_assertion.h"
#include "min_allocator.h" #include "min_allocator.h"
Show All 14 Lines

libcxx/test/libcxx/strings/basic.string/string.access/assert.cback.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>
// Call back() on empty const container. // Call back() on empty const container.
// UNSUPPORTED: c++03, windows // REQUIRES: has-unistd
// UNSUPPORTED: c++03
// XFAIL: use_system_cxx_lib && target={{.+}}-apple-macosx{{10.9|10.10|10.11|10.12|10.13|10.14|10.15|11.0|12.0}} // XFAIL: use_system_cxx_lib && target={{.+}}-apple-macosx{{10.9|10.10|10.11|10.12|10.13|10.14|10.15|11.0|12.0}}
// ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_ENABLE_ASSERTIONS=1 // ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_ENABLE_ASSERTIONS=1
#include <string> #include <string>
#include "check_assertion.h" #include "check_assertion.h"
#include "min_allocator.h" #include "min_allocator.h"
Show All 14 Lines

libcxx/test/libcxx/strings/basic.string/string.access/assert.cfront.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>
// Call front() on empty const container. // Call front() on empty const container.
// UNSUPPORTED: c++03, windows // REQUIRES: has-unistd
// UNSUPPORTED: c++03
// XFAIL: use_system_cxx_lib && target={{.+}}-apple-macosx{{10.9|10.10|10.11|10.12|10.13|10.14|10.15|11.0|12.0}} // XFAIL: use_system_cxx_lib && target={{.+}}-apple-macosx{{10.9|10.10|10.11|10.12|10.13|10.14|10.15|11.0|12.0}}
// ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_ENABLE_ASSERTIONS=1 // ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_ENABLE_ASSERTIONS=1
#include <string> #include <string>
#include "check_assertion.h" #include "check_assertion.h"
#include "min_allocator.h" #include "min_allocator.h"
Show All 15 Lines

libcxx/test/libcxx/strings/basic.string/string.access/assert.cindex.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>
// Index const string out of bounds. // Index const string out of bounds.
// UNSUPPORTED: c++03, windows // REQUIRES: has-unistd
// UNSUPPORTED: c++03
// XFAIL: use_system_cxx_lib && target={{.+}}-apple-macosx{{10.9|10.10|10.11|10.12|10.13|10.14|10.15|11.0|12.0}} // XFAIL: use_system_cxx_lib && target={{.+}}-apple-macosx{{10.9|10.10|10.11|10.12|10.13|10.14|10.15|11.0|12.0}}
// ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_ENABLE_ASSERTIONS=1 // ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_ENABLE_ASSERTIONS=1
#include <string> #include <string>
#include <cassert> #include <cassert>
#include "check_assertion.h" #include "check_assertion.h"
#include "min_allocator.h" #include "min_allocator.h"
Show All 18 Lines

libcxx/test/libcxx/strings/basic.string/string.access/assert.front.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>
// Call front() on empty container. // Call front() on empty container.
// UNSUPPORTED: c++03, windows // REQUIRES: has-unistd
// UNSUPPORTED: c++03
// XFAIL: use_system_cxx_lib && target={{.+}}-apple-macosx{{10.9|10.10|10.11|10.12|10.13|10.14|10.15|11.0|12.0}} // XFAIL: use_system_cxx_lib && target={{.+}}-apple-macosx{{10.9|10.10|10.11|10.12|10.13|10.14|10.15|11.0|12.0}}
// ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_ENABLE_ASSERTIONS=1 // ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_ENABLE_ASSERTIONS=1
#include <string> #include <string>
#include <cassert> #include <cassert>
#include "check_assertion.h" #include "check_assertion.h"
#include "min_allocator.h" #include "min_allocator.h"
Show All 16 Lines

libcxx/test/libcxx/strings/basic.string/string.access/assert.index.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>
// Index string out of bounds. // Index string out of bounds.
// UNSUPPORTED: c++03, windows // REQUIRES: has-unistd
// UNSUPPORTED: c++03
// XFAIL: use_system_cxx_lib && target={{.+}}-apple-macosx{{10.9|10.10|10.11|10.12|10.13|10.14|10.15|11.0|12.0}} // XFAIL: use_system_cxx_lib && target={{.+}}-apple-macosx{{10.9|10.10|10.11|10.12|10.13|10.14|10.15|11.0|12.0}}
// ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_ENABLE_ASSERTIONS=1 // ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_ENABLE_ASSERTIONS=1
#include <string> #include <string>
#include <cassert> #include <cassert>
#include "check_assertion.h" #include "check_assertion.h"
#include "min_allocator.h" #include "min_allocator.h"
Show All 18 Lines

libcxx/test/libcxx/strings/basic.string/string.iterators/debug.iterator.add.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>
// Add to iterator out of bounds. // Add to iterator out of bounds.
// UNSUPPORTED: libcxx-no-debug-mode, c++03, windows // REQUIRES: has-unistd
// UNSUPPORTED: libcxx-no-debug-mode, c++03
// ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DEBUG=1 // ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DEBUG=1
#include <string> #include <string>
#include <cassert> #include <cassert>
#include "check_assertion.h" #include "check_assertion.h"
#include "min_allocator.h" #include "min_allocator.h"
Show All 23 Lines

libcxx/test/libcxx/strings/basic.string/string.iterators/debug.iterator.compare.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>
// Compare iterators from different containers with <. // Compare iterators from different containers with <.
// UNSUPPORTED: libcxx-no-debug-mode, c++03, windows // REQUIRES: has-unistd
// UNSUPPORTED: libcxx-no-debug-mode, c++03
// ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DEBUG=1 // ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DEBUG=1
#include <string> #include <string>
#include "check_assertion.h" #include "check_assertion.h"
#include "min_allocator.h" #include "min_allocator.h"
int main(int, char**) { int main(int, char**) {
Show All 16 Lines

libcxx/test/libcxx/strings/basic.string/string.iterators/debug.iterator.decrement.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>
// Decrement iterator prior to begin. // Decrement iterator prior to begin.
// UNSUPPORTED: libcxx-no-debug-mode, c++03, windows // REQUIRES: has-unistd
// UNSUPPORTED: libcxx-no-debug-mode, c++03
// ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DEBUG=1 // ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DEBUG=1
#include <string> #include <string>
#include <cassert> #include <cassert>
#include "check_assertion.h" #include "check_assertion.h"
#include "min_allocator.h" #include "min_allocator.h"
Show All 21 Lines

libcxx/test/libcxx/strings/basic.string/string.iterators/debug.iterator.dereference.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>
// Dereference non-dereferenceable iterator. // Dereference non-dereferenceable iterator.
// UNSUPPORTED: libcxx-no-debug-mode, c++03, windows // REQUIRES: has-unistd
// UNSUPPORTED: libcxx-no-debug-mode, c++03
// ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DEBUG=1 // ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DEBUG=1
#include <string> #include <string>
#include "check_assertion.h" #include "check_assertion.h"
#include "min_allocator.h" #include "min_allocator.h"
int main(int, char**) { int main(int, char**) {
Show All 16 Lines

libcxx/test/libcxx/strings/basic.string/string.iterators/debug.iterator.increment.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>
// Increment iterator past end. // Increment iterator past end.
// UNSUPPORTED: libcxx-no-debug-mode, c++03, windows // REQUIRES: has-unistd
// UNSUPPORTED: libcxx-no-debug-mode, c++03
// ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DEBUG=1 // ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DEBUG=1
#include <string> #include <string>
#include <cassert> #include <cassert>
#include "check_assertion.h" #include "check_assertion.h"
#include "min_allocator.h" #include "min_allocator.h"
Show All 21 Lines

libcxx/test/libcxx/strings/basic.string/string.iterators/debug.iterator.index.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>
// Index iterator out of bounds. // Index iterator out of bounds.
// UNSUPPORTED: libcxx-no-debug-mode, c++03, windows // REQUIRES: has-unistd
// UNSUPPORTED: libcxx-no-debug-mode, c++03
// ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DEBUG=1 // ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DEBUG=1
#include <string> #include <string>
#include <cassert> #include <cassert>
#include "check_assertion.h" #include "check_assertion.h"
#include "min_allocator.h" #include "min_allocator.h"
Show All 19 Lines

libcxx/test/libcxx/strings/basic.string/string.iterators/debug.iterator.subtract.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>
// Subtract iterators from different containers. // Subtract iterators from different containers.
// UNSUPPORTED: libcxx-no-debug-mode, c++03, windows // REQUIRES: has-unistd
// UNSUPPORTED: libcxx-no-debug-mode, c++03
// ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DEBUG=1 // ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DEBUG=1
#include <string> #include <string>
#include "check_assertion.h" #include "check_assertion.h"
#include "min_allocator.h" #include "min_allocator.h"
int main(int, char**) { int main(int, char**) {
Show All 16 Lines

libcxx/test/libcxx/strings/basic.string/string.modifiers/assert.erase_iter.null.pass.cpp

//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// <string> // <string>
// Call erase(const_iterator position) with end() // Call erase(const_iterator position) with end()
// UNSUPPORTED: c++03, windows // REQUIRES: has-unistd
// UNSUPPORTED: c++03
// XFAIL: use_system_cxx_lib && target={{.+}}-apple-macosx{{10.9|10.10|10.11|10.12|10.13|10.14|10.15|11.0|12.0}} // XFAIL: use_system_cxx_lib && target={{.+}}-apple-macosx{{10.9|10.10|10.11|10.12|10.13|10.14|10.15|11.0|12.0}}
// ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_ENABLE_ASSERTIONS=1 // ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_ENABLE_ASSERTIONS=1
#include <string> #include <string>
#include "check_assertion.h" #include "check_assertion.h"
#include "min_allocator.h" #include "min_allocator.h"
Show All 16 Lines

libcxx/test/libcxx/strings/basic.string/string.modifiers/assert.pop_back.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>
// void pop_back(); // void pop_back();
// UNSUPPORTED: c++03, windows // REQUIRES: has-unistd
// UNSUPPORTED: c++03
// XFAIL: use_system_cxx_lib && target={{.+}}-apple-macosx{{10.9|10.10|10.11|10.12|10.13|10.14|10.15|11.0|12.0}} // XFAIL: use_system_cxx_lib && target={{.+}}-apple-macosx{{10.9|10.10|10.11|10.12|10.13|10.14|10.15|11.0|12.0}}
// ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_ENABLE_ASSERTIONS=1 // ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_ENABLE_ASSERTIONS=1
#include <string> #include <string>
#include "check_assertion.h" #include "check_assertion.h"
int main(int, char**) { int main(int, char**) {
std::string s; std::string s;
TEST_LIBCPP_ASSERT_FAILURE(s.pop_back(), "string::pop_back(): string is already empty"); TEST_LIBCPP_ASSERT_FAILURE(s.pop_back(), "string::pop_back(): string is already empty");
return 0; return 0;
} }

libcxx/test/libcxx/strings/basic.string/string.modifiers/debug.erase.iter.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>
// Call erase(const_iterator position) with an iterator from another container // Call erase(const_iterator position) with an iterator from another container
// UNSUPPORTED: libcxx-no-debug-mode, c++03, windows // REQUIRES: has-unistd
// UNSUPPORTED: libcxx-no-debug-mode, c++03
// ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DEBUG=1 // ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DEBUG=1
#include <string> #include <string>
#include "check_assertion.h" #include "check_assertion.h"
#include "min_allocator.h" #include "min_allocator.h"
int main(int, char**) { int main(int, char**) {
Show All 17 Lines

libcxx/test/libcxx/strings/basic.string/string.modifiers/debug.erase.iter_iter.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>
// Call erase(const_iterator first, const_iterator last); with invalid iterators // Call erase(const_iterator first, const_iterator last); with invalid iterators
// UNSUPPORTED: libcxx-no-debug-mode, c++03, windows // REQUIRES: has-unistd
// UNSUPPORTED: libcxx-no-debug-mode, c++03
// ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DEBUG=1 // ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DEBUG=1
#include <string> #include <string>
#include "check_assertion.h" #include "check_assertion.h"
#include "min_allocator.h" #include "min_allocator.h"
int main(int, char**) { int main(int, char**) {
▲ Show 20 Lines • Show All 70 Lines • Show Last 20 Lines

libcxx/test/libcxx/strings/basic.string/string.modifiers/debug.insert.iter_char.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>
// iterator insert(const_iterator p, charT c); // iterator insert(const_iterator p, charT c);
// UNSUPPORTED: libcxx-no-debug-mode, c++03, windows // REQUIRES: has-unistd
// UNSUPPORTED: libcxx-no-debug-mode, c++03
// ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DEBUG=1 // ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DEBUG=1
// TODO: Since string::insert(iter, char) is intantiated in the dylib, this test doesn't // TODO: Since string::insert(iter, char) is intantiated in the dylib, this test doesn't
// actually work if the dylib hasn't been built with debug assertions enabled. // actually work if the dylib hasn't been built with debug assertions enabled.
// Until we overhaul the debug mode, mark this test as unsupported to avoid // Until we overhaul the debug mode, mark this test as unsupported to avoid
// spurious CI failures. // spurious CI failures.
// REQUIRES: never-run // REQUIRES: never-run
Show All 13 Lines

libcxx/test/libcxx/strings/basic.string/string.modifiers/debug.insert.iter_iter_iter.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>
// template<class InputIterator> // template<class InputIterator>
// iterator insert(const_iterator p, InputIterator first, InputIterator last); // iterator insert(const_iterator p, InputIterator first, InputIterator last);
// UNSUPPORTED: libcxx-no-debug-mode, c++03, windows // REQUIRES: has-unistd
// UNSUPPORTED: libcxx-no-debug-mode, c++03
// ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DEBUG=1 // ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DEBUG=1
#include <string> #include <string>
#include "check_assertion.h" #include "check_assertion.h"
int main(int, char**) { int main(int, char**) {
std::string v; std::string v;
std::string v2; std::string v2;
char a[] = "123"; char a[] = "123";
const int N = sizeof(a)/sizeof(a[0]); const int N = sizeof(a)/sizeof(a[0]);
TEST_LIBCPP_ASSERT_FAILURE(v.insert(v2.cbegin() + 10, a, a + N), TEST_LIBCPP_ASSERT_FAILURE(v.insert(v2.cbegin() + 10, a, a + N),
"Attempted to add/subtract an iterator outside its valid range"); "Attempted to add/subtract an iterator outside its valid range");
return 0; return 0;
} }

libcxx/test/libcxx/strings/basic.string/string.modifiers/debug.insert.iter_size_char.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>
// iterator insert(const_iterator p, size_type n, charT c); // iterator insert(const_iterator p, size_type n, charT c);
// UNSUPPORTED: libcxx-no-debug-mode, c++03, windows // REQUIRES: has-unistd
// UNSUPPORTED: libcxx-no-debug-mode, c++03
// ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DEBUG=1 // ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DEBUG=1
#include <string> #include <string>
#include "check_assertion.h" #include "check_assertion.h"
int main(int, char**) { int main(int, char**) {
std::string s; std::string s;
std::string s2; std::string s2;
TEST_LIBCPP_ASSERT_FAILURE( TEST_LIBCPP_ASSERT_FAILURE(
s.insert(s2.begin(), 1, 'a'), s.insert(s2.begin(), 1, 'a'),
"string::insert(iterator, n, value) called with an iterator not referring to this string"); "string::insert(iterator, n, value) called with an iterator not referring to this string");
return 0; return 0;
} }

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

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

libcxx/test/libcxx/thread/futures/futures.promise/assert.set_exception.pass.cpp

//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// REQUIRES: has-unistd
// UNSUPPORTED: libcpp-has-no-threads // UNSUPPORTED: libcpp-has-no-threads
// UNSUPPORTED: c++03, windows // UNSUPPORTED: c++03
// XFAIL: use_system_cxx_lib && target={{.+}}-apple-macosx{{10.9|10.10|10.11|10.12|10.13|10.14|10.15|11.0|12.0}} // XFAIL: use_system_cxx_lib && target={{.+}}-apple-macosx{{10.9|10.10|10.11|10.12|10.13|10.14|10.15|11.0|12.0}}
// ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_ENABLE_ASSERTIONS=1 // ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_ENABLE_ASSERTIONS=1
// <future> // <future>
// class promise<R> // class promise<R>
// void set_exception(exception_ptr p); // void set_exception(exception_ptr p);
Show All 22 Lines

libcxx/test/libcxx/thread/futures/futures.promise/assert.set_exception_at_thread_exit.pass.cpp

//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// REQUIRES: has-unistd
// UNSUPPORTED: libcpp-has-no-threads // UNSUPPORTED: libcpp-has-no-threads
// UNSUPPORTED: c++03, windows // UNSUPPORTED: c++03
// XFAIL: use_system_cxx_lib && target={{.+}}-apple-macosx{{10.9|10.10|10.11|10.12|10.13|10.14|10.15|11.0|12.0}} // XFAIL: use_system_cxx_lib && target={{.+}}-apple-macosx{{10.9|10.10|10.11|10.12|10.13|10.14|10.15|11.0|12.0}}
// ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_ENABLE_ASSERTIONS=1 // ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_ENABLE_ASSERTIONS=1
// <future> // <future>
// class promise<R> // class promise<R>
// void set_exception_on_thread_exit(exception_ptr p); // void set_exception_on_thread_exit(exception_ptr p);
Show All 22 Lines

libcxx/test/libcxx/utilities/optional/optional.object/optional.object.observe/assert.dereference.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
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// <optional> // <optional>
// constexpr T& optional<T>::operator*() &; // constexpr T& optional<T>::operator*() &;
// constexpr T&& optional<T>::operator*() &&; // constexpr T&& optional<T>::operator*() &&;
// constexpr const T& optional<T>::operator*() const &; // constexpr const T& optional<T>::operator*() const &;
// constexpr T&& optional<T>::operator*() const &&; // constexpr T&& optional<T>::operator*() const &&;
// REQUIRES: has-unistd
// UNSUPPORTED: c++11, c++14 // UNSUPPORTED: c++11, c++14
// UNSUPPORTED: c++03, windows // UNSUPPORTED: c++03
// XFAIL: use_system_cxx_lib && target={{.+}}-apple-macosx{{10.9|10.10|10.11|10.12|10.13|10.14|10.15|11.0|12.0}} // XFAIL: use_system_cxx_lib && target={{.+}}-apple-macosx{{10.9|10.10|10.11|10.12|10.13|10.14|10.15|11.0|12.0}}
// ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_ENABLE_ASSERTIONS=1 // ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_ENABLE_ASSERTIONS=1
#include <optional> #include <optional>
#include "check_assertion.h" #include "check_assertion.h"
int main(int, char**) { int main(int, char**) {
Show All 26 Lines

libcxx/test/libcxx/utilities/optional/optional.object/optional.object.observe/assert.op_arrow.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
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// <optional> // <optional>
// constexpr T* optional<T>::operator->(); // constexpr T* optional<T>::operator->();
// constexpr const T* optional<T>::operator->() const; // constexpr const T* optional<T>::operator->() const;
// REQUIRES: has-unistd
// UNSUPPORTED: c++11, c++14 // UNSUPPORTED: c++11, c++14
// UNSUPPORTED: c++03, windows // UNSUPPORTED: c++03
// XFAIL: use_system_cxx_lib && target={{.+}}-apple-macosx{{10.9|10.10|10.11|10.12|10.13|10.14|10.15|11.0|12.0}} // XFAIL: use_system_cxx_lib && target={{.+}}-apple-macosx{{10.9|10.10|10.11|10.12|10.13|10.14|10.15|11.0|12.0}}
// ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_ENABLE_ASSERTIONS=1 // ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_ENABLE_ASSERTIONS=1
#include <optional> #include <optional>
#include "check_assertion.h" #include "check_assertion.h"
struct X { struct X {
Show All 16 Lines

libcxx/test/support/test.support/test_check_assertion.pass.cpp

//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// UNSUPPORTED: c++03, windows // REQUIRES: has-unistd
// UNSUPPORTED: c++03
// XFAIL: use_system_cxx_lib && target={{.+}}-apple-macosx{{10.9|10.10|10.11|10.12|10.13|10.14|10.15|11.0|12.0}} // XFAIL: use_system_cxx_lib && target={{.+}}-apple-macosx{{10.9|10.10|10.11|10.12|10.13|10.14|10.15|11.0|12.0}}
// ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_ENABLE_ASSERTIONS=1 // ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_ENABLE_ASSERTIONS=1
#include <cassert> #include <cassert>
#include <cstdio> #include <cstdio>
#include <string> #include <string>
#include "check_assertion.h" #include "check_assertion.h"
▲ Show 20 Lines • Show All 46 Lines • Show Last 20 Lines

libcxx/utils/libcxx/test/features.py

Show First 20 Lines • Show All 110 Lines • ▼ Show 20 Lines Feature(name='glibc-old-ru_RU-decimal-point',
#include <locale.h> #include <locale.h>
#include <string.h> #include <string.h>
int main(int, char**) { int main(int, char**) {
setlocale(LC_ALL, "ru_RU.UTF-8"); setlocale(LC_ALL, "ru_RU.UTF-8");
return strcmp(localeconv()->mon_decimal_point, ","); return strcmp(localeconv()->mon_decimal_point, ",");
} }
""")), """)),
Feature(name='has-unistd',
MordanteUnsubmitted
Not Done
ReplyInline Actions

I think this name can be a bit more descriptive, for example has-header-unistd-h.

Mordante: I think this name can be a bit more descriptive, for example `has-header-unistd-h`.
when=lambda cfg: sourceBuilds(cfg, """
#include <unistd.h>
int main(int, char**) {
return 0;
}
""")),
# Whether Bash can run on the executor. # Whether Bash can run on the executor.
# This is not always the case, for example when running on embedded systems. # This is not always the case, for example when running on embedded systems.
# #
# For the corner case of bash existing, but it being missing in the path # For the corner case of bash existing, but it being missing in the path
# set in %{exec} as "--env PATH=one-single-dir", the executor does find # set in %{exec} as "--env PATH=one-single-dir", the executor does find
# and executes bash, but bash then can't find any other common shell # and executes bash, but bash then can't find any other common shell
# utilities. Test executing "bash -c 'bash --version'" to see if bash # utilities. Test executing "bash -c 'bash --version'" to see if bash
# manages to find binaries to execute. # manages to find binaries to execute.
▲ Show 20 Lines • Show All 135 Lines • Show Last 20 Lines