[libcxx] Add precondition check before calling match_results.str() in tests.

[amakc11]

Summary

The match_results constructor has the following postcondition: "Ensures: ready() returns false". The str() method of this class has the following precondition: "Requires: ready() == true". However, some tests call match_results.str() right after the constructor without checking the above precondition. This patch fixes this bug in tests.

[mclow.lists]

Thanks for this patch; but I don't think the suggested changes are what we want.
Instead of:

assert(!m.ready() || m.str() == std::basic_string<CharT>());

I think we should just check:

assert(!m.ready());

because that's the post-condition for the constructor.
If you agree, I can just make the changes myself.

[mclow.lists]

BTW, I agree with you that this is a bug in the tests.

[amakc11]

In D61192#1480548, @mclow.lists wrote:

If you agree, I can just make the changes myself.

Yes, please.

[mclow.lists]

Committed revision https://llvm.org/r359324 to fix this.

test/std/re/re.results/re.results.all/get_allocator.pass.cpp

 #include "test_allocator.h"
 
 template <class CharT, class Allocator>
 void
 test(const Allocator& a)
 {
     std::match_results<const CharT*, Allocator> m(a);
     assert(m.size() == 0);
-    assert(m.str() == std::basic_string<CharT>());
+    assert(!m.ready() || m.str() == std::basic_string<CharT>());
     assert(m.get_allocator() == a);
 }
 
 int main(int, char**)
 {
     test<char>(test_allocator<std::sub_match<const char*> >(3));
     test<wchar_t>(test_allocator<std::sub_match<const wchar_t*> >(3));
 
   return 0;
 }

test/std/re/re.results/re.results.const/allocator.pass.cpp

 #include "test_allocator.h"
 
 template <class CharT, class Allocator>
 void
 test(const Allocator& a)
 {
     std::match_results<const CharT*, Allocator> m(a);
     assert(m.size() == 0);
-    assert(m.str() == std::basic_string<CharT>());
+    assert(!m.ready() || m.str() == std::basic_string<CharT>());
     assert(m.get_allocator() == a);
 }
 
 int main(int, char**)
 {
     test<char>(test_allocator<std::sub_match<const char*> >(3));
     test<wchar_t>(test_allocator<std::sub_match<const wchar_t*> >(3));
 
   return 0;
 }

test/std/re/re.results/re.results.const/copy.pass.cpp

 template <class CharT, class Allocator>
 void
 test(const Allocator& a)
 {
     typedef std::match_results<const CharT*, Allocator> SM;
     SM m0(a);
     SM m1(m0);
 
-    assert(m1.size()          == m0.size());
-    assert(m1.str()           == m0.str());
+    assert(m1.size() == m0.size());
+    assert(!m1.ready() || !m0.ready() || m1.str() == m0.str());
     assert(m1.get_allocator() == m0.get_allocator());
 }
 
 int main(int, char**)
 {
     test<char>   (std::allocator<std::sub_match<const char *> >());
     test<wchar_t>(std::allocator<std::sub_match<const wchar_t *> >());
 
     test<char>   (test_allocator<std::sub_match<const char*> >(3));
     test<wchar_t>(test_allocator<std::sub_match<const wchar_t*> >(3));
 
   return 0;
 }

test/std/re/re.results/re.results.const/copy_assign.pass.cpp

 void
 test(const Allocator& a)
 {
     typedef std::match_results<const CharT*, Allocator> SM;
     SM m0(a);
     SM m1;
 
     m1 = m0;
-    assert(m1.size()          == m0.size());
-    assert(m1.str()           == m0.str());
+    assert(m1.size() == m0.size());
+    assert(!m1.ready() || !m0.ready() || m1.str() == m0.str());
     if (std::allocator_traits<Allocator>::propagate_on_container_copy_assignment::value)
         assert(m1.get_allocator() == m0.get_allocator());
     else
         assert(m1.get_allocator() == Allocator());
 }
 
 int main(int, char**)
 {

test/std/re/re.results/re.results.const/default.pass.cpp

 #include "test_macros.h"
 
 template <class CharT>
 void
 test()
 {
     std::match_results<const CharT*> m;
     assert(m.size() == 0);
-    assert(m.str() == std::basic_string<CharT>());
+    assert(!m.ready() || m.str() == std::basic_string<CharT>());
     assert(m.get_allocator() == std::allocator<std::sub_match<const CharT*> >());
 }
 
 int main(int, char**)
 {
     test<char>();
     test<wchar_t>();
 
   return 0;
 }

test/std/re/re.results/re.results.const/move.pass.cpp

test(const Allocator& a)
     typedef std::match_results<const CharT*, Allocator> SM;
     ASSERT_NOEXCEPT(SM(std::declval<SM&&>()));
 
     SM m0(a);
     assert(m0.get_allocator() == a);
 
     SM m1(std::move(m0));
     assert(m1.size() == 0);
-    assert(m1.str() == std::basic_string<CharT>());
+    assert(!m1.ready() || m1.str() == std::basic_string<CharT>());
     assert(m1.get_allocator() == a);
 }
 
 int main(int, char**)
 {
     test<char>   (std::allocator<std::sub_match<const char *> >());
     test<wchar_t>(std::allocator<std::sub_match<const wchar_t *> >());
 
     test<char>   (test_allocator<std::sub_match<const char*> >(3));
     assert(test_alloc_base::moved == 1);
     test<wchar_t>(test_allocator<std::sub_match<const wchar_t*> >(3));
     assert(test_alloc_base::moved == 2);
 
   return 0;
 }

test/std/re/re.results/re.results.const/move_assign.pass.cpp

 void
 test(const Allocator& a)
 {
     typedef std::match_results<const CharT*, Allocator> SM;
     SM m0(a);
     SM m1;
 
     m1 = std::move(m0);
-    assert(m1.size()          == 0);
-    assert(m1.str()           == std::basic_string<CharT>());
+    assert(m1.size() == 0);
+    assert(!m1.ready() || m1.str() == std::basic_string<CharT>());
     if (std::allocator_traits<Allocator>::propagate_on_container_move_assignment::value)
         assert(m1.get_allocator() == a);
     else
         assert(m1.get_allocator() == Allocator());
 }
 
 int main(int, char**)
 {