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

libcxx initial import

Browse Source 
git-svn-id: https://llvm.org/svn/llvm-project/libcxx/trunk@103490 91177308-0d34-0410-b5e6-96231b3b80d8
This commit is contained in:
Howard Hinnant
2010-05-11 19:42:16 +00:00
commit bc8d3f97eb
3893 changed files with 1209942 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

21
test/thread/thread.condition/cv_status.pass.cpp Normal file
View File

@@ -0,0 +1,21 @@
//===----------------------------------------------------------------------===//
//
// <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
// <condition_variable>
// enum class cv_status { no_timeout, timeout };
#include <condition_variable>
#include <cassert>
int main()
{
assert(std::cv_status::no_timeout == 0);
assert(std::cv_status::timeout == 1);
}

21
test/thread/thread.condition/notify_all_at_thread_exit.pass.cpp Normal file
View File

@@ -0,0 +1,21 @@
//===----------------------------------------------------------------------===//
//
// <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
// <condition_variable>
// void
// notify_all_at_thread_exit(condition_variable& cond, unique_lock<mutex> lk);
#include <condition_variable>
#include <cassert>
int main()
{
#error notify_all_at_thread_exit not implemented
}

24
test/thread/thread.condition/thread.condition.condvar/assign.fail.cpp Normal file
View File

@@ -0,0 +1,24 @@
//===----------------------------------------------------------------------===//
//
// <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
// <condition_variable>
// class condition_variable;
// condition_variable& operator=(const condition_variable&) = delete;
#include <condition_variable>
#include <cassert>
int main()
{
std::condition_variable cv0;
std::condition_variable cv1;
cv1 = cv0;
}

23
test/thread/thread.condition/thread.condition.condvar/copy.fail.cpp Normal file
View File

@@ -0,0 +1,23 @@
//===----------------------------------------------------------------------===//
//
// <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
// <condition_variable>
// class condition_variable;
// condition_variable(const condition_variable&) = delete;
#include <condition_variable>
#include <cassert>
int main()
{
std::condition_variable cv0;
std::condition_variable cv1(cv0);
}

22
test/thread/thread.condition/thread.condition.condvar/default.pass.cpp Normal file
View File

@@ -0,0 +1,22 @@
//===----------------------------------------------------------------------===//
//
// <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
// <condition_variable>
// class condition_variable;
// condition_variable();
#include <condition_variable>
#include <cassert>
int main()
{
std::condition_variable cv;
}

56
test/thread/thread.condition/thread.condition.condvar/destructor.pass.cpp Normal file
View File

@@ -0,0 +1,56 @@
//===----------------------------------------------------------------------===//
//
// <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
// <condition_variable>
// class condition_variable;
// ~condition_variable();
#include <condition_variable>
#include <mutex>
#include <thread>
#include <cassert>
std::condition_variable* cv;
std::mutex m;
typedef std::unique_lock<std::mutex> Lock;
bool f_ready = false;
bool g_ready = false;
void f()
{
Lock lk(m);
f_ready = true;
cv->notify_one();
delete cv;
}
void g()
{
Lock lk(m);
g_ready = true;
cv->notify_one();
while (!f_ready)
cv->wait(lk);
}
int main()
{
cv = new std::condition_variable;
std::thread th2(g);
Lock lk(m);
while (!g_ready)
cv->wait(lk);
lk.unlock();
std::thread th1(f);
th1.join();
th2.join();
}

27
test/thread/thread.condition/thread.condition.condvar/native_handle.pass.cpp Normal file
View File

@@ -0,0 +1,27 @@
//===----------------------------------------------------------------------===//
//
// <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
// <condition_variable>
// class condition_variable;
// typedef pthread_cond_t* native_handle_type;
// native_handle_type native_handle();
#include <condition_variable>
#include <cassert>
int main()
{
static_assert((std::is_same<std::condition_variable::native_handle_type,
pthread_cond_t*>::value), "");
std::condition_variable cv;
std::condition_variable::native_handle_type h = cv.native_handle();
assert(h != nullptr);
}

67
test/thread/thread.condition/thread.condition.condvar/notify_all.pass.cpp Normal file
View File

@@ -0,0 +1,67 @@
//===----------------------------------------------------------------------===//
//
// <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
// <condition_variable>
// class condition_variable;
// void notify_all();
#include <condition_variable>
#include <mutex>
#include <thread>
#include <cassert>
std::condition_variable cv;
std::mutex mut;
int test0 = 0;
int test1 = 0;
int test2 = 0;
void f1()
{
std::unique_lock<std::mutex> lk(mut);
assert(test1 == 0);
while (test1 == 0)
cv.wait(lk);
assert(test1 == 1);
test1 = 2;
}
void f2()
{
std::unique_lock<std::mutex> lk(mut);
assert(test2 == 0);
while (test2 == 0)
cv.wait(lk);
assert(test2 == 1);
test2 = 2;
}
int main()
{
std::thread t1(f1);
std::thread t2(f2);
std::this_thread::sleep_for(std::chrono::milliseconds(100));
{
std::unique_lock<std::mutex>lk(mut);
test1 = 1;
test2 = 1;
}
cv.notify_all();
{
std::this_thread::sleep_for(std::chrono::milliseconds(100));
std::unique_lock<std::mutex>lk(mut);
}
t1.join();
t2.join();
assert(test1 == 2);
assert(test2 == 2);
}

92
test/thread/thread.condition/thread.condition.condvar/notify_one.pass.cpp Normal file
View File

@@ -0,0 +1,92 @@
//===----------------------------------------------------------------------===//
//
// <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
// <condition_variable>
// class condition_variable;
// void notify_one();
#include <condition_variable>
#include <mutex>
#include <thread>
#include <cassert>
std::condition_variable cv;
std::mutex mut;
int test0 = 0;
int test1 = 0;
int test2 = 0;
void f1()
{
std::unique_lock<std::mutex> lk(mut);
assert(test1 == 0);
while (test1 == 0)
cv.wait(lk);
assert(test1 == 1);
test1 = 2;
}
void f2()
{
std::unique_lock<std::mutex> lk(mut);
assert(test2 == 0);
while (test2 == 0)
cv.wait(lk);
assert(test2 == 1);
test2 = 2;
}
int main()
{
std::thread t1(f1);
std::thread t2(f2);
std::this_thread::sleep_for(std::chrono::milliseconds(100));
{
std::unique_lock<std::mutex>lk(mut);
test1 = 1;
test2 = 1;
}
cv.notify_one();
{
std::this_thread::sleep_for(std::chrono::milliseconds(100));
std::unique_lock<std::mutex>lk(mut);
}
if (test1 == 2)
{
t1.join();
test1 = 0;
}
else if (test2 == 2)
{
t2.join();
test2 = 0;
}
else
assert(false);
cv.notify_one();
{
std::this_thread::sleep_for(std::chrono::milliseconds(100));
std::unique_lock<std::mutex>lk(mut);
}
if (test1 == 2)
{
t1.join();
test1 = 0;
}
else if (test2 == 2)
{
t2.join();
test2 = 0;
}
else
assert(false);
}

50
test/thread/thread.condition/thread.condition.condvar/wait.pass.cpp Normal file
View File

@@ -0,0 +1,50 @@
//===----------------------------------------------------------------------===//
//
// <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
// <condition_variable>
// class condition_variable;
// void wait(unique_lock<mutex>& lock);
#include <condition_variable>
#include <mutex>
#include <thread>
#include <cassert>
std::condition_variable cv;
std::mutex mut;
int test1 = 0;
int test2 = 0;
void f()
{
std::unique_lock<std::mutex> lk(mut);
assert(test2 == 0);
test1 = 1;
cv.notify_one();
while (test2 == 0)
cv.wait(lk);
assert(test2 != 0);
}
int main()
{
std::unique_lock<std::mutex>lk(mut);
std::thread t(f);
assert(test1 == 0);
while (test1 == 0)
cv.wait(lk);
assert(test1 != 0);
test2 = 1;
lk.unlock();
cv.notify_one();
t.join();
}

85
test/thread/thread.condition/thread.condition.condvar/wait_for.pass.cpp Normal file
View File

@@ -0,0 +1,85 @@
//===----------------------------------------------------------------------===//
//
// <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
// <condition_variable>
// class condition_variable;
// template <class Rep, class Period>
// cv_status
// wait_for(unique_lock<mutex>& lock,
// const chrono::duration<Rep, Period>& rel_time);
#include <condition_variable>
#include <mutex>
#include <thread>
#include <chrono>
#include <cassert>
std::condition_variable cv;
std::mutex mut;
int test1 = 0;
int test2 = 0;
int runs = 0;
void f()
{
typedef std::chrono::system_clock Clock;
typedef std::chrono::milliseconds milliseconds;
std::unique_lock<std::mutex> lk(mut);
assert(test2 == 0);
test1 = 1;
cv.notify_one();
Clock::time_point t0 = Clock::now();
while (test2 == 0 &&
cv.wait_for(lk, milliseconds(250)) == std::cv_status::no_timeout)
;
Clock::time_point t1 = Clock::now();
if (runs == 0)
{
assert(t1 - t0 < milliseconds(250));
assert(test2 != 0);
}
else
{
assert(t1 - t0 - milliseconds(250) < milliseconds(5));
assert(test2 == 0);
}
++runs;
}
int main()
{
{
std::unique_lock<std::mutex>lk(mut);
std::thread t(f);
assert(test1 == 0);
while (test1 == 0)
cv.wait(lk);
assert(test1 != 0);
test2 = 1;
lk.unlock();
cv.notify_one();
t.join();
}
test1 = 0;
test2 = 0;
{
std::unique_lock<std::mutex>lk(mut);
std::thread t(f);
assert(test1 == 0);
while (test1 == 0)
cv.wait(lk);
assert(test1 != 0);
lk.unlock();
t.join();
}
}

93
test/thread/thread.condition/thread.condition.condvar/wait_for_pred.pass.cpp Normal file
View File

@@ -0,0 +1,93 @@
//===----------------------------------------------------------------------===//
//
// <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
// <condition_variable>
// class condition_variable;
// template <class Rep, class Period, class Predicate>
// bool
// wait_for(unique_lock<mutex>& lock,
// const chrono::duration<Rep, Period>& rel_time,
// Predicate pred);
#include <condition_variable>
#include <mutex>
#include <thread>
#include <chrono>
#include <cassert>
class Pred
{
int& i_;
public:
explicit Pred(int& i) : i_(i) {}
bool operator()() {return i_ != 0;}
};
std::condition_variable cv;
std::mutex mut;
int test1 = 0;
int test2 = 0;
int runs = 0;
void f()
{
typedef std::chrono::system_clock Clock;
typedef std::chrono::milliseconds milliseconds;
std::unique_lock<std::mutex> lk(mut);
assert(test2 == 0);
test1 = 1;
cv.notify_one();
Clock::time_point t0 = Clock::now();
bool r = cv.wait_for(lk, milliseconds(250), Pred(test2));
Clock::time_point t1 = Clock::now();
if (runs == 0)
{
assert(t1 - t0 < milliseconds(250));
assert(test2 != 0);
}
else
{
assert(t1 - t0 - milliseconds(250) < milliseconds(2));
assert(test2 == 0);
}
++runs;
}
int main()
{
{
std::unique_lock<std::mutex>lk(mut);
std::thread t(f);
assert(test1 == 0);
while (test1 == 0)
cv.wait(lk);
assert(test1 != 0);
test2 = 1;
lk.unlock();
cv.notify_one();
t.join();
}
test1 = 0;
test2 = 0;
{
std::unique_lock<std::mutex>lk(mut);
std::thread t(f);
assert(test1 == 0);
while (test1 == 0)
cv.wait(lk);
assert(test1 != 0);
lk.unlock();
t.join();
}
}

60
test/thread/thread.condition/thread.condition.condvar/wait_pred.pass.cpp Normal file
View File

@@ -0,0 +1,60 @@
//===----------------------------------------------------------------------===//
//
// <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
// <condition_variable>
// class condition_variable;
// template <class Predicate>
// void wait(unique_lock<mutex>& lock, Predicate pred);
#include <condition_variable>
#include <mutex>
#include <thread>
#include <functional>
#include <cassert>
std::condition_variable cv;
std::mutex mut;
int test1 = 0;
int test2 = 0;
class Pred
{
int& i_;
public:
explicit Pred(int& i) : i_(i) {}
bool operator()() {return i_ != 0;}
};
void f()
{
std::unique_lock<std::mutex> lk(mut);
assert(test2 == 0);
test1 = 1;
cv.notify_one();
cv.wait(lk, Pred(test2));
assert(test2 != 0);
}
int main()
{
std::unique_lock<std::mutex>lk(mut);
std::thread t(f);
assert(test1 == 0);
while (test1 == 0)
cv.wait(lk);
assert(test1 != 0);
test2 = 1;
lk.unlock();
cv.notify_one();
t.join();
}

100
test/thread/thread.condition/thread.condition.condvar/wait_until.pass.cpp Normal file
View File

@@ -0,0 +1,100 @@
//===----------------------------------------------------------------------===//
//
// <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
// <condition_variable>
// class condition_variable;
// template <class Clock, class Duration>
// cv_status
// wait_until(unique_lock<mutex>& lock,
// const chrono::time_point<Clock, Duration>& abs_time);
#include <condition_variable>
#include <mutex>
#include <thread>
#include <chrono>
#include <cassert>
struct Clock
{
typedef std::chrono::milliseconds duration;
typedef duration::rep rep;
typedef duration::period period;
typedef std::chrono::time_point<Clock> time_point;
static const bool is_monotonic = true;
static time_point now()
{
using namespace std::chrono;
return time_point(duration_cast<duration>(
monotonic_clock::now().time_since_epoch()
));
}
};
std::condition_variable cv;
std::mutex mut;
int test1 = 0;
int test2 = 0;
int runs = 0;
void f()
{
std::unique_lock<std::mutex> lk(mut);
assert(test2 == 0);
test1 = 1;
cv.notify_one();
Clock::time_point t0 = Clock::now();
Clock::time_point t = t0 + Clock::duration(250);
while (test2 == 0 && cv.wait_until(lk, t) == std::cv_status::no_timeout)
;
Clock::time_point t1 = Clock::now();
if (runs == 0)
{
assert(t1 - t0 < Clock::duration(250));
assert(test2 != 0);
}
else
{
assert(t1 - t0 - Clock::duration(250) < Clock::duration(5));
assert(test2 == 0);
}
++runs;
}
int main()
{
{
std::unique_lock<std::mutex>lk(mut);
std::thread t(f);
assert(test1 == 0);
while (test1 == 0)
cv.wait(lk);
assert(test1 != 0);
test2 = 1;
lk.unlock();
cv.notify_one();
t.join();
}
test1 = 0;
test2 = 0;
{
std::unique_lock<std::mutex>lk(mut);
std::thread t(f);
assert(test1 == 0);
while (test1 == 0)
cv.wait(lk);
assert(test1 != 0);
lk.unlock();
t.join();
}
}

111
test/thread/thread.condition/thread.condition.condvar/wait_until_pred.pass.cpp Normal file
View File

@@ -0,0 +1,111 @@
//===----------------------------------------------------------------------===//
//
// <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
// <condition_variable>
// class condition_variable;
// template <class Clock, class Duration, class Predicate>
// bool
// wait_until(unique_lock<mutex>& lock,
// const chrono::time_point<Clock, Duration>& abs_time,
// Predicate pred);
#include <condition_variable>
#include <mutex>
#include <thread>
#include <chrono>
#include <cassert>
struct Clock
{
typedef std::chrono::milliseconds duration;
typedef duration::rep rep;
typedef duration::period period;
typedef std::chrono::time_point<Clock> time_point;
static const bool is_monotonic = true;
static time_point now()
{
using namespace std::chrono;
return time_point(duration_cast<duration>(
monotonic_clock::now().time_since_epoch()
));
}
};
class Pred
{
int& i_;
public:
explicit Pred(int& i) : i_(i) {}
bool operator()() {return i_ != 0;}
};
std::condition_variable cv;
std::mutex mut;
int test1 = 0;
int test2 = 0;
int runs = 0;
void f()
{
std::unique_lock<std::mutex> lk(mut);
assert(test2 == 0);
test1 = 1;
cv.notify_one();
Clock::time_point t0 = Clock::now();
Clock::time_point t = t0 + Clock::duration(250);
bool r = cv.wait_until(lk, t, Pred(test2));
Clock::time_point t1 = Clock::now();
if (runs == 0)
{
assert(t1 - t0 < Clock::duration(250));
assert(test2 != 0);
assert(r);
}
else
{
assert(t1 - t0 - Clock::duration(250) < Clock::duration(2));
assert(test2 == 0);
assert(!r);
}
++runs;
}
int main()
{
{
std::unique_lock<std::mutex>lk(mut);
std::thread t(f);
assert(test1 == 0);
while (test1 == 0)
cv.wait(lk);
assert(test1 != 0);
test2 = 1;
lk.unlock();
cv.notify_one();
t.join();
}
test1 = 0;
test2 = 0;
{
std::unique_lock<std::mutex>lk(mut);
std::thread t(f);
assert(test1 == 0);
while (test1 == 0)
cv.wait(lk);
assert(test1 != 0);
lk.unlock();
t.join();
}
}

24
test/thread/thread.condition/thread.condition.condvarany/assign.fail.cpp Normal file
View File

@@ -0,0 +1,24 @@
//===----------------------------------------------------------------------===//
//
// <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
// <condition_variable>
// class condition_variable_any;
// condition_variable_any& operator=(const condition_variable_any&) = delete;
#include <condition_variable>
#include <cassert>
int main()
{
std::condition_variable_any cv0;
std::condition_variable_any cv1;
cv1 = cv0;
}

23
test/thread/thread.condition/thread.condition.condvarany/copy.fail.cpp Normal file
View File

@@ -0,0 +1,23 @@
//===----------------------------------------------------------------------===//
//
// <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
// <condition_variable>
// class condition_variable_any;
// condition_variable_any(const condition_variable_any&) = delete;
#include <condition_variable>
#include <cassert>
int main()
{
std::condition_variable_any cv0;
std::condition_variable_any cv1(cv0);
}

22
test/thread/thread.condition/thread.condition.condvarany/default.pass.cpp Normal file
View File

@@ -0,0 +1,22 @@
//===----------------------------------------------------------------------===//
//
// <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
// <condition_variable>
// class condition_variable_any;
// condition_variable_any();
#include <condition_variable>
#include <cassert>
int main()
{
std::condition_variable_any cv;
}

57
test/thread/thread.condition/thread.condition.condvarany/destructor.pass.cpp Normal file
View File

@@ -0,0 +1,57 @@
//===----------------------------------------------------------------------===//
//
// <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
// <condition_variable>
// class condition_variable_any;
// ~condition_variable_any();
#include <condition_variable>
#include <mutex>
#include <thread>
#include <cassert>
std::condition_variable_any* cv;
std::mutex m;
bool f_ready = false;
bool g_ready = false;
void f()
{
m.lock();
f_ready = true;
cv->notify_one();
delete cv;
m.unlock();
}
void g()
{
m.lock();
g_ready = true;
cv->notify_one();
while (!f_ready)
cv->wait(m);
m.unlock();
}
int main()
{
cv = new std::condition_variable_any;
std::thread th2(g);
m.lock();
while (!g_ready)
cv->wait(m);
m.unlock();
std::thread th1(f);
th1.join();
th2.join();
}

71
test/thread/thread.condition/thread.condition.condvarany/notify_all.pass.cpp Normal file
View File

@@ -0,0 +1,71 @@
//===----------------------------------------------------------------------===//
//
// <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
// <condition_variable>
// class condition_variable_any;
// void notify_all();
#include <condition_variable>
#include <mutex>
#include <thread>
#include <cassert>
std::condition_variable_any cv;
typedef std::timed_mutex L0;
typedef std::unique_lock<L0> L1;
L0 m0;
int test0 = 0;
int test1 = 0;
int test2 = 0;
void f1()
{
L1 lk(m0);
assert(test1 == 0);
while (test1 == 0)
cv.wait(lk);
assert(test1 == 1);
test1 = 2;
}
void f2()
{
L1 lk(m0);
assert(test2 == 0);
while (test2 == 0)
cv.wait(lk);
assert(test2 == 1);
test2 = 2;
}
int main()
{
std::thread t1(f1);
std::thread t2(f2);
std::this_thread::sleep_for(std::chrono::milliseconds(100));
{
L1 lk(m0);
test1 = 1;
test2 = 1;
}
cv.notify_all();
{
std::this_thread::sleep_for(std::chrono::milliseconds(100));
L1 lk(m0);
}
t1.join();
t2.join();
assert(test1 == 2);
assert(test2 == 2);
}

96
test/thread/thread.condition/thread.condition.condvarany/notify_one.pass.cpp Normal file
View File

@@ -0,0 +1,96 @@
//===----------------------------------------------------------------------===//
//
// <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
// <condition_variable>
// class condition_variable_any;
// void notify_one();
#include <condition_variable>
#include <mutex>
#include <thread>
#include <cassert>
std::condition_variable_any cv;
typedef std::timed_mutex L0;
typedef std::unique_lock<L0> L1;
L0 m0;
int test0 = 0;
int test1 = 0;
int test2 = 0;
void f1()
{
L1 lk(m0);
assert(test1 == 0);
while (test1 == 0)
cv.wait(lk);
assert(test1 == 1);
test1 = 2;
}
void f2()
{
L1 lk(m0);
assert(test2 == 0);
while (test2 == 0)
cv.wait(lk);
assert(test2 == 1);
test2 = 2;
}
int main()
{
std::thread t1(f1);
std::thread t2(f2);
std::this_thread::sleep_for(std::chrono::milliseconds(100));
{
L1 lk(m0);
test1 = 1;
test2 = 1;
}
cv.notify_one();
{
std::this_thread::sleep_for(std::chrono::milliseconds(100));
L1 lk(m0);
}
if (test1 == 2)
{
t1.join();
test1 = 0;
}
else if (test2 == 2)
{
t2.join();
test2 = 0;
}
else
assert(false);
cv.notify_one();
{
std::this_thread::sleep_for(std::chrono::milliseconds(100));
L1 lk(m0);
}
if (test1 == 2)
{
t1.join();
test1 = 0;
}
else if (test2 == 2)
{
t2.join();
test2 = 0;
}
else
assert(false);
}

55
test/thread/thread.condition/thread.condition.condvarany/wait.pass.cpp Normal file
View File

@@ -0,0 +1,55 @@
//===----------------------------------------------------------------------===//
//
// <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
// <condition_variable>
// class condition_variable_any;
// template <class Lock>
// void wait(Lock& lock);
#include <condition_variable>
#include <mutex>
#include <thread>
#include <cassert>
std::condition_variable_any cv;
typedef std::timed_mutex L0;
typedef std::unique_lock<L0> L1;
L0 m0;
int test1 = 0;
int test2 = 0;
void f()
{
L1 lk(m0);
assert(test2 == 0);
test1 = 1;
cv.notify_one();
while (test2 == 0)
cv.wait(lk);
assert(test2 != 0);
}
int main()
{
L1 lk(m0);
std::thread t(f);
assert(test1 == 0);
while (test1 == 0)
cv.wait(lk);
assert(test1 != 0);
test2 = 1;
lk.unlock();
cv.notify_one();
t.join();
}

88
test/thread/thread.condition/thread.condition.condvarany/wait_for.pass.cpp Normal file
View File

@@ -0,0 +1,88 @@
//===----------------------------------------------------------------------===//
//
// <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
// <condition_variable>
// class condition_variable_any;
// template <class Lock, class Rep, class Period>
// cv_status
// wait_for(Lock& lock, const chrono::duration<Rep, Period>& rel_time);
#include <condition_variable>
#include <mutex>
#include <thread>
#include <chrono>
#include <cassert>
std::condition_variable_any cv;
typedef std::timed_mutex L0;
typedef std::unique_lock<L0> L1;
L0 m0;
int test1 = 0;
int test2 = 0;
int runs = 0;
void f()
{
typedef std::chrono::system_clock Clock;
typedef std::chrono::milliseconds milliseconds;
L1 lk(m0);
assert(test2 == 0);
test1 = 1;
cv.notify_one();
Clock::time_point t0 = Clock::now();
while (test2 == 0 &&
cv.wait_for(lk, milliseconds(250)) == std::cv_status::no_timeout)
;
Clock::time_point t1 = Clock::now();
if (runs == 0)
{
assert(t1 - t0 < milliseconds(250));
assert(test2 != 0);
}
else
{
assert(t1 - t0 - milliseconds(250) < milliseconds(5));
assert(test2 == 0);
}
++runs;
}
int main()
{
{
L1 lk(m0);
std::thread t(f);
assert(test1 == 0);
while (test1 == 0)
cv.wait(lk);
assert(test1 != 0);
test2 = 1;
lk.unlock();
cv.notify_one();
t.join();
}
test1 = 0;
test2 = 0;
{
L1 lk(m0);
std::thread t(f);
assert(test1 == 0);
while (test1 == 0)
cv.wait(lk);
assert(test1 != 0);
lk.unlock();
t.join();
}
}

96
test/thread/thread.condition/thread.condition.condvarany/wait_for_pred.pass.cpp Normal file
View File

@@ -0,0 +1,96 @@
//===----------------------------------------------------------------------===//
//
// <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
// <condition_variable>
// class condition_variable_any;
// template <class Lock, class Rep, class Period, class Predicate>
// bool
// wait_for(Lock& lock, const chrono::duration<Rep, Period>& rel_time,
// Predicate pred);
#include <condition_variable>
#include <mutex>
#include <thread>
#include <chrono>
#include <cassert>
class Pred
{
int& i_;
public:
explicit Pred(int& i) : i_(i) {}
bool operator()() {return i_ != 0;}
};
std::condition_variable_any cv;
typedef std::timed_mutex L0;
typedef std::unique_lock<L0> L1;
L0 m0;
int test1 = 0;
int test2 = 0;
int runs = 0;
void f()
{
typedef std::chrono::system_clock Clock;
typedef std::chrono::milliseconds milliseconds;
L1 lk(m0);
assert(test2 == 0);
test1 = 1;
cv.notify_one();
Clock::time_point t0 = Clock::now();
bool r = cv.wait_for(lk, milliseconds(250), Pred(test2));
Clock::time_point t1 = Clock::now();
if (runs == 0)
{
assert(t1 - t0 < milliseconds(250));
assert(test2 != 0);
}
else
{
assert(t1 - t0 - milliseconds(250) < milliseconds(2));
assert(test2 == 0);
}
++runs;
}
int main()
{
{
L1 lk(m0);
std::thread t(f);
assert(test1 == 0);
while (test1 == 0)
cv.wait(lk);
assert(test1 != 0);
test2 = 1;
lk.unlock();
cv.notify_one();
t.join();
}
test1 = 0;
test2 = 0;
{
L1 lk(m0);
std::thread t(f);
assert(test1 == 0);
while (test1 == 0)
cv.wait(lk);
assert(test1 != 0);
lk.unlock();
t.join();
}
}

64
test/thread/thread.condition/thread.condition.condvarany/wait_pred.pass.cpp Normal file
View File

@@ -0,0 +1,64 @@
//===----------------------------------------------------------------------===//
//
// <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
// <condition_variable>
// class condition_variable_any;
// template <class Lock, class Predicate>
// void wait(Lock& lock, Predicate pred);
#include <condition_variable>
#include <mutex>
#include <thread>
#include <functional>
#include <cassert>
std::condition_variable_any cv;
typedef std::timed_mutex L0;
typedef std::unique_lock<L0> L1;
L0 m0;
int test1 = 0;
int test2 = 0;
class Pred
{
int& i_;
public:
explicit Pred(int& i) : i_(i) {}
bool operator()() {return i_ != 0;}
};
void f()
{
L1 lk(m0);
assert(test2 == 0);
test1 = 1;
cv.notify_one();
cv.wait(lk, Pred(test2));
assert(test2 != 0);
}
int main()
{
L1 lk(m0);
std::thread t(f);
assert(test1 == 0);
while (test1 == 0)
cv.wait(lk);
assert(test1 != 0);
test2 = 1;
lk.unlock();
cv.notify_one();
t.join();
}

103
test/thread/thread.condition/thread.condition.condvarany/wait_until.pass.cpp Normal file
View File

@@ -0,0 +1,103 @@
//===----------------------------------------------------------------------===//
//
// <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
// <condition_variable>
// class condition_variable_any;
// template <class Lock, class Clock, class Duration>
// cv_status
// wait_until(Lock& lock, const chrono::time_point<Clock, Duration>& abs_time);
#include <condition_variable>
#include <mutex>
#include <thread>
#include <chrono>
#include <cassert>
struct Clock
{
typedef std::chrono::milliseconds duration;
typedef duration::rep rep;
typedef duration::period period;
typedef std::chrono::time_point<Clock> time_point;
static const bool is_monotonic = true;
static time_point now()
{
using namespace std::chrono;
return time_point(duration_cast<duration>(
monotonic_clock::now().time_since_epoch()
));
}
};
std::condition_variable_any cv;
typedef std::timed_mutex L0;
typedef std::unique_lock<L0> L1;
L0 m0;
int test1 = 0;
int test2 = 0;
int runs = 0;
void f()
{
L1 lk(m0);
assert(test2 == 0);
test1 = 1;
cv.notify_one();
Clock::time_point t0 = Clock::now();
Clock::time_point t = t0 + Clock::duration(250);
while (test2 == 0 && cv.wait_until(lk, t) == std::cv_status::no_timeout)
;
Clock::time_point t1 = Clock::now();
if (runs == 0)
{
assert(t1 - t0 < Clock::duration(250));
assert(test2 != 0);
}
else
{
assert(t1 - t0 - Clock::duration(250) < Clock::duration(5));
assert(test2 == 0);
}
++runs;
}
int main()
{
{
L1 lk(m0);
std::thread t(f);
assert(test1 == 0);
while (test1 == 0)
cv.wait(lk);
assert(test1 != 0);
test2 = 1;
lk.unlock();
cv.notify_one();
t.join();
}
test1 = 0;
test2 = 0;
{
L1 lk(m0);
std::thread t(f);
assert(test1 == 0);
while (test1 == 0)
cv.wait(lk);
assert(test1 != 0);
lk.unlock();
t.join();
}
}

115
test/thread/thread.condition/thread.condition.condvarany/wait_until_pred.pass.cpp Normal file
View File

@@ -0,0 +1,115 @@
//===----------------------------------------------------------------------===//
//
// <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
// <condition_variable>
// class condition_variable_any;
// template <class Lock, class Duration, class Predicate>
// bool
// wait_until(Lock& lock,
// const chrono::time_point<Clock, Duration>& abs_time,
// Predicate pred);
#include <condition_variable>
#include <mutex>
#include <thread>
#include <chrono>
#include <cassert>
struct Clock
{
typedef std::chrono::milliseconds duration;
typedef duration::rep rep;
typedef duration::period period;
typedef std::chrono::time_point<Clock> time_point;
static const bool is_monotonic = true;
static time_point now()
{
using namespace std::chrono;
return time_point(duration_cast<duration>(
monotonic_clock::now().time_since_epoch()
));
}
};
class Pred
{
int& i_;
public:
explicit Pred(int& i) : i_(i) {}
bool operator()() {return i_ != 0;}
};
std::condition_variable_any cv;
typedef std::timed_mutex L0;
typedef std::unique_lock<L0> L1;
L0 m0;
int test1 = 0;
int test2 = 0;
int runs = 0;
void f()
{
L1 lk(m0);
assert(test2 == 0);
test1 = 1;
cv.notify_one();
Clock::time_point t0 = Clock::now();
Clock::time_point t = t0 + Clock::duration(250);
bool r = cv.wait_until(lk, t, Pred(test2));
Clock::time_point t1 = Clock::now();
if (runs == 0)
{
assert(t1 - t0 < Clock::duration(250));
assert(test2 != 0);
assert(r);
}
else
{
assert(t1 - t0 - Clock::duration(250) < Clock::duration(2));
assert(test2 == 0);
assert(!r);
}
++runs;
}
int main()
{
{
L1 lk(m0);
std::thread t(f);
assert(test1 == 0);
while (test1 == 0)
cv.wait(lk);
assert(test1 != 0);
test2 = 1;
lk.unlock();
cv.notify_one();
t.join();
}
test1 = 0;
test2 = 0;
{
L1 lk(m0);
std::thread t(f);
assert(test1 == 0);
while (test1 == 0)
cv.wait(lk);
assert(test1 != 0);
lk.unlock();
t.join();
}
}

20
test/thread/thread.condition/version.pass.cpp Normal file
View File

@@ -0,0 +1,20 @@
//===----------------------------------------------------------------------===//
//
// <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
// <condition_variable>
#include <condition_variable>
#ifndef _LIBCPP_VERSION
#error _LIBCPP_VERSION not defined
#endif
int main()
{
}