[libcxx] Mark most test/std/future tests as UNSUPPORTED in C++03

Summary:
This patch marks *most* tests for `std::promise`, `std::future` and `std::shared_future` as unsupported in C++03. These tests fail in C++03 mode because they attempt to copy a `std::future` even though it is a `MoveOnly` type. AFAIK the missing move-semantics in `std::future` is the only reason these tests fail but without move semantics these classes are useless. For example even though `std::promise::set_value` and `std::promise::set_exception(...)` work in C++03 `std::promise` is still useless because we cannot call `std::promise::get_future(...)`.

It might be possible to hack `std::move(...)` like we do for `std::unique_ptr` to make the move semantics work but I don't think it is worth the effort. Instead I think we should leave the `<future>` header as-is and mark the failing tests as `UNSUPPORTED`. I don't believe there are any users of `std::future` or `std::promise` in C++03 because they are so unusable. Therefore I am not concerned about losing test coverage and possibly breaking users. However because there are still parts of `<future>` that work in C++03 it would be wrong to `#ifdef` out the entire header.

@mclow.lists Should we take further steps to prevent the use of `std::promise`, `std::future` and `std::shared_future` in C++03?


Note: This patch also cleans up the tests and converts them to use `support/test_allocator.h` instead of a duplicate class in `test/std/futures/test_allocator.h`.

Reviewers: mclow.lists

Subscribers: vsk, mclow.lists, cfe-commits

Differential Revision: http://reviews.llvm.org/D12135

git-svn-id: https://llvm.org/svn/llvm-project/libcxx/trunk@246271 91177308-0d34-0410-b5e6-96231b3b80d8

18 files changed, 127 insertions, 186 deletions

diff --git a/test/std/thread/futures/futures.promise/alloc_ctor.pass.cpp b/test/std/thread/futures/futures.promise/alloc_ctor.pass.cpp
index 70a4e00b0..c0fe2ef88 100644
--- a/test/std/thread/futures/futures.promise/alloc_ctor.pass.cpp
+++ b/test/std/thread/futures/futures.promise/alloc_ctor.pass.cpp
@@ -8,6 +8,7 @@
 //===----------------------------------------------------------------------===//
 //
 // UNSUPPORTED: libcpp-has-no-threads
+// UNSUPPORTED: c++98, c++03
 
 // <future>
 
@@ -19,36 +20,36 @@
 #include <future>
 #include <cassert>
 
-#include "../test_allocator.h"
+#include "test_allocator.h"
 #include "min_allocator.h"
 
 int main()
 {
-    assert(test_alloc_base::count == 0);
+    assert(test_alloc_base::alloc_count == 0);
     {
-        std::promise<int> p(std::allocator_arg, test_allocator<int>());
-        assert(test_alloc_base::count == 1);
+        std::promise<int> p(std::allocator_arg, test_allocator<int>(42));
+        assert(test_alloc_base::alloc_count == 1);
         std::future<int> f = p.get_future();
-        assert(test_alloc_base::count == 1);
+        assert(test_alloc_base::alloc_count == 1);
         assert(f.valid());
     }
-    assert(test_alloc_base::count == 0);
+    assert(test_alloc_base::alloc_count == 0);
     {
-        std::promise<int&> p(std::allocator_arg, test_allocator<int>());
-        assert(test_alloc_base::count == 1);
+        std::promise<int&> p(std::allocator_arg, test_allocator<int>(42));
+        assert(test_alloc_base::alloc_count == 1);
         std::future<int&> f = p.get_future();
-        assert(test_alloc_base::count == 1);
+        assert(test_alloc_base::alloc_count == 1);
         assert(f.valid());
     }
-    assert(test_alloc_base::count == 0);
+    assert(test_alloc_base::alloc_count == 0);
     {
-        std::promise<void> p(std::allocator_arg, test_allocator<void>());
-        assert(test_alloc_base::count == 1);
+        std::promise<void> p(std::allocator_arg, test_allocator<void>(42));
+        assert(test_alloc_base::alloc_count == 1);
         std::future<void> f = p.get_future();
-        assert(test_alloc_base::count == 1);
+        assert(test_alloc_base::alloc_count == 1);
         assert(f.valid());
     }
-    assert(test_alloc_base::count == 0);
+    assert(test_alloc_base::alloc_count == 0);
     // Test with a minimal allocator
     {
         std::promise<int> p(std::allocator_arg, bare_allocator<void>());
diff --git a/test/std/thread/futures/futures.promise/copy_assign.fail.cpp b/test/std/thread/futures/futures.promise/copy_assign.fail.cpp
index c08278122..e150ba0df 100644
--- a/test/std/thread/futures/futures.promise/copy_assign.fail.cpp
+++ b/test/std/thread/futures/futures.promise/copy_assign.fail.cpp
@@ -14,74 +14,36 @@
 // promise& operator=(const promise& rhs) = delete;
 
 #include <future>
-#include <cassert>
 
-#include "../test_allocator.h"
+#include "test_macros.h"
 
 int main()
 {
-    assert(test_alloc_base::count == 0);
+#if TEST_STD_VER >= 11
     {
-        std::promise<int> p0(std::allocator_arg, test_allocator<int>());
-        std::promise<int> p(std::allocator_arg, test_allocator<int>());
-        assert(test_alloc_base::count == 2);
-        p = p0;
-        assert(test_alloc_base::count == 1);
-        std::future<int> f = p.get_future();
-        assert(test_alloc_base::count == 1);
-        assert(f.valid());
-        try
-        {
-            f = p0.get_future();
-            assert(false);
-        }
-        catch (const std::future_error& e)
-        {
-            assert(e.code() == make_error_code(std::future_errc::no_state));
-        }
-        assert(test_alloc_base::count == 1);
+        std::promise<int> p0, p;
+        p = p0; // expected-error {{overload resolution selected deleted operator '='}}
     }
-    assert(test_alloc_base::count == 0);
     {
-        std::promise<int&> p0(std::allocator_arg, test_allocator<int>());
-        std::promise<int&> p(std::allocator_arg, test_allocator<int>());
-        assert(test_alloc_base::count == 2);
-        p = p0;
-        assert(test_alloc_base::count == 1);
-        std::future<int&> f = p.get_future();
-        assert(test_alloc_base::count == 1);
-        assert(f.valid());
-        try
-        {
-            f = p0.get_future();
-            assert(false);
-        }
-        catch (const std::future_error& e)
-        {
-            assert(e.code() == make_error_code(std::future_errc::no_state));
-        }
-        assert(test_alloc_base::count == 1);
+        std::promise<int&> p0, p;
+        p = p0; // expected-error {{overload resolution selected deleted operator '='}}
     }
-    assert(test_alloc_base::count == 0);
     {
-        std::promise<void> p0(std::allocator_arg, test_allocator<void>());
-        std::promise<void> p(std::allocator_arg, test_allocator<void>());
-        assert(test_alloc_base::count == 2);
-        p = p0;
-        assert(test_alloc_base::count == 1);
-        std::future<void> f = p.get_future();
-        assert(test_alloc_base::count == 1);
-        assert(f.valid());
-        try
-        {
-            f = p0.get_future();
-            assert(false);
-        }
-        catch (const std::future_error& e)
-        {
-            assert(e.code() == make_error_code(std::future_errc::no_state));
-        }
-        assert(test_alloc_base::count == 1);
+        std::promise<void> p0, p;
+        p = p0; // expected-error {{overload resolution selected deleted operator '='}}
     }
-    assert(test_alloc_base::count == 0);
+#else
+    {
+        std::promise<int> p0, p;
+        p = p0; // expected-error {{'operator=' is a private member of 'std::__1::promise<int>'}}
+    }
+    {
+        std::promise<int&> p0, p;
+        p = p0; // expected-error {{'operator=' is a private member of 'std::__1::promise<int &>'}}
+    }
+    {
+        std::promise<void> p0, p;
+        p = p0; // expected-error {{'operator=' is a private member of 'std::__1::promise<void>'}}
+    }
+#endif
 }
diff --git a/test/std/thread/futures/futures.promise/copy_ctor.fail.cpp b/test/std/thread/futures/futures.promise/copy_ctor.fail.cpp
index 36a3555ae..34becbc12 100644
--- a/test/std/thread/futures/futures.promise/copy_ctor.fail.cpp
+++ b/test/std/thread/futures/futures.promise/copy_ctor.fail.cpp
@@ -14,68 +14,36 @@
 // promise(const promise&) = delete;
 
 #include <future>
-#include <cassert>
 
-#include "../test_allocator.h"
+#include "test_macros.h"
 
 int main()
 {
-    assert(test_alloc_base::count == 0);
+#if TEST_STD_VER >= 11
     {
-        std::promise<int> p0(std::allocator_arg, test_allocator<int>());
-        std::promise<int> p(p0);
-        assert(test_alloc_base::count == 1);
-        std::future<int> f = p.get_future();
-        assert(test_alloc_base::count == 1);
-        assert(f.valid());
-        try
-        {
-            f = p0.get_future();
-            assert(false);
-        }
-        catch (const std::future_error& e)
-        {
-            assert(e.code() == make_error_code(std::future_errc::no_state));
-        }
-        assert(test_alloc_base::count == 1);
+        std::promise<int> p0;
+        std::promise<int> p(p0); // expected-error {{call to deleted constructor of 'std::promise<int>'}}
     }
-    assert(test_alloc_base::count == 0);
     {
-        std::promise<int&> p0(std::allocator_arg, test_allocator<int>());
-        std::promise<int&> p(p0);
-        assert(test_alloc_base::count == 1);
-        std::future<int&> f = p.get_future();
-        assert(test_alloc_base::count == 1);
-        assert(f.valid());
-        try
-        {
-            f = p0.get_future();
-            assert(false);
-        }
-        catch (const std::future_error& e)
-        {
-            assert(e.code() == make_error_code(std::future_errc::no_state));
-        }
-        assert(test_alloc_base::count == 1);
+        std::promise<int &> p0;
+        std::promise<int &> p(p0); // expected-error {{call to deleted constructor of 'std::promise<int &>'}}
     }
-    assert(test_alloc_base::count == 0);
     {
-        std::promise<void> p0(std::allocator_arg, test_allocator<void>());
-        std::promise<void> p(p0);
-        assert(test_alloc_base::count == 1);
-        std::future<void> f = p.get_future();
-        assert(test_alloc_base::count == 1);
-        assert(f.valid());
-        try
-        {
-            f = p0.get_future();
-            assert(false);
-        }
-        catch (const std::future_error& e)
-        {
-            assert(e.code() == make_error_code(std::future_errc::no_state));
-        }
-        assert(test_alloc_base::count == 1);
+        std::promise<void> p0;
+        std::promise<void> p(p0); // expected-error {{call to deleted constructor of 'std::promise<void>'}}
     }
-    assert(test_alloc_base::count == 0);
+#else
+    {
+        std::promise<int> p0;
+        std::promise<int> p(p0); // expected-error {{calling a private constructor of class 'std::__1::promise<int>'}}
+    }
+    {
+        std::promise<int &> p0;
+        std::promise<int &> p(p0); // expected-error {{calling a private constructor of class 'std::__1::promise<int &>'}}
+    }
+    {
+        std::promise<void> p0;
+        std::promise<void> p(p0); // expected-error {{calling a private constructor of class 'std::__1::promise<void>'}}
+    }
+#endif
 }
diff --git a/test/std/thread/futures/futures.promise/default.pass.cpp b/test/std/thread/futures/futures.promise/default.pass.cpp
index 95c9657c6..d108b4275 100644
--- a/test/std/thread/futures/futures.promise/default.pass.cpp
+++ b/test/std/thread/futures/futures.promise/default.pass.cpp
@@ -8,6 +8,7 @@
 //===----------------------------------------------------------------------===//
 //
 // UNSUPPORTED: libcpp-has-no-threads
+// UNSUPPORTED: c++98, c++03
 
 // <future>
 
diff --git a/test/std/thread/futures/futures.promise/dtor.pass.cpp b/test/std/thread/futures/futures.promise/dtor.pass.cpp
index 78912f12a..a28e886bc 100644
--- a/test/std/thread/futures/futures.promise/dtor.pass.cpp
+++ b/test/std/thread/futures/futures.promise/dtor.pass.cpp
@@ -8,6 +8,7 @@
 //===----------------------------------------------------------------------===//
 //
 // UNSUPPORTED: libcpp-has-no-threads
+// UNSUPPORTED: c++98, c++03
 
 // <future>
 
diff --git a/test/std/thread/futures/futures.promise/get_future.pass.cpp b/test/std/thread/futures/futures.promise/get_future.pass.cpp
index a7d084ee7..8392c9f7b 100644
--- a/test/std/thread/futures/futures.promise/get_future.pass.cpp
+++ b/test/std/thread/futures/futures.promise/get_future.pass.cpp
@@ -8,6 +8,7 @@
 //===----------------------------------------------------------------------===//
 //
 // UNSUPPORTED: libcpp-has-no-threads
+// UNSUPPORTED: c++98, c++03
 
 // <future>
 
diff --git a/test/std/thread/futures/futures.promise/move_assign.pass.cpp b/test/std/thread/futures/futures.promise/move_assign.pass.cpp
index c3097df74..80f4046db 100644
--- a/test/std/thread/futures/futures.promise/move_assign.pass.cpp
+++ b/test/std/thread/futures/futures.promise/move_assign.pass.cpp
@@ -8,6 +8,7 @@
 //===----------------------------------------------------------------------===//
 //
 // UNSUPPORTED: libcpp-has-no-threads
+// UNSUPPORTED: c++98, c++03
 
 // <future>
 
@@ -18,20 +19,19 @@
 #include <future>
 #include <cassert>
 
-#include "../test_allocator.h"
+#include "test_allocator.h"
 
 int main()
 {
-#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
-    assert(test_alloc_base::count == 0);
+    assert(test_alloc_base::alloc_count == 0);
     {
         std::promise<int> p0(std::allocator_arg, test_allocator<int>());
         std::promise<int> p(std::allocator_arg, test_allocator<int>());
-        assert(test_alloc_base::count == 2);
+        assert(test_alloc_base::alloc_count == 2);
         p = std::move(p0);
-        assert(test_alloc_base::count == 1);
+        assert(test_alloc_base::alloc_count == 1);
         std::future<int> f = p.get_future();
-        assert(test_alloc_base::count == 1);
+        assert(test_alloc_base::alloc_count == 1);
         assert(f.valid());
         try
         {
@@ -42,17 +42,17 @@ int main()
         {
             assert(e.code() == make_error_code(std::future_errc::no_state));
         }
-        assert(test_alloc_base::count == 1);
+        assert(test_alloc_base::alloc_count == 1);
     }
-    assert(test_alloc_base::count == 0);
+    assert(test_alloc_base::alloc_count == 0);
     {
         std::promise<int&> p0(std::allocator_arg, test_allocator<int>());
         std::promise<int&> p(std::allocator_arg, test_allocator<int>());
-        assert(test_alloc_base::count == 2);
+        assert(test_alloc_base::alloc_count == 2);
         p = std::move(p0);
-        assert(test_alloc_base::count == 1);
+        assert(test_alloc_base::alloc_count == 1);
         std::future<int&> f = p.get_future();
-        assert(test_alloc_base::count == 1);
+        assert(test_alloc_base::alloc_count == 1);
         assert(f.valid());
         try
         {
@@ -63,17 +63,17 @@ int main()
         {
             assert(e.code() == make_error_code(std::future_errc::no_state));
         }
-        assert(test_alloc_base::count == 1);
+        assert(test_alloc_base::alloc_count == 1);
     }
-    assert(test_alloc_base::count == 0);
+    assert(test_alloc_base::alloc_count == 0);
     {
         std::promise<void> p0(std::allocator_arg, test_allocator<void>());
         std::promise<void> p(std::allocator_arg, test_allocator<void>());
-        assert(test_alloc_base::count == 2);
+        assert(test_alloc_base::alloc_count == 2);
         p = std::move(p0);
-        assert(test_alloc_base::count == 1);
+        assert(test_alloc_base::alloc_count == 1);
         std::future<void> f = p.get_future();
-        assert(test_alloc_base::count == 1);
+        assert(test_alloc_base::alloc_count == 1);
         assert(f.valid());
         try
         {
@@ -84,8 +84,7 @@ int main()
         {
             assert(e.code() == make_error_code(std::future_errc::no_state));
         }
-        assert(test_alloc_base::count == 1);
+        assert(test_alloc_base::alloc_count == 1);
     }
-    assert(test_alloc_base::count == 0);
-#endif  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
+    assert(test_alloc_base::alloc_count == 0);
 }
diff --git a/test/std/thread/futures/futures.promise/move_ctor.pass.cpp b/test/std/thread/futures/futures.promise/move_ctor.pass.cpp
index eeec4fb15..d45c48a95 100644
--- a/test/std/thread/futures/futures.promise/move_ctor.pass.cpp
+++ b/test/std/thread/futures/futures.promise/move_ctor.pass.cpp
@@ -8,6 +8,7 @@
 //===----------------------------------------------------------------------===//
 //
 // UNSUPPORTED: libcpp-has-no-threads
+// UNSUPPORTED: c++98, c++03
 
 // <future>
 
@@ -18,18 +19,17 @@
 #include <future>
 #include <cassert>
 
-#include "../test_allocator.h"
+#include "test_allocator.h"
 
 int main()
 {
-#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
-    assert(test_alloc_base::count == 0);
+    assert(test_alloc_base::alloc_count == 0);
     {
         std::promise<int> p0(std::allocator_arg, test_allocator<int>());
         std::promise<int> p(std::move(p0));
-        assert(test_alloc_base::count == 1);
+        assert(test_alloc_base::alloc_count == 1);
         std::future<int> f = p.get_future();
-        assert(test_alloc_base::count == 1);
+        assert(test_alloc_base::alloc_count == 1);
         assert(f.valid());
         try
         {
@@ -40,15 +40,15 @@ int main()
         {
             assert(e.code() == make_error_code(std::future_errc::no_state));
         }
-        assert(test_alloc_base::count == 1);
+        assert(test_alloc_base::alloc_count == 1);
     }
-    assert(test_alloc_base::count == 0);
+    assert(test_alloc_base::alloc_count == 0);
     {
         std::promise<int&> p0(std::allocator_arg, test_allocator<int>());
         std::promise<int&> p(std::move(p0));
-        assert(test_alloc_base::count == 1);
+        assert(test_alloc_base::alloc_count == 1);
         std::future<int&> f = p.get_future();
-        assert(test_alloc_base::count == 1);
+        assert(test_alloc_base::alloc_count == 1);
         assert(f.valid());
         try
         {
@@ -59,15 +59,15 @@ int main()
         {
             assert(e.code() == make_error_code(std::future_errc::no_state));
         }
-        assert(test_alloc_base::count == 1);
+        assert(test_alloc_base::alloc_count == 1);
     }
-    assert(test_alloc_base::count == 0);
+    assert(test_alloc_base::alloc_count == 0);
     {
         std::promise<void> p0(std::allocator_arg, test_allocator<void>());
         std::promise<void> p(std::move(p0));
-        assert(test_alloc_base::count == 1);
+        assert(test_alloc_base::alloc_count == 1);
         std::future<void> f = p.get_future();
-        assert(test_alloc_base::count == 1);
+        assert(test_alloc_base::alloc_count == 1);
         assert(f.valid());
         try
         {
@@ -78,8 +78,7 @@ int main()
         {
             assert(e.code() == make_error_code(std::future_errc::no_state));
         }
-        assert(test_alloc_base::count == 1);
+        assert(test_alloc_base::alloc_count == 1);
     }
-    assert(test_alloc_base::count == 0);
-#endif  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
+    assert(test_alloc_base::alloc_count == 0);
 }
diff --git a/test/std/thread/futures/futures.promise/set_exception.pass.cpp b/test/std/thread/futures/futures.promise/set_exception.pass.cpp
index 51c05eb80..00668f18e 100644
--- a/test/std/thread/futures/futures.promise/set_exception.pass.cpp
+++ b/test/std/thread/futures/futures.promise/set_exception.pass.cpp
@@ -8,6 +8,7 @@
 //===----------------------------------------------------------------------===//
 //
 // UNSUPPORTED: libcpp-has-no-threads
+// UNSUPPORTED: c++98, c++03
 
 // <future>
 
diff --git a/test/std/thread/futures/futures.promise/set_exception_at_thread_exit.pass.cpp b/test/std/thread/futures/futures.promise/set_exception_at_thread_exit.pass.cpp
index 5e5769256..77a6d123e 100644
--- a/test/std/thread/futures/futures.promise/set_exception_at_thread_exit.pass.cpp
+++ b/test/std/thread/futures/futures.promise/set_exception_at_thread_exit.pass.cpp
@@ -8,6 +8,7 @@
 //===----------------------------------------------------------------------===//
 //
 // UNSUPPORTED: libcpp-has-no-threads
+// UNSUPPORTED: c++98, c++03
 
 // <future>
 
diff --git a/test/std/thread/futures/futures.promise/set_lvalue.pass.cpp b/test/std/thread/futures/futures.promise/set_lvalue.pass.cpp
index cdc377750..5a75429ac 100644
--- a/test/std/thread/futures/futures.promise/set_lvalue.pass.cpp
+++ b/test/std/thread/futures/futures.promise/set_lvalue.pass.cpp
@@ -8,6 +8,7 @@
 //===----------------------------------------------------------------------===//
 //
 // UNSUPPORTED: libcpp-has-no-threads
+// UNSUPPORTED: c++98, c++03
 
 // <future>
 
diff --git a/test/std/thread/futures/futures.promise/set_lvalue_at_thread_exit.pass.cpp b/test/std/thread/futures/futures.promise/set_lvalue_at_thread_exit.pass.cpp
index 18f87c596..e127d2c37 100644
--- a/test/std/thread/futures/futures.promise/set_lvalue_at_thread_exit.pass.cpp
+++ b/test/std/thread/futures/futures.promise/set_lvalue_at_thread_exit.pass.cpp
@@ -8,6 +8,7 @@
 //===----------------------------------------------------------------------===//
 //
 // UNSUPPORTED: libcpp-has-no-threads
+// UNSUPPORTED: c++98, c++03
 
 // <future>
 
diff --git a/test/std/thread/futures/futures.promise/set_value_at_thread_exit_const.pass.cpp b/test/std/thread/futures/futures.promise/set_value_at_thread_exit_const.pass.cpp
index ec50cc310..79137488e 100644
--- a/test/std/thread/futures/futures.promise/set_value_at_thread_exit_const.pass.cpp
+++ b/test/std/thread/futures/futures.promise/set_value_at_thread_exit_const.pass.cpp
@@ -8,6 +8,7 @@
 //===----------------------------------------------------------------------===//
 //
 // UNSUPPORTED: libcpp-has-no-threads
+// UNSUPPORTED: c++98, c++03
 
 // <future>
 
diff --git a/test/std/thread/futures/futures.promise/set_value_at_thread_exit_void.pass.cpp b/test/std/thread/futures/futures.promise/set_value_at_thread_exit_void.pass.cpp
index 8c0920846..6a0ce3632 100644
--- a/test/std/thread/futures/futures.promise/set_value_at_thread_exit_void.pass.cpp
+++ b/test/std/thread/futures/futures.promise/set_value_at_thread_exit_void.pass.cpp
@@ -8,6 +8,7 @@
 //===----------------------------------------------------------------------===//
 //
 // UNSUPPORTED: libcpp-has-no-threads
+// UNSUPPORTED: c++98, c++03
 
 // <future>
 
diff --git a/test/std/thread/futures/futures.promise/set_value_const.pass.cpp b/test/std/thread/futures/futures.promise/set_value_const.pass.cpp
index 6673f6307..315956d4a 100644
--- a/test/std/thread/futures/futures.promise/set_value_const.pass.cpp
+++ b/test/std/thread/futures/futures.promise/set_value_const.pass.cpp
@@ -8,6 +8,7 @@
 //===----------------------------------------------------------------------===//
 //
 // UNSUPPORTED: libcpp-has-no-threads
+// UNSUPPORTED: c++98, c++03
 
 // <future>
 
diff --git a/test/std/thread/futures/futures.promise/set_value_void.pass.cpp b/test/std/thread/futures/futures.promise/set_value_void.pass.cpp
index 5012e0bfe..5ede08191 100644
--- a/test/std/thread/futures/futures.promise/set_value_void.pass.cpp
+++ b/test/std/thread/futures/futures.promise/set_value_void.pass.cpp
@@ -8,6 +8,7 @@
 //===----------------------------------------------------------------------===//
 //
 // UNSUPPORTED: libcpp-has-no-threads
+// UNSUPPORTED: c++98, c++03
 
 // <future>
 
diff --git a/test/std/thread/futures/futures.promise/swap.pass.cpp b/test/std/thread/futures/futures.promise/swap.pass.cpp
index 1ed3e6468..21c946981 100644
--- a/test/std/thread/futures/futures.promise/swap.pass.cpp
+++ b/test/std/thread/futures/futures.promise/swap.pass.cpp
@@ -8,6 +8,7 @@
 //===----------------------------------------------------------------------===//
 //
 // UNSUPPORTED: libcpp-has-no-threads
+// UNSUPPORTED: c++98, c++03
 
 // <future>
 
@@ -20,65 +21,65 @@
 #include <future>
 #include <cassert>
 
-#include "../test_allocator.h"
+#include "test_allocator.h"
 
 int main()
 {
-    assert(test_alloc_base::count == 0);
+    assert(test_alloc_base::alloc_count == 0);
     {
         std::promise<int> p0(std::allocator_arg, test_allocator<int>());
         std::promise<int> p(std::allocator_arg, test_allocator<int>());
-        assert(test_alloc_base::count == 2);
+        assert(test_alloc_base::alloc_count == 2);
         p.swap(p0);
-        assert(test_alloc_base::count == 2);
+        assert(test_alloc_base::alloc_count == 2);
         std::future<int> f = p.get_future();
-        assert(test_alloc_base::count == 2);
+        assert(test_alloc_base::alloc_count == 2);
         assert(f.valid());
         f = p0.get_future();
         assert(f.valid());
-        assert(test_alloc_base::count == 2);
+        assert(test_alloc_base::alloc_count == 2);
     }
-    assert(test_alloc_base::count == 0);
+    assert(test_alloc_base::alloc_count == 0);
     {
         std::promise<int> p0(std::allocator_arg, test_allocator<int>());
         std::promise<int> p(std::allocator_arg, test_allocator<int>());
-        assert(test_alloc_base::count == 2);
+        assert(test_alloc_base::alloc_count == 2);
         swap(p, p0);
-        assert(test_alloc_base::count == 2);
+        assert(test_alloc_base::alloc_count == 2);
         std::future<int> f = p.get_future();
-        assert(test_alloc_base::count == 2);
+        assert(test_alloc_base::alloc_count == 2);
         assert(f.valid());
         f = p0.get_future();
         assert(f.valid());
-        assert(test_alloc_base::count == 2);
+        assert(test_alloc_base::alloc_count == 2);
     }
-    assert(test_alloc_base::count == 0);
+    assert(test_alloc_base::alloc_count == 0);
     {
         std::promise<int> p0(std::allocator_arg, test_allocator<int>());
         std::promise<int> p;
-        assert(test_alloc_base::count == 1);
+        assert(test_alloc_base::alloc_count == 1);
         p.swap(p0);
-        assert(test_alloc_base::count == 1);
+        assert(test_alloc_base::alloc_count == 1);
         std::future<int> f = p.get_future();
-        assert(test_alloc_base::count == 1);
+        assert(test_alloc_base::alloc_count == 1);
         assert(f.valid());
         f = p0.get_future();
         assert(f.valid());
-        assert(test_alloc_base::count == 1);
+        assert(test_alloc_base::alloc_count == 1);
     }
-    assert(test_alloc_base::count == 0);
+    assert(test_alloc_base::alloc_count == 0);
     {
         std::promise<int> p0(std::allocator_arg, test_allocator<int>());
         std::promise<int> p;
-        assert(test_alloc_base::count == 1);
+        assert(test_alloc_base::alloc_count == 1);
         swap(p, p0);
-        assert(test_alloc_base::count == 1);
+        assert(test_alloc_base::alloc_count == 1);
         std::future<int> f = p.get_future();
-        assert(test_alloc_base::count == 1);
+        assert(test_alloc_base::alloc_count == 1);
         assert(f.valid());
         f = p0.get_future();
         assert(f.valid());
-        assert(test_alloc_base::count == 1);
+        assert(test_alloc_base::alloc_count == 1);
     }
-    assert(test_alloc_base::count == 0);
+    assert(test_alloc_base::alloc_count == 0);
 }
diff --git a/test/std/thread/futures/futures.promise/uses_allocator.pass.cpp b/test/std/thread/futures/futures.promise/uses_allocator.pass.cpp
index 458826e95..9a1d41cc0 100644
--- a/test/std/thread/futures/futures.promise/uses_allocator.pass.cpp
+++ b/test/std/thread/futures/futures.promise/uses_allocator.pass.cpp
@@ -18,7 +18,7 @@
 //      : true_type { };
 
 #include <future>
-#include "../test_allocator.h"
+#include "test_allocator.h"
 
 int main()
 {