5.2: Sprint Work Products

Introduction

Traditional ASPICE assessments expect Word documents, PDF specifications, and formal review records. Agile teams produce Jira tickets, Git commits, and CI logs. This section provides production-ready templates for sprint artifacts that satisfy ASPICE requirements while maintaining agile velocity.

User Story Template (SWE.1 Requirement Specification)

Jira User Story Structure

# ASPICE-Compliant User Story Template
# ASPICE Process: SWE.1 (Software Requirements Analysis)

id: SWE-234
title: "Emergency Braking System - Pedestrian Detection"
type: User Story
epic: SYS-12  # Parent Epic (SYS.2 System Requirements)

# SWE.1 BP1: Specify functional requirements
description: |
  **As a** vehicle safety system
  **I want to** automatically brake when a pedestrian is detected in the vehicle path
  **So that** collisions with pedestrians are avoided

  **Safety Classification**: ASIL-D (ISO 26262)
  **System Requirement**: [SYS-45] "Vehicle shall prevent pedestrian collisions"

# SWE.1 BP2: Specify non-functional requirements
non_functional_requirements:
  performance:
    - "Detection latency: ≤ 100ms (from camera frame to brake signal)"
    - "Detection range: 5-50 meters"
  safety:
    - "False positive rate: ≤ 0.1% (avoid unnecessary braking)"
    - "False negative rate: ≤ 0.01% (ASIL-D requirement)"
  resource:
    - "CPU usage: ≤ 30% of dedicated safety core"
    - "RAM: ≤ 512 KB"

# SWE.1 BP1: Acceptance criteria (testable requirements)
acceptance_criteria:
  - id: AC-1
    description: "Given a pedestrian at 20m distance, when vehicle speed is 50 km/h, then brakes activate within 100ms"
    test_case: TC-SWE-234-1
    aspice_ref: "SWE.6 BP1: Develop qualification test strategy"

  - id: AC-2
    description: "Given no obstacles, when emergency braking activated, then deceleration rate is 8 m/s²"
    test_case: TC-SWE-234-2
    aspice_ref: "SWE.6 BP3: Perform qualification test"

  - id: AC-3
    description: "Given camera failure, when pedestrian detection unavailable, then driver warning displayed"
    test_case: TC-SWE-234-3
    aspice_ref: "SWE.6 BP3: Perform qualification test"

# SWE.1 BP5: Ensure bidirectional traceability
traceability:
  parent_requirements:
    - SYS-45: "Pedestrian collision prevention"
    - SYS-46: "Emergency braking system"
  derived_requirements:
    - SWE-235: "Pedestrian detection algorithm"
    - SWE-236: "Brake actuation interface"
  test_cases:
    - TC-SWE-234-1: "Pedestrian detection latency test"
    - TC-SWE-234-2: "Emergency braking deceleration test"
    - TC-SWE-234-3: "Camera failure handling test"

# SWE.1 BP7: Manage changes to requirements
change_history:
  - version: 1.0
    date: 2025-01-15
    author: john.doe@company.com
    change: "Initial creation"
    change_request: null

  - version: 1.1
    date: 2025-02-10
    author: jane.smith@company.com
    change: "Updated detection latency from 150ms to 100ms"
    change_request: CR-456
    rationale: "Safety assessment revealed 150ms insufficient for ASIL-D"

# MAN.3 BP7: Estimate effort
estimation:
  story_points: 13
  development_hours: 24
  testing_hours: 16
  review_hours: 4
  confidence: "Medium (new AI model integration)"

# Sprint assignment
sprint: Sprint-25
assignee: alice.johnson@company.com
priority: High

User Story Definition of Ready (DoR)

# Definition of Ready (DoR) - ASPICE SWE.1 Checklist

Before a User Story enters a sprint, it must satisfy:

## Clarity (SWE.1 BP1: Specify requirements)
- [ ] Story has clear "As a / I want / So that" structure
- [ ] Functional behavior is unambiguous
- [ ] Non-functional requirements specified (performance, safety)

## Testability (SWE.6 BP1: Qualification test strategy)
- [ ] Acceptance criteria are testable (Given/When/Then)
- [ ] Each acceptance criterion has a test case ID

## Traceability (SWE.1 BP5: Ensure traceability)
- [ ] Story traces to parent Epic (bidirectional link)
- [ ] Derived requirements identified (if any)

## Size (MAN.3 BP7: Estimate effort)
- [ ] Story is estimable (≤ 13 points; if larger, split it)
- [ ] Story can be completed within one sprint

## Dependencies (MAN.3 BP10: Monitor dependencies)
- [ ] External dependencies identified
- [ ] Blocking dependencies resolved

## Safety (ISO 26262 compliance)
- [ ] Safety classification assigned (ASIL QM/A/B/C/D)
- [ ] Safety requirements reviewed by Functional Safety Manager (if ASIL ≥ B)

---

**Scrum Master verifies DoR during backlog refinement (ASPICE MAN.3 BP5).**

Sprint Planning Artifacts (MAN.3 Project Management)

Sprint Planning Template

# Sprint 25 Planning

**Date**: 2025-02-15
**Duration**: 2 weeks (Feb 15 - Feb 28)
**Team Capacity**: 120 story points (6 developers × 20 points/dev)
**ASPICE Process**: MAN.3 (Project Management)

---

## Sprint Goal (MAN.3 BP4: Define project scope)

**Goal**: Complete pedestrian detection feature for ADAS system (Epic SYS-12)

**Success Criteria**:
1. All 5 user stories in Epic SYS-12 reach "Done" (pass acceptance tests)
2. Integration tests pass on HIL test bench (SWE.5 BP3)
3. Code coverage ≥ 85% (ASIL-D requirement per ISO 26262-6)

---

## Sprint Backlog (MAN.3 BP5: Define project activities)

### High Priority (ASIL-D Safety Features)

| Story ID | Title | Points | Assignee | ASPICE Process |
|----------|-------|--------|----------|----------------|
| SWE-234 | Emergency braking - Pedestrian detection | 13 | Alice | SWE.1, SWE.3, SWE.4 |
| SWE-235 | Pedestrian detection algorithm | 8 | Bob | SWE.3, SWE.4 |
| SWE-236 | Brake actuation interface | 5 | Charlie | SWE.3, SWE.4 |

**Subtotal**: 26 points (ASIL-D critical path)

### Medium Priority (ASIL-B Features)

| Story ID | Title | Points | Assignee | ASPICE Process |
|----------|-------|--------|----------|----------------|
| SWE-240 | Lane departure warning | 8 | Diana | SWE.1, SWE.3 |
| SWE-241 | Driver drowsiness detection | 5 | Eve | SWE.1, SWE.3 |

**Subtotal**: 13 points

### Low Priority (Tech Debt / Process Improvement)

| Story ID | Title | Points | Assignee | ASPICE Process |
|----------|-------|--------|----------|----------------|
| TECH-55 | Refactor CAN bus driver | 3 | Frank | SWE.3 (design improvement) |
| PROC-12 | Add MISRA checker to CI | 2 | Alice | SUP.1 (quality assurance) |

**Subtotal**: 5 points

**Sprint Total**: 44 points (37% capacity utilization)

---

## Velocity Planning (MAN.3 BP7: Define estimates)

| Metric | Value | Calculation |
|--------|-------|-------------|
| **Historical Velocity** | 42 points/sprint | Avg of last 3 sprints: (40 + 45 + 41) / 3 |
| **Team Capacity** | 120 points | 6 devs × 20 points/dev |
| **Planned Absences** | 20 points | Bob on vacation (1 week) |
| **Adjusted Capacity** | 100 points | 120 - 20 |
| **Committed Points** | 44 points | 44% utilization (conservative) |

**Rationale**: Conservative commitment due to ASIL-D complexity and Bob's absence.

---

## Risk Assessment (MAN.3 BP9: Identify project risks)

| Risk | Probability | Impact | Mitigation | ASPICE Ref |
|------|-------------|--------|------------|------------|
| Camera driver instability | Medium | High | Daily smoke tests on HIL bench | SWE.5 BP3 |
| MISRA violations delay merge | Low | Medium | Pre-commit MISRA checks | SWE.3 BP5 |
| Pedestrian dataset insufficient | High | High | Augment with synthetic data | SWE.4 BP2 |

---

## Definition of Done (Sprint-Level)

- [ ] All committed stories reach "Done" status
- [ ] Integration tests pass (SWE.5 BP3)
- [ ] Code coverage ≥ 85% (ASIL-D requirement)
- [ ] No critical/high SonarQube issues
- [ ] Sprint Review demo successful (Product Owner approval)
- [ ] Retrospective completed with action items

---

**Attendees**: Alice, Bob, Charlie, Diana, Eve, Frank (Dev Team) + Product Owner + Scrum Master

**ASPICE Evidence**: Stored in `Confluence://sprints/sprint-25/planning`

Daily Standup Record (MAN.3 BP10 Progress Tracking)

Automated Standup Report

# Daily Standup Bot (Slack Integration)
# ASPICE MAN.3 BP10: Monitor project progress

import requests
from datetime import datetime, timedelta

class StandupBot:
    def __init__(self, jira_url: str, slack_webhook: str):
        self.jira = JiraClient(jira_url)
        self.slack = SlackClient(slack_webhook)

    def generate_daily_report(self, sprint_id: str):
        """
        MAN.3 BP10: Monitor progress daily.
        Auto-generates standup report from Jira updates.
        """
        sprint = self.jira.get_sprint(sprint_id)
        yesterday = datetime.now() - timedelta(days=1)

        # Completed stories (last 24 hours)
        completed = self.jira.get_stories(
            sprint=sprint_id,
            status="Done",
            updated_since=yesterday
        )

        # In-progress stories
        in_progress = self.jira.get_stories(
            sprint=sprint_id,
            status="In Progress"
        )

        # Blocked stories
        blocked = self.jira.get_stories(
            sprint=sprint_id,
            has_blocker=True
        )

        # Sprint burndown
        burndown = self.calculate_burndown(sprint)

        report = f"""
        **Daily Standup - {sprint.name}** (ASPICE MAN.3 BP10)
        [DATE] Date: {datetime.now().strftime('%Y-%m-%d')}

        [PASS] **Completed Yesterday** ({len(completed)} stories, {sum(s.points for s in completed)} points):
        {self._format_stories(completed)}

        🔄 **In Progress** ({len(in_progress)} stories, {sum(s.points for s in in_progress)} points):
        {self._format_stories(in_progress)}

        🚧 **Blockers** ({len(blocked)} stories):
        {self._format_blockers(blocked)}

        [CHART] **Burndown**:
        - Remaining: {burndown['remaining']} points
        - Ideal: {burndown['ideal']} points
        - Status: {'[WARN] Behind' if burndown['remaining'] > burndown['ideal'] else '[PASS] On Track'}

        ---
        ASPICE Evidence: MAN.3 BP10 (Project Progress Monitoring)
        """

        self.slack.post_message(channel="#standup", text=report)
        self.confluence.create_page(
            space="STANDUP",
            title=f"Daily Standup {datetime.now().strftime('%Y-%m-%d')}",
            content=report
        )

        return report

    def _format_stories(self, stories: list) -> str:
        return "\n".join([f"  • [{s.id}] {s.title} ({s.points} pts) - {s.assignee}" for s in stories])

    def _format_blockers(self, stories: list) -> str:
        return "\n".join([f"  • [{s.id}] {s.title} - **Blocked by**: {s.blocker_reason}" for s in stories])

ASPICE Evidence: Daily standup logs in Confluence (MAN.3 BP10).

Sprint Review Artifacts (SWE.6 Qualification Testing)

Sprint Review Agenda Template

# Sprint 25 Review

**Date**: 2025-02-28
**Duration**: 60 minutes
**Attendees**: Dev Team, Product Owner, Stakeholders
**ASPICE Process**: SWE.6 (Software Qualification Testing)

---

## Agenda

### 1. Sprint Goal Recap (5 minutes)
**Goal**: Complete pedestrian detection feature for ADAS system

**Committed**: 44 story points
**Completed**: 42 story points (95% completion)

---

### 2. Demo: Completed Stories (30 minutes)

#### Story 1: [SWE-234] Emergency Braking - Pedestrian Detection (13 pts) [PASS]

**Demo Script**:
1. Show HIL test bench with mannequin at 20m distance
2. Vehicle approaches at 50 km/h
3. **Expected**: Brakes activate within 100ms, vehicle stops before mannequin
4. **Actual**: Brakes activated at 87ms, stopped 2.3m before mannequin [PASS]

**Acceptance Criteria Results**:
- [AC-1] Detection latency ≤ 100ms: [PASS] **PASS** (87ms measured)
- [AC-2] Deceleration rate 8 m/s²: [PASS] **PASS** (8.2 m/s² measured)
- [AC-3] Camera failure warning: [PASS] **PASS** (Warning displayed)

**ASPICE Evidence**:
- Test execution log: `test-reports/TC-SWE-234.xml`
- Video recording: `demos/sprint-25-emergency-braking.mp4`
- Product Owner sign-off: [PASS] **ACCEPTED**

---

#### Story 2: [SWE-235] Pedestrian Detection Algorithm (8 pts) [PASS]

**Demo**: Live camera feed showing bounding boxes around detected pedestrians

**Performance Metrics**:
- Detection accuracy: 98.7% (exceeds 98% requirement)
- False positive rate: 0.08% (below 0.1% threshold)
- Inference latency: 42ms (below 50ms requirement)

**ASPICE Evidence**: Unit test coverage report (94% branch coverage)

---

#### Story 3: [SWE-236] Brake Actuation Interface (5 pts) [PASS]

**Demo**: CAN bus monitor showing brake commands

**ASPICE Evidence**: Integration test results (SWE.5 BP3)

---

### 3. Incomplete Stories (5 minutes)

#### Story: [SWE-240] Lane Departure Warning (8 pts) ⏸

**Status**: 70% complete (blocked by camera calibration issue)

**Rollover to Sprint 26**: Yes

**Blocker Resolution Plan**:
- Root cause: Camera calibration coefficients incorrect
- Fix: Update calibration procedure (TECH-60 created)
- ETA: Resolved in 2 days

---

### 4. Sprint Metrics (10 minutes)

| Metric | Target | Actual | Status |
|--------|--------|--------|--------|
| Story completion | 100% | 95% | [WARN] Near miss |
| Code coverage (ASIL-D) | ≥ 85% | 94% | [PASS] Exceeds |
| MISRA violations | 0 critical | 0 critical | [PASS] Pass |
| Integration test pass rate | 100% | 100% | [PASS] Pass |
| Velocity | 42 pts (planned) | 42 pts (actual) | [PASS] On target |

---

### 5. Stakeholder Feedback (10 minutes)

**Product Owner**:
- [PASS] Pedestrian detection demo impressive
- [WARN] Request: Add nighttime testing (new story SWE-250)

**Functional Safety Manager**:
- [PASS] ASIL-D requirements satisfied
- [PASS] MC/DC coverage sufficient (94% > 85%)

**System Architect**:
- [WARN] Concern: CPU usage at 28% (close to 30% limit)
- [TOOL] Action: Profile algorithm for optimization (TECH-61)

---

## ASPICE Evidence Collection

| Work Product | Location | ASPICE Process |
|--------------|----------|----------------|
| Sprint Review Recording | `videos/sprint-25-review.mp4` | SWE.6 BP3 |
| Test Execution Logs | `test-reports/sprint-25/` | SWE.6 BP3 |
| Acceptance Sign-offs | Jira comments (Product Owner approval) | SWE.6 BP3 |
| Demo Screenshots | `screenshots/sprint-25-demo/` | SWE.6 BP3 |

---

**Next Sprint Planning**: March 1, 2025

Sprint Retrospective (SUP.1 Quality Assurance)

Retrospective Template (ASPICE SUP.1 BP7)

# Sprint 25 Retrospective

**Date**: 2025-02-28
**Duration**: 60 minutes
**Facilitator**: Scrum Master
**Attendees**: Development Team (6 people)
**ASPICE Process**: SUP.1 BP7 (Assess process implementation)

---

## Format: Start/Stop/Continue

### START Doing [PASS]

#### 1. Pre-commit MISRA Checks
**Problem**: 3 PRs rejected in code review due to MISRA violations (wasted 4 hours)

**Proposed Solution**: Add pre-commit hook for MISRA checks
```bash
# .git/hooks/pre-commit
#!/bin/bash
# ASPICE SWE.3 BP5: Ensure coding standards compliance

echo "Running MISRA C:2012 checks..."
cppcheck --addon=misra --error-exitcode=1 src/

if [ $? -ne 0 ]; then
  echo "[FAIL] MISRA violations detected. Fix before committing."
  exit 1
fi

Expected Impact: Reduce review time by 30% (catch issues before PR)

ASPICE Benefit: Earlier defect detection (SUP.1 BP3: Establish quality criteria)

Action Item: [PROC-15] "Implement pre-commit MISRA hook" - Owner: Alice - Due: Sprint 26

2. Automated Traceability Verification

Problem: 2 PRs merged without Jira links (breaks traceability)

Proposed Solution: Add CI check for Jira references

# .github/workflows/traceability-check.yml
- name: Verify Jira Link
  run: |
    PR_TITLE="${{ github.event.pull_request.title }}"
    if ! echo "$PR_TITLE" | grep -qE '\[(SWE|SYS)-[0-9]+\]'; then
      echo "ERROR: PR title must reference Jira story (e.g., [SWE-123])"
      exit 1
    fi

Expected Impact: 100% traceability compliance (currently 87%)

ASPICE Benefit: SUP.8 BP5 (Ensure traceability)

Action Item: [PROC-16] "Add traceability CI check" - Owner: Bob - Due: Sprint 26

STOP Doing 🛑

1. Manual Test Case Execution

Problem: Integration testing on HIL bench takes 4 hours/sprint (manual setup)

Proposed Solution: Automate HIL test execution with Robot Framework

*** Test Cases ***
Emergency Braking Test
    [Documentation]  ASPICE SWE.5 BP3: Integration test automation
    [Tags]  ASIL-D  HIL

    Connect To HIL Bench
    Load Vehicle Model  speed=50km/h
    Place Obstacle  distance=20m  type=pedestrian

    Start Test
    ${brake_time} =  Measure Time To Brake Activation
    Should Be True  ${brake_time} < 100  msg=Brake latency exceeds requirement

    ${stop_distance} =  Measure Stopping Distance
    Should Be True  ${stop_distance} > 2.0  msg=Stopped too close to obstacle

Expected Impact: Reduce testing time from 4h to 30 minutes (87% reduction)

ASPICE Benefit: More frequent integration testing (SWE.5 BP3)

Action Item: [TECH-62] "Automate HIL tests" - Owner: Diana - Due: Sprint 27 (larger effort)

CONTINUE Doing [PASS]

1. Pair Programming for ASIL-D Code

Outcome: Zero critical defects in ASIL-D code this sprint (normally 1-2)

ASPICE Benefit: SWE.3 BP7 (Verify design) - Live code review

Decision: Continue pair programming for all ASIL-C/D stories

2. Architecture Decision Records (ADRs)

Outcome: 3 ADRs written this sprint, helped onboard new team member

ASPICE Benefit: SWE.2 BP1 (Define architecture) - Knowledge retention

Decision: Maintain ADR discipline

Process Improvement Metrics (SUP.1 BP7)

Sprint-over-Sprint Comparison

Trend: Continuous improvement (ASPICE CL3 requirement)

Action Items Summary

ASPICE Evidence

Stored: Confluence://retrospectives/sprint-25

Work Product: SUP.1 BP7 (Process assessment record)

Follow-up: Review action items in Sprint 26 retrospective

---

## Acceptance Test Cases (SWE.6 Qualification Testing)

### Gherkin Test Specification Template

```gherkin
# File: tests/acceptance/emergency_braking.feature
# ASPICE Process: SWE.6 (Software Qualification Testing)
# Requirement: [SWE-234] Emergency Braking - Pedestrian Detection
# Safety Level: ASIL-D

Feature: Emergency Braking - Pedestrian Detection
  As a vehicle safety system
  I want to automatically brake when pedestrians are detected
  So that collisions are prevented

  Background:
    Given the vehicle is operational
    And the camera system is calibrated
    And the emergency braking system is enabled

  # SWE.6 BP3: Perform qualification test
  @ASIL-D @SWE-234 @AC-1
  Scenario: Brake activation within 100ms for pedestrian at 20m
    Given a pedestrian is positioned at 20 meters ahead
    And vehicle speed is 50 km/h
    When the camera detects the pedestrian
    Then brakes shall activate within 100 milliseconds
    And the vehicle shall stop before reaching the pedestrian
    And the stopping distance shall be at least 2 meters

  @ASIL-D @SWE-234 @AC-2
  Scenario: Correct deceleration rate during emergency braking
    Given emergency braking is activated
    When the brakes are applied
    Then the deceleration rate shall be 8.0 ± 0.5 m/s²
    And the passenger airbags shall NOT deploy
    And the brake lights shall illuminate

  @ASIL-D @SWE-234 @AC-3
  Scenario: Driver warning on camera failure
    Given the vehicle is moving at 50 km/h
    When the camera system fails
    Then a warning message shall be displayed to the driver within 500ms
    And the warning shall state "Pedestrian Detection Unavailable"
    And the emergency braking system shall be marked as degraded

  # Edge case testing (ASIL-D requires comprehensive coverage)
  @ASIL-D @SWE-234 @EdgeCase
  Scenario Outline: Variable pedestrian distances
    Given a pedestrian is positioned at <distance> meters ahead
    And vehicle speed is <speed> km/h
    When the camera detects the pedestrian
    Then brakes shall activate within <max_latency> milliseconds
    And the vehicle shall stop before the pedestrian

    Examples:
      | distance | speed | max_latency |
      | 5        | 30    | 80          |
      | 10       | 40    | 90          |
      | 20       | 50    | 100         |
      | 30       | 60    | 100         |
      | 50       | 80    | 100         |

  @ASIL-D @SWE-234 @NegativeTest
  Scenario: No false braking for stationary objects
    Given a traffic sign is positioned at 15 meters ahead
    And vehicle speed is 50 km/h
    When the camera detects the traffic sign
    Then brakes shall NOT activate
    And no warning shall be displayed

---
# ASPICE Traceability
# Requirement: [SWE-234] Emergency Braking - Pedestrian Detection
# Parent Requirement: [SYS-45] Pedestrian collision prevention
# Safety Classification: ASIL-D (ISO 26262)
# Test Coverage: 6 scenarios (including edge cases)

Python Test Implementation (Robot Framework)

# File: tests/acceptance/emergency_braking_steps.py
# ASPICE SWE.6 BP3: Qualification test implementation

from robot.api.deco import keyword
from hil_interface import HILTestBench
import time

class EmergencyBrakingSteps:
    """
    ASPICE SWE.6: Software Qualification Test Steps
    Requirement: [SWE-234] Emergency Braking
    """

    def __init__(self):
        self.hil = HILTestBench(config_file="hil_config.yaml")
        self.brake_activation_time = None

    @keyword("A pedestrian is positioned at ${distance} meters ahead")
    def position_pedestrian(self, distance: float):
        """
        SWE.6 BP2: Define qualification test cases.
        Setup test environment with pedestrian obstacle.
        """
        self.hil.place_obstacle(
            type="pedestrian",
            distance=distance,
            lateral_position=0.0  # Directly in path
        )

    @keyword("Vehicle speed is ${speed} km/h")
    def set_vehicle_speed(self, speed: float):
        """Set initial vehicle speed for test scenario"""
        self.hil.set_vehicle_speed(speed)

    @keyword("The camera detects the pedestrian")
    def wait_for_detection(self):
        """Wait for camera system to detect obstacle"""
        detection_start = time.time()
        detected = self.hil.wait_for_detection(timeout=2.0)

        if not detected:
            raise AssertionError("Camera failed to detect pedestrian within 2 seconds")

        # Record detection time for latency calculation
        self.detection_time = time.time() - detection_start

    @keyword("Brakes shall activate within ${max_latency} milliseconds")
    def verify_brake_latency(self, max_latency: float):
        """
        SWE.6 BP3: Perform qualification test.
        Verify brake activation latency (ASIL-D requirement).
        """
        brake_signal = self.hil.get_brake_signal()
        brake_activation_time = brake_signal.activation_latency_ms

        # ASPICE SWE.6: Record test result
        test_result = {
            "test_case": "TC-SWE-234-1",
            "requirement": "SWE-234 AC-1",
            "parameter": "Brake activation latency",
            "expected": f"≤ {max_latency} ms",
            "actual": f"{brake_activation_time:.1f} ms",
            "status": "PASS" if brake_activation_time <= max_latency else "FAIL",
            "timestamp": time.time()
        }

        self.hil.record_test_result(test_result)

        assert brake_activation_time <= max_latency, \
            f"Brake latency {brake_activation_time:.1f}ms exceeds {max_latency}ms requirement"

    @keyword("The vehicle shall stop before the pedestrian")
    def verify_stopping_distance(self):
        """
        SWE.6 BP3: Verify vehicle stops before obstacle.
        ASIL-D critical safety requirement.
        """
        final_distance = self.hil.get_final_distance_to_obstacle()

        test_result = {
            "test_case": "TC-SWE-234-1",
            "requirement": "SWE-234 AC-1",
            "parameter": "Stopping distance",
            "expected": "> 0.0 meters (no collision)",
            "actual": f"{final_distance:.2f} meters",
            "status": "PASS" if final_distance > 0 else "FAIL",
            "timestamp": time.time()
        }

        self.hil.record_test_result(test_result)

        assert final_distance > 0, \
            f"COLLISION DETECTED: Vehicle stopped {abs(final_distance):.2f}m past pedestrian"

Sprint Burndown Chart (MAN.3 BP10)

Automated Burndown Generation

# File: scripts/generate_burndown.py
# ASPICE MAN.3 BP10: Monitor project progress

import matplotlib.pyplot as plt
from jira import JIRA
from datetime import datetime, timedelta

class BurndownGenerator:
    def __init__(self, jira_url: str, jira_token: str):
        self.jira = JIRA(jira_url, token_auth=jira_token)

    def generate_burndown(self, sprint_id: str, output_file: str):
        """
        MAN.3 BP10: Generate sprint burndown chart.
        ASPICE evidence for progress monitoring.
        """
        sprint = self.jira.sprint(sprint_id)
        start_date = sprint.startDate
        end_date = sprint.endDate

        # Get all stories in sprint
        stories = self.jira.search_issues(f"Sprint = {sprint_id}")
        total_points = sum(int(s.fields.customfield_10016 or 0) for s in stories)

        # Calculate ideal burndown line
        sprint_days = (end_date - start_date).days
        ideal_burndown = [total_points - (total_points / sprint_days * day) for day in range(sprint_days + 1)]

        # Calculate actual burndown (from Jira history)
        actual_burndown = []
        current_date = start_date

        while current_date <= end_date:
            remaining = self._get_remaining_points(sprint_id, current_date)
            actual_burndown.append(remaining)
            current_date += timedelta(days=1)

        # Plot burndown chart
        plt.figure(figsize=(12, 6))
        plt.plot(ideal_burndown, label="Ideal Burndown", linestyle="--", color="gray")
        plt.plot(actual_burndown, label="Actual Burndown", marker="o", color="blue")

        plt.title(f"Sprint {sprint.name} Burndown (ASPICE MAN.3 BP10)")
        plt.xlabel("Day")
        plt.ylabel("Story Points Remaining")
        plt.legend()
        plt.grid(True)

        # Add ASPICE metadata
        plt.figtext(0.5, 0.01, f"ASPICE Process: MAN.3 BP10 (Monitor project progress) | Generated: {datetime.now()}",
                    ha="center", fontsize=8, style="italic")

        plt.savefig(output_file)
        print(f"[PASS] Burndown chart saved: {output_file}")

        return {
            "sprint": sprint.name,
            "total_points": total_points,
            "remaining_points": actual_burndown[-1],
            "completion_rate": ((total_points - actual_burndown[-1]) / total_points) * 100,
            "status": "On Track" if actual_burndown[-1] <= ideal_burndown[-1] else "Behind Schedule"
        }

    def _get_remaining_points(self, sprint_id: str, date: datetime) -> int:
        """Calculate remaining points at a specific date"""
        jql = f"Sprint = {sprint_id} AND status != Done AND updatedDate <= '{date.strftime('%Y-%m-%d')}'"
        remaining_stories = self.jira.search_issues(jql)
        return sum(int(s.fields.customfield_10016 or 0) for s in remaining_stories)

# Usage
generator = BurndownGenerator("https://jira.company.com", "your-api-token")
result = generator.generate_burndown("Sprint-25", "reports/sprint-25-burndown.png")

ASPICE Evidence: Burndown chart stored in reports/ directory (MAN.3 BP10).

Summary

Sprint Work Products - ASPICE Mapping:

Key Takeaways:

1. Traceability: Every User Story links to System Requirements (bidirectional)
2. Quality Gates: Definition of Done enforces ASPICE compliance
3. Evidence: All sprint ceremonies produce auditable ASPICE work products
4. Automation: CI/CD generates evidence automatically (no manual documentation)

Next: See continuous compliance automation in 22.03 Continuous ASPICE Compliance.