SDPT Lab 4 - Revizia istoricului

Rhobincu la 23 martie 2026 13:32

2026-03-23T13:32:44Z

Rhobincu: Pagină nouă: = Lab 4: Software Verification - TDD, Mocking, and Code Coverage = == Introduction == In traditional embedded systems, testing involves compiling code, flashing it to a board, and...

2026-03-23T13:27:18Z

Pagină nouă: = Lab 4: Software Verification - TDD, Mocking, and Code Coverage = == Introduction == In traditional embedded systems, testing involves compiling code, flashing it to a board, and...

Pagină nouă

= Lab 4: Software Verification - TDD, Mocking, and Code Coverage =

== Introduction ==
In traditional embedded systems, testing involves compiling code, flashing it to a board, and physically observing the hardware. This is slow, expensive, and scales poorly. Today, we implement "Shift-Left Testing." We will verify our C++ logic on our Host PC using automated frameworks before it ever touches a microcontroller.

=== Goals ===
* Integrate Google Test and Google Mock via CMake.
* Write Unit Tests using the AAA (Arrange, Act, Assert) pattern.
* Use Dependency Injection to decouple business logic from hardware registers.
* Simulate hardware interactions using Google Mock (GMock).
* Generate interactive HTML Code Coverage reports using <code>gcovr</code>.

== Part 1: Theoretical Reference ==
''Use this section as a reference manual to complete the challenges in Part 2.''

=== 1.1 Google Test & Mock Cheat Sheet ===
'''Basic Assertions:'''
* <code>EXPECT_EQ(actual, expected);</code> (Non-fatal equality check)
* <code>EXPECT_FLOAT_EQ(actual, expected);</code> (Safe float comparison)
* <code>EXPECT_TRUE(condition);</code>

'''Mocking an Interface (GMock):'''
<pre>
class MockSensor : public ISensor {
public:
// MOCK_METHOD(ReturnType, MethodName, (Arguments), (override));
MOCK_METHOD(float, read_temperature, (), (override));
};
</pre>

'''Setting Mock Expectations:'''
<pre>
MockSensor fake_sensor;
// Program the mock to return 45.0 exactly twice.
EXPECT_CALL(fake_sensor, read_temperature())
.Times(2)
.WillRepeatedly(testing::Return(45.0f));
</pre>

=== 1.2 CMake Debug & Coverage Setup ===
Coverage mathematically requires a completely unoptimized binary mapping exactly to your source code lines.
<pre>
if(CMAKE_BUILD_TYPE STREQUAL "Debug")
target_compile_options(my_target PRIVATE -O0 -g --coverage)
target_link_options(my_target PRIVATE --coverage)
endif()
</pre>

=== 1.3 Running gcovr ===
Execute this from inside your <code>build/</code> directory after running the tests:
<pre>
gcovr -r ../ . --html --html-details -o coverage.html -e ".*_deps.*"
</pre>

== Part 2: The Challenges ==

=== Setup: The Raw Materials ===
You are building the safety controller for an industrial oven. It must read temperatures from an I2C sensor and trigger a physical alarm if it overheats.

Create a new workspace (<code>sdpt-lab4</code>). Create <code>include/</code> and <code>src/</code> directories. Populate them with these three files:

'''<code>include/ISensor.h</code>''' (The Hardware Interface)
<pre>
#pragma once

// Pure virtual interface. We DO NOT implement hardware logic here.
class ISensor {
public:
virtual float read_temperature() = 0;
virtual ~ISensor() = default;
};
</pre>

'''<code>include/OvenController.h</code>''' (The Logic Module)
<pre>
#pragma once
#include "ISensor.h"

class OvenController {
private:
ISensor* temp_sensor;
bool alarm_active;
float max_safe_temp;

public:
// Constructor uses Dependency Injection!
OvenController(ISensor* sensor, float safe_limit = 250.0f);

void check_safety();
bool is_alarm_active() const;

// Pure math function
static float raw_adc_to_celsius(int adc_value);
};
</pre>

'''<code>src/OvenController.cpp</code>''' (The Buggy Implementation)
<pre>
#include "../include/OvenController.h"

OvenController::OvenController(ISensor* sensor, float safe_limit)
: temp_sensor(sensor), alarm_active(false), max_safe_temp(safe_limit) {}

void OvenController::check_safety() {
float current_temp = temp_sensor->read_temperature();

// BUG 1: It only triggers if STRICTLY greater. What if it equals the limit?
if (current_temp > max_safe_temp) {
alarm_active = true;
} else {
alarm_active = false;
}
}

bool OvenController::is_alarm_active() const {
return alarm_active;
}

float OvenController::raw_adc_to_celsius(int adc_value) {
// BUG 2: Integer division truncates the decimal! (e.g., 5/2 = 2, not 2.5)
return (adc_value / 4095) * 330.0f;
}
</pre>

=== Challenge 1: The Verification Build System (Estimated: 20 mins) ===
We need a build system that fetches Google Test and compiles our code with coverage instrumentation.
'''Your Task:'''
# Create a <code>CMakeLists.txt</code> in the root directory.
# Build a static library named <code>oven_lib</code> containing <code>src/OvenController.cpp</code>.
# Use <code>FetchContent</code> to pull Google Test (<code>https://github.com/google/googletest.git</code>, tag <code>v1.13.0</code>).
# Create an executable named <code>unit_tests</code>. (You will create <code>tests/test_oven.cpp</code> in the next step).
# Link <code>oven_lib</code>, <code>gtest_main</code>, and <code>gmock</code> to your test executable.
# Add the CMake logic to inject <code>-O0 -g --coverage</code> ONLY if the build type is "Debug".

'''Verification:''' Run <code>cmake -DCMAKE_BUILD_TYPE=Debug ..</code> inside your build folder. It must configure without errors and download GTest.

=== Challenge 2: Pure Math TDD (Estimated: 25 mins) ===
Let's catch the integer division bug using the Red-Green-Refactor cycle.
'''Your Task:'''
# Create a <code>tests/</code> directory and a <code>tests/test_oven.cpp</code> file.
# Include <code><gtest/gtest.h></code> and your <code>OvenController.h</code>.
# Write a <code>TEST(MathTest, ConvertsADCToCelsius)</code>.
# Use <code>EXPECT_FLOAT_EQ</code> to assert that an ADC value of <code>2047</code> (roughly half of 4095) returns approximately <code>164.957f</code>.
# Compile and run <code>./unit_tests</code>. (Watch it fail! This is the RED phase).
# Refactor <code>OvenController.cpp</code> to fix the integer division bug. Recompile. (Watch it pass! This is the GREEN phase).

=== Challenge 3: Hardware Mocking (Estimated: 40 mins) ===
We need to test <code>check_safety()</code>, but we are on a PC. We have no I2C hardware. We must mock the <code>ISensor</code>.
'''Your Task:'''
# In your test file, include <code><gmock/gmock.h></code>.
# Create a <code>MockSensor</code> class that inherits from <code>ISensor</code>. Use <code>MOCK_METHOD</code> to mock <code>read_temperature</code>.
# Write a <code>TEST(SafetyTest, TriggersAlarmOnOverheat)</code>.
#* '''Arrange:''' Instantiate the MockSensor. Instantiate the OvenController, injecting the mock sensor into it with a safe limit of 250.0f.
#* '''Expectation:''' Program the mock to return <code>260.0f</code> when called.
#* '''Act:''' Call <code>check_safety()</code>.
#* '''Assert:''' Expect that <code>is_alarm_active()</code> is true.
# Write a second test: <code>TEST(SafetyTest, TriggersAlarmExactlyAtLimit)</code>.
#* Program the mock to return exactly <code>250.0f</code>.
#* Run the test. It will FAIL due to Bug 1. Fix the production code so it triggers on `>=`.

=== Challenge 4: The Coverage Report (Estimated: 15 mins) ===
Did we test every branch of our code? Let's prove it mathematically.
'''Your Task:'''
# Ensure you have run <code>./unit_tests</code> at least once so the <code>.gcda</code> files are generated.
# Run the <code>gcovr</code> command provided in the Theoretical Reference section.
# Open the resulting <code>coverage.html</code> file in your web browser.

'''Verification:''' Click on the <code>OvenController.cpp</code> file in the HTML report. You should see 100% line coverage and 100% branch coverage (green lines). If you have red lines, you are missing a test case!

== Lab Evaluation ==
To receive full credit, call the professor/TA to your workstation and demonstrate:
# Run <code>./unit_tests</code>. All tests must pass (Green).
# Show your test code, explaining how Dependency Injection allowed you to pass the <code>MockSensor</code> into the controller.
# Open your <code>coverage.html</code> report in the browser, demonstrating 100% branch coverage for the <code>OvenController.cpp</code> file.

@@ Linia 10: / Linia 10: @@
 * Simulate hardware interactions using Google Mock (GMock).
 * Generate interactive HTML Code Coverage reports using <code>gcovr</code>.
 == Part 1: Theoretical Reference ==
@@ Linia 54: / Linia 53: @@
 </pre>
 == Part 2: The Challenges ==
@@ Linia 124: / Linia 129: @@
+}
 </pre>
 === Challenge 1: The Verification Build System (Estimated: 20 mins) ===
@@ Linia 137: / Linia 141: @@
 '''Verification:''' Run <code>cmake -DCMAKE_BUILD_TYPE=Debug ..</code> inside your build folder. It must configure without errors and download GTest.
 === Challenge 2: Pure Math TDD (Estimated: 25 mins) ===
@@ Linia 148: / Linia 151: @@
 # Compile and run <code>./unit_tests</code>. (Watch it fail! This is the RED phase).
 # Refactor <code>OvenController.cpp</code> to fix the integer division bug. Recompile. (Watch it pass! This is the GREEN phase).
 === Challenge 3: Hardware Mocking (Estimated: 40 mins) ===
@@ Linia 163: / Linia 165: @@
 #* Program the mock to return exactly <code>250.0f</code>.
 #* Run the test. It will FAIL due to Bug 1. Fix the production code so it triggers on `>=`.
 === Challenge 4: The Coverage Report (Estimated: 15 mins) ===
@@ Linia 170: / Linia 171: @@
 # Ensure you have run <code>./unit_tests</code> at least once so the <code>.gcda</code> files are generated.
 # Run the <code>gcovr</code> command provided in the Theoretical Reference section.
-# Open the resulting <code>coverage.html</code> file in your web browser.
+# Open the resulting <code>coverage.html</code> file in your web browser. Check that you have achieved 100% branch coverage.
-'''Verification:''' Click on the <code>OvenController.cpp</code> file in the HTML report. You should see 100% line coverage and 100% branch coverage (green lines). If you have red lines, you are missing a test case!
+== Submission and Evaluation (Moodle VPL) ==
-== Lab Evaluation ==
+The VPL server will automatically compile your CMake project, execute your Google Tests, and run <code>gcovr</code>. Your grade will be calculated based on the number of passing tests and the percentage of branch coverage achieved.