@@ -1,42 +1,30 @@
 #!/usr/bin/env bash
 set -e
 
-# -----------------------------------------------------------------------------
 # Check lcov installation
-# -----------------------------------------------------------------------------
 if ! command -v lcov >/dev/null 2>&1; then
   echo "Error: lcov is not installed."
   echo "Install with: sudo apt install lcov"
   exit 1
 fi
 
-# -----------------------------------------------------------------------------
 # Configure project (only if build folder does not exist)
-# -----------------------------------------------------------------------------
 if [ ! -d build ]; then
   cmake -S . -B build \
     -DCMAKE_BUILD_TYPE=Debug \
     -DCMAKE_CXX_FLAGS="--coverage -O0 -g"
 fi
 
-# -----------------------------------------------------------------------------
 # Build project
-# -----------------------------------------------------------------------------
 cmake --build build
 
-# -----------------------------------------------------------------------------
 # Reset previous coverage
-# -----------------------------------------------------------------------------
 lcov --directory build --zerocounters
 
-# -----------------------------------------------------------------------------
 # Run unit tests
-# -----------------------------------------------------------------------------
 ctest --test-dir build --output-on-failure
 
-# -----------------------------------------------------------------------------
 # Capture coverage
-# -----------------------------------------------------------------------------
 mkdir -p coverage_lcov
 
 lcov --capture \
@@ -49,13 +37,9 @@ lcov --capture \
 lcov --remove coverage_lcov/coverage.info '/usr/*' \
      --output-file coverage_lcov/coverage.info
 
-# -----------------------------------------------------------------------------
 # Generate HTML report
-# -----------------------------------------------------------------------------
 genhtml coverage_lcov/coverage.info \
         --output-directory coverage_lcov
 
-# -----------------------------------------------------------------------------
 # Open coverage report
-# -----------------------------------------------------------------------------
 xdg-open coverage_lcov/index.html
@@ -1,55 +1,55 @@
 #include <iostream>
-#include <random>
-using namespace std;
+#include "ExampleRegistry.h"
 
+namespace {
 void conditionals() {
-  cout << "\n--- Conditional Examples ---\n";
+  std::cout << "\n--- Conditional Examples ---\n";
   // if-else
   int x = rand();
-  cout << "x = " << x << "\n";
+  std::cout << "x = " << x << "\n";
   if (x > 0) {
-    cout << "x is positive\n";
+    std::cout << "x is positive\n";
   } else if (x < 0) {
-    cout << "x is negative\n";
+    std::cout << "x is negative\n";
   } else {
-    cout << "x is zero\n";
+    std::cout << "x is zero\n";
   }
 
   // switch
   int choice = rand() % 2 + 1;
-  cout << "choice = " << x << "\n";
+  std::cout << "choice = " << x << "\n";
   switch (choice) {
     case 1:
-      cout << "Choice is 1\n";
+      std::cout << "Choice is 1\n";
       break;
     case 2:
-      cout << "Choice is 2\n";
+      std::cout << "Choice is 2\n";
       break;
     default:
-      cout << "Choice is something else\n";
+      std::cout << "Choice is something else\n";
       break;
   }
 }
 
 void jumps() {
-  cout << "\n--- Jump Statement Examples ---\n";
+  std::cout << "\n--- Jump Statement Examples ---\n";
 
   // goto
   int num = rand();
   if (num == 3)
     goto jumpLabel;
-  cout << "This line will be skipped.\n";
+  std::cout << "This line will be skipped.\n";
 
 jumpLabel:
-  cout << "Jumped here using goto!\n";
+  std::cout << "Jumped here using goto!\n";
 
   // break / continue
   for (int i = 0; i < 5; ++i) {
     if (i == 2)
       continue;  // skip 2
     if (i == 4)
       break;  // stop loop at 4
-    cout << "i = " << i << "\n";
+    std::cout << "i = " << i << "\n";
   }
 }
 
@@ -59,43 +59,43 @@ int square(int n) {
 }
 
 void functionCalls() {
-  cout << "\n--- Function Call Examples ---\n";
+  std::cout << "\n--- Function Call Examples ---\n";
   // function call
   int result = square(5);
-  cout << "square(5) = " << result << "\n";
+  std::cout << "square(5) = " << result << "\n";
 }
 
 void loops() {
-  cout << "\n--- Loop Examples ---\n";
+  std::cout << "\n--- Loop Examples ---\n";
 
   // while
   int i = 0;
   while (i < 3) {
-    cout << "while loop i = " << i << "\n";
+    std::cout << "while loop i = " << i << "\n";
     ++i;
   }
 
   // do-while
   int j = 0;
   do {
-    cout << "do-while loop j = " << j << "\n";
+    std::cout << "do-while loop j = " << j << "\n";
     ++j;
   } while (j < 2);
 
   // for(initialization; condition; update)
   for (int k = 0; k < 3; ++k) {
-    cout << "for loop k = " << k << "\n";
+    std::cout << "for loop k = " << k << "\n";
   }
 
   // ranged-for
   const int arr[] = {10, 20, 30};
   for (int value : arr) {
-    cout << "ranged-for value = " << value << "\n";
+    std::cout << "ranged-for value = " << value << "\n";
   }
 }
 
 void halts() {
-  cout << "\n--- Halt Examples ---\n";
+  std::cout << "\n--- Halt Examples ---\n";
 
   // std::exit() — terminates the program normally
   // std::abort() — terminates abnormally (no cleanup)
@@ -106,17 +106,16 @@ void halts() {
 }
 
 void exceptions() {
-  cout << "\n--- Exception Handling Examples ---\n";
+  std::cout << "\n--- Exception Handling Examples ---\n";
 
   // try - catch - throw
   try {
-    throw runtime_error("Something went wrong!");
-  } catch (const exception& e) {
-    cout << "Caught exception: " << e.what() << "\n";
+    throw std::runtime_error("Something went wrong!");
+  } catch (const std::exception& e) {
+    std::cout << "Caught exception: " << e.what() << "\n";
   }
 }
-
-#include "ExampleRegistry.h"
+}  // namespace
 
 class ControlFlow : public IExample {
  public:
 
@@ -1,5 +1,5 @@
+// cppcheck-suppress-file [unreadVariable, unusedVariable, functionStatic]
 #include <iostream>
-using namespace std;
 
 #include "ExampleRegistry.h"
 
@@ -16,48 +16,54 @@ class InitializeVariable : public IExample {
 REGISTER_EXAMPLE(InitializeVariable, "core", "InitializeVariable");
 
 struct Foo {
-  Foo() { cout << "Default constructor/ default init\n"; }
+  Foo() { std::cout << "Default constructor/ default init\n"; }
 
   // Foo(int)
-  explicit Foo(int) { cout << "Constructor called with int / copy init\n"; }
+  explicit Foo(int) {
+    std::cout << "Constructor called with int / copy init\n";
+  }
 
-  Foo(const Foo& other) { std::cout << "Copy constructor called\n"; }
+  Foo(const Foo& other) {
+    other.dump();
+    std::cout << "Copy constructor called\n";
+  }
+
+  void dump() const {}
 };
 
 void initialize_variable() {
-  cout << "\n--- Variable Initialization Examples ---\n";
+  std::cout << "\n--- Variable Initialization Examples ---\n";
   // There are there common ways to intialize a variable
   // * 1) Default-initialization
-  [[maybe_unused]] int initDefaultVar;
-  [[maybe_unused]] Foo initDefaultObj;
+  int init_default_var;
+  Foo init_default_obj;
 
-  [[maybe_unused]] unsigned char* c = new unsigned char;
+  auto* c = new unsigned char;
   *c = 0xF;  // actual init at this point for c
   delete c;
 
   // * 2) Value-initialization
-  [[maybe_unused]] int initValueVar1();
-  [[maybe_unused]] int initValueVar2{};
+  int init_value_var1();
+  int init_value_var2{};
 
   // * 3) direct-init: Type var(value);
-  [[maybe_unused]] Foo directInitObj(4);  // call Foo(int)
-  [[maybe_unused]] Foo directInitObj2(
-      4.3);  // look for constructor -> implicit 4.3(float) -> 4(int) -> call Foo(int) ->
+  Foo direct_init_obj(4);  // call Foo(int)
+  Foo direct_init_obj2(4.3);  // look for constructor -> implicit 4.3(float) -> 4(int) -> call Foo(int)
 
   // * 4) Copy-init: Type var = other;
   //     1. Compiler tries to convert the value to a temporary Foo.
   //     2. If the constructor is explicit, implicit conversion is blocked -> compilation error.
   //     3. Otherwise, a temporary Foo is created and then copied/moved into the variable.
-  [[maybe_unused]] Foo copyInitObj =
-      (Foo)2.3;  // explicit cast: double 2.3 -> int 2 (implicit narrowing) -> Foo(int)
-                 // -> temporary Foo -> copied/moved into copyInitObj
+  Foo copy_init_obj = (Foo)2.3;
+  // explicit cast: double 2.3 -> int 2 (implicit narrowing) -> Foo(int)
+  // -> temporary Foo -> copied/moved into copyInitObj
   // Foo copyInitObjError = 2.3; // ERROR: implicit conversion blocked by explicit constructor
   // We can explicitly prevent certain conversions using = delete or using {}
 
   //  * 5) List-initialization (Brace init)
   // calls the constructor directly without allowing implicit conversions.
-  [[maybe_unused]] Foo braceInit{3};
+  Foo brace_init{3};
   // Foo braceInit2{3.3}; // ERORR => Prefer this way
-  [[maybe_unused]] int ar[] = {1, 2, 3};  // aggregate init
-  [[maybe_unused]] int ar2[]{1, 2, 3};
+  int ar[] = {1, 2, 3};  // aggregate init
+  int ar2[]{1, 2, 3};
 }