[libcxx] Fix current_exception test on Windows.

[halyavin]

Summary

Take extra copies in current_exception() into account.

[halyavin]

Add lower bound too.

test/std/language.support/support.exception/propagation/current_exception.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is dual licensed under the MIT and the University of Illinois Open
 // Source Licenses. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
-// This test needs to be rewritten for the Windows exception_ptr semantics
-// which copy the exception each time the exception_ptr is copied.
-// XFAIL: LIBCXX-WINDOWS-FIXME
-
 // UNSUPPORTED: libcpp-no-exceptions
 // <exception>
 
 // exception_ptr current_exception();
 
 #include <exception>
 #include <cassert>
 
int main()
         catch (...)
         {
             assert(A::constructed == 1);
         }
         assert(A::constructed == 0);
     }
     assert(A::constructed == 0);
     {
+        try 
+        {
+            throw A();
+            assert(false);
+        }
+        catch(...)
+        {
+            std::exception_ptr p = std::current_exception();
+            int constructed_before = A::constructed;
+            std::exception_ptr p2 = p;
+            assert(A::constructed == constructed_before);
+            assert(p == p2);
+        }
+    }
+    assert(A::constructed == 0);
+    {
         std::exception_ptr p2;
         try
         {
             assert(A::constructed == 0);
             throw A();
             assert(false);
         }
         catch (...)
         {
             std::exception_ptr p = std::current_exception();
-            assert(A::constructed == 1);
+            assert(1 <= A::constructed && A::constructed <= 2);
             assert(p != nullptr);
             p2 = std::current_exception();
-            assert(A::constructed == 1);
-            assert(p == p2);
+            assert(1 <= A::constructed && A::constructed <= 3);
         }
         assert(A::constructed == 1);
     }
     assert(A::constructed == 0);
     {
         std::exception_ptr p2;
         try
         {
             assert(A::constructed == 0);
             throw A();
             assert(false);
         }
         catch (A&)
         {
             std::exception_ptr p = std::current_exception();
-            assert(A::constructed == 1);
+            assert(1 <= A::constructed && A::constructed <= 2);
             assert(p != nullptr);
             p2 = std::current_exception();
-            assert(A::constructed == 1);
-            assert(p == p2);
+            assert(1 <= A::constructed && A::constructed <= 3);
         }
         assert(A::constructed == 1);
     }
     assert(A::constructed == 0);
     {
         std::exception_ptr p2;
         try
         {
             assert(A::constructed == 0);
             throw A();
             assert(false);
         }
         catch (A)
         {
             std::exception_ptr p = std::current_exception();
-            assert(A::constructed == 2);
+            assert(2 <= A::constructed && A::constructed <= 3);
             assert(p != nullptr);
             p2 = std::current_exception();
-            assert(A::constructed == 2);
-            assert(p == p2);
+            assert(2 <= A::constructed && A::constructed <= 4);
         }
         assert(A::constructed == 1);
     }
     assert(A::constructed == 0);
     {
         try
         {
             assert(A::constructed == 0);
assert(A::constructed == 0);
             assert(false);
         }
         catch (...)
         {
             assert(A::constructed == 1);
             try
             {
                 std::exception_ptr p = std::current_exception();
-                assert(A::constructed == 1);
+                assert(1 <= A::constructed && A::constructed <= 2);
                 assert(p != nullptr);
                 throw;
                 assert(false);
             }
             catch (...)
             {
                 assert(A::constructed == 1);
             }
assert(A::constructed == 0);
             {
                 assert(A::constructed == 1);
                 throw;
                 assert(false);
             }
             catch (...)
             {
                 std::exception_ptr p = std::current_exception();
-                assert(A::constructed == 1);
+                assert(1 <= A::constructed && A::constructed <= 2);
                 assert(p != nullptr);
             }
             assert(A::constructed == 1);
         }
         assert(A::constructed == 0);
     }
     assert(A::constructed == 0);
     {
assert(A::constructed == 0);
                 throw;
                 assert(false);
             }
             catch (...)
             {
                 assert(A::constructed == 1);
             }
             std::exception_ptr p = std::current_exception();
-            assert(A::constructed == 1);
+            assert(1 <= A::constructed && A::constructed <= 2);
             assert(p != nullptr);
         }
         assert(A::constructed == 0);
     }
     assert(A::constructed == 0);
     {
         try
         {
assert(A::constructed == 0);
             {
                 assert(A::constructed == 1);
                 throw;
                 assert(false);
             }
             catch (...)
             {
                 p = std::current_exception();
-                assert(A::constructed == 1);
+                assert(1 <= A::constructed && A::constructed <= 2);
             }
-            assert(A::constructed == 1);
+            assert(1 <= A::constructed && A::constructed <= 2);
         }
         assert(A::constructed == 1);
         assert(p != nullptr);
     }
     assert(A::constructed == 0);
 }