diff --git a/core/include/Common/spimpl.h b/core/include/Common/spimpl.h
index b4d5e04..7f6e8be 100644
--- a/core/include/Common/spimpl.h
+++ b/core/include/Common/spimpl.h
@@ -89,8 +89,9 @@ using default_copier_t = typename default_copier<T>::type;
 
 template <class T, class D, class C>
 struct is_default_manageable
-    : public std::integral_constant<bool, std::is_same<D, default_deleter_t<T> >::value
-                                              && std::is_same<C, default_copier_t<T> >::value> {
+    : public std::integral_constant<bool,
+                                    std::is_same<D, default_deleter_t<T> >::value
+                                        && std::is_same<C, default_copier_t<T> >::value> {
 };
 }
 
@@ -131,10 +132,11 @@ public:
     }
 
     template <class U>
-    impl_ptr(U *u, typename std::enable_if<std::is_convertible<U *, pointer>::value
-                                               && is_default_manageable::value,
-                                           dummy_t_>::type
-                   = dummy_t_()) SPIMPL_NOEXCEPT
+    impl_ptr(U *u,
+             typename std::enable_if<std::is_convertible<U *, pointer>::value
+                                         && is_default_manageable::value,
+                                     dummy_t_>::type
+             = dummy_t_()) SPIMPL_NOEXCEPT
         : impl_ptr(u, &details::default_delete<T>, &details::default_copy<T>)
     {
     }
@@ -151,12 +153,12 @@ public:
 
 #ifdef SPIMPL_HAS_AUTO_PTR
     template <class U>
-    impl_ptr(std::auto_ptr<U> &&u, typename std::enable_if<std::is_convertible<U *, pointer>::value
-                                                               && is_default_manageable::value,
-                                                           dummy_t_>::type
-                                   = dummy_t_()) SPIMPL_NOEXCEPT
-        : ptr_(u.release(), &details::default_delete<T>),
-          copier_(&details::default_copy<T>)
+    impl_ptr(std::auto_ptr<U> &&u,
+             typename std::enable_if<std::is_convertible<U *, pointer>::value
+                                         && is_default_manageable::value,
+                                     dummy_t_>::type
+             = dummy_t_()) SPIMPL_NOEXCEPT : ptr_(u.release(), &details::default_delete<T>),
+                                             copier_(&details::default_copy<T>)
     {
     }
 #endif
diff --git a/core/src/DataSource/DataSourceController.cpp b/core/src/DataSource/DataSourceController.cpp
index 220945e..22441fe 100644
--- a/core/src/DataSource/DataSourceController.cpp
+++ b/core/src/DataSource/DataSourceController.cpp
@@ -49,14 +49,14 @@ public:
 DataSourceController::DataSourceController(QObject *parent)
         : impl{spimpl::make_unique_impl<DataSourceControllerPrivate>()}
 {
-    qCDebug(LOG_DataSourceController()) << tr("DataSourceController construction")
-                                        << QThread::currentThread();
+    qCDebug(LOG_DataSourceController())
+        << tr("DataSourceController construction") << QThread::currentThread();
 }
 
 DataSourceController::~DataSourceController()
 {
-    qCDebug(LOG_DataSourceController()) << tr("DataSourceController destruction")
-                                        << QThread::currentThread();
+    qCDebug(LOG_DataSourceController())
+        << tr("DataSourceController destruction") << QThread::currentThread();
     this->waitForFinish();
 }
 
@@ -126,8 +126,8 @@ void DataSourceController::loadProductItem(const QUuid &dataSourceUid,
 
 void DataSourceController::initialize()
 {
-    qCDebug(LOG_DataSourceController()) << tr("DataSourceController init")
-                                        << QThread::currentThread();
+    qCDebug(LOG_DataSourceController())
+        << tr("DataSourceController init") << QThread::currentThread();
     impl->m_WorkingMutex.lock();
     qCDebug(LOG_DataSourceController()) << tr("DataSourceController init END");
 }
diff --git a/core/src/Network/NetworkController.cpp b/core/src/Network/NetworkController.cpp
index dcaacc6..002a47a 100644
--- a/core/src/Network/NetworkController.cpp
+++ b/core/src/Network/NetworkController.cpp
@@ -64,8 +64,8 @@ void NetworkController::onProcessRequested(std::shared_ptr<QNetworkRequest> requ
             impl->unlock();
         }
 
-        qCDebug(LOG_NetworkController()) << tr("NetworkController onReplyFinished END")
-                                         << QThread::currentThread() << reply;
+        qCDebug(LOG_NetworkController())
+            << tr("NetworkController onReplyFinished END") << QThread::currentThread() << reply;
     };
 
     auto onReplyProgress = [reply, request, this](qint64 bytesRead, qint64 totalBytes) {
@@ -73,9 +73,9 @@ void NetworkController::onProcessRequested(std::shared_ptr<QNetworkRequest> requ
         // NOTE: a totalbytes of 0 can happened when a request has been aborted
         if (totalBytes > 0) {
             double progress = (bytesRead * 100.0) / totalBytes;
-            qCDebug(LOG_NetworkController()) << tr("NetworkController onReplyProgress") << progress
-                                             << QThread::currentThread() << request.get() << reply
-                                             << bytesRead << totalBytes;
+            qCDebug(LOG_NetworkController())
+                << tr("NetworkController onReplyProgress") << progress << QThread::currentThread()
+                << request.get() << reply << bytesRead << totalBytes;
             impl->lockRead();
             auto it = impl->m_NetworkReplyToId.find(reply);
             if (it != impl->m_NetworkReplyToId.cend()) {
@@ -87,8 +87,8 @@ void NetworkController::onProcessRequested(std::shared_ptr<QNetworkRequest> requ
                 impl->unlock();
             }
 
-            qCDebug(LOG_NetworkController()) << tr("NetworkController onReplyProgress END")
-                                             << QThread::currentThread() << reply;
+            qCDebug(LOG_NetworkController())
+                << tr("NetworkController onReplyProgress END") << QThread::currentThread() << reply;
         }
     };
 
@@ -125,8 +125,8 @@ void NetworkController::finalize()
 void NetworkController::onReplyCanceled(QUuid identifier)
 {
     auto findReply = [identifier](const auto &entry) { return identifier == entry.second; };
-    qCDebug(LOG_NetworkController()) << tr("NetworkController onReplyCanceled")
-                                     << QThread::currentThread() << identifier;
+    qCDebug(LOG_NetworkController())
+        << tr("NetworkController onReplyCanceled") << QThread::currentThread() << identifier;
 
 
     impl->lockRead();
@@ -138,8 +138,8 @@ void NetworkController::onReplyCanceled(QUuid identifier)
                                          << QThread::currentThread() << identifier;
         it->first->abort();
     }
-    qCDebug(LOG_NetworkController()) << tr("NetworkController onReplyCanceled END")
-                                     << QThread::currentThread();
+    qCDebug(LOG_NetworkController())
+        << tr("NetworkController onReplyCanceled END") << QThread::currentThread();
 }
 
 void NetworkController::waitForFinish()
diff --git a/core/src/Variable/Variable.cpp b/core/src/Variable/Variable.cpp
index 988f06a..5e56d4b 100644
--- a/core/src/Variable/Variable.cpp
+++ b/core/src/Variable/Variable.cpp
@@ -265,8 +265,8 @@ QVector<SqpRange> Variable::provideNotInCacheRangeList(const SqpRange &range) co
                 notInCache << SqpRange{impl->m_CacheRange.m_TEnd, range.m_TEnd};
             }
             else {
-                qCCritical(LOG_Variable()) << tr("Detection of unknown case.")
-                                           << QThread::currentThread();
+                qCCritical(LOG_Variable())
+                    << tr("Detection of unknown case.") << QThread::currentThread();
             }
         }
     }
@@ -305,8 +305,8 @@ QVector<SqpRange> Variable::provideInCacheRangeList(const SqpRange &range) const
                 inCache << impl->m_CacheRange;
             }
             else {
-                qCCritical(LOG_Variable()) << tr("Detection of unknown case.")
-                                           << QThread::currentThread();
+                qCCritical(LOG_Variable())
+                    << tr("Detection of unknown case.") << QThread::currentThread();
             }
         }
     }
diff --git a/core/src/Variable/VariableAcquisitionWorker.cpp b/core/src/Variable/VariableAcquisitionWorker.cpp
index 5eac38c..b8cfca1 100644
--- a/core/src/Variable/VariableAcquisitionWorker.cpp
+++ b/core/src/Variable/VariableAcquisitionWorker.cpp
@@ -49,8 +49,8 @@ VariableAcquisitionWorker::VariableAcquisitionWorker(QObject *parent)
 
 VariableAcquisitionWorker::~VariableAcquisitionWorker()
 {
-    qCInfo(LOG_VariableAcquisitionWorker()) << tr("VariableAcquisitionWorker destruction")
-                                            << QThread::currentThread();
+    qCInfo(LOG_VariableAcquisitionWorker())
+        << tr("VariableAcquisitionWorker destruction") << QThread::currentThread();
     this->waitForFinish();
 }
 
@@ -144,8 +144,8 @@ void VariableAcquisitionWorker::abortProgressRequested(QUuid vIdentifier)
 void VariableAcquisitionWorker::onVariableRetrieveDataInProgress(QUuid acqIdentifier,
                                                                  double progress)
 {
-    qCDebug(LOG_VariableAcquisitionWorker()) << tr("TORM: onVariableRetrieveDataInProgress ")
-                                             << acqIdentifier << progress;
+    qCDebug(LOG_VariableAcquisitionWorker())
+        << tr("TORM: onVariableRetrieveDataInProgress ") << acqIdentifier << progress;
     impl->lockRead();
     auto aIdToARit = impl->m_AcqIdentifierToAcqRequestMap.find(acqIdentifier);
     if (aIdToARit != impl->m_AcqIdentifierToAcqRequestMap.cend()) {
@@ -170,16 +170,16 @@ void VariableAcquisitionWorker::onVariableRetrieveDataInProgress(QUuid acqIdenti
 
 void VariableAcquisitionWorker::onVariableAcquisitionFailed(QUuid acqIdentifier)
 {
-    qCDebug(LOG_VariableAcquisitionWorker()) << tr("onVariableAcquisitionFailed")
-                                             << QThread::currentThread();
+    qCDebug(LOG_VariableAcquisitionWorker())
+        << tr("onVariableAcquisitionFailed") << QThread::currentThread();
     impl->lockRead();
     auto it = impl->m_AcqIdentifierToAcqRequestMap.find(acqIdentifier);
     if (it != impl->m_AcqIdentifierToAcqRequestMap.cend()) {
         auto request = it->second;
         impl->unlock();
-        qCInfo(LOG_VariableAcquisitionWorker()) << tr("onVariableAcquisitionFailed")
-                                                << acqIdentifier << request.m_vIdentifier
-                                                << QThread::currentThread();
+        qCInfo(LOG_VariableAcquisitionWorker())
+            << tr("onVariableAcquisitionFailed") << acqIdentifier << request.m_vIdentifier
+            << QThread::currentThread();
         emit variableCanceledRequested(request.m_vIdentifier);
     }
     else {
@@ -192,8 +192,8 @@ void VariableAcquisitionWorker::onVariableDataAcquired(QUuid acqIdentifier,
                                                        std::shared_ptr<IDataSeries> dataSeries,
                                                        SqpRange dataRangeAcquired)
 {
-    qCDebug(LOG_VariableAcquisitionWorker()) << tr("TORM: onVariableDataAcquired on range ")
-                                             << acqIdentifier << dataRangeAcquired;
+    qCDebug(LOG_VariableAcquisitionWorker())
+        << tr("TORM: onVariableDataAcquired on range ") << acqIdentifier << dataRangeAcquired;
     impl->lockWrite();
     auto aIdToARit = impl->m_AcqIdentifierToAcqRequestMap.find(acqIdentifier);
     if (aIdToARit != impl->m_AcqIdentifierToAcqRequestMap.cend()) {
@@ -258,8 +258,8 @@ void VariableAcquisitionWorker::onExecuteRequest(QUuid acqIdentifier)
 
 void VariableAcquisitionWorker::initialize()
 {
-    qCDebug(LOG_VariableAcquisitionWorker()) << tr("VariableAcquisitionWorker init")
-                                             << QThread::currentThread();
+    qCDebug(LOG_VariableAcquisitionWorker())
+        << tr("VariableAcquisitionWorker init") << QThread::currentThread();
     impl->m_WorkingMutex.lock();
     qCDebug(LOG_VariableAcquisitionWorker()) << tr("VariableAcquisitionWorker init END");
 }
diff --git a/core/src/Variable/VariableCacheController.cpp b/core/src/Variable/VariableCacheController.cpp
index fd1e836..9edc77c 100644
--- a/core/src/Variable/VariableCacheController.cpp
+++ b/core/src/Variable/VariableCacheController.cpp
@@ -30,8 +30,8 @@ VariableCacheController::VariableCacheController(QObject *parent)
 void VariableCacheController::addDateTime(std::shared_ptr<Variable> variable,
                                           const SqpRange &dateTime)
 {
-    qCDebug(LOG_VariableCacheController()) << "VariableCacheController::addDateTime"
-                                           << QThread::currentThread()->objectName();
+    qCDebug(LOG_VariableCacheController())
+        << "VariableCacheController::addDateTime" << QThread::currentThread()->objectName();
     if (variable) {
         auto findVariableIte = impl->m_VariableToSqpRangeListMap.find(variable);
         if (findVariableIte == impl->m_VariableToSqpRangeListMap.end()) {
@@ -104,8 +104,8 @@ VariableCacheController::provideNotInCacheDateTimeList(std::shared_ptr<Variable>
 QVector<SqpRange>
 VariableCacheController::dateCacheList(std::shared_ptr<Variable> variable) const noexcept
 {
-    qCDebug(LOG_VariableCacheController()) << "VariableCacheController::dateCacheList"
-                                           << QThread::currentThread()->objectName();
+    qCDebug(LOG_VariableCacheController())
+        << "VariableCacheController::dateCacheList" << QThread::currentThread()->objectName();
     try {
         return impl->m_VariableToSqpRangeListMap.at(variable);
     }
@@ -215,8 +215,8 @@ void VariableCacheController::displayCache(std::shared_ptr<Variable> variable) c
 {
     auto variableDateTimeList = impl->m_VariableToSqpRangeListMap.find(variable);
     if (variableDateTimeList != impl->m_VariableToSqpRangeListMap.end()) {
-        qCInfo(LOG_VariableCacheController()) << tr("VariableCacheController::displayCache")
-                                              << variableDateTimeList->second;
+        qCInfo(LOG_VariableCacheController())
+            << tr("VariableCacheController::displayCache") << variableDateTimeList->second;
     }
     else {
         qCWarning(LOG_VariableCacheController())
diff --git a/core/src/Variable/VariableController.cpp b/core/src/Variable/VariableController.cpp
index 7b231da..21332a7 100644
--- a/core/src/Variable/VariableController.cpp
+++ b/core/src/Variable/VariableController.cpp
@@ -148,8 +148,8 @@ struct VariableController::VariableControllerPrivate {
 VariableController::VariableController(QObject *parent)
         : QObject{parent}, impl{spimpl::make_unique_impl<VariableControllerPrivate>(this)}
 {
-    qCDebug(LOG_VariableController()) << tr("VariableController construction")
-                                      << QThread::currentThread();
+    qCDebug(LOG_VariableController())
+        << tr("VariableController construction") << QThread::currentThread();
 
     connect(impl->m_VariableModel, &VariableModel::abortProgessRequested, this,
             &VariableController::onAbortProgressRequested);
@@ -176,8 +176,8 @@ VariableController::VariableController(QObject *parent)
 
 VariableController::~VariableController()
 {
-    qCDebug(LOG_VariableController()) << tr("VariableController destruction")
-                                      << QThread::currentThread();
+    qCDebug(LOG_VariableController())
+        << tr("VariableController destruction") << QThread::currentThread();
     this->waitForFinish();
 }
 
@@ -296,8 +296,8 @@ VariableController::createVariable(const QString &name, const QVariantHash &meta
 void VariableController::onDateTimeOnSelection(const SqpRange &dateTime)
 {
     // TODO check synchronisation and Rescale
-    qCDebug(LOG_VariableController()) << "VariableController::onDateTimeOnSelection"
-                                      << QThread::currentThread()->objectName();
+    qCDebug(LOG_VariableController())
+        << "VariableController::onDateTimeOnSelection" << QThread::currentThread()->objectName();
     auto selectedRows = impl->m_VariableSelectionModel->selectedRows();
     auto varRequestId = QUuid::createUuid();
 
@@ -383,9 +383,9 @@ void VariableController::onAbortAcquisitionRequested(QUuid vIdentifier)
 
 void VariableController::onAddSynchronizationGroupId(QUuid synchronizationGroupId)
 {
-    qCDebug(LOG_VariableController()) << "TORM: VariableController::onAddSynchronizationGroupId"
-                                      << QThread::currentThread()->objectName()
-                                      << synchronizationGroupId;
+    qCDebug(LOG_VariableController())
+        << "TORM: VariableController::onAddSynchronizationGroupId"
+        << QThread::currentThread()->objectName() << synchronizationGroupId;
     auto vSynchroGroup = std::make_shared<VariableSynchronizationGroup>();
     impl->m_GroupIdToVariableSynchronizationGroupMap.insert(
         std::make_pair(synchronizationGroupId, vSynchroGroup));
@@ -400,8 +400,8 @@ void VariableController::onAddSynchronized(std::shared_ptr<Variable> variable,
                                            QUuid synchronizationGroupId)
 
 {
-    qCDebug(LOG_VariableController()) << "TORM: VariableController::onAddSynchronized"
-                                      << synchronizationGroupId;
+    qCDebug(LOG_VariableController())
+        << "TORM: VariableController::onAddSynchronized" << synchronizationGroupId;
     auto varToVarIdIt = impl->m_VariableToIdentifierMap.find(variable);
     if (varToVarIdIt != impl->m_VariableToIdentifierMap.cend()) {
         auto groupIdToVSGIt
@@ -506,8 +506,8 @@ void VariableController::onRequestDataLoading(QVector<std::shared_ptr<Variable> 
                 // Don't process already processed var
                 if (!variables.contains(var)) {
                     if (var != nullptr) {
-                        qCDebug(LOG_VariableController()) << "processRequest synchro for"
-                                                          << var->name();
+                        qCDebug(LOG_VariableController())
+                            << "processRequest synchro for" << var->name();
                         auto vSyncRangeRequested = computeSynchroRangeRequested(
                             var->range(), range, groupIdToOldRangeMap.at(gId));
                         qCDebug(LOG_VariableController()) << "synchro RR" << vSyncRangeRequested;
@@ -601,8 +601,8 @@ void VariableController::VariableControllerPrivate::processRequest(std::shared_p
                 varProvider);
 
             if (!varRequestIdCanceled.isNull()) {
-                qCDebug(LOG_VariableAcquisitionWorker()) << tr("vsarRequestIdCanceled: ")
-                                                         << varRequestIdCanceled;
+                qCDebug(LOG_VariableAcquisitionWorker())
+                    << tr("vsarRequestIdCanceled: ") << varRequestIdCanceled;
                 cancelVariableRequest(varRequestIdCanceled);
             }
         }
@@ -647,8 +647,8 @@ VariableController::VariableControllerPrivate::findVariable(QUuid vIdentifier)
 std::shared_ptr<IDataSeries> VariableController::VariableControllerPrivate::retrieveDataSeries(
     const QVector<AcquisitionDataPacket> acqDataPacketVector)
 {
-    qCDebug(LOG_VariableController()) << tr("TORM: retrieveDataSeries acqDataPacketVector size")
-                                      << acqDataPacketVector.size();
+    qCDebug(LOG_VariableController())
+        << tr("TORM: retrieveDataSeries acqDataPacketVector size") << acqDataPacketVector.size();
     std::shared_ptr<IDataSeries> dataSeries;
     if (!acqDataPacketVector.isEmpty()) {
         dataSeries = acqDataPacketVector[0].m_DateSeries;
@@ -665,8 +665,8 @@ void VariableController::VariableControllerPrivate::registerProvider(
     std::shared_ptr<IDataProvider> provider)
 {
     if (m_ProviderSet.find(provider) == m_ProviderSet.end()) {
-        qCDebug(LOG_VariableController()) << tr("Registering of a new provider")
-                                          << provider->objectName();
+        qCDebug(LOG_VariableController())
+            << tr("Registering of a new provider") << provider->objectName();
         m_ProviderSet.insert(provider);
         connect(provider.get(), &IDataProvider::dataProvided, m_VariableAcquisitionWorker.get(),
                 &VariableAcquisitionWorker::onVariableDataAcquired);
@@ -772,8 +772,8 @@ void VariableController::VariableControllerPrivate::updateVariableRequest(QUuid 
              (varIdToVarRequestMapIt != varIdToVarRequestMap.cend()) && processVariableUpdate;
              ++varIdToVarRequestMapIt) {
             processVariableUpdate &= varIdToVarRequestMapIt->second.m_CanUpdate;
-            qCDebug(LOG_VariableController()) << tr("updateVariableRequest")
-                                              << processVariableUpdate;
+            qCDebug(LOG_VariableController())
+                << tr("updateVariableRequest") << processVariableUpdate;
         }
 
         if (processVariableUpdate) {
@@ -783,10 +783,10 @@ void VariableController::VariableControllerPrivate::updateVariableRequest(QUuid 
                     auto &varRequest = varIdToVarRequestMapIt->second;
                     var->setRange(varRequest.m_RangeRequested);
                     var->setCacheRange(varRequest.m_CacheRangeRequested);
-                    qCDebug(LOG_VariableController()) << tr("1: onDataProvided")
-                                                      << varRequest.m_RangeRequested;
-                    qCDebug(LOG_VariableController()) << tr("2: onDataProvided")
-                                                      << varRequest.m_CacheRangeRequested;
+                    qCDebug(LOG_VariableController())
+                        << tr("1: onDataProvided") << varRequest.m_RangeRequested;
+                    qCDebug(LOG_VariableController())
+                        << tr("2: onDataProvided") << varRequest.m_CacheRangeRequested;
                     var->mergeDataSeries(varRequest.m_DataSeries);
                     qCDebug(LOG_VariableController()) << tr("3: onDataProvided");
 
@@ -805,11 +805,11 @@ void VariableController::VariableControllerPrivate::updateVariableRequest(QUuid 
             }
 
             // cleaning varRequestId
-            qCDebug(LOG_VariableController()) << tr("0: erase REQUEST in  MAP ?")
-                                              << m_VarRequestIdToVarIdVarRequestMap.size();
+            qCDebug(LOG_VariableController())
+                << tr("0: erase REQUEST in  MAP ?") << m_VarRequestIdToVarIdVarRequestMap.size();
             m_VarRequestIdToVarIdVarRequestMap.erase(varRequestId);
-            qCDebug(LOG_VariableController()) << tr("1: erase REQUEST in  MAP ?")
-                                              << m_VarRequestIdToVarIdVarRequestMap.size();
+            qCDebug(LOG_VariableController())
+                << tr("1: erase REQUEST in  MAP ?") << m_VarRequestIdToVarIdVarRequestMap.size();
         }
     }
     else {
diff --git a/core/src/Visualization/VisualizationController.cpp b/core/src/Visualization/VisualizationController.cpp
index 0f4d9fd..e6c5e98 100644
--- a/core/src/Visualization/VisualizationController.cpp
+++ b/core/src/Visualization/VisualizationController.cpp
@@ -18,21 +18,21 @@ public:
 VisualizationController::VisualizationController(QObject *parent)
         : impl{spimpl::make_unique_impl<VisualizationControllerPrivate>()}
 {
-    qCDebug(LOG_VisualizationController()) << tr("VisualizationController construction")
-                                           << QThread::currentThread();
+    qCDebug(LOG_VisualizationController())
+        << tr("VisualizationController construction") << QThread::currentThread();
 }
 
 VisualizationController::~VisualizationController()
 {
-    qCDebug(LOG_VisualizationController()) << tr("VisualizationController destruction")
-                                           << QThread::currentThread();
+    qCDebug(LOG_VisualizationController())
+        << tr("VisualizationController destruction") << QThread::currentThread();
     this->waitForFinish();
 }
 
 void VisualizationController::initialize()
 {
-    qCDebug(LOG_VisualizationController()) << tr("VisualizationController init")
-                                           << QThread::currentThread();
+    qCDebug(LOG_VisualizationController())
+        << tr("VisualizationController init") << QThread::currentThread();
     impl->m_WorkingMutex.lock();
     qCDebug(LOG_VisualizationController()) << tr("VisualizationController init END");
 }
diff --git a/gui/src/Visualization/VisualizationGraphWidget.cpp b/gui/src/Visualization/VisualizationGraphWidget.cpp
index fc99f91..62ab281 100644
--- a/gui/src/Visualization/VisualizationGraphWidget.cpp
+++ b/gui/src/Visualization/VisualizationGraphWidget.cpp
@@ -267,9 +267,9 @@ void VisualizationGraphWidget::onGraphMenuRequested(const QPoint &pos) noexcept
 
 void VisualizationGraphWidget::onRangeChanged(const QCPRange &t1, const QCPRange &t2)
 {
-    qCDebug(LOG_VisualizationGraphWidget()) << tr("TORM: VisualizationGraphWidget::onRangeChanged")
-                                            << QThread::currentThread()->objectName() << "DoAcqui"
-                                            << impl->m_DoAcquisition;
+    qCDebug(LOG_VisualizationGraphWidget())
+        << tr("TORM: VisualizationGraphWidget::onRangeChanged")
+        << QThread::currentThread()->objectName() << "DoAcqui" << impl->m_DoAcquisition;
 
     auto graphRange = SqpRange{t1.lower, t1.upper};
     auto oldGraphRange = SqpRange{t2.lower, t2.upper};
diff --git a/gui/src/Visualization/VisualizationZoneWidget.cpp b/gui/src/Visualization/VisualizationZoneWidget.cpp
index aacba29..0c646bb 100644
--- a/gui/src/Visualization/VisualizationZoneWidget.cpp
+++ b/gui/src/Visualization/VisualizationZoneWidget.cpp
@@ -127,10 +127,10 @@ VisualizationGraphWidget *VisualizationZoneWidget::createGraph(std::shared_ptr<V
                         graphChildRange.m_TStart += deltaLeft;
                         graphChildRange.m_TEnd -= deltaRight;
                         qCDebug(LOG_VisualizationZoneWidget()) << tr("TORM: ZoomIn");
-                        qCDebug(LOG_VisualizationZoneWidget()) << tr("TORM: deltaLeft")
-                                                               << deltaLeft;
-                        qCDebug(LOG_VisualizationZoneWidget()) << tr("TORM: deltaRight")
-                                                               << deltaRight;
+                        qCDebug(LOG_VisualizationZoneWidget())
+                            << tr("TORM: deltaLeft") << deltaLeft;
+                        qCDebug(LOG_VisualizationZoneWidget())
+                            << tr("TORM: deltaRight") << deltaRight;
                         qCDebug(LOG_VisualizationZoneWidget())
                             << tr("TORM: dt") << graphRange.m_TEnd - graphRange.m_TStart;
 
@@ -141,10 +141,10 @@ VisualizationGraphWidget *VisualizationZoneWidget::createGraph(std::shared_ptr<V
                         qCDebug(LOG_VisualizationZoneWidget()) << tr("TORM: ZoomOut");
                         auto deltaLeft = oldGraphRange.m_TStart - graphRange.m_TStart;
                         auto deltaRight = graphRange.m_TEnd - oldGraphRange.m_TEnd;
-                        qCDebug(LOG_VisualizationZoneWidget()) << tr("TORM: deltaLeft")
-                                                               << deltaLeft;
-                        qCDebug(LOG_VisualizationZoneWidget()) << tr("TORM: deltaRight")
-                                                               << deltaRight;
+                        qCDebug(LOG_VisualizationZoneWidget())
+                            << tr("TORM: deltaLeft") << deltaLeft;
+                        qCDebug(LOG_VisualizationZoneWidget())
+                            << tr("TORM: deltaRight") << deltaRight;
                         qCDebug(LOG_VisualizationZoneWidget())
                             << tr("TORM: dt") << graphRange.m_TEnd - graphRange.m_TStart;
                         graphChildRange.m_TStart -= deltaLeft;
@@ -179,10 +179,10 @@ VisualizationGraphWidget *VisualizationZoneWidget::createGraph(std::shared_ptr<V
                         break;
                 }
                 graphChild->enableAcquisition(false);
-                qCDebug(LOG_VisualizationZoneWidget()) << tr("TORM: Range before: ")
-                                                       << graphChild->graphRange();
-                qCDebug(LOG_VisualizationZoneWidget()) << tr("TORM: Range after : ")
-                                                       << graphChildRange;
+                qCDebug(LOG_VisualizationZoneWidget())
+                    << tr("TORM: Range before: ") << graphChild->graphRange();
+                qCDebug(LOG_VisualizationZoneWidget())
+                    << tr("TORM: Range after : ") << graphChildRange;
                 qCDebug(LOG_VisualizationZoneWidget())
                     << tr("TORM: child dt") << graphChildRange.m_TEnd - graphChildRange.m_TStart;
                 graphChild->setGraphRange(graphChildRange);
diff --git a/gui/src/Visualization/qcustomplot.cpp b/gui/src/Visualization/qcustomplot.cpp
index 5be83c0..5ecb630 100644
--- a/gui/src/Visualization/qcustomplot.cpp
+++ b/gui/src/Visualization/qcustomplot.cpp
@@ -1574,10 +1574,7 @@ void QCPLayerable::applyAntialiasingHint(QCPPainter *painter, bool localAntialia
 
   \see initializeParentPlot
 */
-void QCPLayerable::parentPlotInitialized(QCustomPlot *parentPlot)
-{
-    Q_UNUSED(parentPlot)
-}
+void QCPLayerable::parentPlotInitialized(QCustomPlot *parentPlot){Q_UNUSED(parentPlot)}
 
 /*! \internal
 
@@ -9394,14 +9391,16 @@ void QCPAxisPainterPrivate::draw(QCPPainter *painter)
     painter->setBrush(QBrush(basePen.color()));
     QCPVector2D baseLineVector(baseLine.dx(), baseLine.dy());
     if (lowerEnding.style() != QCPLineEnding::esNone)
-        lowerEnding.draw(painter, QCPVector2D(baseLine.p1())
-                                      - baseLineVector.normalized() * lowerEnding.realLength()
-                                            * (lowerEnding.inverted() ? -1 : 1),
+        lowerEnding.draw(painter,
+                         QCPVector2D(baseLine.p1())
+                             - baseLineVector.normalized() * lowerEnding.realLength()
+                                   * (lowerEnding.inverted() ? -1 : 1),
                          -baseLineVector);
     if (upperEnding.style() != QCPLineEnding::esNone)
-        upperEnding.draw(painter, QCPVector2D(baseLine.p2())
-                                      + baseLineVector.normalized() * upperEnding.realLength()
-                                            * (upperEnding.inverted() ? -1 : 1),
+        upperEnding.draw(painter,
+                         QCPVector2D(baseLine.p2())
+                             + baseLineVector.normalized() * upperEnding.realLength()
+                                   * (upperEnding.inverted() ? -1 : 1),
                          baseLineVector);
     painter->setAntialiasing(antialiasingBackup);
 
@@ -16630,8 +16629,9 @@ void QCPColorGradient::updateColorBuffer()
                             hue -= 1.0;
                         if (useAlpha) {
                             const QRgb rgb
-                                = QColor::fromHsvF(hue, (1 - t) * lowHsv.saturationF()
-                                                            + t * highHsv.saturationF(),
+                                = QColor::fromHsvF(hue,
+                                                   (1 - t) * lowHsv.saturationF()
+                                                       + t * highHsv.saturationF(),
                                                    (1 - t) * lowHsv.valueF() + t * highHsv.valueF())
                                       .rgb();
                             const float alpha = (1 - t) * lowHsv.alphaF() + t * highHsv.alphaF();
@@ -16640,8 +16640,9 @@ void QCPColorGradient::updateColorBuffer()
                         }
                         else {
                             mColorBuffer[i]
-                                = QColor::fromHsvF(hue, (1 - t) * lowHsv.saturationF()
-                                                            + t * highHsv.saturationF(),
+                                = QColor::fromHsvF(hue,
+                                                   (1 - t) * lowHsv.saturationF()
+                                                       + t * highHsv.saturationF(),
                                                    (1 - t) * lowHsv.valueF() + t * highHsv.valueF())
                                       .rgb();
                         }
@@ -19998,12 +19999,14 @@ void QCPColorScale::update(UpdatePhase phase)
     switch (phase) {
         case upMargins: {
             if (mType == QCPAxis::atBottom || mType == QCPAxis::atTop) {
-                setMaximumSize(QWIDGETSIZE_MAX, mBarWidth + mAxisRect.data()->margins().top()
-                                                    + mAxisRect.data()->margins().bottom()
-                                                    + margins().top() + margins().bottom());
-                setMinimumSize(0, mBarWidth + mAxisRect.data()->margins().top()
-                                      + mAxisRect.data()->margins().bottom() + margins().top()
-                                      + margins().bottom());
+                setMaximumSize(QWIDGETSIZE_MAX,
+                               mBarWidth + mAxisRect.data()->margins().top()
+                                   + mAxisRect.data()->margins().bottom() + margins().top()
+                                   + margins().bottom());
+                setMinimumSize(0,
+                               mBarWidth + mAxisRect.data()->margins().top()
+                                   + mAxisRect.data()->margins().bottom() + margins().top()
+                                   + margins().bottom());
             }
             else {
                 setMaximumSize(mBarWidth + mAxisRect.data()->margins().left()
diff --git a/plugins/amda/src/AmdaProvider.cpp b/plugins/amda/src/AmdaProvider.cpp
index f10071c..bc723d0 100644
--- a/plugins/amda/src/AmdaProvider.cpp
+++ b/plugins/amda/src/AmdaProvider.cpp
@@ -83,8 +83,8 @@ void AmdaProvider::requestDataLoading(QUuid acqIdentifier, const DataProviderPar
     const auto times = parameters.m_Times;
     const auto data = parameters.m_Data;
     for (const auto &dateTime : qAsConst(times)) {
-        qCDebug(LOG_AmdaProvider()) << tr("TORM AmdaProvider::requestDataLoading ") << acqIdentifier
-                                    << dateTime;
+        qCDebug(LOG_AmdaProvider())
+            << tr("TORM AmdaProvider::requestDataLoading ") << acqIdentifier << dateTime;
         this->retrieveData(acqIdentifier, dateTime, data);
 
 
@@ -203,8 +203,8 @@ void AmdaProvider::retrieveData(QUuid token, const SqpRange &dateTime, const QVa
                     emit dataProvidedFailed(dataId);
                 }
             }
-            qCDebug(LOG_AmdaProvider()) << tr("acquisition requests erase because of finishing")
-                                        << dataId;
+            qCDebug(LOG_AmdaProvider())
+                << tr("acquisition requests erase because of finishing") << dataId;
             m_AcqIdToRequestProgressMap.erase(dataId);
         }
         else {
diff --git a/plugins/amda/tests/TestAmdaParser.cpp b/plugins/amda/tests/TestAmdaParser.cpp
index d2779a2..e2023f9 100644
--- a/plugins/amda/tests/TestAmdaParser.cpp
+++ b/plugins/amda/tests/TestAmdaParser.cpp
@@ -142,14 +142,14 @@ void TestAmdaParser::testReadJson_data()
     QTest::newRow("Valid file") << QStringLiteral("ValidFile1.json") << validResults1();
 
     // Invalid files
-    QTest::newRow("Invalid file (unexisting file)") << QStringLiteral("UnexistingFile.json")
-                                                    << invalidResults();
-    QTest::newRow("Invalid file (two root objects)") << QStringLiteral("TwoRootsFile.json")
-                                                     << invalidResults();
-    QTest::newRow("Invalid file (wrong root key)") << QStringLiteral("WrongRootKey.json")
-                                                   << invalidResults();
-    QTest::newRow("Invalid file (wrong root type)") << QStringLiteral("WrongRootType.json")
-                                                    << invalidResults();
+    QTest::newRow("Invalid file (unexisting file)")
+        << QStringLiteral("UnexistingFile.json") << invalidResults();
+    QTest::newRow("Invalid file (two root objects)")
+        << QStringLiteral("TwoRootsFile.json") << invalidResults();
+    QTest::newRow("Invalid file (wrong root key)")
+        << QStringLiteral("WrongRootKey.json") << invalidResults();
+    QTest::newRow("Invalid file (wrong root type)")
+        << QStringLiteral("WrongRootType.json") << invalidResults();
 }
 
 void TestAmdaParser::testReadJson()
diff --git a/plugins/amda/tests/TestAmdaResultParser.cpp b/plugins/amda/tests/TestAmdaResultParser.cpp
index 70a840f..be6616b 100644
--- a/plugins/amda/tests/TestAmdaResultParser.cpp
+++ b/plugins/amda/tests/TestAmdaResultParser.cpp
@@ -229,11 +229,11 @@ void TestAmdaResultParser::testReadScalarTxt_data()
                                          QVector<QDateTime>{}, QVector<double>{}};
 
     // Invalid files
-    QTest::newRow("Invalid file (unexisting file)") << QStringLiteral("UnexistingFile.txt")
-                                                    << ExpectedResults<ScalarSeries>{};
+    QTest::newRow("Invalid file (unexisting file)")
+        << QStringLiteral("UnexistingFile.txt") << ExpectedResults<ScalarSeries>{};
 
-    QTest::newRow("Invalid file (file not found on server)") << QStringLiteral("FileNotFound.txt")
-                                                             << ExpectedResults<ScalarSeries>{};
+    QTest::newRow("Invalid file (file not found on server)")
+        << QStringLiteral("FileNotFound.txt") << ExpectedResults<ScalarSeries>{};
 }
 
 void TestAmdaResultParser::testReadScalarTxt()
diff --git a/plugins/mockplugin/src/CosinusProvider.cpp b/plugins/mockplugin/src/CosinusProvider.cpp
index ed23a60..334636b 100644
--- a/plugins/mockplugin/src/CosinusProvider.cpp
+++ b/plugins/mockplugin/src/CosinusProvider.cpp
@@ -171,8 +171,8 @@ void CosinusProvider::requestDataLoading(QUuid acqIdentifier,
 {
     // TODO: Add Mutex
     m_VariableToEnableProvider[acqIdentifier] = true;
-    qCDebug(LOG_CosinusProvider()) << "TORM: CosinusProvider::requestDataLoading"
-                                   << QThread::currentThread()->objectName();
+    qCDebug(LOG_CosinusProvider())
+        << "TORM: CosinusProvider::requestDataLoading" << QThread::currentThread()->objectName();
     // NOTE: Try to use multithread if possible
     const auto times = parameters.m_Times;