LineageOS/android_external_libcxx
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Protect exceptional paths under libcpp-no-exceptions

Browse Source 
These tests are of the form

try {
   action-that-may-throw
   assert(!exceptional-condition)
   assert(some-other-facts)
 } catch (relevant-exception) {
   assert(exceptional-condition)
 }

Under libcpp-no-exceptions there is still value in verifying
some-other-facts while avoiding the exceptional case. So for these tests
just conditionally check some-other-facts if exceptional-condition is
false. When exception are supported make sure that a true
exceptional-condition throws an exception

Differential Revision: https://reviews.llvm.org/D26136



git-svn-id: https://llvm.org/svn/llvm-project/libcxx/trunk@285697 91177308-0d34-0410-b5e6-96231b3b80d8
This commit is contained in:
Roger Ferrer Ibanez
2016-11-01 15:46:16 +00:00
parent 8883740456
commit c09116009c
28 changed files with 598 additions and 248 deletions
Download Patch File Download Diff File Expand all files Collapse all files

43
test/std/strings/basic.string/string.modifiers/string_insert/size_T_size_size.pass.cpp
View File

@@ -7,7 +7,6 @@
//
//===----------------------------------------------------------------------===//
// XFAIL: libcpp-no-exceptions
// <string>
// template <class T>
@@ -28,20 +27,29 @@ test(S s, typename S::size_type pos1, SV sv, typename S::size_type pos2,
typename S::size_type n, S expected)
{
static_assert((!std::is_same<S, SV>::value), "");
typename S::size_type old_size = s.size();
const typename S::size_type old_size = s.size();
S s0 = s;
try
if (pos1 <= old_size && pos2 <= sv.size())
{
s.insert(pos1, sv, pos2, n);
LIBCPP_ASSERT(s.__invariants());
assert(pos1 <= old_size && pos2 <= sv.size());
assert(s == expected);
}
catch (std::out_of_range&)
#ifndef TEST_HAS_NO_EXCEPTIONS
else
{
assert(pos1 > old_size || pos2 > sv.size());
assert(s == s0);
try
{
s.insert(pos1, sv, pos2, n);
assert(false);
}
catch (std::out_of_range&)
{
assert(pos1 > old_size || pos2 > sv.size());
assert(s == s0);
}
}
#endif
}
template <class S, class SV>
@@ -49,20 +57,29 @@ void
test_npos(S s, typename S::size_type pos1, SV sv, typename S::size_type pos2, S expected)
{
static_assert((!std::is_same<S, SV>::value), "");
typename S::size_type old_size = s.size();
const typename S::size_type old_size = s.size();
S s0 = s;
try
if (pos1 <= old_size && pos2 <= sv.size())
{
s.insert(pos1, sv, pos2);
LIBCPP_ASSERT(s.__invariants());
assert(pos1 <= old_size && pos2 <= sv.size());
assert(s == expected);
}
catch (std::out_of_range&)
#ifndef TEST_HAS_NO_EXCEPTIONS
else
{
assert(pos1 > old_size || pos2 > sv.size());
assert(s == s0);
try
{
s.insert(pos1, sv, pos2);
assert(false);
}
catch (std::out_of_range&)
{
assert(pos1 > old_size || pos2 > sv.size());
assert(s == s0);
}
}
#endif
}

22
test/std/strings/basic.string/string.modifiers/string_insert/size_pointer.pass.cpp
View File

@@ -7,7 +7,6 @@
//
//===----------------------------------------------------------------------===//
// XFAIL: libcpp-no-exceptions
// <string>
// basic_string<charT,traits,Allocator>&
@@ -24,20 +23,29 @@ template <class S>
void
test(S s, typename S::size_type pos, const typename S::value_type* str, S expected)
{
typename S::size_type old_size = s.size();
const typename S::size_type old_size = s.size();
S s0 = s;
try
if (pos <= old_size)
{
s.insert(pos, str);
LIBCPP_ASSERT(s.__invariants());
assert(pos <= old_size);
assert(s == expected);
}
catch (std::out_of_range&)
#ifndef TEST_HAS_NO_EXCEPTIONS
else
{
assert(pos > old_size);
assert(s == s0);
try
{
s.insert(pos, str);
assert(false);
}
catch (std::out_of_range&)
{
assert(pos > old_size);
assert(s == s0);
}
}
#endif
}
int main()

22
test/std/strings/basic.string/string.modifiers/string_insert/size_pointer_size.pass.cpp
View File

@@ -7,7 +7,6 @@
//
//===----------------------------------------------------------------------===//
// XFAIL: libcpp-no-exceptions
// <string>
// basic_string<charT,traits,Allocator>&
@@ -25,20 +24,29 @@ void
test(S s, typename S::size_type pos, const typename S::value_type* str,
typename S::size_type n, S expected)
{
typename S::size_type old_size = s.size();
const typename S::size_type old_size = s.size();
S s0 = s;
try
if (pos <= old_size)
{
s.insert(pos, str, n);
LIBCPP_ASSERT(s.__invariants());
assert(pos <= old_size);
assert(s == expected);
}
catch (std::out_of_range&)
#ifndef TEST_HAS_NO_EXCEPTIONS
else
{
assert(pos > old_size);
assert(s == s0);
try
{
s.insert(pos, str, n);
assert(false);
}
catch (std::out_of_range&)
{
assert(pos > old_size);
assert(s == s0);
}
}
#endif
}
int main()

22
test/std/strings/basic.string/string.modifiers/string_insert/size_size_char.pass.cpp
View File

@@ -7,7 +7,6 @@
//
//===----------------------------------------------------------------------===//
// XFAIL: libcpp-no-exceptions
// <string>
// basic_string<charT,traits,Allocator>&
@@ -25,20 +24,29 @@ void
test(S s, typename S::size_type pos, typename S::size_type n,
typename S::value_type str, S expected)
{
typename S::size_type old_size = s.size();
const typename S::size_type old_size = s.size();
S s0 = s;
try
if (pos <= old_size)
{
s.insert(pos, n, str);
LIBCPP_ASSERT(s.__invariants());
assert(pos <= old_size);
assert(s == expected);
}
catch (std::out_of_range&)
#ifndef TEST_HAS_NO_EXCEPTIONS
else
{
assert(pos > old_size);
assert(s == s0);
try
{
s.insert(pos, n, str);
assert(false);
}
catch (std::out_of_range&)
{
assert(pos > old_size);
assert(s == s0);
}
}
#endif
}
int main()

22
test/std/strings/basic.string/string.modifiers/string_insert/size_string.pass.cpp
View File

@@ -7,7 +7,6 @@
//
//===----------------------------------------------------------------------===//
// XFAIL: libcpp-no-exceptions
// <string>
// basic_string<charT,traits,Allocator>&
@@ -24,20 +23,29 @@ template <class S>
void
test(S s, typename S::size_type pos, S str, S expected)
{
typename S::size_type old_size = s.size();
const typename S::size_type old_size = s.size();
S s0 = s;
try
if (pos <= old_size)
{
s.insert(pos, str);
LIBCPP_ASSERT(s.__invariants());
assert(pos <= old_size);
assert(s == expected);
}
catch (std::out_of_range&)
#ifndef TEST_HAS_NO_EXCEPTIONS
else
{
assert(pos > old_size);
assert(s == s0);
try
{
s.insert(pos, str);
assert(false);
}
catch (std::out_of_range&)
{
assert(pos > old_size);
assert(s == s0);
}
}
#endif
}
int main()

43
test/std/strings/basic.string/string.modifiers/string_insert/size_string_size_size.pass.cpp
View File

@@ -7,7 +7,6 @@
//
//===----------------------------------------------------------------------===//
// XFAIL: libcpp-no-exceptions
// <string>
// basic_string<charT,traits,Allocator>&
@@ -27,40 +26,58 @@ void
test(S s, typename S::size_type pos1, S str, typename S::size_type pos2,
typename S::size_type n, S expected)
{
typename S::size_type old_size = s.size();
const typename S::size_type old_size = s.size();
S s0 = s;
try
if (pos1 <= old_size && pos2 <= str.size())
{
s.insert(pos1, str, pos2, n);
LIBCPP_ASSERT(s.__invariants());
assert(pos1 <= old_size && pos2 <= str.size());
assert(s == expected);
}
catch (std::out_of_range&)
#ifndef TEST_HAS_NO_EXCEPTIONS
else
{
assert(pos1 > old_size || pos2 > str.size());
assert(s == s0);
try
{
s.insert(pos1, str, pos2, n);
assert(false);
}
catch (std::out_of_range&)
{
assert(pos1 > old_size || pos2 > str.size());
assert(s == s0);
}
}
#endif
}
template <class S>
void
test_npos(S s, typename S::size_type pos1, S str, typename S::size_type pos2, S expected)
{
typename S::size_type old_size = s.size();
const typename S::size_type old_size = s.size();
S s0 = s;
try
if (pos1 <= old_size && pos2 <= str.size())
{
s.insert(pos1, str, pos2);
LIBCPP_ASSERT(s.__invariants());
assert(pos1 <= old_size && pos2 <= str.size());
assert(s == expected);
}
catch (std::out_of_range&)
#ifndef TEST_HAS_NO_EXCEPTIONS
else
{
assert(pos1 > old_size || pos2 > str.size());
assert(s == s0);
try
{
s.insert(pos1, str, pos2);
assert(false);
}
catch (std::out_of_range&)
{
assert(pos1 > old_size || pos2 > str.size());
assert(s == s0);
}
}
#endif
}