DIS-Bench: Evaluating LLMs on System Testing via Directed Input Synthesis

Directed Input Synthesis (DIS). Given a real-world C/C++ repository, an entry program that consumes a byte buffer, and a target branch (a source location plus a branch direction), generate an input that drives the entry program to cover that branch. Success is checked by running the input on a coverage-instrumented build of the program.

Split	File	Tasks
DIS-Bench	dataset_full.jsonl	8,267 stable roadblock branches from 37 entry programs
DIS-Bench-Lite	dataset.jsonl	555 tasks, 15 per program (used for all experiments in the paper)

This artifact contains everything needed to evaluate new solutions and to reproduce every table, figure, and number in the paper from the released per-attempt results.

Contents

Path	Description
dataset.jsonl, dataset_full.jsonl	DIS-Bench-Lite and DIS-Bench
Dockerfile	Evaluation environment
targets/	The 37 coverage-instrumented entry programs
inst_src_match/	Per-program map between instrumented branches and source branches (src_site_id), including the enclosing function of each branch
src/	Sources of the target programs; paths match source_location / src_dir in the dataset (/src/...)
cov_utils/	Coverage runner (SeedRunner, a forkserver-based executor) and the LLVM instrumentation pass
eval/	Evaluator (eval.py), command-line verifier (verify_generator.py) and a passing / failing example
seeds/	Seed corpora of the random-testing campaigns that mined the targets (corpus/), and input dictionaries for some programs (dict/)
experiments/generators/	Every generator produced by the evaluated configurations (see below)
experiments/results/	Per-attempt verdicts (pass / reach / sfunc / execution status) of every attempt
analysis/	Scripts that recompute all tables, figures and quoted numbers of the paper, and the inputs of the appendix analyses

Quick start

docker build -t dis-bench .
docker run --rm -it --ipc=host --network none dis-bench bash

--ipc=host is required (the coverage runner uses SysV shared memory). Inside the container (working directory /dis-bench, unprivileged user dis):

# verify one generator against one task (PASS / FAIL, plus reach and sfunc)
python3 eval/verify_generator.py --task eval/examples/pass_task.json --generator eval/examples/pass_generator.py
python3 eval/verify_generator.py --dataset dataset.jsonl --index 0 --generator my_generator.py

# batch mode: JSONL lines with the task fields and a "generator" path
python3 eval/verify_generator.py --batch jobs.jsonl -j 16 --out verdicts.jsonl

# re-evaluate released generators of one configuration
python3 eval/eval.py --generators_dir experiments/generators --model qwen-3.5-27b \
    --thinking false --method claude --prog jq --output_dir /tmp/reeval

# recompute every table / figure / number of the paper from experiments/results
cd analysis && python3 build_data.py && python3 make_tables.py && python3 make_figures.py && python3 make_facts.py

Task format

Each line of dataset.jsonl / dataset_full.jsonl is one task:

{"prog": "libpng_read_fuzzer", "src_site_id": 934, "to_take": 1,
 "source_location": "/src/libpng/libpng/pngrutil.c:4457:11", "branch": true,
 "format": "png", "src_dir": "/src/libpng/libpng"}

Field	Description
prog	Entry program (binary name in /targets)
src_site_id	Identifier of the conditional statement (index into inst_src_match/<prog>.pkl)
to_take	Target branch direction: 1 = true branch, 0 = false branch
source_location	file:line:column of the conditional statement
branch	Boolean alias of to_take
format	Expected input file format(s), comma-separated
src_dir	Source directory of the program inside the image

A solution is a Python file defining generate_buf(), which returns the input as bytes. The prompt template used for all experiments is given in the paper (Appendix B.4).

Programs and formats

37 entry programs, 51 input formats, 9 categories.

Package	Entry (prog)	Format(s)	Category	#Lite	#Full
binutils	nm (nm-new)	elf	Binaries	15	103
binutils	objdump (objdump)	elf	Binaries	15	456
binutils	readelf (readelf)	elf	Binaries	15	154
binutils	size (size)	elf	Binaries	15	186
binutils	strip (strip-new)	elf	Binaries	15	460
bloaty	bloaty (bloaty_fuzz_target)	elf,mach-o,pe,wasm	Binaries	15	60
exiv2	exiv2 (exiv2)	jpeg	Image	15	24
ffmpeg	ffmpeg (ffmpeg)	avi,mov,flv,mp4,mp3,h264	Video/Audio	15	430
freetype2	freetype2 (freetype2_ftfuzzer)	ttf,otf	Fonts	15	587
harfbuzz	harfbuzz (harfbuzz_hb-shape-fuzzer)	ttf,otf	Fonts	15	522
jasper	jasper (imginfo)	bmp,mif,pgx,pnm,ras,jpeg,png,tga	Image	15	156
jhead	jhead (jhead)	jpeg	Image	15	36
jq	jq (jq)	json	Data Formats	15	23
lcms	lcms (lcms_cms_transform_fuzzer)	cms	Others	15	85
libjpeg-turbo	libjpeg-turbo (libjpeg_turbo_fuzzer)	jpeg	Image	15	56
libpcap	libpcap (libpcap_fuzz_both)	pcap	Data Formats	15	64
libpng	libpng (libpng_read_fuzzer)	png	Image	15	65
libsndfile	libsndfile (sndfile_fuzzer)	aifc,aiff,au,caf,mp3,oga,opus,paf,raw,rf64,sds,wav,xi	Video/Audio	15	177
libtiff	tiff2ps (tiff2ps)	tiff	Image	15	198
libtiff	tiffsplit (tiffsplit)	tiff	Image	15	209
libxml2	libxml2 (libxml2_xml)	xml	Documents	15	376
lua	lua (lua)	lua	Compilers/Interpreters	15	134
mbedtls	mbedtls (mbedtls_fuzz_dtlsclient)	dtls	Network	15	100
mruby	mruby (mruby_fuzzer)	ruby	Compilers/Interpreters	15	350
mujs	mujs (mujs)	javascript	Compilers/Interpreters	15	126
ncurses	infotocap (infotocap)	terminfo	Others	15	84
openh264	openh264 (openh264_decoder_fuzzer)	h264	Video/Audio	15	100
openthread	openthread (openthread_ot-ip6-send-fuzzer)	openthread	Network	15	18
php	php (php_php-fuzz-parser)	php	Compilers/Interpreters	15	287
proj4	proj4 (proj4_proj_crs_to_crs_fuzzer)	proj	Others	15	481
re2	re2 (re2_fuzzer)	re2	Others	15	23
sqlite3	sqlite3 (sqlite3_ossfuzz)	sql	Data Formats	15	784
stb	stb (stb_stbi_read_fuzzer)	bmp,gif,jpeg,tga,png	Image	15	54
tcpdump	tcpdump (tcpdump)	pcap	Network	15	998
vorbis	vorbis (vorbis_decode_fuzzer)	vorbis	Video/Audio	15	61
woff2	woff2 (woff2_convert_woff2ttf_fuzzer)	woff2	Fonts	15	58
xpdf	xpdf (pdftotext)	pdf	Documents	15	182

Category	DIS-Bench-Lite	DIS-Bench
Image	120	798
Video/Audio	60	768
Documents	30	558
Fonts	45	1167
Data Formats	45	871
Compilers/Interpreters	60	897
Binaries	90	1419
Network	45	1116
Others	60	673
Total	555	8267

Category	Formats
Image	jpeg, bmp, mif, pgx, pnm, ras, png, tga, tiff, gif
Video/Audio	avi, mov, flv, mp4, mp3, h264, aifc, aiff, au, caf, oga, opus, paf, raw, rf64, sds, wav, xi, vorbis
Documents	xml, pdf
Fonts	ttf, otf, woff2
Data Formats	json, pcap, sql
Compilers/Interpreters	lua, ruby, javascript, php
Binaries	elf, mach-o, pe, wasm
Network	dtls, openthread
Others	cms, terminfo, proj, re2

Evaluation protocol

eval/eval.py is the evaluator that produced every result in the paper. For one attempt it

1. executes the generator in a separate process with a 1-second time limit and a 100 MB address-space limit (RLIMIT_AS); files opened for writing are captured in memory instead of being written to disk;
2. collects candidate inputs: the return value of generate_buf(), the return values of other functions defined in the file that take no or one argument, files the code writes, and printed output;
3. runs the instrumented entry program on each candidate (inputs longer than 10,000 bytes are truncated) and records
   • pass — the target branch (src_site_id, to_take) is covered,
   • reach — the conditional statement src_site_id is executed (either direction),
   • sfunc — some branch inside the function enclosing the target is executed;
4. repeats steps 1–3 up to 10 times for non-deterministic generators; the attempt passes as soon as one repetition passes.

Execution statuses in the result files: success, missing_generator (no generator.py was produced), missing_function / no_result (no candidate input could be extracted), syntax_error, name_error, import_error, type_error, value_error, runtime_error, timeout, memory_exceeded.

Isolation. The limits above bound CPU time and memory, and prevent generators from writing files, but they do not restrict file reads, process creation, or network access. Run the evaluator inside the provided container, as the unprivileged user, and preferably with --network none. Some targets branch on the effective user id (e.g. tcpdump), so the evaluator must not run as root.

Metrics. For each task, pass@k is computed with the unbiased estimator 1 − C(n−c, k) / C(n, k) over the n recorded attempts, c of which pass; reach@k and sfunc@k are analogous. Overall scores average over the tasks with at least one recorded attempt within each program and then weight the 37 programs equally; per-category and per-type scores count a task without any recorded attempt as unsolved. For complete runs both conventions coincide (paper, Appendix B.5). analysis/build_data.py implements this.

Benchmark construction

For every entry program, several independent 24-hour random-testing campaigns are started from the seed corpora in seeds/. In each campaign, a branch is a roadblock if its conditional statement is reached at least 30 minutes before the end of the campaign (τ_tail = 30 min) and the branch itself stays uncovered for at least 1 hour after that (Δ_road = 1 h). A branch is a stable roadblock — and becomes a DIS-Bench task — if it is a roadblock in at least half of the campaigns (paper, Section 3.2 and Algorithm 1). DIS-Bench-Lite samples 15 tasks uniformly at random per program.

Released experiment outputs

experiments/generators/<model>---<thinking>---<method>/<model>---<prog>---<src_site_id>---<to_take>---<try_id>/generator.py and experiments/results/<method>_<model>_<thinking>_<prog>.json (one record per attempt) cover exactly the configurations reported in the paper:

Models	Methods	Samples per task
Qwen3.5-27B, Qwen3.5-122B-A10B, Gemma4-31B, GLM-4.7-Flash, GPT-OSS-20B, GPT-OSS-120B, MiniMax-M2.5	rag (thinking and non-thinking)	5
same seven models	miniswe, openhands, claude (Mini-SWE-Agent, OpenHands, Claude-Code scaffolds)	3
Seed-2.0	miniswe, openhands, claude	3
GPT-5.4	miniswe, openhands, claude	1
Qwen3.5-27B, MiniMax-M2.5	rag_fo, rag_lc, rag_dense (context ablation, paper Appendix D.2)	1

Each result file has one record per attempt; generator_exists = false marks an attempt that produced no generator.

Analysis inputs (analysis/data/)

File	Used for
target_types.csv	Target-type labels of all DIS-Bench-Lite tasks (paper, Appendix D.1)
aflgo_75_targets.json	AFLGo time-to-target on 75 DIS-Bench-Lite targets; the paper counts a target as reached if it is covered within 6 hours (Appendix D.4)
reach_trace.json	Source locations executed by an input from the construction campaigns that reaches the target conditional, for 260 targets (Appendix D.3)
failure_mode_annotations.jsonl, failure_mode_stats.json	Failure-mode labels of 111 failed MiniMax-M2.5 + OpenHands attempts and their statistics (Section 4.3)

python3 build_data.py writes analysis/output/ (results.json, RESULTS.md, tasks.csv, outcomes.jsonl); make_tables.py, make_figures.py and make_facts.py write the LaTeX tables, the figures and FACTS.md (every number quoted in the paper text) into the same directory.