This is an archive of the discontinued LLVM Phabricator instance.

Differential D121462

[libc++] Overhaul all tests for assertions and debug mode
ClosedPublic

Authored by ldionne on Mar 11 2022, 7:00 AM.

Details

Reviewers
None
Group Reviewers
Restricted Project
Commits
rGf6fd1c1438f0: [libc++] Overhaul all tests for assertions and debug mode
Summary

Prior to this patch, there was no distinction between tests that check
basic assertions and tests that check full-fledged iterator debugging
assertions. Both were disabled when support for the debug mode is not
provided in the dylib, which is stronger than it needs to be.

Furthermore, all of the tests using "debug_macros.h" that contain more
than one assertion in them were broken -- any code after the first
assertion would never be executed.

This patch refactors all of our assertion-related tests to:

  1. Be enabled whenever they can, i.e. basic assertions tests are run even when the debug mode is disabled.
  2. Use the superior check_assertion.h (previously debug_mode_helper.h) instead of debug_macros.h, which allows multiple assertions in the same program.
  3. Coalesce some tests into the same file to make them more readable.
  4. Use consistent naming for test files -- no more db{1,2,3,...,10} tests.

This is a large but mostly mechanical patch.

Diff Detail

Event Timeline

ldionne created this revision.Mar 11 2022, 7:00 AM
Herald added a project: Restricted Project. · View Herald TranscriptMar 11 2022, 7:00 AM
Herald added a subscriber: arphaman. · View Herald Transcript
ldionne requested review of this revision.Mar 11 2022, 7:00 AM
Herald added a project: Restricted Project. · View Herald TranscriptMar 11 2022, 7:00 AM
Herald added a reviewer: Restricted Project. · View Herald Transcript
Herald added a subscriber: libcxx-commits. · View Herald Transcript
ldionne added a comment.Mar 11 2022, 7:02 AM

It would have been possible but very tedious to split this into smaller patches due to the number of touched files. I believe the easiest way to review this is to trust that I'm indeed doing what I explain in the commit summary, and review whether that plan seems reasonable instead (hopefully it does).

Harbormaster completed remote builds in B153766: Diff 414651.Mar 11 2022, 9:38 AM
ldionne updated this revision to Diff 415092.Mar 14 2022, 7:39 AM

Address hopefully most CI failures.

Herald added a subscriber: arichardson. · View Herald TranscriptMar 14 2022, 7:39 AM
Harbormaster completed remote builds in B154102: Diff 415092.Mar 14 2022, 8:38 AM
ldionne updated this revision to Diff 415164.Mar 14 2022, 11:03 AM

Hopefully fix CI on Windows.

Harbormaster completed remote builds in B154147: Diff 415164.Mar 14 2022, 1:06 PM
ldionne accepted this revision as: Restricted Project.Mar 14 2022, 1:39 PM

Ci is green -- the Apple System failure is a flake. I'll ship this tomorrow if nobody chimes in, since this is pretty mechanical.

This revision was not accepted when it landed; it landed in state Needs Review.Mar 15 2022, 7:56 AM
This revision was landed with ongoing or failed builds.
Closed by commit rGf6fd1c1438f0: [libc++] Overhaul all tests for assertions and debug mode (authored by ldionne). · Explain Why
This revision was automatically updated to reflect the committed changes.
ldionne added a commit: rGf6fd1c1438f0: [libc++] Overhaul all tests for assertions and debug mode.

Revision Contents

PathSize
libcxx/
test/
libcxx/
algorithms/
52 lines
28 lines
4 lines
4 lines
4 lines
containers/
sequences/
array/
array.zero/
35 lines
35 lines
39 lines
deque/
assert.pop_back.empty.pass.cpp
pop_back_empty.pass.cpp
8 lines
list/
list.cons/
debug.copy.pass.cpp
db_copy.pass.cpp
9 lines
list.modifiers/
assert.erase_iter.end.pass.cpp
erase_iter_db1.pass.cpp
11 lines
assert.pop_back.empty.pass.cpp
pop_back_db1.pass.cpp
11 lines
debug.emplace.pass.cpp
emplace_db1.pass.cpp
10 lines
debug.erase.iter.pass.cpp
erase_iter_db2.pass.cpp
9 lines
57 lines
debug.insert.iter_iter_iter.pass.cpp
insert_iter_iter_iter_db1.pass.cpp
23 lines
debug.insert.iter_rvalue.pass.cpp
insert_iter_rvalue_db1.pass.cpp
9 lines
debug.insert.iter_size_value.pass.cpp
insert_iter_size_value_db1.pass.cpp
9 lines
debug.insert.iter_value.pass.cpp
insert_iter_value_db1.pass.cpp
9 lines
list.ops/
debug.splice.pos_list.pass.cpp
db_splice_pos_list.pass.cpp
20 lines
debug.splice.pos_list_iter.pass.cpp
db_splice_pos_list_iter.pass.cpp
21 lines
debug.splice.pos_list_iter_iter.pass.cpp
db_splice_pos_list_iter_iter.pass.cpp
21 lines
vector/
41 lines
assert.cback.empty.pass.cpp
db_cback_2.pass.cpp
25 lines
assert.cfront.empty.pass.cpp
db_cfront_2.pass.cpp
25 lines
assert.cindex.oob.pass.cpp
db_cindex.pass.cpp
24 lines
42 lines
assert.index.oob.pass.cpp
db_index_2.pass.cpp
28 lines
assert.pop_back.empty.pass.cpp
pop_back_empty.pass.cpp
8 lines
46 lines
debug.iterator.compare.pass.cpp
db_iterators_9.pass.cpp
26 lines
debug.iterator.decrement.pass.cpp
db_iterators_13.pass.cpp
32 lines
debug.iterator.index.pass.cpp
db_iterators_11.pass.cpp
29 lines
debug.iterator.subtract.pass.cpp
db_iterators_10.pass.cpp
26 lines
sequences/
vector/
unord/
unord.set/
debug.iterator.dereference.pass.cpp
db_iterators_10.pass.cpp
27 lines
debug.iterator.increment.pass.cpp
db_iterators_9.pass.cpp
32 lines
unord/
unord.map/
assert.bucket.pass.cpp
db_bucket.pass.cpp
8 lines
assert.bucket_size.pass.cpp
bucket_size.pass.cpp
8 lines
assert.max_load_factor.pass.cpp
max_load_factor.pass.cpp
8 lines
debug.insert.hint_const_lvalue.pass.cpp
db_insert_hint_const_lvalue.pass.cpp
5 lines
debug.insert.hint_rvalue.pass.cpp
db_insert_hint_rvalue.pass.cpp
7 lines
41 lines
46 lines
39 lines
49 lines
debug.swap.pass.cpp
db_swap_1.pass.cpp
6 lines
unord.map.modifiers/
43 lines
64 lines
unord.multimap/
assert.bucket.pass.cpp
bucket.pass.cpp
8 lines
assert.bucket_size.pass.cpp
bucket_size.pass.cpp
8 lines
assert.max_load_factor.pass.cpp
max_load_factor.pass.cpp
8 lines
debug.insert.hint_const_lvalue.pass.cpp
db_insert_hint_const_lvalue.pass.cpp
6 lines
debug.insert.hint_rvalue.pass.cpp
db_insert_hint_rvalue.pass.cpp
8 lines
41 lines
46 lines
39 lines
50 lines
debug.swap.pass.cpp
db_swap_1.pass.cpp
9 lines
unord.multimap.modifiers/
43 lines
64 lines
unord.multiset/
assert.bucket.pass.cpp
bucket.pass.cpp
8 lines
assert.bucket_size.pass.cpp
bucket_size.pass.cpp
8 lines
assert.max_load_factor.pass.cpp
max_load_factor.pass.cpp
8 lines
41 lines
60 lines
debug.insert.hint_const_lvalue.pass.cpp
db_insert_hint_const_lvalue.pass.cpp
6 lines
39 lines
47 lines
41 lines
51 lines
debug.swap.pass.cpp
db_swap_1.pass.cpp
6 lines
unord.set/
assert.bucket.pass.cpp
bucket.pass.cpp
8 lines
assert.bucket_size.pass.cpp
bucket_size.pass.cpp
8 lines
assert.max_load_factor.pass.cpp
max_load_factor.pass.cpp
8 lines
41 lines
60 lines
debug.insert.hint_const_lvalue.pass.cpp
db_insert_hint_const_lvalue.pass.cpp
6 lines
39 lines
47 lines
41 lines
49 lines
debug.swap.pass.cpp
db_swap_1.pass.cpp
6 lines
debug/
check_assertion_test.pass.cpp
debug_helper_test.pass.cpp
13 lines
containers.multithread.pass.cpp/
containers/
db_sequence_container_iterators.multithread.pass.cpp
11 lines
containers/
associative_containers.pass.cpp
db_associative_container_tests.pass.cpp
7 lines
sequence_container_iterators.pass.cpp
db_sequence_container_iterators.pass.cpp
7 lines
string.pass.cpp
db_string.pass.cpp
7 lines
unord_containers.pass.cpp
db_unord_container_tests.pass.cpp
7 lines
2 lines
register_debug_handler.pass.cpp
debug_register.pass.cpp
experimental/
memory/
memory.polymorphic.allocator.class/
memory.polymorphic.allocator.mem/
assert.deallocate.pass.cpp
deallocate.assert.pass.cpp
14 lines
memory.resource.adaptor/
memory.resource.adaptor.mem/
assert.deallocate.pass.cpp
deallocate.assert.pass.cpp
14 lines
input.output/
filesystems/
class.path/
path.itr/
assert.iterator.pass.cpp
iterator_db.pass.cpp
34 lines
iterators/
assert.advance.pass.cpp
advance.debug1.pass.cpp
16 lines
assert.next.pass.cpp
next.debug1.pass.cpp
18 lines
assert.prev.pass.cpp
prev.debug1.pass.cpp
16 lines
strings/
basic.string/
string.access/
assert.back.pass.cpp
db_back_2.pass.cpp
28 lines
assert.cback.pass.cpp
db_cback_2.pass.cpp
25 lines
assert.cfront.pass.cpp
db_cfront_2.pass.cpp
22 lines
assert.cindex.pass.cpp
db_cindex_2.pass.cpp
25 lines
assert.front.pass.cpp
db_front_2.pass.cpp
24 lines
assert.index.pass.cpp
db_index_2.pass.cpp
25 lines
string.iterators/
44 lines
debug.iterator.compare.pass.cpp
db_iterators_9.pass.cpp
23 lines
debug.iterator.decrement.pass.cpp
db_iterators_13.pass.cpp
29 lines
debug.iterator.index.pass.cpp
db_iterators_11.pass.cpp
26 lines
string.modifiers/
assert.erase_iter.null.pass.cpp
erase_iter_db1.pass.cpp
23 lines
assert.pop_back.pass.cpp
erase_pop_back_db1.pass.cpp
11 lines
38 lines
91 lines
debug.insert.iter_char.pass.cpp
insert_iter_char_db1.pass.cpp
9 lines
debug.insert.iter_iter_iter.pass.cpp
insert_iter_iter_iter_db1.pass.cpp
9 lines
debug.insert.iter_size_char.pass.cpp
insert_iter_size_char_db1.pass.cpp
9 lines
string.view/
34 lines
strings/
containers/
basic.string/
unord/
string.iterators/
unord.map/
debug.iterator.dereference.pass.cpp
db_iterators_10.pass.cpp
29 lines
string.iterators/
unord.multimap/
debug.iterator.increment.pass.cpp
db_iterators_9.pass.cpp
33 lines
basic.string/
string.iterators/
sequences/
vector/
debug.iterator.subtract.pass.cpp
db_iterators_10.pass.cpp
28 lines
thread/
futures/
futures.promise/
assert.set_exception.pass.cpp
set_exception.pass.cpp
23 lines
assert.set_exception_at_thread_exit.pass.cpp
set_exception_at_thread_exit.pass.cpp
24 lines
utilities/
optional/
optional.object/
optional.object.observe/
51 lines
39 lines
support/
check_assertion.h
debug_mode_helper.h
8 lines
4 lines
utils/
libcxx/
test/
1 line

Diff 415435

libcxx/test/libcxx/algorithms/debug_less.inconsistent.pass.cpp

  • This file was added.
//===----------------------------------------------------------------------===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
// <algorithm>
// template <class _Compare> struct __debug_less
// Make sure __debug_less asserts when the comparator is not consistent.
// UNSUPPORTED: libcxx-no-debug-mode, c++03, windows
// ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DEBUG=1
#include <algorithm>
#include <iterator>
#include "check_assertion.h"
template <int ID>
struct MyType {
int value;
explicit MyType(int xvalue = 0) : value(xvalue) {}
};
template <int ID1, int ID2>
bool operator<(MyType<ID1> const& LHS, MyType<ID2> const& RHS) {
return LHS.value < RHS.value;
}
template <class ValueType>
struct BadComparator {
bool operator()(ValueType const&, ValueType const&) const {
return true;
}
};
int main(int, char**) {
typedef MyType<0> MT0;
MT0 one(1);
MT0 two(2);
BadComparator<MT0> c;
std::__debug_less<BadComparator<MT0>> d(c);
TEST_LIBCPP_ASSERT_FAILURE(d(one, two), "Comparator does not induce a strict weak ordering");
return 0;
}

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 // UNSUPPORTED: libcxx-no-debug-mode, c++03, windows
// 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 "debug_macros.h" #include "check_assertion.h"
template <int ID> template <int ID>
struct MyType { struct MyType {
int value; int value;
explicit MyType(int xvalue = 0) : value(xvalue) {} explicit MyType(int xvalue = 0) : value(xvalue) {}
}; };
template <int ID1, int ID2> template <int ID1, int ID2>
Show All 13 Lines
template <class ValueType> template <class ValueType>
struct GoodComparator : public CompareBase { struct GoodComparator : public CompareBase {
bool operator()(ValueType const& lhs, ValueType const& rhs) const { bool operator()(ValueType const& lhs, ValueType const& rhs) const {
++CompareBase::called; ++CompareBase::called;
return lhs < rhs; return lhs < rhs;
} }
}; };
template <class ValueType>
struct BadComparator : public CompareBase {
bool operator()(ValueType const&, ValueType const&) const {
++CompareBase::called;
return true;
}
};
template <class T1, class T2> template <class T1, class T2>
struct TwoWayHomoComparator : public CompareBase { struct TwoWayHomoComparator : public CompareBase {
bool operator()(T1 const& lhs, T2 const& rhs) const { bool operator()(T1 const& lhs, T2 const& rhs) const {
++CompareBase::called; ++CompareBase::called;
return lhs < rhs; return lhs < rhs;
} }
bool operator()(T2 const& lhs, T1 const& rhs) const { bool operator()(T2 const& lhs, T1 const& rhs) const {
▲ Show 20 Lines • Show All 63 Lines • ▼ Show 20 Lines MT1 four(4);
D d(c); D d(c);
assert(d(one, three) == true); assert(d(one, three) == true);
assert(called == 1); assert(called == 1);
called = 0; called = 0;
} }
} }
void test_failing() {
MT0 one(1);
MT0 two(2);
{
typedef BadComparator<MT0> C;
typedef __debug_less<C> D;
C c;
D d(c);
TEST_LIBCPP_ASSERT_FAILURE(d(one, two), "Comparator does not induce a strict weak ordering");
}
}
template <int> template <int>
struct Tag { struct Tag {
explicit Tag(int v) : value(v) {} explicit Tag(int v) : value(v) {}
int value; int value;
}; };
template <class = void> template <class = void>
struct FooImp { struct FooImp {
▲ Show 20 Lines • Show All 103 Lines • ▼ Show 20 Linesconstexpr bool test_constexpr() {
assert(dcmp(1, 2)); assert(dcmp(1, 2));
assert(!dcmp(1, 1)); assert(!dcmp(1, 1));
return true; return true;
} }
#endif #endif
int main(int, char**) { int main(int, char**) {
test_passing(); test_passing();
test_failing();
test_upper_and_lower_bound(); test_upper_and_lower_bound();
test_non_const_arg_cmp(); test_non_const_arg_cmp();
test_value_iterator(); test_value_iterator();
test_value_categories(); test_value_categories();
#if TEST_STD_VER > 11 #if TEST_STD_VER > 11
static_assert(test_constexpr(), ""); static_assert(test_constexpr(), "");
#endif #endif
return 0; return 0;
} }

libcxx/test/libcxx/algorithms/nth_element_stability.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>
// Test std::nth_element stability randomization // Test std::nth_element stability randomization
// UNSUPPORTED: libcxx-no-debug-mode // UNSUPPORTED: libcxx-no-debug-mode, c++03, windows
// UNSUPPORTED: c++03
// ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DEBUG=1 // ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DEBUG=1
#include <algorithm> #include <algorithm>
#include <array> #include <array>
#include <cassert> #include <cassert>
#include <functional> #include <functional>
#include <iterator> #include <iterator>
#include <vector> #include <vector>
▲ Show 20 Lines • Show All 80 Lines • Show Last 20 Lines

libcxx/test/libcxx/algorithms/partial_sort_stability.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>
// Test std::partial_sort stability randomization // Test std::partial_sort stability randomization
// UNSUPPORTED: libcxx-no-debug-mode // UNSUPPORTED: libcxx-no-debug-mode, c++03, windows
// UNSUPPORTED: c++03
// ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DEBUG=1 // ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DEBUG=1
#include <algorithm> #include <algorithm>
#include <array> #include <array>
#include <cassert> #include <cassert>
#include <functional> #include <functional>
#include <iterator> #include <iterator>
#include <vector> #include <vector>
▲ Show 20 Lines • Show All 80 Lines • Show Last 20 Lines

libcxx/test/libcxx/algorithms/sort_stability.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>
// Test std::sort stability randomization // Test std::sort stability randomization
// UNSUPPORTED: libcxx-no-debug-mode // UNSUPPORTED: libcxx-no-debug-mode, c++03, windows
// UNSUPPORTED: c++03
// ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DEBUG=1 // ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DEBUG=1
#include <algorithm> #include <algorithm>
#include <array> #include <array>
#include <cassert> #include <cassert>
#include <iterator> #include <iterator>
#include <vector> #include <vector>
▲ Show 20 Lines • Show All 77 Lines • Show Last 20 Lines

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

  • This file was added.
//===----------------------------------------------------------------------===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
// UNSUPPORTED: c++03, windows, libcxx-no-debug-mode
// ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DEBUG=0
// test that array<T, 0>::back() triggers an assertion
#include <array>
#include "check_assertion.h"
int main(int, char**) {
{
typedef std::array<int, 0> C;
C c = {};
C const& cc = c;
TEST_LIBCPP_ASSERT_FAILURE(c.back(), "cannot call array<T, 0>::back() on a zero-sized array");
TEST_LIBCPP_ASSERT_FAILURE(cc.back(), "cannot call array<T, 0>::back() on a zero-sized array");
}
{
typedef std::array<const int, 0> C;
C c = {{}};
C const& cc = c;
TEST_LIBCPP_ASSERT_FAILURE(c.back(), "cannot call array<T, 0>::back() on a zero-sized array");
TEST_LIBCPP_ASSERT_FAILURE(cc.back(), "cannot call array<T, 0>::back() on a zero-sized array");
}
return 0;
}

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

  • This file was added.
//===----------------------------------------------------------------------===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
// UNSUPPORTED: c++03, windows, libcxx-no-debug-mode
// ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DEBUG=0
// test that array<T, 0>::back() triggers an assertion
#include <array>
#include "check_assertion.h"
int main(int, char**) {
{
typedef std::array<int, 0> C;
C c = {};
C const& cc = c;
TEST_LIBCPP_ASSERT_FAILURE(c.front(), "cannot call array<T, 0>::front() on a zero-sized array");
TEST_LIBCPP_ASSERT_FAILURE(cc.front(), "cannot call array<T, 0>::front() on a zero-sized array");
}
{
typedef std::array<const int, 0> C;
C c = {{}};
C const& cc = c;
TEST_LIBCPP_ASSERT_FAILURE(c.front(), "cannot call array<T, 0>::front() on a zero-sized array");
TEST_LIBCPP_ASSERT_FAILURE(cc.front(), "cannot call array<T, 0>::front() on a zero-sized array");
}
return 0;
}

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

  • This file was added.
//===----------------------------------------------------------------------===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
// UNSUPPORTED: c++03, windows, libcxx-no-debug-mode
// ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DEBUG=0
// test that array<T, 0>::operator[] triggers an assertion
#include <array>
#include "check_assertion.h"
int main(int, char**) {
{
typedef std::array<int, 0> C;
C c = {};
C const& cc = c;
TEST_LIBCPP_ASSERT_FAILURE(c[0], "cannot call array<T, 0>::operator[] on a zero-sized array");
TEST_LIBCPP_ASSERT_FAILURE(c[1], "cannot call array<T, 0>::operator[] on a zero-sized array");
TEST_LIBCPP_ASSERT_FAILURE(cc[0], "cannot call array<T, 0>::operator[] on a zero-sized array");
TEST_LIBCPP_ASSERT_FAILURE(cc[1], "cannot call array<T, 0>::operator[] on a zero-sized array");
}
{
typedef std::array<const int, 0> C;
C c = {{}};
C const& cc = c;
TEST_LIBCPP_ASSERT_FAILURE(c[0], "cannot call array<T, 0>::operator[] on a zero-sized array");
TEST_LIBCPP_ASSERT_FAILURE(c[1], "cannot call array<T, 0>::operator[] on a zero-sized array");
TEST_LIBCPP_ASSERT_FAILURE(cc[0], "cannot call array<T, 0>::operator[] on a zero-sized array");
TEST_LIBCPP_ASSERT_FAILURE(cc[1], "cannot call array<T, 0>::operator[] on a zero-sized array");
}
return 0;
}

libcxx/test/libcxx/containers/sequences/array/array.zero/db_back.pass.cpp

  • This file was deleted.
//===----------------------------------------------------------------------===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
// UNSUPPORTED: c++03
// UNSUPPORTED: windows
// ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DEBUG=1
// UNSUPPORTED: libcxx-no-debug-mode
// test array<T, 0>::front() raises a debug error.
#include <array>
#include "test_macros.h"
#include "debug_mode_helper.h"
int main(int, char**)
{
{
typedef std::array<int, 0> C;
C c = {};
C const& cc = c;
EXPECT_DEATH( c.back() );
EXPECT_DEATH( cc.back() );
}
{
typedef std::array<const int, 0> C;
C c = {{}};
C const& cc = c;
EXPECT_DEATH( c.back() );
EXPECT_DEATH( cc.back() );
}
return 0;
}

libcxx/test/libcxx/containers/sequences/array/array.zero/db_front.pass.cpp

  • This file was deleted.
//===----------------------------------------------------------------------===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
// UNSUPPORTED: c++03
// UNSUPPORTED: windows
// ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DEBUG=1
// UNSUPPORTED: libcxx-no-debug-mode
// test array<T, 0>::front() raises a debug error.
#include <array>
#include "test_macros.h"
#include "debug_mode_helper.h"
int main(int, char**)
{
{
typedef std::array<int, 0> C;
C c = {};
C const& cc = c;
EXPECT_DEATH(c.front());
EXPECT_DEATH(cc.front());
}
{
typedef std::array<const int, 0> C;
C c = {{}};
C const& cc = c;
EXPECT_DEATH(c.front());
EXPECT_DEATH(cc.front());
}
return 0;
}

libcxx/test/libcxx/containers/sequences/array/array.zero/db_indexing.pass.cpp

  • This file was deleted.
//===----------------------------------------------------------------------===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
// UNSUPPORTED: c++03
// UNSUPPORTED: windows
// ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DEBUG=1
// UNSUPPORTED: libcxx-no-debug-mode
// test array<T, 0>::operator[] raises a debug error.
#include <array>
#include "test_macros.h"
#include "debug_mode_helper.h"
int main(int, char**)
{
{
typedef std::array<int, 0> C;
C c = {};
C const& cc = c;
EXPECT_DEATH( c[0] );
EXPECT_DEATH( c[1] );
EXPECT_DEATH( cc[0] );
EXPECT_DEATH( cc[1] );
}
{
typedef std::array<const int, 0> C;
C c = {{}};
C const& cc = c;
EXPECT_DEATH( c[0] );
EXPECT_DEATH( c[1] );
EXPECT_DEATH( cc[0] );
EXPECT_DEATH( cc[1] );
}
return 0;
}

libcxx/test/libcxx/containers/sequences/deque/assert.pop_back.empty.pass.cpp

  • This file was moved from libcxx/test/libcxx/containers/sequences/deque/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: libcxx-no-debug-mode // UNSUPPORTED: c++03, windows, libcxx-no-debug-mode
// ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DEBUG=0
// ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DEBUG=1
#include <deque> #include <deque>
#include "test_macros.h" #include "check_assertion.h"
#include "debug_macros.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/deque/pop_back_empty.pass.cpp

  • This file was moved to libcxx/test/libcxx/containers/sequences/deque/assert.pop_back.empty.pass.cpp.

libcxx/test/libcxx/containers/sequences/list/list.cons/db_copy.pass.cpp

  • This file was moved to libcxx/test/libcxx/containers/sequences/list/list.cons/debug.copy.pass.cpp.

libcxx/test/libcxx/containers/sequences/list/list.cons/debug.copy.pass.cpp

  • This file was moved from libcxx/test/libcxx/containers/sequences/list/list.cons/db_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 // UNSUPPORTED: libcxx-no-debug-mode, c++03, windows
// ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DEBUG=1 // ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DEBUG=1
#include <list> #include <list>
#include "test_macros.h" #include "check_assertion.h"
#include "debug_macros.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

  • This file was moved from libcxx/test/libcxx/containers/sequences/list/list.modifiers/erase_iter_db1.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: libcxx-no-debug-mode // UNSUPPORTED: c++03, windows, libcxx-no-debug-mode
// ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DEBUG=0
// ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DEBUG=1
#include <list> #include <list>
#include "test_macros.h" #include "check_assertion.h"
#include "debug_macros.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

  • This file was moved from libcxx/test/libcxx/containers/sequences/list/list.modifiers/pop_back_db1.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: libcxx-no-debug-mode // UNSUPPORTED: c++03, windows, libcxx-no-debug-mode
// ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DEBUG=0
// ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DEBUG=1
#include <list> #include <list>
#include <cassert> #include <cassert>
#include "test_macros.h" #include "check_assertion.h"
#include "debug_macros.h"
int main(int, char**) int main(int, char**) {
{
int a[] = {1, 2, 3}; int a[] = {1, 2, 3};
std::list<int> c(a, a+3); std::list<int> c(a, a+3);
c.pop_back(); c.pop_back();
assert(c == std::list<int>(a, a+2)); assert(c == std::list<int>(a, a+2));
c.pop_back(); c.pop_back();
assert(c == std::list<int>(a, a+1)); assert(c == std::list<int>(a, a+1));
c.pop_back(); c.pop_back();
assert(c.empty()); assert(c.empty());
TEST_LIBCPP_ASSERT_FAILURE(c.pop_back(), "list::pop_back() called on an empty list"); TEST_LIBCPP_ASSERT_FAILURE(c.pop_back(), "list::pop_back() called on an empty list");
return 0; return 0;
} }

libcxx/test/libcxx/containers/sequences/list/list.modifiers/debug.emplace.pass.cpp

  • This file was moved from libcxx/test/libcxx/containers/sequences/list/list.modifiers/emplace_db1.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: c++03 // UNSUPPORTED: libcxx-no-debug-mode, c++03, windows
// UNSUPPORTED: libcxx-no-debug-mode
// ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DEBUG=1 // ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DEBUG=1
#include <list> #include <list>
#include "test_macros.h" #include "check_assertion.h"
#include "debug_macros.h"
struct A { struct A {
explicit A(int i, double d) { explicit A(int i, double d) {
(void)i; (void)i;
(void)d; (void)d;
} }
}; };
int main(int, char**) int main(int, char**) {
{
std::list<A> c1; std::list<A> c1;
std::list<A> c2; std::list<A> c2;
TEST_LIBCPP_ASSERT_FAILURE(c1.emplace(c2.cbegin(), 2, 3.5), TEST_LIBCPP_ASSERT_FAILURE(c1.emplace(c2.cbegin(), 2, 3.5),
"list::emplace(iterator, args...) called with an iterator not referring to this list"); "list::emplace(iterator, args...) called with an iterator not referring to this list");
return 0; return 0;
} }

libcxx/test/libcxx/containers/sequences/list/list.modifiers/debug.erase.iter.pass.cpp

  • This file was moved from libcxx/test/libcxx/containers/sequences/list/list.modifiers/erase_iter_db2.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 // UNSUPPORTED: libcxx-no-debug-mode, c++03, windows
// ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DEBUG=1 // ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DEBUG=1
#include <list> #include <list>
#include "test_macros.h" #include "check_assertion.h"
#include "debug_macros.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

  • This file was added.
//===----------------------------------------------------------------------===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
// <list>
// Call erase(const_iterator first, const_iterator last); with various invalid iterators
// UNSUPPORTED: libcxx-no-debug-mode, c++03, windows
// ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DEBUG=1
#include <list>
#include "check_assertion.h"
int main(int, char**) {
// First iterator from another container
{
int a1[] = {1, 2, 3};
std::list<int> l1(a1, a1+3);
std::list<int> l2(a1, a1+3);
TEST_LIBCPP_ASSERT_FAILURE(l1.erase(l2.cbegin(), std::next(l1.cbegin())),
"list::erase(iterator, iterator) called with an iterator not referring to this list");
}
// Second iterator from another container
{
int a1[] = {1, 2, 3};
std::list<int> l1(a1, a1+3);
std::list<int> l2(a1, a1+3);
TEST_LIBCPP_ASSERT_FAILURE(l1.erase(l1.cbegin(), std::next(l2.cbegin())),
"list::erase(iterator, iterator) called with an iterator not referring to this list");
}
// Both iterators from another container
{
int a1[] = {1, 2, 3};
std::list<int> l1(a1, a1+3);
std::list<int> l2(a1, a1+3);
TEST_LIBCPP_ASSERT_FAILURE(l1.erase(l2.cbegin(), std::next(l2.cbegin())),
"list::erase(iterator, iterator) called with an iterator not referring to this list");
}
// With an invalid range
{
int a1[] = {1, 2, 3};
std::list<int> l1(a1, a1+3);
TEST_LIBCPP_ASSERT_FAILURE(l1.erase(std::next(l1.cbegin()), l1.cbegin()),
"Attempted to increment a non-incrementable list::const_iterator");
}
return 0;
}

libcxx/test/libcxx/containers/sequences/list/list.modifiers/debug.insert.iter_iter_iter.pass.cpp

  • This file was moved from libcxx/test/libcxx/containers/sequences/list/list.modifiers/insert_iter_iter_iter_db1.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 // UNSUPPORTED: libcxx-no-debug-mode, c++03, windows
// ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DEBUG=1 // ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DEBUG=1
#include <list> #include <list>
#include "test_macros.h" #include "check_assertion.h"
#include "debug_macros.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

  • This file was moved from libcxx/test/libcxx/containers/sequences/list/list.modifiers/insert_iter_rvalue_db1.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 // UNSUPPORTED: libcxx-no-debug-mode, c++03, windows
// ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DEBUG=1 // ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DEBUG=1
#include <list> #include <list>
#include "test_macros.h" #include "check_assertion.h"
#include "debug_macros.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

  • This file was moved from libcxx/test/libcxx/containers/sequences/list/list.modifiers/insert_iter_size_value_db1.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 // UNSUPPORTED: libcxx-no-debug-mode, c++03, windows
// ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DEBUG=1 // ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DEBUG=1
#include <list> #include <list>
#include "test_macros.h" #include "check_assertion.h"
#include "debug_macros.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

  • This file was moved from libcxx/test/libcxx/containers/sequences/list/list.modifiers/insert_iter_value_db1.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 // UNSUPPORTED: libcxx-no-debug-mode, c++03, windows
// ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DEBUG=1 // ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DEBUG=1
#include <list> #include <list>
#include "test_macros.h" #include "check_assertion.h"
#include "debug_macros.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.modifiers/emplace_db1.pass.cpp

  • This file was moved to libcxx/test/libcxx/containers/sequences/list/list.modifiers/debug.emplace.pass.cpp.

libcxx/test/libcxx/containers/sequences/list/list.modifiers/erase_iter_db1.pass.cpp

  • This file was moved to libcxx/test/libcxx/containers/sequences/list/list.modifiers/assert.erase_iter.end.pass.cpp.

libcxx/test/libcxx/containers/sequences/list/list.modifiers/erase_iter_db2.pass.cpp

  • This file was moved to libcxx/test/libcxx/containers/sequences/list/list.modifiers/debug.erase.iter.pass.cpp.

libcxx/test/libcxx/containers/sequences/list/list.modifiers/erase_iter_iter_db1.pass.cpp

  • This file was deleted.
//===----------------------------------------------------------------------===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
// <list>
// Call erase(const_iterator first, const_iterator last); with first iterator from another container
// UNSUPPORTED: libcxx-no-debug-mode
// ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DEBUG=1
#include <list>
#include "test_macros.h"
#include "debug_macros.h"
int main(int, char**)
{
int a1[] = {1, 2, 3};
std::list<int> l1(a1, a1+3);
std::list<int> l2(a1, a1+3);
TEST_LIBCPP_ASSERT_FAILURE(l1.erase(l2.cbegin(), std::next(l1.cbegin())),
"list::erase(iterator, iterator) called with an iterator not referring to this list");
return 0;
}

libcxx/test/libcxx/containers/sequences/list/list.modifiers/erase_iter_iter_db2.pass.cpp

  • This file was deleted.
//===----------------------------------------------------------------------===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
// <list>
// Call erase(const_iterator first, const_iterator last); with second iterator from another container
// UNSUPPORTED: libcxx-no-debug-mode
// ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DEBUG=1
#include <list>
#include "test_macros.h"
#include "debug_macros.h"
int main(int, char**)
{
int a1[] = {1, 2, 3};
std::list<int> l1(a1, a1+3);
std::list<int> l2(a1, a1+3);
TEST_LIBCPP_ASSERT_FAILURE(l1.erase(l1.cbegin(), std::next(l2.cbegin())),
"list::erase(iterator, iterator) called with an iterator not referring to this list");
return 0;
}

libcxx/test/libcxx/containers/sequences/list/list.modifiers/erase_iter_iter_db3.pass.cpp

  • This file was deleted.
//===----------------------------------------------------------------------===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
// <list>
// Call erase(const_iterator first, const_iterator last); with both iterators from another container
// UNSUPPORTED: libcxx-no-debug-mode
// ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DEBUG=1
#include <list>
#include "test_macros.h"
#include "debug_macros.h"
int main(int, char**)
{
int a1[] = {1, 2, 3};
std::list<int> l1(a1, a1+3);
std::list<int> l2(a1, a1+3);
TEST_LIBCPP_ASSERT_FAILURE(l1.erase(l2.cbegin(), std::next(l2.cbegin())),
"list::erase(iterator, iterator) called with an iterator not referring to this list");
return 0;
}

libcxx/test/libcxx/containers/sequences/list/list.modifiers/erase_iter_iter_db4.pass.cpp

  • This file was deleted.
//===----------------------------------------------------------------------===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
// <list>
// Call erase(const_iterator first, const_iterator last); with a bad range
// UNSUPPORTED: libcxx-no-debug-mode
// ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DEBUG=1
#include <list>
#include "test_macros.h"
#include "debug_macros.h"
int main(int, char**)
{
int a1[] = {1, 2, 3};
std::list<int> l1(a1, a1+3);
TEST_LIBCPP_ASSERT_FAILURE(l1.erase(std::next(l1.cbegin()), l1.cbegin()),
"Attempted to increment a non-incrementable list::const_iterator");
return 0;
}

libcxx/test/libcxx/containers/sequences/list/list.modifiers/insert_iter_iter_iter_db1.pass.cpp

  • This file was moved to libcxx/test/libcxx/containers/sequences/list/list.modifiers/debug.insert.iter_iter_iter.pass.cpp.

libcxx/test/libcxx/containers/sequences/list/list.modifiers/insert_iter_rvalue_db1.pass.cpp

  • This file was moved to libcxx/test/libcxx/containers/sequences/list/list.modifiers/debug.insert.iter_rvalue.pass.cpp.

libcxx/test/libcxx/containers/sequences/list/list.modifiers/insert_iter_size_value_db1.pass.cpp

  • This file was moved to libcxx/test/libcxx/containers/sequences/list/list.modifiers/debug.insert.iter_size_value.pass.cpp.

libcxx/test/libcxx/containers/sequences/list/list.modifiers/insert_iter_value_db1.pass.cpp

  • This file was moved to libcxx/test/libcxx/containers/sequences/list/list.modifiers/debug.insert.iter_value.pass.cpp.

libcxx/test/libcxx/containers/sequences/list/list.modifiers/pop_back_db1.pass.cpp

  • This file was moved to libcxx/test/libcxx/containers/sequences/list/list.modifiers/assert.pop_back.empty.pass.cpp.

libcxx/test/libcxx/containers/sequences/list/list.ops/db_splice_pos_list.pass.cpp

  • This file was moved to libcxx/test/libcxx/containers/sequences/list/list.ops/debug.splice.pos_list.pass.cpp.

libcxx/test/libcxx/containers/sequences/list/list.ops/db_splice_pos_list_iter.pass.cpp

  • This file was moved to libcxx/test/libcxx/containers/sequences/list/list.ops/debug.splice.pos_list_iter.pass.cpp.

libcxx/test/libcxx/containers/sequences/list/list.ops/db_splice_pos_list_iter_iter.pass.cpp

  • This file was moved to libcxx/test/libcxx/containers/sequences/list/list.ops/debug.splice.pos_list_iter_iter.pass.cpp.

libcxx/test/libcxx/containers/sequences/list/list.ops/debug.splice.pos_list.pass.cpp

  • This file was moved from libcxx/test/libcxx/containers/sequences/list/list.ops/db_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 // UNSUPPORTED: libcxx-no-debug-mode, c++03, windows
// ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DEBUG=1 // ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DEBUG=1
#include <list> #include <list>
#include "test_macros.h" #include "check_assertion.h"
#include "debug_macros.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

  • This file was moved from libcxx/test/libcxx/containers/sequences/list/list.ops/db_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 // UNSUPPORTED: libcxx-no-debug-mode, c++03, windows
// ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DEBUG=1 // ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DEBUG=1
#include <list> #include <list>
#include "test_macros.h" #include "check_assertion.h"
#include "debug_macros.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

  • This file was moved from libcxx/test/libcxx/containers/sequences/list/list.ops/db_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 // UNSUPPORTED: libcxx-no-debug-mode, c++03, windows
// ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DEBUG=1 // ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DEBUG=1
#include <list> #include <list>
#include "test_macros.h" #include "check_assertion.h"
#include "debug_macros.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

  • This file was added.
//===----------------------------------------------------------------------===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
// <vector>
// Call back() on empty container.
// UNSUPPORTED: c++03, windows, libcxx-no-debug-mode
// ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DEBUG=0
#include <vector>
#include <cassert>
#include "check_assertion.h"
#include "min_allocator.h"
int main(int, char**) {
{
typedef int T;
typedef std::vector<T, min_allocator<T> > C;
C c(1);
assert(c.back() == 0);
c.clear();
TEST_LIBCPP_ASSERT_FAILURE(c.back(), "back() called on an empty vector");
}
{
typedef int T;
typedef std::vector<T> C;
C c(1);
assert(c.back() == 0);
c.clear();
TEST_LIBCPP_ASSERT_FAILURE(c.back(), "back() called on an empty vector");
}
return 0;
}

libcxx/test/libcxx/containers/sequences/vector/assert.cback.empty.pass.cpp

  • This file was moved from libcxx/test/libcxx/containers/sequences/vector/db_cback_2.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: libcxx-no-debug-mode // UNSUPPORTED: c++03, windows, libcxx-no-debug-mode
// ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DEBUG=0
// ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DEBUG=1
#include <vector> #include <vector>
#include "debug_macros.h" #include "check_assertion.h"
#include "test_macros.h"
#include "min_allocator.h" #include "min_allocator.h"
int main(int, char**) { int main(int, char**) {
{
typedef int T; typedef int T;
typedef std::vector<T, min_allocator<T> > C; typedef std::vector<T, min_allocator<T> > C;
const C c; const C c;
TEST_LIBCPP_ASSERT_FAILURE(c.back(), "back() called on an empty vector"); TEST_LIBCPP_ASSERT_FAILURE(c.back(), "back() called on an empty vector");
}
{
typedef int T;
typedef std::vector<T> C;
const C c;
TEST_LIBCPP_ASSERT_FAILURE(c.back(), "back() called on an empty vector");
}
return 0; return 0;
} }

libcxx/test/libcxx/containers/sequences/vector/assert.cfront.empty.pass.cpp

  • This file was moved from libcxx/test/libcxx/containers/sequences/vector/db_cfront_2.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: libcxx-no-debug-mode // UNSUPPORTED: c++03, windows, libcxx-no-debug-mode
// ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DEBUG=0
// ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DEBUG=1
#include <vector> #include <vector>
#include "debug_macros.h" #include "check_assertion.h"
#include "test_macros.h"
#include "min_allocator.h" #include "min_allocator.h"
int main(int, char**) { int main(int, char**) {
{
typedef int T; typedef int T;
typedef std::vector<T, min_allocator<T> > C; typedef std::vector<T, min_allocator<T> > C;
const C c; const C c;
TEST_LIBCPP_ASSERT_FAILURE(c.front(), "front() called on an empty vector"); TEST_LIBCPP_ASSERT_FAILURE(c.front(), "front() called on an empty vector");
}
{
typedef int T;
typedef std::vector<T> C;
const C c;
TEST_LIBCPP_ASSERT_FAILURE(c.front(), "front() called on an empty vector");
}
return 0; return 0;
} }

libcxx/test/libcxx/containers/sequences/vector/assert.cindex.oob.pass.cpp

  • This file was moved from libcxx/test/libcxx/containers/sequences/vector/db_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
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// <vector> // <vector>
// Index const vector out of bounds. // Index const vector out of bounds.
// UNSUPPORTED: libcxx-no-debug-mode // UNSUPPORTED: c++03, windows, libcxx-no-debug-mode
// ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DEBUG=0
// ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DEBUG=1
#include <vector> #include <vector>
#include <cassert> #include <cassert>
#include "debug_macros.h" #include "check_assertion.h"
#include "test_macros.h" #include "min_allocator.h"
int main(int, char**) {
{
typedef int T;
typedef std::vector<T, min_allocator<T> > C;
const C c(1);
assert(c[0] == 0);
TEST_LIBCPP_ASSERT_FAILURE(c[1], "vector[] index out of bounds");
}
int main(int, char**)
{ {
typedef int T; typedef int T;
typedef std::vector<T> C; typedef std::vector<T> C;
const C c(1); const C c(1);
assert(c[0] == 0); assert(c[0] == 0);
TEST_LIBCPP_ASSERT_FAILURE(c[1], "vector[] index out of bounds"); TEST_LIBCPP_ASSERT_FAILURE(c[1], "vector[] index out of bounds");
}
return 0; return 0;
} }

libcxx/test/libcxx/containers/sequences/vector/assert.front.empty.pass.cpp

  • This file was added.
//===----------------------------------------------------------------------===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
// <vector>
// Call front() on empty container.
// UNSUPPORTED: c++03, windows, libcxx-no-debug-mode
// ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DEBUG=0
#include <vector>
#include <cassert>
#include "check_assertion.h"
#include "min_allocator.h"
int main(int, char**) {
{
typedef int T;
typedef std::vector<T, min_allocator<T> > C;
C c(1);
assert(c.front() == 0);
c.clear();
TEST_LIBCPP_ASSERT_FAILURE(c.front(), "front() called on an empty vector");
}
{
typedef int T;
typedef std::vector<T> C;
C c(1);
assert(c.front() == 0);
c.clear();
TEST_LIBCPP_ASSERT_FAILURE(c.front(), "front() called on an empty vector");
}
return 0;
}

libcxx/test/libcxx/containers/sequences/vector/assert.index.oob.pass.cpp

  • This file was moved from libcxx/test/libcxx/containers/sequences/vector/db_index_2.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: libcxx-no-debug-mode // UNSUPPORTED: c++03, windows, libcxx-no-debug-mode
// ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DEBUG=0
// ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DEBUG=1
#include <vector> #include <vector>
#include <cassert> #include <cassert>
#include "test_macros.h" #include "check_assertion.h"
#include "debug_macros.h"
#include "min_allocator.h" #include "min_allocator.h"
int main(int, char**) { int main(int, char**) {
{
typedef int T; typedef int T;
typedef std::vector<T, min_allocator<T> > C; typedef std::vector<T, min_allocator<T> > C;
C c(1); C c(1);
assert(c[0] == 0); assert(c[0] == 0);
TEST_LIBCPP_ASSERT_FAILURE(c[1], "vector[] index out of bounds"); TEST_LIBCPP_ASSERT_FAILURE(c[1], "vector[] index out of bounds");
}
{
typedef int T;
typedef std::vector<T> C;
C c(1);
assert(c[0] == 0);
TEST_LIBCPP_ASSERT_FAILURE(c[1], "vector[] index out of bounds");
}
return 0; return 0;
} }

libcxx/test/libcxx/containers/sequences/vector/assert.pop_back.empty.pass.cpp

  • This file was moved from libcxx/test/libcxx/containers/sequences/vector/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: libcxx-no-debug-mode // UNSUPPORTED: c++03, windows, libcxx-no-debug-mode
// ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DEBUG=0
// ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DEBUG=1
#include <vector> #include <vector>
#include "test_macros.h" #include "check_assertion.h"
#include "debug_macros.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/db_back.pass.cpp

  • This file was deleted.
//===----------------------------------------------------------------------===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
// <vector>
// Call back() on empty container.
// UNSUPPORTED: libcxx-no-debug-mode
// ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DEBUG=1
#include <vector>
#include <cassert>
#include "test_macros.h"
#include "debug_macros.h"
int main(int, char**) {
typedef int T;
typedef std::vector<T> C;
C c(1);
assert(c.back() == 0);
c.clear();
TEST_LIBCPP_ASSERT_FAILURE(c.back(), "back() called on an empty vector");
return 0;
}

libcxx/test/libcxx/containers/sequences/vector/db_back_2.pass.cpp

  • This file was deleted.
//===----------------------------------------------------------------------===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
// <vector>
// Call back() on empty container.
// UNSUPPORTED: libcxx-no-debug-mode
// ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DEBUG=1
#include <vector>
#include <cassert>
#include "test_macros.h"
#include "debug_macros.h"
#include "min_allocator.h"
int main(int, char**) {
typedef int T;
typedef std::vector<T, min_allocator<T> > C;
C c(1);
assert(c.back() == 0);
c.clear();
TEST_LIBCPP_ASSERT_FAILURE(c.back(), "back() called on an empty vector");
return 0;
}

libcxx/test/libcxx/containers/sequences/vector/db_cback.pass.cpp

  • This file was deleted.
//===----------------------------------------------------------------------===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
// <vector>
// Call back() on empty const container.
// UNSUPPORTED: libcxx-no-debug-mode
// ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DEBUG=1
#include <vector>
#include "test_macros.h"
#include "debug_macros.h"
int main(int, char**) {
typedef int T;
typedef std::vector<T> C;
const C c;
TEST_LIBCPP_ASSERT_FAILURE(c.back(), "back() called on an empty vector");
return 0;
}

libcxx/test/libcxx/containers/sequences/vector/db_cback_2.pass.cpp

  • This file was moved to libcxx/test/libcxx/containers/sequences/vector/assert.cback.empty.pass.cpp.

libcxx/test/libcxx/containers/sequences/vector/db_cfront.pass.cpp

  • This file was deleted.
//===----------------------------------------------------------------------===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
// <vector>
// Call front() on empty const container.
// UNSUPPORTED: libcxx-no-debug-mode
// ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DEBUG=1
#include <vector>
#include "test_macros.h"
#include "debug_macros.h"
int main(int, char**) {
typedef int T;
typedef std::vector<T> C;
const C c;
TEST_LIBCPP_ASSERT_FAILURE(c.front(), "front() called on an empty vector");
return 0;
}

libcxx/test/libcxx/containers/sequences/vector/db_cfront_2.pass.cpp

  • This file was moved to libcxx/test/libcxx/containers/sequences/vector/assert.cfront.empty.pass.cpp.

libcxx/test/libcxx/containers/sequences/vector/db_cindex.pass.cpp

  • This file was moved to libcxx/test/libcxx/containers/sequences/vector/assert.cindex.oob.pass.cpp.

libcxx/test/libcxx/containers/sequences/vector/db_cindex_2.pass.cpp

  • This file was deleted.
//===----------------------------------------------------------------------===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
// <vector>
// Index const vector out of bounds.
// UNSUPPORTED: libcxx-no-debug-mode
// ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DEBUG=1
#include <vector>
#include <cassert>
#include "debug_macros.h"
#include "test_macros.h"
#include "min_allocator.h"
int main(int, char**) {
typedef int T;
typedef std::vector<T, min_allocator<T> > C;
const C c(1);
assert(c[0] == 0);
TEST_LIBCPP_ASSERT_FAILURE(c[1], "vector[] index out of bounds");
return 0;
}

libcxx/test/libcxx/containers/sequences/vector/db_front.pass.cpp

  • This file was deleted.
//===----------------------------------------------------------------------===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
// <vector>
// Call front() on empty container.
// UNSUPPORTED: libcxx-no-debug-mode
// ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DEBUG=1
#include <vector>
#include <cassert>
#include "test_macros.h"
#include "debug_macros.h"
int main(int, char**) {
typedef int T;
typedef std::vector<T> C;
C c(1);
assert(c.front() == 0);
c.clear();
TEST_LIBCPP_ASSERT_FAILURE(c.front(), "front() called on an empty vector");
return 0;
}

libcxx/test/libcxx/containers/sequences/vector/db_front_2.pass.cpp

  • This file was deleted.
//===----------------------------------------------------------------------===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
// <vector>
// Call front() on empty container.
// UNSUPPORTED: libcxx-no-debug-mode
// ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DEBUG=1
#include <vector>
#include <cassert>
#include "test_macros.h"
#include "debug_macros.h"
#include "min_allocator.h"
int main(int, char**) {
typedef int T;
typedef std::vector<T, min_allocator<T> > C;
C c(1);
assert(c.front() == 0);
c.clear();
TEST_LIBCPP_ASSERT_FAILURE(c.front(), "front() called on an empty vector");
return 0;
}

libcxx/test/libcxx/containers/sequences/vector/db_index.pass.cpp

  • This file was deleted.
//===----------------------------------------------------------------------===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
// <vector>
// Index vector out of bounds.
// UNSUPPORTED: libcxx-no-debug-mode
// ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DEBUG=1
#include <vector>
#include <cassert>
#include "test_macros.h"
#include "debug_macros.h"
int main(int, char**) {
typedef int T;
typedef std::vector<T> C;
C c(1);
assert(c[0] == 0);
TEST_LIBCPP_ASSERT_FAILURE(c[1], "vector[] index out of bounds");
return 0;
}

libcxx/test/libcxx/containers/sequences/vector/db_index_2.pass.cpp

  • This file was moved to libcxx/test/libcxx/containers/sequences/vector/assert.index.oob.pass.cpp.

libcxx/test/libcxx/containers/sequences/vector/db_iterators_10.pass.cpp

  • This file was deleted after being copied to libcxx/test/libcxx/containers/sequences/vector/debug.iterator.subtract.pass.cpp, libcxx/test/libcxx/strings/basic.string/string.iterators/debug.iterator.subtract.pass.cpp.
The contents of this file were not changed.

libcxx/test/libcxx/containers/sequences/vector/db_iterators_11.pass.cpp

  • This file was moved to libcxx/test/libcxx/containers/sequences/vector/debug.iterator.index.pass.cpp.

libcxx/test/libcxx/containers/sequences/vector/db_iterators_12.pass.cpp

  • This file was deleted.
//===----------------------------------------------------------------------===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
// <vector>
// Add to iterator out of bounds.
// UNSUPPORTED: libcxx-no-debug-mode
// ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DEBUG=1
#include <vector>
#include <cassert>
#include "test_macros.h"
#include "debug_macros.h"
#include "min_allocator.h"
int main(int, char**) {
typedef int T;
typedef std::vector<T, min_allocator<T> > C;
C c(1);
C::iterator i = c.begin();
i += 1;
assert(i == c.end());
i = c.begin();
TEST_LIBCPP_ASSERT_FAILURE(i + 2, "Attempted to add/subtract an iterator outside its valid range");
return 0;
}

libcxx/test/libcxx/containers/sequences/vector/db_iterators_13.pass.cpp

  • This file was moved to libcxx/test/libcxx/containers/sequences/vector/debug.iterator.decrement.pass.cpp.

libcxx/test/libcxx/containers/sequences/vector/db_iterators_14.pass.cpp

  • This file was deleted.
//===----------------------------------------------------------------------===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
// <vector>
// Increment iterator past end.
// UNSUPPORTED: libcxx-no-debug-mode
// ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DEBUG=1
#include <vector>
#include <cassert>
#include "test_macros.h"
#include "debug_macros.h"
#include "min_allocator.h"
int main(int, char**) {
typedef int T;
typedef std::vector<T, min_allocator<T> > C;
C c(1);
C::iterator i = c.begin();
++i;
assert(i == c.end());
TEST_LIBCPP_ASSERT_FAILURE(++i, "Attempted to increment a non-incrementable iterator");
return 0;
}

libcxx/test/libcxx/containers/sequences/vector/db_iterators_15.pass.cpp

  • This file was deleted.
//===----------------------------------------------------------------------===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
// <vector>
// Dereference non-dereferenceable iterator.
// UNSUPPORTED: libcxx-no-debug-mode
// ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DEBUG=1
#include <vector>
#include "test_macros.h"
#include "debug_macros.h"
#include "min_allocator.h"
int main(int, char**) {
typedef int T;
typedef std::vector<T, min_allocator<T> > C;
C c(1);
C::iterator i = c.end();
TEST_LIBCPP_ASSERT_FAILURE(*i, "Attempted to dereference a non-dereferenceable iterator");
return 0;
}

libcxx/test/libcxx/containers/sequences/vector/db_iterators_2.pass.cpp

  • This file was deleted.
//===----------------------------------------------------------------------===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
// <vector>
// Compare iterators from different containers with <.
// UNSUPPORTED: libcxx-no-debug-mode
// ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DEBUG=1
#include <vector>
#include "test_macros.h"
#include "debug_macros.h"
int main(int, char**) {
typedef int T;
typedef std::vector<T> C;
C c1;
C c2;
TEST_LIBCPP_ASSERT_FAILURE(c1.begin() < c2.begin(), "Attempted to compare incomparable iterators");
return 0;
}

libcxx/test/libcxx/containers/sequences/vector/db_iterators_3.pass.cpp

  • This file was deleted.
//===----------------------------------------------------------------------===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
// <vector>
// Subtract iterators from different containers.
// UNSUPPORTED: libcxx-no-debug-mode
// ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DEBUG=1
#include <vector>
#include "test_macros.h"
#include "debug_macros.h"
int main(int, char**) {
typedef int T;
typedef std::vector<T> C;
C c1;
C c2;
TEST_LIBCPP_ASSERT_FAILURE(c1.begin() - c2.begin(), "Attempted to subtract incompatible iterators");
return 0;
}

libcxx/test/libcxx/containers/sequences/vector/db_iterators_4.pass.cpp

  • This file was deleted.
//===----------------------------------------------------------------------===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
// <vector>
// Index iterator out of bounds.
// UNSUPPORTED: libcxx-no-debug-mode
// ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DEBUG=1
#include <vector>
#include <cassert>
#include "test_macros.h"
#include "debug_macros.h"
int main(int, char**) {
typedef int T;
typedef std::vector<T> C;
C c(1);
C::iterator i = c.begin();
assert(i[0] == 0);
TEST_LIBCPP_ASSERT_FAILURE(i[1], "Attempted to subscript an iterator outside its valid range");
return 0;
}

libcxx/test/libcxx/containers/sequences/vector/db_iterators_5.pass.cpp

  • This file was deleted.
//===----------------------------------------------------------------------===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
// <vector>
// Add to iterator out of bounds.
// UNSUPPORTED: libcxx-no-debug-mode
// ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DEBUG=1
#include <vector>
#include <cassert>
#include "test_macros.h"
#include "debug_macros.h"
int main(int, char**) {
typedef int T;
typedef std::vector<T> C;
C c(1);
C::iterator i = c.begin();
i += 1;
assert(i == c.end());
i = c.begin();
TEST_LIBCPP_ASSERT_FAILURE(i + 2, "Attempted to add/subtract an iterator outside its valid range");
return 0;
}

libcxx/test/libcxx/containers/sequences/vector/db_iterators_6.pass.cpp

  • This file was deleted.
//===----------------------------------------------------------------------===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
// <vector>
// Decrement iterator prior to begin.
// UNSUPPORTED: libcxx-no-debug-mode
// ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DEBUG=1
#include <vector>
#include <cassert>
#include "test_macros.h"
#include "debug_macros.h"
int main(int, char**) {
typedef int T;
typedef std::vector<T> C;
C c(1);
C::iterator i = c.end();
--i;
assert(i == c.begin());
TEST_LIBCPP_ASSERT_FAILURE(--i, "Attempted to decrement a non-decrementable iterator");
return 0;
}

libcxx/test/libcxx/containers/sequences/vector/db_iterators_7.pass.cpp

  • This file was deleted.
//===----------------------------------------------------------------------===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
// <vector>
// Increment iterator past end.
// UNSUPPORTED: libcxx-no-debug-mode
// ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DEBUG=1
#include <vector>
#include <cassert>
#include "test_macros.h"
#include "debug_macros.h"
int main(int, char**) {
typedef int T;
typedef std::vector<T> C;
C c(1);
C::iterator i = c.begin();
++i;
assert(i == c.end());
TEST_LIBCPP_ASSERT_FAILURE(++i, "Attempted to increment a non-incrementable iterator");
return 0;
}

libcxx/test/libcxx/containers/sequences/vector/db_iterators_8.pass.cpp

  • This file was deleted.
//===----------------------------------------------------------------------===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
// <vector>
// Dereference non-dereferenceable iterator.
// UNSUPPORTED: libcxx-no-debug-mode
// ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DEBUG=1
#include <vector>
#include "test_macros.h"
#include "debug_macros.h"
int main(int, char**) {
typedef int T;
typedef std::vector<T> C;
C c(1);
C::iterator i = c.end();
TEST_LIBCPP_ASSERT_FAILURE(*i, "Attempted to dereference a non-dereferenceable iterator");
return 0;
}

libcxx/test/libcxx/containers/sequences/vector/db_iterators_9.pass.cpp

  • This file was moved to libcxx/test/libcxx/containers/sequences/vector/debug.iterator.compare.pass.cpp.

libcxx/test/libcxx/containers/sequences/vector/debug.iterator.add.pass.cpp

  • This file was added.
//===----------------------------------------------------------------------===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
// <vector>
// Add to iterator out of bounds.
// UNSUPPORTED: libcxx-no-debug-mode, c++03, windows
// ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DEBUG=1
#include <vector>
#include <cassert>
#include "check_assertion.h"
#include "min_allocator.h"
int main(int, char**) {
{
typedef int T;
typedef std::vector<T> C;
C c(1);
C::iterator i = c.begin();
i += 1;
assert(i == c.end());
i = c.begin();
TEST_LIBCPP_ASSERT_FAILURE(i + 2, "Attempted to add/subtract an iterator outside its valid range");
}
{
typedef int T;
typedef std::vector<T, min_allocator<T> > C;
C c(1);
C::iterator i = c.begin();
i += 1;
assert(i == c.end());
i = c.begin();
TEST_LIBCPP_ASSERT_FAILURE(i + 2, "Attempted to add/subtract an iterator outside its valid range");
}
return 0;
}

libcxx/test/libcxx/containers/sequences/vector/debug.iterator.compare.pass.cpp

  • This file was moved from libcxx/test/libcxx/containers/sequences/vector/db_iterators_9.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 // UNSUPPORTED: libcxx-no-debug-mode, c++03, windows
// ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DEBUG=1 // ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DEBUG=1
#include <vector> #include <vector>
#include "test_macros.h" #include "check_assertion.h"
#include "debug_macros.h"
#include "min_allocator.h" #include "min_allocator.h"
int main(int, char**) { int main(int, char**) {
{
typedef int T;
typedef std::vector<T> C;
C c1;
C c2;
TEST_LIBCPP_ASSERT_FAILURE(c1.begin() < c2.begin(), "Attempted to compare incomparable iterators");
}
{
typedef int T; typedef int T;
typedef std::vector<T, min_allocator<T> > C; typedef std::vector<T, min_allocator<T> > C;
C c1; C c1;
C c2; C c2;
TEST_LIBCPP_ASSERT_FAILURE(c1.begin() < c2.begin(), "Attempted to compare incomparable iterators"); TEST_LIBCPP_ASSERT_FAILURE(c1.begin() < c2.begin(), "Attempted to compare incomparable iterators");
}
return 0; return 0;
} }

libcxx/test/libcxx/containers/sequences/vector/debug.iterator.decrement.pass.cpp

  • This file was moved from libcxx/test/libcxx/containers/sequences/vector/db_iterators_13.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 // UNSUPPORTED: libcxx-no-debug-mode, c++03, windows
// ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DEBUG=1 // ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DEBUG=1
#include <vector> #include <vector>
#include <cassert> #include <cassert>
#include "test_macros.h" #include "check_assertion.h"
#include "debug_macros.h"
#include "min_allocator.h" #include "min_allocator.h"
int main(int, char**) { int main(int, char**) {
{
typedef int T;
typedef std::vector<T> C;
C c(1);
C::iterator i = c.end();
--i;
assert(i == c.begin());
TEST_LIBCPP_ASSERT_FAILURE(--i, "Attempted to decrement a non-decrementable iterator");
}
{
typedef int T; typedef int T;
typedef std::vector<T, min_allocator<T> > C; typedef std::vector<T, min_allocator<T> > C;
C c(1); C c(1);
C::iterator i = c.end(); C::iterator i = c.end();
--i; --i;
assert(i == c.begin()); assert(i == c.begin());
TEST_LIBCPP_ASSERT_FAILURE(--i, "Attempted to decrement a non-decrementable iterator"); TEST_LIBCPP_ASSERT_FAILURE(--i, "Attempted to decrement a non-decrementable iterator");
}
return 0; return 0;
} }

libcxx/test/libcxx/containers/sequences/vector/debug.iterator.dereference.pass.cpp

  • This file was moved from libcxx/test/libcxx/containers/unord/unord.set/db_iterators_10.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> // <vector>
// Dereference non-dereferenceable iterator. // Dereference non-dereferenceable iterator.
// UNSUPPORTED: libcxx-no-debug-mode // UNSUPPORTED: libcxx-no-debug-mode, c++03, windows
// UNSUPPORTED: c++03
// ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DEBUG=1 // ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DEBUG=1
#include <unordered_set> #include <vector>
#include "test_macros.h" #include "check_assertion.h"
#include "debug_macros.h"
#include "min_allocator.h" #include "min_allocator.h"
int main(int, char**) { int main(int, char**) {
{
typedef int T; typedef int T;
typedef std::unordered_set<T, std::hash<T>, std::equal_to<T>, min_allocator<T>> C; typedef std::vector<T> C;
C c(1); C c(1);
C::iterator i = c.end(); C::iterator i = c.end();
TEST_LIBCPP_ASSERT_FAILURE(*i, "Attempted to dereference a non-dereferenceable unordered container const_iterator"); TEST_LIBCPP_ASSERT_FAILURE(*i, "Attempted to dereference a non-dereferenceable iterator");
}
{
typedef int T;
typedef std::vector<T, min_allocator<T> > C;
C c(1);
C::iterator i = c.end();
TEST_LIBCPP_ASSERT_FAILURE(*i, "Attempted to dereference a non-dereferenceable iterator");
}
return 0; return 0;
} }

libcxx/test/libcxx/containers/sequences/vector/debug.iterator.increment.pass.cpp

  • This file was moved from libcxx/test/libcxx/containers/unord/unord.set/db_iterators_9.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> // <vector>
// Increment iterator past end. // Increment iterator past end.
// UNSUPPORTED: libcxx-no-debug-mode // UNSUPPORTED: libcxx-no-debug-mode, c++03, windows
// UNSUPPORTED: c++03
// ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DEBUG=1 // ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DEBUG=1
#include <unordered_set> #include <vector>
#include <cassert> #include <cassert>
#include "test_macros.h" #include "check_assertion.h"
#include "debug_macros.h"
#include "min_allocator.h" #include "min_allocator.h"
int main(int, char**) { int main(int, char**) {
{
typedef int T;
typedef std::vector<T> C;
C c(1);
C::iterator i = c.begin();
++i;
assert(i == c.end());
TEST_LIBCPP_ASSERT_FAILURE(++i, "Attempted to increment a non-incrementable iterator");
}
{
typedef int T; typedef int T;
typedef std::unordered_set<T, std::hash<T>, std::equal_to<T>, min_allocator<T>> C; typedef std::vector<T, min_allocator<T> > C;
C c({42}); C c(1);
C::iterator i = c.begin(); C::iterator i = c.begin();
assert(i != c.end());
++i; ++i;
assert(i == c.end()); assert(i == c.end());
TEST_LIBCPP_ASSERT_FAILURE(++i, "Attempted to increment a non-incrementable unordered container const_iterator"); TEST_LIBCPP_ASSERT_FAILURE(++i, "Attempted to increment a non-incrementable iterator");
}
return 0; return 0;
} }

libcxx/test/libcxx/containers/sequences/vector/debug.iterator.index.pass.cpp

  • This file was moved from libcxx/test/libcxx/containers/sequences/vector/db_iterators_11.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 // UNSUPPORTED: libcxx-no-debug-mode, c++03, windows
// ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DEBUG=1 // ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DEBUG=1
#include <vector> #include <vector>
#include <cassert> #include <cassert>
#include "test_macros.h" #include "check_assertion.h"
#include "debug_macros.h"
#include "min_allocator.h" #include "min_allocator.h"
int main(int, char**) { int main(int, char**) {
{
typedef int T;
typedef std::vector<T> C;
C c(1);
C::iterator i = c.begin();
assert(i[0] == 0);
TEST_LIBCPP_ASSERT_FAILURE(i[1], "Attempted to subscript an iterator outside its valid range");
}
{
typedef int T; typedef int T;
typedef std::vector<T, min_allocator<T> > C; typedef std::vector<T, min_allocator<T> > C;
C c(1); C c(1);
C::iterator i = c.begin(); C::iterator i = c.begin();
assert(i[0] == 0); assert(i[0] == 0);
TEST_LIBCPP_ASSERT_FAILURE(i[1], "Attempted to subscript an iterator outside its valid range"); TEST_LIBCPP_ASSERT_FAILURE(i[1], "Attempted to subscript an iterator outside its valid range");
}
return 0; return 0;
} }

libcxx/test/libcxx/containers/sequences/vector/debug.iterator.subtract.pass.cpp

  • This file was copied from libcxx/test/libcxx/containers/sequences/vector/db_iterators_10.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 // UNSUPPORTED: libcxx-no-debug-mode, c++03, windows
// ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DEBUG=1 // ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DEBUG=1
#include <vector> #include <vector>
#include "test_macros.h" #include "check_assertion.h"
#include "debug_macros.h"
#include "min_allocator.h" #include "min_allocator.h"
int main(int, char**) { int main(int, char**) {
{
typedef int T;
typedef std::vector<T> C;
C c1;
C c2;
TEST_LIBCPP_ASSERT_FAILURE(c1.begin() - c2.begin(), "Attempted to subtract incompatible iterators");
}
{
typedef int T; typedef int T;
typedef std::vector<T, min_allocator<T> > C; typedef std::vector<T, min_allocator<T> > C;
C c1; C c1;
C c2; C c2;
TEST_LIBCPP_ASSERT_FAILURE(c1.begin() - c2.begin(), "Attempted to subtract incompatible iterators"); TEST_LIBCPP_ASSERT_FAILURE(c1.begin() - c2.begin(), "Attempted to subtract incompatible iterators");
}
return 0; return 0;
} }

libcxx/test/libcxx/containers/sequences/vector/pop_back_empty.pass.cpp

  • This file was moved to libcxx/test/libcxx/containers/sequences/vector/assert.pop_back.empty.pass.cpp.

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

  • This file was moved from libcxx/test/libcxx/containers/unord/unord.map/db_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: libcxx-no-debug-mode // UNSUPPORTED: c++03, windows, libcxx-no-debug-mode
// ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DEBUG=0
// ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DEBUG=1
#include <unordered_map> #include <unordered_map>
#include <string> #include <string>
#include "test_macros.h" #include "check_assertion.h"
#include "debug_macros.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

  • This file was moved from libcxx/test/libcxx/containers/unord/unord.map/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: libcxx-no-debug-mode // UNSUPPORTED: c++03, windows, libcxx-no-debug-mode
// ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DEBUG=0
// ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DEBUG=1
#include <unordered_map> #include <unordered_map>
#include <string> #include <string>
#include "test_macros.h" #include "check_assertion.h"
#include "debug_macros.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

  • This file was moved from libcxx/test/libcxx/containers/unord/unord.map/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: libcxx-no-debug-mode // UNSUPPORTED: c++03, windows, libcxx-no-debug-mode
// ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DEBUG=0
// ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DEBUG=1
#include <unordered_map> #include <unordered_map>
#include <string> #include <string>
#include "test_macros.h" #include "check_assertion.h"
#include "debug_macros.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/bucket_size.pass.cpp

  • This file was moved to libcxx/test/libcxx/containers/unord/unord.map/assert.bucket_size.pass.cpp.

libcxx/test/libcxx/containers/unord/unord.map/db_bucket.pass.cpp

  • This file was moved to libcxx/test/libcxx/containers/unord/unord.map/assert.bucket.pass.cpp.

libcxx/test/libcxx/containers/unord/unord.map/db_insert_hint_const_lvalue.pass.cpp

  • This file was moved to libcxx/test/libcxx/containers/unord/unord.map/debug.insert.hint_const_lvalue.pass.cpp.

libcxx/test/libcxx/containers/unord/unord.map/db_insert_hint_rvalue.pass.cpp

  • This file was moved to libcxx/test/libcxx/containers/unord/unord.map/debug.insert.hint_rvalue.pass.cpp.

libcxx/test/libcxx/containers/unord/unord.map/db_iterators_10.pass.cpp

  • This file was moved to libcxx/test/libcxx/strings/basic.string/string.iterators/debug.iterator.dereference.pass.cpp.

libcxx/test/libcxx/containers/unord/unord.map/db_iterators_7.pass.cpp

  • This file was deleted.
//===----------------------------------------------------------------------===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
// <unordered_map>
// Increment iterator past end.
// UNSUPPORTED: libcxx-no-debug-mode
// ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DEBUG=1
#include <unordered_map>
#include <cassert>
#include <string>
#include "test_macros.h"
#include "debug_macros.h"
int main(int, char**) {
typedef std::unordered_map<int, std::string> C;
C c;
c.insert(std::make_pair(1, "one"));
C::iterator i = c.begin();
++i;
assert(i == c.end());
TEST_LIBCPP_ASSERT_FAILURE(++i, "Attempted to increment a non-incrementable unordered container iterator");
return 0;
}

libcxx/test/libcxx/containers/unord/unord.map/db_iterators_8.pass.cpp

  • This file was deleted.
//===----------------------------------------------------------------------===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
// <unordered_map>
// Dereference non-dereferenceable iterator.
// UNSUPPORTED: libcxx-no-debug-mode
// ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DEBUG=1
#include <unordered_map>
#include <string>
#include "test_macros.h"
#include "debug_macros.h"
int main(int, char**) {
typedef std::unordered_map<int, std::string> C;
C c;
c.insert(std::make_pair(1, "one"));
C::iterator i = c.end();
TEST_LIBCPP_ASSERT_FAILURE(*i, "Attempted to dereference a non-dereferenceable unordered container iterator");
return 0;
}

libcxx/test/libcxx/containers/unord/unord.map/db_iterators_9.pass.cpp

  • This file was deleted.
//===----------------------------------------------------------------------===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
// <unordered_map>
// Increment iterator past end.
// UNSUPPORTED: libcxx-no-debug-mode
// UNSUPPORTED: c++03
// ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DEBUG=1
#include <unordered_map>
#include <cassert>
#include <string>
#include "test_macros.h"
#include "debug_macros.h"
#include "min_allocator.h"
int main(int, char**) {
typedef std::unordered_map<int, std::string, std::hash<int>, std::equal_to<int>,
min_allocator<std::pair<const int, std::string>>> C;
C c;
c.insert(std::make_pair(1, "one"));
C::iterator i = c.begin();
++i;
assert(i == c.end());
TEST_LIBCPP_ASSERT_FAILURE(++i, "Attempted to increment a non-incrementable unordered container iterator");
return 0;
}

libcxx/test/libcxx/containers/unord/unord.map/db_local_iterators_10.pass.cpp

  • This file was deleted.
//===----------------------------------------------------------------------===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
// <unordered_map>
// Dereference non-dereferenceable iterator.
// UNSUPPORTED: libcxx-no-debug-mode
// UNSUPPORTED: c++03
// ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DEBUG=1
#include <unordered_map>
#include <string>
#include "test_macros.h"
#include "debug_macros.h"
#include "min_allocator.h"
int main(int, char**) {
typedef std::unordered_map<int, std::string, std::hash<int>, std::equal_to<int>,
min_allocator<std::pair<const int, std::string>>> C;
C c(1);
C::local_iterator i = c.end(0);
TEST_LIBCPP_ASSERT_FAILURE(*i, "Attempted to dereference a non-dereferenceable unordered container local_iterator");
return 0;
}

libcxx/test/libcxx/containers/unord/unord.map/db_local_iterators_7.pass.cpp

  • This file was deleted.
//===----------------------------------------------------------------------===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
// <unordered_map>
// Increment local_iterator past end.
// UNSUPPORTED: libcxx-no-debug-mode
// ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DEBUG=1
#include <unordered_map>
#include <string>
#include <cassert>
#include "test_macros.h"
#include "debug_macros.h"
int main(int, char**) {
typedef std::unordered_map<int, std::string> C;
C c;
c.insert(std::make_pair(42, std::string()));
C::size_type b = c.bucket(42);
C::local_iterator i = c.begin(b);
assert(i != c.end(b));
++i;
assert(i == c.end(b));
TEST_LIBCPP_ASSERT_FAILURE(++i, "Attempted to increment a non-incrementable unordered container local_iterator");
return 0;
}

libcxx/test/libcxx/containers/unord/unord.map/db_local_iterators_8.pass.cpp

  • This file was deleted.
//===----------------------------------------------------------------------===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
// <unordered_map>
// Dereference non-dereferenceable iterator.
// UNSUPPORTED: libcxx-no-debug-mode
// ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DEBUG=1
#include <unordered_map>
#include <string>
#include "test_macros.h"
#include "debug_macros.h"
int main(int, char**) {
typedef std::unordered_map<int, std::string> C;
C c(1);
C::local_iterator i = c.end(0);
TEST_LIBCPP_ASSERT_FAILURE(*i, "Attempted to dereference a non-dereferenceable unordered container local_iterator");
return 0;
}

libcxx/test/libcxx/containers/unord/unord.map/db_local_iterators_9.pass.cpp

  • This file was deleted.
//===----------------------------------------------------------------------===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
// <unordered_map>
// Increment local_iterator past end.
// UNSUPPORTED: libcxx-no-debug-mode
// UNSUPPORTED: c++03
// ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DEBUG=1
#include <unordered_map>
#include <string>
#include <cassert>
#include "test_macros.h"
#include "debug_macros.h"
#include "min_allocator.h"
int main(int, char**) {
typedef std::unordered_map<int, std::string, std::hash<int>, std::equal_to<int>,
min_allocator<std::pair<const int, std::string>>> C;
C c({{42, std::string()}});
C::size_type b = c.bucket(42);
C::local_iterator i = c.begin(b);
assert(i != c.end(b));
++i;
assert(i == c.end(b));
TEST_LIBCPP_ASSERT_FAILURE(++i, "Attempted to increment a non-incrementable unordered container local_iterator");
return 0;
}

libcxx/test/libcxx/containers/unord/unord.map/db_swap_1.pass.cpp

  • This file was moved to libcxx/test/libcxx/containers/unord/unord.map/debug.swap.pass.cpp.

libcxx/test/libcxx/containers/unord/unord.map/debug.insert.hint_const_lvalue.pass.cpp

  • This file was moved from libcxx/test/libcxx/containers/unord/unord.map/db_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 // UNSUPPORTED: libcxx-no-debug-mode, c++03, windows
// 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 "test_macros.h" #include "test_macros.h"
#include "debug_macros.h"
int main(int, char**) { int main(int, char**) {
typedef std::unordered_map<double, int> C; typedef std::unordered_map<double, int> C;
typedef C::value_type P; typedef C::value_type P;
C c; C c;
C c2; C c2;
C::const_iterator e = c2.end(); C::const_iterator e = c2.end();
P v(3.5, 3); P v(3.5, 3);
Show All 12 Lines

libcxx/test/libcxx/containers/unord/unord.map/debug.insert.hint_rvalue.pass.cpp

  • This file was moved from libcxx/test/libcxx/containers/unord/unord.map/db_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
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// UNSUPPORTED: c++03
// <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 // UNSUPPORTED: libcxx-no-debug-mode, c++03, windows
// 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 "test_macros.h" #include "test_macros.h"
#include "debug_macros.h"
int main(int, char**) { int main(int, char**) {
typedef std::unordered_map<double, int> C; typedef std::unordered_map<double, int> C;
typedef C::value_type P; typedef C::value_type P;
C c; C c;
C c2; C c2;
C::const_iterator e = c2.end(); C::const_iterator e = c2.end();
TEST_LIBCPP_ASSERT_FAILURE( TEST_LIBCPP_ASSERT_FAILURE(
c.insert(e, P(3.5, 3)), c.insert(e, P(3.5, 3)),
"unordered_map::insert(const_iterator, const value_type&) called with an iterator not referring to this unordered_map"); "unordered_map::insert(const_iterator, const value_type&) called with an iterator not referring to this unordered_map");
return 0; return 0;
} }

libcxx/test/libcxx/containers/unord/unord.map/debug.iterator.dereference.pass.cpp

  • This file was added.
//===----------------------------------------------------------------------===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
// <unordered_map>
// Dereference non-dereferenceable iterator.
// UNSUPPORTED: libcxx-no-debug-mode, c++03, windows
// ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DEBUG=1
#include <unordered_map>
#include <string>
#include "check_assertion.h"
#include "min_allocator.h"
int main(int, char**) {
{
typedef std::unordered_map<int, std::string> C;
C c;
c.insert(std::make_pair(1, "one"));
C::iterator i = c.end();
TEST_LIBCPP_ASSERT_FAILURE(*i, "Attempted to dereference a non-dereferenceable unordered container iterator");
}
{
typedef std::unordered_map<int, std::string, std::hash<int>, std::equal_to<int>,
min_allocator<std::pair<const int, std::string>>> C;
C c;
c.insert(std::make_pair(1, "one"));
C::iterator i = c.end();
TEST_LIBCPP_ASSERT_FAILURE(*i, "Attempted to dereference a non-dereferenceable unordered container iterator");
}
return 0;
}

libcxx/test/libcxx/containers/unord/unord.map/debug.iterator.increment.pass.cpp

  • This file was added.
//===----------------------------------------------------------------------===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
// <unordered_map>
// Increment iterator past end.
// UNSUPPORTED: libcxx-no-debug-mode, c++03, windows
// ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DEBUG=1
#include <unordered_map>
#include <cassert>
#include <string>
#include "check_assertion.h"
#include "min_allocator.h"
int main(int, char**) {
{
typedef std::unordered_map<int, std::string> C;
C c;
c.insert(std::make_pair(1, "one"));
C::iterator i = c.begin();
++i;
assert(i == c.end());
TEST_LIBCPP_ASSERT_FAILURE(++i, "Attempted to increment a non-incrementable unordered container iterator");
}
{
typedef std::unordered_map<int, std::string, std::hash<int>, std::equal_to<int>,
min_allocator<std::pair<const int, std::string>>> C;
C c;
c.insert(std::make_pair(1, "one"));
C::iterator i = c.begin();
++i;
assert(i == c.end());
TEST_LIBCPP_ASSERT_FAILURE(++i, "Attempted to increment a non-incrementable unordered container iterator");
}
return 0;
}

libcxx/test/libcxx/containers/unord/unord.map/debug.local_iterator.dereference.pass.cpp

  • This file was added.
//===----------------------------------------------------------------------===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
// <unordered_map>
// Dereference non-dereferenceable iterator.
// UNSUPPORTED: libcxx-no-debug-mode, c++03, windows
// ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DEBUG=1
#include <unordered_map>
#include <string>
#include "check_assertion.h"
#include "min_allocator.h"
int main(int, char**) {
{
typedef std::unordered_map<int, std::string> C;
C c(1);
C::local_iterator i = c.end(0);
TEST_LIBCPP_ASSERT_FAILURE(*i, "Attempted to dereference a non-dereferenceable unordered container local_iterator");
}
{
typedef std::unordered_map<int, std::string, std::hash<int>, std::equal_to<int>,
min_allocator<std::pair<const int, std::string>>> C;
C c(1);
C::local_iterator i = c.end(0);
TEST_LIBCPP_ASSERT_FAILURE(*i, "Attempted to dereference a non-dereferenceable unordered container local_iterator");
}
return 0;
}

libcxx/test/libcxx/containers/unord/unord.map/debug.local_iterator.increment.pass.cpp

  • This file was added.
//===----------------------------------------------------------------------===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
// <unordered_map>
// Increment local_iterator past end.
// UNSUPPORTED: libcxx-no-debug-mode, c++03, windows
// ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DEBUG=1
#include <unordered_map>
#include <string>
#include <cassert>
#include "check_assertion.h"
#include "min_allocator.h"
int main(int, char**) {
{
typedef std::unordered_map<int, std::string> C;
C c;
c.insert(std::make_pair(42, std::string()));
C::size_type b = c.bucket(42);
C::local_iterator i = c.begin(b);
assert(i != c.end(b));
++i;
assert(i == c.end(b));
TEST_LIBCPP_ASSERT_FAILURE(++i, "Attempted to increment a non-incrementable unordered container local_iterator");
}
{
typedef std::unordered_map<int, std::string, std::hash<int>, std::equal_to<int>,
min_allocator<std::pair<const int, std::string>>> C;
C c({{42, std::string()}});
C::size_type b = c.bucket(42);
C::local_iterator i = c.begin(b);
assert(i != c.end(b));
++i;
assert(i == c.end(b));
TEST_LIBCPP_ASSERT_FAILURE(++i, "Attempted to increment a non-incrementable unordered container local_iterator");
}
return 0;
}

libcxx/test/libcxx/containers/unord/unord.map/debug.swap.pass.cpp

  • This file was moved from libcxx/test/libcxx/containers/unord/unord.map/db_swap_1.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 // UNSUPPORTED: libcxx-no-debug-mode, c++03, windows
// ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DEBUG=1 // ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DEBUG=1
#include <unordered_map> #include <unordered_map>
#include "test_macros.h" #include "check_assertion.h"
#include "debug_macros.h"
int main(int, char**) { int main(int, char**) {
typedef std::pair<int, int> P; typedef std::pair<int, int> P;
P a1[] = {P(1, 1), P(3, 3), P(7, 7), P(9, 9), P(10, 10)}; P a1[] = {P(1, 1), P(3, 3), P(7, 7), P(9, 9), P(10, 10)};
P a2[] = {P(0, 0), P(2, 2), P(4, 4), P(5, 5), P(6, 6), P(8, 8), P(11, 11)}; P a2[] = {P(0, 0), P(2, 2), P(4, 4), P(5, 5), P(6, 6), P(8, 8), P(11, 11)};
std::unordered_map<int, int> c1(a1, a1+sizeof(a1)/sizeof(a1[0])); std::unordered_map<int, int> c1(a1, a1+sizeof(a1)/sizeof(a1[0]));
std::unordered_map<int, int> c2(a2, a2+sizeof(a2)/sizeof(a2[0])); std::unordered_map<int, int> c2(a2, a2+sizeof(a2)/sizeof(a2[0]));
std::unordered_map<int, int>::iterator i1 = c1.begin(); std::unordered_map<int, int>::iterator i1 = c1.begin();
std::unordered_map<int, int>::iterator i2 = c2.begin(); std::unordered_map<int, int>::iterator i2 = c2.begin();
swap(c1, c2); swap(c1, c2);
c1.erase(i2); c1.erase(i2);
TEST_LIBCPP_ASSERT_FAILURE( TEST_LIBCPP_ASSERT_FAILURE(
c1.erase(i1), "unordered container erase(iterator) called with an iterator not referring to this container"); c1.erase(i1), "unordered container erase(iterator) called with an iterator not referring to this container");
return 0; return 0;
} }

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

  • This file was moved to libcxx/test/libcxx/containers/unord/unord.map/assert.max_load_factor.pass.cpp.

libcxx/test/libcxx/containers/unord/unord.map/unord.map.modifiers/debug.erase.iter.pass.cpp

  • This file was added.
//===----------------------------------------------------------------------===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
// <unordered_map>
// Call erase(const_iterator position) with invalid iterators
// UNSUPPORTED: libcxx-no-debug-mode, c++03, windows
// ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DEBUG=1
#include <unordered_map>
#include "check_assertion.h"
int main(int, char**) {
// With end()
{
typedef std::pair<int, int> P;
P a1[] = {P(1, 1), P(2, 2), P(3, 3)};
std::unordered_map<int, int> l1(a1, a1+3);
std::unordered_map<int, int>::const_iterator i = l1.end();
TEST_LIBCPP_ASSERT_FAILURE(l1.erase(i),
"unordered container erase(iterator) called with a non-dereferenceable iterator");
}
// With iterator from another container
{
typedef std::pair<int, int> P;
P a1[] = {P(1, 1), P(2, 2), P(3, 3)};
std::unordered_map<int, int> l1(a1, a1+3);
std::unordered_map<int, int> l2(a1, a1+3);
std::unordered_map<int, int>::const_iterator i = l2.begin();
TEST_LIBCPP_ASSERT_FAILURE(
l1.erase(i), "unordered container erase(iterator) called with an iterator not referring to this container");
}
return 0;
}

libcxx/test/libcxx/containers/unord/unord.map/unord.map.modifiers/debug.erase.iter_iter.pass.cpp

  • This file was added.
//===----------------------------------------------------------------------===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
// <unordered_map>
// Call erase(const_iterator first, const_iterator last); with invalid iterators
// UNSUPPORTED: libcxx-no-debug-mode, c++03, windows
// ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DEBUG=1
#include <unordered_map>
#include "check_assertion.h"
int main(int, char**) {
// First iterator from a different container
{
typedef std::pair<int, int> P;
P a1[] = {P(1, 1), P(2, 2), P(3, 3)};
std::unordered_map<int, int> l1(a1, a1+3);
std::unordered_map<int, int> l2(a1, a1+3);
TEST_LIBCPP_ASSERT_FAILURE(
l1.erase(l2.cbegin(), std::next(l1.cbegin())),
"unordered container::erase(iterator, iterator) called with an iterator not referring to this container");
}
// Second iterator from a different container
{
typedef std::pair<int, int> P;
P a1[] = {P(1, 1), P(2, 2), P(3, 3)};
std::unordered_map<int, int> l1(a1, a1+3);
std::unordered_map<int, int> l2(a1, a1+3);
TEST_LIBCPP_ASSERT_FAILURE(
l1.erase(l1.cbegin(), std::next(l2.cbegin())),
"unordered container::erase(iterator, iterator) called with an iterator not referring to this container");
}
// Both iterators from a different container
{
typedef std::pair<int, int> P;
P a1[] = {P(1, 1), P(2, 2), P(3, 3)};
std::unordered_map<int, int> l1(a1, a1+3);
std::unordered_map<int, int> l2(a1, a1+3);
TEST_LIBCPP_ASSERT_FAILURE(
l1.erase(l2.cbegin(), std::next(l2.cbegin())),
"unordered container::erase(iterator, iterator) called with an iterator not referring to this container");
}
// With iterators that don't form a valid range
{
typedef std::pair<int, int> P;
P a1[] = {P(1, 1), P(2, 2), P(3, 3)};
std::unordered_map<int, int> l1(a1, a1+3);
TEST_LIBCPP_ASSERT_FAILURE(l1.erase(std::next(l1.cbegin()), l1.cbegin()),
"Attempted to increment a non-incrementable unordered container const_iterator");
}
return 0;
}

libcxx/test/libcxx/containers/unord/unord.map/unord.map.modifiers/erase_iter_db1.pass.cpp

  • This file was deleted.
//===----------------------------------------------------------------------===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
// <unordered_map>
// Call erase(const_iterator position) with end()
// UNSUPPORTED: libcxx-no-debug-mode
// ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DEBUG=1
#include <unordered_map>
#include "test_macros.h"
#include "debug_macros.h"
int main(int, char**) {
typedef std::pair<int, int> P;
P a1[] = {P(1, 1), P(2, 2), P(3, 3)};
std::unordered_map<int, int> l1(a1, a1+3);
std::unordered_map<int, int>::const_iterator i = l1.end();
TEST_LIBCPP_ASSERT_FAILURE(l1.erase(i),
"unordered container erase(iterator) called with a non-dereferenceable iterator");
return 0;
}

libcxx/test/libcxx/containers/unord/unord.map/unord.map.modifiers/erase_iter_db2.pass.cpp

  • This file was deleted.
//===----------------------------------------------------------------------===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
// <unordered_map>
// Call erase(const_iterator position) with iterator from another container
// UNSUPPORTED: libcxx-no-debug-mode
// ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DEBUG=1
#include <unordered_map>
#include "test_macros.h"
#include "debug_macros.h"
int main(int, char**) {
typedef std::pair<int, int> P;
P a1[] = {P(1, 1), P(2, 2), P(3, 3)};
std::unordered_map<int, int> l1(a1, a1+3);
std::unordered_map<int, int> l2(a1, a1+3);
std::unordered_map<int, int>::const_iterator i = l2.begin();
TEST_LIBCPP_ASSERT_FAILURE(
l1.erase(i), "unordered container erase(iterator) called with an iterator not referring to this container");
return 0;
}

libcxx/test/libcxx/containers/unord/unord.map/unord.map.modifiers/erase_iter_iter_db1.pass.cpp

  • This file was deleted.
//===----------------------------------------------------------------------===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
// <unordered_map>
// Call erase(const_iterator first, const_iterator last); with first iterator from another container
// UNSUPPORTED: libcxx-no-debug-mode
// ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DEBUG=1
#include <unordered_map>
#include "test_macros.h"
#include "debug_macros.h"
int main(int, char**) {
typedef std::pair<int, int> P;
P a1[] = {P(1, 1), P(2, 2), P(3, 3)};
std::unordered_map<int, int> l1(a1, a1+3);
std::unordered_map<int, int> l2(a1, a1+3);
TEST_LIBCPP_ASSERT_FAILURE(
l1.erase(l2.cbegin(), std::next(l1.cbegin())),
"unordered container::erase(iterator, iterator) called with an iterator not referring to this container");
return 0;
}

libcxx/test/libcxx/containers/unord/unord.map/unord.map.modifiers/erase_iter_iter_db2.pass.cpp

  • This file was deleted.
//===----------------------------------------------------------------------===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
// <unordered_map>
// Call erase(const_iterator first, const_iterator last); with second iterator from another container
// UNSUPPORTED: libcxx-no-debug-mode
// ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DEBUG=1
#include <unordered_map>
#include "test_macros.h"
#include "debug_macros.h"
int main(int, char**) {
typedef std::pair<int, int> P;
P a1[] = {P(1, 1), P(2, 2), P(3, 3)};
std::unordered_map<int, int> l1(a1, a1+3);
std::unordered_map<int, int> l2(a1, a1+3);
TEST_LIBCPP_ASSERT_FAILURE(
l1.erase(l1.cbegin(), std::next(l2.cbegin())),
"unordered container::erase(iterator, iterator) called with an iterator not referring to this container");
return 0;
}

libcxx/test/libcxx/containers/unord/unord.map/unord.map.modifiers/erase_iter_iter_db3.pass.cpp

  • This file was deleted.
//===----------------------------------------------------------------------===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
// <unordered_map>
// Call erase(const_iterator first, const_iterator last); with both iterators from another container
// UNSUPPORTED: libcxx-no-debug-mode
// ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DEBUG=1
#include <unordered_map>
#include "test_macros.h"
#include "debug_macros.h"
int main(int, char**) {
typedef std::pair<int, int> P;
P a1[] = {P(1, 1), P(2, 2), P(3, 3)};
std::unordered_map<int, int> l1(a1, a1+3);
std::unordered_map<int, int> l2(a1, a1+3);
TEST_LIBCPP_ASSERT_FAILURE(
l1.erase(l2.cbegin(), std::next(l2.cbegin())),
"unordered container::erase(iterator, iterator) called with an iterator not referring to this container");
return 0;
}

libcxx/test/libcxx/containers/unord/unord.map/unord.map.modifiers/erase_iter_iter_db4.pass.cpp

  • This file was deleted.
//===----------------------------------------------------------------------===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
// <unordered_map>
// Call erase(const_iterator first, const_iterator last); with a bad range
// UNSUPPORTED: libcxx-no-debug-mode
// ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DEBUG=1
#include <unordered_map>
#include "test_macros.h"
#include "debug_macros.h"
int main(int, char**) {
typedef std::pair<int, int> P;
P a1[] = {P(1, 1), P(2, 2), P(3, 3)};
std::unordered_map<int, int> l1(a1, a1+3);
TEST_LIBCPP_ASSERT_FAILURE(l1.erase(std::next(l1.cbegin()), l1.cbegin()),
"Attempted to increment a non-incrementable unordered container const_iterator");
return 0;
}

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

  • This file was moved from libcxx/test/libcxx/containers/unord/unord.multimap/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: libcxx-no-debug-mode // UNSUPPORTED: c++03, windows, libcxx-no-debug-mode
// ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DEBUG=0
// ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DEBUG=1
#include <unordered_map> #include <unordered_map>
#include <string> #include <string>
#include "test_macros.h" #include "check_assertion.h"
#include "debug_macros.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

  • This file was moved from libcxx/test/libcxx/containers/unord/unord.multimap/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: libcxx-no-debug-mode // UNSUPPORTED: c++03, windows, libcxx-no-debug-mode
// ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DEBUG=0
// ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DEBUG=1
#include <unordered_map> #include <unordered_map>
#include <string> #include <string>
#include "test_macros.h" #include "check_assertion.h"
#include "debug_macros.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

  • This file was moved from libcxx/test/libcxx/containers/unord/unord.multimap/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: libcxx-no-debug-mode // UNSUPPORTED: c++03, windows, libcxx-no-debug-mode
// ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DEBUG=0
// ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DEBUG=1
#include <unordered_map> #include <unordered_map>
#include <string> #include <string>
#include "test_macros.h" #include "check_assertion.h"
#include "debug_macros.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/bucket.pass.cpp

  • This file was moved to libcxx/test/libcxx/containers/unord/unord.multimap/assert.bucket.pass.cpp.

libcxx/test/libcxx/containers/unord/unord.multimap/bucket_size.pass.cpp

  • This file was moved to libcxx/test/libcxx/containers/unord/unord.multimap/assert.bucket_size.pass.cpp.

libcxx/test/libcxx/containers/unord/unord.multimap/db_insert_hint_const_lvalue.pass.cpp

  • This file was moved to libcxx/test/libcxx/containers/unord/unord.multimap/debug.insert.hint_const_lvalue.pass.cpp.

libcxx/test/libcxx/containers/unord/unord.multimap/db_insert_hint_rvalue.pass.cpp

  • This file was moved to libcxx/test/libcxx/containers/unord/unord.multimap/debug.insert.hint_rvalue.pass.cpp.

libcxx/test/libcxx/containers/unord/unord.multimap/db_iterators_10.pass.cpp

  • This file was deleted.
//===----------------------------------------------------------------------===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
// <unordered_map>
// Dereference non-dereferenceable iterator.
// UNSUPPORTED: libcxx-no-debug-mode
// UNSUPPORTED: c++03
// ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DEBUG=1
#include <string>
#include <unordered_map>
#include "test_macros.h"
#include "debug_macros.h"
#include "min_allocator.h"
int main(int, char**) {
typedef std::unordered_multimap<int, std::string, std::hash<int>, std::equal_to<int>,
min_allocator<std::pair<const int, std::string>>> C;
C c;
c.insert(std::make_pair(1, "one"));
C::iterator i = c.end();
TEST_LIBCPP_ASSERT_FAILURE(*i, "Attempted to dereference a non-dereferenceable unordered container iterator");
return 0;
}

libcxx/test/libcxx/containers/unord/unord.multimap/db_iterators_7.pass.cpp

  • This file was deleted.
//===----------------------------------------------------------------------===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
// <unordered_map>
// Increment iterator past end.
// UNSUPPORTED: libcxx-no-debug-mode
// ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DEBUG=1
#include <unordered_map>
#include <cassert>
#include <string>
#include "test_macros.h"
#include "debug_macros.h"
int main(int, char**) {
typedef std::unordered_multimap<int, std::string> C;
C c;
c.insert(std::make_pair(1, "one"));
C::iterator i = c.begin();
++i;
assert(i == c.end());
TEST_LIBCPP_ASSERT_FAILURE(++i, "Attempted to increment a non-incrementable unordered container iterator");
return 0;
}

libcxx/test/libcxx/containers/unord/unord.multimap/db_iterators_8.pass.cpp

  • This file was deleted.
//===----------------------------------------------------------------------===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
// <unordered_map>
// Dereference non-dereferenceable iterator.
// UNSUPPORTED: libcxx-no-debug-mode
// ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DEBUG=1
#include <string>
#include <unordered_map>
#include "test_macros.h"
#include "debug_macros.h"
int main(int, char**) {
typedef std::unordered_multimap<int, std::string> C;
C c;
c.insert(std::make_pair(1, "one"));
C::iterator i = c.end();
TEST_LIBCPP_ASSERT_FAILURE(*i, "Attempted to dereference a non-dereferenceable unordered container iterator");
return 0;
}

libcxx/test/libcxx/containers/unord/unord.multimap/db_iterators_9.pass.cpp

  • This file was moved to libcxx/test/libcxx/strings/basic.string/string.iterators/debug.iterator.increment.pass.cpp.

libcxx/test/libcxx/containers/unord/unord.multimap/db_local_iterators_10.pass.cpp

  • This file was deleted.
//===----------------------------------------------------------------------===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
// <unordered_map>
// Dereference non-dereferenceable iterator.
// UNSUPPORTED: libcxx-no-debug-mode
// UNSUPPORTED: c++03
// ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DEBUG=1
#include <unordered_map>
#include <string>
#include "test_macros.h"
#include "debug_macros.h"
#include "min_allocator.h"
int main(int, char**) {
typedef std::unordered_multimap<int, std::string, std::hash<int>, std::equal_to<int>,
min_allocator<std::pair<const int, std::string>>> C;
C c(1);
C::local_iterator i = c.end(0);
TEST_LIBCPP_ASSERT_FAILURE(*i, "Attempted to dereference a non-dereferenceable unordered container local_iterator");
return 0;
}

libcxx/test/libcxx/containers/unord/unord.multimap/db_local_iterators_7.pass.cpp

  • This file was deleted.
//===----------------------------------------------------------------------===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
// <unordered_map>
// Increment local_iterator past end.
// UNSUPPORTED: libcxx-no-debug-mode
// ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DEBUG=1
#include <unordered_map>
#include <cassert>
#include <string>
#include "test_macros.h"
#include "debug_macros.h"
int main(int, char**) {
typedef std::unordered_multimap<int, std::string> C;
C c;
c.insert(std::make_pair(42, std::string()));
C::size_type b = c.bucket(42);
C::local_iterator i = c.begin(b);
assert(i != c.end(b));
++i;
assert(i == c.end(b));
TEST_LIBCPP_ASSERT_FAILURE(++i, "Attempted to increment a non-incrementable unordered container local_iterator");
return 0;
}

libcxx/test/libcxx/containers/unord/unord.multimap/db_local_iterators_8.pass.cpp

  • This file was deleted.
//===----------------------------------------------------------------------===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
// <unordered_map>
// Dereference non-dereferenceable iterator.
// UNSUPPORTED: libcxx-no-debug-mode
// ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DEBUG=1
#include <unordered_map>
#include <string>
#include "test_macros.h"
#include "debug_macros.h"
int main(int, char**) {
typedef std::unordered_multimap<int, std::string> C;
C c(1);
C::local_iterator i = c.end(0);
TEST_LIBCPP_ASSERT_FAILURE(*i, "Attempted to dereference a non-dereferenceable unordered container local_iterator");
return 0;
}

libcxx/test/libcxx/containers/unord/unord.multimap/db_local_iterators_9.pass.cpp

  • This file was deleted.
//===----------------------------------------------------------------------===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
// <unordered_map>
// Increment local_iterator past end.
// UNSUPPORTED: libcxx-no-debug-mode
// UNSUPPORTED: c++03
// ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DEBUG=1
#include <unordered_map>
#include <cassert>
#include <string>
#include "test_macros.h"
#include "debug_macros.h"
#include "min_allocator.h"
int main(int, char**) {
typedef std::unordered_multimap<int, std::string, std::hash<int>, std::equal_to<int>,
min_allocator<std::pair<const int, std::string>>> C;
C c({{1, std::string()}});
c.insert(std::make_pair(42, std::string()));
C::size_type b = c.bucket(42);
C::local_iterator i = c.begin(b);
assert(i != c.end(b));
++i;
assert(i == c.end(b));
TEST_LIBCPP_ASSERT_FAILURE(++i, "Attempted to increment a non-incrementable unordered container local_iterator");
return 0;
}

libcxx/test/libcxx/containers/unord/unord.multimap/db_swap_1.pass.cpp

  • This file was moved to libcxx/test/libcxx/containers/unord/unord.multimap/debug.swap.pass.cpp.

libcxx/test/libcxx/containers/unord/unord.multimap/debug.insert.hint_const_lvalue.pass.cpp

  • This file was moved from libcxx/test/libcxx/containers/unord/unord.multimap/db_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 // UNSUPPORTED: libcxx-no-debug-mode, c++03, windows
// ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DEBUG=1 // ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DEBUG=1
#include <unordered_map> #include <unordered_map>
#include "test_macros.h" #include "check_assertion.h"
#include "debug_macros.h"
int main(int, char**) { int main(int, char**) {
typedef std::unordered_multimap<double, int> C; typedef std::unordered_multimap<double, int> C;
typedef C::value_type P; typedef C::value_type P;
C c; C c;
C c2; C c2;
C::const_iterator e = c2.end(); C::const_iterator e = c2.end();
P v(3.5, 3); P v(3.5, 3);
TEST_LIBCPP_ASSERT_FAILURE( TEST_LIBCPP_ASSERT_FAILURE(
c.insert(e, v), c.insert(e, v),
"unordered container::emplace_hint(const_iterator, args...) called with an iterator not referring to this unordered container"); "unordered container::emplace_hint(const_iterator, args...) called with an iterator not referring to this unordered container");
return 0; return 0;
} }

libcxx/test/libcxx/containers/unord/unord.multimap/debug.insert.hint_rvalue.pass.cpp

  • This file was moved from libcxx/test/libcxx/containers/unord/unord.multimap/db_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
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// UNSUPPORTED: c++03
// <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 // UNSUPPORTED: libcxx-no-debug-mode, c++03, windows
// ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DEBUG=1 // ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DEBUG=1
#include <unordered_map> #include <unordered_map>
#include "test_macros.h" #include "check_assertion.h"
#include "debug_macros.h"
int main(int, char**) { int main(int, char**) {
typedef std::unordered_multimap<double, int> C; typedef std::unordered_multimap<double, int> C;
typedef C::value_type P; typedef C::value_type P;
C c; C c;
C c2; C c2;
C::const_iterator e = c2.end(); C::const_iterator e = c2.end();
TEST_LIBCPP_ASSERT_FAILURE( TEST_LIBCPP_ASSERT_FAILURE(
c.insert(e, P(3.5, 3)), c.insert(e, P(3.5, 3)),
"unordered container::emplace_hint(const_iterator, args...) called with an iterator not referring to this unordered container"); "unordered container::emplace_hint(const_iterator, args...) called with an iterator not referring to this unordered container");
return 0; return 0;
} }

libcxx/test/libcxx/containers/unord/unord.multimap/debug.iterator.dereference.pass.cpp

  • This file was added.
//===----------------------------------------------------------------------===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
// <unordered_map>
// Dereference non-dereferenceable iterator.
// UNSUPPORTED: libcxx-no-debug-mode, c++03, windows
// ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DEBUG=1
#include <string>
#include <unordered_map>
#include "check_assertion.h"
#include "min_allocator.h"
int main(int, char**) {
{
typedef std::unordered_multimap<int, std::string> C;
C c;
c.insert(std::make_pair(1, "one"));
C::iterator i = c.end();
TEST_LIBCPP_ASSERT_FAILURE(*i, "Attempted to dereference a non-dereferenceable unordered container iterator");
}
{
typedef std::unordered_multimap<int, std::string, std::hash<int>, std::equal_to<int>,
min_allocator<std::pair<const int, std::string>>> C;
C c;
c.insert(std::make_pair(1, "one"));
C::iterator i = c.end();
TEST_LIBCPP_ASSERT_FAILURE(*i, "Attempted to dereference a non-dereferenceable unordered container iterator");
}
return 0;
}

libcxx/test/libcxx/containers/unord/unord.multimap/debug.iterator.increment.pass.cpp

  • This file was added.
//===----------------------------------------------------------------------===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
// <unordered_map>
// Increment iterator past end.
// UNSUPPORTED: libcxx-no-debug-mode, c++03, windows
// ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DEBUG=1
#include <unordered_map>
#include <cassert>
#include <string>
#include "check_assertion.h"
#include "min_allocator.h"
int main(int, char**) {
{
typedef std::unordered_multimap<int, std::string> C;
C c;
c.insert(std::make_pair(1, "one"));
C::iterator i = c.begin();
++i;
assert(i == c.end());
TEST_LIBCPP_ASSERT_FAILURE(++i, "Attempted to increment a non-incrementable unordered container iterator");
}
{
typedef std::unordered_multimap<int, std::string, std::hash<int>, std::equal_to<int>,
min_allocator<std::pair<const int, std::string>>> C;
C c;
c.insert(std::make_pair(1, "one"));
C::iterator i = c.begin();
++i;
assert(i == c.end());
TEST_LIBCPP_ASSERT_FAILURE(++i, "Attempted to increment a non-incrementable unordered container iterator");
}
return 0;
}

libcxx/test/libcxx/containers/unord/unord.multimap/debug.local_iterator.dereference.pass.cpp

  • This file was added.
//===----------------------------------------------------------------------===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
// <unordered_map>
// Dereference non-dereferenceable iterator.
// UNSUPPORTED: libcxx-no-debug-mode, c++03, windows
// ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DEBUG=1
#include <unordered_map>
#include <string>
#include "check_assertion.h"
#include "min_allocator.h"
int main(int, char**) {
{
typedef std::unordered_multimap<int, std::string> C;
C c(1);
C::local_iterator i = c.end(0);
TEST_LIBCPP_ASSERT_FAILURE(*i, "Attempted to dereference a non-dereferenceable unordered container local_iterator");
}
{
typedef std::unordered_multimap<int, std::string, std::hash<int>, std::equal_to<int>,
min_allocator<std::pair<const int, std::string>>> C;
C c(1);
C::local_iterator i = c.end(0);
TEST_LIBCPP_ASSERT_FAILURE(*i, "Attempted to dereference a non-dereferenceable unordered container local_iterator");
}
return 0;
}

libcxx/test/libcxx/containers/unord/unord.multimap/debug.local_iterator.increment.pass.cpp

  • This file was added.
//===----------------------------------------------------------------------===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
// <unordered_map>
// Increment local_iterator past end.
// UNSUPPORTED: libcxx-no-debug-mode, c++03, windows
// ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DEBUG=1
#include <unordered_map>
#include <cassert>
#include <string>
#include "check_assertion.h"
#include "min_allocator.h"
int main(int, char**) {
{
typedef std::unordered_multimap<int, std::string> C;
C c;
c.insert(std::make_pair(42, std::string()));
C::size_type b = c.bucket(42);
C::local_iterator i = c.begin(b);
assert(i != c.end(b));
++i;
assert(i == c.end(b));
TEST_LIBCPP_ASSERT_FAILURE(++i, "Attempted to increment a non-incrementable unordered container local_iterator");
}
{
typedef std::unordered_multimap<int, std::string, std::hash<int>, std::equal_to<int>,
min_allocator<std::pair<const int, std::string>>> C;
C c({{1, std::string()}});
c.insert(std::make_pair(42, std::string()));
C::size_type b = c.bucket(42);
C::local_iterator i = c.begin(b);
assert(i != c.end(b));
++i;
assert(i == c.end(b));
TEST_LIBCPP_ASSERT_FAILURE(++i, "Attempted to increment a non-incrementable unordered container local_iterator");
}
return 0;
}

libcxx/test/libcxx/containers/unord/unord.multimap/debug.swap.pass.cpp

  • This file was moved from libcxx/test/libcxx/containers/unord/unord.multimap/db_swap_1.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 // UNSUPPORTED: libcxx-no-debug-mode, c++03, windows
// ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DEBUG=1 // ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DEBUG=1
#include <unordered_map> #include <unordered_map>
#include "test_macros.h" #include "check_assertion.h"
#include "debug_macros.h"
int main(int, char**) int main(int, char**) {
{
typedef std::pair<int, int> P; typedef std::pair<int, int> P;
P a1[] = {P(1, 1), P(3, 3), P(7, 7), P(9, 9), P(10, 10)}; P a1[] = {P(1, 1), P(3, 3), P(7, 7), P(9, 9), P(10, 10)};
P a2[] = {P(0, 0), P(2, 2), P(4, 4), P(5, 5), P(6, 6), P(8, 8), P(11, 11)}; P a2[] = {P(0, 0), P(2, 2), P(4, 4), P(5, 5), P(6, 6), P(8, 8), P(11, 11)};
std::unordered_multimap<int, int> c1(a1, a1+sizeof(a1)/sizeof(a1[0])); std::unordered_multimap<int, int> c1(a1, a1+sizeof(a1)/sizeof(a1[0]));
std::unordered_multimap<int, int> c2(a2, a2+sizeof(a2)/sizeof(a2[0])); std::unordered_multimap<int, int> c2(a2, a2+sizeof(a2)/sizeof(a2[0]));
std::unordered_multimap<int, int>::iterator i1 = c1.begin(); std::unordered_multimap<int, int>::iterator i1 = c1.begin();
std::unordered_multimap<int, int>::iterator i2 = c2.begin(); std::unordered_multimap<int, int>::iterator i2 = c2.begin();
swap(c1, c2); swap(c1, c2);
c1.erase(i2); c1.erase(i2);
TEST_LIBCPP_ASSERT_FAILURE( TEST_LIBCPP_ASSERT_FAILURE(
c1.erase(i1), "unordered container erase(iterator) called with an iterator not referring to this container"); c1.erase(i1), "unordered container erase(iterator) called with an iterator not referring to this container");
return 0; return 0;
} }

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

  • This file was moved to libcxx/test/libcxx/containers/unord/unord.multimap/assert.max_load_factor.pass.cpp.

libcxx/test/libcxx/containers/unord/unord.multimap/unord.multimap.modifiers/debug.erase.iter.pass.cpp

  • This file was added.
//===----------------------------------------------------------------------===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
// <unordered_map>
// Call erase(const_iterator position) with invalid iterators
// UNSUPPORTED: libcxx-no-debug-mode, c++03, windows
// ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DEBUG=1
#include <unordered_map>
#include "check_assertion.h"
int main(int, char**) {
// With end()
{
typedef std::pair<int, int> P;
P a1[] = {P(1, 1), P(2, 2), P(3, 3)};
std::unordered_multimap<int, int> l1(a1, a1+3);
std::unordered_multimap<int, int>::const_iterator i = l1.end();
TEST_LIBCPP_ASSERT_FAILURE(l1.erase(i),
"unordered container erase(iterator) called with a non-dereferenceable iterator");
}
// With iterator from another container
{
typedef std::pair<int, int> P;
P a1[] = {P(1, 1), P(2, 2), P(3, 3)};
std::unordered_multimap<int, int> l1(a1, a1+3);
std::unordered_multimap<int, int> l2(a1, a1+3);
std::unordered_multimap<int, int>::const_iterator i = l2.begin();
TEST_LIBCPP_ASSERT_FAILURE(
l1.erase(i), "unordered container erase(iterator) called with an iterator not referring to this container");
}
return 0;
}

libcxx/test/libcxx/containers/unord/unord.multimap/unord.multimap.modifiers/debug.erase.iter_iter.pass.cpp

  • This file was added.
//===----------------------------------------------------------------------===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
// <unordered_map>
// Call erase(const_iterator first, const_iterator last); with invalid iterators
// UNSUPPORTED: libcxx-no-debug-mode, c++03, windows
// ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DEBUG=1
#include <unordered_map>
#include "check_assertion.h"
int main(int, char**) {
// With first iterator from another container
{
typedef std::pair<int, int> P;
P a1[] = {P(1, 1), P(2, 2), P(3, 3)};
std::unordered_multimap<int, int> l1(a1, a1+3);
std::unordered_multimap<int, int> l2(a1, a1+3);
TEST_LIBCPP_ASSERT_FAILURE(
l1.erase(l2.cbegin(), std::next(l1.cbegin())),
"unordered container::erase(iterator, iterator) called with an iterator not referring to this container");
}
// With second iterator from another container
{
typedef std::pair<int, int> P;
P a1[] = {P(1, 1), P(2, 2), P(3, 3)};
std::unordered_multimap<int, int> l1(a1, a1+3);
std::unordered_multimap<int, int> l2(a1, a1+3);
TEST_LIBCPP_ASSERT_FAILURE(
l1.erase(l1.cbegin(), std::next(l2.cbegin())),
"unordered container::erase(iterator, iterator) called with an iterator not referring to this container");
}
// With both iterators from another container
{
typedef std::pair<int, int> P;
P a1[] = {P(1, 1), P(2, 2), P(3, 3)};
std::unordered_multimap<int, int> l1(a1, a1+3);
std::unordered_multimap<int, int> l2(a1, a1+3);
TEST_LIBCPP_ASSERT_FAILURE(
l1.erase(l2.cbegin(), std::next(l2.cbegin())),
"unordered container::erase(iterator, iterator) called with an iterator not referring to this container");
}
// With an invalid range
{
typedef std::pair<int, int> P;
P a1[] = {P(1, 1), P(2, 2), P(3, 3)};
std::unordered_multimap<int, int> l1(a1, a1+3);
TEST_LIBCPP_ASSERT_FAILURE(l1.erase(std::next(l1.cbegin()), l1.cbegin()),
"Attempted to increment a non-incrementable unordered container const_iterator");
}
return 0;
}

libcxx/test/libcxx/containers/unord/unord.multimap/unord.multimap.modifiers/erase_iter_db1.pass.cpp

  • This file was deleted.
//===----------------------------------------------------------------------===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
// <unordered_map>
// Call erase(const_iterator position) with end()
// UNSUPPORTED: libcxx-no-debug-mode
// ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DEBUG=1
#include <unordered_map>
#include "test_macros.h"
#include "debug_macros.h"
int main(int, char**) {
typedef std::pair<int, int> P;
P a1[] = {P(1, 1), P(2, 2), P(3, 3)};
std::unordered_multimap<int, int> l1(a1, a1+3);
std::unordered_multimap<int, int>::const_iterator i = l1.end();
TEST_LIBCPP_ASSERT_FAILURE(l1.erase(i),
"unordered container erase(iterator) called with a non-dereferenceable iterator");
return 0;
}

libcxx/test/libcxx/containers/unord/unord.multimap/unord.multimap.modifiers/erase_iter_db2.pass.cpp

  • This file was deleted.
//===----------------------------------------------------------------------===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
// <unordered_map>
// Call erase(const_iterator position) with iterator from another container
// UNSUPPORTED: libcxx-no-debug-mode
// ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DEBUG=1
#include <unordered_map>
#include "test_macros.h"
#include "debug_macros.h"
int main(int, char**) {
typedef std::pair<int, int> P;
P a1[] = {P(1, 1), P(2, 2), P(3, 3)};
std::unordered_multimap<int, int> l1(a1, a1+3);
std::unordered_multimap<int, int> l2(a1, a1+3);
std::unordered_multimap<int, int>::const_iterator i = l2.begin();
TEST_LIBCPP_ASSERT_FAILURE(
l1.erase(i), "unordered container erase(iterator) called with an iterator not referring to this container");
return 0;
}

libcxx/test/libcxx/containers/unord/unord.multimap/unord.multimap.modifiers/erase_iter_iter_db1.pass.cpp

  • This file was deleted.
//===----------------------------------------------------------------------===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
// <unordered_map>
// Call erase(const_iterator first, const_iterator last); with first iterator from another container
// UNSUPPORTED: libcxx-no-debug-mode
// ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DEBUG=1
#include <unordered_map>
#include "test_macros.h"
#include "debug_macros.h"
int main(int, char**) {
typedef std::pair<int, int> P;
P a1[] = {P(1, 1), P(2, 2), P(3, 3)};
std::unordered_multimap<int, int> l1(a1, a1+3);
std::unordered_multimap<int, int> l2(a1, a1+3);
TEST_LIBCPP_ASSERT_FAILURE(
l1.erase(l2.cbegin(), std::next(l1.cbegin())),
"unordered container::erase(iterator, iterator) called with an iterator not referring to this container");
return 0;
}

libcxx/test/libcxx/containers/unord/unord.multimap/unord.multimap.modifiers/erase_iter_iter_db2.pass.cpp

  • This file was deleted.
//===----------------------------------------------------------------------===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
// <unordered_map>
// Call erase(const_iterator first, const_iterator last); with second iterator from another container
// UNSUPPORTED: libcxx-no-debug-mode
// ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DEBUG=1
#include <unordered_map>
#include "test_macros.h"
#include "debug_macros.h"
int main(int, char**) {
typedef std::pair<int, int> P;
P a1[] = {P(1, 1), P(2, 2), P(3, 3)};
std::unordered_multimap<int, int> l1(a1, a1+3);
std::unordered_multimap<int, int> l2(a1, a1+3);
TEST_LIBCPP_ASSERT_FAILURE(
l1.erase(l1.cbegin(), std::next(l2.cbegin())),
"unordered container::erase(iterator, iterator) called with an iterator not referring to this container");
return 0;
}

libcxx/test/libcxx/containers/unord/unord.multimap/unord.multimap.modifiers/erase_iter_iter_db3.pass.cpp

  • This file was deleted.
//===----------------------------------------------------------------------===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
// <unordered_map>
// Call erase(const_iterator first, const_iterator last); with both iterators from another container
// UNSUPPORTED: libcxx-no-debug-mode
// ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DEBUG=1
#include <unordered_map>
#include "test_macros.h"
#include "debug_macros.h"
int main(int, char**) {
typedef std::pair<int, int> P;
P a1[] = {P(1, 1), P(2, 2), P(3, 3)};
std::unordered_multimap<int, int> l1(a1, a1+3);
std::unordered_multimap<int, int> l2(a1, a1+3);
TEST_LIBCPP_ASSERT_FAILURE(
l1.erase(l2.cbegin(), std::next(l2.cbegin())),
"unordered container::erase(iterator, iterator) called with an iterator not referring to this container");
return 0;
}

libcxx/test/libcxx/containers/unord/unord.multimap/unord.multimap.modifiers/erase_iter_iter_db4.pass.cpp

  • This file was deleted.
//===----------------------------------------------------------------------===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
// <unordered_map>
// Call erase(const_iterator first, const_iterator last); with a bad range
// UNSUPPORTED: libcxx-no-debug-mode
// ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DEBUG=1
#include <unordered_map>
#include "test_macros.h"
#include "debug_macros.h"
int main(int, char**) {
typedef std::pair<int, int> P;
P a1[] = {P(1, 1), P(2, 2), P(3, 3)};
std::unordered_multimap<int, int> l1(a1, a1+3);
TEST_LIBCPP_ASSERT_FAILURE(l1.erase(std::next(l1.cbegin()), l1.cbegin()),
"Attempted to increment a non-incrementable unordered container const_iterator");
return 0;
}

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

  • This file was moved from libcxx/test/libcxx/containers/unord/unord.multiset/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: libcxx-no-debug-mode // UNSUPPORTED: c++03, windows, libcxx-no-debug-mode
// ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DEBUG=0
// ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DEBUG=1
#include <unordered_set> #include <unordered_set>
#include "test_macros.h" #include "check_assertion.h"
#include "debug_macros.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

  • This file was moved from libcxx/test/libcxx/containers/unord/unord.multiset/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: libcxx-no-debug-mode // UNSUPPORTED: c++03, windows, libcxx-no-debug-mode
// ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DEBUG=0
// ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DEBUG=1
#include <unordered_set> #include <unordered_set>
#include "test_macros.h" #include "check_assertion.h"
#include "debug_macros.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

  • This file was moved from libcxx/test/libcxx/containers/unord/unord.multiset/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: libcxx-no-debug-mode // UNSUPPORTED: c++03, windows, libcxx-no-debug-mode
// ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DEBUG=0
// ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DEBUG=1
#include <unordered_set> #include <unordered_set>
#include "test_macros.h" #include "check_assertion.h"
#include "debug_macros.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/bucket.pass.cpp

  • This file was moved to libcxx/test/libcxx/containers/unord/unord.multiset/assert.bucket.pass.cpp.

libcxx/test/libcxx/containers/unord/unord.multiset/bucket_size.pass.cpp

  • This file was moved to libcxx/test/libcxx/containers/unord/unord.multiset/assert.bucket_size.pass.cpp.

libcxx/test/libcxx/containers/unord/unord.multiset/db_insert_hint_const_lvalue.pass.cpp

  • This file was moved to libcxx/test/libcxx/containers/unord/unord.multiset/debug.insert.hint_const_lvalue.pass.cpp.

libcxx/test/libcxx/containers/unord/unord.multiset/db_iterators_10.pass.cpp

  • This file was deleted.
//===----------------------------------------------------------------------===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
// <unordered_set>
// Dereference non-dereferenceable iterator.
// UNSUPPORTED: libcxx-no-debug-mode
// UNSUPPORTED: c++03
// ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DEBUG=1
#include <unordered_set>
#include "test_macros.h"
#include "debug_macros.h"
#include "min_allocator.h"
int main(int, char**) {
typedef int T;
typedef std::unordered_multiset<T, std::hash<T>, std::equal_to<T>, min_allocator<T>> C;
C c(1);
C::iterator i = c.end();
TEST_LIBCPP_ASSERT_FAILURE(*i, "Attempted to dereference a non-dereferenceable unordered container const_iterator");
return 0;
}

libcxx/test/libcxx/containers/unord/unord.multiset/db_iterators_7.pass.cpp

  • This file was deleted.
//===----------------------------------------------------------------------===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
// <unordered_set>
// Increment iterator past end.
// UNSUPPORTED: libcxx-no-debug-mode
// ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DEBUG=1
#include <unordered_set>
#include <cassert>
#include "test_macros.h"
#include "debug_macros.h"
int main(int, char**) {
typedef int T;
typedef std::unordered_multiset<T> C;
C c;
c.insert(42);
C::iterator i = c.begin();
assert(i != c.end());
++i;
assert(i == c.end());
TEST_LIBCPP_ASSERT_FAILURE(++i, "Attempted to increment a non-incrementable unordered container const_iterator");
return 0;
}

libcxx/test/libcxx/containers/unord/unord.multiset/db_iterators_8.pass.cpp

  • This file was deleted.
//===----------------------------------------------------------------------===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
// <unordered_set>
// Dereference non-dereferenceable iterator.
// UNSUPPORTED: libcxx-no-debug-mode
// ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DEBUG=1
#include <unordered_set>
#include "test_macros.h"
#include "debug_macros.h"
int main(int, char**) {
typedef int T;
typedef std::unordered_multiset<T> C;
C c(1);
C::iterator i = c.end();
TEST_LIBCPP_ASSERT_FAILURE(*i, "Attempted to dereference a non-dereferenceable unordered container const_iterator");
return 0;
}

libcxx/test/libcxx/containers/unord/unord.multiset/db_iterators_9.pass.cpp

  • This file was deleted.
//===----------------------------------------------------------------------===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
// <unordered_set>
// Increment iterator past end.
// UNSUPPORTED: libcxx-no-debug-mode
// UNSUPPORTED: c++03
// ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DEBUG=1
#include <unordered_set>
#include <cassert>
#include "test_macros.h"
#include "debug_macros.h"
#include "min_allocator.h"
int main(int, char**) {
typedef int T;
typedef std::unordered_multiset<T, std::hash<T>, std::equal_to<T>, min_allocator<T>> C;
C c({42});
C::iterator i = c.begin();
assert(i != c.end());
++i;
assert(i == c.end());
TEST_LIBCPP_ASSERT_FAILURE(++i, "Attempted to increment a non-incrementable unordered container const_iterator");
return 0;
}

libcxx/test/libcxx/containers/unord/unord.multiset/db_local_iterators_10.pass.cpp

  • This file was deleted.
//===----------------------------------------------------------------------===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
// <unordered_set>
// Dereference non-dereferenceable iterator.
// UNSUPPORTED: libcxx-no-debug-mode
// UNSUPPORTED: c++03
// ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DEBUG=1
#include <unordered_set>
#include "test_macros.h"
#include "debug_macros.h"
#include "min_allocator.h"
int main(int, char**) {
typedef int T;
typedef std::unordered_multiset<T, std::hash<T>, std::equal_to<T>, min_allocator<T>> C;
C c(1);
C::local_iterator i = c.end(0);
TEST_LIBCPP_ASSERT_FAILURE(
*i, "Attempted to dereference a non-dereferenceable unordered container const_local_iterator");
return 0;
}

libcxx/test/libcxx/containers/unord/unord.multiset/db_local_iterators_7.pass.cpp

  • This file was deleted.
//===----------------------------------------------------------------------===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
// <unordered_set>
// Increment local_iterator past end.
// UNSUPPORTED: libcxx-no-debug-mode
// ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DEBUG=1
#include <unordered_set>
#include <cassert>
#include "test_macros.h"
#include "debug_macros.h"
int main(int, char**) {
typedef int T;
typedef std::unordered_multiset<T> C;
C c;
c.insert(42);
C::size_type b = c.bucket(42);
C::local_iterator i = c.begin(b);
assert(i != c.end(b));
++i;
assert(i == c.end(b));
TEST_LIBCPP_ASSERT_FAILURE(++i,
"Attempted to increment a non-incrementable unordered container const_local_iterator");
return 0;
}

libcxx/test/libcxx/containers/unord/unord.multiset/db_local_iterators_8.pass.cpp

  • This file was deleted.
//===----------------------------------------------------------------------===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
// <unordered_set>
// Dereference non-dereferenceable iterator.
// UNSUPPORTED: libcxx-no-debug-mode
// ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DEBUG=1
#include <unordered_set>
#include "test_macros.h"
#include "debug_macros.h"
int main(int, char**) {
typedef int T;
typedef std::unordered_multiset<T> C;
C c(1);
C::local_iterator i = c.end(0);
TEST_LIBCPP_ASSERT_FAILURE(
*i, "Attempted to dereference a non-dereferenceable unordered container const_local_iterator");
return 0;
}

libcxx/test/libcxx/containers/unord/unord.multiset/db_local_iterators_9.pass.cpp

  • This file was deleted.
//===----------------------------------------------------------------------===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
// <unordered_set>
// Increment local_iterator past end.
// UNSUPPORTED: libcxx-no-debug-mode
// UNSUPPORTED: c++03
// ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DEBUG=1
#include <unordered_set>
#include <cassert>
#include "test_macros.h"
#include "debug_macros.h"
#include "min_allocator.h"
int main(int, char**) {
typedef int T;
typedef std::unordered_multiset<T, std::hash<T>, std::equal_to<T>, min_allocator<T>> C;
C c({42});
C::size_type b = c.bucket(42);
C::local_iterator i = c.begin(b);
assert(i != c.end(b));
++i;
assert(i == c.end(b));
TEST_LIBCPP_ASSERT_FAILURE(++i,
"Attempted to increment a non-incrementable unordered container const_local_iterator");
return 0;
}

libcxx/test/libcxx/containers/unord/unord.multiset/db_swap_1.pass.cpp

  • This file was moved to libcxx/test/libcxx/containers/unord/unord.multiset/debug.swap.pass.cpp.

libcxx/test/libcxx/containers/unord/unord.multiset/debug.erase.iter.pass.cpp

  • This file was added.
//===----------------------------------------------------------------------===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
// <unordered_set>
// Call erase(const_iterator position) with invalid iterators
// UNSUPPORTED: libcxx-no-debug-mode, c++03, windows
// ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DEBUG=1
#include <unordered_set>
#include "check_assertion.h"
int main(int, char**) {
// With end()
{
int a1[] = {1, 2, 3};
std::unordered_multiset<int> l1(a1, a1+3);
std::unordered_multiset<int>::const_iterator i = l1.end();
TEST_LIBCPP_ASSERT_FAILURE(l1.erase(i),
"unordered container erase(iterator) called with a non-dereferenceable iterator");
}
// With iterator from another container
{
int a1[] = {1, 2, 3};
std::unordered_multiset<int> l1(a1, a1+3);
std::unordered_multiset<int> l2(a1, a1+3);
std::unordered_multiset<int>::const_iterator i = l2.begin();
TEST_LIBCPP_ASSERT_FAILURE(
l1.erase(i), "unordered container erase(iterator) called with an iterator not referring to this container");
}
return 0;
}

libcxx/test/libcxx/containers/unord/unord.multiset/debug.erase.iter_iter.pass.cpp

  • This file was added.
//===----------------------------------------------------------------------===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
// <unordered_set>
// Call erase(const_iterator first, const_iterator last); with invalid iterators
// UNSUPPORTED: libcxx-no-debug-mode, c++03, windows
// ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DEBUG=1
#include <unordered_set>
#include "check_assertion.h"
int main(int, char**) {
// With first iterator from another container
{
int a1[] = {1, 2, 3};
std::unordered_multiset<int> l1(a1, a1+3);
std::unordered_multiset<int> l2(a1, a1+3);
TEST_LIBCPP_ASSERT_FAILURE(
l1.erase(l2.cbegin(), std::next(l1.cbegin())),
"unordered container::erase(iterator, iterator) called with an iterator not referring to this container");
}
// With second iterator from another container
{
int a1[] = {1, 2, 3};
std::unordered_multiset<int> l1(a1, a1+3);
std::unordered_multiset<int> l2(a1, a1+3);
TEST_LIBCPP_ASSERT_FAILURE(
l1.erase(l1.cbegin(), std::next(l2.cbegin())),
"unordered container::erase(iterator, iterator) called with an iterator not referring to this container");
}
// With both iterators from another container
{
int a1[] = {1, 2, 3};
std::unordered_multiset<int> l1(a1, a1+3);
std::unordered_multiset<int> l2(a1, a1+3);
TEST_LIBCPP_ASSERT_FAILURE(
l1.erase(l2.cbegin(), std::next(l2.cbegin())),
"unordered container::erase(iterator, iterator) called with an iterator not referring to this container");
}
// With an invalid range
{
int a1[] = {1, 2, 3};
std::unordered_multiset<int> l1(a1, a1+3);
TEST_LIBCPP_ASSERT_FAILURE(l1.erase(std::next(l1.cbegin()), l1.cbegin()),
"Attempted to increment a non-incrementable unordered container const_iterator");
}
return 0;
}

libcxx/test/libcxx/containers/unord/unord.multiset/debug.insert.hint_const_lvalue.pass.cpp

  • This file was moved from libcxx/test/libcxx/containers/unord/unord.multiset/db_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 // UNSUPPORTED: libcxx-no-debug-mode, c++03, windows
// ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DEBUG=1 // ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DEBUG=1
#include <unordered_set> #include <unordered_set>
#include "test_macros.h" #include "check_assertion.h"
#include "debug_macros.h"
int main(int, char**) { int main(int, char**) {
typedef std::unordered_multiset<double> C; typedef std::unordered_multiset<double> C;
typedef C::value_type P; typedef C::value_type P;
C c; C c;
C c2; C c2;
C::const_iterator e = c2.end(); C::const_iterator e = c2.end();
P v(3.5); P v(3.5);
TEST_LIBCPP_ASSERT_FAILURE( TEST_LIBCPP_ASSERT_FAILURE(
c.insert(e, v), c.insert(e, v),
"unordered container::emplace_hint(const_iterator, args...) called with an iterator not referring to this unordered container"); "unordered container::emplace_hint(const_iterator, args...) called with an iterator not referring to this unordered container");
return 0; return 0;
} }

libcxx/test/libcxx/containers/unord/unord.multiset/debug.iterator.dereference.pass.cpp

  • This file was added.
//===----------------------------------------------------------------------===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
// <unordered_set>
// Dereference non-dereferenceable iterator.
// UNSUPPORTED: libcxx-no-debug-mode, c++03, windows
// ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DEBUG=1
#include <unordered_set>
#include "check_assertion.h"
#include "min_allocator.h"
int main(int, char**) {
{
typedef int T;
typedef std::unordered_multiset<T> C;
C c(1);
C::iterator i = c.end();
TEST_LIBCPP_ASSERT_FAILURE(*i, "Attempted to dereference a non-dereferenceable unordered container const_iterator");
}
{
typedef int T;
typedef std::unordered_multiset<T, std::hash<T>, std::equal_to<T>, min_allocator<T>> C;
C c(1);
C::iterator i = c.end();
TEST_LIBCPP_ASSERT_FAILURE(*i, "Attempted to dereference a non-dereferenceable unordered container const_iterator");
}
return 0;
}

libcxx/test/libcxx/containers/unord/unord.multiset/debug.iterator.increment.pass.cpp

  • This file was added.
//===----------------------------------------------------------------------===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
// <unordered_set>
// Increment iterator past end.
// UNSUPPORTED: libcxx-no-debug-mode, c++03, windows
// ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DEBUG=1
#include <unordered_set>
#include <cassert>
#include "check_assertion.h"
#include "min_allocator.h"
int main(int, char**) {
{
typedef int T;
typedef std::unordered_multiset<T> C;
C c;
c.insert(42);
C::iterator i = c.begin();
assert(i != c.end());
++i;
assert(i == c.end());
TEST_LIBCPP_ASSERT_FAILURE(++i, "Attempted to increment a non-incrementable unordered container const_iterator");
}
{
typedef int T;
typedef std::unordered_multiset<T, std::hash<T>, std::equal_to<T>, min_allocator<T>> C;
C c({42});
C::iterator i = c.begin();
assert(i != c.end());
++i;
assert(i == c.end());
TEST_LIBCPP_ASSERT_FAILURE(++i, "Attempted to increment a non-incrementable unordered container const_iterator");
}
return 0;
}

libcxx/test/libcxx/containers/unord/unord.multiset/debug.local_iterator.dereference.pass.cpp

  • This file was added.
//===----------------------------------------------------------------------===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
// <unordered_set>
// Dereference non-dereferenceable iterator.
// UNSUPPORTED: libcxx-no-debug-mode, c++03, windows
// ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DEBUG=1
#include <unordered_set>
#include "check_assertion.h"
#include "min_allocator.h"
int main(int, char**) {
{
typedef int T;
typedef std::unordered_multiset<T> C;
C c(1);
C::local_iterator i = c.end(0);
TEST_LIBCPP_ASSERT_FAILURE(
*i, "Attempted to dereference a non-dereferenceable unordered container const_local_iterator");
}
{
typedef int T;
typedef std::unordered_multiset<T, std::hash<T>, std::equal_to<T>, min_allocator<T>> C;
C c(1);
C::local_iterator i = c.end(0);
TEST_LIBCPP_ASSERT_FAILURE(
*i, "Attempted to dereference a non-dereferenceable unordered container const_local_iterator");
}
return 0;
}

libcxx/test/libcxx/containers/unord/unord.multiset/debug.local_iterator.increment.pass.cpp

  • This file was added.
//===----------------------------------------------------------------------===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
// <unordered_set>
// Increment local_iterator past end.
// UNSUPPORTED: libcxx-no-debug-mode, c++03, windows
// ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DEBUG=1
#include <unordered_set>
#include <cassert>
#include "check_assertion.h"
#include "min_allocator.h"
int main(int, char**) {
{
typedef int T;
typedef std::unordered_multiset<T> C;
C c;
c.insert(42);
C::size_type b = c.bucket(42);
C::local_iterator i = c.begin(b);
assert(i != c.end(b));
++i;
assert(i == c.end(b));
TEST_LIBCPP_ASSERT_FAILURE(++i,
"Attempted to increment a non-incrementable unordered container const_local_iterator");
}
{
typedef int T;
typedef std::unordered_multiset<T, std::hash<T>, std::equal_to<T>, min_allocator<T>> C;
C c({42});
C::size_type b = c.bucket(42);
C::local_iterator i = c.begin(b);
assert(i != c.end(b));
++i;
assert(i == c.end(b));
TEST_LIBCPP_ASSERT_FAILURE(++i,
"Attempted to increment a non-incrementable unordered container const_local_iterator");
}
return 0;
}

libcxx/test/libcxx/containers/unord/unord.multiset/debug.swap.pass.cpp

  • This file was moved from libcxx/test/libcxx/containers/unord/unord.multiset/db_swap_1.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 // UNSUPPORTED: libcxx-no-debug-mode, c++03, windows
// ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DEBUG=1 // ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DEBUG=1
#include <unordered_set> #include <unordered_set>
#include "test_macros.h" #include "check_assertion.h"
#include "debug_macros.h"
int main(int, char**) { int main(int, char**) {
int a1[] = {1, 3, 7, 9, 10}; int a1[] = {1, 3, 7, 9, 10};
int a2[] = {0, 2, 4, 5, 6, 8, 11}; int a2[] = {0, 2, 4, 5, 6, 8, 11};
std::unordered_multiset<int> c1(a1, a1+sizeof(a1)/sizeof(a1[0])); std::unordered_multiset<int> c1(a1, a1+sizeof(a1)/sizeof(a1[0]));
std::unordered_multiset<int> c2(a2, a2+sizeof(a2)/sizeof(a2[0])); std::unordered_multiset<int> c2(a2, a2+sizeof(a2)/sizeof(a2[0]));
std::unordered_multiset<int>::iterator i1 = c1.begin(); std::unordered_multiset<int>::iterator i1 = c1.begin();
std::unordered_multiset<int>::iterator i2 = c2.begin(); std::unordered_multiset<int>::iterator i2 = c2.begin();
swap(c1, c2); swap(c1, c2);
c1.erase(i2); c1.erase(i2);
TEST_LIBCPP_ASSERT_FAILURE( TEST_LIBCPP_ASSERT_FAILURE(
c1.erase(i1), "unordered container erase(iterator) called with an iterator not referring to this container"); c1.erase(i1), "unordered container erase(iterator) called with an iterator not referring to this container");
return 0; return 0;
} }

libcxx/test/libcxx/containers/unord/unord.multiset/erase_iter_db1.pass.cpp

  • This file was deleted.
//===----------------------------------------------------------------------===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
// <unordered_set>
// Call erase(const_iterator position) with end()
// UNSUPPORTED: libcxx-no-debug-mode
// ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DEBUG=1
#include <unordered_set>
#include "test_macros.h"
#include "debug_macros.h"
int main(int, char**) {
int a1[] = {1, 2, 3};
std::unordered_multiset<int> l1(a1, a1+3);
std::unordered_multiset<int>::const_iterator i = l1.end();
TEST_LIBCPP_ASSERT_FAILURE(l1.erase(i),
"unordered container erase(iterator) called with a non-dereferenceable iterator");
return 0;
}

libcxx/test/libcxx/containers/unord/unord.multiset/erase_iter_db2.pass.cpp

  • This file was deleted.
//===----------------------------------------------------------------------===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
// <unordered_set>
// Call erase(const_iterator position) with iterator from another container
// UNSUPPORTED: libcxx-no-debug-mode
// ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DEBUG=1
#include <unordered_set>
#include "test_macros.h"
#include "debug_macros.h"
int main(int, char**) {
int a1[] = {1, 2, 3};
std::unordered_multiset<int> l1(a1, a1+3);
std::unordered_multiset<int> l2(a1, a1+3);
std::unordered_multiset<int>::const_iterator i = l2.begin();
TEST_LIBCPP_ASSERT_FAILURE(
l1.erase(i), "unordered container erase(iterator) called with an iterator not referring to this container");
return 0;
}

libcxx/test/libcxx/containers/unord/unord.multiset/erase_iter_iter_db1.pass.cpp

  • This file was deleted.
//===----------------------------------------------------------------------===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
// <unordered_set>
// Call erase(const_iterator first, const_iterator last); with first iterator from another container
// UNSUPPORTED: libcxx-no-debug-mode
// ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DEBUG=1
#include <unordered_set>
#include "test_macros.h"
#include "debug_macros.h"
int main(int, char**) {
int a1[] = {1, 2, 3};
std::unordered_multiset<int> l1(a1, a1+3);
std::unordered_multiset<int> l2(a1, a1+3);
TEST_LIBCPP_ASSERT_FAILURE(
l1.erase(l2.cbegin(), std::next(l1.cbegin())),
"unordered container::erase(iterator, iterator) called with an iterator not referring to this container");
return 0;
}

libcxx/test/libcxx/containers/unord/unord.multiset/erase_iter_iter_db2.pass.cpp

  • This file was deleted.
//===----------------------------------------------------------------------===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
// <unordered_set>
// Call erase(const_iterator first, const_iterator last); with second iterator from another container
// UNSUPPORTED: libcxx-no-debug-mode
// ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DEBUG=1
#include <unordered_set>
#include "test_macros.h"
#include "debug_macros.h"
int main(int, char**) {
int a1[] = {1, 2, 3};
std::unordered_multiset<int> l1(a1, a1+3);
std::unordered_multiset<int> l2(a1, a1+3);
TEST_LIBCPP_ASSERT_FAILURE(
l1.erase(l1.cbegin(), std::next(l2.cbegin())),
"unordered container::erase(iterator, iterator) called with an iterator not referring to this container");
return 0;
}

libcxx/test/libcxx/containers/unord/unord.multiset/erase_iter_iter_db3.pass.cpp

  • This file was deleted.
//===----------------------------------------------------------------------===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
// <unordered_set>
// Call erase(const_iterator first, const_iterator last); with both iterators from another container
// UNSUPPORTED: libcxx-no-debug-mode
// ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DEBUG=1
#include <unordered_set>
#include "test_macros.h"
#include "debug_macros.h"
int main(int, char**) {
int a1[] = {1, 2, 3};
std::unordered_multiset<int> l1(a1, a1+3);
std::unordered_multiset<int> l2(a1, a1+3);
TEST_LIBCPP_ASSERT_FAILURE(
l1.erase(l2.cbegin(), std::next(l2.cbegin())),
"unordered container::erase(iterator, iterator) called with an iterator not referring to this container");
return 0;
}

libcxx/test/libcxx/containers/unord/unord.multiset/erase_iter_iter_db4.pass.cpp

  • This file was deleted.
//===----------------------------------------------------------------------===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
// <unordered_set>
// Call erase(const_iterator first, const_iterator last); with a bad range
// UNSUPPORTED: libcxx-no-debug-mode
// ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DEBUG=1
#include <unordered_set>
#include "test_macros.h"
#include "debug_macros.h"
int main(int, char**) {
int a1[] = {1, 2, 3};
std::unordered_multiset<int> l1(a1, a1+3);
TEST_LIBCPP_ASSERT_FAILURE(l1.erase(std::next(l1.cbegin()), l1.cbegin()),
"Attempted to increment a non-incrementable unordered container const_iterator");
return 0;
}

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

  • This file was moved to libcxx/test/libcxx/containers/unord/unord.multiset/assert.max_load_factor.pass.cpp.

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

  • This file was moved from libcxx/test/libcxx/containers/unord/unord.set/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: libcxx-no-debug-mode // UNSUPPORTED: c++03, windows, libcxx-no-debug-mode
// ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DEBUG=0
// ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DEBUG=1
#include <unordered_set> #include <unordered_set>
#include "test_macros.h" #include "check_assertion.h"
#include "debug_macros.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

  • This file was moved from libcxx/test/libcxx/containers/unord/unord.set/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: libcxx-no-debug-mode // UNSUPPORTED: c++03, windows, libcxx-no-debug-mode
// ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DEBUG=0
// ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DEBUG=1
#include <unordered_set> #include <unordered_set>
#include "test_macros.h" #include "check_assertion.h"
#include "debug_macros.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

  • This file was moved from libcxx/test/libcxx/containers/unord/unord.set/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: libcxx-no-debug-mode // UNSUPPORTED: c++03, windows, libcxx-no-debug-mode
// ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DEBUG=0
// ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DEBUG=1
#include <unordered_set> #include <unordered_set>
#include "test_macros.h" #include "check_assertion.h"
#include "debug_macros.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/bucket.pass.cpp

  • This file was moved to libcxx/test/libcxx/containers/unord/unord.set/assert.bucket.pass.cpp.

libcxx/test/libcxx/containers/unord/unord.set/bucket_size.pass.cpp

  • This file was moved to libcxx/test/libcxx/containers/unord/unord.set/assert.bucket_size.pass.cpp.

libcxx/test/libcxx/containers/unord/unord.set/db_insert_hint_const_lvalue.pass.cpp

  • This file was moved to libcxx/test/libcxx/containers/unord/unord.set/debug.insert.hint_const_lvalue.pass.cpp.

libcxx/test/libcxx/containers/unord/unord.set/db_iterators_10.pass.cpp

  • This file was moved to libcxx/test/libcxx/containers/sequences/vector/debug.iterator.dereference.pass.cpp.

libcxx/test/libcxx/containers/unord/unord.set/db_iterators_7.pass.cpp

  • This file was deleted.
//===----------------------------------------------------------------------===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
// <unordered_set>
// Increment iterator past end.
// UNSUPPORTED: libcxx-no-debug-mode
// ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DEBUG=1
#include <unordered_set>
#include <cassert>
#include "test_macros.h"
#include "debug_macros.h"
int main(int, char**) {
typedef int T;
typedef std::unordered_set<T> C;
C c;
c.insert(42);
C::iterator i = c.begin();
assert(i != c.end());
++i;
assert(i == c.end());
TEST_LIBCPP_ASSERT_FAILURE(++i, "Attempted to increment a non-incrementable unordered container const_iterator");
return 0;
}

libcxx/test/libcxx/containers/unord/unord.set/db_iterators_8.pass.cpp

  • This file was deleted.
//===----------------------------------------------------------------------===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
// <unordered_set>
// Dereference non-dereferenceable iterator.
// UNSUPPORTED: libcxx-no-debug-mode
// ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DEBUG=1
#include <unordered_set>
#include "test_macros.h"
#include "debug_macros.h"
int main(int, char**) {
typedef int T;
typedef std::unordered_set<T> C;
C c(1);
C::iterator i = c.end();
TEST_LIBCPP_ASSERT_FAILURE(*i, "Attempted to dereference a non-dereferenceable unordered container const_iterator");
return 0;
}

libcxx/test/libcxx/containers/unord/unord.set/db_iterators_9.pass.cpp

  • This file was moved to libcxx/test/libcxx/containers/sequences/vector/debug.iterator.increment.pass.cpp.

libcxx/test/libcxx/containers/unord/unord.set/db_local_iterators_10.pass.cpp

  • This file was deleted.
//===----------------------------------------------------------------------===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
// <unordered_set>
// Dereference non-dereferenceable iterator.
// UNSUPPORTED: libcxx-no-debug-mode
// UNSUPPORTED: c++03
// ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DEBUG=1
#include <unordered_set>
#include "test_macros.h"
#include "debug_macros.h"
#include "min_allocator.h"
int main(int, char**) {
typedef int T;
typedef std::unordered_set<T, std::hash<T>, std::equal_to<T>, min_allocator<T>> C;
C c(1);
C::local_iterator i = c.end(0);
TEST_LIBCPP_ASSERT_FAILURE(
*i, "Attempted to dereference a non-dereferenceable unordered container const_local_iterator");
return 0;
}

libcxx/test/libcxx/containers/unord/unord.set/db_local_iterators_7.pass.cpp

  • This file was deleted.
//===----------------------------------------------------------------------===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
// <unordered_set>
// Increment local_iterator past end.
// UNSUPPORTED: libcxx-no-debug-mode
// ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DEBUG=1
#include <unordered_set>
#include <cassert>
#include "test_macros.h"
#include "debug_macros.h"
int main(int, char**) {
typedef int T;
typedef std::unordered_set<T> C;
C c;
c.insert(42);
C::size_type b = c.bucket(42);
C::local_iterator i = c.begin(b);
assert(i != c.end(b));
++i;
assert(i == c.end(b));
TEST_LIBCPP_ASSERT_FAILURE(++i,
"Attempted to increment a non-incrementable unordered container const_local_iterator");
return 0;
}

libcxx/test/libcxx/containers/unord/unord.set/db_local_iterators_8.pass.cpp

  • This file was deleted.
//===----------------------------------------------------------------------===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
// <unordered_set>
// Dereference non-dereferenceable iterator.
// UNSUPPORTED: libcxx-no-debug-mode
// ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DEBUG=1
#include <unordered_set>
#include "test_macros.h"
#include "debug_macros.h"
int main(int, char**) {
typedef int T;
typedef std::unordered_set<T> C;
C c(1);
C::local_iterator i = c.end(0);
TEST_LIBCPP_ASSERT_FAILURE(
*i, "Attempted to dereference a non-dereferenceable unordered container const_local_iterator");
return 0;
}

libcxx/test/libcxx/containers/unord/unord.set/db_local_iterators_9.pass.cpp

  • This file was deleted.
//===----------------------------------------------------------------------===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
// <unordered_set>
// Increment local_iterator past end.
// UNSUPPORTED: libcxx-no-debug-mode
// UNSUPPORTED: c++03
// ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DEBUG=1
#include <unordered_set>
#include <cassert>
#include "test_macros.h"
#include "debug_macros.h"
#include "min_allocator.h"
int main(int, char**) {
typedef int T;
typedef std::unordered_set<T, std::hash<T>, std::equal_to<T>, min_allocator<T>> C;
C c({42});
C::size_type b = c.bucket(42);
C::local_iterator i = c.begin(b);
assert(i != c.end(b));
++i;
assert(i == c.end(b));
TEST_LIBCPP_ASSERT_FAILURE(++i,
"Attempted to increment a non-incrementable unordered container const_local_iterator");
return 0;
}

libcxx/test/libcxx/containers/unord/unord.set/db_swap_1.pass.cpp

  • This file was moved to libcxx/test/libcxx/containers/unord/unord.set/debug.swap.pass.cpp.

libcxx/test/libcxx/containers/unord/unord.set/debug.erase.iter.pass.cpp

  • This file was added.
//===----------------------------------------------------------------------===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
// <unordered_set>
// Call erase(const_iterator position) with invalid iterators
// UNSUPPORTED: libcxx-no-debug-mode, c++03, windows
// ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DEBUG=1
#include <unordered_set>
#include "check_assertion.h"
int main(int, char**) {
// With end()
{
int a1[] = {1, 2, 3};
std::unordered_set<int> l1(a1, a1+3);
std::unordered_set<int>::const_iterator i = l1.end();
TEST_LIBCPP_ASSERT_FAILURE(l1.erase(i),
"unordered container erase(iterator) called with a non-dereferenceable iterator");
}
// With iterator from another container
{
int a1[] = {1, 2, 3};
std::unordered_set<int> l1(a1, a1+3);
std::unordered_set<int> l2(a1, a1+3);
std::unordered_set<int>::const_iterator i = l2.begin();
TEST_LIBCPP_ASSERT_FAILURE(
l1.erase(i), "unordered container erase(iterator) called with an iterator not referring to this container");
}
return 0;
}

libcxx/test/libcxx/containers/unord/unord.set/debug.erase.iter_iter.pass.cpp

  • This file was added.
//===----------------------------------------------------------------------===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
// <unordered_set>
// Call erase(const_iterator first, const_iterator last); with first iterator from another container
// UNSUPPORTED: libcxx-no-debug-mode, c++03, windows
// ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DEBUG=1
#include <unordered_set>
#include "check_assertion.h"
int main(int, char**) {
// With first iterator from another container
{
int a1[] = {1, 2, 3};
std::unordered_set<int> l1(a1, a1+3);
std::unordered_set<int> l2(a1, a1+3);
TEST_LIBCPP_ASSERT_FAILURE(
l1.erase(l2.cbegin(), std::next(l1.cbegin())),
"unordered container::erase(iterator, iterator) called with an iterator not referring to this container");
}
// With second iterator from another container
{
int a1[] = {1, 2, 3};
std::unordered_set<int> l1(a1, a1+3);
std::unordered_set<int> l2(a1, a1+3);
TEST_LIBCPP_ASSERT_FAILURE(
l1.erase(l1.cbegin(), std::next(l2.cbegin())),
"unordered container::erase(iterator, iterator) called with an iterator not referring to this container");
}
// With both iterators from another container
{
int a1[] = {1, 2, 3};
std::unordered_set<int> l1(a1, a1+3);
std::unordered_set<int> l2(a1, a1+3);
TEST_LIBCPP_ASSERT_FAILURE(
l1.erase(l2.cbegin(), std::next(l2.cbegin())),
"unordered container::erase(iterator, iterator) called with an iterator not referring to this container");
}
// With an invalid range
{
int a1[] = {1, 2, 3};
std::unordered_set<int> l1(a1, a1+3);
TEST_LIBCPP_ASSERT_FAILURE(l1.erase(std::next(l1.cbegin()), l1.cbegin()),
"Attempted to increment a non-incrementable unordered container const_iterator");
}
return 0;
}

libcxx/test/libcxx/containers/unord/unord.set/debug.insert.hint_const_lvalue.pass.cpp

  • This file was moved from libcxx/test/libcxx/containers/unord/unord.set/db_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 // UNSUPPORTED: libcxx-no-debug-mode, c++03, windows
// ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DEBUG=1 // ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DEBUG=1
#include <unordered_set> #include <unordered_set>
#include "test_macros.h" #include "check_assertion.h"
#include "debug_macros.h"
int main(int, char**) { int main(int, char**) {
typedef std::unordered_set<double> C; typedef std::unordered_set<double> C;
typedef C::value_type P; typedef C::value_type P;
C c; C c;
C c2; C c2;
C::const_iterator e = c2.end(); C::const_iterator e = c2.end();
P v(3.5); P v(3.5);
TEST_LIBCPP_ASSERT_FAILURE( TEST_LIBCPP_ASSERT_FAILURE(
c.insert(e, v), c.insert(e, v),
"unordered_set::insert(const_iterator, const value_type&) called with an iterator not referring to this unordered_set"); "unordered_set::insert(const_iterator, const value_type&) called with an iterator not referring to this unordered_set");
return 0; return 0;
} }

libcxx/test/libcxx/containers/unord/unord.set/debug.iterator.dereference.pass.cpp

  • This file was added.
//===----------------------------------------------------------------------===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
// <unordered_set>
// Dereference non-dereferenceable iterator.
// UNSUPPORTED: libcxx-no-debug-mode, c++03, windows
// ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DEBUG=1
#include <unordered_set>
#include "check_assertion.h"
#include "min_allocator.h"
int main(int, char**) {
{
typedef int T;
typedef std::unordered_set<T> C;
C c(1);
C::iterator i = c.end();
TEST_LIBCPP_ASSERT_FAILURE(*i, "Attempted to dereference a non-dereferenceable unordered container const_iterator");
}
{
typedef int T;
typedef std::unordered_set<T, std::hash<T>, std::equal_to<T>, min_allocator<T>> C;
C c(1);
C::iterator i = c.end();
TEST_LIBCPP_ASSERT_FAILURE(*i, "Attempted to dereference a non-dereferenceable unordered container const_iterator");
}
return 0;
}

libcxx/test/libcxx/containers/unord/unord.set/debug.iterator.increment.pass.cpp

  • This file was added.
//===----------------------------------------------------------------------===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
// <unordered_set>
// Increment iterator past end.
// UNSUPPORTED: libcxx-no-debug-mode, c++03, windows
// ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DEBUG=1
#include <unordered_set>
#include <cassert>
#include "check_assertion.h"
#include "min_allocator.h"
int main(int, char**) {
{
typedef int T;
typedef std::unordered_set<T> C;
C c;
c.insert(42);
C::iterator i = c.begin();
assert(i != c.end());
++i;
assert(i == c.end());
TEST_LIBCPP_ASSERT_FAILURE(++i, "Attempted to increment a non-incrementable unordered container const_iterator");
}
{
typedef int T;
typedef std::unordered_set<T, std::hash<T>, std::equal_to<T>, min_allocator<T>> C;
C c({42});
C::iterator i = c.begin();
assert(i != c.end());
++i;
assert(i == c.end());
TEST_LIBCPP_ASSERT_FAILURE(++i, "Attempted to increment a non-incrementable unordered container const_iterator");
}
return 0;
}

libcxx/test/libcxx/containers/unord/unord.set/debug.local_iterator.dereference.pass.cpp

  • This file was added.
//===----------------------------------------------------------------------===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
// <unordered_set>
// Dereference non-dereferenceable iterator.
// UNSUPPORTED: libcxx-no-debug-mode, c++03, windows
// ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DEBUG=1
#include <unordered_set>
#include "check_assertion.h"
#include "min_allocator.h"
int main(int, char**) {
{
typedef int T;
typedef std::unordered_set<T> C;
C c(1);
C::local_iterator i = c.end(0);
TEST_LIBCPP_ASSERT_FAILURE(
*i, "Attempted to dereference a non-dereferenceable unordered container const_local_iterator");
}
{
typedef int T;
typedef std::unordered_set<T, std::hash<T>, std::equal_to<T>, min_allocator<T>> C;
C c(1);
C::local_iterator i = c.end(0);
TEST_LIBCPP_ASSERT_FAILURE(
*i, "Attempted to dereference a non-dereferenceable unordered container const_local_iterator");
}
return 0;
}

libcxx/test/libcxx/containers/unord/unord.set/debug.local_iterator.increment.pass.cpp

  • This file was added.
//===----------------------------------------------------------------------===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
// <unordered_set>
// Increment local_iterator past end.
// UNSUPPORTED: libcxx-no-debug-mode, c++03, windows
// ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DEBUG=1
#include <unordered_set>
#include <cassert>
#include "check_assertion.h"
#include "min_allocator.h"
int main(int, char**) {
{
typedef int T;
typedef std::unordered_set<T> C;
C c;
c.insert(42);
C::size_type b = c.bucket(42);
C::local_iterator i = c.begin(b);
assert(i != c.end(b));
++i;
assert(i == c.end(b));
TEST_LIBCPP_ASSERT_FAILURE(++i, "Attempted to increment a non-incrementable unordered container const_local_iterator");
}
{
typedef int T;
typedef std::unordered_set<T, std::hash<T>, std::equal_to<T>, min_allocator<T>> C;
C c({42});
C::size_type b = c.bucket(42);
C::local_iterator i = c.begin(b);
assert(i != c.end(b));
++i;
assert(i == c.end(b));
TEST_LIBCPP_ASSERT_FAILURE(++i, "Attempted to increment a non-incrementable unordered container const_local_iterator");
}
return 0;
}

libcxx/test/libcxx/containers/unord/unord.set/debug.swap.pass.cpp

  • This file was moved from libcxx/test/libcxx/containers/unord/unord.set/db_swap_1.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 // UNSUPPORTED: libcxx-no-debug-mode, c++03, windows
// ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DEBUG=1 // ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DEBUG=1
#include <unordered_set> #include <unordered_set>
#include "test_macros.h" #include "check_assertion.h"
#include "debug_macros.h"
int main(int, char**) { int main(int, char**) {
int a1[] = {1, 3, 7, 9, 10}; int a1[] = {1, 3, 7, 9, 10};
int a2[] = {0, 2, 4, 5, 6, 8, 11}; int a2[] = {0, 2, 4, 5, 6, 8, 11};
std::unordered_set<int> c1(a1, a1+sizeof(a1)/sizeof(a1[0])); std::unordered_set<int> c1(a1, a1+sizeof(a1)/sizeof(a1[0]));
std::unordered_set<int> c2(a2, a2+sizeof(a2)/sizeof(a2[0])); std::unordered_set<int> c2(a2, a2+sizeof(a2)/sizeof(a2[0]));
std::unordered_set<int>::iterator i1 = c1.begin(); std::unordered_set<int>::iterator i1 = c1.begin();
std::unordered_set<int>::iterator i2 = c2.begin(); std::unordered_set<int>::iterator i2 = c2.begin();
swap(c1, c2); swap(c1, c2);
c1.erase(i2); c1.erase(i2);
TEST_LIBCPP_ASSERT_FAILURE( TEST_LIBCPP_ASSERT_FAILURE(
c1.erase(i1), "unordered container erase(iterator) called with an iterator not referring to this container"); c1.erase(i1), "unordered container erase(iterator) called with an iterator not referring to this container");
return 0; return 0;
} }

libcxx/test/libcxx/containers/unord/unord.set/erase_iter_db1.pass.cpp

  • This file was deleted.
//===----------------------------------------------------------------------===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
// <unordered_set>
// Call erase(const_iterator position) with end()
// UNSUPPORTED: libcxx-no-debug-mode
// ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DEBUG=1
#include <unordered_set>
#include "test_macros.h"
#include "debug_macros.h"
int main(int, char**) {
int a1[] = {1, 2, 3};
std::unordered_set<int> l1(a1, a1+3);
std::unordered_set<int>::const_iterator i = l1.end();
TEST_LIBCPP_ASSERT_FAILURE(l1.erase(i),
"unordered container erase(iterator) called with a non-dereferenceable iterator");
return 0;
}

libcxx/test/libcxx/containers/unord/unord.set/erase_iter_db2.pass.cpp

  • This file was deleted.
//===----------------------------------------------------------------------===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
// <unordered_set>
// Call erase(const_iterator position) with iterator from another container
// UNSUPPORTED: libcxx-no-debug-mode
// ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DEBUG=1
#include <unordered_set>
#include "test_macros.h"
#include "debug_macros.h"
int main(int, char**) {
int a1[] = {1, 2, 3};
std::unordered_set<int> l1(a1, a1+3);
std::unordered_set<int> l2(a1, a1+3);
std::unordered_set<int>::const_iterator i = l2.begin();
TEST_LIBCPP_ASSERT_FAILURE(
l1.erase(i), "unordered container erase(iterator) called with an iterator not referring to this container");
return 0;
}

libcxx/test/libcxx/containers/unord/unord.set/erase_iter_iter_db1.pass.cpp

  • This file was deleted.
//===----------------------------------------------------------------------===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
// <unordered_set>
// Call erase(const_iterator first, const_iterator last); with first iterator from another container
// UNSUPPORTED: libcxx-no-debug-mode
// ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DEBUG=1
#include <unordered_set>
#include "test_macros.h"
#include "debug_macros.h"
int main(int, char**) {
int a1[] = {1, 2, 3};
std::unordered_set<int> l1(a1, a1+3);
std::unordered_set<int> l2(a1, a1+3);
TEST_LIBCPP_ASSERT_FAILURE(
l1.erase(l2.cbegin(), std::next(l1.cbegin())),
"unordered container::erase(iterator, iterator) called with an iterator not referring to this container");
return 0;
}

libcxx/test/libcxx/containers/unord/unord.set/erase_iter_iter_db2.pass.cpp

  • This file was deleted.
//===----------------------------------------------------------------------===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
// <unordered_set>
// Call erase(const_iterator first, const_iterator last); with second iterator from another container
// UNSUPPORTED: libcxx-no-debug-mode
// ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DEBUG=1
#include <unordered_set>
#include "test_macros.h"
#include "debug_macros.h"
int main(int, char**) {
int a1[] = {1, 2, 3};
std::unordered_set<int> l1(a1, a1+3);
std::unordered_set<int> l2(a1, a1+3);
TEST_LIBCPP_ASSERT_FAILURE(
l1.erase(l1.cbegin(), std::next(l2.cbegin())),
"unordered container::erase(iterator, iterator) called with an iterator not referring to this container");
return 0;
}

libcxx/test/libcxx/containers/unord/unord.set/erase_iter_iter_db3.pass.cpp

  • This file was deleted.
//===----------------------------------------------------------------------===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
// <unordered_set>
// Call erase(const_iterator first, const_iterator last); with both iterators from another container
// UNSUPPORTED: libcxx-no-debug-mode
// ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DEBUG=1
#include <unordered_set>
#include "test_macros.h"
#include "debug_macros.h"
int main(int, char**) {
int a1[] = {1, 2, 3};
std::unordered_set<int> l1(a1, a1+3);
std::unordered_set<int> l2(a1, a1+3);
TEST_LIBCPP_ASSERT_FAILURE(
l1.erase(l2.cbegin(), std::next(l2.cbegin())),
"unordered container::erase(iterator, iterator) called with an iterator not referring to this container");
return 0;
}

libcxx/test/libcxx/containers/unord/unord.set/erase_iter_iter_db4.pass.cpp

  • This file was deleted.
//===----------------------------------------------------------------------===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
// <unordered_set>
// Call erase(const_iterator first, const_iterator last); with a bad range
// UNSUPPORTED: libcxx-no-debug-mode
// ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DEBUG=1
#include <unordered_set>
#include "test_macros.h"
#include "debug_macros.h"
int main(int, char**) {
int a1[] = {1, 2, 3};
std::unordered_set<int> l1(a1, a1+3);
TEST_LIBCPP_ASSERT_FAILURE(l1.erase(std::next(l1.cbegin()), l1.cbegin()),
"Attempted to increment a non-incrementable unordered container const_iterator");
return 0;
}

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

  • This file was moved to libcxx/test/libcxx/containers/unord/unord.set/assert.max_load_factor.pass.cpp.

libcxx/test/libcxx/debug/check_assertion_test.pass.cpp

  • This file was moved from libcxx/test/libcxx/debug/debug_helper_test.pass.cpp.
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// UNSUPPORTED: c++03 // UNSUPPORTED: libcxx-no-debug-mode, c++03, windows
// UNSUPPORTED: windows
// ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DEBUG=1 // ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DEBUG=1
// UNSUPPORTED: libcxx-no-debug-mode
#include <__debug> #include <__debug>
#include "debug_mode_helper.h"
#include <cstdio> #include <cstdio>
#include "test_macros.h"
#include "check_assertion.h"
#include "test_macros.h"
template <class Func> template <class Func>
inline bool TestDeathTest(const char* stmt, Func&& func, DeathTest::ResultKind ExpectResult, DebugInfoMatcher Matcher = AnyMatcher) { inline bool TestDeathTest(const char* stmt, Func&& func, DeathTest::ResultKind ExpectResult, DebugInfoMatcher Matcher = AnyMatcher) {
DeathTest DT(Matcher); DeathTest DT(Matcher);
DeathTest::ResultKind RK = DT.Run(func); DeathTest::ResultKind RK = DT.Run(func);
auto OnFailure = [&](std::string msg) { auto OnFailure = [&](std::string msg) {
std::fprintf(stderr, "EXPECT_DEATH( %s ) failed! (%s)\n\n", stmt, msg.c_str()); std::fprintf(stderr, "EXPECT_DEATH( %s ) failed! (%s)\n\n", stmt, msg.c_str());
if (!DT.getChildStdErr().empty()) { if (!DT.getChildStdErr().empty()) {
Show All 24 Lines
void test_did_not_die() { void test_did_not_die() {
TEST_DEATH_TEST(DeathTest::RK_DidNotDie, ((void)0)); TEST_DEATH_TEST(DeathTest::RK_DidNotDie, ((void)0));
} }
void test_unknown() { void test_unknown() {
TEST_DEATH_TEST(DeathTest::RK_Unknown, std::exit(13)); TEST_DEATH_TEST(DeathTest::RK_Unknown, std::exit(13));
} }
int main(int, char**) int main(int, char**) {
{
test_no_match_found(); test_no_match_found();
test_did_not_die(); test_did_not_die();
test_unknown(); test_unknown();
return 0; return 0;
} }

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

  • This file was moved from libcxx/test/libcxx/debug/containers/db_sequence_container_iterators.multithread.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 // UNSUPPORTED: c++11, c++14
// UNSUPPORTED: windows
// UNSUPPORTED: libcpp-has-no-threads // UNSUPPORTED: libcpp-has-no-threads
// UNSUPPORTED: libcxx-no-debug-mode, c++03
// ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DEBUG=1 // ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DEBUG=1
// UNSUPPORTED: libcxx-no-debug-mode
// test multihtreaded container debugging // test multithreaded container debugging
#include <cassert> #include <cassert>
#include <cstddef> #include <cstddef>
#include <deque> #include <deque>
#include <list> #include <list>
#include <thread> #include <thread>
#include <vector> #include <vector>
#include "container_debug_tests.h"
#include "test_macros.h"
template <typename Container> template <typename Container>
Container makeContainer(int size) { Container makeContainer(int size) {
Container c; Container c;
typedef typename Container::value_type ValueType; typedef typename Container::value_type ValueType;
for (int i = 0; i < size; ++i) for (int i = 0; i < size; ++i)
c.insert(c.end(), ValueType(i)); c.insert(c.end(), ValueType(i));
assert(c.size() == static_cast<std::size_t>(size)); assert(c.size() == static_cast<std::size_t>(size));
Show All 36 Lines

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

  • This file was moved from libcxx/test/libcxx/debug/containers/db_associative_container_tests.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 // UNSUPPORTED: c++11, c++14
// UNSUPPORTED: windows
// UNSUPPORTED: libcxx-no-debug-mode, c++03, windows
// ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DEBUG=1 // ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DEBUG=1
// UNSUPPORTED: libcxx-no-debug-mode
// test container debugging // test container debugging
#include <map> #include <map>
#include <set> #include <set>
#include <utility> #include <utility>
#include <cassert> #include <cassert>
#include "check_assertion.h"
#include "container_debug_tests.h" #include "container_debug_tests.h"
#include "test_macros.h" #include "test_macros.h"
#include "debug_mode_helper.h"
using namespace IteratorDebugChecks; using namespace IteratorDebugChecks;
template <class Container, ContainerType CT> template <class Container, ContainerType CT>
struct AssociativeContainerChecks : BasicContainerChecks<Container, CT> { struct AssociativeContainerChecks : BasicContainerChecks<Container, CT> {
using Base = BasicContainerChecks<Container, CT>; using Base = BasicContainerChecks<Container, CT>;
using value_type = typename Container::value_type; using value_type = typename Container::value_type;
using iterator = typename Container::iterator; using iterator = typename Container::iterator;
Show All 32 Lines

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

  • This file was moved to libcxx/test/libcxx/debug/containers/associative_containers.pass.cpp.

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

  • This file was moved to libcxx/test/libcxx/debug/containers.multithread.pass.cpp.

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

  • This file was moved to libcxx/test/libcxx/debug/containers/sequence_container_iterators.pass.cpp.

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

  • This file was moved to libcxx/test/libcxx/debug/containers/string.pass.cpp.

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

  • This file was moved to libcxx/test/libcxx/debug/containers/unord_containers.pass.cpp.

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

  • This file was moved from libcxx/test/libcxx/debug/containers/db_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
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// UNSUPPORTED: c++03, c++11, c++14 // UNSUPPORTED: c++11, c++14
// UNSUPPORTED: windows
// UNSUPPORTED: libcxx-no-debug-mode, c++03, windows
// ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DEBUG=1 // ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DEBUG=1
// UNSUPPORTED: libcxx-no-debug-mode
// test container debugging // test container debugging
#include <forward_list> #include <forward_list>
#include <list> #include <list>
#include <vector> #include <vector>
#include <deque> #include <deque>
#include "check_assertion.h"
#include "container_debug_tests.h" #include "container_debug_tests.h"
#include "test_macros.h" #include "test_macros.h"
#include "debug_mode_helper.h"
using namespace IteratorDebugChecks; using namespace IteratorDebugChecks;
template <class Container, ContainerType CT> template <class Container, ContainerType CT>
struct SequenceContainerChecks : BasicContainerChecks<Container, CT> { struct SequenceContainerChecks : BasicContainerChecks<Container, CT> {
using Base = BasicContainerChecks<Container, CT>; using Base = BasicContainerChecks<Container, CT>;
using value_type = typename Container::value_type; using value_type = typename Container::value_type;
using allocator_type = typename Container::allocator_type; using allocator_type = typename Container::allocator_type;
▲ Show 20 Lines • Show All 305 Lines • Show Last 20 Lines

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

  • This file was moved from libcxx/test/libcxx/debug/containers/db_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
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// UNSUPPORTED: c++03, c++11, c++14 // UNSUPPORTED: c++11, c++14
// UNSUPPORTED: windows
// UNSUPPORTED: libcxx-no-debug-mode, c++03, windows
// ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DEBUG=1 // ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DEBUG=1
// UNSUPPORTED: libcxx-no-debug-mode
// test container debugging // test container debugging
#include <string> #include <string>
#include <vector> #include <vector>
#include "test_macros.h" #include "test_macros.h"
#include "check_assertion.h"
#include "container_debug_tests.h" #include "container_debug_tests.h"
#include "debug_mode_helper.h"
using namespace IteratorDebugChecks; using namespace IteratorDebugChecks;
typedef std::basic_string<char, std::char_traits<char>, test_allocator<char>> StringType; typedef std::basic_string<char, std::char_traits<char>, test_allocator<char>> StringType;
template <class Container = StringType, ContainerType CT = CT_String> template <class Container = StringType, ContainerType CT = CT_String>
struct StringContainerChecks : BasicContainerChecks<Container, CT> { struct StringContainerChecks : BasicContainerChecks<Container, CT> {
using Base = BasicContainerChecks<Container, CT_String>; using Base = BasicContainerChecks<Container, CT_String>;
▲ Show 20 Lines • Show All 65 Lines • Show Last 20 Lines

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

  • This file was moved from libcxx/test/libcxx/debug/containers/db_unord_container_tests.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 // UNSUPPORTED: c++11, c++14
// UNSUPPORTED: windows
// UNSUPPORTED: libcxx-no-debug-mode, c++03, windows
// ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DEBUG=1 // ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DEBUG=1
// UNSUPPORTED: libcxx-no-debug-mode
// 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>
#include "check_assertion.h"
#include "container_debug_tests.h" #include "container_debug_tests.h"
#include "test_macros.h" #include "test_macros.h"
#include "debug_mode_helper.h"
using namespace IteratorDebugChecks; using namespace IteratorDebugChecks;
template <class Container, ContainerType CT> template <class Container, ContainerType CT>
struct UnorderedContainerChecks : BasicContainerChecks<Container, CT> { struct UnorderedContainerChecks : BasicContainerChecks<Container, CT> {
using Base = BasicContainerChecks<Container, CT>; using Base = BasicContainerChecks<Container, CT>;
using value_type = typename Container::value_type; using value_type = typename Container::value_type;
using iterator = typename Container::iterator; using iterator = typename Container::iterator;
Show All 34 Lines

libcxx/test/libcxx/debug/db_string_view.pass.cpp

  • This file was deleted.
//===----------------------------------------------------------------------===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
// UNSUPPORTED: c++03, c++11, c++14
// UNSUPPORTED: windows
// ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DEBUG=1
// UNSUPPORTED: libcxx-no-debug-mode
// test container debugging
#include <string_view>
#include "test_macros.h"
#include "debug_mode_helper.h"
void test_null_argument() {
// C++2b prohibits construction of string_view from nullptr_t.
const char* nullp = nullptr;
const char* null = NULL;
(void)nullp;
(void)null;
EXPECT_DEATH((std::string_view(nullp)));
EXPECT_DEATH((std::string_view(null)));
EXPECT_DEATH(std::string_view(static_cast<const char*>(0)));
{
std::string_view v;
EXPECT_DEATH(((void)(v == nullp)));
EXPECT_DEATH(((void)(nullp == v)));
}
}
int main(int, char**) {
test_null_argument();
return 0;
}

libcxx/test/libcxx/debug/debug_abort.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
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// ADDITIONAL_COMPILE_FLAGS: -Wno-macro-redefined -D_LIBCPP_DEBUG=0
// UNSUPPORTED: libcxx-no-debug-mode // UNSUPPORTED: libcxx-no-debug-mode
// ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DEBUG=1
// Test that the default debug handler aborts the program. // Test that the default debug handler aborts the program.
#include <__assert> #include <__assert>
#include <csignal> #include <csignal>
#include <cstdlib> #include <cstdlib>
#include "test_macros.h" #include "test_macros.h"
Show All 14 Lines

libcxx/test/libcxx/debug/debug_helper_test.pass.cpp

  • This file was moved to libcxx/test/libcxx/debug/check_assertion_test.pass.cpp.

libcxx/test/libcxx/debug/debug_register.pass.cpp

  • This file was moved to libcxx/test/libcxx/debug/register_debug_handler.pass.cpp.

libcxx/test/libcxx/debug/register_debug_handler.pass.cpp

  • This file was moved from libcxx/test/libcxx/debug/debug_register.pass.cpp.
The contents of this file were not changed.

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

  • This file was moved from libcxx/test/libcxx/experimental/memory/memory.polymorphic.allocator.class/memory.polymorphic.allocator.mem/deallocate.assert.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
// <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: libcxx-no-debug-mode // UNSUPPORTED: c++03, windows, libcxx-no-debug-mode
// ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DEBUG=0
// ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DEBUG=1
#include <experimental/memory_resource> #include <experimental/memory_resource>
#include <type_traits> #include <type_traits>
#include <cassert> #include <cassert>
#include "check_assertion.h"
#include "test_memory_resource.h" #include "test_memory_resource.h"
#include "test_macros.h"
#include "debug_macros.h"
namespace ex = std::experimental::pmr; namespace ex = std::experimental::pmr;
int main(int, char**) int main(int, char**) {
{
using Alloc = ex::polymorphic_allocator<int>; using Alloc = ex::polymorphic_allocator<int>;
using Traits = std::allocator_traits<Alloc>; using Traits = std::allocator_traits<Alloc>;
NullResource R; NullResource R;
Alloc a(&R); Alloc a(&R);
const std::size_t maxSize = Traits::max_size(a); const std::size_t maxSize = Traits::max_size(a);
a.deallocate(nullptr, maxSize); // no assertion a.deallocate(nullptr, maxSize); // no assertion
TEST_LIBCPP_ASSERT_FAILURE(a.deallocate(nullptr, maxSize + 1), "deallocate called for size which exceeds max_size()"); TEST_LIBCPP_ASSERT_FAILURE(a.deallocate(nullptr, maxSize + 1), "deallocate called for size which exceeds max_size()");
return 0; return 0;
} }

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

  • This file was moved to libcxx/test/libcxx/experimental/memory/memory.polymorphic.allocator.class/memory.polymorphic.allocator.mem/assert.deallocate.pass.cpp.

libcxx/test/libcxx/experimental/memory/memory.resource.adaptor/memory.resource.adaptor.mem/assert.deallocate.pass.cpp

  • This file was moved from libcxx/test/libcxx/experimental/memory/memory.resource.adaptor/memory.resource.adaptor.mem/deallocate.assert.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
// <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: libcxx-no-debug-mode // UNSUPPORTED: c++03, windows, libcxx-no-debug-mode
// ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DEBUG=0
// ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DEBUG=1
#include <experimental/memory_resource> #include <experimental/memory_resource>
#include <type_traits> #include <type_traits>
#include <cassert> #include <cassert>
#include "check_assertion.h"
#include "test_memory_resource.h" #include "test_memory_resource.h"
#include "test_macros.h"
#include "debug_macros.h"
namespace ex = std::experimental::pmr; namespace ex = std::experimental::pmr;
int main(int, char**) int main(int, char**) {
{
using Alloc = NullAllocator<char>; using Alloc = NullAllocator<char>;
AllocController P; AllocController P;
ex::resource_adaptor<Alloc> r(Alloc{P}); ex::resource_adaptor<Alloc> r(Alloc{P});
ex::memory_resource & m1 = r; ex::memory_resource & m1 = r;
std::size_t maxSize = std::numeric_limits<std::size_t>::max() std::size_t maxSize = std::numeric_limits<std::size_t>::max()
- alignof(std::max_align_t); - alignof(std::max_align_t);
m1.deallocate(nullptr, maxSize); // no assertion m1.deallocate(nullptr, maxSize); // no assertion
TEST_LIBCPP_ASSERT_FAILURE(m1.deallocate(nullptr, maxSize + 1), "do_deallocate called for size which exceeds the maximum allocation size"); TEST_LIBCPP_ASSERT_FAILURE(m1.deallocate(nullptr, maxSize + 1), "do_deallocate called for size which exceeds the maximum allocation size");
return 0; return 0;
} }

libcxx/test/libcxx/experimental/memory/memory.resource.adaptor/memory.resource.adaptor.mem/deallocate.assert.pass.cpp

  • This file was moved to libcxx/test/libcxx/experimental/memory/memory.resource.adaptor/memory.resource.adaptor.mem/assert.deallocate.pass.cpp.

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

  • This file was moved from libcxx/test/libcxx/input.output/filesystems/class.path/path.itr/iterator_db.pass.cpp.
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// UNSUPPORTED: c++03 // UNSUPPORTED: c++03, windows, libcxx-no-debug-mode
// UNSUPPORTED: windows // ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DEBUG=0
// UNSUPPORTED: libcxx-no-debug-mode
// ADDITIONAL_COMPILE_FLAGS: -Wno-macro-redefined -D_LIBCPP_DEBUG=0
// <filesystem> // <filesystem>
// class path // class path
#include "filesystem_include.h" #include "filesystem_include.h"
#include <iterator> #include <iterator>
#include <type_traits> #include <type_traits>
#include <cassert> #include <cassert>
#include "test_macros.h" #include "check_assertion.h"
#include "debug_mode_helper.h"
int main(int, char**) { int main(int, char**) {
using namespace fs;
// Test incrementing/decrementing a singular iterator // Test incrementing/decrementing a singular iterator
{ {
path::iterator singular; fs::path::iterator singular;
EXPECT_DEATH( ++singular ); TEST_LIBCPP_ASSERT_FAILURE(++singular, "attempting to increment a singular iterator");
EXPECT_DEATH( --singular ); TEST_LIBCPP_ASSERT_FAILURE(--singular, "attempting to decrement a singular iterator");
} }
// Test decrementing the begin iterator
// Test incrementing the end iterator
{ {
path p("foo/bar"); fs::path p("foo/bar");
auto it = p.begin(); auto it = p.begin();
++it; TEST_LIBCPP_ASSERT_FAILURE(--it, "attempting to decrement the begin iterator");
++it;
EXPECT_DEATH( ++it );
} }
// Test incrementing the end iterator // Test incrementing the end iterator
{ {
path p("foo/bar"); fs::path p("foo/bar");
auto it = p.end(); auto it = p.end();
EXPECT_DEATH( ++it ); TEST_LIBCPP_ASSERT_FAILURE(++it, "attempting to increment the end iterator");
--it;
--it;
EXPECT_DEATH( --it );
} }
return 0; return 0;
} }

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

  • This file was moved to libcxx/test/libcxx/input.output/filesystems/class.path/path.itr/assert.iterator.pass.cpp.

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

  • This file was moved to libcxx/test/libcxx/iterators/assert.advance.pass.cpp.

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

  • This file was moved from libcxx/test/libcxx/iterators/advance.debug1.pass.cpp.
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// UNSUPPORTED: c++03 // UNSUPPORTED: c++03, windows, libcxx-no-debug-mode
// UNSUPPORTED: windows // ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DEBUG=0
// ADDITIONAL_COMPILE_FLAGS: -Wno-macro-redefined -D_LIBCPP_DEBUG=0
// UNSUPPORTED: libcxx-no-debug-mode
// <list> // <list>
// Call advance(non-bidi iterator, -1) // Call advance(non-bidi iterator, -1)
#include <iterator> #include <iterator>
#include "test_macros.h"
#include "debug_mode_helper.h"
#include "check_assertion.h"
#include "test_iterators.h" #include "test_iterators.h"
int main(int, char**) int main(int, char**) {
{
int a[] = {1, 2, 3}; int a[] = {1, 2, 3};
bidirectional_iterator<int *> bidi(a+1); bidirectional_iterator<int *> bidi(a+1);
std::advance(bidi, 1); // should work fine std::advance(bidi, 1); // should work fine
std::advance(bidi, 0); // should work fine std::advance(bidi, 0); // should work fine
std::advance(bidi, -1); // should work fine std::advance(bidi, -1); // should work fine
forward_iterator<int *> it(a+1); forward_iterator<int *> it(a+1);
std::advance(it, 1); // should work fine std::advance(it, 1); // should work fine
std::advance(it, 0); // should work fine std::advance(it, 0); // should work fine
EXPECT_DEATH( std::advance(it, -1) ); // can't go backwards on a FwdIter TEST_LIBCPP_ASSERT_FAILURE(std::advance(it, -1), "Attempt to advance(it, n) with negative n on a non-bidirectional iterator");
return 0; return 0;
} }

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

  • This file was moved from libcxx/test/libcxx/iterators/next.debug1.pass.cpp.
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// UNSUPPORTED: c++03 // UNSUPPORTED: c++03, windows, libcxx-no-debug-mode
// UNSUPPORTED: windows // ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DEBUG=0
// ADDITIONAL_COMPILE_FLAGS: -Wno-macro-redefined -D_LIBCPP_DEBUG=0
// UNSUPPORTED: libcxx-no-debug-mode
// <list> // <list>
// Call next(non-bidi iterator, -1) // Call next(non-bidi iterator, -1)
#include <iterator> #include <iterator>
#include "test_macros.h"
#include "debug_mode_helper.h"
#include "check_assertion.h"
#include "test_iterators.h" #include "test_iterators.h"
int main(int, char**) int main(int, char**) {
{
int a[] = {1, 2, 3}; int a[] = {1, 2, 3};
forward_iterator<int *> it(a+1); forward_iterator<int *> it(a+1);
std::next(it, 1); // should work fine std::next(it, 1); // should work fine
std::next(it, 0); // should work fine std::next(it, 0); // should work fine
EXPECT_DEATH( std::next(it, -1) ); // can't go backwards on a FwdIter TEST_LIBCPP_ASSERT_FAILURE(std::next(it, -1), "Attempt to next(it, n) with negative n on a non-bidirectional iterator");
return 0; return 0;
} }

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

  • This file was moved from libcxx/test/libcxx/iterators/prev.debug1.pass.cpp.
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// UNSUPPORTED: c++03 // UNSUPPORTED: c++03, windows, libcxx-no-debug-mode
// UNSUPPORTED: windows // ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DEBUG=0
// ADDITIONAL_COMPILE_FLAGS: -Wno-macro-redefined -D_LIBCPP_DEBUG=0
// UNSUPPORTED: libcxx-no-debug-mode
// <list> // <list>
// Call prev(forward_iterator, -1) // Call prev(forward_iterator, -1)
#include <iterator> #include <iterator>
#include "test_macros.h"
#include "debug_mode_helper.h"
#include "check_assertion.h"
#include "test_iterators.h" #include "test_iterators.h"
int main(int, char**) int main(int, char**) {
{
int a[] = {1, 2, 3}; int a[] = {1, 2, 3};
bidirectional_iterator<int *> bidi(a+1); bidirectional_iterator<int *> bidi(a+1);
std::prev(bidi, -1); // should work fine std::prev(bidi, -1); // should work fine
std::prev(bidi, 0); // should work fine std::prev(bidi, 0); // should work fine
std::prev(bidi, 1); // should work fine std::prev(bidi, 1); // should work fine
forward_iterator<int *> it(a+1); forward_iterator<int *> it(a+1);
std::prev(it, -1); // should work fine std::prev(it, -1); // should work fine
std::prev(it, 0); // should work fine std::prev(it, 0); // should work fine
EXPECT_DEATH( std::prev(it, 1) ); // can't go backwards on a FwdIter TEST_LIBCPP_ASSERT_FAILURE(std::prev(it, 1), "Attempt to prev(it, n) with a positive n on a non-bidirectional iterator");
return 0; return 0;
} }

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

  • This file was moved to libcxx/test/libcxx/iterators/assert.next.pass.cpp.

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

  • This file was moved to libcxx/test/libcxx/iterators/assert.prev.pass.cpp.

libcxx/test/libcxx/strings/basic.string/string.access/assert.back.pass.cpp

  • This file was moved from libcxx/test/libcxx/strings/basic.string/string.access/db_back_2.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: libcxx-no-debug-mode // UNSUPPORTED: c++03, windows, libcxx-no-debug-mode
// ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DEBUG=0
// ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DEBUG=1
#include <string> #include <string>
#include <cassert>
#include "test_macros.h" #include "check_assertion.h"
#include "debug_macros.h"
#include "min_allocator.h" #include "min_allocator.h"
int main(int, char**) { int main(int, char**) {
{
std::string s;
TEST_LIBCPP_ASSERT_FAILURE(s.back(), "string::back(): string is empty");
}
{
typedef std::basic_string<char, std::char_traits<char>, min_allocator<char> > S; typedef std::basic_string<char, std::char_traits<char>, min_allocator<char> > S;
S s(1, '\0'); S s;
assert(s.back() == 0);
s.clear();
TEST_LIBCPP_ASSERT_FAILURE(s.back(), "string::back(): string is empty"); TEST_LIBCPP_ASSERT_FAILURE(s.back(), "string::back(): string is empty");
}
return 0; return 0;
} }

libcxx/test/libcxx/strings/basic.string/string.access/assert.cback.pass.cpp

  • This file was moved from libcxx/test/libcxx/strings/basic.string/string.access/db_cback_2.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: libcxx-no-debug-mode // UNSUPPORTED: c++03, windows, libcxx-no-debug-mode
// ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DEBUG=0
// ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DEBUG=1
#include <string> #include <string>
#include "debug_macros.h" #include "check_assertion.h"
#include "test_macros.h"
#include "min_allocator.h" #include "min_allocator.h"
int main(int, char**) { int main(int, char**) {
{
std::string const s;
TEST_LIBCPP_ASSERT_FAILURE(s.back(), "string::back(): string is empty");
}
{
typedef std::basic_string<char, std::char_traits<char>, min_allocator<char> > S; typedef std::basic_string<char, std::char_traits<char>, min_allocator<char> > S;
const S s; const S s;
TEST_LIBCPP_ASSERT_FAILURE(s.back(), "string::back(): string is empty"); TEST_LIBCPP_ASSERT_FAILURE(s.back(), "string::back(): string is empty");
}
return 0; return 0;
} }

libcxx/test/libcxx/strings/basic.string/string.access/assert.cfront.pass.cpp

  • This file was moved from libcxx/test/libcxx/strings/basic.string/string.access/db_cfront_2.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: libcxx-no-debug-mode // UNSUPPORTED: c++03, windows, libcxx-no-debug-mode
// ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DEBUG=0
// ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DEBUG=1
#include <string> #include <string>
#include "debug_macros.h" #include "check_assertion.h"
#include "test_macros.h"
#include "min_allocator.h" #include "min_allocator.h"
int main(int, char**) { int main(int, char**) {
{
typedef std::string S;
const S s;
TEST_LIBCPP_ASSERT_FAILURE(s.front(), "string::front(): string is empty");
}
{
typedef std::basic_string<char, std::char_traits<char>, min_allocator<char> > S; typedef std::basic_string<char, std::char_traits<char>, min_allocator<char> > S;
const S s; const S s;
TEST_LIBCPP_ASSERT_FAILURE(s.front(), "string::front(): string is empty"); TEST_LIBCPP_ASSERT_FAILURE(s.front(), "string::front(): string is empty");
}
return 0; return 0;
} }

libcxx/test/libcxx/strings/basic.string/string.access/assert.cindex.pass.cpp

  • This file was moved from libcxx/test/libcxx/strings/basic.string/string.access/db_cindex_2.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: libcxx-no-debug-mode // UNSUPPORTED: c++03, windows, libcxx-no-debug-mode
// ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DEBUG=0
// ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DEBUG=1
#include <string> #include <string>
#include <cassert> #include <cassert>
#include "test_macros.h" #include "check_assertion.h"
#include "debug_macros.h"
#include "min_allocator.h" #include "min_allocator.h"
int main(int, char**) { int main(int, char**) {
{
typedef std::basic_string<char, std::char_traits<char>, min_allocator<char> > S; typedef std::basic_string<char, std::char_traits<char>, min_allocator<char> > S;
const S s; const S s;
assert(s[0] == 0); assert(s[0] == 0);
TEST_LIBCPP_ASSERT_FAILURE(s[1], "string index out of bounds"); TEST_LIBCPP_ASSERT_FAILURE(s[1], "string index out of bounds");
}
{
typedef std::string S;
const S s;
assert(s[0] == 0);
TEST_LIBCPP_ASSERT_FAILURE(s[1], "string index out of bounds");
}
return 0; return 0;
} }

libcxx/test/libcxx/strings/basic.string/string.access/assert.front.pass.cpp

  • This file was moved from libcxx/test/libcxx/strings/basic.string/string.access/db_front_2.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: libcxx-no-debug-mode // UNSUPPORTED: c++03, windows, libcxx-no-debug-mode
// ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DEBUG=0
// ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DEBUG=1
#include <string> #include <string>
#include <cassert> #include <cassert>
#include "test_macros.h" #include "check_assertion.h"
#include "debug_macros.h"
#include "min_allocator.h" #include "min_allocator.h"
int main(int, char**) { int main(int, char**) {
{
typedef std::string S;
S s;
TEST_LIBCPP_ASSERT_FAILURE(s.front(), "string::front(): string is empty");
}
{
typedef std::basic_string<char, std::char_traits<char>, min_allocator<char> > S; typedef std::basic_string<char, std::char_traits<char>, min_allocator<char> > S;
S s(1, '\0'); S s;
assert(s.front() == 0);
s.clear();
TEST_LIBCPP_ASSERT_FAILURE(s.front(), "string::front(): string is empty"); TEST_LIBCPP_ASSERT_FAILURE(s.front(), "string::front(): string is empty");
}
return 0; return 0;
} }

libcxx/test/libcxx/strings/basic.string/string.access/assert.index.pass.cpp

  • This file was moved from libcxx/test/libcxx/strings/basic.string/string.access/db_index_2.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: libcxx-no-debug-mode // UNSUPPORTED: c++03, windows, libcxx-no-debug-mode
// ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DEBUG=0
// ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DEBUG=1
#include <string> #include <string>
#include <cassert> #include <cassert>
#include "test_macros.h" #include "check_assertion.h"
#include "debug_macros.h"
#include "min_allocator.h" #include "min_allocator.h"
int main(int, char**) { int main(int, char**) {
{
typedef std::string S;
S s;
assert(s[0] == 0);
TEST_LIBCPP_ASSERT_FAILURE(s[1], "string index out of bounds");
}
{
typedef std::basic_string<char, std::char_traits<char>, min_allocator<char> > S; typedef std::basic_string<char, std::char_traits<char>, min_allocator<char> > S;
S s; S s;
assert(s[0] == 0); assert(s[0] == 0);
TEST_LIBCPP_ASSERT_FAILURE(s[1], "string index out of bounds"); TEST_LIBCPP_ASSERT_FAILURE(s[1], "string index out of bounds");
}
return 0; return 0;
} }

libcxx/test/libcxx/strings/basic.string/string.access/back.const.pass.cpp

  • This file was deleted.
//===----------------------------------------------------------------------===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
// <string>
// const charT& back() const;
// UNSUPPORTED: libcxx-no-debug-mode
// ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DEBUG=1
#include <string>
#include "test_macros.h"
#include "debug_macros.h"
int main(int, char**) {
std::string const s;
TEST_LIBCPP_ASSERT_FAILURE(s.back(), "string::back(): string is empty");
return 0;
}

libcxx/test/libcxx/strings/basic.string/string.access/back.pass.cpp

  • This file was deleted.
//===----------------------------------------------------------------------===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
// <string>
// charT& back();
// UNSUPPORTED: libcxx-no-debug-mode
// ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DEBUG=1
#include <string>
#include "test_macros.h"
#include "debug_macros.h"
int main(int, char**) {
std::string s;
TEST_LIBCPP_ASSERT_FAILURE(s.back(), "string::back(): string is empty");
return 0;
}

libcxx/test/libcxx/strings/basic.string/string.access/db_back.pass.cpp

  • This file was deleted.
//===----------------------------------------------------------------------===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
// <string>
// Call back() on empty container.
// UNSUPPORTED: libcxx-no-debug-mode
// ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DEBUG=1
#include <string>
#include <cassert>
#include "test_macros.h"
#include "debug_macros.h"
int main(int, char**) {
typedef std::string S;
S s(1, '\0');
assert(s.back() == 0);
s.clear();
TEST_LIBCPP_ASSERT_FAILURE(s.back(), "string::back(): string is empty");
return 0;
}

libcxx/test/libcxx/strings/basic.string/string.access/db_back_2.pass.cpp

  • This file was moved to libcxx/test/libcxx/strings/basic.string/string.access/assert.back.pass.cpp.

libcxx/test/libcxx/strings/basic.string/string.access/db_cback.pass.cpp

  • This file was deleted.
//===----------------------------------------------------------------------===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
// <string>
// Call back() on empty const container.
// UNSUPPORTED: libcxx-no-debug-mode
// ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DEBUG=1
#include <string>
#include "test_macros.h"
#include "debug_macros.h"
int main(int, char**) {
typedef std::string S;
const S s;
TEST_LIBCPP_ASSERT_FAILURE(s.back(), "string::back(): string is empty");
return 0;
}

libcxx/test/libcxx/strings/basic.string/string.access/db_cback_2.pass.cpp

  • This file was moved to libcxx/test/libcxx/strings/basic.string/string.access/assert.cback.pass.cpp.

libcxx/test/libcxx/strings/basic.string/string.access/db_cfront.pass.cpp

  • This file was deleted.
//===----------------------------------------------------------------------===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
// <string>
// Call front() on empty const container.
// UNSUPPORTED: libcxx-no-debug-mode
// ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DEBUG=1
#include <string>
#include "test_macros.h"
#include "debug_macros.h"
int main(int, char**) {
typedef std::string S;
const S s;
TEST_LIBCPP_ASSERT_FAILURE(s.front(), "string::front(): string is empty");
return 0;
}

libcxx/test/libcxx/strings/basic.string/string.access/db_cfront_2.pass.cpp

  • This file was moved to libcxx/test/libcxx/strings/basic.string/string.access/assert.cfront.pass.cpp.

libcxx/test/libcxx/strings/basic.string/string.access/db_cindex.pass.cpp

  • This file was deleted.
//===----------------------------------------------------------------------===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
// <string>
// Index const string out of bounds.
// UNSUPPORTED: libcxx-no-debug-mode
// ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DEBUG=1
#include <string>
#include <cassert>
#include "test_macros.h"
#include "debug_macros.h"
int main(int, char**) {
typedef std::string S;
const S s;
assert(s[0] == 0);
TEST_LIBCPP_ASSERT_FAILURE(s[1], "string index out of bounds");
return 0;
}

libcxx/test/libcxx/strings/basic.string/string.access/db_cindex_2.pass.cpp

  • This file was moved to libcxx/test/libcxx/strings/basic.string/string.access/assert.cindex.pass.cpp.

libcxx/test/libcxx/strings/basic.string/string.access/db_front.pass.cpp

  • This file was deleted.
//===----------------------------------------------------------------------===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
// <string>
// Call front() on empty container.
// UNSUPPORTED: libcxx-no-debug-mode
// ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DEBUG=1
#include <string>
#include <cassert>
#include "test_macros.h"
#include "debug_macros.h"
int main(int, char**) {
typedef std::string S;
S s(1, '\0');
assert(s.front() == 0);
s.clear();
TEST_LIBCPP_ASSERT_FAILURE(s.front(), "string::front(): string is empty");
return 0;
}

libcxx/test/libcxx/strings/basic.string/string.access/db_front_2.pass.cpp

  • This file was moved to libcxx/test/libcxx/strings/basic.string/string.access/assert.front.pass.cpp.

libcxx/test/libcxx/strings/basic.string/string.access/db_index.pass.cpp

  • This file was deleted.
//===----------------------------------------------------------------------===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
// <string>
// Index string out of bounds.
// UNSUPPORTED: libcxx-no-debug-mode
// ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DEBUG=1
#include <string>
#include <cassert>
#include "test_macros.h"
#include "debug_macros.h"
int main(int, char**) {
typedef std::string S;
S s;
assert(s[0] == 0);
TEST_LIBCPP_ASSERT_FAILURE(s[1], "string index out of bounds");
return 0;
}

libcxx/test/libcxx/strings/basic.string/string.access/db_index_2.pass.cpp

  • This file was moved to libcxx/test/libcxx/strings/basic.string/string.access/assert.index.pass.cpp.

libcxx/test/libcxx/strings/basic.string/string.access/front.const.pass.cpp

  • This file was deleted.
//===----------------------------------------------------------------------===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
// <string>
// const charT& front() const;
// UNSUPPORTED: libcxx-no-debug-mode
// ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DEBUG=1
#include <string>
#include "test_macros.h"
#include "debug_macros.h"
int main(int, char**) {
std::string const s;
TEST_LIBCPP_ASSERT_FAILURE(s.front(), "string::front(): string is empty");
return 0;
}

libcxx/test/libcxx/strings/basic.string/string.access/front.pass.cpp

  • This file was deleted.
//===----------------------------------------------------------------------===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
// <string>
// charT& front();
// UNSUPPORTED: libcxx-no-debug-mode
// ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DEBUG=1
#include <string>
#include "test_macros.h"
#include "debug_macros.h"
int main(int, char**) {
std::string s;
TEST_LIBCPP_ASSERT_FAILURE(s.front(), "string::front(): string is empty");
return 0;
}

libcxx/test/libcxx/strings/basic.string/string.access/index.const.pass.cpp

  • This file was deleted.
//===----------------------------------------------------------------------===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
// <string>
// const_reference operator[](size_type pos) const;
// UNSUPPORTED: libcxx-no-debug-mode
// ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DEBUG=1
#include <string>
#include <cassert>
#include "test_macros.h"
#include "debug_macros.h"
int main(int, char**) {
std::string const s;
char c = s[0];
assert(c == '\0');
TEST_LIBCPP_ASSERT_FAILURE(s[1], "string index out of bounds");
return 0;
}

libcxx/test/libcxx/strings/basic.string/string.access/index.pass.cpp

  • This file was deleted.
//===----------------------------------------------------------------------===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
// <string>
// reference operator[](size_type pos);
// UNSUPPORTED: libcxx-no-debug-mode
// ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DEBUG=1
#include <string>
#include <cassert>
#include "test_macros.h"
#include "debug_macros.h"
int main(int, char**) {
std::string s;
char c = s[0];
assert(c == '\0');
TEST_LIBCPP_ASSERT_FAILURE(s[1], "string index out of bounds");
return 0;
}

libcxx/test/libcxx/strings/basic.string/string.iterators/db_iterators_10.pass.cpp

  • This file was deleted.
//===----------------------------------------------------------------------===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
// <string>
// Subtract iterators from different containers with <.
// UNSUPPORTED: libcxx-no-debug-mode
// ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DEBUG=1
#include <string>
#include "test_macros.h"
#include "debug_macros.h"
#include "min_allocator.h"
int main(int, char**) {
typedef std::basic_string<char, std::char_traits<char>, min_allocator<char> > S;
S s1;
S s2;
TEST_LIBCPP_ASSERT_FAILURE(s1.begin() - s2.begin(), "Attempted to subtract incompatible iterators");
return 0;
}

libcxx/test/libcxx/strings/basic.string/string.iterators/db_iterators_11.pass.cpp

  • This file was moved to libcxx/test/libcxx/strings/basic.string/string.iterators/debug.iterator.index.pass.cpp.

libcxx/test/libcxx/strings/basic.string/string.iterators/db_iterators_12.pass.cpp

  • This file was deleted.
//===----------------------------------------------------------------------===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
// <string>
// Add to iterator out of bounds.
// UNSUPPORTED: libcxx-no-debug-mode
// ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DEBUG=1
#include <string>
#include <cassert>
#include "test_macros.h"
#include "debug_macros.h"
#include "min_allocator.h"
int main(int, char**) {
typedef std::basic_string<char, std::char_traits<char>, min_allocator<char> > C;
C c(1, '\0');
C::iterator i = c.begin();
i += 1;
assert(i == c.end());
i = c.begin();
TEST_LIBCPP_ASSERT_FAILURE(i += 2, "Attempted to add/subtract an iterator outside its valid range");
return 0;
}

libcxx/test/libcxx/strings/basic.string/string.iterators/db_iterators_13.pass.cpp

  • This file was moved to libcxx/test/libcxx/strings/basic.string/string.iterators/debug.iterator.decrement.pass.cpp.

libcxx/test/libcxx/strings/basic.string/string.iterators/db_iterators_14.pass.cpp

  • This file was deleted.
//===----------------------------------------------------------------------===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
// <string>
// Increment iterator past end.
// UNSUPPORTED: libcxx-no-debug-mode
// ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DEBUG=1
#include <string>
#include <cassert>
#include "test_macros.h"
#include "debug_macros.h"
#include "min_allocator.h"
int main(int, char**) {
typedef std::basic_string<char, std::char_traits<char>, min_allocator<char> > C;
C c(1, '\0');
C::iterator i = c.begin();
++i;
assert(i == c.end());
TEST_LIBCPP_ASSERT_FAILURE(++i, "Attempted to increment a non-incrementable iterator");
return 0;
}

libcxx/test/libcxx/strings/basic.string/string.iterators/db_iterators_15.pass.cpp

  • This file was deleted.
//===----------------------------------------------------------------------===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
// <string>
// Dereference non-dereferenceable iterator.
// UNSUPPORTED: libcxx-no-debug-mode
// ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DEBUG=1
#include <string>
#include "test_macros.h"
#include "debug_macros.h"
#include "min_allocator.h"
int main(int, char**) {
typedef std::basic_string<char, std::char_traits<char>, min_allocator<char> > C;
C c(1, '\0');
C::iterator i = c.end();
TEST_LIBCPP_ASSERT_FAILURE(*i, "Attempted to dereference a non-dereferenceable iterator");
return 0;
}

libcxx/test/libcxx/strings/basic.string/string.iterators/db_iterators_2.pass.cpp

  • This file was deleted.
//===----------------------------------------------------------------------===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
// <string>
// Compare iterators from different containers with <.
// UNSUPPORTED: libcxx-no-debug-mode
// ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DEBUG=1
#include <string>
#include "test_macros.h"
#include "debug_macros.h"
int main(int, char**) {
typedef std::string S;
S s1;
S s2;
TEST_LIBCPP_ASSERT_FAILURE(s1.begin() < s2.begin(), "Attempted to compare incomparable iterators");
return 0;
}

libcxx/test/libcxx/strings/basic.string/string.iterators/db_iterators_3.pass.cpp

  • This file was deleted.
//===----------------------------------------------------------------------===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
// <string>
// Subtract iterators from different containers with <.
// UNSUPPORTED: libcxx-no-debug-mode
// ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DEBUG=1
#include <string>
#include "test_macros.h"
#include "debug_macros.h"
int main(int, char**) {
typedef std::string S;
S s1;
S s2;
TEST_LIBCPP_ASSERT_FAILURE(s1.begin() - s2.begin(), "Attempted to subtract incompatible iterators");
return 0;
}

libcxx/test/libcxx/strings/basic.string/string.iterators/db_iterators_4.pass.cpp

  • This file was deleted.
//===----------------------------------------------------------------------===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
// <string>
// Index iterator out of bounds.
// UNSUPPORTED: libcxx-no-debug-mode
// ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DEBUG=1
#include <string>
#include <cassert>
#include "test_macros.h"
#include "debug_macros.h"
int main(int, char**) {
typedef std::string C;
C c(1, '\0');
C::iterator i = c.begin();
assert(i[0] == 0);
TEST_LIBCPP_ASSERT_FAILURE(i[1], "Attempted to subscript an iterator outside its valid range");
return 0;
}

libcxx/test/libcxx/strings/basic.string/string.iterators/db_iterators_5.pass.cpp

  • This file was deleted.
//===----------------------------------------------------------------------===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
// <string>
// Add to iterator out of bounds.
// UNSUPPORTED: libcxx-no-debug-mode
// ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DEBUG=1
#include <string>
#include <cassert>
#include "test_macros.h"
#include "debug_macros.h"
int main(int, char**) {
typedef std::string C;
C c(1, '\0');
C::iterator i = c.begin();
i += 1;
assert(i == c.end());
i = c.begin();
TEST_LIBCPP_ASSERT_FAILURE(i += 2, "Attempted to add/subtract an iterator outside its valid range");
return 0;
}

libcxx/test/libcxx/strings/basic.string/string.iterators/db_iterators_6.pass.cpp

  • This file was deleted.
//===----------------------------------------------------------------------===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
// <string>
// Decrement iterator prior to begin.
// UNSUPPORTED: libcxx-no-debug-mode
// ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DEBUG=1
#include <string>
#include <cassert>
#include "test_macros.h"
#include "debug_macros.h"
int main(int, char**) {
typedef std::string C;
C c(1, '\0');
C::iterator i = c.end();
--i;
assert(i == c.begin());
TEST_LIBCPP_ASSERT_FAILURE(--i, "Attempted to decrement a non-decrementable iterator");
return 0;
}

libcxx/test/libcxx/strings/basic.string/string.iterators/db_iterators_7.pass.cpp

  • This file was deleted.
//===----------------------------------------------------------------------===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
// <string>
// Increment iterator past end.
// UNSUPPORTED: libcxx-no-debug-mode
// ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DEBUG=1
#include <string>
#include <cassert>
#include "test_macros.h"
#include "debug_macros.h"
int main(int, char**) {
typedef std::string C;
C c(1, '\0');
C::iterator i = c.begin();
++i;
assert(i == c.end());
TEST_LIBCPP_ASSERT_FAILURE(++i, "Attempted to increment a non-incrementable iterator");
return 0;
}

libcxx/test/libcxx/strings/basic.string/string.iterators/db_iterators_8.pass.cpp

  • This file was deleted.
//===----------------------------------------------------------------------===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
// <string>
// Dereference non-dereferenceable iterator.
// UNSUPPORTED: libcxx-no-debug-mode
// ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DEBUG=1
#include <string>
#include "test_macros.h"
#include "debug_macros.h"
int main(int, char**) {
typedef std::string C;
C c(1, '\0');
C::iterator i = c.end();
TEST_LIBCPP_ASSERT_FAILURE(*i, "Attempted to dereference a non-dereferenceable iterator");
return 0;
}

libcxx/test/libcxx/strings/basic.string/string.iterators/db_iterators_9.pass.cpp

  • This file was moved to libcxx/test/libcxx/strings/basic.string/string.iterators/debug.iterator.compare.pass.cpp.

libcxx/test/libcxx/strings/basic.string/string.iterators/debug.iterator.add.pass.cpp

  • This file was added.
//===----------------------------------------------------------------------===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
// <string>
// Add to iterator out of bounds.
// UNSUPPORTED: libcxx-no-debug-mode, c++03, windows
// ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DEBUG=1
#include <string>
#include <cassert>
#include "check_assertion.h"
#include "min_allocator.h"
int main(int, char**) {
{
typedef std::string C;
C c(1, '\0');
C::iterator i = c.begin();
i += 1;
assert(i == c.end());
i = c.begin();
TEST_LIBCPP_ASSERT_FAILURE(i += 2, "Attempted to add/subtract an iterator outside its valid range");
}
{
typedef std::basic_string<char, std::char_traits<char>, min_allocator<char> > C;
C c(1, '\0');
C::iterator i = c.begin();
i += 1;
assert(i == c.end());
i = c.begin();
TEST_LIBCPP_ASSERT_FAILURE(i += 2, "Attempted to add/subtract an iterator outside its valid range");
}
return 0;
}

libcxx/test/libcxx/strings/basic.string/string.iterators/debug.iterator.compare.pass.cpp

  • This file was moved from libcxx/test/libcxx/strings/basic.string/string.iterators/db_iterators_9.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 // UNSUPPORTED: libcxx-no-debug-mode, c++03, windows
// ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DEBUG=1 // ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DEBUG=1
#include <string> #include <string>
#include "test_macros.h" #include "check_assertion.h"
#include "debug_macros.h"
#include "min_allocator.h" #include "min_allocator.h"
int main(int, char**) { int main(int, char**) {
{
typedef std::string S;
S s1;
S s2;
TEST_LIBCPP_ASSERT_FAILURE(s1.begin() < s2.begin(), "Attempted to compare incomparable iterators");
}
{
typedef std::basic_string<char, std::char_traits<char>, min_allocator<char> > S; typedef std::basic_string<char, std::char_traits<char>, min_allocator<char> > S;
S s1; S s1;
S s2; S s2;
TEST_LIBCPP_ASSERT_FAILURE(s1.begin() < s2.begin(), "Attempted to compare incomparable iterators"); TEST_LIBCPP_ASSERT_FAILURE(s1.begin() < s2.begin(), "Attempted to compare incomparable iterators");
}
return 0; return 0;
} }

libcxx/test/libcxx/strings/basic.string/string.iterators/debug.iterator.decrement.pass.cpp

  • This file was moved from libcxx/test/libcxx/strings/basic.string/string.iterators/db_iterators_13.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 // UNSUPPORTED: libcxx-no-debug-mode, c++03, windows
// ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DEBUG=1 // ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DEBUG=1
#include <string> #include <string>
#include <cassert> #include <cassert>
#include "test_macros.h" #include "check_assertion.h"
#include "debug_macros.h"
#include "min_allocator.h" #include "min_allocator.h"
int main(int, char**) { int main(int, char**) {
{
typedef std::string C;
C c(1, '\0');
C::iterator i = c.end();
--i;
assert(i == c.begin());
TEST_LIBCPP_ASSERT_FAILURE(--i, "Attempted to decrement a non-decrementable iterator");
}
{
typedef std::basic_string<char, std::char_traits<char>, min_allocator<char> > C; typedef std::basic_string<char, std::char_traits<char>, min_allocator<char> > C;
C c(1, '\0'); C c(1, '\0');
C::iterator i = c.end(); C::iterator i = c.end();
--i; --i;
assert(i == c.begin()); assert(i == c.begin());
TEST_LIBCPP_ASSERT_FAILURE(--i, "Attempted to decrement a non-decrementable iterator"); TEST_LIBCPP_ASSERT_FAILURE(--i, "Attempted to decrement a non-decrementable iterator");
}
return 0; return 0;
} }

libcxx/test/libcxx/strings/basic.string/string.iterators/debug.iterator.dereference.pass.cpp

  • This file was moved from libcxx/test/libcxx/containers/unord/unord.map/db_iterators_10.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> // <string>
// Dereference non-dereferenceable iterator. // Dereference non-dereferenceable iterator.
// UNSUPPORTED: libcxx-no-debug-mode // UNSUPPORTED: libcxx-no-debug-mode, c++03, windows
// UNSUPPORTED: c++03
// ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DEBUG=1 // ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DEBUG=1
#include <unordered_map>
#include <string> #include <string>
#include "test_macros.h" #include "check_assertion.h"
#include "debug_macros.h"
#include "min_allocator.h" #include "min_allocator.h"
int main(int, char**) { int main(int, char**) {
typedef std::unordered_map<int, std::string, std::hash<int>, std::equal_to<int>, {
min_allocator<std::pair<const int, std::string>>> C; typedef std::string C;
C c; C c(1, '\0');
c.insert(std::make_pair(1, "one"));
C::iterator i = c.end(); C::iterator i = c.end();
TEST_LIBCPP_ASSERT_FAILURE(*i, "Attempted to dereference a non-dereferenceable unordered container iterator"); TEST_LIBCPP_ASSERT_FAILURE(*i, "Attempted to dereference a non-dereferenceable iterator");
}
{
typedef std::basic_string<char, std::char_traits<char>, min_allocator<char> > C;
C c(1, '\0');
C::iterator i = c.end();
TEST_LIBCPP_ASSERT_FAILURE(*i, "Attempted to dereference a non-dereferenceable iterator");
}
return 0; return 0;
} }

libcxx/test/libcxx/strings/basic.string/string.iterators/debug.iterator.increment.pass.cpp

  • This file was moved from libcxx/test/libcxx/containers/unord/unord.multimap/db_iterators_9.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> // <string>
// Increment iterator past end. // Increment iterator past end.
// UNSUPPORTED: libcxx-no-debug-mode // UNSUPPORTED: libcxx-no-debug-mode, c++03, windows
// UNSUPPORTED: c++03
// ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DEBUG=1 // ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DEBUG=1
#include <cassert>
#include <string> #include <string>
#include <unordered_map> #include <cassert>
#include "test_macros.h" #include "check_assertion.h"
#include "debug_macros.h"
#include "min_allocator.h" #include "min_allocator.h"
int main(int, char**) { int main(int, char**) {
typedef std::unordered_multimap<int, std::string, std::hash<int>, std::equal_to<int>, {
min_allocator<std::pair<const int, std::string>>> C; typedef std::string C;
C c; C c(1, '\0');
c.insert(std::make_pair(1, "one"));
C::iterator i = c.begin(); C::iterator i = c.begin();
++i; ++i;
assert(i == c.end()); assert(i == c.end());
TEST_LIBCPP_ASSERT_FAILURE(++i, "Attempted to increment a non-incrementable unordered container iterator"); TEST_LIBCPP_ASSERT_FAILURE(++i, "Attempted to increment a non-incrementable iterator");
}
{
typedef std::basic_string<char, std::char_traits<char>, min_allocator<char> > C;
C c(1, '\0');
C::iterator i = c.begin();
++i;
assert(i == c.end());
TEST_LIBCPP_ASSERT_FAILURE(++i, "Attempted to increment a non-incrementable iterator");
}
return 0; return 0;
} }

libcxx/test/libcxx/strings/basic.string/string.iterators/debug.iterator.index.pass.cpp

  • This file was moved from libcxx/test/libcxx/strings/basic.string/string.iterators/db_iterators_11.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 // UNSUPPORTED: libcxx-no-debug-mode, c++03, windows
// ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DEBUG=1 // ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DEBUG=1
#include <string> #include <string>
#include <cassert> #include <cassert>
#include "test_macros.h" #include "check_assertion.h"
#include "debug_macros.h"
#include "min_allocator.h" #include "min_allocator.h"
int main(int, char**) { int main(int, char**) {
{
typedef std::string C;
C c(1, '\0');
C::iterator i = c.begin();
assert(i[0] == 0);
TEST_LIBCPP_ASSERT_FAILURE(i[1], "Attempted to subscript an iterator outside its valid range");
}
{
typedef std::basic_string<char, std::char_traits<char>, min_allocator<char> > C; typedef std::basic_string<char, std::char_traits<char>, min_allocator<char> > C;
C c(1, '\0'); C c(1, '\0');
C::iterator i = c.begin(); C::iterator i = c.begin();
assert(i[0] == 0); assert(i[0] == 0);
TEST_LIBCPP_ASSERT_FAILURE(i[1], "Attempted to subscript an iterator outside its valid range"); TEST_LIBCPP_ASSERT_FAILURE(i[1], "Attempted to subscript an iterator outside its valid range");
}
return 0; return 0;
} }

libcxx/test/libcxx/strings/basic.string/string.iterators/debug.iterator.subtract.pass.cpp

  • This file was moved from libcxx/test/libcxx/containers/sequences/vector/db_iterators_10.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> // <string>
// Subtract iterators from different containers. // Subtract iterators from different containers.
// UNSUPPORTED: libcxx-no-debug-mode // UNSUPPORTED: libcxx-no-debug-mode, c++03, windows
// ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DEBUG=1 // ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DEBUG=1
#include <vector> #include <string>
#include "test_macros.h" #include "check_assertion.h"
#include "debug_macros.h"
#include "min_allocator.h" #include "min_allocator.h"
int main(int, char**) { int main(int, char**) {
typedef int T; {
typedef std::vector<T, min_allocator<T> > C; typedef std::string S;
C c1; S s1;
C c2; S s2;
TEST_LIBCPP_ASSERT_FAILURE(c1.begin() - c2.begin(), "Attempted to subtract incompatible iterators"); TEST_LIBCPP_ASSERT_FAILURE(s1.begin() - s2.begin(), "Attempted to subtract incompatible iterators");
}
{
typedef std::basic_string<char, std::char_traits<char>, min_allocator<char> > S;
S s1;
S s2;
TEST_LIBCPP_ASSERT_FAILURE(s1.begin() - s2.begin(), "Attempted to subtract incompatible iterators");
}
return 0; return 0;
} }

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

  • This file was moved from libcxx/test/libcxx/strings/basic.string/string.modifiers/erase_iter_db1.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: libcxx-no-debug-mode // UNSUPPORTED: c++03, windows, libcxx-no-debug-mode
// ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DEBUG=0
// ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DEBUG=1
#include <string> #include <string>
#include "test_macros.h" #include "check_assertion.h"
#include "debug_macros.h" #include "min_allocator.h"
int main(int, char**) {
{
typedef std::basic_string<char, std::char_traits<char>, min_allocator<char> > S;
S l1("123");
S::const_iterator i = l1.end();
TEST_LIBCPP_ASSERT_FAILURE(l1.erase(i), "string::erase(iterator) called with a non-dereferenceable iterator");
}
int main(int, char**)
{ {
std::string l1("123"); std::string l1("123");
std::string::const_iterator i = l1.end(); std::string::const_iterator i = l1.end();
TEST_LIBCPP_ASSERT_FAILURE(l1.erase(i), "string::erase(iterator) called with a non-dereferenceable iterator"); TEST_LIBCPP_ASSERT_FAILURE(l1.erase(i), "string::erase(iterator) called with a non-dereferenceable iterator");
}
return 0; return 0;
} }

libcxx/test/libcxx/strings/basic.string/string.modifiers/assert.pop_back.pass.cpp

  • This file was moved from libcxx/test/libcxx/strings/basic.string/string.modifiers/erase_pop_back_db1.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: libcxx-no-debug-mode // UNSUPPORTED: c++03, windows, libcxx-no-debug-mode
// ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DEBUG=0
// ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DEBUG=1
#include <string> #include <string>
#include "test_macros.h" #include "check_assertion.h"
#include "debug_macros.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

  • This file was added.
//===----------------------------------------------------------------------===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
// <string>
// Call erase(const_iterator position) with an iterator from another container
// UNSUPPORTED: libcxx-no-debug-mode, c++03, windows
// ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DEBUG=1
#include <string>
#include "check_assertion.h"
#include "min_allocator.h"
int main(int, char**) {
{
std::string l1("123");
std::string l2("123");
std::string::const_iterator i = l2.begin();
TEST_LIBCPP_ASSERT_FAILURE(l1.erase(i), "string::erase(iterator) called with an iterator not referring to this string");
}
{
typedef std::basic_string<char, std::char_traits<char>, min_allocator<char> > S;
S l1("123");
S l2("123");
S::const_iterator i = l2.begin();
TEST_LIBCPP_ASSERT_FAILURE(l1.erase(i), "string::erase(iterator) called with an iterator not referring to this string");
}
return 0;
}

libcxx/test/libcxx/strings/basic.string/string.modifiers/debug.erase.iter_iter.pass.cpp

  • This file was added.
//===----------------------------------------------------------------------===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
// <string>
// Call erase(const_iterator first, const_iterator last); with invalid iterators
// UNSUPPORTED: libcxx-no-debug-mode, c++03, windows
// ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DEBUG=1
#include <string>
#include "check_assertion.h"
#include "min_allocator.h"
int main(int, char**) {
// With first iterator from another container
{
{
std::string l1("123");
std::string l2("123");
TEST_LIBCPP_ASSERT_FAILURE(
l1.erase(l2.cbegin(), l1.cbegin() + 1),
"string::erase(iterator, iterator) called with an iterator not referring to this string");
}
{
typedef std::basic_string<char, std::char_traits<char>, min_allocator<char> > S;
S l1("123");
S l2("123");
TEST_LIBCPP_ASSERT_FAILURE(l1.erase(l2.cbegin(), l1.cbegin() + 1),
"string::erase(iterator, iterator) called with an iterator not referring to this string");
}
}
// With second iterator from another container
{
{
std::string l1("123");
std::string l2("123");
TEST_LIBCPP_ASSERT_FAILURE(l1.erase(l1.cbegin(), l2.cbegin() + 1), "Attempted to compare incomparable iterators");
}
{
typedef std::basic_string<char, std::char_traits<char>, min_allocator<char> > S;
S l1("123");
S l2("123");
TEST_LIBCPP_ASSERT_FAILURE(l1.erase(l1.cbegin(), l2.cbegin() + 1), "Attempted to compare incomparable iterators");
}
}
// With both iterators from another container
{
{
std::string l1("123");
std::string l2("123");
TEST_LIBCPP_ASSERT_FAILURE(
l1.erase(l2.cbegin(), l2.cbegin() + 1),
"string::erase(iterator, iterator) called with an iterator not referring to this string");
}
{
typedef std::basic_string<char, std::char_traits<char>, min_allocator<char> > S;
S l1("123");
S l2("123");
TEST_LIBCPP_ASSERT_FAILURE(
l1.erase(l2.cbegin(), l2.cbegin() + 1),
"string::erase(iterator, iterator) called with an iterator not referring to this string");
}
}
// With an invalid range
{
{
std::string l1("123");
TEST_LIBCPP_ASSERT_FAILURE(l1.erase(l1.cbegin() + 1, l1.cbegin()),
"string::erase(first, last) called with invalid range");
}
{
typedef std::basic_string<char, std::char_traits<char>, min_allocator<char> > S;
S l1("123");
TEST_LIBCPP_ASSERT_FAILURE(l1.erase(l1.cbegin() + 1, l1.cbegin()),
"string::erase(first, last) called with invalid range");
}
}
return 0;
}

libcxx/test/libcxx/strings/basic.string/string.modifiers/debug.insert.iter_char.pass.cpp

  • This file was moved from libcxx/test/libcxx/strings/basic.string/string.modifiers/insert_iter_char_db1.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 // UNSUPPORTED: libcxx-no-debug-mode, c++03, windows
// 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
#include <string> #include <string>
#include "test_macros.h" #include "check_assertion.h"
#include "debug_macros.h"
int main(int, char**) int main(int, char**) {
{
typedef std::string S; typedef std::string S;
S s; S s;
S s2; S s2;
TEST_LIBCPP_ASSERT_FAILURE(s.insert(s2.begin(), '1'), TEST_LIBCPP_ASSERT_FAILURE(s.insert(s2.begin(), '1'),
"string::insert(iterator, character) called with an iterator not referring to this string"); "string::insert(iterator, character) called with an iterator not referring to this string");
return 0; return 0;
} }

libcxx/test/libcxx/strings/basic.string/string.modifiers/debug.insert.iter_iter_iter.pass.cpp

  • This file was moved from libcxx/test/libcxx/strings/basic.string/string.modifiers/insert_iter_iter_iter_db1.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 // UNSUPPORTED: libcxx-no-debug-mode, c++03, windows
// ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DEBUG=1 // ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DEBUG=1
#include <string> #include <string>
#include "test_macros.h" #include "check_assertion.h"
#include "debug_macros.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

  • This file was moved from libcxx/test/libcxx/strings/basic.string/string.modifiers/insert_iter_size_char_db1.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 // UNSUPPORTED: libcxx-no-debug-mode, c++03, windows
// ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DEBUG=1 // ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DEBUG=1
#include <string> #include <string>
#include "test_macros.h" #include "check_assertion.h"
#include "debug_macros.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/basic.string/string.modifiers/erase_iter_db1.pass.cpp

  • This file was moved to libcxx/test/libcxx/strings/basic.string/string.modifiers/assert.erase_iter.null.pass.cpp.

libcxx/test/libcxx/strings/basic.string/string.modifiers/erase_iter_db2.pass.cpp

  • This file was deleted.
//===----------------------------------------------------------------------===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
// <string>
// Call erase(const_iterator position) with iterator from another container
// UNSUPPORTED: libcxx-no-debug-mode
// ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DEBUG=1
#include <string>
#include "test_macros.h"
#include "debug_macros.h"
int main(int, char**)
{
std::string l1("123");
std::string l2("123");
std::string::const_iterator i = l2.begin();
TEST_LIBCPP_ASSERT_FAILURE(l1.erase(i),
"string::erase(iterator) called with an iterator not referring to this string");
return 0;
}

libcxx/test/libcxx/strings/basic.string/string.modifiers/erase_iter_db3.pass.cpp

  • This file was deleted.
//===----------------------------------------------------------------------===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
// <string>
// Call erase(const_iterator position) with end()
// UNSUPPORTED: libcxx-no-debug-mode
// ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DEBUG=1
#include <string>
#include "test_macros.h"
#include "debug_macros.h"
#include "min_allocator.h"
int main(int, char**) {
typedef std::basic_string<char, std::char_traits<char>, min_allocator<char> > S;
S l1("123");
S::const_iterator i = l1.end();
TEST_LIBCPP_ASSERT_FAILURE(l1.erase(i), "string::erase(iterator) called with a non-dereferenceable iterator");
return 0;
}

libcxx/test/libcxx/strings/basic.string/string.modifiers/erase_iter_db4.pass.cpp

  • This file was deleted.
//===----------------------------------------------------------------------===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
// <string>
// Call erase(const_iterator position) with iterator from another container
// UNSUPPORTED: libcxx-no-debug-mode
// ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DEBUG=1
#include <string>
#include "test_macros.h"
#include "debug_macros.h"
#include "min_allocator.h"
int main(int, char**) {
typedef std::basic_string<char, std::char_traits<char>, min_allocator<char> > S;
S l1("123");
S l2("123");
S::const_iterator i = l2.begin();
TEST_LIBCPP_ASSERT_FAILURE(l1.erase(i),
"string::erase(iterator) called with an iterator not referring to this string");
return 0;
}

libcxx/test/libcxx/strings/basic.string/string.modifiers/erase_iter_iter_db1.pass.cpp

  • This file was deleted.
//===----------------------------------------------------------------------===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
// <string>
// Call erase(const_iterator first, const_iterator last); with first iterator from another container
// UNSUPPORTED: libcxx-no-debug-mode
// ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DEBUG=1
#include <string>
#include "test_macros.h"
#include "debug_macros.h"
int main(int, char**)
{
std::string l1("123");
std::string l2("123");
TEST_LIBCPP_ASSERT_FAILURE(
l1.erase(l2.cbegin(), l1.cbegin() + 1),
"string::erase(iterator, iterator) called with an iterator not referring to this string");
return 0;
}

libcxx/test/libcxx/strings/basic.string/string.modifiers/erase_iter_iter_db2.pass.cpp

  • This file was deleted.
//===----------------------------------------------------------------------===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
// <string>
// Call erase(const_iterator first, const_iterator last); with second iterator from another container
// UNSUPPORTED: libcxx-no-debug-mode
// ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DEBUG=1
#include <string>
#include "test_macros.h"
#include "debug_macros.h"
int main(int, char**)
{
std::string l1("123");
std::string l2("123");
TEST_LIBCPP_ASSERT_FAILURE(l1.erase(l1.cbegin(), l2.cbegin() + 1), "Attempted to compare incomparable iterators");
return 0;
}

libcxx/test/libcxx/strings/basic.string/string.modifiers/erase_iter_iter_db3.pass.cpp

  • This file was deleted.
//===----------------------------------------------------------------------===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
// <string>
// Call erase(const_iterator first, const_iterator last); with both iterators from another container
// UNSUPPORTED: libcxx-no-debug-mode
// ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DEBUG=1
#include <string>
#include "test_macros.h"
#include "debug_macros.h"
int main(int, char**)
{
std::string l1("123");
std::string l2("123");
TEST_LIBCPP_ASSERT_FAILURE(
l1.erase(l2.cbegin(), l2.cbegin() + 1),
"string::erase(iterator, iterator) called with an iterator not referring to this string");
return 0;
}

libcxx/test/libcxx/strings/basic.string/string.modifiers/erase_iter_iter_db4.pass.cpp

  • This file was deleted.
//===----------------------------------------------------------------------===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
// <string>
// Call erase(const_iterator first, const_iterator last); with a bad range
// UNSUPPORTED: libcxx-no-debug-mode
// ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DEBUG=1
#include <string>
#include "test_macros.h"
#include "debug_macros.h"
int main(int, char**)
{
std::string l1("123");
TEST_LIBCPP_ASSERT_FAILURE(l1.erase(l1.cbegin() + 1, l1.cbegin()),
"string::erase(first, last) called with invalid range");
return 0;
}

libcxx/test/libcxx/strings/basic.string/string.modifiers/erase_iter_iter_db5.pass.cpp

  • This file was deleted.
//===----------------------------------------------------------------------===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
// <string>
// Call erase(const_iterator first, const_iterator last); with first iterator from another container
// UNSUPPORTED: libcxx-no-debug-mode
// ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DEBUG=1
#include <string>
#include "test_macros.h"
#include "debug_macros.h"
#include "min_allocator.h"
int main(int, char**) {
typedef std::basic_string<char, std::char_traits<char>, min_allocator<char> > S;
S l1("123");
S l2("123");
TEST_LIBCPP_ASSERT_FAILURE(l1.erase(l2.cbegin(), l1.cbegin() + 1),
"string::erase(iterator, iterator) called with an iterator not referring to this string");
return 0;
}

libcxx/test/libcxx/strings/basic.string/string.modifiers/erase_iter_iter_db6.pass.cpp

  • This file was deleted.
//===----------------------------------------------------------------------===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
// <string>
// Call erase(const_iterator first, const_iterator last); with second iterator from another container
// UNSUPPORTED: libcxx-no-debug-mode
// ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DEBUG=1
#include <string>
#include "test_macros.h"
#include "debug_macros.h"
#include "min_allocator.h"
int main(int, char**) {
typedef std::basic_string<char, std::char_traits<char>, min_allocator<char> > S;
S l1("123");
S l2("123");
TEST_LIBCPP_ASSERT_FAILURE(l1.erase(l1.cbegin(), l2.cbegin() + 1), "Attempted to compare incomparable iterators");
return 0;
}

libcxx/test/libcxx/strings/basic.string/string.modifiers/erase_iter_iter_db7.pass.cpp

  • This file was deleted.
//===----------------------------------------------------------------------===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
// <string>
// Call erase(const_iterator first, const_iterator last); with both iterators from another container
// UNSUPPORTED: libcxx-no-debug-mode
// ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DEBUG=1
#include <string>
#include "test_macros.h"
#include "debug_macros.h"
#include "min_allocator.h"
int main(int, char**) {
typedef std::basic_string<char, std::char_traits<char>, min_allocator<char> > S;
S l1("123");
S l2("123");
TEST_LIBCPP_ASSERT_FAILURE(l1.erase(l1.cbegin() + 1, l1.cbegin()),
"string::erase(first, last) called with invalid range");
return 0;
}

libcxx/test/libcxx/strings/basic.string/string.modifiers/erase_iter_iter_db8.pass.cpp

  • This file was deleted.
//===----------------------------------------------------------------------===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
// <string>
// Call erase(const_iterator first, const_iterator last); with a bad range
// UNSUPPORTED: libcxx-no-debug-mode
// ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DEBUG=1
#include <string>
#include "test_macros.h"
#include "debug_macros.h"
#include "min_allocator.h"
int main(int, char**) {
typedef std::basic_string<char, std::char_traits<char>, min_allocator<char> > S;
S l1("123");
TEST_LIBCPP_ASSERT_FAILURE(l1.erase(l1.cbegin() + 1, l1.cbegin()),
"string::erase(first, last) called with invalid range");
return 0;
}

libcxx/test/libcxx/strings/basic.string/string.modifiers/erase_pop_back_db1.pass.cpp

  • This file was moved to libcxx/test/libcxx/strings/basic.string/string.modifiers/assert.pop_back.pass.cpp.

libcxx/test/libcxx/strings/basic.string/string.modifiers/insert_iter_char_db1.pass.cpp

  • This file was moved to libcxx/test/libcxx/strings/basic.string/string.modifiers/debug.insert.iter_char.pass.cpp.

libcxx/test/libcxx/strings/basic.string/string.modifiers/insert_iter_iter_iter_db1.pass.cpp

  • This file was moved to libcxx/test/libcxx/strings/basic.string/string.modifiers/debug.insert.iter_iter_iter.pass.cpp.

libcxx/test/libcxx/strings/basic.string/string.modifiers/insert_iter_size_char_db1.pass.cpp

  • This file was moved to libcxx/test/libcxx/strings/basic.string/string.modifiers/debug.insert.iter_size_char.pass.cpp.

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

  • This file was added.
//===----------------------------------------------------------------------===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
// UNSUPPORTED: c++11, c++14
// UNSUPPORTED: c++03, windows, libcxx-no-debug-mode
// ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DEBUG=0
// Construct a string_view from a null pointer
// constexpr basic_string_view( const CharT* s );
#include <string_view>
#include "check_assertion.h"
int main(int, char**) {
TEST_LIBCPP_ASSERT_FAILURE(std::string_view((char const*)NULL), "null pointer passed to non-null argument of char_traits<...>::length");
TEST_LIBCPP_ASSERT_FAILURE(std::string_view((char const*)nullptr), "null pointer passed to non-null argument of char_traits<...>::length");
TEST_LIBCPP_ASSERT_FAILURE(std::string_view((char const*)0), "null pointer passed to non-null argument of char_traits<...>::length");
{
std::string_view v;
TEST_LIBCPP_ASSERT_FAILURE(v == (char const*)nullptr, "null pointer passed to non-null argument of char_traits<...>::length");
TEST_LIBCPP_ASSERT_FAILURE(v == (char const*)NULL, "null pointer passed to non-null argument of char_traits<...>::length");
TEST_LIBCPP_ASSERT_FAILURE((char const*)nullptr == v, "null pointer passed to non-null argument of char_traits<...>::length");
TEST_LIBCPP_ASSERT_FAILURE((char const*)NULL == v, "null pointer passed to non-null argument of char_traits<...>::length");
}
return 0;
}

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

  • This file was moved from libcxx/test/libcxx/thread/futures/futures.promise/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
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// UNSUPPORTED: windows
// UNSUPPORTED: libcpp-has-no-threads // UNSUPPORTED: libcpp-has-no-threads
// UNSUPPORTED: c++03
// UNSUPPORTED: libcxx-no-debug-mode
// ADDITIONAL_COMPILE_FLAGS: -Wno-macro-redefined -D_LIBCPP_DEBUG=0 // UNSUPPORTED: c++03, windows, libcxx-no-debug-mode
// ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DEBUG=0
// <future> // <future>
// class promise<R> // class promise<R>
// void set_exception(exception_ptr p); // void set_exception(exception_ptr p);
// Test that a null exception_ptr is diagnosed. // Test that a null exception_ptr is diagnosed.
#include <future> #include <future>
#include <exception> #include <exception>
#include <cstdlib>
#include <cassert>
#include "test_macros.h" #include "check_assertion.h"
#include "debug_mode_helper.h"
int main(int, char**) int main(int, char**) {
{
{ {
typedef int T; typedef int T;
std::promise<T> p; std::promise<T> p;
TEST_LIBCPP_ASSERT_FAILURE(p.set_exception(std::exception_ptr()), "promise::set_exception: received nullptr");
EXPECT_DEATH( p.set_exception(std::exception_ptr()) );
} }
{ {
typedef int& T; typedef int& T;
std::promise<T> p; std::promise<T> p;
TEST_LIBCPP_ASSERT_FAILURE(p.set_exception(std::exception_ptr()), "promise::set_exception: received nullptr");
EXPECT_DEATH( p.set_exception(std::exception_ptr()) );
} }
return 0; return 0;
} }

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

  • This file was moved from libcxx/test/libcxx/thread/futures/futures.promise/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
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// UNSUPPORTED: windows
// UNSUPPORTED: libcpp-has-no-threads // UNSUPPORTED: libcpp-has-no-threads
// UNSUPPORTED: c++03
// UNSUPPORTED: libcxx-no-debug-mode
// ADDITIONAL_COMPILE_FLAGS: -Wno-macro-redefined -D_LIBCPP_DEBUG=0 // UNSUPPORTED: c++03, windows, libcxx-no-debug-mode
// ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DEBUG=0
// <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);
// Test that a null exception_ptr is diagnosed. // Test that a null exception_ptr is diagnosed.
#include <future> #include <future>
#include <exception> #include <exception>
#include <cstdlib>
#include <cassert>
#include "test_macros.h"
#include "debug_mode_helper.h"
#include "check_assertion.h"
int main(int, char**) int main(int, char**) {
{
{ {
typedef int T; typedef int T;
std::promise<T> p; std::promise<T> p;
TEST_LIBCPP_ASSERT_FAILURE(p.set_exception_at_thread_exit(std::exception_ptr()), "promise::set_exception_at_thread_exit: received nullptr");
EXPECT_DEATH( p.set_exception_at_thread_exit(std::exception_ptr()) );
} }
{ {
typedef int& T; typedef int& T;
std::promise<T> p; std::promise<T> p;
TEST_LIBCPP_ASSERT_FAILURE(p.set_exception_at_thread_exit(std::exception_ptr()), "promise::set_exception_at_thread_exit: received nullptr");
EXPECT_DEATH( p.set_exception_at_thread_exit(std::exception_ptr()) );
} }
return 0; return 0;
} }

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

  • This file was moved to libcxx/test/libcxx/thread/futures/futures.promise/assert.set_exception.pass.cpp.

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

  • This file was moved to libcxx/test/libcxx/thread/futures/futures.promise/assert.set_exception_at_thread_exit.pass.cpp.

libcxx/test/libcxx/utilities/optional/optional.object/optional.object.observe/assert.dereference.pass.cpp

  • This file was added.
//===----------------------------------------------------------------------===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
// <optional>
// constexpr T& optional<T>::operator*() &;
// constexpr T&& optional<T>::operator*() &&;
// constexpr const T& optional<T>::operator*() const &;
// constexpr T&& optional<T>::operator*() const &&;
// UNSUPPORTED: c++11, c++14
// UNSUPPORTED: c++03, windows, libcxx-no-debug-mode
// ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DEBUG=0
#include <optional>
#include "check_assertion.h"
int main(int, char**) {
// &
{
std::optional<int> opt;
TEST_LIBCPP_ASSERT_FAILURE(*opt, "optional operator* called on a disengaged value");
}
// &&
{
std::optional<int> opt;
TEST_LIBCPP_ASSERT_FAILURE(*std::move(opt), "optional operator* called on a disengaged value");
}
// const &
{
const std::optional<int> opt;
TEST_LIBCPP_ASSERT_FAILURE(*opt, "optional operator* called on a disengaged value");
}
// const &&
{
const std::optional<int> opt;
TEST_LIBCPP_ASSERT_FAILURE(*std::move(opt), "optional operator* called on a disengaged value");
}
return 0;
}

libcxx/test/libcxx/utilities/optional/optional.object/optional.object.observe/assert.op_arrow.pass.cpp

  • This file was added.
//===----------------------------------------------------------------------===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
// <optional>
// constexpr T* optional<T>::operator->();
// constexpr const T* optional<T>::operator->() const;
// UNSUPPORTED: c++11, c++14
// UNSUPPORTED: c++03, windows, libcxx-no-debug-mode
// ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DEBUG=0
#include <optional>
#include "check_assertion.h"
struct X {
int test() const { return 3; }
};
int main(int, char**) {
{
std::optional<X> opt;
TEST_LIBCPP_ASSERT_FAILURE(opt->test(), "optional operator-> called on a disengaged value");
}
{
const std::optional<X> opt;
TEST_LIBCPP_ASSERT_FAILURE(opt->test(), "optional operator-> called on a disengaged value");
}
return 0;
}

libcxx/test/libcxx/utilities/optional/optional.object/optional.object.observe/dereference.pass.cpp

  • This file was deleted.
//===----------------------------------------------------------------------===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
// UNSUPPORTED: c++03, c++11, c++14
// <optional>
// constexpr T& optional<T>::operator*() &;
// UNSUPPORTED: libcxx-no-debug-mode
// ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DEBUG=1
#include <optional>
#include "test_macros.h"
#include "debug_macros.h"
int main(int, char**) {
std::optional<int> opt;
TEST_LIBCPP_ASSERT_FAILURE(*opt, "optional operator* called on a disengaged value");
return 0;
}

libcxx/test/libcxx/utilities/optional/optional.object/optional.object.observe/dereference_const.pass.cpp

  • This file was deleted.
//===----------------------------------------------------------------------===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
// UNSUPPORTED: c++03, c++11, c++14
// <optional>
// constexpr const T& optional<T>::operator*() const &;
// UNSUPPORTED: libcxx-no-debug-mode
// ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DEBUG=1
#include <optional>
#include "test_macros.h"
#include "debug_macros.h"
int main(int, char**) {
const std::optional<int> opt;
TEST_LIBCPP_ASSERT_FAILURE(*opt, "optional operator* called on a disengaged value");
return 0;
}

libcxx/test/libcxx/utilities/optional/optional.object/optional.object.observe/dereference_const_rvalue.pass.cpp

  • This file was deleted.
//===----------------------------------------------------------------------===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
// UNSUPPORTED: c++03, c++11, c++14
// <optional>
// constexpr T&& optional<T>::operator*() const &&;
// UNSUPPORTED: libcxx-no-debug-mode
// ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DEBUG=1
#include <optional>
#include "test_macros.h"
#include "debug_macros.h"
int main(int, char**) {
const std::optional<int> opt;
TEST_LIBCPP_ASSERT_FAILURE(*std::move(opt), "optional operator* called on a disengaged value");
return 0;
}

libcxx/test/libcxx/utilities/optional/optional.object/optional.object.observe/dereference_rvalue.pass.cpp

  • This file was deleted.
//===----------------------------------------------------------------------===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
// UNSUPPORTED: c++03, c++11, c++14
// <optional>
// constexpr T&& optional<T>::operator*() &&;
// UNSUPPORTED: libcxx-no-debug-mode
// ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DEBUG=1
#include <optional>
#include "test_macros.h"
#include "debug_macros.h"
int main(int, char**) {
std::optional<int> opt;
TEST_LIBCPP_ASSERT_FAILURE(*std::move(opt), "optional operator* called on a disengaged value");
return 0;
}

libcxx/test/libcxx/utilities/optional/optional.object/optional.object.observe/op_arrow.pass.cpp

  • This file was deleted.
//===----------------------------------------------------------------------===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
// UNSUPPORTED: c++03, c++11, c++14
// <optional>
// constexpr T* optional<T>::operator->();
// UNSUPPORTED: libcxx-no-debug-mode
// ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DEBUG=1
#include <optional>
#include "test_macros.h"
#include "debug_macros.h"
struct X {
int test() noexcept {return 3;}
};
int main(int, char**) {
std::optional<X> opt;
TEST_LIBCPP_ASSERT_FAILURE(opt->test(), "optional operator-> called on a disengaged value");
return 0;
}

libcxx/test/libcxx/utilities/optional/optional.object/optional.object.observe/op_arrow_const.pass.cpp

  • This file was deleted.
//===----------------------------------------------------------------------===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
// UNSUPPORTED: c++03, c++11, c++14
// <optional>
// constexpr const T* optional<T>::operator->() const;
// UNSUPPORTED: libcxx-no-debug-mode
// ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DEBUG=1
#include <optional>
#include "test_macros.h"
#include "debug_macros.h"
struct X {
int test() const {return 3;}
};
int main(int, char**) {
const std::optional<X> opt;
TEST_LIBCPP_ASSERT_FAILURE(opt->test(), "optional operator-> called on a disengaged value");
return 0;
}

libcxx/test/support/check_assertion.h

  • This file was moved from libcxx/test/support/debug_mode_helper.h.
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// 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
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#ifndef TEST_SUPPORT_DEBUG_MODE_HELPER_H #ifndef TEST_SUPPORT_CHECK_ASSERTION_H
#define TEST_SUPPORT_DEBUG_MODE_HELPER_H #define TEST_SUPPORT_CHECK_ASSERTION_H
#ifndef _LIBCPP_DEBUG #ifndef _LIBCPP_DEBUG
#error _LIBCPP_DEBUG must be defined before including this header #error _LIBCPP_DEBUG must be defined before including this header
#endif #endif
#include <ciso646> #include <ciso646>
#ifndef _LIBCPP_VERSION #ifndef _LIBCPP_VERSION
#error "This header may only be used for libc++ tests" #error "This header may only be used for libc++ tests"
▲ Show 20 Lines • Show All 270 Lines • ▼ Show 20 Linesinline bool ExpectDeath(const char* stmt, Func&& func) {
return ExpectDeath(stmt, func, AnyMatcher); return ExpectDeath(stmt, func, AnyMatcher);
} }
/// Assert that the specified expression throws a libc++ debug exception. /// Assert that the specified expression throws a libc++ debug exception.
#define EXPECT_DEATH(...) assert((ExpectDeath(#__VA_ARGS__, [&]() { __VA_ARGS__; } ))) #define EXPECT_DEATH(...) assert((ExpectDeath(#__VA_ARGS__, [&]() { __VA_ARGS__; } )))
#define EXPECT_DEATH_MATCHES(Matcher, ...) assert((ExpectDeath(#__VA_ARGS__, [&]() { __VA_ARGS__; }, Matcher))) #define EXPECT_DEATH_MATCHES(Matcher, ...) assert((ExpectDeath(#__VA_ARGS__, [&]() { __VA_ARGS__; }, Matcher)))
#endif // TEST_SUPPORT_DEBUG_MODE_HELPER_H #define TEST_LIBCPP_ASSERT_FAILURE(expr, message) assert((ExpectDeath(#expr, [&]() { (void)(expr); }, DebugInfoMatcher(message))))
#endif // TEST_SUPPORT_CHECK_ASSERTION_H

libcxx/test/support/container_debug_tests.h

Show All 18 Lines
#endif #endif
#include <__debug> #include <__debug>
#include <utility> #include <utility>
#include <cstddef> #include <cstddef>
#include <cstdlib> #include <cstdlib>
#include <cassert> #include <cassert>
#include "test_macros.h" #include "check_assertion.h"
#include "debug_mode_helper.h"
#include "test_allocator.h" #include "test_allocator.h"
#include "test_macros.h"
// These test make use of 'if constexpr'. // These test make use of 'if constexpr'.
#if TEST_STD_VER <= 14 #if TEST_STD_VER <= 14
#error This header may only be used in C++17 and greater #error This header may only be used in C++17 and greater
#endif #endif
namespace IteratorDebugChecks { namespace IteratorDebugChecks {
▲ Show 20 Lines • Show All 313 Lines • Show Last 20 Lines

libcxx/test/support/debug_macros.h

  • This file was deleted.
//===----------------------------------------------------------------------===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
#ifndef TEST_SUPPORT_DEBUG_MACROS_H
#define TEST_SUPPORT_DEBUG_MACROS_H
#include <__debug>
#include <cassert>
#include <string>
static const char* expected_libcpp_assert_message = 0;
static void test_debug_function(std::__libcpp_debug_info const& info) {
if (0 == std::strcmp(info.__msg_, expected_libcpp_assert_message))
std::exit(0);
std::fprintf(stderr, "%s\n", info.what().c_str());
std::abort();
}
#define TEST_LIBCPP_ASSERT_FAILURE(expr, m) \
do { \
::expected_libcpp_assert_message = m; \
std::__libcpp_set_debug_function(&::test_debug_function); \
(void)(expr); \
assert(false); \
} while (false)
#endif // TEST_SUPPORT_DEBUG_MACROS_H

libcxx/test/support/debug_mode_helper.h

  • This file was moved to libcxx/test/support/check_assertion.h.

libcxx/utils/libcxx/test/params.py

Show First 20 Lines • Show All 119 Lines • ▼ Show 20 Lines Parameter(name='enable_warnings', choices=[True, False], type=bool, default=True,
actions=lambda warnings: [] if not warnings else [ actions=lambda warnings: [] if not warnings else [
AddOptionalWarningFlag(w) for w in _warningFlags AddOptionalWarningFlag(w) for w in _warningFlags
]), ]),
Parameter(name='debug_level', choices=['', '0', '1'], type=str, default='', Parameter(name='debug_level', choices=['', '0', '1'], type=str, default='',
help="The debugging level to enable in the test suite.", help="The debugging level to enable in the test suite.",
actions=lambda debugLevel: [] if debugLevel == '' else filter(None, [ actions=lambda debugLevel: [] if debugLevel == '' else filter(None, [
AddFeature('debug_level={}'.format(debugLevel)), AddFeature('debug_level={}'.format(debugLevel)),
AddCompileFlag('-Wno-macro-redefined'),
AddCompileFlag('-D_LIBCPP_DEBUG={}'.format(debugLevel)), AddCompileFlag('-D_LIBCPP_DEBUG={}'.format(debugLevel)),
AddFeature('LIBCXX-DEBUG-FIXME') if debugLevel == '1' else None AddFeature('LIBCXX-DEBUG-FIXME') if debugLevel == '1' else None
])), ])),
Parameter(name='use_sanitizer', choices=['', 'Address', 'Undefined', 'Memory', 'MemoryWithOrigins', 'Thread', 'DataFlow', 'Leaks'], type=str, default='', Parameter(name='use_sanitizer', choices=['', 'Address', 'Undefined', 'Memory', 'MemoryWithOrigins', 'Thread', 'DataFlow', 'Leaks'], type=str, default='',
help="An optional sanitizer to enable when building and running the test suite.", help="An optional sanitizer to enable when building and running the test suite.",
actions=lambda sanitizer: filter(None, [ actions=lambda sanitizer: filter(None, [
AddFlag('-g -fno-omit-frame-pointer') if sanitizer else None, AddFlag('-g -fno-omit-frame-pointer') if sanitizer else None,
▲ Show 20 Lines • Show All 85 Lines • Show Last 20 Lines
libcxx/test/support/container_debug_tests.h