Lab-09: Software Testing and Quality Assurance

1. Tools. Verify the toolchain from Lab-08 and add the test and analysis tools. gcov ships with GCC; gcovr is a Python package. MSVC does not produce gcov data: Windows users measure coverage in WSL (Ubuntu) or rely on the CI coverage job of Task 4, and can still run all tests with MSVC.

   git switch main && git pull && git switch -c lab-09
   cmake --version            # 3.28 or later
   g++ --version              # GCC 13 or later (or clang++ 17 or later)
   python -m pip install --user gcovr     # or: pipx install gcovr
   gcovr --version
   clang-tidy --version       # any current release (LLVM, or Visual Studio 2022 "C++ Clang tools")
   cppcheck --version         # 2.13 or later
   gh --version               # optional: GitHub CLI to file issues from the terminal
   # WSL / Ubuntu in one line:
   # sudo apt install build-essential cmake gcovr clang-tidy cppcheck

2. Inputs from earlier labs. This lab reuses the acceptance criteria and traceability matrix of Lab-05, the state machine of Lab-06, the Sprint 2 backlog of Lab-07 and the C++ code and CI pipeline of Labs 07 and 08. If one of them is incomplete, use the fallback; do not stop to repair the earlier lab. If your file names differ, keep yours and name them in lab09/README.md.

   Input	File	What you need from it	Fallback if missing
   Acceptance criteria	lab05/user-stories.md	Gherkin scenarios of the register, cancel and check-in stories	Write one Given/When/Then per rule of the case-study brief below into lab09/test-design.md.
   Traceability matrix	lab05/traceability-matrix.csv	FR ids, story ids, an empty test column	Use the fallback ids of the brief: FR-05 create event, FR-11 register, FR-12 cancel, FR-13 check-in, FR-14 waiting list (Should).
   Registration state machine	lab06/ (state machine diagram)	States and transitions of a Registration	Registered → Cancelled (cancel), Registered → CheckedIn (check-in), Waitlisted → Registered (seat freed, Should).
   Sprint 2 backlog and definition of done	lab07/ and the GitHub Project board	Which stories are in Sprint 2; the team's DoD	Stories: register, cancel, check-in, attendance list. DoD: reviewed PR, tests pass in CI, acceptance criteria met.
   C++ code	include/clubhub/, src/, tests/	RegistrationService with registerStudent, cancel, checkIn; EventRepository, RegistrationRepository	The fallback header in step 5; implement the rules of the brief before Task 3.
   CI pipeline	.github/workflows/ci.yml (Lab-08)	Build matrix GCC + Clang running ctest; protected main	The coverage job of Task 4 also works on its own; protect main with one required review.

3. Case-study brief. The box below holds everything about the product that this lab needs. Where a step says "the brief", it means this box.
   Case-study brief: ITC Club Hub, the rules under test

   Product

   ITC Club Hub for the student clubs of the Institute of Technology of Cambodia. Club leaders register a club, an administrator approves it; approved clubs publish events (title, date and time, location, capacity, description); students browse, register, cancel and get a reminder; organisers check students in at the door and see attendance; administrators see a monthly report. The C++20 core (domain model, rules, CLI, CSV storage) is what you test.

   Register (FR-11)

   The event must exist and must not have started (now < start). The student must not already hold a Registered or CheckedIn registration for it; a student who cancelled may register again. Seats taken (Registered + CheckedIn) must be below capacity, otherwise the request is rejected with EventFull (or Waitlisted once the Should story FR-14 is built).

   Create event (FR-05)

   Capacity is at least 1; only a club with status Approved may publish.

   Cancel (FR-12)

   Only a Registered registration can be cancelled, and only while now ≤ start − 24 h (the deadline itself is still allowed). Cancelling frees the seat.

   Check-in (FR-13)

   Only a Registered student can be checked in (not Cancelled, Waitlisted or already CheckedIn). Fallback window, to confirm with your Product Owner: from start − 60 min to start + 120 min, both ends included.

   Time

   Resolution one minute. Time points are std::chrono::system_clock::time_point values; the CLI shows local time (UTC+7). The service never calls system_clock::now() itself: it asks an injected Clock.

   Domain names

   Namespace clubhub: Club, Event, Student, Registration, ClubStatus (Pending, Approved, Rejected), RegistrationStatus (Registered, Cancelled, CheckedIn, Waitlisted), RegistrationService with registerStudent, cancel, checkIn, and the EventRepository / RegistrationRepository interfaces with CSV implementations.

   Personal data

   Student id, name, email, optional phone, memberships, attendance. Test data, issues and reports use invented ids (e20230001…) and names only, never real students.

   Rhythm and roles

   Sprint 2 runs in weeks 11 and 12; this lab is week 11. The Product Owner approves the test plan and runs the acceptance test with the client (the instructor or TA); the Sprint 2 Scrum Master keeps the board and the time boxes; one developer is chosen as test lead at sprint planning.

4. Deliverable folder. Create lab09/ with these files (empty for now); every task fills some of them. Code goes to the usual project folders.

   clubhub/
   ├── include/clubhub/clock.hpp              # Task 3 (Clock, SystemClock)
   ├── src/  (RegistrationService takes a Clock)
   ├── tests/
   │   ├── fake_clock.hpp                     # Task 3
   │   ├── in_memory_repositories.hpp         # Task 3
   │   └── registration_service_test.cpp      # Task 3 (+ Task 4 extra tests)
   ├── .clang-tidy                            # Task 5
   ├── .github/
   │   ├── workflows/ci.yml                   # Task 4 adds the coverage job
   │   ├── pull_request_template.md           # Task 5 (review checklist)
   │   └── ISSUE_TEMPLATE/bug_report.md       # Task 5
   └── lab09/
       ├── test-plan.md                       # Task 1
       ├── test-design.md                     # Task 2 (partitions, boundaries, coverage table)
       ├── test-cases.csv                     # Task 2 (+ Task 4 rows)
       ├── traceability-matrix.csv            # Task 2 (v2 of Lab-05's matrix)
       ├── coverage-summary.txt               # Task 4
       ├── coverage-notes.md                  # Task 4
       ├── code-review.md                     # Task 5
       ├── static-analysis.md                 # Task 5
       ├── bug-reports.md                     # Task 5
       ├── README.md                          # Task 5 (record what changed)
       ├── exploratory-session.md             # Challenge
       └── acceptance-test-script.md          # Challenge

5. Fallback interfaces. If your Lab-07 code has no service yet, start from this header (adapt names to your code if they already exist; the tests of this lab assume these member functions).

   // include/clubhub/registration_service.hpp (fallback)
   #pragma once
   #include <optional>
   #include <stdexcept>
   #include <string>
   #include "clubhub/clock.hpp"
   #include "clubhub/event.hpp"
   #include "clubhub/registration.hpp"
   
   namespace clubhub {
   
   enum class Rule {
       EventNotFound, EventInPast, AlreadyRegistered, EventFull,
       NotRegistered, CancellationClosed, CheckInClosed
   };
   
   class RuleViolation : public std::runtime_error {
   public:
       explicit RuleViolation(Rule rule)
           : std::runtime_error{"business rule violated"}, rule_{rule} {}
       [[nodiscard]] Rule rule() const noexcept { return rule_; }
   private:
       Rule rule_;
   };
   
   class EventRepository {
   public:
       virtual ~EventRepository() = default;
       // throws RuleViolation{Rule::EventNotFound} for an unknown id
       virtual const Event& get(int eventId) const = 0;
       virtual void save(const Event& event) = 0;
   };
   
   class RegistrationRepository {
   public:
       virtual ~RegistrationRepository() = default;
       virtual std::optional<Registration> find(const std::string& studentId,
                                                int eventId) const = 0;
       // Registered + CheckedIn registrations of the event
       virtual int countActive(int eventId) const = 0;
       virtual void save(const Registration& registration) = 0;
       virtual void setStatus(const std::string& studentId, int eventId,
                              RegistrationStatus status) = 0;
   };
   
   class RegistrationService {
   public:
       RegistrationService(EventRepository& events, RegistrationRepository& regs,
                           const Clock& clock)
           : events_{events}, regs_{regs}, clock_{clock} {}
       Registration registerStudent(const std::string& studentId, int eventId);
       void cancel(const std::string& studentId, int eventId);
       void checkIn(const std::string& studentId, int eventId);
   private:
       EventRepository& events_;
       RegistrationRepository& regs_;
       const Clock& clock_;
   };
   
   }  // namespace clubhub

Goal

Write a one-page lab09/test-plan.md that says what Sprint 2 will test, at which levels and with which techniques, in which environment, who does what, and which measurable entry and exit criteria decide whether the increment can be released.

Steps

1. At sprint planning, choose the test lead (one developer). The test lead creates lab09/test-plan.md from the starter with version v1.0, the date, and the names of the Product Owner and test lead.
2. Section 1 Scope: list the Sprint 2 stories from the board with their FR ids (at least register, cancel and check-in). List at least three items out of scope with a reason (for example reminders: story not in Sprint 2; GUI: optional, not built; monthly report: Sprint 3).
3. Section 2 Levels and techniques: one row per level (unit, integration, system, acceptance) naming what is tested, the technique (EP and BVA, branch coverage, scripted CLI test cases, Gherkin acceptance), the tool (GoogleTest + CTest, gcovr, a shell script, manual) and who runs it.
4. Section 3 Environment: compilers and operating systems (GCC 13 and Clang 17 on ubuntu-latest in CI, the compilers on members' laptops), test data (tests/data/*.csv with invented ids only), time control (FakeClock in unit tests; a CLI --now option if you add one).
5. Sections 4 and 5 Entry and exit criteria: at least three of each, all measurable. The exit criteria must include "branch coverage of RegistrationService ≥ 80 %", "every Must test case passes in CI" and a rule about open defects by severity.
6. Sections 6 and 7 Roles, schedule and risks: a day-by-day table for weeks 11 and 12, and at least four risks with the test response (for example dates and time zones, corrupt CSV lines, a misunderstood rule, two members editing the same CSV file).
7. Open a pull request with only this file; the Product Owner reviews and approves it (the approval in GitHub is the sign-off). Commit message: Lab-09 task 1: test plan.

Starter template

# Test plan · ITC Club Hub · Sprint 2 (v1.0, 2026-11-__)
Product Owner: ____   Test lead: ____   Scrum Master (Sprint 2): ____

## 1. Scope
| Story | FR ids | In scope for testing |
|-------|--------|----------------------|
| US-__ Register for an event | FR-11 | yes |
Out of scope (and why):
-

## 2. Test levels and techniques
| Level | What is tested | Technique | Tool | Who |
|-------|----------------|-----------|------|-----|
| Unit | RegistrationService rules | EP, BVA, branch coverage | GoogleTest, gcovr | developers |

## 3. Environment
## 4. Entry criteria
## 5. Exit criteria
## 6. Roles and schedule
| Day | Activity | Who |
|-----|----------|-----|
## 7. Risks
| Risk | Likelihood | Impact | Test response |
|------|------------|--------|---------------|
## 8. Deliverables
test-cases.csv, automated tests in tests/, coverage report (CI artifact),
test summary report at the sprint review

Expected output (excerpt of sections 2 and 5)

| Level       | What is tested                      | Technique              | Tool                | Who        |
| Unit        | RegistrationService, Event          | EP, BVA, branch cov.   | GoogleTest, gcovr   | developers |
| Integration | service + CsvRegistrationRepository | round trip, bad lines  | GoogleTest, tmp dir | developers |
| System      | CLI commands on prepared CSV data   | scripted test cases    | tests/system.sh     | test lead  |
| Acceptance  | Gherkin scenarios of Lab-05         | acceptance test script | manual, with client | PO         |

5. Exit criteria
- every Must test case in test-cases.csv passes in CI (GCC and Clang)
- branch coverage of src/registration_service.cpp >= 80 % (gcovr gate)
- no open Critical or Major defect; Minor ones listed in the test report
- test summary report presented at the sprint review

Show hints

Acceptance checklist

Goal

Derive equivalence classes and boundary values for the register, create-event, cancel and check-in rules of the brief, turn them into at least 18 test cases with concrete expected results in lab09/test-cases.csv, and trace every case to an FR id.

Steps

1. Split the rules among the developers (register and create event, cancel, check-in). In lab09/test-design.md, list for each rule its conditions: numeric inputs (seats taken, capacity), times relative to the start, the student's registration status, whether the event exists.
2. For each condition, write the valid and invalid partitions in a table and give them ids (EP-R1… for register, EP-C1… for cancel, EP-K1… for check-in). Do not forget non-numeric partitions such as "previously Cancelled".
3. For every ordered partition, write the boundary values (BV-R1…) with a one-minute and one-seat resolution: at least 2-value BVA everywhere, 3-value BVA for the 24-hour deadline and both ends of the check-in window.
4. Derive the test cases in lab09/test-cases.csv (columns of the starter): every partition and every boundary value covered at least once; at least 18 rows (register and create event ≥ 8, cancel ≥ 5, check-in ≥ 5). The expected result is concrete: the new status, the Rule of the exception, the seat count.
5. Fill level (unit, integration, system, acceptance) and leave automated_by empty for now; Task 3 fills it with the GoogleTest name. System-level rows describe CLI commands exactly.
6. Trace: map every Gherkin scenario of Lab-05 for these stories to at least one test case. Copy lab05/traceability-matrix.csv to lab09/traceability-matrix.csv, raise its version to v2 and fill the test_cases column; any FR id of Sprint 2 without a test case goes into a Gaps list with a decision.
7. Another developer checks the coverage table at the end of test-design.md (partition or boundary id → test case ids) and signs it with their name. Commit: Lab-09 task 2: test design.

Starter

# Test design · Sprint 2 (v1.0)

## FR-11 registerStudent (capacity C = 3 in the unit tests)
| Condition | Valid partitions | Invalid partitions | Boundary values |
|-----------|------------------|--------------------|-----------------|
| seats taken k | EP-R1 0 ≤ k ≤ C−1 | EP-R2 k ≥ C (EventFull) | BV-R1 k = C−1, BV-R2 k = C; C = 1: k = 0, 1 |
| time t vs start S | EP-R3 t < S | EP-R4 t ≥ S (EventInPast) | BV-R3 S − 1 min, BV-R4 S |
| student's status | EP-R5 none, EP-R6 Cancelled | EP-R7 Registered or CheckedIn | n/a |
| event id | EP-R8 exists | EP-R9 unknown (EventNotFound) | n/a |

## FR-12 cancel · ## FR-13 checkIn · ## FR-05 create event   (TODO)

## Coverage table (checked by: ____)
| Partition / boundary | Test cases |
|----------------------|------------|
| EP-R1 | TC-REG-01 |

id,fr_id,rule,technique,partition_or_boundary,precondition,steps,input,expected,level,automated_by
TC-REG-01,FR-11,register,EP,EP-R1 seat free,"C=3, k=1, now=S-72h",registerStudent,"e20230001, event 1","Registered; countActive = 2",unit,
TC-REG-02,FR-11,register,BVA,BV-R1 last seat,"C=3, k=2, now=S-72h",registerStudent,"e20230003, event 1","Registered; event full",unit,
TC-REG-03,FR-11,register,BVA,BV-R2 no seat left,"C=3, k=3, now=S-72h",registerStudent,"e20230004, event 1","RuleViolation EventFull; countActive = 3",unit,
TC-CAN-02,FR-12,cancel,BVA,BV-C2 on the deadline,"e20230001 Registered, now=S-24h",cancel,"e20230001, event 1","Cancelled; countActive - 1",unit,
TC-SYS-01,FR-12,cancel,BVA,BV-C3 just after deadline,"data/ with event 1 at 2026-11-20 18:00","clubhub --now ""2026-11-19 18:01"" cancel e20230001 1","e20230001, event 1","prints Error: cancellation closed; exit code 2",system,
# TODO: at least 18 rows in total

Expected output (summary at the top of test-design.md)

Show hints

Acceptance checklist

Goal

Implement every unit-level row of test-cases.csv as a GoogleTest test: a fixture with in-memory repositories and a FakeClock, parameterised tests for the boundaries, and assertions on the exact rule that was violated. All tests pass locally and in CI on GCC and Clang.

Steps

1. Add include/clubhub/clock.hpp with Clock and SystemClock (as on slide 15 of the chapter). Change the RegistrationService constructor to take a const Clock&; main.cpp passes a SystemClock. Then git grep "system_clock::now" src/ must find nothing.
2. Add tests/fake_clock.hpp and tests/in_memory_repositories.hpp (starter). Unit tests must never read or write the real data/ folder.
3. In tests/registration_service_test.cpp, create the fixture RegistrationServiceTest and implement each unit-level test case as a TEST_F with a // TC-REG-03 comment above it. Write the test name into the automated_by column of test-cases.csv.
4. Implement the boundaries as parameterised tests: CancelDeadlineTest (D − 1 min, D, D + 1 min, S), CapacityBoundaryTest (C = 1 and C = 3, k = C − 1 and k = C) and CheckInWindowTest (S − 61, S − 60, S + 120, S + 121 min).
5. Assert the rule, not only the exception type: use the expectRule helper from the hints, so that an EventFull thrown where EventInPast was expected fails the test.
6. Add the new test files to clubhub_tests in CMakeLists.txt, then run cmake --build build && ctest --test-dir build --output-on-failure. A test that fails because the code is wrong is good news: fix the code in a separate commit that names the test case.
7. Push, open a pull request, and make CI green in both matrix legs. Check that every developer authored test commits: git shortlog -sn -- tests/.

Starter code

// tests/in_memory_repositories.hpp
#pragma once
#include <algorithm>
#include <map>
#include <utility>
#include "clubhub/registration_service.hpp"

namespace clubhub {

class InMemoryEventRepository final : public EventRepository {
public:
    const Event& get(int eventId) const override {
        const auto it = events_.find(eventId);
        if (it == events_.end()) {
            throw RuleViolation{Rule::EventNotFound};
        }
        return it->second;
    }
    void save(const Event& event) override { events_.insert_or_assign(event.id(), event); }
private:
    std::map<int, Event> events_;
};

class InMemoryRegistrationRepository final : public RegistrationRepository {
public:
    std::optional<Registration> find(const std::string& studentId,
                                     int eventId) const override {
        const auto it = regs_.find({studentId, eventId});
        if (it == regs_.end()) { return std::nullopt; }
        return it->second;
    }
    int countActive(int eventId) const override {
        return static_cast<int>(std::ranges::count_if(regs_, [eventId](const auto& kv) {
            const Registration& r = kv.second;
            return r.eventId == eventId && (r.status == RegistrationStatus::Registered ||
                                           r.status == RegistrationStatus::CheckedIn);
        }));
    }
    void save(const Registration& r) override { regs_.insert_or_assign({r.studentId, r.eventId}, r); }
    void setStatus(const std::string& studentId, int eventId,
                   RegistrationStatus status) override {
        regs_.at({studentId, eventId}).status = status;
    }
private:
    std::map<std::pair<std::string, int>, Registration> regs_;
};

}  // namespace clubhub

// tests/registration_service_test.cpp
#include <gtest/gtest.h>
#include <chrono>
#include <ostream>
#include <string>
#include "fake_clock.hpp"
#include "in_memory_repositories.hpp"

using namespace std::chrono;
using namespace clubhub;

class RegistrationServiceTest : public ::testing::Test {
protected:
    static constexpr int kEventId = 1;
    // 2026-11-20 18:00 local time (UTC+7) = 11:00 UTC
    const TimePoint start = sys_days{2026y / November / 20} + 11h;
    FakeClock clock{start - 72h};
    InMemoryEventRepository events;
    InMemoryRegistrationRepository regs;
    RegistrationService service{events, regs, clock};

    void SetUp() override {
        events.save(Event{kEventId, "C++ Workshop", start, "B-201", 3});
    }
    // registers students s1..sk so that k seats are taken
    void fillSeats(int k) {
        for (int i = 1; i <= k; ++i) {
            service.registerStudent("s" + std::to_string(i), kEventId);
        }
    }
};

// TC-REG-01 (FR-11, EP-R1 seat free)
TEST_F(RegistrationServiceTest, RegistersWhenSeatIsFree) {
    fillSeats(1);
    service.registerStudent("e20230001", kEventId);
    const auto reg = regs.find("e20230001", kEventId);
    ASSERT_TRUE(reg.has_value());
    EXPECT_EQ(reg->status, RegistrationStatus::Registered);
    EXPECT_EQ(regs.countActive(kEventId), 2);
}

// TC-REG-03 (FR-11, BV-R2 no seat left)
TEST_F(RegistrationServiceTest, RejectsWhenFull) {
    // TODO: fill 3 seats, expect Rule::EventFull, count stays 3
}

// TC-CAN-01..04 (FR-12, 3-value BVA around D = S - 24 h, plus S)
struct CancelCase {
    minutes beforeStart;
    bool allowed;
};
// readable parameter values in gtest and ctest output
void PrintTo(const CancelCase& c, std::ostream* os) {
    *os << c.beforeStart.count() << "min_before_" << (c.allowed ? "allowed" : "rejected");
}
class CancelDeadlineTest : public RegistrationServiceTest,
                           public ::testing::WithParamInterface<CancelCase> {};

TEST_P(CancelDeadlineTest, AppliesThe24HourRule) {
    // TODO: register e20230001, clock.set(start - beforeStart), cancel,
    //       check the status (allowed) or Rule::CancellationClosed
}
INSTANTIATE_TEST_SUITE_P(Boundaries, CancelDeadlineTest,
    ::testing::Values(CancelCase{24h + 1min, true} /* TODO: D, D + 1 min, S */));

// TODO: CapacityBoundaryTest, CheckInWindowTest, remaining TEST_F cases

Expected output

$ ctest --test-dir build --output-on-failure
Test project /home/runner/work/clubhub/clubhub/build
      Start  1: EventTest.KeepsTitleAndCapacity
 1/34 Test  #1: EventTest.KeepsTitleAndCapacity .................................   Passed    0.01 sec
      Start  2: RegistrationServiceTest.RegistersWhenSeatIsFree
 2/34 Test  #2: RegistrationServiceTest.RegistersWhenSeatIsFree .................   Passed    0.01 sec
...
      Start 21: Boundaries/CancelDeadlineTest.AppliesThe24HourRule/1439min_before_rejected
21/34 Test #21: Boundaries/CancelDeadlineTest.AppliesThe24HourRule/1439min_before_rejected ...   Passed    0.01 sec
...
34/34 Test #34: Window/CheckInWindowTest.AppliesTheWindow/121min_after_start_rejected ........   Passed    0.01 sec

100% tests passed, 0 tests failed out of 34

Total Test time (real) =   0.52 sec

Show hints

Acceptance checklist

Goal

Add a coverage job to the pipeline that measures statement and branch coverage with gcov and gcovr, fails when branch coverage of RegistrationService drops below 80 %, publishes the HTML report, and document which lines stay uncovered and why.

Steps

1. Add the CLUBHUB_COVERAGE option of the starter to CMakeLists.txt, before the first add_library or add_executable, so that every target is instrumented.
2. On Linux, macOS or WSL with GCC: configure build-cov with -DCMAKE_BUILD_TYPE=Debug -DCLUBHUB_COVERAGE=ON, build, run ctest, then run gcovr with --html-details coverage/index.html --print-summary and open the report. (Windows only: skip to step 3 and read the report from the CI artifact.)
3. Add the coverage job of the starter to .github/workflows/ci.yml. It runs after your build job (adjust needs: to your job id), installs gcovr, uploads coverage/ as the artifact coverage-report and runs the gate --fail-under-branch 80 on src/registration_service.cpp.
4. Open the report for registration_service.cpp. For every red line and every yellow (partially taken) branch, decide: missing test, or code that cannot be reached? Add tests for the missing ones, each as a new row in test-cases.csv with technique branch, until branch coverage is at least 80 %.
5. Save the --print-summary output for the whole src/ and for registration_service.cpp into lab09/coverage-summary.txt, with the commit hash.
6. Write lab09/coverage-notes.md: a table of every line or branch that stays uncovered, why (Should feature not built, defensive code, file-system failure that needs fault injection) and the decision. You may mark at most three truly unreachable lines with // GCOVR_EXCL_LINE plus a comment explaining why.
7. Commit: Lab-09 task 4: coverage in CI. The pull request must show the coverage job green.

Starter

# CMakeLists.txt, near the top (before add_library / add_executable)
option(CLUBHUB_COVERAGE "Instrument the build for gcov" OFF)
if(CLUBHUB_COVERAGE)
  if(CMAKE_CXX_COMPILER_ID MATCHES "GNU|Clang")
    add_compile_options(--coverage -O0 -g)
    add_link_options(--coverage)
  else()
    message(WARNING "Coverage needs GCC or Clang; option ignored")
  endif()
endif()

# .github/workflows/ci.yml: add this job next to your build job
  coverage:
    runs-on: ubuntu-latest
    needs: build            # the id of your Lab-08 build job
    steps:
      - uses: actions/checkout@v4
      - name: Install gcovr
        run: pipx install gcovr
      - name: Configure with coverage (GCC)
        run: cmake -S . -B build-cov -DCMAKE_BUILD_TYPE=Debug -DCLUBHUB_COVERAGE=ON
      - name: Build and test
        run: |
          cmake --build build-cov -j
          ctest --test-dir build-cov --output-on-failure
      - name: Coverage report
        run: |
          mkdir -p coverage
          gcovr -r . build-cov --filter src/ \
                --exclude-throw-branches --exclude-unreachable-branches \
                --html-details coverage/index.html --print-summary
      - name: Branch coverage gate (RegistrationService)
        run: |
          gcovr -r . build-cov --filter 'src/registration_service\.cpp' \
                --exclude-throw-branches --exclude-unreachable-branches \
                --print-summary --fail-under-branch 80
      - uses: actions/upload-artifact@v4
        if: always()
        with:
          name: coverage-report
          path: coverage/

Expected output

flowchart LR
  P["push / pull request"] --> B["build matrix
GCC 13 · Clang 17"]
  B --> T["ctest
34 tests"]
  T --> C["coverage job
--coverage -O0"]
  C --> R["gcovr HTML report
artifact coverage-report"]
  C --> G{"branches of
registration_service.cpp
at least 80 %?"}
  G -- yes --> OK(["check green, merge allowed"])
  G -- no --> KO(["check red, merge blocked"])

# lab09/coverage-summary.txt (commit 9e41b7a)
src/ (all files)
lines: 91.2% (145 out of 159)
functions: 96.0% (24 out of 25)
branches: 78.6% (66 out of 84)

src/registration_service.cpp
lines: 96.3% (52 out of 54)
functions: 100.0% (7 out of 7)
branches: 86.4% (19 out of 22)

Show hints

Acceptance checklist

Goal

Run the three quality-assurance practices of the chapter on your own code: a checklist-based peer review of another member's pull request, one static-analysis run whose findings you fix or justify, and three reproducible bug reports filed as GitHub issues, one of them driven to Closed. Finish by recording what changed.

Steps

1. Add .github/pull_request_template.md with the C++ review checklist and .github/ISSUE_TEMPLATE/bug_report.md (starters below). Merge them first so that the following PRs and issues use them.
2. Peer review. Rotate so that every member reviews a pull request written by someone else (for example the Task 3 test PRs). The reviewer leaves at least three comments, each starting with its checklist area (Ownership:, const:, Error handling:, Naming:, Tests:); the author answers each and pushes fixes; approve only when CI is green. Summarise in lab09/code-review.md: PR link, author, reviewer, comments per area, defects found, time spent.
3. Static analysis. Add .clang-tidy, configure with -DCMAKE_EXPORT_COMPILE_COMMANDS=ON, then run clang-tidy -p build src/*.cpp and cppcheck --enable=warning,style,performance --std=c++20 --project=build/compile_commands.json. Record every finding in lab09/static-analysis.md (tool, file:line, check id, decision, commit).
4. Fix at least five findings (or all, if there are fewer). A finding you do not fix is suppressed with // NOLINT(check-id): reason or a cppcheck inline suppression and listed with its reason. Re-run both tools and paste the final summary. Optional: add a CI step that runs cppcheck with --error-exitcode=1.
5. Bug reports. File three GitHub issues with the template, label bug, from real observations of this lab (a failing test in Task 3, a review finding, a CLI run). Each has environment, severity, steps to reproduce, expected and actual result, and the FR id; the Product Owner sets the priority. List them in lab09/bug-reports.md.
6. Drive at least one bug through the life cycle: Assigned, a fixing PR whose description says Fixes #n and that adds a regression test, Verified by the reporter, Closed. Record the states with dates in bug-reports.md.
7. Record what changed. Create lab09/README.md from the starter: the table of this lab's files with their main authors, the inputs reused from Labs 05 to 08 with their commit or version, the results (test cases, coverage, findings, bugs) and a change-log row. Commit and open the pull request Lab-09 – <team name>.

Starter files

<!-- .github/pull_request_template.md -->
## What and why
Closes #

## Review checklist (reviewer ticks; comments start with the area)
- [ ] Ownership: no naked new/delete; owners are values or unique_ptr (R.11, R.20)
- [ ] const: queries are const member functions; big inputs by const& (Con.2, F.16)
- [ ] Error handling: broken rules throw RuleViolation; no empty catch; RAII (E.2, E.6)
- [ ] Naming: PascalCase types, camelCase functions, member_ suffix (NL.8)
- [ ] Tests: every new or changed rule has a test that fails without the change
- [ ] Readability: short functions, named constants, no dead code (ES.45)
- [ ] CI green: build matrix, tests, coverage gate

---
name: Bug report
about: Report a defect in ITC Club Hub
title: "[Bug] <what happens> (violates FR-xx)"
labels: bug
---
**Environment**: commit <sha> · OS · compiler and version · Debug/Release
**Severity**: Critical | Major | Minor | Trivial
**Priority** (Product Owner): High | Medium | Low
**Requirement**: FR-xx · **Found by**: TC-xxx | review | exploratory session

**Preconditions**

**Steps to reproduce**
1.

**Expected result**

**Actual result**

**Attachments and notes** (console output, CSV excerpt; invented data only)

# .clang-tidy
Checks: >
  bugprone-*, cppcoreguidelines-*, modernize-*, performance-*,
  readability-*, -modernize-use-trailing-return-type,
  -readability-identifier-length
WarningsAsErrors: 'bugprone-*'

# Lab-09 · Testing and quality assurance (v1.0, 2026-11-__)

## Files of this lab
| File | Content | Task | Main author(s) |
|------|---------|------|----------------|
| lab09/test-plan.md | Sprint 2 test plan, approved by the PO | 1 | |
| tests/registration_service_test.cpp | fixture, TEST_P boundaries | 3 | |

## Inputs reused from earlier labs
| Input | Version or commit | Used for |
|-------|-------------------|----------|
| lab05/traceability-matrix.csv | v1, commit ____ | FR ids, copied to lab09 as v2 |
| .github/workflows/ci.yml (Lab-08) | commit ____ | coverage job added |

## Results
- Test cases: __ designed, __ automated, __ manual
- Coverage of RegistrationService: lines __ %, branches __ %
- Static analysis: __ findings, __ fixed, __ suppressed with a reason
- Bugs: #__ (Closed), #__, #__

## Change log
| Date | Version | Change | Author |
|------|---------|--------|--------|

Expected output (excerpt of static-analysis.md)

Show hints

Acceptance checklist

1. Repository layout (new or changed in this lab):

   clubhub/
   ├── CMakeLists.txt                     # CLUBHUB_COVERAGE option, new test files
   ├── .clang-tidy
   ├── .github/
   │   ├── workflows/ci.yml               # + coverage job
   │   ├── pull_request_template.md
   │   └── ISSUE_TEMPLATE/bug_report.md
   ├── include/clubhub/clock.hpp
   ├── src/                               # RegistrationService uses the Clock
   ├── tests/
   │   ├── fake_clock.hpp
   │   ├── in_memory_repositories.hpp
   │   └── registration_service_test.cpp
   └── lab09/
       ├── test-plan.md  test-design.md  test-cases.csv  traceability-matrix.csv
       ├── coverage-summary.txt  coverage-notes.md
       ├── code-review.md  static-analysis.md  bug-reports.md
       ├── README.md
       └── exploratory-session.md  acceptance-test-script.md    # challenge

2. Self-check from a clean checkout; all commands must succeed (the coverage part on Linux, macOS or WSL with GCC):

   cmake -S . -B build && cmake --build build && ctest --test-dir build
   cmake -S . -B build-cov -DCMAKE_BUILD_TYPE=Debug -DCLUBHUB_COVERAGE=ON
   cmake --build build-cov && ctest --test-dir build-cov
   gcovr -r . build-cov --filter 'src/registration_service\.cpp' \
         --exclude-throw-branches --exclude-unreachable-branches --fail-under-branch 80
   git grep -n "system_clock::now" src/ | grep -v clock.hpp    # must print nothing
   python lab09/check_test_cases.py                             # the script below

   # lab09/check_test_cases.py: every test case has an FR id and an expected result
   import csv, sys
   rows = list(csv.DictReader(open("lab09/test-cases.csv", encoding="utf-8")))
   ids = [r["id"] for r in rows]
   missing = [r["id"] for r in rows if not r["fr_id"].strip() or not r["expected"].strip()]
   duplicates = sorted({i for i in ids if ids.count(i) > 1})
   unit_not_automated = [r["id"] for r in rows if r["level"] == "unit" and not r["automated_by"].strip()]
   print(f"{len(rows)} test cases; missing FR/expected: {missing}; duplicates: {duplicates}; "
         f"unit rows without a test: {unit_not_automated}")
   sys.exit(1 if missing or duplicates or unit_not_automated or len(rows) < 18 else 0)

3. Work on branch lab-09 and open the pull request Lab-09 – <team name> against main, with the CI checks green and one approving review. Link the three bug issues and the coverage artifact in the PR description.