Coding style applied according to style checkersubmit/tizen/20160418.104308accepted/tizen/wearable/20160418.235737accepted/tizen/tv/20160418.235750accepted/tizen/mobile/20160418.235742accepted/tizen/ivi/20160418.235747accepted/tizen/common/20160418.142113

Checker/Guide in http://10.113.136.204/confluence/pages/viewpage.action?pageId=44567756

Change-Id: Ie1c934dcc898b72a68b7a56d43eea4a3298b509c
Signed-off-by: Kyungwook Tak <k.tak@samsung.com>

25 files changed, 2673 insertions, 2387 deletions

diff --git a/tests/DBFixture.cpp b/tests/DBFixture.cpp
index a6abfd2b..f08846be 100644
--- a/tests/DBFixture.cpp
+++ b/tests/DBFixture.cpp
@@ -32,214 +32,226 @@ using namespace std::chrono;
 
 DBFixture::DBFixture()
 {
-    BOOST_CHECK(unlink(m_crypto_db_fname) == 0 || errno == ENOENT);
-    init();
+	BOOST_CHECK(unlink(m_crypto_db_fname) == 0 || errno == ENOENT);
+	init();
 }
 DBFixture::DBFixture(const char *db_fname)
 {
-    BOOST_CHECK(unlink(m_crypto_db_fname) == 0 || errno == ENOENT);
+	BOOST_CHECK(unlink(m_crypto_db_fname) == 0 || errno == ENOENT);
 
-    // copy file
-    std::ifstream f1(db_fname, std::fstream::binary);
-    std::ofstream f2(m_crypto_db_fname, std::fstream::trunc|std::fstream::binary);
-    f2 << f1.rdbuf();
-    f2.close();
-    f1.close();
+	// copy file
+	std::ifstream f1(db_fname, std::fstream::binary);
+	std::ofstream f2(m_crypto_db_fname, std::fstream::trunc | std::fstream::binary);
+	f2 << f1.rdbuf();
+	f2.close();
+	f1.close();
 
-    init();
+	init();
 }
 
 void DBFixture::init()
 {
-    high_resolution_clock::time_point srand_feed = high_resolution_clock::now();
-    srand(srand_feed.time_since_epoch().count());
+	high_resolution_clock::time_point srand_feed = high_resolution_clock::now();
+	srand(srand_feed.time_since_epoch().count());
 
-    BOOST_REQUIRE_NO_THROW(m_db = DB::Crypto(m_crypto_db_fname, defaultPass));
+	BOOST_REQUIRE_NO_THROW(m_db = DB::Crypto(m_crypto_db_fname, defaultPass));
 }
 
 double DBFixture::performance_get_time_elapsed_ms()
 {
-    return duration_cast<milliseconds>(m_end_time - m_start_time).count();
+	return duration_cast<milliseconds>(m_end_time - m_start_time).count();
 }
 
 void DBFixture::performance_start(const char *operation_name)
 {
-    m_operation = std::string(operation_name?operation_name:"unknown");
-    BOOST_TEST_MESSAGE("\t<performance> running " << m_operation << " performance test...");
-    m_start_time = high_resolution_clock::now();
+	m_operation = std::string(operation_name ? operation_name : "unknown");
+	BOOST_TEST_MESSAGE("\t<performance> running " << m_operation <<
+					   " performance test...");
+	m_start_time = high_resolution_clock::now();
 }
 
 void DBFixture::performance_stop(long num_operations_performed)
 {
-    m_end_time = high_resolution_clock::now();
-    double time_elapsed_ms = performance_get_time_elapsed_ms();
-    BOOST_TEST_MESSAGE("\t<performance> time elapsed: " << time_elapsed_ms << "[ms], number of " << m_operation << ": " << num_operations_performed);
-    if(num_operations_performed>0)
-        BOOST_TEST_MESSAGE("\t<performance> average time per " << m_operation << ": " << time_elapsed_ms/num_operations_performed << "[ms]");
+	m_end_time = high_resolution_clock::now();
+	double time_elapsed_ms = performance_get_time_elapsed_ms();
+	BOOST_TEST_MESSAGE("\t<performance> time elapsed: " << time_elapsed_ms <<
+					   "[ms], number of " << m_operation << ": " << num_operations_performed);
+
+	if (num_operations_performed > 0)
+		BOOST_TEST_MESSAGE("\t<performance> average time per " << m_operation << ": " <<
+						   time_elapsed_ms / num_operations_performed << "[ms]");
 }
 
-void DBFixture::generate_name(unsigned int id, Name & output)
+void DBFixture::generate_name(unsigned int id, Name &output)
 {
-    std::stringstream ss;
-    ss << "name_no_" << id;
-    output = ss.str();
+	std::stringstream ss;
+	ss << "name_no_" << id;
+	output = ss.str();
 }
 
-void DBFixture::generate_label(unsigned int id, Label & output)
+void DBFixture::generate_label(unsigned int id, Label &output)
 {
-    std::stringstream ss;
-    ss << "label_no_" << id;
-    output = ss.str();
+	std::stringstream ss;
+	ss << "label_no_" << id;
+	output = ss.str();
 }
 
-void DBFixture::generate_perf_DB(unsigned int num_name, unsigned int num_elements)
+void DBFixture::generate_perf_DB(unsigned int num_name,
+								 unsigned int num_elements)
 {
-    // to speed up data creation - cache the row
-    DB::Row rowPattern = create_default_row(DataType::BINARY_DATA);
-    rowPattern.data = RawBuffer(100, 20);
-    rowPattern.dataSize = rowPattern.data.size();
-    rowPattern.tag = RawBuffer(AES_GCM_TAG_SIZE, 1);
-
-    for(unsigned int i=0; i<num_name; i++)
-    {
-        generate_name(i, rowPattern.name);
-        generate_label(i/num_elements, rowPattern.ownerLabel);
-
-        BOOST_REQUIRE_NO_THROW(m_db.saveRow(rowPattern));
-    }
+	// to speed up data creation - cache the row
+	DB::Row rowPattern = create_default_row(DataType::BINARY_DATA);
+	rowPattern.data = RawBuffer(100, 20);
+	rowPattern.dataSize = rowPattern.data.size();
+	rowPattern.tag = RawBuffer(AES_GCM_TAG_SIZE, 1);
+
+	for (unsigned int i = 0; i < num_name; i++) {
+		generate_name(i, rowPattern.name);
+		generate_label(i / num_elements, rowPattern.ownerLabel);
+
+		BOOST_REQUIRE_NO_THROW(m_db.saveRow(rowPattern));
+	}
 }
 
-long DBFixture::add_full_access_rights(unsigned int num_name, unsigned int num_name_per_label)
+long DBFixture::add_full_access_rights(unsigned int num_name,
+									   unsigned int num_name_per_label)
 {
-    long iterations = 0;
-    unsigned int num_labels = num_name / num_name_per_label;
-    Name name;
-    Label owner_label, accessor_label;
-    for(unsigned int a=0; a<num_name; a++)
-    {
-        generate_name(a, name);
-        generate_label(a/num_name_per_label, owner_label);
-        for(unsigned int l=0; l<num_labels; l++)
-        {
-            // bypass the owner label
-            if(l == (a/num_name_per_label))
-                continue;
-
-            // add permission
-            generate_label(l, accessor_label);
-            add_permission(name, owner_label, accessor_label);
-            iterations ++;
-        }
-    }
-
-    return iterations;
+	long iterations = 0;
+	unsigned int num_labels = num_name / num_name_per_label;
+	Name name;
+	Label owner_label, accessor_label;
+
+	for (unsigned int a = 0; a < num_name; a++) {
+		generate_name(a, name);
+		generate_label(a / num_name_per_label, owner_label);
+
+		for (unsigned int l = 0; l < num_labels; l++) {
+			// bypass the owner label
+			if (l == (a / num_name_per_label))
+				continue;
+
+			// add permission
+			generate_label(l, accessor_label);
+			add_permission(name, owner_label, accessor_label);
+			iterations++;
+		}
+	}
+
+	return iterations;
 }
 
 DB::Row DBFixture::create_default_row(DataType type)
 {
-    return create_default_row(m_default_name, m_default_label, type);
+	return create_default_row(m_default_name, m_default_label, type);
 }
 
 DB::Row DBFixture::create_default_row(const Name &name,
-                                    const Label &label,
-                                    DataType type)
+									  const Label &label,
+									  DataType type)
 {
-    DB::Row row;
-    row.name = name;
-    row.ownerLabel = label;
-    row.exportable = 1;
-    row.algorithmType = DBCMAlgType::AES_GCM_256;
-    row.dataType = type;
-    row.iv = createDefaultPass();
-    row.encryptionScheme = 0;
-    row.dataSize = 0;
-    row.backendId = CryptoBackend::OpenSSL;
-
-    return row;
+	DB::Row row;
+	row.name = name;
+	row.ownerLabel = label;
+	row.exportable = 1;
+	row.algorithmType = DBCMAlgType::AES_GCM_256;
+	row.dataType = type;
+	row.iv = createDefaultPass();
+	row.encryptionScheme = 0;
+	row.dataSize = 0;
+	row.backendId = CryptoBackend::OpenSSL;
+
+	return row;
 }
 
 void DBFixture::compare_row(const DB::Row &lhs, const DB::Row &rhs)
 {
-    BOOST_CHECK_MESSAGE(lhs.name == rhs.name,
-            "namees didn't match! Got: " << rhs.name
-                << " , expected : " << lhs.name);
+	BOOST_CHECK_MESSAGE(lhs.name == rhs.name,
+						"namees didn't match! Got: " << rhs.name
+						<< " , expected : " << lhs.name);
 
-    BOOST_CHECK_MESSAGE(lhs.ownerLabel == rhs.ownerLabel,
-            "smackLabel didn't match! Got: " << rhs.ownerLabel
-                << " , expected : " << lhs.ownerLabel);
+	BOOST_CHECK_MESSAGE(lhs.ownerLabel == rhs.ownerLabel,
+						"smackLabel didn't match! Got: " << rhs.ownerLabel
+						<< " , expected : " << lhs.ownerLabel);
 
-    BOOST_CHECK_MESSAGE(lhs.exportable == rhs.exportable,
-            "exportable didn't match! Got: " << rhs.exportable
-                << " , expected : " << lhs.exportable);
+	BOOST_CHECK_MESSAGE(lhs.exportable == rhs.exportable,
+						"exportable didn't match! Got: " << rhs.exportable
+						<< " , expected : " << lhs.exportable);
 
-    BOOST_CHECK_MESSAGE(lhs.iv == rhs.iv,
-            "iv didn't match! Got: " << rhs.iv.size()
-                << " , expected : " << lhs.iv.size());
+	BOOST_CHECK_MESSAGE(lhs.iv == rhs.iv,
+						"iv didn't match! Got: " << rhs.iv.size()
+						<< " , expected : " << lhs.iv.size());
 
-    BOOST_CHECK_MESSAGE(lhs.data == rhs.data,
-            "data didn't match! Got: " << rhs.data.size()
-                << " , expected : " << lhs.data.size());
+	BOOST_CHECK_MESSAGE(lhs.data == rhs.data,
+						"data didn't match! Got: " << rhs.data.size()
+						<< " , expected : " << lhs.data.size());
 
-    BOOST_CHECK_MESSAGE(lhs.backendId == rhs.backendId,
-            "backendId didn't match! Got: " << static_cast<int>(rhs.backendId)
-                << " , expected : " << static_cast<int>(lhs.backendId));
+	BOOST_CHECK_MESSAGE(lhs.backendId == rhs.backendId,
+						"backendId didn't match! Got: " << static_cast<int>(rhs.backendId)
+						<< " , expected : " << static_cast<int>(lhs.backendId));
 }
 
 void DBFixture::check_DB_integrity(const DB::Row &rowPattern)
 {
-    BOOST_REQUIRE_NO_THROW(m_db.saveRow(rowPattern));
-
-    DB::Crypto::RowOptional optional_row;
-    BOOST_REQUIRE_NO_THROW(optional_row = m_db.getRow("name", "label", DataType::BINARY_DATA));
-    BOOST_REQUIRE_MESSAGE(optional_row, "Select didn't return any row");
-
-    compare_row(*optional_row, rowPattern);
-    DB::Row name_duplicate = rowPattern;
-    name_duplicate.data = createDefaultPass();
-    name_duplicate.dataSize = name_duplicate.data.size();
-
-    unsigned int erased;
-    BOOST_REQUIRE_NO_THROW(erased = m_db.deleteRow("name", "label"));
-    BOOST_REQUIRE_MESSAGE(erased > 0, "Inserted row didn't exist in db");
-
-    DB::Crypto::RowOptional row_optional;
-    BOOST_REQUIRE_NO_THROW(row_optional = m_db.getRow("name", "label", DataType::BINARY_DATA));
-    BOOST_REQUIRE_MESSAGE(!row_optional, "Select should not return row after deletion");
+	BOOST_REQUIRE_NO_THROW(m_db.saveRow(rowPattern));
+
+	DB::Crypto::RowOptional optional_row;
+	BOOST_REQUIRE_NO_THROW(optional_row = m_db.getRow("name", "label",
+										  DataType::BINARY_DATA));
+	BOOST_REQUIRE_MESSAGE(optional_row, "Select didn't return any row");
+
+	compare_row(*optional_row, rowPattern);
+	DB::Row name_duplicate = rowPattern;
+	name_duplicate.data = createDefaultPass();
+	name_duplicate.dataSize = name_duplicate.data.size();
+
+	unsigned int erased;
+	BOOST_REQUIRE_NO_THROW(erased = m_db.deleteRow("name", "label"));
+	BOOST_REQUIRE_MESSAGE(erased > 0, "Inserted row didn't exist in db");
+
+	DB::Crypto::RowOptional row_optional;
+	BOOST_REQUIRE_NO_THROW(row_optional = m_db.getRow("name", "label",
+										  DataType::BINARY_DATA));
+	BOOST_REQUIRE_MESSAGE(!row_optional,
+						  "Select should not return row after deletion");
 }
 
 void DBFixture::insert_row()
 {
-    insert_row(m_default_name, m_default_label);
+	insert_row(m_default_name, m_default_label);
 }
 
 void DBFixture::insert_row(const Name &name, const Label &owner_label)
 {
-    DB::Row rowPattern = create_default_row(name, owner_label, DataType::BINARY_DATA);
-    rowPattern.data = RawBuffer(100, 20);
-    rowPattern.dataSize = rowPattern.data.size();
-    rowPattern.tag = RawBuffer(AES_GCM_TAG_SIZE, 1);
-    BOOST_REQUIRE_NO_THROW(m_db.saveRow(rowPattern));
+	DB::Row rowPattern = create_default_row(name, owner_label,
+											DataType::BINARY_DATA);
+	rowPattern.data = RawBuffer(100, 20);
+	rowPattern.dataSize = rowPattern.data.size();
+	rowPattern.tag = RawBuffer(AES_GCM_TAG_SIZE, 1);
+	BOOST_REQUIRE_NO_THROW(m_db.saveRow(rowPattern));
 }
 
 void DBFixture::delete_row(const Name &name, const Label &owner_label)
 {
-    bool exit_flag;
-    BOOST_REQUIRE_NO_THROW(exit_flag = m_db.deleteRow(name, owner_label));
-    BOOST_REQUIRE_MESSAGE(true == exit_flag, "remove name failed: no rows removed");
+	bool exit_flag;
+	BOOST_REQUIRE_NO_THROW(exit_flag = m_db.deleteRow(name, owner_label));
+	BOOST_REQUIRE_MESSAGE(true == exit_flag, "remove name failed: no rows removed");
 }
 
-void DBFixture::add_permission(const Name &name, const Label &owner_label, const Label &accessor_label)
+void DBFixture::add_permission(const Name &name, const Label &owner_label,
+							   const Label &accessor_label)
 {
-    BOOST_REQUIRE_NO_THROW(m_db.setPermission(name,
-                                              owner_label,
-                                              accessor_label,
-                                              CKM::Permission::READ | CKM::Permission::REMOVE));
+	BOOST_REQUIRE_NO_THROW(m_db.setPermission(name,
+						   owner_label,
+						   accessor_label,
+						   CKM::Permission::READ | CKM::Permission::REMOVE));
 }
 
-void DBFixture::read_row_expect_success(const Name &name, const Label &owner_label)
+void DBFixture::read_row_expect_success(const Name &name,
+										const Label &owner_label)
 {
-    DB::Crypto::RowOptional row;
-    BOOST_REQUIRE_NO_THROW(row = m_db.getRow(name, owner_label, DataType::BINARY_DATA));
-    BOOST_REQUIRE_MESSAGE(row, "row is empty");
-    BOOST_REQUIRE_MESSAGE(row->name == name, "name is not valid");
+	DB::Crypto::RowOptional row;
+	BOOST_REQUIRE_NO_THROW(row = m_db.getRow(name, owner_label,
+								 DataType::BINARY_DATA));
+	BOOST_REQUIRE_MESSAGE(row, "row is empty");
+	BOOST_REQUIRE_MESSAGE(row->name == name, "name is not valid");
 }
diff --git a/tests/DBFixture.h b/tests/DBFixture.h
index 2cd2cdc7..62f19a2a 100644
--- a/tests/DBFixture.h
+++ b/tests/DBFixture.h
@@ -27,44 +27,48 @@
 #include <protocols.h>
 #include <chrono>
 
-class DBFixture
-{
-    public:
-        DBFixture();
-        DBFixture(const char *db_fname);
+class DBFixture {
+public:
+	DBFixture();
+	DBFixture(const char *db_fname);
 
-        constexpr static const char* m_default_name = "name";
-        constexpr static const char* m_default_label = "label";
+	constexpr static const char *m_default_name = "name";
+	constexpr static const char *m_default_label = "label";
 
-        // ::::::::::::::::::::::::: helper methods :::::::::::::::::::::::::
-        static void generate_name(unsigned int id, CKM::Name & output);
-        static void generate_label(unsigned int id, CKM::Label & output);
-        static CKM::DB::Row create_default_row(CKM::DataType type = CKM::DataType::BINARY_DATA);
-        static CKM::DB::Row create_default_row(const CKM::Name &name,
-                                             const CKM::Label &label,
-                                             CKM::DataType type = CKM::DataType::BINARY_DATA);
-        static void compare_row(const CKM::DB::Row &lhs, const CKM::DB::Row &rhs);
+	// ::::::::::::::::::::::::: helper methods :::::::::::::::::::::::::
+	static void generate_name(unsigned int id, CKM::Name &output);
+	static void generate_label(unsigned int id, CKM::Label &output);
+	static CKM::DB::Row create_default_row(CKM::DataType type =
+			CKM::DataType::BINARY_DATA);
+	static CKM::DB::Row create_default_row(const CKM::Name &name,
+										   const CKM::Label &label,
+										   CKM::DataType type = CKM::DataType::BINARY_DATA);
+	static void compare_row(const CKM::DB::Row &lhs, const CKM::DB::Row &rhs);
 
-        // ::::::::::::::::::::::::: time measurement :::::::::::::::::::::::::
-        void performance_start(const char *operation_name);
-        void performance_stop(long num_operations_performed);
+	// ::::::::::::::::::::::::: time measurement :::::::::::::::::::::::::
+	void performance_start(const char *operation_name);
+	void performance_stop(long num_operations_performed);
 
-        // ::::::::::::::::::::::::: DB :::::::::::::::::::::::::
-        void generate_perf_DB(unsigned int num_name, unsigned int num_label);
-        long add_full_access_rights(unsigned int num_name, unsigned int num_names_per_label);
-        void check_DB_integrity(const CKM::DB::Row &rowPattern);
-        void insert_row();
-        void insert_row(const CKM::Name &name, const CKM::Label &owner_label);
-        void delete_row(const CKM::Name &name, const CKM::Label &owner_label);
-        void add_permission(const CKM::Name &name, const CKM::Label &owner_label, const CKM::Label &accessor_label);
-        void read_row_expect_success(const CKM::Name &name, const CKM::Label &owner_label);
+	// ::::::::::::::::::::::::: DB :::::::::::::::::::::::::
+	void generate_perf_DB(unsigned int num_name, unsigned int num_label);
+	long add_full_access_rights(unsigned int num_name,
+								unsigned int num_names_per_label);
+	void check_DB_integrity(const CKM::DB::Row &rowPattern);
+	void insert_row();
+	void insert_row(const CKM::Name &name, const CKM::Label &owner_label);
+	void delete_row(const CKM::Name &name, const CKM::Label &owner_label);
+	void add_permission(const CKM::Name &name, const CKM::Label &owner_label,
+						const CKM::Label &accessor_label);
+	void read_row_expect_success(const CKM::Name &name,
+								 const CKM::Label &owner_label);
 
-        CKM::DB::Crypto    m_db;
-    private:
-        void    init();
-        double  performance_get_time_elapsed_ms();
+	CKM::DB::Crypto    m_db;
 
-        constexpr static const char* m_crypto_db_fname = "/tmp/testme.db";
-        std::string m_operation;
-        std::chrono::high_resolution_clock::time_point m_start_time, m_end_time;
+private:
+	void    init();
+	double  performance_get_time_elapsed_ms();
+
+	constexpr static const char *m_crypto_db_fname = "/tmp/testme.db";
+	std::string m_operation;
+	std::chrono::high_resolution_clock::time_point m_start_time, m_end_time;
 };
diff --git a/tests/colour_log_formatter.cpp b/tests/colour_log_formatter.cpp
index 8857f740..efcb408b 100644
--- a/tests/colour_log_formatter.cpp
+++ b/tests/colour_log_formatter.cpp
@@ -40,19 +40,21 @@ namespace {
 const_string
 test_phase_identifier()
 {
-    return framework::is_initialized()
-            ? const_string( framework::current_test_case().p_name.get() )
-            : BOOST_TEST_L( "Test setup" );
+	return framework::is_initialized()
+		   ? const_string(framework::current_test_case().p_name.get())
+		   : BOOST_TEST_L("Test setup");
 }
 
 const_string
-get_basename(const const_string &file_name) {
-    return basename(file_name.begin());
+get_basename(const const_string &file_name)
+{
+	return basename(file_name.begin());
 }
 
 std::string
-get_basename(const std::string &file_name) {
-    return basename(file_name.c_str());
+get_basename(const std::string &file_name)
+{
+	return basename(file_name.c_str());
 }
 
 } // local namespace
@@ -61,185 +63,206 @@ get_basename(const std::string &file_name) {
 
 void
 colour_log_formatter::log_start(
-        std::ostream& output,
-        counter_t test_cases_amount )
+	std::ostream &output,
+	counter_t test_cases_amount)
 {
-    if( test_cases_amount > 0 )
-        output  << "Running " << test_cases_amount << " test "
-                << (test_cases_amount > 1 ? "cases" : "case") << "...\n";
+	if (test_cases_amount > 0)
+		output  << "Running " << test_cases_amount << " test "
+				<< (test_cases_amount > 1 ? "cases" : "case") << "...\n";
 }
 
 //____________________________________________________________________________//
 
 void
-colour_log_formatter::log_finish( std::ostream& ostr )
+colour_log_formatter::log_finish(std::ostream &ostr)
 {
-    ostr.flush();
+	ostr.flush();
 }
 
 //____________________________________________________________________________//
 
 void
-colour_log_formatter::log_build_info( std::ostream& output )
+colour_log_formatter::log_build_info(std::ostream &output)
 {
-    output  << "Platform: " << BOOST_PLATFORM            << '\n'
-            << "Compiler: " << BOOST_COMPILER            << '\n'
-            << "STL     : " << BOOST_STDLIB              << '\n'
-            << "Boost   : " << BOOST_VERSION/100000      << "."
-                            << BOOST_VERSION/100 % 1000  << "."
-                            << BOOST_VERSION % 100       << std::endl;
+	output  << "Platform: " << BOOST_PLATFORM            << '\n'
+			<< "Compiler: " << BOOST_COMPILER            << '\n'
+			<< "STL     : " << BOOST_STDLIB              << '\n'
+			<< "Boost   : " << BOOST_VERSION / 100000      << "."
+			<< BOOST_VERSION / 100 % 1000  << "."
+			<< BOOST_VERSION % 100       << std::endl;
 }
 
 //____________________________________________________________________________//
 
 void
 colour_log_formatter::test_unit_start(
-        std::ostream& output,
-        test_unit const& tu )
+	std::ostream &output,
+	test_unit const &tu)
 {
-    if (tu.p_type_name->find(const_string("suite")) == 0) {
-        output << "Starting test " << tu.p_type_name << " \"" << tu.p_name << "\"" << std::endl;
-    } else {
-        output << "Running test " << tu.p_type_name << " \"" << tu.p_name << "\"" << std::endl;
-    }
+	if (tu.p_type_name->find(const_string("suite")) == 0) {
+		output << "Starting test " << tu.p_type_name << " \"" << tu.p_name << "\"" <<
+			   std::endl;
+	} else {
+		output << "Running test " << tu.p_type_name << " \"" << tu.p_name << "\"" <<
+			   std::endl;
+	}
 }
 
 //____________________________________________________________________________//
 
 void
 colour_log_formatter::test_unit_finish(
-        std::ostream& output,
-        test_unit const& tu,
-        unsigned long elapsed )
+	std::ostream &output,
+	test_unit const &tu,
+	unsigned long elapsed)
 {
-    if (tu.p_type_name->find(const_string("suite")) == 0) {
-        output << "Finished test " << tu.p_type_name << " \"" << tu.p_name << "\""<< std::endl;
-        return;
-    }
-    std::string color = CKM::Colors::Text::GREEN_BEGIN;
-    std::string status = "OK";
-    if (m_isTestCaseFailed) {
-        color = CKM::Colors::Text::RED_BEGIN;
-        status = "FAIL";
-    }
-    output << "\t" << "[   " << color << status << CKM::Colors::Text::COLOR_END << "   ]";
-
-
-    output << ", " << CKM::Colors::Text::CYAN_BEGIN << "time: ";
-    if( elapsed > 0 ) {
-        if( elapsed % 1000 == 0 )
-            output << elapsed/1000 << "ms";
-        else
-            output << elapsed << "mks";
-    } else {
-        output << "N/A";
-    }
-
-    output << CKM::Colors::Text::COLOR_END << std::endl;
-    m_isTestCaseFailed = false;
+	if (tu.p_type_name->find(const_string("suite")) == 0) {
+		output << "Finished test " << tu.p_type_name << " \"" << tu.p_name << "\"" <<
+			   std::endl;
+		return;
+	}
+
+	std::string color = CKM::Colors::Text::GREEN_BEGIN;
+	std::string status = "OK";
+
+	if (m_isTestCaseFailed) {
+		color = CKM::Colors::Text::RED_BEGIN;
+		status = "FAIL";
+	}
+
+	output << "\t" << "[   " << color << status << CKM::Colors::Text::COLOR_END <<
+		   "   ]";
+
+
+	output << ", " << CKM::Colors::Text::CYAN_BEGIN << "time: ";
+
+	if (elapsed > 0) {
+		if (elapsed % 1000 == 0)
+			output << elapsed / 1000 << "ms";
+		else
+			output << elapsed << "mks";
+	} else {
+		output << "N/A";
+	}
+
+	output << CKM::Colors::Text::COLOR_END << std::endl;
+	m_isTestCaseFailed = false;
 }
 
 //____________________________________________________________________________//
 
 void
 colour_log_formatter::test_unit_skipped(
-        std::ostream& output,
-        test_unit const& tu )
+	std::ostream &output,
+	test_unit const &tu)
 {
-    output  << "Test " << tu.p_type_name << " \"" << tu.p_name << "\"" << "is skipped" << std::endl;
+	output  << "Test " << tu.p_type_name << " \"" << tu.p_name << "\"" <<
+			"is skipped" << std::endl;
 }
 
 //____________________________________________________________________________//
 
 void
 colour_log_formatter::log_exception(
-        std::ostream& output,
-        log_checkpoint_data const& checkpoint_data,
-        boost::execution_exception const& ex )
+	std::ostream &output,
+	log_checkpoint_data const &checkpoint_data,
+	boost::execution_exception const &ex)
 {
-    boost::execution_exception::location const& loc = ex.where();
-    output << '\t' << CKM::Colors::Text::BOLD_YELLOW_BEGIN << get_basename(loc.m_file_name)
-            << '(' << loc.m_line_num << "), ";
+	boost::execution_exception::location const &loc = ex.where();
+	output << '\t' << CKM::Colors::Text::BOLD_YELLOW_BEGIN << get_basename(
+			   loc.m_file_name)
+		   << '(' << loc.m_line_num << "), ";
+
+	output << "fatal error in \""
+		   << (loc.m_function.is_empty() ? test_phase_identifier() : loc.m_function) <<
+		   "\": ";
 
-    output << "fatal error in \""
-            << (loc.m_function.is_empty() ? test_phase_identifier() : loc.m_function ) << "\": ";
+	output << CKM::Colors::Text::COLOR_END << ex.what();
 
-    output << CKM::Colors::Text::COLOR_END << ex.what();
+	if (!checkpoint_data.m_file_name.is_empty()) {
+		output << '\n';
+		output << "\tlast checkpoint : " << get_basename(checkpoint_data.m_file_name)
+			   << '(' << checkpoint_data.m_line_num << ")";
 
-    if( !checkpoint_data.m_file_name.is_empty() ) {
-        output << '\n';
-        output << "\tlast checkpoint : " << get_basename(checkpoint_data.m_file_name)
-                << '(' << checkpoint_data.m_line_num << ")";
-        if( !checkpoint_data.m_message.empty() )
-            output << ": " << checkpoint_data.m_message;
-    }
+		if (!checkpoint_data.m_message.empty())
+			output << ": " << checkpoint_data.m_message;
+	}
 
-    output << std::endl;
-    m_isTestCaseFailed = true;
+	output << std::endl;
+	m_isTestCaseFailed = true;
 }
 
 //____________________________________________________________________________//
 
 void
 colour_log_formatter::log_entry_start(
-        std::ostream& output,
-        log_entry_data const& entry_data,
-        log_entry_types let )
+	std::ostream &output,
+	log_entry_data const &entry_data,
+	log_entry_types let)
 {
-    switch( let ) {
-        case BOOST_UTL_ET_INFO:
-            output << '\t' << entry_data.m_file_name << '(' << entry_data.m_line_num << "), ";
-            output << "info: ";
-            break;
-        case BOOST_UTL_ET_MESSAGE:
-            break;
-        case BOOST_UTL_ET_WARNING:
-            output << '\t' << get_basename(entry_data.m_file_name) << '(' << entry_data.m_line_num << "), ";
-            output << "warning in \"" << test_phase_identifier() << "\": ";
-            break;
-        case BOOST_UTL_ET_ERROR:
-            output << '\t' << CKM::Colors::Text::BOLD_YELLOW_BEGIN <<  get_basename(entry_data.m_file_name)
-                << '(' << entry_data.m_line_num << "), ";
-            output << "error in \"" << test_phase_identifier() << "\": ";
-            m_isTestCaseFailed = true;
-            break;
-        case BOOST_UTL_ET_FATAL_ERROR:
-            output << '\t' << CKM::Colors::Text::BOLD_YELLOW_BEGIN <<  get_basename(entry_data.m_file_name)
-                << '(' << entry_data.m_line_num << "),  ";
-            output <<  " fatal error in \"" << test_phase_identifier() << "\": ";
-            m_isTestCaseFailed = true;
-            break;
-    }
-    output << CKM::Colors::Text::COLOR_END;
+	switch (let) {
+	case BOOST_UTL_ET_INFO:
+		output << '\t' << entry_data.m_file_name << '(' << entry_data.m_line_num <<
+			   "), ";
+		output << "info: ";
+		break;
+
+	case BOOST_UTL_ET_MESSAGE:
+		break;
+
+	case BOOST_UTL_ET_WARNING:
+		output << '\t' << get_basename(entry_data.m_file_name) << '(' <<
+			   entry_data.m_line_num << "), ";
+		output << "warning in \"" << test_phase_identifier() << "\": ";
+		break;
+
+	case BOOST_UTL_ET_ERROR:
+		output << '\t' << CKM::Colors::Text::BOLD_YELLOW_BEGIN <<  get_basename(
+				   entry_data.m_file_name)
+			   << '(' << entry_data.m_line_num << "), ";
+		output << "error in \"" << test_phase_identifier() << "\": ";
+		m_isTestCaseFailed = true;
+		break;
+
+	case BOOST_UTL_ET_FATAL_ERROR:
+		output << '\t' << CKM::Colors::Text::BOLD_YELLOW_BEGIN <<  get_basename(
+				   entry_data.m_file_name)
+			   << '(' << entry_data.m_line_num << "),  ";
+		output <<  " fatal error in \"" << test_phase_identifier() << "\": ";
+		m_isTestCaseFailed = true;
+		break;
+	}
+
+	output << CKM::Colors::Text::COLOR_END;
 }
 
 //____________________________________________________________________________//
 
 void
 colour_log_formatter::log_entry_value(
-        std::ostream& output,
-        const_string value )
+	std::ostream &output,
+	const_string value)
 {
-    output << value;
+	output << value;
 }
 
 //____________________________________________________________________________//
 
 void
 colour_log_formatter::log_entry_value(
-        std::ostream& output,
-        lazy_ostream const& value )
+	std::ostream &output,
+	lazy_ostream const &value)
 {
-    output << value;
+	output << value;
 }
 
 //____________________________________________________________________________//
 
 void
 colour_log_formatter::log_entry_finish(
-        std::ostream& output )
+	std::ostream &output)
 {
-    output << std::endl;
+	output << std::endl;
 }
 
 //____________________________________________________________________________//
diff --git a/tests/colour_log_formatter.h b/tests/colour_log_formatter.h
index a9e44066..3c5dae00 100644
--- a/tests/colour_log_formatter.h
+++ b/tests/colour_log_formatter.h
@@ -18,42 +18,43 @@
 namespace CKM {
 class colour_log_formatter : public boost::unit_test::unit_test_log_formatter {
 public:
-    // Formatter interface
-    colour_log_formatter() : m_isTestCaseFailed(false) {}
-    void    log_start(
-                std::ostream&,
-                boost::unit_test::counter_t test_cases_amount );
-    void    log_finish( std::ostream& );
-    void    log_build_info( std::ostream& );
+	// Formatter interface
+	colour_log_formatter() : m_isTestCaseFailed(false) {}
+	void    log_start(
+		std::ostream &,
+		boost::unit_test::counter_t test_cases_amount);
+	void    log_finish(std::ostream &);
+	void    log_build_info(std::ostream &);
 
-    void    test_unit_start(
-                std::ostream&,
-                boost::unit_test::test_unit const& tu );
-    void    test_unit_finish(
-                std::ostream&,
-                boost::unit_test::test_unit const& tu,
-                unsigned long elapsed );
-    void    test_unit_skipped(
-                std::ostream&,
-                boost::unit_test::test_unit const& tu );
+	void    test_unit_start(
+		std::ostream &,
+		boost::unit_test::test_unit const &tu);
+	void    test_unit_finish(
+		std::ostream &,
+		boost::unit_test::test_unit const &tu,
+		unsigned long elapsed);
+	void    test_unit_skipped(
+		std::ostream &,
+		boost::unit_test::test_unit const &tu);
 
-    void    log_exception(
-                std::ostream&,
-                boost::unit_test::log_checkpoint_data const&,
-                boost::execution_exception const& ex );
+	void    log_exception(
+		std::ostream &,
+		boost::unit_test::log_checkpoint_data const &,
+		boost::execution_exception const &ex);
+
+	void    log_entry_start(
+		std::ostream &,
+		boost::unit_test::log_entry_data const &,
+		log_entry_types let);
+	void    log_entry_value(
+		std::ostream &,
+		boost::unit_test::const_string value);
+	void    log_entry_value(
+		std::ostream &,
+		boost::unit_test::lazy_ostream const &value);
+	void    log_entry_finish(std::ostream &);
 
-    void    log_entry_start(
-                std::ostream&,
-                boost::unit_test::log_entry_data const&,
-                log_entry_types let );
-    void    log_entry_value(
-                std::ostream&,
-                boost::unit_test::const_string value );
-    void    log_entry_value(
-                std::ostream&,
-                boost::unit_test::lazy_ostream const& value );
-    void    log_entry_finish( std::ostream& );
 private:
-    bool m_isTestCaseFailed;
+	bool m_isTestCaseFailed;
 };
 } // namespace CKM
diff --git a/tests/encryption-scheme/generate-db.cpp b/tests/encryption-scheme/generate-db.cpp
index 3177230a..8bb6e3c9 100644
--- a/tests/encryption-scheme/generate-db.cpp
+++ b/tests/encryption-scheme/generate-db.cpp
@@ -26,16 +26,16 @@
 
 int main()
 {
-    try {
-        SchemeTest st;
-        st.FillDb();
-        return 0;
-    } catch (const std::runtime_error& e) {
-        std::cerr << e.what() << std::endl;
-        return -1;
-    } catch (...) {
-        std::cerr << "Unknown exception occured!" << std::endl;
-        return -1;
-    }
+	try {
+		SchemeTest st;
+		st.FillDb();
+		return 0;
+	} catch (const std::runtime_error &e) {
+		std::cerr << e.what() << std::endl;
+		return -1;
+	} catch (...) {
+		std::cerr << "Unknown exception occured!" << std::endl;
+		return -1;
+	}
 }
 
diff --git a/tests/encryption-scheme/scheme-test.cpp b/tests/encryption-scheme/scheme-test.cpp
index 47d15692..d0096ace 100644
--- a/tests/encryption-scheme/scheme-test.cpp
+++ b/tests/encryption-scheme/scheme-test.cpp
@@ -51,8 +51,8 @@ using namespace std;
 namespace {
 const uid_t UID = 7654;
 const gid_t GID = 7654;
-const char* const DBPASS = "db-pass";
-const char* const LABEL = "my-label";
+const char *const DBPASS = "db-pass";
+const char *const LABEL = "my-label";
 const Label DB_LABEL = "/" + string(LABEL);
 const int ENC_SCHEME_OFFSET = 24;
 const string TEST_DATA_STR = "test-data";
@@ -62,742 +62,846 @@ const size_t IV_LEN = 16;
 const size_t CHAIN_LEN = 3;
 
 enum {
-    NO_PASS = 0,
-    PASS = 1
+	NO_PASS = 0,
+	PASS = 1
 };
 
 enum {
-    NO_EXP = 0,
-    EXP = 1
+	NO_EXP = 0,
+	EXP = 1
 };
 
 // [password][exportable]
 Policy policy[2][2] = {
-        {{ Password(), false }, { Password(), true }},
-        {{ TEST_PASS,  false }, { TEST_PASS,  true }},
+	{{ Password(), false }, { Password(), true }},
+	{{ TEST_PASS,  false }, { TEST_PASS,  true }},
 };
 
 struct Group {
-    enum {
-        SINGLE_ITEM,
-        KEY_PAIR_RSA,
-        CERT_CHAIN
-    } type;
-    Items items;
+	enum {
+		SINGLE_ITEM,
+		KEY_PAIR_RSA,
+		CERT_CHAIN
+	} type;
+	Items items;
 };
 
 Group GROUPS[] = {
-    // Data
-    { Group::SINGLE_ITEM, {
-            Item("data-alias1", DataType::BINARY_DATA,  policy[NO_PASS][EXP])
-    }},
-    { Group::SINGLE_ITEM, {
-            Item("data-alias2", DataType::BINARY_DATA,  policy[PASS][EXP])
-    }},
-
-    // RSA keys
-    { Group::KEY_PAIR_RSA, {
-            Item("key-rsa-alias-prv1", DataType::KEY_RSA_PRIVATE,  policy[NO_PASS][NO_EXP]),
-            Item("key-rsa-alias-pub1", DataType::KEY_RSA_PUBLIC,   policy[NO_PASS][NO_EXP])
-    }},
-    { Group::KEY_PAIR_RSA, {
-            Item("key-rsa-alias-prv2", DataType::KEY_RSA_PRIVATE,  policy[NO_PASS][EXP]),
-            Item("key-rsa-alias-pub2", DataType::KEY_RSA_PUBLIC,   policy[NO_PASS][EXP]),
-    }},
-    { Group::KEY_PAIR_RSA, {
-            Item("key-rsa-alias-prv3", DataType::KEY_RSA_PRIVATE,  policy[PASS][NO_EXP]),
-            Item("key-rsa-alias-pub3", DataType::KEY_RSA_PUBLIC,   policy[PASS][NO_EXP]),
-    }},
-    { Group::KEY_PAIR_RSA, {
-            Item("key-rsa-alias-prv4", DataType::KEY_RSA_PRIVATE,  policy[PASS][EXP]),
-            Item("key-rsa-alias-pub4", DataType::KEY_RSA_PUBLIC,   policy[PASS][EXP]),
-    }},
-    // different policies
-    { Group::KEY_PAIR_RSA, {
-            Item("key-rsa-alias-prv5", DataType::KEY_RSA_PRIVATE,  policy[PASS][NO_EXP]),
-            Item("key-rsa-alias-pub5", DataType::KEY_RSA_PUBLIC,   policy[NO_PASS][EXP]),
-    }},
-
-    // AES
-    { Group::SINGLE_ITEM, {
-            Item("key-aes-alias1",     DataType::KEY_AES,          policy[NO_PASS][NO_EXP]),
-    }},
-    { Group::SINGLE_ITEM, {
-            Item("key-aes-alias2",     DataType::KEY_AES,          policy[NO_PASS][EXP]),
-    }},
-    { Group::SINGLE_ITEM, {
-            Item("key-aes-alias3",     DataType::KEY_AES,          policy[PASS][NO_EXP]),
-    }},
-    { Group::SINGLE_ITEM, {
-            Item("key-aes-alias4",     DataType::KEY_AES,          policy[PASS][EXP]),
-    }},
-
-    // Certificates
-    { Group::CERT_CHAIN, {
-            Item("cert-root-alias1",   DataType::CERTIFICATE,      policy[NO_PASS][NO_EXP]),
-            Item("cert-im-ca-alias1",  DataType::CERTIFICATE,      policy[NO_PASS][NO_EXP]),
-            Item("cert-leaf-alias1",   DataType::CERTIFICATE,      policy[NO_PASS][NO_EXP]),
-    }},
-    { Group::CERT_CHAIN, {
-            Item("cert-root-alias2",   DataType::CERTIFICATE,      policy[NO_PASS][EXP]),
-            Item("cert-im-ca-alias2",  DataType::CERTIFICATE,      policy[NO_PASS][EXP]),
-            Item("cert-leaf-alias2",   DataType::CERTIFICATE,      policy[NO_PASS][EXP]),
-    }},
-    { Group::CERT_CHAIN, {
-            Item("cert-root-alias3",   DataType::CERTIFICATE,      policy[PASS][NO_EXP]),
-            Item("cert-im-ca-alias3",  DataType::CERTIFICATE,      policy[PASS][NO_EXP]),
-            Item("cert-leaf-alias3",   DataType::CERTIFICATE,      policy[PASS][NO_EXP]),
-    }},
-    { Group::CERT_CHAIN, {
-            Item("cert-root-alias4",   DataType::CERTIFICATE,      policy[PASS][EXP]),
-            Item("cert-im-ca-alias4",  DataType::CERTIFICATE,      policy[PASS][EXP]),
-            Item("cert-leaf-alias4",   DataType::CERTIFICATE,      policy[PASS][EXP]),
-    }},
-
-    // PKCS
-    { Group::SINGLE_ITEM, {
-            Item("pkcs-alias1",        DataType::CHAIN_CERT_0,     policy[NO_PASS][NO_EXP]),
-    }},
-    { Group::SINGLE_ITEM, {
-            Item("pkcs-alias2",        DataType::CHAIN_CERT_0,     policy[NO_PASS][EXP]),
-    }},
-    { Group::SINGLE_ITEM, {
-            Item("pkcs-alias3",        DataType::CHAIN_CERT_0,     policy[PASS][NO_EXP]),
-    }},
-    { Group::SINGLE_ITEM, {
-            Item("pkcs-alias4",        DataType::CHAIN_CERT_0,     policy[PASS][EXP]),
-    }},
+	// Data
+	{
+		Group::SINGLE_ITEM, {
+			Item("data-alias1", DataType::BINARY_DATA,  policy[NO_PASS][EXP])
+		}
+	},
+	{
+		Group::SINGLE_ITEM, {
+			Item("data-alias2", DataType::BINARY_DATA,  policy[PASS][EXP])
+		}
+	},
+
+	// RSA keys
+	{
+		Group::KEY_PAIR_RSA, {
+			Item("key-rsa-alias-prv1", DataType::KEY_RSA_PRIVATE,  policy[NO_PASS][NO_EXP]),
+			Item("key-rsa-alias-pub1", DataType::KEY_RSA_PUBLIC,   policy[NO_PASS][NO_EXP])
+		}
+	},
+	{
+		Group::KEY_PAIR_RSA, {
+			Item("key-rsa-alias-prv2", DataType::KEY_RSA_PRIVATE,  policy[NO_PASS][EXP]),
+			Item("key-rsa-alias-pub2", DataType::KEY_RSA_PUBLIC,   policy[NO_PASS][EXP]),
+		}
+	},
+	{
+		Group::KEY_PAIR_RSA, {
+			Item("key-rsa-alias-prv3", DataType::KEY_RSA_PRIVATE,  policy[PASS][NO_EXP]),
+			Item("key-rsa-alias-pub3", DataType::KEY_RSA_PUBLIC,   policy[PASS][NO_EXP]),
+		}
+	},
+	{
+		Group::KEY_PAIR_RSA, {
+			Item("key-rsa-alias-prv4", DataType::KEY_RSA_PRIVATE,  policy[PASS][EXP]),
+			Item("key-rsa-alias-pub4", DataType::KEY_RSA_PUBLIC,   policy[PASS][EXP]),
+		}
+	},
+	// different policies
+	{
+		Group::KEY_PAIR_RSA, {
+			Item("key-rsa-alias-prv5", DataType::KEY_RSA_PRIVATE,  policy[PASS][NO_EXP]),
+			Item("key-rsa-alias-pub5", DataType::KEY_RSA_PUBLIC,   policy[NO_PASS][EXP]),
+		}
+	},
+
+	// AES
+	{
+		Group::SINGLE_ITEM, {
+			Item("key-aes-alias1",     DataType::KEY_AES,          policy[NO_PASS][NO_EXP]),
+		}
+	},
+	{
+		Group::SINGLE_ITEM, {
+			Item("key-aes-alias2",     DataType::KEY_AES,          policy[NO_PASS][EXP]),
+		}
+	},
+	{
+		Group::SINGLE_ITEM, {
+			Item("key-aes-alias3",     DataType::KEY_AES,          policy[PASS][NO_EXP]),
+		}
+	},
+	{
+		Group::SINGLE_ITEM, {
+			Item("key-aes-alias4",     DataType::KEY_AES,          policy[PASS][EXP]),
+		}
+	},
+
+	// Certificates
+	{
+		Group::CERT_CHAIN, {
+			Item("cert-root-alias1",   DataType::CERTIFICATE,      policy[NO_PASS][NO_EXP]),
+			Item("cert-im-ca-alias1",  DataType::CERTIFICATE,      policy[NO_PASS][NO_EXP]),
+			Item("cert-leaf-alias1",   DataType::CERTIFICATE,      policy[NO_PASS][NO_EXP]),
+		}
+	},
+	{
+		Group::CERT_CHAIN, {
+			Item("cert-root-alias2",   DataType::CERTIFICATE,      policy[NO_PASS][EXP]),
+			Item("cert-im-ca-alias2",  DataType::CERTIFICATE,      policy[NO_PASS][EXP]),
+			Item("cert-leaf-alias2",   DataType::CERTIFICATE,      policy[NO_PASS][EXP]),
+		}
+	},
+	{
+		Group::CERT_CHAIN, {
+			Item("cert-root-alias3",   DataType::CERTIFICATE,      policy[PASS][NO_EXP]),
+			Item("cert-im-ca-alias3",  DataType::CERTIFICATE,      policy[PASS][NO_EXP]),
+			Item("cert-leaf-alias3",   DataType::CERTIFICATE,      policy[PASS][NO_EXP]),
+		}
+	},
+	{
+		Group::CERT_CHAIN, {
+			Item("cert-root-alias4",   DataType::CERTIFICATE,      policy[PASS][EXP]),
+			Item("cert-im-ca-alias4",  DataType::CERTIFICATE,      policy[PASS][EXP]),
+			Item("cert-leaf-alias4",   DataType::CERTIFICATE,      policy[PASS][EXP]),
+		}
+	},
+
+	// PKCS
+	{
+		Group::SINGLE_ITEM, {
+			Item("pkcs-alias1",        DataType::CHAIN_CERT_0,     policy[NO_PASS][NO_EXP]),
+		}
+	},
+	{
+		Group::SINGLE_ITEM, {
+			Item("pkcs-alias2",        DataType::CHAIN_CERT_0,     policy[NO_PASS][EXP]),
+		}
+	},
+	{
+		Group::SINGLE_ITEM, {
+			Item("pkcs-alias3",        DataType::CHAIN_CERT_0,     policy[PASS][NO_EXP]),
+		}
+	},
+	{
+		Group::SINGLE_ITEM, {
+			Item("pkcs-alias4",        DataType::CHAIN_CERT_0,     policy[PASS][EXP]),
+		}
+	},
 };
 
 const size_t CHAIN_SIZE = 3;
 
 // TEST_ROOT_CA, expires 2035
 std::string TEST_ROOT_CA =
-    "-----BEGIN CERTIFICATE-----\n"
-    "MIIDnzCCAoegAwIBAgIJAMH/ADkC5YSTMA0GCSqGSIb3DQEBBQUAMGYxCzAJBgNV\n"
-    "BAYTAkFVMRMwEQYDVQQIDApTb21lLVN0YXRlMQ0wCwYDVQQKDARBQ01FMRAwDgYD\n"
-    "VQQLDAdUZXN0aW5nMSEwHwYDVQQDDBhUZXN0IHJvb3QgY2EgY2VydGlmaWNhdGUw\n"
-    "HhcNMTQxMjMwMTcyMTUyWhcNMjQxMjI3MTcyMTUyWjBmMQswCQYDVQQGEwJBVTET\n"
-    "MBEGA1UECAwKU29tZS1TdGF0ZTENMAsGA1UECgwEQUNNRTEQMA4GA1UECwwHVGVz\n"
-    "dGluZzEhMB8GA1UEAwwYVGVzdCByb290IGNhIGNlcnRpZmljYXRlMIIBIjANBgkq\n"
-    "hkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEA0EJRdUtd2th0vTVF7QxvDKzyFCF3w9vC\n"
-    "9IDE/Yr12w+a9jd0s7/eG96qTHIYffS3B7x2MB+d4n+SR3W0qmYh7xk8qfEgH3da\n"
-    "eDoV59IZ9r543KM+g8jm6KffYGX1bIJVVY5OhBRbO9nY6byYpd5kbCIUB6dCf7/W\n"
-    "rQl1aIdLGFIegAzPGFPXDcU6F192686x54bxt/itMX4agHJ9ZC/rrTBIZghVsjJo\n"
-    "5/AH5WZpasv8sfrGiiohAxtieoYoJkv5MOYP4/2lPlOY+Cgw1Yoz+HHv31AllgFs\n"
-    "BquBb/kJVmCCNsAOcnvQzTZUsW/TXz9G2nwRdqI1nSy2JvVjZGsqGQIDAQABo1Aw\n"
-    "TjAdBgNVHQ4EFgQUt6pkzFt1PZlfYRL/HGnufF4frdwwHwYDVR0jBBgwFoAUt6pk\n"
-    "zFt1PZlfYRL/HGnufF4frdwwDAYDVR0TBAUwAwEB/zANBgkqhkiG9w0BAQUFAAOC\n"
-    "AQEAld7Qwq0cdzDQ51w1RVLwTR8Oy25PB3rzwEHcSGJmdqlMi3xOdaz80S1R1BBX\n"
-    "ldvGBG5Tn0vT7xSuhmSgI2/HnBpy9ocHVOmhtNB4473NieEpfTYrnGXrFxu46Wus\n"
-    "9m/ZnugcQ2G6C54A/NFtvgLmaC8uH8M7gKdS6uYUwJFQEofkjmd4UpOYSqmcRXhS\n"
-    "Jzd5FYFWkJhKJYp3nlENSOD8CUFFVGekm05nFN2gRVc/qaqQkEX77+XYvhodLRsV\n"
-    "qMn7nf7taidDKLO2T4bhujztnTYOhhaXKgPy7AtZ28N2wvX96VyAPB/vrchGmyBK\n"
-    "kOg11TpPdNDkhb1J4ZCh2gupDg==\n"
-    "-----END CERTIFICATE-----\n";
+	"-----BEGIN CERTIFICATE-----\n"
+	"MIIDnzCCAoegAwIBAgIJAMH/ADkC5YSTMA0GCSqGSIb3DQEBBQUAMGYxCzAJBgNV\n"
+	"BAYTAkFVMRMwEQYDVQQIDApTb21lLVN0YXRlMQ0wCwYDVQQKDARBQ01FMRAwDgYD\n"
+	"VQQLDAdUZXN0aW5nMSEwHwYDVQQDDBhUZXN0IHJvb3QgY2EgY2VydGlmaWNhdGUw\n"
+	"HhcNMTQxMjMwMTcyMTUyWhcNMjQxMjI3MTcyMTUyWjBmMQswCQYDVQQGEwJBVTET\n"
+	"MBEGA1UECAwKU29tZS1TdGF0ZTENMAsGA1UECgwEQUNNRTEQMA4GA1UECwwHVGVz\n"
+	"dGluZzEhMB8GA1UEAwwYVGVzdCByb290IGNhIGNlcnRpZmljYXRlMIIBIjANBgkq\n"
+	"hkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEA0EJRdUtd2th0vTVF7QxvDKzyFCF3w9vC\n"
+	"9IDE/Yr12w+a9jd0s7/eG96qTHIYffS3B7x2MB+d4n+SR3W0qmYh7xk8qfEgH3da\n"
+	"eDoV59IZ9r543KM+g8jm6KffYGX1bIJVVY5OhBRbO9nY6byYpd5kbCIUB6dCf7/W\n"
+	"rQl1aIdLGFIegAzPGFPXDcU6F192686x54bxt/itMX4agHJ9ZC/rrTBIZghVsjJo\n"
+	"5/AH5WZpasv8sfrGiiohAxtieoYoJkv5MOYP4/2lPlOY+Cgw1Yoz+HHv31AllgFs\n"
+	"BquBb/kJVmCCNsAOcnvQzTZUsW/TXz9G2nwRdqI1nSy2JvVjZGsqGQIDAQABo1Aw\n"
+	"TjAdBgNVHQ4EFgQUt6pkzFt1PZlfYRL/HGnufF4frdwwHwYDVR0jBBgwFoAUt6pk\n"
+	"zFt1PZlfYRL/HGnufF4frdwwDAYDVR0TBAUwAwEB/zANBgkqhkiG9w0BAQUFAAOC\n"
+	"AQEAld7Qwq0cdzDQ51w1RVLwTR8Oy25PB3rzwEHcSGJmdqlMi3xOdaz80S1R1BBX\n"
+	"ldvGBG5Tn0vT7xSuhmSgI2/HnBpy9ocHVOmhtNB4473NieEpfTYrnGXrFxu46Wus\n"
+	"9m/ZnugcQ2G6C54A/NFtvgLmaC8uH8M7gKdS6uYUwJFQEofkjmd4UpOYSqmcRXhS\n"
+	"Jzd5FYFWkJhKJYp3nlENSOD8CUFFVGekm05nFN2gRVc/qaqQkEX77+XYvhodLRsV\n"
+	"qMn7nf7taidDKLO2T4bhujztnTYOhhaXKgPy7AtZ28N2wvX96VyAPB/vrchGmyBK\n"
+	"kOg11TpPdNDkhb1J4ZCh2gupDg==\n"
+	"-----END CERTIFICATE-----\n";
 
 // TEST_IM_CA, signed by TEST_ROOT_CA, expires 2035
 std::string TEST_IM_CA =
-    "-----BEGIN CERTIFICATE-----\n"
-    "MIIDljCCAn6gAwIBAgICEAAwDQYJKoZIhvcNAQEFBQAwZjELMAkGA1UEBhMCQVUx\n"
-    "EzARBgNVBAgMClNvbWUtU3RhdGUxDTALBgNVBAoMBEFDTUUxEDAOBgNVBAsMB1Rl\n"
-    "c3RpbmcxITAfBgNVBAMMGFRlc3Qgcm9vdCBjYSBjZXJ0aWZpY2F0ZTAeFw0xNTAx\n"
-    "MTYxNjQ1MzRaFw0zNTAxMTExNjQ1MzRaMGQxCzAJBgNVBAYTAkFVMRMwEQYDVQQI\n"
-    "DApTb21lLVN0YXRlMQ0wCwYDVQQKDARBQ01FMRAwDgYDVQQLDAdUZXN0aW5nMR8w\n"
-    "HQYDVQQDDBZUZXN0IElNIENBIGNlcnRpZmljYXRlMIIBIjANBgkqhkiG9w0BAQEF\n"
-    "AAOCAQ8AMIIBCgKCAQEAzmBF78qClgoKfnLAncMXZwZ14TW+5kags1+QCYeg3c7j\n"
-    "L9+RvDxIaX2tKf1sukJcwQfYqUlQkwt+58LMOb2ORtkpj8Or6WCWCZ0BzneT8ug7\n"
-    "nxJT4m9+bohMF0JoKjjB2H4KNMHamLIwUxRKt6nyfk81kVhJOi2vzzxd+UCPi6Pc\n"
-    "UAbJNH48eNgOIg55nyFovVzYj8GIo/9GvHJj83PPa/KlJZ+Z1qZASZZ/VYorplVT\n"
-    "thsHXKfejhFy5YJ9t7n/vyAQsyBsagZsvX19xnH41fbYXHKf8UbXG23rNaZlchs6\n"
-    "XJVLQdzOpj3WTj/lCocVHqLaZISLhNQ3aI7kUBUdiwIDAQABo1AwTjAdBgNVHQ4E\n"
-    "FgQUoCYNaCBP4jl/3SYQuK8Ka+6i3QEwHwYDVR0jBBgwFoAUt6pkzFt1PZlfYRL/\n"
-    "HGnufF4frdwwDAYDVR0TBAUwAwEB/zANBgkqhkiG9w0BAQUFAAOCAQEAjRzWiD97\n"
-    "Htv4Kxpm3P+C+xP9AEteCJfO+7p8MWgtWEJOknJyt55zeKS2JwZIq57KcbqD8U7v\n"
-    "vAUx1ymtUhlFPFd7J1mJ3pou+3aFYmGShYhGHpbrmUwjp7HVP588jrW1NoZVHdMc\n"
-    "4OgJWFrViXeu9+maIcekjMB/+9Y0dUgQuK5ZuT5H/Jwet7Th/o9uufTUZjBzRvrB\n"
-    "pbXgQpqgME2av4Q/6LuldPCTHLtWXgFUU2R+yCGmuGilvhFJnKoQryAbYnIQNWE8\n"
-    "SLoHQ9s1i7Zyb7HU6UAaqMOz15LBkyAqtNyJcO2p7Q/p5YK0xfD4xisI5qXucqVm\n"
-    "F2obL5qJSTN/RQ==\n"
-    "-----END CERTIFICATE-----\n";
+	"-----BEGIN CERTIFICATE-----\n"
+	"MIIDljCCAn6gAwIBAgICEAAwDQYJKoZIhvcNAQEFBQAwZjELMAkGA1UEBhMCQVUx\n"
+	"EzARBgNVBAgMClNvbWUtU3RhdGUxDTALBgNVBAoMBEFDTUUxEDAOBgNVBAsMB1Rl\n"
+	"c3RpbmcxITAfBgNVBAMMGFRlc3Qgcm9vdCBjYSBjZXJ0aWZpY2F0ZTAeFw0xNTAx\n"
+	"MTYxNjQ1MzRaFw0zNTAxMTExNjQ1MzRaMGQxCzAJBgNVBAYTAkFVMRMwEQYDVQQI\n"
+	"DApTb21lLVN0YXRlMQ0wCwYDVQQKDARBQ01FMRAwDgYDVQQLDAdUZXN0aW5nMR8w\n"
+	"HQYDVQQDDBZUZXN0IElNIENBIGNlcnRpZmljYXRlMIIBIjANBgkqhkiG9w0BAQEF\n"
+	"AAOCAQ8AMIIBCgKCAQEAzmBF78qClgoKfnLAncMXZwZ14TW+5kags1+QCYeg3c7j\n"
+	"L9+RvDxIaX2tKf1sukJcwQfYqUlQkwt+58LMOb2ORtkpj8Or6WCWCZ0BzneT8ug7\n"
+	"nxJT4m9+bohMF0JoKjjB2H4KNMHamLIwUxRKt6nyfk81kVhJOi2vzzxd+UCPi6Pc\n"
+	"UAbJNH48eNgOIg55nyFovVzYj8GIo/9GvHJj83PPa/KlJZ+Z1qZASZZ/VYorplVT\n"
+	"thsHXKfejhFy5YJ9t7n/vyAQsyBsagZsvX19xnH41fbYXHKf8UbXG23rNaZlchs6\n"
+	"XJVLQdzOpj3WTj/lCocVHqLaZISLhNQ3aI7kUBUdiwIDAQABo1AwTjAdBgNVHQ4E\n"
+	"FgQUoCYNaCBP4jl/3SYQuK8Ka+6i3QEwHwYDVR0jBBgwFoAUt6pkzFt1PZlfYRL/\n"
+	"HGnufF4frdwwDAYDVR0TBAUwAwEB/zANBgkqhkiG9w0BAQUFAAOCAQEAjRzWiD97\n"
+	"Htv4Kxpm3P+C+xP9AEteCJfO+7p8MWgtWEJOknJyt55zeKS2JwZIq57KcbqD8U7v\n"
+	"vAUx1ymtUhlFPFd7J1mJ3pou+3aFYmGShYhGHpbrmUwjp7HVP588jrW1NoZVHdMc\n"
+	"4OgJWFrViXeu9+maIcekjMB/+9Y0dUgQuK5ZuT5H/Jwet7Th/o9uufTUZjBzRvrB\n"
+	"pbXgQpqgME2av4Q/6LuldPCTHLtWXgFUU2R+yCGmuGilvhFJnKoQryAbYnIQNWE8\n"
+	"SLoHQ9s1i7Zyb7HU6UAaqMOz15LBkyAqtNyJcO2p7Q/p5YK0xfD4xisI5qXucqVm\n"
+	"F2obL5qJSTN/RQ==\n"
+	"-----END CERTIFICATE-----\n";
 
 // TEST_LEAF, signed by TEST_IM_CA, expires 2035
 std::string TEST_LEAF =
-    "-----BEGIN CERTIFICATE-----\n"
-    "MIIDOzCCAiMCAQEwDQYJKoZIhvcNAQEFBQAwZDELMAkGA1UEBhMCQVUxEzARBgNV\n"
-    "BAgMClNvbWUtU3RhdGUxDTALBgNVBAoMBEFDTUUxEDAOBgNVBAsMB1Rlc3Rpbmcx\n"
-    "HzAdBgNVBAMMFlRlc3QgSU0gQ0EgY2VydGlmaWNhdGUwHhcNMTUwMTE2MTY0ODE0\n"
-    "WhcNMzUwMTExMTY0ODE0WjBjMQswCQYDVQQGEwJBVTETMBEGA1UECAwKU29tZS1T\n"
-    "dGF0ZTENMAsGA1UECgwEQUNNRTEQMA4GA1UECwwHVGVzdGluZzEeMBwGA1UEAwwV\n"
-    "VGVzdCBsZWFmIGNlcnRpZmljYXRlMIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIB\n"
-    "CgKCAQEAzTdDIa2tDmRxFnIgiG+mBz8GoSVODs0ImNQGbqj+pLhBOFRH8fsah4Jl\n"
-    "z5YF9KwhMVLknnHGFLE/Nb7Ac35kEzhMQMpTRxohW83oxw3eZ8zN/FBoKqg4qHRq\n"
-    "QR8kS10YXTgrBR0ex/Vp+OUKEw6h7yL2r4Tpvrn9/qHwsxtLxqWbDIVf1O9b1Lfc\n"
-    "bllYMdmV5E62yN5tcwrDP8gvHjFnVeLzrG8wTpc9FR90/0Jkfp5jAJcArOBLrT0E\n"
-    "4VRqs+4HuwT8jAwFAmNnc7IYX5qSjtSWkmmHe73K/lzB+OiI0JEc/3eWUTWqwTSk\n"
-    "4tNCiQGBKJ39LXPTBBJdzmxVH7CUDQIDAQABMA0GCSqGSIb3DQEBBQUAA4IBAQAp\n"
-    "UdDOGu3hNiG+Vn10aQ6B1ZmOj3t+45gUV3sC+y8hB8EK1g4P5Ke9bVDts0T5eOnj\n"
-    "CSc+6VoND5O4adI0IFFRFljHNVnvjeosHfUZNnowsmA2ptQBtC1g5ZKRvKXlkC5/\n"
-    "i5BGgRqPFA7y9WB9Y05MrJHf3E+Oz/RBsLeeNiNN+rF5X1vYExvGHpo0M0zS0ze9\n"
-    "HtC0aOy8ocsTrQkf3ceHTAXx2i8ftoSSD4klojtWFpWMrNQa52F7wB9nU6FfKRuF\n"
-    "Zj/T1JkYXKkEwZU6nAR2jdZp3EP9xj3o15V/tyFcXHx6l8NTxn4cJb+Xe4VquQJz\n"
-    "6ON7PVe0ABN/AlwVQiFE\n"
-    "-----END CERTIFICATE-----\n";
+	"-----BEGIN CERTIFICATE-----\n"
+	"MIIDOzCCAiMCAQEwDQYJKoZIhvcNAQEFBQAwZDELMAkGA1UEBhMCQVUxEzARBgNV\n"
+	"BAgMClNvbWUtU3RhdGUxDTALBgNVBAoMBEFDTUUxEDAOBgNVBAsMB1Rlc3Rpbmcx\n"
+	"HzAdBgNVBAMMFlRlc3QgSU0gQ0EgY2VydGlmaWNhdGUwHhcNMTUwMTE2MTY0ODE0\n"
+	"WhcNMzUwMTExMTY0ODE0WjBjMQswCQYDVQQGEwJBVTETMBEGA1UECAwKU29tZS1T\n"
+	"dGF0ZTENMAsGA1UECgwEQUNNRTEQMA4GA1UECwwHVGVzdGluZzEeMBwGA1UEAwwV\n"
+	"VGVzdCBsZWFmIGNlcnRpZmljYXRlMIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIB\n"
+	"CgKCAQEAzTdDIa2tDmRxFnIgiG+mBz8GoSVODs0ImNQGbqj+pLhBOFRH8fsah4Jl\n"
+	"z5YF9KwhMVLknnHGFLE/Nb7Ac35kEzhMQMpTRxohW83oxw3eZ8zN/FBoKqg4qHRq\n"
+	"QR8kS10YXTgrBR0ex/Vp+OUKEw6h7yL2r4Tpvrn9/qHwsxtLxqWbDIVf1O9b1Lfc\n"
+	"bllYMdmV5E62yN5tcwrDP8gvHjFnVeLzrG8wTpc9FR90/0Jkfp5jAJcArOBLrT0E\n"
+	"4VRqs+4HuwT8jAwFAmNnc7IYX5qSjtSWkmmHe73K/lzB+OiI0JEc/3eWUTWqwTSk\n"
+	"4tNCiQGBKJ39LXPTBBJdzmxVH7CUDQIDAQABMA0GCSqGSIb3DQEBBQUAA4IBAQAp\n"
+	"UdDOGu3hNiG+Vn10aQ6B1ZmOj3t+45gUV3sC+y8hB8EK1g4P5Ke9bVDts0T5eOnj\n"
+	"CSc+6VoND5O4adI0IFFRFljHNVnvjeosHfUZNnowsmA2ptQBtC1g5ZKRvKXlkC5/\n"
+	"i5BGgRqPFA7y9WB9Y05MrJHf3E+Oz/RBsLeeNiNN+rF5X1vYExvGHpo0M0zS0ze9\n"
+	"HtC0aOy8ocsTrQkf3ceHTAXx2i8ftoSSD4klojtWFpWMrNQa52F7wB9nU6FfKRuF\n"
+	"Zj/T1JkYXKkEwZU6nAR2jdZp3EP9xj3o15V/tyFcXHx6l8NTxn4cJb+Xe4VquQJz\n"
+	"6ON7PVe0ABN/AlwVQiFE\n"
+	"-----END CERTIFICATE-----\n";
 
 
 
 struct FdCloser {
-    void operator()(int* fd) {
-        if(fd)
-            close(*fd);
-    }
+	void operator()(int *fd)
+	{
+		if (fd)
+			close(*fd);
+	}
 };
 
 typedef std::unique_ptr<int, FdCloser> FdPtr;
 
-uid_t getUid(const char *name) {
-    struct passwd pwd;
-    struct passwd *result = nullptr;
-    int bufsize = sysconf(_SC_GETPW_R_SIZE_MAX);
-    if (bufsize <= 0)
-        bufsize = 16384; /* should be more than enough */
+uid_t getUid(const char *name)
+{
+	struct passwd pwd;
+	struct passwd *result = nullptr;
+	int bufsize = sysconf(_SC_GETPW_R_SIZE_MAX);
+
+	if (bufsize <= 0)
+		bufsize = 16384; /* should be more than enough */
 
-    memset(&pwd, 0x00, sizeof(pwd));
+	memset(&pwd, 0x00, sizeof(pwd));
 
-    std::vector<char> buf(bufsize, 0);
+	std::vector<char> buf(bufsize, 0);
 
-    int ret = getpwnam_r(name, &pwd, buf.data(), bufsize, &result);
-    BOOST_REQUIRE_MESSAGE(ret == 0 && result, "getpwnam_r failed");
+	int ret = getpwnam_r(name, &pwd, buf.data(), bufsize, &result);
+	BOOST_REQUIRE_MESSAGE(ret == 0 && result, "getpwnam_r failed");
 
-    return pwd.pw_uid;
+	return pwd.pw_uid;
 }
 
-gid_t getGid(const char *name) {
-    struct group grp;
-    struct group *result = nullptr;
-    size_t bufsize = sysconf(_SC_GETGR_R_SIZE_MAX);
-    if (bufsize <= 0)
-        bufsize = 16384; /* should be more than enough */
+gid_t getGid(const char *name)
+{
+	struct group grp;
+	struct group *result = nullptr;
+	size_t bufsize = sysconf(_SC_GETGR_R_SIZE_MAX);
+
+	if (bufsize <= 0)
+		bufsize = 16384; /* should be more than enough */
 
-    memset(&grp, 0x00, sizeof(grp));
+	memset(&grp, 0x00, sizeof(grp));
 
-    std::vector<char> buf(bufsize, 0);
+	std::vector<char> buf(bufsize, 0);
 
-    int ret = getgrnam_r(name, &grp, buf.data(), bufsize, &result);
-    BOOST_REQUIRE_MESSAGE(ret == 0 && result, "getgrnam_r failed");
+	int ret = getgrnam_r(name, &grp, buf.data(), bufsize, &result);
+	BOOST_REQUIRE_MESSAGE(ret == 0 && result, "getgrnam_r failed");
 
-    return grp.gr_gid;
+	return grp.gr_gid;
 }
 
-void restoreFile(const string& filename) {
-    static uid_t CKM_UID = getUid(USER_NAME);
-    static gid_t CKM_GID = getGid(GROUP_NAME);
-    string sourcePath = string(DB_TEST_DIR) + "/" + filename;
-    string targetPath = string(RW_DATA_DIR) + "/" + filename;
+void restoreFile(const string &filename)
+{
+	static uid_t CKM_UID = getUid(USER_NAME);
+	static gid_t CKM_GID = getGid(GROUP_NAME);
+	string sourcePath = string(DB_TEST_DIR) + "/" + filename;
+	string targetPath = string(RW_DATA_DIR) + "/" + filename;
 
-    int err, ret;
+	int err, ret;
 
-    int sourceFd = TEMP_FAILURE_RETRY(open(sourcePath.c_str(), O_RDONLY));
-    err = errno;
-    BOOST_REQUIRE_MESSAGE(sourceFd > 0, "Opening " << sourcePath << " failed: " << GetErrnoString(err));
+	int sourceFd = TEMP_FAILURE_RETRY(open(sourcePath.c_str(), O_RDONLY));
+	err = errno;
+	BOOST_REQUIRE_MESSAGE(sourceFd > 0,
+						  "Opening " << sourcePath << " failed: " << GetErrnoString(err));
 
-    FdPtr sourceFdPtr(&sourceFd);
+	FdPtr sourceFdPtr(&sourceFd);
 
-    int targetFd = TEMP_FAILURE_RETRY(creat(targetPath.c_str(), 0644));
-    err = errno;
-    BOOST_REQUIRE_MESSAGE(targetFd > 0, "Creating " << targetPath << " failed: " << GetErrnoString(err));
+	int targetFd = TEMP_FAILURE_RETRY(creat(targetPath.c_str(), 0644));
+	err = errno;
+	BOOST_REQUIRE_MESSAGE(targetFd > 0,
+						  "Creating " << targetPath << " failed: " << GetErrnoString(err));
 
-    ret = fchown(targetFd, CKM_UID, CKM_GID);
-    err = errno;
-    BOOST_REQUIRE_MESSAGE(ret != -1, "fchown() failed: " << GetErrnoString(err));
+	ret = fchown(targetFd, CKM_UID, CKM_GID);
+	err = errno;
+	BOOST_REQUIRE_MESSAGE(ret != -1, "fchown() failed: " << GetErrnoString(err));
 
-    FdPtr targetFdPtr(&targetFd);
+	FdPtr targetFdPtr(&targetFd);
 
-    struct stat sourceStat;
-    ret = fstat(sourceFd, &sourceStat);
-    err = errno;
-    BOOST_REQUIRE_MESSAGE(ret != -1, "fstat() failed: " << GetErrnoString(err));
+	struct stat sourceStat;
+	ret = fstat(sourceFd, &sourceStat);
+	err = errno;
+	BOOST_REQUIRE_MESSAGE(ret != -1, "fstat() failed: " << GetErrnoString(err));
 
-    ret = sendfile(targetFd, sourceFd, 0, sourceStat.st_size);
-    err = errno;
-    BOOST_REQUIRE_MESSAGE(ret != -1, "sendfile() failed: " << GetErrnoString(err));
+	ret = sendfile(targetFd, sourceFd, 0, sourceStat.st_size);
+	err = errno;
+	BOOST_REQUIRE_MESSAGE(ret != -1, "sendfile() failed: " << GetErrnoString(err));
 
-    ret = fsync(targetFd);
-    err = errno;
-    BOOST_REQUIRE_MESSAGE(ret != -1, "fsync() failed: " << GetErrnoString(err));
+	ret = fsync(targetFd);
+	err = errno;
+	BOOST_REQUIRE_MESSAGE(ret != -1, "fsync() failed: " << GetErrnoString(err));
 }
 
 void generateRandom(size_t random_bytes, unsigned char *output)
 {
-    if(random_bytes<=0 || !output)
-        throw runtime_error("Invalid param");
-
-    std::ifstream is("/dev/urandom", std::ifstream::binary);
-    if(!is)
-        throw runtime_error("Failed to read /dev/urandom");
-    is.read(reinterpret_cast<char*>(output), random_bytes);
-    if(static_cast<std::streamsize>(random_bytes) != is.gcount())
-        throw runtime_error("Not enough bytes read from /dev/urandom");
+	if (random_bytes <= 0 || !output)
+		throw runtime_error("Invalid param");
+
+	std::ifstream is("/dev/urandom", std::ifstream::binary);
+
+	if (!is)
+		throw runtime_error("Failed to read /dev/urandom");
+
+	is.read(reinterpret_cast<char *>(output), random_bytes);
+
+	if (static_cast<std::streamsize>(random_bytes) != is.gcount())
+		throw runtime_error("Not enough bytes read from /dev/urandom");
 }
 
 RawBuffer createRandomBuffer(size_t random_bytes)
 {
-    RawBuffer buffer(random_bytes);
-    generateRandom(buffer.size(), buffer.data());
-    return buffer;
+	RawBuffer buffer(random_bytes);
+	generateRandom(buffer.size(), buffer.data());
+	return buffer;
 }
 } // namespace anonymous
 
 
-SchemeTest::SchemeTest() : m_userChanged(false), m_directAccessEnabled(false) {
-    m_control = Control::create();
-    m_mgr = Manager::create();
-    initOpenSsl();
-
-    SmackAccess sa;
-    sa.add("System", LABEL, "rwx");
-    sa.add(LABEL, "System", "rwx");
-    sa.add(LABEL, "System::Run", "x");
-    sa.apply();
+SchemeTest::SchemeTest() : m_userChanged(false), m_directAccessEnabled(false)
+{
+	m_control = Control::create();
+	m_mgr = Manager::create();
+	initOpenSsl();
+
+	SmackAccess sa;
+	sa.add("System", LABEL, "rwx");
+	sa.add(LABEL, "System", "rwx");
+	sa.add(LABEL, "System::Run", "x");
+	sa.apply();
 }
 
-SchemeTest::~SchemeTest() {
-    try {
-        SwitchToRoot();
-    } catch (...) {}
+SchemeTest::~SchemeTest()
+{
+	try {
+		SwitchToRoot();
+	} catch (...) {}
 }
 
-void SchemeTest::RemoveUserData() {
-    if(CKM_API_SUCCESS != m_control->lockUserKey(UID))
-        throw runtime_error("lockUserKey failed");
+void SchemeTest::RemoveUserData()
+{
+	if (CKM_API_SUCCESS != m_control->lockUserKey(UID))
+		throw runtime_error("lockUserKey failed");
 
-    if(CKM_API_SUCCESS != m_control->removeUserData(UID))
-        throw runtime_error("removeUserData failed");
+	if (CKM_API_SUCCESS != m_control->removeUserData(UID))
+		throw runtime_error("removeUserData failed");
 }
 
-void SchemeTest::SwitchToUser() {
-    if (m_userChanged)
-        return;
+void SchemeTest::SwitchToUser()
+{
+	if (m_userChanged)
+		return;
 
-    if(CKM_API_SUCCESS != m_control->unlockUserKey(UID, DBPASS))
-        throw runtime_error("unlockUserKey failed");
+	if (CKM_API_SUCCESS != m_control->unlockUserKey(UID, DBPASS))
+		throw runtime_error("unlockUserKey failed");
 
-    // get calling label
-    char* label = NULL;
-    if (smack_new_label_from_self(&label) <= 0)
-        throw runtime_error("smack_new_label_from_self failed");
+	// get calling label
+	char *label = NULL;
 
-    m_origLabel = string(label);
-    free(label);
+	if (smack_new_label_from_self(&label) <= 0)
+		throw runtime_error("smack_new_label_from_self failed");
 
-    if(0 > smack_set_label_for_self(LABEL))
-        throw runtime_error("smack_set_label_for_self failed");
+	m_origLabel = string(label);
+	free(label);
 
-    if(0 > setegid(GID))
-        throw runtime_error("setegid failed");
+	if (0 > smack_set_label_for_self(LABEL))
+		throw runtime_error("smack_set_label_for_self failed");
 
-    if(0 > seteuid(UID))
-        throw runtime_error("seteuid failed");
+	if (0 > setegid(GID))
+		throw runtime_error("setegid failed");
 
-    m_userChanged = true;
-}
+	if (0 > seteuid(UID))
+		throw runtime_error("seteuid failed");
 
-void SchemeTest::SwitchToRoot() {
-    if (!m_userChanged)
-        return;
+	m_userChanged = true;
+}
 
-    if(0 > seteuid(0))
-        throw runtime_error("seteuid failed");
-    if(0 > setegid(0))
-        throw runtime_error("setegid failed");
+void SchemeTest::SwitchToRoot()
+{
+	if (!m_userChanged)
+		return;
 
-    if(0 > smack_set_label_for_self(m_origLabel.c_str()))
-        throw runtime_error("smack_set_label_for_self failed");
+	if (0 > seteuid(0))
+		throw runtime_error("seteuid failed");
 
-    if(m_control->lockUserKey(UID) != CKM_API_SUCCESS)
-        throw runtime_error("lockUserKey failed");
-}
+	if (0 > setegid(0))
+		throw runtime_error("setegid failed");
 
-void SchemeTest::FillDb() {
-    // pkcs
-    ifstream is(DB_TEST_DIR "/encryption-scheme.p12");
-    if(!is)
-        throw runtime_error("Failed to read pkcs");
-    istreambuf_iterator<char> begin(is), end;
-    RawBuffer pkcsBuffer(begin, end);
-    auto pkcs = PKCS12::create(pkcsBuffer, Password());
-    if(pkcs->empty())
-        throw runtime_error("Empty pkcs");
-
-    SwitchToUser();
-
-    // certificates
-    RawBuffer rootCaBuffer(TEST_ROOT_CA.begin(), TEST_ROOT_CA.end());
-    CertificateShPtr rootCa = CKM::Certificate::create(rootCaBuffer, CKM::DataFormat::FORM_PEM);
-    RawBuffer imCaBuffer(TEST_IM_CA.begin(), TEST_IM_CA.end());
-    CertificateShPtr imCa = CKM::Certificate::create(imCaBuffer, CKM::DataFormat::FORM_PEM);
-    RawBuffer leafBuffer(TEST_LEAF.begin(), TEST_LEAF.end());
-    CertificateShPtr leaf = CKM::Certificate::create(leafBuffer, CKM::DataFormat::FORM_PEM);
-
-    for(const auto& g:GROUPS) {
-        switch (g.type) {
-        case Group::KEY_PAIR_RSA:
-            if(g.items.size() != 2)
-                throw runtime_error("Wrong number of keys");
-            if( g.items[0].type != DataType::KEY_RSA_PRIVATE ||
-                g.items[1].type != DataType::KEY_RSA_PUBLIC)
-                throw runtime_error("Invalid item type");
-
-            if(CKM_API_SUCCESS != m_mgr->createKeyPairRSA(1024,
-                                                          g.items[0].alias,
-                                                          g.items[1].alias,
-                                                          g.items[0].policy,
-                                                          g.items[1].policy))
-                throw runtime_error("createKeyPair failed");
-            break;
-
-        case Group::CERT_CHAIN:
-            if(g.items.size() != CHAIN_SIZE)
-                throw runtime_error("Wrong number of certificates");
-            if( g.items[0].type != DataType::CERTIFICATE ||
-                g.items[1].type != DataType::CERTIFICATE ||
-                g.items[2].type != DataType::CERTIFICATE)
-                throw runtime_error("Invalid item type");
-
-            if(CKM_API_SUCCESS != m_mgr->saveCertificate(g.items[0].alias, rootCa, g.items[0].policy))
-                throw runtime_error("saveCertificate failed");
-            if(CKM_API_SUCCESS != m_mgr->saveCertificate(g.items[1].alias, imCa, g.items[1].policy))
-                throw runtime_error("saveCertificate failed");
-            if(CKM_API_SUCCESS != m_mgr->saveCertificate(g.items[2].alias, leaf, g.items[2].policy))
-                throw runtime_error("saveCertificate failed");
-            break;
-
-        default:
-            for(const auto& i:g.items) {
-                switch (i.type) {
-                case DataType::BINARY_DATA:
-                    if(CKM_API_SUCCESS != m_mgr->saveData(i.alias, TEST_DATA, i.policy))
-                        throw runtime_error("saveData failed");
-                    break;
-
-                case DataType::KEY_AES:
-                    if(CKM_API_SUCCESS != m_mgr->createKeyAES(256, i.alias, i.policy))
-                        throw runtime_error("createKeyAES failed");
-                    break;
-
-                case DataType::CHAIN_CERT_0:    // PKCS
-                    if(CKM_API_SUCCESS != m_mgr->savePKCS12(i.alias, pkcs, i.policy, i.policy))
-                        throw runtime_error("savePkcs12 failed");
-                    break;
-
-                default:
-                    throw runtime_error("unsupported data type");
-                }
-            }
-            break;
-        }
-    }
-}
+	if (0 > smack_set_label_for_self(m_origLabel.c_str()))
+		throw runtime_error("smack_set_label_for_self failed");
 
-void SchemeTest::ReadAll(bool useWrongPass) {
-    SwitchToUser();
-
-    for(const auto& g:GROUPS) {
-        for(const auto& i:g.items) {
-            int ret;
-            Password pass = i.policy.password;
-            if(useWrongPass) {
-                if(pass.empty())
-                    pass = TEST_PASS;
-                else
-                    pass = Password();
-            }
-
-            switch (i.type) {
-            case DataType::BINARY_DATA:
-            {
-                RawBuffer receivedData;
-                ret = m_mgr->getData(i.alias, pass, receivedData);
-                BOOST_REQUIRE_MESSAGE(useWrongPass || receivedData == TEST_DATA,
-                                      "Received data is different for " << i.alias);
-                break;
-            }
-
-            case DataType::KEY_AES:
-            case DataType::KEY_RSA_PRIVATE:
-            case DataType::KEY_RSA_PUBLIC:
-            {
-                KeyShPtr receivedKey;
-                ret = m_mgr->getKey(i.alias, pass, receivedKey);
-                break;
-            }
-
-            case DataType::CERTIFICATE:
-            {
-                CertificateShPtr receivedCert;
-                ret = m_mgr->getCertificate(i.alias, pass, receivedCert);
-                break;
-            }
-
-            case DataType::CHAIN_CERT_0: // pkcs
-            {
-                PKCS12ShPtr pkcs;
-                ret = m_mgr->getPKCS12(i.alias, pass, pass, pkcs);
-                break;
-            }
-
-            default:
-                BOOST_FAIL("Unsupported data type " << i.type);
-            }
-
-            if(i.policy.extractable) {
-                if(useWrongPass)
-                    BOOST_REQUIRE_MESSAGE(ret == CKM_API_ERROR_AUTHENTICATION_FAILED,
-                                          "Reading item " << i.alias << " should fail with " <<
-                                          CKM_API_ERROR_AUTHENTICATION_FAILED << " got: " << ret);
-                else
-                    BOOST_REQUIRE_MESSAGE(ret == CKM_API_SUCCESS, "Reading item " << i.alias <<
-                                          " failed with " << ret);
-            }
-            else
-                BOOST_REQUIRE_MESSAGE(ret == CKM_API_ERROR_NOT_EXPORTABLE, "Item " << i.alias <<
-                                      " should not be exportable");
-        }
-    }
+	if (m_control->lockUserKey(UID) != CKM_API_SUCCESS)
+		throw runtime_error("lockUserKey failed");
 }
 
-void SchemeTest::SignVerify() {
-    SwitchToUser();
-
-    for(const auto& g:GROUPS) {
-        if(g.type == Group::KEY_PAIR_RSA) {
-            BOOST_REQUIRE_MESSAGE(g.items.size() == 2, "Wrong number of keys");
-            BOOST_REQUIRE_MESSAGE(g.items[0].type == DataType::KEY_RSA_PRIVATE &&
-                                  g.items[1].type == DataType::KEY_RSA_PUBLIC, "Wrong key");
-
-            SignVerifyItem(g.items[0], g.items[1]);
-        } else {
-            for(const auto& i:g.items) {
-                switch (i.type) {
-                case DataType::CHAIN_CERT_0:
-                    SignVerifyItem(i, i);
-                    break;
-
-                default:
-                    break;
-                }
-            }
-        }
-    }
+void SchemeTest::FillDb()
+{
+	// pkcs
+	ifstream is(DB_TEST_DIR "/encryption-scheme.p12");
+
+	if (!is)
+		throw runtime_error("Failed to read pkcs");
+
+	istreambuf_iterator<char> begin(is), end;
+	RawBuffer pkcsBuffer(begin, end);
+	auto pkcs = PKCS12::create(pkcsBuffer, Password());
+
+	if (pkcs->empty())
+		throw runtime_error("Empty pkcs");
+
+	SwitchToUser();
+
+	// certificates
+	RawBuffer rootCaBuffer(TEST_ROOT_CA.begin(), TEST_ROOT_CA.end());
+	CertificateShPtr rootCa = CKM::Certificate::create(rootCaBuffer,
+							  CKM::DataFormat::FORM_PEM);
+	RawBuffer imCaBuffer(TEST_IM_CA.begin(), TEST_IM_CA.end());
+	CertificateShPtr imCa = CKM::Certificate::create(imCaBuffer,
+							CKM::DataFormat::FORM_PEM);
+	RawBuffer leafBuffer(TEST_LEAF.begin(), TEST_LEAF.end());
+	CertificateShPtr leaf = CKM::Certificate::create(leafBuffer,
+							CKM::DataFormat::FORM_PEM);
+
+	for (const auto &g : GROUPS) {
+		switch (g.type) {
+		case Group::KEY_PAIR_RSA:
+			if (g.items.size() != 2)
+				throw runtime_error("Wrong number of keys");
+
+			if (g.items[0].type != DataType::KEY_RSA_PRIVATE ||
+					g.items[1].type != DataType::KEY_RSA_PUBLIC)
+				throw runtime_error("Invalid item type");
+
+			if (CKM_API_SUCCESS != m_mgr->createKeyPairRSA(1024,
+					g.items[0].alias,
+					g.items[1].alias,
+					g.items[0].policy,
+					g.items[1].policy))
+				throw runtime_error("createKeyPair failed");
+
+			break;
+
+		case Group::CERT_CHAIN:
+			if (g.items.size() != CHAIN_SIZE)
+				throw runtime_error("Wrong number of certificates");
+
+			if (g.items[0].type != DataType::CERTIFICATE ||
+					g.items[1].type != DataType::CERTIFICATE ||
+					g.items[2].type != DataType::CERTIFICATE)
+				throw runtime_error("Invalid item type");
+
+			if (CKM_API_SUCCESS != m_mgr->saveCertificate(g.items[0].alias, rootCa,
+					g.items[0].policy))
+				throw runtime_error("saveCertificate failed");
+
+			if (CKM_API_SUCCESS != m_mgr->saveCertificate(g.items[1].alias, imCa,
+					g.items[1].policy))
+				throw runtime_error("saveCertificate failed");
+
+			if (CKM_API_SUCCESS != m_mgr->saveCertificate(g.items[2].alias, leaf,
+					g.items[2].policy))
+				throw runtime_error("saveCertificate failed");
+
+			break;
+
+		default:
+			for (const auto &i : g.items) {
+				switch (i.type) {
+				case DataType::BINARY_DATA:
+					if (CKM_API_SUCCESS != m_mgr->saveData(i.alias, TEST_DATA, i.policy))
+						throw runtime_error("saveData failed");
+
+					break;
+
+				case DataType::KEY_AES:
+					if (CKM_API_SUCCESS != m_mgr->createKeyAES(256, i.alias, i.policy))
+						throw runtime_error("createKeyAES failed");
+
+					break;
+
+				case DataType::CHAIN_CERT_0:    // PKCS
+					if (CKM_API_SUCCESS != m_mgr->savePKCS12(i.alias, pkcs, i.policy, i.policy))
+						throw runtime_error("savePkcs12 failed");
+
+					break;
+
+				default:
+					throw runtime_error("unsupported data type");
+				}
+			}
+
+			break;
+		}
+	}
 }
 
-void SchemeTest::EncryptDecrypt() {
-    SwitchToUser();
-
-    for(const auto& g:GROUPS) {
-        if(g.type == Group::KEY_PAIR_RSA) {
-            BOOST_REQUIRE_MESSAGE(g.items.size() == 2, "Wrong number of keys");
-            BOOST_REQUIRE_MESSAGE(g.items[0].type == DataType::KEY_RSA_PRIVATE &&
-                                  g.items[1].type == DataType::KEY_RSA_PUBLIC, "Wrong key");
-
-            EncryptDecryptItem(g.items[0], g.items[1]);
-        } else {
-            for(const auto& i:g.items) {
-                switch (i.type) {
-                case DataType::KEY_AES:
-                    EncryptDecryptItem(i);
-                    break;
-
-                case DataType::CHAIN_CERT_0:
-                    EncryptDecryptItem(i, i);
-                    break;
-
-                default:
-                    break;
-                }
-            }
-        }
-    }
+void SchemeTest::ReadAll(bool useWrongPass)
+{
+	SwitchToUser();
+
+	for (const auto &g : GROUPS) {
+		for (const auto &i : g.items) {
+			int ret;
+			Password pass = i.policy.password;
+
+			if (useWrongPass) {
+				if (pass.empty())
+					pass = TEST_PASS;
+				else
+					pass = Password();
+			}
+
+			switch (i.type) {
+			case DataType::BINARY_DATA: {
+				RawBuffer receivedData;
+				ret = m_mgr->getData(i.alias, pass, receivedData);
+				BOOST_REQUIRE_MESSAGE(useWrongPass || receivedData == TEST_DATA,
+									  "Received data is different for " << i.alias);
+				break;
+			}
+
+			case DataType::KEY_AES:
+			case DataType::KEY_RSA_PRIVATE:
+			case DataType::KEY_RSA_PUBLIC: {
+				KeyShPtr receivedKey;
+				ret = m_mgr->getKey(i.alias, pass, receivedKey);
+				break;
+			}
+
+			case DataType::CERTIFICATE: {
+				CertificateShPtr receivedCert;
+				ret = m_mgr->getCertificate(i.alias, pass, receivedCert);
+				break;
+			}
+
+			case DataType::CHAIN_CERT_0: { // pkcs
+				PKCS12ShPtr pkcs;
+				ret = m_mgr->getPKCS12(i.alias, pass, pass, pkcs);
+				break;
+			}
+
+			default:
+				BOOST_FAIL("Unsupported data type " << i.type);
+			}
+
+			if (i.policy.extractable) {
+				if (useWrongPass)
+					BOOST_REQUIRE_MESSAGE(ret == CKM_API_ERROR_AUTHENTICATION_FAILED,
+										  "Reading item " << i.alias << " should fail with " <<
+										  CKM_API_ERROR_AUTHENTICATION_FAILED << " got: " << ret);
+				else
+					BOOST_REQUIRE_MESSAGE(ret == CKM_API_SUCCESS, "Reading item " << i.alias <<
+										  " failed with " << ret);
+			} else {
+				BOOST_REQUIRE_MESSAGE(ret == CKM_API_ERROR_NOT_EXPORTABLE, "Item " << i.alias <<
+									  " should not be exportable");
+			}
+		}
+	}
 }
 
-void SchemeTest::CreateChain() {
-    SwitchToUser();
-
-    for(const auto& g:GROUPS) {
-        if(g.type == Group::CERT_CHAIN) {
-            BOOST_REQUIRE_MESSAGE(g.items.size() == CHAIN_SIZE, "Not enough certificates");
-            for(const auto& c:g.items)
-                BOOST_REQUIRE_MESSAGE(c.type == DataType::CERTIFICATE, "Wrong item type");
-            Items trusted(CHAIN_SIZE-1);
-            std::copy(g.items.begin(), g.items.begin() + CHAIN_SIZE-1, trusted.begin());
-
-            // last one is ee (leaf)
-            CreateChainItem(g.items.back(), trusted);
-        } else {
-            for(const auto& i:g.items) {
-                if(i.type == DataType::CHAIN_CERT_0) // PKCS
-                    CreateChainItem(i, { i });
-            }
-        }
-    }
+void SchemeTest::SignVerify()
+{
+	SwitchToUser();
+
+	for (const auto &g : GROUPS) {
+		if (g.type == Group::KEY_PAIR_RSA) {
+			BOOST_REQUIRE_MESSAGE(g.items.size() == 2, "Wrong number of keys");
+			BOOST_REQUIRE_MESSAGE(g.items[0].type == DataType::KEY_RSA_PRIVATE &&
+								  g.items[1].type == DataType::KEY_RSA_PUBLIC, "Wrong key");
+
+			SignVerifyItem(g.items[0], g.items[1]);
+		} else {
+			for (const auto &i : g.items) {
+				switch (i.type) {
+				case DataType::CHAIN_CERT_0:
+					SignVerifyItem(i, i);
+					break;
+
+				default:
+					break;
+				}
+			}
+		}
+	}
 }
 
-void SchemeTest::RemoveAll() {
-    SwitchToUser();
-
-    for(const auto& g:GROUPS) {
-        for(const auto& i:g.items) {
-            int ret = m_mgr->removeAlias(i.alias);
-            BOOST_REQUIRE_MESSAGE(ret == CKM_API_SUCCESS,
-                                  "removeAlias() failed with " << ret << " for " << i.alias);
-        }
-    }
-}
-size_t SchemeTest::CountObjects() {
-    EnableDirectDbAccess();
-
-    size_t ret = 0;
-    for(const auto& g:GROUPS) {
-        for(const auto& i:g.items) {
-            DB::RowVector rows;
-            // it is assumed that aliases are different
-            m_db->getRows(i.alias, DB_LABEL, DataType::DB_FIRST, DataType::DB_LAST, rows);
-            ret += rows.size();
-        }
-    }
-    return ret;
+void SchemeTest::EncryptDecrypt()
+{
+	SwitchToUser();
+
+	for (const auto &g : GROUPS) {
+		if (g.type == Group::KEY_PAIR_RSA) {
+			BOOST_REQUIRE_MESSAGE(g.items.size() == 2, "Wrong number of keys");
+			BOOST_REQUIRE_MESSAGE(g.items[0].type == DataType::KEY_RSA_PRIVATE &&
+								  g.items[1].type == DataType::KEY_RSA_PUBLIC, "Wrong key");
+
+			EncryptDecryptItem(g.items[0], g.items[1]);
+		} else {
+			for (const auto &i : g.items) {
+				switch (i.type) {
+				case DataType::KEY_AES:
+					EncryptDecryptItem(i);
+					break;
+
+				case DataType::CHAIN_CERT_0:
+					EncryptDecryptItem(i, i);
+					break;
+
+				default:
+					break;
+				}
+			}
+		}
+	}
 }
 
-void SchemeTest::RestoreDb() {
-    restoreFile("key-7654");
-    restoreFile("db-key-7654");
-    restoreFile("db-7654");
-    m_db.reset();
-    m_directAccessEnabled = false;
+void SchemeTest::CreateChain()
+{
+	SwitchToUser();
+
+	for (const auto &g : GROUPS) {
+		if (g.type == Group::CERT_CHAIN) {
+			BOOST_REQUIRE_MESSAGE(g.items.size() == CHAIN_SIZE, "Not enough certificates");
+
+			for (const auto &c : g.items)
+				BOOST_REQUIRE_MESSAGE(c.type == DataType::CERTIFICATE, "Wrong item type");
+
+			Items trusted(CHAIN_SIZE - 1);
+			std::copy(g.items.begin(), g.items.begin() + CHAIN_SIZE - 1, trusted.begin());
+
+			// last one is ee (leaf)
+			CreateChainItem(g.items.back(), trusted);
+		} else {
+			for (const auto &i : g.items) {
+				if (i.type == DataType::CHAIN_CERT_0) // PKCS
+					CreateChainItem(i, { i });
+			}
+		}
+	}
 }
 
-void SchemeTest::CheckSchemeVersion(const ItemFilter& filter, int version) {
-    EnableDirectDbAccess();
-
-    for(const auto& g:GROUPS) {
-        for(const auto& i:g.items) {
-            if(!filter.Matches(i))
-                continue;
-
-            DB::RowVector rows;
-            m_db->getRows(i.alias, DB_LABEL, filter.typeFrom, filter.typeTo, rows);
-            BOOST_REQUIRE_MESSAGE(rows.size() > 0, "No rows found for " << i.alias);
-            for(const auto& r : rows) {
-                BOOST_REQUIRE_MESSAGE(
-                        (r.encryptionScheme >> ENC_SCHEME_OFFSET) == version,
-                        "Wrong encryption scheme for " << i.alias << ". Expected " << version <<
-                        " got: " << (r.encryptionScheme >> ENC_SCHEME_OFFSET));
-            }
-        }
-    }
+void SchemeTest::RemoveAll()
+{
+	SwitchToUser();
+
+	for (const auto &g : GROUPS) {
+		for (const auto &i : g.items) {
+			int ret = m_mgr->removeAlias(i.alias);
+			BOOST_REQUIRE_MESSAGE(ret == CKM_API_SUCCESS,
+								  "removeAlias() failed with " << ret << " for " << i.alias);
+		}
+	}
 }
+size_t SchemeTest::CountObjects()
+{
+	EnableDirectDbAccess();
 
-void SchemeTest::EnableDirectDbAccess() {
-    SwitchToRoot();
-
-    if(m_directAccessEnabled)
-        return;
-
-    // direct access to db
-    FileSystem fs(UID);
-    auto wrappedDKEK = fs.getDKEK();
-    auto keyProvider = KeyProvider(wrappedDKEK, DBPASS);
+	size_t ret = 0;
 
-    auto wrappedDatabaseDEK = fs.getDBDEK();
-    RawBuffer key = keyProvider.getPureDEK(wrappedDatabaseDEK);
+	for (const auto &g : GROUPS) {
+		for (const auto &i : g.items) {
+			DB::RowVector rows;
+			// it is assumed that aliases are different
+			m_db->getRows(i.alias, DB_LABEL, DataType::DB_FIRST, DataType::DB_LAST, rows);
+			ret += rows.size();
+		}
+	}
 
-    m_db.reset(new DB::Crypto(fs.getDBPath(), key));
-    m_directAccessEnabled = true;
+	return ret;
 }
 
-void SchemeTest::SignVerifyItem(const Item& itemPrv, const Item& itemPub) {
-    int ret;
-    KeyShPtr receivedKey;
-    RawBuffer signature;
-    // create/verify signature
-    ret = m_mgr->createSignature(itemPrv.alias,
-                                 itemPrv.policy.password,
-                                 TEST_DATA,
-                                 HashAlgorithm::SHA512,
-                                 RSAPaddingAlgorithm::X931,
-                                 signature);
-    BOOST_REQUIRE_MESSAGE(ret == CKM_API_SUCCESS, "createSignature() failed with " << ret <<
-                          " for " << itemPrv.alias);
-    ret = m_mgr->verifySignature(itemPub.alias,
-                                 itemPub.policy.password,
-                                 TEST_DATA,
-                                 signature,
-                                 HashAlgorithm::SHA512,
-                                 RSAPaddingAlgorithm::X931);
-    BOOST_REQUIRE_MESSAGE(ret == CKM_API_SUCCESS, "verifySignature() failed with " << ret <<
-                          " for " << itemPub.alias);
+void SchemeTest::RestoreDb()
+{
+	restoreFile("key-7654");
+	restoreFile("db-key-7654");
+	restoreFile("db-7654");
+	m_db.reset();
+	m_directAccessEnabled = false;
+}
 
+void SchemeTest::CheckSchemeVersion(const ItemFilter &filter, int version)
+{
+	EnableDirectDbAccess();
+
+	for (const auto &g : GROUPS) {
+		for (const auto &i : g.items) {
+			if (!filter.Matches(i))
+				continue;
+
+			DB::RowVector rows;
+			m_db->getRows(i.alias, DB_LABEL, filter.typeFrom, filter.typeTo, rows);
+			BOOST_REQUIRE_MESSAGE(rows.size() > 0, "No rows found for " << i.alias);
+
+			for (const auto &r : rows) {
+				BOOST_REQUIRE_MESSAGE(
+					(r.encryptionScheme >> ENC_SCHEME_OFFSET) == version,
+					"Wrong encryption scheme for " << i.alias << ". Expected " << version <<
+					" got: " << (r.encryptionScheme >> ENC_SCHEME_OFFSET));
+			}
+		}
+	}
 }
 
-void SchemeTest::EncryptDecryptItem(const Item& item) {
-    CryptoAlgorithm algo;
-    RawBuffer iv = createRandomBuffer(IV_LEN);
-    RawBuffer encrypted, decrypted;
-    int ret;
+void SchemeTest::EnableDirectDbAccess()
+{
+	SwitchToRoot();
 
-    algo.setParam(ParamName::ALGO_TYPE, AlgoType::AES_GCM);
-    algo.setParam(ParamName::ED_IV, iv);
+	if (m_directAccessEnabled)
+		return;
 
-    ret = m_mgr->encrypt(algo, item.alias, item.policy.password, TEST_DATA, encrypted);
-    BOOST_REQUIRE_MESSAGE(ret == CKM_API_SUCCESS, "encrypt() failed iwth " << ret << " for " <<
-                          item.alias);
+	// direct access to db
+	FileSystem fs(UID);
+	auto wrappedDKEK = fs.getDKEK();
+	auto keyProvider = KeyProvider(wrappedDKEK, DBPASS);
 
-    ret = m_mgr->decrypt(algo, item.alias, item.policy.password, encrypted, decrypted);
-    BOOST_REQUIRE_MESSAGE(ret == CKM_API_SUCCESS, "decrypt() failed iwth " << ret << " for " <<
-                          item.alias);
+	auto wrappedDatabaseDEK = fs.getDBDEK();
+	RawBuffer key = keyProvider.getPureDEK(wrappedDatabaseDEK);
 
-    BOOST_REQUIRE_MESSAGE(decrypted == TEST_DATA, "Decrypted data not equal to original");
+	m_db.reset(new DB::Crypto(fs.getDBPath(), key));
+	m_directAccessEnabled = true;
 }
 
-void SchemeTest::EncryptDecryptItem(const Item& itemPrv, const Item& itemPub) {
-    CryptoAlgorithm algo;
-    RawBuffer encrypted, decrypted;
-    int ret;
-
-    algo.setParam(ParamName::ALGO_TYPE, AlgoType::RSA_OAEP);
-
-    ret = m_mgr->encrypt(algo, itemPub.alias, itemPub.policy.password, TEST_DATA, encrypted);
-    BOOST_REQUIRE_MESSAGE(ret == CKM_API_SUCCESS, "encrypt() failed iwth " << ret << " for " <<
-                          itemPub.alias);
+void SchemeTest::SignVerifyItem(const Item &itemPrv, const Item &itemPub)
+{
+	int ret;
+	KeyShPtr receivedKey;
+	RawBuffer signature;
+	// create/verify signature
+	ret = m_mgr->createSignature(itemPrv.alias,
+								 itemPrv.policy.password,
+								 TEST_DATA,
+								 HashAlgorithm::SHA512,
+								 RSAPaddingAlgorithm::X931,
+								 signature);
+	BOOST_REQUIRE_MESSAGE(ret == CKM_API_SUCCESS,
+						  "createSignature() failed with " << ret <<
+						  " for " << itemPrv.alias);
+	ret = m_mgr->verifySignature(itemPub.alias,
+								 itemPub.policy.password,
+								 TEST_DATA,
+								 signature,
+								 HashAlgorithm::SHA512,
+								 RSAPaddingAlgorithm::X931);
+	BOOST_REQUIRE_MESSAGE(ret == CKM_API_SUCCESS,
+						  "verifySignature() failed with " << ret <<
+						  " for " << itemPub.alias);
+}
 
-    ret = m_mgr->decrypt(algo, itemPrv.alias, itemPrv.policy.password, encrypted, decrypted);
-    BOOST_REQUIRE_MESSAGE(ret == CKM_API_SUCCESS, "decrypt() failed iwth " << ret << " for " <<
-                          itemPrv.alias);
+void SchemeTest::EncryptDecryptItem(const Item &item)
+{
+	CryptoAlgorithm algo;
+	RawBuffer iv = createRandomBuffer(IV_LEN);
+	RawBuffer encrypted, decrypted;
+	int ret;
+
+	algo.setParam(ParamName::ALGO_TYPE, AlgoType::AES_GCM);
+	algo.setParam(ParamName::ED_IV, iv);
+
+	ret = m_mgr->encrypt(algo, item.alias, item.policy.password, TEST_DATA,
+						 encrypted);
+	BOOST_REQUIRE_MESSAGE(ret == CKM_API_SUCCESS,
+						  "encrypt() failed iwth " << ret << " for " <<
+						  item.alias);
+
+	ret = m_mgr->decrypt(algo, item.alias, item.policy.password, encrypted,
+						 decrypted);
+	BOOST_REQUIRE_MESSAGE(ret == CKM_API_SUCCESS,
+						  "decrypt() failed iwth " << ret << " for " <<
+						  item.alias);
+
+	BOOST_REQUIRE_MESSAGE(decrypted == TEST_DATA,
+						  "Decrypted data not equal to original");
+}
 
-    BOOST_REQUIRE_MESSAGE(decrypted == TEST_DATA, "Decrypted data not equal to original");
+void SchemeTest::EncryptDecryptItem(const Item &itemPrv, const Item &itemPub)
+{
+	CryptoAlgorithm algo;
+	RawBuffer encrypted, decrypted;
+	int ret;
+
+	algo.setParam(ParamName::ALGO_TYPE, AlgoType::RSA_OAEP);
+
+	ret = m_mgr->encrypt(algo, itemPub.alias, itemPub.policy.password, TEST_DATA,
+						 encrypted);
+	BOOST_REQUIRE_MESSAGE(ret == CKM_API_SUCCESS,
+						  "encrypt() failed iwth " << ret << " for " <<
+						  itemPub.alias);
+
+	ret = m_mgr->decrypt(algo, itemPrv.alias, itemPrv.policy.password, encrypted,
+						 decrypted);
+	BOOST_REQUIRE_MESSAGE(ret == CKM_API_SUCCESS,
+						  "decrypt() failed iwth " << ret << " for " <<
+						  itemPrv.alias);
+
+	BOOST_REQUIRE_MESSAGE(decrypted == TEST_DATA,
+						  "Decrypted data not equal to original");
 }
 
-void SchemeTest::CreateChainItem(const Item& leaf, const Items& certs) {
-    CertificateShPtrVector chain;
-    AliasVector trusted;
-
-    if(!leaf.policy.extractable || !leaf.policy.password.empty())
-        return;
-
-    for(const auto& i : certs) {
-        if(!i.policy.extractable || !i.policy.password.empty())
-            return;
-        trusted.push_back(i.alias);
-    }
-
-    CertificateShPtr leafCrt;
-    int ret = m_mgr->getCertificate(leaf.alias, leaf.policy.password, leafCrt);
-    BOOST_REQUIRE_MESSAGE(ret == CKM_API_SUCCESS,
-                          "getCertificate failed with " << ret << " for " <<
-                          leaf.alias);
-
-    ret = m_mgr->getCertificateChain(leafCrt, AliasVector(), trusted, false, chain);
-    BOOST_REQUIRE_MESSAGE(ret == CKM_API_SUCCESS,
-                          "getCertificateChain() failed with " << ret);
-    BOOST_REQUIRE_MESSAGE(chain.size() == CHAIN_LEN, "Wrong chain length: " << chain.size());
+void SchemeTest::CreateChainItem(const Item &leaf, const Items &certs)
+{
+	CertificateShPtrVector chain;
+	AliasVector trusted;
+
+	if (!leaf.policy.extractable || !leaf.policy.password.empty())
+		return;
+
+	for (const auto &i : certs) {
+		if (!i.policy.extractable || !i.policy.password.empty())
+			return;
+
+		trusted.push_back(i.alias);
+	}
+
+	CertificateShPtr leafCrt;
+	int ret = m_mgr->getCertificate(leaf.alias, leaf.policy.password, leafCrt);
+	BOOST_REQUIRE_MESSAGE(ret == CKM_API_SUCCESS,
+						  "getCertificate failed with " << ret << " for " <<
+						  leaf.alias);
+
+	ret = m_mgr->getCertificateChain(leafCrt, AliasVector(), trusted, false, chain);
+	BOOST_REQUIRE_MESSAGE(ret == CKM_API_SUCCESS,
+						  "getCertificateChain() failed with " << ret);
+	BOOST_REQUIRE_MESSAGE(chain.size() == CHAIN_LEN,
+						  "Wrong chain length: " << chain.size());
 }
diff --git a/tests/encryption-scheme/scheme-test.h b/tests/encryption-scheme/scheme-test.h
index 96dab6cf..d9880842 100644
--- a/tests/encryption-scheme/scheme-test.h
+++ b/tests/encryption-scheme/scheme-test.h
@@ -37,92 +37,99 @@ class Crypto;
 } // CKM
 
 struct Item {
-    Item() : type(CKM::DataType::Type::DB_LAST)
-    {
-    }
-
-    Item(const CKM::Alias& alias,
-         const CKM::DataType::Type type,
-         const CKM::Policy& policy)
-    : alias(alias), type(type), policy(policy)
-    {
-    }
-
-    CKM::Alias alias;
-    CKM::DataType::Type type;
-    CKM::Policy policy;
+	Item() : type(CKM::DataType::Type::DB_LAST)
+	{
+	}
+
+	Item(const CKM::Alias &alias,
+		 const CKM::DataType::Type type,
+		 const CKM::Policy &policy)
+		: alias(alias), type(type), policy(policy)
+	{
+	}
+
+	CKM::Alias alias;
+	CKM::DataType::Type type;
+	CKM::Policy policy;
 };
 
 typedef std::vector<Item> Items;
 
 struct ItemFilter {
-    ItemFilter() :
-        typeFrom(CKM::DataType::DB_FIRST),
-        typeTo(CKM::DataType::DB_LAST),
-        exportableOnly(false),
-        noPassword(false)
-    {}
-
-    explicit ItemFilter(CKM::DataType::Type type) :
-        typeFrom(type),
-        typeTo(type),
-        exportableOnly(false),
-        noPassword(false)
-    {}
-
-    ItemFilter(CKM::DataType::Type typeFrom, CKM::DataType::Type typeTo) :
-        typeFrom(typeFrom),
-        typeTo(typeTo),
-        exportableOnly(false),
-        noPassword(false)
-    {}
-
-    bool Matches(const Item& item) const {
-        if(item.type < typeFrom || item.type > typeTo)
-            return false;
-        if(exportableOnly && !item.policy.extractable)
-            return false;
-        if(noPassword && !item.policy.password.empty())
-            return false;
-        return true;
-    }
-
-    CKM::DataType::Type typeFrom;
-    CKM::DataType::Type typeTo;
-    bool exportableOnly;
-    bool noPassword;
+	ItemFilter() :
+		typeFrom(CKM::DataType::DB_FIRST),
+		typeTo(CKM::DataType::DB_LAST),
+		exportableOnly(false),
+		noPassword(false)
+	{
+	}
+
+	explicit ItemFilter(CKM::DataType::Type type) :
+		typeFrom(type),
+		typeTo(type),
+		exportableOnly(false),
+		noPassword(false)
+	{
+	}
+
+	ItemFilter(CKM::DataType::Type typeFrom, CKM::DataType::Type typeTo) :
+		typeFrom(typeFrom),
+		typeTo(typeTo),
+		exportableOnly(false),
+		noPassword(false)
+	{
+	}
+
+	bool Matches(const Item &item) const
+	{
+		if (item.type < typeFrom || item.type > typeTo)
+			return false;
+
+		if (exportableOnly && !item.policy.extractable)
+			return false;
+
+		if (noPassword && !item.policy.password.empty())
+			return false;
+
+		return true;
+	}
+
+	CKM::DataType::Type typeFrom;
+	CKM::DataType::Type typeTo;
+	bool exportableOnly;
+	bool noPassword;
 };
 
 class SchemeTest {
 public:
-    SchemeTest();
-    ~SchemeTest();
-
-    void RemoveUserData();
-    void FillDb();
-    void ReadAll(bool useWrongPass = false);
-    void SignVerify();
-    void EncryptDecrypt();
-    void CreateChain();
-    void RemoveAll();
-    size_t CountObjects();
-    void RestoreDb();
-    void CheckSchemeVersion(const ItemFilter& filter, int version);
+	SchemeTest();
+	~SchemeTest();
+
+	void RemoveUserData();
+	void FillDb();
+	void ReadAll(bool useWrongPass = false);
+	void SignVerify();
+	void EncryptDecrypt();
+	void CreateChain();
+	void RemoveAll();
+	size_t CountObjects();
+	void RestoreDb();
+	void CheckSchemeVersion(const ItemFilter &filter, int version);
 
 private:
-    void SwitchToUser();
-    void SwitchToRoot();
-    void EnableDirectDbAccess();
-    void SignVerifyItem(const Item& itemPrv, const Item& itemPub);
-    void EncryptDecryptItem(const Item& item);
-    void EncryptDecryptItem(const Item& itemPrv, const Item& itemPub);
-    void CreateChainItem(const Item& leaf, const Items& certs);
-
-    CKM::ControlShPtr m_control;
-    CKM::ManagerShPtr m_mgr;
-    std::string m_origLabel;
-    bool m_userChanged;
-
-    std::unique_ptr<CKM::DB::Crypto> m_db;
-    bool m_directAccessEnabled;
+	void SwitchToUser();
+	void SwitchToRoot();
+	void EnableDirectDbAccess();
+	void SignVerifyItem(const Item &itemPrv, const Item &itemPub);
+	void EncryptDecryptItem(const Item &item);
+	void EncryptDecryptItem(const Item &itemPrv, const Item &itemPub);
+	void CreateChainItem(const Item &leaf, const Items &certs);
+
+	CKM::ControlShPtr m_control;
+	CKM::ManagerShPtr m_mgr;
+	std::string m_origLabel;
+	bool m_userChanged;
+
+	std::unique_ptr<CKM::DB::Crypto> m_db;
+	bool m_directAccessEnabled;
 };
diff --git a/tests/encryption-scheme/smack-access.cpp b/tests/encryption-scheme/smack-access.cpp
index 89e1bcbf..8115e641 100644
--- a/tests/encryption-scheme/smack-access.cpp
+++ b/tests/encryption-scheme/smack-access.cpp
@@ -28,25 +28,28 @@
 
 SmackAccess::SmackAccess() : m_handle(nullptr)
 {
-    if(0 != smack_accesses_new(&m_handle))
-        throw std::runtime_error("smack_accesses_new failed");
+	if (0 != smack_accesses_new(&m_handle))
+		throw std::runtime_error("smack_accesses_new failed");
 }
 
 void SmackAccess::add(
-    const std::string &subject,
-    const std::string &object,
-    const std::string &rights)
+	const std::string &subject,
+	const std::string &object,
+	const std::string &rights)
 {
-    if(0 != smack_accesses_add(m_handle, subject.c_str(), object.c_str(), rights.c_str()))
-        throw std::runtime_error("smack_accesses_add failed");
+	if (0 != smack_accesses_add(m_handle, subject.c_str(), object.c_str(),
+								rights.c_str()))
+		throw std::runtime_error("smack_accesses_add failed");
 }
 
-void SmackAccess::apply() {
-    if(0 != smack_accesses_apply(m_handle))
-        throw std::runtime_error("smack_accesses_apply failed");
+void SmackAccess::apply()
+{
+	if (0 != smack_accesses_apply(m_handle))
+		throw std::runtime_error("smack_accesses_apply failed");
 }
 
-SmackAccess::~SmackAccess() {
-    if (m_handle)
-        smack_accesses_free(m_handle);
+SmackAccess::~SmackAccess()
+{
+	if (m_handle)
+		smack_accesses_free(m_handle);
 }
diff --git a/tests/encryption-scheme/smack-access.h b/tests/encryption-scheme/smack-access.h
index 5fc740c0..1ee72c4c 100644
--- a/tests/encryption-scheme/smack-access.h
+++ b/tests/encryption-scheme/smack-access.h
@@ -28,15 +28,15 @@ struct smack_accesses;
 
 class SmackAccess {
 public:
-    SmackAccess();
-    SmackAccess(const SmackAccess &second) = delete;
-    SmackAccess& operator=(const SmackAccess &second) = delete;
+	SmackAccess();
+	SmackAccess(const SmackAccess &second) = delete;
+	SmackAccess &operator=(const SmackAccess &second) = delete;
 
-    void add(const std::string &subject,
-             const std::string &object,
-             const std::string &rights);
-    void apply();
-    virtual ~SmackAccess();
+	void add(const std::string &subject,
+			 const std::string &object,
+			 const std::string &rights);
+	void apply();
+	virtual ~SmackAccess();
 private:
-    struct smack_accesses *m_handle;
+	struct smack_accesses *m_handle;
 };
diff --git a/tests/main.cpp b/tests/main.cpp
index efaf1be8..c3ff1ebd 100644
--- a/tests/main.cpp
+++ b/tests/main.cpp
@@ -31,41 +31,47 @@
 #include <exception.h>
 
 struct TestConfig {
-    TestConfig() {
-        boost::unit_test::unit_test_log.set_threshold_level( boost::unit_test::log_test_units);
-        boost::unit_test::results_reporter::set_level(boost::unit_test::SHORT_REPORT);
-        boost::unit_test::unit_test_log.set_formatter(new CKM::colour_log_formatter);
-    }
-    ~TestConfig(){
-    }
+	TestConfig()
+	{
+		boost::unit_test::unit_test_log.set_threshold_level(
+			boost::unit_test::log_test_units);
+		boost::unit_test::results_reporter::set_level(boost::unit_test::SHORT_REPORT);
+		boost::unit_test::unit_test_log.set_formatter(new CKM::colour_log_formatter);
+	}
+	~TestConfig()
+	{
+	}
 };
 
 bool isLibInitialized = false;
 
 struct KeyProviderLib {
-    KeyProviderLib() {
-        try {
-            CKM::KeyProvider::initializeLibrary();
-            isLibInitialized = true;
-        } catch (const CKM::Exc::Exception &) {
-            std::cout << "Library initialization failed!" << std::endl;
-        }
-    }
-    ~KeyProviderLib() {
-        try {
-            CKM::KeyProvider::closeLibrary();
-        } catch (const CKM::Exc::Exception &) {
-            std::cout << "Library deinitialization failed!" << std::endl;
-        }
-    }
+	KeyProviderLib()
+	{
+		try {
+			CKM::KeyProvider::initializeLibrary();
+			isLibInitialized = true;
+		} catch (const CKM::Exc::Exception &) {
+			std::cout << "Library initialization failed!" << std::endl;
+		}
+	}
+	~KeyProviderLib()
+	{
+		try {
+			CKM::KeyProvider::closeLibrary();
+		} catch (const CKM::Exc::Exception &) {
+			std::cout << "Library deinitialization failed!" << std::endl;
+		}
+	}
 };
 
 struct LogSetup {
-    LogSetup() {
-        CKM::SetupClientLogSystem();
-        CKM::Singleton<CKM::Log::LogSystem>::Instance().SetTag("CKM_INTERNAL_TESTS");
-    }
-    ~LogSetup() {}
+	LogSetup()
+	{
+		CKM::SetupClientLogSystem();
+		CKM::Singleton<CKM::Log::LogSystem>::Instance().SetTag("CKM_INTERNAL_TESTS");
+	}
+	~LogSetup() {}
 };
 
 BOOST_GLOBAL_FIXTURE(KeyProviderLib)
diff --git a/tests/test-key-provider.cpp b/tests/test-key-provider.cpp
index 2f026abb..2186304b 100644
--- a/tests/test-key-provider.cpp
+++ b/tests/test-key-provider.cpp
@@ -39,118 +39,128 @@ const std::string SMACK_LABEL_2 = "SAMPLE_SMACK_LABEL_2";
 extern bool isLibInitialized;
 
 BOOST_AUTO_TEST_SUITE(KEY_PROVIDER_TEST)
-BOOST_AUTO_TEST_CASE(KeyDomainKEK){
-    BOOST_REQUIRE_MESSAGE(isLibInitialized,
-            "Library is not initialized!");
-    CKM::KeyProvider keyProvider;
-    CKM::RawBuffer rb_test;
-    BOOST_REQUIRE_NO_THROW(rb_test =
-            CKM::KeyProvider::generateDomainKEK(USERNAME_LONG, PASSWORD));
-    BOOST_REQUIRE_NO_THROW(keyProvider = CKM::KeyProvider(rb_test, PASSWORD));
-    BOOST_REQUIRE_MESSAGE(keyProvider.isInitialized(),
-            "KeyProvider created, but uninitialized");
+BOOST_AUTO_TEST_CASE(KeyDomainKEK)
+{
+	BOOST_REQUIRE_MESSAGE(isLibInitialized,
+						  "Library is not initialized!");
+	CKM::KeyProvider keyProvider;
+	CKM::RawBuffer rb_test;
+	BOOST_REQUIRE_NO_THROW(rb_test =
+							   CKM::KeyProvider::generateDomainKEK(USERNAME_LONG, PASSWORD));
+	BOOST_REQUIRE_NO_THROW(keyProvider = CKM::KeyProvider(rb_test, PASSWORD));
+	BOOST_REQUIRE_MESSAGE(keyProvider.isInitialized(),
+						  "KeyProvider created, but uninitialized");
 }
 
-BOOST_AUTO_TEST_CASE(KeyDomainKekInvalidPassword){
-    BOOST_REQUIRE_MESSAGE(isLibInitialized,
-            "Library is not initialized!");
-    CKM::KeyProvider keyProvider;
-    CKM::RawBuffer rb_test;
-    BOOST_REQUIRE_NO_THROW(rb_test =
-            CKM::KeyProvider::generateDomainKEK(USERNAME_LONG, PASSWORD));
-    BOOST_REQUIRE_THROW(keyProvider = CKM::KeyProvider(rb_test, INCORRECT_PASSWORD),
-            CKM::Exc::AuthenticationFailed);
-    BOOST_REQUIRE_MESSAGE(!keyProvider.isInitialized(),
-            "KeyProvider not created, but initialized");
+BOOST_AUTO_TEST_CASE(KeyDomainKekInvalidPassword)
+{
+	BOOST_REQUIRE_MESSAGE(isLibInitialized,
+						  "Library is not initialized!");
+	CKM::KeyProvider keyProvider;
+	CKM::RawBuffer rb_test;
+	BOOST_REQUIRE_NO_THROW(rb_test =
+							   CKM::KeyProvider::generateDomainKEK(USERNAME_LONG, PASSWORD));
+	BOOST_REQUIRE_THROW(keyProvider = CKM::KeyProvider(rb_test, INCORRECT_PASSWORD),
+						CKM::Exc::AuthenticationFailed);
+	BOOST_REQUIRE_MESSAGE(!keyProvider.isInitialized(),
+						  "KeyProvider not created, but initialized");
 }
 
-BOOST_AUTO_TEST_CASE(KeygetPureDomainKEK){
-    BOOST_REQUIRE_MESSAGE(isLibInitialized,
-            "Library is not initialized!");
-    CKM::KeyProvider keyProvider;
-    CKM::RawBuffer rb_test;
-    BOOST_REQUIRE_NO_THROW(rb_test =
-            CKM::KeyProvider::generateDomainKEK(USERNAME_LONG, PASSWORD));
-    BOOST_REQUIRE_NO_THROW(keyProvider = CKM::KeyProvider(rb_test, PASSWORD));
-    BOOST_REQUIRE_MESSAGE(keyProvider.isInitialized(),
-            "KeyProvider created, but uninitialized");
-    BOOST_REQUIRE_NO_THROW(rb_test = keyProvider.getPureDomainKEK());
+BOOST_AUTO_TEST_CASE(KeygetPureDomainKEK)
+{
+	BOOST_REQUIRE_MESSAGE(isLibInitialized,
+						  "Library is not initialized!");
+	CKM::KeyProvider keyProvider;
+	CKM::RawBuffer rb_test;
+	BOOST_REQUIRE_NO_THROW(rb_test =
+							   CKM::KeyProvider::generateDomainKEK(USERNAME_LONG, PASSWORD));
+	BOOST_REQUIRE_NO_THROW(keyProvider = CKM::KeyProvider(rb_test, PASSWORD));
+	BOOST_REQUIRE_MESSAGE(keyProvider.isInitialized(),
+						  "KeyProvider created, but uninitialized");
+	BOOST_REQUIRE_NO_THROW(rb_test = keyProvider.getPureDomainKEK());
 }
 
-BOOST_AUTO_TEST_CASE(KeyGetWrappedDomainKEK){
-    BOOST_REQUIRE_MESSAGE(isLibInitialized,
-            "Library is not initialized!");
-    CKM::KeyProvider keyProvider;
-    CKM::RawBuffer rb_test;
-    BOOST_REQUIRE_NO_THROW(rb_test =
-            CKM::KeyProvider::generateDomainKEK(USERNAME_LONG, PASSWORD));
-    BOOST_REQUIRE_NO_THROW(keyProvider = CKM::KeyProvider(rb_test, PASSWORD));
-    BOOST_REQUIRE_MESSAGE(keyProvider.isInitialized(),
-            "KeyProvider created, but uninitialized");
-    BOOST_REQUIRE_NO_THROW(rb_test = keyProvider.getWrappedDomainKEK(PASSWORD));
+BOOST_AUTO_TEST_CASE(KeyGetWrappedDomainKEK)
+{
+	BOOST_REQUIRE_MESSAGE(isLibInitialized,
+						  "Library is not initialized!");
+	CKM::KeyProvider keyProvider;
+	CKM::RawBuffer rb_test;
+	BOOST_REQUIRE_NO_THROW(rb_test =
+							   CKM::KeyProvider::generateDomainKEK(USERNAME_LONG, PASSWORD));
+	BOOST_REQUIRE_NO_THROW(keyProvider = CKM::KeyProvider(rb_test, PASSWORD));
+	BOOST_REQUIRE_MESSAGE(keyProvider.isInitialized(),
+						  "KeyProvider created, but uninitialized");
+	BOOST_REQUIRE_NO_THROW(rb_test = keyProvider.getWrappedDomainKEK(PASSWORD));
 }
 
-BOOST_AUTO_TEST_CASE(KeyGenerateDEK){
-    BOOST_REQUIRE_MESSAGE(isLibInitialized,
-            "Library is not initialized!");
-    CKM::KeyProvider keyProvider;
-    CKM::RawBuffer rb_test;
-    CKM::RawBuffer rb_DEK1;
-    BOOST_REQUIRE_NO_THROW(rb_test =
-            CKM::KeyProvider::generateDomainKEK(USERNAME_LONG, PASSWORD));
-    BOOST_REQUIRE_NO_THROW(keyProvider = CKM::KeyProvider(rb_test, PASSWORD));
-    BOOST_REQUIRE_MESSAGE(keyProvider.isInitialized(),
-            "KeyProvider created, but uninitialized");
-    BOOST_REQUIRE_NO_THROW(rb_DEK1 = keyProvider.generateDEK(SMACK_LABEL_1));
+BOOST_AUTO_TEST_CASE(KeyGenerateDEK)
+{
+	BOOST_REQUIRE_MESSAGE(isLibInitialized,
+						  "Library is not initialized!");
+	CKM::KeyProvider keyProvider;
+	CKM::RawBuffer rb_test;
+	CKM::RawBuffer rb_DEK1;
+	BOOST_REQUIRE_NO_THROW(rb_test =
+							   CKM::KeyProvider::generateDomainKEK(USERNAME_LONG, PASSWORD));
+	BOOST_REQUIRE_NO_THROW(keyProvider = CKM::KeyProvider(rb_test, PASSWORD));
+	BOOST_REQUIRE_MESSAGE(keyProvider.isInitialized(),
+						  "KeyProvider created, but uninitialized");
+	BOOST_REQUIRE_NO_THROW(rb_DEK1 = keyProvider.generateDEK(SMACK_LABEL_1));
 }
 
-BOOST_AUTO_TEST_CASE(KeyGetPureDEK){
-    BOOST_REQUIRE_MESSAGE(isLibInitialized,
-            "Library is not initialized!");
-    CKM::KeyProvider keyProvider;
-    CKM::RawBuffer rb_pureDEK1;
-    CKM::RawBuffer rb_DEK1;
-    CKM::RawBuffer rb_test;
-    BOOST_REQUIRE_NO_THROW(rb_test =
-            CKM::KeyProvider::generateDomainKEK(USERNAME_LONG, PASSWORD));
-    BOOST_REQUIRE_NO_THROW(keyProvider = CKM::KeyProvider(rb_test, PASSWORD));
-    BOOST_REQUIRE_MESSAGE(keyProvider.isInitialized(),
-            "KeyProvider created, but uninitialized");
-    BOOST_REQUIRE_NO_THROW(rb_DEK1 = keyProvider.generateDEK(SMACK_LABEL_1));
-    BOOST_REQUIRE_NO_THROW(rb_pureDEK1 = keyProvider.getPureDEK(rb_DEK1));
+BOOST_AUTO_TEST_CASE(KeyGetPureDEK)
+{
+	BOOST_REQUIRE_MESSAGE(isLibInitialized,
+						  "Library is not initialized!");
+	CKM::KeyProvider keyProvider;
+	CKM::RawBuffer rb_pureDEK1;
+	CKM::RawBuffer rb_DEK1;
+	CKM::RawBuffer rb_test;
+	BOOST_REQUIRE_NO_THROW(rb_test =
+							   CKM::KeyProvider::generateDomainKEK(USERNAME_LONG, PASSWORD));
+	BOOST_REQUIRE_NO_THROW(keyProvider = CKM::KeyProvider(rb_test, PASSWORD));
+	BOOST_REQUIRE_MESSAGE(keyProvider.isInitialized(),
+						  "KeyProvider created, but uninitialized");
+	BOOST_REQUIRE_NO_THROW(rb_DEK1 = keyProvider.generateDEK(SMACK_LABEL_1));
+	BOOST_REQUIRE_NO_THROW(rb_pureDEK1 = keyProvider.getPureDEK(rb_DEK1));
 }
 
-BOOST_AUTO_TEST_CASE(KeyReencrypt){
-    BOOST_REQUIRE_MESSAGE(isLibInitialized,
-            "Library is not initialized!");
-    CKM::RawBuffer rb_test;
-    BOOST_REQUIRE_NO_THROW(rb_test =
-            CKM::KeyProvider::generateDomainKEK(USERNAME_LONG, PASSWORD));
-    BOOST_REQUIRE_NO_THROW(CKM::KeyProvider::reencrypt(rb_test, PASSWORD,
-            NEW_PASSWORD));
+BOOST_AUTO_TEST_CASE(KeyReencrypt)
+{
+	BOOST_REQUIRE_MESSAGE(isLibInitialized,
+						  "Library is not initialized!");
+	CKM::RawBuffer rb_test;
+	BOOST_REQUIRE_NO_THROW(rb_test =
+							   CKM::KeyProvider::generateDomainKEK(USERNAME_LONG, PASSWORD));
+	BOOST_REQUIRE_NO_THROW(CKM::KeyProvider::reencrypt(rb_test, PASSWORD,
+						   NEW_PASSWORD));
 }
 
-BOOST_AUTO_TEST_CASE(KeyReencrypt_incorrect_password){
-    BOOST_REQUIRE_MESSAGE(isLibInitialized,
-            "Library is not initialized!");
-    CKM::RawBuffer rb_test;
-    BOOST_REQUIRE_NO_THROW(rb_test =
-            CKM::KeyProvider::generateDomainKEK(USERNAME_LONG, PASSWORD));
-    BOOST_REQUIRE_THROW((rb_test = CKM::KeyProvider::reencrypt(rb_test, INCORRECT_PASSWORD,
-            NEW_PASSWORD)), CKM::Exc::AuthenticationFailed);
+BOOST_AUTO_TEST_CASE(KeyReencrypt_incorrect_password)
+{
+	BOOST_REQUIRE_MESSAGE(isLibInitialized,
+						  "Library is not initialized!");
+	CKM::RawBuffer rb_test;
+	BOOST_REQUIRE_NO_THROW(rb_test =
+							   CKM::KeyProvider::generateDomainKEK(USERNAME_LONG, PASSWORD));
+	BOOST_REQUIRE_THROW((rb_test = CKM::KeyProvider::reencrypt(rb_test,
+								   INCORRECT_PASSWORD,
+								   NEW_PASSWORD)), CKM::Exc::AuthenticationFailed);
 }
 
-BOOST_AUTO_TEST_CASE(KeyGetPureDEK_after_reencrypt){
-    BOOST_REQUIRE_MESSAGE(isLibInitialized,
-            "Library is not initialized!");
-    CKM::KeyProvider keyProvider;
-    CKM::RawBuffer rb_DEK1;
-    CKM::RawBuffer rb_test;
-    BOOST_REQUIRE_NO_THROW(rb_test =
-            CKM::KeyProvider::generateDomainKEK(USERNAME_LONG, PASSWORD));
-    BOOST_REQUIRE_NO_THROW(keyProvider = CKM::KeyProvider(rb_test, PASSWORD));
-    BOOST_REQUIRE_NO_THROW(rb_DEK1 = keyProvider.generateDEK(SMACK_LABEL_1));
-    BOOST_REQUIRE_NO_THROW(keyProvider.getPureDEK(rb_DEK1));
+BOOST_AUTO_TEST_CASE(KeyGetPureDEK_after_reencrypt)
+{
+	BOOST_REQUIRE_MESSAGE(isLibInitialized,
+						  "Library is not initialized!");
+	CKM::KeyProvider keyProvider;
+	CKM::RawBuffer rb_DEK1;
+	CKM::RawBuffer rb_test;
+	BOOST_REQUIRE_NO_THROW(rb_test =
+							   CKM::KeyProvider::generateDomainKEK(USERNAME_LONG, PASSWORD));
+	BOOST_REQUIRE_NO_THROW(keyProvider = CKM::KeyProvider(rb_test, PASSWORD));
+	BOOST_REQUIRE_NO_THROW(rb_DEK1 = keyProvider.generateDEK(SMACK_LABEL_1));
+	BOOST_REQUIRE_NO_THROW(keyProvider.getPureDEK(rb_DEK1));
 }
 
 BOOST_AUTO_TEST_SUITE_END()
diff --git a/tests/test_base64.cpp b/tests/test_base64.cpp
index 2f030aee..df1a2414 100644
--- a/tests/test_base64.cpp
+++ b/tests/test_base64.cpp
@@ -33,12 +33,12 @@ using CKM::RawBuffer;
 namespace {
 
 constexpr unsigned char RAW_DATA[] =  {
-    0xf8, 0x87, 0x0a, 0xc5, 0xd3, 0x6d, 0x44, 0x49, 0x03, 0x9f, 0xbd, 0x1e, 0xa8, 0x2f, 0xf6, 0xc3,
-    0xdf, 0x3b, 0x02, 0x13, 0x58, 0x1b, 0x12, 0x30, 0x1c, 0xd7, 0xad, 0xa5, 0x1f, 0x5d, 0x01, 0x33
+	0xf8, 0x87, 0x0a, 0xc5, 0xd3, 0x6d, 0x44, 0x49, 0x03, 0x9f, 0xbd, 0x1e, 0xa8, 0x2f, 0xf6, 0xc3,
+	0xdf, 0x3b, 0x02, 0x13, 0x58, 0x1b, 0x12, 0x30, 0x1c, 0xd7, 0xad, 0xa5, 0x1f, 0x5d, 0x01, 0x33
 };
 
 const std::vector<unsigned char>
-    RAW_DATA_VEC(RAW_DATA, RAW_DATA + sizeof(RAW_DATA) / sizeof(unsigned char));
+RAW_DATA_VEC(RAW_DATA, RAW_DATA + sizeof(RAW_DATA) / sizeof(unsigned char));
 
 const RawBuffer rawbuf(RAW_DATA_VEC.begin(), RAW_DATA_VEC.end());
 
@@ -48,64 +48,69 @@ BOOST_AUTO_TEST_SUITE(BASE64_TEST)
 
 BOOST_AUTO_TEST_CASE(ENCODE_DECODE_POSITIVE)
 {
-    /* try encode */
-    Base64Encoder encoder;
-    BOOST_REQUIRE_NO_THROW(encoder.append(rawbuf));
-    BOOST_REQUIRE_NO_THROW(encoder.finalize());
-
-    RawBuffer encdata;
-    BOOST_REQUIRE_NO_THROW(encdata = encoder.get());
-    BOOST_REQUIRE_NO_THROW(encoder.reset());
-
-    /* try decode */
-    Base64Decoder decoder;
-    BOOST_REQUIRE_NO_THROW(decoder.append(encdata));
-    BOOST_REQUIRE_NO_THROW(decoder.finalize());
-
-    RawBuffer decdata;
-    BOOST_REQUIRE_NO_THROW(decdata = decoder.get());
-    BOOST_REQUIRE_NO_THROW(decoder.reset());
-    
-    /* compare with orig data */
-    BOOST_REQUIRE_MESSAGE(
-        rawbuf.size() == decdata.size() && memcmp(rawbuf.data(), decdata.data(), rawbuf.size()) == 0,
-        "Original data and encoded-decoded data is different!");
+	/* try encode */
+	Base64Encoder encoder;
+	BOOST_REQUIRE_NO_THROW(encoder.append(rawbuf));
+	BOOST_REQUIRE_NO_THROW(encoder.finalize());
+
+	RawBuffer encdata;
+	BOOST_REQUIRE_NO_THROW(encdata = encoder.get());
+	BOOST_REQUIRE_NO_THROW(encoder.reset());
+
+	/* try decode */
+	Base64Decoder decoder;
+	BOOST_REQUIRE_NO_THROW(decoder.append(encdata));
+	BOOST_REQUIRE_NO_THROW(decoder.finalize());
+
+	RawBuffer decdata;
+	BOOST_REQUIRE_NO_THROW(decdata = decoder.get());
+	BOOST_REQUIRE_NO_THROW(decoder.reset());
+
+	/* compare with orig data */
+	BOOST_REQUIRE_MESSAGE(
+		rawbuf.size() == decdata.size() &&
+		memcmp(rawbuf.data(), decdata.data(), rawbuf.size()) == 0,
+		"Original data and encoded-decoded data is different!");
 }
 
 BOOST_AUTO_TEST_CASE(THROW_SOMETHING)
 {
-    /* encode data */
-    Base64Encoder encoder;
-    BOOST_REQUIRE_THROW(encoder.get(), Base64Encoder::Exception::NotFinalized);
+	/* encode data */
+	Base64Encoder encoder;
+	BOOST_REQUIRE_THROW(encoder.get(), Base64Encoder::Exception::NotFinalized);
 
-    BOOST_REQUIRE_NO_THROW(encoder.append(rawbuf));
-    BOOST_REQUIRE_NO_THROW(encoder.finalize());
+	BOOST_REQUIRE_NO_THROW(encoder.append(rawbuf));
+	BOOST_REQUIRE_NO_THROW(encoder.finalize());
 
-    BOOST_REQUIRE_THROW(encoder.append(rawbuf), Base64Encoder::Exception::AlreadyFinalized);
-    BOOST_REQUIRE_THROW(encoder.finalize(), Base64Encoder::Exception::AlreadyFinalized);
+	BOOST_REQUIRE_THROW(encoder.append(rawbuf),
+						Base64Encoder::Exception::AlreadyFinalized);
+	BOOST_REQUIRE_THROW(encoder.finalize(),
+						Base64Encoder::Exception::AlreadyFinalized);
 
-    RawBuffer encdata;
-    BOOST_REQUIRE_NO_THROW(encdata = encoder.get());
+	RawBuffer encdata;
+	BOOST_REQUIRE_NO_THROW(encdata = encoder.get());
 
-    /* decode data */
-    Base64Decoder decoder;
-    BOOST_REQUIRE_THROW(decoder.get(), Base64Decoder::Exception::NotFinalized);
+	/* decode data */
+	Base64Decoder decoder;
+	BOOST_REQUIRE_THROW(decoder.get(), Base64Decoder::Exception::NotFinalized);
 
-    BOOST_REQUIRE_NO_THROW(decoder.append(encdata));
-    BOOST_REQUIRE_NO_THROW(decoder.finalize());
+	BOOST_REQUIRE_NO_THROW(decoder.append(encdata));
+	BOOST_REQUIRE_NO_THROW(decoder.finalize());
 
-    BOOST_REQUIRE_THROW(decoder.append(encdata), Base64Decoder::Exception::AlreadyFinalized);
-    BOOST_REQUIRE_THROW(decoder.finalize(), Base64Decoder::Exception::AlreadyFinalized);
+	BOOST_REQUIRE_THROW(decoder.append(encdata),
+						Base64Decoder::Exception::AlreadyFinalized);
+	BOOST_REQUIRE_THROW(decoder.finalize(),
+						Base64Decoder::Exception::AlreadyFinalized);
 
-    RawBuffer decdata;
-    BOOST_REQUIRE_NO_THROW(decdata = decoder.get());
+	RawBuffer decdata;
+	BOOST_REQUIRE_NO_THROW(decdata = decoder.get());
 }
 
 BOOST_AUTO_TEST_CASE(ILLEGAL_DATA)
 {
-    Base64Decoder decoder;
-    BOOST_REQUIRE_NO_THROW(decoder.append(rawbuf));
-    BOOST_REQUIRE(!decoder.finalize());
+	Base64Decoder decoder;
+	BOOST_REQUIRE_NO_THROW(decoder.append(rawbuf));
+	BOOST_REQUIRE(!decoder.finalize());
 }
 
 BOOST_AUTO_TEST_SUITE_END()
diff --git a/tests/test_comm-manager.cpp b/tests/test_comm-manager.cpp
index facd20b9..b06a3acd 100644
--- a/tests/test_comm-manager.cpp
+++ b/tests/test_comm-manager.cpp
@@ -28,155 +28,182 @@
 
 namespace {
 struct MessageA {
-    MessageA(int ai) : i(ai) {}
-    int i;
+	MessageA(int ai) : i(ai) {}
+	int i;
 };
 
 struct MessageB {
-    MessageB(char ac) : c(ac) {}
-    char c;
+	MessageB(char ac) : c(ac) {}
+	char c;
 };
 
 struct MessageC {
-    MessageC(const std::string& astr) : str(astr) {}
-    std::string str;
+	MessageC(const std::string &astr) : str(astr) {}
+	std::string str;
 };
 
 struct Listener {
-    Listener() : i(0) {}
+	Listener() : i(0) {}
 
-    void Handle(const MessageA& msg) {
-        i = msg.i;
-    }
+	void Handle(const MessageA &msg)
+	{
+		i = msg.i;
+	}
 
-    void Handle(const MessageC& msg) {
-        str = msg.str;
-    }
+	void Handle(const MessageC &msg)
+	{
+		str = msg.str;
+	}
 
-    int i;
-    std::string str;
+	int i;
+	std::string str;
 };
 
 } // namespace anonymous
 
 BOOST_AUTO_TEST_SUITE(MESSAGE_MANAGER_TEST)
 
-BOOST_AUTO_TEST_CASE(TMM_0010_NoListener) {
-    CKM::CommunicationManager<MessageA> mgr;
-    BOOST_REQUIRE_MESSAGE(0 == mgr.SendMessage(MessageA(22)), "There should be no listener.");
+BOOST_AUTO_TEST_CASE(TMM_0010_NoListener)
+{
+	CKM::CommunicationManager<MessageA> mgr;
+	BOOST_REQUIRE_MESSAGE(0 == mgr.SendMessage(MessageA(22)),
+						  "There should be no listener.");
 }
 
-BOOST_AUTO_TEST_CASE(TMM_0020_Basic) {
-    CKM::CommunicationManager<MessageA> mgr;
-    int received = 0;
-    mgr.Register<MessageA>([&](const MessageA& msg){ received = msg.i; });
-    BOOST_REQUIRE_MESSAGE(1 == mgr.SendMessage(MessageA(4)), "No listener found");
-    BOOST_REQUIRE_MESSAGE(received != 0, "Message not received");
-    BOOST_REQUIRE_MESSAGE(received == 4, "Wrong message received i=" << received);
+BOOST_AUTO_TEST_CASE(TMM_0020_Basic)
+{
+	CKM::CommunicationManager<MessageA> mgr;
+	int received = 0;
+	mgr.Register<MessageA>([&](const MessageA & msg) {
+		received = msg.i;
+	});
+	BOOST_REQUIRE_MESSAGE(1 == mgr.SendMessage(MessageA(4)), "No listener found");
+	BOOST_REQUIRE_MESSAGE(received != 0, "Message not received");
+	BOOST_REQUIRE_MESSAGE(received == 4, "Wrong message received i=" << received);
 }
 
-BOOST_AUTO_TEST_CASE(TMM_0030_MultipleMessages) {
-    CKM::CommunicationManager<MessageA, MessageB> mgr;
-    int reci = 0;
-    char recc = 0;
-    mgr.Register<MessageA>([&](const MessageA& msg){ reci = msg.i; });
-    mgr.Register<MessageB>([&](const MessageB& msg){ recc = msg.c; });
-    BOOST_REQUIRE_MESSAGE(1 == mgr.SendMessage(MessageB('c')), "No listener found");
-    BOOST_REQUIRE_MESSAGE(reci == 0, "Unexpected message received");
-    BOOST_REQUIRE_MESSAGE(recc != 0, "Message not received");
-    BOOST_REQUIRE_MESSAGE(recc == 'c', "Wrong message received c=" << recc);
-
-    BOOST_REQUIRE_MESSAGE(1 == mgr.SendMessage(MessageA(42)), "No listener found");
-    BOOST_REQUIRE_MESSAGE(reci!= 0, "Message not received");
-    BOOST_REQUIRE_MESSAGE(reci == 42, "Wrong message received i=" << reci);
-    BOOST_REQUIRE_MESSAGE(recc == 'c', "Previous message overwritten c=" << recc);
+BOOST_AUTO_TEST_CASE(TMM_0030_MultipleMessages)
+{
+	CKM::CommunicationManager<MessageA, MessageB> mgr;
+	int reci = 0;
+	char recc = 0;
+	mgr.Register<MessageA>([&](const MessageA & msg) {
+		reci = msg.i;
+	});
+	mgr.Register<MessageB>([&](const MessageB & msg) {
+		recc = msg.c;
+	});
+	BOOST_REQUIRE_MESSAGE(1 == mgr.SendMessage(MessageB('c')), "No listener found");
+	BOOST_REQUIRE_MESSAGE(reci == 0, "Unexpected message received");
+	BOOST_REQUIRE_MESSAGE(recc != 0, "Message not received");
+	BOOST_REQUIRE_MESSAGE(recc == 'c', "Wrong message received c=" << recc);
+
+	BOOST_REQUIRE_MESSAGE(1 == mgr.SendMessage(MessageA(42)), "No listener found");
+	BOOST_REQUIRE_MESSAGE(reci != 0, "Message not received");
+	BOOST_REQUIRE_MESSAGE(reci == 42, "Wrong message received i=" << reci);
+	BOOST_REQUIRE_MESSAGE(recc == 'c', "Previous message overwritten c=" << recc);
 }
 
-BOOST_AUTO_TEST_CASE(TMM_0040_Listener) {
-    CKM::CommunicationManager<MessageA, MessageB, MessageC> mgr;
-    Listener l;
-    mgr.Register<MessageC>([&](const MessageC& msg){ l.Handle(msg); });
-    mgr.Register<MessageA>([&](const MessageA& msg){ l.Handle(msg); });
-
-    BOOST_REQUIRE_MESSAGE(1 == mgr.SendMessage(MessageC("lorem ipsum")), "No listener found");
-    BOOST_REQUIRE_MESSAGE(l.i == 0, "Unexpected message received");
-    BOOST_REQUIRE_MESSAGE(!l.str.empty(), "Message not received");
-    BOOST_REQUIRE_MESSAGE(l.str == "lorem ipsum", "Wrong message received c=" << l.str);
-
-    BOOST_REQUIRE_MESSAGE(1 == mgr.SendMessage(MessageA(3)), "No listener found");
-    BOOST_REQUIRE_MESSAGE(l.i!= 0, "Message not received");
-    BOOST_REQUIRE_MESSAGE(l.i == 3, "Wrong message received i=" << l.i);
-    BOOST_REQUIRE_MESSAGE(l.str == "lorem ipsum", "Previous message overwritten str=" << l.str);
+BOOST_AUTO_TEST_CASE(TMM_0040_Listener)
+{
+	CKM::CommunicationManager<MessageA, MessageB, MessageC> mgr;
+	Listener l;
+	mgr.Register<MessageC>([&](const MessageC & msg) {
+		l.Handle(msg);
+	});
+	mgr.Register<MessageA>([&](const MessageA & msg) {
+		l.Handle(msg);
+	});
+
+	BOOST_REQUIRE_MESSAGE(1 == mgr.SendMessage(MessageC("lorem ipsum")),
+						  "No listener found");
+	BOOST_REQUIRE_MESSAGE(l.i == 0, "Unexpected message received");
+	BOOST_REQUIRE_MESSAGE(!l.str.empty(), "Message not received");
+	BOOST_REQUIRE_MESSAGE(l.str == "lorem ipsum",
+						  "Wrong message received c=" << l.str);
+
+	BOOST_REQUIRE_MESSAGE(1 == mgr.SendMessage(MessageA(3)), "No listener found");
+	BOOST_REQUIRE_MESSAGE(l.i != 0, "Message not received");
+	BOOST_REQUIRE_MESSAGE(l.i == 3, "Wrong message received i=" << l.i);
+	BOOST_REQUIRE_MESSAGE(l.str == "lorem ipsum",
+						  "Previous message overwritten str=" << l.str);
 }
 
-BOOST_AUTO_TEST_CASE(TMM_0050_2Listeners) {
-    CKM::CommunicationManager<MessageA> mgr;
-    bool called[2];
-    called[0] = false;
-    called[1] = false;
-    mgr.Register<MessageA>([&](const MessageA& msg){
-        BOOST_REQUIRE_MESSAGE(msg.i == 5, "Unexpected message received i=" << msg.i);
-        called[0] = true;
-    });
-    mgr.Register<MessageA>([&](const MessageA& msg){
-        BOOST_REQUIRE_MESSAGE(msg.i == 5, "Unexpected message received i=" << msg.i);
-        called[1] = true;
-    });
-
-    BOOST_REQUIRE_MESSAGE(2 == mgr.SendMessage(MessageA(5)), "No listener found");
-    BOOST_REQUIRE_MESSAGE(called[0], "First listener not called");
-    BOOST_REQUIRE_MESSAGE(called[1], "Second listener not called");
+BOOST_AUTO_TEST_CASE(TMM_0050_2Listeners)
+{
+	CKM::CommunicationManager<MessageA> mgr;
+	bool called[2];
+	called[0] = false;
+	called[1] = false;
+	mgr.Register<MessageA>([&](const MessageA & msg) {
+		BOOST_REQUIRE_MESSAGE(msg.i == 5, "Unexpected message received i=" << msg.i);
+		called[0] = true;
+	});
+	mgr.Register<MessageA>([&](const MessageA & msg) {
+		BOOST_REQUIRE_MESSAGE(msg.i == 5, "Unexpected message received i=" << msg.i);
+		called[1] = true;
+	});
+
+	BOOST_REQUIRE_MESSAGE(2 == mgr.SendMessage(MessageA(5)), "No listener found");
+	BOOST_REQUIRE_MESSAGE(called[0], "First listener not called");
+	BOOST_REQUIRE_MESSAGE(called[1], "Second listener not called");
 }
 
-BOOST_AUTO_TEST_CASE(TMM_0060_Stress) {
-    CKM::CommunicationManager<MessageA, MessageB, MessageC> mgr;
-
-    std::default_random_engine generator(std::chrono::system_clock::now().time_since_epoch().count());
-    std::uniform_int_distribution<size_t> message_dist(0,2);
-    std::uniform_int_distribution<size_t> count_dist(1,10);
-
-    size_t a = 0;
-    size_t b = 0;
-    size_t c = 0;
-    mgr.Register<MessageA>([&](const MessageA& msg) {
-        BOOST_REQUIRE_MESSAGE(msg.i == 42, "Wrong message: " << msg.i);
-        a++;
-    });
-    mgr.Register<MessageB>([&](const MessageB& msg) {
-        BOOST_REQUIRE_MESSAGE(msg.c == 'c', "Wrong message: " << msg.c);
-        b++;
-    });
-    mgr.Register<MessageC>([&](const MessageC& msg) {
-        BOOST_REQUIRE_MESSAGE(msg.str == "lorem ipsum", "Wrong message: " << msg.str);
-        c++;
-    });
-
-    for (size_t i=0; i < 1000; i++)
-    {
-        size_t cnt = count_dist(generator);
-        for (size_t s = 0; s < cnt; s++) {
-            switch(message_dist(generator))
-            {
-            case 0:
-                BOOST_REQUIRE_MESSAGE(1 == mgr.SendMessage(MessageA(42)), "No listener found");
-                a--;
-                break;
-            case 1:
-                BOOST_REQUIRE_MESSAGE(1 == mgr.SendMessage(MessageB('c')), "No listener found");
-                b--;
-                break;
-            case 2:
-                BOOST_REQUIRE_MESSAGE(1 == mgr.SendMessage(MessageC("lorem ipsum")), "No listener found");
-                c--;
-                break;
-            default:
-                BOOST_FAIL("Unexpected message type");
-            }
-        }
-    }
-    BOOST_REQUIRE_MESSAGE(a == 0, "Unexpected number of MessageA: " << a);
-    BOOST_REQUIRE_MESSAGE(b == 0, "Unexpected number of MessageB: " << b);
-    BOOST_REQUIRE_MESSAGE(c == 0, "Unexpected number of MessageC: " << c);
+BOOST_AUTO_TEST_CASE(TMM_0060_Stress)
+{
+	CKM::CommunicationManager<MessageA, MessageB, MessageC> mgr;
+
+	std::default_random_engine generator(
+		std::chrono::system_clock::now().time_since_epoch().count());
+	std::uniform_int_distribution<size_t> message_dist(0, 2);
+	std::uniform_int_distribution<size_t> count_dist(1, 10);
+
+	size_t a = 0;
+	size_t b = 0;
+	size_t c = 0;
+	mgr.Register<MessageA>([&](const MessageA & msg) {
+		BOOST_REQUIRE_MESSAGE(msg.i == 42, "Wrong message: " << msg.i);
+		a++;
+	});
+	mgr.Register<MessageB>([&](const MessageB & msg) {
+		BOOST_REQUIRE_MESSAGE(msg.c == 'c', "Wrong message: " << msg.c);
+		b++;
+	});
+	mgr.Register<MessageC>([&](const MessageC & msg) {
+		BOOST_REQUIRE_MESSAGE(msg.str == "lorem ipsum", "Wrong message: " << msg.str);
+		c++;
+	});
+
+	for (size_t i = 0; i < 1000; i++) {
+		size_t cnt = count_dist(generator);
+
+		for (size_t s = 0; s < cnt; s++) {
+			switch (message_dist(generator)) {
+			case 0:
+				BOOST_REQUIRE_MESSAGE(1 == mgr.SendMessage(MessageA(42)), "No listener found");
+				a--;
+				break;
+
+			case 1:
+				BOOST_REQUIRE_MESSAGE(1 == mgr.SendMessage(MessageB('c')), "No listener found");
+				b--;
+				break;
+
+			case 2:
+				BOOST_REQUIRE_MESSAGE(1 == mgr.SendMessage(MessageC("lorem ipsum")),
+									  "No listener found");
+				c--;
+				break;
+
+			default:
+				BOOST_FAIL("Unexpected message type");
+			}
+		}
+	}
+
+	BOOST_REQUIRE_MESSAGE(a == 0, "Unexpected number of MessageA: " << a);
+	BOOST_REQUIRE_MESSAGE(b == 0, "Unexpected number of MessageB: " << b);
+	BOOST_REQUIRE_MESSAGE(c == 0, "Unexpected number of MessageC: " << c);
 }
 
 BOOST_AUTO_TEST_SUITE_END()
diff --git a/tests/test_common.cpp b/tests/test_common.cpp
index b96e9138..ec2b2425 100644
--- a/tests/test_common.cpp
+++ b/tests/test_common.cpp
@@ -25,33 +25,37 @@
 
 using namespace CKM;
 
-RawBuffer createDefaultPass() {
-    return createPass(0, RAW_PASS_SIZE);
+RawBuffer createDefaultPass()
+{
+	return createPass(0, RAW_PASS_SIZE);
 }
 
-RawBuffer createPass(std::size_t from, std::size_t to) {
-    RawBuffer raw;
+RawBuffer createPass(std::size_t from, std::size_t to)
+{
+	RawBuffer raw;
 
-    for (std::size_t i = from; i < to; i++)
-        raw.push_back(static_cast<unsigned char>(i));
+	for (std::size_t i = from; i < to; i++)
+		raw.push_back(static_cast<unsigned char>(i));
 
-    return raw;
+	return raw;
 }
 
-RawBuffer createBigBlob(std::size_t size) {
-    return createPass(0, size);
+RawBuffer createBigBlob(std::size_t size)
+{
+	return createPass(0, size);
 }
 
 //raw to hex string conversion from SqlConnection
-std::string rawToHexString(const RawBuffer &raw) {
-    std::string dump;
-
-    for (auto &e : raw) {
-        char buf[3];
-        snprintf(buf, sizeof(buf), "%02x", (e & 0xff));
-        dump.push_back(buf[0]);
-        dump.push_back(buf[1]);
-    }
-
-    return dump;
+std::string rawToHexString(const RawBuffer &raw)
+{
+	std::string dump;
+
+	for (auto &e : raw) {
+		char buf[3];
+		snprintf(buf, sizeof(buf), "%02x", (e & 0xff));
+		dump.push_back(buf[0]);
+		dump.push_back(buf[1]);
+	}
+
+	return dump;
 }
diff --git a/tests/test_common.h b/tests/test_common.h
index b9b70bfc..07aae64d 100644
--- a/tests/test_common.h
+++ b/tests/test_common.h
@@ -35,7 +35,7 @@ CKM::RawBuffer createBigBlob(std::size_t size);
 
 const CKM::RawBuffer defaultPass = createDefaultPass();
 const std::string pattern =
-    "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f";
+	"000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f";
 
 const std::size_t RAW_PASS_SIZE = 32;
 const std::size_t HEX_PASS_SIZE = RAW_PASS_SIZE * 2;
diff --git a/tests/test_data-type.cpp b/tests/test_data-type.cpp
index 215f552b..e2ba333c 100644
--- a/tests/test_data-type.cpp
+++ b/tests/test_data-type.cpp
@@ -32,130 +32,136 @@ BOOST_AUTO_TEST_SUITE(DATA_TYPE_TEST)
 
 BOOST_AUTO_TEST_CASE(CONSTRUCTOR)
 {
-    BOOST_REQUIRE_THROW(DataType(static_cast<DataType::Type>(999)), DataType::Exception::OutOfRange);
-    BOOST_REQUIRE_THROW(DataType(static_cast<KeyType>(999)), DataType::Exception::OutOfRange);
+	BOOST_REQUIRE_THROW(DataType(static_cast<DataType::Type>(999)),
+						DataType::Exception::OutOfRange);
+	BOOST_REQUIRE_THROW(DataType(static_cast<KeyType>(999)),
+						DataType::Exception::OutOfRange);
 
-    std::vector<DataType> types;
+	std::vector<DataType> types;
 
-    types.emplace_back(AlgoType::AES_CTR);
-    types.emplace_back(AlgoType::AES_CBC);
-    types.emplace_back(AlgoType::AES_GCM);
-    types.emplace_back(AlgoType::AES_CFB);
-    types.emplace_back(AlgoType::AES_GEN);
-    for (auto &type : types)
-        BOOST_REQUIRE(type == DataType(DataType::KEY_AES));
+	types.emplace_back(AlgoType::AES_CTR);
+	types.emplace_back(AlgoType::AES_CBC);
+	types.emplace_back(AlgoType::AES_GCM);
+	types.emplace_back(AlgoType::AES_CFB);
+	types.emplace_back(AlgoType::AES_GEN);
 
-    types.clear();
+	for (auto &type : types)
+		BOOST_REQUIRE(type == DataType(DataType::KEY_AES));
 
-    types.emplace_back(AlgoType::RSA_SV);
-    types.emplace_back(AlgoType::RSA_OAEP);
-    types.emplace_back(AlgoType::RSA_GEN);
-    for (auto &type : types)
-        BOOST_REQUIRE(type == DataType(DataType::KEY_RSA_PUBLIC));
+	types.clear();
 
-    types.clear();
+	types.emplace_back(AlgoType::RSA_SV);
+	types.emplace_back(AlgoType::RSA_OAEP);
+	types.emplace_back(AlgoType::RSA_GEN);
 
-    types.emplace_back(AlgoType::DSA_SV);
-    types.emplace_back(AlgoType::DSA_GEN);
-    for (auto &type : types)
-        BOOST_REQUIRE(type == DataType(DataType::KEY_DSA_PUBLIC));
+	for (auto &type : types)
+		BOOST_REQUIRE(type == DataType(DataType::KEY_RSA_PUBLIC));
 
-    types.clear();
+	types.clear();
 
-    types.emplace_back(AlgoType::ECDSA_SV);
-    types.emplace_back(AlgoType::ECDSA_GEN);
-    for (auto &type : types)
-        BOOST_REQUIRE(type == DataType(DataType::KEY_ECDSA_PUBLIC));
+	types.emplace_back(AlgoType::DSA_SV);
+	types.emplace_back(AlgoType::DSA_GEN);
 
-    types.clear();
+	for (auto &type : types)
+		BOOST_REQUIRE(type == DataType(DataType::KEY_DSA_PUBLIC));
 
-    BOOST_REQUIRE_THROW(
-        DataType(static_cast<AlgoType>(-1)),
-        DataType::Exception::OutOfRange);
+	types.clear();
+
+	types.emplace_back(AlgoType::ECDSA_SV);
+	types.emplace_back(AlgoType::ECDSA_GEN);
+
+	for (auto &type : types)
+		BOOST_REQUIRE(type == DataType(DataType::KEY_ECDSA_PUBLIC));
+
+	types.clear();
+
+	BOOST_REQUIRE_THROW(
+		DataType(static_cast<AlgoType>(-1)),
+		DataType::Exception::OutOfRange);
 }
 
 BOOST_AUTO_TEST_CASE(KEY_TYPE_CASTING)
 {
-    std::vector<std::pair<DataType, KeyType>> pairs;
+	std::vector<std::pair<DataType, KeyType>> pairs;
 
-    pairs.emplace_back(DataType::KEY_RSA_PUBLIC, KeyType::KEY_RSA_PUBLIC);
-    pairs.emplace_back(DataType::KEY_RSA_PRIVATE, KeyType::KEY_RSA_PRIVATE);
+	pairs.emplace_back(DataType::KEY_RSA_PUBLIC, KeyType::KEY_RSA_PUBLIC);
+	pairs.emplace_back(DataType::KEY_RSA_PRIVATE, KeyType::KEY_RSA_PRIVATE);
 
-    pairs.emplace_back(DataType::KEY_DSA_PUBLIC, KeyType::KEY_DSA_PUBLIC);
-    pairs.emplace_back(DataType::KEY_DSA_PRIVATE, KeyType::KEY_DSA_PRIVATE);
+	pairs.emplace_back(DataType::KEY_DSA_PUBLIC, KeyType::KEY_DSA_PUBLIC);
+	pairs.emplace_back(DataType::KEY_DSA_PRIVATE, KeyType::KEY_DSA_PRIVATE);
 
-    pairs.emplace_back(DataType::KEY_ECDSA_PUBLIC, KeyType::KEY_ECDSA_PUBLIC);
-    pairs.emplace_back(DataType::KEY_ECDSA_PRIVATE, KeyType::KEY_ECDSA_PRIVATE);
+	pairs.emplace_back(DataType::KEY_ECDSA_PUBLIC, KeyType::KEY_ECDSA_PUBLIC);
+	pairs.emplace_back(DataType::KEY_ECDSA_PRIVATE, KeyType::KEY_ECDSA_PRIVATE);
 
-    pairs.emplace_back(DataType::KEY_AES, KeyType::KEY_AES);
+	pairs.emplace_back(DataType::KEY_AES, KeyType::KEY_AES);
 
-    for (auto &p : pairs)
-        BOOST_REQUIRE(p.second == DataType(static_cast<KeyType>(p.first)));
+	for (auto &p : pairs)
+		BOOST_REQUIRE(p.second == DataType(static_cast<KeyType>(p.first)));
 }
 
 BOOST_AUTO_TEST_CASE(UNARY_OPERATIONS)
 {
-    BOOST_REQUIRE(DataType(DataType::KEY_AES).isSKey());
-    BOOST_REQUIRE(!DataType(DataType::KEY_RSA_PUBLIC).isSKey());
-
-    BOOST_REQUIRE(DataType(DataType::DB_CHAIN_FIRST).isChainCert());
-    BOOST_REQUIRE(DataType(DataType::DB_CHAIN_LAST).isChainCert());
-    BOOST_REQUIRE(!DataType(DataType::KEY_AES).isChainCert());
-
-    BOOST_REQUIRE(DataType(DataType::KEY_RSA_PUBLIC).isKeyPublic());
-    BOOST_REQUIRE(DataType(DataType::KEY_DSA_PUBLIC).isKeyPublic());
-    BOOST_REQUIRE(DataType(DataType::KEY_ECDSA_PUBLIC).isKeyPublic());
-    BOOST_REQUIRE(!DataType(DataType::KEY_RSA_PRIVATE).isKeyPublic());
-    BOOST_REQUIRE(!DataType(DataType::KEY_DSA_PRIVATE).isKeyPublic());
-    BOOST_REQUIRE(!DataType(DataType::KEY_ECDSA_PRIVATE).isKeyPublic());
-    BOOST_REQUIRE(!DataType(DataType::KEY_AES).isKeyPublic());
-    BOOST_REQUIRE(!DataType(DataType::DB_CHAIN_LAST).isKeyPublic());
-
-    BOOST_REQUIRE(DataType(DataType::KEY_RSA_PRIVATE).isKeyPrivate());
-    BOOST_REQUIRE(DataType(DataType::KEY_DSA_PRIVATE).isKeyPrivate());
-    BOOST_REQUIRE(DataType(DataType::KEY_ECDSA_PRIVATE).isKeyPrivate());
-    BOOST_REQUIRE(!DataType(DataType::KEY_RSA_PUBLIC).isKeyPrivate());
-    BOOST_REQUIRE(!DataType(DataType::KEY_DSA_PUBLIC).isKeyPrivate());
-    BOOST_REQUIRE(!DataType(DataType::KEY_ECDSA_PUBLIC).isKeyPrivate());
-    BOOST_REQUIRE(!DataType(DataType::KEY_AES).isKeyPrivate());
-    BOOST_REQUIRE(!DataType(DataType::DB_CHAIN_FIRST).isKeyPrivate());
-
-    BOOST_REQUIRE(DataType(DataType::CERTIFICATE).isCertificate());
-    BOOST_REQUIRE(!DataType(DataType::KEY_AES).isCertificate());
-    BOOST_REQUIRE(!DataType().isCertificate());
-    BOOST_REQUIRE(!DataType(DataType::DB_CHAIN_FIRST).isCertificate());
-
-    BOOST_REQUIRE(DataType().isBinaryData());
-    BOOST_REQUIRE(DataType(DataType::BINARY_DATA).isBinaryData());
-    BOOST_REQUIRE(!DataType(DataType::KEY_AES).isBinaryData());
-    BOOST_REQUIRE(!DataType(DataType::KEY_RSA_PUBLIC).isBinaryData());
-    BOOST_REQUIRE(!DataType(DataType::DB_CHAIN_LAST).isBinaryData());
-
-    BOOST_REQUIRE(DataType(DataType::DB_KEY_FIRST).isKey());
-    BOOST_REQUIRE(DataType(DataType::DB_KEY_LAST).isKey());
-    BOOST_REQUIRE(DataType(DataType::KEY_AES).isKey());
-    BOOST_REQUIRE(DataType(DataType::KEY_RSA_PUBLIC).isKey());
-    BOOST_REQUIRE(DataType(DataType::KEY_RSA_PRIVATE).isKey());
-    BOOST_REQUIRE(DataType(DataType::KEY_DSA_PUBLIC).isKey());
-    BOOST_REQUIRE(DataType(DataType::KEY_DSA_PRIVATE).isKey());
-    BOOST_REQUIRE(DataType(DataType::KEY_ECDSA_PUBLIC).isKey());
-    BOOST_REQUIRE(DataType(DataType::KEY_ECDSA_PRIVATE).isKey());
-    BOOST_REQUIRE(!DataType(DataType::DB_CHAIN_FIRST).isKey());
-    BOOST_REQUIRE(!DataType(DataType::CERTIFICATE).isKey());
-    BOOST_REQUIRE(!DataType().isKey());
+	BOOST_REQUIRE(DataType(DataType::KEY_AES).isSKey());
+	BOOST_REQUIRE(!DataType(DataType::KEY_RSA_PUBLIC).isSKey());
+
+	BOOST_REQUIRE(DataType(DataType::DB_CHAIN_FIRST).isChainCert());
+	BOOST_REQUIRE(DataType(DataType::DB_CHAIN_LAST).isChainCert());
+	BOOST_REQUIRE(!DataType(DataType::KEY_AES).isChainCert());
+
+	BOOST_REQUIRE(DataType(DataType::KEY_RSA_PUBLIC).isKeyPublic());
+	BOOST_REQUIRE(DataType(DataType::KEY_DSA_PUBLIC).isKeyPublic());
+	BOOST_REQUIRE(DataType(DataType::KEY_ECDSA_PUBLIC).isKeyPublic());
+	BOOST_REQUIRE(!DataType(DataType::KEY_RSA_PRIVATE).isKeyPublic());
+	BOOST_REQUIRE(!DataType(DataType::KEY_DSA_PRIVATE).isKeyPublic());
+	BOOST_REQUIRE(!DataType(DataType::KEY_ECDSA_PRIVATE).isKeyPublic());
+	BOOST_REQUIRE(!DataType(DataType::KEY_AES).isKeyPublic());
+	BOOST_REQUIRE(!DataType(DataType::DB_CHAIN_LAST).isKeyPublic());
+
+	BOOST_REQUIRE(DataType(DataType::KEY_RSA_PRIVATE).isKeyPrivate());
+	BOOST_REQUIRE(DataType(DataType::KEY_DSA_PRIVATE).isKeyPrivate());
+	BOOST_REQUIRE(DataType(DataType::KEY_ECDSA_PRIVATE).isKeyPrivate());
+	BOOST_REQUIRE(!DataType(DataType::KEY_RSA_PUBLIC).isKeyPrivate());
+	BOOST_REQUIRE(!DataType(DataType::KEY_DSA_PUBLIC).isKeyPrivate());
+	BOOST_REQUIRE(!DataType(DataType::KEY_ECDSA_PUBLIC).isKeyPrivate());
+	BOOST_REQUIRE(!DataType(DataType::KEY_AES).isKeyPrivate());
+	BOOST_REQUIRE(!DataType(DataType::DB_CHAIN_FIRST).isKeyPrivate());
+
+	BOOST_REQUIRE(DataType(DataType::CERTIFICATE).isCertificate());
+	BOOST_REQUIRE(!DataType(DataType::KEY_AES).isCertificate());
+	BOOST_REQUIRE(!DataType().isCertificate());
+	BOOST_REQUIRE(!DataType(DataType::DB_CHAIN_FIRST).isCertificate());
+
+	BOOST_REQUIRE(DataType().isBinaryData());
+	BOOST_REQUIRE(DataType(DataType::BINARY_DATA).isBinaryData());
+	BOOST_REQUIRE(!DataType(DataType::KEY_AES).isBinaryData());
+	BOOST_REQUIRE(!DataType(DataType::KEY_RSA_PUBLIC).isBinaryData());
+	BOOST_REQUIRE(!DataType(DataType::DB_CHAIN_LAST).isBinaryData());
+
+	BOOST_REQUIRE(DataType(DataType::DB_KEY_FIRST).isKey());
+	BOOST_REQUIRE(DataType(DataType::DB_KEY_LAST).isKey());
+	BOOST_REQUIRE(DataType(DataType::KEY_AES).isKey());
+	BOOST_REQUIRE(DataType(DataType::KEY_RSA_PUBLIC).isKey());
+	BOOST_REQUIRE(DataType(DataType::KEY_RSA_PRIVATE).isKey());
+	BOOST_REQUIRE(DataType(DataType::KEY_DSA_PUBLIC).isKey());
+	BOOST_REQUIRE(DataType(DataType::KEY_DSA_PRIVATE).isKey());
+	BOOST_REQUIRE(DataType(DataType::KEY_ECDSA_PUBLIC).isKey());
+	BOOST_REQUIRE(DataType(DataType::KEY_ECDSA_PRIVATE).isKey());
+	BOOST_REQUIRE(!DataType(DataType::DB_CHAIN_FIRST).isKey());
+	BOOST_REQUIRE(!DataType(DataType::CERTIFICATE).isKey());
+	BOOST_REQUIRE(!DataType().isKey());
 }
 
 BOOST_AUTO_TEST_CASE(GET_CHAIN_TYPE)
 {
-    DataType type;
+	DataType type;
 
-    BOOST_REQUIRE(type.getChainDatatype(0) == DataType(DataType::DB_CHAIN_FIRST));
-    BOOST_REQUIRE(type.getChainDatatype(5) == DataType(DataType::CHAIN_CERT_5));
-    BOOST_REQUIRE(type.getChainDatatype(8) == DataType(DataType::CHAIN_CERT_8));
-    BOOST_REQUIRE(type.getChainDatatype(13) == DataType(DataType::CHAIN_CERT_13));
-    BOOST_REQUIRE(type.getChainDatatype(15) == DataType(DataType::DB_CHAIN_LAST));
+	BOOST_REQUIRE(type.getChainDatatype(0) == DataType(DataType::DB_CHAIN_FIRST));
+	BOOST_REQUIRE(type.getChainDatatype(5) == DataType(DataType::CHAIN_CERT_5));
+	BOOST_REQUIRE(type.getChainDatatype(8) == DataType(DataType::CHAIN_CERT_8));
+	BOOST_REQUIRE(type.getChainDatatype(13) == DataType(DataType::CHAIN_CERT_13));
+	BOOST_REQUIRE(type.getChainDatatype(15) == DataType(DataType::DB_CHAIN_LAST));
 
-    BOOST_REQUIRE_THROW(type.getChainDatatype(16), DataType::Exception::OutOfRange);
+	BOOST_REQUIRE_THROW(type.getChainDatatype(16), DataType::Exception::OutOfRange);
 }
 
 BOOST_AUTO_TEST_SUITE_END()
diff --git a/tests/test_db_crypto.cpp b/tests/test_db_crypto.cpp
index a598e4e8..e9f471bf 100644
--- a/tests/test_db_crypto.cpp
+++ b/tests/test_db_crypto.cpp
@@ -32,8 +32,7 @@
 
 using namespace CKM;
 
-namespace
-{
+namespace {
 const int restricted_local = 1;
 const int restricted_global = 0;
 
@@ -45,63 +44,69 @@ const unsigned int c_names_per_label = 15;
 } // namespace anonymous
 
 BOOST_FIXTURE_TEST_SUITE(DBCRYPTO_TEST, DBFixture)
-BOOST_AUTO_TEST_CASE(DBtestSimple) {
-    DB::Row rowPattern = create_default_row();
-    rowPattern.data = RawBuffer(32, 1);
-    rowPattern.dataSize = rowPattern.data.size();
-    rowPattern.tag = RawBuffer(AES_GCM_TAG_SIZE, 1);
+BOOST_AUTO_TEST_CASE(DBtestSimple)
+{
+	DB::Row rowPattern = create_default_row();
+	rowPattern.data = RawBuffer(32, 1);
+	rowPattern.dataSize = rowPattern.data.size();
+	rowPattern.tag = RawBuffer(AES_GCM_TAG_SIZE, 1);
 
-    check_DB_integrity(rowPattern);
+	check_DB_integrity(rowPattern);
 }
-BOOST_AUTO_TEST_CASE(DBtestBIG) {
-    DB::Row rowPattern = create_default_row();
-    rowPattern.data = createBigBlob(4096);
-    rowPattern.dataSize = rowPattern.data.size();
-    rowPattern.tag = RawBuffer(AES_GCM_TAG_SIZE, 1);
+BOOST_AUTO_TEST_CASE(DBtestBIG)
+{
+	DB::Row rowPattern = create_default_row();
+	rowPattern.data = createBigBlob(4096);
+	rowPattern.dataSize = rowPattern.data.size();
+	rowPattern.tag = RawBuffer(AES_GCM_TAG_SIZE, 1);
 
-    check_DB_integrity(rowPattern);
+	check_DB_integrity(rowPattern);
 }
-BOOST_AUTO_TEST_CASE(DBtestGlobal) {
-    DB::Row rowPattern = create_default_row();
-    rowPattern.data = RawBuffer(1024, 2);
-    rowPattern.dataSize = rowPattern.data.size();
-    rowPattern.tag = RawBuffer(AES_GCM_TAG_SIZE, 1);
+BOOST_AUTO_TEST_CASE(DBtestGlobal)
+{
+	DB::Row rowPattern = create_default_row();
+	rowPattern.data = RawBuffer(1024, 2);
+	rowPattern.dataSize = rowPattern.data.size();
+	rowPattern.tag = RawBuffer(AES_GCM_TAG_SIZE, 1);
 
-    BOOST_REQUIRE_NO_THROW(m_db.saveRow(rowPattern));
+	BOOST_REQUIRE_NO_THROW(m_db.saveRow(rowPattern));
 
-    DB::Row name_duplicate = rowPattern;
-    rowPattern.ownerLabel = rowPattern.ownerLabel + "1";
+	DB::Row name_duplicate = rowPattern;
+	rowPattern.ownerLabel = rowPattern.ownerLabel + "1";
 }
-BOOST_AUTO_TEST_CASE(DBtestTransaction) {
-    DB::Row rowPattern = create_default_row();
-    rowPattern.data = RawBuffer(100, 20);
-    rowPattern.dataSize = rowPattern.data.size();
-    rowPattern.tag = RawBuffer(AES_GCM_TAG_SIZE, 1);
-    DB::Crypto::Transaction transaction(&m_db);
-
-    BOOST_REQUIRE_NO_THROW(m_db.saveRow(rowPattern));
-    BOOST_REQUIRE_NO_THROW(transaction.rollback());
-
-    DB::Crypto::RowOptional row_optional;
-    BOOST_REQUIRE_NO_THROW(row_optional = m_db.getRow(m_default_name, m_default_label,
-                                                      DataType::BINARY_DATA));
-    BOOST_CHECK_MESSAGE(!row_optional, "Row still present after rollback");
+BOOST_AUTO_TEST_CASE(DBtestTransaction)
+{
+	DB::Row rowPattern = create_default_row();
+	rowPattern.data = RawBuffer(100, 20);
+	rowPattern.dataSize = rowPattern.data.size();
+	rowPattern.tag = RawBuffer(AES_GCM_TAG_SIZE, 1);
+	DB::Crypto::Transaction transaction(&m_db);
+
+	BOOST_REQUIRE_NO_THROW(m_db.saveRow(rowPattern));
+	BOOST_REQUIRE_NO_THROW(transaction.rollback());
+
+	DB::Crypto::RowOptional row_optional;
+	BOOST_REQUIRE_NO_THROW(row_optional = m_db.getRow(m_default_name,
+										  m_default_label,
+										  DataType::BINARY_DATA));
+	BOOST_CHECK_MESSAGE(!row_optional, "Row still present after rollback");
 }
 
-BOOST_AUTO_TEST_CASE(DBtestBackend) {
-    DB::Row rowPattern = create_default_row();
-    rowPattern.data = RawBuffer(32, 1);
-    rowPattern.dataSize = rowPattern.data.size();
-    rowPattern.tag = RawBuffer(AES_GCM_TAG_SIZE, 1);
+BOOST_AUTO_TEST_CASE(DBtestBackend)
+{
+	DB::Row rowPattern = create_default_row();
+	rowPattern.data = RawBuffer(32, 1);
+	rowPattern.dataSize = rowPattern.data.size();
+	rowPattern.tag = RawBuffer(AES_GCM_TAG_SIZE, 1);
 
-    rowPattern.backendId =  CryptoBackend::OpenSSL;
-    check_DB_integrity(rowPattern);
+	rowPattern.backendId =  CryptoBackend::OpenSSL;
+	check_DB_integrity(rowPattern);
 
-    rowPattern.backendId =  CryptoBackend::TrustZone;
-    check_DB_integrity(rowPattern);
+	rowPattern.backendId =  CryptoBackend::TrustZone;
+	check_DB_integrity(rowPattern);
 
-    rowPattern.backendId =  CryptoBackend::None;
-    check_DB_integrity(rowPattern);
+	rowPattern.backendId =  CryptoBackend::None;
+	check_DB_integrity(rowPattern);
 }
 
 BOOST_AUTO_TEST_SUITE_END()
@@ -112,247 +117,253 @@ BOOST_FIXTURE_TEST_SUITE(DBCRYPTO_PERF_TEST, DBFixture)
 
 BOOST_AUTO_TEST_CASE(DBperfAddNames)
 {
-    // actual test
-    performance_start("saveRow");
-    {
-        generate_perf_DB(c_num_names_add_test, c_names_per_label);
-    }
-    performance_stop(c_num_names_add_test);
+	// actual test
+	performance_start("saveRow");
+
+	{
+		generate_perf_DB(c_num_names_add_test, c_names_per_label);
+	}
+
+	performance_stop(c_num_names_add_test);
 }
 
 BOOST_AUTO_TEST_CASE(DBperfLookupAliasByOwner)
 {
-    // prepare data
-    generate_perf_DB(c_num_names, c_names_per_label);
-
-    unsigned int num_labels = c_num_names/c_names_per_label;
-    Name name;
-    Label label;
-
-    // actual test - successful lookup
-    performance_start("getRow");
-    for(unsigned int t=0; t<c_test_retries; t++)
-    {
-        int label_num = rand_r(&t) % num_labels;
-        generate_label(label_num, label);
-
-        unsigned int start_name = label_num*c_names_per_label;
-        for(unsigned int name_num=start_name; name_num<(start_name+c_names_per_label); name_num++)
-        {
-            generate_name(name_num, name);
-            read_row_expect_success(name, label);
-        }
-    }
-    performance_stop(c_test_retries * c_num_names);
+	// prepare data
+	generate_perf_DB(c_num_names, c_names_per_label);
+
+	unsigned int num_labels = c_num_names / c_names_per_label;
+	Name name;
+	Label label;
+
+	// actual test - successful lookup
+	performance_start("getRow");
+
+	for (unsigned int t = 0; t < c_test_retries; t++) {
+		int label_num = rand_r(&t) % num_labels;
+		generate_label(label_num, label);
+
+		unsigned int start_name = label_num * c_names_per_label;
+
+		for (unsigned int name_num = start_name;
+				name_num < (start_name + c_names_per_label); name_num++) {
+			generate_name(name_num, name);
+			read_row_expect_success(name, label);
+		}
+	}
+
+	performance_stop(c_test_retries * c_num_names);
 }
 
 BOOST_AUTO_TEST_CASE(DBperfLookupAliasRandomOwnershipNoPermissions)
 {
-    // prepare data
-    generate_perf_DB(c_num_names, c_names_per_label);
-
-    Name name;
-    Label owner_label;
-    Label smack_label;
-    unsigned int num_labels = c_num_names / c_names_per_label;
-
-    // actual test - random lookup
-    performance_start("getRow");
-    for(unsigned int t=0; t<c_test_retries; t++)
-    {
-        int name_idx = rand_r(&t)%c_num_names;
-        generate_name(name_idx, name);
-        generate_label(name_idx/c_names_per_label, owner_label);
-        generate_label(rand_r(&t)%num_labels, smack_label);
-
-        // do not care of result
-        m_db.getRow(name, owner_label, DataType::BINARY_DATA);
-    }
-    performance_stop(c_test_retries * c_num_names);
+	// prepare data
+	generate_perf_DB(c_num_names, c_names_per_label);
+
+	Name name;
+	Label owner_label;
+	Label smack_label;
+	unsigned int num_labels = c_num_names / c_names_per_label;
+
+	// actual test - random lookup
+	performance_start("getRow");
+
+	for (unsigned int t = 0; t < c_test_retries; t++) {
+		int name_idx = rand_r(&t) % c_num_names;
+		generate_name(name_idx, name);
+		generate_label(name_idx / c_names_per_label, owner_label);
+		generate_label(rand_r(&t) % num_labels, smack_label);
+
+		// do not care of result
+		m_db.getRow(name, owner_label, DataType::BINARY_DATA);
+	}
+
+	performance_stop(c_test_retries * c_num_names);
 }
 
 BOOST_AUTO_TEST_CASE(DBperfAddPermissions)
 {
-    // prepare data
-    generate_perf_DB(c_num_names, c_names_per_label);
+	// prepare data
+	generate_perf_DB(c_num_names, c_names_per_label);
 
-    // actual test - add access rights
-    performance_start("setPermission");
-    long iterations = add_full_access_rights(c_num_names, c_names_per_label);
-    performance_stop(iterations);
+	// actual test - add access rights
+	performance_start("setPermission");
+	long iterations = add_full_access_rights(c_num_names, c_names_per_label);
+	performance_stop(iterations);
 }
 
 BOOST_AUTO_TEST_CASE(DBperfAliasRemoval)
 {
-    // prepare data
-    generate_perf_DB(c_num_names, c_names_per_label);
-    add_full_access_rights(c_num_names, c_names_per_label);
-
-    // actual test - random lookup
-    performance_start("deleteRow");
-    Name name;
-    Label label;
-    for(unsigned int t=0; t<c_num_names; t++)
-    {
-        generate_name(t, name);
-        generate_label(t/c_names_per_label, label);
-
-        BOOST_REQUIRE_NO_THROW(m_db.deleteRow(name, label));
-    }
-    performance_stop(c_num_names);
-
-    // verify everything has been removed
-    unsigned int num_labels = c_num_names / c_names_per_label;
-    for(unsigned int l=0; l<num_labels; l++)
-    {
-        generate_label(l, label);
-        LabelNameVector expect_no_data;
-        BOOST_REQUIRE_NO_THROW(m_db.listNames(label, expect_no_data, DataType::BINARY_DATA));
-        BOOST_REQUIRE(0 == expect_no_data.size());
-    }
+	// prepare data
+	generate_perf_DB(c_num_names, c_names_per_label);
+	add_full_access_rights(c_num_names, c_names_per_label);
+
+	// actual test - random lookup
+	performance_start("deleteRow");
+	Name name;
+	Label label;
+
+	for (unsigned int t = 0; t < c_num_names; t++) {
+		generate_name(t, name);
+		generate_label(t / c_names_per_label, label);
+
+		BOOST_REQUIRE_NO_THROW(m_db.deleteRow(name, label));
+	}
+
+	performance_stop(c_num_names);
+
+	// verify everything has been removed
+	unsigned int num_labels = c_num_names / c_names_per_label;
+
+	for (unsigned int l = 0; l < num_labels; l++) {
+		generate_label(l, label);
+		LabelNameVector expect_no_data;
+		BOOST_REQUIRE_NO_THROW(m_db.listNames(label, expect_no_data,
+											  DataType::BINARY_DATA));
+		BOOST_REQUIRE(0 == expect_no_data.size());
+	}
 }
 
 BOOST_AUTO_TEST_CASE(DBperfGetAliasList)
 {
-    // prepare data
-    generate_perf_DB(c_num_names, c_names_per_label);
-    add_full_access_rights(c_num_names, c_names_per_label);
-
-    unsigned int num_labels = c_num_names / c_names_per_label;
-    Label label;
-
-    // actual test - random lookup
-    performance_start("listNames");
-    for(unsigned int t=0; t<(c_test_retries/num_labels); t++)
-    {
-        LabelNameVector ret_list;
-        generate_label(rand_r(&t)%num_labels, label);
-
-        BOOST_REQUIRE_NO_THROW(m_db.listNames(label, ret_list, DataType::BINARY_DATA));
-        BOOST_REQUIRE(c_num_names == ret_list.size());
-        ret_list.clear();
-    }
-    performance_stop(c_test_retries/num_labels);
+	// prepare data
+	generate_perf_DB(c_num_names, c_names_per_label);
+	add_full_access_rights(c_num_names, c_names_per_label);
+
+	unsigned int num_labels = c_num_names / c_names_per_label;
+	Label label;
+
+	// actual test - random lookup
+	performance_start("listNames");
+
+	for (unsigned int t = 0; t < (c_test_retries / num_labels); t++) {
+		LabelNameVector ret_list;
+		generate_label(rand_r(&t) % num_labels, label);
+
+		BOOST_REQUIRE_NO_THROW(m_db.listNames(label, ret_list, DataType::BINARY_DATA));
+		BOOST_REQUIRE(c_num_names == ret_list.size());
+		ret_list.clear();
+	}
+
+	performance_stop(c_test_retries / num_labels);
 }
 BOOST_AUTO_TEST_SUITE_END()
 
 
 BOOST_AUTO_TEST_SUITE(DBCRYPTO_MIGRATION_TEST)
-namespace
-{
+namespace {
 const unsigned migration_names = 16107;
 const unsigned migration_labels = 273;
 const unsigned migration_reference_label_idx = 0;
 const unsigned migration_accessed_element_idx = 7;
 
-void verifyDBisValid(DBFixture & fixture)
+void verifyDBisValid(DBFixture &fixture)
 {
-    /**
-     * there are (migration_labels), each having (migration_names)/(migration_labels) entries.
-     * reference label (migration_reference_label_idx) exists such that it has access to
-     * all others' label element with index (migration_accessed_element_idx).
-     *
-     * Example:
-     * - migration_label_63 has access to all items owned by migration_label_63,
-     *   which gives (migration_names)/(migration_labels) entries.
-     *
-     * - migration_label_0 (0 is the reference label) has access to all items
-     *   owned by migration_label_0 and all others' label element index 7,
-     *   which gives (migration_names)/(migration_labels)  + (migration_labels-1) entries.
-     *
-     */
-    Label reference_label;
-    fixture.generate_label(migration_reference_label_idx, reference_label);
-
-    // check number of elements accessible to the reference label
-    LabelNameVector ret_list;
-    BOOST_REQUIRE_NO_THROW(fixture.m_db.listNames(reference_label, ret_list, DataType::BINARY_DATA));
-    BOOST_REQUIRE((migration_names/migration_labels)/*own items*/ + (migration_labels-1)/*other labels'*/ == ret_list.size());
-    ret_list.clear();
-
-    // check number of elements accessible to the other labels
-    for(unsigned int l=0; l<migration_labels; l++)
-    {
-        // bypass the reference owner label
-        if(l == migration_reference_label_idx)
-            continue;
-
-        Label current_label;
-        fixture.generate_label(l, current_label);
-        BOOST_REQUIRE_NO_THROW(fixture.m_db.listNames(current_label, ret_list, DataType::BINARY_DATA));
-        BOOST_REQUIRE((migration_names/migration_labels) == ret_list.size());
-        for(auto it: ret_list)
-            BOOST_REQUIRE(it.first == current_label);
-        ret_list.clear();
-    }
+	/**
+	 * there are (migration_labels), each having (migration_names)/(migration_labels) entries.
+	 * reference label (migration_reference_label_idx) exists such that it has access to
+	 * all others' label element with index (migration_accessed_element_idx).
+	 *
+	 * Example:
+	 * - migration_label_63 has access to all items owned by migration_label_63,
+	 *   which gives (migration_names)/(migration_labels) entries.
+	 *
+	 * - migration_label_0 (0 is the reference label) has access to all items
+	 *   owned by migration_label_0 and all others' label element index 7,
+	 *   which gives (migration_names)/(migration_labels)  + (migration_labels-1) entries.
+	 *
+	 */
+	Label reference_label;
+	fixture.generate_label(migration_reference_label_idx, reference_label);
+
+	// check number of elements accessible to the reference label
+	LabelNameVector ret_list;
+	BOOST_REQUIRE_NO_THROW(fixture.m_db.listNames(reference_label, ret_list,
+						   DataType::BINARY_DATA));
+	BOOST_REQUIRE((migration_names / migration_labels)/*own items*/ +
+				  (migration_labels - 1)/*other labels'*/ == ret_list.size());
+	ret_list.clear();
+
+	// check number of elements accessible to the other labels
+	for (unsigned int l = 0; l < migration_labels; l++) {
+		// bypass the reference owner label
+		if (l == migration_reference_label_idx)
+			continue;
+
+		Label current_label;
+		fixture.generate_label(l, current_label);
+		BOOST_REQUIRE_NO_THROW(fixture.m_db.listNames(current_label, ret_list,
+							   DataType::BINARY_DATA));
+		BOOST_REQUIRE((migration_names / migration_labels) == ret_list.size());
+
+		for (auto it : ret_list)
+			BOOST_REQUIRE(it.first == current_label);
+
+		ret_list.clear();
+	}
 }
 
-struct DBVer1Migration : public DBFixture
-{
-    DBVer1Migration() : DBFixture(DB_TEST_DIR "/testme_ver1.db")
-    {}
+struct DBVer1Migration : public DBFixture {
+	DBVer1Migration() : DBFixture(DB_TEST_DIR "/testme_ver1.db") {}
 };
 
-struct DBVer2Migration : public DBFixture
-{
-    DBVer2Migration() : DBFixture(DB_TEST_DIR "/testme_ver2.db")
-    {}
+struct DBVer2Migration : public DBFixture {
+	DBVer2Migration() : DBFixture(DB_TEST_DIR "/testme_ver2.db") {}
 };
 
-struct DBVer3Migration : public DBFixture
-{
-    DBVer3Migration() : DBFixture(DB_TEST_DIR "/testme_ver3.db")
-    {}
+struct DBVer3Migration : public DBFixture {
+	DBVer3Migration() : DBFixture(DB_TEST_DIR "/testme_ver3.db") {}
 };
 }
 
 BOOST_AUTO_TEST_CASE(DBMigrationDBVer1)
 {
-    DBVer1Migration DBver1;
-    verifyDBisValid(DBver1);
+	DBVer1Migration DBver1;
+	verifyDBisValid(DBver1);
 }
 
 BOOST_AUTO_TEST_CASE(DBMigrationDBVer2)
 {
-    DBVer2Migration DBver2;
-    verifyDBisValid(DBver2);
+	DBVer2Migration DBver2;
+	verifyDBisValid(DBver2);
 }
 
 BOOST_AUTO_TEST_CASE(DBMigrationDBVer3)
 {
-    DBVer3Migration DBver3;
-    verifyDBisValid(DBver3);
+	DBVer3Migration DBver3;
+	verifyDBisValid(DBver3);
 }
 
 BOOST_AUTO_TEST_CASE(DBMigrationDBCurrent)
 {
-    DBFixture currentDB;
-
-    // prepare data using current DB mechanism
-    Label reference_label;
-    currentDB.generate_label(migration_reference_label_idx, reference_label);
-    {
-        currentDB.generate_perf_DB(migration_names, migration_names/migration_labels);
-
-        // only the reference label has access to the other labels element <migration_accessed_element_idx>
-        for(unsigned int l=0; l<migration_labels; l++)
-        {
-            // bypass the reference owner label
-            if(l == migration_reference_label_idx)
-                continue;
-
-            unsigned element_index = migration_accessed_element_idx + l*migration_names/migration_labels;
-
-            // add permission
-            Name accessed_name;
-            currentDB.generate_name(element_index, accessed_name);
-            Label current_label;
-            currentDB.generate_label(l, current_label);
-            currentDB.add_permission(accessed_name, current_label, reference_label);
-        }
-    }
-
-    verifyDBisValid(currentDB);
+	DBFixture currentDB;
+
+	// prepare data using current DB mechanism
+	Label reference_label;
+	currentDB.generate_label(migration_reference_label_idx, reference_label);
+
+	{
+		currentDB.generate_perf_DB(migration_names, migration_names / migration_labels);
+
+		// only the reference label has access to the other labels element <migration_accessed_element_idx>
+		for (unsigned int l = 0; l < migration_labels; l++) {
+			// bypass the reference owner label
+			if (l == migration_reference_label_idx)
+				continue;
+
+			unsigned element_index = migration_accessed_element_idx + l * migration_names /
+									 migration_labels;
+
+			// add permission
+			Name accessed_name;
+			currentDB.generate_name(element_index, accessed_name);
+			Label current_label;
+			currentDB.generate_label(l, current_label);
+			currentDB.add_permission(accessed_name, current_label, reference_label);
+		}
+	}
+
+	verifyDBisValid(currentDB);
 }
 
 BOOST_AUTO_TEST_SUITE_END()
diff --git a/tests/test_descriptor-set.cpp b/tests/test_descriptor-set.cpp
index 443cdf58..4d345a8e 100644
--- a/tests/test_descriptor-set.cpp
+++ b/tests/test_descriptor-set.cpp
@@ -46,9 +46,10 @@ typedef std::unique_ptr<int[], std::function<void(int *)>> PipePtr;
 
 const short POLLALL = std::numeric_limits<short>::max();
 
-void closePipe(int* fd) {
-    close(fd[0]);
-    close(fd[1]);
+void closePipe(int *fd)
+{
+	close(fd[0]);
+	close(fd[1]);
 }
 
 /*
@@ -57,27 +58,30 @@ void closePipe(int* fd) {
  * Wraps pipe in unique_ptr
  */
 #define PIPE(fd) \
-    int (fd)[2]; \
-    BOOST_REQUIRE_MESSAGE(0 == pipe((fd)),"Pipe creation failed: " << GetErrnoString()); \
-    PipePtr fd##Ptr((fd), closePipe);
+	int (fd)[2]; \
+	BOOST_REQUIRE_MESSAGE(0 == pipe((fd)), "Pipe creation failed: " << GetErrnoString()); \
+	PipePtr fd##Ptr((fd), closePipe);
 
-void unexpectedCallback(int, short) {
-    BOOST_FAIL("Unexpected callback");
+void unexpectedCallback(int, short)
+{
+	BOOST_FAIL("Unexpected callback");
 }
 
-void readFd(int fd, int expectedFd, short revents) {
-    char buf[1];
-    BOOST_REQUIRE_MESSAGE(fd == expectedFd, "Unexpected descriptor");
-    BOOST_REQUIRE_MESSAGE(revents & POLLIN, "Unexpected event");
-    BOOST_REQUIRE_MESSAGE(1 == TEMP_FAILURE_RETRY(read(fd,buf,1)),
-                          "Pipe read failed" << GetErrnoString());
+void readFd(int fd, int expectedFd, short revents)
+{
+	char buf[1];
+	BOOST_REQUIRE_MESSAGE(fd == expectedFd, "Unexpected descriptor");
+	BOOST_REQUIRE_MESSAGE(revents & POLLIN, "Unexpected event");
+	BOOST_REQUIRE_MESSAGE(1 == TEMP_FAILURE_RETRY(read(fd, buf, 1)),
+						  "Pipe read failed" << GetErrnoString());
 }
 
-void writeFd(int fd, int expectedFd, short revents) {
-    BOOST_REQUIRE_MESSAGE(fd == expectedFd, "Unexpected descriptor");
-    BOOST_REQUIRE_MESSAGE(revents & POLLOUT, "Unexpected event");
-    BOOST_REQUIRE_MESSAGE(1 == TEMP_FAILURE_RETRY(write(fd,"j",1)),
-                          "Pipe writing failed" << GetErrnoString());
+void writeFd(int fd, int expectedFd, short revents)
+{
+	BOOST_REQUIRE_MESSAGE(fd == expectedFd, "Unexpected descriptor");
+	BOOST_REQUIRE_MESSAGE(revents & POLLOUT, "Unexpected event");
+	BOOST_REQUIRE_MESSAGE(1 == TEMP_FAILURE_RETRY(write(fd, "j", 1)),
+						  "Pipe writing failed" << GetErrnoString());
 }
 
 } // anonymous namespace
@@ -87,148 +91,151 @@ BOOST_AUTO_TEST_SUITE(DESCRIPTOR_SET_TEST)
 /*
  * Wait on empty descriptor set. Function should return immediately.
  */
-BOOST_AUTO_TEST_CASE(T010_Empty) {
-    DescriptorSet descriptors;
+BOOST_AUTO_TEST_CASE(T010_Empty)
+{
+	DescriptorSet descriptors;
 
-    BOOST_REQUIRE_NO_THROW(descriptors.wait(POLL_TIMEOUT));
+	BOOST_REQUIRE_NO_THROW(descriptors.wait(POLL_TIMEOUT));
 }
 
 /*
  * Add and remove (twice) descriptor. Wait on empty set. No callback should be called. wait() should
  * return immediately.
  */
-BOOST_AUTO_TEST_CASE(T020_AddRemove) {
-    DescriptorSet descriptors;
-    descriptors.add(10, POLLALL, unexpectedCallback);
-    descriptors.remove(10);
-    descriptors.remove(10);
-
-    BOOST_REQUIRE_NO_THROW(descriptors.wait(POLL_TIMEOUT));
+BOOST_AUTO_TEST_CASE(T020_AddRemove)
+{
+	DescriptorSet descriptors;
+	descriptors.add(10, POLLALL, unexpectedCallback);
+	descriptors.remove(10);
+	descriptors.remove(10);
+
+	BOOST_REQUIRE_NO_THROW(descriptors.wait(POLL_TIMEOUT));
 }
 
 /*
  * Add 2 descriptors and purge all. Wait on empty set. No callback should be called. wait() should
  * return immediately.
  */
-BOOST_AUTO_TEST_CASE(T030_AddPurge) {
-    DescriptorSet descriptors;
-    descriptors.add(10, POLLALL, unexpectedCallback);
-    descriptors.add(20, POLLALL, unexpectedCallback);
-    descriptors.purge();
-
-    BOOST_REQUIRE_NO_THROW(descriptors.wait(POLL_TIMEOUT));
+BOOST_AUTO_TEST_CASE(T030_AddPurge)
+{
+	DescriptorSet descriptors;
+	descriptors.add(10, POLLALL, unexpectedCallback);
+	descriptors.add(20, POLLALL, unexpectedCallback);
+	descriptors.purge();
+
+	BOOST_REQUIRE_NO_THROW(descriptors.wait(POLL_TIMEOUT));
 }
 
 /*
  * Add pipe[1] descriptor and wait for write possibility. Provided callback should be called
  * immediately.
  */
-BOOST_AUTO_TEST_CASE(T040_Callback) {
-    DescriptorSet descriptors;
-    bool callback = false;
+BOOST_AUTO_TEST_CASE(T040_Callback)
+{
+	DescriptorSet descriptors;
+	bool callback = false;
 
-    PIPE(fd);
+	PIPE(fd);
 
-    descriptors.add(fd[1],POLLALL, [&callback](int, short revents)
-    {
-        callback = true;
-        BOOST_REQUIRE_MESSAGE(revents & POLLOUT, "Not able to write");
-    });
+	descriptors.add(fd[1], POLLALL, [&callback](int, short revents) {
+		callback = true;
+		BOOST_REQUIRE_MESSAGE(revents & POLLOUT, "Not able to write");
+	});
 
-    BOOST_REQUIRE_NO_THROW(descriptors.wait(POLL_TIMEOUT));
-    BOOST_REQUIRE_MESSAGE(callback, "Callback was not called");
+	BOOST_REQUIRE_NO_THROW(descriptors.wait(POLL_TIMEOUT));
+	BOOST_REQUIRE_MESSAGE(callback, "Callback was not called");
 }
 
 /*
  * Add pipe[1] descriptor twice with different callbacks. The first one should be overwritten and
  * shouldn't be called. The second one should be called instead.
  */
-BOOST_AUTO_TEST_CASE(T050_DoubleAdd) {
-    DescriptorSet descriptors;
-    bool callback = false;
+BOOST_AUTO_TEST_CASE(T050_DoubleAdd)
+{
+	DescriptorSet descriptors;
+	bool callback = false;
 
-    PIPE(fd);
+	PIPE(fd);
 
-    descriptors.add(fd[1], POLLALL, unexpectedCallback);
-    descriptors.add(fd[1], POLLALL, [&callback](int, short revents)
-    {
-        callback = true;
-        BOOST_REQUIRE_MESSAGE(revents & POLLOUT, "Not able to write");
-    });
+	descriptors.add(fd[1], POLLALL, unexpectedCallback);
+	descriptors.add(fd[1], POLLALL, [&callback](int, short revents) {
+		callback = true;
+		BOOST_REQUIRE_MESSAGE(revents & POLLOUT, "Not able to write");
+	});
 
-    BOOST_REQUIRE_NO_THROW(descriptors.wait(POLL_TIMEOUT));
-    BOOST_REQUIRE_MESSAGE(callback, "Callback was not called");
+	BOOST_REQUIRE_NO_THROW(descriptors.wait(POLL_TIMEOUT));
+	BOOST_REQUIRE_MESSAGE(callback, "Callback was not called");
 }
 
 /*
  * Add pipe[0] descriptor and wait. Callback should not be called. Instead the 8s timeout should
  * occur and a proper exception should be thrown.
  */
-BOOST_AUTO_TEST_CASE(T060_Timeout) {
-    DescriptorSet descriptors;
+BOOST_AUTO_TEST_CASE(T060_Timeout)
+{
+	DescriptorSet descriptors;
 
-    PIPE(fd);
+	PIPE(fd);
 
-    descriptors.add(fd[0],POLLALL, unexpectedCallback);
+	descriptors.add(fd[0], POLLALL, unexpectedCallback);
 
-    BOOST_REQUIRE_THROW(descriptors.wait(POLL_TIMEOUT_SHORT), CKM::DescriptorSet::Timeout);
+	BOOST_REQUIRE_THROW(descriptors.wait(POLL_TIMEOUT_SHORT),
+						CKM::DescriptorSet::Timeout);
 }
 
 /*
  * Create pipe and try to write it. Start thread that will read it.
  */
-BOOST_AUTO_TEST_CASE(T070_Write) {
-    DescriptorSet descriptors;
-    bool callback = false;
-
-    PIPE(fd);
-
-    descriptors.add(fd[1],POLLOUT, [&fd, &callback](int desc, short revents)
-    {
-        callback = true;
-        writeFd(desc, fd[1], revents);
-    } );
-
-    {
-        auto thread = CreateWatchedThread([fd]
-        {
-            char buf[1];
-            ssize_t tmp = TEMP_FAILURE_RETRY(read(fd[0], buf, 1));
-            THREAD_REQUIRE_MESSAGE(tmp == 1, "Pipe reading failed " << GetErrnoString());
-        });
-
-        BOOST_REQUIRE_NO_THROW(descriptors.wait(POLL_TIMEOUT));
-    }
-
-    BOOST_REQUIRE_MESSAGE(callback, "Callback not called");
+BOOST_AUTO_TEST_CASE(T070_Write)
+{
+	DescriptorSet descriptors;
+	bool callback = false;
+
+	PIPE(fd);
+
+	descriptors.add(fd[1], POLLOUT, [&fd, &callback](int desc, short revents) {
+		callback = true;
+		writeFd(desc, fd[1], revents);
+	});
+
+	{
+		auto thread = CreateWatchedThread([fd] {
+			char buf[1];
+			ssize_t tmp = TEMP_FAILURE_RETRY(read(fd[0], buf, 1));
+			THREAD_REQUIRE_MESSAGE(tmp == 1, "Pipe reading failed " << GetErrnoString());
+		});
+
+		BOOST_REQUIRE_NO_THROW(descriptors.wait(POLL_TIMEOUT));
+	}
+
+	BOOST_REQUIRE_MESSAGE(callback, "Callback not called");
 }
 
 /*
  * Create pipe and try to read it. Start thread that will write it.
  */
-BOOST_AUTO_TEST_CASE(T080_Read) {
-    DescriptorSet descriptors;
-    bool callback = false;
+BOOST_AUTO_TEST_CASE(T080_Read)
+{
+	DescriptorSet descriptors;
+	bool callback = false;
 
-    PIPE(fd);
+	PIPE(fd);
 
-    descriptors.add(fd[0],POLLIN, [&](int desc, short revents)
-    {
-        callback = true;
-        readFd(desc, fd[0], revents);
-    } );
+	descriptors.add(fd[0], POLLIN, [&](int desc, short revents) {
+		callback = true;
+		readFd(desc, fd[0], revents);
+	});
 
-    {
-        auto thread = CreateWatchedThread([fd]
-        {
-            ssize_t tmp = TEMP_FAILURE_RETRY(write(fd[1], "j", 1));
-            THREAD_REQUIRE_MESSAGE(tmp == 1, "Pipe writing failed " << GetErrnoString());
-        });
+	{
+		auto thread = CreateWatchedThread([fd] {
+			ssize_t tmp = TEMP_FAILURE_RETRY(write(fd[1], "j", 1));
+			THREAD_REQUIRE_MESSAGE(tmp == 1, "Pipe writing failed " << GetErrnoString());
+		});
 
-        BOOST_REQUIRE_NO_THROW(descriptors.wait(POLL_TIMEOUT));
-    }
+		BOOST_REQUIRE_NO_THROW(descriptors.wait(POLL_TIMEOUT));
+	}
 
-    BOOST_REQUIRE_MESSAGE(callback, "Callback not called");
+	BOOST_REQUIRE_MESSAGE(callback, "Callback not called");
 }
 
 /*
@@ -236,44 +243,43 @@ BOOST_AUTO_TEST_CASE(T080_Read) {
  * the pipe, remove it from the descriptor set and try to write the second pipe. The thread will
  * read it. In second pipe callback remove the second pipe descriptor from the set.
  */
-BOOST_AUTO_TEST_CASE(T090_WriteAfterRead) {
-    DescriptorSet descriptors;
-    bool callback1 = false;
-    bool callback2 = false;
-
-    PIPE(fd);
-    PIPE(fd2);
-
-    descriptors.add(fd[0],POLLIN, [&](int desc, short revents)
-    {
-        callback1 = true;
-        readFd(desc, fd[0], revents);
-
-        descriptors.remove(desc);
-        descriptors.add(fd2[1],POLLOUT, [&](int desc, short revents) {
-            callback2 = true;
-            writeFd(desc, fd2[1], revents);
-            descriptors.remove(desc);
-        } );
-    } );
-
-    {
-        auto thread = CreateWatchedThread([fd,fd2]
-        {
-            ssize_t tmp = TEMP_FAILURE_RETRY(write(fd[1], "j", 1));
-            BOOST_REQUIRE_MESSAGE(tmp == 1, "Pipe writing failed " << GetErrnoString());
-
-            char buf[1];
-            tmp = TEMP_FAILURE_RETRY(read(fd2[0], buf, 1));
-            THREAD_REQUIRE_MESSAGE(tmp == 1, "Pipe reading failed " << GetErrnoString());
-        });
-
-        BOOST_REQUIRE_NO_THROW(descriptors.wait(POLL_TIMEOUT));
-        BOOST_REQUIRE_NO_THROW(descriptors.wait(POLL_TIMEOUT));
-    }
-
-    BOOST_REQUIRE_MESSAGE(callback1, "First callback not called");
-    BOOST_REQUIRE_MESSAGE(callback2, "Second callback not called");
+BOOST_AUTO_TEST_CASE(T090_WriteAfterRead)
+{
+	DescriptorSet descriptors;
+	bool callback1 = false;
+	bool callback2 = false;
+
+	PIPE(fd);
+	PIPE(fd2);
+
+	descriptors.add(fd[0], POLLIN, [&](int desc, short revents) {
+		callback1 = true;
+		readFd(desc, fd[0], revents);
+
+		descriptors.remove(desc);
+		descriptors.add(fd2[1], POLLOUT, [&](int desc, short revents) {
+			callback2 = true;
+			writeFd(desc, fd2[1], revents);
+			descriptors.remove(desc);
+		});
+	});
+
+	{
+		auto thread = CreateWatchedThread([fd, fd2] {
+			ssize_t tmp = TEMP_FAILURE_RETRY(write(fd[1], "j", 1));
+			BOOST_REQUIRE_MESSAGE(tmp == 1, "Pipe writing failed " << GetErrnoString());
+
+			char buf[1];
+			tmp = TEMP_FAILURE_RETRY(read(fd2[0], buf, 1));
+			THREAD_REQUIRE_MESSAGE(tmp == 1, "Pipe reading failed " << GetErrnoString());
+		});
+
+		BOOST_REQUIRE_NO_THROW(descriptors.wait(POLL_TIMEOUT));
+		BOOST_REQUIRE_NO_THROW(descriptors.wait(POLL_TIMEOUT));
+	}
+
+	BOOST_REQUIRE_MESSAGE(callback1, "First callback not called");
+	BOOST_REQUIRE_MESSAGE(callback2, "Second callback not called");
 }
 
 BOOST_AUTO_TEST_SUITE_END()
diff --git a/tests/test_encryption-scheme.cpp b/tests/test_encryption-scheme.cpp
index 9e4579a3..dc2e3bd0 100644
--- a/tests/test_encryption-scheme.cpp
+++ b/tests/test_encryption-scheme.cpp
@@ -36,117 +36,127 @@ const int NEW_ENC_SCHEME  = 1;
 BOOST_AUTO_TEST_SUITE(ENCRYPTION_SCHEME_TEST)
 
 // Test database should have the old scheme
-BOOST_AUTO_TEST_CASE(T010_Check_old_scheme) {
-    SchemeTest test;
-    test.RestoreDb();
+BOOST_AUTO_TEST_CASE(T010_Check_old_scheme)
+{
+	SchemeTest test;
+	test.RestoreDb();
 
-    ItemFilter filter;
-    test.CheckSchemeVersion(filter, OLD_ENC_SCHEME);
+	ItemFilter filter;
+	test.CheckSchemeVersion(filter, OLD_ENC_SCHEME);
 }
 
 // Newly written data should use the new scheme
-BOOST_AUTO_TEST_CASE(T020_Check_new_scheme) {
-    SchemeTest test;
-    test.RemoveUserData();
-    test.FillDb();
-
-    ItemFilter filter;
-    test.CheckSchemeVersion(filter, NEW_ENC_SCHEME);
+BOOST_AUTO_TEST_CASE(T020_Check_new_scheme)
+{
+	SchemeTest test;
+	test.RemoveUserData();
+	test.FillDb();
+
+	ItemFilter filter;
+	test.CheckSchemeVersion(filter, NEW_ENC_SCHEME);
 }
 
-BOOST_AUTO_TEST_CASE(T030_Remove_old_scheme) {
-    SchemeTest test;
-    test.RestoreDb();
-    test.RemoveAll();
+BOOST_AUTO_TEST_CASE(T030_Remove_old_scheme)
+{
+	SchemeTest test;
+	test.RestoreDb();
+	test.RemoveAll();
 
-    size_t aliases = test.CountObjects();
-    BOOST_REQUIRE_MESSAGE(aliases == 0, "All aliases should be removed");
+	size_t aliases = test.CountObjects();
+	BOOST_REQUIRE_MESSAGE(aliases == 0, "All aliases should be removed");
 }
 
-BOOST_AUTO_TEST_CASE(T040_Remove_new_scheme) {
-    SchemeTest test;
-    test.RemoveUserData();
-    test.FillDb();
-    test.RemoveAll();
+BOOST_AUTO_TEST_CASE(T040_Remove_new_scheme)
+{
+	SchemeTest test;
+	test.RemoveUserData();
+	test.FillDb();
+	test.RemoveAll();
 
-    size_t aliases = test.CountObjects();
-    BOOST_REQUIRE_MESSAGE(aliases == 0, "All aliases should be removed");
+	size_t aliases = test.CountObjects();
+	BOOST_REQUIRE_MESSAGE(aliases == 0, "All aliases should be removed");
 }
 
 // Reading old db should reencrypt objects with new scheme
-BOOST_AUTO_TEST_CASE(T100_Read) {
-    SchemeTest test;
-    test.RestoreDb();
-    test.ReadAll();
-
-    ItemFilter filter;
-    filter.exportableOnly = true;
-    test.CheckSchemeVersion(filter, NEW_ENC_SCHEME);
+BOOST_AUTO_TEST_CASE(T100_Read)
+{
+	SchemeTest test;
+	test.RestoreDb();
+	test.ReadAll();
+
+	ItemFilter filter;
+	filter.exportableOnly = true;
+	test.CheckSchemeVersion(filter, NEW_ENC_SCHEME);
 }
 
-BOOST_AUTO_TEST_CASE(T110_Count_objects_after_read) {
-    SchemeTest test;
-    test.RestoreDb();
-    size_t orig = test.CountObjects();
-    BOOST_REQUIRE_MESSAGE(orig > 0, "No objects in db");
+BOOST_AUTO_TEST_CASE(T110_Count_objects_after_read)
+{
+	SchemeTest test;
+	test.RestoreDb();
+	size_t orig = test.CountObjects();
+	BOOST_REQUIRE_MESSAGE(orig > 0, "No objects in db");
 
-    test.ReadAll();
+	test.ReadAll();
 
-    size_t current = test.CountObjects();
-    BOOST_REQUIRE_MESSAGE(current == orig,
-                          "Original number of objects: " << orig << " Current: " << current);
+	size_t current = test.CountObjects();
+	BOOST_REQUIRE_MESSAGE(current == orig,
+						  "Original number of objects: " << orig << " Current: " << current);
 }
 
 // Reading old db with incorrect passwords should leave the scheme unchanged
-BOOST_AUTO_TEST_CASE(T120_Read_wrong_pass) {
-    SchemeTest test;
-    test.RestoreDb();
-    test.ReadAll(true);
-
-    ItemFilter filter;
-    test.CheckSchemeVersion(filter, OLD_ENC_SCHEME);
+BOOST_AUTO_TEST_CASE(T120_Read_wrong_pass)
+{
+	SchemeTest test;
+	test.RestoreDb();
+	test.ReadAll(true);
+
+	ItemFilter filter;
+	test.CheckSchemeVersion(filter, OLD_ENC_SCHEME);
 }
 
 // Signing/verification should reencrypt objects with new scheme
-BOOST_AUTO_TEST_CASE(T200_SignVerify) {
-    SchemeTest test;
-    test.RestoreDb();
-    test.SignVerify();
-
-    ItemFilter filter(DataType::KEY_RSA_PUBLIC, DataType::KEY_RSA_PRIVATE);
-    test.CheckSchemeVersion(filter, NEW_ENC_SCHEME);
+BOOST_AUTO_TEST_CASE(T200_SignVerify)
+{
+	SchemeTest test;
+	test.RestoreDb();
+	test.SignVerify();
+
+	ItemFilter filter(DataType::KEY_RSA_PUBLIC, DataType::KEY_RSA_PRIVATE);
+	test.CheckSchemeVersion(filter, NEW_ENC_SCHEME);
 }
 
 // Encryption/decryption should reencrypt objects with new scheme
-BOOST_AUTO_TEST_CASE(T210_EncryptDecrypt) {
-    SchemeTest test;
-    test.RestoreDb();
-    test.EncryptDecrypt();
+BOOST_AUTO_TEST_CASE(T210_EncryptDecrypt)
+{
+	SchemeTest test;
+	test.RestoreDb();
+	test.EncryptDecrypt();
 
-    ItemFilter filter1(DataType::KEY_RSA_PUBLIC, DataType::KEY_RSA_PRIVATE);
-    test.CheckSchemeVersion(filter1, NEW_ENC_SCHEME);
+	ItemFilter filter1(DataType::KEY_RSA_PUBLIC, DataType::KEY_RSA_PRIVATE);
+	test.CheckSchemeVersion(filter1, NEW_ENC_SCHEME);
 
-    ItemFilter filter2(DataType::KEY_AES);
-    test.CheckSchemeVersion(filter2, NEW_ENC_SCHEME);
+	ItemFilter filter2(DataType::KEY_AES);
+	test.CheckSchemeVersion(filter2, NEW_ENC_SCHEME);
 }
 
 // Chain creation should reencrypt objects with new scheme
-BOOST_AUTO_TEST_CASE(T220_CreateChain) {
-    SchemeTest test;
-    test.RestoreDb();
-    test.CreateChain();
-
-    // non exportable certificates and certificates protected with passwords can't be used for chain
-    // creation
-    ItemFilter filter1(DataType::CERTIFICATE);
-    filter1.exportableOnly = true;
-    filter1.noPassword = true;
-    test.CheckSchemeVersion(filter1, NEW_ENC_SCHEME);
-
-    ItemFilter filter2(DataType::CHAIN_CERT_0, DataType::CHAIN_CERT_15);
-    filter2.exportableOnly = true;
-    filter2.noPassword = true;
-    test.CheckSchemeVersion(filter2, NEW_ENC_SCHEME);
+BOOST_AUTO_TEST_CASE(T220_CreateChain)
+{
+	SchemeTest test;
+	test.RestoreDb();
+	test.CreateChain();
+
+	// non exportable certificates and certificates protected with passwords can't be used for chain
+	// creation
+	ItemFilter filter1(DataType::CERTIFICATE);
+	filter1.exportableOnly = true;
+	filter1.noPassword = true;
+	test.CheckSchemeVersion(filter1, NEW_ENC_SCHEME);
+
+	ItemFilter filter2(DataType::CHAIN_CERT_0, DataType::CHAIN_CERT_15);
+	filter2.exportableOnly = true;
+	filter2.noPassword = true;
+	test.CheckSchemeVersion(filter2, NEW_ENC_SCHEME);
 }
 
 BOOST_AUTO_TEST_SUITE_END()
diff --git a/tests/test_for-each-file.cpp b/tests/test_for-each-file.cpp
index 60baf35e..543910b7 100644
--- a/tests/test_for-each-file.cpp
+++ b/tests/test_for-each-file.cpp
@@ -32,16 +32,17 @@ BOOST_AUTO_TEST_SUITE(TRAVERSE_DIR_TEST)
 
 BOOST_AUTO_TEST_CASE(T010_check_prefix)
 {
-    std::vector<std::string> files;
+	std::vector<std::string> files;
 
-    forEachFile(DB_TEST_DIR "/traverse", [&files](const std::string &filename) {
-        if (filename.find("res-") == std::string::npos)
-            return;
+	forEachFile(DB_TEST_DIR "/traverse", [&files](const std::string & filename) {
+		if (filename.find("res-") == std::string::npos)
+			return;
 
-        files.push_back(filename);
-    });
+		files.push_back(filename);
+	});
 
-    BOOST_REQUIRE_MESSAGE(files.size() == 10, "files num in traverse dir should be 10");
+	BOOST_REQUIRE_MESSAGE(files.size() == 10,
+						  "files num in traverse dir should be 10");
 }
 
 BOOST_AUTO_TEST_SUITE_END()
diff --git a/tests/test_safe-buffer.cpp b/tests/test_safe-buffer.cpp
index a324fe14..fa42c369 100644
--- a/tests/test_safe-buffer.cpp
+++ b/tests/test_safe-buffer.cpp
@@ -33,45 +33,48 @@ namespace {
 
 const size_t LEN = 100;
 
-struct Item
-{
-    Item(size_t a) : mA(a) {}
-    ~Item() {}
+struct Item {
+	Item(size_t a) : mA(a) {}
+	~Item() {}
 
-    bool operator==(const size_t& other) const {
-        return mA == other;
-    }
+	bool operator==(const size_t &other) const
+	{
+		return mA == other;
+	}
 
-    size_t mA;
+	size_t mA;
 };
 
 template <typename T>
 size_t buffer_erase_test()
 {
-    typename T::value_type* data = NULL;
-    typename T::size_type i = 0;
-    {
-        T buffer;
-        for (i=0;i<LEN;++i)
-            buffer.push_back(typename T::value_type(i));
-
-        data = buffer.data();
-
-        for (i=0;i<LEN;++i)
-            BOOST_CHECK(data[i] == i);
-    }
-
-    /*
-     *  operator delete of RawBuffer which is called after buffer memory is erased
-     *  (see erase_on_dealloc::deallocate) sometimes leaves garbage in the beginning of that memory.
-     *  Therefore the test will be marked as failing only if more than 1/10 of the data matches
-     *  original
-     */
-    size_t cnt = 0;
-    for (i=0;i<LEN;++i)
-        cnt += (data[i] == i?1:0);
-
-    return cnt;
+	typename T::value_type *data = NULL;
+	typename T::size_type i = 0;
+
+	{
+		T buffer;
+
+		for (i = 0; i < LEN; ++i)
+			buffer.push_back(typename T::value_type(i));
+
+		data = buffer.data();
+
+		for (i = 0; i < LEN; ++i)
+			BOOST_CHECK(data[i] == i);
+	}
+
+	/*
+	 *  operator delete of RawBuffer which is called after buffer memory is erased
+	 *  (see erase_on_dealloc::deallocate) sometimes leaves garbage in the beginning of that memory.
+	 *  Therefore the test will be marked as failing only if more than 1/10 of the data matches
+	 *  original
+	 */
+	size_t cnt = 0;
+
+	for (i = 0; i < LEN; ++i)
+		cnt += (data[i] == i ? 1 : 0);
+
+	return cnt;
 }
 
 } // namespace anonymous
@@ -80,28 +83,36 @@ BOOST_AUTO_TEST_SUITE(SAFE_BUFFER_TEST)
 
 // Tests for SafeBuffer. Checks if memory occupied by the buffer is wiped after it's deleted.
 
-BOOST_AUTO_TEST_CASE(SafeBufferTest_uc_control_group) {
-    size_t cnt = buffer_erase_test<std::vector<unsigned char> >();
+BOOST_AUTO_TEST_CASE(SafeBufferTest_uc_control_group)
+{
+	size_t cnt = buffer_erase_test<std::vector<unsigned char>>();
 
-    BOOST_REQUIRE_MESSAGE(cnt > LEN/2, "Less than 1/2 of data matches the original.");
+	BOOST_REQUIRE_MESSAGE(cnt > LEN / 2,
+						  "Less than 1/2 of data matches the original.");
 }
 
-BOOST_AUTO_TEST_CASE(SafeBufferTest_item_control_group) {
-    size_t cnt = buffer_erase_test<std::vector<Item> >();
+BOOST_AUTO_TEST_CASE(SafeBufferTest_item_control_group)
+{
+	size_t cnt = buffer_erase_test<std::vector<Item>>();
 
-    BOOST_REQUIRE_MESSAGE(cnt > LEN/2, "Less than 1/2 of data matches the original.");
+	BOOST_REQUIRE_MESSAGE(cnt > LEN / 2,
+						  "Less than 1/2 of data matches the original.");
 }
 
-BOOST_AUTO_TEST_CASE(SafeBufferTest_uc) {
-    size_t cnt = buffer_erase_test<RawBuffer>();
+BOOST_AUTO_TEST_CASE(SafeBufferTest_uc)
+{
+	size_t cnt = buffer_erase_test<RawBuffer>();
 
-    BOOST_REQUIRE_MESSAGE(cnt <= LEN/10, "More than 1/10 of data matches the original.");
+	BOOST_REQUIRE_MESSAGE(cnt <= LEN / 10,
+						  "More than 1/10 of data matches the original.");
 }
 
-BOOST_AUTO_TEST_CASE(SafeBufferTest_item) {
-    size_t cnt = buffer_erase_test<SafeBuffer<Item>::Type>();
+BOOST_AUTO_TEST_CASE(SafeBufferTest_item)
+{
+	size_t cnt = buffer_erase_test<SafeBuffer<Item>::Type>();
 
-    BOOST_REQUIRE_MESSAGE(cnt <= LEN/10, "More than 1/10 of data matches the original.");
+	BOOST_REQUIRE_MESSAGE(cnt <= LEN / 10,
+						  "More than 1/10 of data matches the original.");
 }
 
 BOOST_AUTO_TEST_SUITE_END()
diff --git a/tests/test_serialization.cpp b/tests/test_serialization.cpp
index 653e5fd2..5fff3af8 100644
--- a/tests/test_serialization.cpp
+++ b/tests/test_serialization.cpp
@@ -36,103 +36,111 @@ std::string AAD_STR("sdfdsgsghrtkghwiuho3irhfoewituhre");
 RawBuffer IV(IV_STR.begin(), IV_STR.end());
 RawBuffer AAD(AAD_STR.begin(), AAD_STR.end());
 
-void checkIntParam(const CryptoAlgorithm& algo, ParamName name, uint64_t expected)
+void checkIntParam(const CryptoAlgorithm &algo, ParamName name,
+				   uint64_t expected)
 {
-    uint64_t integer;
-    BOOST_REQUIRE_MESSAGE(algo.getParam(name, integer),
-                          "Failed to get parameter " << static_cast<int>(name));
-    BOOST_REQUIRE_MESSAGE(
-            integer == expected,
-            "Parameter " << static_cast<int>(name) <<
-            " expected value: " << expected <<
-            " got: " << integer);
+	uint64_t integer;
+	BOOST_REQUIRE_MESSAGE(algo.getParam(name, integer),
+						  "Failed to get parameter " << static_cast<int>(name));
+	BOOST_REQUIRE_MESSAGE(
+		integer == expected,
+		"Parameter " << static_cast<int>(name) <<
+		" expected value: " << expected <<
+		" got: " << integer);
 }
 
-void checkIntParamNegative(const CryptoAlgorithm& algo, ParamName name)
+void checkIntParamNegative(const CryptoAlgorithm &algo, ParamName name)
 {
-    uint64_t integer;
-    BOOST_REQUIRE_MESSAGE(!algo.getParam(name, integer),
-                          "Getting int parameter " << static_cast<int>(name) << " should fail");
+	uint64_t integer;
+	BOOST_REQUIRE_MESSAGE(!algo.getParam(name, integer),
+						  "Getting int parameter " << static_cast<int>(name) << " should fail");
 }
 
-void checkBufferParam(const CryptoAlgorithm& algo, ParamName name, RawBuffer expected)
+void checkBufferParam(const CryptoAlgorithm &algo, ParamName name,
+					  RawBuffer expected)
 {
-    RawBuffer buffer;
-    BOOST_REQUIRE_MESSAGE(algo.getParam(name, buffer),
-                          "Failed to get buffer parameter " << static_cast<int>(name));
-    BOOST_REQUIRE_MESSAGE(buffer == expected,
-                          "Parameter " << static_cast<int>(name) << " different than expected");
+	RawBuffer buffer;
+	BOOST_REQUIRE_MESSAGE(algo.getParam(name, buffer),
+						  "Failed to get buffer parameter " << static_cast<int>(name));
+	BOOST_REQUIRE_MESSAGE(buffer == expected,
+						  "Parameter " << static_cast<int>(name) << " different than expected");
 }
 
-void checkBufferParamNegative(const CryptoAlgorithm& algo, ParamName name)
+void checkBufferParamNegative(const CryptoAlgorithm &algo, ParamName name)
 {
-    RawBuffer buffer;
-    BOOST_REQUIRE_MESSAGE(!algo.getParam(name, buffer),
-                          "Getting buffer parameter " << static_cast<int>(name) << " should fail");
+	RawBuffer buffer;
+	BOOST_REQUIRE_MESSAGE(!algo.getParam(name, buffer),
+						  "Getting buffer parameter " << static_cast<int>(name) << " should fail");
 }
 
 template <typename T>
-void setParam(CryptoAlgorithm& algo, ParamName name, const T& value, bool success)
+void setParam(CryptoAlgorithm &algo, ParamName name, const T &value,
+			  bool success)
 {
-    BOOST_REQUIRE_MESSAGE(success == algo.setParam(name, value),
-                          "Adding param " << static_cast<int>(name) <<
-                          " should " << (success ? "succeed":"fail"));
+	BOOST_REQUIRE_MESSAGE(success == algo.setParam(name, value),
+						  "Adding param " << static_cast<int>(name) <<
+						  " should " << (success ? "succeed" : "fail"));
 }
 
 } // namespace anonymous
 
 BOOST_AUTO_TEST_SUITE(SERIALIZATION_TEST)
 
-BOOST_AUTO_TEST_CASE(Serialization_CryptoAlgorithm) {
-    CryptoAlgorithm ca;
-    setParam(ca,ParamName::ALGO_TYPE, static_cast<uint64_t>(AlgoType::AES_GCM), true);
-    setParam(ca,ParamName::ED_IV, AAD, true);
-    setParam(ca,ParamName::ED_IV, IV, true); // try to overwrite
-    setParam(ca,ParamName::ED_TAG_LEN, 128, true);
-    setParam(ca,ParamName::ED_AAD, AAD, true);
-
-    CryptoAlgorithmSerializable input(ca);
-    CryptoAlgorithmSerializable output;
-    auto msg = MessageBuffer::Serialize(input);
-    RawBuffer buffer = msg.Pop();
-    MessageBuffer resp;
-    resp.Push(buffer);
-    resp.Deserialize(output);
-
-    checkIntParam(output, ParamName::ALGO_TYPE, static_cast<uint64_t>(AlgoType::AES_GCM));
-    checkBufferParam(output, ParamName::ED_IV, IV);
-    checkIntParam(output, ParamName::ED_TAG_LEN, 128);
-    checkBufferParam(output, ParamName::ED_AAD, AAD);
-
-    // wrong type
-    checkBufferParamNegative(output, ParamName::ALGO_TYPE);
-    checkIntParamNegative(output, ParamName::ED_IV);
-
-    // non-existing
-    checkIntParamNegative(output, ParamName::ED_CTR_LEN);
-    checkBufferParamNegative(output, ParamName::ED_LABEL);
-    checkIntParamNegative(output, ParamName::GEN_KEY_LEN);
-    checkIntParamNegative(output, ParamName::GEN_EC);
-    checkIntParamNegative(output, ParamName::SV_HASH_ALGO);
-    checkIntParamNegative(output, ParamName::SV_RSA_PADDING);
-
-    checkIntParamNegative(output, static_cast<ParamName>(666));
+BOOST_AUTO_TEST_CASE(Serialization_CryptoAlgorithm)
+{
+	CryptoAlgorithm ca;
+	setParam(ca, ParamName::ALGO_TYPE, static_cast<uint64_t>(AlgoType::AES_GCM),
+			 true);
+	setParam(ca, ParamName::ED_IV, AAD, true);
+	setParam(ca, ParamName::ED_IV, IV, true); // try to overwrite
+	setParam(ca, ParamName::ED_TAG_LEN, 128, true);
+	setParam(ca, ParamName::ED_AAD, AAD, true);
+
+	CryptoAlgorithmSerializable input(ca);
+	CryptoAlgorithmSerializable output;
+	auto msg = MessageBuffer::Serialize(input);
+	RawBuffer buffer = msg.Pop();
+	MessageBuffer resp;
+	resp.Push(buffer);
+	resp.Deserialize(output);
+
+	checkIntParam(output, ParamName::ALGO_TYPE,
+				  static_cast<uint64_t>(AlgoType::AES_GCM));
+	checkBufferParam(output, ParamName::ED_IV, IV);
+	checkIntParam(output, ParamName::ED_TAG_LEN, 128);
+	checkBufferParam(output, ParamName::ED_AAD, AAD);
+
+	// wrong type
+	checkBufferParamNegative(output, ParamName::ALGO_TYPE);
+	checkIntParamNegative(output, ParamName::ED_IV);
+
+	// non-existing
+	checkIntParamNegative(output, ParamName::ED_CTR_LEN);
+	checkBufferParamNegative(output, ParamName::ED_LABEL);
+	checkIntParamNegative(output, ParamName::GEN_KEY_LEN);
+	checkIntParamNegative(output, ParamName::GEN_EC);
+	checkIntParamNegative(output, ParamName::SV_HASH_ALGO);
+	checkIntParamNegative(output, ParamName::SV_RSA_PADDING);
+
+	checkIntParamNegative(output, static_cast<ParamName>(666));
 }
 
-BOOST_AUTO_TEST_CASE(Serialization_CryptoAlgorithm_wrong_name) {
-    CryptoAlgorithm ca;
-    // param name out of range
-    setParam(ca, static_cast<ParamName>(666), 666, false);
-    // param name not supported by serializer
-    setParam(ca, static_cast<ParamName>(10), 666, true);
-
-    CryptoAlgorithmSerializable input(ca);
-    CryptoAlgorithmSerializable output;
-    auto msg = MessageBuffer::Serialize(input);
-    RawBuffer buffer = msg.Pop();
-    MessageBuffer resp;
-    resp.Push(buffer);
-    BOOST_REQUIRE_THROW(resp.Deserialize(output), CryptoAlgorithmSerializable::UnsupportedParam);
+BOOST_AUTO_TEST_CASE(Serialization_CryptoAlgorithm_wrong_name)
+{
+	CryptoAlgorithm ca;
+	// param name out of range
+	setParam(ca, static_cast<ParamName>(666), 666, false);
+	// param name not supported by serializer
+	setParam(ca, static_cast<ParamName>(10), 666, true);
+
+	CryptoAlgorithmSerializable input(ca);
+	CryptoAlgorithmSerializable output;
+	auto msg = MessageBuffer::Serialize(input);
+	RawBuffer buffer = msg.Pop();
+	MessageBuffer resp;
+	resp.Push(buffer);
+	BOOST_REQUIRE_THROW(resp.Deserialize(output),
+						CryptoAlgorithmSerializable::UnsupportedParam);
 }
 
 BOOST_AUTO_TEST_SUITE_END()
diff --git a/tests/test_sql.cpp b/tests/test_sql.cpp
index a07329e6..6b2a7a67 100644
--- a/tests/test_sql.cpp
+++ b/tests/test_sql.cpp
@@ -37,131 +37,145 @@
 #pragma GCC diagnostic push
 #pragma GCC diagnostic warning "-Wdeprecated-declarations"
 
-
 const char *encrypt_me = "/tmp/encryptme.db";
 const char *encrypt_me_not = "/tmp/encryptmenot.db";
 
 const char *create_table = "CREATE TABLE t1(a,b);";
 const char *insert_table = "INSERT INTO t1(a,b) VALUES ("
-                                       " 'one for the money',"
-                                       " 'two for the show');";
+						   " 'one for the money',"
+						   " 'two for the show');";
 const char *select_table = "SELECT * FROM t1";
 
 CKM::RawBuffer raw_password = createDefaultPass();
 
 BOOST_AUTO_TEST_SUITE(SQL_TEST)
-BOOST_AUTO_TEST_CASE(sqlTestConversion){
-
-    BOOST_REQUIRE_MESSAGE(raw_password.size() == RAW_PASS_SIZE,
-            "Password should have 32 characters, got: " << raw_password.size());
-    std::string pass_check = rawToHexString(raw_password);
-    BOOST_REQUIRE_MESSAGE(pass_check.length() == HEX_PASS_SIZE,
-            "Hex string should have 64 characters, got: " << pass_check.length());
-    BOOST_CHECK(pass_check == pattern);
+BOOST_AUTO_TEST_CASE(sqlTestConversion)
+{
+	BOOST_REQUIRE_MESSAGE(raw_password.size() == RAW_PASS_SIZE,
+						  "Password should have 32 characters, got: " << raw_password.size());
+	std::string pass_check = rawToHexString(raw_password);
+	BOOST_REQUIRE_MESSAGE(pass_check.length() == HEX_PASS_SIZE,
+						  "Hex string should have 64 characters, got: " << pass_check.length());
+	BOOST_CHECK(pass_check == pattern);
 }
 
-BOOST_AUTO_TEST_CASE(sqlTestConversionBig){
-    /* 192 ~ 208 in hex */
-    const std::string tmppattern = "c0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0";
+BOOST_AUTO_TEST_CASE(sqlTestConversionBig)
+{
+	/* 192 ~ 208 in hex */
+	const std::string tmppattern = "c0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0";
 
-    auto pass = createPass(192, 209);
-    BOOST_REQUIRE_MESSAGE(pass.size() == 17, "Password size should be 17");
+	auto pass = createPass(192, 209);
+	BOOST_REQUIRE_MESSAGE(pass.size() == 17, "Password size should be 17");
 
-    auto pass_hex = rawToHexString(pass);
-    BOOST_REQUIRE_MESSAGE(pass_hex.length() == 34, "Hexed password size should be 34");
-    BOOST_CHECK(pass_hex == tmppattern);
+	auto pass_hex = rawToHexString(pass);
+	BOOST_REQUIRE_MESSAGE(pass_hex.length() == 34,
+						  "Hexed password size should be 34");
+	BOOST_CHECK(pass_hex == tmppattern);
 }
 
-BOOST_AUTO_TEST_CASE(sqlTestSetKeyTooShort) {
-    using namespace CKM::DB;
-    BOOST_CHECK(unlink(encrypt_me_not) == 0 || errno == ENOENT);
-    SqlConnection connection(encrypt_me_not,
-                               SqlConnection::Flag::CRW);
-    CKM::RawBuffer wrong_key(RAW_PASS_SIZE - 1, 1);
-    BOOST_REQUIRE_THROW(connection.SetKey(wrong_key),
-            SqlConnection::Exception::InvalidArguments);
+BOOST_AUTO_TEST_CASE(sqlTestSetKeyTooShort)
+{
+	using namespace CKM::DB;
+	BOOST_CHECK(unlink(encrypt_me_not) == 0 || errno == ENOENT);
+	SqlConnection connection(encrypt_me_not,
+							 SqlConnection::Flag::CRW);
+	CKM::RawBuffer wrong_key(RAW_PASS_SIZE - 1, 1);
+	BOOST_REQUIRE_THROW(connection.SetKey(wrong_key),
+						SqlConnection::Exception::InvalidArguments);
 }
 
-BOOST_AUTO_TEST_CASE(sqlTestSetKeyTooLong) {
-    using namespace CKM::DB;
-    BOOST_CHECK(unlink(encrypt_me_not) == 0 || errno == ENOENT);
-    SqlConnection connection(encrypt_me_not,
-                               SqlConnection::Flag::CRW);
-    CKM::RawBuffer wrong_key(RAW_PASS_SIZE + 1, 1);
-    BOOST_REQUIRE_THROW(connection.SetKey(wrong_key),
-            SqlConnection::Exception::InvalidArguments);
+BOOST_AUTO_TEST_CASE(sqlTestSetKeyTooLong)
+{
+	using namespace CKM::DB;
+	BOOST_CHECK(unlink(encrypt_me_not) == 0 || errno == ENOENT);
+	SqlConnection connection(encrypt_me_not,
+							 SqlConnection::Flag::CRW);
+	CKM::RawBuffer wrong_key(RAW_PASS_SIZE + 1, 1);
+	BOOST_REQUIRE_THROW(connection.SetKey(wrong_key),
+						SqlConnection::Exception::InvalidArguments);
 }
 
-BOOST_AUTO_TEST_CASE(sqlTestConnectionUnencrypted) {
-    using namespace CKM::DB;
-    BOOST_CHECK(unlink(encrypt_me_not) == 0 || errno == ENOENT);
-    {
-        SqlConnection encrypting_you_not(encrypt_me_not,
-                                     SqlConnection::Flag::CRW);
-        BOOST_REQUIRE_NO_THROW(encrypting_you_not.ExecCommand(create_table));
-        BOOST_REQUIRE_NO_THROW(encrypting_you_not.ExecCommand(insert_table));
-    }
-    {
-        SqlConnection encrypting_you_not(encrypt_me_not,
-                                     SqlConnection::Flag::RW);
-        SqlConnection::DataCommandUniquePtr selectCommand;
-        BOOST_REQUIRE_NO_THROW(selectCommand = encrypting_you_not.
-            PrepareDataCommand(select_table));
-        BOOST_REQUIRE_NO_THROW(selectCommand->Step());
-        std::string value;
-        BOOST_REQUIRE_NO_THROW(value = selectCommand->GetColumnString(0));
-        BOOST_REQUIRE(value == "one for the money");
-    }
+BOOST_AUTO_TEST_CASE(sqlTestConnectionUnencrypted)
+{
+	using namespace CKM::DB;
+	BOOST_CHECK(unlink(encrypt_me_not) == 0 || errno == ENOENT);
+
+	{
+		SqlConnection encrypting_you_not(encrypt_me_not,
+										 SqlConnection::Flag::CRW);
+		BOOST_REQUIRE_NO_THROW(encrypting_you_not.ExecCommand(create_table));
+		BOOST_REQUIRE_NO_THROW(encrypting_you_not.ExecCommand(insert_table));
+	}
+
+	{
+		SqlConnection encrypting_you_not(encrypt_me_not,
+										 SqlConnection::Flag::RW);
+		SqlConnection::DataCommandUniquePtr selectCommand;
+		BOOST_REQUIRE_NO_THROW(selectCommand = encrypting_you_not.
+											   PrepareDataCommand(select_table));
+		BOOST_REQUIRE_NO_THROW(selectCommand->Step());
+		std::string value;
+		BOOST_REQUIRE_NO_THROW(value = selectCommand->GetColumnString(0));
+		BOOST_REQUIRE(value == "one for the money");
+	}
 }
 
-BOOST_AUTO_TEST_CASE(sqlTestConnectionEncrypted) {
-    using namespace CKM::DB;
-    BOOST_CHECK(unlink(encrypt_me) == 0 || errno == ENOENT);
-    {
-        SqlConnection encrypting_you(encrypt_me,
-                                     SqlConnection::Flag::CRW);
-        BOOST_REQUIRE_NO_THROW(encrypting_you.SetKey(raw_password));
-        BOOST_REQUIRE_NO_THROW(encrypting_you.ExecCommand(create_table));
-        BOOST_REQUIRE_NO_THROW(encrypting_you.ExecCommand(insert_table));
-    }
-    {
-        SqlConnection encrypting_you(encrypt_me,
-                                     SqlConnection::Flag::RW);
-        encrypting_you.SetKey(raw_password);
-        SqlConnection::DataCommandUniquePtr selectCommand;
-        BOOST_REQUIRE_NO_THROW(selectCommand = encrypting_you.
-            PrepareDataCommand(select_table));
-        BOOST_REQUIRE_NO_THROW(selectCommand->Step());
-        std::string value;
-        BOOST_REQUIRE_NO_THROW(value = selectCommand->GetColumnString(0));
-        BOOST_REQUIRE(value == "one for the money");
-    }
+BOOST_AUTO_TEST_CASE(sqlTestConnectionEncrypted)
+{
+	using namespace CKM::DB;
+	BOOST_CHECK(unlink(encrypt_me) == 0 || errno == ENOENT);
+
+	{
+		SqlConnection encrypting_you(encrypt_me,
+									 SqlConnection::Flag::CRW);
+		BOOST_REQUIRE_NO_THROW(encrypting_you.SetKey(raw_password));
+		BOOST_REQUIRE_NO_THROW(encrypting_you.ExecCommand(create_table));
+		BOOST_REQUIRE_NO_THROW(encrypting_you.ExecCommand(insert_table));
+	}
+
+	{
+		SqlConnection encrypting_you(encrypt_me,
+									 SqlConnection::Flag::RW);
+		encrypting_you.SetKey(raw_password);
+		SqlConnection::DataCommandUniquePtr selectCommand;
+		BOOST_REQUIRE_NO_THROW(selectCommand = encrypting_you.
+											   PrepareDataCommand(select_table));
+		BOOST_REQUIRE_NO_THROW(selectCommand->Step());
+		std::string value;
+		BOOST_REQUIRE_NO_THROW(value = selectCommand->GetColumnString(0));
+		BOOST_REQUIRE(value == "one for the money");
+	}
 }
 
-BOOST_AUTO_TEST_CASE(sqlTestConnectionEncryptedNegative) {
-
-    using namespace CKM::DB;
-    BOOST_CHECK(unlink(encrypt_me) == 0 || errno == ENOENT);
-    {
-        SqlConnection encrypting_you(encrypt_me,
-                                     SqlConnection::Flag::CRW);
-        BOOST_REQUIRE_NO_THROW(encrypting_you.SetKey(raw_password));
-        BOOST_REQUIRE_NO_THROW(encrypting_you.ExecCommand(create_table));
-        BOOST_REQUIRE_NO_THROW(encrypting_you.ExecCommand(insert_table));
-    }
-    {
-        SqlConnection encrypting_you(encrypt_me,
-                                     SqlConnection::Flag::RW);
-        CKM::RawBuffer wrong_password;
-        for(std::size_t i = 0; i < RAW_PASS_SIZE; i++) {
-            wrong_password.push_back(raw_password[i] + 1);
-        }
-        BOOST_REQUIRE_NO_THROW(encrypting_you.SetKey(wrong_password));
-
-        SqlConnection::DataCommandUniquePtr selectCommand;
-        BOOST_REQUIRE_THROW(selectCommand = encrypting_you.PrepareDataCommand(select_table),
-                SqlConnection::Exception::SyntaxError)
-    }
+BOOST_AUTO_TEST_CASE(sqlTestConnectionEncryptedNegative)
+{
+	using namespace CKM::DB;
+	BOOST_CHECK(unlink(encrypt_me) == 0 || errno == ENOENT);
+
+	{
+		SqlConnection encrypting_you(encrypt_me,
+									 SqlConnection::Flag::CRW);
+		BOOST_REQUIRE_NO_THROW(encrypting_you.SetKey(raw_password));
+		BOOST_REQUIRE_NO_THROW(encrypting_you.ExecCommand(create_table));
+		BOOST_REQUIRE_NO_THROW(encrypting_you.ExecCommand(insert_table));
+	}
+
+	{
+		SqlConnection encrypting_you(encrypt_me,
+									 SqlConnection::Flag::RW);
+		CKM::RawBuffer wrong_password;
+
+		for (std::size_t i = 0; i < RAW_PASS_SIZE; i++)
+			wrong_password.push_back(raw_password[i] + 1);
+
+		BOOST_REQUIRE_NO_THROW(encrypting_you.SetKey(wrong_password));
+
+		SqlConnection::DataCommandUniquePtr selectCommand;
+		BOOST_REQUIRE_THROW(selectCommand = encrypting_you.PrepareDataCommand(
+												select_table),
+							SqlConnection::Exception::SyntaxError)
+	}
 }
+
 BOOST_AUTO_TEST_SUITE_END()
 #pragma GCC diagnostic pop
diff --git a/tests/test_watched-thread.h b/tests/test_watched-thread.h
index 57ae0cf0..fe65decf 100644
--- a/tests/test_watched-thread.h
+++ b/tests/test_watched-thread.h
@@ -34,46 +34,48 @@ DECLARE_EXCEPTION_TYPE(CKM::Exception, ThreadErrorMessage)
 template <typename F, typename... Args>
 class WatchedThread {
 public:
-    // can't use rreferences for Args because std::thread needs to copy all arguments
-    explicit WatchedThread(F&& function, const Args&... args) :
-        m_function(std::move(function)),
-        m_thread(&WatchedThread::Wrapper, this, args...)
-    {}
+	// can't use rreferences for Args because std::thread needs to copy all arguments
+	explicit WatchedThread(F &&function, const Args &... args) :
+		m_function(std::move(function)),
+		m_thread(&WatchedThread::Wrapper, this, args...) {}
 
-    ~WatchedThread() {
-        m_thread.join();
-        if (!m_error.empty())
-            BOOST_FAIL(m_error);
-    }
+	~WatchedThread()
+	{
+		m_thread.join();
 
-    NONCOPYABLE(WatchedThread);
+		if (!m_error.empty())
+			BOOST_FAIL(m_error);
+	}
 
-    WatchedThread(WatchedThread&&) = default;
-    WatchedThread& operator=(WatchedThread&&) = default;
+	NONCOPYABLE(WatchedThread);
 
-protected:
+	WatchedThread(WatchedThread &&) = default;
+	WatchedThread &operator=(WatchedThread &&) = default;
 
-    void Wrapper(const Args&... args) {
-        try {
-            m_function(args...);
-        } catch (const ThreadErrorMessage& e) {
-            m_error = e.DumpToString();
-        }
-    }
+protected:
+	void Wrapper(const Args &... args)
+	{
+		try {
+			m_function(args...);
+		} catch (const ThreadErrorMessage &e) {
+			m_error = e.DumpToString();
+		}
+	}
 
-    std::string m_error;
-    F m_function;
-    std::thread m_thread;
+	std::string m_error;
+	F m_function;
+	std::thread m_thread;
 };
 
 template <typename F, typename... Args>
-WatchedThread<F, Args...> CreateWatchedThread(F&& function, const Args&... args)
+WatchedThread<F, Args...> CreateWatchedThread(F &&function,
+		const Args &... args)
 {
-    return WatchedThread<F, Args...>(std::move(function), args...);
+	return WatchedThread<F, Args...>(std::move(function), args...);
 }
 
-#define THREAD_REQUIRE_MESSAGE(expr, message)                \
-    do {                                                     \
-        if (!(expr))                                         \
-            ThrowMsg( ThreadErrorMessage, message);          \
-    } while (false);
+#define THREAD_REQUIRE_MESSAGE(expr, message)      \
+	do {                                           \
+		if (!(expr))                               \
+			ThrowMsg(ThreadErrorMessage, message); \
+	} while (false);
diff --git a/tests/test_xml-parser.cpp b/tests/test_xml-parser.cpp
index 44692611..ab25ce94 100644
--- a/tests/test_xml-parser.cpp
+++ b/tests/test_xml-parser.cpp
@@ -27,8 +27,7 @@
 using namespace CKM;
 using namespace XML;
 
-namespace
-{
+namespace {
 const char *XML_1_okay          = "XML_1_okay.xml";
 const char *XSD_1_okay          = "XML_1_okay.xsd";
 const char *XML_1_wrong         = "XML_1_wrong.xml";
@@ -41,20 +40,20 @@ const char *XSD_4_device_key    = "XML_4_device_key.xsd";
 
 std::string format_test_path(const char *file)
 {
-    return std::string(DB_TEST_DIR) + "/" + std::string(file);
+	return std::string(DB_TEST_DIR) + "/" + std::string(file);
 }
 
 bool startCallbackFlag = false;
 XML::Parser::ElementHandlerPtr dummyStartCallback()
 {
-    startCallbackFlag = true;
-    // return empty pointer
-    return XML::Parser::ElementHandlerPtr();
+	startCallbackFlag = true;
+	// return empty pointer
+	return XML::Parser::ElementHandlerPtr();
 }
 bool endCallbackFlag = false;
 void dummyEndCallback(const XML::Parser::ElementHandlerPtr &)
 {
-    endCallbackFlag = true;
+	endCallbackFlag = true;
 }
 }
 
@@ -62,258 +61,270 @@ BOOST_AUTO_TEST_SUITE(XML_PARSER_TEST)
 
 BOOST_AUTO_TEST_CASE(XmlParserTest_wrong_argument)
 {
-    std::string emptyPath;
-    XML::Parser parser(emptyPath);
-    BOOST_REQUIRE(Parser::ErrorCode::ERROR_INVALID_ARGUMENT == parser.Validate(emptyPath));
+	std::string emptyPath;
+	XML::Parser parser(emptyPath);
+	BOOST_REQUIRE(Parser::ErrorCode::ERROR_INVALID_ARGUMENT == parser.Validate(
+					  emptyPath));
 
-    // no listeners
-    BOOST_REQUIRE(Parser::ErrorCode::ERROR_INVALID_ARGUMENT == parser.Parse());
+	// no listeners
+	BOOST_REQUIRE(Parser::ErrorCode::ERROR_INVALID_ARGUMENT == parser.Parse());
 
-    BOOST_REQUIRE(Parser::ErrorCode::PARSE_SUCCESS == parser.RegisterElementCb("Key", dummyStartCallback, dummyEndCallback));
-    BOOST_REQUIRE(Parser::ErrorCode::ERROR_XML_PARSE_FAILED == parser.Parse());
+	BOOST_REQUIRE(Parser::ErrorCode::PARSE_SUCCESS ==
+				  parser.RegisterElementCb("Key", dummyStartCallback, dummyEndCallback));
+	BOOST_REQUIRE(Parser::ErrorCode::ERROR_XML_PARSE_FAILED == parser.Parse());
 }
 
 BOOST_AUTO_TEST_CASE(XmlParserTest_no_XML_file)
 {
-    XML::Parser parser(format_test_path("i-am-not-here").c_str());
-    BOOST_REQUIRE(Parser::ErrorCode::ERROR_XML_VALIDATION_FAILED == parser.Validate(format_test_path(XSD_1_okay).c_str()));
+	XML::Parser parser(format_test_path("i-am-not-here").c_str());
+	BOOST_REQUIRE(Parser::ErrorCode::ERROR_XML_VALIDATION_FAILED == parser.Validate(
+					  format_test_path(XSD_1_okay).c_str()));
 }
 
 BOOST_AUTO_TEST_CASE(XmlParserTest_XML1_correct_verify)
 {
-    XML::Parser parser(format_test_path(XML_1_okay).c_str());
-    BOOST_REQUIRE(0 == parser.Validate(format_test_path(XSD_1_okay).c_str()));
+	XML::Parser parser(format_test_path(XML_1_okay).c_str());
+	BOOST_REQUIRE(0 == parser.Validate(format_test_path(XSD_1_okay).c_str()));
 }
 
 BOOST_AUTO_TEST_CASE(XmlParserTest_XML1_wrong_verify)
 {
-    XML::Parser parser(format_test_path(XML_1_wrong).c_str());
-    BOOST_REQUIRE(Parser::ErrorCode::ERROR_XML_VALIDATION_FAILED == parser.Validate(format_test_path(XSD_1_okay).c_str()));
+	XML::Parser parser(format_test_path(XML_1_wrong).c_str());
+	BOOST_REQUIRE(Parser::ErrorCode::ERROR_XML_VALIDATION_FAILED == parser.Validate(
+					  format_test_path(XSD_1_okay).c_str()));
 }
 
 BOOST_AUTO_TEST_CASE(XmlParserTest_XML1_wrong_schema)
 {
-    XML::Parser parser(format_test_path(XML_1_okay).c_str());
-    BOOST_REQUIRE(Parser::ErrorCode::ERROR_XSD_PARSE_FAILED == parser.Validate(format_test_path(XSD_1_wrong).c_str()));
+	XML::Parser parser(format_test_path(XML_1_okay).c_str());
+	BOOST_REQUIRE(Parser::ErrorCode::ERROR_XSD_PARSE_FAILED == parser.Validate(
+					  format_test_path(XSD_1_wrong).c_str()));
 }
 
 BOOST_AUTO_TEST_CASE(XmlParserTest_XML1_correct_parse_incorrect_callbacks)
 {
-    XML::Parser parser(format_test_path(XML_1_okay).c_str());
-    BOOST_REQUIRE(0 == parser.Validate(format_test_path(XSD_1_okay).c_str()));
+	XML::Parser parser(format_test_path(XML_1_okay).c_str());
+	BOOST_REQUIRE(0 == parser.Validate(format_test_path(XSD_1_okay).c_str()));
 
-    BOOST_REQUIRE(Parser::ErrorCode::PARSE_SUCCESS == parser.RegisterElementCb("Data", NULL, NULL));
-    BOOST_REQUIRE(Parser::ErrorCode::PARSE_SUCCESS == parser.Parse());
+	BOOST_REQUIRE(Parser::ErrorCode::PARSE_SUCCESS ==
+				  parser.RegisterElementCb("Data", NULL, NULL));
+	BOOST_REQUIRE(Parser::ErrorCode::PARSE_SUCCESS == parser.Parse());
 }
 
 BOOST_AUTO_TEST_CASE(XmlParserTest_XML1_correct_parse)
 {
-    XML::Parser parser(format_test_path(XML_1_okay).c_str());
-    BOOST_REQUIRE(0 == parser.Validate(format_test_path(XSD_1_okay).c_str()));
-
-    BOOST_REQUIRE(Parser::ErrorCode::PARSE_SUCCESS == parser.RegisterElementCb("Key", dummyStartCallback, NULL));
-    BOOST_REQUIRE(Parser::ErrorCode::PARSE_SUCCESS == parser.RegisterElementCb("Cert", NULL, dummyEndCallback));
-    startCallbackFlag = false;
-    endCallbackFlag = false;
-    BOOST_REQUIRE(Parser::ErrorCode::PARSE_SUCCESS == parser.Parse());
-    BOOST_REQUIRE(startCallbackFlag == true);
-    BOOST_REQUIRE(endCallbackFlag == true);
+	XML::Parser parser(format_test_path(XML_1_okay).c_str());
+	BOOST_REQUIRE(0 == parser.Validate(format_test_path(XSD_1_okay).c_str()));
+
+	BOOST_REQUIRE(Parser::ErrorCode::PARSE_SUCCESS ==
+				  parser.RegisterElementCb("Key", dummyStartCallback, NULL));
+	BOOST_REQUIRE(Parser::ErrorCode::PARSE_SUCCESS ==
+				  parser.RegisterElementCb("Cert", NULL, dummyEndCallback));
+	startCallbackFlag = false;
+	endCallbackFlag = false;
+	BOOST_REQUIRE(Parser::ErrorCode::PARSE_SUCCESS == parser.Parse());
+	BOOST_REQUIRE(startCallbackFlag == true);
+	BOOST_REQUIRE(endCallbackFlag == true);
 }
 
-class StructureTest
-{
+class StructureTest {
 public:
-    class ExpectedSumHandler : public XML::Parser::ElementHandler
-    {
-        public:
-            ExpectedSumHandler() : m_value(0) {}
-
-            virtual void Start(const XML::Parser::Attributes &) {}
-            virtual void Characters(const std::string &data) {
-                m_value = atoi(data.c_str());
-            }
-            virtual void End() {}
-
-            int getSum() const {
-                return m_value;
-            }
-
-        protected:
-            int m_value;
-    };
-
-    class MathHandler : public XML::Parser::ElementHandler
-    {
-        public:
-            MathHandler() : m_valueSet(false), m_value(0), m_powerFactor(1) {}
-
-            virtual void Start(const XML::Parser::Attributes &attr) {
-                const auto & it = attr.find("powerFactor");
-                if(it != attr.end())
-                    m_powerFactor = atoi(it->second.c_str());
-            }
-            virtual void Characters(const std::string &data) {
-                m_value = pow(atoi(data.c_str()), m_powerFactor);
-                m_valueSet = true;
-            }
-            virtual void End() {}
-
-            virtual int compute(int prevVal) = 0;
-
-        protected:
-            bool m_valueSet;
-            int m_value;
-            int m_powerFactor;
-    };
-    class AddHandler : public MathHandler
-    {
-        public:
-            virtual int compute(int prevVal) {
-                if( !m_valueSet )
-                    return prevVal;
-
-                return prevVal + m_value;
-            }
-    };
-
-    class MultiplyHandler : public MathHandler
-    {
-        public:
-            virtual int compute(int prevVal) {
-                if( !m_valueSet )
-                    return prevVal;
-
-                return prevVal * m_value;
-            }
-    };
-
-    class DivHandler : public MathHandler
-    {
-        public:
-            virtual int compute(int prevVal) {
-                if( !m_valueSet )
-                    return prevVal;
-
-                if(m_value == 0)
-                    return prevVal;
-                return prevVal / m_value;
-            }
-    };
-
-    StructureTest(const char *filename) : m_parser(filename), m_sum(0), m_expectedSum(0)
-    {
-        m_parser.RegisterErrorCb(StructureTest::Error);
-        m_parser.RegisterElementCb("Add",
-                [this]() -> XML::Parser::ElementHandlerPtr
-                {
-                    return std::make_shared<AddHandler>();
-                },
-                [this](const XML::Parser::ElementHandlerPtr & element)
-                {
-                    // add computation
-                    if(element)
-                    {
-                        MathHandler *mathElement = reinterpret_cast<MathHandler*>(element.get());
-                        m_sum = mathElement->compute(m_sum);
-                    }
-                });
-        m_parser.RegisterElementCb("Multiply",
-                [this]() -> XML::Parser::ElementHandlerPtr
-                {
-                    return std::make_shared<MultiplyHandler>();
-                },
-                [this](const XML::Parser::ElementHandlerPtr &element)
-                {
-                    // multiply computation
-                    if(element)
-                    {
-                        MathHandler *mathElement = reinterpret_cast<MathHandler*>(element.get());
-                        m_sum = mathElement->compute(m_sum);
-                    }
-                });
-        m_parser.RegisterElementCb("Div",
-                [this]() -> XML::Parser::ElementHandlerPtr
-                {
-                    return std::make_shared<DivHandler>();
-                },
-                [this](const XML::Parser::ElementHandlerPtr &element)
-                {
-                    // division computation
-                    if(element)
-                    {
-                        MathHandler *mathElement = reinterpret_cast<MathHandler*>(element.get());
-                        m_sum = mathElement->compute(m_sum);
-                    }
-                });
-        m_parser.RegisterElementCb("ExpectedSum",
-                [this]() -> XML::Parser::ElementHandlerPtr
-                {
-                    return std::make_shared<ExpectedSumHandler>();
-                },
-                [this](const XML::Parser::ElementHandlerPtr &element)
-                {
-                    if(element)
-                    {
-                        ExpectedSumHandler *sumElement = reinterpret_cast<ExpectedSumHandler*>(element.get());
-                        m_expectedSum = sumElement->getSum();
-                    }
-                });
-    }
-
-    static void Error(const Parser::ErrorType /*errorType*/,
-                      const std::string & log_msg)
-    {
-        BOOST_FAIL(log_msg);
-    }
-
-    int Parse()
-    {
-        return m_parser.Parse();
-    }
-
-    int getSum() const {
-        return m_sum;
-    }
-    int getExpectedSum() const {
-        return m_expectedSum;
-    }
+	class ExpectedSumHandler : public XML::Parser::ElementHandler {
+	public:
+		ExpectedSumHandler() : m_value(0) {}
+
+		virtual void Start(const XML::Parser::Attributes &) {}
+		virtual void Characters(const std::string &data)
+		{
+			m_value = atoi(data.c_str());
+		}
+		virtual void End() {}
+
+		int getSum() const
+		{
+			return m_value;
+		}
+
+	protected:
+		int m_value;
+	};
+
+	class MathHandler : public XML::Parser::ElementHandler {
+	public:
+		MathHandler() : m_valueSet(false), m_value(0), m_powerFactor(1) {}
+
+		virtual void Start(const XML::Parser::Attributes &attr)
+		{
+			const auto &it = attr.find("powerFactor");
+
+			if (it != attr.end())
+				m_powerFactor = atoi(it->second.c_str());
+		}
+		virtual void Characters(const std::string &data)
+		{
+			m_value = pow(atoi(data.c_str()), m_powerFactor);
+			m_valueSet = true;
+		}
+		virtual void End() {}
+
+		virtual int compute(int prevVal) = 0;
+
+	protected:
+		bool m_valueSet;
+		int m_value;
+		int m_powerFactor;
+	};
+	class AddHandler : public MathHandler {
+	public:
+		virtual int compute(int prevVal)
+		{
+			if (!m_valueSet)
+				return prevVal;
+
+			return prevVal + m_value;
+		}
+	};
+
+	class MultiplyHandler : public MathHandler {
+	public:
+		virtual int compute(int prevVal)
+		{
+			if (!m_valueSet)
+				return prevVal;
+
+			return prevVal * m_value;
+		}
+	};
+
+	class DivHandler : public MathHandler {
+	public:
+		virtual int compute(int prevVal)
+		{
+			if (!m_valueSet)
+				return prevVal;
+
+			if (m_value == 0)
+				return prevVal;
+
+			return prevVal / m_value;
+		}
+	};
+
+	StructureTest(const char *filename) : m_parser(filename), m_sum(0),
+		m_expectedSum(0)
+	{
+		m_parser.RegisterErrorCb(StructureTest::Error);
+		m_parser.RegisterElementCb("Add",
+		[this]() -> XML::Parser::ElementHandlerPtr {
+			return std::make_shared<AddHandler>();
+		},
+		[this](const XML::Parser::ElementHandlerPtr & element) {
+			// add computation
+			if (element) {
+				MathHandler *mathElement = reinterpret_cast<MathHandler *>(element.get());
+				m_sum = mathElement->compute(m_sum);
+			}
+		});
+
+		m_parser.RegisterElementCb("Multiply",
+		[this]() -> XML::Parser::ElementHandlerPtr {
+			return std::make_shared<MultiplyHandler>();
+		},
+		[this](const XML::Parser::ElementHandlerPtr & element) {
+			// multiply computation
+			if (element) {
+				MathHandler *mathElement = reinterpret_cast<MathHandler *>(element.get());
+				m_sum = mathElement->compute(m_sum);
+			}
+		});
+
+		m_parser.RegisterElementCb("Div",
+		[this]() -> XML::Parser::ElementHandlerPtr {
+			return std::make_shared<DivHandler>();
+		},
+		[this](const XML::Parser::ElementHandlerPtr & element) {
+			// division computation
+			if (element) {
+				MathHandler *mathElement = reinterpret_cast<MathHandler *>(element.get());
+				m_sum = mathElement->compute(m_sum);
+			}
+		});
+
+		m_parser.RegisterElementCb("ExpectedSum",
+		[this]() -> XML::Parser::ElementHandlerPtr {
+			return std::make_shared<ExpectedSumHandler>();
+		},
+		[this](const XML::Parser::ElementHandlerPtr & element) {
+			if (element) {
+				ExpectedSumHandler *sumElement = reinterpret_cast<ExpectedSumHandler *>
+												 (element.get());
+				m_expectedSum = sumElement->getSum();
+			}
+		});
+	}
+
+	static void Error(const Parser::ErrorType /*errorType*/,
+					  const std::string &log_msg)
+	{
+		BOOST_FAIL(log_msg);
+	}
+
+	int Parse()
+	{
+		return m_parser.Parse();
+	}
+
+	int getSum() const
+	{
+		return m_sum;
+	}
+
+	int getExpectedSum() const
+	{
+		return m_expectedSum;
+	}
+
 private:
-    XML::Parser m_parser;
-    int m_sum;
-    int m_expectedSum;
+	XML::Parser m_parser;
+	int m_sum;
+	int m_expectedSum;
 };
 
 BOOST_AUTO_TEST_CASE(XmlParserTest_XML2_structure)
 {
-    StructureTest parser(format_test_path(XML_2_structure).c_str());
-    BOOST_REQUIRE(0 == parser.Parse());
-    BOOST_REQUIRE_MESSAGE(parser.getSum() == parser.getExpectedSum(),
-                          "got sum: " << parser.getSum() << " while expected: " << parser.getExpectedSum());
+	StructureTest parser(format_test_path(XML_2_structure).c_str());
+	BOOST_REQUIRE(0 == parser.Parse());
+	BOOST_REQUIRE_MESSAGE(parser.getSum() == parser.getExpectedSum(),
+						  "got sum: " << parser.getSum() << " while expected: " <<
+						  parser.getExpectedSum());
 }
 
 BOOST_AUTO_TEST_CASE(XmlParserTest_XML3_encrypted_correct_parse)
 {
-    XML::Parser parser(format_test_path(XML_3_encrypted).c_str());
-    BOOST_REQUIRE(0 == parser.Validate(format_test_path(XSD_3_encrypted).c_str()));
-
-    BOOST_REQUIRE(Parser::ErrorCode::PARSE_SUCCESS == parser.RegisterElementCb("Key", dummyStartCallback, NULL));
-    BOOST_REQUIRE(Parser::ErrorCode::PARSE_SUCCESS == parser.RegisterElementCb("Cert", NULL, dummyEndCallback));
-    startCallbackFlag = false;
-    endCallbackFlag = false;
-    BOOST_REQUIRE(Parser::ErrorCode::PARSE_SUCCESS == parser.Parse());
-    BOOST_REQUIRE(startCallbackFlag == true);
-    BOOST_REQUIRE(endCallbackFlag == true);
+	XML::Parser parser(format_test_path(XML_3_encrypted).c_str());
+	BOOST_REQUIRE(0 == parser.Validate(format_test_path(XSD_3_encrypted).c_str()));
+
+	BOOST_REQUIRE(Parser::ErrorCode::PARSE_SUCCESS ==
+				  parser.RegisterElementCb("Key", dummyStartCallback, NULL));
+	BOOST_REQUIRE(Parser::ErrorCode::PARSE_SUCCESS ==
+				  parser.RegisterElementCb("Cert", NULL, dummyEndCallback));
+	startCallbackFlag = false;
+	endCallbackFlag = false;
+	BOOST_REQUIRE(Parser::ErrorCode::PARSE_SUCCESS == parser.Parse());
+	BOOST_REQUIRE(startCallbackFlag == true);
+	BOOST_REQUIRE(endCallbackFlag == true);
 }
 
 BOOST_AUTO_TEST_CASE(XmlParserTest_XML4_device_key_correct_parse)
 {
-    XML::Parser parser(format_test_path(XML_4_device_key).c_str());
-    BOOST_REQUIRE(0 == parser.Validate(format_test_path(XSD_4_device_key).c_str()));
-
-    BOOST_REQUIRE(Parser::ErrorCode::PARSE_SUCCESS == parser.RegisterElementCb("RSAPrivateKey", dummyStartCallback, NULL));
-    startCallbackFlag = false;
-    BOOST_REQUIRE(Parser::ErrorCode::PARSE_SUCCESS == parser.Parse());
-    BOOST_REQUIRE(startCallbackFlag == true);
+	XML::Parser parser(format_test_path(XML_4_device_key).c_str());
+	BOOST_REQUIRE(0 == parser.Validate(format_test_path(XSD_4_device_key).c_str()));
+
+	BOOST_REQUIRE(Parser::ErrorCode::PARSE_SUCCESS ==
+				  parser.RegisterElementCb("RSAPrivateKey", dummyStartCallback, NULL));
+	startCallbackFlag = false;
+	BOOST_REQUIRE(Parser::ErrorCode::PARSE_SUCCESS == parser.Parse());
+	BOOST_REQUIRE(startCallbackFlag == true);
 }
 
 BOOST_AUTO_TEST_SUITE_END()