BlindSpotFuzz

Blind-spot-guided fuzz testing for autonomous driving systems.

BlindSpotFuzz (BSF) is a research prototype for testing Autonomous Driving Systems (ADS) under sensing blind spots and occlusion-induced safety risks. Unlike conventional ADS fuzzers that primarily mutate dynamic object behaviors, BSF explicitly models visibility constraints and uses occlusion-aware feedback to guide scenario generation toward cases where the ADS may make unsafe planning decisions due to limited perception.

BlindSpotFuzz was developed as the artifact for the paper:

BlindSpotFuzz: Testing Autonomous Driving Systems Through Blind-Spot-Guided Fuzzing
Sali Moussa, Junyan Ma, Muhammad Umer Abbasi
Automated Software Engineering, 2026
DOI: 10.1007/s10515-026-00597-x

The archived research artifact is available on Zenodo:

https://doi.org/10.5281/zenodo.17817291

---

Overview

Autonomous Driving Systems rely on perception modules to observe surrounding vehicles, pedestrians, road infrastructure, and traffic signals. In realistic driving environments, however, relevant road users may be partially or fully hidden by other vehicles, traffic queues, roadside objects, or complex road geometry. These blind spots can cause the ADS planning module to make unsafe decisions even when other agents behave normally.

BlindSpotFuzz addresses this problem by introducing a blind-spot-guided fuzzing framework for ADS testing. It combines:

1. Occlusion-aware scenario modeling to detect and quantify blind spots around the ego vehicle.
2. Fitness metrics that guide fuzzing toward scenarios with severe or diverse occlusion patterns.
3. LLM-assisted seed generation that reconstructs occlusion-prone road structures and initial scenarios from accident reports.
4. Simulation-based evaluation on Baidu Apollo 7.0 using record analysis and violation tracking.

The goal of BSF is to help researchers and ADS test engineers generate safety-critical scenarios that expose planning deficiencies caused by limited sensing capability.

---

Key Contributions

BlindSpotFuzz provides the following research and engineering contributions:

• Blind-spot-guided ADS fuzzing
  A fuzz testing method designed specifically to uncover ADS failures caused by occlusion and limited sensing visibility.

• Scenario occlusion model
  A geometric model that estimates blind-spot conditions based on ego-vehicle orientation, surrounding object positions, sensor range, and angular overlap.

• Four occlusion-aware testing metrics
  BSF uses the following metrics as feedback signals for search-based scenario generation:

  Metric	Purpose
  Severity of Occlusion (SO)	Measures the most severe occlusion coverage at a simulation time step.
  Evolutionary Coverage (EC)	Measures cumulative occlusion coverage across the scenario execution.
  Scenario Change Detection (SCD)	Captures abrupt changes in occlusion patterns that may indicate safety-critical transitions.
  Coverage of Blind Spots (CBS)	Measures how much of the discretized blind-spot sensing space has been explored by the test suite.

• LLM-based initial seed generation
  BSF uses large language models to extract road structures and traffic participant information from crash reports, then constructs simulation-ready road networks and scenario seeds.

• Integration with Baidu Apollo
  The framework evaluates generated scenarios on Baidu Apollo 7.0 and records violation scenarios for further analysis.

• Reproducible research artifact
  The artifact is intended to support reproduction of the results reported in the paper and to enable future research on occlusion-aware ADS testing.

---

Requirements

Hardware

The experiments reported in the paper were conducted using:

• CPU: Intel Core i9-10900K
• Memory: 32 GB RAM
• OS: Ubuntu 22.04.4

Practical requirements may vary depending on the number of Apollo instances, scenario duration, and experiment budget.

Software

• Ubuntu 22.04.4 or compatible Linux distribution
• Docker
• Baidu Apollo 7.0
• Python 3.x
• pip
• Python dependencies listed in requirements.txt

Optional but recommended:

• NVIDIA GPU and compatible drivers, depending on the Apollo/simulation configuration
• Sufficient disk space for Apollo records and logs

---

Installation

1. Install Baidu Apollo 7.0

Download the Apollo 7.0 artifact used in the experiments:

https://doi.org/10.5281/zenodo.7622089

At the root directory of Apollo, create the required runtime directories:

mkdir data data/log data/bag data/core

Start the Apollo Docker container:

./docker/scripts/dev_start.sh -l

Find the container name:

docker ps -a

Enter the container in root mode:

docker exec -it apollo_dev_your_name /bin/bash

Replace apollo_dev_your_name with the actual Apollo container name.

Inside the Apollo container, build Apollo:

./apollo.sh build

These Apollo setup steps usually need to be completed only once.

---

2. Install BlindSpotFuzz

Clone this repository:

git clone https://github.com/NEEMSYS/BlindSpotFuzz.git
cd BlindSpotFuzz

Install Python dependencies:

pip install -r requirements.txt

If installation fails when installing Shapely, install the GEOS dependency first:

sudo apt-get update
sudo apt-get install libgeos-dev
pip install -r requirements.txt

---

3. Configure paths

Edit config.py and set the required local paths.

APOLLO_ROOT = "/path/to/apollo"

---

Usage

Run BlindSpotFuzz

To start the main GA-based fuzzing process:

python main_ga.py

During execution, BSF mutates and evaluates scenarios in Apollo. After running for an extended period, generated record files should appear under:

data/records/

These records correspond to executed scenarios and can be used for violation analysis and reproducibility checks.

---

Test the occlusion module

To test the blind-spot / occlusion module:

python test_blindspot.py

Before running this command, verify the HD map configuration in config.py.

The test expects the borregas_ave map, update the map path accordingly:

HD_MAP_PATH = ".../borregas_ave/..."

Expected behavior:

• multiple Apollo instances should start;
• each instance should provide a visualization URL in the terminal;
• the scenario should be viewable through a browser;
• the blind-spot / occlusion effect should be observable by switching between Apollo instances.

---

Method Summary

BlindSpotFuzz follows the workflow below:

1. Seed generation
   Accident reports are processed to extract road structure, traffic participants, and occlusion-prone conditions.

2. Map and scenario construction
   Extracted road information is converted into simulation-ready road networks and initial seed scenarios.

3. Scenario mutation
   The fuzzing engine mutates scenario parameters using search-based testing operators.

4. Simulation execution
   Candidate scenarios are executed in Baidu Apollo.

5. Occlusion analysis
   The occlusion model estimates blind-spot conditions around the ego vehicle.

6. Fitness evaluation
   SO, EC, SCD, and CBS guide the search toward critical occlusion scenarios.

7. Violation analysis
   Generated records are analyzed to identify safety violations and bug-revealing ADS behaviors.

---

Citation

If you use BlindSpotFuzz in your research, please cite:

@article{moussa2026blindspotfuzz,
  title   = {BlindSpotFuzz: Testing Autonomous Driving Systems Through Blind-Spot-Guided Fuzzing},
  author  = {Moussa, Sali and Ma, Junyan and Abbasi, Muhammad Umer},
  journal = {Automated Software Engineering},
  volume  = {33},
  number  = {52},
  year    = {2026},
  doi     = {10.1007/s10515-026-00597-x}
}