diff options
Diffstat (limited to 'src/components/utils')
66 files changed, 1297 insertions, 1285 deletions
diff --git a/src/components/utils/include/utils/appenders_loader.h b/src/components/utils/include/utils/appenders_loader.h index 03d3217994..65556e6862 100644 --- a/src/components/utils/include/utils/appenders_loader.h +++ b/src/components/utils/include/utils/appenders_loader.h @@ -40,6 +40,7 @@ class AppendersLoader { AppendersLoader(); ~AppendersLoader(); bool Loaded() const; + private: void* handle_; }; diff --git a/src/components/utils/include/utils/back_trace.h b/src/components/utils/include/utils/back_trace.h index f2410e36bc..180714e5a6 100644 --- a/src/components/utils/include/utils/back_trace.h +++ b/src/components/utils/include/utils/back_trace.h @@ -68,8 +68,8 @@ class Backtrace { std::vector<void*> backtrace_; }; -std::ostream& operator<< (std::ostream& os, const Backtrace& bt); +std::ostream& operator<<(std::ostream& os, const Backtrace& bt); -} // namespace utils +} // namespace utils -#endif // SRC_COMPONENTS_UTILS_INCLUDE_UTILS_BACK_TRACE_H_ +#endif // SRC_COMPONENTS_UTILS_INCLUDE_UTILS_BACK_TRACE_H_ diff --git a/src/components/utils/include/utils/bitstream.h b/src/components/utils/include/utils/bitstream.h index 6b9d6337ef..13eacc6cb1 100644 --- a/src/components/utils/include/utils/bitstream.h +++ b/src/components/utils/include/utils/bitstream.h @@ -57,12 +57,21 @@ class BitStream { // Mark stream as badly-formed. // Should be called by Extract* family of procedures if they decide // that stream is invalid - void MarkBad() { bad_ = true; } + void MarkBad() { + bad_ = true; + } // Predicates to check whether there were errors while parsing // Stream is good when it is created - bool IsGood() { return !bad_; } - bool IsBad() { return bad_; } - operator bool() { return IsGood(); } + bool IsGood() { + return !bad_; + } + bool IsBad() { + return bad_; + } + operator bool() { + return IsGood(); + } + private: // These two functions are used for internal stream checks only // Stream parser procedures must not define their logic depending on @@ -78,13 +87,13 @@ class BitStream { // Extract single value, amount of bits read from stream depends on T size // If there is not enough data in the stream, stream is marked bad - template<typename T> + template <typename T> void Extract(T& val); // Read single value, amount of bits read from stream is signaled by |bits| // parameter. T must be wide enough to hold this amount of bits. // If there is not enough data in the stream, stream is marked bad - template<typename T> + template <typename T> void ExtractBits(T& val, size_t bits); // Extract |length| bytes from the stream. Stream read position @@ -94,10 +103,11 @@ class BitStream { private: const uint8_t* bytes_; - const size_t bytes_count_; + const size_t bytes_count_; size_t byte_offset_; size_t bit_offset_; bool bad_; + private: friend void Extract(BitStream*, uint8_t*); friend void Extract(BitStream*, uint8_t*, size_t); @@ -105,7 +115,6 @@ class BitStream { friend void Extract(BitStream*, uint32_t*, size_t); friend void Extract(BitStream*, std::string*, size_t); friend void Extract(BitStream*, std::vector<uint8_t>*, size_t); - }; // Extract single byte from stream @@ -133,16 +142,15 @@ void Extract(BitStream* bs, std::string* str, size_t length); // vector |data|. If stream is too short it is marked bad. void Extract(BitStream* bs, std::vector<uint8_t>* data, size_t length); - // Template member definitions -template<typename T> +template <typename T> void BitStream::Extract(T& val) { // Slow but simple implementation // It's a space for bit stream reading optimization ExtractBits(val, sizeof(val) * CHAR_BIT); } -template<typename T> +template <typename T> void BitStream::ExtractBits(T& val, size_t bits) { DCHECK(sizeof(val) * CHAR_BIT >= bits); if (IsGood()) { @@ -164,7 +172,6 @@ void BitStream::ExtractBits(T& val, size_t bits) { } } -} // namespace utils - +} // namespace utils -#endif // SRC_COMPONENTS_UTILS_INCLUDE_UTILS_BITSTREAM_H_ +#endif // SRC_COMPONENTS_UTILS_INCLUDE_UTILS_BITSTREAM_H_ diff --git a/src/components/utils/include/utils/convert_utils.h b/src/components/utils/include/utils/convert_utils.h index b3e849d6bd..0609164a60 100644 --- a/src/components/utils/include/utils/convert_utils.h +++ b/src/components/utils/include/utils/convert_utils.h @@ -60,7 +60,6 @@ unsigned long long int ConvertUInt64ToLongLongUInt(const uint64_t value); */ uint64_t ConvertLongLongUIntToUInt64(const unsigned long long int value); - /** * Convert one number value to another type value */ diff --git a/src/components/utils/include/utils/file_system.h b/src/components/utils/include/utils/file_system.h index 0757a17110..5862241c9c 100644 --- a/src/components/utils/include/utils/file_system.h +++ b/src/components/utils/include/utils/file_system.h @@ -41,7 +41,6 @@ namespace file_system { - /** * @brief Get available disc space. * @@ -165,7 +164,8 @@ bool DeleteFile(const std::string& name); * @brief Removes directory. * * @param name path to directory. - * @param is_recursively true if you need delete directory recursively, otherwise false. + * @param is_recursively true if you need delete directory recursively, + *otherwise false. * @return returns true if the directory is successfully deleted. */ bool RemoveDirectory(const std::string& directory_name, @@ -220,8 +220,7 @@ bool WriteBinaryFile(const std::string& name, * @param result read data * @return returns true if the operation is successfully. */ -bool ReadBinaryFile(const std::string& name, - std::vector<uint8_t>& result); +bool ReadBinaryFile(const std::string& name, std::vector<uint8_t>& result); bool ReadFile(const std::string& name, std::string& result); @@ -255,8 +254,7 @@ uint64_t GetFileModificationTime(const std::string& path); * @param dst Destination file path * @return if result success return true */ -bool CopyFile(const std::string& src, - const std::string& dst); +bool CopyFile(const std::string& src, const std::string& dst); /** * @brief Move file from source to destination @@ -265,8 +263,7 @@ bool CopyFile(const std::string& src, * @param dst Destination file path * @return if result success return true */ -bool MoveFile(const std::string& src, - const std::string& dst); +bool MoveFile(const std::string& src, const std::string& dst); void remove_directory_content(const std::string& directory_name); diff --git a/src/components/utils/include/utils/helpers.h b/src/components/utils/include/utils/helpers.h index f16acfc90a..17d4af27a1 100644 --- a/src/components/utils/include/utils/helpers.h +++ b/src/components/utils/include/utils/helpers.h @@ -31,12 +31,13 @@ */ #ifndef SRC_COMPONENTS_UTILS_INCLUDE_UTILS_HELPERS_H #define SRC_COMPONENTS_UTILS_INCLUDE_UTILS_HELPERS_H -#include<algorithm> +#include <algorithm> /** * These helpers allows to simplify compare strategy between some objects. * Suppose user has some enum with value E with some numbers of possible values * enum E {V1, V2, V3, V5}; - * So we want to know if some user-input value is belong to one of the enum's subset. + * So we want to know if some user-input value is belong to one of the enum's + *subset. * Usually user has to do next routine * * E input_value = V3; @@ -56,71 +57,72 @@ */ namespace helpers { - template<typename T> - bool EQ (T what, T to) { - return what == to; - } - - template<typename T> - bool NEQ (T what, T to) { - return !EQ<T>(what, to); - } +template <typename T> +bool EQ(T what, T to) { + return what == to; +} - template<class U = bool> - bool ALL (U what, U to) { - return what && to; - } +template <typename T> +bool NEQ(T what, T to) { + return !EQ<T>(what, to); +} - template<class U = bool> - bool ONE (U what, U to) { - return what || to; - } +template <class U = bool> +bool ALL(U what, U to) { + return what && to; +} - template <typename T, - bool (*CompareType)(T ,T), - bool (*CmpStrategy)(bool ,bool)> - bool Compare (T what, T to) { - return CompareType(what, to); - } +template <class U = bool> +bool ONE(U what, U to) { + return what || to; +} - template <typename T, - bool (*CompareType)(T ,T), - bool (*CmpStrategy)(bool, bool)> - bool Compare(T what, T to, T to1) { - return CmpStrategy(Compare<T, CompareType, CmpStrategy>(what, to), - Compare<T, CompareType, CmpStrategy>(what, to1)); - } +template <typename T, + bool (*CompareType)(T, T), + bool (*CmpStrategy)(bool, bool)> +bool Compare(T what, T to) { + return CompareType(what, to); +} - template <typename T, - bool (*CompareType)(T ,T), - bool (*CmpStrategy)(bool, bool)> - bool Compare(T what, T to, T to1, T to2) { - return CmpStrategy(Compare<T, CompareType, CmpStrategy>(what, to, to1), - Compare<T, CompareType, CmpStrategy>(what, to2)); - } +template <typename T, + bool (*CompareType)(T, T), + bool (*CmpStrategy)(bool, bool)> +bool Compare(T what, T to, T to1) { + return CmpStrategy(Compare<T, CompareType, CmpStrategy>(what, to), + Compare<T, CompareType, CmpStrategy>(what, to1)); +} - template <typename T, - bool (*CompareType)(T ,T), - bool (*CmpStrategy)(bool, bool)> - bool Compare(T what, T to, T to1, T to2, T to3) { - return CmpStrategy(Compare<T, CompareType, CmpStrategy>(what, to, to1, to2), - Compare<T, CompareType, CmpStrategy>(what, to3)); - } +template <typename T, + bool (*CompareType)(T, T), + bool (*CmpStrategy)(bool, bool)> +bool Compare(T what, T to, T to1, T to2) { + return CmpStrategy(Compare<T, CompareType, CmpStrategy>(what, to, to1), + Compare<T, CompareType, CmpStrategy>(what, to2)); +} - template <typename T, - bool (*CompareType)(T ,T), - bool (*CmpStrategy)(bool, bool)> - bool Compare(T what, T to, T to1, T to2, T to3, T to4) { - return CmpStrategy(Compare<T, CompareType, CmpStrategy>(what, to, to1, to2, to3), - Compare<T, CompareType, CmpStrategy>(what, to4)); - } +template <typename T, + bool (*CompareType)(T, T), + bool (*CmpStrategy)(bool, bool)> +bool Compare(T what, T to, T to1, T to2, T to3) { + return CmpStrategy(Compare<T, CompareType, CmpStrategy>(what, to, to1, to2), + Compare<T, CompareType, CmpStrategy>(what, to3)); +} +template <typename T, + bool (*CompareType)(T, T), + bool (*CmpStrategy)(bool, bool)> +bool Compare(T what, T to, T to1, T to2, T to3, T to4) { + return CmpStrategy( + Compare<T, CompareType, CmpStrategy>(what, to, to1, to2, to3), + Compare<T, CompareType, CmpStrategy>(what, to4)); +} - template<typename Container> - bool in_range(const Container& container, const typename Container::value_type& value) { - return - std::find(container.begin(), container.end(), value) != container.end(); - } +template <typename Container> +bool in_range(const Container& container, + const typename Container::value_type& value) { + return std::find(container.begin(), container.end(), value) != + container.end(); +} } -#endif // SRC_COMPONENTS_UTILS_INCLUDE_UTILS_HELPERS_H +#endif // SRC_COMPONENTS_UTILS_INCLUDE_UTILS_HELPERS_H diff --git a/src/components/utils/include/utils/log_message_loop_thread.h b/src/components/utils/include/utils/log_message_loop_thread.h index 80816877b6..deea1a07c0 100644 --- a/src/components/utils/include/utils/log_message_loop_thread.h +++ b/src/components/utils/include/utils/log_message_loop_thread.h @@ -53,21 +53,20 @@ typedef struct { typedef std::queue<LogMessage> LogMessageQueue; -typedef threads::MessageLoopThread<LogMessageQueue> LogMessageLoopThreadTemplate; +typedef threads::MessageLoopThread<LogMessageQueue> + LogMessageLoopThreadTemplate; class LogMessageHandler : public LogMessageLoopThreadTemplate::Handler { public: virtual void Handle(const LogMessage message) OVERRIDE; }; -class LogMessageLoopThread : - public LogMessageLoopThreadTemplate { - +class LogMessageLoopThread : public LogMessageLoopThreadTemplate { public: LogMessageLoopThread(); - ~LogMessageLoopThread(); + ~LogMessageLoopThread(); -DISALLOW_COPY_AND_ASSIGN(LogMessageLoopThread); + DISALLOW_COPY_AND_ASSIGN(LogMessageLoopThread); }; } // namespace logger diff --git a/src/components/utils/include/utils/qdb_wrapper/sql_database.h b/src/components/utils/include/utils/qdb_wrapper/sql_database.h index 54c89f678c..ba5c8a722a 100644 --- a/src/components/utils/include/utils/qdb_wrapper/sql_database.h +++ b/src/components/utils/include/utils/qdb_wrapper/sql_database.h @@ -90,6 +90,7 @@ class SQLDatabase { * Call backup for opened DB */ bool Backup(); + protected: /** * Gets connection to the SQLite database diff --git a/src/components/utils/include/utils/qdb_wrapper/sql_error.h b/src/components/utils/include/utils/qdb_wrapper/sql_error.h index 79706cc0ef..25fd558308 100644 --- a/src/components/utils/include/utils/qdb_wrapper/sql_error.h +++ b/src/components/utils/include/utils/qdb_wrapper/sql_error.h @@ -39,8 +39,8 @@ namespace utils { namespace dbms { typedef enum Error { - OK = 0, /* Successful result */ - ERROR /* Error */ + OK = 0, /* Successful result */ + ERROR /* Error */ } Error; /** diff --git a/src/components/utils/include/utils/qdb_wrapper/sql_query.h b/src/components/utils/include/utils/qdb_wrapper/sql_query.h index 34fbfc61c7..f1da6ccad9 100644 --- a/src/components/utils/include/utils/qdb_wrapper/sql_query.h +++ b/src/components/utils/include/utils/qdb_wrapper/sql_query.h @@ -238,7 +238,7 @@ class SQLQuery { /** * The result of query */ - qdb_result_t *result_; + qdb_result_t* result_; /** * The current row in result for select diff --git a/src/components/utils/include/utils/resource_usage.h b/src/components/utils/include/utils/resource_usage.h index ff90b2c22f..4dd8a7eafd 100644 --- a/src/components/utils/include/utils/resource_usage.h +++ b/src/components/utils/include/utils/resource_usage.h @@ -44,8 +44,8 @@ #include "utils/logger.h" -#define MAX_COMM_LEN 128 -#define MAX_CMDLINE_LEN 128 +#define MAX_COMM_LEN 128 +#define MAX_CMDLINE_LEN 128 namespace utils { @@ -56,7 +56,7 @@ struct ResourseUsage { }; class Resources { - public: + public: typedef uint32_t MemInfo; #if defined(__QNXNTO__) typedef procfs_info PidStats; @@ -108,19 +108,18 @@ class Resources { unsigned long long delayacct_blkio_ticks; unsigned long guest_time; long int cguest_time; - }; + }; #else #endif - public: - /* - * @brief Returns current resource usage of process - * @return Raw pointer on ResourseUsage if success, otherwise return NULL - */ + public: + /* + * @brief Returns current resource usage of process + * @return Raw pointer on ResourseUsage if success, otherwise return NULL + */ static ResourseUsage* getCurrentResourseUsage(); -private: - + private: #ifdef BUILD_TESTS friend class ResourceUsagePrivateTest; FRIEND_TEST(ResourceUsagePrivateTest, ReadStatFileTest); @@ -134,7 +133,8 @@ private: /* * @brief reads /proc/PID/stat file on linux * do not work on QNX ( return false, output wan't be changed ) - * @param output - storage for result string ( there will be separated content of /proc/PID/stat ) + * @param output - storage for result string ( there will be separated content + * of /proc/PID/stat ) * @return true on succes false onb fail */ static bool ReadStatFile(std::string& output); @@ -171,9 +171,6 @@ private: */ static const char* proc; }; - } - - #endif /* SRC_COMPONENTS_UTILS_INCLUDE_UTILS_RESOURCE_USAGE_H_ */ diff --git a/src/components/utils/include/utils/signals.h b/src/components/utils/include/utils/signals.h index b8b71b95e3..48120d53cd 100644 --- a/src/components/utils/include/utils/signals.h +++ b/src/components/utils/include/utils/signals.h @@ -34,7 +34,7 @@ #define SRC_COMPONENTS_UTILS_INCLUDE_UTILS_SIGNALS_H_ #ifdef __QNXNTO__ -typedef void (*sighandler_t) (int); +typedef void (*sighandler_t)(int); #else #include <signal.h> #endif diff --git a/src/components/utils/include/utils/singleton.h b/src/components/utils/include/utils/singleton.h index fff7294d1c..b73780ee1d 100644 --- a/src/components/utils/include/utils/singleton.h +++ b/src/components/utils/include/utils/singleton.h @@ -43,15 +43,13 @@ namespace deleters { class DummyDeleter { public: - void grab(void* pointer) { - } + void grab(void* pointer) {} }; -template<typename T> +template <typename T> class Deleter { public: - Deleter() : pointer_(0) { - } + Deleter() : pointer_(0) {} ~Deleter() { if (pointer_) { delete pointer_; @@ -60,69 +58,68 @@ class Deleter { void grab(T* pointer) { pointer_ = pointer; } + private: T* pointer_; }; } // namespace deleters -template<typename T, class Deleter = deleters::DummyDeleter> +template <typename T, class Deleter = deleters::DummyDeleter> class Singleton { -/** - * @brief Singleton template - * Singleton classes must derive from this template specialized with class itself: - * - * class MySingleton : public Singleton<MySingleton> {...}; - * - * All such classes must declare instance() method as friend - * by adding FRIEND_BASE_SINGLETON_CLASS macro from macro.h to class definition: - * - * FRIEND_BASE_SINGLETON_CLASS(MySingleton); - * - * Instance of this class (if created) can be deleted by Deleter destructor - * which is called after main() (or from exit()) - * This requires T destructor to be accessible for Deleter (e.g. public) - * Deleter template parameter can be specified with any class - * with public default constructor, destructor and method - * void grab(T*); - * However, default Deleter specification does nothing - * - * Also instance can be deleted explicitly by calling destroy() method - * - * Both instance() and destroy() methods are thread safe - * but not thread safety between simultaneous calls - * of instance() and destroy() is cared about - */ + /** + * @brief Singleton template + * Singleton classes must derive from this template specialized with class + *itself: + * + * class MySingleton : public Singleton<MySingleton> {...}; + * + * All such classes must declare instance() method as friend + * by adding FRIEND_BASE_SINGLETON_CLASS macro from macro.h to class + *definition: + * + * FRIEND_BASE_SINGLETON_CLASS(MySingleton); + * + * Instance of this class (if created) can be deleted by Deleter destructor + * which is called after main() (or from exit()) + * This requires T destructor to be accessible for Deleter (e.g. public) + * Deleter template parameter can be specified with any class + * with public default constructor, destructor and method + * void grab(T*); + * However, default Deleter specification does nothing + * + * Also instance can be deleted explicitly by calling destroy() method + * + * Both instance() and destroy() methods are thread safe + * but not thread safety between simultaneous calls + * of instance() and destroy() is cared about + */ public: -/** - * @brief Returns the singleton of class - */ + /** + * @brief Returns the singleton of class + */ static T* instance(); -/** - * @brief Destroys the singleton (if it had been created) - */ + /** + * @brief Destroys the singleton (if it had been created) + */ static void destroy(); -/** - * @brief Checks whether the singleton exists - */ + /** + * @brief Checks whether the singleton exists + */ static bool exists(); private: - static T** instance_pointer(); static Deleter* deleter(); static sync_primitives::Lock lock_; }; - -template<typename T, class Deleter> +template <typename T, class Deleter> sync_primitives::Lock Singleton<T, Deleter>::lock_; - -template<typename T, class Deleter> +template <typename T, class Deleter> T* Singleton<T, Deleter>::instance() { - T* local_instance; atomic_pointer_assign(local_instance, *instance_pointer()); memory_barrier(); @@ -142,9 +139,8 @@ T* Singleton<T, Deleter>::instance() { return local_instance; } -template<typename T, class Deleter> +template <typename T, class Deleter> void Singleton<T, Deleter>::destroy() { - T* local_instance; atomic_pointer_assign(local_instance, *instance_pointer()); memory_barrier(); @@ -162,18 +158,18 @@ void Singleton<T, Deleter>::destroy() { } } -template<typename T, class Deleter> +template <typename T, class Deleter> bool Singleton<T, Deleter>::exists() { return *instance_pointer() != 0; } -template<typename T, class Deleter> +template <typename T, class Deleter> T** Singleton<T, Deleter>::instance_pointer() { static T* instance = 0; return &instance; } -template<typename T, class Deleter> +template <typename T, class Deleter> Deleter* Singleton<T, Deleter>::deleter() { static Deleter deleter; return &deleter; diff --git a/src/components/utils/include/utils/sqlite_wrapper/sql_error.h b/src/components/utils/include/utils/sqlite_wrapper/sql_error.h index 70e73820f8..8a53e12169 100644 --- a/src/components/utils/include/utils/sqlite_wrapper/sql_error.h +++ b/src/components/utils/include/utils/sqlite_wrapper/sql_error.h @@ -39,37 +39,37 @@ namespace utils { namespace dbms { typedef enum Error { - OK = 0, /* Successful result */ - ERROR, /* SQL error or missing database */ - INTERNAL, /* Internal logic error in SQLite */ - PERM, /* Access permission denied */ - ABORT, /* Callback routine requested an abort */ - BUSY, /* The database file is locked */ - LOCKED, /* A table in the database is locked */ - NOMEM, /* A malloc() failed */ - READONLY, /* Attempt to write a readonly database */ - INTERRUPT, /* Operation terminated by sqlite3_interrupt()*/ - IOERR, /* Some kind of disk I/O error occurred */ - CORRUPT, /* The database disk image is malformed */ - NOTFOUND, /* Unknown opcode in sqlite3_file_control() */ - FULL, /* Insertion failed because database is full */ - CANTOPEN, /* Unable to open the database file */ - PROTOCOL, /* Database lock protocol error */ - EMPTY, /* Database is empty */ - SCHEMA, /* The database schema changed */ - TOOBIG, /* String or BLOB exceeds size limit */ - CONSTRAINT, /* Abort due to constraint violation */ - MISMATCH, /* Data type mismatch */ - MISUSE, /* Library used incorrectly */ - NOLFS, /* Uses OS features not supported on host */ - AUTH, /* Authorization denied */ - FORMAT, /* Auxiliary database format error */ - RANGE, /* 2nd parameter to sqlite3_bind out of range */ - NOTADB, /* File opened that is not a database file */ - NOTICE, /* Notifications from sqlite3_log() */ - WARNING, /* Warnings from sqlite3_log() */ - ROW = 100, /* sqlite3_step() has another row ready */ - DONE = 101 /* sqlite3_step() has finished executing */ + OK = 0, /* Successful result */ + ERROR, /* SQL error or missing database */ + INTERNAL, /* Internal logic error in SQLite */ + PERM, /* Access permission denied */ + ABORT, /* Callback routine requested an abort */ + BUSY, /* The database file is locked */ + LOCKED, /* A table in the database is locked */ + NOMEM, /* A malloc() failed */ + READONLY, /* Attempt to write a readonly database */ + INTERRUPT, /* Operation terminated by sqlite3_interrupt()*/ + IOERR, /* Some kind of disk I/O error occurred */ + CORRUPT, /* The database disk image is malformed */ + NOTFOUND, /* Unknown opcode in sqlite3_file_control() */ + FULL, /* Insertion failed because database is full */ + CANTOPEN, /* Unable to open the database file */ + PROTOCOL, /* Database lock protocol error */ + EMPTY, /* Database is empty */ + SCHEMA, /* The database schema changed */ + TOOBIG, /* String or BLOB exceeds size limit */ + CONSTRAINT, /* Abort due to constraint violation */ + MISMATCH, /* Data type mismatch */ + MISUSE, /* Library used incorrectly */ + NOLFS, /* Uses OS features not supported on host */ + AUTH, /* Authorization denied */ + FORMAT, /* Auxiliary database format error */ + RANGE, /* 2nd parameter to sqlite3_bind out of range */ + NOTADB, /* File opened that is not a database file */ + NOTICE, /* Notifications from sqlite3_log() */ + WARNING, /* Warnings from sqlite3_log() */ + ROW = 100, /* sqlite3_step() has another row ready */ + DONE = 101 /* sqlite3_step() has finished executing */ } Error; /** diff --git a/src/components/utils/include/utils/stl_utils.h b/src/components/utils/include/utils/stl_utils.h index 70fbadbd5e..4a4e3d2fe8 100644 --- a/src/components/utils/include/utils/stl_utils.h +++ b/src/components/utils/include/utils/stl_utils.h @@ -40,45 +40,48 @@ namespace utils { * Utility class that automatically deletes STL collection of * freestore objects */ -template<class T> +template <class T> class StlCollectionDeleter { public: typedef T Collection; - StlCollectionDeleter(T* collection) - : collection_(collection) { + StlCollectionDeleter(T* collection) : collection_(collection) { DCHECK(collection_); } ~StlCollectionDeleter() { - for (typename Collection::iterator i = collection_->begin(), end = - collection_->end(); i != end; ++i) { + for (typename Collection::iterator i = collection_->begin(), + end = collection_->end(); + i != end; + ++i) { delete *i; *i = NULL; } } + private: Collection* collection_; }; -template<class T> +template <class T> class StlMapDeleter { public: typedef T Collection; - StlMapDeleter(T* collection) - : collection_(collection) { + StlMapDeleter(T* collection) : collection_(collection) { DCHECK(collection_); } ~StlMapDeleter() { - for (typename Collection::iterator i = collection_->begin(), end = - collection_->end(); i != end; ++i) { + for (typename Collection::iterator i = collection_->begin(), + end = collection_->end(); + i != end; + ++i) { delete i->second; i->second = NULL; } - } + private: Collection* collection_; }; } // namespace utils -#endif // SRC_COMPONENTS_UTILS_INCLUDE_UTILS_STL_UTILS_H_ +#endif // SRC_COMPONENTS_UTILS_INCLUDE_UTILS_STL_UTILS_H_ diff --git a/src/components/utils/include/utils/threads/pulse_thread_delegate.h b/src/components/utils/include/utils/threads/pulse_thread_delegate.h index 207b64caaf..623e12b261 100644 --- a/src/components/utils/include/utils/threads/pulse_thread_delegate.h +++ b/src/components/utils/include/utils/threads/pulse_thread_delegate.h @@ -42,9 +42,11 @@ namespace threads { /** * @brief This ThreadDelegate derivative is designed * to implement threads waiting for QNX Pulse messages - * When constucted, an instance of this class creates QNX channel and connects to it + * When constucted, an instance of this class creates QNX channel and connects + * to it * In exitThreadMain() channel is disconnected and destroyed - * In threadMain() endless loop event is armed via pure virtual method ArmEvent() + * In threadMain() endless loop event is armed via pure virtual method + * ArmEvent() * and thread blocks on MsgReceivePulse() waiting for Pulse * When Pulse comes, OnPulse() pure virtual method is invoked * Subclassed must implement ArmEvent() for events of interest @@ -52,39 +54,42 @@ namespace threads { */ class PulseThreadDelegate : public ThreadDelegate { public: -/** - * @brief default constructor - */ + /** + * @brief default constructor + */ PulseThreadDelegate(); virtual void threadMain(); virtual void exitThreadMain(); protected: -/** - * @brief This method is to be implemented to arm events of interest - * @param event pointer to structure sigevent - * @return If this method returns true, thread is blocked on MsgReceivePulse() waiting for Pulse - */ + /** + * @brief This method is to be implemented to arm events of interest + * @param event pointer to structure sigevent + * @return If this method returns true, thread is blocked on + * MsgReceivePulse() waiting for Pulse + */ virtual bool ArmEvent(struct sigevent* event) = 0; -/** - * @brief This method is invoked from threadMain() when Pulse comes - */ + /** + * @brief This method is invoked from threadMain() when Pulse comes + */ virtual void OnPulse() = 0; /** * This method is to be initialize child class * @return If this method returns false, thread will be stopped */ - virtual bool Init() { return true; } + virtual bool Init() { + return true; + } -/** - * Finalizes thread - * Can free resources - */ + /** + * Finalizes thread + * Can free resources + */ virtual void Finalize() {} private: - enum {PULSE_CODE = _PULSE_CODE_MINAVAIL + 1}; + enum { PULSE_CODE = _PULSE_CODE_MINAVAIL + 1 }; volatile bool run_; int chid_; diff --git a/src/components/utils/include/utils/threads/thread_manager.h b/src/components/utils/include/utils/threads/thread_manager.h index d72abb428f..3f53c902c4 100644 --- a/src/components/utils/include/utils/threads/thread_manager.h +++ b/src/components/utils/include/utils/threads/thread_manager.h @@ -51,7 +51,7 @@ #include "utils/threads/thread_delegate.h" namespace threads { - class Thread; +class Thread; /* * This class is here currently to remember names associated to threads. @@ -69,12 +69,13 @@ class ThreadManager : public utils::Singleton<ThreadManager> { }; ThreadManager() {} MessageQueue<ThreadDesc> threads_to_terminate; + private: DISALLOW_COPY_AND_ASSIGN(ThreadManager); FRIEND_BASE_SINGLETON_CLASS(ThreadManager); }; -} // namespace threads +} // namespace threads -#endif // SRC_COMPONENTS_UTILS_INCLUDE_UTILS_THREADS_THREAD_MANAGER_H_ +#endif // SRC_COMPONENTS_UTILS_INCLUDE_UTILS_THREADS_THREAD_MANAGER_H_ diff --git a/src/components/utils/include/utils/threads/thread_validator.h b/src/components/utils/include/utils/threads/thread_validator.h index dc2d138e2e..2e7dac02ab 100644 --- a/src/components/utils/include/utils/threads/thread_validator.h +++ b/src/components/utils/include/utils/threads/thread_validator.h @@ -68,11 +68,11 @@ class SingleThreadSimpleValidator { // of classes being checked for absence of concurrent access void AssertRunningOnCreationThread() const; PlatformThreadHandle creation_thread_id() const; + private: const PlatformThreadHandle creation_thread_id_; }; - /* * This is bit more sophisticated debug helper which allows * objects being checked to be transferred between threads. @@ -97,10 +97,11 @@ class SingleThreadValidator { // of classes being checked for absence of unintended concurrent // access void AssertRunningOnValidThread() const; + private: mutable PlatformThreadHandle owning_thread_id_; }; -} // namespace threads +} // namespace threads -#endif // SRC_COMPONENTS_UTILS_INCLUDE_THREADS_THREAD_VALIDATOR_H_ +#endif // SRC_COMPONENTS_UTILS_INCLUDE_THREADS_THREAD_VALIDATOR_H_ diff --git a/src/components/utils/include/utils/timer.h b/src/components/utils/include/utils/timer.h index 69b2d08a4d..837e7ed598 100644 --- a/src/components/utils/include/utils/timer.h +++ b/src/components/utils/include/utils/timer.h @@ -65,7 +65,7 @@ class Timer { * Stops timer if it's running */ ~Timer(); - + /** * @brief Starts timer with specified timeout * @param timeout Timer timeout diff --git a/src/components/utils/src/auto_trace.cc b/src/components/utils/src/auto_trace.cc index 606e8330cb..0379630319 100644 --- a/src/components/utils/src/auto_trace.cc +++ b/src/components/utils/src/auto_trace.cc @@ -38,32 +38,28 @@ namespace logger { -AutoTrace::AutoTrace( - log4cxx::LoggerPtr logger, - const log4cxx::spi::LocationInfo& location) : - logger_(logger), location_(location) { - if (logger::logs_enabled() && - logger_->isTraceEnabled()) { +AutoTrace::AutoTrace(log4cxx::LoggerPtr logger, + const log4cxx::spi::LocationInfo& location) + : logger_(logger), location_(location) { + if (logger::logs_enabled() && logger_->isTraceEnabled()) { push_log(logger_, ::log4cxx::Level::getTrace(), "Enter", apr_time_now(), location_, - ::log4cxx::spi::LoggingEvent::getCurrentThreadName() - ); + ::log4cxx::spi::LoggingEvent::getCurrentThreadName()); } } AutoTrace::~AutoTrace() { - if (logger::logs_enabled() && - logger_->isTraceEnabled()) { + if (logger::logs_enabled() && logger_->isTraceEnabled()) { push_log(logger_, ::log4cxx::Level::getTrace(), "Exit", apr_time_now(), - location_, // the location corresponds rather to creation of autotrace object than to deletion - ::log4cxx::spi::LoggingEvent::getCurrentThreadName() - ); + location_, // the location corresponds rather to creation of + // autotrace object than to deletion + ::log4cxx::spi::LoggingEvent::getCurrentThreadName()); } } diff --git a/src/components/utils/src/back_trace.cc b/src/components/utils/src/back_trace.cc index f49c60b467..c587643cc6 100644 --- a/src/components/utils/src/back_trace.cc +++ b/src/components/utils/src/back_trace.cc @@ -67,16 +67,16 @@ string demangle(const char* symbol) { Backtrace::Backtrace(int32_t count, int32_t skip_top) : thread_id_(threads::Thread::CurrentId()) { - int32_t skip = skip_top + 1; // Skip this constructor - vector<void*> full_trace (count + skip); + int32_t skip = skip_top + 1; // Skip this constructor + vector<void*> full_trace(count + skip); int32_t captured = backtrace(&full_trace.front(), count + skip); int32_t first_call = std::min(captured, skip); int32_t last_call = std::min(first_call + count, captured); - backtrace_.assign(full_trace.begin() + first_call, full_trace.begin() + last_call); + backtrace_.assign(full_trace.begin() + first_call, + full_trace.begin() + last_call); } -Backtrace::~Backtrace() { -} +Backtrace::~Backtrace() {} vector<string> Backtrace::CallStack() const { vector<string> callstack; @@ -93,15 +93,16 @@ threads::PlatformThreadHandle Backtrace::ThreadId() const { return thread_id_; } -ostream& operator<< (ostream& os, const Backtrace& bt) { +ostream& operator<<(ostream& os, const Backtrace& bt) { const vector<string> symbols = bt.CallStack(); - os<<"Stack trace ("<<bt.ThreadId()<<")\n"; + os << "Stack trace (" << bt.ThreadId() << ")\n"; if (symbols.empty()) { - os<<"Not available"<<std::endl; - } else for (size_t i = 0; i < symbols.size(); ++i) { - os<<symbols[i]<<std::endl; - } + os << "Not available" << std::endl; + } else + for (size_t i = 0; i < symbols.size(); ++i) { + os << symbols[i] << std::endl; + } return os; } -} // namespace utils +} // namespace utils diff --git a/src/components/utils/src/bitstream.cc b/src/components/utils/src/bitstream.cc index ae353b44c6..e0cc502d54 100644 --- a/src/components/utils/src/bitstream.cc +++ b/src/components/utils/src/bitstream.cc @@ -34,15 +34,13 @@ namespace utils { BitStream::BitStream(uint8_t* bytes, size_t bytes_count) - : bytes_(bytes), - bytes_count_(bytes_count), - byte_offset_(0), - bit_offset_(0), - bad_(false) { -} + : bytes_(bytes) + , bytes_count_(bytes_count) + , byte_offset_(0) + , bit_offset_(0) + , bad_(false) {} -BitStream::~BitStream() { -} +BitStream::~BitStream() {} size_t BitStream::FullBytesLeft() { size_t left = bytes_count_ - byte_offset_; @@ -104,7 +102,7 @@ void Extract(BitStream* bs, std::string* str, size_t length) { bs->MarkBad(); return; } - str->resize(length+1); + str->resize(length + 1); void* stringdata = &(*str)[0]; bs->ExtractBytes(stringdata, length); str->resize(length); @@ -129,4 +127,3 @@ void Extract(BitStream* bs, std::vector<uint8_t>* data, size_t length) { } } // namespace utils - diff --git a/src/components/utils/src/conditional_variable_posix.cc b/src/components/utils/src/conditional_variable_posix.cc index 1fde18b1f9..50ebc74556 100644 --- a/src/components/utils/src/conditional_variable_posix.cc +++ b/src/components/utils/src/conditional_variable_posix.cc @@ -49,44 +49,43 @@ CREATE_LOGGERPTR_GLOBAL(logger_, "Utils") ConditionalVariable::ConditionalVariable() { pthread_condattr_t attrs; - int initialized = pthread_condattr_init(&attrs); + int initialized = pthread_condattr_init(&attrs); if (initialized != 0) - LOG4CXX_ERROR(logger_, "Failed to initialize " - "conditional variable attributes"); + LOG4CXX_ERROR(logger_, + "Failed to initialize " + "conditional variable attributes"); pthread_condattr_setclock(&attrs, CLOCK_MONOTONIC); initialized = pthread_cond_init(&cond_var_, &attrs); if (initialized != 0) - LOG4CXX_ERROR(logger_, "Failed to initialize " - "conditional variable"); + LOG4CXX_ERROR(logger_, + "Failed to initialize " + "conditional variable"); int rv = pthread_condattr_destroy(&attrs); if (rv != 0) - LOG4CXX_ERROR(logger_, "Failed to destroy " - "conditional variable attributes"); + LOG4CXX_ERROR(logger_, + "Failed to destroy " + "conditional variable attributes"); } ConditionalVariable::~ConditionalVariable() { pthread_cond_destroy(&cond_var_); - } void ConditionalVariable::NotifyOne() { int signaled = pthread_cond_signal(&cond_var_); if (signaled != 0) LOG4CXX_ERROR(logger_, "Failed to signal conditional variable"); - } void ConditionalVariable::Broadcast() { int signaled = pthread_cond_broadcast(&cond_var_); if (signaled != 0) LOG4CXX_ERROR(logger_, "Failed to broadcast conditional variable"); - } bool ConditionalVariable::Wait(Lock& lock) { lock.AssertTakenAndMarkFree(); - int wait_status = pthread_cond_wait(&cond_var_, - &lock.mutex_); + int wait_status = pthread_cond_wait(&cond_var_, &lock.mutex_); lock.AssertFreeAndMarkTaken(); if (wait_status != 0) { LOG4CXX_ERROR(logger_, "Failed to wait for conditional variable"); @@ -98,8 +97,7 @@ bool ConditionalVariable::Wait(Lock& lock) { bool ConditionalVariable::Wait(AutoLock& auto_lock) { Lock& lock = auto_lock.GetLock(); lock.AssertTakenAndMarkFree(); - int wait_status = pthread_cond_wait(&cond_var_, - &lock.mutex_); + int wait_status = pthread_cond_wait(&cond_var_, &lock.mutex_); lock.AssertFreeAndMarkTaken(); if (wait_status != 0) { LOG4CXX_ERROR(logger_, "Failed to wait for conditional variable"); @@ -109,24 +107,23 @@ bool ConditionalVariable::Wait(AutoLock& auto_lock) { } ConditionalVariable::WaitStatus ConditionalVariable::WaitFor( - AutoLock& auto_lock, uint32_t milliseconds){ + AutoLock& auto_lock, uint32_t milliseconds) { struct timespec now; clock_gettime(CLOCK_MONOTONIC, &now); timespec wait_interval; - wait_interval.tv_sec = now.tv_sec + - (milliseconds / kMillisecondsPerSecond); - wait_interval.tv_nsec = now.tv_nsec + + wait_interval.tv_sec = now.tv_sec + (milliseconds / kMillisecondsPerSecond); + wait_interval.tv_nsec = + now.tv_nsec + (milliseconds % kMillisecondsPerSecond) * kNanosecondsPerMillisecond; wait_interval.tv_sec += wait_interval.tv_nsec / kNanosecondsPerSecond; wait_interval.tv_nsec %= kNanosecondsPerSecond; Lock& lock = auto_lock.GetLock(); lock.AssertTakenAndMarkFree(); - int timedwait_status = pthread_cond_timedwait(&cond_var_, - &lock.mutex_, - &wait_interval); + int timedwait_status = + pthread_cond_timedwait(&cond_var_, &lock.mutex_, &wait_interval); lock.AssertFreeAndMarkTaken(); WaitStatus wait_status = kNoTimeout; - switch(timedwait_status) { + switch (timedwait_status) { case 0: { wait_status = kNoTimeout; break; @@ -140,10 +137,13 @@ ConditionalVariable::WaitStatus ConditionalVariable::WaitFor( break; } default: { - LOG4CXX_ERROR(logger_, "Failed to timewait for conditional variable timedwait_status: " << timedwait_status); + LOG4CXX_ERROR( + logger_, + "Failed to timewait for conditional variable timedwait_status: " + << timedwait_status); } } return wait_status; } -} // namespace sync_primitives +} // namespace sync_primitives diff --git a/src/components/utils/src/convert_utils.cc b/src/components/utils/src/convert_utils.cc index 50a32f3da0..319b231a96 100644 --- a/src/components/utils/src/convert_utils.cc +++ b/src/components/utils/src/convert_utils.cc @@ -52,13 +52,15 @@ int64_t utils::ConvertLongLongIntToInt64(const long long int value) { return static_cast<int64_t>(value); } -unsigned long long int utils::ConvertUInt64ToLongLongUInt(const uint64_t value) { +unsigned long long int utils::ConvertUInt64ToLongLongUInt( + const uint64_t value) { DCHECK(value >= std::numeric_limits<unsigned long long int>::min()); DCHECK(value <= std::numeric_limits<unsigned long long int>::max()); return static_cast<unsigned long long int>(value); } -uint64_t utils::ConvertLongLongUIntToUInt64(const unsigned long long int value) { +uint64_t utils::ConvertLongLongUIntToUInt64( + const unsigned long long int value) { DCHECK_OR_RETURN( value >= std::numeric_limits<uint64_t>::min(), std::min<uint64_t>(value, std::numeric_limits<uint64_t>::min())); diff --git a/src/components/utils/src/date_time.cc b/src/components/utils/src/date_time.cc index 9313874f48..fdf0926eb2 100644 --- a/src/components/utils/src/date_time.cc +++ b/src/components/utils/src/date_time.cc @@ -34,41 +34,41 @@ #include <stdint.h> #include "utils/date_time.h" - namespace date_time { - TimevalStruct DateTime::getCurrentTime() { - TimevalStruct currentTime; - timezone timeZone; +TimevalStruct DateTime::getCurrentTime() { + TimevalStruct currentTime; + timezone timeZone; - gettimeofday(¤tTime, &timeZone); + gettimeofday(¤tTime, &timeZone); - return currentTime; - } + return currentTime; +} -int64_t date_time::DateTime::getSecs(const TimevalStruct &time) { - const TimevalStruct times = ConvertionUsecs(time); - return static_cast<int64_t>(times.tv_sec); +int64_t date_time::DateTime::getSecs(const TimevalStruct& time) { + const TimevalStruct times = ConvertionUsecs(time); + return static_cast<int64_t>(times.tv_sec); } -int64_t DateTime::getmSecs(const TimevalStruct &time) { +int64_t DateTime::getmSecs(const TimevalStruct& time) { const TimevalStruct times = ConvertionUsecs(time); - return static_cast<int64_t>(times.tv_sec) * MILLISECONDS_IN_SECOND - + times.tv_usec / MICROSECONDS_IN_MILLISECOND; + return static_cast<int64_t>(times.tv_sec) * MILLISECONDS_IN_SECOND + + times.tv_usec / MICROSECONDS_IN_MILLISECOND; } -int64_t DateTime::getuSecs(const TimevalStruct &time) { +int64_t DateTime::getuSecs(const TimevalStruct& time) { const TimevalStruct times = ConvertionUsecs(time); - return static_cast<int64_t>(times.tv_sec) * MILLISECONDS_IN_SECOND - * MICROSECONDS_IN_MILLISECOND + times.tv_usec; + return static_cast<int64_t>(times.tv_sec) * MILLISECONDS_IN_SECOND * + MICROSECONDS_IN_MILLISECOND + + times.tv_usec; } int64_t DateTime::calculateTimeSpan(const TimevalStruct& sinceTime) { return calculateTimeDiff(getCurrentTime(), sinceTime); } -int64_t DateTime::calculateTimeDiff(const TimevalStruct &time1, - const TimevalStruct &time2){ +int64_t DateTime::calculateTimeDiff(const TimevalStruct& time1, + const TimevalStruct& time2) { const TimevalStruct times1 = ConvertionUsecs(time1); const TimevalStruct times2 = ConvertionUsecs(time2); TimevalStruct ret; @@ -80,10 +80,10 @@ int64_t DateTime::calculateTimeDiff(const TimevalStruct &time1, return getmSecs(ret); } -void DateTime::AddMilliseconds(TimevalStruct& time, - uint32_t milliseconds) { - const uint32_t sec = milliseconds/MILLISECONDS_IN_SECOND; - const uint32_t usec = (milliseconds%MILLISECONDS_IN_SECOND)*MICROSECONDS_IN_MILLISECOND; +void DateTime::AddMilliseconds(TimevalStruct& time, uint32_t milliseconds) { + const uint32_t sec = milliseconds / MILLISECONDS_IN_SECOND; + const uint32_t usec = + (milliseconds % MILLISECONDS_IN_SECOND) * MICROSECONDS_IN_MILLISECOND; time.tv_sec += sec; time.tv_usec += usec; time = ConvertionUsecs(time); @@ -101,31 +101,35 @@ TimevalStruct DateTime::Sub(const TimevalStruct& time1, bool DateTime::Greater(const TimevalStruct& time1, const TimevalStruct& time2) { const TimevalStruct times1 = ConvertionUsecs(time1); const TimevalStruct times2 = ConvertionUsecs(time2); - return timercmp(×1, ×2, >); + return timercmp(×1, ×2, > ); } bool DateTime::Less(const TimevalStruct& time1, const TimevalStruct& time2) { const TimevalStruct times1 = ConvertionUsecs(time1); const TimevalStruct times2 = ConvertionUsecs(time2); - return timercmp(×1, ×2, <); + return timercmp(×1, ×2, < ); } bool DateTime::Equal(const TimevalStruct& time1, const TimevalStruct& time2) { const TimevalStruct times1 = ConvertionUsecs(time1); const TimevalStruct times2 = ConvertionUsecs(time2); - return !timercmp(×1, ×2, !=); + return !timercmp(×1, ×2, != ); } -TimeCompare date_time::DateTime::compareTime(const TimevalStruct &time1, const TimevalStruct &time2) { - if (Greater(time1, time2)) return GREATER; - if (Less(time1, time2)) return LESS; +TimeCompare date_time::DateTime::compareTime(const TimevalStruct& time1, + const TimevalStruct& time2) { + if (Greater(time1, time2)) + return GREATER; + if (Less(time1, time2)) + return LESS; return EQUAL; } -TimevalStruct date_time::DateTime::ConvertionUsecs(const TimevalStruct &time){ +TimevalStruct date_time::DateTime::ConvertionUsecs(const TimevalStruct& time) { if (time.tv_usec >= MICROSECONDS_IN_SECOND) { TimevalStruct time1; - time1.tv_sec = static_cast<int64_t>(time.tv_sec) + (time.tv_usec/MICROSECONDS_IN_SECOND); + time1.tv_sec = static_cast<int64_t>(time.tv_sec) + + (time.tv_usec / MICROSECONDS_IN_SECOND); time1.tv_usec = static_cast<int64_t>(time.tv_usec) % MICROSECONDS_IN_SECOND; return time1; } @@ -142,6 +146,7 @@ bool operator==(const TimevalStruct& time1, const TimevalStruct& time2) { return date_time::DateTime::Equal(time1, time2); } -const TimevalStruct operator-(const TimevalStruct& time1, const TimevalStruct& time2) { - return date_time::DateTime::Sub(time1, time2); +const TimevalStruct operator-(const TimevalStruct& time1, + const TimevalStruct& time2) { + return date_time::DateTime::Sub(time1, time2); } diff --git a/src/components/utils/src/lock_posix.cc b/src/components/utils/src/lock_posix.cc index 8c943124b4..0a678123f0 100644 --- a/src/components/utils/src/lock_posix.cc +++ b/src/components/utils/src/lock_posix.cc @@ -44,18 +44,18 @@ CREATE_LOGGERPTR_GLOBAL(logger_, "Utils") Lock::Lock() #ifndef NDEBUG - : lock_taken_(0), - is_mutex_recursive_(false) -#endif // NDEBUG + : lock_taken_(0) + , is_mutex_recursive_(false) +#endif // NDEBUG { Init(false); } Lock::Lock(bool is_recursive) #ifndef NDEBUG - : lock_taken_(0), - is_mutex_recursive_(is_recursive) -#endif // NDEBUG + : lock_taken_(0) + , is_mutex_recursive_(is_recursive) +#endif // NDEBUG { Init(is_recursive); } @@ -68,16 +68,18 @@ Lock::~Lock() { #endif int32_t status = pthread_mutex_destroy(&mutex_); if (status != 0) { - LOG4CXX_ERROR(logger_, "Failed to destroy mutex " << &mutex_ << ": " - << strerror(status)); + LOG4CXX_ERROR(logger_, + "Failed to destroy mutex " << &mutex_ << ": " + << strerror(status)); } } void Lock::Acquire() { const int32_t status = pthread_mutex_lock(&mutex_); if (status != 0) { - LOG4CXX_FATAL(logger_, "Failed to acquire mutex " << &mutex_ << ": " - << strerror(status)); + LOG4CXX_FATAL(logger_, + "Failed to acquire mutex " << &mutex_ << ": " + << strerror(status)); DCHECK(status != 0); } else { AssertFreeAndMarkTaken(); @@ -88,8 +90,9 @@ void Lock::Release() { AssertTakenAndMarkFree(); const int32_t status = pthread_mutex_unlock(&mutex_); if (status != 0) { - LOG4CXX_ERROR(logger_, "Failed to unlock mutex" << &mutex_ << ": " - << strerror(status)); + LOG4CXX_ERROR(logger_, + "Failed to unlock mutex" << &mutex_ << ": " + << strerror(status)); } } @@ -125,9 +128,8 @@ void Lock::Init(bool is_recursive) { pthread_mutexattr_t attr; pthread_mutexattr_init(&attr); - const int32_t mutex_type = is_recursive - ? PTHREAD_MUTEX_RECURSIVE - : PTHREAD_MUTEX_ERRORCHECK; + const int32_t mutex_type = + is_recursive ? PTHREAD_MUTEX_RECURSIVE : PTHREAD_MUTEX_ERRORCHECK; pthread_mutexattr_settype(&attr, mutex_type); const int32_t status = pthread_mutex_init(&mutex_, &attr); @@ -135,8 +137,8 @@ void Lock::Init(bool is_recursive) { pthread_mutexattr_destroy(&attr); if (status != 0) { - LOG4CXX_FATAL(logger_, "Failed to initialize mutex. " - << std::strerror(status)); + LOG4CXX_FATAL(logger_, + "Failed to initialize mutex. " << std::strerror(status)); DCHECK(status != 0); } } diff --git a/src/components/utils/src/log_message_loop_thread.cc b/src/components/utils/src/log_message_loop_thread.cc index 1403a5f712..77bc8107eb 100644 --- a/src/components/utils/src/log_message_loop_thread.cc +++ b/src/components/utils/src/log_message_loop_thread.cc @@ -43,13 +43,12 @@ void LogMessageHandler::Handle(const LogMessage message) { message.threadName); } -LogMessageLoopThread::LogMessageLoopThread() : - LogMessageLoopThreadTemplate("Logger", new LogMessageHandler()) { -} +LogMessageLoopThread::LogMessageLoopThread() + : LogMessageLoopThreadTemplate("Logger", new LogMessageHandler()) {} LogMessageLoopThread::~LogMessageLoopThread() { -// we'll have to drop messages -// while deleting logger thread + // we'll have to drop messages + // while deleting logger thread logger_status = DeletingLoggerThread; } diff --git a/src/components/utils/src/logger.cc b/src/components/utils/src/logger.cc index 7d6eb6386a..4e93ca3d14 100644 --- a/src/components/utils/src/logger.cc +++ b/src/components/utils/src/logger.cc @@ -35,15 +35,17 @@ #include "utils/logger_status.h" #include <apr_time.h> -void deinit_logger () { +void deinit_logger() { CREATE_LOGGERPTR_LOCAL(logger_, "Utils") LOG4CXX_DEBUG(logger_, "Logger deinitialization"); logger::set_logs_enabled(false); logger::delete_log_message_loop_thread(); log4cxx::LoggerPtr rootLogger = log4cxx::Logger::getRootLogger(); - log4cxx::spi::LoggerRepositoryPtr repository = rootLogger->getLoggerRepository(); + log4cxx::spi::LoggerRepositoryPtr repository = + rootLogger->getLoggerRepository(); log4cxx::LoggerList loggers = repository->getCurrentLoggers(); - for (log4cxx::LoggerList::iterator i = loggers.begin(); i != loggers.end(); ++i) { + for (log4cxx::LoggerList::iterator i = loggers.begin(); i != loggers.end(); + ++i) { log4cxx::LoggerPtr logger = *i; logger->removeAllAppenders(); } diff --git a/src/components/utils/src/push_log.cc b/src/components/utils/src/push_log.cc index 9825ad9df4..6e16c99181 100644 --- a/src/components/utils/src/push_log.cc +++ b/src/components/utils/src/push_log.cc @@ -44,10 +44,10 @@ bool push_log(log4cxx::LoggerPtr logger, const std::string& entry, log4cxx_time_t timeStamp, const log4cxx::spi::LocationInfo& location, - const log4cxx::LogString& threadName - ) { + const log4cxx::LogString& threadName) { if (LoggerThreadCreated == logger_status) { - LogMessage message = {logger, level, entry, timeStamp, location, threadName}; + LogMessage message = { + logger, level, entry, timeStamp, location, threadName}; if (log_message_loop_thread) { log_message_loop_thread->PostMessage(message); return true; @@ -56,17 +56,18 @@ bool push_log(log4cxx::LoggerPtr logger, if (LoggerThreadNotCreated == logger_status) { logger_status = CreatingLoggerThread; -// we'll have to drop messages -// while creating logger thread + // we'll have to drop messages + // while creating logger thread create_log_message_loop_thread(); - LogMessage message = {logger, level, entry, timeStamp, location, threadName}; + LogMessage message = { + logger, level, entry, timeStamp, location, threadName}; log_message_loop_thread->PostMessage(message); logger_status = LoggerThreadCreated; return true; } -// also we drop messages -// while deleting logger thread + // also we drop messages + // while deleting logger thread return false; } @@ -91,11 +92,11 @@ void delete_log_message_loop_thread() { } void flush_logger() { - logger::LoggerStatus old_status = logger::logger_status; - // Stop pushing new messages to the log queue - logger::logger_status = logger::DeletingLoggerThread; - log_message_loop_thread->WaitDumpQueue(); - logger::logger_status = old_status; + logger::LoggerStatus old_status = logger::logger_status; + // Stop pushing new messages to the log queue + logger::logger_status = logger::DeletingLoggerThread; + log_message_loop_thread->WaitDumpQueue(); + logger::logger_status = old_status; } } // namespace logger diff --git a/src/components/utils/src/qdb_wrapper/sql_database.cc b/src/components/utils/src/qdb_wrapper/sql_database.cc index aabef97f3f..b95fe17845 100644 --- a/src/components/utils/src/qdb_wrapper/sql_database.cc +++ b/src/components/utils/src/qdb_wrapper/sql_database.cc @@ -40,10 +40,7 @@ namespace dbms { CREATE_LOGGERPTR_GLOBAL(logger_, "Utils") SQLDatabase::SQLDatabase(const std::string& db_name) - : conn_(NULL), - db_name_(db_name), - error_(Error::OK) { -} + : conn_(NULL), db_name_(db_name), error_(Error::OK) {} SQLDatabase::~SQLDatabase() { Close(); @@ -51,7 +48,8 @@ SQLDatabase::~SQLDatabase() { bool SQLDatabase::Open() { sync_primitives::AutoLock auto_lock(conn_lock_); - if (conn_) return true; + if (conn_) + return true; conn_ = qdb_connect(db_name_.c_str(), 0); if (conn_ == NULL) { error_ = Error::ERROR; @@ -102,9 +100,9 @@ qdb_hdl_t* SQLDatabase::conn() const { bool SQLDatabase::Backup() { if (qdb_backup(conn_, QDB_ATTACH_DEFAULT) == -1) { - error_ = Error::ERROR; + error_ = Error::ERROR; LOG4CXX_ERROR(logger_, "Backup returned error: " << std::strerror(errno)); - return false; + return false; } LOG4CXX_INFO(logger_, "Backup was successful."); return true; diff --git a/src/components/utils/src/qdb_wrapper/sql_error.cc b/src/components/utils/src/qdb_wrapper/sql_error.cc index 22b02a3452..c99a4d2ae3 100644 --- a/src/components/utils/src/qdb_wrapper/sql_error.cc +++ b/src/components/utils/src/qdb_wrapper/sql_error.cc @@ -36,9 +36,7 @@ namespace utils { namespace dbms { SQLError::SQLError(Error number, const std::string& text) - : number_(number), - text_(text) { -} + : number_(number), text_(text) {} Error SQLError::number() const { return number_; @@ -63,4 +61,3 @@ std::string SQLError::text() const { } // namespace dbms } // namespace utils - diff --git a/src/components/utils/src/qdb_wrapper/sql_query.cc b/src/components/utils/src/qdb_wrapper/sql_query.cc index 755a595515..e5facb5853 100644 --- a/src/components/utils/src/qdb_wrapper/sql_query.cc +++ b/src/components/utils/src/qdb_wrapper/sql_query.cc @@ -41,70 +41,65 @@ namespace utils { namespace dbms { - CREATE_LOGGERPTR_GLOBAL(logger_, "Utils") +CREATE_LOGGERPTR_GLOBAL(logger_, "Utils") class SetBindInteger { public: - explicit SetBindInteger(qdb_binding_t* array) - : array_(array) { - } + explicit SetBindInteger(qdb_binding_t* array) : array_(array) {} void operator()(const std::pair<int, int64_t>& x) { // In QDB the number of position for binding starts since 1. QDB_SETARRAYBIND_INT(array_, x.first + 1, x.second); } + private: qdb_binding_t* array_; }; class SetBindReal { public: - explicit SetBindReal(qdb_binding_t* array) - : array_(array) { - } + explicit SetBindReal(qdb_binding_t* array) : array_(array) {} void operator()(const std::pair<int, double>& x) { // In QDB the number of position for binding starts since 1. QDB_SETARRAYBIND_REAL(array_, x.first + 1, x.second); } + private: qdb_binding_t* array_; }; class SetBindText { public: - explicit SetBindText(qdb_binding_t* array) - : array_(array) { - } + explicit SetBindText(qdb_binding_t* array) : array_(array) {} void operator()(const std::pair<int, std::string>& x) { // In QDB the number of position for binding starts since 1. QDB_SETARRAYBIND_TEXT(array_, x.first + 1, x.second.c_str()); } + private: qdb_binding_t* array_; }; class SetBindNull { public: - explicit SetBindNull(qdb_binding_t* array) - : array_(array) { - } + explicit SetBindNull(qdb_binding_t* array) : array_(array) {} void operator()(int x) { // In QDB the number of position for binding starts since 1. QDB_SETARRAYBIND_NULL(array_, x + 1); } + private: qdb_binding_t* array_; }; SQLQuery::SQLQuery(SQLDatabase* db) - : db_(db), - query_(""), - statement_(-1), - bindings_(NULL), - result_(NULL), - current_row_(0), - rows_(0), - error_(Error::OK) { -} + : db_(db) + , query_("") + , statement_(-1) + , bindings_(NULL) + , result_(NULL) + , current_row_(0) + , rows_(0) + , error_(Error::OK) {} SQLQuery::~SQLQuery() { Finalize(); @@ -124,17 +119,17 @@ bool SQLQuery::Prepare(const std::string& query) { } uint8_t SQLQuery::SetBinds() { - uint8_t binding_count = int_binds_.size() + double_binds_.size() - + string_binds_.size() + null_binds_.size(); + uint8_t binding_count = int_binds_.size() + double_binds_.size() + + string_binds_.size() + null_binds_.size(); bindings_ = new qdb_binding_t[binding_count]; - std::for_each(int_binds_.begin(), int_binds_.end(), - SetBindInteger(bindings_)); - std::for_each(double_binds_.begin(), double_binds_.end(), - SetBindReal(bindings_)); - std::for_each(string_binds_.begin(), string_binds_.end(), - SetBindText(bindings_)); + std::for_each( + int_binds_.begin(), int_binds_.end(), SetBindInteger(bindings_)); + std::for_each( + double_binds_.begin(), double_binds_.end(), SetBindReal(bindings_)); + std::for_each( + string_binds_.begin(), string_binds_.end(), SetBindText(bindings_)); std::for_each(null_binds_.begin(), null_binds_.end(), SetBindNull(bindings_)); return binding_count; @@ -239,7 +234,7 @@ bool SQLQuery::GetBoolean(int pos) const { int SQLQuery::GetInteger(int pos) const { void* ret = qdb_cell(result_, current_row_, pos); - if (rows_ !=0 && ret) { + if (rows_ != 0 && ret) { return *static_cast<int*>(ret); } return 0; @@ -247,7 +242,7 @@ int SQLQuery::GetInteger(int pos) const { uint32_t SQLQuery::GetUInteger(int pos) const { void* ret = qdb_cell(result_, current_row_, pos); - if (rows_ !=0 && ret) { + if (rows_ != 0 && ret) { return *static_cast<uint32_t*>(ret); } return 0; @@ -255,16 +250,15 @@ uint32_t SQLQuery::GetUInteger(int pos) const { int64_t SQLQuery::GetLongInt(int pos) const { void* ret = qdb_cell(result_, current_row_, pos); - if (rows_ !=0 && ret) { + if (rows_ != 0 && ret) { return *static_cast<int64_t*>(ret); } return 0; } - double SQLQuery::GetDouble(int pos) const { void* ret = qdb_cell(result_, current_row_, pos); - if (rows_ !=0 && ret) { + if (rows_ != 0 && ret) { return *static_cast<double*>(ret); } return 0; @@ -297,4 +291,3 @@ int64_t SQLQuery::LastInsertId() const { } // namespace dbms } // namespace utils - diff --git a/src/components/utils/src/resource_usage.cc b/src/components/utils/src/resource_usage.cc index 62c8d25b82..385c2bfa2e 100644 --- a/src/components/utils/src/resource_usage.cc +++ b/src/components/utils/src/resource_usage.cc @@ -47,7 +47,7 @@ bool Resources::ReadStatFile(std::string& output) { if (false == file_system::FileExists(filename)) { return false; } - if (false == file_system::ReadFile(filename,output)) { + if (false == file_system::ReadFile(filename, output)) { return false; } return true; @@ -60,61 +60,95 @@ bool Resources::GetProcInfo(Resources::PidStats& output) { return false; } uint32_t num_succes = sscanf(proc_buf.c_str(), - "%d" //pid - " %*s"//com - " %c" //state - " %d" //ppid - " %d" //pgrp - " %d" //session - " %d" //tty_nr - " %d" //tpgid - " %u" //flags - " %lu" //minflt - " %lu" //cminflt - " %lu" //majflt - " %lu" //cmajflt - " %lu" //utime - " %lu" //stime - " %ld" //cutime - " %ld" //cstime - " %ld" //priority - " %ld" //nice - " %ld" //num_threads - " %ld" //itrealvalue - " %llu" //starttime - " %lu" //vsize - " %ld" //rss - " %lu" //rsslim - " %lu" //startcode - " %lu" //endcode - " %lu" //startstack - " %lu" //kstkesp - " %lu" //kstkip - " %lu" //signal - " %lu" //blocked - " %lu" //sigignore - " %lu" //sigcatch - " %lu" //wchan - " %lu" //nswap - " %lu" //cnswap - " %d" //exit_signal - " %d" //processor - " %u" //rt_priority - " %u" //policy - " %llu" //delayacct_blkio_ticks - " %lu" //guest_time - " %ld" //cguest_time - ,&(output.pid), &(output.state), &(output.ppid), &(output.pgrp), &(output.session), - &(output.tty_nr), &(output.tpgid), &(output.flags), &(output.minflt), &(output.cminflt), - &(output.majflt), &(output.cmajflt), &(output.utime), &(output.stime), &(output.cutime), - &(output.cstime), &(output.priority), &( output.nice), &(output.num_threads), &(output.itrealvalue), - &(output.starttime), &(output.vsize), &(output.rss), &(output.rsslim), &(output.startcode), - &(output.endcode), &(output.startstack), &(output.kstkesp), &(output.kstkeip), &(output.signal), - &(output.blocked), &(output.sigignore), &(output.sigcatch), &(output.wchan), &(output.nswap), - &(output.cnswap), &(output.exit_signal), &(output.processor), &(output.rt_priority), &(output.policy), - &(output.delayacct_blkio_ticks), &(output.guest_time), &(output.cguest_time) - ); - if(num_succes != 43) { // 43 is number of iteams in Resources::PidStats + "%d" // pid + " %*s" // com + " %c" // state + " %d" // ppid + " %d" // pgrp + " %d" // session + " %d" // tty_nr + " %d" // tpgid + " %u" // flags + " %lu" // minflt + " %lu" // cminflt + " %lu" // majflt + " %lu" // cmajflt + " %lu" // utime + " %lu" // stime + " %ld" // cutime + " %ld" // cstime + " %ld" // priority + " %ld" // nice + " %ld" // num_threads + " %ld" // itrealvalue + " %llu" // starttime + " %lu" // vsize + " %ld" // rss + " %lu" // rsslim + " %lu" // startcode + " %lu" // endcode + " %lu" // startstack + " %lu" // kstkesp + " %lu" // kstkip + " %lu" // signal + " %lu" // blocked + " %lu" // sigignore + " %lu" // sigcatch + " %lu" // wchan + " %lu" // nswap + " %lu" // cnswap + " %d" // exit_signal + " %d" // processor + " %u" // rt_priority + " %u" // policy + " %llu" // delayacct_blkio_ticks + " %lu" // guest_time + " %ld" // cguest_time + , + &(output.pid), + &(output.state), + &(output.ppid), + &(output.pgrp), + &(output.session), + &(output.tty_nr), + &(output.tpgid), + &(output.flags), + &(output.minflt), + &(output.cminflt), + &(output.majflt), + &(output.cmajflt), + &(output.utime), + &(output.stime), + &(output.cutime), + &(output.cstime), + &(output.priority), + &(output.nice), + &(output.num_threads), + &(output.itrealvalue), + &(output.starttime), + &(output.vsize), + &(output.rss), + &(output.rsslim), + &(output.startcode), + &(output.endcode), + &(output.startstack), + &(output.kstkesp), + &(output.kstkeip), + &(output.signal), + &(output.blocked), + &(output.sigignore), + &(output.sigcatch), + &(output.wchan), + &(output.nswap), + &(output.cnswap), + &(output.exit_signal), + &(output.processor), + &(output.rt_priority), + &(output.policy), + &(output.delayacct_blkio_ticks), + &(output.guest_time), + &(output.cguest_time)); + if (num_succes != 43) { // 43 is number of iteams in Resources::PidStats LOG4CXX_ERROR(logger_, "Couldn't parse all iteams in /proc/PID/stat file"); return false; } @@ -122,8 +156,9 @@ bool Resources::GetProcInfo(Resources::PidStats& output) { #elif defined(__QNXNTO__) int fd = open(GetProcPath().c_str(), O_RDONLY); if (0 >= fd) { - LOG4CXX_ERROR(logger_, "Failed open process proc file : " << GetProcPath() << - "; error no : " << strerror( errno ) ); + LOG4CXX_ERROR(logger_, + "Failed open process proc file : " + << GetProcPath() << "; error no : " << strerror(errno)); close(fd); return false; @@ -134,9 +169,9 @@ bool Resources::GetProcInfo(Resources::PidStats& output) { #endif } -bool Resources::GetMemInfo(Resources::MemInfo &output) { +bool Resources::GetMemInfo(Resources::MemInfo& output) { bool result = false; - #if defined(OS_LINUX) +#if defined(OS_LINUX) Resources::PidStats pid_stat; if (false == GetProcInfo(pid_stat)) { LOG4CXX_ERROR(logger_, "Failed to get proc info"); @@ -154,7 +189,7 @@ bool Resources::GetMemInfo(Resources::MemInfo &output) { LOG4CXX_ERROR(logger_, "Unable to access to " << proc); result = false; return result; - } + } if (0 == readdir(proc_dir)) { LOG4CXX_ERROR(logger_, "Unable to read : " << proc_dir); closedir(proc_dir); @@ -163,9 +198,9 @@ bool Resources::GetMemInfo(Resources::MemInfo &output) { } closedir(proc_dir); if (-1 == stat(as_path.c_str(), &st) || 0 == st.st_size) { - LOG4CXX_ERROR(logger_, "Unable to stat : " << as_path.c_str()); - result = false; - return result; + LOG4CXX_ERROR(logger_, "Unable to stat : " << as_path.c_str()); + result = false; + return result; } output = st.st_size; result = true; @@ -186,9 +221,9 @@ std::string Resources::GetStatPath() { std::string Resources::GetProcPath() { char buffer[1024]; pid_t my_pid = getpid(); - snprintf(buffer, sizeof(buffer), "%s%d/", proc , my_pid); + snprintf(buffer, sizeof(buffer), "%s%d/", proc, my_pid); std::string filename(buffer); return filename; } -} // namespace utils +} // namespace utils diff --git a/src/components/utils/src/sqlite_wrapper/sql_database.cc b/src/components/utils/src/sqlite_wrapper/sql_database.cc index 88e43c3675..bf19275bac 100644 --- a/src/components/utils/src/sqlite_wrapper/sql_database.cc +++ b/src/components/utils/src/sqlite_wrapper/sql_database.cc @@ -40,14 +40,10 @@ const std::string SQLDatabase::kInMemory = ":memory:"; const std::string SQLDatabase::kExtension = ".sqlite"; SQLDatabase::SQLDatabase() - : conn_(NULL), - databasename_(kInMemory), - error_(SQLITE_OK) {} + : conn_(NULL), databasename_(kInMemory), error_(SQLITE_OK) {} SQLDatabase::SQLDatabase(const std::string& db_name) - : conn_(NULL), - databasename_(db_name + kExtension), - error_(SQLITE_OK) {} + : conn_(NULL), databasename_(db_name + kExtension), error_(SQLITE_OK) {} SQLDatabase::~SQLDatabase() { Close(); @@ -55,7 +51,8 @@ SQLDatabase::~SQLDatabase() { bool SQLDatabase::Open() { sync_primitives::AutoLock auto_lock(conn_lock_); - if (conn_) return true; + if (conn_) + return true; error_ = sqlite3_open(databasename_.c_str(), &conn_); return error_ == SQLITE_OK; } @@ -104,7 +101,7 @@ sqlite3* SQLDatabase::conn() const { } void SQLDatabase::set_path(const std::string& path) { - databasename_ = path + databasename_; + databasename_ = path + databasename_; } std::string SQLDatabase::get_path() const { @@ -112,7 +109,7 @@ std::string SQLDatabase::get_path() const { } bool SQLDatabase::Backup() { - return true; + return true; } } // namespace dbms } // namespace utils diff --git a/src/components/utils/src/sqlite_wrapper/sql_error.cc b/src/components/utils/src/sqlite_wrapper/sql_error.cc index 791d3455f1..9062731a81 100644 --- a/src/components/utils/src/sqlite_wrapper/sql_error.cc +++ b/src/components/utils/src/sqlite_wrapper/sql_error.cc @@ -36,9 +36,7 @@ namespace utils { namespace dbms { SQLError::SQLError(Error number, const std::string& text) - : number_(number), - text_(text) { -} + : number_(number), text_(text) {} Error SQLError::number() const { return number_; @@ -150,4 +148,3 @@ std::string SQLError::text() const { } // namespace dbms } // namespace utils - diff --git a/src/components/utils/src/sqlite_wrapper/sql_query.cc b/src/components/utils/src/sqlite_wrapper/sql_query.cc index ba2af76663..5a62ec360d 100644 --- a/src/components/utils/src/sqlite_wrapper/sql_query.cc +++ b/src/components/utils/src/sqlite_wrapper/sql_query.cc @@ -39,11 +39,7 @@ namespace utils { namespace dbms { SQLQuery::SQLQuery(SQLDatabase* db) - : db_(*db), - query_(""), - statement_(NULL), - error_(SQLITE_OK) { -} + : db_(*db), query_(""), statement_(NULL), error_(SQLITE_OK) {} SQLQuery::~SQLQuery() { Finalize(); @@ -52,9 +48,10 @@ SQLQuery::~SQLQuery() { bool SQLQuery::Prepare(const std::string& query) { Finalize(); sync_primitives::AutoLock auto_lock(statement_lock_); - if (statement_) return false; - error_ = sqlite3_prepare(db_.conn(), query.c_str(), query.length(), - &statement_, NULL); + if (statement_) + return false; + error_ = sqlite3_prepare( + db_.conn(), query.c_str(), query.length(), &statement_, NULL); query_ = query; return error_ == SQLITE_OK; } @@ -109,8 +106,8 @@ void SQLQuery::Bind(int pos, bool value) { void SQLQuery::Bind(int pos, const std::string& value) { // In SQLite the number of position for binding starts since 1. - error_ = sqlite3_bind_text(statement_, pos + 1, value.c_str(), value.length(), - SQLITE_TRANSIENT); + error_ = sqlite3_bind_text( + statement_, pos + 1, value.c_str(), value.length(), SQLITE_TRANSIENT); } bool SQLQuery::GetBoolean(int pos) const { @@ -122,13 +119,11 @@ int SQLQuery::GetInteger(int pos) const { } uint32_t SQLQuery::GetUInteger(int pos) const { - return static_cast<uint32_t>( - sqlite3_column_int64(statement_, pos)); + return static_cast<uint32_t>(sqlite3_column_int64(statement_, pos)); } int64_t SQLQuery::GetLongInt(int pos) const { - return static_cast<int64_t>( - sqlite3_column_int64(statement_, pos)); + return static_cast<int64_t>(sqlite3_column_int64(statement_, pos)); } double SQLQuery::GetDouble(int pos) const { @@ -164,4 +159,3 @@ int64_t SQLQuery::LastInsertId() const { } // namespace dbms } // namespace utils - diff --git a/src/components/utils/src/system.cc b/src/components/utils/src/system.cc index 70659419a7..6c3cf56133 100644 --- a/src/components/utils/src/system.cc +++ b/src/components/utils/src/system.cc @@ -30,13 +30,13 @@ * POSSIBILITY OF SUCH DAMAGE. */ #ifdef __QNX__ -# include <process.h> +#include <process.h> #else // __QNX__ -# include <sys/types.h> -# include <sys/wait.h> -# include <sys/stat.h> -# include <fcntl.h> -# include <unistd.h> +#include <sys/types.h> +#include <sys/wait.h> +#include <sys/stat.h> +#include <fcntl.h> +#include <unistd.h> #endif // __QNX__ #include <algorithm> @@ -52,13 +52,12 @@ namespace utils { CREATE_LOGGERPTR_LOCAL(logger_, "Utils") struct GetCString { - char * operator ()(const std::string& string) { + char* operator()(const std::string& string) { return const_cast<char*>(string.c_str()); } }; -System::System(const std::string& command) - : command_(command) { +System::System(const std::string& command) : command_(command) { argv_.push_back(command); } @@ -88,7 +87,7 @@ bool System::Execute() { bool System::Execute(bool wait) { size_t size = argv_.size(); - char * *argv = new char*[size + 1]; + char** argv = new char* [size + 1]; std::transform(argv_.begin(), argv_.end(), argv, GetCString()); argv[size] = NULL; @@ -97,8 +96,9 @@ bool System::Execute(bool wait) { delete[] argv; if (ret == -1) { - LOG4CXX_ERROR(logger_, "Can't execute command: " << command_ - << " Errno is: " << std::strerror(errno)); + LOG4CXX_ERROR(logger_, + "Can't execute command: " << command_ << " Errno is: " + << std::strerror(errno)); return false; } @@ -137,7 +137,7 @@ bool System::Execute(bool wait) { dup2(fd_dev0, STDERR_FILENO); size_t size = argv_.size(); - char * *argv = new char*[size + 1]; + char** argv = new char* [size + 1]; std::transform(argv_.begin(), argv_.end(), argv, GetCString()); argv[size] = NULL; diff --git a/src/components/utils/src/threads/async_runner.cc b/src/components/utils/src/threads/async_runner.cc index f580eebaf0..131aaa3f78 100644 --- a/src/components/utils/src/threads/async_runner.cc +++ b/src/components/utils/src/threads/async_runner.cc @@ -40,11 +40,10 @@ namespace threads { CREATE_LOGGERPTR_GLOBAL(logger_, "Utils") -AsyncRunner::AsyncRunner(const std::string &thread_name) - : executor_(new AsyncRunnerDelegate) { +AsyncRunner::AsyncRunner(const std::string& thread_name) + : executor_(new AsyncRunnerDelegate) { LOG4CXX_AUTO_TRACE(logger_); - thread_ = threads::CreateThread(thread_name.c_str(), - executor_); + thread_ = threads::CreateThread(thread_name.c_str(), executor_); thread_->start(); } @@ -65,9 +64,7 @@ AsyncRunner::~AsyncRunner() { threads::DeleteThread(thread_); } -AsyncRunner::AsyncRunnerDelegate::AsyncRunnerDelegate() - : stop_flag_(false) { -} +AsyncRunner::AsyncRunnerDelegate::AsyncRunnerDelegate() : stop_flag_(false) {} void AsyncRunner::AsyncRunnerDelegate::processDelegate() { if (!delegates_queue_.empty()) { @@ -113,4 +110,4 @@ void AsyncRunner::AsyncRunnerDelegate::runDelegate(ThreadDelegate* delegate) { delegate_notifier_.NotifyOne(); } -} // namespace policy. +} // namespace policy. diff --git a/src/components/utils/src/threads/pulse_thread_delegate.cc b/src/components/utils/src/threads/pulse_thread_delegate.cc index 68db5dcbea..37e6c670d1 100644 --- a/src/components/utils/src/threads/pulse_thread_delegate.cc +++ b/src/components/utils/src/threads/pulse_thread_delegate.cc @@ -61,7 +61,8 @@ PulseThreadDelegate::PulseThreadDelegate() : run_(false) { void PulseThreadDelegate::threadMain() { if (!Init()) { - LOG4CXX_ERROR(logger_, "Failed to initialize thread for QNX channel " << chid_); + LOG4CXX_ERROR(logger_, + "Failed to initialize thread for QNX channel " << chid_); return; } while (run_) { @@ -77,13 +78,14 @@ void PulseThreadDelegate::threadMain() { OnPulse(); break; } - } - else { + } else { if (run_) { - LOG4CXX_WARN(logger_, "Error occurred while waiting for pulse on QNX channel " << chid_); - } - else { - LOG4CXX_INFO(logger_, "QNX channel " << chid_ << " is apparently destroyed"); + LOG4CXX_WARN(logger_, + "Error occurred while waiting for pulse on QNX channel " + << chid_); + } else { + LOG4CXX_INFO(logger_, + "QNX channel " << chid_ << " is apparently destroyed"); } } } @@ -97,16 +99,14 @@ void PulseThreadDelegate::exitThreadMain() { LOG4CXX_TRACE(logger_, "Disconnecting from QNX channel " << chid_); if (ConnectDetach(coid_) != -1) { LOG4CXX_DEBUG(logger_, "Disconnected from QNX channel " << chid_); - } - else { + } else { LOG4CXX_WARN(logger_, "Failed to disconnect from QNX channel " << chid_); } LOG4CXX_TRACE(logger_, "Destroying QNX channel " << chid_); - if (ChannelDestroy(chid_) != -1) { // unblocks MsgReceivePulse() + if (ChannelDestroy(chid_) != -1) { // unblocks MsgReceivePulse() LOG4CXX_DEBUG(logger_, "QNX channel " << chid_ << " destroyed"); - } - else { + } else { LOG4CXX_WARN(logger_, "Failed to destroy QNX channel " << chid_); } } diff --git a/src/components/utils/src/threads/thread_delegate.cc b/src/components/utils/src/threads/thread_delegate.cc index 417bae5753..7bdce000da 100644 --- a/src/components/utils/src/threads/thread_delegate.cc +++ b/src/components/utils/src/threads/thread_delegate.cc @@ -55,7 +55,7 @@ void ThreadDelegate::exitThreadMain() { } } -void ThreadDelegate::set_thread(Thread *thread) { +void ThreadDelegate::set_thread(Thread* thread) { DCHECK(thread); thread_ = thread; } diff --git a/src/components/utils/src/threads/thread_manager.cc b/src/components/utils/src/threads/thread_manager.cc index 528dc8c4de..2959a86cb7 100644 --- a/src/components/utils/src/threads/thread_manager.cc +++ b/src/components/utils/src/threads/thread_manager.cc @@ -51,4 +51,4 @@ namespace threads { CREATE_LOGGERPTR_GLOBAL(logger_, "Utils") -} // namespace threads +} // namespace threads diff --git a/src/components/utils/src/threads/thread_validator.cc b/src/components/utils/src/threads/thread_validator.cc index 99b812c456..4024522ae4 100644 --- a/src/components/utils/src/threads/thread_validator.cc +++ b/src/components/utils/src/threads/thread_validator.cc @@ -39,39 +39,32 @@ namespace threads { CREATE_LOGGERPTR_GLOBAL(logger_, "Utils") SingleThreadSimpleValidator::SingleThreadSimpleValidator() - : creation_thread_id_(Thread::CurrentId()) { -} + : creation_thread_id_(Thread::CurrentId()) {} -SingleThreadSimpleValidator::~SingleThreadSimpleValidator() { -} +SingleThreadSimpleValidator::~SingleThreadSimpleValidator() {} void SingleThreadSimpleValidator::AssertRunningOnCreationThread() const { PlatformThreadHandle current_id = Thread::CurrentId(); if (creation_thread_id_ != current_id) { - LOG4CXX_ERROR(logger_, "Single-threaded object created at thread " - << creation_thread_id_ - <<" is accessed from thread " - << current_id + LOG4CXX_ERROR(logger_, + "Single-threaded object created at thread " + << creation_thread_id_ << " is accessed from thread " + << current_id #ifdef BACKTRACE_SUPPORT - << "\n" - << utils::Backtrace() + << "\n" << utils::Backtrace() #endif - ); + ); } } -PlatformThreadHandle SingleThreadSimpleValidator::creation_thread_id() const -{ +PlatformThreadHandle SingleThreadSimpleValidator::creation_thread_id() const { return creation_thread_id_; } - SingleThreadValidator::SingleThreadValidator() - : owning_thread_id_(Thread::CurrentId()){ -} + : owning_thread_id_(Thread::CurrentId()) {} -SingleThreadValidator::~SingleThreadValidator() { -} +SingleThreadValidator::~SingleThreadValidator() {} void SingleThreadValidator::PassToThread(PlatformThreadHandle thread_id) const { owning_thread_id_ = thread_id; @@ -80,18 +73,17 @@ void SingleThreadValidator::PassToThread(PlatformThreadHandle thread_id) const { void SingleThreadValidator::AssertRunningOnValidThread() const { PlatformThreadHandle current_id = Thread::CurrentId(); if (owning_thread_id_ != current_id) { - LOG4CXX_ERROR(logger_, "Single-threaded object owned by thread " - << owning_thread_id_ - << " is accessed from thread " - << current_id << "\n" + LOG4CXX_ERROR(logger_, + "Single-threaded object owned by thread " + << owning_thread_id_ << " is accessed from thread " + << current_id << "\n" #ifdef BACKTRACE_SUPPORT - << utils::Backtrace() + << utils::Backtrace() #endif - ); + ); } } - -} // namespace threads +} // namespace threads // vim: set ts=2 sw=2 et: diff --git a/src/components/utils/src/timer.cc b/src/components/utils/src/timer.cc index 99141d61b7..d1d1ec5f3b 100644 --- a/src/components/utils/src/timer.cc +++ b/src/components/utils/src/timer.cc @@ -150,9 +150,9 @@ void timer::Timer::TimerDelegate::threadMain() { LOG4CXX_DEBUG(logger_, "Milliseconds left to wait: " << curr_timeout); if (sync_primitives::ConditionalVariable::kTimeout == termination_condition_.WaitFor(auto_lock, curr_timeout)) { - LOG4CXX_DEBUG(logger_, - "Timer has finished counting. Timeout (ms): " - << curr_timeout); + LOG4CXX_DEBUG( + logger_, + "Timer has finished counting. Timeout (ms): " << curr_timeout); if (timer_) { timer_->OnTimeout(); } diff --git a/src/components/utils/test/async_runner_test.cc b/src/components/utils/test/async_runner_test.cc index e0db33bb96..9b71d8732f 100644 --- a/src/components/utils/test/async_runner_test.cc +++ b/src/components/utils/test/async_runner_test.cc @@ -59,9 +59,7 @@ class TestThreadDelegate : public ThreadDelegate { class AsyncRunnerTest : public ::testing::Test { public: - AsyncRunnerTest() - : kDelegatesNum_(1), - asr_pt_(NULL) { + AsyncRunnerTest() : kDelegatesNum_(1), asr_pt_(NULL) { CreateAsyncRunner(); CreateThreadsArray(); } @@ -75,13 +73,13 @@ class AsyncRunnerTest : public ::testing::Test { Lock test_lock_; uint32_t kDelegatesNum_; ConditionalVariable cond_var_; - TestThreadDelegate **delegates_; - AsyncRunner *asr_pt_; + TestThreadDelegate** delegates_; + AsyncRunner* asr_pt_; void CreateThreadsArray() { srand(std::time(NULL)); kDelegatesNum_ = (rand() % 20 + 1); - delegates_ = new TestThreadDelegate*[kDelegatesNum_]; + delegates_ = new TestThreadDelegate* [kDelegatesNum_]; } void DeleteThreadsArray() { @@ -111,8 +109,9 @@ TEST_F(AsyncRunnerTest, ASyncRunManyDelegates_ExpectSuccessfulAllDelegatesRun) { EXPECT_EQ(kDelegatesNum_, check_value); } -//TODO(VVeremjova) APPLINK-12834 Sometimes delegates do not run -TEST_F(AsyncRunnerTest, DISABLED_RunManyDelegatesAndStop_ExpectSuccessfulDelegatesStop) { +// TODO(VVeremjova) APPLINK-12834 Sometimes delegates do not run +TEST_F(AsyncRunnerTest, + DISABLED_RunManyDelegatesAndStop_ExpectSuccessfulDelegatesStop) { AutoLock lock(test_lock_); // Clear global value before test check_value = 0; @@ -138,4 +137,3 @@ TEST_F(AsyncRunnerTest, DISABLED_RunManyDelegatesAndStop_ExpectSuccessfulDelegat } // namespace utils } // namespace components } // namespace test - diff --git a/src/components/utils/test/back_trace_test.cc b/src/components/utils/test/back_trace_test.cc index 12d5df81fc..071c4d3342 100644 --- a/src/components/utils/test/back_trace_test.cc +++ b/src/components/utils/test/back_trace_test.cc @@ -40,11 +40,10 @@ namespace utils { using namespace ::utils; TEST(BackTraceTest, CallStackShouldNotBeEmpty) { - - //arrange + // arrange Backtrace newtrace = Backtrace(); - std::vector < std::string > symbols = newtrace.CallStack(); - //assert + std::vector<std::string> symbols = newtrace.CallStack(); + // assert ASSERT_FALSE(symbols.empty()); } diff --git a/src/components/utils/test/bitstream_test.cc b/src/components/utils/test/bitstream_test.cc index 07a80bde07..df27aaa835 100644 --- a/src/components/utils/test/bitstream_test.cc +++ b/src/components/utils/test/bitstream_test.cc @@ -42,19 +42,19 @@ namespace utils { using ::utils::BitStream; TEST(BitstreamTest, CreateBitstream_WithDataWithDatasize_BitStreamIsGood) { - - //arrange + // arrange uint8_t data = 10; size_t bits = 2; BitStream bs(&data, bits); - //assert + // assert EXPECT_TRUE(bs.IsGood()); } -TEST(BitstreamTest, ExtractBitstreamInUint8_ExtractAllData_BitStreamIsGoodDataExtractedCorrectly) { - - //arrange +TEST( + BitstreamTest, + ExtractBitstreamInUint8_ExtractAllData_BitStreamIsGoodDataExtractedCorrectly) { + // arrange uint8_t data = 10; size_t bits = 2; BitStream bs(&data, bits); @@ -62,15 +62,15 @@ TEST(BitstreamTest, ExtractBitstreamInUint8_ExtractAllData_BitStreamIsGoodDataEx uint8_t extract_data = 0; Extract(&bs, &extract_data); - //assert + // assert EXPECT_TRUE(bs.IsGood()); EXPECT_EQ(data, extract_data); } -TEST(BitstreamTest, ExtractBitstreamInUint8_WithDataWithZeroSize_BitStreamIsBad) { - - //arrange +TEST(BitstreamTest, + ExtractBitstreamInUint8_WithDataWithZeroSize_BitStreamIsBad) { + // arrange uint8_t data = 10; size_t bits = 0; BitStream bs(&data, bits); @@ -78,13 +78,14 @@ TEST(BitstreamTest, ExtractBitstreamInUint8_WithDataWithZeroSize_BitStreamIsBad) uint8_t extract_data = 0; Extract(&bs, &extract_data); - //assert + // assert EXPECT_TRUE(bs.IsBad()); } -TEST(BitstreamTest, ExtractBitstreamInUint32_WithDatasizeEq4_BitStreamIsGoodDataExtractedCorrectly) { - - //arrange +TEST( + BitstreamTest, + ExtractBitstreamInUint32_WithDatasizeEq4_BitStreamIsGoodDataExtractedCorrectly) { + // arrange uint8_t data = 10; size_t bits = 4; BitStream bs(&data, bits); @@ -92,14 +93,12 @@ TEST(BitstreamTest, ExtractBitstreamInUint32_WithDatasizeEq4_BitStreamIsGoodData uint32_t extract_data = 0; Extract(&bs, &extract_data); - //assert + // assert EXPECT_TRUE(bs.IsGood()); - } TEST(BitstreamTest, ExtractBitstreamInUint32_DatasizeLess4_BitStreamIsBad) { - - //arrange + // arrange uint8_t data = 10; size_t bits = 3; BitStream bs(&data, bits); @@ -107,14 +106,12 @@ TEST(BitstreamTest, ExtractBitstreamInUint32_DatasizeLess4_BitStreamIsBad) { uint32_t extract_data = 0; Extract(&bs, &extract_data); - //assert + // assert EXPECT_TRUE(bs.IsBad()); - } TEST(BitstreamTest, ExtractFullBitstream_WithDataWithDatasize_BitStreamIsGood) { - - //arrange + // arrange uint8_t data = 10; size_t bits = 8; BitStream bs(&data, bits); @@ -123,15 +120,15 @@ TEST(BitstreamTest, ExtractFullBitstream_WithDataWithDatasize_BitStreamIsGood) { Extract(&bs, &extract_data, bits); - //assert + // assert EXPECT_TRUE(bs.IsGood()); EXPECT_EQ(data, extract_data); } -TEST(BitstreamTest, ExtractBitstreamInString_WithDataWithDatasize_BitStreamIsGood) { - - //arrange +TEST(BitstreamTest, + ExtractBitstreamInString_WithDataWithDatasize_BitStreamIsGood) { + // arrange uint8_t data = 10; size_t bits = 2; BitStream bs(&data, bits); @@ -141,46 +138,45 @@ TEST(BitstreamTest, ExtractBitstreamInString_WithDataWithDatasize_BitStreamIsGoo Extract(&bs, &strdata, length); - //assert + // assert EXPECT_TRUE(bs.IsGood()); } TEST(BitstreamTest, CreateBitstream_NoDataZeroDatasize_BitStreamIsGood) { - - //arrange - uint8_t *data = NULL; + // arrange + uint8_t* data = NULL; size_t bits = 0; BitStream bs(data, bits); - //assert + // assert EXPECT_TRUE(bs.IsGood()); } -TEST(BitstreamTest, CreateBitstream_NoDataWithUpperboundDataSize_BitStreamIsGood) { - - //arrange - uint8_t *data = NULL; +TEST(BitstreamTest, + CreateBitstream_NoDataWithUpperboundDataSize_BitStreamIsGood) { + // arrange + uint8_t* data = NULL; size_t bits = 65535; BitStream bs(data, bits); - //assert + // assert EXPECT_TRUE(bs.IsGood()); } -TEST(BitstreamTest, CreateBitstream_WithUpperboundDataWithLessDataSize_BitStreamIsGood) { - - //arrange +TEST(BitstreamTest, + CreateBitstream_WithUpperboundDataWithLessDataSize_BitStreamIsGood) { + // arrange uint8_t data = 255; size_t bits = sizeof(char); BitStream bs(&data, bits); - //assert + // assert EXPECT_TRUE(bs.IsGood()); } -TEST(BitstreamTest, ExtractBitstream_WithUpperboundDataWithLessDataSize_BitStreamIsGood) { - - //arrange +TEST(BitstreamTest, + ExtractBitstream_WithUpperboundDataWithLessDataSize_BitStreamIsGood) { + // arrange uint8_t data = 255; size_t bits = sizeof(char); BitStream bs(&data, bits); @@ -188,13 +184,13 @@ TEST(BitstreamTest, ExtractBitstream_WithUpperboundDataWithLessDataSize_BitStrea uint8_t extract_data = 0; Extract(&bs, &extract_data, bits); - //assert + // assert EXPECT_TRUE(bs.IsGood()); } -TEST(BitstreamTest, ExtractBitstream_WithUpperboundDataWithZeroDataSize_BitStreamIsGood) { - - //arrange +TEST(BitstreamTest, + ExtractBitstream_WithUpperboundDataWithZeroDataSize_BitStreamIsGood) { + // arrange uint8_t data = 255; size_t bits = 0; BitStream bs(&data, bits); @@ -202,26 +198,25 @@ TEST(BitstreamTest, ExtractBitstream_WithUpperboundDataWithZeroDataSize_BitStrea uint8_t extract_data = 0; Extract(&bs, &extract_data, bits); - //assert + // assert EXPECT_TRUE(bs.IsGood()); } TEST(BitstreamTest, ExtractBitstream_WithDataMarkedBad_ExpectIsBad) { - - //arrange + // arrange uint8_t data = 255; size_t bits = sizeof(int); BitStream bs(&data, bits); - //assert + // assert EXPECT_TRUE(bs.IsGood()); - //act + // act bs.MarkBad(); - //assert + // assert EXPECT_TRUE(bs.IsBad()); - //act + // act Extract(&bs, &data, bits); - //arrange + // arrange EXPECT_TRUE(bs.IsBad()); } diff --git a/src/components/utils/test/conditional_variable_test.cc b/src/components/utils/test/conditional_variable_test.cc index a898732ffc..fe93e17617 100644 --- a/src/components/utils/test/conditional_variable_test.cc +++ b/src/components/utils/test/conditional_variable_test.cc @@ -45,22 +45,20 @@ namespace utils { class ConditionalVariableTest : public ::testing::Test { public: - ConditionalVariableTest() - : test_value_("initialized"), - counter_(0) { - } + ConditionalVariableTest() : test_value_("initialized"), counter_(0) {} void check_counter(); void task_one(); - static void* check_counter_helper(void *context) { - (reinterpret_cast<ConditionalVariableTest *>(context))->check_counter(); + static void* check_counter_helper(void* context) { + (reinterpret_cast<ConditionalVariableTest*>(context))->check_counter(); return NULL; } - static void* task_one_helper(void *context) { - (reinterpret_cast<ConditionalVariableTest *>(context))->task_one(); + static void* task_one_helper(void* context) { + (reinterpret_cast<ConditionalVariableTest*>(context))->task_one(); return NULL; } + protected: std::string test_value_; sync_primitives::ConditionalVariable cond_var_; @@ -73,10 +71,13 @@ void ConditionalVariableTest::check_counter() { sync_primitives::AutoLock test_lock(test_mutex_); if (counter_ <= 1) { counter_++; - cond_var_.Wait(test_mutex_); // Mutex unlock & Thread sleeps until Notification - } - else if(counter_ == 2) { // Checking for equal 2 in this specific case. Because we were waiting for 2 threads to be finished - cond_var_.Broadcast(); // Notify All threads waiting on conditional variable + cond_var_.Wait( + test_mutex_); // Mutex unlock & Thread sleeps until Notification + } else if (counter_ == 2) { // Checking for equal 2 in this specific case. + // Because we were waiting for 2 threads to be + // finished + cond_var_ + .Broadcast(); // Notify All threads waiting on conditional variable } } @@ -84,18 +85,18 @@ void ConditionalVariableTest::check_counter() { void ConditionalVariableTest::task_one() { sync_primitives::AutoLock test_lock(test_mutex_); test_value_ = "changed by thread 1"; - cond_var_.NotifyOne(); // Notify At least one thread waiting on conditional variable + cond_var_.NotifyOne(); // Notify At least one thread waiting on conditional + // variable test_value_ = "changed again by thread 1"; } -TEST_F(ConditionalVariableTest, CheckNotifyOne_OneThreadNotified_ExpectSuccessful) { +TEST_F(ConditionalVariableTest, + CheckNotifyOne_OneThreadNotified_ExpectSuccessful) { pthread_t thread1; sync_primitives::AutoLock test_lock(test_mutex_); test_value_ = "changed by main thread"; - const bool thread_created = pthread_create(&thread1, - NULL, - &ConditionalVariableTest::task_one_helper, - this); + const bool thread_created = pthread_create( + &thread1, NULL, &ConditionalVariableTest::task_one_helper, this); ASSERT_FALSE(thread_created) << "thread1 is not created!"; test_value_ = "changed twice by main thread"; cond_var_.WaitFor(test_lock, 2000); @@ -103,30 +104,29 @@ TEST_F(ConditionalVariableTest, CheckNotifyOne_OneThreadNotified_ExpectSuccessfu EXPECT_EQ(last_value, test_value_); } -TEST_F(ConditionalVariableTest, CheckBroadcast_AllThreadsNotified_ExpectSuccessful) { +TEST_F(ConditionalVariableTest, + CheckBroadcast_AllThreadsNotified_ExpectSuccessful) { pthread_t thread1; pthread_t thread2; - bool thread_created = pthread_create(&thread1, - NULL, - &ConditionalVariableTest::check_counter_helper, - this); + bool thread_created = pthread_create( + &thread1, NULL, &ConditionalVariableTest::check_counter_helper, this); ASSERT_FALSE(thread_created) << "thread1 is not created!"; - thread_created = pthread_create(&thread2, - NULL, - &ConditionalVariableTest::check_counter_helper, - this); + thread_created = pthread_create( + &thread2, NULL, &ConditionalVariableTest::check_counter_helper, this); ASSERT_FALSE(thread_created) << "thread2 is not created!"; check_counter(); EXPECT_EQ(2u, counter_); } -TEST_F(ConditionalVariableTest, CheckWaitForWithTimeout1sec_ThreadBlockedForTimeout_ExpectSuccessfulWakeUp) { +TEST_F( + ConditionalVariableTest, + CheckWaitForWithTimeout1sec_ThreadBlockedForTimeout_ExpectSuccessfulWakeUp) { sync_primitives::AutoLock test_lock(test_mutex_); - sync_primitives::ConditionalVariable::WaitStatus wait_st = cond_var_.WaitFor(test_lock, 1000); + sync_primitives::ConditionalVariable::WaitStatus wait_st = + cond_var_.WaitFor(test_lock, 1000); EXPECT_EQ(sync_primitives::ConditionalVariable::kTimeout, wait_st); } } // namespace utils } // namespace components } // namespace test - diff --git a/src/components/utils/test/data_accessor_test.cc b/src/components/utils/test/data_accessor_test.cc index 105ec8517f..b15310ff3f 100644 --- a/src/components/utils/test/data_accessor_test.cc +++ b/src/components/utils/test/data_accessor_test.cc @@ -39,31 +39,28 @@ namespace components { namespace utils { TEST(DataAccessorTest, CreateDataAccessor) { - - //arrange + // arrange int test_value = 10; sync_primitives::Lock testSet_lock_; DataAccessor<int> testdata(test_value, testSet_lock_); int data_from_testdata = testdata.GetData(); - //assert + // assert EXPECT_EQ(test_value, data_from_testdata); } TEST(DataAccessorTest, CreateDataAccessor_MutexIsLocked_CannotLockItAgain) { - - //arrange + // arrange int test_value = 10; sync_primitives::Lock testSet_lock_; DataAccessor<int> testdata(test_value, testSet_lock_); - //assert + // assert EXPECT_FALSE(testSet_lock_.Try()); } TEST(DataAccessorTest, CopyDataAccessor_GetDataFromDataAccessors) { - - //arrange + // arrange int test_value = 10; sync_primitives::Lock testSet_lock_; DataAccessor<int> testdata(test_value, testSet_lock_); @@ -72,15 +69,15 @@ TEST(DataAccessorTest, CopyDataAccessor_GetDataFromDataAccessors) { int data_from_testdata = testdata.GetData(); int data_from_testdata_copy = testdata_copy.GetData(); - //assert + // assert EXPECT_EQ(data_from_testdata, data_from_testdata_copy); EXPECT_FALSE(testSet_lock_.Try()); } -TEST(DataAccessorTest,ChangedDataInDataAccessor_ChangeData_DataInDataAccessorIsChanged) { - - //arrange +TEST(DataAccessorTest, + ChangedDataInDataAccessor_ChangeData_DataInDataAccessorIsChanged) { + // arrange int test_value = 10; sync_primitives::Lock testSet_lock_; DataAccessor<int> testdata(test_value, testSet_lock_); @@ -88,32 +85,31 @@ TEST(DataAccessorTest,ChangedDataInDataAccessor_ChangeData_DataInDataAccessorIsC int data_from_testdata_after_change = testdata.GetData(); - //assert + // assert EXPECT_EQ(test_value, data_from_testdata_after_change); } -TEST(DataAccessorTest, DeleteDataAccessor_CreatedOneDeleteOneThread_MutexIsUnlocked) { - - //arrange +TEST(DataAccessorTest, + DeleteDataAccessor_CreatedOneDeleteOneThread_MutexIsUnlocked) { + // arrange int test_value = 10; sync_primitives::Lock testSet_lock_; { DataAccessor<int> testdata(test_value, testSet_lock_); - //assert + // assert EXPECT_FALSE(testSet_lock_.Try()); } - //assert + // assert EXPECT_TRUE(testSet_lock_.Try()); testSet_lock_.Release(); - } -TEST(DataAccessorTest, DeleteDataAccessor_CreatedThreadAndCopyDeleteBothThreads_MutexIsUnlocked) { - - //arrange +TEST(DataAccessorTest, + DeleteDataAccessor_CreatedThreadAndCopyDeleteBothThreads_MutexIsUnlocked) { + // arrange int test_value = 10; sync_primitives::Lock testSet_lock_; { @@ -121,18 +117,16 @@ TEST(DataAccessorTest, DeleteDataAccessor_CreatedThreadAndCopyDeleteBothThreads_ { DataAccessor<int> testdata_copy(testdata); - //assert + // assert EXPECT_FALSE(testSet_lock_.Try()); } - //assert + // assert EXPECT_FALSE(testSet_lock_.Try()); - } - //assert + // assert EXPECT_TRUE(testSet_lock_.Try()); testSet_lock_.Release(); - } } // namespace utils diff --git a/src/components/utils/test/date_time_test.cc b/src/components/utils/test/date_time_test.cc index c5deba8f5c..fc34b7a998 100644 --- a/src/components/utils/test/date_time_test.cc +++ b/src/components/utils/test/date_time_test.cc @@ -39,86 +39,85 @@ namespace utils { using namespace date_time; TEST(DateTimeTest, GetCurrentTime) { - - //arrange + // arrange const TimevalStruct time1 = date_time::DateTime::getCurrentTime(); - //assert + // assert ASSERT_NE(0, time1.tv_sec); ASSERT_GE(time1.tv_usec, 0); - //act + // act const TimevalStruct time2 = date_time::DateTime::getCurrentTime(); - //assert + // assert ASSERT_NE(0, time2.tv_sec); ASSERT_GE(time2.tv_usec, 0); ASSERT_GE(time2.tv_sec, time1.tv_sec); } TEST(DateTimeTest, GetSecs) { - //arrange + // arrange TimevalStruct time; time.tv_sec = 1; time.tv_usec = 2 * date_time::DateTime::MICROSECONDS_IN_MILLISECOND; - //assert + // assert ASSERT_EQ(1, date_time::DateTime::getSecs(time)); } TEST(DateTimeTest, GetmSecs) { - //arrange + // arrange TimevalStruct time; time.tv_sec = 1; time.tv_usec = 2 * date_time::DateTime::MICROSECONDS_IN_MILLISECOND; - int64_t expect_value = time.tv_sec - * date_time::DateTime::MILLISECONDS_IN_SECOND - + time.tv_usec / date_time::DateTime::MICROSECONDS_IN_MILLISECOND; - //assert + int64_t expect_value = + time.tv_sec * date_time::DateTime::MILLISECONDS_IN_SECOND + + time.tv_usec / date_time::DateTime::MICROSECONDS_IN_MILLISECOND; + // assert ASSERT_EQ(expect_value, date_time::DateTime::getmSecs(time)); } TEST(DateTimeTest, GetuSecs) { - //arrange + // arrange TimevalStruct time; time.tv_sec = 3; time.tv_usec = 4; - int64_t expect_value = time.tv_sec - * date_time::DateTime::MILLISECONDS_IN_SECOND - * date_time::DateTime::MICROSECONDS_IN_MILLISECOND + time.tv_usec; - //assert + int64_t expect_value = time.tv_sec * + date_time::DateTime::MILLISECONDS_IN_SECOND * + date_time::DateTime::MICROSECONDS_IN_MILLISECOND + + time.tv_usec; + // assert ASSERT_EQ(expect_value, date_time::DateTime::getuSecs(time)); } TEST(DateTimeTest, GetuSecsmSecs) { - //arrange + // arrange TimevalStruct time; time.tv_sec = 5; time.tv_usec = 6; - int64_t expect_value = date_time::DateTime::getuSecs(time) - / date_time::DateTime::MICROSECONDS_IN_MILLISECOND; + int64_t expect_value = date_time::DateTime::getuSecs(time) / + date_time::DateTime::MICROSECONDS_IN_MILLISECOND; - //assert + // assert ASSERT_EQ(expect_value, date_time::DateTime::getmSecs(time)); } TEST(DateTimeTest, CalculateTimeSpan) { - //arrange + // arrange const TimevalStruct time = date_time::DateTime::getCurrentTime(); const uint32_t sleep_time_mSec = 10; usleep(sleep_time_mSec * date_time::DateTime::MICROSECONDS_IN_MILLISECOND); - //assert + // assert ASSERT_GE(date_time::DateTime::calculateTimeSpan(time), sleep_time_mSec); } TEST(DateTimeTest, CalculateTimeDiff) { - - //arrange + // arrange TimevalStruct time1; time1.tv_sec = 1; time1.tv_usec = 2 * date_time::DateTime::MICROSECONDS_IN_MILLISECOND; @@ -127,26 +126,26 @@ TEST(DateTimeTest, CalculateTimeDiff) { time2.tv_sec = 3; time2.tv_usec = 4 * date_time::DateTime::MICROSECONDS_IN_MILLISECOND; - //time2 to time1 + // time2 to time1 TimevalStruct diff1; diff1.tv_sec = time2.tv_sec - time1.tv_sec; diff1.tv_usec = time2.tv_usec - time1.tv_usec; - const int64_t mSecDiff = static_cast<int64_t>(diff1.tv_sec) * 1000 - + diff1.tv_usec / 1000; + const int64_t mSecDiff = + static_cast<int64_t>(diff1.tv_sec) * 1000 + diff1.tv_usec / 1000; - //assert + // assert ASSERT_EQ(mSecDiff, date_time::DateTime::calculateTimeDiff(time2, time1)); - //time1 to time2 + // time1 to time2 TimevalStruct diff2; diff2.tv_sec = time1.tv_sec - time2.tv_sec; diff2.tv_usec = time1.tv_usec - time2.tv_usec; - const int64_t mSecDiff2 = -(static_cast<int64_t>(diff2.tv_sec) * 1000 - + diff2.tv_usec / 1000); + const int64_t mSecDiff2 = + -(static_cast<int64_t>(diff2.tv_sec) * 1000 + diff2.tv_usec / 1000); - //assert + // assert ASSERT_EQ(mSecDiff2, date_time::DateTime::calculateTimeDiff(time1, time2)); } @@ -164,8 +163,7 @@ TEST(DateTimeTest, CalculateEqualTimeDiff) { } TEST(DateTimeTest, compareTime) { - - //arrange + // arrange TimevalStruct time1; time1.tv_sec = 1; time1.tv_usec = 2 * date_time::DateTime::MICROSECONDS_IN_MILLISECOND; @@ -174,30 +172,30 @@ TEST(DateTimeTest, compareTime) { time2.tv_sec = 2; time2.tv_usec = 4 * date_time::DateTime::MICROSECONDS_IN_MILLISECOND; - //assert + // assert ASSERT_EQ(LESS, date_time::DateTime::compareTime(time1, time2)); ASSERT_EQ(GREATER, date_time::DateTime::compareTime(time2, time1)); ASSERT_NE(EQUAL, date_time::DateTime::compareTime(time2, time1)); - //act + // act TimevalStruct time3 = date_time::DateTime::Sub(time2, time1); - //assert + // assert ASSERT_EQ(EQUAL, date_time::DateTime::compareTime(time1, time3)); } TEST(DateTimeTest, GetSecs_UsecConvertedInSec) { - //arrange + // arrange TimevalStruct time1; time1.tv_sec = 0; time1.tv_usec = date_time::DateTime::MICROSECONDS_IN_SECOND; - //assert + // assert ASSERT_EQ(1, date_time::DateTime::getSecs(time1)); } TEST(DateTimeTest, compareTime_UsecConvertedInSec) { - //arrange + // arrange TimevalStruct time1; time1.tv_sec = 1; time1.tv_usec = 0; @@ -206,14 +204,14 @@ TEST(DateTimeTest, compareTime_UsecConvertedInSec) { time2.tv_sec = 0; time2.tv_usec = date_time::DateTime::MICROSECONDS_IN_SECOND; - //assert + // assert ASSERT_EQ(1, date_time::DateTime::getSecs(time1)); ASSERT_EQ(1, date_time::DateTime::getSecs(time2)); ASSERT_EQ(EQUAL, date_time::DateTime::compareTime(time1, time2)); } TEST(DateTimeTest, compareEqualTime_UsecConvertedInSec) { - //arrange + // arrange TimevalStruct time1; time1.tv_sec = 1; time1.tv_usec = 0; @@ -222,12 +220,12 @@ TEST(DateTimeTest, compareEqualTime_UsecConvertedInSec) { time2.tv_sec = 0; time2.tv_usec = date_time::DateTime::MICROSECONDS_IN_SECOND; - //assert + // assert ASSERT_TRUE(date_time::DateTime::Equal(time1, time2)); } TEST(DateTimeTest, compareLessTime_UsecConvertedInSec) { - //arrange + // arrange TimevalStruct time1; time1.tv_sec = 1; time1.tv_usec = 0; @@ -236,12 +234,12 @@ TEST(DateTimeTest, compareLessTime_UsecConvertedInSec) { time2.tv_sec = 0; time2.tv_usec = 2 * date_time::DateTime::MICROSECONDS_IN_SECOND; - //assert + // assert ASSERT_TRUE(date_time::DateTime::Less(time1, time2)); } TEST(DateTimeTest, compareGreaterTime_UsecConvertedInSec) { - //arrange + // arrange TimevalStruct time1; time1.tv_sec = 1; time1.tv_usec = 0; @@ -250,12 +248,12 @@ TEST(DateTimeTest, compareGreaterTime_UsecConvertedInSec) { time2.tv_sec = 0; time2.tv_usec = 2 * date_time::DateTime::MICROSECONDS_IN_SECOND; - //assert + // assert ASSERT_TRUE(date_time::DateTime::Greater(time2, time1)); } TEST(DateTimeTest, CalculateTimeSub_UsecConvertedInSec) { - //arrange + // arrange TimevalStruct time1; time1.tv_sec = 1; time1.tv_usec = 0; @@ -266,12 +264,12 @@ TEST(DateTimeTest, CalculateTimeSub_UsecConvertedInSec) { TimevalStruct time3 = date_time::DateTime::Sub(time2, time1); - //assert + // assert ASSERT_EQ(EQUAL, date_time::DateTime::compareTime(time1, time3)); } TEST(DateTimeTest, CalculateTimeDiff_UsecConvertedInSec) { - //arrange + // arrange TimevalStruct time1; time1.tv_sec = 2; time1.tv_usec = 5 * date_time::DateTime::MICROSECONDS_IN_SECOND; @@ -280,13 +278,13 @@ TEST(DateTimeTest, CalculateTimeDiff_UsecConvertedInSec) { time2.tv_sec = 3; time2.tv_usec = 1 * date_time::DateTime::MICROSECONDS_IN_SECOND; - //assert + // assert ASSERT_EQ(3000, date_time::DateTime::calculateTimeDiff(time2, time1)); ASSERT_EQ(3000, date_time::DateTime::calculateTimeDiff(time1, time2)); } TEST(DateTimeTest, CalculateEqualTimeDiff_UsecConvertedInSec) { - //arrange + // arrange TimevalStruct time1; time1.tv_sec = 2; time1.tv_usec = 2 * date_time::DateTime::MICROSECONDS_IN_SECOND; @@ -295,13 +293,13 @@ TEST(DateTimeTest, CalculateEqualTimeDiff_UsecConvertedInSec) { time2.tv_sec = 3; time2.tv_usec = 1 * date_time::DateTime::MICROSECONDS_IN_SECOND; - //assert + // assert ASSERT_EQ(0, date_time::DateTime::calculateTimeDiff(time2, time1)); ASSERT_EQ(0, date_time::DateTime::calculateTimeDiff(time1, time2)); } TEST(DateTimeTest, CalculateEqualTimeSub_UsecConvertedInSec) { - //arrange + // arrange TimevalStruct time1; time1.tv_sec = 3; time1.tv_usec = 0; @@ -316,12 +314,13 @@ TEST(DateTimeTest, CalculateEqualTimeSub_UsecConvertedInSec) { TimevalStruct time_expected; time_expected.tv_sec = 0; time_expected.tv_usec = 0; - //assert + // assert ASSERT_EQ(EQUAL, date_time::DateTime::compareTime(time_expected, time3)); ASSERT_EQ(EQUAL, date_time::DateTime::compareTime(time_expected, time4)); } -TEST(DateTimeTest, AddMilliseconds_SetMillisecondMultiplesSecond_ExpectChangeTime) { +TEST(DateTimeTest, + AddMilliseconds_SetMillisecondMultiplesSecond_ExpectChangeTime) { TimevalStruct time1; time1.tv_sec = 3; time1.tv_usec = 0; @@ -331,7 +330,8 @@ TEST(DateTimeTest, AddMilliseconds_SetMillisecondMultiplesSecond_ExpectChangeTim ASSERT_EQ(0, time1.tv_usec); } -TEST(DateTimeTest, AddMilliseconds_SetMillisecondNotMultiplesSecond_ExpectChangeTime) { +TEST(DateTimeTest, + AddMilliseconds_SetMillisecondNotMultiplesSecond_ExpectChangeTime) { TimevalStruct time1; uint32_t milliseconds = 7500; time1.tv_sec = 3; @@ -341,7 +341,8 @@ TEST(DateTimeTest, AddMilliseconds_SetMillisecondNotMultiplesSecond_ExpectChange ASSERT_EQ(500000, time1.tv_usec); } -TEST(DateTimeTest, AddMilliseconds_SetMilliSecondLessThenSeconds_ExpectChangeTime) { +TEST(DateTimeTest, + AddMilliseconds_SetMilliSecondLessThenSeconds_ExpectChangeTime) { TimevalStruct time1; uint32_t milliseconds = 500; time1.tv_sec = 3; @@ -351,7 +352,8 @@ TEST(DateTimeTest, AddMilliseconds_SetMilliSecondLessThenSeconds_ExpectChangeTim ASSERT_EQ(500000, time1.tv_usec); } -TEST(DateTimeTest, AddMilliseconds_SetMillisecondEqualNull_ExpectNotChangeTime) { +TEST(DateTimeTest, + AddMilliseconds_SetMillisecondEqualNull_ExpectNotChangeTime) { TimevalStruct time1; uint32_t milliseconds = 0; time1.tv_sec = 3; @@ -371,32 +373,31 @@ TEST(DateTimeTest, AddMilliseconds_SetOverlowMicrosecond_ExpectChangeTime) { ASSERT_EQ(100000, time1.tv_usec); } -TEST(DateTimeTest, Operator_minus_TimevalStruct_positive){ - TimevalStruct time1; - TimevalStruct time2; - TimevalStruct time3; - time1.tv_sec = 3; - time1.tv_usec = 0; - time2.tv_sec = 3; - time2.tv_usec = 0; - time3.tv_sec = 2; - time3.tv_usec = 9000000; - ASSERT_EQ(0, date_time::DateTime::getSecs(time1 - time2)); - ASSERT_EQ(8000000, date_time::DateTime::getuSecs(time3 - time1)); +TEST(DateTimeTest, Operator_minus_TimevalStruct_positive) { + TimevalStruct time1; + TimevalStruct time2; + TimevalStruct time3; + time1.tv_sec = 3; + time1.tv_usec = 0; + time2.tv_sec = 3; + time2.tv_usec = 0; + time3.tv_sec = 2; + time3.tv_usec = 9000000; + ASSERT_EQ(0, date_time::DateTime::getSecs(time1 - time2)); + ASSERT_EQ(8000000, date_time::DateTime::getuSecs(time3 - time1)); } -TEST(DateTimeTest, Operator_minus_TimevalStruct_negative){ - TimevalStruct time1; - TimevalStruct time2; - time1.tv_sec = 3; - time1.tv_usec = 0; - time2.tv_sec = 2; - time2.tv_usec = 9000000; - ASSERT_NE(1, date_time::DateTime::getSecs(time1 - time2)); - ASSERT_NE(-8000000, date_time::DateTime::getSecs(time2 - time1)); +TEST(DateTimeTest, Operator_minus_TimevalStruct_negative) { + TimevalStruct time1; + TimevalStruct time2; + time1.tv_sec = 3; + time1.tv_usec = 0; + time2.tv_sec = 2; + time2.tv_usec = 9000000; + ASSERT_NE(1, date_time::DateTime::getSecs(time1 - time2)); + ASSERT_NE(-8000000, date_time::DateTime::getSecs(time2 - time1)); } - } // namespace utils } // namespace components } // namespace test diff --git a/src/components/utils/test/generated_code_with_sqlite_test.cc b/src/components/utils/test/generated_code_with_sqlite_test.cc index d75d924321..cb319fa0ac 100644 --- a/src/components/utils/test/generated_code_with_sqlite_test.cc +++ b/src/components/utils/test/generated_code_with_sqlite_test.cc @@ -62,81 +62,83 @@ const std::string GeneratedCodeTest::kDatabaseName = "test_db"; const std::string GeneratedCodeTest::kEndpointsCreation = "CREATE TABLE Endpoints (" - "endpoint_id INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL," - "service_id VARCHAR(45) NOT NULL," - "application_id VARCHAR(45)," - "url VARCHAR(45) NOT NULL," - "is_default INTEGER NOT NULL CHECK(is_default>=0))"; + "endpoint_id INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL," + "service_id VARCHAR(45) NOT NULL," + "application_id VARCHAR(45)," + "url VARCHAR(45) NOT NULL," + "is_default INTEGER NOT NULL CHECK(is_default>=0))"; const std::string GeneratedCodeTest::kEndpointsContent = "INSERT INTO Endpoints " - "VALUES (1, '0x07', null, 'http://url.example.com', 1)"; + "VALUES (1, '0x07', null, 'http://url.example.com', 1)"; const std::string GeneratedCodeTest::kAppPoliciesCreation = "CREATE TABLE AppPolicies (" - "id INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL," - "application_id VARCHAR(45)," - "priority VARCHAR(45)," - "is_default INTEGER NOT NULL CHECK(is_default>=0))"; + "id INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL," + "application_id VARCHAR(45)," + "priority VARCHAR(45)," + "is_default INTEGER NOT NULL CHECK(is_default>=0))"; -const std::string GeneratedCodeTest::kGroupsCreation = "CREATE TABLE Groups (" +const std::string GeneratedCodeTest::kGroupsCreation = + "CREATE TABLE Groups (" "id INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL," "application_id VARCHAR(45) NOT NULL," "group_name VARCHAR(45) NOT NULL )"; -TEST_F(GeneratedCodeTest, FindSectionEndpoints_OpenDBSetDefaultUrl_ExpectDefaultUrl) { - - //arrange +TEST_F(GeneratedCodeTest, + FindSectionEndpoints_OpenDBSetDefaultUrl_ExpectDefaultUrl) { + // arrange dbms::SQLDatabase db(GeneratedCodeTest::kDatabaseName); - //assert + // assert EXPECT_TRUE(db.Open()); policy_table::ServiceEndpoints ep; - //assert + // assert EXPECT_TRUE(policy_table::FindSection(&db, ep)); EXPECT_EQ(1u, ep.size()); - //act + // act std::string url = ep["0x07"]["default"].front(); - //assert + // assert EXPECT_EQ("http://url.example.com", url); } -TEST_F(GeneratedCodeTest, RemoveSectionEndpoints_RemoveSectionEndpoints_Expect0EndPoints) { - //arrange +TEST_F(GeneratedCodeTest, + RemoveSectionEndpoints_RemoveSectionEndpoints_Expect0EndPoints) { + // arrange dbms::SQLDatabase db(GeneratedCodeTest::kDatabaseName); - //assert + // assert EXPECT_TRUE(db.Open()); - //act + // act policy_table::ServiceEndpoints ep; - //assert + // assert EXPECT_TRUE(policy_table::RemoveSection(&db, ep)); dbms::SQLQuery sqlquery(&db); - //act + // act std::string check_query = "select count (*) from endpoints"; - //assert + // assert EXPECT_TRUE(sqlquery.Prepare(check_query)); EXPECT_TRUE(sqlquery.Exec()); // Index for binding starts from 1, index for results starts from 0 EXPECT_EQ(0, sqlquery.GetInteger(0)); } -TEST_F(GeneratedCodeTest, UpdateSectionEndpoints_SetUrlPoint_ExpectPointEqualsUrl) { - - //arrange +TEST_F(GeneratedCodeTest, + UpdateSectionEndpoints_SetUrlPoint_ExpectPointEqualsUrl) { + // arrange dbms::SQLDatabase db(GeneratedCodeTest::kDatabaseName); - //assert + // assert EXPECT_TRUE(db.Open()); - //act + // act std::string test_url = "http://url.example.com"; policy_table::URL urls; @@ -148,52 +150,50 @@ TEST_F(GeneratedCodeTest, UpdateSectionEndpoints_SetUrlPoint_ExpectPointEqualsUr policy_table::ServiceEndpoints ep; ep["0x07"] = urllist; - //assert + // assert EXPECT_TRUE(policy_table::UpdateSection(&db, ep)); dbms::SQLQuery sqlquery(&db); std::string num_of_records_check = "select count (*) from endpoints"; - //assert + // assert EXPECT_TRUE(sqlquery.Prepare(num_of_records_check)); EXPECT_TRUE(sqlquery.Exec()); // Index for binding starts from 1, index for results starts from 0 EXPECT_EQ(1, sqlquery.GetInteger(0)); EXPECT_TRUE(sqlquery.Reset()); - - //act + // act std::string url_check_query = "select * from endpoints"; - //assert + // assert EXPECT_TRUE(sqlquery.Prepare(url_check_query)); EXPECT_TRUE(sqlquery.Exec()); // Index for binding starts from 1, index for results starts from 0 EXPECT_EQ(test_url, sqlquery.GetString(3)); } -TEST_F(GeneratedCodeTest, UpdateSectionAppPolicies_SetAppParams_ExpectDBHasThem) { - - //arrange +TEST_F(GeneratedCodeTest, + UpdateSectionAppPolicies_SetAppParams_ExpectDBHasThem) { + // arrange dbms::SQLDatabase db(GeneratedCodeTest::kDatabaseName); - //assert + // assert EXPECT_TRUE(db.Open()); - //act + // act policy_table::ApplicationPolicies ap; const std::string application_id = "12345678"; ap[application_id].groups.push_back("Base-4"); ap[application_id].priority = policy_table::P_NORMAL; - //assert + // assert EXPECT_TRUE(policy_table::UpdateSection(&db, ap)); - //act + // act dbms::SQLQuery sqlquery(&db); - - //assert + // assert EXPECT_TRUE(sqlquery.Prepare("select count (*) from AppPolicies")); EXPECT_TRUE(sqlquery.Exec()); // Index for binding starts from 1, index for results starts from 0 @@ -206,9 +206,8 @@ TEST_F(GeneratedCodeTest, UpdateSectionAppPolicies_SetAppParams_ExpectDBHasThem) EXPECT_EQ(1, sqlquery.GetInteger(0)); EXPECT_TRUE(sqlquery.Reset()); - EXPECT_TRUE( - sqlquery.Prepare( - "select application_id from Groups where group_name='Base-4'")); + EXPECT_TRUE(sqlquery.Prepare( + "select application_id from Groups where group_name='Base-4'")); EXPECT_TRUE(sqlquery.Exec()); // Index for binding starts from 1, index for results starts from 0 EXPECT_EQ(application_id, sqlquery.GetString(0)); diff --git a/src/components/utils/test/include/generated_code_with_sqlite_test.h b/src/components/utils/test/include/generated_code_with_sqlite_test.h index 4ce14be649..1abeb5f6b6 100644 --- a/src/components/utils/test/include/generated_code_with_sqlite_test.h +++ b/src/components/utils/test/include/generated_code_with_sqlite_test.h @@ -51,7 +51,8 @@ bool FindSection(dbms::SQLDatabase* db, policy_table::ServiceEndpoints& ep) { * table Endpoints * index, service_type, application_id, url, is_default * - * If url belongs to default section, application_id should be null and is_defaut = true + * If url belongs to default section, application_id should be null and + *is_defaut = true * Otherwise application_id should be set and is_default = false */ @@ -101,7 +102,7 @@ bool RemoveSection(dbms::SQLDatabase* db, // bool is_nicknames_removed = sqlquery.Exec("delete from Nicknames"); bool is_groups_removed = sqlquery.Exec("delete from Groups"); - return is_policies_removed /*&& is_nicknames_removed*/&& is_groups_removed; + return is_policies_removed /*&& is_nicknames_removed*/ && is_groups_removed; } bool RemoveSection(dbms::SQLDatabase* db, @@ -135,7 +136,8 @@ bool UpdateSection(dbms::SQLDatabase* db, * table Endpoints * index, service_type, application_id, url, is_default * - * If url belongs to default section, application_id should be null and is_defaut = true + * If url belongs to default section, application_id should be null and + *is_defaut = true * Otherwise application_id should be set and is_default = false */ @@ -225,7 +227,8 @@ bool UpdateSection(dbms::SQLDatabase* db, return false; } - std::string query = "insert into FunctionalGroups values(" + std::string query = + "insert into FunctionalGroups values(" "?," "(select index from Groups where group_name=?)," "(select index from Rpcs where rpc=?)," @@ -245,10 +248,10 @@ bool UpdateSection(dbms::SQLDatabase* db, for (; it_rpcs != it_rpcs_end; ++it_rpcs) { policy_table::RpcParameters rpc_params = (*it_rpcs).second; - policy_table::HmiLevels::const_iterator it_hmi_levels = rpc_params - .hmi_levels.begin(); - policy_table::HmiLevels::const_iterator it_hmi_levels_end = rpc_params - .hmi_levels.end(); + policy_table::HmiLevels::const_iterator it_hmi_levels = + rpc_params.hmi_levels.begin(); + policy_table::HmiLevels::const_iterator it_hmi_levels_end = + rpc_params.hmi_levels.end(); for (; it_hmi_levels != it_hmi_levels_end; ++it_hmi_levels) { // Index binding @@ -302,7 +305,8 @@ bool UpdateSection(dbms::SQLDatabase* db, return false; } - std::string groups_query = "insert into Groups values (" + std::string groups_query = + "insert into Groups values (" "?," "?," "?)"; @@ -334,7 +338,8 @@ bool UpdateSection(dbms::SQLDatabase* db, app_policies_sqlquery.Bind(3, false); } - // Struct contains groups, nicknames, priority for application/default section + // Struct contains groups, nicknames, priority for application/default + // section policy_table::ApplicationParams app_params = (*it_ap).second; // Priority binding @@ -354,10 +359,13 @@ bool UpdateSection(dbms::SQLDatabase* db, // begin/end methods in its interface // To be discussed with I.Kozyrenko - // policy_table::StringArray::const_iterator it_nicknames = app_params.nicknames.begin(); - // policy_table::StringArray::const_iterator it_nicknames_end = app_params.nicknames.end(); + // policy_table::StringArray::const_iterator it_nicknames = + // app_params.nicknames.begin(); + // policy_table::StringArray::const_iterator it_nicknames_end = + // app_params.nicknames.end(); // - // for (int nick_index = 0;it_nicknames != it_nicknames_end; ++ it_nicknames, ++nick_index) { + // for (int nick_index = 0;it_nicknames != it_nicknames_end; ++ + // it_nicknames, ++nick_index) { // nicknames_sqlquery.Bind(0, nick_index); // nicknames_sqlquery.Bind(1, app_policy_name); // @@ -372,11 +380,11 @@ bool UpdateSection(dbms::SQLDatabase* db, policy_table::Strings::const_iterator it_groups = app_params.groups.begin(); - policy_table::Strings::const_iterator it_groups_end = app_params.groups - .end(); + policy_table::Strings::const_iterator it_groups_end = + app_params.groups.end(); for (int group_index = 0; it_groups != it_groups_end; - ++it_groups, ++group_index) { + ++it_groups, ++group_index) { groups_sqlquery.Bind(0, group_index); groups_sqlquery.Bind(1, app_policy_name); groups_sqlquery.Bind(2, (*it_groups)); diff --git a/src/components/utils/test/log_message_loop_thread_test.cc b/src/components/utils/test/log_message_loop_thread_test.cc index d457325d4d..14515961bb 100644 --- a/src/components/utils/test/log_message_loop_thread_test.cc +++ b/src/components/utils/test/log_message_loop_thread_test.cc @@ -45,13 +45,13 @@ using ::testing::_; TEST(LogMessageLoopThread, DestroyLogMessage_loggerStatusDeletingLogger) { logger::logger_status = CreatingLoggerThread; LogMessageLoopThread* loop_thread = new LogMessageLoopThread(); - //assert + // assert EXPECT_EQ(CreatingLoggerThread, logger::logger_status); - //act + // act delete loop_thread; - //assert + // assert EXPECT_EQ(DeletingLoggerThread, logger::logger_status); logger::logger_status = LoggerThreadNotCreated; @@ -66,7 +66,7 @@ TEST(LogMessageLoopThread, HandleNeverCalled) { logger::logger_status = CreatingLoggerThread; MockLogMessageTest mmock; - EXPECT_CALL(mmock,Handle(_)).Times(0); + EXPECT_CALL(mmock, Handle(_)).Times(0); LogMessageLoopThread* loop_thread = new LogMessageLoopThread(); delete loop_thread; diff --git a/src/components/utils/test/message_queue_test.cc b/src/components/utils/test/message_queue_test.cc index 8ce7196b07..d80016c6a8 100644 --- a/src/components/utils/test/message_queue_test.cc +++ b/src/components/utils/test/message_queue_test.cc @@ -43,21 +43,20 @@ using ::utils::MessageQueue; class MessageQueueTest : public testing::Test { public: MessageQueueTest() - : test_val_1("Hello,"), - test_val_2("Beautiful "), - test_val_3("World!"), - test_line(""), - check_value(false) { - } + : test_val_1("Hello,") + , test_val_2("Beautiful ") + , test_val_3("World!") + , test_line("") + , check_value(false) {} void add_one_element_to_queue(); void extract_from_queue(); void add_three_elements_to_queue(); void ShutDownQueue(); - static void* add_one_element_to_queue_helper(void *context); - static void* extract_from_queue_helper(void *context); - static void* add_three_elements_to_queue_helper(void *context); - static void* ShutDownQueue_helper(void *context); + static void* add_one_element_to_queue_helper(void* context); + static void* extract_from_queue_helper(void* context); + static void* add_three_elements_to_queue_helper(void* context); + static void* ShutDownQueue_helper(void* context); protected: MessageQueue<std::string> test_queue; @@ -96,20 +95,20 @@ void MessageQueueTest::ShutDownQueue() { pthread_exit(NULL); } -void* MessageQueueTest::add_one_element_to_queue_helper(void *context) { - (reinterpret_cast<MessageQueueTest *>(context))->add_one_element_to_queue(); +void* MessageQueueTest::add_one_element_to_queue_helper(void* context) { + (reinterpret_cast<MessageQueueTest*>(context))->add_one_element_to_queue(); return NULL; } -void* MessageQueueTest::extract_from_queue_helper(void *context) { - (reinterpret_cast<MessageQueueTest *>(context))->extract_from_queue(); +void* MessageQueueTest::extract_from_queue_helper(void* context) { + (reinterpret_cast<MessageQueueTest*>(context))->extract_from_queue(); return NULL; } -void* MessageQueueTest::add_three_elements_to_queue_helper(void *context) { - (reinterpret_cast<MessageQueueTest *>(context))->add_three_elements_to_queue(); +void* MessageQueueTest::add_three_elements_to_queue_helper(void* context) { + (reinterpret_cast<MessageQueueTest*>(context))->add_three_elements_to_queue(); return NULL; } -void* MessageQueueTest::ShutDownQueue_helper(void *context) { - (reinterpret_cast<MessageQueueTest *>(context))->ShutDownQueue(); +void* MessageQueueTest::ShutDownQueue_helper(void* context) { + (reinterpret_cast<MessageQueueTest*>(context))->ShutDownQueue(); return NULL; } @@ -119,9 +118,13 @@ TEST_F(MessageQueueTest, DefaultCtorTest_ExpectEmptyQueueCreated) { ASSERT_EQ(test_value, test_queue.empty()); } -TEST_F(MessageQueueTest, MessageQueuePushThreeElementsTest_ExpectThreeElementsAdded) { +TEST_F(MessageQueueTest, + MessageQueuePushThreeElementsTest_ExpectThreeElementsAdded) { pthread_t thread1; - pthread_create(&thread1, NULL, &MessageQueueTest::add_three_elements_to_queue_helper, this); + pthread_create(&thread1, + NULL, + &MessageQueueTest::add_three_elements_to_queue_helper, + this); pthread_join(thread1, NULL); // check if 3 elements were added successfully ASSERT_EQ(3u, test_queue.size()); @@ -140,12 +143,15 @@ TEST_F(MessageQueueTest, NotEmptyMessageQueueResetTest_ExpectEmptyQueue) { ASSERT_EQ(0u, test_queue.size()); } -TEST_F(MessageQueueTest, MessageQueuePopOneElementTest_ExpectOneElementRemovedFromQueue) { +TEST_F(MessageQueueTest, + MessageQueuePopOneElementTest_ExpectOneElementRemovedFromQueue) { pthread_t thread1; pthread_t thread2; // Creating threads with thread function mentioned above - pthread_create(&thread1, NULL, &MessageQueueTest::add_one_element_to_queue_helper, this); - pthread_create(&thread2, NULL, &MessageQueueTest::extract_from_queue_helper, this); + pthread_create( + &thread1, NULL, &MessageQueueTest::add_one_element_to_queue_helper, this); + pthread_create( + &thread2, NULL, &MessageQueueTest::extract_from_queue_helper, this); // Primary thread waits until thread 2 to be finished pthread_join(thread2, NULL); // Check if first element was removed successfully @@ -154,7 +160,8 @@ TEST_F(MessageQueueTest, MessageQueuePopOneElementTest_ExpectOneElementRemovedFr ASSERT_EQ(0u, test_queue.size()); } -TEST_F(MessageQueueTest, MessageQueueShutdownTest_ExpectMessageQueueWillBeShutDown) { +TEST_F(MessageQueueTest, + MessageQueueShutdownTest_ExpectMessageQueueWillBeShutDown) { pthread_t thread1; // Creating thread with thread function mentioned above pthread_create(&thread1, NULL, &MessageQueueTest::ShutDownQueue_helper, this); diff --git a/src/components/utils/test/messagemeter_test.cc b/src/components/utils/test/messagemeter_test.cc index 0db947e564..69db658542 100644 --- a/src/components/utils/test/messagemeter_test.cc +++ b/src/components/utils/test/messagemeter_test.cc @@ -40,21 +40,21 @@ #include "utils/messagemeter.h" #include "utils/date_time.h" -namespace test { -namespace components { -namespace utils { +namespace test { +namespace components { +namespace utils { // Pair of values <second, msecond> typedef std::pair<int, int> TimePair; -const TimePair testing_time_pairs[] = { TimePair(0, 50), - TimePair(0, 100), - TimePair(0, 200), - TimePair(0, 500), - TimePair(0, 900), - TimePair(1, 0), - TimePair(1, 500) }; - -class MessageMeterTest: public ::testing::TestWithParam<TimePair> { +const TimePair testing_time_pairs[] = {TimePair(0, 50), + TimePair(0, 100), + TimePair(0, 200), + TimePair(0, 500), + TimePair(0, 900), + TimePair(1, 0), + TimePair(1, 500)}; + +class MessageMeterTest : public ::testing::TestWithParam<TimePair> { protected: void SetUp() OVERRIDE { usecs = date_time::DateTime::MICROSECONDS_IN_MILLISECOND; @@ -63,20 +63,17 @@ class MessageMeterTest: public ::testing::TestWithParam<TimePair> { id3 = 0xFEBCDA; const TimePair time_pair = GetParam(); - EXPECT_GT(usecs, - time_pair.second) << "Wrong time (msecs) value"; + EXPECT_GT(usecs, time_pair.second) << "Wrong time (msecs) value"; time_range.tv_sec = time_pair.first; time_range.tv_usec = time_pair.second * usecs; - EXPECT_LT(0, - date_time::DateTime::getuSecs(time_range)) + EXPECT_LT(0, date_time::DateTime::getuSecs(time_range)) << "Wrong test case with null range value"; meter.set_time_range(time_range); time_range_msecs = date_time::DateTime::getmSecs(time_range); } - void TearDown() OVERRIDE { - } + void TearDown() OVERRIDE {} ::utils::MessageMeter<int> meter; TimevalStruct time_range = {0, 0}; int64_t time_range_msecs; @@ -86,29 +83,28 @@ class MessageMeterTest: public ::testing::TestWithParam<TimePair> { TEST(MessageMeterTest, DefaultTimeRange) { const ::utils::MessageMeter<int> default_meter; - const TimevalStruct time_second {1, 0}; + const TimevalStruct time_second{1, 0}; EXPECT_EQ(time_second, default_meter.time_range()); } TEST(MessageMeterTest, TimeRangeSetter) { ::utils::MessageMeter<int> meter; - TimevalStruct time_range {0, 0}; + TimevalStruct time_range{0, 0}; const int test_count_secs = 1000; // Skip 1000th msec value as wrong for TimevalStruct const int test_count_msecs = 999; for (int sec = test_count_secs; sec >= 0; --sec) { for (int msec = test_count_msecs; msec >= 0; --msec) { time_range.tv_sec = sec; - time_range.tv_usec = msec * date_time::DateTime::MICROSECONDS_IN_MILLISECOND; + time_range.tv_usec = + msec * date_time::DateTime::MICROSECONDS_IN_MILLISECOND; // Setter TimevalStruct meter.set_time_range(time_range); - EXPECT_EQ(time_range, - meter.time_range()) << sec << "." << msec << " sec"; + EXPECT_EQ(time_range, meter.time_range()) << sec << "." << msec << " sec"; // Setter mSecs meter.set_time_range(sec * date_time::DateTime::MILLISECONDS_IN_SECOND + msec); - EXPECT_EQ(time_range, - meter.time_range()) << sec << "." << msec << " sec"; + EXPECT_EQ(time_range, meter.time_range()) << sec << "." << msec << " sec"; } } } @@ -117,20 +113,16 @@ TEST(MessageMeterTest, AddingWithNullTimeRange) { ::utils::MessageMeter<int> meter; const int id1 = 1; const int id2 = 2; - const TimevalStruct null_time_range {0, 0}; + const TimevalStruct null_time_range{0, 0}; meter.set_time_range(null_time_range); for (int i = 0; i < 10000; ++i) { // 1st Connection - EXPECT_EQ(0u, - meter.TrackMessage(id1)); - EXPECT_EQ(0u, - meter.Frequency(id1)); + EXPECT_EQ(0u, meter.TrackMessage(id1)); + EXPECT_EQ(0u, meter.Frequency(id1)); // 2d Connection - EXPECT_EQ(0u, - meter.TrackMessage(id2)); - EXPECT_EQ(0u, - meter.Frequency(id2)); + EXPECT_EQ(0u, meter.TrackMessage(id2)); + EXPECT_EQ(0u, meter.Frequency(id2)); } } @@ -139,8 +131,8 @@ TEST_P(MessageMeterTest, TrackMessage_AddingOverPeriod_CorrectCountOfMessages) { const TimevalStruct start_time = date_time::DateTime::getCurrentTime(); // Add messages for less range period int64_t time_span; - while ((time_span = date_time::DateTime::calculateTimeSpan(start_time)) - < time_range_msecs) { + while ((time_span = date_time::DateTime::calculateTimeSpan(start_time)) < + time_range_msecs) { ++messages; size_t tracked_frequency = meter.TrackMessage(id1); @@ -158,13 +150,13 @@ TEST_P(MessageMeterTest, TrackMessage_AddingOverPeriod_CorrectCountOfMessages) { } TEST_P(MessageMeterTest, - TrackMessage_AddingOverPeriodMultiIds_CorrectCountOfMessages) { + TrackMessage_AddingOverPeriodMultiIds_CorrectCountOfMessages) { size_t messages = 0; const TimevalStruct start_time = date_time::DateTime::getCurrentTime(); // Add messages for less range period int64_t time_span; - while ((time_span = date_time::DateTime::calculateTimeSpan(start_time)) - < time_range_msecs) { + while ((time_span = date_time::DateTime::calculateTimeSpan(start_time)) < + time_range_msecs) { ++messages; size_t tracked_frequency_id1 = meter.TrackMessage(id1); @@ -181,9 +173,8 @@ TEST_P(MessageMeterTest, EXPECT_GE(messages, tracked_frequency_id3) << "Tracked messages can`t be over cycles."; - if (messages > frequency_id1 || - messages > frequency_id2 || - messages > frequency_id3) { + if (messages > frequency_id1 || messages > frequency_id2 || + messages > frequency_id3) { EXPECT_GE(time_range_msecs, time_span); break; } @@ -196,22 +187,19 @@ TEST_P(MessageMeterTest, TEST_P(MessageMeterTest, Frequency_CountingOverPeriod_CorrectCountOfMessages) { const size_t one_message = 1; const TimevalStruct start_time = date_time::DateTime::getCurrentTime(); - EXPECT_EQ(one_message, - meter.TrackMessage(id1)); - EXPECT_EQ(one_message, - meter.TrackMessage(id2)); - EXPECT_EQ(one_message, - meter.TrackMessage(id3)); + EXPECT_EQ(one_message, meter.TrackMessage(id1)); + EXPECT_EQ(one_message, meter.TrackMessage(id2)); + EXPECT_EQ(one_message, meter.TrackMessage(id3)); // Check messages count over period int64_t time_span; - while ((time_span = date_time::DateTime::calculateTimeSpan(start_time)) - < time_range_msecs) { + while ((time_span = date_time::DateTime::calculateTimeSpan(start_time)) < + time_range_msecs) { usleep(time_range_msecs); if (one_message != meter.Frequency(id1) || - one_message != meter.Frequency(id2) || - one_message != meter.Frequency(id3)) { + one_message != meter.Frequency(id2) || + one_message != meter.Frequency(id3)) { EXPECT_GE(time_range_msecs, time_span); break; } @@ -220,77 +208,53 @@ TEST_P(MessageMeterTest, Frequency_CountingOverPeriod_CorrectCountOfMessages) { TEST_P(MessageMeterTest, CountingOutOfPeriod) { const size_t one_message = 1; - EXPECT_EQ(one_message, - meter.TrackMessage(id1)); - EXPECT_EQ(one_message, - meter.TrackMessage(id2)); - EXPECT_EQ(one_message, - meter.TrackMessage(id3)); + EXPECT_EQ(one_message, meter.TrackMessage(id1)); + EXPECT_EQ(one_message, meter.TrackMessage(id2)); + EXPECT_EQ(one_message, meter.TrackMessage(id3)); // sleep more than time range usleep(time_range_msecs * usecs * 1.1); - EXPECT_EQ(0u, - meter.Frequency(id1)); - EXPECT_EQ(0u, - meter.Frequency(id2)); - EXPECT_EQ(0u, - meter.Frequency(id3)); + EXPECT_EQ(0u, meter.Frequency(id1)); + EXPECT_EQ(0u, meter.Frequency(id2)); + EXPECT_EQ(0u, meter.Frequency(id3)); } TEST_P(MessageMeterTest, ClearId) { const size_t one_message = 1; - EXPECT_EQ(one_message, - meter.TrackMessage(id1)); - EXPECT_EQ(one_message, - meter.TrackMessage(id2)); - EXPECT_EQ(one_message, - meter.TrackMessage(id3)); + EXPECT_EQ(one_message, meter.TrackMessage(id1)); + EXPECT_EQ(one_message, meter.TrackMessage(id2)); + EXPECT_EQ(one_message, meter.TrackMessage(id3)); meter.RemoveIdentifier(id1); - EXPECT_EQ(0u, - meter.Frequency(id1)); - EXPECT_EQ(one_message, - meter.Frequency(id2)); - EXPECT_EQ(one_message, - meter.Frequency(id3)); + EXPECT_EQ(0u, meter.Frequency(id1)); + EXPECT_EQ(one_message, meter.Frequency(id2)); + EXPECT_EQ(one_message, meter.Frequency(id3)); meter.RemoveIdentifier(id2); - EXPECT_EQ(0u, - meter.Frequency(id1)); - EXPECT_EQ(0u, - meter.Frequency(id2)); - EXPECT_EQ(one_message, - meter.Frequency(id3)); + EXPECT_EQ(0u, meter.Frequency(id1)); + EXPECT_EQ(0u, meter.Frequency(id2)); + EXPECT_EQ(one_message, meter.Frequency(id3)); meter.RemoveIdentifier(id3); - EXPECT_EQ(0u, - meter.Frequency(id1)); - EXPECT_EQ(0u, - meter.Frequency(id2)); - EXPECT_EQ(0u, - meter.Frequency(id3)); + EXPECT_EQ(0u, meter.Frequency(id1)); + EXPECT_EQ(0u, meter.Frequency(id2)); + EXPECT_EQ(0u, meter.Frequency(id3)); } TEST_P(MessageMeterTest, ClearIds) { const size_t one_message = 1; - EXPECT_EQ(one_message, - meter.TrackMessage(id1)); - EXPECT_EQ(one_message, - meter.TrackMessage(id2)); - EXPECT_EQ(one_message, - meter.TrackMessage(id3)); + EXPECT_EQ(one_message, meter.TrackMessage(id1)); + EXPECT_EQ(one_message, meter.TrackMessage(id2)); + EXPECT_EQ(one_message, meter.TrackMessage(id3)); meter.ClearIdentifiers(); - EXPECT_EQ(0u, - meter.Frequency(id2)); - EXPECT_EQ(0u, - meter.Frequency(id2)); - EXPECT_EQ(0u, - meter.Frequency(id3)); + EXPECT_EQ(0u, meter.Frequency(id2)); + EXPECT_EQ(0u, meter.Frequency(id2)); + EXPECT_EQ(0u, meter.Frequency(id3)); } INSTANTIATE_TEST_CASE_P(MessageMeterTestCase, diff --git a/src/components/utils/test/posix_thread_test.cc b/src/components/utils/test/posix_thread_test.cc index d597f036d0..f98794d08a 100644 --- a/src/components/utils/test/posix_thread_test.cc +++ b/src/components/utils/test/posix_thread_test.cc @@ -41,13 +41,14 @@ namespace utils { using namespace sync_primitives; using namespace threads; -// TODO(AByzhynar): Change this to use Gtest class to create all variables for every TEST_F +// TODO(AByzhynar): Change this to use Gtest class to create all variables for +// every TEST_F // TODO(AByzhynar): Add multithreading tests namespace { const uint32_t MAX_SIZE = 20; const size_t MyStackSize = 32768; -const char *threadName("test thread"); +const char* threadName("test thread"); const std::string test_thread_name("THREAD"); sync_primitives::ConditionalVariable cond_var_; sync_primitives::Lock test_mutex_; @@ -56,9 +57,7 @@ sync_primitives::Lock test_mutex_; // ThreadDelegate successor class TestThreadDelegate : public threads::ThreadDelegate { public: - TestThreadDelegate() - : check_value_(false) { - } + TestThreadDelegate() : check_value_(false) {} void threadMain() { AutoLock test_lock(test_mutex_); check_value_ = true; @@ -68,14 +67,15 @@ class TestThreadDelegate : public threads::ThreadDelegate { bool check_value() const { return check_value_; } + private: bool check_value_; }; TEST(PosixThreadTest, CreateThread_ExpectThreadCreated) { // Arrange - threads::Thread *thread = NULL; - TestThreadDelegate *threadDelegate = new TestThreadDelegate(); + threads::Thread* thread = NULL; + TestThreadDelegate* threadDelegate = new TestThreadDelegate(); // Create thread ASSERT_NO_THROW(thread = CreateThread(threadName, threadDelegate)); EXPECT_TRUE(thread != NULL); @@ -89,8 +89,8 @@ TEST(PosixThreadTest, CreateThread_ExpectThreadCreated) { TEST(PosixThreadTest, CheckCreatedThreadName_ExpectCorrectName) { // Arrange - threads::Thread *thread = NULL; - threads::ThreadDelegate *threadDelegate = new TestThreadDelegate(); + threads::Thread* thread = NULL; + threads::ThreadDelegate* threadDelegate = new TestThreadDelegate(); // Create thread ASSERT_NO_THROW(thread = CreateThread(threadName, threadDelegate)); // Check thread was created with correct name @@ -100,10 +100,11 @@ TEST(PosixThreadTest, CheckCreatedThreadName_ExpectCorrectName) { EXPECT_EQ(NULL, thread->delegate()); } -TEST(PosixThreadTest, CheckCreatedThreadNameChangeToLongName_ExpectThreadNameReduced) { +TEST(PosixThreadTest, + CheckCreatedThreadNameChangeToLongName_ExpectThreadNameReduced) { // Arrange - threads::Thread *thread = NULL; - TestThreadDelegate *threadDelegate = new TestThreadDelegate(); + threads::Thread* thread = NULL; + TestThreadDelegate* threadDelegate = new TestThreadDelegate(); AutoLock test_lock(test_mutex_); // Create thread ASSERT_NO_THROW(thread = CreateThread(threadName, threadDelegate)); @@ -124,14 +125,17 @@ TEST(PosixThreadTest, CheckCreatedThreadNameChangeToLongName_ExpectThreadNameRed EXPECT_EQ(NULL, thread->delegate()); } -TEST(PosixThreadTest, StartCreatedThreadWithOptionsJoinableAndMyStackSize_ExpectMyStackSizeStackAndJoinableThreadStarted) { +TEST( + PosixThreadTest, + StartCreatedThreadWithOptionsJoinableAndMyStackSize_ExpectMyStackSizeStackAndJoinableThreadStarted) { // Arrange - threads::Thread *thread = NULL; - TestThreadDelegate *threadDelegate = new TestThreadDelegate(); + threads::Thread* thread = NULL; + TestThreadDelegate* threadDelegate = new TestThreadDelegate(); AutoLock test_lock(test_mutex_); // Create thread ASSERT_NO_THROW(thread = CreateThread(threadName, threadDelegate)); - // Start thread with following options (Stack size = 32768 & thread is joinable) + // Start thread with following options (Stack size = 32768 & thread is + // joinable) thread->start(threads::ThreadOptions(MyStackSize)); // Check thread is joinable EXPECT_TRUE(thread->is_joinable()); @@ -144,10 +148,12 @@ TEST(PosixThreadTest, StartCreatedThreadWithOptionsJoinableAndMyStackSize_Expect EXPECT_EQ(NULL, thread->delegate()); } -TEST(PosixThreadTest, StartCreatedThreadWithDefaultOptions_ExpectZeroStackAndJoinableThreadStarted) { +TEST( + PosixThreadTest, + StartCreatedThreadWithDefaultOptions_ExpectZeroStackAndJoinableThreadStarted) { // Arrange - threads::Thread *thread = NULL; - TestThreadDelegate *threadDelegate = new TestThreadDelegate(); + threads::Thread* thread = NULL; + TestThreadDelegate* threadDelegate = new TestThreadDelegate(); AutoLock test_lock(test_mutex_); // Create thread ASSERT_NO_THROW(thread = CreateThread(threadName, threadDelegate)); @@ -164,10 +170,12 @@ TEST(PosixThreadTest, StartCreatedThreadWithDefaultOptions_ExpectZeroStackAndJoi EXPECT_EQ(NULL, thread->delegate()); } -TEST(PosixThreadTest, StartThreadWithZeroStackAndDetached_ExpectMinimumStackAndDetachedThreadStarted) { +TEST( + PosixThreadTest, + StartThreadWithZeroStackAndDetached_ExpectMinimumStackAndDetachedThreadStarted) { // Arrange - threads::Thread *thread = NULL; - TestThreadDelegate *threadDelegate = new TestThreadDelegate(); + threads::Thread* thread = NULL; + TestThreadDelegate* threadDelegate = new TestThreadDelegate(); AutoLock test_lock(test_mutex_); // Create thread ASSERT_NO_THROW(thread = CreateThread(threadName, threadDelegate)); @@ -184,10 +192,12 @@ TEST(PosixThreadTest, StartThreadWithZeroStackAndDetached_ExpectMinimumStackAndD EXPECT_EQ(NULL, thread->delegate()); } -TEST(PosixThreadTest, DISABLED_CheckCreatedThreadNameChangeToEmpty_ExpectThreadNameChangedToEmpty) { +TEST( + PosixThreadTest, + DISABLED_CheckCreatedThreadNameChangeToEmpty_ExpectThreadNameChangedToEmpty) { // Arrange - threads::Thread *thread = NULL; - TestThreadDelegate *threadDelegate = new TestThreadDelegate(); + threads::Thread* thread = NULL; + TestThreadDelegate* threadDelegate = new TestThreadDelegate(); AutoLock test_lock(test_mutex_); // Create thread ASSERT_NO_THROW(thread = CreateThread(threadName, threadDelegate)); @@ -208,10 +218,11 @@ TEST(PosixThreadTest, DISABLED_CheckCreatedThreadNameChangeToEmpty_ExpectThreadN EXPECT_EQ(NULL, thread->delegate()); } -TEST(PosixThreadTest, CheckCreatedThreadNameChangeToShortName_ExpectThreadNameChangedToShort) { +TEST(PosixThreadTest, + CheckCreatedThreadNameChangeToShortName_ExpectThreadNameChangedToShort) { // Arrange - threads::Thread *thread = NULL; - TestThreadDelegate *threadDelegate = new TestThreadDelegate(); + threads::Thread* thread = NULL; + TestThreadDelegate* threadDelegate = new TestThreadDelegate(); AutoLock test_lock(test_mutex_); // Create thread ASSERT_NO_THROW(thread = CreateThread(threadName, threadDelegate)); @@ -235,13 +246,14 @@ TEST(PosixThreadTest, CheckCreatedThreadNameChangeToShortName_ExpectThreadNameCh TEST(PosixThreadTest, StartThread_ExpectThreadStarted) { // Arrange - threads::Thread *thread = NULL; - TestThreadDelegate *threadDelegate = new TestThreadDelegate(); + threads::Thread* thread = NULL; + TestThreadDelegate* threadDelegate = new TestThreadDelegate(); AutoLock test_lock(test_mutex_); // Create thread ASSERT_NO_THROW(thread = CreateThread(threadName, threadDelegate)); // Start created thread - EXPECT_TRUE(thread->start(threads::ThreadOptions(threads::Thread::kMinStackSize))); + EXPECT_TRUE( + thread->start(threads::ThreadOptions(threads::Thread::kMinStackSize))); cond_var_.WaitFor(test_lock, 10000); EXPECT_TRUE(threadDelegate->check_value()); DeleteThread(thread); @@ -253,17 +265,19 @@ TEST(PosixThreadTest, StartOneThreadTwice_ExpectTheSameThreadStartedTwice) { // Arrange PlatformThreadHandle thread1_id; PlatformThreadHandle thread2_id; - threads::Thread *thread = NULL; - TestThreadDelegate *threadDelegate = new TestThreadDelegate(); + threads::Thread* thread = NULL; + TestThreadDelegate* threadDelegate = new TestThreadDelegate(); AutoLock test_lock(test_mutex_); // Create thread ASSERT_NO_THROW(thread = CreateThread(threadName, threadDelegate)); // Start created thread - EXPECT_TRUE(thread->start(threads::ThreadOptions(threads::Thread::kMinStackSize))); + EXPECT_TRUE( + thread->start(threads::ThreadOptions(threads::Thread::kMinStackSize))); thread1_id = thread->CurrentId(); thread->stop(); // Try to start thread again - EXPECT_TRUE(thread->start(threads::ThreadOptions(threads::Thread::kMinStackSize))); + EXPECT_TRUE( + thread->start(threads::ThreadOptions(threads::Thread::kMinStackSize))); thread2_id = thread->CurrentId(); EXPECT_EQ(thread1_id, thread2_id); cond_var_.WaitFor(test_lock, 10000); @@ -273,17 +287,19 @@ TEST(PosixThreadTest, StartOneThreadTwice_ExpectTheSameThreadStartedTwice) { EXPECT_EQ(NULL, thread->delegate()); } -TEST(PosixThreadTest, StartOneThreadAgainAfterRename_ExpectRenamedThreadStarted) { +TEST(PosixThreadTest, + StartOneThreadAgainAfterRename_ExpectRenamedThreadStarted) { // Arrange PlatformThreadHandle thread1_id; PlatformThreadHandle thread2_id; - threads::Thread *thread = NULL; - TestThreadDelegate *threadDelegate = new TestThreadDelegate(); + threads::Thread* thread = NULL; + TestThreadDelegate* threadDelegate = new TestThreadDelegate(); AutoLock test_lock(test_mutex_); // Create thread ASSERT_NO_THROW(thread = CreateThread(threadName, threadDelegate)); // Start created thread - EXPECT_TRUE(thread->start(threads::ThreadOptions(threads::Thread::kMinStackSize))); + EXPECT_TRUE( + thread->start(threads::ThreadOptions(threads::Thread::kMinStackSize))); thread1_id = thread->CurrentId(); // Rename started thread. Name will be cut to 15 symbols + '\0' // This is the limit in current POSIX thread implementation @@ -295,7 +311,8 @@ TEST(PosixThreadTest, StartOneThreadAgainAfterRename_ExpectRenamedThreadStarted) EXPECT_EQ(test_thread_name, std::string(name)); // Stop thread thread->stop(); - EXPECT_TRUE(thread->start(threads::ThreadOptions(threads::Thread::kMinStackSize))); + EXPECT_TRUE( + thread->start(threads::ThreadOptions(threads::Thread::kMinStackSize))); thread2_id = thread->CurrentId(); // Expect the same thread started with the the same name EXPECT_EQ(test_thread_name, std::string(name)); diff --git a/src/components/utils/test/prioritized_queue_test.cc b/src/components/utils/test/prioritized_queue_test.cc index 19e168cdce..ef105f6c4e 100644 --- a/src/components/utils/test/prioritized_queue_test.cc +++ b/src/components/utils/test/prioritized_queue_test.cc @@ -41,16 +41,13 @@ using ::utils::PrioritizedQueue; class TestMessage { public: - TestMessage() - : priority(0) { - } + TestMessage() : priority(0) {} TestMessage(std::string message, size_t msg_priority) - : msg_(message), - priority(msg_priority) { - } + : msg_(message), priority(msg_priority) {} size_t PriorityOrder() const; std::string msg() const; - friend bool operator==(const TestMessage &msg1, const TestMessage &msg2); + friend bool operator==(const TestMessage& msg1, const TestMessage& msg2); + private: std::string msg_; size_t priority; @@ -64,9 +61,9 @@ std::string TestMessage::msg() const { return msg_; } -bool operator==(const TestMessage &msg1, const TestMessage &msg2) { - return (msg1.msg() == msg2.msg() - && msg1.PriorityOrder() == msg2.PriorityOrder()); +bool operator==(const TestMessage& msg1, const TestMessage& msg2) { + return (msg1.msg() == msg2.msg() && + msg1.PriorityOrder() == msg2.PriorityOrder()); } class PrioritizedQueueTest : public testing::Test { @@ -108,13 +105,15 @@ TEST_F(PrioritizedQueueTest, AddFourElementsTest_ExpectQueueNotEmpty) { EXPECT_FALSE(test_queue.empty()); } -TEST_F(PrioritizedQueueTest, CheckMessageOrder_ExpectMessageWithHighestPriorityAddedFirst) { +TEST_F(PrioritizedQueueTest, + CheckMessageOrder_ExpectMessageWithHighestPriorityAddedFirst) { // Creating 4 messages with different priorities TestMessage message1("Ford", 111); TestMessage message2("Hello", 21); TestMessage message3("Luxoft", 14); TestMessage message4("from", 4); - // Adding created messages to Prioritized queue. Expect queue ordered according priority + // Adding created messages to Prioritized queue. Expect queue ordered + // according priority test_queue.push(message4); test_queue.push(message3); test_queue.push(message1); @@ -123,7 +122,8 @@ TEST_F(PrioritizedQueueTest, CheckMessageOrder_ExpectMessageWithHighestPriorityA EXPECT_EQ(message1, test_queue.front()); } -TEST_F(PrioritizedQueueTest, Push_AddMessagesWithEqualPriority_ExpectMessagesWithEqualPriorityAdded) { +TEST_F(PrioritizedQueueTest, + Push_AddMessagesWithEqualPriority_ExpectMessagesWithEqualPriorityAdded) { // Creating 2 messages with the same priorities TestMessage message1("Hello", 111); TestMessage message2("Luxoft", 111); @@ -134,14 +134,17 @@ TEST_F(PrioritizedQueueTest, Push_AddMessagesWithEqualPriority_ExpectMessagesWit EXPECT_EQ(2u, test_queue.size()); } -TEST_F(PrioritizedQueueTest, Pop_OneElementInPriorityQueue_ExpectQueueStillAliveWithRestMessagesWithEqualPriority) { +TEST_F( + PrioritizedQueueTest, + Pop_OneElementInPriorityQueue_ExpectQueueStillAliveWithRestMessagesWithEqualPriority) { // Creating 4 messages with same priorities TestMessage message1("Ford's", 111); TestMessage message2("Partner", 111); // Adding created messages to Prioritized queue. test_queue.push(message1); test_queue.push(message2); - // Expect 2 messages were added successfully to One element of prioritized queue + // Expect 2 messages were added successfully to One element of prioritized + // queue EXPECT_EQ(2u, test_queue.size()); // Extracting first element from the queue EXPECT_EQ(message1, test_queue.front()); @@ -153,7 +156,9 @@ TEST_F(PrioritizedQueueTest, Pop_OneElementInPriorityQueue_ExpectQueueStillAlive EXPECT_EQ(0u, test_queue.size()); } -TEST_F(PrioritizedQueueTest, Pop_TwoElementsInPriorityQueue_ExpectElementErasedIfOnlyOneWithConcretePriorityExist) { +TEST_F( + PrioritizedQueueTest, + Pop_TwoElementsInPriorityQueue_ExpectElementErasedIfOnlyOneWithConcretePriorityExist) { // Creating 2 messages with same priority and 1 with different TestMessage message1("Hello", 111); TestMessage message2("Luxoft", 111); @@ -162,7 +167,8 @@ TEST_F(PrioritizedQueueTest, Pop_TwoElementsInPriorityQueue_ExpectElementErasedI test_queue.push(message1); test_queue.push(message2); test_queue.push(message3); - // Expect 3 messages were added successfully to Two elements of prioritized queue + // Expect 3 messages were added successfully to Two elements of prioritized + // queue EXPECT_EQ(3u, test_queue.size()); // Extracting first element from the queue EXPECT_EQ(message1, test_queue.front()); @@ -177,7 +183,8 @@ TEST_F(PrioritizedQueueTest, Pop_TwoElementsInPriorityQueue_ExpectElementErasedI EXPECT_EQ(0u, test_queue.size()); } -TEST_F(PrioritizedQueueTest, NotEmptyPrioritizedQueuePopElement_ExpectQueueDecreasedOneElement) { +TEST_F(PrioritizedQueueTest, + NotEmptyPrioritizedQueuePopElement_ExpectQueueDecreasedOneElement) { // Creating 4 prioritized messages TestMessage message1("Alice", 111); TestMessage message2("in", 14); diff --git a/src/components/utils/test/qdb_wrapper/sql_query_test.cc b/src/components/utils/test/qdb_wrapper/sql_query_test.cc index 4d880a4cda..6c866ffb9d 100644 --- a/src/components/utils/test/qdb_wrapper/sql_query_test.cc +++ b/src/components/utils/test/qdb_wrapper/sql_query_test.cc @@ -55,8 +55,9 @@ class SQLQueryTest : public ::testing::Test { static void SetUpTestCase() { conn = qdb_connect(kDatabaseName.c_str(), 0); ASSERT_TRUE(conn); - int ret = qdb_statement(conn, "CREATE TABLE testTable (integerValue INTEGER," - " doubleValue REAL, stringValue TEXT)"); + int ret = qdb_statement(conn, + "CREATE TABLE testTable (integerValue INTEGER," + " doubleValue REAL, stringValue TEXT)"); ASSERT_NE(-1, ret); } @@ -93,9 +94,10 @@ TEST_F(SQLQueryTest, Query) { } TEST_F(SQLQueryTest, ExecString) { - const std::string kInsert("INSERT INTO testTable" - " (integerValue, doubleValue, stringValue)" - " VALUES(1, 1.1, 'one-один')"); + const std::string kInsert( + "INSERT INTO testTable" + " (integerValue, doubleValue, stringValue)" + " VALUES(1, 1.1, 'one-один')"); SQLDatabase* db = new SQLDatabase(kDatabaseName); ASSERT_TRUE(db->Open()); @@ -153,8 +155,9 @@ TEST_F(SQLQueryTest, BindString) { } TEST_F(SQLQueryTest, BindAllTypes) { - const std::string kInsert("INSERT INTO testTable (integerValue, doubleValue," - " stringValue) VALUES (?, ?, ?)"); + const std::string kInsert( + "INSERT INTO testTable (integerValue, doubleValue," + " stringValue) VALUES (?, ?, ?)"); const int kIntegerValue = 5; const double kDoubleValue = 5.5; const std::string kStringValue = "five-пять"; @@ -176,13 +179,15 @@ TEST_F(SQLQueryTest, BindAllTypes) { } TEST_F(SQLQueryTest, Value) { - const char* insert = "INSERT INTO testTable " + const char* insert = + "INSERT INTO testTable " "(integerValue, doubleValue, stringValue) " "VALUES (6, 6.6, 'six-шесть');"; ASSERT_NE(-1, qdb_statement(conn, insert)); - const std::string kSelect("SELECT integerValue, doubleValue, stringValue" - " FROM testTable WHERE integerValue = 6"); + const std::string kSelect( + "SELECT integerValue, doubleValue, stringValue" + " FROM testTable WHERE integerValue = 6"); const int kIntegerValue = 6; const double kDoubleValue = 6.6; const std::string kStringValue = "six-шесть"; @@ -203,8 +208,9 @@ TEST_F(SQLQueryTest, Value) { } TEST_F(SQLQueryTest, EmptySelect) { - const std::string kSelect("SELECT integerValue, doubleValue, stringValue" - " FROM testTable WHERE 0"); + const std::string kSelect( + "SELECT integerValue, doubleValue, stringValue" + " FROM testTable WHERE 0"); SQLDatabase* db = new SQLDatabase(kDatabaseName); ASSERT_TRUE(db->Open()); @@ -216,13 +222,15 @@ TEST_F(SQLQueryTest, EmptySelect) { } TEST_F(SQLQueryTest, NextAndBind) { - const char* insert = "INSERT INTO testTable " + const char* insert = + "INSERT INTO testTable " "(integerValue, doubleValue, stringValue) " "VALUES (7, 7.7, 'seven-семь');"; ASSERT_NE(-1, qdb_statement(conn, insert)); - const std::string kSelect("SELECT integerValue, doubleValue, stringValue" - " FROM testTable WHERE integerValue = ?"); + const std::string kSelect( + "SELECT integerValue, doubleValue, stringValue" + " FROM testTable WHERE integerValue = ?"); const int kIntegerValue = 7; const double kDoubleValue = 7.7; const std::string kStringValue = "seven-семь"; @@ -245,7 +253,8 @@ TEST_F(SQLQueryTest, NextAndBind) { } TEST_F(SQLQueryTest, LastInsertId) { - const char* create = "CREATE TABLE idTable ( " + const char* create = + "CREATE TABLE idTable ( " "id INTEGER PRIMARY KEY AUTOINCREMENT," "value TEXT)"; ASSERT_NE(-1, qdb_statement(conn, create)); @@ -270,8 +279,9 @@ TEST_F(SQLQueryTest, LastInsertId) { } TEST_F(SQLQueryTest, BindNull) { - const std::string kInsert("INSERT INTO testTable (`integerValue`)" - " VALUES (?)"); + const std::string kInsert( + "INSERT INTO testTable (`integerValue`)" + " VALUES (?)"); SQLDatabase* db = new SQLDatabase(kDatabaseName); ASSERT_TRUE(db->Open()); diff --git a/src/components/utils/test/resource_usage_test.cc b/src/components/utils/test/resource_usage_test.cc index cac5dc2e31..96b4fe4b49 100644 --- a/src/components/utils/test/resource_usage_test.cc +++ b/src/components/utils/test/resource_usage_test.cc @@ -60,25 +60,24 @@ TEST_F(ResourceUsagePrivateTest, GetMemInfoTest) { } TEST_F(ResourceUsagePrivateTest, GetStatPathTest_FileExists) { - //arrange + // arrange std::string filename = res.GetStatPath(); - //assert + // assert EXPECT_TRUE(file_system::FileExists(filename)); } TEST_F(ResourceUsagePrivateTest, GetStatPathTest_ReadFile) { - //arrange + // arrange std::string filename = res.GetStatPath(); std::string output; - //assert + // assert EXPECT_TRUE(file_system::ReadFile(filename, output)); - } TEST_F(ResourceUsagePrivateTest, GetProcPathTest) { - ///arrange + /// arrange std::string fd = res.GetProcPath(); std::string filename = res.GetStatPath(); - //assert + // assert EXPECT_EQ(filename, fd + "/stat"); } } @@ -88,7 +87,8 @@ namespace components { namespace utils_test { TEST(ResourceUsageTest, SuccesfulGrabResources) { - ::utils::ResourseUsage* resources = ::utils::Resources::getCurrentResourseUsage(); + ::utils::ResourseUsage* resources = + ::utils::Resources::getCurrentResourseUsage(); EXPECT_TRUE(resources != NULL); delete resources; } diff --git a/src/components/utils/test/rwlock_posix_test.cc b/src/components/utils/test/rwlock_posix_test.cc index 779b57ff32..6cb140f4c5 100644 --- a/src/components/utils/test/rwlock_posix_test.cc +++ b/src/components/utils/test/rwlock_posix_test.cc @@ -72,20 +72,20 @@ class RWlockTest : public ::testing::Test { } } - static void* ReadLock_helper(void *context) { - RWlockTest *temp = reinterpret_cast<RWlockTest *>(context); + static void* ReadLock_helper(void* context) { + RWlockTest* temp = reinterpret_cast<RWlockTest*>(context); temp->ReadLock(); return NULL; } - static void* TryReadLock_helper(void *context) { - RWlockTest *temp = reinterpret_cast<RWlockTest *>(context); + static void* TryReadLock_helper(void* context) { + RWlockTest* temp = reinterpret_cast<RWlockTest*>(context); temp->ExpectReadLockFail(); return NULL; } - static void* TryWriteLock_helper(void *context) { - RWlockTest *temp = reinterpret_cast<RWlockTest *>(context); + static void* TryWriteLock_helper(void* context) { + RWlockTest* temp = reinterpret_cast<RWlockTest*>(context); temp->ExpectWriteLockFail(); return NULL; } @@ -101,7 +101,8 @@ TEST_F(RWlockTest, AcquireForReading_ExpectAccessForReading) { EXPECT_TRUE(test_rwlock.AcquireForReading()); // Try to lock rw lock for reading again EXPECT_TRUE(test_rwlock.AcquireForReading()); - // Creating kNumThreads threads, starting them with callback function, waits until all of them finished + // Creating kNumThreads threads, starting them with callback function, waits + // until all of them finished ThreadsDispatcher(&RWlockTest::ReadLock_helper); // Releasing RW locks EXPECT_TRUE(test_rwlock.Release()); @@ -113,7 +114,8 @@ TEST_F(RWlockTest, AcquireForReading_ExpectNoAccessForWriting) { EXPECT_TRUE(test_rwlock.AcquireForReading()); // Try to lock rw lock for writing EXPECT_FALSE(test_rwlock.TryAcquireForWriting()); - // Creating kNumThreads threads, starting them with callback function, waits until all of them finished + // Creating kNumThreads threads, starting them with callback function, waits + // until all of them finished ThreadsDispatcher(&RWlockTest::TryWriteLock_helper); EXPECT_TRUE(test_rwlock.Release()); } @@ -123,7 +125,8 @@ TEST_F(RWlockTest, AcquireForWriting_ExpectNoAccessForReading) { EXPECT_TRUE(test_rwlock.AcquireForWriting()); // Try to lock rw lock for reading EXPECT_FALSE(test_rwlock.TryAcquireForReading()); - // Creating kNumThreads threads, starting them with callback function, waits until all of them finished + // Creating kNumThreads threads, starting them with callback function, waits + // until all of them finished ThreadsDispatcher(&RWlockTest::TryReadLock_helper); EXPECT_TRUE(test_rwlock.Release()); } @@ -133,7 +136,8 @@ TEST_F(RWlockTest, AcquireForWriting_ExpectNoMoreAccessForWriting) { EXPECT_TRUE(test_rwlock.AcquireForWriting()); // Try to lock rw lock for reading EXPECT_FALSE(test_rwlock.TryAcquireForWriting()); - // Creating kNumThreads threads, starting them with callback function, waits until all of them finished + // Creating kNumThreads threads, starting them with callback function, waits + // until all of them finished ThreadsDispatcher(&RWlockTest::TryWriteLock_helper); EXPECT_TRUE(test_rwlock.Release()); } diff --git a/src/components/utils/test/shared_ptr_test.cc b/src/components/utils/test/shared_ptr_test.cc index 92d867fe76..85682073aa 100644 --- a/src/components/utils/test/shared_ptr_test.cc +++ b/src/components/utils/test/shared_ptr_test.cc @@ -42,20 +42,20 @@ namespace utils { namespace SharedPtrTest { class CMockObject { - public: - CMockObject(int id); - virtual ~CMockObject(); - virtual int getId() const; + public: + CMockObject(int id); + virtual ~CMockObject(); + virtual int getId() const; - MOCK_METHOD0(destructor, void ()); + MOCK_METHOD0(destructor, void()); - private: - int mId_; + private: + int mId_; }; class CExtendedMockObject : public CMockObject { - public: - CExtendedMockObject(int id); + public: + CExtendedMockObject(int id); }; } // namespace CMockObject @@ -66,9 +66,7 @@ class CExtendedMockObject : public CMockObject { using namespace test::components::utils::SharedPtrTest; using ::testing::NiceMock; -CMockObject::CMockObject(int id) - : mId_(id) { -} +CMockObject::CMockObject(int id) : mId_(id) {} CMockObject::~CMockObject() { destructor(); @@ -78,9 +76,7 @@ int CMockObject::getId() const { return mId_; } -CExtendedMockObject::CExtendedMockObject(int id) - : CMockObject(id) { -} +CExtendedMockObject::CExtendedMockObject(int id) : CMockObject(id) {} typedef utils::SharedPtr<CMockObject> tMockObjectPtr; typedef utils::SharedPtr<CExtendedMockObject> tExtendedMockObjectPtr; @@ -120,9 +116,9 @@ TEST(SharedPtrTest, CopyConstructorTest) { ASSERT_EQ(1, p3->getId()); ASSERT_EQ(3u, *(p3.get_ReferenceCounter())); { - tMockObjectPtr p4 = p3; - ASSERT_EQ(1, p4->getId()); - ASSERT_EQ(4u, *(p3.get_ReferenceCounter())); + tMockObjectPtr p4 = p3; + ASSERT_EQ(1, p4->getId()); + ASSERT_EQ(4u, *(p3.get_ReferenceCounter())); } // Check reference counter decreased ASSERT_EQ(3u, *(p3.get_ReferenceCounter())); @@ -283,10 +279,9 @@ TEST(SharedPtrTest, LessThanOperatorTest) { // Checks if (object1 < object2) { - ASSERT_TRUE(p1 < p2); - } - else { - ASSERT_FALSE(p1 < p2); + ASSERT_TRUE(p1 < p2); + } else { + ASSERT_FALSE(p1 < p2); } EXPECT_CALL(*object1, destructor()); @@ -309,7 +304,8 @@ TEST(SharedPtrTest, StaticPointerCastTest_DerivedToBase_ExpectCastOk) { ASSERT_EQ(2, ep1->getId()); ASSERT_EQ(1u, *(ep1.get_ReferenceCounter())); // Cast from SharedPtr to Derived class to SharedPtr to Base class - p1 = utils::SharedPtr<CExtendedMockObject>::static_pointer_cast< CMockObject >(ep1); + p1 = utils::SharedPtr<CExtendedMockObject>::static_pointer_cast<CMockObject>( + ep1); // Checks ASSERT_EQ(2, p1->getId()); ASSERT_EQ(2u, *(p1.get_ReferenceCounter())); @@ -334,7 +330,8 @@ TEST(SharedPtrTest, StaticPointerCastTest_BaseToDerived_ExpectCastOk) { ASSERT_EQ(2, ep1->getId()); ASSERT_EQ(1u, *(ep1.get_ReferenceCounter())); // Cast from SharedPtr to Base class to SharedPtr to Derived class - ep1 = utils::SharedPtr<CMockObject>::static_pointer_cast<CExtendedMockObject>(p1); + ep1 = utils::SharedPtr<CMockObject>::static_pointer_cast<CExtendedMockObject>( + p1); // Checks ASSERT_EQ(1, ep1->getId()); ASSERT_EQ(2u, *(ep1.get_ReferenceCounter())); @@ -359,7 +356,8 @@ TEST(SharedPtrTest, DynamicPointerCastTest_DerivedToBase_ExpectCastOk) { ASSERT_EQ(2, ep1->getId()); ASSERT_EQ(1u, *(ep1.get_ReferenceCounter())); // Cast from SharedPtr to Derived class to SharedPtr to Base class - p1 = utils::SharedPtr<CExtendedMockObject>::dynamic_pointer_cast< CMockObject >(ep1); + p1 = utils::SharedPtr<CExtendedMockObject>::dynamic_pointer_cast<CMockObject>( + ep1); // Checks ASSERT_EQ(2, p1->getId()); ASSERT_EQ(2u, *(p1.get_ReferenceCounter())); @@ -384,7 +382,9 @@ TEST(SharedPtrTest, DynamicPointerCastTest_BaseToDerived_ExpectNullPtr) { ASSERT_EQ(2, ep1->getId()); ASSERT_EQ(1u, *(ep1.get_ReferenceCounter())); // Cast from SharedPtr to Base class to SharedPtr to Derived class - ep1 = utils::SharedPtr<CMockObject>::dynamic_pointer_cast<CExtendedMockObject>(p1); + ep1 = + utils::SharedPtr<CMockObject>::dynamic_pointer_cast<CExtendedMockObject>( + p1); // Checks ASSERT_EQ(NULL, ep1); @@ -539,6 +539,7 @@ TEST(SharedPtrTest, StressTest) { } } } - printf("%zu objects created, %zu pointers copied\n", objectCreated, + printf("%zu objects created, %zu pointers copied\n", + objectCreated, pointersCopied); } diff --git a/src/components/utils/test/singleton_test.cc b/src/components/utils/test/singleton_test.cc index 8a9e6b31e1..3bad45a7d7 100644 --- a/src/components/utils/test/singleton_test.cc +++ b/src/components/utils/test/singleton_test.cc @@ -42,7 +42,6 @@ using ::utils::Singleton; class SingletonTest : public ::utils::Singleton<SingletonTest> { public: - void SetValue(int value) { test_value = value; } @@ -50,128 +49,129 @@ class SingletonTest : public ::utils::Singleton<SingletonTest> { return test_value; } - FRIEND_BASE_SINGLETON_CLASS (SingletonTest); + FRIEND_BASE_SINGLETON_CLASS(SingletonTest); + private: int test_value; }; TEST(SingletonTest, CreateAndDestroySingleton) { - //assert + // assert ASSERT_EQ(SingletonTest::instance(), SingletonTest::instance()); ASSERT_EQ(0, SingletonTest::instance()->GetValue()); ASSERT_TRUE(SingletonTest::exists()); SingletonTest::instance()->SetValue(5); ASSERT_EQ(5, SingletonTest::instance()->GetValue()); - //act + // act SingletonTest::destroy(); - //assert + // assert ASSERT_FALSE(SingletonTest::exists()); } TEST(SingletonTest, DestroySingletonTwice) { - //assert + // assert ASSERT_EQ(0, SingletonTest::instance()->GetValue()); ASSERT_TRUE(SingletonTest::exists()); - //act + // act SingletonTest::destroy(); - //assert + // assert ASSERT_FALSE(SingletonTest::exists()); - //act + // act SingletonTest::destroy(); - //assert + // assert ASSERT_FALSE(SingletonTest::exists()); } TEST(SingletonTest, DeleteSingletonCreateAnother) { - //arrange + // arrange SingletonTest::instance()->SetValue(10); - //assert + // assert ASSERT_TRUE(SingletonTest::exists()); ASSERT_EQ(10, SingletonTest::instance()->GetValue()); - //act + // act SingletonTest::destroy(); - //assert + // assert ASSERT_FALSE(SingletonTest::exists()); - //act + // act SingletonTest::instance(); - //assert + // assert ASSERT_EQ(0, SingletonTest::instance()->GetValue()); ASSERT_TRUE(SingletonTest::exists()); SingletonTest::destroy(); } void* func_pthread1(void*) { - SingletonTest* singleton_in_other_thread = SingletonTest::instance(); + SingletonTest* singleton_in_other_thread = SingletonTest::instance(); pthread_exit(singleton_in_other_thread); return NULL; } -void* func_pthread2(void * value) { - SingletonTest * instance = reinterpret_cast<SingletonTest *>(value); +void* func_pthread2(void* value) { + SingletonTest* instance = reinterpret_cast<SingletonTest*>(value); instance->destroy(); - pthread_exit (NULL); + pthread_exit(NULL); return NULL; } TEST(SingletonTest, CreateSingletonInDifferentThreads) { - //arrange + // arrange SingletonTest::instance(); ASSERT_TRUE(SingletonTest::exists()); pthread_t thread1; pthread_create(&thread1, NULL, func_pthread1, NULL); - void *instance2; + void* instance2; pthread_join(thread1, &instance2); - SingletonTest * instance_2 = reinterpret_cast<SingletonTest *>(instance2); + SingletonTest* instance_2 = reinterpret_cast<SingletonTest*>(instance2); - //assert + // assert ASSERT_EQ(SingletonTest::instance(), instance_2); - //act + // act SingletonTest::destroy(); - //assert + // assert ASSERT_FALSE(SingletonTest::exists()); } TEST(SingletonTest, CreateDeleteSingletonInDifferentThreads) { - //arrange + // arrange pthread_t thread1; pthread_create(&thread1, NULL, func_pthread1, NULL); pthread_t thread2; pthread_create(&thread2, NULL, func_pthread1, NULL); - void *instance1; + void* instance1; pthread_join(thread1, &instance1); - SingletonTest * instance_1 = reinterpret_cast<SingletonTest *>(instance1); + SingletonTest* instance_1 = reinterpret_cast<SingletonTest*>(instance1); - void *instance2; + void* instance2; pthread_join(thread2, &instance2); - SingletonTest * instance_2 = reinterpret_cast<SingletonTest *>(instance2); + SingletonTest* instance_2 = reinterpret_cast<SingletonTest*>(instance2); - //assert + // assert ASSERT_TRUE(instance_1->exists()); ASSERT_TRUE(instance_2->exists()); ASSERT_EQ(instance_1, instance_2); - //act + // act SingletonTest::destroy(); - //assert + // assert ASSERT_FALSE(instance_1->exists()); ASSERT_FALSE(instance_2->exists()); } TEST(SingletonTest, DeleteSingletonInDifferentThread) { - //arrange + // arrange SingletonTest::instance(); ASSERT_TRUE(SingletonTest::exists()); @@ -180,7 +180,7 @@ TEST(SingletonTest, DeleteSingletonInDifferentThread) { pthread_join(thread1, NULL); - //assert + // assert ASSERT_FALSE(SingletonTest::exists()); } diff --git a/src/components/utils/test/sqlite_wrapper/sql_database_test.cc b/src/components/utils/test/sqlite_wrapper/sql_database_test.cc index ab72fb0eff..927f9dd88f 100644 --- a/src/components/utils/test/sqlite_wrapper/sql_database_test.cc +++ b/src/components/utils/test/sqlite_wrapper/sql_database_test.cc @@ -50,55 +50,52 @@ namespace dbms { } TEST(SQLDatabaseTest, OpenCloseMemory_OpenAndCloseDB_ActsWithoutError) { - - //arrange + // arrange SQLDatabase db; bool ret = db.Open(); - //assert + // assert EXPECT_FALSE(IsError(db.LastError())); ASSERT_TRUE(ret); - //act + // act db.Close(); - //assert + // assert EXPECT_FALSE(IsError(db.LastError())); } TEST(SQLDatabaseTest, OpenCloseFile_OpenAndCloseSpecifiedDB_ActsWithoutError) { - - //arrange + // arrange SQLDatabase db("test-database"); bool ret = db.Open(); - //assert + // assert EXPECT_FALSE(IsError(db.LastError())); ASSERT_TRUE(ret); - //act + // act db.Close(); - //assert + // assert EXPECT_FALSE(IsError(db.LastError())); remove("test-database.sqlite"); } TEST(SQLDatabaseTest, OpenDBTwice_NoError) { - - //arrange + // arrange SQLDatabase db; bool ret = db.Open(); - //assert + // assert EXPECT_FALSE(IsError(db.LastError())); ASSERT_TRUE(ret); - //act + // act ret = db.Open(); - //assert + // assert EXPECT_FALSE(IsError(db.LastError())); ASSERT_TRUE(ret); @@ -106,44 +103,42 @@ TEST(SQLDatabaseTest, OpenDBTwice_NoError) { } TEST(SQLDatabaseTest, CloseDBTwice_NoError) { - - //arrange + // arrange SQLDatabase db; bool ret = db.Open(); - //assert + // assert EXPECT_FALSE(IsError(db.LastError())); ASSERT_TRUE(ret); - //act + // act db.Close(); - //assert + // assert EXPECT_FALSE(IsError(db.LastError())); - //act + // act db.Close(); - //assert + // assert EXPECT_FALSE(IsError(db.LastError())); } TEST(SQLDatabaseTest, Close_DBWasNotOpened_NoError) { - - //act + // act SQLDatabase db; db.Close(); - //assert + // assert EXPECT_FALSE(IsError(db.LastError())); } -TEST(SQLDatabaseTest, CommitTransaction_StartAndCommitTransaction_ExpectActsWithoutError) { - - //arrange +TEST(SQLDatabaseTest, + CommitTransaction_StartAndCommitTransaction_ExpectActsWithoutError) { + // arrange SQLDatabase db; - //assert + // assert ASSERT_TRUE(db.Open()); EXPECT_TRUE(db.BeginTransaction()); EXPECT_FALSE(IsError(db.LastError())); @@ -153,12 +148,12 @@ TEST(SQLDatabaseTest, CommitTransaction_StartAndCommitTransaction_ExpectActsWith db.Close(); } -TEST(SQLDatabaseTest, RollbackTransaction_StartAndRollbackTransaction_ExpectActsWithoutError) { - - //arrange +TEST(SQLDatabaseTest, + RollbackTransaction_StartAndRollbackTransaction_ExpectActsWithoutError) { + // arrange SQLDatabase db; - //assert + // assert ASSERT_TRUE(db.Open()); EXPECT_TRUE(db.BeginTransaction()); EXPECT_FALSE(IsError(db.LastError())); @@ -168,12 +163,12 @@ TEST(SQLDatabaseTest, RollbackTransaction_StartAndRollbackTransaction_ExpectActs db.Close(); } -TEST(SQLDatabaseTest, FailedCommitTransaction_CommitTransactionWithoutBeginning_ExpectError) { - - //arrange +TEST(SQLDatabaseTest, + FailedCommitTransaction_CommitTransactionWithoutBeginning_ExpectError) { + // arrange SQLDatabase db; - //assert + // assert ASSERT_TRUE(db.Open()); EXPECT_FALSE(db.CommitTransaction()); EXPECT_TRUE(IsError(db.LastError())); @@ -181,12 +176,13 @@ TEST(SQLDatabaseTest, FailedCommitTransaction_CommitTransactionWithoutBeginning_ db.Close(); } -TEST(SQLDatabaseTest, FailedRollbackTransaction_RollbackTransactionWithoutBeginning_ExpectError) { - - //arrange +TEST( + SQLDatabaseTest, + FailedRollbackTransaction_RollbackTransactionWithoutBeginning_ExpectError) { + // arrange SQLDatabase db; - //assert + // assert ASSERT_TRUE(db.Open()); EXPECT_FALSE(db.RollbackTransaction()); EXPECT_TRUE(IsError(db.LastError())); @@ -195,27 +191,25 @@ TEST(SQLDatabaseTest, FailedRollbackTransaction_RollbackTransactionWithoutBeginn } TEST(SQLDatabaseTest, BadTransaction_BeginTransitionWithoutOpenDB_ExpectError) { - - //arrange + // arrange SQLDatabase db; - //assert + // assert EXPECT_FALSE(db.BeginTransaction()); EXPECT_TRUE(IsError(db.LastError())); } TEST(SQLDatabaseTest, IsReadWrite_FirstOpenDBIsRWSecondIsNot) { - - //arrange + // arrange SQLDatabase db("test-database"); - //assert + // assert ASSERT_TRUE(db.Open()); EXPECT_TRUE(db.IsReadWrite()); db.Close(); chmod("test-database.sqlite", S_IRUSR); - //assert + // assert ASSERT_TRUE(db.Open()); EXPECT_FALSE(db.IsReadWrite()); diff --git a/src/components/utils/test/sqlite_wrapper/sql_query_test.cc b/src/components/utils/test/sqlite_wrapper/sql_query_test.cc index 07aff6127e..0cf378bab5 100644 --- a/src/components/utils/test/sqlite_wrapper/sql_query_test.cc +++ b/src/components/utils/test/sqlite_wrapper/sql_query_test.cc @@ -54,9 +54,12 @@ class SQLQueryTest : public ::testing::Test { static void SetUpTestCase() { sqlite3_open((kDatabaseName + ".sqlite").c_str(), &conn); - sqlite3_exec(conn, "CREATE TABLE testTable (integerValue INTEGER," + sqlite3_exec(conn, + "CREATE TABLE testTable (integerValue INTEGER," " doubleValue REAL, stringValue TEXT)", - NULL, NULL, NULL); + NULL, + NULL, + NULL); } static void TearDownTestCase() { @@ -97,131 +100,132 @@ sqlite3* SQLQueryTest::conn = 0; const std::string SQLQueryTest::kDatabaseName = "test-query"; TEST_F(SQLQueryTest, Query_CreateQuery_QueryInDBEqualCreated) { - - //arrange + // arrange const std::string kSelect("SELECT * FROM testTable WHERE integerValue = ?"); SQLDatabase db(kDatabaseName); - //assert + // assert ASSERT_TRUE(db.Open()); - //act + // act SQLQuery query(&db); query.Prepare(kSelect); - //assert + // assert EXPECT_STREQ(kSelect.c_str(), query.query().c_str()); } TEST_F(SQLQueryTest, ExecString_ExecuteQuery_ActWithoutError) { - - //arrange - const std::string kInsert("INSERT INTO testTable" - " (integerValue, doubleValue, stringValue)" - " VALUES(2, 3.4, 'five-пять')"); + // arrange + const std::string kInsert( + "INSERT INTO testTable" + " (integerValue, doubleValue, stringValue)" + " VALUES(2, 3.4, 'five-пять')"); SQLDatabase db(kDatabaseName); - //assert + // assert ASSERT_TRUE(db.Open()); - //act + // act SQLQuery query(&db); - //assert + // assert EXPECT_TRUE(query.Exec(kInsert)); EXPECT_FALSE(IsError(query.LastError())); } -TEST_F(SQLQueryTest, Bind_BindSeveralQueries_ExpectExecutedQueriesWithoutErrors) { - - //arrange +TEST_F(SQLQueryTest, + Bind_BindSeveralQueries_ExpectExecutedQueriesWithoutErrors) { + // arrange const std::string kInsert1("INSERT INTO testTable (integerValue) VALUES (?)"); const std::string kInsert2("INSERT INTO testTable (doubleValue) VALUES (?)"); const std::string kInsert3("INSERT INTO testTable (stringValue) VALUES (?)"); - const std::string kInsert4("INSERT INTO testTable (integerValue, doubleValue," - " stringValue) VALUES (?, ?, ?)"); + const std::string kInsert4( + "INSERT INTO testTable (integerValue, doubleValue," + " stringValue) VALUES (?, ?, ?)"); const int kIntegerValue = 1; const double kDoubleValue = 2.3; const std::string kStringValue = "four"; SQLDatabase db(kDatabaseName); - //assert + // assert ASSERT_TRUE(db.Open()); - //act + // act SQLQuery query1(&db); - //assert + // assert EXPECT_TRUE(query1.Prepare(kInsert1)); EXPECT_FALSE(IsError(query1.LastError())); query1.Bind(0, kIntegerValue); - //assert + // assert EXPECT_FALSE(IsError(query1.LastError())); EXPECT_TRUE(query1.Exec()); EXPECT_TRUE(IsDone(query1.LastError())); - //act + // act SQLQuery query2(&db); - //assert + // assert EXPECT_TRUE(query2.Prepare(kInsert2)); EXPECT_FALSE(IsError(query2.LastError())); query2.Bind(0, kDoubleValue); - //assert + // assert EXPECT_FALSE(IsError(query2.LastError())); EXPECT_TRUE(query2.Exec()); EXPECT_TRUE(IsDone(query2.LastError())); - //act + // act SQLQuery query3(&db); EXPECT_TRUE(query3.Prepare(kInsert3)); EXPECT_FALSE(IsError(query3.LastError())); query3.Bind(0, kStringValue); - //assert + // assert EXPECT_FALSE(IsError(query3.LastError())); EXPECT_TRUE(query3.Exec()); EXPECT_TRUE(IsDone(query3.LastError())); - //act + // act SQLQuery query4(&db); - //assert + // assert EXPECT_TRUE(query4.Prepare(kInsert4)); EXPECT_FALSE(IsError(query4.LastError())); query4.Bind(0, kIntegerValue); query4.Bind(1, kDoubleValue); query4.Bind(2, kStringValue); - //assert + // assert EXPECT_FALSE(IsError(query4.LastError())); EXPECT_TRUE(query4.Exec()); EXPECT_TRUE(IsDone(query4.LastError())); } TEST_F(SQLQueryTest, SetValue_InsertValues_ExpectDBHasInsertedValues) { - - //arrange - const char* insert = "INSERT INTO testTable " + // arrange + const char* insert = + "INSERT INTO testTable " "(integerValue, doubleValue, stringValue) " "VALUES (1, 2.3, 'four');"; - //assert + // assert ASSERT_EQ(SQLITE_OK, sqlite3_exec(conn, insert, NULL, NULL, NULL)); - //act - const std::string kSelect("SELECT integerValue, doubleValue, stringValue" - " FROM testTable"); + // act + const std::string kSelect( + "SELECT integerValue, doubleValue, stringValue" + " FROM testTable"); const int kIntegerValue = 1; const double kDoubleValue = 2.3; const std::string kStringValue = "four"; SQLDatabase db(kDatabaseName); - //assert + // assert ASSERT_TRUE(db.Open()); - //act + // act SQLQuery query(&db); - //assert + // assert EXPECT_TRUE(query.Prepare(kSelect)); EXPECT_FALSE(IsError(query.LastError())); EXPECT_TRUE(query.Exec()); @@ -234,39 +238,42 @@ TEST_F(SQLQueryTest, SetValue_InsertValues_ExpectDBHasInsertedValues) { } TEST_F(SQLQueryTest, EmptySelect_SelectValuesEqual0_ExecWithoutErrors) { - - //arrange - const std::string kSelect("SELECT integerValue, doubleValue, stringValue" - " FROM testTable WHERE 0"); + // arrange + const std::string kSelect( + "SELECT integerValue, doubleValue, stringValue" + " FROM testTable WHERE 0"); SQLDatabase db(kDatabaseName); - //assert + // assert ASSERT_TRUE(db.Open()); - //act + // act SQLQuery query(&db); - //assert + // assert EXPECT_TRUE(query.Prepare(kSelect)); EXPECT_FALSE(IsError(query.LastError())); EXPECT_TRUE(query.Exec()); EXPECT_TRUE(IsDone(query.LastError())); } -TEST_F(SQLQueryTest, NextAndBind_InsertValuesAndBindQuery_ExecWithoutErrorsAndBindingQueryIsLast) { - - //arrange - const char* insert = "INSERT INTO testTable " +TEST_F( + SQLQueryTest, + NextAndBind_InsertValuesAndBindQuery_ExecWithoutErrorsAndBindingQueryIsLast) { + // arrange + const char* insert = + "INSERT INTO testTable " "(integerValue, doubleValue, stringValue) " "VALUES (1, 2.3, 'four');"; - //assert + // assert ASSERT_EQ(SQLITE_OK, sqlite3_exec(conn, insert, NULL, NULL, NULL)); - const std::string kSelect("SELECT integerValue, doubleValue, stringValue" - " FROM testTable WHERE stringValue = ?"); + const std::string kSelect( + "SELECT integerValue, doubleValue, stringValue" + " FROM testTable WHERE stringValue = ?"); - //act + // act const int kIntegerValue = 1; const double kDoubleValue = 2.3; const std::string kStringValue = "four"; @@ -276,12 +283,12 @@ TEST_F(SQLQueryTest, NextAndBind_InsertValuesAndBindQuery_ExecWithoutErrorsAndBi SQLQuery query(&db); - //assert + // assert ASSERT_TRUE(query.Prepare(kSelect)); EXPECT_FALSE(IsError(query.LastError())); - //act + // act query.Bind(0, kStringValue); - //assert + // assert EXPECT_FALSE(IsError(query.LastError())); EXPECT_TRUE(query.Exec()); ASSERT_TRUE(IsRow(query.LastError())); @@ -293,36 +300,35 @@ TEST_F(SQLQueryTest, NextAndBind_InsertValuesAndBindQuery_ExecWithoutErrorsAndBi } TEST_F(SQLQueryTest, LastInsertId_InsertValuesAndBindQuery_GetExpectedId) { - - //arrange - const char* create = "CREATE TABLE idTable ( " + // arrange + const char* create = + "CREATE TABLE idTable ( " "id INTEGER PRIMARY KEY AUTOINCREMENT," "value TEXT)"; - //assert + // assert ASSERT_EQ(SQLITE_OK, sqlite3_exec(conn, create, NULL, NULL, NULL)); - const int64_t kExpectId = 1; const std::string kValue("Test last id of insert row"); const std::string kInsert("INSERT INTO idTable (value) VALUES(?)"); - //act + // act SQLDatabase db(kDatabaseName); - //assert + // assert ASSERT_TRUE(db.Open()); - //act + // act SQLQuery query(&db); - //assert + // assert ASSERT_TRUE(query.Prepare(kInsert)); EXPECT_FALSE(IsError(query.LastError())); - //act + // act query.Bind(0, kValue); - //assert + // assert EXPECT_FALSE(IsError(query.LastError())); EXPECT_TRUE(query.Exec()); ASSERT_TRUE(IsDone(query.LastError())); @@ -333,36 +339,35 @@ TEST_F(SQLQueryTest, LastInsertId_InsertValuesAndBindQuery_GetExpectedId) { } TEST_F(SQLQueryTest, BindNull_BindWithoutValue_ActWithoutErrors) { - - //arrange - const std::string kInsert("INSERT INTO testTable (`integerValue`)" - " VALUES (?)"); + // arrange + const std::string kInsert( + "INSERT INTO testTable (`integerValue`)" + " VALUES (?)"); SQLDatabase db(kDatabaseName); - //assert + // assert ASSERT_TRUE(db.Open()); - //act + // act SQLQuery query(&db); - //assert + // assert ASSERT_TRUE(query.Prepare(kInsert)); EXPECT_FALSE(IsError(query.LastError())); query.Bind(0); - //assert + // assert EXPECT_FALSE(IsError(query.LastError())); EXPECT_TRUE(query.Exec()); ASSERT_TRUE(IsDone(query.LastError())); } TEST_F(SQLQueryTest, DoublePrepare_TwicePrepareQuery_ActWithoutErrors) { - - //arrange + // arrange SQLDatabase db(kDatabaseName); - //assert + // assert ASSERT_TRUE(db.Open()); - //act + // act SQLQuery query(&db); - //assert + // assert EXPECT_TRUE(query.Prepare("SELECT * FROM testTable")); EXPECT_FALSE(IsError(query.LastError())); EXPECT_TRUE(query.Prepare("SELECT * FROM testTable")); diff --git a/src/components/utils/test/stl_utils_test.cc b/src/components/utils/test/stl_utils_test.cc index dfc00de982..1fbde052f1 100644 --- a/src/components/utils/test/stl_utils_test.cc +++ b/src/components/utils/test/stl_utils_test.cc @@ -44,8 +44,7 @@ using ::utils::StlMapDeleter; class TestObject { public: - ~TestObject() { - } + ~TestObject() {} }; typedef std::map<int, TestObject*> TestMap; @@ -56,9 +55,7 @@ TEST(StlDeleter, DestructMapWithOneElement) { test_map[1] = new TestObject(); EXPECT_EQ(1u, test_map.size()); - { - StlMapDeleter<TestMap> test_list_deleter_(&test_map); - } + { StlMapDeleter<TestMap> test_list_deleter_(&test_map); } EXPECT_EQ(1u, test_map.size()); EXPECT_EQ(NULL, test_map[1]); } @@ -69,9 +66,7 @@ TEST(StlDeleter, DestructMapWithSeveralElements) { test_map[2] = new TestObject(); EXPECT_EQ(2u, test_map.size()); - { - StlMapDeleter<TestMap> test_list_deleter_(&test_map); - } + { StlMapDeleter<TestMap> test_list_deleter_(&test_map); } EXPECT_EQ(2u, test_map.size()); EXPECT_EQ(NULL, test_map[1]); EXPECT_EQ(NULL, test_map[2]); @@ -82,9 +77,7 @@ TEST(StlDeleter, DestructVectorWithOneElement) { test_vector.push_back(new TestObject()); EXPECT_EQ(1u, test_vector.size()); - { - StlCollectionDeleter<TestVector> test_list_deleter_(&test_vector); - } + { StlCollectionDeleter<TestVector> test_list_deleter_(&test_vector); } EXPECT_EQ(1u, test_vector.size()); EXPECT_EQ(NULL, test_vector[0]); } @@ -95,9 +88,7 @@ TEST(StlDeleter, DestructVectorWithSeveralElements) { test_vector.push_back(new TestObject()); EXPECT_EQ(2u, test_vector.size()); - { - StlCollectionDeleter<TestVector> test_list_deleter_(&test_vector); - } + { StlCollectionDeleter<TestVector> test_list_deleter_(&test_vector); } EXPECT_EQ(2u, test_vector.size()); EXPECT_EQ(NULL, test_vector[0]); EXPECT_EQ(NULL, test_vector[1]); diff --git a/src/components/utils/test/system_test.cc b/src/components/utils/test/system_test.cc index 42307998b4..aced77f849 100644 --- a/src/components/utils/test/system_test.cc +++ b/src/components/utils/test/system_test.cc @@ -62,7 +62,6 @@ TEST(SystemTest, Constructor_WithFileNameCommandName_ExpectArgsStored) { // Check if actual number of arguments arec correct int vec_size = object.argv().size(); ASSERT_EQ(vec_size, 1); // Correct number of arguments is 1 - } TEST(SystemTest, AddTwoArgsToCommand_ExpectTwoArgsAdded) { @@ -93,33 +92,39 @@ TEST(SystemTest, AddTwoArgsToCommand_CheckOrder_ExpectOrderCorrect) { EXPECT_STREQ(object.argv()[2].c_str(), args[1]); } - - TEST(SystemTest, SynchronousInvokeWithExistingCommand_ExpectSuccessfull) { const std::string test_command("./testscript.sh"); System object(test_command); - // Check if Execute() method is working properly with synchronous command invoke + // Check if Execute() method is working properly with synchronous command + // invoke ASSERT_TRUE(object.Execute(true)); } -TEST(SystemTest, SynchronousInvokeWithEmptyCommand_IncorrectCommand_ExpectFailed) { +TEST(SystemTest, + SynchronousInvokeWithEmptyCommand_IncorrectCommand_ExpectFailed) { const std::string test_command(""); // any incorrect command System object(test_command); - // Check if Execute() method will fail with not correct command (synchronous command invoke) + // Check if Execute() method will fail with not correct command (synchronous + // command invoke) ASSERT_FALSE(object.Execute(true)); } TEST(SystemTest, ASynchronousInvokeEmptyCommand_InvokeSuccessfull) { - const std::string test_command(""); // Possible to put here any command (existing or incorrect) - const std::string test_list_args("anything"); // as command will never be executed from child process - System object(test_command, test_list_args); // as parrent process does not wait for child process to be finished - - // Check if Execute() method is working properly with asynchronous command invoke + const std::string test_command( + ""); // Possible to put here any command (existing or incorrect) + const std::string test_list_args( + "anything"); // as command will never be executed from child process + System object(test_command, test_list_args); // as parrent process does not + // wait for child process to be + // finished + + // Check if Execute() method is working properly with asynchronous command + // invoke ASSERT_TRUE(object.Execute()); } -} // namespace utils -} // namespace components -} // namespace test +} // namespace utils +} // namespace components +} // namespace test diff --git a/src/components/utils/test/thread_validator_test.cc b/src/components/utils/test/thread_validator_test.cc index 16d9d12874..b6e21d7157 100644 --- a/src/components/utils/test/thread_validator_test.cc +++ b/src/components/utils/test/thread_validator_test.cc @@ -45,9 +45,8 @@ using namespace ::threads; TEST(ThreadValidatorTest, CompareID_CurrentThreadAndPthread_AreEqual) { SingleThreadSimpleValidator object; ASSERT_EQ(object.creation_thread_id(), pthread_self()); - } -} // namespace utils -} // namespace components -} // namespace test +} // namespace utils +} // namespace components +} // namespace test |