caio/clang-p2996
1
0
Fork 0
Code Issues Pull Requests Actions 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

llvm-svn: 285697
This commit is contained in:
Roger Ferrer Ibanez
2016-11-01 15:46:16 +00:00
parent 6dd8fab443
commit 8a915ed644
28 changed files with 598 additions and 248 deletions
Download Patch File Download Diff File Expand all files Collapse all files

43
libcxx/test/std/strings/basic.string/string.modifiers/string_replace/size_size_T_size_size.pass.cpp
View File

@@ -7,7 +7,6 @@
//
//===----------------------------------------------------------------------===//
// XFAIL: libcpp-no-exceptions
// <string>
// template <class T>
@@ -31,23 +30,32 @@ test(S s, typename S::size_type pos1, typename S::size_type n1,
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.replace(pos1, n1, sv, pos2, n2);
LIBCPP_ASSERT(s.__invariants());
assert(pos1 <= old_size && pos2 <= sv.size());
assert(s == expected);
typename S::size_type xlen = std::min(n1, old_size - pos1);
typename S::size_type rlen = std::min(n2, sv.size() - pos2);
assert(s.size() == old_size - xlen + rlen);
}
catch (std::out_of_range&)
#ifndef TEST_HAS_NO_EXCEPTIONS
else
{
assert(pos1 > old_size || pos2 > sv.size());
assert(s == s0);
try
{
s.replace(pos1, n1, sv, pos2, n2);
assert(false);
}
catch (std::out_of_range&)
{
assert(pos1 > old_size || pos2 > sv.size());
assert(s == s0);
}
}
#endif
}
template <class S, class SV>
@@ -57,23 +65,32 @@ test_npos(S s, typename S::size_type pos1, typename S::size_type n1,
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.replace(pos1, n1, sv, pos2);
LIBCPP_ASSERT(s.__invariants());
assert(pos1 <= old_size && pos2 <= sv.size());
assert(s == expected);
typename S::size_type xlen = std::min(n1, old_size - pos1);
typename S::size_type rlen = std::min(S::npos, sv.size() - pos2);
assert(s.size() == old_size - xlen + rlen);
}
catch (std::out_of_range&)
#ifndef TEST_HAS_NO_EXCEPTIONS
else
{
assert(pos1 > old_size || pos2 > sv.size());
assert(s == s0);
try
{
s.replace(pos1, n1, sv, pos2);
assert(false);
}
catch (std::out_of_range&)
{
assert(pos1 > old_size || pos2 > sv.size());
assert(s == s0);
}
}
#endif
}

22
libcxx/test/std/strings/basic.string/string.modifiers/string_replace/size_size_pointer.pass.cpp
View File

@@ -7,7 +7,6 @@
//
//===----------------------------------------------------------------------===//
// XFAIL: libcpp-no-exceptions
// <string>
// basic_string<charT,traits,Allocator>&
@@ -26,23 +25,32 @@ void
test(S s, typename S::size_type pos, typename S::size_type n1,
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.replace(pos, n1, str);
LIBCPP_ASSERT(s.__invariants());
assert(pos <= old_size);
assert(s == expected);
typename S::size_type xlen = std::min(n1, old_size - pos);
typename S::size_type rlen = S::traits_type::length(str);
assert(s.size() == old_size - xlen + rlen);
}
catch (std::out_of_range&)
#ifndef TEST_HAS_NO_EXCEPTIONS
else
{
assert(pos > old_size);
assert(s == s0);
try
{
s.replace(pos, n1, str);
assert(false);
}
catch (std::out_of_range&)
{
assert(pos > old_size);
assert(s == s0);
}
}
#endif
}
template <class S>

22
libcxx/test/std/strings/basic.string/string.modifiers/string_replace/size_size_pointer_size.pass.cpp
View File

@@ -7,7 +7,6 @@
//
//===----------------------------------------------------------------------===//
// XFAIL: libcpp-no-exceptions
// <string>
// basic_string<charT,traits,Allocator>&
@@ -27,23 +26,32 @@ test(S s, typename S::size_type pos, typename S::size_type n1,
const typename S::value_type* str, typename S::size_type n2,
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.replace(pos, n1, str, n2);
LIBCPP_ASSERT(s.__invariants());
assert(pos <= old_size);
assert(s == expected);
typename S::size_type xlen = std::min(n1, old_size - pos);
typename S::size_type rlen = n2;
assert(s.size() == old_size - xlen + rlen);
}
catch (std::out_of_range&)
#ifndef TEST_HAS_NO_EXCEPTIONS
else
{
assert(pos > old_size);
assert(s == s0);
try
{
s.replace(pos, n1, str, n2);
assert(false);
}
catch (std::out_of_range&)
{
assert(pos > old_size);
assert(s == s0);
}
}
#endif
}
template <class S>

22
libcxx/test/std/strings/basic.string/string.modifiers/string_replace/size_size_size_char.pass.cpp
View File

@@ -7,7 +7,6 @@
//
//===----------------------------------------------------------------------===//
// XFAIL: libcpp-no-exceptions
// <string>
// basic_string<charT,traits,Allocator>&
@@ -27,23 +26,32 @@ test(S s, typename S::size_type pos, typename S::size_type n1,
typename S::size_type n2, typename S::value_type c,
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.replace(pos, n1, n2, c);
LIBCPP_ASSERT(s.__invariants());
assert(pos <= old_size);
assert(s == expected);
typename S::size_type xlen = std::min(n1, old_size - pos);
typename S::size_type rlen = n2;
assert(s.size() == old_size - xlen + rlen);
}
catch (std::out_of_range&)
#ifndef TEST_HAS_NO_EXCEPTIONS
else
{
assert(pos > old_size);
assert(s == s0);
try
{
s.replace(pos, n1, n2, c);
assert(false);
}
catch (std::out_of_range&)
{
assert(pos > old_size);
assert(s == s0);
}
}
#endif
}
template <class S>

22
libcxx/test/std/strings/basic.string/string.modifiers/string_replace/size_size_string.pass.cpp
View File

@@ -7,7 +7,6 @@
//
//===----------------------------------------------------------------------===//
// XFAIL: libcpp-no-exceptions
// <string>
// basic_string<charT,traits,Allocator>&
@@ -25,23 +24,32 @@ template <class S>
void
test(S s, typename S::size_type pos1, typename S::size_type n1, 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 (pos1 <= old_size)
{
s.replace(pos1, n1, str);
LIBCPP_ASSERT(s.__invariants());
assert(pos1 <= old_size);
assert(s == expected);
typename S::size_type xlen = std::min(n1, old_size - pos1);
typename S::size_type rlen = str.size();
assert(s.size() == old_size - xlen + rlen);
}
catch (std::out_of_range&)
#ifndef TEST_HAS_NO_EXCEPTIONS
else
{
assert(pos1 > old_size);
assert(s == s0);
try
{
s.replace(pos1, n1, str);
assert(false);
}
catch (std::out_of_range&)
{
assert(pos1 > old_size);
assert(s == s0);
}
}
#endif
}
template <class S>

43
libcxx/test/std/strings/basic.string/string.modifiers/string_replace/size_size_string_size_size.pass.cpp
View File

@@ -7,7 +7,6 @@
//
//===----------------------------------------------------------------------===//
// XFAIL: libcpp-no-exceptions
// <string>
// basic_string<charT,traits,Allocator>&
@@ -29,23 +28,32 @@ test(S s, typename S::size_type pos1, typename S::size_type n1,
S str, typename S::size_type pos2, typename S::size_type n2,
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.replace(pos1, n1, str, pos2, n2);
LIBCPP_ASSERT(s.__invariants());
assert(pos1 <= old_size && pos2 <= str.size());
assert(s == expected);
typename S::size_type xlen = std::min(n1, old_size - pos1);
typename S::size_type rlen = std::min(n2, str.size() - pos2);
assert(s.size() == old_size - xlen + rlen);
}
catch (std::out_of_range&)
#ifndef TEST_HAS_NO_EXCEPTIONS
else
{
assert(pos1 > old_size || pos2 > str.size());
assert(s == s0);
try
{
s.replace(pos1, n1, str, pos2, n2);
assert(false);
}
catch (std::out_of_range&)
{
assert(pos1 > old_size || pos2 > str.size());
assert(s == s0);
}
}
#endif
}
template <class S>
@@ -54,23 +62,32 @@ test_npos(S s, typename S::size_type pos1, typename S::size_type n1,
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.replace(pos1, n1, str, pos2);
LIBCPP_ASSERT(s.__invariants());
assert(pos1 <= old_size && pos2 <= str.size());
assert(s == expected);
typename S::size_type xlen = std::min(n1, old_size - pos1);
typename S::size_type rlen = std::min(S::npos, str.size() - pos2);
assert(s.size() == old_size - xlen + rlen);
}
catch (std::out_of_range&)
#ifndef TEST_HAS_NO_EXCEPTIONS
else
{
assert(pos1 > old_size || pos2 > str.size());
assert(s == s0);
try
{
s.replace(pos1, n1, str, pos2);
assert(false);
}
catch (std::out_of_range&)
{
assert(pos1 > old_size || pos2 > str.size());
assert(s == s0);
}
}
#endif
}