Subject: [Boost-commit] svn:boost r76296 - trunk/libs/thread/test
From: vicente.botet_at_[hidden]
Date: 2012-01-03 16:26:00
Author: viboes
Date: 2012-01-03 16:25:58 EST (Tue, 03 Jan 2012)
New Revision: 76296
URL: http://svn.boost.org/trac/boost/changeset/76296
Log:
Thread: Added test related to tickets
Added:
trunk/libs/thread/test/test_2501.cpp (contents, props changed)
trunk/libs/thread/test/test_4521.cpp (contents, props changed)
trunk/libs/thread/test/test_4648.cpp (contents, props changed)
trunk/libs/thread/test/test_4882.cpp (contents, props changed)
trunk/libs/thread/test/test_5351.cpp (contents, props changed)
trunk/libs/thread/test/test_5502.cpp (contents, props changed)
trunk/libs/thread/test/test_5542_1.cpp (contents, props changed)
trunk/libs/thread/test/test_5542_2.cpp (contents, props changed)
trunk/libs/thread/test/test_5542_3.cpp (contents, props changed)
trunk/libs/thread/test/test_6130.cpp (contents, props changed)
trunk/libs/thread/test/test_6174.cpp (contents, props changed)
Added: trunk/libs/thread/test/test_2501.cpp
==============================================================================
--- (empty file)
+++ trunk/libs/thread/test/test_2501.cpp 2012-01-03 16:25:58 EST (Tue, 03 Jan 2012)
@@ -0,0 +1,10 @@
+#include <boost/thread/shared_mutex.hpp>
+
+int main() {
+
+ boost::shared_mutex mtx; boost::upgrade_lock<boost::shared_mutex> lk(mtx);
+
+ boost::upgrade_to_unique_lock<boost::shared_mutex> lk2(lk);
+
+ return 0;
+}
Added: trunk/libs/thread/test/test_4521.cpp
==============================================================================
--- (empty file)
+++ trunk/libs/thread/test/test_4521.cpp 2012-01-03 16:25:58 EST (Tue, 03 Jan 2012)
@@ -0,0 +1,21 @@
+#include <boost/thread.hpp>
+
+int calculate_the_answer_to_life_the_universe_and_everything()
+{
+ return 42;
+}
+
+int main() {
+boost::packaged_task<int> pt(calculate_the_answer_to_life_the_universe_and_everything);
+boost::unique_future<int> fi=pt.get_future();
+
+boost::thread task(boost::move(pt)); // launch task on a thread
+
+fi.wait(); // wait for it to finish
+
+//assert(fi.is_ready());
+//assert(fi.has_value());
+//assert(!fi.has_exception());
+//assert(fi.get_state()==boost::future_state::ready);
+//assert(fi.get()==42);
+}
Added: trunk/libs/thread/test/test_4648.cpp
==============================================================================
--- (empty file)
+++ trunk/libs/thread/test/test_4648.cpp 2012-01-03 16:25:58 EST (Tue, 03 Jan 2012)
@@ -0,0 +1,42 @@
+#include <iostream>
+#include <boost/thread.hpp>
+#include <boost/current_function.hpp>
+
+class boostThreadLocksTest
+{
+public:
+ boost::shared_mutex myMutex;
+ //boost::upgrade_lock<boost::shared_mutex> myLock;
+ static int firstFunction(boostThreadLocksTest *pBoostThreadLocksTest);
+ static int secondFunction(boostThreadLocksTest *pBoostThreadLocksTest,
+ boost::upgrade_lock<boost::shared_mutex>& upgr);
+ boostThreadLocksTest()
+ :myMutex()
+ //, myLock(myMutex,boost::defer_lock_t())
+ {};
+};
+
+int boostThreadLocksTest::firstFunction(boostThreadLocksTest *pBoostThreadLocksTest)
+{
+ std::cout<<"Entering "<<boost::this_thread::get_id()<<" "<<"firstFunction"<<std::endl;
+ boost::upgrade_lock<boost::shared_mutex> myLock(pBoostThreadLocksTest->myMutex);
+ pBoostThreadLocksTest->secondFunction(pBoostThreadLocksTest, myLock);
+ std::cout<<"Returned From Call "<<boost::this_thread::get_id()<<" "<<"firstFunction"<<std::endl;
+ std::cout<<"Returning from "<<boost::this_thread::get_id()<<" "<<"firstFunction"<<std::endl;
+ return(0);
+}
+int boostThreadLocksTest::secondFunction(boostThreadLocksTest *pBoostThreadLocksTest, boost::upgrade_lock<boost::shared_mutex>& upgr) {
+ std::cout<<"Before Exclusive Locking "<<boost::this_thread::get_id()<<" "<<"secondFunction"<<std::endl;
+ boost::upgrade_to_unique_lock<boost::shared_mutex> localUniqueLock(upgr);
+ std::cout<<"After Exclusive Locking "<<boost::this_thread::get_id()<<" "<<"secondFunction"<<std::endl;
+ return(0);
+}
+int main() {
+ boostThreadLocksTest myObject;
+ boost::thread_group myThreadGroup;
+ myThreadGroup.create_thread(boost::bind(boostThreadLocksTest::firstFunction,&myObject));
+ myThreadGroup.create_thread(boost::bind(boostThreadLocksTest::firstFunction,&myObject));
+ myThreadGroup.create_thread(boost::bind(boostThreadLocksTest::firstFunction,&myObject));
+ myThreadGroup.join_all();
+ return 0;
+}
Added: trunk/libs/thread/test/test_4882.cpp
==============================================================================
--- (empty file)
+++ trunk/libs/thread/test/test_4882.cpp 2012-01-03 16:25:58 EST (Tue, 03 Jan 2012)
@@ -0,0 +1,50 @@
+#include <boost/thread/thread.hpp>
+#include <boost/thread/shared_mutex.hpp>
+
+#include <iostream>
+
+boost::shared_mutex mutex;
+
+void thread()
+{
+ std::cout << __FILE__ << ":" << __LINE__ << std::endl;
+ try
+ {
+ for (int i =0; i<10; ++i)
+ {
+ boost::system_time timeout = boost::get_system_time() + boost::posix_time::milliseconds(50);
+
+ if (mutex.timed_lock(timeout))
+ {
+ std::cout << __FILE__ << ":" << __LINE__ << std::endl;
+ boost::this_thread::sleep(boost::posix_time::milliseconds(10));
+ mutex.unlock();
+ std::cout << __FILE__ << ":" << __LINE__ << std::endl;
+ }
+ }
+ }
+ catch (boost::lock_error& le)
+ {
+ std::cerr << "lock_error exception\n";
+ }
+ std::cout << __FILE__ << ":" << __LINE__ << std::endl;
+}
+
+int main()
+{
+ std::cout << __FILE__ << ":" << __LINE__ << std::endl;
+ const int nrThreads = 20;
+ boost::thread* threads[nrThreads];
+
+ for (int i = 0; i < nrThreads; ++i)
+ threads[i] = new boost::thread(&thread);
+
+ for (int i = 0; i < nrThreads; ++i)
+ {
+ threads[i]->join();
+ std::cout << __FILE__ << ":" << __LINE__ << std::endl;
+ delete threads[i];
+ }
+ std::cout << __FILE__ << ":" << __LINE__ << std::endl;
+ return 0;
+}
Added: trunk/libs/thread/test/test_5351.cpp
==============================================================================
--- (empty file)
+++ trunk/libs/thread/test/test_5351.cpp 2012-01-03 16:25:58 EST (Tue, 03 Jan 2012)
@@ -0,0 +1,45 @@
+#include <iostream>
+#include <boost/thread.hpp>
+#include <boost/date_time/posix_time/posix_time_types.hpp>
+#include <boost/thread/future.hpp>
+
+using namespace boost::posix_time;
+using namespace boost;
+
+int foo()
+{
+ this_thread::sleep(seconds(10));
+ return 0;
+}
+
+
+int main(int argc, char** argv)
+{
+ boost::packaged_task<int> pt(&foo);
+ boost::unique_future<int> fi = pt.get_future();
+ boost::thread task(boost::move(pt)); // launch task on a thread
+
+ task.interrupt();
+
+ try
+ {
+ int v = fi.get();
+ }
+ catch (boost::thread_interrupted& exc)
+ {
+ std::cout << "OK: " << std::endl;
+ return 0;
+ }
+ catch (boost::exception& exc)
+ {
+ std::cout << __LINE__ << " ERROR: " << boost::diagnostic_information(exc) << std::endl;
+ return 1;
+ }
+ catch (...)
+ {
+ std::cout << __LINE__ << " ERROR: " << std::endl;
+ return 2;
+ }
+ std::cout << __LINE__ << " ERROR: " << std::endl;
+ return 3;
+}
Added: trunk/libs/thread/test/test_5502.cpp
==============================================================================
--- (empty file)
+++ trunk/libs/thread/test/test_5502.cpp 2012-01-03 16:25:58 EST (Tue, 03 Jan 2012)
@@ -0,0 +1,86 @@
+// bm.cpp
+
+// g++ test.cpp -lboost_thread-mt && ./a.out
+
+// the ration of XXX and YYY determines
+// if this works or deadlocks
+int XXX = 20;
+int YYY = 10;
+
+#include <boost/thread.hpp>
+#include <boost/thread/shared_mutex.hpp>
+
+#include <unistd.h>
+#include <iostream>
+#include <boost/detail/lightweight_test.hpp>
+
+using namespace std;
+
+void sleepmillis(useconds_t miliis)
+{
+ usleep(miliis * 1000);
+}
+
+void worker1(boost::shared_mutex * lk, int * x)
+{
+ (*x)++; // 1
+ cout << "lock b try " << *x << endl;
+ while (1)
+ {
+ if (lk->timed_lock(boost::posix_time::milliseconds(XXX))) break;
+ sleepmillis(YYY);
+ }
+ cout << "lock b got " << *x << endl;
+ (*x)++; // 2
+ lk->unlock();
+}
+
+void worker2(boost::shared_mutex * lk, int * x)
+{
+ cout << "lock c try" << endl;
+ lk->lock_shared();
+ (*x)++;
+ cout << "lock c got" << endl;
+ lk->unlock_shared();
+ cout << "lock c unlocked" << endl;
+ (*x)++;
+}
+
+int main()
+{
+
+ // create
+ boost::shared_mutex* lk = new boost::shared_mutex();
+
+ // read lock
+ cout << "lock a" << endl;
+ lk->lock_shared();
+
+ int x1 = 0;
+ boost::thread t1(boost::bind(worker1, lk, &x1));
+ while (!x1)
+ ;
+ BOOST_TEST(x1 == 1);
+ sleepmillis(500);
+ BOOST_TEST(x1 == 1);
+
+ int x2 = 0;
+ boost::thread t2(boost::bind(worker2, lk, &x2));
+ t2.join();
+ BOOST_TEST(x2 == 2);
+
+ lk->unlock_shared();
+ cout << "unlock a" << endl;
+
+ for (int i = 0; i < 2000; i++)
+ {
+ if (x1 == 2) break;
+ sleepmillis(10);
+ }
+
+ BOOST_TEST(x1 == 2);
+ t1.join();
+ delete lk;
+
+ return 0;
+}
Added: trunk/libs/thread/test/test_5542_1.cpp
==============================================================================
--- (empty file)
+++ trunk/libs/thread/test/test_5542_1.cpp 2012-01-03 16:25:58 EST (Tue, 03 Jan 2012)
@@ -0,0 +1,62 @@
+#include <iostream>
+#include <boost/thread.hpp>
+
+class Worker
+{
+public:
+
+ Worker()
+ {
+ // the thread is not-a-thread until we call start()
+ }
+
+ void start(int N)
+ {
+ std::cout << "start\n";
+ m_Thread = boost::thread(&Worker::processQueue, this, N);
+ std::cout << "started\n";
+ }
+
+ void join()
+ {
+ m_Thread.join();
+ }
+
+ void processQueue(unsigned N)
+ {
+ float ms = N * 1e3;
+ boost::posix_time::milliseconds workTime(ms);
+
+ std::cout << "Worker: started, will work for "
+ << ms << "ms"
+ << std::endl;
+
+ // We're busy, honest!
+ boost::this_thread::sleep(workTime);
+
+ std::cout << "Worker: completed" << std::endl;
+ }
+
+private:
+
+ boost::thread m_Thread;
+};
+
+int main(int argc, char* argv[])
+{
+ std::cout << "main: startup" << std::endl;
+
+ Worker worker;
+
+ std::cout << "main: create worker" << std::endl;
+
+ worker.start(3);
+
+ std::cout << "main: waiting for thread" << std::endl;
+
+ worker.join();
+
+ std::cout << "main: done" << std::endl;
+
+ return 0;
+}
Added: trunk/libs/thread/test/test_5542_2.cpp
==============================================================================
--- (empty file)
+++ trunk/libs/thread/test/test_5542_2.cpp 2012-01-03 16:25:58 EST (Tue, 03 Jan 2012)
@@ -0,0 +1,11 @@
+#include <boost/thread.hpp>
+
+void run_thread() {
+ return;
+}
+
+int main() {
+ boost::thread t(run_thread);
+ return 0;
+}
+
Added: trunk/libs/thread/test/test_5542_3.cpp
==============================================================================
--- (empty file)
+++ trunk/libs/thread/test/test_5542_3.cpp 2012-01-03 16:25:58 EST (Tue, 03 Jan 2012)
@@ -0,0 +1,30 @@
+#include <iostream>
+#include <boost/thread.hpp>
+#include <boost/date_time.hpp>
+
+void workerFunc()
+{
+ boost::posix_time::seconds workTime(3);
+
+ std::cout << "Worker: running" << std::endl;
+
+ // Pretend to do something useful...
+ boost::this_thread::sleep(workTime);
+
+ std::cout << "Worker: finished" << std::endl;
+}
+
+int main(int argc, char* argv[])
+{
+ std::cout << "main: startup" << std::endl;
+
+ boost::thread workerThread(workerFunc);
+
+ std::cout << "main: waiting for thread" << std::endl;
+
+ workerThread.join();
+
+ std::cout << "main: done" << std::endl;
+
+ return 0;
+}
Added: trunk/libs/thread/test/test_6130.cpp
==============================================================================
--- (empty file)
+++ trunk/libs/thread/test/test_6130.cpp 2012-01-03 16:25:58 EST (Tue, 03 Jan 2012)
@@ -0,0 +1,22 @@
+#include <boost/thread.hpp>
+#include <assert.h>
+#include <iostream>
+#include <stdlib.h>
+#include <unistd.h>
+
+boost::mutex mtx;
+boost::condition_variable cv;
+
+int main()
+{
+ for (int i=0; i<3; ++i) {
+ const time_t wait_time = ::time(0)+1;
+
+ boost::mutex::scoped_lock lk(mtx);
+ const bool res = cv.timed_wait(lk, boost::posix_time::from_time_t(wait_time));
+ const time_t end_time = ::time(0);
+ assert(end_time >= wait_time);
+ std::cerr << end_time - wait_time << " OK\n";
+ }
+ return 0;
+}
Added: trunk/libs/thread/test/test_6174.cpp
==============================================================================
--- (empty file)
+++ trunk/libs/thread/test/test_6174.cpp 2012-01-03 16:25:58 EST (Tue, 03 Jan 2012)
@@ -0,0 +1,35 @@
+
+
+#include <boost/thread.hpp>
+#include <boost/config.hpp>
+
+#ifndef BOOST_NO_RVALUE_REFERENCES
+struct MovableButNonCopyable {
+#ifndef BOOST_NO_DEFAULTED_FUNCTIONS
+ MovableButNonCopyable() = default;
+ MovableButNonCopyable(MovableButNonCopyable const&) = delete;
+ MovableButNonCopyable& operator=(MovableButNonCopyable const&) = delete;
+ MovableButNonCopyable(MovableButNonCopyable&&) = default;
+ MovableButNonCopyable& operator=(MovableButNonCopyable&&) = default;
+#else
+ MovableButNonCopyable() {};
+ MovableButNonCopyable(MovableButNonCopyable&&) {};
+ MovableButNonCopyable& operator=(MovableButNonCopyable&&) {
+ return *this;
+ };
+private:
+ MovableButNonCopyable(MovableButNonCopyable const&);
+ MovableButNonCopyable& operator=(MovableButNonCopyable const&);
+#endif
+};
+int main()
+{
+ boost::packaged_task<MovableButNonCopyable>(MovableButNonCopyable());
+ return 0;
+}
+#else
+int main()
+{
+ return 0;
+}
+#endif