generic-library/cxx
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

Implemented N3194

Browse Source 
git-svn-id: https://llvm.org/svn/llvm-project/libcxx/trunk@120458 91177308-0d34-0410-b5e6-96231b3b80d8
This commit is contained in:
Howard Hinnant
2010-11-30 20:23:32 +00:00
parent ac417faebc
commit 7de47902d0
20 changed files with 62 additions and 1021 deletions
Download Patch File Download Diff File Expand all files Collapse all files

74
test/thread/futures/futures.atomic_future/copy_assign.pass.cpp
View File

@@ -1,74 +0,0 @@
//===----------------------------------------------------------------------===//
//
// 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.
//
//===----------------------------------------------------------------------===//
// <future>
// class atomic_future<R>
// atomic_future& operator=(const atomic_future& rhs);
#include <future>
#include <cassert>
int main()
{
#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
{
typedef int T;
std::promise<T> p;
std::atomic_future<T> f0 = p.get_future();
std::atomic_future<T> f;
f = f0;
assert(f0.valid());
assert(f.valid());
}
{
typedef int T;
std::atomic_future<T> f0;
std::atomic_future<T> f;
f = f0;
assert(!f0.valid());
assert(!f.valid());
}
{
typedef int& T;
std::promise<T> p;
std::atomic_future<T> f0 = p.get_future();
std::atomic_future<T> f;
f = f0;
assert(f0.valid());
assert(f.valid());
}
{
typedef int& T;
std::atomic_future<T> f0;
std::atomic_future<T> f;
f = f0;
assert(!f0.valid());
assert(!f.valid());
}
{
typedef void T;
std::promise<T> p;
std::atomic_future<T> f0 = p.get_future();
std::atomic_future<T> f;
f = f0;
assert(f0.valid());
assert(f.valid());
}
{
typedef void T;
std::atomic_future<T> f0;
std::atomic_future<T> f;
f = f0;
assert(!f0.valid());
assert(!f.valid());
}
#endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES
}

66
test/thread/futures/futures.atomic_future/copy_ctor.pass.cpp
View File

@@ -1,66 +0,0 @@
//===----------------------------------------------------------------------===//
//
// 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.
//
//===----------------------------------------------------------------------===//
// <future>
// class atomic_future<R>
// atomic_future(const atomic_future& rhs);
#include <future>
#include <cassert>
int main()
{
{
typedef int T;
std::promise<T> p;
std::atomic_future<T> f0 = p.get_future();
std::atomic_future<T> f = f0;
assert(f0.valid());
assert(f.valid());
}
{
typedef int T;
std::atomic_future<T> f0;
std::atomic_future<T> f = f0;
assert(!f0.valid());
assert(!f.valid());
}
{
typedef int& T;
std::promise<T> p;
std::atomic_future<T> f0 = p.get_future();
std::atomic_future<T> f = f0;
assert(f0.valid());
assert(f.valid());
}
{
typedef int& T;
std::atomic_future<T> f0;
std::atomic_future<T> f = std::move(f0);
assert(!f0.valid());
assert(!f.valid());
}
{
typedef void T;
std::promise<T> p;
std::atomic_future<T> f0 = p.get_future();
std::atomic_future<T> f = f0;
assert(f0.valid());
assert(f.valid());
}
{
typedef void T;
std::atomic_future<T> f0;
std::atomic_future<T> f = f0;
assert(!f0.valid());
assert(!f.valid());
}
}

33
test/thread/futures/futures.atomic_future/default.pass.cpp
View File

@@ -1,33 +0,0 @@
//===----------------------------------------------------------------------===//
//
// 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.
//
//===----------------------------------------------------------------------===//
// <future>
// class atomic_future<R>
// atomic_future();
#include <future>
#include <cassert>
int main()
{
{
std::atomic_future<int> f;
assert(!f.valid());
}
{
std::atomic_future<int&> f;
assert(!f.valid());
}
{
std::atomic_future<void> f;
assert(!f.valid());
}
}

66
test/thread/futures/futures.atomic_future/dtor.pass.cpp
View File

@@ -1,66 +0,0 @@
//===----------------------------------------------------------------------===//
//
// 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.
//
//===----------------------------------------------------------------------===//
// <future>
// class atomic_future<R>
// ~atomic_future();
#include <future>
#include <cassert>
#include "../test_allocator.h"
int main()
{
assert(test_alloc_base::count == 0);
{
typedef int T;
std::atomic_future<T> f;
{
std::promise<T> p(std::allocator_arg, test_allocator<T>());
assert(test_alloc_base::count == 1);
f = p.get_future();
assert(test_alloc_base::count == 1);
assert(f.valid());
}
assert(test_alloc_base::count == 1);
assert(f.valid());
}
assert(test_alloc_base::count == 0);
{
typedef int& T;
std::atomic_future<T> f;
{
std::promise<T> p(std::allocator_arg, test_allocator<int>());
assert(test_alloc_base::count == 1);
f = p.get_future();
assert(test_alloc_base::count == 1);
assert(f.valid());
}
assert(test_alloc_base::count == 1);
assert(f.valid());
}
assert(test_alloc_base::count == 0);
{
typedef void T;
std::atomic_future<T> f;
{
std::promise<T> p(std::allocator_arg, test_allocator<T>());
assert(test_alloc_base::count == 1);
f = p.get_future();
assert(test_alloc_base::count == 1);
assert(f.valid());
}
assert(test_alloc_base::count == 1);
assert(f.valid());
}
assert(test_alloc_base::count == 0);
}

143
test/thread/futures/futures.atomic_future/get.pass.cpp
View File

@@ -1,143 +0,0 @@
//===----------------------------------------------------------------------===//
//
// 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.
//
//===----------------------------------------------------------------------===//
// <future>
// class atomic_future<R>
// const R& atomic_future::get();
// R& atomic_future<R&>::get();
// void atomic_future<void>::get();
#include <future>
#include <cassert>
void func1(std::promise<int>& p)
{
std::this_thread::sleep_for(std::chrono::milliseconds(500));
p.set_value(3);
}
void func2(std::promise<int>& p)
{
std::this_thread::sleep_for(std::chrono::milliseconds(500));
p.set_exception(std::make_exception_ptr(3));
}
int j = 0;
void func3(std::promise<int&>& p)
{
std::this_thread::sleep_for(std::chrono::milliseconds(500));
j = 5;
p.set_value(j);
}
void func4(std::promise<int&>& p)
{
std::this_thread::sleep_for(std::chrono::milliseconds(500));
p.set_exception(std::make_exception_ptr(3.5));
}
void func5(std::promise<void>& p)
{
std::this_thread::sleep_for(std::chrono::milliseconds(500));
p.set_value();
}
void func6(std::promise<void>& p)
{
std::this_thread::sleep_for(std::chrono::milliseconds(500));
p.set_exception(std::make_exception_ptr('c'));
}
int main()
{
{
typedef int T;
{
std::promise<T> p;
std::atomic_future<T> f = p.get_future();
std::thread(func1, std::move(p)).detach();
assert(f.valid());
assert(f.get() == 3);
assert(f.valid());
}
{
std::promise<T> p;
std::atomic_future<T> f = p.get_future();
std::thread(func2, std::move(p)).detach();
try
{
assert(f.valid());
assert(f.get() == 3);
assert(false);
}
catch (int i)
{
assert(i == 3);
}
assert(f.valid());
}
}
{
typedef int& T;
{
std::promise<T> p;
std::atomic_future<T> f = p.get_future();
std::thread(func3, std::move(p)).detach();
assert(f.valid());
assert(f.get() == 5);
assert(f.valid());
}
{
std::promise<T> p;
std::atomic_future<T> f = p.get_future();
std::thread(func4, std::move(p)).detach();
try
{
assert(f.valid());
assert(f.get() == 3);
assert(false);
}
catch (double i)
{
assert(i == 3.5);
}
assert(f.valid());
}
}
{
typedef void T;
{
std::promise<T> p;
std::atomic_future<T> f = p.get_future();
std::thread(func5, std::move(p)).detach();
assert(f.valid());
f.get();
assert(f.valid());
}
{
std::promise<T> p;
std::atomic_future<T> f = p.get_future();
std::thread(func6, std::move(p)).detach();
try
{
assert(f.valid());
f.get();
assert(false);
}
catch (char i)
{
assert(i == 'c');
}
assert(f.valid());
}
}
}

86
test/thread/futures/futures.atomic_future/wait.pass.cpp
View File

@@ -1,86 +0,0 @@
//===----------------------------------------------------------------------===//
//
// 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.
//
//===----------------------------------------------------------------------===//
// <future>
// class atomic_future<R>
// void wait() const;
#include <future>
#include <cassert>
void func1(std::promise<int>& p)
{
std::this_thread::sleep_for(std::chrono::milliseconds(500));
p.set_value(3);
}
int j = 0;
void func3(std::promise<int&>& p)
{
std::this_thread::sleep_for(std::chrono::milliseconds(500));
j = 5;
p.set_value(j);
}
void func5(std::promise<void>& p)
{
std::this_thread::sleep_for(std::chrono::milliseconds(500));
p.set_value();
}
int main()
{
typedef std::chrono::high_resolution_clock Clock;
typedef std::chrono::duration<double, std::milli> ms;
{
typedef int T;
std::promise<T> p;
std::atomic_future<T> f = p.get_future();
std::thread(func1, std::move(p)).detach();
assert(f.valid());
f.wait();
assert(f.valid());
Clock::time_point t0 = Clock::now();
f.wait();
Clock::time_point t1 = Clock::now();
assert(f.valid());
assert(t1-t0 < ms(5));
}
{
typedef int& T;
std::promise<T> p;
std::atomic_future<T> f = p.get_future();
std::thread(func3, std::move(p)).detach();
assert(f.valid());
f.wait();
assert(f.valid());
Clock::time_point t0 = Clock::now();
f.wait();
Clock::time_point t1 = Clock::now();
assert(f.valid());
assert(t1-t0 < ms(5));
}
{
typedef void T;
std::promise<T> p;
std::atomic_future<T> f = p.get_future();
std::thread(func5, std::move(p)).detach();
assert(f.valid());
f.wait();
assert(f.valid());
Clock::time_point t0 = Clock::now();
f.wait();
Clock::time_point t1 = Clock::now();
assert(f.valid());
assert(t1-t0 < ms(5));
}
}

95
test/thread/futures/futures.atomic_future/wait_for.pass.cpp
View File

@@ -1,95 +0,0 @@
//===----------------------------------------------------------------------===//
//
// 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.
//
//===----------------------------------------------------------------------===//
// <future>
// class atomic_future<R>
// template <class Rep, class Period>
// future_status
// wait_for(const chrono::duration<Rep, Period>& rel_time) const;
#include <future>
#include <cassert>
typedef std::chrono::milliseconds ms;
void func1(std::promise<int>& p)
{
std::this_thread::sleep_for(ms(500));
p.set_value(3);
}
int j = 0;
void func3(std::promise<int&>& p)
{
std::this_thread::sleep_for(ms(500));
j = 5;
p.set_value(j);
}
void func5(std::promise<void>& p)
{
std::this_thread::sleep_for(ms(500));
p.set_value();
}
int main()
{
typedef std::chrono::high_resolution_clock Clock;
{
typedef int T;
std::promise<T> p;
std::atomic_future<T> f = p.get_future();
std::thread(func1, std::move(p)).detach();
assert(f.valid());
assert(f.wait_for(ms(300)) == std::future_status::timeout);
assert(f.valid());
assert(f.wait_for(ms(300)) == std::future_status::ready);
assert(f.valid());
Clock::time_point t0 = Clock::now();
f.wait();
Clock::time_point t1 = Clock::now();
assert(f.valid());
assert(t1-t0 < ms(5));
}
{
typedef int& T;
std::promise<T> p;
std::atomic_future<T> f = p.get_future();
std::thread(func3, std::move(p)).detach();
assert(f.valid());
assert(f.wait_for(ms(300)) == std::future_status::timeout);
assert(f.valid());
assert(f.wait_for(ms(300)) == std::future_status::ready);
assert(f.valid());
Clock::time_point t0 = Clock::now();
f.wait();
Clock::time_point t1 = Clock::now();
assert(f.valid());
assert(t1-t0 < ms(5));
}
{
typedef void T;
std::promise<T> p;
std::atomic_future<T> f = p.get_future();
std::thread(func5, std::move(p)).detach();
assert(f.valid());
assert(f.wait_for(ms(300)) == std::future_status::timeout);
assert(f.valid());
assert(f.wait_for(ms(300)) == std::future_status::ready);
assert(f.valid());
Clock::time_point t0 = Clock::now();
f.wait();
Clock::time_point t1 = Clock::now();
assert(f.valid());
assert(t1-t0 < ms(5));
}
}

95
test/thread/futures/futures.atomic_future/wait_until.pass.cpp
View File

@@ -1,95 +0,0 @@
//===----------------------------------------------------------------------===//
//
// 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.
//
//===----------------------------------------------------------------------===//
// <future>
// class atomic_future<R>
// template <class Clock, class Duration>
// future_status
// wait_until(const chrono::time_point<Clock, Duration>& abs_time) const;
#include <future>
#include <cassert>
typedef std::chrono::milliseconds ms;
void func1(std::promise<int>& p)
{
std::this_thread::sleep_for(ms(500));
p.set_value(3);
}
int j = 0;
void func3(std::promise<int&>& p)
{
std::this_thread::sleep_for(ms(500));
j = 5;
p.set_value(j);
}
void func5(std::promise<void>& p)
{
std::this_thread::sleep_for(ms(500));
p.set_value();
}
int main()
{
typedef std::chrono::high_resolution_clock Clock;
{
typedef int T;
std::promise<T> p;
std::atomic_future<T> f = p.get_future();
std::thread(func1, std::move(p)).detach();
assert(f.valid());
assert(f.wait_until(Clock::now() + ms(300)) == std::future_status::timeout);
assert(f.valid());
assert(f.wait_until(Clock::now() + ms(300)) == std::future_status::ready);
assert(f.valid());
Clock::time_point t0 = Clock::now();
f.wait();
Clock::time_point t1 = Clock::now();
assert(f.valid());
assert(t1-t0 < ms(5));
}
{
typedef int& T;
std::promise<T> p;
std::atomic_future<T> f = p.get_future();
std::thread(func3, std::move(p)).detach();
assert(f.valid());
assert(f.wait_until(Clock::now() + ms(300)) == std::future_status::timeout);
assert(f.valid());
assert(f.wait_until(Clock::now() + ms(300)) == std::future_status::ready);
assert(f.valid());
Clock::time_point t0 = Clock::now();
f.wait();
Clock::time_point t1 = Clock::now();
assert(f.valid());
assert(t1-t0 < ms(5));
}
{
typedef void T;
std::promise<T> p;
std::atomic_future<T> f = p.get_future();
std::thread(func5, std::move(p)).detach();
assert(f.valid());
assert(f.wait_until(Clock::now() + ms(300)) == std::future_status::timeout);
assert(f.valid());
assert(f.wait_until(Clock::now() + ms(300)) == std::future_status::ready);
assert(f.valid());
Clock::time_point t0 = Clock::now();
f.wait();
Clock::time_point t1 = Clock::now();
assert(f.valid());
assert(t1-t0 < ms(5));
}
}

8
test/thread/futures/futures.tas/futures.task.members/assign_copy.fail.cpp
View File

@@ -32,8 +32,8 @@ int main()
std::packaged_task<double(int, char)> p0(A(5));
std::packaged_task<double(int, char)> p;
p = p0;
assert(!p0);
assert(p);
assert(!p0.valid());
assert(p.valid());
std::future<double> f = p.get_future();
p(3, 'a');
assert(f.get() == 105.0);
@@ -42,7 +42,7 @@ int main()
std::packaged_task<double(int, char)> p0;
std::packaged_task<double(int, char)> p;
p = p0;
assert(!p0);
assert(!p);
assert(!p0.valid());
assert(!p.valid());
}
}

8
test/thread/futures/futures.tas/futures.task.members/assign_move.pass.cpp
View File

@@ -32,8 +32,8 @@ int main()
std::packaged_task<double(int, char)> p0(A(5));
std::packaged_task<double(int, char)> p;
p = std::move(p0);
assert(!p0);
assert(p);
assert(!p0.valid());
assert(p.valid());
std::future<double> f = p.get_future();
p(3, 'a');
assert(f.get() == 105.0);
@@ -42,7 +42,7 @@ int main()
std::packaged_task<double(int, char)> p0;
std::packaged_task<double(int, char)> p;
p = std::move(p0);
assert(!p0);
assert(!p);
assert(!p0.valid());
assert(!p.valid());
}
}

8
test/thread/futures/futures.tas/futures.task.members/ctor_copy.fail.cpp
View File

@@ -31,8 +31,8 @@ int main()
{
std::packaged_task<double(int, char)> p0(A(5));
std::packaged_task<double(int, char)> p(p0);
assert(!p0);
assert(p);
assert(!p0.valid());
assert(p.valid());
std::future<double> f = p.get_future();
p(3, 'a');
assert(f.get() == 105.0);
@@ -40,7 +40,7 @@ int main()
{
std::packaged_task<double(int, char)> p0;
std::packaged_task<double(int, char)> p(p0);
assert(!p0);
assert(!p);
assert(!p0.valid());
assert(!p.valid());
}
}

2
test/thread/futures/futures.tas/futures.task.members/ctor_default.pass.cpp
View File

@@ -21,5 +21,5 @@ struct A {};
int main()
{
std::packaged_task<A(int, char)> p;
assert(!p);
assert(!p.valid());
}

4
test/thread/futures/futures.tas/futures.task.members/ctor_func.pass.cpp
View File

@@ -39,7 +39,7 @@ int main()
{
{
std::packaged_task<double(int, char)> p(A(5));
assert(p);
assert(p.valid());
std::future<double> f = p.get_future();
p(3, 'a');
assert(f.get() == 105.0);
@@ -51,7 +51,7 @@ int main()
{
A a(5);
std::packaged_task<double(int, char)> p(a);
assert(p);
assert(p.valid());
std::future<double> f = p.get_future();
p(3, 'a');
assert(f.get() == 105.0);

4
test/thread/futures/futures.tas/futures.task.members/ctor_func_alloc.pass.cpp
View File

@@ -43,7 +43,7 @@ int main()
std::packaged_task<double(int, char)> p(std::allocator_arg,
test_allocator<A>(), A(5));
assert(test_alloc_base::count > 0);
assert(p);
assert(p.valid());
std::future<double> f = p.get_future();
p(3, 'a');
assert(f.get() == 105.0);
@@ -58,7 +58,7 @@ int main()
std::packaged_task<double(int, char)> p(std::allocator_arg,
test_allocator<A>(), a);
assert(test_alloc_base::count > 0);
assert(p);
assert(p.valid());
std::future<double> f = p.get_future();
p(3, 'a');
assert(f.get() == 105.0);

8
test/thread/futures/futures.tas/futures.task.members/ctor_move.pass.cpp
View File

@@ -31,8 +31,8 @@ int main()
{
std::packaged_task<double(int, char)> p0(A(5));
std::packaged_task<double(int, char)> p = std::move(p0);
assert(!p0);
assert(p);
assert(!p0.valid());
assert(p.valid());
std::future<double> f = p.get_future();
p(3, 'a');
assert(f.get() == 105.0);
@@ -40,7 +40,7 @@ int main()
{
std::packaged_task<double(int, char)> p0;
std::packaged_task<double(int, char)> p = std::move(p0);
assert(!p0);
assert(!p);
assert(!p0.valid());
assert(!p.valid());
}
}

8
test/thread/futures/futures.tas/futures.task.members/swap.pass.cpp
View File

@@ -32,8 +32,8 @@ int main()
std::packaged_task<double(int, char)> p0(A(5));
std::packaged_task<double(int, char)> p;
p.swap(p0);
assert(!p0);
assert(p);
assert(!p0.valid());
assert(p.valid());
std::future<double> f = p.get_future();
p(3, 'a');
assert(f.get() == 105.0);
@@ -42,7 +42,7 @@ int main()
std::packaged_task<double(int, char)> p0;
std::packaged_task<double(int, char)> p;
p.swap(p0);
assert(!p0);
assert(!p);
assert(!p0.valid());
assert(!p.valid());
}
}

8
test/thread/futures/futures.tas/futures.task.nonmembers/swap.pass.cpp
View File

@@ -34,8 +34,8 @@ int main()
std::packaged_task<double(int, char)> p0(A(5));
std::packaged_task<double(int, char)> p;
swap(p, p0);
assert(!p0);
assert(p);
assert(!p0.valid());
assert(p.valid());
std::future<double> f = p.get_future();
p(3, 'a');
assert(f.get() == 105.0);
@@ -44,7 +44,7 @@ int main()
std::packaged_task<double(int, char)> p0;
std::packaged_task<double(int, char)> p;
swap(p, p0);
assert(!p0);
assert(!p);
assert(!p0.valid());
assert(!p.valid());
}
}

16
test/thread/futures/futures.atomic_future/ctor_future.pass.cpp → test/thread/futures/futures.unique_future/share.pass.cpp
View File

@@ -9,9 +9,9 @@
// <future>
// class atomic_future<R>
// class future<R>
// atomic_future(future<R>&& rhs);
// shared_future<R> share() &&;
#include <future>
#include <cassert>
@@ -22,14 +22,14 @@ int main()
typedef int T;
std::promise<T> p;
std::future<T> f0 = p.get_future();
std::atomic_future<T> f = std::move(f0);
std::shared_future<T> f = std::move(f0.share());
assert(!f0.valid());
assert(f.valid());
}
{
typedef int T;
std::future<T> f0;
std::atomic_future<T> f = std::move(f0);
std::shared_future<T> f = std::move(f0.share());
assert(!f0.valid());
assert(!f.valid());
}
@@ -37,14 +37,14 @@ int main()
typedef int& T;
std::promise<T> p;
std::future<T> f0 = p.get_future();
std::atomic_future<T> f = std::move(f0);
std::shared_future<T> f = std::move(f0.share());
assert(!f0.valid());
assert(f.valid());
}
{
typedef int& T;
std::future<T> f0;
std::atomic_future<T> f = std::move(f0);
std::shared_future<T> f = std::move(f0.share());
assert(!f0.valid());
assert(!f.valid());
}
@@ -52,14 +52,14 @@ int main()
typedef void T;
std::promise<T> p;
std::future<T> f0 = p.get_future();
std::atomic_future<T> f = std::move(f0);
std::shared_future<T> f = std::move(f0.share());
assert(!f0.valid());
assert(f.valid());
}
{
typedef void T;
std::future<T> f0;
std::atomic_future<T> f = std::move(f0);
std::shared_future<T> f = std::move(f0.share());
assert(!f0.valid());
assert(!f.valid());
}