Рефакторинг: удалил не нужный теперь "тяжеловесный" класс uniset_mutex

extensions/DBServer-PostgreSQL/DBServer_PostgreSQL.cc

@@ -145,7 +145,7 @@ bool DBServer_PostgreSQL::writeToBase( const string& query )
 
 	if( !db || !connect_ok )
 	{
-		uniset_mutex_lock l(mqbuf, 200);
+		std::lock_guard<std::mutex> l(mqbuf);
 		qbuf.push(query);
 
 		if( qbuf.size() > qbufSize )
@@ -177,7 +177,7 @@ bool DBServer_PostgreSQL::writeToBase( const string& query )
 //--------------------------------------------------------------------------------------------
 void DBServer_PostgreSQL::flushBuffer()
 {
-	uniset_mutex_lock l(mqbuf, 400);
+	std::lock_guard<std::mutex> l(mqbuf);
 
 	// Сперва пробуем очистить всё что накопилось в очереди до этого...
 	while( !qbuf.empty() )

extensions/DBServer-PostgreSQL/DBServer_PostgreSQL.h

@@ -111,7 +111,7 @@ class DBServer_PostgreSQL:
 		bool lastRemove = { false };
 
 		void flushBuffer();
-		UniSetTypes::uniset_mutex mqbuf;
+		std::mutex mqbuf;
 
 		// writeBuffer
 		const std::list<std::string> tblcols = { "date", "time","time_usec","sensor_id","value","node" };

extensions/IOControl/IOControl.cc

@@ -372,7 +372,7 @@ void IOControl::execute()
 		// init first time....
 		if( !force && !noCards )
 		{
-			uniset_mutex_lock l(iopollMutex, 5000);
+			std::lock_guard<std::mutex> l(iopollMutex);
 			force = true;
 			iopoll();
 			force = false;
@@ -424,7 +424,7 @@ void IOControl::execute()
 				}
 
 				{
-					uniset_mutex_lock l(iopollMutex, 5000);
+					std::lock_guard<std::mutex> l(iopollMutex);
 					iopoll();
 				}
 			}
@@ -1302,7 +1302,7 @@ void IOControl::sysCommand( const SystemMessage* sm )
 				if( !force )
 				{
 					force = true;
-					uniset_mutex_lock l(iopollMutex, 8000);
+					std::lock_guard<std::mutex> l(iopollMutex);
 					iopoll();
 					force = false;
 				}

extensions/IOControl/IOControl.h

@@ -398,7 +398,7 @@ class IOControl:
 		int defCardNum = { -1 };        /*!< номер карты по умолчанию */
 		int maxCardNum = { 10 };        /*! максимально разрешённый номер для карты */
 
-		UniSetTypes::uniset_mutex iopollMutex;
+		std::mutex iopollMutex;
 		std::atomic_bool activated = { false };
 		bool readconf_ok = { false };
 		int activateTimeout;

extensions/LogicProcessor/PassiveLProcessor.cc

@@ -155,7 +155,7 @@ void PassiveLProcessor::sysCommand( const UniSetTypes::SystemMessage* sm )
 				return;
 			}
 
-			UniSetTypes::uniset_mutex_lock l(mutex_start, 10000);
+			std::lock_guard<std::mutex> l(mutex_start);
 			askSensors(UniversalIO::UIONotify);
 			askTimer(tidStep, LProcessor::sleepTime);
 			break;
@@ -210,11 +210,11 @@ void PassiveLProcessor::sysCommand( const UniSetTypes::SystemMessage* sm )
 // -------------------------------------------------------------------------
 bool PassiveLProcessor::activateObject()
 {
-	// блокирование обработки Starsp
+	// блокирование обработки StarUp
 	// пока не пройдёт инициализация датчиков
 	// см. sysCommand()
 	{
-		UniSetTypes::uniset_mutex_lock l(mutex_start, 5000);
+		std::lock_guard<std::mutex> l(mutex_start);
 		UniSetObject::activateObject();
 		initIterators();
 	}

extensions/LogicProcessor/PassiveLProcessor.h

@@ -74,7 +74,7 @@ class PassiveLProcessor:
 		UniSetTypes::ObjectId sidHeartBeat = { UniSetTypes::DefaultObjectId };
 		int maxHeartBeat = { 10 };
 		IOController::IOStateList::iterator itHeartBeat;
-		UniSetTypes::uniset_mutex mutex_start;
+		std::mutex mutex_start;
 };
 // ---------------------------------------------------------------------------
 #endif

extensions/ModbusMaster/RTUExchange.h

@@ -43,7 +43,7 @@ class RTUExchange:
 
 	protected:
 		std::shared_ptr<ModbusRTUMaster> mbrtu;
-		UniSetTypes::uniset_mutex mbMutex;
+		std::mutex mbMutex;
 		std::string devname;
 		ComPort::Speed defSpeed;
 		bool use485F;

extensions/ModbusSlave/MBSlave.cc

@@ -698,7 +698,7 @@ void MBSlave::updateTCPStatistics()
 
 		// Обновляем информацию по соединениям
 		{
-			uniset_mutex_lock l(sessMutex);
+			std::lock_guard<std::mutex> l(sessMutex);
 			sess.clear();
 			tcpserver->getSessions(sess);
 		}
@@ -2583,7 +2583,7 @@ UniSetTypes::SimpleInfo* MBSlave::getInfo( CORBA::Long userparam )
 	{
 		size_t snum = 0;
 		{
-			uniset_mutex_lock l(sessMutex);
+			std::lock_guard<std::mutex> l(sessMutex);
 			snum = sess.size();
 		}
 
@@ -2593,7 +2593,7 @@ UniSetTypes::SimpleInfo* MBSlave::getInfo( CORBA::Long userparam )
 			inf << "   " << m.second.getShortInfo() << endl;
 
 		{
-			uniset_mutex_lock l(sessMutex);
+			std::lock_guard<std::mutex> l(sessMutex);
 			inf << "TCP sessions[" << sess.size() << "]: max=" << sessMaxNum << " updateStatTime=" << updateStatTime << endl;
 
 			for( const auto& m : sess )

extensions/ModbusSlave/MBSlave.h

@@ -581,7 +581,7 @@ class MBSlave:
 		timeout_t sessTimeout = { 2000 };  /*!< таймаут на сессию */
 		timeout_t updateStatTime = { 4000 };
 		ModbusTCPServer::Sessions sess; /*!< список открытых сессий */
-		UniSetTypes::uniset_mutex sessMutex;
+		std::mutex sessMutex;
 		unsigned int sessMaxNum = { 5 };
 		std::shared_ptr<ModbusTCPServerSlot> tcpserver;
 

extensions/UNetUDP/UNetReceiver.cc

@@ -246,7 +246,7 @@ void UNetReceiver::evfinish( const ev::loop_ref& eloop )
 	activated = false;
 
 	{
-		uniset_mutex_lock l(checkConnMutex);
+		std::lock_guard<std::mutex> l(checkConnMutex);
 
 		if( evCheckConnection.is_active() )
 			evCheckConnection.stop();
@@ -554,7 +554,7 @@ void UNetReceiver::checkConnectionEvent( ev::periodic& tm, int revents )
 
 	unetinfo << myname << "(checkConnectionEvent): check connection event.." << endl;
 
-	uniset_mutex_lock l(checkConnMutex);
+	std::lock_guard<std::mutex> l(checkConnMutex);
 
 	if( !createConnection(false) )
 		tm.again();

extensions/UNetUDP/UNetReceiver.h

@@ -217,7 +217,7 @@ class UNetReceiver:
 
 		double updateTime = { 0.01 };
 		double checkConnectionTime = { 10.0 }; // sec
-		UniSetTypes::uniset_mutex checkConnMutex;
+		std::mutex checkConnMutex;
 
 		UniSetTypes::uniset_rwmutex pollMutex;
 		PassiveTimer ptRecvTimeout;

extensions/lib/SingleProcess.cc

@@ -26,9 +26,8 @@ using namespace UniSetTypes;
 using namespace std;
 // --------------------------------------------------------------------------------
 /*! замок для блокирования совместного доступа к функции обрабтки сигналов */
-static UniSetTypes::uniset_mutex signalMutex("Main::signalMutex");
-static volatile sig_atomic_t procterm = 0;
-static volatile sig_atomic_t doneterm = 0;
+static std::atomic_bool procterm;
+static std::atomic_bool doneterm;
 static SingleProcess* gMain = NULL;
 static const int TERMINATE_TIMEOUT = 2; //  время отведенное на завершение процесса [сек]
 // --------------------------------------------------------------------------------
@@ -63,8 +62,6 @@ void SingleProcess::terminated( int signo )
 		// lock
 
 		// на случай прихода нескольких сигналов
-		uniset_mutex_lock l(signalMutex, 1000);
-
 		if( !procterm )
 		{
 			procterm = 1;

include/IOController.h

@@ -262,10 +262,10 @@ class IOController:
 	private:
 		friend class NCRestorer;
 
-		UniSetTypes::uniset_mutex siganyMutex;
+		std::mutex siganyMutex;
 		ChangeSignal sigAnyChange;
 
-		UniSetTypes::uniset_mutex siganyundefMutex;
+		std::mutex siganyundefMutex;
 		ChangeSignal sigAnyUndefChange;
 		InitSignal sigInit;
 

include/Mutex.h

@@ -29,61 +29,6 @@
 // -----------------------------------------------------------------------------------------
 namespace UniSetTypes
 {
-	class uniset_mutex
-	{
-		public:
-			uniset_mutex();
-			uniset_mutex( const std::string& name );
-			~uniset_mutex();
-
-			void lock();
-			void unlock();
-			bool try_lock_for( const time_t& msec );
-
-			inline std::string name()
-			{
-				return nm;
-			}
-			inline void setName( const std::string& name )
-			{
-				nm = name;
-			}
-
-		protected:
-
-		private:
-			friend class uniset_mutex_lock;
-			uniset_mutex(const uniset_mutex& r) = delete;
-			uniset_mutex& operator=(const uniset_mutex& r) = delete;
-			std::string nm;
-			std::timed_mutex m_lock;
-	};
-
-	std::ostream& operator<<(std::ostream& os, uniset_mutex& m );
-	// -------------------------------------------------------------------------
-	/*! \class uniset_mutex_lock
-	 *  \author Pavel Vainerman
-	 *
-	 *  Предназначен для блокирования совместного доступа. Как пользоваться см. \ref MutexHowToPage
-	 *  \note Если ресурс уже занят, то lock ждет его освобождения...
-	*/
-	class uniset_mutex_lock
-	{
-		public:
-			uniset_mutex_lock( uniset_mutex& m, const time_t timeoutMS = 0 );
-			~uniset_mutex_lock();
-
-			bool lock_ok();
-
-		private:
-			uniset_mutex* mutex;
-			std::atomic_bool locked;
-
-			uniset_mutex_lock(const uniset_mutex_lock&) = delete;
-			uniset_mutex_lock& operator=(const uniset_mutex_lock&) = delete;
-	};
-
-	// -------------------------------------------------------------------------
 	// rwmutex..
 	class uniset_rwmutex
 	{

include/modbus/ModbusServer.h

@@ -314,7 +314,7 @@ class ModbusServer
 		ModbusRTU::mbErrCode recv(const std::unordered_set<ModbusRTU::ModbusAddr>& vaddr, ModbusRTU::ModbusMessage& buf, timeout_t timeout );
 		ModbusRTU::mbErrCode recv_pdu( ModbusRTU::ModbusMessage& rbuf, timeout_t timeout );
 
-		UniSetTypes::uniset_mutex recvMutex;
+		std::timed_mutex recvMutex;
 		timeout_t recvTimeOut_ms = { 50 };        /*!< таймаут на приём */
 		timeout_t replyTimeout_ms = { 2000 };    /*!< таймаут на формирование ответа */
 		timeout_t aftersend_msec = { 0 };        /*!< пауза после посылки ответа */

include/modbus/ModbusTCPServer.h

@@ -139,7 +139,7 @@ class ModbusTCPServer:
 		std::queue<unsigned char> qrecv;
 		ModbusTCP::MBAPHeader curQueryHeader;
 
-		UniSetTypes::uniset_mutex sMutex;
+		std::mutex sMutex;
 		typedef std::list<ModbusTCPSession*> SessionList;
 		SessionList slist;
 

src/Communications/Modbus/ModbusRTUSlave.cc

@@ -31,8 +31,6 @@ ModbusRTUSlave::ModbusRTUSlave( const string& dev, bool use485, bool tr_ctl ):
 	port(NULL),
 	myport(true)
 {
-	recvMutex.setName("(ModbusRTUSlave): dev='" + dev + "' recvMutex:");
-
 	if( use485 )
 	{
 		ComPort485F* cp;
@@ -148,49 +146,48 @@ bool ModbusRTUSlave::isActive()
 // -------------------------------------------------------------------------
 mbErrCode ModbusRTUSlave::realReceive(const std::unordered_set<ModbusAddr>& vmbaddr, timeout_t timeout )
 {
+	if( !recvMutex.try_lock_for( std::chrono::milliseconds(timeout)) )
 	{
-		uniset_mutex_lock lck(recvMutex, timeout);
+		if( dlog->is_crit() )
+			dlog->crit() << "(ModbusRTUSlave::receive): Don`t lock recvMutex.." << endl;
 
-		if( !lck.lock_ok() )
-		{
-			if( dlog->is_crit() )
-				dlog->crit() << "(ModbusRTUSlave::receive): Don`t lock " << recvMutex << endl;
+		return erTimeOut;
+	}
 
-			return erTimeOut;
-		}
+	std::lock_guard<std::timed_mutex> lk(recvMutex,std::adopt_lock);
 
-		ModbusMessage buf;
-		mbErrCode res = erBadReplyNodeAddress;
+	ModbusMessage buf;
+	mbErrCode res = erBadReplyNodeAddress;
 
-		do
-		{
-			res = recv(vmbaddr, buf, timeout);
+	do
+	{
+		res = recv(vmbaddr, buf, timeout);
 
-			if( res != erNoError && res != erBadReplyNodeAddress )
+		if( res != erNoError && res != erBadReplyNodeAddress )
+		{
+			// Если ошибка подразумевает посылку ответа с сообщением об ошибке
+			// то посылаем
+			if( res < erInternalErrorCode )
 			{
-				// Если ошибка подразумевает посылку ответа с сообщением об ошибке
-				// то посылаем
-				if( res < erInternalErrorCode )
-				{
-					ErrorRetMessage em( buf.addr, buf.func, res );
-					buf = em.transport_msg();
-					send(buf);
-					printProcessingTime();
-				}
-
-				if( aftersend_msec > 0 )
-					msleep(aftersend_msec);
-
-				return res;
+				ErrorRetMessage em( buf.addr, buf.func, res );
+				buf = em.transport_msg();
+				send(buf);
+				printProcessingTime();
 			}
 
-			// если полученный пакет адресован
-			// не данному узлу (и не широковещательный)
-			// то ждать следующий...
+			if( aftersend_msec > 0 )
+				msleep(aftersend_msec);
+
+			return res;
 		}
-		while( res == erBadReplyNodeAddress );
 
-		return processing(buf);
+		// если полученный пакет адресован
+		// не данному узлу (и не широковещательный)
+		// то ждать следующий...
 	}
+	while( res == erBadReplyNodeAddress );
+
+	return processing(buf);
+
 }
 // -------------------------------------------------------------------------

src/Communications/Modbus/ModbusServer.cc

@@ -31,7 +31,6 @@ using namespace ModbusRTU;
 using namespace UniSetTypes;
 // -------------------------------------------------------------------------
 ModbusServer::ModbusServer():
-	recvMutex("ModbusServer_recvMutex"),
 	recvTimeOut_ms(50),
 	replyTimeout_ms(2000),
 	aftersend_msec(0),

src/Communications/Modbus/ModbusTCPServer.cc

@@ -53,7 +53,7 @@ void ModbusTCPServer::setMaxSessions( size_t num )
 {
 	if( num < sessCount )
 	{
-		uniset_mutex_lock l(sMutex);
+		std::lock_guard<std::mutex> l(sMutex);
 
 		int k = sessCount - num;
 		int d = 0;
@@ -147,7 +147,7 @@ void ModbusTCPServer::evfinish()
 // -------------------------------------------------------------------------
 void ModbusTCPServer::sessionFinished( ModbusTCPSession* s )
 {
-	uniset_mutex_lock l(sMutex);
+	std::lock_guard<std::mutex> l(sMutex);
 
 	for( auto i = slist.begin(); i != slist.end(); ++i )
 	{
@@ -162,7 +162,7 @@ void ModbusTCPServer::sessionFinished( ModbusTCPSession* s )
 // -------------------------------------------------------------------------
 void ModbusTCPServer::getSessions( Sessions& lst )
 {
-	uniset_mutex_lock l(sMutex);
+	std::lock_guard<std::mutex> l(sMutex);
 
 	for( const auto& i : slist )
 	{
@@ -266,7 +266,7 @@ void ModbusTCPServer::ioAccept(ev::io& watcher, int revents)
 		s->connectFinalSession( sigc::mem_fun(this, &ModbusTCPServer::sessionFinished) );
 
 		{
-			uniset_mutex_lock l(sMutex);
+			std::lock_guard<std::mutex> l(sMutex);
 			slist.push_back(s);
 		}
 

src/Processes/IOController.cc

@@ -206,7 +206,7 @@ void IOController::localSetUndefinedState( IOStateList::iterator& li,
 	{
 		if( changed )
 		{
-			uniset_mutex_lock l(siganyundefMutex);
+			std::lock_guard<std::mutex> l(siganyundefMutex);
 			sigAnyUndefChange.emit(li->second, this);
 		}
 	}
@@ -228,7 +228,7 @@ void IOController::localSetUndefinedState( IOStateList::iterator& li,
 	{
 		if( changed )
 		{
-			uniset_mutex_lock l(siganyMutex);
+			std::lock_guard<std::mutex> l(siganyMutex);
 			sigAnyChange.emit(li->second, this);
 		}
 	}
@@ -339,7 +339,7 @@ void IOController::localSetValue( std::shared_ptr<USensorInfo>& usi,
 	{
 		if( changed )
 		{
-			uniset_mutex_lock l(siganyMutex);
+			std::lock_guard<std::mutex> l(siganyMutex);
 			sigAnyChange.emit(usi, this);
 		}
 	}

src/Various/Mutex.cc

@@ -31,83 +31,6 @@ using namespace std;
 using namespace UniSetTypes;
 // -----------------------------------------------------------------------------
 #define MUTEX_DEBUG(m) {}
-
-uniset_mutex::uniset_mutex():
-	nm("")
-{
-}
-// -----------------------------------------------------------------------------
-uniset_mutex::uniset_mutex( const string& name ):
-	nm(name)
-{
-}
-// -----------------------------------------------------------------------------
-uniset_mutex::~uniset_mutex()
-{
-}
-// -----------------------------------------------------------------------------
-std::ostream& UniSetTypes::operator<<(std::ostream& os, uniset_mutex& m )
-{
-	return os << m.name();
-}
-// -----------------------------------------------------------------------------
-void uniset_mutex::lock()
-{
-	m_lock.lock();
-	MUTEX_DEBUG(cerr << nm << " Locked.." << endl;)
-}
-// -----------------------------------------------------------------------------
-void uniset_mutex::unlock()
-{
-	m_lock.unlock();
-	MUTEX_DEBUG(cerr << nm << " Unlocked.." << endl;)
-}
-// -----------------------------------------------------------------------------
-bool uniset_mutex::try_lock_for( const time_t& msec )
-{
-	return m_lock.try_lock_for( std::chrono::milliseconds(msec) );
-}
-// -----------------------------------------------------------------------------
-uniset_mutex_lock::uniset_mutex_lock( uniset_mutex& m, const time_t timeMS ):
-	mutex(&m),
-	locked(false)
-{
-
-	if( timeMS == 0 )
-	{
-		mutex->lock();
-		locked = true;
-		return;
-	}
-
-	if( !mutex->try_lock_for(timeMS) )
-	{
-		if( !mutex->name().empty() )
-		{
-			ulog9 << "(mutex_lock): вышло заданное время ожидания "
-				  << timeMS << " msec для " << mutex->name() << endl;
-		}
-
-		return;
-	}
-
-	// здесь мы уже под защитой mutex..
-	locked = true;
-}
-// -----------------------------------------------------------------------------
-bool uniset_mutex_lock::lock_ok()
-{
-	return locked.load();
-}
-// -----------------------------------------------------------------------------
-uniset_mutex_lock::~uniset_mutex_lock()
-{
-	if( locked )
-	{
-		mutex->unlock();
-		locked = false;
-	}
-}
 // -----------------------------------------------------------------------------
 uniset_rwmutex::uniset_rwmutex( const std::string& name ):
 	nm(name)

tests/test_logserver.cc

@@ -22,8 +22,8 @@ static const std::string test_msg2 = "Test message N2";
 static ostringstream msg;
 static ostringstream msg2;
 static ostringstream la_msg;
-static uniset_mutex r1_mutex;
-static uniset_mutex r2_mutex;
+static std::mutex r1_mutex;
+static std::mutex r2_mutex;
 
 static std::atomic_bool g_read_cancel = ATOMIC_VAR_INIT(0);
 
@@ -32,13 +32,13 @@ static int readTimeout = 4000;
 // --------------------------------------------------------------------------
 void rlog1OnEvent( const std::string& s )
 {
-	uniset_mutex_lock l(r1_mutex);
+	std::lock_guard<std::mutex> l(r1_mutex);
 	msg << s;
 }
 // --------------------------------------------------------------------------
 void rlog2OnEvent( const std::string& s )
 {
-	uniset_mutex_lock l(r2_mutex);
+	std::lock_guard<std::mutex> l(r2_mutex);
 	msg2 << s;
 }
 // --------------------------------------------------------------------------
@@ -148,7 +148,7 @@ TEST_CASE("LogServer", "[LogServer]" )
 
 	msleep(readTimeout); // пауза на переподключение reader-а к серверу..
 	{
-		uniset_mutex_lock l(r1_mutex);
+		std::lock_guard<std::mutex> l(r1_mutex);
 		REQUIRE( msg.str() == m.str() );
 	}
 
@@ -163,7 +163,7 @@ TEST_CASE("LogServer", "[LogServer]" )
 	msleep(readTimeout); // пауза на переподключение reader-а к серверу..
 
 	{
-		uniset_mutex_lock l(r1_mutex);
+		std::lock_guard<std::mutex> l(r1_mutex);
 		REQUIRE( msg.str() == m2.str() );
 	}
 
@@ -224,12 +224,12 @@ TEST_CASE("MaxSessions", "[LogServer]" )
 
 	msleep(readTimeout); // пауза на переподключение reader-а к серверу..
 	{
-		uniset_mutex_lock l(r1_mutex);
+		std::lock_guard<std::mutex> l(r1_mutex);
 		REQUIRE( msg.str() == m.str() );
 	}
 
 	{
-		uniset_mutex_lock l(r2_mutex);
+		std::lock_guard<std::mutex> l(r2_mutex);
 		/*
 				// Ищем часть сообщения об ошибке: '(LOG SERVER): Exceeded the limit on the number of sessions = 1'
 				size_t pos = msg2.str().find("Exceeded the limit");

tests/test_mutex.cc

@@ -9,69 +9,6 @@
 using namespace std;
 using namespace UniSetTypes;
 // -----------------------------------------------------------------------------
-TEST_CASE("uniset_mutex", "[mutex][basic]" )
-{
-	uniset_mutex m("mutex1");
-
-	CHECK( m.name() == "mutex1" );
-
-	m.lock();
-	CHECK_FALSE( m.try_lock_for(20) );
-
-	m.unlock();
-	CHECK( m.try_lock_for(20) );
-	CHECK_FALSE( m.try_lock_for(20) );
-
-	m.setName("m");
-	CHECK( m.name() == "m" );
-}
-// -----------------------------------------------------------------------------
-TEST_CASE("uniset_mutex_lock", "[mutex][basic]" )
-{
-	SECTION("simple lock");
-	{
-		uniset_mutex m("mutex1");
-		{
-			uniset_mutex_lock l(m);
-			CHECK_FALSE( m.try_lock_for(20) );
-		} // unlock
-
-		CHECK( m.try_lock_for(20) );
-	}
-
-	SECTION("exception lock");
-	{
-		uniset_mutex m("mutex1");
-
-		try
-		{
-			uniset_mutex_lock l(m);
-			CHECK_FALSE( m.try_lock_for(20) );
-			throw std::logic_error("err");
-		}
-		catch( const std::logic_error& e )
-		{
-		} // unlock
-
-		CHECK( m.try_lock_for(20) );
-	}
-
-	SECTION("timeout lock");
-	{
-		uniset_mutex m("mutex1");
-		{
-			uniset_mutex_lock l(m, 10);
-			CHECK_FALSE( m.try_lock_for(20) );
-
-			uniset_mutex_lock l2(m, 20);
-			CHECK_FALSE(l2.lock_ok());
-		} // unlock..
-
-		uniset_mutex_lock l3(m, 20);
-		CHECK(l3.lock_ok());
-	}
-}
-// -----------------------------------------------------------------------------
 TEST_CASE("uniset_rwmutex", "[mutex][basic]" )
 {
 	SECTION("simple lock");