Добавил тест для uniset_mutex..

extensions/tests/test_iobase.cc

@@ -258,7 +258,7 @@ TEST_CASE("IOBase: channel break","[iobase][extensions]")
     CHECK( uniset_conf()!=nullptr );
 
 	IOBase ib;
-	// просто проверка.. при отключнном breaklim.. (всегда FALSE)
+	// просто проверка.. при отключённом breaklim.. (всегда FALSE)
 	CHECK_FALSE( ib.check_channel_break(100) );
 	CHECK_FALSE( ib.check_channel_break(-100) );
 	CHECK_FALSE( ib.check_channel_break(0) );

include/Mutex.h

@@ -95,9 +95,9 @@ namespace UniSetTypes
             void wrlock();
             void rlock();
 
-            bool trylock();
-            bool tryrlock();
-            bool trywrlock();
+            bool try_lock();
+            bool try_rlock();
+            bool try_wrlock();
 
             uniset_rwmutex( const uniset_rwmutex& r ) = delete;
             uniset_rwmutex& operator=(const uniset_rwmutex& r)=delete;

src/Various/Mutex.cc

@@ -156,17 +156,17 @@ void uniset_rwmutex::unlock()
     MUTEX_DEBUG(cerr << nm << " Unlocked.." << endl;)
 }
 
-bool uniset_rwmutex::tryrlock()
+bool uniset_rwmutex::try_rlock()
 {
     return m.tryReadLock();
 }
 
-bool uniset_rwmutex::trywrlock()
+bool uniset_rwmutex::try_wrlock()
 {
     return m.tryWriteLock();
 }
 
-bool uniset_rwmutex::trylock()
+bool uniset_rwmutex::try_lock()
 {
     return m.tryWriteLock();
 }

tests/Makefile.am

@@ -22,7 +22,8 @@ test_triggerAND.cc \
 test_triggerOUT.cc \
 test_pulse.cc \
 test_modbustypes.cc \
-test_utypes.cc 
+test_utypes.cc \
+test_mutex.cc
 
 tests_with_conf_LDADD   = $(top_builddir)/lib/libUniSet2.la
 tests_with_conf_CPPFLAGS = -I$(top_builddir)/include

tests/test_mutex.cc

+#include <catch.hpp>
+// -----------------------------------------------------------------------------
+#include <iostream>
+#include "Mutex.h"
+// -----------------------------------------------------------------------------
+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( 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");
+	{
+		uniset_rwmutex m("rwmutex");
+
+		m.rlock(); // первый R-захват
+		CHECK( m.try_rlock() ); // второй R-захват
+		CHECK_FALSE( m.try_wrlock() );
+		CHECK_FALSE( m.try_lock() );
+		m.unlock(); // отпускаем "первый R-захват"
+		CHECK_FALSE( m.try_wrlock() );
+		CHECK_FALSE( m.try_lock() );
+		m.unlock(); // отпускаем второй R-захват
+
+		CHECK( m.try_wrlock() );
+		CHECK_FALSE( m.try_rlock() );
+		CHECK_FALSE( m.try_lock() );
+		m.unlock();
+		CHECK( m.try_lock() );
+	}
+}
+// -----------------------------------------------------------------------------
+TEST_CASE("uniset_rwmutex_wrlock", "[mutex][basic]" )
+{
+	SECTION("simple lock");
+	{
+		uniset_rwmutex m;
+		{
+			uniset_rwmutex_wrlock l(m);
+			CHECK_FALSE( m.try_lock() );
+		} // unlock
+
+		uniset_rwmutex_wrlock l2(m);
+		CHECK_FALSE( m.try_lock() );
+	}
+
+	SECTION("exception lock");
+	{
+		uniset_rwmutex m;
+		try
+		{
+			uniset_rwmutex_wrlock l(m);
+			CHECK_FALSE( m.try_lock() );
+			throw std::logic_error("err");
+		}
+		catch( std::logic_error& e )
+		{
+		} // unlock
+
+		uniset_rwmutex_wrlock l2(m);
+		CHECK_FALSE( m.try_lock() );
+	}
+}
+// -----------------------------------------------------------------------------
+TEST_CASE("uniset_rwmutex_rlock", "[mutex][basic]" )
+{
+	SECTION("simple lock");
+	{
+		uniset_rwmutex m;
+		{
+			uniset_rwmutex_rlock l(m);
+			CHECK_FALSE( m.try_lock() );
+		} // unlock
+
+		uniset_rwmutex_rlock l2(m);
+		CHECK_FALSE( m.try_lock() );
+	}
+
+	SECTION("exception lock");
+	{
+		uniset_rwmutex m;
+		try
+		{
+			uniset_rwmutex_rlock l(m);
+			CHECK_FALSE( m.try_lock() );
+			throw std::logic_error("err");
+		}
+		catch( std::logic_error& e )
+		{
+		} // unlock
+
+		uniset_rwmutex_rlock l2(m);
+		CHECK_FALSE( m.try_lock() );
+	}
+}
+// -----------------------------------------------------------------------------
+TEST_CASE("uniset_rwmutex_{wr|r}lock", "[mutex][basic]" )
+{
+	uniset_rwmutex m("rwmutex1");
+
+	{
+		uniset_rwmutex_rlock l1(m);
+		uniset_rwmutex_rlock l2(m);
+		uniset_rwmutex_rlock l3(m);
+		CHECK_FALSE( m.try_wrlock() );
+	} // unlock
+
+	uniset_rwmutex_wrlock l1(m);
+	CHECK_FALSE( m.try_lock() );
+}
+// -----------------------------------------------------------------------------

tests/test_unixml.cc

@@ -8,7 +8,7 @@ using namespace std;
 #include "UniXML.h"
 #include "UniSetTypes.h"
 
-TEST_CASE("UniXML", "[UniXML]" )
+TEST_CASE("UniXML", "[unixml][basic]" )
 {
     SECTION( "Default constructor" ) 
     {