diff --git a/docs/sections/building.md b/docs/sections/building.md
index 42b0daa..1489343 100644
--- a/docs/sections/building.md
+++ b/docs/sections/building.md
@@ -838,8 +838,8 @@
     extern const uint8_t im0[IMAGE_DATA_SIZE];
     extern const uint8_t im1[IMAGE_DATA_SIZE];
 
-    const char* get_filename(const uint32_t idx);
-    const uint8_t* get_img_array(const uint32_t idx);
+    const char* GetFilename(const uint32_t idx);
+    const uint8_t* GetImgArray(const uint32_t idx);
 
     #endif /* GENERATED_IMAGES_H */
     ```
@@ -859,7 +859,7 @@
         im1
     };
 
-    const char* get_filename(const uint32_t idx)
+    const char* GetFilename(const uint32_t idx)
     {
         if (idx < NUMBER_OF_FILES) {
             return img_filenames[idx];
@@ -867,7 +867,7 @@
         return nullptr;
     }
 
-    const uint8_t* get_img_array(const uint32_t idx)
+    const uint8_t* GetImgArray(const uint32_t idx)
     {
         if (idx < NUMBER_OF_FILES) {
             return img_arrays[idx];
diff --git a/scripts/py/setup_hooks.py b/scripts/py/setup_hooks.py
index 178765c..ead5e1f 100644
--- a/scripts/py/setup_hooks.py
+++ b/scripts/py/setup_hooks.py
@@ -67,7 +67,7 @@
                 exit $exitcode1
             fi
 
-            cppcheck --enable=performance,portability  --error-exitcode=1 $changed_files
+            cppcheck --enable=performance,portability  --error-exitcode=1 --suppress=*:tests* $changed_files
             exitcode2=$?
             if [ $exitcode2 -ne 0 ]; then
                 exit $exitcode2
diff --git a/scripts/py/templates/AudioClips.cc.template b/scripts/py/templates/AudioClips.cc.template
index 724aa84..659234b 100644
--- a/scripts/py/templates/AudioClips.cc.template
+++ b/scripts/py/templates/AudioClips.cc.template
@@ -18,45 +18,41 @@
 
 #include "InputFiles.hpp"
 
-static const char *audio_clip_filenames[] = {
+static const char* audioClipFilenames[] = {
 {% for name in clip_names %}
     "{{name}}",
 {% endfor %}
 };
 
-static const int16_t *audio_clip_arrays[] = {
-    {{ var_names|join(',\n\t') }}
+static const int16_t* audioClipArrays[] = {
+    {{ var_names|join(',\n    ') }}
 };
 
 
-static const size_t audio_clip_sizes[NUMBER_OF_FILES] = {
-    {{ clip_sizes|join(',\n\t') }}
+static const size_t audioClipSizes[NUMBER_OF_FILES] = {
+    {{ clip_sizes|join(',\n    ') }}
 };
 
-
-const char* get_filename(const uint32_t idx)
+const char* GetFilename(const uint32_t idx)
 {
     if (idx < NUMBER_OF_FILES) {
-        return audio_clip_filenames[idx];
+        return audioClipFilenames[idx];
     }
     return nullptr;
 }
 
-
-const int16_t* get_audio_array(const uint32_t idx)
+const int16_t* GetAudioArray(const uint32_t idx)
 {
     if (idx < NUMBER_OF_FILES) {
-        return audio_clip_arrays[idx];
+        return audioClipArrays[idx];
     }
     return nullptr;
 }
 
-
-uint32_t get_audio_array_size(const uint32_t idx)
+uint32_t GetAudioArraySize(const uint32_t idx)
 {
     if (idx < NUMBER_OF_FILES) {
-        return audio_clip_sizes[idx];
+        return audioClipSizes[idx];
     }
     return 0;
 }
-
diff --git a/scripts/py/templates/AudioClips.hpp.template b/scripts/py/templates/AudioClips.hpp.template
index dfe435c..12a7ae5 100644
--- a/scripts/py/templates/AudioClips.hpp.template
+++ b/scripts/py/templates/AudioClips.hpp.template
@@ -22,14 +22,31 @@
 #include <cstdint>
 #include <stddef.h>
 
-#define NUMBER_OF_FILES  ({{clips_count}}U)
+#define NUMBER_OF_FILES ({{clips_count}}U)
 
 {% for var_name, size in varname_size %}
 extern const int16_t {{var_name}}[{{size}}];
 {% endfor %}
 
-const char* get_filename(const uint32_t idx);
-const int16_t* get_audio_array(const uint32_t idx);
-uint32_t get_audio_array_size(const uint32_t idx);
+/**
+ * @brief       Gets the filename for the baked-in input array
+ * @param[in]   idx     Index of the input.
+ * @return      const C string pointer to the name.
+ **/
+const char* GetFilename(const uint32_t idx);
+
+/**
+ * @brief       Gets the pointer to audio data.
+ * @param[in]   idx     Index of the input.
+ * @return      Pointer to 16-bit signed integer data.
+ **/
+const int16_t* GetAudioArray(const uint32_t idx);
+
+/**
+ * @brief       Gets the size of the input array.
+ * @param[in]   idx     Index of the input.
+ * @return      Size of the input array in bytes.
+ **/
+uint32_t GetAudioArraySize(const uint32_t idx);
 
 #endif /* GENERATED_AUDIOCLIPS_H */
diff --git a/scripts/py/templates/Images.cc.template b/scripts/py/templates/Images.cc.template
index 0cbd4f3..2620ab4 100644
--- a/scripts/py/templates/Images.cc.template
+++ b/scripts/py/templates/Images.cc.template
@@ -18,30 +18,28 @@
 
 #include "InputFiles.hpp"
 
-static const char *img_filenames[] = {
+static const char* imgFilenames[] = {
 {% for name in img_names %}
     "{{name}}",
 {% endfor %}
 };
 
-static const uint8_t *img_arrays[] = {
-    {{ var_names|join(',\n\t') }}
+static const uint8_t* imgArrays[] = {
+    {{ var_names|join(',\n    ') }}
 };
 
-const char* get_filename(const uint32_t idx)
+const char* GetFilename(const uint32_t idx)
 {
     if (idx < NUMBER_OF_FILES) {
-        return img_filenames[idx];
+        return imgFilenames[idx];
     }
     return nullptr;
 }
 
-
-const uint8_t* get_img_array(const uint32_t idx)
+const uint8_t* GetImgArray(const uint32_t idx)
 {
     if (idx < NUMBER_OF_FILES) {
-        return img_arrays[idx];
+        return imgArrays[idx];
     }
     return nullptr;
 }
-
diff --git a/scripts/py/templates/Images.hpp.template b/scripts/py/templates/Images.hpp.template
index 01f0c0f..d39fc49 100644
--- a/scripts/py/templates/Images.hpp.template
+++ b/scripts/py/templates/Images.hpp.template
@@ -21,14 +21,25 @@
 
 #include <cstdint>
 
-#define NUMBER_OF_FILES  ({{imgs_count}}U)
-#define IMAGE_DATA_SIZE  ({{img_size}}U)
+#define NUMBER_OF_FILES ({{imgs_count}}U)
+#define IMAGE_DATA_SIZE ({{img_size}}U)
 
 {% for var_name in var_names %}
 extern const uint8_t {{var_name}}[IMAGE_DATA_SIZE];
 {% endfor %}
 
-const char* get_filename(const uint32_t idx);
-const uint8_t* get_img_array(const uint32_t idx);
+/**
+ * @brief       Gets the filename for the baked-in input array
+ * @param[in]   idx     Index of the input.
+ * @return      const C string pointer to the name.
+ **/
+const char* GetFilename(const uint32_t idx);
+
+/**
+ * @brief       Gets the pointer to image data.
+ * @param[in]   idx     Index of the input.
+ * @return      Pointer to the 8-bit unsigned integer data.
+ **/
+const uint8_t* GetImgArray(const uint32_t idx);
 
 #endif /* GENERATED_IMAGES_H */
diff --git a/scripts/py/templates/TestData.cc.template b/scripts/py/templates/TestData.cc.template
index 18f415a..f07879f 100644
--- a/scripts/py/templates/TestData.cc.template
+++ b/scripts/py/templates/TestData.cc.template
@@ -22,26 +22,26 @@
 namespace {{namespace}} {
 {% endfor %}
 
-static const {{data_type}} *ifm_arrays[] = {
-    {{ ifm_var_names|join(',\n\t') }}
+static const {{data_type}} *ifmArrays[] = {
+    {{ ifm_var_names|join(',\n    ') }}
 };
 
-static const {{data_type}} *ofm_arrays[] = {
-    {{ ofm_var_names|join(',\n\t') }}
+static const {{data_type}} *ofmArrays[] = {
+    {{ ofm_var_names|join(',\n    ') }}
 };
 
-const {{data_type}}* get_ifm_data_array(const uint32_t idx)
+const {{data_type}}* GetIfmDataArray(const uint32_t idx)
 {
     if (idx < NUMBER_OF_IFM_FILES) {
-        return ifm_arrays[idx];
+        return ifmArrays[idx];
     }
     return nullptr;
 }
 
-const {{data_type}}* get_ofm_data_array(const uint32_t idx)
+const {{data_type}}* GetOfmDataArray(const uint32_t idx)
 {
     if (idx < NUMBER_OF_OFM_FILES) {
-        return ofm_arrays[idx];
+        return ofmArrays[idx];
     }
     return nullptr;
 }
diff --git a/scripts/py/templates/TestData.hpp.template b/scripts/py/templates/TestData.hpp.template
index 13c410d..bd56f9f 100644
--- a/scripts/py/templates/TestData.hpp.template
+++ b/scripts/py/templates/TestData.hpp.template
@@ -25,13 +25,13 @@
 namespace {{namespace}} {
 {% endfor %}
 
-#define NUMBER_OF_IFM_FILES  ({{ifm_count}}U)
-#define NUMBER_OF_OFM_FILES  ({{ofm_count}}U)
+#define NUMBER_OF_IFM_FILES ({{ifm_count}}U)
+#define NUMBER_OF_OFM_FILES ({{ofm_count}}U)
 {% for ifm_size in ifm_var_sizes %}
-#define IFM_{{loop.index0}}_DATA_SIZE  ({{ifm_size}}U)
+#define IFM_{{loop.index0}}_DATA_SIZE ({{ifm_size}}U)
 {% endfor %}
 {% for ofm_size in ofm_var_sizes %}
-#define OFM_{{loop.index0}}_DATA_SIZE  ({{ofm_size}}U)
+#define OFM_{{loop.index0}}_DATA_SIZE ({{ofm_size}}U)
 {% endfor %}
 
 {% for ifm_var_name in ifm_var_names %}
@@ -42,8 +42,19 @@
 extern const {{data_type}} {{ofm_var_name}}[OFM_{{loop.index0}}_DATA_SIZE];
 {% endfor %}
 
-const {{data_type}}* get_ifm_data_array(const uint32_t idx);
-const {{data_type}}* get_ofm_data_array(const uint32_t idx);
+/**
+ * @brief       Gets the pointer to input feature map (IFM).
+ * @param[in]   idx     Index of the input.
+ * @return      Pointer to IFM.
+ **/
+const {{data_type}}* GetIfmDataArray(const uint32_t idx);
+
+/**
+ * @brief       Gets the pointer to output feature map (OFM).
+ * @param[in]   idx     Index of the output.
+ * @return      Pointer to OFM.
+ **/
+const {{data_type}}* GetOfmDataArray(const uint32_t idx);
 
 {% for namespace in namespaces %}
 } /* namespace {{namespace}} */
diff --git a/scripts/py/templates/default.hpp.template b/scripts/py/templates/default.hpp.template
index 14b2326..9a461a6 100644
--- a/scripts/py/templates/default.hpp.template
+++ b/scripts/py/templates/default.hpp.template
@@ -21,8 +21,13 @@
 
 #include <cstdint>
 
-#define NUMBER_OF_FILES  (0U)
+#define NUMBER_OF_FILES (0U)
 
-const char* get_filename(const uint32_t idx);
+/**
+ * @brief       Gets the filename for the baked-in input array
+ * @param[in]   idx     Index of the input.
+ * @return      const C string pointer to the name.
+ **/
+const char* GetFilename(const uint32_t idx);
 
 #endif /* DEFAULT_GENERATED_INPUT_H */
diff --git a/source/application/main/UseCaseCommonUtils.cc b/source/application/main/UseCaseCommonUtils.cc
index d1276ab..7d0a2ca 100644
--- a/source/application/main/UseCaseCommonUtils.cc
+++ b/source/application/main/UseCaseCommonUtils.cc
@@ -1,6 +1,6 @@
 /*
- * SPDX-FileCopyrightText: Copyright 2021-2022  Arm Limited and/or its affiliates <open-source-office@arm.com>
- * SPDX-License-Identifier: Apache-2.0
+ * SPDX-FileCopyrightText: Copyright 2021-2022  Arm Limited and/or its affiliates
+ * <open-source-office@arm.com> SPDX-License-Identifier: Apache-2.0
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -21,7 +21,6 @@
 
 #include <cinttypes>
 
-
 void DisplayCommonMenu()
 {
     printf("\n\n");
@@ -36,7 +35,7 @@
     fflush(stdout);
 }
 
-bool PresentInferenceResult(const std::vector<arm::app::ClassificationResult> &results)
+bool PresentInferenceResult(const std::vector<arm::app::ClassificationResult>& results)
 {
     constexpr uint32_t dataPsnTxtStartX1 = 150;
     constexpr uint32_t dataPsnTxtStartY1 = 30;
@@ -44,7 +43,7 @@
     constexpr uint32_t dataPsnTxtStartX2 = 10;
     constexpr uint32_t dataPsnTxtStartY2 = 150;
 
-    constexpr uint32_t dataPsnTxtYIncr = 16;  /* Row index increment. */
+    constexpr uint32_t dataPsnTxtYIncr = 16; /* Row index increment. */
 
     hal_lcd_set_text_color(COLOR_GREEN);
 
@@ -56,31 +55,28 @@
     info("Total number of inferences: 1\n");
 
     for (uint32_t i = 0; i < results.size(); ++i) {
-        std::string resultStr =
-                std::to_string(i + 1) + ") " +
-                std::to_string(results[i].m_labelIdx) +
-                " (" + std::to_string(results[i].m_normalisedVal) + ")";
+        std::string resultStr = std::to_string(i + 1) + ") " +
+                                std::to_string(results[i].m_labelIdx) + " (" +
+                                std::to_string(results[i].m_normalisedVal) + ")";
 
         hal_lcd_display_text(
-                resultStr.c_str(), resultStr.size(),
-                dataPsnTxtStartX1, rowIdx1, false);
+            resultStr.c_str(), resultStr.size(), dataPsnTxtStartX1, rowIdx1, false);
         rowIdx1 += dataPsnTxtYIncr;
 
         resultStr = std::to_string(i + 1) + ") " + results[i].m_label;
-        hal_lcd_display_text(
-                resultStr.c_str(), resultStr.size(),
-                dataPsnTxtStartX2, rowIdx2, 0);
+        hal_lcd_display_text(resultStr.c_str(), resultStr.size(), dataPsnTxtStartX2, rowIdx2, 0);
         rowIdx2 += dataPsnTxtYIncr;
 
-        info("%" PRIu32 ") %" PRIu32 " (%f) -> %s\n", i,
-            results[i].m_labelIdx, results[i].m_normalisedVal,
-            results[i].m_label.c_str());
+        info("%" PRIu32 ") %" PRIu32 " (%f) -> %s\n",
+             i,
+             results[i].m_labelIdx,
+             results[i].m_normalisedVal,
+             results[i].m_label.c_str());
     }
 
     return true;
 }
 
-
 void IncrementAppCtxIfmIdx(arm::app::ApplicationContext& ctx, const std::string& useCase)
 {
 #if NUMBER_OF_FILES > 0
@@ -92,7 +88,7 @@
     }
     ++curImIdx;
     ctx.Set<uint32_t>(useCase, curImIdx);
-#else /* NUMBER_OF_FILES > 0 */
+#else  /* NUMBER_OF_FILES > 0 */
     UNUSED(ctx);
     UNUSED(useCase);
 #endif /* NUMBER_OF_FILES > 0 */
@@ -102,13 +98,12 @@
 {
 #if NUMBER_OF_FILES > 0
     if (idx >= NUMBER_OF_FILES) {
-        printf_err("Invalid idx %" PRIu32 " (expected less than %u)\n",
-                   idx, NUMBER_OF_FILES);
+        printf_err("Invalid idx %" PRIu32 " (expected less than %u)\n", idx, NUMBER_OF_FILES);
         return false;
     }
     ctx.Set<uint32_t>(ctxIfmName, idx);
     return true;
-#else /* NUMBER_OF_FILES > 0 */
+#else  /* NUMBER_OF_FILES > 0 */
     UNUSED(ctx);
     UNUSED(idx);
     UNUSED(ctxIfmName);
@@ -119,83 +114,76 @@
 namespace arm {
 namespace app {
 
+    bool RunInference(arm::app::Model& model, Profiler& profiler)
+    {
+        profiler.StartProfiling("Inference");
+        bool runInf = model.RunInference();
+        profiler.StopProfiling();
 
-bool RunInference(arm::app::Model& model, Profiler& profiler)
-{
-    profiler.StartProfiling("Inference");
-    bool runInf = model.RunInference();
-    profiler.StopProfiling();
+        return runInf;
+    }
 
-    return runInf;
-}
+    int ReadUserInputAsInt()
+    {
+        char chInput[128];
+        memset(chInput, 0, sizeof(chInput));
 
-int ReadUserInputAsInt()
-{
-    char chInput[128];
-    memset(chInput, 0, sizeof(chInput));
+        hal_get_user_input(chInput, sizeof(chInput));
+        return atoi(chInput);
+    }
 
-    hal_get_user_input(chInput, sizeof(chInput));
-    return atoi(chInput);
-}
+    void DumpTensorData(const uint8_t* tensorData, size_t size, size_t lineBreakForNumElements)
+    {
+        char strhex[8];
+        std::string strdump;
 
-void DumpTensorData(const uint8_t* tensorData,
-                    size_t size,
-                    size_t lineBreakForNumElements)
-{
-    char strhex[8];
-    std::string strdump;
-
-    for (size_t i = 0; i < size; ++i) {
-        if (0 == i % lineBreakForNumElements) {
-            printf("%s\n\t", strdump.c_str());
-            strdump.clear();
+        for (size_t i = 0; i < size; ++i) {
+            if (0 == i % lineBreakForNumElements) {
+                printf("%s\n\t", strdump.c_str());
+                strdump.clear();
+            }
+            snprintf(strhex, sizeof(strhex) - 1, "0x%02x, ", tensorData[i]);
+            strdump += std::string(strhex);
         }
-        snprintf(strhex, sizeof(strhex) - 1,
-                 "0x%02x, ", tensorData[i]);
-        strdump += std::string(strhex);
+
+        if (!strdump.empty()) {
+            printf("%s\n", strdump.c_str());
+        }
     }
 
-    if (!strdump.empty()) {
-        printf("%s\n", strdump.c_str());
-    }
-}
+    void DumpTensor(const TfLiteTensor* tensor, const size_t lineBreakForNumElements)
+    {
+        if (!tensor) {
+            printf_err("invalid tensor\n");
+            return;
+        }
 
-void DumpTensor(const TfLiteTensor* tensor, const size_t lineBreakForNumElements)
-{
-    if (!tensor) {
-        printf_err("invalid tensor\n");
-        return;
+        const uint32_t tensorSz = tensor->bytes;
+        const auto* tensorData  = tflite::GetTensorData<uint8_t>(tensor);
+
+        DumpTensorData(tensorData, tensorSz, lineBreakForNumElements);
     }
 
-    const uint32_t tensorSz = tensor->bytes;
-    const auto* tensorData = tflite::GetTensorData<uint8_t>(tensor);
+    bool ListFilesHandler(ApplicationContext& ctx)
+    {
+        auto& model = ctx.Get<Model&>("model");
 
-    DumpTensorData(tensorData, tensorSz, lineBreakForNumElements);
-}
+        constexpr uint32_t dataPsnTxtStartX = 20;
+        constexpr uint32_t dataPsnTxtStartY = 40;
 
-bool ListFilesHandler(ApplicationContext& ctx)
-{
-    auto& model = ctx.Get<Model&>("model");
+        if (!model.IsInited()) {
+            printf_err("Model is not initialised! Terminating processing.\n");
+            return false;
+        }
 
-    constexpr uint32_t dataPsnTxtStartX = 20;
-    constexpr uint32_t dataPsnTxtStartY = 40;
+        /* Clear the LCD */
+        hal_lcd_clear(COLOR_BLACK);
 
-    if (!model.IsInited()) {
-        printf_err("Model is not initialised! Terminating processing.\n");
-        return false;
-    }
-
-    /* Clear the LCD */
-    hal_lcd_clear(COLOR_BLACK);
-
-    /* Show the total number of embedded files. */
-    std::string strNumFiles = std::string{"Total Number of Files: "} +
-                               std::to_string(NUMBER_OF_FILES);
-    hal_lcd_display_text(strNumFiles.c_str(),
-                                         strNumFiles.size(),
-                                         dataPsnTxtStartX,
-                                         dataPsnTxtStartY,
-                                         false);
+        /* Show the total number of embedded files. */
+        std::string strNumFiles =
+            std::string{"Total Number of Files: "} + std::to_string(NUMBER_OF_FILES);
+        hal_lcd_display_text(
+            strNumFiles.c_str(), strNumFiles.size(), dataPsnTxtStartX, dataPsnTxtStartY, false);
 
 #if NUMBER_OF_FILES > 0
         constexpr uint32_t dataPsnTxtYIncr = 16;
@@ -203,17 +191,16 @@
         uint32_t yVal = dataPsnTxtStartY + dataPsnTxtYIncr;
         for (uint32_t i = 0; i < NUMBER_OF_FILES; ++i, yVal += dataPsnTxtYIncr) {
 
-            std::string currentFilename{get_filename(i)};
-            hal_lcd_display_text(currentFilename.c_str(),
-                                                 currentFilename.size(),
-                                                 dataPsnTxtStartX, yVal, false);
+            std::string currentFilename{GetFilename(i)};
+            hal_lcd_display_text(
+                currentFilename.c_str(), currentFilename.size(), dataPsnTxtStartX, yVal, false);
 
             info("\t%" PRIu32 " => %s\n", i, currentFilename.c_str());
         }
 #endif /* NUMBER_OF_FILES > 0 */
 
         return true;
-}
+    }
 
 } /* namespace app */
 } /* namespace arm */
diff --git a/source/use_case/ad/src/UseCaseHandler.cc b/source/use_case/ad/src/UseCaseHandler.cc
index 222aaf3..c71fdeb 100644
--- a/source/use_case/ad/src/UseCaseHandler.cc
+++ b/source/use_case/ad/src/UseCaseHandler.cc
@@ -1,6 +1,6 @@
 /*
- * SPDX-FileCopyrightText: Copyright 2021-2022 Arm Limited and/or its affiliates <open-source-office@arm.com>
- * SPDX-License-Identifier: Apache-2.0
+ * SPDX-FileCopyrightText: Copyright 2021-2022 Arm Limited and/or its affiliates
+ * <open-source-office@arm.com> SPDX-License-Identifier: Apache-2.0
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -16,16 +16,16 @@
  */
 #include "UseCaseHandler.hpp"
 
-#include "AdModel.hpp"
-#include "InputFiles.hpp"
-#include "Classifier.hpp"
-#include "hal.h"
 #include "AdMelSpectrogram.hpp"
-#include "AudioUtils.hpp"
-#include "ImageUtils.hpp"
-#include "UseCaseCommonUtils.hpp"
-#include "log_macros.h"
+#include "AdModel.hpp"
 #include "AdProcessing.hpp"
+#include "AudioUtils.hpp"
+#include "Classifier.hpp"
+#include "ImageUtils.hpp"
+#include "InputFiles.hpp"
+#include "UseCaseCommonUtils.hpp"
+#include "hal.h"
+#include "log_macros.h"
 
 namespace arm {
 namespace app {
@@ -44,7 +44,7 @@
      *                          File name should be in format anything_goes_XX_here.wav
      *                          where XX is the machine ID e.g. 00, 02, 04 or 06
      *  @return     AD model output index as 8 bit integer.
-    **/
+     **/
     static int8_t OutputIndexFromFileName(std::string wavFileName);
 
     /* Anomaly Detection inference handler */
@@ -57,7 +57,7 @@
 
         /* If the request has a valid size, set the audio index */
         if (clipIndex < NUMBER_OF_FILES) {
-            if (!SetAppCtxIfmIdx(ctx, clipIndex,"clipIndex")) {
+            if (!SetAppCtxIfmIdx(ctx, clipIndex, "clipIndex")) {
                 return false;
             }
         }
@@ -66,26 +66,22 @@
             return false;
         }
 
-        auto& profiler = ctx.Get<Profiler&>("profiler");
+        auto& profiler                = ctx.Get<Profiler&>("profiler");
         const auto melSpecFrameLength = ctx.Get<uint32_t>("frameLength");
         const auto melSpecFrameStride = ctx.Get<uint32_t>("frameStride");
-        const auto scoreThreshold = ctx.Get<float>("scoreThreshold");
-        const auto trainingMean = ctx.Get<float>("trainingMean");
-        auto startClipIdx = ctx.Get<uint32_t>("clipIndex");
+        const auto scoreThreshold     = ctx.Get<float>("scoreThreshold");
+        const auto trainingMean       = ctx.Get<float>("trainingMean");
+        auto startClipIdx             = ctx.Get<uint32_t>("clipIndex");
 
         TfLiteTensor* outputTensor = model.GetOutputTensor(0);
-        TfLiteTensor* inputTensor = model.GetInputTensor(0);
+        TfLiteTensor* inputTensor  = model.GetInputTensor(0);
 
         if (!inputTensor->dims) {
             printf_err("Invalid input tensor dims\n");
             return false;
         }
 
-        AdPreProcess preProcess{
-            inputTensor,
-            melSpecFrameLength,
-            melSpecFrameStride,
-            trainingMean};
+        AdPreProcess preProcess{inputTensor, melSpecFrameLength, melSpecFrameStride, trainingMean};
 
         AdPostProcess postProcess{outputTensor};
 
@@ -95,17 +91,17 @@
             auto currentIndex = ctx.Get<uint32_t>("clipIndex");
 
             /* Get the output index to look at based on id in the filename. */
-            int8_t machineOutputIndex = OutputIndexFromFileName(get_filename(currentIndex));
+            int8_t machineOutputIndex = OutputIndexFromFileName(GetFilename(currentIndex));
             if (machineOutputIndex == -1) {
                 return false;
             }
 
             /* Creating a sliding window through the whole audio clip. */
-            auto audioDataSlider = audio::SlidingWindow<const int16_t>(
-                get_audio_array(currentIndex),
-                get_audio_array_size(currentIndex),
-                preProcess.GetAudioWindowSize(),
-                preProcess.GetAudioDataStride());
+            auto audioDataSlider =
+                audio::SlidingWindow<const int16_t>(GetAudioArray(currentIndex),
+                                                    GetAudioArraySize(currentIndex),
+                                                    preProcess.GetAudioWindowSize(),
+                                                    preProcess.GetAudioDataStride());
 
             /* Result is an averaged sum over inferences. */
             float result = 0;
@@ -113,11 +109,11 @@
             /* Display message on the LCD - inference running. */
             std::string str_inf{"Running inference... "};
             hal_lcd_display_text(
-                str_inf.c_str(), str_inf.size(),
-                dataPsnTxtInfStartX, dataPsnTxtInfStartY, 0);
+                str_inf.c_str(), str_inf.size(), dataPsnTxtInfStartX, dataPsnTxtInfStartY, 0);
 
             info("Running inference on audio clip %" PRIu32 " => %s\n",
-                currentIndex, get_filename(currentIndex));
+                 currentIndex,
+                 GetFilename(currentIndex));
 
             /* Start sliding through audio clip. */
             while (audioDataSlider.HasNext()) {
@@ -126,7 +122,8 @@
                 preProcess.SetAudioWindowIndex(audioDataSlider.Index());
                 preProcess.DoPreProcess(inferenceWindow, preProcess.GetAudioWindowSize());
 
-                info("Inference %zu/%zu\n", audioDataSlider.Index() + 1,
+                info("Inference %zu/%zu\n",
+                     audioDataSlider.Index() + 1,
                      audioDataSlider.TotalStrides() + 1);
 
                 /* Run inference over this audio clip sliding window */
@@ -139,7 +136,7 @@
 
 #if VERIFY_TEST_OUTPUT
                 DumpTensor(outputTensor);
-#endif /* VERIFY_TEST_OUTPUT */
+#endif        /* VERIFY_TEST_OUTPUT */
             } /* while (audioDataSlider.HasNext()) */
 
             /* Use average over whole clip as final score. */
@@ -148,8 +145,7 @@
             /* Erase. */
             str_inf = std::string(str_inf.size(), ' ');
             hal_lcd_display_text(
-                    str_inf.c_str(), str_inf.size(),
-                    dataPsnTxtInfStartX, dataPsnTxtInfStartY, 0);
+                str_inf.c_str(), str_inf.size(), dataPsnTxtInfStartX, dataPsnTxtInfStartY, 0);
 
             ctx.Set<float>("result", result);
             if (!PresentInferenceResult(result, scoreThreshold)) {
@@ -158,7 +154,7 @@
 
             profiler.PrintProfilingResult();
 
-            IncrementAppCtxIfmIdx(ctx,"clipIndex");
+            IncrementAppCtxIfmIdx(ctx, "clipIndex");
 
         } while (runAll && ctx.Get<uint32_t>("clipIndex") != startClipIdx);
 
@@ -176,8 +172,10 @@
         /* Display each result */
         uint32_t rowIdx1 = dataPsnTxtStartY1 + 2 * dataPsnTxtYIncr;
 
-        std::string anomalyScore = std::string{"Average anomaly score is: "} + std::to_string(result);
-        std::string anomalyThreshold = std::string("Anomaly threshold is: ") + std::to_string(threshold);
+        std::string anomalyScore =
+            std::string{"Average anomaly score is: "} + std::to_string(result);
+        std::string anomalyThreshold =
+            std::string("Anomaly threshold is: ") + std::to_string(threshold);
 
         std::string anomalyResult;
         if (result > threshold) {
@@ -187,8 +185,7 @@
         }
 
         hal_lcd_display_text(
-                anomalyScore.c_str(), anomalyScore.size(),
-                dataPsnTxtStartX1, rowIdx1, false);
+            anomalyScore.c_str(), anomalyScore.size(), dataPsnTxtStartX1, rowIdx1, false);
 
         info("%s\n", anomalyScore.c_str());
         info("%s\n", anomalyThreshold.c_str());
@@ -200,26 +197,28 @@
     static int8_t OutputIndexFromFileName(std::string wavFileName)
     {
         /* Filename is assumed in the form machine_id_00.wav */
-        std::string delimiter = "_";  /* First character used to split the file name up. */
+        std::string delimiter = "_"; /* First character used to split the file name up. */
         size_t delimiterStart;
         std::string subString;
-        size_t machineIdxInString = 3;  /* Which part of the file name the machine id should be at. */
+        size_t machineIdxInString =
+            3; /* Which part of the file name the machine id should be at. */
 
         for (size_t i = 0; i < machineIdxInString; ++i) {
             delimiterStart = wavFileName.find(delimiter);
-            subString = wavFileName.substr(0, delimiterStart);
+            subString      = wavFileName.substr(0, delimiterStart);
             wavFileName.erase(0, delimiterStart + delimiter.length());
         }
 
         /* At this point substring should be 00.wav */
-        delimiter = ".";  /* Second character used to split the file name up. */
+        delimiter      = "."; /* Second character used to split the file name up. */
         delimiterStart = subString.find(delimiter);
-        subString = (delimiterStart != std::string::npos) ? subString.substr(0, delimiterStart) : subString;
+        subString =
+            (delimiterStart != std::string::npos) ? subString.substr(0, delimiterStart) : subString;
 
-        auto is_number = [](const std::string& str) ->  bool
-        {
+        auto is_number = [](const std::string& str) -> bool {
             std::string::const_iterator it = str.begin();
-            while (it != str.end() && std::isdigit(*it)) ++it;
+            while (it != str.end() && std::isdigit(*it))
+                ++it;
             return !str.empty() && it == str.end();
         };
 
diff --git a/source/use_case/asr/src/UseCaseHandler.cc b/source/use_case/asr/src/UseCaseHandler.cc
index 76409b6..d13a03a 100644
--- a/source/use_case/asr/src/UseCaseHandler.cc
+++ b/source/use_case/asr/src/UseCaseHandler.cc
@@ -1,6 +1,6 @@
 /*
- * SPDX-FileCopyrightText: Copyright 2021-2022 Arm Limited and/or its affiliates <open-source-office@arm.com>
- * SPDX-License-Identifier: Apache-2.0
+ * SPDX-FileCopyrightText: Copyright 2021-2022 Arm Limited and/or its affiliates
+ * <open-source-office@arm.com> SPDX-License-Identifier: Apache-2.0
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -16,17 +16,17 @@
  */
 #include "UseCaseHandler.hpp"
 
-#include "InputFiles.hpp"
 #include "AsrClassifier.hpp"
-#include "Wav2LetterModel.hpp"
-#include "hal.h"
+#include "AsrResult.hpp"
 #include "AudioUtils.hpp"
 #include "ImageUtils.hpp"
-#include "UseCaseCommonUtils.hpp"
-#include "AsrResult.hpp"
-#include "Wav2LetterPreprocess.hpp"
-#include "Wav2LetterPostprocess.hpp"
+#include "InputFiles.hpp"
 #include "OutputDecode.hpp"
+#include "UseCaseCommonUtils.hpp"
+#include "Wav2LetterModel.hpp"
+#include "Wav2LetterPostprocess.hpp"
+#include "Wav2LetterPreprocess.hpp"
+#include "hal.h"
 #include "log_macros.h"
 
 namespace arm {
@@ -42,19 +42,19 @@
     /* ASR inference handler. */
     bool ClassifyAudioHandler(ApplicationContext& ctx, uint32_t clipIndex, bool runAll)
     {
-        auto& model = ctx.Get<Model&>("model");
-        auto& profiler = ctx.Get<Profiler&>("profiler");
-        auto mfccFrameLen = ctx.Get<uint32_t>("frameLength");
+        auto& model          = ctx.Get<Model&>("model");
+        auto& profiler       = ctx.Get<Profiler&>("profiler");
+        auto mfccFrameLen    = ctx.Get<uint32_t>("frameLength");
         auto mfccFrameStride = ctx.Get<uint32_t>("frameStride");
-        auto scoreThreshold = ctx.Get<float>("scoreThreshold");
-        auto inputCtxLen = ctx.Get<uint32_t>("ctxLen");
+        auto scoreThreshold  = ctx.Get<float>("scoreThreshold");
+        auto inputCtxLen     = ctx.Get<uint32_t>("ctxLen");
         /* If the request has a valid size, set the audio index. */
         if (clipIndex < NUMBER_OF_FILES) {
-            if (!SetAppCtxIfmIdx(ctx, clipIndex,"clipIndex")) {
+            if (!SetAppCtxIfmIdx(ctx, clipIndex, "clipIndex")) {
                 return false;
             }
         }
-        auto initialClipIdx = ctx.Get<uint32_t>("clipIndex");
+        auto initialClipIdx                    = ctx.Get<uint32_t>("clipIndex");
         constexpr uint32_t dataPsnTxtInfStartX = 20;
         constexpr uint32_t dataPsnTxtInfStartY = 40;
 
@@ -63,7 +63,7 @@
             return false;
         }
 
-        TfLiteTensor* inputTensor = model.GetInputTensor(0);
+        TfLiteTensor* inputTensor  = model.GetInputTensor(0);
         TfLiteTensor* outputTensor = model.GetOutputTensor(0);
 
         /* Get input shape. Dimensions of the tensor should have been verified by
@@ -81,18 +81,21 @@
         const float secondsPerSample = (1.0 / audio::Wav2LetterMFCC::ms_defaultSamplingFreq);
 
         /* Set up pre and post-processing objects. */
-        AsrPreProcess preProcess = AsrPreProcess(inputTensor, Wav2LetterModel::ms_numMfccFeatures,
+        AsrPreProcess preProcess = AsrPreProcess(inputTensor,
+                                                 Wav2LetterModel::ms_numMfccFeatures,
                                                  inputShape->data[Wav2LetterModel::ms_inputRowsIdx],
-                                                 mfccFrameLen, mfccFrameStride);
+                                                 mfccFrameLen,
+                                                 mfccFrameStride);
 
         std::vector<ClassificationResult> singleInfResult;
         const uint32_t outputCtxLen = AsrPostProcess::GetOutputContextLen(model, inputCtxLen);
-        AsrPostProcess postProcess = AsrPostProcess(
-                outputTensor, ctx.Get<AsrClassifier&>("classifier"),
-                ctx.Get<std::vector<std::string>&>("labels"),
-                singleInfResult, outputCtxLen,
-                Wav2LetterModel::ms_blankTokenIdx, Wav2LetterModel::ms_outputRowsIdx
-                );
+        AsrPostProcess postProcess  = AsrPostProcess(outputTensor,
+                                                    ctx.Get<AsrClassifier&>("classifier"),
+                                                    ctx.Get<std::vector<std::string>&>("labels"),
+                                                    singleInfResult,
+                                                    outputCtxLen,
+                                                    Wav2LetterModel::ms_blankTokenIdx,
+                                                    Wav2LetterModel::ms_outputRowsIdx);
 
         /* Loop to process audio clips. */
         do {
@@ -102,8 +105,8 @@
             auto currentIndex = ctx.Get<uint32_t>("clipIndex");
 
             /* Get the current audio buffer and respective size. */
-            const int16_t* audioArr = get_audio_array(currentIndex);
-            const uint32_t audioArrSize = get_audio_array_size(currentIndex);
+            const int16_t* audioArr     = GetAudioArray(currentIndex);
+            const uint32_t audioArrSize = GetAudioArraySize(currentIndex);
 
             if (!audioArr) {
                 printf_err("Invalid audio array pointer.\n");
@@ -119,19 +122,19 @@
 
             /* Creating a sliding window through the whole audio clip. */
             auto audioDataSlider = audio::FractionalSlidingWindow<const int16_t>(
-                    audioArr, audioArrSize,
-                    audioDataWindowLen, audioDataWindowStride);
+                audioArr, audioArrSize, audioDataWindowLen, audioDataWindowStride);
 
             /* Declare a container for final results. */
             std::vector<asr::AsrResult> finalResults;
 
             /* Display message on the LCD - inference running. */
             std::string str_inf{"Running inference... "};
-            hal_lcd_display_text(str_inf.c_str(), str_inf.size(),
-                    dataPsnTxtInfStartX, dataPsnTxtInfStartY, 0);
+            hal_lcd_display_text(
+                str_inf.c_str(), str_inf.size(), dataPsnTxtInfStartX, dataPsnTxtInfStartY, 0);
 
-            info("Running inference on audio clip %" PRIu32 " => %s\n", currentIndex,
-                 get_filename(currentIndex));
+            info("Running inference on audio clip %" PRIu32 " => %s\n",
+                 currentIndex,
+                 GetFilename(currentIndex));
 
             size_t inferenceWindowLen = audioDataWindowLen;
 
@@ -146,7 +149,8 @@
 
                 const int16_t* inferenceWindow = audioDataSlider.Next();
 
-                info("Inference %zu/%zu\n", audioDataSlider.Index() + 1,
+                info("Inference %zu/%zu\n",
+                     audioDataSlider.Index() + 1,
                      static_cast<size_t>(ceilf(audioDataSlider.FractionalTotalStrides() + 1)));
 
                 /* Run the pre-processing, inference and post-processing. */
@@ -168,20 +172,22 @@
                 }
 
                 /* Add results from this window to our final results vector. */
-                finalResults.emplace_back(asr::AsrResult(singleInfResult,
-                        (audioDataSlider.Index() * secondsPerSample * audioDataWindowStride),
-                        audioDataSlider.Index(), scoreThreshold));
+                finalResults.emplace_back(asr::AsrResult(
+                    singleInfResult,
+                    (audioDataSlider.Index() * secondsPerSample * audioDataWindowStride),
+                    audioDataSlider.Index(),
+                    scoreThreshold));
 
 #if VERIFY_TEST_OUTPUT
                 armDumpTensor(outputTensor,
-                    outputTensor->dims->data[Wav2LetterModel::ms_outputColsIdx]);
-#endif /* VERIFY_TEST_OUTPUT */
+                              outputTensor->dims->data[Wav2LetterModel::ms_outputColsIdx]);
+#endif        /* VERIFY_TEST_OUTPUT */
             } /* while (audioDataSlider.HasNext()) */
 
             /* Erase. */
             str_inf = std::string(str_inf.size(), ' ');
-            hal_lcd_display_text(str_inf.c_str(), str_inf.size(),
-                    dataPsnTxtInfStartX, dataPsnTxtInfStartY, 0);
+            hal_lcd_display_text(
+                str_inf.c_str(), str_inf.size(), dataPsnTxtInfStartX, dataPsnTxtInfStartY, 0);
 
             ctx.Set<std::vector<asr::AsrResult>>("results", finalResults);
 
@@ -191,19 +197,18 @@
 
             profiler.PrintProfilingResult();
 
-            IncrementAppCtxIfmIdx(ctx,"clipIndex");
+            IncrementAppCtxIfmIdx(ctx, "clipIndex");
 
         } while (runAll && ctx.Get<uint32_t>("clipIndex") != initialClipIdx);
 
         return true;
     }
 
-
     static bool PresentInferenceResult(const std::vector<asr::AsrResult>& results)
     {
         constexpr uint32_t dataPsnTxtStartX1 = 20;
         constexpr uint32_t dataPsnTxtStartY1 = 60;
-        constexpr bool allow_multiple_lines = true;
+        constexpr bool allow_multiple_lines  = true;
 
         hal_lcd_set_text_color(COLOR_GREEN);
 
@@ -212,9 +217,8 @@
         /* Results from multiple inferences should be combined before processing. */
         std::vector<ClassificationResult> combinedResults;
         for (const auto& result : results) {
-            combinedResults.insert(combinedResults.end(),
-                                   result.m_resultVec.begin(),
-                                   result.m_resultVec.end());
+            combinedResults.insert(
+                combinedResults.end(), result.m_resultVec.begin(), result.m_resultVec.end());
         }
 
         /* Get each inference result string using the decoder. */
@@ -222,16 +226,19 @@
             std::string infResultStr = audio::asr::DecodeOutput(result.m_resultVec);
 
             info("For timestamp: %f (inference #: %" PRIu32 "); label: %s\n",
-                 result.m_timeStamp, result.m_inferenceNumber,
+                 result.m_timeStamp,
+                 result.m_inferenceNumber,
                  infResultStr.c_str());
         }
 
         /* Get the decoded result for the combined result. */
         std::string finalResultStr = audio::asr::DecodeOutput(combinedResults);
 
-        hal_lcd_display_text(finalResultStr.c_str(), finalResultStr.size(),
-                dataPsnTxtStartX1, dataPsnTxtStartY1,
-                allow_multiple_lines);
+        hal_lcd_display_text(finalResultStr.c_str(),
+                             finalResultStr.size(),
+                             dataPsnTxtStartX1,
+                             dataPsnTxtStartY1,
+                             allow_multiple_lines);
 
         info("Complete recognition: %s\n", finalResultStr.c_str());
         return true;
diff --git a/source/use_case/img_class/src/UseCaseHandler.cc b/source/use_case/img_class/src/UseCaseHandler.cc
index 4732064..52c42f3 100644
--- a/source/use_case/img_class/src/UseCaseHandler.cc
+++ b/source/use_case/img_class/src/UseCaseHandler.cc
@@ -1,6 +1,6 @@
 /*
- * SPDX-FileCopyrightText: Copyright 2021-2022 Arm Limited and/or its affiliates <open-source-office@arm.com>
- * SPDX-License-Identifier: Apache-2.0
+ * SPDX-FileCopyrightText: Copyright 2021-2022 Arm Limited and/or its affiliates
+ * <open-source-office@arm.com> SPDX-License-Identifier: Apache-2.0
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -17,13 +17,13 @@
 #include "UseCaseHandler.hpp"
 
 #include "Classifier.hpp"
+#include "ImageUtils.hpp"
+#include "ImgClassProcessing.hpp"
 #include "InputFiles.hpp"
 #include "MobileNetModel.hpp"
-#include "ImageUtils.hpp"
 #include "UseCaseCommonUtils.hpp"
 #include "hal.h"
 #include "log_macros.h"
-#include "ImgClassProcessing.hpp"
 
 #include <cinttypes>
 
@@ -36,7 +36,7 @@
     bool ClassifyImageHandler(ApplicationContext& ctx, uint32_t imgIndex, bool runAll)
     {
         auto& profiler = ctx.Get<Profiler&>("profiler");
-        auto& model = ctx.Get<Model&>("model");
+        auto& model    = ctx.Get<Model&>("model");
         /* If the request has a valid size, set the image index as it might not be set. */
         if (imgIndex < NUMBER_OF_FILES) {
             if (!SetAppCtxIfmIdx(ctx, imgIndex, "imgIndex")) {
@@ -46,19 +46,18 @@
         auto initialImgIdx = ctx.Get<uint32_t>("imgIndex");
 
         constexpr uint32_t dataPsnImgDownscaleFactor = 2;
-        constexpr uint32_t dataPsnImgStartX = 10;
-        constexpr uint32_t dataPsnImgStartY = 35;
+        constexpr uint32_t dataPsnImgStartX          = 10;
+        constexpr uint32_t dataPsnImgStartY          = 35;
 
         constexpr uint32_t dataPsnTxtInfStartX = 150;
         constexpr uint32_t dataPsnTxtInfStartY = 40;
 
-
         if (!model.IsInited()) {
             printf_err("Model is not initialised! Terminating processing.\n");
             return false;
         }
 
-        TfLiteTensor* inputTensor = model.GetInputTensor(0);
+        TfLiteTensor* inputTensor  = model.GetInputTensor(0);
         TfLiteTensor* outputTensor = model.GetOutputTensor(0);
         if (!inputTensor->dims) {
             printf_err("Invalid input tensor dims\n");
@@ -70,17 +69,19 @@
 
         /* Get input shape for displaying the image. */
         TfLiteIntArray* inputShape = model.GetInputShape(0);
-        const uint32_t nCols = inputShape->data[arm::app::MobileNetModel::ms_inputColsIdx];
-        const uint32_t nRows = inputShape->data[arm::app::MobileNetModel::ms_inputRowsIdx];
+        const uint32_t nCols       = inputShape->data[arm::app::MobileNetModel::ms_inputColsIdx];
+        const uint32_t nRows       = inputShape->data[arm::app::MobileNetModel::ms_inputRowsIdx];
         const uint32_t nChannels = inputShape->data[arm::app::MobileNetModel::ms_inputChannelsIdx];
 
         /* Set up pre and post-processing. */
         ImgClassPreProcess preProcess = ImgClassPreProcess(inputTensor, model.IsDataSigned());
 
         std::vector<ClassificationResult> results;
-        ImgClassPostProcess postProcess = ImgClassPostProcess(outputTensor,
-                ctx.Get<ImgClassClassifier&>("classifier"), ctx.Get<std::vector<std::string>&>("labels"),
-                results);
+        ImgClassPostProcess postProcess =
+            ImgClassPostProcess(outputTensor,
+                                ctx.Get<ImgClassClassifier&>("classifier"),
+                                ctx.Get<std::vector<std::string>&>("labels"),
+                                results);
 
         do {
             hal_lcd_clear(COLOR_BLACK);
@@ -88,29 +89,34 @@
             /* Strings for presentation/logging. */
             std::string str_inf{"Running inference... "};
 
-            const uint8_t* imgSrc = get_img_array(ctx.Get<uint32_t>("imgIndex"));
+            const uint8_t* imgSrc = GetImgArray(ctx.Get<uint32_t>("imgIndex"));
             if (nullptr == imgSrc) {
-                printf_err("Failed to get image index %" PRIu32 " (max: %u)\n", ctx.Get<uint32_t>("imgIndex"),
+                printf_err("Failed to get image index %" PRIu32 " (max: %u)\n",
+                           ctx.Get<uint32_t>("imgIndex"),
                            NUMBER_OF_FILES - 1);
                 return false;
             }
 
             /* Display this image on the LCD. */
-            hal_lcd_display_image(
-                imgSrc,
-                nCols, nRows, nChannels,
-                dataPsnImgStartX, dataPsnImgStartY, dataPsnImgDownscaleFactor);
+            hal_lcd_display_image(imgSrc,
+                                  nCols,
+                                  nRows,
+                                  nChannels,
+                                  dataPsnImgStartX,
+                                  dataPsnImgStartY,
+                                  dataPsnImgDownscaleFactor);
 
             /* Display message on the LCD - inference running. */
-            hal_lcd_display_text(str_inf.c_str(), str_inf.size(),
-                    dataPsnTxtInfStartX, dataPsnTxtInfStartY, false);
+            hal_lcd_display_text(
+                str_inf.c_str(), str_inf.size(), dataPsnTxtInfStartX, dataPsnTxtInfStartY, false);
 
             /* Select the image to run inference with. */
-            info("Running inference on image %" PRIu32 " => %s\n", ctx.Get<uint32_t>("imgIndex"),
-                get_filename(ctx.Get<uint32_t>("imgIndex")));
+            info("Running inference on image %" PRIu32 " => %s\n",
+                 ctx.Get<uint32_t>("imgIndex"),
+                 GetFilename(ctx.Get<uint32_t>("imgIndex")));
 
-            const size_t imgSz = inputTensor->bytes < IMAGE_DATA_SIZE ?
-                                  inputTensor->bytes : IMAGE_DATA_SIZE;
+            const size_t imgSz =
+                inputTensor->bytes < IMAGE_DATA_SIZE ? inputTensor->bytes : IMAGE_DATA_SIZE;
 
             /* Run the pre-processing, inference and post-processing. */
             if (!preProcess.DoPreProcess(imgSrc, imgSz)) {
@@ -130,8 +136,8 @@
 
             /* Erase. */
             str_inf = std::string(str_inf.size(), ' ');
-            hal_lcd_display_text(str_inf.c_str(), str_inf.size(),
-                    dataPsnTxtInfStartX, dataPsnTxtInfStartY, false);
+            hal_lcd_display_text(
+                str_inf.c_str(), str_inf.size(), dataPsnTxtInfStartX, dataPsnTxtInfStartY, false);
 
             /* Add results to context for access outside handler. */
             ctx.Set<std::vector<ClassificationResult>>("results", results);
@@ -146,7 +152,7 @@
 
             profiler.PrintProfilingResult();
 
-            IncrementAppCtxIfmIdx(ctx,"imgIndex");
+            IncrementAppCtxIfmIdx(ctx, "imgIndex");
 
         } while (runAll && ctx.Get<uint32_t>("imgIndex") != initialImgIdx);
 
diff --git a/source/use_case/kws/src/UseCaseHandler.cc b/source/use_case/kws/src/UseCaseHandler.cc
index c20c32b..ce99ed3 100644
--- a/source/use_case/kws/src/UseCaseHandler.cc
+++ b/source/use_case/kws/src/UseCaseHandler.cc
@@ -1,6 +1,6 @@
 /*
- * SPDX-FileCopyrightText: Copyright 2021-2022 Arm Limited and/or its affiliates <open-source-office@arm.com>
- * SPDX-License-Identifier: Apache-2.0
+ * SPDX-FileCopyrightText: Copyright 2021-2022 Arm Limited and/or its affiliates
+ * <open-source-office@arm.com> SPDX-License-Identifier: Apache-2.0
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -16,16 +16,16 @@
  */
 #include "UseCaseHandler.hpp"
 
-#include "InputFiles.hpp"
-#include "KwsClassifier.hpp"
-#include "MicroNetKwsModel.hpp"
-#include "hal.h"
 #include "AudioUtils.hpp"
 #include "ImageUtils.hpp"
-#include "UseCaseCommonUtils.hpp"
-#include "KwsResult.hpp"
-#include "log_macros.h"
+#include "InputFiles.hpp"
+#include "KwsClassifier.hpp"
 #include "KwsProcessing.hpp"
+#include "KwsResult.hpp"
+#include "MicroNetKwsModel.hpp"
+#include "UseCaseCommonUtils.hpp"
+#include "hal.h"
+#include "log_macros.h"
 
 #include <vector>
 
@@ -42,15 +42,15 @@
     /* KWS inference handler. */
     bool ClassifyAudioHandler(ApplicationContext& ctx, uint32_t clipIndex, bool runAll)
     {
-        auto& profiler = ctx.Get<Profiler&>("profiler");
-        auto& model = ctx.Get<Model&>("model");
+        auto& profiler             = ctx.Get<Profiler&>("profiler");
+        auto& model                = ctx.Get<Model&>("model");
         const auto mfccFrameLength = ctx.Get<int>("frameLength");
         const auto mfccFrameStride = ctx.Get<int>("frameStride");
-        const auto scoreThreshold = ctx.Get<float>("scoreThreshold");
+        const auto scoreThreshold  = ctx.Get<float>("scoreThreshold");
 
         /* If the request has a valid size, set the audio index. */
         if (clipIndex < NUMBER_OF_FILES) {
-            if (!SetAppCtxIfmIdx(ctx, clipIndex,"clipIndex")) {
+            if (!SetAppCtxIfmIdx(ctx, clipIndex, "clipIndex")) {
                 return false;
             }
         }
@@ -58,9 +58,10 @@
 
         constexpr uint32_t dataPsnTxtInfStartX = 20;
         constexpr uint32_t dataPsnTxtInfStartY = 40;
-        constexpr int minTensorDims = static_cast<int>(
-            (MicroNetKwsModel::ms_inputRowsIdx > MicroNetKwsModel::ms_inputColsIdx)?
-             MicroNetKwsModel::ms_inputRowsIdx : MicroNetKwsModel::ms_inputColsIdx);
+        constexpr int minTensorDims =
+            static_cast<int>((MicroNetKwsModel::ms_inputRowsIdx > MicroNetKwsModel::ms_inputColsIdx)
+                                 ? MicroNetKwsModel::ms_inputRowsIdx
+                                 : MicroNetKwsModel::ms_inputColsIdx);
 
         if (!model.IsInited()) {
             printf_err("Model is not initialised! Terminating processing.\n");
@@ -68,7 +69,7 @@
         }
 
         /* Get Input and Output tensors for pre/post processing. */
-        TfLiteTensor* inputTensor = model.GetInputTensor(0);
+        TfLiteTensor* inputTensor  = model.GetInputTensor(0);
         TfLiteTensor* outputTensor = model.GetOutputTensor(0);
         if (!inputTensor->dims) {
             printf_err("Invalid input tensor dims\n");
@@ -79,20 +80,22 @@
         }
 
         /* Get input shape for feature extraction. */
-        TfLiteIntArray* inputShape = model.GetInputShape(0);
+        TfLiteIntArray* inputShape     = model.GetInputShape(0);
         const uint32_t numMfccFeatures = inputShape->data[MicroNetKwsModel::ms_inputColsIdx];
-        const uint32_t numMfccFrames = inputShape->data[arm::app::MicroNetKwsModel::ms_inputRowsIdx];
+        const uint32_t numMfccFrames =
+            inputShape->data[arm::app::MicroNetKwsModel::ms_inputRowsIdx];
 
         /* We expect to be sampling 1 second worth of data at a time.
          * NOTE: This is only used for time stamp calculation. */
         const float secondsPerSample = 1.0 / audio::MicroNetKwsMFCC::ms_defaultSamplingFreq;
 
         /* Set up pre and post-processing. */
-        KwsPreProcess preProcess = KwsPreProcess(inputTensor, numMfccFeatures, numMfccFrames,
-                                                 mfccFrameLength, mfccFrameStride);
+        KwsPreProcess preProcess = KwsPreProcess(
+            inputTensor, numMfccFeatures, numMfccFrames, mfccFrameLength, mfccFrameStride);
 
         std::vector<ClassificationResult> singleInfResult;
-        KwsPostProcess postProcess = KwsPostProcess(outputTensor, ctx.Get<KwsClassifier &>("classifier"),
+        KwsPostProcess postProcess = KwsPostProcess(outputTensor,
+                                                    ctx.Get<KwsClassifier&>("classifier"),
                                                     ctx.Get<std::vector<std::string>&>("labels"),
                                                     singleInfResult);
 
@@ -103,26 +106,29 @@
             auto currentIndex = ctx.Get<uint32_t>("clipIndex");
 
             /* Creating a sliding window through the whole audio clip. */
-            auto audioDataSlider = audio::SlidingWindow<const int16_t>(
-                    get_audio_array(currentIndex),
-                    get_audio_array_size(currentIndex),
-                    preProcess.m_audioDataWindowSize, preProcess.m_audioDataStride);
+            auto audioDataSlider =
+                audio::SlidingWindow<const int16_t>(GetAudioArray(currentIndex),
+                                                    GetAudioArraySize(currentIndex),
+                                                    preProcess.m_audioDataWindowSize,
+                                                    preProcess.m_audioDataStride);
 
             /* Declare a container to hold results from across the whole audio clip. */
             std::vector<kws::KwsResult> finalResults;
 
             /* Display message on the LCD - inference running. */
             std::string str_inf{"Running inference... "};
-            hal_lcd_display_text(str_inf.c_str(), str_inf.size(),
-                    dataPsnTxtInfStartX, dataPsnTxtInfStartY, 0);
-            info("Running inference on audio clip %" PRIu32 " => %s\n", currentIndex,
-                 get_filename(currentIndex));
+            hal_lcd_display_text(
+                str_inf.c_str(), str_inf.size(), dataPsnTxtInfStartX, dataPsnTxtInfStartY, 0);
+            info("Running inference on audio clip %" PRIu32 " => %s\n",
+                 currentIndex,
+                 GetFilename(currentIndex));
 
             /* Start sliding through audio clip. */
             while (audioDataSlider.HasNext()) {
                 const int16_t* inferenceWindow = audioDataSlider.Next();
 
-                info("Inference %zu/%zu\n", audioDataSlider.Index() + 1,
+                info("Inference %zu/%zu\n",
+                     audioDataSlider.Index() + 1,
                      audioDataSlider.TotalStrides() + 1);
 
                 /* Run the pre-processing, inference and post-processing. */
@@ -142,19 +148,21 @@
                 }
 
                 /* Add results from this window to our final results vector. */
-                finalResults.emplace_back(kws::KwsResult(singleInfResult,
-                        audioDataSlider.Index() * secondsPerSample * preProcess.m_audioDataStride,
-                        audioDataSlider.Index(), scoreThreshold));
+                finalResults.emplace_back(kws::KwsResult(
+                    singleInfResult,
+                    audioDataSlider.Index() * secondsPerSample * preProcess.m_audioDataStride,
+                    audioDataSlider.Index(),
+                    scoreThreshold));
 
 #if VERIFY_TEST_OUTPUT
                 DumpTensor(outputTensor);
-#endif /* VERIFY_TEST_OUTPUT */
+#endif        /* VERIFY_TEST_OUTPUT */
             } /* while (audioDataSlider.HasNext()) */
 
             /* Erase. */
             str_inf = std::string(str_inf.size(), ' ');
-            hal_lcd_display_text(str_inf.c_str(), str_inf.size(),
-                    dataPsnTxtInfStartX, dataPsnTxtInfStartY, false);
+            hal_lcd_display_text(
+                str_inf.c_str(), str_inf.size(), dataPsnTxtInfStartX, dataPsnTxtInfStartY, false);
 
             ctx.Set<std::vector<kws::KwsResult>>("results", finalResults);
 
@@ -164,7 +172,7 @@
 
             profiler.PrintProfilingResult();
 
-            IncrementAppCtxIfmIdx(ctx,"clipIndex");
+            IncrementAppCtxIfmIdx(ctx, "clipIndex");
 
         } while (runAll && ctx.Get<uint32_t>("clipIndex") != initialClipIdx);
 
@@ -175,7 +183,7 @@
     {
         constexpr uint32_t dataPsnTxtStartX1 = 20;
         constexpr uint32_t dataPsnTxtStartY1 = 30;
-        constexpr uint32_t dataPsnTxtYIncr   = 16;  /* Row index increment. */
+        constexpr uint32_t dataPsnTxtYIncr   = 16; /* Row index increment. */
 
         hal_lcd_set_text_color(COLOR_GREEN);
         info("Final results:\n");
@@ -190,28 +198,28 @@
             float score = 0.f;
             if (!result.m_resultVec.empty()) {
                 topKeyword = result.m_resultVec[0].m_label;
-                score = result.m_resultVec[0].m_normalisedVal;
+                score      = result.m_resultVec[0].m_normalisedVal;
             }
 
-            std::string resultStr =
-                    std::string{"@"} + std::to_string(result.m_timeStamp) +
-                    std::string{"s: "} + topKeyword + std::string{" ("} +
-                    std::to_string(static_cast<int>(score * 100)) + std::string{"%)"};
+            std::string resultStr = std::string{"@"} + std::to_string(result.m_timeStamp) +
+                                    std::string{"s: "} + topKeyword + std::string{" ("} +
+                                    std::to_string(static_cast<int>(score * 100)) +
+                                    std::string{"%)"};
 
-            hal_lcd_display_text(resultStr.c_str(), resultStr.size(),
-                    dataPsnTxtStartX1, rowIdx1, false);
+            hal_lcd_display_text(
+                resultStr.c_str(), resultStr.size(), dataPsnTxtStartX1, rowIdx1, false);
             rowIdx1 += dataPsnTxtYIncr;
 
             if (result.m_resultVec.empty()) {
-                info("For timestamp: %f (inference #: %" PRIu32
-                             "); label: %s; threshold: %f\n",
-                     result.m_timeStamp, result.m_inferenceNumber,
+                info("For timestamp: %f (inference #: %" PRIu32 "); label: %s; threshold: %f\n",
+                     result.m_timeStamp,
+                     result.m_inferenceNumber,
                      topKeyword.c_str(),
                      result.m_threshold);
             } else {
                 for (uint32_t j = 0; j < result.m_resultVec.size(); ++j) {
                     info("For timestamp: %f (inference #: %" PRIu32
-                                 "); label: %s, score: %f; threshold: %f\n",
+                         "); label: %s, score: %f; threshold: %f\n",
                          result.m_timeStamp,
                          result.m_inferenceNumber,
                          result.m_resultVec[j].m_label.c_str(),
diff --git a/source/use_case/kws_asr/src/UseCaseHandler.cc b/source/use_case/kws_asr/src/UseCaseHandler.cc
index e733605..8a024b7 100644
--- a/source/use_case/kws_asr/src/UseCaseHandler.cc
+++ b/source/use_case/kws_asr/src/UseCaseHandler.cc
@@ -1,6 +1,6 @@
 /*
- * SPDX-FileCopyrightText: Copyright 2021-2022 Arm Limited and/or its affiliates <open-source-office@arm.com>
- * SPDX-License-Identifier: Apache-2.0
+ * SPDX-FileCopyrightText: Copyright 2021-2022 Arm Limited and/or its affiliates
+ * <open-source-office@arm.com> SPDX-License-Identifier: Apache-2.0
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -16,35 +16,34 @@
  */
 #include "UseCaseHandler.hpp"
 
-#include "hal.h"
-#include "InputFiles.hpp"
-#include "AudioUtils.hpp"
-#include "ImageUtils.hpp"
-#include "UseCaseCommonUtils.hpp"
-#include "MicroNetKwsModel.hpp"
-#include "MicroNetKwsMfcc.hpp"
-#include "Classifier.hpp"
-#include "KwsResult.hpp"
-#include "Wav2LetterModel.hpp"
-#include "Wav2LetterMfcc.hpp"
-#include "Wav2LetterPreprocess.hpp"
-#include "Wav2LetterPostprocess.hpp"
-#include "KwsProcessing.hpp"
-#include "AsrResult.hpp"
 #include "AsrClassifier.hpp"
+#include "AsrResult.hpp"
+#include "AudioUtils.hpp"
+#include "Classifier.hpp"
+#include "ImageUtils.hpp"
+#include "InputFiles.hpp"
+#include "KwsProcessing.hpp"
+#include "KwsResult.hpp"
+#include "MicroNetKwsMfcc.hpp"
+#include "MicroNetKwsModel.hpp"
 #include "OutputDecode.hpp"
+#include "UseCaseCommonUtils.hpp"
+#include "Wav2LetterMfcc.hpp"
+#include "Wav2LetterModel.hpp"
+#include "Wav2LetterPostprocess.hpp"
+#include "Wav2LetterPreprocess.hpp"
+#include "hal.h"
 #include "log_macros.h"
 
-
 using KwsClassifier = arm::app::Classifier;
 
 namespace arm {
 namespace app {
 
     struct KWSOutput {
-        bool executionSuccess = false;
+        bool executionSuccess        = false;
         const int16_t* asrAudioStart = nullptr;
-        int32_t asrAudioSamples = 0;
+        int32_t asrAudioSamples      = 0;
     };
 
     /**
@@ -69,23 +68,24 @@
      **/
     static KWSOutput doKws(ApplicationContext& ctx)
     {
-        auto& profiler = ctx.Get<Profiler&>("profiler");
-        auto& kwsModel = ctx.Get<Model&>("kwsModel");
+        auto& profiler                = ctx.Get<Profiler&>("profiler");
+        auto& kwsModel                = ctx.Get<Model&>("kwsModel");
         const auto kwsMfccFrameLength = ctx.Get<int>("kwsFrameLength");
         const auto kwsMfccFrameStride = ctx.Get<int>("kwsFrameStride");
-        const auto kwsScoreThreshold = ctx.Get<float>("kwsScoreThreshold");
+        const auto kwsScoreThreshold  = ctx.Get<float>("kwsScoreThreshold");
 
         auto currentIndex = ctx.Get<uint32_t>("clipIndex");
 
         constexpr uint32_t dataPsnTxtInfStartX = 20;
         constexpr uint32_t dataPsnTxtInfStartY = 40;
 
-        constexpr int minTensorDims = static_cast<int>(
-            (MicroNetKwsModel::ms_inputRowsIdx > MicroNetKwsModel::ms_inputColsIdx)?
-             MicroNetKwsModel::ms_inputRowsIdx : MicroNetKwsModel::ms_inputColsIdx);
+        constexpr int minTensorDims =
+            static_cast<int>((MicroNetKwsModel::ms_inputRowsIdx > MicroNetKwsModel::ms_inputColsIdx)
+                                 ? MicroNetKwsModel::ms_inputRowsIdx
+                                 : MicroNetKwsModel::ms_inputColsIdx);
 
         /* Output struct from doing KWS. */
-        KWSOutput output {};
+        KWSOutput output{};
 
         if (!kwsModel.IsInited()) {
             printf_err("KWS model has not been initialised\n");
@@ -93,7 +93,7 @@
         }
 
         /* Get Input and Output tensors for pre/post processing. */
-        TfLiteTensor* kwsInputTensor = kwsModel.GetInputTensor(0);
+        TfLiteTensor* kwsInputTensor  = kwsModel.GetInputTensor(0);
         TfLiteTensor* kwsOutputTensor = kwsModel.GetOutputTensor(0);
         if (!kwsInputTensor->dims) {
             printf_err("Invalid input tensor dims\n");
@@ -104,28 +104,30 @@
         }
 
         /* Get input shape for feature extraction. */
-        TfLiteIntArray* inputShape = kwsModel.GetInputShape(0);
+        TfLiteIntArray* inputShape     = kwsModel.GetInputShape(0);
         const uint32_t numMfccFeatures = inputShape->data[MicroNetKwsModel::ms_inputColsIdx];
-        const uint32_t numMfccFrames = inputShape->data[MicroNetKwsModel::ms_inputRowsIdx];
+        const uint32_t numMfccFrames   = inputShape->data[MicroNetKwsModel::ms_inputRowsIdx];
 
         /* We expect to be sampling 1 second worth of data at a time
          * NOTE: This is only used for time stamp calculation. */
-        const float kwsAudioParamsSecondsPerSample = 1.0 / audio::MicroNetKwsMFCC::ms_defaultSamplingFreq;
+        const float kwsAudioParamsSecondsPerSample =
+            1.0 / audio::MicroNetKwsMFCC::ms_defaultSamplingFreq;
 
         /* Set up pre and post-processing. */
-        KwsPreProcess preProcess = KwsPreProcess(kwsInputTensor, numMfccFeatures, numMfccFrames,
-                                                 kwsMfccFrameLength, kwsMfccFrameStride);
+        KwsPreProcess preProcess = KwsPreProcess(
+            kwsInputTensor, numMfccFeatures, numMfccFrames, kwsMfccFrameLength, kwsMfccFrameStride);
 
         std::vector<ClassificationResult> singleInfResult;
-        KwsPostProcess postProcess = KwsPostProcess(kwsOutputTensor, ctx.Get<KwsClassifier &>("kwsClassifier"),
+        KwsPostProcess postProcess = KwsPostProcess(kwsOutputTensor,
+                                                    ctx.Get<KwsClassifier&>("kwsClassifier"),
                                                     ctx.Get<std::vector<std::string>&>("kwsLabels"),
                                                     singleInfResult);
 
         /* Creating a sliding window through the whole audio clip. */
-        auto audioDataSlider = audio::SlidingWindow<const int16_t>(
-                get_audio_array(currentIndex),
-                get_audio_array_size(currentIndex),
-                preProcess.m_audioDataWindowSize, preProcess.m_audioDataStride);
+        auto audioDataSlider = audio::SlidingWindow<const int16_t>(GetAudioArray(currentIndex),
+                                                                   GetAudioArraySize(currentIndex),
+                                                                   preProcess.m_audioDataWindowSize,
+                                                                   preProcess.m_audioDataStride);
 
         /* Declare a container to hold kws results from across the whole audio clip. */
         std::vector<kws::KwsResult> finalResults;
@@ -133,11 +135,11 @@
         /* Display message on the LCD - inference running. */
         std::string str_inf{"Running KWS inference... "};
         hal_lcd_display_text(
-                            str_inf.c_str(), str_inf.size(),
-                            dataPsnTxtInfStartX, dataPsnTxtInfStartY, false);
+            str_inf.c_str(), str_inf.size(), dataPsnTxtInfStartX, dataPsnTxtInfStartY, false);
 
         info("Running KWS inference on audio clip %" PRIu32 " => %s\n",
-             currentIndex, get_filename(currentIndex));
+             currentIndex,
+             GetFilename(currentIndex));
 
         /* Start sliding through audio clip. */
         while (audioDataSlider.HasNext()) {
@@ -159,22 +161,26 @@
                 return output;
             }
 
-            info("Inference %zu/%zu\n", audioDataSlider.Index() + 1,
+            info("Inference %zu/%zu\n",
+                 audioDataSlider.Index() + 1,
                  audioDataSlider.TotalStrides() + 1);
 
             /* Add results from this window to our final results vector. */
             finalResults.emplace_back(
-                    kws::KwsResult(singleInfResult,
-                            audioDataSlider.Index() * kwsAudioParamsSecondsPerSample * preProcess.m_audioDataStride,
-                            audioDataSlider.Index(), kwsScoreThreshold));
+                kws::KwsResult(singleInfResult,
+                               audioDataSlider.Index() * kwsAudioParamsSecondsPerSample *
+                                   preProcess.m_audioDataStride,
+                               audioDataSlider.Index(),
+                               kwsScoreThreshold));
 
             /* Break out when trigger keyword is detected. */
-            if (singleInfResult[0].m_label == ctx.Get<const std::string&>("triggerKeyword")
-                    && singleInfResult[0].m_normalisedVal > kwsScoreThreshold) {
+            if (singleInfResult[0].m_label == ctx.Get<const std::string&>("triggerKeyword") &&
+                singleInfResult[0].m_normalisedVal > kwsScoreThreshold) {
                 output.asrAudioStart = inferenceWindow + preProcess.m_audioDataWindowSize;
-                output.asrAudioSamples = get_audio_array_size(currentIndex) -
-                                        (audioDataSlider.NextWindowStartIndex() -
-                                        preProcess.m_audioDataStride + preProcess.m_audioDataWindowSize);
+                output.asrAudioSamples =
+                    GetAudioArraySize(currentIndex) -
+                    (audioDataSlider.NextWindowStartIndex() - preProcess.m_audioDataStride +
+                     preProcess.m_audioDataWindowSize);
                 break;
             }
 
@@ -186,8 +192,8 @@
 
         /* Erase. */
         str_inf = std::string(str_inf.size(), ' ');
-        hal_lcd_display_text(str_inf.c_str(), str_inf.size(),
-                dataPsnTxtInfStartX, dataPsnTxtInfStartY, false);
+        hal_lcd_display_text(
+            str_inf.c_str(), str_inf.size(), dataPsnTxtInfStartX, dataPsnTxtInfStartY, false);
 
         if (!PresentInferenceResult(finalResults)) {
             return output;
@@ -208,12 +214,12 @@
      **/
     static bool doAsr(ApplicationContext& ctx, const KWSOutput& kwsOutput)
     {
-        auto& asrModel = ctx.Get<Model&>("asrModel");
-        auto& profiler = ctx.Get<Profiler&>("profiler");
-        auto asrMfccFrameLen = ctx.Get<uint32_t>("asrFrameLength");
+        auto& asrModel          = ctx.Get<Model&>("asrModel");
+        auto& profiler          = ctx.Get<Profiler&>("profiler");
+        auto asrMfccFrameLen    = ctx.Get<uint32_t>("asrFrameLength");
         auto asrMfccFrameStride = ctx.Get<uint32_t>("asrFrameStride");
-        auto asrScoreThreshold = ctx.Get<float>("asrScoreThreshold");
-        auto asrInputCtxLen = ctx.Get<uint32_t>("ctxLen");
+        auto asrScoreThreshold  = ctx.Get<float>("asrScoreThreshold");
+        auto asrInputCtxLen     = ctx.Get<uint32_t>("ctxLen");
 
         constexpr uint32_t dataPsnTxtInfStartX = 20;
         constexpr uint32_t dataPsnTxtInfStartY = 40;
@@ -226,31 +232,32 @@
         hal_lcd_clear(COLOR_BLACK);
 
         /* Get Input and Output tensors for pre/post processing. */
-        TfLiteTensor* asrInputTensor = asrModel.GetInputTensor(0);
+        TfLiteTensor* asrInputTensor  = asrModel.GetInputTensor(0);
         TfLiteTensor* asrOutputTensor = asrModel.GetOutputTensor(0);
 
         /* Get input shape. Dimensions of the tensor should have been verified by
-        * the callee. */
+         * the callee. */
         TfLiteIntArray* inputShape = asrModel.GetInputShape(0);
 
-
         const uint32_t asrInputRows = asrInputTensor->dims->data[Wav2LetterModel::ms_inputRowsIdx];
         const uint32_t asrInputInnerLen = asrInputRows - (2 * asrInputCtxLen);
 
         /* Make sure the input tensor supports the above context and inner lengths. */
         if (asrInputRows <= 2 * asrInputCtxLen || asrInputRows <= asrInputInnerLen) {
             printf_err("ASR input rows not compatible with ctx length %" PRIu32 "\n",
-                asrInputCtxLen);
+                       asrInputCtxLen);
             return false;
         }
 
         /* Audio data stride corresponds to inputInnerLen feature vectors. */
-        const uint32_t asrAudioDataWindowLen = (asrInputRows - 1) * asrMfccFrameStride + (asrMfccFrameLen);
+        const uint32_t asrAudioDataWindowLen =
+            (asrInputRows - 1) * asrMfccFrameStride + (asrMfccFrameLen);
         const uint32_t asrAudioDataWindowStride = asrInputInnerLen * asrMfccFrameStride;
-        const float asrAudioParamsSecondsPerSample = 1.0 / audio::Wav2LetterMFCC::ms_defaultSamplingFreq;
+        const float asrAudioParamsSecondsPerSample =
+            1.0 / audio::Wav2LetterMFCC::ms_defaultSamplingFreq;
 
         /* Get the remaining audio buffer and respective size from KWS results. */
-        const int16_t* audioArr = kwsOutput.asrAudioStart;
+        const int16_t* audioArr     = kwsOutput.asrAudioStart;
         const uint32_t audioArrSize = kwsOutput.asrAudioSamples;
 
         /* Audio clip must have enough samples to produce 1 MFCC feature. */
@@ -262,35 +269,40 @@
         }
 
         /* Initialise an audio slider. */
-        auto audioDataSlider = audio::FractionalSlidingWindow<const int16_t>(
-                audioBuffer.data(),
-                audioBuffer.size(),
-                asrAudioDataWindowLen,
-                asrAudioDataWindowStride);
+        auto audioDataSlider =
+            audio::FractionalSlidingWindow<const int16_t>(audioBuffer.data(),
+                                                          audioBuffer.size(),
+                                                          asrAudioDataWindowLen,
+                                                          asrAudioDataWindowStride);
 
         /* Declare a container for results. */
         std::vector<asr::AsrResult> asrResults;
 
         /* Display message on the LCD - inference running. */
         std::string str_inf{"Running ASR inference... "};
-        hal_lcd_display_text(str_inf.c_str(), str_inf.size(),
-                dataPsnTxtInfStartX, dataPsnTxtInfStartY, false);
+        hal_lcd_display_text(
+            str_inf.c_str(), str_inf.size(), dataPsnTxtInfStartX, dataPsnTxtInfStartY, false);
 
         size_t asrInferenceWindowLen = asrAudioDataWindowLen;
 
         /* Set up pre and post-processing objects. */
-        AsrPreProcess asrPreProcess = AsrPreProcess(asrInputTensor, arm::app::Wav2LetterModel::ms_numMfccFeatures,
-                                              inputShape->data[Wav2LetterModel::ms_inputRowsIdx],
-                                              asrMfccFrameLen, asrMfccFrameStride);
+        AsrPreProcess asrPreProcess =
+            AsrPreProcess(asrInputTensor,
+                          arm::app::Wav2LetterModel::ms_numMfccFeatures,
+                          inputShape->data[Wav2LetterModel::ms_inputRowsIdx],
+                          asrMfccFrameLen,
+                          asrMfccFrameStride);
 
         std::vector<ClassificationResult> singleInfResult;
         const uint32_t outputCtxLen = AsrPostProcess::GetOutputContextLen(asrModel, asrInputCtxLen);
-        AsrPostProcess asrPostProcess = AsrPostProcess(
-                asrOutputTensor, ctx.Get<AsrClassifier&>("asrClassifier"),
-                ctx.Get<std::vector<std::string>&>("asrLabels"),
-                singleInfResult, outputCtxLen,
-                Wav2LetterModel::ms_blankTokenIdx, Wav2LetterModel::ms_outputRowsIdx
-        );
+        AsrPostProcess asrPostProcess =
+            AsrPostProcess(asrOutputTensor,
+                           ctx.Get<AsrClassifier&>("asrClassifier"),
+                           ctx.Get<std::vector<std::string>&>("asrLabels"),
+                           singleInfResult,
+                           outputCtxLen,
+                           Wav2LetterModel::ms_blankTokenIdx,
+                           Wav2LetterModel::ms_outputRowsIdx);
         /* Start sliding through audio clip. */
         while (audioDataSlider.HasNext()) {
 
@@ -302,8 +314,9 @@
 
             const int16_t* asrInferenceWindow = audioDataSlider.Next();
 
-            info("Inference %zu/%zu\n", audioDataSlider.Index() + 1,
-                static_cast<size_t>(ceilf(audioDataSlider.FractionalTotalStrides() + 1)));
+            info("Inference %zu/%zu\n",
+                 audioDataSlider.Index() + 1,
+                 static_cast<size_t>(ceilf(audioDataSlider.FractionalTotalStrides() + 1)));
 
             /* Run the pre-processing, inference and post-processing. */
             if (!asrPreProcess.DoPreProcess(asrInferenceWindow, asrInferenceWindowLen)) {
@@ -327,25 +340,27 @@
             /* Get results. */
             std::vector<ClassificationResult> asrClassificationResult;
             auto& asrClassifier = ctx.Get<AsrClassifier&>("asrClassifier");
-            asrClassifier.GetClassificationResults(
-                    asrOutputTensor, asrClassificationResult,
-                    ctx.Get<std::vector<std::string>&>("asrLabels"), 1);
+            asrClassifier.GetClassificationResults(asrOutputTensor,
+                                                   asrClassificationResult,
+                                                   ctx.Get<std::vector<std::string>&>("asrLabels"),
+                                                   1);
 
-            asrResults.emplace_back(asr::AsrResult(asrClassificationResult,
-                                                (audioDataSlider.Index() *
-                                                 asrAudioParamsSecondsPerSample *
-                                                 asrAudioDataWindowStride),
-                                                 audioDataSlider.Index(), asrScoreThreshold));
+            asrResults.emplace_back(
+                asr::AsrResult(asrClassificationResult,
+                               (audioDataSlider.Index() * asrAudioParamsSecondsPerSample *
+                                asrAudioDataWindowStride),
+                               audioDataSlider.Index(),
+                               asrScoreThreshold));
 
 #if VERIFY_TEST_OUTPUT
-            armDumpTensor(asrOutputTensor, asrOutputTensor->dims->data[Wav2LetterModel::ms_outputColsIdx]);
+            armDumpTensor(asrOutputTensor,
+                          asrOutputTensor->dims->data[Wav2LetterModel::ms_outputColsIdx]);
 #endif /* VERIFY_TEST_OUTPUT */
 
             /* Erase */
             str_inf = std::string(str_inf.size(), ' ');
             hal_lcd_display_text(
-                        str_inf.c_str(), str_inf.size(),
-                        dataPsnTxtInfStartX, dataPsnTxtInfStartY, false);
+                str_inf.c_str(), str_inf.size(), dataPsnTxtInfStartX, dataPsnTxtInfStartY, false);
         }
         if (!PresentInferenceResult(asrResults)) {
             return false;
@@ -363,7 +378,7 @@
 
         /* If the request has a valid size, set the audio index. */
         if (clipIndex < NUMBER_OF_FILES) {
-            if (!SetAppCtxIfmIdx(ctx, clipIndex,"kws_asr")) {
+            if (!SetAppCtxIfmIdx(ctx, clipIndex, "kws_asr")) {
                 return false;
             }
         }
@@ -379,13 +394,13 @@
 
             if (kwsOutput.asrAudioStart != nullptr && kwsOutput.asrAudioSamples > 0) {
                 info("Trigger keyword spotted\n");
-                if(!doAsr(ctx, kwsOutput)) {
+                if (!doAsr(ctx, kwsOutput)) {
                     printf_err("ASR failed\n");
                     return false;
                 }
             }
 
-            IncrementAppCtxIfmIdx(ctx,"kws_asr");
+            IncrementAppCtxIfmIdx(ctx, "kws_asr");
 
         } while (runAll && ctx.Get<uint32_t>("clipIndex") != startClipIdx);
 
@@ -396,36 +411,38 @@
     {
         constexpr uint32_t dataPsnTxtStartX1 = 20;
         constexpr uint32_t dataPsnTxtStartY1 = 30;
-        constexpr uint32_t dataPsnTxtYIncr   = 16;  /* Row index increment. */
+        constexpr uint32_t dataPsnTxtYIncr   = 16; /* Row index increment. */
 
         hal_lcd_set_text_color(COLOR_GREEN);
 
         /* Display each result. */
         uint32_t rowIdx1 = dataPsnTxtStartY1 + 2 * dataPsnTxtYIncr;
 
-        for (auto & result : results) {
+        for (auto& result : results) {
             std::string topKeyword{"<none>"};
             float score = 0.f;
 
             if (!result.m_resultVec.empty()) {
                 topKeyword = result.m_resultVec[0].m_label;
-                score = result.m_resultVec[0].m_normalisedVal;
+                score      = result.m_resultVec[0].m_normalisedVal;
             }
 
-            std::string resultStr =
-                    std::string{"@"} + std::to_string(result.m_timeStamp) +
-                    std::string{"s: "} + topKeyword + std::string{" ("} +
-                    std::to_string(static_cast<int>(score * 100)) + std::string{"%)"};
+            std::string resultStr = std::string{"@"} + std::to_string(result.m_timeStamp) +
+                                    std::string{"s: "} + topKeyword + std::string{" ("} +
+                                    std::to_string(static_cast<int>(score * 100)) +
+                                    std::string{"%)"};
 
-            hal_lcd_display_text(resultStr.c_str(), resultStr.size(),
-                    dataPsnTxtStartX1, rowIdx1, 0);
+            hal_lcd_display_text(
+                resultStr.c_str(), resultStr.size(), dataPsnTxtStartX1, rowIdx1, 0);
             rowIdx1 += dataPsnTxtYIncr;
 
             info("For timestamp: %f (inference #: %" PRIu32 "); threshold: %f\n",
-                 result.m_timeStamp, result.m_inferenceNumber,
+                 result.m_timeStamp,
+                 result.m_inferenceNumber,
                  result.m_threshold);
             for (uint32_t j = 0; j < result.m_resultVec.size(); ++j) {
-                info("\t\tlabel @ %" PRIu32 ": %s, score: %f\n", j,
+                info("\t\tlabel @ %" PRIu32 ": %s, score: %f\n",
+                     j,
                      result.m_resultVec[j].m_label.c_str(),
                      result.m_resultVec[j].m_normalisedVal);
             }
@@ -438,30 +455,32 @@
     {
         constexpr uint32_t dataPsnTxtStartX1 = 20;
         constexpr uint32_t dataPsnTxtStartY1 = 80;
-        constexpr bool allow_multiple_lines = true;
+        constexpr bool allow_multiple_lines  = true;
 
         hal_lcd_set_text_color(COLOR_GREEN);
 
         /* Results from multiple inferences should be combined before processing. */
         std::vector<arm::app::ClassificationResult> combinedResults;
         for (auto& result : results) {
-            combinedResults.insert(combinedResults.end(),
-                                   result.m_resultVec.begin(),
-                                   result.m_resultVec.end());
+            combinedResults.insert(
+                combinedResults.end(), result.m_resultVec.begin(), result.m_resultVec.end());
         }
 
         for (auto& result : results) {
             /* Get the final result string using the decoder. */
             std::string infResultStr = audio::asr::DecodeOutput(result.m_resultVec);
 
-            info("Result for inf %" PRIu32 ": %s\n", result.m_inferenceNumber,
-                 infResultStr.c_str());
+            info(
+                "Result for inf %" PRIu32 ": %s\n", result.m_inferenceNumber, infResultStr.c_str());
         }
 
         std::string finalResultStr = audio::asr::DecodeOutput(combinedResults);
 
-        hal_lcd_display_text(finalResultStr.c_str(), finalResultStr.size(),
-                dataPsnTxtStartX1, dataPsnTxtStartY1, allow_multiple_lines);
+        hal_lcd_display_text(finalResultStr.c_str(),
+                             finalResultStr.size(),
+                             dataPsnTxtStartX1,
+                             dataPsnTxtStartY1,
+                             allow_multiple_lines);
 
         info("Final result: %s\n", finalResultStr.c_str());
         return true;
diff --git a/source/use_case/noise_reduction/src/UseCaseHandler.cc b/source/use_case/noise_reduction/src/UseCaseHandler.cc
index 0aef600..0c5ff39 100644
--- a/source/use_case/noise_reduction/src/UseCaseHandler.cc
+++ b/source/use_case/noise_reduction/src/UseCaseHandler.cc
@@ -1,6 +1,6 @@
 /*
- * SPDX-FileCopyrightText: Copyright 2021-2022 Arm Limited and/or its affiliates <open-source-office@arm.com>
- * SPDX-License-Identifier: Apache-2.0
+ * SPDX-FileCopyrightText: Copyright 2021-2022 Arm Limited and/or its affiliates
+ * <open-source-office@arm.com> SPDX-License-Identifier: Apache-2.0
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -14,24 +14,24 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-#include "hal.h"
 #include "UseCaseHandler.hpp"
-#include "UseCaseCommonUtils.hpp"
 #include "AudioUtils.hpp"
 #include "ImageUtils.hpp"
 #include "InputFiles.hpp"
-#include "RNNoiseModel.hpp"
 #include "RNNoiseFeatureProcessor.hpp"
+#include "RNNoiseModel.hpp"
 #include "RNNoiseProcessing.hpp"
+#include "UseCaseCommonUtils.hpp"
+#include "hal.h"
 #include "log_macros.h"
 
 namespace arm {
 namespace app {
 
     /**
-    * @brief            Helper function to increment current audio clip features index.
-    * @param[in,out]    ctx   Pointer to the application context object.
-    **/
+     * @brief            Helper function to increment current audio clip features index.
+     * @param[in,out]    ctx   Pointer to the application context object.
+     **/
     static void IncrementAppCtxClipIdx(ApplicationContext& ctx);
 
     /* Noise reduction inference handler. */
@@ -41,17 +41,18 @@
         constexpr uint32_t dataPsnTxtInfStartY = 40;
 
         /* Variables used for memory dumping. */
-        size_t memDumpMaxLen = 0;
-        uint8_t* memDumpBaseAddr = nullptr;
+        size_t memDumpMaxLen            = 0;
+        uint8_t* memDumpBaseAddr        = nullptr;
         size_t undefMemDumpBytesWritten = 0;
-        size_t* pMemDumpBytesWritten = &undefMemDumpBytesWritten;
-        if (ctx.Has("MEM_DUMP_LEN") && ctx.Has("MEM_DUMP_BASE_ADDR") && ctx.Has("MEM_DUMP_BYTE_WRITTEN")) {
-            memDumpMaxLen = ctx.Get<size_t>("MEM_DUMP_LEN");
-            memDumpBaseAddr = ctx.Get<uint8_t*>("MEM_DUMP_BASE_ADDR");
+        size_t* pMemDumpBytesWritten    = &undefMemDumpBytesWritten;
+        if (ctx.Has("MEM_DUMP_LEN") && ctx.Has("MEM_DUMP_BASE_ADDR") &&
+            ctx.Has("MEM_DUMP_BYTE_WRITTEN")) {
+            memDumpMaxLen        = ctx.Get<size_t>("MEM_DUMP_LEN");
+            memDumpBaseAddr      = ctx.Get<uint8_t*>("MEM_DUMP_BASE_ADDR");
             pMemDumpBytesWritten = ctx.Get<size_t*>("MEM_DUMP_BYTE_WRITTEN");
         }
         std::reference_wrapper<size_t> memDumpBytesWritten = std::ref(*pMemDumpBytesWritten);
-        auto& profiler = ctx.Get<Profiler&>("profiler");
+        auto& profiler                                     = ctx.Get<Profiler&>("profiler");
 
         /* Get model reference. */
         auto& model = ctx.Get<RNNoiseModel&>("model");
@@ -61,15 +62,16 @@
         }
 
         /* Populate Pre-Processing related parameters. */
-        auto audioFrameLen = ctx.Get<uint32_t>("frameLength");
-        auto audioFrameStride = ctx.Get<uint32_t>("frameStride");
+        auto audioFrameLen      = ctx.Get<uint32_t>("frameLength");
+        auto audioFrameStride   = ctx.Get<uint32_t>("frameStride");
         auto nrNumInputFeatures = ctx.Get<uint32_t>("numInputFeatures");
 
         TfLiteTensor* inputTensor = model.GetInputTensor(0);
         if (nrNumInputFeatures != inputTensor->bytes) {
             printf_err("Input features size must be equal to input tensor size."
                        " Feature size = %" PRIu32 ", Tensor size = %zu.\n",
-                       nrNumInputFeatures, inputTensor->bytes);
+                       nrNumInputFeatures,
+                       inputTensor->bytes);
             return false;
         }
 
@@ -78,49 +80,55 @@
         /* Initial choice of index for WAV file. */
         auto startClipIdx = ctx.Get<uint32_t>("clipIndex");
 
-        std::function<const int16_t* (const uint32_t)> audioAccessorFunc = get_audio_array;
+        std::function<const int16_t*(const uint32_t)> audioAccessorFunc = GetAudioArray;
         if (ctx.Has("features")) {
-            audioAccessorFunc = ctx.Get<std::function<const int16_t* (const uint32_t)>>("features");
+            audioAccessorFunc = ctx.Get<std::function<const int16_t*(const uint32_t)>>("features");
         }
-        std::function<uint32_t (const uint32_t)> audioSizeAccessorFunc = get_audio_array_size;
+        std::function<uint32_t(const uint32_t)> audioSizeAccessorFunc = GetAudioArraySize;
         if (ctx.Has("featureSizes")) {
-            audioSizeAccessorFunc = ctx.Get<std::function<uint32_t (const uint32_t)>>("featureSizes");
+            audioSizeAccessorFunc =
+                ctx.Get<std::function<uint32_t(const uint32_t)>>("featureSizes");
         }
-        std::function<const char*(const uint32_t)> audioFileAccessorFunc = get_filename;
+        std::function<const char*(const uint32_t)> audioFileAccessorFunc = GetFilename;
         if (ctx.Has("featureFileNames")) {
-            audioFileAccessorFunc = ctx.Get<std::function<const char*(const uint32_t)>>("featureFileNames");
+            audioFileAccessorFunc =
+                ctx.Get<std::function<const char*(const uint32_t)>>("featureFileNames");
         }
         do {
             hal_lcd_clear(COLOR_BLACK);
 
             auto startDumpAddress = memDumpBaseAddr + memDumpBytesWritten;
-            auto currentIndex = ctx.Get<uint32_t>("clipIndex");
+            auto currentIndex     = ctx.Get<uint32_t>("clipIndex");
 
             /* Creating a sliding window through the audio. */
-            auto audioDataSlider = audio::SlidingWindow<const int16_t>(
-                    audioAccessorFunc(currentIndex),
-                    audioSizeAccessorFunc(currentIndex), audioFrameLen,
-                    audioFrameStride);
+            auto audioDataSlider =
+                audio::SlidingWindow<const int16_t>(audioAccessorFunc(currentIndex),
+                                                    audioSizeAccessorFunc(currentIndex),
+                                                    audioFrameLen,
+                                                    audioFrameStride);
 
-            info("Running inference on input feature map %" PRIu32 " => %s\n", currentIndex,
+            info("Running inference on input feature map %" PRIu32 " => %s\n",
+                 currentIndex,
                  audioFileAccessorFunc(currentIndex));
 
-            memDumpBytesWritten += DumpDenoisedAudioHeader(audioFileAccessorFunc(currentIndex),
-                                                           (audioDataSlider.TotalStrides() + 1) * audioFrameLen,
-                 memDumpBaseAddr + memDumpBytesWritten,
-                 memDumpMaxLen - memDumpBytesWritten);
+            memDumpBytesWritten +=
+                DumpDenoisedAudioHeader(audioFileAccessorFunc(currentIndex),
+                                        (audioDataSlider.TotalStrides() + 1) * audioFrameLen,
+                                        memDumpBaseAddr + memDumpBytesWritten,
+                                        memDumpMaxLen - memDumpBytesWritten);
 
             /* Set up pre and post-processing. */
             std::shared_ptr<rnn::RNNoiseFeatureProcessor> featureProcessor =
-                    std::make_shared<rnn::RNNoiseFeatureProcessor>();
+                std::make_shared<rnn::RNNoiseFeatureProcessor>();
             std::shared_ptr<rnn::FrameFeatures> frameFeatures =
-                    std::make_shared<rnn::FrameFeatures>();
+                std::make_shared<rnn::FrameFeatures>();
 
-            RNNoisePreProcess preProcess = RNNoisePreProcess(inputTensor, featureProcessor, frameFeatures);
+            RNNoisePreProcess preProcess =
+                RNNoisePreProcess(inputTensor, featureProcessor, frameFeatures);
 
             std::vector<int16_t> denoisedAudioFrame(audioFrameLen);
-            RNNoisePostProcess postProcess = RNNoisePostProcess(outputTensor, denoisedAudioFrame,
-                    featureProcessor, frameFeatures);
+            RNNoisePostProcess postProcess = RNNoisePostProcess(
+                outputTensor, denoisedAudioFrame, featureProcessor, frameFeatures);
 
             bool resetGRU = true;
 
@@ -133,11 +141,12 @@
                 }
 
                 /* Reset or copy over GRU states first to avoid TFLu memory overlap issues. */
-                if (resetGRU){
+                if (resetGRU) {
                     model.ResetGruState();
                 } else {
                     /* Copying gru state outputs to gru state inputs.
-                     * Call ResetGruState in between the sequence of inferences on unrelated input data. */
+                     * Call ResetGruState in between the sequence of inferences on unrelated input
+                     * data. */
                     model.CopyGruStates();
                 }
 
@@ -145,10 +154,15 @@
                 std::string str_inf{"Running inference... "};
 
                 /* Display message on the LCD - inference running. */
-                hal_lcd_display_text(str_inf.c_str(), str_inf.size(),
-                        dataPsnTxtInfStartX, dataPsnTxtInfStartY, false);
+                hal_lcd_display_text(str_inf.c_str(),
+                                     str_inf.size(),
+                                     dataPsnTxtInfStartX,
+                                     dataPsnTxtInfStartY,
+                                     false);
 
-                info("Inference %zu/%zu\n", audioDataSlider.Index() + 1, audioDataSlider.TotalStrides() + 1);
+                info("Inference %zu/%zu\n",
+                     audioDataSlider.Index() + 1,
+                     audioDataSlider.TotalStrides() + 1);
 
                 /* Run inference over this feature sliding window. */
                 if (!RunInference(model, profiler)) {
@@ -165,15 +179,18 @@
 
                 /* Erase. */
                 str_inf = std::string(str_inf.size(), ' ');
-                hal_lcd_display_text(str_inf.c_str(), str_inf.size(),
-                        dataPsnTxtInfStartX, dataPsnTxtInfStartY, false);
+                hal_lcd_display_text(str_inf.c_str(),
+                                     str_inf.size(),
+                                     dataPsnTxtInfStartX,
+                                     dataPsnTxtInfStartY,
+                                     false);
 
                 if (memDumpMaxLen > 0) {
                     /* Dump final post processed output to memory. */
-                    memDumpBytesWritten += DumpOutputDenoisedAudioFrame(
-                            denoisedAudioFrame,
-                            memDumpBaseAddr + memDumpBytesWritten,
-                            memDumpMaxLen - memDumpBytesWritten);
+                    memDumpBytesWritten +=
+                        DumpOutputDenoisedAudioFrame(denoisedAudioFrame,
+                                                     memDumpBaseAddr + memDumpBytesWritten,
+                                                     memDumpMaxLen - memDumpBytesWritten);
                 }
             }
 
@@ -181,43 +198,54 @@
                 /* Needed to not let the compiler complain about type mismatch. */
                 size_t valMemDumpBytesWritten = memDumpBytesWritten;
                 info("Output memory dump of %zu bytes written at address 0x%p\n",
-                     valMemDumpBytesWritten, startDumpAddress);
+                     valMemDumpBytesWritten,
+                     startDumpAddress);
             }
 
             /* Finish by dumping the footer. */
-            DumpDenoisedAudioFooter(memDumpBaseAddr + memDumpBytesWritten, memDumpMaxLen - memDumpBytesWritten);
+            DumpDenoisedAudioFooter(memDumpBaseAddr + memDumpBytesWritten,
+                                    memDumpMaxLen - memDumpBytesWritten);
 
             info("All inferences for audio clip complete.\n");
             profiler.PrintProfilingResult();
             IncrementAppCtxClipIdx(ctx);
 
             std::string clearString{' '};
-            hal_lcd_display_text(clearString.c_str(), clearString.size(),
-                    dataPsnTxtInfStartX, dataPsnTxtInfStartY, false);
+            hal_lcd_display_text(clearString.c_str(),
+                                 clearString.size(),
+                                 dataPsnTxtInfStartX,
+                                 dataPsnTxtInfStartY,
+                                 false);
 
             std::string completeMsg{"Inference complete!"};
 
             /* Display message on the LCD - inference complete. */
-            hal_lcd_display_text(completeMsg.c_str(), completeMsg.size(),
-                    dataPsnTxtInfStartX, dataPsnTxtInfStartY, false);
+            hal_lcd_display_text(completeMsg.c_str(),
+                                 completeMsg.size(),
+                                 dataPsnTxtInfStartX,
+                                 dataPsnTxtInfStartY,
+                                 false);
 
         } while (runAll && ctx.Get<uint32_t>("clipIndex") != startClipIdx);
 
         return true;
     }
 
-    size_t DumpDenoisedAudioHeader(const char* filename, size_t dumpSize,
-                                   uint8_t* memAddress, size_t memSize){
+    size_t DumpDenoisedAudioHeader(const char* filename,
+                                   size_t dumpSize,
+                                   uint8_t* memAddress,
+                                   size_t memSize)
+    {
 
-        if (memAddress == nullptr){
+        if (memAddress == nullptr) {
             return 0;
         }
 
         int32_t filenameLength = strlen(filename);
         size_t numBytesWritten = 0;
         size_t numBytesToWrite = 0;
-        int32_t dumpSizeByte = dumpSize * sizeof(int16_t);
-        bool overflow = false;
+        int32_t dumpSizeByte   = dumpSize * sizeof(int16_t);
+        bool overflow          = false;
 
         /* Write the filename length */
         numBytesToWrite = sizeof(filenameLength);
@@ -231,7 +259,7 @@
 
         /* Write file name */
         numBytesToWrite = filenameLength;
-        if(memSize - numBytesToWrite > 0) {
+        if (memSize - numBytesToWrite > 0) {
             std::memcpy(memAddress + numBytesWritten, filename, numBytesToWrite);
             numBytesWritten += numBytesToWrite;
             memSize -= numBytesWritten;
@@ -241,7 +269,7 @@
 
         /* Write dumpSize in byte */
         numBytesToWrite = sizeof(dumpSizeByte);
-        if(memSize  - numBytesToWrite > 0) {
+        if (memSize - numBytesToWrite > 0) {
             std::memcpy(memAddress + numBytesWritten, &(dumpSizeByte), numBytesToWrite);
             numBytesWritten += numBytesToWrite;
             memSize -= numBytesWritten;
@@ -249,8 +277,10 @@
             overflow = true;
         }
 
-        if(false == overflow) {
-            info("Audio Clip dump header info (%zu bytes) written to %p\n", numBytesWritten,  memAddress);
+        if (false == overflow) {
+            info("Audio Clip dump header info (%zu bytes) written to %p\n",
+                 numBytesWritten,
+                 memAddress);
         } else {
             printf_err("Not enough memory to dump Audio Clip header.\n");
         }
@@ -258,7 +288,8 @@
         return numBytesWritten;
     }
 
-    size_t DumpDenoisedAudioFooter(uint8_t* memAddress, size_t memSize){
+    size_t DumpDenoisedAudioFooter(uint8_t* memAddress, size_t memSize)
+    {
         if ((memAddress == nullptr) || (memSize < 4)) {
             return 0;
         }
@@ -266,23 +297,27 @@
         std::memcpy(memAddress, &eofMarker, sizeof(int32_t));
 
         return sizeof(int32_t);
-     }
+    }
 
     size_t DumpOutputDenoisedAudioFrame(const std::vector<int16_t>& audioFrame,
-                                        uint8_t* memAddress, size_t memSize)
+                                        uint8_t* memAddress,
+                                        size_t memSize)
     {
         if (memAddress == nullptr) {
             return 0;
         }
 
         size_t numByteToBeWritten = audioFrame.size() * sizeof(int16_t);
-        if( numByteToBeWritten > memSize) {
-            printf_err("Overflow error: Writing %zu of %zu bytes to memory @ 0x%p.\n", memSize, numByteToBeWritten, memAddress);
+        if (numByteToBeWritten > memSize) {
+            printf_err("Overflow error: Writing %zu of %zu bytes to memory @ 0x%p.\n",
+                       memSize,
+                       numByteToBeWritten,
+                       memAddress);
             numByteToBeWritten = memSize;
         }
 
         std::memcpy(memAddress, audioFrame.data(), numByteToBeWritten);
-        info("Copied %zu bytes to %p\n", numByteToBeWritten,  memAddress);
+        info("Copied %zu bytes to %p\n", numByteToBeWritten, memAddress);
 
         return numByteToBeWritten;
     }
@@ -290,13 +325,13 @@
     size_t DumpOutputTensorsToMemory(Model& model, uint8_t* memAddress, const size_t memSize)
     {
         const size_t numOutputs = model.GetNumOutputs();
-        size_t numBytesWritten = 0;
-        uint8_t* ptr = memAddress;
+        size_t numBytesWritten  = 0;
+        uint8_t* ptr            = memAddress;
 
         /* Iterate over all output tensors. */
         for (size_t i = 0; i < numOutputs; ++i) {
             const TfLiteTensor* tensor = model.GetOutputTensor(i);
-            const auto* tData = tflite::GetTensorData<uint8_t>(tensor);
+            const auto* tData          = tflite::GetTensorData<uint8_t>(tensor);
 #if VERIFY_TEST_OUTPUT
             DumpTensor(tensor);
 #endif /* VERIFY_TEST_OUTPUT */
@@ -305,15 +340,13 @@
                 if (tensor->bytes > 0) {
                     std::memcpy(ptr, tData, tensor->bytes);
 
-                    info("Copied %zu bytes for tensor %zu to 0x%p\n",
-                        tensor->bytes, i, ptr);
+                    info("Copied %zu bytes for tensor %zu to 0x%p\n", tensor->bytes, i, ptr);
 
                     numBytesWritten += tensor->bytes;
                     ptr += tensor->bytes;
                 }
             } else {
-                printf_err("Error writing tensor %zu to memory @ 0x%p\n",
-                    i, memAddress);
+                printf_err("Error writing tensor %zu to memory @ 0x%p\n", i, memAddress);
                 break;
             }
         }
diff --git a/source/use_case/object_detection/src/UseCaseHandler.cc b/source/use_case/object_detection/src/UseCaseHandler.cc
index 084059e..9330187 100644
--- a/source/use_case/object_detection/src/UseCaseHandler.cc
+++ b/source/use_case/object_detection/src/UseCaseHandler.cc
@@ -1,6 +1,6 @@
 /*
- * SPDX-FileCopyrightText: Copyright 2022 Arm Limited and/or its affiliates <open-source-office@arm.com>
- * SPDX-License-Identifier: Apache-2.0
+ * SPDX-FileCopyrightText: Copyright 2022 Arm Limited and/or its affiliates
+ * <open-source-office@arm.com> SPDX-License-Identifier: Apache-2.0
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -15,11 +15,11 @@
  * limitations under the License.
  */
 #include "UseCaseHandler.hpp"
-#include "InputFiles.hpp"
-#include "YoloFastestModel.hpp"
-#include "UseCaseCommonUtils.hpp"
 #include "DetectorPostProcessing.hpp"
 #include "DetectorPreProcessing.hpp"
+#include "InputFiles.hpp"
+#include "UseCaseCommonUtils.hpp"
+#include "YoloFastestModel.hpp"
 #include "hal.h"
 #include "log_macros.h"
 
@@ -34,7 +34,8 @@
      * @param[in]       results            Vector of detection results to be displayed.
      * @return          true if successful, false otherwise.
      **/
-    static bool PresentInferenceResult(const std::vector<object_detection::DetectionResult>& results);
+    static bool
+    PresentInferenceResult(const std::vector<object_detection::DetectionResult>& results);
 
     /**
      * @brief           Draw boxes directly on the LCD for all detected objects.
@@ -43,11 +44,10 @@
      * @param[in]       imageStartY        Y coordinate where the image starts on the LCD.
      * @param[in]       imgDownscaleFactor How much image has been downscaled on LCD.
      **/
-    static void DrawDetectionBoxes(
-           const std::vector<object_detection::DetectionResult>& results,
-           uint32_t imgStartX,
-           uint32_t imgStartY,
-           uint32_t imgDownscaleFactor);
+    static void DrawDetectionBoxes(const std::vector<object_detection::DetectionResult>& results,
+                                   uint32_t imgStartX,
+                                   uint32_t imgStartY,
+                                   uint32_t imgDownscaleFactor);
 
     /* Object detection inference handler. */
     bool ObjectDetectionHandler(ApplicationContext& ctx, uint32_t imgIndex, bool runAll)
@@ -55,8 +55,8 @@
         auto& profiler = ctx.Get<Profiler&>("profiler");
 
         constexpr uint32_t dataPsnImgDownscaleFactor = 1;
-        constexpr uint32_t dataPsnImgStartX = 10;
-        constexpr uint32_t dataPsnImgStartY = 35;
+        constexpr uint32_t dataPsnImgStartX          = 10;
+        constexpr uint32_t dataPsnImgStartY          = 35;
 
         constexpr uint32_t dataPsnTxtInfStartX = 20;
         constexpr uint32_t dataPsnTxtInfStartY = 28;
@@ -78,7 +78,7 @@
 
         auto initialImgIdx = ctx.Get<uint32_t>("imgIndex");
 
-        TfLiteTensor* inputTensor = model.GetInputTensor(0);
+        TfLiteTensor* inputTensor   = model.GetInputTensor(0);
         TfLiteTensor* outputTensor0 = model.GetOutputTensor(0);
         TfLiteTensor* outputTensor1 = model.GetOutputTensor(1);
 
@@ -99,12 +99,14 @@
         DetectorPreProcess preProcess = DetectorPreProcess(inputTensor, true, model.IsDataSigned());
 
         std::vector<object_detection::DetectionResult> results;
-        const object_detection::PostProcessParams postProcessParams {
-            inputImgRows, inputImgCols, object_detection::originalImageSize,
-            object_detection::anchor1, object_detection::anchor2
-        };
-        DetectorPostProcess postProcess = DetectorPostProcess(outputTensor0, outputTensor1,
-                results, postProcessParams);
+        const object_detection::PostProcessParams postProcessParams{
+            inputImgRows,
+            inputImgCols,
+            object_detection::originalImageSize,
+            object_detection::anchor1,
+            object_detection::anchor2};
+        DetectorPostProcess postProcess =
+            DetectorPostProcess(outputTensor0, outputTensor1, results, postProcessParams);
         do {
             /* Ensure there are no results leftover from previous inference when running all. */
             results.clear();
@@ -112,11 +114,11 @@
             /* Strings for presentation/logging. */
             std::string str_inf{"Running inference... "};
 
-            const uint8_t* currImage = get_img_array(ctx.Get<uint32_t>("imgIndex"));
+            const uint8_t* currImage = GetImgArray(ctx.Get<uint32_t>("imgIndex"));
 
             auto dstPtr = static_cast<uint8_t*>(inputTensor->data.uint8);
-            const size_t copySz = inputTensor->bytes < IMAGE_DATA_SIZE ?
-                                inputTensor->bytes : IMAGE_DATA_SIZE;
+            const size_t copySz =
+                inputTensor->bytes < IMAGE_DATA_SIZE ? inputTensor->bytes : IMAGE_DATA_SIZE;
 
             /* Run the pre-processing, inference and post-processing. */
             if (!preProcess.DoPreProcess(currImage, copySz)) {
@@ -135,12 +137,13 @@
                 dataPsnImgDownscaleFactor);
 
             /* Display message on the LCD - inference running. */
-            hal_lcd_display_text(str_inf.c_str(), str_inf.size(),
-                    dataPsnTxtInfStartX, dataPsnTxtInfStartY, false);
+            hal_lcd_display_text(
+                str_inf.c_str(), str_inf.size(), dataPsnTxtInfStartX, dataPsnTxtInfStartY, false);
 
             /* Run inference over this image. */
-            info("Running inference on image %" PRIu32 " => %s\n", ctx.Get<uint32_t>("imgIndex"),
-                get_filename(ctx.Get<uint32_t>("imgIndex")));
+            info("Running inference on image %" PRIu32 " => %s\n",
+                 ctx.Get<uint32_t>("imgIndex"),
+                 GetFilename(ctx.Get<uint32_t>("imgIndex")));
 
             if (!RunInference(model, profiler)) {
                 printf_err("Inference failed.");
@@ -154,11 +157,12 @@
 
             /* Erase. */
             str_inf = std::string(str_inf.size(), ' ');
-            hal_lcd_display_text(str_inf.c_str(), str_inf.size(),
-                                 dataPsnTxtInfStartX, dataPsnTxtInfStartY, false);
+            hal_lcd_display_text(
+                str_inf.c_str(), str_inf.size(), dataPsnTxtInfStartX, dataPsnTxtInfStartY, false);
 
             /* Draw boxes. */
-            DrawDetectionBoxes(results, dataPsnImgStartX, dataPsnImgStartY, dataPsnImgDownscaleFactor);
+            DrawDetectionBoxes(
+                results, dataPsnImgStartX, dataPsnImgStartY, dataPsnImgDownscaleFactor);
 
 #if VERIFY_TEST_OUTPUT
             DumpTensor(modelOutput0);
@@ -171,14 +175,15 @@
 
             profiler.PrintProfilingResult();
 
-            IncrementAppCtxIfmIdx(ctx,"imgIndex");
+            IncrementAppCtxIfmIdx(ctx, "imgIndex");
 
         } while (runAll && ctx.Get<uint32_t>("imgIndex") != initialImgIdx);
 
         return true;
     }
 
-    static bool PresentInferenceResult(const std::vector<object_detection::DetectionResult>& results)
+    static bool
+    PresentInferenceResult(const std::vector<object_detection::DetectionResult>& results)
     {
         hal_lcd_set_text_color(COLOR_GREEN);
 
@@ -187,9 +192,14 @@
         info("Total number of inferences: 1\n");
 
         for (uint32_t i = 0; i < results.size(); ++i) {
-            info("%" PRIu32 ") (%f) -> %s {x=%d,y=%d,w=%d,h=%d}\n", i,
-                results[i].m_normalisedVal, "Detection box:",
-                results[i].m_x0, results[i].m_y0, results[i].m_w, results[i].m_h );
+            info("%" PRIu32 ") (%f) -> %s {x=%d,y=%d,w=%d,h=%d}\n",
+                 i,
+                 results[i].m_normalisedVal,
+                 "Detection box:",
+                 results[i].m_x0,
+                 results[i].m_y0,
+                 results[i].m_w,
+                 results[i].m_h);
         }
 
         return true;
@@ -202,24 +212,34 @@
     {
         uint32_t lineThickness = 1;
 
-        for (const auto& result: results) {
+        for (const auto& result : results) {
             /* Top line. */
-            hal_lcd_display_box(imgStartX + result.m_x0/imgDownscaleFactor,
-                    imgStartY + result.m_y0/imgDownscaleFactor,
-                    result.m_w/imgDownscaleFactor, lineThickness, COLOR_GREEN);
+            hal_lcd_display_box(imgStartX + result.m_x0 / imgDownscaleFactor,
+                                imgStartY + result.m_y0 / imgDownscaleFactor,
+                                result.m_w / imgDownscaleFactor,
+                                lineThickness,
+                                COLOR_GREEN);
             /* Bot line. */
-            hal_lcd_display_box(imgStartX + result.m_x0/imgDownscaleFactor,
-                    imgStartY + (result.m_y0 + result.m_h)/imgDownscaleFactor - lineThickness,
-                    result.m_w/imgDownscaleFactor, lineThickness, COLOR_GREEN);
+            hal_lcd_display_box(imgStartX + result.m_x0 / imgDownscaleFactor,
+                                imgStartY + (result.m_y0 + result.m_h) / imgDownscaleFactor -
+                                    lineThickness,
+                                result.m_w / imgDownscaleFactor,
+                                lineThickness,
+                                COLOR_GREEN);
 
             /* Left line. */
-            hal_lcd_display_box(imgStartX + result.m_x0/imgDownscaleFactor,
-                    imgStartY + result.m_y0/imgDownscaleFactor,
-                    lineThickness, result.m_h/imgDownscaleFactor, COLOR_GREEN);
+            hal_lcd_display_box(imgStartX + result.m_x0 / imgDownscaleFactor,
+                                imgStartY + result.m_y0 / imgDownscaleFactor,
+                                lineThickness,
+                                result.m_h / imgDownscaleFactor,
+                                COLOR_GREEN);
             /* Right line. */
-            hal_lcd_display_box(imgStartX + (result.m_x0 + result.m_w)/imgDownscaleFactor - lineThickness,
-                    imgStartY + result.m_y0/imgDownscaleFactor,
-                    lineThickness, result.m_h/imgDownscaleFactor, COLOR_GREEN);
+            hal_lcd_display_box(imgStartX + (result.m_x0 + result.m_w) / imgDownscaleFactor -
+                                    lineThickness,
+                                imgStartY + result.m_y0 / imgDownscaleFactor,
+                                lineThickness,
+                                result.m_h / imgDownscaleFactor,
+                                COLOR_GREEN);
         }
     }
 
diff --git a/source/use_case/vww/src/UseCaseHandler.cc b/source/use_case/vww/src/UseCaseHandler.cc
index e2e48d1..4704c97 100644
--- a/source/use_case/vww/src/UseCaseHandler.cc
+++ b/source/use_case/vww/src/UseCaseHandler.cc
@@ -1,6 +1,6 @@
 /*
- * SPDX-FileCopyrightText: Copyright 2021-2022  Arm Limited and/or its affiliates <open-source-office@arm.com>
- * SPDX-License-Identifier: Apache-2.0
+ * SPDX-FileCopyrightText: Copyright 2021-2022  Arm Limited and/or its affiliates
+ * <open-source-office@arm.com> SPDX-License-Identifier: Apache-2.0
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -15,34 +15,34 @@
  * limitations under the License.
  */
 #include "UseCaseHandler.hpp"
-#include "VisualWakeWordModel.hpp"
 #include "Classifier.hpp"
-#include "InputFiles.hpp"
 #include "ImageUtils.hpp"
+#include "InputFiles.hpp"
 #include "UseCaseCommonUtils.hpp"
+#include "VisualWakeWordModel.hpp"
+#include "VisualWakeWordProcessing.hpp"
 #include "hal.h"
 #include "log_macros.h"
-#include "VisualWakeWordProcessing.hpp"
 
 namespace arm {
 namespace app {
 
     /* Visual Wake Word inference handler. */
-    bool ClassifyImageHandler(ApplicationContext &ctx, uint32_t imgIndex, bool runAll)
+    bool ClassifyImageHandler(ApplicationContext& ctx, uint32_t imgIndex, bool runAll)
     {
         auto& profiler = ctx.Get<Profiler&>("profiler");
-        auto& model = ctx.Get<Model&>("model");
+        auto& model    = ctx.Get<Model&>("model");
         /* If the request has a valid size, set the image index. */
         if (imgIndex < NUMBER_OF_FILES) {
-            if (!SetAppCtxIfmIdx(ctx, imgIndex,"imgIndex")) {
+            if (!SetAppCtxIfmIdx(ctx, imgIndex, "imgIndex")) {
                 return false;
             }
         }
         auto initialImgIdx = ctx.Get<uint32_t>("imgIndex");
 
         constexpr uint32_t dataPsnImgDownscaleFactor = 1;
-        constexpr uint32_t dataPsnImgStartX = 10;
-        constexpr uint32_t dataPsnImgStartY = 35;
+        constexpr uint32_t dataPsnImgStartX          = 10;
+        constexpr uint32_t dataPsnImgStartY          = 35;
 
         constexpr uint32_t dataPsnTxtInfStartX = 150;
         constexpr uint32_t dataPsnTxtInfStartY = 40;
@@ -52,7 +52,7 @@
             return false;
         }
 
-        TfLiteTensor* inputTensor = model.GetInputTensor(0);
+        TfLiteTensor* inputTensor  = model.GetInputTensor(0);
         TfLiteTensor* outputTensor = model.GetOutputTensor(0);
         if (!inputTensor->dims) {
             printf_err("Invalid input tensor dims\n");
@@ -66,7 +66,8 @@
         TfLiteIntArray* inputShape = model.GetInputShape(0);
         const uint32_t nCols = inputShape->data[arm::app::VisualWakeWordModel::ms_inputColsIdx];
         const uint32_t nRows = inputShape->data[arm::app::VisualWakeWordModel::ms_inputRowsIdx];
-        if (arm::app::VisualWakeWordModel::ms_inputChannelsIdx >= static_cast<uint32_t>(inputShape->size)) {
+        if (arm::app::VisualWakeWordModel::ms_inputChannelsIdx >=
+            static_cast<uint32_t>(inputShape->size)) {
             printf_err("Invalid channel index.\n");
             return false;
         }
@@ -78,9 +79,11 @@
         VisualWakeWordPreProcess preProcess = VisualWakeWordPreProcess(inputTensor);
 
         std::vector<ClassificationResult> results;
-        VisualWakeWordPostProcess postProcess = VisualWakeWordPostProcess(outputTensor,
-                ctx.Get<Classifier&>("classifier"),
-                ctx.Get<std::vector<std::string>&>("labels"), results);
+        VisualWakeWordPostProcess postProcess =
+            VisualWakeWordPostProcess(outputTensor,
+                                      ctx.Get<Classifier&>("classifier"),
+                                      ctx.Get<std::vector<std::string>&>("labels"),
+                                      results);
 
         do {
             hal_lcd_clear(COLOR_BLACK);
@@ -88,29 +91,34 @@
             /* Strings for presentation/logging. */
             std::string str_inf{"Running inference... "};
 
-            const uint8_t* imgSrc = get_img_array(ctx.Get<uint32_t>("imgIndex"));
+            const uint8_t* imgSrc = GetImgArray(ctx.Get<uint32_t>("imgIndex"));
             if (nullptr == imgSrc) {
-                printf_err("Failed to get image index %" PRIu32 " (max: %u)\n", ctx.Get<uint32_t>("imgIndex"),
+                printf_err("Failed to get image index %" PRIu32 " (max: %u)\n",
+                           ctx.Get<uint32_t>("imgIndex"),
                            NUMBER_OF_FILES - 1);
                 return false;
             }
 
             /* Display this image on the LCD. */
-            hal_lcd_display_image(
-                imgSrc,
-                nCols, nRows, displayChannels,
-                dataPsnImgStartX, dataPsnImgStartY, dataPsnImgDownscaleFactor);
+            hal_lcd_display_image(imgSrc,
+                                  nCols,
+                                  nRows,
+                                  displayChannels,
+                                  dataPsnImgStartX,
+                                  dataPsnImgStartY,
+                                  dataPsnImgDownscaleFactor);
 
             /* Display message on the LCD - inference running. */
-            hal_lcd_display_text(str_inf.c_str(), str_inf.size(),
-                                dataPsnTxtInfStartX, dataPsnTxtInfStartY, 0);
+            hal_lcd_display_text(
+                str_inf.c_str(), str_inf.size(), dataPsnTxtInfStartX, dataPsnTxtInfStartY, 0);
 
             /* Run inference over this image. */
-            info("Running inference on image %" PRIu32 " => %s\n", ctx.Get<uint32_t>("imgIndex"),
-                get_filename(ctx.Get<uint32_t>("imgIndex")));
+            info("Running inference on image %" PRIu32 " => %s\n",
+                 ctx.Get<uint32_t>("imgIndex"),
+                 GetFilename(ctx.Get<uint32_t>("imgIndex")));
 
-            const size_t imgSz = inputTensor->bytes < IMAGE_DATA_SIZE ?
-                                 inputTensor->bytes : IMAGE_DATA_SIZE;
+            const size_t imgSz =
+                inputTensor->bytes < IMAGE_DATA_SIZE ? inputTensor->bytes : IMAGE_DATA_SIZE;
 
             /* Run the pre-processing, inference and post-processing. */
             if (!preProcess.DoPreProcess(imgSrc, imgSz)) {
@@ -130,8 +138,8 @@
 
             /* Erase. */
             str_inf = std::string(str_inf.size(), ' ');
-            hal_lcd_display_text(str_inf.c_str(), str_inf.size(),
-                                 dataPsnTxtInfStartX, dataPsnTxtInfStartY, 0);
+            hal_lcd_display_text(
+                str_inf.c_str(), str_inf.size(), dataPsnTxtInfStartX, dataPsnTxtInfStartY, 0);
 
             /* Add results to context for access outside handler. */
             ctx.Set<std::vector<ClassificationResult>>("results", results);
@@ -146,7 +154,7 @@
 
             profiler.PrintProfilingResult();
 
-            IncrementAppCtxIfmIdx(ctx,"imgIndex");
+            IncrementAppCtxIfmIdx(ctx, "imgIndex");
 
         } while (runAll && ctx.Get<uint32_t>("imgIndex") != initialImgIdx);
 
diff --git a/tests/use_case/ad/InferenceTestAD.cc b/tests/use_case/ad/InferenceTestAD.cc
index e02e923..4991a30 100644
--- a/tests/use_case/ad/InferenceTestAD.cc
+++ b/tests/use_case/ad/InferenceTestAD.cc
@@ -1,6 +1,6 @@
 /*
- * SPDX-FileCopyrightText: Copyright 2021 Arm Limited and/or its affiliates <open-source-office@arm.com>
- * SPDX-License-Identifier: Apache-2.0
+ * SPDX-FileCopyrightText: Copyright 2021 Arm Limited and/or its affiliates
+ * <open-source-office@arm.com> SPDX-License-Identifier: Apache-2.0
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -19,10 +19,10 @@
 #include <random>
 
 #include "AdModel.hpp"
+#include "BufAttributes.hpp"
+#include "TensorFlowLiteMicro.hpp"
 #include "TestData_ad.hpp"
 #include "log_macros.h"
-#include "TensorFlowLiteMicro.hpp"
-#include "BufAttributes.hpp"
 
 #ifndef AD_FEATURE_VEC_DATA_SIZE
 #define AD_IN_FEATURE_VEC_DATA_SIZE (1024)
@@ -42,10 +42,12 @@
 
 bool RunInference(arm::app::Model& model, const int8_t vec[])
 {
-    TfLiteTensor *inputTensor = model.GetInputTensor(0);
+    TfLiteTensor* inputTensor = model.GetInputTensor(0);
     REQUIRE(inputTensor);
 
-    const size_t copySz = inputTensor->bytes < AD_IN_FEATURE_VEC_DATA_SIZE ? inputTensor->bytes : AD_IN_FEATURE_VEC_DATA_SIZE;
+    const size_t copySz = inputTensor->bytes < AD_IN_FEATURE_VEC_DATA_SIZE
+                              ? inputTensor->bytes
+                              : AD_IN_FEATURE_VEC_DATA_SIZE;
 
     memcpy(inputTensor->data.data, vec, copySz);
 
@@ -54,16 +56,14 @@
 
 bool RunInferenceRandom(arm::app::Model& model)
 {
-    TfLiteTensor *inputTensor = model.GetInputTensor(0);
+    TfLiteTensor* inputTensor = model.GetInputTensor(0);
     REQUIRE(inputTensor);
 
     std::random_device rndDevice;
     std::mt19937 mersenneGen{rndDevice()};
     std::uniform_int_distribution<short> dist{-128, 127};
 
-    auto gen = [&dist, &mersenneGen]() {
-        return dist(mersenneGen);
-    };
+    auto gen = [&dist, &mersenneGen]() { return dist(mersenneGen); };
 
     std::vector<int8_t> randomInput(inputTensor->bytes);
     std::generate(std::begin(randomInput), std::end(randomInput), gen);
@@ -73,19 +73,18 @@
 }
 
 template <typename T>
-void TestInference(const T *input_goldenFV, const T *output_goldenFV, arm::app::Model& model)
+void TestInference(const T* input_goldenFV, const T* output_goldenFV, arm::app::Model& model)
 {
     REQUIRE(RunInference(model, static_cast<const T*>(input_goldenFV)));
 
-    TfLiteTensor *outputTensor = model.GetOutputTensor(0);
+    TfLiteTensor* outputTensor = model.GetOutputTensor(0);
 
     REQUIRE(outputTensor);
     REQUIRE(outputTensor->bytes == OFM_0_DATA_SIZE);
     auto tensorData = tflite::GetTensorData<T>(outputTensor);
     REQUIRE(tensorData);
 
-    for (size_t i = 0; i < outputTensor->bytes; i++)
-    {
+    for (size_t i = 0; i < outputTensor->bytes; i++) {
         REQUIRE(static_cast<int>(tensorData[i]) == static_cast<int>(((T)output_goldenFV[i])));
     }
 }
@@ -107,9 +106,10 @@
 TEST_CASE("Running golden vector inference with TensorFlow Lite Micro and AdModel Int8", "[AD]")
 {
     REQUIRE(NUMBER_OF_IFM_FILES == NUMBER_OF_IFM_FILES);
-    for (uint32_t i = 0 ; i < NUMBER_OF_IFM_FILES; ++i) {
-        auto input_goldenFV = get_ifm_data_array(i);;
-        auto output_goldenFV = get_ofm_data_array(i);
+    for (uint32_t i = 0; i < NUMBER_OF_IFM_FILES; ++i) {
+        auto input_goldenFV = GetIfmDataArray(i);
+        ;
+        auto output_goldenFV = GetOfmDataArray(i);
 
         DYNAMIC_SECTION("Executing inference with re-init")
         {
@@ -123,7 +123,6 @@
             REQUIRE(model.IsInited());
 
             TestInference<int8_t>(input_goldenFV, output_goldenFV, model);
-
         }
     }
 }
diff --git a/tests/use_case/asr/InferenceTestWav2Letter.cc b/tests/use_case/asr/InferenceTestWav2Letter.cc
index e6012c3..991617c 100644
--- a/tests/use_case/asr/InferenceTestWav2Letter.cc
+++ b/tests/use_case/asr/InferenceTestWav2Letter.cc
@@ -1,6 +1,6 @@
 /*
- * SPDX-FileCopyrightText: Copyright 2021 Arm Limited and/or its affiliates <open-source-office@arm.com>
- * SPDX-License-Identifier: Apache-2.0
+ * SPDX-FileCopyrightText: Copyright 2021 Arm Limited and/or its affiliates
+ * <open-source-office@arm.com> SPDX-License-Identifier: Apache-2.0
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -14,10 +14,10 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-#include "TensorFlowLiteMicro.hpp"
-#include "Wav2LetterModel.hpp"
-#include "TestData_asr.hpp"
 #include "BufAttributes.hpp"
+#include "TensorFlowLiteMicro.hpp"
+#include "TestData_asr.hpp"
+#include "Wav2LetterModel.hpp"
 
 #include <catch.hpp>
 #include <random>
@@ -51,11 +51,9 @@
 
     std::random_device rndDevice;
     std::mt19937 mersenneGen{rndDevice()};
-    std::uniform_int_distribution<short> dist {-128, 127};
+    std::uniform_int_distribution<short> dist{-128, 127};
 
-    auto gen = [&dist, &mersenneGen](){
-                   return dist(mersenneGen);
-               };
+    auto gen = [&dist, &mersenneGen]() { return dist(mersenneGen); };
 
     std::vector<int8_t> randomAudio(inputTensor->bytes);
     std::generate(std::begin(randomAudio), std::end(randomAudio), gen);
@@ -64,21 +62,22 @@
     return true;
 }
 
-TEST_CASE("Running random inference with TensorFlow Lite Micro and Wav2LetterModel Int8", "[Wav2Letter]")
+TEST_CASE("Running random inference with TensorFlow Lite Micro and Wav2LetterModel Int8",
+          "[Wav2Letter]")
 {
     arm::app::Wav2LetterModel model{};
 
     REQUIRE_FALSE(model.IsInited());
     REQUIRE(model.Init(arm::app::tensorArena,
-                    sizeof(arm::app::tensorArena),
-                    arm::app::asr::GetModelPointer(),
-                    arm::app::asr::GetModelLen()));
+                       sizeof(arm::app::tensorArena),
+                       arm::app::asr::GetModelPointer(),
+                       arm::app::asr::GetModelLen()));
     REQUIRE(model.IsInited());
 
     REQUIRE(RunInferenceRandom(model));
 }
 
-template<typename T>
+template <typename T>
 void TestInference(const T* input_goldenFV, const T* output_goldenFV, arm::app::Model& model)
 {
     TfLiteTensor* inputTensor = model.GetInputTensor(0);
@@ -101,9 +100,10 @@
 TEST_CASE("Running inference with Tflu and Wav2LetterModel Int8", "[Wav2Letter]")
 {
     REQUIRE(NUMBER_OF_IFM_FILES == NUMBER_OF_IFM_FILES);
-    for (uint32_t i = 0 ; i < NUMBER_OF_IFM_FILES; ++i) {
-        auto input_goldenFV = get_ifm_data_array(i);;
-        auto output_goldenFV = get_ofm_data_array(i);
+    for (uint32_t i = 0; i < NUMBER_OF_IFM_FILES; ++i) {
+        auto input_goldenFV = GetIfmDataArray(i);
+        ;
+        auto output_goldenFV = GetOfmDataArray(i);
 
         DYNAMIC_SECTION("Executing inference with re-init")
         {
@@ -111,13 +111,12 @@
 
             REQUIRE_FALSE(model.IsInited());
             REQUIRE(model.Init(arm::app::tensorArena,
-                    sizeof(arm::app::tensorArena),
-                    arm::app::asr::GetModelPointer(),
-                    arm::app::asr::GetModelLen()));
+                               sizeof(arm::app::tensorArena),
+                               arm::app::asr::GetModelPointer(),
+                               arm::app::asr::GetModelLen()));
             REQUIRE(model.IsInited());
 
             TestInference<int8_t>(input_goldenFV, output_goldenFV, model);
-
         }
     }
 }
diff --git a/tests/use_case/img_class/InferenceTestMobilenetV2.cc b/tests/use_case/img_class/InferenceTestMobilenetV2.cc
index 7921959..09eba00 100644
--- a/tests/use_case/img_class/InferenceTestMobilenetV2.cc
+++ b/tests/use_case/img_class/InferenceTestMobilenetV2.cc
@@ -1,6 +1,6 @@
 /*
- * SPDX-FileCopyrightText: Copyright 2021-2022 Arm Limited and/or its affiliates <open-source-office@arm.com>
- * SPDX-License-Identifier: Apache-2.0
+ * SPDX-FileCopyrightText: Copyright 2021-2022 Arm Limited and/or its affiliates
+ * <open-source-office@arm.com> SPDX-License-Identifier: Apache-2.0
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -14,22 +14,22 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
+#include "BufAttributes.hpp"
 #include "ImageUtils.hpp"
 #include "MobileNetModel.hpp"
 #include "TensorFlowLiteMicro.hpp"
 #include "TestData_img_class.hpp"
-#include "BufAttributes.hpp"
 
 #include <catch.hpp>
 
 namespace arm {
-    namespace app {
-        static uint8_t tensorArena[ACTIVATION_BUF_SZ] ACTIVATION_BUF_ATTRIBUTE;
-        namespace img_class {
-            extern uint8_t* GetModelPointer();
-            extern size_t GetModelLen();
-        } /* namespace img_class */
-    } /* namespace app */
+namespace app {
+    static uint8_t tensorArena[ACTIVATION_BUF_SZ] ACTIVATION_BUF_ATTRIBUTE;
+    namespace img_class {
+        extern uint8_t* GetModelPointer();
+        extern size_t GetModelLen();
+    } /* namespace img_class */
+} /* namespace app */
 } /* namespace arm */
 
 using namespace test;
@@ -39,22 +39,22 @@
     TfLiteTensor* inputTensor = model.GetInputTensor(0);
     REQUIRE(inputTensor);
 
-    const size_t copySz = inputTensor->bytes < IFM_0_DATA_SIZE ?
-                            inputTensor->bytes :
-                            IFM_0_DATA_SIZE;
+    const size_t copySz =
+        inputTensor->bytes < IFM_0_DATA_SIZE ? inputTensor->bytes : IFM_0_DATA_SIZE;
     memcpy(inputTensor->data.data, imageData, copySz);
 
-    if(model.IsDataSigned()){
+    if (model.IsDataSigned()) {
         arm::app::image::ConvertImgToInt8(inputTensor->data.data, copySz);
     }
 
     return model.RunInference();
 }
 
-template<typename T>
-void TestInference(int imageIdx, arm::app::Model& model, T tolerance) {
-    auto image = get_ifm_data_array(imageIdx);
-    auto goldenFV = get_ofm_data_array(imageIdx);
+template <typename T>
+void TestInference(int imageIdx, arm::app::Model& model, T tolerance)
+{
+    auto image    = GetIfmDataArray(imageIdx);
+    auto goldenFV = GetOfmDataArray(imageIdx);
 
     REQUIRE(RunInference(model, image));
 
@@ -66,11 +66,11 @@
     REQUIRE(tensorData);
 
     for (size_t i = 0; i < outputTensor->bytes; i++) {
-        REQUIRE(static_cast<int>(tensorData[i]) == Approx(static_cast<int>((T)goldenFV[i])).epsilon(tolerance));
+        REQUIRE(static_cast<int>(tensorData[i]) ==
+                Approx(static_cast<int>((T)goldenFV[i])).epsilon(tolerance));
     }
 }
 
-
 TEST_CASE("Running inference with TensorFlow Lite Micro and MobileNeV2 Uint8", "[MobileNetV2]")
 {
     SECTION("Executing inferences sequentially")
@@ -84,12 +84,12 @@
                            arm::app::img_class::GetModelLen()));
         REQUIRE(model.IsInited());
 
-        for (uint32_t i = 0 ; i < NUMBER_OF_IFM_FILES; ++i) {
+        for (uint32_t i = 0; i < NUMBER_OF_IFM_FILES; ++i) {
             TestInference<uint8_t>(i, model, 1);
         }
     }
 
-    for (uint32_t i = 0 ; i < NUMBER_OF_IFM_FILES; ++i) {
+    for (uint32_t i = 0; i < NUMBER_OF_IFM_FILES; ++i) {
         DYNAMIC_SECTION("Executing inference with re-init")
         {
             arm::app::MobileNetModel model{};
diff --git a/tests/use_case/kws/InferenceTestMicroNetKws.cc b/tests/use_case/kws/InferenceTestMicroNetKws.cc
index 27c6f96..ace6684 100644
--- a/tests/use_case/kws/InferenceTestMicroNetKws.cc
+++ b/tests/use_case/kws/InferenceTestMicroNetKws.cc
@@ -1,6 +1,6 @@
 /*
- * SPDX-FileCopyrightText: Copyright 2021 Arm Limited and/or its affiliates <open-source-office@arm.com>
- * SPDX-License-Identifier: Apache-2.0
+ * SPDX-FileCopyrightText: Copyright 2021 Arm Limited and/or its affiliates
+ * <open-source-office@arm.com> SPDX-License-Identifier: Apache-2.0
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -14,10 +14,10 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-#include "MicroNetKwsModel.hpp"
-#include "TestData_kws.hpp"
-#include "TensorFlowLiteMicro.hpp"
 #include "BufAttributes.hpp"
+#include "MicroNetKwsModel.hpp"
+#include "TensorFlowLiteMicro.hpp"
+#include "TestData_kws.hpp"
 
 #include <catch.hpp>
 #include <random>
@@ -39,9 +39,8 @@
     TfLiteTensor* inputTensor = model.GetInputTensor(0);
     REQUIRE(inputTensor);
 
-    const size_t copySz = inputTensor->bytes < IFM_0_DATA_SIZE ?
-                            inputTensor->bytes :
-                            IFM_0_DATA_SIZE;
+    const size_t copySz =
+        inputTensor->bytes < IFM_0_DATA_SIZE ? inputTensor->bytes : IFM_0_DATA_SIZE;
     memcpy(inputTensor->data.data, vec, copySz);
 
     return model.RunInference();
@@ -54,11 +53,9 @@
 
     std::random_device rndDevice;
     std::mt19937 mersenneGen{rndDevice()};
-    std::uniform_int_distribution<short> dist {-128, 127};
+    std::uniform_int_distribution<short> dist{-128, 127};
 
-    auto gen = [&dist, &mersenneGen](){
-                   return dist(mersenneGen);
-               };
+    auto gen = [&dist, &mersenneGen]() { return dist(mersenneGen); };
 
     std::vector<int8_t> randomAudio(inputTensor->bytes);
     std::generate(std::begin(randomAudio), std::end(randomAudio), gen);
@@ -67,7 +64,7 @@
     return true;
 }
 
-template<typename T>
+template <typename T>
 void TestInference(const T* input_goldenFV, const T* output_goldenFV, arm::app::Model& model)
 {
     REQUIRE(RunInference(model, input_goldenFV));
@@ -84,15 +81,16 @@
     }
 }
 
-TEST_CASE("Running random inference with TensorFlow Lite Micro and MicroNetKwsModel Int8", "[MicroNetKws]")
+TEST_CASE("Running random inference with TensorFlow Lite Micro and MicroNetKwsModel Int8",
+          "[MicroNetKws]")
 {
     arm::app::MicroNetKwsModel model{};
 
     REQUIRE_FALSE(model.IsInited());
     REQUIRE(model.Init(arm::app::tensorArena,
-                    sizeof(arm::app::tensorArena),
-                    arm::app::kws::GetModelPointer(),
-                    arm::app::kws::GetModelLen()));
+                       sizeof(arm::app::tensorArena),
+                       arm::app::kws::GetModelPointer(),
+                       arm::app::kws::GetModelLen()));
     REQUIRE(model.IsInited());
 
     REQUIRE(RunInferenceRandom(model));
@@ -101,9 +99,10 @@
 TEST_CASE("Running inference with TensorFlow Lite Micro and MicroNetKwsModel int8", "[MicroNetKws]")
 {
     REQUIRE(NUMBER_OF_IFM_FILES == NUMBER_OF_OFM_FILES);
-    for (uint32_t i = 0 ; i < NUMBER_OF_IFM_FILES; ++i) {
-        const int8_t* input_goldenFV = get_ifm_data_array(i);;
-        const int8_t* output_goldenFV = get_ofm_data_array(i);
+    for (uint32_t i = 0; i < NUMBER_OF_IFM_FILES; ++i) {
+        const int8_t* input_goldenFV = GetIfmDataArray(i);
+        ;
+        const int8_t* output_goldenFV = GetOfmDataArray(i);
 
         DYNAMIC_SECTION("Executing inference with re-init " << i)
         {
@@ -111,13 +110,12 @@
 
             REQUIRE_FALSE(model.IsInited());
             REQUIRE(model.Init(arm::app::tensorArena,
-                    sizeof(arm::app::tensorArena),
-                    arm::app::kws::GetModelPointer(),
-                    arm::app::kws::GetModelLen()));
+                               sizeof(arm::app::tensorArena),
+                               arm::app::kws::GetModelPointer(),
+                               arm::app::kws::GetModelLen()));
             REQUIRE(model.IsInited());
 
             TestInference<int8_t>(input_goldenFV, output_goldenFV, model);
-
         }
     }
 }
diff --git a/tests/use_case/kws_asr/InferenceTestMicroNetKws.cc b/tests/use_case/kws_asr/InferenceTestMicroNetKws.cc
index 9fd8171..4cfd784 100644
--- a/tests/use_case/kws_asr/InferenceTestMicroNetKws.cc
+++ b/tests/use_case/kws_asr/InferenceTestMicroNetKws.cc
@@ -1,6 +1,6 @@
 /*
- * SPDX-FileCopyrightText: Copyright 2021 Arm Limited and/or its affiliates <open-source-office@arm.com>
- * SPDX-License-Identifier: Apache-2.0
+ * SPDX-FileCopyrightText: Copyright 2021 Arm Limited and/or its affiliates
+ * <open-source-office@arm.com> SPDX-License-Identifier: Apache-2.0
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -14,10 +14,10 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-#include "MicroNetKwsModel.hpp"
-#include "TestData_kws.hpp"
-#include "TensorFlowLiteMicro.hpp"
 #include "BufAttributes.hpp"
+#include "MicroNetKwsModel.hpp"
+#include "TensorFlowLiteMicro.hpp"
+#include "TestData_kws.hpp"
 
 #include <catch.hpp>
 #include <random>
@@ -35,87 +35,89 @@
 namespace test {
 namespace kws {
 
-bool RunInference(arm::app::Model& model, const int8_t vec[]) {
-    TfLiteTensor* inputTensor = model.GetInputTensor(0);
-    REQUIRE(inputTensor);
+    bool RunInference(arm::app::Model& model, const int8_t vec[])
+    {
+        TfLiteTensor* inputTensor = model.GetInputTensor(0);
+        REQUIRE(inputTensor);
 
-    const size_t copySz = inputTensor->bytes < IFM_0_DATA_SIZE ?
-                          inputTensor->bytes :
-                          IFM_0_DATA_SIZE;
-    memcpy(inputTensor->data.data, vec, copySz);
+        const size_t copySz =
+            inputTensor->bytes < IFM_0_DATA_SIZE ? inputTensor->bytes : IFM_0_DATA_SIZE;
+        memcpy(inputTensor->data.data, vec, copySz);
 
-    return model.RunInference();
-}
-
-bool RunInferenceRandom(arm::app::Model& model) {
-    TfLiteTensor* inputTensor = model.GetInputTensor(0);
-    REQUIRE(inputTensor);
-
-    std::random_device rndDevice;
-    std::mt19937 mersenneGen{rndDevice()};
-    std::uniform_int_distribution<short> dist{-128, 127};
-
-    auto gen = [&dist, &mersenneGen]() {
-        return dist(mersenneGen);
-    };
-
-    std::vector<int8_t> randomAudio(inputTensor->bytes);
-    std::generate(std::begin(randomAudio), std::end(randomAudio), gen);
-
-    REQUIRE(RunInference(model, randomAudio.data()));
-    return true;
-}
-
-template<typename T>
-void TestInference(const T* input_goldenFV, const T* output_goldenFV, arm::app::Model& model) {
-    REQUIRE(RunInference(model, input_goldenFV));
-
-    TfLiteTensor* outputTensor = model.GetOutputTensor(0);
-
-    REQUIRE(outputTensor);
-    REQUIRE(outputTensor->bytes == OFM_0_DATA_SIZE);
-    auto tensorData = tflite::GetTensorData<T>(outputTensor);
-    REQUIRE(tensorData);
-
-    for (size_t i = 0; i < outputTensor->bytes; i++) {
-        REQUIRE(static_cast<int>(tensorData[i]) == static_cast<int>((T) output_goldenFV[i]));
+        return model.RunInference();
     }
-}
 
-TEST_CASE("Running random inference with Tflu and MicroNetKwsModel Int8", "[MicroNetKws]") {
-    arm::app::MicroNetKwsModel model{};
+    bool RunInferenceRandom(arm::app::Model& model)
+    {
+        TfLiteTensor* inputTensor = model.GetInputTensor(0);
+        REQUIRE(inputTensor);
 
-    REQUIRE_FALSE(model.IsInited());
-    REQUIRE(model.Init(arm::app::tensorArena,
-                    sizeof(arm::app::tensorArena),
-                    arm::app::kws::GetModelPointer(),
-                    arm::app::kws::GetModelLen()));
-    REQUIRE(model.IsInited());
+        std::random_device rndDevice;
+        std::mt19937 mersenneGen{rndDevice()};
+        std::uniform_int_distribution<short> dist{-128, 127};
 
-    REQUIRE(RunInferenceRandom(model));
-}
+        auto gen = [&dist, &mersenneGen]() { return dist(mersenneGen); };
 
-TEST_CASE("Running inference with Tflu and MicroNetKwsModel Int8", "[MicroNetKws]") {
-    REQUIRE(NUMBER_OF_IFM_FILES == NUMBER_OF_OFM_FILES);
-    for (uint32_t i = 0; i < NUMBER_OF_IFM_FILES; ++i) {
-        const int8_t* input_goldenFV = get_ifm_data_array(i);
-        const int8_t* output_goldenFV = get_ofm_data_array(i);
+        std::vector<int8_t> randomAudio(inputTensor->bytes);
+        std::generate(std::begin(randomAudio), std::end(randomAudio), gen);
 
-        DYNAMIC_SECTION("Executing inference with re-init") {
-            arm::app::MicroNetKwsModel model{};
+        REQUIRE(RunInference(model, randomAudio.data()));
+        return true;
+    }
 
-            REQUIRE_FALSE(model.IsInited());
-            REQUIRE(model.Init(arm::app::tensorArena,
-                    sizeof(arm::app::tensorArena),
-                    arm::app::kws::GetModelPointer(),
-                    arm::app::kws::GetModelLen()));
-            REQUIRE(model.IsInited());
+    template <typename T>
+    void TestInference(const T* input_goldenFV, const T* output_goldenFV, arm::app::Model& model)
+    {
+        REQUIRE(RunInference(model, input_goldenFV));
 
-            TestInference<int8_t>(input_goldenFV, output_goldenFV, model);
+        TfLiteTensor* outputTensor = model.GetOutputTensor(0);
 
+        REQUIRE(outputTensor);
+        REQUIRE(outputTensor->bytes == OFM_0_DATA_SIZE);
+        auto tensorData = tflite::GetTensorData<T>(outputTensor);
+        REQUIRE(tensorData);
+
+        for (size_t i = 0; i < outputTensor->bytes; i++) {
+            REQUIRE(static_cast<int>(tensorData[i]) == static_cast<int>((T)output_goldenFV[i]));
         }
     }
-}
 
-} //namespace
-} //namespace
+    TEST_CASE("Running random inference with Tflu and MicroNetKwsModel Int8", "[MicroNetKws]")
+    {
+        arm::app::MicroNetKwsModel model{};
+
+        REQUIRE_FALSE(model.IsInited());
+        REQUIRE(model.Init(arm::app::tensorArena,
+                           sizeof(arm::app::tensorArena),
+                           arm::app::kws::GetModelPointer(),
+                           arm::app::kws::GetModelLen()));
+        REQUIRE(model.IsInited());
+
+        REQUIRE(RunInferenceRandom(model));
+    }
+
+    TEST_CASE("Running inference with Tflu and MicroNetKwsModel Int8", "[MicroNetKws]")
+    {
+        REQUIRE(NUMBER_OF_IFM_FILES == NUMBER_OF_OFM_FILES);
+        for (uint32_t i = 0; i < NUMBER_OF_IFM_FILES; ++i) {
+            const int8_t* input_goldenFV  = GetIfmDataArray(i);
+            const int8_t* output_goldenFV = GetOfmDataArray(i);
+
+            DYNAMIC_SECTION("Executing inference with re-init")
+            {
+                arm::app::MicroNetKwsModel model{};
+
+                REQUIRE_FALSE(model.IsInited());
+                REQUIRE(model.Init(arm::app::tensorArena,
+                                   sizeof(arm::app::tensorArena),
+                                   arm::app::kws::GetModelPointer(),
+                                   arm::app::kws::GetModelLen()));
+                REQUIRE(model.IsInited());
+
+                TestInference<int8_t>(input_goldenFV, output_goldenFV, model);
+            }
+        }
+    }
+
+} // namespace kws
+} // namespace test
diff --git a/tests/use_case/kws_asr/InferenceTestWav2Letter.cc b/tests/use_case/kws_asr/InferenceTestWav2Letter.cc
index 72dcadc..b49b886 100644
--- a/tests/use_case/kws_asr/InferenceTestWav2Letter.cc
+++ b/tests/use_case/kws_asr/InferenceTestWav2Letter.cc
@@ -1,6 +1,6 @@
 /*
- * SPDX-FileCopyrightText: Copyright 2021 Arm Limited and/or its affiliates <open-source-office@arm.com>
- * SPDX-License-Identifier: Apache-2.0
+ * SPDX-FileCopyrightText: Copyright 2021 Arm Limited and/or its affiliates
+ * <open-source-office@arm.com> SPDX-License-Identifier: Apache-2.0
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -14,10 +14,10 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-#include "TensorFlowLiteMicro.hpp"
-#include "Wav2LetterModel.hpp"
-#include "TestData_asr.hpp"
 #include "BufAttributes.hpp"
+#include "TensorFlowLiteMicro.hpp"
+#include "TestData_asr.hpp"
+#include "Wav2LetterModel.hpp"
 
 #include <catch.hpp>
 #include <random>
@@ -35,94 +35,91 @@
 namespace test {
 namespace asr {
 
-bool RunInference(arm::app::Model& model, const int8_t vec[], const size_t copySz)
-{
-    TfLiteTensor* inputTensor = model.GetInputTensor(0);
-    REQUIRE(inputTensor);
+    bool RunInference(arm::app::Model& model, const int8_t vec[], const size_t copySz)
+    {
+        TfLiteTensor* inputTensor = model.GetInputTensor(0);
+        REQUIRE(inputTensor);
 
-    memcpy(inputTensor->data.data, vec, copySz);
+        memcpy(inputTensor->data.data, vec, copySz);
 
-    return model.RunInference();
-}
-
-bool RunInferenceRandom(arm::app::Model& model)
-{
-    TfLiteTensor* inputTensor = model.GetInputTensor(0);
-    REQUIRE(inputTensor);
-
-    std::random_device rndDevice;
-    std::mt19937 mersenneGen{rndDevice()};
-    std::uniform_int_distribution<short> dist {-128, 127};
-
-    auto gen = [&dist, &mersenneGen](){
-                   return dist(mersenneGen);
-               };
-
-    std::vector<int8_t> randomAudio(inputTensor->bytes);
-    std::generate(std::begin(randomAudio), std::end(randomAudio), gen);
-
-    REQUIRE(RunInference(model, randomAudio.data(), inputTensor->bytes));
-    return true;
-}
-
-TEST_CASE("Running random inference with Tflu and Wav2LetterModel Int8", "[Wav2Letter]")
-{
-    arm::app::Wav2LetterModel model{};
-
-    REQUIRE_FALSE(model.IsInited());
-    REQUIRE(model.Init(arm::app::tensorArena,
-                       sizeof(arm::app::tensorArena),
-                       arm::app::asr::GetModelPointer(),
-                       arm::app::asr::GetModelLen()));
-    REQUIRE(model.IsInited());
-
-    REQUIRE(RunInferenceRandom(model));
-}
-
-
-template<typename T>
-void TestInference(const T* input_goldenFV, const T* output_goldenFV, arm::app::Model& model)
-{
-    TfLiteTensor* inputTensor = model.GetInputTensor(0);
-    REQUIRE(inputTensor);
-
-    REQUIRE(RunInference(model, input_goldenFV, inputTensor->bytes));
-
-    TfLiteTensor* outputTensor = model.GetOutputTensor(0);
-
-    REQUIRE(outputTensor);
-    REQUIRE(outputTensor->bytes == OFM_0_DATA_SIZE);
-    auto tensorData = tflite::GetTensorData<T>(outputTensor);
-    REQUIRE(tensorData);
-
-    for (size_t i = 0; i < outputTensor->bytes; i++) {
-        REQUIRE(static_cast<int>(tensorData[i]) == static_cast<int>(((T)output_goldenFV[i])));
+        return model.RunInference();
     }
-}
 
-TEST_CASE("Running inference with Tflu and Wav2LetterModel Int8", "[Wav2Letter]")
-{
-    REQUIRE(NUMBER_OF_IFM_FILES == NUMBER_OF_OFM_FILES);
-    for (uint32_t i = 0 ; i < NUMBER_OF_IFM_FILES; ++i) {
-        auto input_goldenFV = get_ifm_data_array(i);;
-        auto output_goldenFV = get_ofm_data_array(i);
+    bool RunInferenceRandom(arm::app::Model& model)
+    {
+        TfLiteTensor* inputTensor = model.GetInputTensor(0);
+        REQUIRE(inputTensor);
 
-        DYNAMIC_SECTION("Executing inference with re-init")
-        {
-            arm::app::Wav2LetterModel model{};
+        std::random_device rndDevice;
+        std::mt19937 mersenneGen{rndDevice()};
+        std::uniform_int_distribution<short> dist{-128, 127};
 
-            REQUIRE_FALSE(model.IsInited());
-            REQUIRE(model.Init(arm::app::tensorArena,
-                    sizeof(arm::app::tensorArena),
-                    arm::app::asr::GetModelPointer(),
-                    arm::app::asr::GetModelLen()));
-            REQUIRE(model.IsInited());
+        auto gen = [&dist, &mersenneGen]() { return dist(mersenneGen); };
 
-            TestInference<int8_t>(input_goldenFV, output_goldenFV, model);
+        std::vector<int8_t> randomAudio(inputTensor->bytes);
+        std::generate(std::begin(randomAudio), std::end(randomAudio), gen);
 
+        REQUIRE(RunInference(model, randomAudio.data(), inputTensor->bytes));
+        return true;
+    }
+
+    TEST_CASE("Running random inference with Tflu and Wav2LetterModel Int8", "[Wav2Letter]")
+    {
+        arm::app::Wav2LetterModel model{};
+
+        REQUIRE_FALSE(model.IsInited());
+        REQUIRE(model.Init(arm::app::tensorArena,
+                           sizeof(arm::app::tensorArena),
+                           arm::app::asr::GetModelPointer(),
+                           arm::app::asr::GetModelLen()));
+        REQUIRE(model.IsInited());
+
+        REQUIRE(RunInferenceRandom(model));
+    }
+
+    template <typename T>
+    void TestInference(const T* input_goldenFV, const T* output_goldenFV, arm::app::Model& model)
+    {
+        TfLiteTensor* inputTensor = model.GetInputTensor(0);
+        REQUIRE(inputTensor);
+
+        REQUIRE(RunInference(model, input_goldenFV, inputTensor->bytes));
+
+        TfLiteTensor* outputTensor = model.GetOutputTensor(0);
+
+        REQUIRE(outputTensor);
+        REQUIRE(outputTensor->bytes == OFM_0_DATA_SIZE);
+        auto tensorData = tflite::GetTensorData<T>(outputTensor);
+        REQUIRE(tensorData);
+
+        for (size_t i = 0; i < outputTensor->bytes; i++) {
+            REQUIRE(static_cast<int>(tensorData[i]) == static_cast<int>(((T)output_goldenFV[i])));
         }
     }
-}
 
-} //namespace
-} //namespace
+    TEST_CASE("Running inference with Tflu and Wav2LetterModel Int8", "[Wav2Letter]")
+    {
+        REQUIRE(NUMBER_OF_IFM_FILES == NUMBER_OF_OFM_FILES);
+        for (uint32_t i = 0; i < NUMBER_OF_IFM_FILES; ++i) {
+            auto input_goldenFV = GetIfmDataArray(i);
+            ;
+            auto output_goldenFV = GetOfmDataArray(i);
+
+            DYNAMIC_SECTION("Executing inference with re-init")
+            {
+                arm::app::Wav2LetterModel model{};
+
+                REQUIRE_FALSE(model.IsInited());
+                REQUIRE(model.Init(arm::app::tensorArena,
+                                   sizeof(arm::app::tensorArena),
+                                   arm::app::asr::GetModelPointer(),
+                                   arm::app::asr::GetModelLen()));
+                REQUIRE(model.IsInited());
+
+                TestInference<int8_t>(input_goldenFV, output_goldenFV, model);
+            }
+        }
+    }
+
+} // namespace asr
+} // namespace test
diff --git a/tests/use_case/noise_reduction/InferenceTestRNNoise.cc b/tests/use_case/noise_reduction/InferenceTestRNNoise.cc
index 3cdaee1..17ce9ac 100644
--- a/tests/use_case/noise_reduction/InferenceTestRNNoise.cc
+++ b/tests/use_case/noise_reduction/InferenceTestRNNoise.cc
@@ -1,6 +1,6 @@
 /*
- * SPDX-FileCopyrightText: Copyright 2021 Arm Limited and/or its affiliates <open-source-office@arm.com>
- * SPDX-License-Identifier: Apache-2.0
+ * SPDX-FileCopyrightText: Copyright 2021 Arm Limited and/or its affiliates
+ * <open-source-office@arm.com> SPDX-License-Identifier: Apache-2.0
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -14,10 +14,10 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-#include "TensorFlowLiteMicro.hpp"
-#include "RNNoiseModel.hpp"
-#include "TestData_noise_reduction.hpp"
 #include "BufAttributes.hpp"
+#include "RNNoiseModel.hpp"
+#include "TensorFlowLiteMicro.hpp"
+#include "TestData_noise_reduction.hpp"
 
 #include <catch.hpp>
 #include <random>
@@ -50,15 +50,13 @@
     {
         std::random_device rndDevice;
         std::mt19937 mersenneGen{rndDevice()};
-        std::uniform_int_distribution<short> dist {-128, 127};
+        std::uniform_int_distribution<short> dist{-128, 127};
 
-        auto gen = [&dist, &mersenneGen](){
-            return dist(mersenneGen);
-        };
+        auto gen = [&dist, &mersenneGen]() { return dist(mersenneGen); };
 
         std::vector<std::vector<int8_t>> randomInput{NUMBER_OF_IFM_FILES};
         for (size_t i = 0; i < model.GetNumInputs(); ++i) {
-            TfLiteTensor *inputTensor = model.GetInputTensor(i);
+            TfLiteTensor* inputTensor = model.GetInputTensor(i);
             REQUIRE(inputTensor);
             randomInput[i].resize(inputTensor->bytes);
             std::generate(std::begin(randomInput[i]), std::end(randomInput[i]), gen);
@@ -82,8 +80,10 @@
         REQUIRE(RunInferenceRandom(model));
     }
 
-    template<typename T>
-    void TestInference(const std::vector<std::vector<T>> input_goldenFV, const std::vector<std::vector<T>> output_goldenFV, arm::app::Model& model)
+    template <typename T>
+    void TestInference(const std::vector<std::vector<T>> input_goldenFV,
+                       const std::vector<std::vector<T>> output_goldenFV,
+                       arm::app::Model& model)
     {
         for (size_t i = 0; i < model.GetNumInputs(); ++i) {
             TfLiteTensor* inputTensor = model.GetInputTensor(i);
@@ -93,41 +93,37 @@
         REQUIRE(RunInference(model, input_goldenFV));
 
         for (size_t i = 0; i < model.GetNumOutputs(); ++i) {
-            TfLiteTensor *outputTensor = model.GetOutputTensor(i);
+            TfLiteTensor* outputTensor = model.GetOutputTensor(i);
 
             REQUIRE(outputTensor);
             auto tensorData = tflite::GetTensorData<T>(outputTensor);
             REQUIRE(tensorData);
 
             for (size_t j = 0; j < outputTensor->bytes; j++) {
-                REQUIRE(static_cast<int>(tensorData[j]) == static_cast<int>((output_goldenFV[i][j])));
+                REQUIRE(static_cast<int>(tensorData[j]) ==
+                        static_cast<int>((output_goldenFV[i][j])));
             }
         }
     }
 
     TEST_CASE("Running inference with Tflu and RNNoise Int8", "[RNNoise]")
     {
-        std::vector<std::vector<int8_t>> goldenInputFV {NUMBER_OF_IFM_FILES};
-        std::vector<std::vector<int8_t>> goldenOutputFV {NUMBER_OF_OFM_FILES};
+        std::vector<std::vector<int8_t>> goldenInputFV{NUMBER_OF_IFM_FILES};
+        std::vector<std::vector<int8_t>> goldenOutputFV{NUMBER_OF_OFM_FILES};
 
-        std::array<size_t, NUMBER_OF_IFM_FILES> inputSizes = {IFM_0_DATA_SIZE,
-                                                              IFM_1_DATA_SIZE,
-                                                              IFM_2_DATA_SIZE,
-                                                              IFM_3_DATA_SIZE};
+        std::array<size_t, NUMBER_OF_IFM_FILES> inputSizes = {
+            IFM_0_DATA_SIZE, IFM_1_DATA_SIZE, IFM_2_DATA_SIZE, IFM_3_DATA_SIZE};
 
-        std::array<size_t, NUMBER_OF_OFM_FILES> outputSizes = {OFM_0_DATA_SIZE,
-                                                               OFM_1_DATA_SIZE,
-                                                               OFM_2_DATA_SIZE,
-                                                               OFM_3_DATA_SIZE,
-                                                               OFM_4_DATA_SIZE};
+        std::array<size_t, NUMBER_OF_OFM_FILES> outputSizes = {
+            OFM_0_DATA_SIZE, OFM_1_DATA_SIZE, OFM_2_DATA_SIZE, OFM_3_DATA_SIZE, OFM_4_DATA_SIZE};
 
-        for (uint32_t i = 0 ; i < NUMBER_OF_IFM_FILES; ++i) {
+        for (uint32_t i = 0; i < NUMBER_OF_IFM_FILES; ++i) {
             goldenInputFV[i].resize(inputSizes[i]);
-            std::memcpy(goldenInputFV[i].data(), get_ifm_data_array(i), inputSizes[i]);
+            std::memcpy(goldenInputFV[i].data(), GetIfmDataArray(i), inputSizes[i]);
         }
-        for (uint32_t i = 0 ; i < NUMBER_OF_OFM_FILES; ++i) {
+        for (uint32_t i = 0; i < NUMBER_OF_OFM_FILES; ++i) {
             goldenOutputFV[i].resize(outputSizes[i]);
-            std::memcpy(goldenOutputFV[i].data(), get_ofm_data_array(i), outputSizes[i]);
+            std::memcpy(goldenOutputFV[i].data(), GetOfmDataArray(i), outputSizes[i]);
         }
 
         DYNAMIC_SECTION("Executing inference with re-init")
@@ -146,4 +142,4 @@
     }
 
 } /* namespace noise_reduction */
-}  /* namespace test */
+} /* namespace test */
diff --git a/tests/use_case/noise_reduction/RNNNoiseUCTests.cc b/tests/use_case/noise_reduction/RNNNoiseUCTests.cc
index d835c21..7f9ff19 100644
--- a/tests/use_case/noise_reduction/RNNNoiseUCTests.cc
+++ b/tests/use_case/noise_reduction/RNNNoiseUCTests.cc
@@ -1,6 +1,6 @@
 /*
- * SPDX-FileCopyrightText: Copyright 2021-2022 Arm Limited and/or its affiliates <open-source-office@arm.com>
- * SPDX-License-Identifier: Apache-2.0
+ * SPDX-FileCopyrightText: Copyright 2021-2022 Arm Limited and/or its affiliates
+ * <open-source-office@arm.com> SPDX-License-Identifier: Apache-2.0
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -14,13 +14,13 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
+#include "BufAttributes.hpp"
+#include "InputFiles.hpp"
+#include "Profiler.hpp"
+#include "RNNUCTestCaseData.hpp"
 #include "RNNoiseModel.hpp"
 #include "UseCaseHandler.hpp"
-#include "InputFiles.hpp"
-#include "RNNUCTestCaseData.hpp"
-#include "BufAttributes.hpp"
 #include "hal.h"
-#include "Profiler.hpp"
 
 #include <catch.hpp>
 
@@ -34,13 +34,13 @@
 } /* namespace app */
 } /* namespace arm */
 
-#define PLATFORM    hal_platform_init();
+#define PLATFORM hal_platform_init();
 
-#define CONTEXT \
-arm::app::ApplicationContext caseContext; \
-arm::app::Profiler profiler{"noise_reduction"}; \
-caseContext.Set<arm::app::Profiler&>("profiler", profiler); \
-caseContext.Set<arm::app::RNNoiseModel&>("model", model);
+#define CONTEXT                                                 \
+    arm::app::ApplicationContext caseContext;                   \
+    arm::app::Profiler profiler{"noise_reduction"};             \
+    caseContext.Set<arm::app::Profiler&>("profiler", profiler); \
+    caseContext.Set<arm::app::RNNoiseModel&>("model", model);
 
 TEST_CASE("Verify output tensor memory dump")
 {
@@ -56,12 +56,12 @@
 
     /* Populate the output tensors */
     const size_t numOutputs = model.GetNumOutputs();
-    size_t sizeToWrite = 0;
-    size_t lastTensorSize = model.GetOutputTensor(numOutputs - 1)->bytes;
+    size_t sizeToWrite      = 0;
+    size_t lastTensorSize   = model.GetOutputTensor(numOutputs - 1)->bytes;
 
     for (size_t i = 0; i < numOutputs; ++i) {
         TfLiteTensor* tensor = model.GetOutputTensor(i);
-        auto* tData = tflite::GetTensorData<uint8_t>(tensor);
+        auto* tData          = tflite::GetTensorData<uint8_t>(tensor);
 
         if (tensor->bytes > 0) {
             memset(tData, static_cast<uint8_t>(i), tensor->bytes);
@@ -69,7 +69,6 @@
         }
     }
 
-
     SECTION("Positive use case")
     {
         /* Run the memory dump */
@@ -80,7 +79,7 @@
         size_t k = 0;
         for (size_t i = 0; i < numOutputs && k < memPool.size(); ++i) {
             TfLiteTensor* tensor = model.GetOutputTensor(i);
-            auto* tData = tflite::GetTensorData<uint8_t>(tensor);
+            auto* tData          = tflite::GetTensorData<uint8_t>(tensor);
 
             for (size_t j = 0; j < tensor->bytes && k < memPool.size(); ++j) {
                 REQUIRE(tData[j] == memPool[k++]);
@@ -126,28 +125,31 @@
     REQUIRE(arm::app::NoiseReductionHandler(caseContext, true));
 }
 
-std::function<uint32_t(const uint32_t)> get_golden_input_p232_208_array_size(const uint32_t numberOfFeatures) {
+std::function<uint32_t(const uint32_t)>
+get_golden_input_p232_208_array_size(const uint32_t numberOfFeatures)
+{
 
-    return [numberOfFeatures](const uint32_t) ->  uint32_t{
-        return numberOfFeatures;
-    };
+    return [numberOfFeatures](const uint32_t) -> uint32_t { return numberOfFeatures; };
 }
 
-const char* get_test_filename(const uint32_t idx) {
-    auto name = get_filename(idx);
+const char* get_test_filename(const uint32_t idx)
+{
+    auto name = GetFilename(idx);
     REQUIRE(std::string("p232_208.wav") == name);
     return "p232_208.wav";
 }
 
-void testInfByIndex(std::vector<uint32_t>& numberOfInferences) {
+void testInfByIndex(std::vector<uint32_t>& numberOfInferences)
+{
     PLATFORM
 
     arm::app::RNNoiseModel model;
 
     CONTEXT
 
-    caseContext.Set<std::function<const int16_t*(const uint32_t)>>("features", get_audio_array);
-    caseContext.Set<std::function<const char* (const uint32_t)>>("featureFileNames", get_test_filename);
+    caseContext.Set<std::function<const int16_t*(const uint32_t)>>("features", GetAudioArray);
+    caseContext.Set<std::function<const char*(const uint32_t)>>("featureFileNames",
+                                                                get_test_filename);
     caseContext.Set<uint32_t>("frameLength", arm::app::rnn::g_FrameLength);
     caseContext.Set<uint32_t>("frameStride", arm::app::rnn::g_FrameStride);
     caseContext.Set<uint32_t>("numInputFeatures", arm::app::rnn::g_NumInputFeatures);
@@ -160,18 +162,21 @@
     size_t oneInferenceOutSizeBytes = arm::app::rnn::g_FrameLength * sizeof(int16_t);
 
     auto infIndex = 0;
-    for (auto numInf: numberOfInferences) {
-        DYNAMIC_SECTION("Number of features: "<< numInf) {
-            caseContext.Set<uint32_t>("clipIndex", 1);  /* Only getting p232_208.wav for tests. */
+    for (auto numInf : numberOfInferences) {
+        DYNAMIC_SECTION("Number of features: " << numInf)
+        {
+            caseContext.Set<uint32_t>("clipIndex", 1); /* Only getting p232_208.wav for tests. */
             uint32_t audioSizeInput = numInf * arm::app::rnn::g_FrameLength;
-            caseContext.Set<std::function<uint32_t(const uint32_t)>>("featureSizes",
-                                                                     get_golden_input_p232_208_array_size(audioSizeInput));
+            caseContext.Set<std::function<uint32_t(const uint32_t)>>(
+                "featureSizes", get_golden_input_p232_208_array_size(audioSizeInput));
 
-            size_t headerNumBytes = 4 + 12 + 4;  /* Filename length, filename (12 for p232_208.wav), dump size. */
-            size_t footerNumBytes = 4;  /* Eof value. */
-            size_t memDumpMaxLenBytes = headerNumBytes + footerNumBytes + oneInferenceOutSizeBytes * numInf;
+            size_t headerNumBytes =
+                4 + 12 + 4; /* Filename length, filename (12 for p232_208.wav), dump size. */
+            size_t footerNumBytes = 4; /* Eof value. */
+            size_t memDumpMaxLenBytes =
+                headerNumBytes + footerNumBytes + oneInferenceOutSizeBytes * numInf;
 
-            std::vector<uint8_t > memDump(memDumpMaxLenBytes);
+            std::vector<uint8_t> memDump(memDumpMaxLenBytes);
             size_t undefMemDumpBytesWritten = 0;
             caseContext.Set<size_t>("MEM_DUMP_LEN", memDumpMaxLenBytes);
             caseContext.Set<uint8_t*>("MEM_DUMP_BASE_ADDR", memDump.data());
@@ -199,8 +204,9 @@
 
 TEST_CASE("Inference by index - one inference", "[RNNoise]")
 {
-    auto totalAudioSize = get_audio_array_size(1);
-    REQUIRE(64757 == totalAudioSize);  /* Checking that the input file is as expected and has not changed. */
+    auto totalAudioSize = GetAudioArraySize(1);
+    REQUIRE(64757 ==
+            totalAudioSize); /* Checking that the input file is as expected and has not changed. */
 
     /* Run 1 inference */
     std::vector<uint32_t> numberOfInferences = {1};
@@ -209,8 +215,9 @@
 
 TEST_CASE("Inference by index - several inferences", "[RNNoise]")
 {
-    auto totalAudioSize = get_audio_array_size(1);
-    REQUIRE(64757 == totalAudioSize);  /* Checking that the input file is as expected and has not changed. */
+    auto totalAudioSize = GetAudioArraySize(1);
+    REQUIRE(64757 ==
+            totalAudioSize); /* Checking that the input file is as expected and has not changed. */
 
     /* 3 different inference amounts: 1, 2 and all inferences required to cover total feature set */
     uint32_t totalInferences                 = totalAudioSize / arm::app::rnn::g_FrameLength;
diff --git a/tests/use_case/object_detection/InferenceTestYoloFastest.cc b/tests/use_case/object_detection/InferenceTestYoloFastest.cc
index f1c3719..b3cf37d 100644
--- a/tests/use_case/object_detection/InferenceTestYoloFastest.cc
+++ b/tests/use_case/object_detection/InferenceTestYoloFastest.cc
@@ -1,6 +1,6 @@
 /*
- * SPDX-FileCopyrightText: Copyright 2022 Arm Limited and/or its affiliates <open-source-office@arm.com>
- * SPDX-License-Identifier: Apache-2.0
+ * SPDX-FileCopyrightText: Copyright 2022 Arm Limited and/or its affiliates
+ * <open-source-office@arm.com> SPDX-License-Identifier: Apache-2.0
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -14,58 +14,51 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-#include "log_macros.h"
-#include "ImageUtils.hpp"
-#include "YoloFastestModel.hpp"
-#include "TensorFlowLiteMicro.hpp"
-#include "DetectorPostProcessing.hpp"
-#include "InputFiles.hpp"
 #include "BufAttributes.hpp"
+#include "DetectorPostProcessing.hpp"
+#include "ImageUtils.hpp"
+#include "InputFiles.hpp"
+#include "TensorFlowLiteMicro.hpp"
+#include "YoloFastestModel.hpp"
+#include "log_macros.h"
 
 namespace arm {
-    namespace app {
-        static uint8_t tensorArena[ACTIVATION_BUF_SZ] ACTIVATION_BUF_ATTRIBUTE;
-        namespace object_detection {
-            extern uint8_t* GetModelPointer();
-            extern size_t GetModelLen();
-        } /* namespace object_detection */
-    } /* namespace app */
+namespace app {
+    static uint8_t tensorArena[ACTIVATION_BUF_SZ] ACTIVATION_BUF_ATTRIBUTE;
+    namespace object_detection {
+        extern uint8_t* GetModelPointer();
+        extern size_t GetModelLen();
+    } /* namespace object_detection */
+} /* namespace app */
 } /* namespace arm */
 
 #include <catch.hpp>
 
-void GetExpectedResults(std::vector<std::vector<arm::app::object_detection::DetectionResult>> &expected_results)
+void GetExpectedResults(
+    std::vector<std::vector<arm::app::object_detection::DetectionResult>>& expected_results)
 {
     /* Img1
     0)  (0.999246) -> Detection box: {x=89,y=17,w=41,h=56}
     1)  (0.995367) -> Detection box: {x=27,y=81,w=48,h=53}
     */
-    expected_results.push_back({
-        arm::app::object_detection::DetectionResult(0.99,89,17,41,56),
-        arm::app::object_detection::DetectionResult(0.99,27,81,48,53)
-    });
+    expected_results.push_back({arm::app::object_detection::DetectionResult(0.99, 89, 17, 41, 56),
+                                arm::app::object_detection::DetectionResult(0.99, 27, 81, 48, 53)});
     /* Img2
     0)  (0.998107) -> Detection box: {x=87,y=35,w=53,h=64}
     */
-    expected_results.push_back({
-        arm::app::object_detection::DetectionResult(0.99,87,35,53,64)
-    });
+    expected_results.push_back({arm::app::object_detection::DetectionResult(0.99, 87, 35, 53, 64)});
     /* Img3
     0)  (0.999244) -> Detection box: {x=105,y=73,w=58,h=66}
     1)  (0.985984) -> Detection box: {x=34,y=40,w=70,h=95}
     */
-    expected_results.push_back({
-        arm::app::object_detection::DetectionResult(0.99,105,73,58,66),
-        arm::app::object_detection::DetectionResult(0.98,34,40,70,95)
-    });
+    expected_results.push_back({arm::app::object_detection::DetectionResult(0.99, 105, 73, 58, 66),
+                                arm::app::object_detection::DetectionResult(0.98, 34, 40, 70, 95)});
     /* Img4
     0)  (0.993294) -> Detection box: {x=22,y=43,w=39,h=53}
     1)  (0.992021) -> Detection box: {x=63,y=60,w=38,h=45}
     */
-    expected_results.push_back({
-        arm::app::object_detection::DetectionResult(0.99,22,43,39,53),
-        arm::app::object_detection::DetectionResult(0.99,63,60,38,45)
-    });
+    expected_results.push_back({arm::app::object_detection::DetectionResult(0.99, 22, 43, 39, 53),
+                                arm::app::object_detection::DetectionResult(0.99, 63, 60, 38, 45)});
 }
 
 bool RunInference(arm::app::Model& model, const uint8_t imageData[])
@@ -73,41 +66,43 @@
     TfLiteTensor* inputTensor = model.GetInputTensor(0);
     REQUIRE(inputTensor);
 
-    const size_t copySz = inputTensor->bytes < IMAGE_DATA_SIZE ?
-                            inputTensor->bytes : IMAGE_DATA_SIZE;
+    const size_t copySz =
+        inputTensor->bytes < IMAGE_DATA_SIZE ? inputTensor->bytes : IMAGE_DATA_SIZE;
 
-    arm::app::image::RgbToGrayscale(imageData,inputTensor->data.uint8,copySz);
+    arm::app::image::RgbToGrayscale(imageData, inputTensor->data.uint8, copySz);
 
-    if(model.IsDataSigned()){
+    if (model.IsDataSigned()) {
         arm::app::image::ConvertImgToInt8(inputTensor->data.data, copySz);
     }
 
     return model.RunInference();
 }
 
-template<typename T>
-void TestInferenceDetectionResults(int imageIdx, arm::app::Model& model, T tolerance) {
+template <typename T>
+void TestInferenceDetectionResults(int imageIdx, arm::app::Model& model, T tolerance)
+{
 
     std::vector<arm::app::object_detection::DetectionResult> results;
-    auto image = get_img_array(imageIdx);
+    auto image = GetImgArray(imageIdx);
 
     TfLiteIntArray* inputShape = model.GetInputShape(0);
-    auto nCols = inputShape->data[arm::app::YoloFastestModel::ms_inputColsIdx];
-    auto nRows = inputShape->data[arm::app::YoloFastestModel::ms_inputRowsIdx];
+    auto nCols                 = inputShape->data[arm::app::YoloFastestModel::ms_inputColsIdx];
+    auto nRows                 = inputShape->data[arm::app::YoloFastestModel::ms_inputRowsIdx];
 
     REQUIRE(RunInference(model, image));
 
-
     std::vector<TfLiteTensor*> output_arr{model.GetOutputTensor(0), model.GetOutputTensor(1)};
-    for (size_t i =0; i < output_arr.size(); i++) {
+    for (size_t i = 0; i < output_arr.size(); i++) {
         REQUIRE(output_arr[i]);
         REQUIRE(tflite::GetTensorData<T>(output_arr[i]));
     }
 
-    const arm::app::object_detection::PostProcessParams postProcessParams {
-            nRows, nCols, arm::app::object_detection::originalImageSize,
-            arm::app::object_detection::anchor1, arm::app::object_detection::anchor2
-    };
+    const arm::app::object_detection::PostProcessParams postProcessParams{
+        nRows,
+        nCols,
+        arm::app::object_detection::originalImageSize,
+        arm::app::object_detection::anchor1,
+        arm::app::object_detection::anchor2};
     arm::app::DetectorPostProcess postp{output_arr[0], output_arr[1], results, postProcessParams};
     postp.DoPostProcess();
 
@@ -117,18 +112,21 @@
     /* Validate got the same number of boxes */
     REQUIRE(results.size() == expected_results[imageIdx].size());
 
-
-    for (int i=0; i < (int)results.size(); i++) {
+    for (int i = 0; i < (int)results.size(); i++) {
         /* Validate confidence and box dimensions */
-        REQUIRE(std::abs(results[i].m_normalisedVal - expected_results[imageIdx][i].m_normalisedVal) < 0.1);
-        REQUIRE(static_cast<int>(results[i].m_x0) == Approx(static_cast<int>((T)expected_results[imageIdx][i].m_x0)).epsilon(tolerance));
-        REQUIRE(static_cast<int>(results[i].m_y0) == Approx(static_cast<int>((T)expected_results[imageIdx][i].m_y0)).epsilon(tolerance));
-        REQUIRE(static_cast<int>(results[i].m_w) == Approx(static_cast<int>((T)expected_results[imageIdx][i].m_w)).epsilon(tolerance));
-        REQUIRE(static_cast<int>(results[i].m_h) == Approx(static_cast<int>((T)expected_results[imageIdx][i].m_h)).epsilon(tolerance));
+        REQUIRE(std::abs(results[i].m_normalisedVal -
+                         expected_results[imageIdx][i].m_normalisedVal) < 0.1);
+        REQUIRE(static_cast<int>(results[i].m_x0) ==
+                Approx(static_cast<int>((T)expected_results[imageIdx][i].m_x0)).epsilon(tolerance));
+        REQUIRE(static_cast<int>(results[i].m_y0) ==
+                Approx(static_cast<int>((T)expected_results[imageIdx][i].m_y0)).epsilon(tolerance));
+        REQUIRE(static_cast<int>(results[i].m_w) ==
+                Approx(static_cast<int>((T)expected_results[imageIdx][i].m_w)).epsilon(tolerance));
+        REQUIRE(static_cast<int>(results[i].m_h) ==
+                Approx(static_cast<int>((T)expected_results[imageIdx][i].m_h)).epsilon(tolerance));
     }
 }
 
-
 TEST_CASE("Running inference with TensorFlow Lite Micro and YoloFastest", "[YoloFastest]")
 {
     SECTION("Executing inferences sequentially")
@@ -142,12 +140,12 @@
                            arm::app::object_detection::GetModelLen()));
         REQUIRE(model.IsInited());
 
-        for (uint32_t i = 0 ; i < NUMBER_OF_FILES; ++i) {
+        for (uint32_t i = 0; i < NUMBER_OF_FILES; ++i) {
             TestInferenceDetectionResults<uint8_t>(i, model, 1);
         }
     }
 
-    for (uint32_t i = 0 ; i < NUMBER_OF_FILES; ++i) {
+    for (uint32_t i = 0; i < NUMBER_OF_FILES; ++i) {
         DYNAMIC_SECTION("Executing inference with re-init")
         {
             arm::app::YoloFastestModel model{};
diff --git a/tests/use_case/vww/InferenceVisualWakeWordModelTests.cc b/tests/use_case/vww/InferenceVisualWakeWordModelTests.cc
index 4d3092e..82bffc6 100644
--- a/tests/use_case/vww/InferenceVisualWakeWordModelTests.cc
+++ b/tests/use_case/vww/InferenceVisualWakeWordModelTests.cc
@@ -1,6 +1,6 @@
 /*
- * SPDX-FileCopyrightText: Copyright 2021-2022 Arm Limited and/or its affiliates <open-source-office@arm.com>
- * SPDX-License-Identifier: Apache-2.0
+ * SPDX-FileCopyrightText: Copyright 2021-2022 Arm Limited and/or its affiliates
+ * <open-source-office@arm.com> SPDX-License-Identifier: Apache-2.0
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -16,9 +16,9 @@
  */
 
 #include "ImageUtils.hpp"
+#include "TensorFlowLiteMicro.hpp"
 #include "TestData_vww.hpp"
 #include "VisualWakeWordModel.hpp"
-#include "TensorFlowLiteMicro.hpp"
 
 #include <catch.hpp>
 
@@ -27,24 +27,24 @@
     TfLiteTensor* inputTensor = model.GetInputTensor(0);
     REQUIRE(inputTensor);
 
-    const size_t copySz = inputTensor->bytes < IFM_0_DATA_SIZE ?
-                            inputTensor->bytes :
-                            IFM_0_DATA_SIZE;
+    const size_t copySz =
+        inputTensor->bytes < IFM_0_DATA_SIZE ? inputTensor->bytes : IFM_0_DATA_SIZE;
 
     memcpy(inputTensor->data.data, imageData, copySz);
 
-    if(model.IsDataSigned()){
+    if (model.IsDataSigned()) {
         arm::app::image::ConvertImgToInt8(inputTensor->data.data, copySz);
     }
 
     return model.RunInference();
 }
 
-template<typename T>
-void TestInference(int imageIdx,arm::app::Model& model) {
+template <typename T>
+void TestInference(int imageIdx, arm::app::Model& model)
+{
 
-    auto image = test::get_ifm_data_array(imageIdx);
-    auto goldenFV = test::get_ofm_data_array(imageIdx);
+    auto image    = test::GetIfmDataArray(imageIdx);
+    auto goldenFV = test::GetOfmDataArray(imageIdx);
 
     REQUIRE(RunInference(model, image));
 
@@ -56,7 +56,7 @@
     REQUIRE(tensorData);
 
     for (size_t i = 0; i < outputTensor->bytes; i++) {
-        auto testVal = static_cast<int>(tensorData[i]);
+        auto testVal   = static_cast<int>(tensorData[i]);
         auto goldenVal = static_cast<int>(goldenFV[i]);
         CHECK(testVal == goldenVal);
     }