This is an archive of the discontinued LLVM Phabricator instance.

Differential D100592

[libcxx][test] Split off debug mode tests
ClosedPublic

Authored by krisb on Apr 15 2021, 12:17 PM.

Details

Reviewers
• Quuxplusone
ldionne
Group Reviewers
Restricted Project
Commits
rG90248f2daa05: [libcxx][test] Split off debug mode tests
Summary

This continues the work started by @ldionne in 2908eb20ba7.

The debug mode tests from

  • libcxx/containers/sequences/vector/
  • libcxx/strings/basic.string/string.access/
  • libcxx/strings/basic.string/string.iterators/

similarly contain two tests in every file making the second test never
run. The patch splits the tests into separate files.

Diff Detail

Event Timeline

krisb created this revision.Apr 15 2021, 12:17 PM
Herald added a subscriber: arphaman. · View Herald TranscriptApr 15 2021, 12:17 PM
krisb requested review of this revision.Apr 15 2021, 12:17 PM
Herald added a project: Restricted Project. · View Herald TranscriptApr 15 2021, 12:17 PM
Herald added a reviewer: Restricted Project. · View Herald Transcript
Herald added a subscriber: libcxx-commits. · View Herald Transcript
Harbormaster completed remote builds in B98992: Diff 337864.Apr 15 2021, 12:19 PM
krisb added a child revision: D100595: [libcxx][test] Attempt to make debug mode tests more bulletproof.Apr 15 2021, 12:42 PM
ldionne accepted this revision.Apr 15 2021, 1:44 PM

Thanks a lot for doing this! Assuming you didn't make any changes to the code itself, this LGTM.

Can you please rebase onto main and re-upload. That'll trigger the CI again and you can ship this once it is green. Thanks!

This revision is now accepted and ready to land.Apr 15 2021, 1:44 PM
• Quuxplusone accepted this revision.Apr 15 2021, 2:45 PM
• Quuxplusone added inline comments.
libcxx/test/libcxx/containers/sequences/vector/db_back.pass.cpp
32–33

IIUC, this can/should be simply

(void)c.back();  // expect this to exit
assert(false);

But as long as you fix it in D100595, it's no problem to leave it wonky in this commit.

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

Why is this test unsupported in C++03? Actually, what on earth is the point of this test?
I'm fine shipping this commit as-is, as long as we get to the bottom of it in D100595.
But I'd be happier with just git rm'ing this new file, because (unless I'm missing something) it's identical to db_iterators_2.pass.cpp except for the unneeded UNSUPPORTED line.

krisb added inline comments.Apr 19 2021, 5:24 AM
libcxx/test/libcxx/containers/sequences/vector/db_back.pass.cpp
32–33

Yes, I'd prefer to leave the changes like this for D100595.

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

Thanks for pointing to this.
I didn't think much about the tests themselves while creating this patch, just extracted the second part of each test to a separate file and automatically marked them UNSUPPORTED: c++03 because they were under #if TEST_STD_VER >= 11.
But you are right, we do not need UNSUPPORTED: c++03 here (and for all the similar tests), the tests work fine with c++03 as well as with other supported versions of the standard. I guess this code was under #if TEST_STD_VER >= 11 following min_allocator requirements, which needed c++11 or newer before D67675, but I didn't dig deeper to answer why min_allocator required c++ >= 11. I'll update the tests.

Actually, what on earth is the point of this test?

This test unlike db_iterators_2.pass.cpp constructs a basic_string with a custom allocator.
Basically, it follows the same pattern as other tests for containers (both normal and debug modes) where we have one test with default parameters and one with a custom allocator. So, I'd keep this test in.

krisb updated this revision to Diff 338491.Apr 19 2021, 5:26 AM

Remove 'UNSUPPORTED: c++03' where it isn't necessary.

ldionne accepted this revision.Apr 19 2021, 5:49 AM

Still LGTM

krisb mentioned this in D100595: [libcxx][test] Attempt to make debug mode tests more bulletproof.Apr 19 2021, 8:47 AM
Harbormaster completed remote builds in B99457: Diff 338491.Apr 19 2021, 9:33 AM
Closed by commit rG90248f2daa05: [libcxx][test] Split off debug mode tests (authored by krisb). · Explain WhyApr 20 2021, 3:00 AM
This revision was automatically updated to reflect the committed changes.
krisb added a commit: rG90248f2daa05: [libcxx][test] Split off debug mode tests.
krisb mentioned this in D102194: [libcxx][test] Split more debug mode tests.May 10 2021, 1:35 PM
krisb mentioned this in rGf8306647fa05: [libcxx][test] Split more debug mode tests.May 11 2021, 11:28 PM

Revision Contents

PathSize
libcxx/
test/
libcxx/
containers/
sequences/
vector/
35 lines
db_back_2.pass.cpp
db_cback.pass.cpp
30 lines
29 lines
db_cback_2.pass.cpp
db_cback.pass.cpp
26 lines
29 lines
db_cfront_2.pass.cpp
db_cfront.pass.cpp
26 lines
35 lines
db_front_2.pass.cpp
db_cback.pass.cpp
30 lines
35 lines
db_index_2.pass.cpp
db_cback.pass.cpp
30 lines
db_iterators_10.pass.cpp
db_iterators_3.pass.cpp
30 lines
db_iterators_11.pass.cpp
db_cback.pass.cpp
30 lines
db_iterators_12.pass.cpp
db_cback.pass.cpp
32 lines
db_iterators_13.pass.cpp
db_cback.pass.cpp
31 lines
db_iterators_14.pass.cpp
db_cback.pass.cpp
31 lines
db_iterators_15.pass.cpp
db_iterators_8.pass.cpp
30 lines
33 lines
33 lines
35 lines
41 lines
38 lines
38 lines
33 lines
db_iterators_9.pass.cpp
db_iterators_2.pass.cpp
30 lines
strings/
basic.string/
string.access/
32 lines
db_back_2.pass.cpp
db_cback.pass.cpp
27 lines
26 lines
db_cback_2.pass.cpp
db_cback.pass.cpp
23 lines
26 lines
db_cfront_2.pass.cpp
db_cfront.pass.cpp
23 lines
29 lines
db_cindex_2.pass.cpp
db_cindex.pass.cpp
26 lines
32 lines
db_front_2.pass.cpp
db_cback.pass.cpp
27 lines
29 lines
db_index_2.pass.cpp
db_index.pass.cpp
26 lines
string.iterators/
db_iterators_10.pass.cpp
db_iterators_3.pass.cpp
29 lines
db_iterators_15.pass.cpp
db_iterators_8.pass.cpp
26 lines
32 lines
32 lines
32 lines
38 lines
35 lines
35 lines
29 lines
db_iterators_9.pass.cpp
db_iterators_2.pass.cpp
29 lines
string.iterators/
string.access/
db_iterators_11.pass.cpp
db_cback.pass.cpp
27 lines
db_iterators_12.pass.cpp
db_cback.pass.cpp
29 lines
db_iterators_13.pass.cpp
db_cback.pass.cpp
28 lines
db_iterators_14.pass.cpp
db_cback.pass.cpp
28 lines

Diff 338491

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

Show All 16 Lines
#include <vector> #include <vector>
#include <cassert> #include <cassert>
#include <iterator> #include <iterator>
#include <exception> #include <exception>
#include <cstdlib> #include <cstdlib>
#include "test_macros.h" #include "test_macros.h"
#include "min_allocator.h"
int main(int, char**) int main(int, char**) {
{
{
typedef int T; typedef int T;
typedef std::vector<T> C; typedef std::vector<T> C;
C c(1); C c(1);
assert(c.back() == 0); assert(c.back() == 0);
c.clear(); c.clear();
assert(c.back() == 0); assert(c.back() == 0);
assert(false); assert(false);
QuuxplusoneUnsubmitted
Not Done
ReplyInline Actions

IIUC, this can/should be simply

(void)c.back();  // expect this to exit
assert(false);

But as long as you fix it in D100595, it's no problem to leave it wonky in this commit.

Quuxplusone: IIUC, this can/should be simply ``` (void)c.back(); // expect this to exit assert(false); ```…
krisbAuthorUnsubmitted
Done
ReplyInline Actions

Yes, I'd prefer to leave the changes like this for D100595.

krisb: Yes, I'd prefer to leave the changes like this for D100595.
}
#if TEST_STD_VER >= 11 return 0;
{
typedef int T;
typedef std::vector<T, min_allocator<T>> C;
C c(1);
assert(c.back() == 0);
c.clear();
assert(c.back() == 0);
assert(false);
}
#endif
} }

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

  • This file was copied from libcxx/test/libcxx/containers/sequences/vector/db_cback.pass.cpp.
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// <vector> // <vector>
// Call back() on empty const container. // Call back() on empty container.
// UNSUPPORTED: libcxx-no-debug-mode // UNSUPPORTED: libcxx-no-debug-mode
// ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DEBUG=1 // ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DEBUG=1
#define _LIBCPP_ASSERT(x, m) ((x) ? (void)0 : std::exit(0)) #define _LIBCPP_ASSERT(x, m) ((x) ? (void)0 : std::exit(0))
#include <vector> #include <vector>
#include <cassert> #include <cassert>
#include <iterator> #include <iterator>
#include <exception> #include <exception>
#include <cstdlib> #include <cstdlib>
#include "test_macros.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 std::vector<T> C;
const C c;
assert(c.back() == 0);
assert(false);
}
#if TEST_STD_VER >= 11
{
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; C c(1);
assert(c.back() == 0);
c.clear();
assert(c.back() == 0); assert(c.back() == 0);
assert(false); assert(false);
}
#endif return 0;
} }

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

  • This file was copied to libcxx/test/libcxx/containers/sequences/vector/db_back_2.pass.cpp, libcxx/test/libcxx/containers/sequences/vector/db_cback_2.pass.cpp, libcxx/test/libcxx/containers/sequences/vector/db_front_2.pass.cpp, libcxx/test/libcxx/containers/sequences/vector/db_index_2.pass.cpp, libcxx/test/libcxx/containers/sequences/vector/db_iterators_11.pass.cpp, libcxx/test/libcxx/containers/sequences/vector/db_iterators_12.pass.cpp, libcxx/test/libcxx/containers/sequences/vector/db_iterators_13.pass.cpp, libcxx/test/libcxx/containers/sequences/vector/db_iterators_14.pass.cpp.
Show All 16 Lines
#include <vector> #include <vector>
#include <cassert> #include <cassert>
#include <iterator> #include <iterator>
#include <exception> #include <exception>
#include <cstdlib> #include <cstdlib>
#include "test_macros.h" #include "test_macros.h"
#include "min_allocator.h"
int main(int, char**) int main(int, char**) {
{
{
typedef int T; typedef int T;
typedef std::vector<T> C; typedef std::vector<T> C;
const C c; const C c;
assert(c.back() == 0); assert(c.back() == 0);
assert(false); assert(false);
}
#if TEST_STD_VER >= 11 return 0;
{
typedef int T;
typedef std::vector<T, min_allocator<T>> C;
const C c;
assert(c.back() == 0);
assert(false);
}
#endif
} }

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

  • This file was copied from libcxx/test/libcxx/containers/sequences/vector/db_cback.pass.cpp.
Show All 18 Lines
#include <cassert> #include <cassert>
#include <iterator> #include <iterator>
#include <exception> #include <exception>
#include <cstdlib> #include <cstdlib>
#include "test_macros.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 std::vector<T> C;
const C c;
assert(c.back() == 0);
assert(false);
}
#if TEST_STD_VER >= 11
{
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;
assert(c.back() == 0); assert(c.back() == 0);
assert(false); assert(false);
}
#endif return 0;
} }

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

  • This file was copied to libcxx/test/libcxx/containers/sequences/vector/db_cfront_2.pass.cpp.
Show All 16 Lines
#include <vector> #include <vector>
#include <cassert> #include <cassert>
#include <iterator> #include <iterator>
#include <exception> #include <exception>
#include <cstdlib> #include <cstdlib>
#include "test_macros.h" #include "test_macros.h"
#include "min_allocator.h"
int main(int, char**) int main(int, char**) {
{
{
typedef int T; typedef int T;
typedef std::vector<T> C; typedef std::vector<T> C;
const C c; const C c;
assert(c.front() == 0); assert(c.front() == 0);
assert(false); assert(false);
}
#if TEST_STD_VER >= 11 return 0;
{
typedef int T;
typedef std::vector<T, min_allocator<T>> C;
const C c;
assert(c.front() == 0);
assert(false);
}
#endif
} }

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

  • This file was copied from libcxx/test/libcxx/containers/sequences/vector/db_cfront.pass.cpp.
Show All 18 Lines
#include <cassert> #include <cassert>
#include <iterator> #include <iterator>
#include <exception> #include <exception>
#include <cstdlib> #include <cstdlib>
#include "test_macros.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 std::vector<T> C;
const C c;
assert(c.front() == 0);
assert(false);
}
#if TEST_STD_VER >= 11
{
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;
assert(c.front() == 0); assert(c.front() == 0);
assert(false); assert(false);
}
#endif return 0;
} }

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

Show All 16 Lines
#include <vector> #include <vector>
#include <cassert> #include <cassert>
#include <iterator> #include <iterator>
#include <exception> #include <exception>
#include <cstdlib> #include <cstdlib>
#include "test_macros.h" #include "test_macros.h"
#include "min_allocator.h"
int main(int, char**) int main(int, char**) {
{
{
typedef int T; typedef int T;
typedef std::vector<T> C; typedef std::vector<T> C;
C c(1); C c(1);
assert(c.front() == 0); assert(c.front() == 0);
c.clear(); c.clear();
assert(c.front() == 0); assert(c.front() == 0);
assert(false); assert(false);
}
#if TEST_STD_VER >= 11 return 0;
{
typedef int T;
typedef std::vector<T, min_allocator<T>> C;
C c(1);
assert(c.front() == 0);
c.clear();
assert(c.front() == 0);
assert(false);
}
#endif
} }

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

  • This file was copied from libcxx/test/libcxx/containers/sequences/vector/db_cback.pass.cpp.
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// <vector> // <vector>
// Call back() on empty const container. // Call front() on empty container.
// UNSUPPORTED: libcxx-no-debug-mode // UNSUPPORTED: libcxx-no-debug-mode
// ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DEBUG=1 // ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DEBUG=1
#define _LIBCPP_ASSERT(x, m) ((x) ? (void)0 : std::exit(0)) #define _LIBCPP_ASSERT(x, m) ((x) ? (void)0 : std::exit(0))
#include <vector> #include <vector>
#include <cassert> #include <cassert>
#include <iterator> #include <iterator>
#include <exception> #include <exception>
#include <cstdlib> #include <cstdlib>
#include "test_macros.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 std::vector<T> C;
const C c;
assert(c.back() == 0);
assert(false);
}
#if TEST_STD_VER >= 11
{
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; C c(1);
assert(c.back() == 0); assert(c.front() == 0);
c.clear();
assert(c.front() == 0);
assert(false); assert(false);
}
#endif return 0;
} }

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

Show All 16 Lines
#include <vector> #include <vector>
#include <cassert> #include <cassert>
#include <iterator> #include <iterator>
#include <exception> #include <exception>
#include <cstdlib> #include <cstdlib>
#include "test_macros.h" #include "test_macros.h"
#include "min_allocator.h"
int main(int, char**) int main(int, char**) {
{
{
typedef int T; typedef int T;
typedef std::vector<T> C; typedef std::vector<T> C;
C c(1); C c(1);
assert(c[0] == 0); assert(c[0] == 0);
c.clear(); c.clear();
assert(c[0] == 0); assert(c[0] == 0);
assert(false); assert(false);
}
#if TEST_STD_VER >= 11 return 0;
{
typedef int T;
typedef std::vector<T, min_allocator<T>> C;
C c(1);
assert(c[0] == 0);
c.clear();
assert(c[0] == 0);
assert(false);
}
#endif
} }

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

  • This file was copied from libcxx/test/libcxx/containers/sequences/vector/db_cback.pass.cpp.
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// <vector> // <vector>
// Call back() on empty const container. // Index vector out of bounds.
// UNSUPPORTED: libcxx-no-debug-mode // UNSUPPORTED: libcxx-no-debug-mode
// ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DEBUG=1 // ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DEBUG=1
#define _LIBCPP_ASSERT(x, m) ((x) ? (void)0 : std::exit(0)) #define _LIBCPP_ASSERT(x, m) ((x) ? (void)0 : std::exit(0))
#include <vector> #include <vector>
#include <cassert> #include <cassert>
#include <iterator> #include <iterator>
#include <exception> #include <exception>
#include <cstdlib> #include <cstdlib>
#include "test_macros.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 std::vector<T> C;
const C c;
assert(c.back() == 0);
assert(false);
}
#if TEST_STD_VER >= 11
{
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; C c(1);
assert(c.back() == 0); assert(c[0] == 0);
c.clear();
assert(c[0] == 0);
assert(false); assert(false);
}
#endif return 0;
} }

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

  • This file was copied from libcxx/test/libcxx/containers/sequences/vector/db_iterators_3.pass.cpp.
Show All 18 Lines
#include <cassert> #include <cassert>
#include <iterator> #include <iterator>
#include <exception> #include <exception>
#include <cstdlib> #include <cstdlib>
#include "test_macros.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 std::vector<T> C;
C c1;
C c2;
int i = c1.begin() - c2.begin(); (void)i;
assert(false);
}
#if TEST_STD_VER >= 11
{
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;
int i = c1.begin() - c2.begin(); (void)i; int i = c1.begin() - c2.begin();
(void)i;
assert(false); assert(false);
}
#endif return 0;
} }

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

  • This file was copied from libcxx/test/libcxx/containers/sequences/vector/db_cback.pass.cpp.
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// <vector> // <vector>
// Call back() on empty const container. // Index iterator out of bounds.
// UNSUPPORTED: libcxx-no-debug-mode // UNSUPPORTED: libcxx-no-debug-mode
// ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DEBUG=1 // ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DEBUG=1
#define _LIBCPP_ASSERT(x, m) ((x) ? (void)0 : std::exit(0)) #define _LIBCPP_ASSERT(x, m) ((x) ? (void)0 : std::exit(0))
#include <vector> #include <vector>
#include <cassert> #include <cassert>
#include <iterator> #include <iterator>
#include <exception> #include <exception>
#include <cstdlib> #include <cstdlib>
#include "test_macros.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 std::vector<T> C;
const C c;
assert(c.back() == 0);
assert(false);
}
#if TEST_STD_VER >= 11
{
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; C c(1);
assert(c.back() == 0); C::iterator i = c.begin();
assert(i[0] == 0);
assert(i[1] == 0);
assert(false); assert(false);
}
#endif return 0;
} }

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

  • This file was copied from libcxx/test/libcxx/containers/sequences/vector/db_cback.pass.cpp.
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// <vector> // <vector>
// Call back() on empty const container. // Add to iterator out of bounds.
// UNSUPPORTED: libcxx-no-debug-mode // UNSUPPORTED: libcxx-no-debug-mode
// ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DEBUG=1 // ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DEBUG=1
#define _LIBCPP_ASSERT(x, m) ((x) ? (void)0 : std::exit(0)) #define _LIBCPP_ASSERT(x, m) ((x) ? (void)0 : std::exit(0))
#include <vector> #include <vector>
#include <cassert> #include <cassert>
#include <iterator> #include <iterator>
#include <exception> #include <exception>
#include <cstdlib> #include <cstdlib>
#include "test_macros.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 std::vector<T> C;
const C c;
assert(c.back() == 0);
assert(false);
}
#if TEST_STD_VER >= 11
{
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; C c(1);
assert(c.back() == 0); C::iterator i = c.begin();
i += 1;
assert(i == c.end());
i = c.begin();
i += 2;
assert(false); assert(false);
}
#endif return 0;
} }

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

  • This file was copied from libcxx/test/libcxx/containers/sequences/vector/db_cback.pass.cpp.
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// <vector> // <vector>
// Call back() on empty const container. // Decrement iterator prior to begin.
// UNSUPPORTED: libcxx-no-debug-mode // UNSUPPORTED: libcxx-no-debug-mode
// ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DEBUG=1 // ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DEBUG=1
#define _LIBCPP_ASSERT(x, m) ((x) ? (void)0 : std::exit(0)) #define _LIBCPP_ASSERT(x, m) ((x) ? (void)0 : std::exit(0))
#include <vector> #include <vector>
#include <cassert> #include <cassert>
#include <iterator> #include <iterator>
#include <exception> #include <exception>
#include <cstdlib> #include <cstdlib>
#include "test_macros.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 std::vector<T> C;
const C c;
assert(c.back() == 0);
assert(false);
}
#if TEST_STD_VER >= 11
{
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; C c(1);
assert(c.back() == 0); C::iterator i = c.end();
--i;
assert(i == c.begin());
--i;
assert(false); assert(false);
}
#endif return 0;
} }

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

  • This file was copied from libcxx/test/libcxx/containers/sequences/vector/db_cback.pass.cpp.
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// <vector> // <vector>
// Call back() on empty const container. // Increment iterator past end.
// UNSUPPORTED: libcxx-no-debug-mode // UNSUPPORTED: libcxx-no-debug-mode
// ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DEBUG=1 // ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DEBUG=1
#define _LIBCPP_ASSERT(x, m) ((x) ? (void)0 : std::exit(0)) #define _LIBCPP_ASSERT(x, m) ((x) ? (void)0 : std::exit(0))
#include <vector> #include <vector>
#include <cassert> #include <cassert>
#include <iterator> #include <iterator>
#include <exception> #include <exception>
#include <cstdlib> #include <cstdlib>
#include "test_macros.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 std::vector<T> C;
const C c;
assert(c.back() == 0);
assert(false);
}
#if TEST_STD_VER >= 11
{
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; C c(1);
assert(c.back() == 0); C::iterator i = c.begin();
++i;
assert(i == c.end());
++i;
assert(false); assert(false);
}
#endif return 0;
} }

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

  • This file was copied from libcxx/test/libcxx/containers/sequences/vector/db_iterators_8.pass.cpp.
Show All 18 Lines
#include <cassert> #include <cassert>
#include <iterator> #include <iterator>
#include <exception> #include <exception>
#include <cstdlib> #include <cstdlib>
#include "test_macros.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 std::vector<T> C;
C c(1);
C::iterator i = c.end();
T j = *i; (void)j;
assert(false);
}
#if TEST_STD_VER >= 11
{
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();
T j = *i; (void)j; T j = *i;
(void)j;
assert(false); assert(false);
}
#endif return 0;
} }

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

  • This file was copied to libcxx/test/libcxx/containers/sequences/vector/db_iterators_9.pass.cpp.
Show All 16 Lines
#include <vector> #include <vector>
#include <cassert> #include <cassert>
#include <iterator> #include <iterator>
#include <exception> #include <exception>
#include <cstdlib> #include <cstdlib>
#include "test_macros.h" #include "test_macros.h"
#include "min_allocator.h"
int main(int, char**) int main(int, char**) {
{
{
typedef int T; typedef int T;
typedef std::vector<T> C; typedef std::vector<T> C;
C c1; C c1;
C c2; C c2;
bool b = c1.begin() < c2.begin(); (void)b; bool b = c1.begin() < c2.begin();
(void)b;
assert(false); assert(false);
}
#if TEST_STD_VER >= 11 return 0;
{
typedef int T;
typedef std::vector<T, min_allocator<T>> C;
C c1;
C c2;
bool b = c1.begin() < c2.begin(); (void)b;
assert(false);
}
#endif
} }

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

  • This file was copied to libcxx/test/libcxx/containers/sequences/vector/db_iterators_10.pass.cpp.
Show All 16 Lines
#include <vector> #include <vector>
#include <cassert> #include <cassert>
#include <iterator> #include <iterator>
#include <exception> #include <exception>
#include <cstdlib> #include <cstdlib>
#include "test_macros.h" #include "test_macros.h"
#include "min_allocator.h"
int main(int, char**) int main(int, char**) {
{
{
typedef int T; typedef int T;
typedef std::vector<T> C; typedef std::vector<T> C;
C c1; C c1;
C c2; C c2;
int i = c1.begin() - c2.begin(); (void)i; int i = c1.begin() - c2.begin();
(void)i;
assert(false); assert(false);
}
#if TEST_STD_VER >= 11 return 0;
{
typedef int T;
typedef std::vector<T, min_allocator<T>> C;
C c1;
C c2;
int i = c1.begin() - c2.begin(); (void)i;
assert(false);
}
#endif
} }

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

Show All 16 Lines
#include <vector> #include <vector>
#include <cassert> #include <cassert>
#include <iterator> #include <iterator>
#include <exception> #include <exception>
#include <cstdlib> #include <cstdlib>
#include "test_macros.h" #include "test_macros.h"
#include "min_allocator.h"
int main(int, char**) int main(int, char**) {
{
{
typedef int T; typedef int T;
typedef std::vector<T> C; typedef std::vector<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);
assert(i[1] == 0); assert(i[1] == 0);
assert(false); assert(false);
}
#if TEST_STD_VER >= 11 return 0;
{
typedef int T;
typedef std::vector<T, min_allocator<T>> C;
C c(1);
C::iterator i = c.begin();
assert(i[0] == 0);
assert(i[1] == 0);
assert(false);
}
#endif
} }

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

Show All 16 Lines
#include <vector> #include <vector>
#include <cassert> #include <cassert>
#include <iterator> #include <iterator>
#include <exception> #include <exception>
#include <cstdlib> #include <cstdlib>
#include "test_macros.h" #include "test_macros.h"
#include "min_allocator.h"
int main(int, char**) int main(int, char**) {
{
{
typedef int T; typedef int T;
typedef std::vector<T> C; typedef std::vector<T> C;
C c(1); C c(1);
C::iterator i = c.begin(); C::iterator i = c.begin();
i += 1; i += 1;
assert(i == c.end()); assert(i == c.end());
i = c.begin(); i = c.begin();
i += 2; i += 2;
assert(false); assert(false);
}
#if TEST_STD_VER >= 11 return 0;
{
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();
i += 2;
assert(false);
}
#endif
} }

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

Show All 16 Lines
#include <vector> #include <vector>
#include <cassert> #include <cassert>
#include <iterator> #include <iterator>
#include <exception> #include <exception>
#include <cstdlib> #include <cstdlib>
#include "test_macros.h" #include "test_macros.h"
#include "min_allocator.h"
int main(int, char**) int main(int, char**) {
{
{
typedef int T; typedef int T;
typedef std::vector<T> C; typedef std::vector<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());
--i; --i;
assert(false); assert(false);
}
#if TEST_STD_VER >= 11 return 0;
{
typedef int T;
typedef std::vector<T, min_allocator<T>> C;
C c(1);
C::iterator i = c.end();
--i;
assert(i == c.begin());
--i;
assert(false);
}
#endif
} }

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

Show All 16 Lines
#include <vector> #include <vector>
#include <cassert> #include <cassert>
#include <iterator> #include <iterator>
#include <exception> #include <exception>
#include <cstdlib> #include <cstdlib>
#include "test_macros.h" #include "test_macros.h"
#include "min_allocator.h"
int main(int, char**) int main(int, char**) {
{
{
typedef int T; typedef int T;
typedef std::vector<T> C; typedef std::vector<T> C;
C c(1); C c(1);
C::iterator i = c.begin(); C::iterator i = c.begin();
++i; ++i;
assert(i == c.end()); assert(i == c.end());
++i; ++i;
assert(false); assert(false);
}
#if TEST_STD_VER >= 11 return 0;
{
typedef int T;
typedef std::vector<T, min_allocator<T>> C;
C c(1);
C::iterator i = c.begin();
++i;
assert(i == c.end());
++i;
assert(false);
}
#endif
} }

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

  • This file was copied to libcxx/test/libcxx/containers/sequences/vector/db_iterators_15.pass.cpp.
Show All 16 Lines
#include <vector> #include <vector>
#include <cassert> #include <cassert>
#include <iterator> #include <iterator>
#include <exception> #include <exception>
#include <cstdlib> #include <cstdlib>
#include "test_macros.h" #include "test_macros.h"
#include "min_allocator.h"
int main(int, char**) int main(int, char**) {
{
{
typedef int T; typedef int T;
typedef std::vector<T> C; typedef std::vector<T> C;
C c(1); C c(1);
C::iterator i = c.end(); C::iterator i = c.end();
T j = *i; (void)j; T j = *i;
(void)j;
assert(false); assert(false);
}
#if TEST_STD_VER >= 11 return 0;
{
typedef int T;
typedef std::vector<T, min_allocator<T>> C;
C c(1);
C::iterator i = c.end();
T j = *i; (void)j;
assert(false);
}
#endif
} }

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

  • This file was copied from libcxx/test/libcxx/containers/sequences/vector/db_iterators_2.pass.cpp.
Show All 18 Lines
#include <cassert> #include <cassert>
#include <iterator> #include <iterator>
#include <exception> #include <exception>
#include <cstdlib> #include <cstdlib>
#include "test_macros.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 std::vector<T> C;
C c1;
C c2;
bool b = c1.begin() < c2.begin(); (void)b;
assert(false);
}
#if TEST_STD_VER >= 11
{
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;
bool b = c1.begin() < c2.begin(); (void)b; bool b = c1.begin() < c2.begin();
(void)b;
assert(false); assert(false);
}
#endif return 0;
} }

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

Show All 16 Lines
#include <string> #include <string>
#include <cassert> #include <cassert>
#include <iterator> #include <iterator>
#include <exception> #include <exception>
#include <cstdlib> #include <cstdlib>
#include "test_macros.h" #include "test_macros.h"
#include "min_allocator.h"
int main(int, char**) int main(int, char**) {
{
{
typedef std::string S; typedef std::string S;
S s(1, '\0'); S s(1, '\0');
assert(s.back() == 0); assert(s.back() == 0);
s.clear(); s.clear();
assert(s.back() == 0); assert(s.back() == 0);
assert(false); assert(false);
}
#if TEST_STD_VER >= 11 return 0;
{
typedef std::basic_string<char, std::char_traits<char>, min_allocator<char>> S;
S s(1, '\0');
assert(s.back() == 0);
s.clear();
assert(s.back() == 0);
assert(false);
}
#endif
} }

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

  • This file was copied from libcxx/test/libcxx/strings/basic.string/string.access/db_cback.pass.cpp.
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// <string> // <string>
// Call back() on empty const container. // Call back() on empty container.
// UNSUPPORTED: libcxx-no-debug-mode // UNSUPPORTED: libcxx-no-debug-mode
// ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DEBUG=1 // ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DEBUG=1
#define _LIBCPP_ASSERT(x, m) ((x) ? (void)0 : std::exit(0)) #define _LIBCPP_ASSERT(x, m) ((x) ? (void)0 : std::exit(0))
#include <string> #include <string>
#include <cassert> #include <cassert>
#include <iterator> #include <iterator>
#include <exception> #include <exception>
#include <cstdlib> #include <cstdlib>
#include "test_macros.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;
assert(s.back() == 0);
assert(false);
}
#if TEST_STD_VER >= 11
{
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; S s(1, '\0');
assert(s.back() == 0);
s.clear();
assert(s.back() == 0); assert(s.back() == 0);
assert(false); assert(false);
}
#endif return 0;
} }

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

  • This file was copied to libcxx/test/libcxx/strings/basic.string/string.access/db_back_2.pass.cpp, libcxx/test/libcxx/strings/basic.string/string.access/db_cback_2.pass.cpp, libcxx/test/libcxx/strings/basic.string/string.access/db_front_2.pass.cpp, libcxx/test/libcxx/strings/basic.string/string.iterators/db_iterators_11.pass.cpp, libcxx/test/libcxx/strings/basic.string/string.iterators/db_iterators_12.pass.cpp, libcxx/test/libcxx/strings/basic.string/string.iterators/db_iterators_13.pass.cpp, libcxx/test/libcxx/strings/basic.string/string.iterators/db_iterators_14.pass.cpp.
Show All 16 Lines
#include <string> #include <string>
#include <cassert> #include <cassert>
#include <iterator> #include <iterator>
#include <exception> #include <exception>
#include <cstdlib> #include <cstdlib>
#include "test_macros.h" #include "test_macros.h"
#include "min_allocator.h"
int main(int, char**) int main(int, char**) {
{
{
typedef std::string S; typedef std::string S;
const S s; const S s;
assert(s.back() == 0); assert(s.back() == 0);
assert(false); assert(false);
}
#if TEST_STD_VER >= 11 return 0;
{
typedef std::basic_string<char, std::char_traits<char>, min_allocator<char>> S;
const S s;
assert(s.back() == 0);
assert(false);
}
#endif
} }

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

  • This file was copied from libcxx/test/libcxx/strings/basic.string/string.access/db_cback.pass.cpp.
Show All 18 Lines
#include <cassert> #include <cassert>
#include <iterator> #include <iterator>
#include <exception> #include <exception>
#include <cstdlib> #include <cstdlib>
#include "test_macros.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;
assert(s.back() == 0);
assert(false);
}
#if TEST_STD_VER >= 11
{
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.back() == 0); assert(s.back() == 0);
assert(false); assert(false);
}
#endif return 0;
} }

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

  • This file was copied to libcxx/test/libcxx/strings/basic.string/string.access/db_cfront_2.pass.cpp.
Show All 16 Lines
#include <string> #include <string>
#include <cassert> #include <cassert>
#include <iterator> #include <iterator>
#include <exception> #include <exception>
#include <cstdlib> #include <cstdlib>
#include "test_macros.h" #include "test_macros.h"
#include "min_allocator.h"
int main(int, char**) int main(int, char**) {
{
{
typedef std::string S; typedef std::string S;
const S s; const S s;
assert(s.front() == 0); assert(s.front() == 0);
assert(false); assert(false);
}
#if TEST_STD_VER >= 11 return 0;
{
typedef std::basic_string<char, std::char_traits<char>, min_allocator<char>> S;
const S s;
assert(s.front() == 0);
assert(false);
}
#endif
} }

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

  • This file was copied from libcxx/test/libcxx/strings/basic.string/string.access/db_cfront.pass.cpp.
Show All 18 Lines
#include <cassert> #include <cassert>
#include <iterator> #include <iterator>
#include <exception> #include <exception>
#include <cstdlib> #include <cstdlib>
#include "test_macros.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;
assert(s.front() == 0);
assert(false);
}
#if TEST_STD_VER >= 11
{
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.front() == 0); assert(s.front() == 0);
assert(false); assert(false);
}
#endif return 0;
} }

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

  • This file was copied to libcxx/test/libcxx/strings/basic.string/string.access/db_cindex_2.pass.cpp.
Show All 16 Lines
#include <string> #include <string>
#include <cassert> #include <cassert>
#include <iterator> #include <iterator>
#include <exception> #include <exception>
#include <cstdlib> #include <cstdlib>
#include "test_macros.h" #include "test_macros.h"
#include "min_allocator.h"
int main(int, char**) int main(int, char**) {
{
{
typedef std::string S; typedef std::string S;
const S s; const S s;
assert(s[0] == 0); assert(s[0] == 0);
assert(s[1] == 0); assert(s[1] == 0);
assert(false); assert(false);
}
#if TEST_STD_VER >= 11 return 0;
{
typedef std::basic_string<char, std::char_traits<char>, min_allocator<char>> S;
const S s;
assert(s[0] == 0);
assert(s[1] == 0);
assert(false);
}
#endif
} }

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

  • This file was copied from libcxx/test/libcxx/strings/basic.string/string.access/db_cindex.pass.cpp.
Show All 18 Lines
#include <cassert> #include <cassert>
#include <iterator> #include <iterator>
#include <exception> #include <exception>
#include <cstdlib> #include <cstdlib>
#include "test_macros.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;
assert(s[0] == 0);
assert(s[1] == 0);
assert(false);
}
#if TEST_STD_VER >= 11
{
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);
assert(s[1] == 0); assert(s[1] == 0);
assert(false); assert(false);
}
#endif return 0;
} }

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

Show All 16 Lines
#include <string> #include <string>
#include <cassert> #include <cassert>
#include <iterator> #include <iterator>
#include <exception> #include <exception>
#include <cstdlib> #include <cstdlib>
#include "test_macros.h" #include "test_macros.h"
#include "min_allocator.h"
int main(int, char**) int main(int, char**) {
{
{
typedef std::string S; typedef std::string S;
S s(1, '\0'); S s(1, '\0');
assert(s.front() == 0); assert(s.front() == 0);
s.clear(); s.clear();
assert(s.front() == 0); assert(s.front() == 0);
assert(false); assert(false);
}
#if TEST_STD_VER >= 11 return 0;
{
typedef std::basic_string<char, std::char_traits<char>, min_allocator<char>> S;
S s(1, '\0');
assert(s.front() == 0);
s.clear();
assert(s.front() == 0);
assert(false);
}
#endif
} }

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

  • This file was copied from libcxx/test/libcxx/strings/basic.string/string.access/db_cback.pass.cpp.
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// <string> // <string>
// Call back() on empty const container. // Call front() on empty container.
// UNSUPPORTED: libcxx-no-debug-mode // UNSUPPORTED: libcxx-no-debug-mode
// ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DEBUG=1 // ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DEBUG=1
#define _LIBCPP_ASSERT(x, m) ((x) ? (void)0 : std::exit(0)) #define _LIBCPP_ASSERT(x, m) ((x) ? (void)0 : std::exit(0))
#include <string> #include <string>
#include <cassert> #include <cassert>
#include <iterator> #include <iterator>
#include <exception> #include <exception>
#include <cstdlib> #include <cstdlib>
#include "test_macros.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;
assert(s.back() == 0);
assert(false);
}
#if TEST_STD_VER >= 11
{
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; S s(1, '\0');
assert(s.back() == 0); assert(s.front() == 0);
s.clear();
assert(s.front() == 0);
assert(false); assert(false);
}
#endif return 0;
} }

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

  • This file was copied to libcxx/test/libcxx/strings/basic.string/string.access/db_index_2.pass.cpp.
Show All 16 Lines
#include <string> #include <string>
#include <cassert> #include <cassert>
#include <iterator> #include <iterator>
#include <exception> #include <exception>
#include <cstdlib> #include <cstdlib>
#include "test_macros.h" #include "test_macros.h"
#include "min_allocator.h"
int main(int, char**) int main(int, char**) {
{
{
typedef std::string S; typedef std::string S;
S s; S s;
assert(s[0] == 0); assert(s[0] == 0);
assert(s[1] == 0); assert(s[1] == 0);
assert(false); assert(false);
}
#if TEST_STD_VER >= 11 return 0;
{
typedef std::basic_string<char, std::char_traits<char>, min_allocator<char>> S;
S s;
assert(s[0] == 0);
assert(s[1] == 0);
assert(false);
}
#endif
} }

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

  • This file was copied from libcxx/test/libcxx/strings/basic.string/string.access/db_index.pass.cpp.
Show All 18 Lines
#include <cassert> #include <cassert>
#include <iterator> #include <iterator>
#include <exception> #include <exception>
#include <cstdlib> #include <cstdlib>
#include "test_macros.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;
S s;
assert(s[0] == 0);
assert(s[1] == 0);
assert(false);
}
#if TEST_STD_VER >= 11
{
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);
assert(s[1] == 0); assert(s[1] == 0);
assert(false); assert(false);
}
#endif return 0;
} }

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

  • This file was copied from libcxx/test/libcxx/strings/basic.string/string.iterators/db_iterators_3.pass.cpp.
Show All 18 Lines
#include <cassert> #include <cassert>
#include <iterator> #include <iterator>
#include <exception> #include <exception>
#include <cstdlib> #include <cstdlib>
#include "test_macros.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;
S s1;
S s2;
int i = s1.begin() - s2.begin();
(void) i;
assert(false);
}
#if TEST_STD_VER >= 11
{
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;
int i = s1.begin() - s2.begin(); int i = s1.begin() - s2.begin();
(void) i; (void)i;
assert(false); assert(false);
}
#endif return 0;
} }

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

  • This file was copied from libcxx/test/libcxx/strings/basic.string/string.access/db_cback.pass.cpp.
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// <string> // <string>
// Call back() on empty const container. // Index iterator out of bounds.
// UNSUPPORTED: libcxx-no-debug-mode // UNSUPPORTED: libcxx-no-debug-mode
// ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DEBUG=1 // ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DEBUG=1
#define _LIBCPP_ASSERT(x, m) ((x) ? (void)0 : std::exit(0)) #define _LIBCPP_ASSERT(x, m) ((x) ? (void)0 : std::exit(0))
#include <string> #include <string>
#include <cassert> #include <cassert>
#include <iterator> #include <iterator>
#include <exception> #include <exception>
#include <cstdlib> #include <cstdlib>
#include "test_macros.h" #include "test_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> > C;
{ C c(1, '\0');
typedef std::string S; C::iterator i = c.begin();
const S s; assert(i[0] == 0);
assert(s.back() == 0); assert(i[1] == 0);
assert(false); assert(false);
}
#if TEST_STD_VER >= 11 return 0;
{
typedef std::basic_string<char, std::char_traits<char>, min_allocator<char>> S;
const S s;
assert(s.back() == 0);
assert(false);
}
#endif
} }

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

  • This file was copied from libcxx/test/libcxx/strings/basic.string/string.access/db_cback.pass.cpp.
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// <string> // <string>
// Call back() on empty const container. // Add to iterator out of bounds.
// UNSUPPORTED: libcxx-no-debug-mode // UNSUPPORTED: libcxx-no-debug-mode
// ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DEBUG=1 // ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DEBUG=1
#define _LIBCPP_ASSERT(x, m) ((x) ? (void)0 : std::exit(0)) #define _LIBCPP_ASSERT(x, m) ((x) ? (void)0 : std::exit(0))
#include <string> #include <string>
#include <cassert> #include <cassert>
#include <iterator> #include <iterator>
#include <exception> #include <exception>
#include <cstdlib> #include <cstdlib>
#include "test_macros.h" #include "test_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> > C;
{ C c(1, '\0');
typedef std::string S; C::iterator i = c.begin();
const S s; i += 1;
assert(s.back() == 0); assert(i == c.end());
i = c.begin();
i += 2;
assert(false); assert(false);
}
#if TEST_STD_VER >= 11 return 0;
{
typedef std::basic_string<char, std::char_traits<char>, min_allocator<char>> S;
const S s;
assert(s.back() == 0);
assert(false);
}
#endif
} }

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

  • This file was copied from libcxx/test/libcxx/strings/basic.string/string.access/db_cback.pass.cpp.
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// <string> // <string>
// Call back() on empty const container. // Decrement iterator prior to begin.
// UNSUPPORTED: libcxx-no-debug-mode // UNSUPPORTED: libcxx-no-debug-mode
// ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DEBUG=1 // ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DEBUG=1
#define _LIBCPP_ASSERT(x, m) ((x) ? (void)0 : std::exit(0)) #define _LIBCPP_ASSERT(x, m) ((x) ? (void)0 : std::exit(0))
#include <string> #include <string>
#include <cassert> #include <cassert>
#include <iterator> #include <iterator>
#include <exception> #include <exception>
#include <cstdlib> #include <cstdlib>
#include "test_macros.h" #include "test_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> > C;
{ C c(1, '\0');
typedef std::string S; C::iterator i = c.end();
const S s; --i;
assert(s.back() == 0); assert(i == c.begin());
--i;
assert(false); assert(false);
}
#if TEST_STD_VER >= 11 return 0;
{
typedef std::basic_string<char, std::char_traits<char>, min_allocator<char>> S;
const S s;
assert(s.back() == 0);
assert(false);
}
#endif
} }

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

  • This file was copied from libcxx/test/libcxx/strings/basic.string/string.access/db_cback.pass.cpp.
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// <string> // <string>
// Call back() on empty const container. // Increment iterator past end.
// UNSUPPORTED: libcxx-no-debug-mode // UNSUPPORTED: libcxx-no-debug-mode
// ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DEBUG=1 // ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DEBUG=1
#define _LIBCPP_ASSERT(x, m) ((x) ? (void)0 : std::exit(0)) #define _LIBCPP_ASSERT(x, m) ((x) ? (void)0 : std::exit(0))
#include <string> #include <string>
#include <cassert> #include <cassert>
#include <iterator> #include <iterator>
#include <exception> #include <exception>
#include <cstdlib> #include <cstdlib>
#include "test_macros.h" #include "test_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> > C;
{ C c(1, '\0');
typedef std::string S; C::iterator i = c.begin();
const S s; ++i;
assert(s.back() == 0); assert(i == c.end());
++i;
assert(false); assert(false);
}
#if TEST_STD_VER >= 11 return 0;
{
typedef std::basic_string<char, std::char_traits<char>, min_allocator<char>> S;
const S s;
assert(s.back() == 0);
assert(false);
}
#endif
} }

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

  • This file was copied from libcxx/test/libcxx/strings/basic.string/string.iterators/db_iterators_8.pass.cpp.
Show All 18 Lines
#include <cassert> #include <cassert>
#include <iterator> #include <iterator>
#include <exception> #include <exception>
#include <cstdlib> #include <cstdlib>
#include "test_macros.h" #include "test_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();
(void) *i;
assert(false);
}
#if TEST_STD_VER >= 11
{
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();
(void) *i; (void)*i;
assert(false); assert(false);
}
#endif return 0;
} }

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

  • This file was copied to libcxx/test/libcxx/strings/basic.string/string.iterators/db_iterators_9.pass.cpp.
Show All 16 Lines
#include <string> #include <string>
#include <cassert> #include <cassert>
#include <iterator> #include <iterator>
#include <exception> #include <exception>
#include <cstdlib> #include <cstdlib>
#include "test_macros.h" #include "test_macros.h"
#include "min_allocator.h"
int main(int, char**) int main(int, char**) {
{
{
typedef std::string S; typedef std::string S;
S s1; S s1;
S s2; S s2;
bool b = s1.begin() < s2.begin(); bool b = s1.begin() < s2.begin();
(void) b; (void)b;
assert(false); assert(false);
}
#if TEST_STD_VER >= 11 return 0;
{
typedef std::basic_string<char, std::char_traits<char>, min_allocator<char>> S;
S s1;
S s2;
bool b = s1.begin() < s2.begin();
(void) b;
assert(false);
}
#endif
} }

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

  • This file was copied to libcxx/test/libcxx/strings/basic.string/string.iterators/db_iterators_10.pass.cpp.
Show All 16 Lines
#include <string> #include <string>
#include <cassert> #include <cassert>
#include <iterator> #include <iterator>
#include <exception> #include <exception>
#include <cstdlib> #include <cstdlib>
#include "test_macros.h" #include "test_macros.h"
#include "min_allocator.h"
int main(int, char**) int main(int, char**) {
{
{
typedef std::string S; typedef std::string S;
S s1; S s1;
S s2; S s2;
int i = s1.begin() - s2.begin(); int i = s1.begin() - s2.begin();
(void) i; (void)i;
assert(false); assert(false);
}
#if TEST_STD_VER >= 11 return 0;
{
typedef std::basic_string<char, std::char_traits<char>, min_allocator<char>> S;
S s1;
S s2;
int i = s1.begin() - s2.begin();
(void) i;
assert(false);
}
#endif
} }

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

Show All 16 Lines
#include <string> #include <string>
#include <cassert> #include <cassert>
#include <iterator> #include <iterator>
#include <exception> #include <exception>
#include <cstdlib> #include <cstdlib>
#include "test_macros.h" #include "test_macros.h"
#include "min_allocator.h"
int main(int, char**) int main(int, char**) {
{
{
typedef std::string C; typedef std::string 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);
assert(i[1] == 0); assert(i[1] == 0);
assert(false); assert(false);
}
#if TEST_STD_VER >= 11 return 0;
{
typedef std::basic_string<char, std::char_traits<char>, min_allocator<char>> C;
C c(1, '\0');
C::iterator i = c.begin();
assert(i[0] == 0);
assert(i[1] == 0);
assert(false);
}
#endif
} }

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

Show All 16 Lines
#include <string> #include <string>
#include <cassert> #include <cassert>
#include <iterator> #include <iterator>
#include <exception> #include <exception>
#include <cstdlib> #include <cstdlib>
#include "test_macros.h" #include "test_macros.h"
#include "min_allocator.h"
int main(int, char**) int main(int, char**) {
{
{
typedef std::string C; typedef std::string C;
C c(1, '\0'); C c(1, '\0');
C::iterator i = c.begin(); C::iterator i = c.begin();
i += 1; i += 1;
assert(i == c.end()); assert(i == c.end());
i = c.begin(); i = c.begin();
i += 2; i += 2;
assert(false); assert(false);
}
#if TEST_STD_VER >= 11 return 0;
{
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();
i += 2;
assert(false);
}
#endif
} }

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

Show All 16 Lines
#include <string> #include <string>
#include <cassert> #include <cassert>
#include <iterator> #include <iterator>
#include <exception> #include <exception>
#include <cstdlib> #include <cstdlib>
#include "test_macros.h" #include "test_macros.h"
#include "min_allocator.h"
int main(int, char**) int main(int, char**) {
{
{
typedef std::string C; typedef std::string 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());
--i; --i;
assert(false); assert(false);
}
#if TEST_STD_VER >= 11 return 0;
{
typedef std::basic_string<char, std::char_traits<char>, min_allocator<char>> C;
C c(1, '\0');
C::iterator i = c.end();
--i;
assert(i == c.begin());
--i;
assert(false);
}
#endif
} }

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

Show All 16 Lines
#include <string> #include <string>
#include <cassert> #include <cassert>
#include <iterator> #include <iterator>
#include <exception> #include <exception>
#include <cstdlib> #include <cstdlib>
#include "test_macros.h" #include "test_macros.h"
#include "min_allocator.h"
int main(int, char**) int main(int, char**) {
{
{
typedef std::string C; typedef std::string C;
C c(1, '\0'); C c(1, '\0');
C::iterator i = c.begin(); C::iterator i = c.begin();
++i; ++i;
assert(i == c.end()); assert(i == c.end());
++i; ++i;
assert(false); assert(false);
}
#if TEST_STD_VER >= 11 return 0;
{
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());
++i;
assert(false);
}
#endif
} }

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

  • This file was copied to libcxx/test/libcxx/strings/basic.string/string.iterators/db_iterators_15.pass.cpp.
Show All 16 Lines
#include <string> #include <string>
#include <cassert> #include <cassert>
#include <iterator> #include <iterator>
#include <exception> #include <exception>
#include <cstdlib> #include <cstdlib>
#include "test_macros.h" #include "test_macros.h"
#include "min_allocator.h"
int main(int, char**) int main(int, char**) {
{
{
typedef std::string C; typedef std::string C;
C c(1, '\0'); C c(1, '\0');
C::iterator i = c.end(); C::iterator i = c.end();
(void) *i; (void)*i;
assert(false); assert(false);
}
#if TEST_STD_VER >= 11 return 0;
{
typedef std::basic_string<char, std::char_traits<char>, min_allocator<char>> C;
C c(1, '\0');
C::iterator i = c.end();
(void) *i;
assert(false);
}
#endif
} }

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

  • This file was copied from libcxx/test/libcxx/strings/basic.string/string.iterators/db_iterators_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>
// Compare iterators from different containers with <. // Compare iterators from different containers with <.
// UNSUPPORTED: libcxx-no-debug-mode // UNSUPPORTED: libcxx-no-debug-mode
QuuxplusoneUnsubmitted
Not Done
ReplyInline Actions

Why is this test unsupported in C++03? Actually, what on earth is the point of this test?
I'm fine shipping this commit as-is, as long as we get to the bottom of it in D100595.
But I'd be happier with just git rm'ing this new file, because (unless I'm missing something) it's identical to db_iterators_2.pass.cpp except for the unneeded UNSUPPORTED line.

Quuxplusone: Why is this test unsupported in C++03? Actually, what on earth is the point of this test? I'm…
krisbAuthorUnsubmitted
Done
ReplyInline Actions

Thanks for pointing to this.
I didn't think much about the tests themselves while creating this patch, just extracted the second part of each test to a separate file and automatically marked them UNSUPPORTED: c++03 because they were under #if TEST_STD_VER >= 11.
But you are right, we do not need UNSUPPORTED: c++03 here (and for all the similar tests), the tests work fine with c++03 as well as with other supported versions of the standard. I guess this code was under #if TEST_STD_VER >= 11 following min_allocator requirements, which needed c++11 or newer before D67675, but I didn't dig deeper to answer why min_allocator required c++ >= 11. I'll update the tests.

Actually, what on earth is the point of this test?

This test unlike db_iterators_2.pass.cpp constructs a basic_string with a custom allocator.
Basically, it follows the same pattern as other tests for containers (both normal and debug modes) where we have one test with default parameters and one with a custom allocator. So, I'd keep this test in.

krisb: Thanks for pointing to this. I didn't think much about the tests themselves while creating this…
// ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DEBUG=1 // ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DEBUG=1
#define _LIBCPP_ASSERT(x, m) ((x) ? (void)0 : std::exit(0)) #define _LIBCPP_ASSERT(x, m) ((x) ? (void)0 : std::exit(0))
#include <string> #include <string>
#include <cassert> #include <cassert>
#include <iterator> #include <iterator>
#include <exception> #include <exception>
#include <cstdlib> #include <cstdlib>
#include "test_macros.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;
S s1;
S s2;
bool b = s1.begin() < s2.begin();
(void) b;
assert(false);
}
#if TEST_STD_VER >= 11
{
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;
bool b = s1.begin() < s2.begin(); bool b = s1.begin() < s2.begin();
(void) b; (void)b;
assert(false); assert(false);
}
#endif return 0;
} }