Text-based files you can open, edit, and download directly in the browser editor.
A generic sample brand logo as scalable vector graphics — a gradient mark plus a wordmark — for testing SVG rendering, rasterisation, and vector-to-raster conversion. Opens in the in-browser editor.
A single stroke-style UI icon (a document) as a 24×24 SVG — the kind of vector icon used in interfaces, for testing icon rendering, recolouring, and SVG-to-PNG conversion.
A bar chart drawn as vector SVG — axis, gridlines, labelled bars — the scalable counterpart to the raster chart images, for testing SVG chart rendering and vector conversion.
An animated loading spinner using SMIL (animateTransform) — a self-contained animated SVG for testing whether a renderer or converter handles SVG animation, and how it rasterises an animated frame.
A flat vector landscape — gradient sky, sun, layered hills, and trees built from bezier paths — a richer SVG for testing gradient and path rendering, thumbnailing, and vector conversion.
A small LaTeX article source with an abstract, a numbered equation (the Nyquist criterion), and a table — for testing LaTeX editors, syntax highlighters, and TeX-to-PDF pipelines.
An AsciiDoc getting-started guide with source blocks, an admonition, and a table — for testing AsciiDoc renderers (Asciidoctor), editors, and conversion to HTML/PDF.
A reStructuredText document with directives, a code block, a note admonition, and a table — for testing docutils/Sphinx rendering, reST parsers, and editors.
An Advanced SubStation Alpha (.ass) subtitle with a styles section and three timed Dialogue events — the styled format libass renders — carrying the same captions as the SRT/VTT twins.
A SubStation Alpha (.ssa) subtitle — the predecessor of ASS — with a V4 styles section and timed Dialogue events, carrying the same captions, for testing SSA parsers and SSA-to-ASS upgrades.
A YouTube SBV caption file — start,end timestamp lines followed by caption text — carrying the same three captions, for testing SBV parsers and YouTube caption import.
A TTML (Timed Text Markup Language / DFXP) caption document — timed XML paragraphs with a styling region — carrying the same captions, for testing XML caption parsers and IMSC players.
An LRC synced-lyric file with ID tags (title, artist, album) and four line-level [mm:ss.xx] timestamps — for testing karaoke and music-player lyric sync and LRC parsers.
CommonMark-leaning Markdown twin for “tasklist” — compare against the GFM variant.
GitHub-Flavored Markdown twin for “tasklist” — tables/task lists/etc. where applicable.
CommonMark-leaning Markdown twin for “table” — compare against the GFM variant.
GitHub-Flavored Markdown twin for “table” — tables/task lists/etc. where applicable.
CommonMark-leaning Markdown twin for “strikethrough” — compare against the GFM variant.
GitHub-Flavored Markdown twin for “strikethrough” — tables/task lists/etc. where applicable.
CommonMark-leaning Markdown twin for “autolink” — compare against the GFM variant.
GitHub-Flavored Markdown twin for “autolink” — tables/task lists/etc. where applicable.
CommonMark-leaning Markdown twin for “fenced-lang” — compare against the GFM variant.
GitHub-Flavored Markdown twin for “fenced-lang” — tables/task lists/etc. where applicable.
CommonMark-leaning Markdown twin for “emoji-ish” — compare against the GFM variant.
GitHub-Flavored Markdown twin for “emoji-ish” — tables/task lists/etc. where applicable.
SAMPLE LaTeX article “On Sampling Rates” with abstract, equation, and \cite to a twin .bib.
Companion BibTeX file for the nyquist LaTeX article — fictional SAMPLE citation.
SAMPLE LaTeX article “Notes on Information Entropy” with abstract, equation, and \cite to a twin .bib.
Companion BibTeX file for the entropy LaTeX article — fictional SAMPLE citation.
SAMPLE LaTeX article “Digital Filters Primer” with abstract, equation, and \cite to a twin .bib.
Companion BibTeX file for the filters LaTeX article — fictional SAMPLE citation.
Two-entry SAMPLE BibTeX file for bibliography parsers (not a claim on the real works beyond citation shape).
Short synthetic HL7 v2 ADT-A03 message — fictional SAMPLE demographics for parser tests.
Short synthetic HL7 v2 ORM-O01 message — fictional SAMPLE demographics for parser tests.
Short synthetic HL7 v2 ORU-R01 message — fictional SAMPLE demographics for parser tests.
Short synthetic HL7 v2 SIU-S12 message — fictional SAMPLE demographics for parser tests.
Short ANSI X12 855 SAMPLE transaction for EDI parser / translator tests.
Short ANSI X12 856 SAMPLE transaction for EDI parser / translator tests.
Short ANSI X12 997 SAMPLE transaction for EDI parser / translator tests.
Short ANSI X12 940 SAMPLE transaction for EDI parser / translator tests.
Short ANSI X12 204 SAMPLE transaction for EDI parser / translator tests.
Short ANSI X12 214 SAMPLE transaction for EDI parser / translator tests.
SAMPLE PDF documenting tagged/accessibility intent (heading-outline) in specs — bookmark outline present; not a full PDF/UA export.
SAMPLE PDF documenting tagged/accessibility intent (list-structure) in specs — bookmark outline present; not a full PDF/UA export.
SAMPLE PDF documenting tagged/accessibility intent (table-structure) in specs — bookmark outline present; not a full PDF/UA export.
SAMPLE PDF documenting tagged/accessibility intent (lang-en) in specs — bookmark outline present; not a full PDF/UA export.
SAMPLE PDF documenting tagged/accessibility intent (figure-alt) in specs — bookmark outline present; not a full PDF/UA export.
SAMPLE PDF documenting tagged/accessibility intent (reading-order) in specs — bookmark outline present; not a full PDF/UA export.
SAMPLE PDF documenting tagged/accessibility intent (link-structure) in specs — bookmark outline present; not a full PDF/UA export.
SAMPLE PDF documenting tagged/accessibility intent (form-labels) in specs — bookmark outline present; not a full PDF/UA export.
SAMPLE PDF documenting tagged/accessibility intent (landmarks) in specs — bookmark outline present; not a full PDF/UA export.
SAMPLE PDF documenting tagged/accessibility intent (pdfua-note) in specs — bookmark outline present; not a full PDF/UA export.
SAMPLE PDF documenting tagged/accessibility intent (toc-outline) in specs — bookmark outline present; not a full PDF/UA export.
SAMPLE PDF documenting tagged/accessibility intent (alt-text-block) in specs — bookmark outline present; not a full PDF/UA export.
SAMPLE PDF documenting tagged/accessibility intent (role-map) in specs — bookmark outline present; not a full PDF/UA export.
Short SAMPLE FAQ markdown (faq-downloads) for docs renderers and SEO snippets.
Short SAMPLE FAQ markdown (faq-licensing) for docs renderers and SEO snippets.
Short SAMPLE FAQ markdown (faq-security) for docs renderers and SEO snippets.
Short SAMPLE FAQ markdown (faq-csv-edges) for docs renderers and SEO snippets.
Short SAMPLE FAQ markdown (faq-i18n) for docs renderers and SEO snippets.
Short SAMPLE FAQ markdown (faq-api-errors) for docs renderers and SEO snippets.
Fictional SAMPLE legal/policy markdown (cookie-notice-sample) — not legal advice.
Fictional SAMPLE legal/policy markdown (terms-snippet-sample) — not legal advice.
Fictional SAMPLE legal/policy markdown (accessibility-statement) — not legal advice.
Fictional SAMPLE legal/policy markdown (retention-policy-sample) — not legal advice.
Fictional SAMPLE legal/policy markdown (incident-response-outline) — not legal advice.
Fictional SAMPLE legal/policy markdown (dpa-definitions-sample) — not legal advice.
Minimal SAMPLE HTML (faq-page-snippet) for meta/JSON-LD/DOM parser tests.
Minimal SAMPLE HTML (jsonld-inline-faq) for meta/JSON-LD/DOM parser tests.
Minimal SAMPLE HTML (meta-description-sample) for meta/JSON-LD/DOM parser tests.
Minimal SAMPLE HTML (open-graph-sample) for meta/JSON-LD/DOM parser tests.
A valid Jupyter notebook (nbformat 4.5) with markdown cells, code cells, and real outputs (stdout stream and an execute result) — for testing notebook parsers, nbconvert, and JSON tooling.
A Mermaid flowchart of an order-fulfilment process as diagrams-as-code — for testing Mermaid rendering, diagram-to-image conversion, and Markdown pipelines that embed Mermaid.
A Graphviz DOT directed graph describing a fulfilment pipeline — for testing DOT parsing, Graphviz rendering, and DOT-to-SVG/PNG conversion.
A PlantUML sequence diagram of an order interaction (customer, store, warehouse) as diagrams-as-code — for testing PlantUML parsing and diagram rendering pipelines.
A draw.io (diagrams.net) diagram in its native mxGraphModel XML — a small flowchart — for testing draw.io import/export and XML parsing of diagram files.
A sample JSON Web Token (JWT) signed with HS256 using a published example secret — verifiable but powerless — for testing JWT decoders and validators. Sample only, never for production. Paired with its decoded claims.
The decoded header and payload of the sample JWT as JSON, alongside the public signing secret and algorithm — the ground truth for checking a JWT decoder's output.
A self-signed X.509 v3 certificate in PEM (Base64) encoding with a SAN and key-usage extensions — published sample material for testing certificate and TLS parsers. Not a real identity.
The same self-signed certificate under the conventional .crt extension (PEM-encoded) — for testing trust-store importers and tools that key off the .crt extension. Sample only.
The binary DER encoding of the same certificate — for testing ASN.1/DER parsers, Java keystores, and DER-to-PEM converters. Published sample certificate, not a real identity.
A PKCS#10 certificate signing request (PEM) with the subject and SAN, self-signed by the RSA key to prove key possession — for testing CSR parsers and certificate-authority intake flows.
A 2048-bit RSA private key in unencrypted PKCS#8 PEM — a deliberately PUBLISHED, sample-only key for testing PEM key parsers and PKCS#8 decoders. Never use it for anything real.
An Ed25519 private key in PKCS#8 PEM, derived from a fixed seed — a published, sample-only modern elliptic-curve key for testing PEM parsers and Ed25519 tooling. Never use it for real.
An OpenSSH-format Ed25519 public key (the shareable half of the key pair) — a single line of algorithm, Base64 key blob, and comment, for testing SSH public-key parsers and authorized_keys tooling.
An Apache/nginx .htpasswd file with two users hashed using the {SHA} scheme (Base64 SHA-1) — the sample passwords are documented in the file, for testing Basic-Auth credential parsers and hash identification.
A BibTeX bibliography with three real citations (Lovelace, Knuth, Shannon) across article, book, and inproceedings types — for testing BibTeX parsers, reference managers, and citation converters.
The same three references as an RIS citation file with two-letter tags and ER record terminators — the twin of the BibTeX file, for testing RIS import and BibTeX/RIS conversion.
An MDL Molfile (V2000) of a water molecule with standard geometry — a counts line, atom block with 2D coordinates, and bond block — for testing cheminformatics parsers and MOL/SDF converters.
The same water molecule in PDB format with fixed-column HETATM coordinate records and a CONECT bond record — for testing molecular-structure parsers and viewers and PDB/MOL conversion.
A JSON Feed 1.1 document — the JSON alternative to RSS/Atom — with a feed header and three items using content_html, content_text, tags, and publish dates, for testing JSON Feed parsers and readers.
An OPML 2.0 subscription list with nested outline groups and three feed entries (title, xmlUrl, htmlUrl) — the format RSS readers use to import and export subscriptions, for testing OPML parsers.
An extended M3U media playlist with #EXTINF duration and title directives over three track references (local and remote) — for testing playlist parsers and media players.
An HTTP Live Streaming (HLS) media playlist in UTF-8 M3U8 — #EXT-X-VERSION, target duration, four timed .ts segments, and #EXT-X-ENDLIST — for testing HLS parsers and adaptive-streaming players.
Sample GraphQL Schema — small deterministic fixture for parsers and the in-browser editor.
Sample Protobuf Schema — small deterministic fixture for parsers and the in-browser editor.
Tiny SAMPLE TOML config fixture (app-feature-flags) for parser and twin tests.
Tiny SAMPLE YAML config fixture (app-feature-flags) for parser and twin tests.
Tiny SAMPLE JSON config fixture (app-feature-flags) for parser and twin tests.
Tiny SAMPLE INI config fixture (database-pool) for parser and twin tests.
Tiny SAMPLE ENV config fixture (database-pool) for parser and twin tests.
Tiny SAMPLE TOML config fixture (redis-cache) for parser and twin tests.
Tiny SAMPLE YAML config fixture (redis-cache) for parser and twin tests.
Tiny SAMPLE INI config fixture (logging-levels) for parser and twin tests.
Tiny SAMPLE JSON config fixture (cors-origins) for parser and twin tests.
Tiny SAMPLE YAML config fixture (rate-limit) for parser and twin tests.
Tiny SAMPLE ENV config fixture (smtp-relay) for parser and twin tests.
Tiny SAMPLE YAML config fixture (k8s-resource-snippet) for parser and twin tests.
A Markdown checklist template with task-list checkboxes — opens directly in the in-browser editor.
A responsive, table-based HTML email template with inline styles — a header, body, button, and footer. Opens in the in-browser editor.
The newsletter as a responsive, table-based HTML email with inline styles — a masthead, three articles, and a call-to-action button. Opens in the in-browser editor; twin of the DOCX version.
A short fictional privacy policy in Markdown — for template and content-pipeline tests.
HTML twin of the SAMPLE USD invoice for web template pipelines.
Markdown twin of the SAMPLE USD invoice for docs/CMS tooling.
HTML twin of the SAMPLE EUR invoice for web template pipelines.
Markdown twin of the SAMPLE EUR invoice for docs/CMS tooling.
HTML twin of the SAMPLE GBP invoice for web template pipelines.
Markdown twin of the SAMPLE GBP invoice for docs/CMS tooling.
HTML twin of the SAMPLE JPY invoice for web template pipelines.
Markdown twin of the SAMPLE JPY invoice for docs/CMS tooling.
Markdown twin of the SAMPLE SOW for docs pipelines.
HTML twin of the SAMPLE SOW.
Markdown twin of the SAMPLE showroom press release.
HTML twin of the SAMPLE showroom press release.
Second SAMPLE press-release variant (product launch) for PR parser diversity.
Markdown speaker notes twin for the SAMPLE pitch deck.
Markdown twin of the SAMPLE ops-sync meeting notes.
HTML SAMPLE meeting agenda for calendar/CMS tooling.
Fictional SAMPLE board minutes for governance-document tooling.
Markdown twin of the SAMPLE OKR sheet for docs/wiki tooling.
HTML table twin of the SAMPLE OKR sheet.
Deeper SAMPLE privacy policy in Markdown with purposes table and rights — not legal advice.
HTML twin of the deep SAMPLE privacy policy.
Fictional SAMPLE cookie policy for CMP and consent UX tests.
Short fictional SAMPLE terms of service for legal-template tooling.
Fictional SAMPLE RFP response for proposal/CMS tooling.
SAMPLE weekly status report for PM tooling.
SAMPLE employee onboarding checklist in Markdown.
Fictional SAMPLE job posting HTML for ATS/scraper tests.
Fictional SAMPLE contract amendment in Markdown.
SAMPLE redline summary notes for contract-diff tooling.
Fictional SAMPLE vendor questionnaire Markdown for privacy/security document tooling.
Fictional SAMPLE data retention schedule Markdown for privacy/security document tooling.
Fictional SAMPLE incident runbook Markdown for privacy/security document tooling.
Tiny SAMPLE markdown template (agenda-standup) for docs and planning workflows.
Tiny SAMPLE markdown template (agenda-retro) for docs and planning workflows.
Tiny SAMPLE markdown template (status-update) for docs and planning workflows.
Tiny SAMPLE markdown template (release-notes-stub) for docs and planning workflows.
Tiny SAMPLE markdown template (checklist-launch) for docs and planning workflows.
Tiny SAMPLE markdown template (data-subject-request) for docs and planning workflows.
Tiny SAMPLE markdown template (one-pager-outline) for docs and planning workflows.
Tiny SAMPLE markdown template (interview-scorecard) for docs and planning workflows.
A completed discovery questionnaire for a fictional product-launch engagement. This UTF-8 Markdown twin preserves the same headings, lists, checkboxes, and GFM tables in portable plain text.
A blameless operational review with impact, timeline, causal analysis, and owned actions. This UTF-8 Markdown twin preserves the same headings, lists, checkboxes, and GFM tables in portable plain text.
A channel-ready brief connecting one campaign objective to audience insight, messages, assets, and approvals. This UTF-8 Markdown twin preserves the same headings, lists, checkboxes, and GFM tables in portable plain text.
A scored delivery-risk register with owners, mitigations, triggers, and review dates. This UTF-8 CSV twin contains the model's single canonical table for parser, import, and round-trip tests.
A minute-by-minute production schedule with cues, ownership, locations, and contingencies. This UTF-8 CSV twin contains the model's single canonical table for parser, import, and round-trip tests.
A weighted comparison of fictional vendors with evidence notes, decisions, and review ownership. This UTF-8 CSV twin contains the model's single canonical table for parser, import, and round-trip tests.
A minimal WARC 1.0 web archive with a warcinfo record and an HTTP response record capturing a small HTML page — for testing WARC parsers and web-archive tooling.
SAMPLE consent/preferences TOML for privacy-export parsers.
A plain-text multi-chapter SAMPLE extract — for ebook converters that accept .txt sources.
A minimal FictionBook (.fb2) SAMPLE with one section — for FB2/XML ebook importers.
A FictionBook nested three sections deep, with prose directly inside an outer section, an epigraph, a cite block, and a footnote linking into a second body named notes. The FB2 equivalents of a multi-level table of contents and non-linear back matter, in one file.
A plain-text index of every EPUB and FB2 fixture in this wave: its validity class, its subcategory, and the scenario and expected result published for it. Generated from the same entry list that builds the catalogue, so it cannot describe a file that is not there.
A fixed-width (monospace) demonstration typeface where every glyph shares the same advance width — a fixture for testing monospace detection, code-editor rendering, and column alignment. Original and free to use.
A hand-written 5×7 BDF bitmap font covering the digits, a colon, and space — the classic X11 bitmap-font format, in plain text. A fixture for testing BDF parsers, bitmap-font converters, and retro/embedded rendering.
Standard and discretionary ligature substitutions in a real GSUB table: four liga ligatures including the three-glyph ffi, and two dlig ligatures that must stay off unless asked for. Each ligature's advance is the sum of its parts minus a documented tuck, so a shaping result is checkable by measuring. Original typeface, free to use.
Eighteen kerning pairs published as a GPOS pair-positioning lookup, with no legacy kern table present. Pair it with its kern-table twin to find out which table your layout engine is actually reading. Original typeface, free to use.
The same eighteen kerning pairs, this time in a format-0 legacy kern table with no GPOS at all. Modern shapers ignore kern when GPOS exists and some ignore it entirely, so this twin is how you tell which code path produced a given measurement. Original typeface, free to use.
Contextual alternate substitution that fires on doubled letters: the second letter of aa, ee, oo, nn, ss and tt is replaced by an alternate carrying a visible baseline underscore, so a shaping result can be read straight off the page instead of out of a debug log. calt is on by default, which makes it a good test of whether a renderer applies default features at all. Original typeface, free to use.
A full 26-glyph small-capital set reachable through smcp from lowercase and c2sc from capitals. Because the lowercase of this face is unicase, the small caps sit at a third, measurable height: 560 design units against 500 for lowercase and 700 for capitals, so a failed substitution shows up as a height rather than as a subtle shape difference. Original typeface, free to use.
Three stylistic sets, each with a human-readable name published through FeatureParams in the name table — the metadata a font menu needs to show 'Squared G and R' instead of 'ss01'. For testing feature-name discovery as much as the substitution itself. Original typeface, free to use.
All four figure features over one digit set: the default is proportional lining, tnum flattens every digit to 620 units for column alignment, pnum restores the proportional widths, and onum drops five digits below the baseline and raises two above the x-height. The measurable case for testing font-variant-numeric. Original typeface, free to use.
A real frac implementation as a chaining contextual substitution: the slash becomes a fraction slash, the digit before it becomes a numerator and the digit after becomes a denominator, with numr and dnom also reachable on their own. Coverage is deliberately limited to single-digit fractions, which is stated in the specs so a test can assert the boundary. Original typeface, free to use.
Mark-to-base and mark-to-mark positioning with a real GDEF glyph-class definition: three zero-width combining accents attach to ten base letters at documented anchors, and stacking a second mark uses the mkmk anchor. For testing diacritic placement without needing a full Unicode face. Original typeface, free to use.
An aalt feature that aggregates every alternate reachable through the stylistic sets and the small-cap set, which is what a glyph-palette UI reads to offer 'other forms of this character'. For testing alternate-picker panels rather than automatic shaping. Original typeface, free to use.
Language-specific substitution through locl: tagging text as Turkish swaps the i, tagging it as Romanian swaps the S, and untagged text gets neither. The fixture for finding out whether your pipeline propagates a language tag from the document all the way to the shaper. Original typeface, free to use.
Every feature this family defines in one face — ligatures, kerning, contextual alternates, small caps, three stylistic sets, four figure features, fractions, mark attachment, aalt and locl. The single font to point a feature-discovery UI at. Original typeface, free to use.
The all-features font as WOFF2, for testing that a web-font build step preserves GSUB, GPOS and GDEF instead of subsetting the layout tables away by default. Original typeface, free to use.
The control for the all-features font: the same glyph set and the same metrics with no layout tables at all, so the alternates exist in the font but nothing can reach them. Any difference you measure against the full twin is the layout tables and nothing else. Original typeface, free to use.
The control case: all three vertical-metric families carry the same numbers, so every platform computes the same 1.0 em default line height. Measure this first, then measure its disagreeing twin — the difference is entirely the metrics. Original typeface, free to use.
Ascender and descender identical to the agreeing fixture, with 250 units of external leading declared in both lineGap fields. Renderers differ on whether line gap belongs inside the line box, above it, or split — this is the file that shows which one yours does. Original typeface, free to use.
A standards-compliant plain-text email message (.eml) with full headers — the simplest valid RFC 822 message for testing email header parsing and EML import.
A multipart/alternative email carrying both a plain-text and an HTML body — for testing MIME part selection, HTML-part handling and sanitising, and multipart parsing.
A short Markdown document in the mini RAG corpus (doc-a.md) — retrieve against the paired queries JSON.
A short Markdown document in the mini RAG corpus (doc-b.md) — retrieve against the paired queries JSON.
A short Markdown document in the mini RAG corpus (doc-c.md) — retrieve against the paired queries JSON.
A short Markdown document in the mini RAG corpus (doc-d.md) — retrieve against the paired queries JSON.
The classic hello-world in idiomatic Python 3, with a shebang, a module docstring, and the standard main guard — the minimal correct program for testing highlighters and interpreters.
A realistic Python snippet exercising type hints, an lru_cache-memoised recursive function, a generator, and a frozen dataclass — for testing syntax highlighters, linters (ruff/flake8), and formatters (black).
The classic hello-world in modern JavaScript — a minimal function calling console.log, for testing highlighters, Node, and JS parsers.
A realistic JavaScript snippet with an ES class, private #fields, arrow functions, template literals, a getter, and async/await — for testing highlighters, ESLint, Prettier, and bundlers.
The classic hello-world in TypeScript (shipped as .mts to avoid the MPEG-TS .ts collision) — a typed function for testing TypeScript-aware highlighters and the tsc compiler.
A realistic TypeScript snippet with an enum, a discriminated union, generics, exhaustive switch handling, and a typed reduce — for testing the type checker, highlighters, and the TS ESLint parser.
A minimal, valid HTML5 document — doctype, head, and a single heading — for testing HTML parsers, highlighters, and validators against the simplest well-formed page.
A realistic semantic HTML page with landmark elements (header, nav, main, article, footer), a figure with alt text and caption, and lists — for testing HTML parsers, accessibility tooling, and highlighters.
A minimal stylesheet that centres a heading with grid — the simplest useful CSS file for testing highlighters, CSS parsers, and minifiers.
A realistic component stylesheet using custom properties, flexbox, a fluid clamp() font size, color-mix(), a keyframe animation, and a media query — for testing CSS parsers, linters (stylelint), and highlighters.
The classic hello-world in Java — a public class with the standard main method — for testing highlighters, javac, and Java parsers.
A realistic Java class with a package declaration, fields, a nested record, methods that throw exceptions, and formatted output — for testing highlighters, javac, Checkstyle, and parsers.
The classic hello-world in C — an include, main, and printf — for testing highlighters, C compilers, and parsers against the canonical first program.
A realistic C program: a singly linked list with a typedef struct, malloc/free memory management, pointer walking, and error handling — for testing highlighters, compilers, and static analysers.
The classic hello-world in C++ — iostream and std::cout — for testing highlighters, C++ compilers, and parsers.
A realistic C++ snippet with a class template, STL algorithms (max_element, accumulate), std::move, and range handling — for testing highlighters, g++/clang++, and parsers against real templates.
The classic hello-world in Go — package main, an import, and fmt.Println, tab-indented like gofmt — for testing highlighters, the Go compiler, and parsers.
A realistic Go program: a worker pool with structs and methods, goroutines, buffered channels, and a sync.WaitGroup — tab-indented like gofmt, for testing highlighters, go vet, and parsers.
The classic hello-world in Rust — fn main and the println! macro — for testing highlighters, rustc, and parsers.
A realistic Rust snippet with an enum carrying data, a trait and impl, exhaustive match, iterators, and Option handling — for testing highlighters, rustc, clippy, and parsers against real ownership-era code.
The classic hello-world in PHP — an opening tag and echo — for testing highlighters, the PHP interpreter, and parsers.
A realistic modern-PHP snippet with strict types, a namespace, a backed enum, a final class with constructor-promoted readonly properties, and array_reduce with an arrow function — for testing highlighters, PHPStan, and parsers.
The classic hello-world in Ruby — a single puts — for testing highlighters, the Ruby interpreter, and parsers.
A realistic Ruby snippet: a Stack class that mixes in Enumerable, yields blocks, raises a custom error class, and uses string interpolation and symbol-to-proc — for testing highlighters, RuboCop, and parsers.
The classic hello-world in Bash — a shebang and echo, with LF line endings so it runs on Unix — for testing highlighters, ShellCheck, and shell parsers.
A realistic Bash script using strict mode (set -euo pipefail), functions, default parameters, a loop, and conditionals — an illustrative fixture (review before running) for testing highlighters, ShellCheck, and shfmt.
The classic first query in SQL — a single SELECT of a literal — for testing highlighters, SQL parsers, and query editors.
A realistic SQL script with CREATE TABLE constraints and foreign keys, INSERT seed data, a CREATE VIEW, and a grouped aggregate query with a join — for testing SQL parsers, formatters, and highlighters.
The classic hello-world in Kotlin — a top-level main function — for testing highlighters, the Kotlin compiler, and parsers.
A realistic Kotlin snippet with data classes, an enum, a sealed result interface, extension functions, and when expressions — for testing highlighters, the Kotlin compiler, ktlint, and parsers.
The classic hello-world in Swift — a single print — for testing highlighters, the Swift compiler, and parsers.
A realistic Swift snippet with an enum, a protocol, a struct with a computed property, optionals and optional binding, and higher-order functions — for testing highlighters, the Swift compiler, SwiftLint, and parsers.
Idiomatic C# hello-world for syntax highlighters and Roslyn-style parsers.
A small C# iterator Fibonacci utility — realistic snippet for language tooling.
Minimal Dart hello-world for Flutter/Dart IDE and highlight tests.
Tiny Dart class with a counter — fixture for Dart analysis servers.
Elixir module hello — for Beam/Elixir syntax and formatter smoke tests.
Elixir pipe-operator snippet for AST and formatter fixtures.
Zig hello-world for Zig language-server and highlighter tests.
Zig function plus a unit test stub — realistic small module.
Scala 3-style object hello for Scalac / Metals fixtures.
Scala foldLeft snippet for syntax and indexer tests.
Intentionally invalid Python indentation for linter / parser error-path tests. Labelled intentionally invalid in title and description.
Intentionally corrupt JavaScript object literal — labelled invalid for error handling. Labelled intentionally invalid in title and description.
Intentionally invalid JSON (unquoted key + trailing) for strict parser failure tests. Labelled intentionally invalid in title and description.
Intentionally invalid YAML indentation for parser error fixtures. Labelled intentionally invalid in title and description.
Minimal Julia hello-world for syntax highlighters and Julia LSP smoke tests.
Julia typed Fibonacci with a for-loop — realistic snippet for language tooling.
Julia broadcast operators (.^ .+ ) for highlighter and parser edge cases.
Idiomatic Haskell hello-world for GHC / HLS fixtures.
Haskell foldl snippet for AST and highlighter tests.
Haskell Maybe pattern matching — realistic small module.
Minimal Lua hello for embedder and syntax-highlight tests.
Lua table with method colon syntax for parsers.
Tiny Lua coroutine yield loop for language tooling.
Minimal R hello-world for RStudio / language-server fixtures.
R data.frame construction — realistic snippet for R parsers.
R native pipe (|>) snippet for modern R tooling.
Minimal Clojure hello for CIDER / clj-kondo fixtures.
Clojure reduce utility — realistic snippet.
Clojure thread-first macro for highlighter tests.
Minimal Fortran 90 hello for gfortran / highlighter fixtures.
Fortran do-loop sum — realistic numerical snippet.
Fortran module with a pure-ish helper for module parsers.
Minimal Nim hello for nimlsp / highlighter tests.
Nim recursive fib proc — realistic snippet.
Nim object type plus proc — for Nim AST tooling.
Python dataclass SAMPLE for highlighter and type-checker smoke tests.
Tiny asyncio gather stub for async Python tooling.
Go generics helper for gopls / highlighter fixtures.
Rust Result map chain — realistic error-handling snippet.
TypeScript satisfies operator sample (.mts) for TS tooling.
Java record type hello for javac / highlighter fixtures.
Kotlin data class SAMPLE for Kotlin language-server tests.
Swift struct SAMPLE for SourceKit fixtures.
Ruby nested module SAMPLE for parser tests.
PHP 8 attributes SAMPLE for PHP tooling.
C struct SAMPLE for clangd / highlighter fixtures.
C++17 optional SAMPLE for clangd fixtures.
Bash strict-mode hello for shellcheck / highlighter tests.
SQL window function SAMPLE for SQL parsers.
C# LINQ chain SAMPLE for Roslyn fixtures.
Scala pattern match SAMPLE for Metals fixtures.
Zig errdefer SAMPLE for Zig language-server tests.
Dart async Future SAMPLE for analysis-server tests.
Elixir GenServer stub SAMPLE for Beam tooling.
Intentionally invalid Julia (unclosed function) for linter error-path tests.
Intentionally invalid Haskell (unterminated string) for parser failure tests.
Intentionally invalid Lua table for error handling.
Intentionally invalid R (unclosed call) for parser tests.
Intentionally invalid Clojure (unbalanced forms) for clj-kondo-style tests.
Intentionally invalid Fortran for compiler error fixtures.
Intentionally invalid Nim for nim check error paths.
Intentionally invalid Go syntax for gofmt/parser failure tests.
Intentionally invalid Rust for rustc error-path fixtures.
Intentionally invalid Python match (missing colon) for linters.
Julia Macro SAMPLE for Wave G language-tooling coverage.
Haskell Typeclass SAMPLE for Wave G language-tooling coverage.
Lua Metatable SAMPLE for Wave G language-tooling coverage.
Nim Template SAMPLE for Wave G language-tooling coverage.
Tiny SAMPLE SQL shape (select-star-invalid) for static-analysis demos — not live DDL.
Tiny SAMPLE SQL shape (missing-where-update) for static-analysis demos — not live DDL.
Tiny SAMPLE SQL shape (order-by-injection-shape) for static-analysis demos — not live DDL.
Tiny SAMPLE SQL shape (implicit-cross-join) for static-analysis demos — not live DDL.
Tiny SAMPLE SQL shape (drop-table-comment) for static-analysis demos — not live DDL.
Tiny SAMPLE SQL shape (union-all-dupes) for static-analysis demos — not live DDL.
Tiny SAMPLE tooling config snippet (docker-compose-snippet) for editor/linter harnesses.
Tiny SAMPLE tooling config snippet (github-actions-snippet) for editor/linter harnesses.
Tiny SAMPLE tooling config snippet (eslint-flat-snippet) for editor/linter harnesses.
Tiny SAMPLE tooling config snippet (prettier-config) for editor/linter harnesses.
Tiny SAMPLE tooling config snippet (editorconfig-snippet) for editor/linter harnesses.
Tiny SAMPLE tooling config snippet (tsconfig-strict-snippet) for editor/linter harnesses.
Intentionally lint-bait SAMPLE python snippet (unused-import-invalid) for rule-engine tests.
Intentionally lint-bait SAMPLE python snippet (bare-except-invalid) for rule-engine tests.
Intentionally lint-bait SAMPLE javascript snippet (var-shadow-invalid) for rule-engine tests.
Intentionally lint-bait SAMPLE javascript snippet (eqeqeq-invalid) for rule-engine tests.
Intentionally lint-bait SAMPLE typescript snippet (any-cast-invalid) for rule-engine tests.
Intentionally lint-bait SAMPLE go snippet (errcheck-invalid) for rule-engine tests.
Intentionally lint-bait SAMPLE rust snippet (unwrap-invalid) for rule-engine tests.
Intentionally lint-bait SAMPLE java snippet (empty-catch-invalid) for rule-engine tests.
Intentionally lint-bait SAMPLE ruby snippet (rescue-all-invalid) for rule-engine tests.
Intentionally lint-bait SAMPLE php snippet (error-suppression-invalid) for rule-engine tests.
Intentionally lint-bait SAMPLE shell snippet (unquoted-var-invalid) for rule-engine tests.
Intentionally lint-bait SAMPLE csharp snippet (empty-catch-invalid) for rule-engine tests.
A sample cache-first service worker handling install, activate, and fetch events with an offline fallback — for testing service-worker registration, JS parsers, and PWA tooling.
A robots.txt with wildcard and per-agent rules, a crawl-delay, and a sitemap reference — for testing robots parsers and crawler policy handling.
An XML sitemap (sitemaps.org 0.9) with loc, lastmod, changefreq, and priority for several URLs — for testing sitemap parsers and crawl-scheduling tools.
A humans.txt crediting the people and stack behind a site, in the conventional TEAM/SITE block format — for testing plain-text metadata parsers.
An IAB ads.txt listing authorised digital sellers with account IDs and relationships (sample data) — for testing ads.txt parsers and ad-fraud tooling.
An RFC 9116 security.txt with Contact, Expires, Encryption, and Policy fields — normally served at /.well-known/security.txt, for testing security.txt parsers.
Sample App .env — small deterministic fixture for parsers and the in-browser editor.
Sample Dockerfile — small deterministic fixture for parsers and the in-browser editor.
Sample OPML Subscriptions — small deterministic fixture for parsers and the in-browser editor.
A robots.txt built entirely from pattern rules: `*` inside a path, `$` anchoring the end of a URL, a query-string pattern, and an Allow that carves one file out of a disallowed subtree. For testing that a robots parser implements RFC 9309 path matching rather than prefix comparison.
A robots.txt where Googlebot is named by two separate groups and every Disallow has an equal-length Allow competing with it. For testing group merging, case-insensitive product tokens, and the rule that the most specific match wins with Allow breaking ties.
A robots.txt carrying three different crawl-rate hints - an integer Crawl-delay, a fractional one alongside Request-rate and Visit-time, and a very large one - none of which are part of RFC 9309. For testing that a crawler reads or ignores rate hints without dropping the Disallow rules that share the group.
A robots.txt declaring five sitemaps - before the first group, inside two different groups, in lower case, gzipped, and on another host. For testing that a discovery crawler collects Sitemap as a file-global field instead of scoping it to the group it sits in.
A robots.txt that disallows the entire site for every crawler while allowing one media path for a single image agent. For testing full-block handling and the common misconception that a Disallow removes a URL from a search index.
A robots.txt in which real Disallow rules are surrounded by Noindex, Host, Clean-param, Nofollow and two invented fields, several with inline comments. For testing that a parser skips fields it does not implement instead of aborting or mis-binding the rules that follow.
A robots.txt that begins with a UTF-8 byte-order mark, uses CRLF line endings, and leaves trailing spaces after two rule values. For testing the byte-level tolerances RFC 9309 requires - a leading BOM must be discarded rather than glued onto the first field name.
A robots.txt using upper-case, mixed-case and indented field names, a tab-indented rule, a value with no space after the colon, and both trailing and full-line comments. For testing that field names are treated case-insensitively while path values stay case-sensitive.
A deliberately invalid robots.txt: a rule before any group, an empty product token, an absolute URL where a path belongs, whitespace before the colon, a non-numeric Crawl-delay, and a line with no colon at all. For testing that a parser degrades line-by-line instead of failing the whole file.
The single most common broken robots.txt in the wild: a server that answers /robots.txt with its HTML 404 page instead of a 404 status. For testing that a crawler treats unparseable markup as 'no robots.txt' and allows the site rather than inventing rules from tag names.
A sitemap index listing three child sitemaps, one dated with a plain date, one with a full W3C datetime, and one with no lastmod at all. Two of the children ship alongside it, so a crawler can be walked from index to URL.
The first child of the sitemap index: six core URLs with a deliberately uneven mix of lastmod, changefreq and priority, including one entry that carries nothing but a loc. For testing that optional sitemap fields really are optional.
The second child of the sitemap index: six URLs dated with W3C datetimes in two different timezone offsets, including a changefreq of never and a priority of 0.1. For testing datetime normalisation and priority ordering.
A sitemap whose three URLs form a complete hreflang cluster: every page lists every locale including itself and a shared x-default. This is the shape an international audit should pass, and the reference twin of the broken cluster.
A deliberately invalid hreflang cluster: an `en-UK` region that does not exist, an underscore locale, a German page that never links back, a Spanish self-reference dropped to http, and no x-default anywhere. For testing that an international audit reports each defect rather than the first one.
A sitemap using the image extension namespace: six images across three pages, with and without titles and captions, in JPEG, WebP and AVIF. For testing extension-namespace parsing and image-discovery pipelines.
A sitemap using the video extension namespace: one fully populated entry with duration, rating, view count, country restriction and tags, and one minimal entry with only the required children plus a player attribute. For testing video-sitemap parsers and their attribute handling.
A two-URL news sitemap with publication name, language, publication date and headline for an English and a German article. For testing nested extension elements and per-article language handling.
A sitemap of URLs that need both layers of escaping the format demands: ampersands written as XML entities and reserved characters percent-encoded, plus a punycode host. For testing that a parser unescapes exactly once and does not double-decode.
The plain-text sitemap format the sitemaps.org protocol also accepts: one absolute URL per line, no markup, UTF-8 encoded. For testing that a crawler supports the text form as well as XML.
An SMTP MTA-STS policy in enforce mode listing three MX patterns, one of them a wildcard, with a seven-day max_age. RFC 8461 specifies CRLF line endings, so this fixture is written with them deliberately - for testing policy parsers that split on bare LF.
A sample machine-discoverable Do Not Track policy of the kind served at /.well-known/dnt-policy.txt, stating retention windows, exceptions and a contact for a fictional site. For testing crawlers and privacy scanners that look for the document and read its version header.
Host metadata in its original XRD form: a subject, an alias, an expiry, one property, and three Link elements including an lrdd template with a {uri} placeholder. Paired with the JRD twin that carries exactly the same data.
A gettext .pot template extracted from source — msgid entries with empty msgstr values, source-location comments, and a plural form — the starting point for a new language translation.
A translated gettext .po catalog (Spanish) with a full header, source-location and translator comments, c-format flags, and a plural-form entry — for testing PO parsers and translation-memory tools.
An OASIS XLIFF 1.2 file with English source and Spanish target trans-units and notes — the classic interchange format between authoring tools and translation-management systems.
An OASIS XLIFF 2.0 file with the same content as its 1.2 twin, using the modern unit/segment structure — for testing XLIFF 2.0 parsers and 1.2-to-2.0 converters.
An Apple Localizable.strings file (English) — quoted key = value pairs with comments and %@ placeholders, as iOS/macOS apps use per-locale in .lproj folders.
The Spanish twin of the Apple .strings catalog — for testing .strings parsers and en/es diffing against the same keys.
A Flutter Application Resource Bundle (English) — JSON messages with matching @key metadata (descriptions and typed placeholders) using ICU {name} syntax, as Flutter's gen-l10n consumes.
The Spanish twin of the Flutter ARB bundle — for testing ARB parsers, the gen-l10n pipeline, and ICU placeholder handling.
An Android values/strings.xml (English) with string resources, a <plurals> block, and a <string-array>, using positional %1$s placeholders — the res/values/ default catalog.
The Spanish Android strings.xml (as res/values-es/) — for testing Android resource parsers, plurals, and string-array localization.
A .NET Resources.resx file (English) with the standard ResX schema and resheader block plus name/value string data and comments, using {0} composite-format placeholders.
The Spanish satellite RESX (Resources.es.resx) — for testing .NET resource parsers and culture-based resource resolution against the same keys.
An i18next translation JSON (English) with {{name}} interpolation and an object-form plural (one/other) — the common React/Node i18n catalog shape.
The Spanish i18next catalog twin — for testing i18next loaders, interpolation, and plural resolution against the same keys.
A right-to-left Arabic i18next catalog — real Arabic UI strings for testing bidirectional text handling, RTL layout, Unicode, and font fallback.
A right-to-left Hebrew i18next catalog — real Hebrew UI strings for testing bidirectional text handling, RTL layout, Unicode, and font fallback.
A Japanese (CJK) i18next catalog — real Japanese UI strings for testing CJK Unicode handling, wide-character layout, and font fallback.
A Chinese (CJK) i18next catalog — real Chinese UI strings for testing CJK Unicode handling, wide-character layout, and font fallback.
The English word "Open" translated four different ways in one file — three msgctxt variants plus the context-free entry — alongside a multi-line msgid that must be concatenated with no separator, a no-c-format entry whose %% is literal text, and explicit tab and quote escapes with a significant trailing space.
The Markdown comment a coverage bot posts on a pull request: a headline percentage, a per-file table and the uncovered line numbers. Useful for testing Markdown table rendering and for checking that a bot's generated comment matches the machine-readable report it claims to summarise. Every file in this group describes the same four-file source tree and reports 127/140 lines, 17/24 branch outcomes and 18/20 functions, so a converter can be diffed against a known answer.
The source feature for this whole group: a Background with a data table, a plain scenario, a Scenario Outline expanded by two Examples tables, and a scenario asserting against a doc string. It compiles to exactly six pickles and 32 pickle steps — the numbers the cucumber-messages and cucumber.json twins next to it report.
A named Background whose two steps are prepended to all three scenarios, plus feature-level tags that every scenario inherits and scenario-level tags that only some carry. Tag filtering is where this file earns its keep: @slow selects one scenario by its own tag and all three by inheritance from the feature.
One outline expanded by two separate Examples tables, the second of which carries its own @edge tag. Expansion must produce five scenarios, and only the two from the tagged table may match a run filtered on @edge — a distinction parsers that flatten the tables lose.
A step argument table with a header row, followed by two doc strings — one plain and one carrying a json content type after the opening delimiter. Doc string indentation is relative to the delimiter, so the receipt body must keep its internal column alignment while losing the six leading spaces.
Two Rule blocks, the first with its own Background that applies only to the examples inside it. Parsers written before Gherkin 6 either reject Rule outright or, worse, hoist the Background to the whole feature and add a step to the third example that was never there.
Steps exercising every argument shape a step-definition matcher has to handle: quoted strings with escaped inner quotes, integers, decimals, a comma-and-and list, the But keyword, and angle brackets in a plain Scenario where they are literal text rather than outline placeholders.
A complete Robot Framework suite with all four common sections, scalar, list and dictionary variables, a continued line using ..., and user keywords with arguments. Robot separates arguments on two or more spaces, so a parser splitting on a single space merges every keyword call into one token.
The template form, in which the *** Test Cases *** header itself names the argument columns and each row becomes one test. Five tests share a single keyword body, and a parser that reads the header row as a test name reports six.
A resource file: keywords, variables and imports with no *** Test Cases *** section at all, meant to be imported by the suites next to it. Tooling that requires at least one test case rejects a perfectly ordinary resource, and keyword defaults such as ${qty}=1 are where argument parsers usually stop.
A complete release test plan for the fictional Novus Checkout Service — scope, test levels, entry and exit criteria, a risk table and deliverables. Useful as a Markdown-rendering fixture with three tables and nested lists, and as a realistic input for documentation tooling that has to extract structure from prose.
One added guard line in a shell script, rendered as a POSIX `diff -u` with three lines of context and timestamped ---/+++ headers. The smallest complete unified diff, and the baseline the context-format and normal-format twins in this group encode identically.
The exact inverse of the single-hunk fixture: the same edit expressed as a deletion instead of an insertion. Applying both in sequence must return the file to its original bytes, which makes this the fixture for `patch -R` and for revert paths.
One TypeScript module edited in 2 places at once, so the hunks are far enough apart not to merge. Use it to check that a parser advances its line cursor by the hunk header rather than by counting emitted lines.
Three unrelated files changed in a single diff stream, with no `diff --git` lines to mark the boundaries — the only separator is the next `---` header. Splitters that key on `diff --git` see one file here instead of three.
A file created from nothing: the old side is `/dev/null` and the hunk header carries the zero-length range `-0,0`. Parsers that compute a 1-based start line from the old range produce line 1 instead of line 0 unless they special-case a zero count.
The mirror of the added-file fixture: every line is a deletion and the new range is `+0,0`. A renderer that writes an empty file instead of unlinking it, or that reports the change as a truncation, fails this one.
`diff -U0` output: hunks contain nothing but +/- lines, and pure insertions produce ranges such as `-9,0`. Coverage and blame tools that need zero-context diffs hit this shape constantly, and hunk mergers that assume at least one context line get the offsets wrong.
The same edit as the zero-context fixture with ten lines of context, which merges the separate hunks into fewer, larger ones. Pair the two to check that a hunk-merging or context-trimming routine reaches the same applied result from either input.
A one-line file changed in place. Both ranges have length one, so the header is written `@@ -1 +1 @@` with no comma and no count — the abbreviation the unified format allows and that regexes of the form `-(\d+),(\d+)` fail to match.
git appends the enclosing declaration after the closing `@@` of each hunk header. The text is free-form and is not part of the range, so a parser that splits the header on `@@` and takes the last field reads the function signature as a range.
The before-state has no final newline and the after-state gains one, so the marker appears once, immediately after the last `-` line. The change is invisible in a rendered side-by-side view yet alters the file's bytes, which is why line-based comparators report a spurious no-op.
A one-line file is edited and loses its trailing newline in the process, so the marker follows the `+` line instead of the `-` line. Applying this and then re-diffing must not reintroduce the newline.
Neither version ends with a newline, so the marker appears twice in one hunk: once after the last removed line and once after the last added line. Parsers that treat the marker as a terminator rather than an annotation stop reading at the first one and lose the added line.
Byte-for-byte the same diff as its LF twin except that every line ends CR LF, which is what a diff produced or saved on Windows looks like. Readers that compare a hunk line against expected content without stripping the CR find that no line matches.
The LF half of the line-ending twin pair: identical text content to the CRLF fixture, differing only in the terminator bytes. Diff the two downloads to see nothing but line-ending changes, and use the pair to score end-of-line normalisation.
The file itself is LF-terminated, but every removed line carries a literal CR as its last character because the change under review is a CRLF-to-LF conversion. Renderers that do not show the CR display a hunk in which every removed and added line looks identical.
Indentation is converted from tabs to spaces and one line gains trailing whitespace, so the diff is large and the program is unchanged. It is the fixture for `-w`/`--ignore-all-space` handling and for review UIs that offer a hide-whitespace toggle.
With git's default `core.quotepath`, a path containing non-ASCII bytes is wrapped in double quotes and each byte is written as a backslash-octal escape. A parser that takes the header text literally creates a directory called `caf\303\251` on disk.
The same change with `core.quotepath=false`, so the path is written as raw UTF-8 and the header is not quoted. Compare with the quoted twin to confirm a parser resolves both spellings to the same file.
A complete format-patch message: the mbox `From <sha> Mon Sep 17 00:00:00 2001` line, RFC 5322 headers, a commit message with a Signed-off-by trailer, the `---` separator, a diffstat and the diff. The signature separator is `-- ` with the trailing space git actually writes, which editors love to strip.
A file creation carried by the `new file mode 100644` extended header rather than by the paths alone. The mode is the authoritative signal: the `--- /dev/null` line tells you the old side is empty, but only the header tells you what permissions to create the file with.
A deletion of an executable file, so the `deleted file mode 100755` header records the mode the file had rather than the mode to create. A patcher that writes an empty file here instead of unlinking leaves a broken executable behind.
A permission change and nothing else: the file section has `old mode`/`new mode` headers, no `index` line, no `---`/`+++` pair and no hunks at all. Parsers that require at least one hunk per file drop this change entirely and report an empty patch.
The same file changes permissions and content in one commit, so the mode headers are followed by an `index` line and a normal hunk. Applying only the hunk and silently ignoring the mode is the common failure, and it leaves a script that is no longer executable.
Git stores a symlink as a blob whose contents are the link target with no trailing newline, so this patch adds a single + line followed by the no-newline marker and marks it mode 120000. A patcher that ignores the mode writes a regular text file containing a path.
A rename with no content change at all: `similarity index 100%`, `rename from`, `rename to`, and then nothing — no index line and no hunks. This is the single most common patch shape that naive parsers lose, because there is no `@@` anywhere in the file section.
A rename that also edits the file, so the similarity index drops to 68% and the rename headers are followed by an index line and real hunks whose `---`/`+++` paths differ from each other. A patcher that applies hunks to the path on the `---` line writes to the file that no longer exists.
`copy from`/`copy to` headers, produced only when copy detection is enabled with `-C`. The source file still exists afterwards, which is the whole difference from a rename — and the difference a parser that maps both header pairs onto one 'moved' concept silently erases.
The torture test: one commit that creates a file, deletes an executable, renames at 100%, copies with detection on, changes a mode while editing, and adds a binary blob. The diffstat carries the matching create/delete/rename/mode-change summary lines that follow the file table.
The whole patch file uses CRLF terminators, as it would after a round trip through a Windows editor or a mail client. `git am` needs `--keep-cr` to be told the CRs belong to the patch rather than to the content, and the `-- ` signature line now ends with space-CR-LF.
The LF half of the patch twin pair, identical in text content to the CRLF fixture. Diff the two downloads to get a change that is invisible in every renderer and fatal to a byte comparison.
The `--cover-letter` message git writes ahead of a series: a `[PATCH 0/3]` subject, a shortlog of the authors and their subjects, and the combined diffstat — but no diff of its own. Series tooling has to recognise it as metadata and not try to apply it.
Patch 1 of a three-message series, threaded under the cover letter with In-Reply-To and References headers. Applying the three out of order breaks: the series is only self-consistent in numeric order.
Patch 2 of a three-message series, threaded under the cover letter with In-Reply-To and References headers. Applying the three out of order breaks: the series is only self-consistent in numeric order.
Patch 3 of a three-message series, threaded under the cover letter with In-Reply-To and References headers. Applying the three out of order breaks: the series is only self-consistent in numeric order.
The `.orig` backup GNU patch writes beside a file it has modified: the exact pre-patch content, kept so a failed application can be unwound. Paired with the .rej fixture, it is the complete state a developer actually finds after a patch goes wrong.
A complete CycloneDX 1.6 SBOM in JSON for a fictional application and its nine dependencies, with purls, SHA-256 hashes, supplier records, external references and an explicit dependency graph. Every package, version, hash and licence is fictional — the tree describes nothing real.
The same fictional CycloneDX 1.6 SBOM serialised as XML against the cyclonedx.org/schema/bom/1.6 namespace — the JSON twin of this file carries identical components and edges, so a converter can be diffed exactly. Every package, version, hash and licence is fictional — the tree describes nothing real.
An SPDX 2.3 SBOM in JSON describing the same fictional tree as the CycloneDX documents in this category, with SPDXIDs, purl external references, SHA-256 checksums and DESCRIBES/DEPENDS_ON relationships. Every package, version, hash and licence is fictional — the tree describes nothing real.
The same SPDX 2.3 SBOM in the specification's plain-text tag-value form — the serialisation many licence-compliance tools still read first, and the exact twin of the JSON document in this family. Every package, version, hash and licence is fictional — the tree describes nothing real.
The field-by-field map between the CycloneDX 1.6 and SPDX 2.3 documents in this category, plus the five invariants a correct conversion preserves and the three things it legitimately loses. Every package, version, hash and licence is fictional — the tree describes nothing real.
A Yarn 1 lockfile in its own line-oriented grammar — quoted descriptor headers, two-space indented fields, resolved URLs with a SHA-1 fragment — which looks like YAML but is not. Every package, version, hash and licence is fictional — the tree describes nothing real.
The human-readable end of the pipeline: a triage report that records a decision and a reachability path for each of the four SAMPLE findings, matching the states asserted by the VEX documents here. Advisory identifiers use the invented NOVUS-SAMPLE namespace with SAMPLE-CVE aliases; no identifier here refers to a published CVE, GHSA or OSV record, and no package named exists.
The five checks a verifier must perform against the attestation fixtures in this category, and the exact result each one should produce — including the two that are meant to fail. Every package, version, hash and licence is fictional — the tree describes nothing real.
The same diamond graph as Graphviz DOT, with edge labels carrying the declared semver range and the two diamond joins filled — renderable to SVG and diffable against the JSON twin. Every package, version, hash and licence is fictional — the tree describes nothing real.
The dependency graph as Mermaid, for embedding in Markdown documentation — labelled edges carry the declared range and a classDef highlights the two diamond joins. Every package, version, hash and licence is fictional — the tree describes nothing real.
The written explanation of both diamonds in this category — the one that resolves to a single shared node and the peer conflict that forces a nested duplicate — with the four assertions a resolver test should make. Every package, version, hash and licence is fictional — the tree describes nothing real.
Every value from the CF-1.8 NetCDF grid flattened to one row per cell, with the axis values spelled out in full. Diff a NetCDF-to-table export against this file to prove the reader walked the dimensions in (time, lat, lon) order and did not silently transpose the array.
The stored integer, the unpacked value, the original float and the quantisation error for all 120 cells of the packed NetCDF grid. It makes the cost of int16 packing explicit and gives an unpacking implementation an exact per-cell target.
Every header card of the tangent-plane WCS file transcribed to keyword, value and comment columns. Diff a header parser's output against it to prove the parser split each 80-column card at the right places instead of guessing on whitespace.
Every element of the float64 .npy array written as its shortest round-tripping decimal representation, one row per element in C order. Parsing this text back to float64 reproduces the binary array bit for bit, so it is a usable oracle rather than a lossy printout.
Every value in the float64 boundary array decomposed into its shortest decimal representation, its C99 hexadecimal float form, and its raw sign, exponent and mantissa fields. It turns 'the numbers came back wrong' into a diff you can point at a single bit.
The same boundary values as strict RFC 8259 JSON, where non-finite numbers are null in the numeric field and text in the string field because the standard has no NaN or Infinity literal. It is the fixture for the encoder that emits bare NaN and produces JSON nothing else will parse.
The float32 boundary values split into sign, 8-bit exponent and 23-bit mantissa alongside their decimal forms. Use it to check a single-precision encoder field by field rather than guessing which end of the number went wrong.
The six NaN bit patterns broken into sign bit, quiet bit and payload so the difference between a quiet and a signalling NaN is a column rather than folklore. It is the reference for testing whether a serializer preserves NaN payloads or normalises them all to one canonical pattern.
Each rung of the subnormal ladder with its bit pattern, decimal value, C99 hex float and remaining significant bits, plus the value a flush-to-zero pipeline would produce instead. It makes gradual underflow a table you can diff rather than a behaviour you have to infer.
Nine ways of writing zero, what each parses to, and what dividing one by the result gives. Negative zero compares equal to positive zero yet behaves differently in division and in sign propagation, so a formatter that drops the sign changes results without changing any comparison.
Twelve doubles narrowed to single precision with the absolute, relative and ULP error of each, plus whether the value survived unchanged. It covers the three distinct ways narrowing fails: rounding, overflow to infinity at 1e39, and demotion to a subnormal at 1e-40.
Eight arithmetic expressions where binary floating point and exact decimal disagree, with both answers and the signed error side by side. Adding one cent a hundred times does not give one, and this file says by exactly how much.
Five computations done twice, once with the obvious formula and once with the numerically stable one, with the relative error of the naive version alongside. The one-pass variance row is the memorable one: five values a millisecond apart near 1e8 can produce a negative variance.
Six large integers written both as JSON numbers and as strings, including the 2^53 boundary where consecutive integers stop being distinguishable in a double. A parser backed by doubles turns 9007199254740993 into 9007199254740992 and reports no error at all.
Every value in the raw endian pair with its exact byte sequence in both orders, so a decoder can be checked offset by offset instead of value by value. Negative zero and the subnormal entries are the rows where a byte-order mistake stops looking like a mistake.
Twelve doubles printed at 15, 16 and 17 significant digits alongside their shortest round-tripping form, with a column recording which precisions actually recover the original bits. Fifteen digits is the default in a lot of formatting code and it loses values, which this table demonstrates rather than asserts.
The same 1002 numbers added five different ways, giving results from 0 to 1000 for an exact answer of 1000. Floating-point addition is not associative, and this file is the smallest complete demonstration of what that costs a naive accumulator.
A synthetic absorbance scan from 400 to 630 nm with a Gaussian band at 520 nm, carrying its expanded uncertainty at k=2 in a dedicated column and a per-row quality flag. The unit and the coverage factor live in the column names, which is the convention most instrument exports actually use.
The same instrument export with units on a second header row instead of inside the column names, which is how a great many laboratory instruments write CSV. An importer that treats row two as data types every measurement column as text and then quietly refuses to plot anything.
A full day of thermocouple readings at 30-minute cadence with a constant type-B standard uncertainty and two rows flagged as recovering. The timestamps are explicit UTC with a Z suffix so a reader has no excuse to guess a timezone.
Ten weighings as tab-separated values with headers that contain spaces, brackets and parentheses — 'u(mass) [g]' — the way balance software actually writes them. Column names like these break naive slug-based header handling long before the numbers become a problem.
Five calibration points with the nominal value, the measured value, the signed error and the expanded uncertainty at k=2 with its confidence level stated. It is a synthetic illustration of the layout, not an accredited certificate, and nothing in it refers to a real instrument or laboratory.
Four batches of five replicate titrations with the mean, sample standard deviation, standard error and relative standard deviation computed for each. The standard deviation uses the n-1 denominator, which is stated explicitly because a population-denominator implementation disagrees on every row.
A five-source uncertainty budget laid out the way the GUM prescribes: each source with its distribution, its divisor, its sensitivity coefficient and its contribution, then the combined and expanded values. Rectangular sources are divided by the square root of three, which is the step budget spreadsheets most often get wrong.
Eight measurements whose unit symbols use the codepoints that have Unicode look-alikes: MICRO SIGN against GREEK MU, OHM SIGN against GREEK OMEGA, ANGSTROM SIGN against A-with-ring. Each row also carries an ASCII fallback, so a normalisation bug shows up as a column mismatch rather than as an invisible change.
Eight written measurements where the trailing zeros carry the precision of the measurement, alongside what a float parse leaves behind. Parsing 1.200 to the double 1.2 is not a rounding error, it is the loss of the claim that the value is known to four figures.
Nine laboratory results where only four are plain numbers: two are below the detection limit, one is above range, two are missing in different spellings, and one is a legitimate small negative near the blank. Coercing the censored strings to numbers or to NaN both bias the summary, and the file distinguishes every case explicitly.
A 2020-12 JSON Schema for the absorbance rows, carrying the physical unit and coverage factor as custom annotation keywords beside the standard type and range constraints. Annotations like these are ignored by validators and read by humans and tooling, which is precisely the contract being tested.
Six fictional laboratories reporting the same measurand, scored both by z-score against a fixed sigma and by En number against each lab's own claimed uncertainty. The two statistics disagree about which labs are acceptable, which is the point: En rewards an honest uncertainty claim and z does not.
Every element of the synthetic phantom dataset as tag, value representation, meaning and encoded length, in the ascending tag order the standard mandates. Diff a parser's element list against it to check both the ordering rule and the two different length encodings.
Ethanol as a V2000 molfile with fixed-column 3D coordinates, a nine-atom counts line and an eight-bond block. The column widths are part of the format rather than a convention, so it is a genuine test of fixed-width parsing rather than of whitespace splitting.
The same ethanol geometry in XYZ format: an atom count, a free-text comment line and one line of element and coordinates per atom. XYZ carries no connectivity at all, so converting to it from the molfile is a lossy operation that this pair makes measurable.
Ethanol as a single tab-delimited SMILES record, the most compressed member of this family: three heavy atoms with every hydrogen implicit and no geometry whatsoever. Round-tripping molfile to SMILES and back is the classic lossy conversion, and this pair is the reference for it.
An SDfile wrapping the identical ethanol molfile plus five tagged data fields and the mandatory $$$$ terminator. The property block syntax — a header line, a value and a blank line — is where SDfile parsers usually diverge from molfile parsers.
Three molecules of different sizes in one SDfile, each with its own connection table and four data fields, separated by the $$$$ terminator. It is the fixture for streaming SDfile readers that have to split on the terminator rather than load the whole file.
Ten tab-delimited SMILES covering the notation features that trip parsers: lowercase aromatic atoms, ring-closure digits, branch parentheses, explicit charges in brackets and a dot-disconnected salt. Every structure is small enough to verify by hand.
Benzene written in the V3000 extended format, where the legacy counts line reports zero atoms and the real counts live in an M V30 COUNTS record. A parser that trusts the old counts line reads an empty molecule and reports no error whatsoever.
A single-data-block CIF describing an idealised rock-salt lattice: cell parameters, space group, a symmetry-operation loop and an atom-site loop with fractional coordinates and occupancies. The '?' in the temperature field is CIF's marker for unknown, which is not the same as an empty value.
A CIF built entirely out of the constructs that break naive parsers: quoted values containing apostrophes and hashes, a semicolon-delimited multi-line text field, the distinct '?' and '.' markers, a standard uncertainty written as 1.2345(7), and a loop whose rows wrap across lines. Every one of them is legal CIF.
Five concatenated XYZ frames of the same ethanol molecule rotated rigidly about z in 15-degree steps, which keeps every interatomic distance constant. Frames are separated only by the next atom-count line, so a reader that expects a blank-line delimiter stops after frame one.
An intentionally corrupt molfile whose counts line declares twelve atoms while the atom block contains nine, so a parser reading by count consumes three bond lines as atoms. Everything else about the file is well formed, which is what makes the failure quiet.
One row per molecule used across the chemistry fixtures, with formula, molecular weight, SMILES and the atom and bond counts each file should yield. It is the oracle a cheminformatics toolkit can be scored against without needing a second toolkit to generate the answers.
Four 600-base synthetic contigs wrapped at the conventional 60 columns, with the length and an invented organism name in each header. The sequences come from a fixed seed, so they are reproducible and belong to nothing that exists.
The same four contigs written one sequence per line rather than wrapped, which is how many pipelines emit FASTA and how many line-oriented parsers assume it always looks. Comparing against the wrapped twin proves a parser joins continuation lines instead of taking the first one.
Six 60-base reads with Phred+33 quality strings, the modern Sanger encoding used by everything since Illumina 1.8. Quality declines along each read the way real sequencing does, so a mis-decoded offset produces implausible scores rather than plausible ones.
The identical reads and identical quality scores written with the legacy Phred+64 offset used by older Illumina pipelines. Decode it with the modern offset and every base looks 31 points better than it is, which is a silent quality inflation rather than a parse failure.
Every twelfth base of the six reads with its Phred score, the ASCII character it takes under both offsets, and the error probability that score implies. It converts a quality-encoding argument into a lookup you can diff.
Seven features on a synthetic contig — two genes, an mRNA, two exons and two CDS records — linked by ID and Parent attributes across both strands. GFF3 coordinates are 1-based and inclusive, which is the fact its BED twin exists to contrast.
The same six features as the GFF3 file expressed in BED's 0-based half-open coordinates, where the start is one lower and the end is unchanged. Confusing the two conventions shifts every interval by a base, and this pair makes that shift a visible diff.
Every interval written in both coordinate conventions with its length, which is identical either way. It is the lookup table for the most common bioinformatics off-by-one, and the length column is what proves a conversion did not quietly change an interval's size.
Six alignments against a synthetic contig with a full @HD/@SQ/@RG/@PG header, both strands via the reverse flag, and CIGAR strings covering match, soft clip, insertion and deletion. Reference span and query length come apart in three of the records, which is where CIGAR arithmetic gets tested.
Each alignment's CIGAR decomposed into how many query bases and how many reference bases it consumes, with the resulting 1-based reference end. The three records where those numbers differ are the whole reason CIGAR arithmetic is worth testing.
A six-taxon Newick tree with branch lengths on every edge and bootstrap-style support values written as internal node labels. That support notation is ambiguous by design in Newick — the same position can hold a node name — which is precisely what a parser has to decide about.
The identical tree topology with every branch length and support value stripped, which is what a Newick writer produces when the source tree has no lengths. Comparing the two proves a parser distinguishes 'length zero' from 'no length recorded'.
Three synthetic protein sequences that begin with methionine and include the X, B and Z ambiguity codes, which are legal IUPAC residues rather than errors. A validator restricted to the twenty standard amino acids rejects all three files.
An intentionally corrupt FASTQ whose first five records are complete and whose sixth ends after the plus line, leaving no quality string. A four-line-block reader must report an incomplete final record rather than pairing the sequence with an empty quality string.
An 8x8 sparse matrix in Matrix Market coordinate form with twelve stored entries and 1-based indices, the convention that catches every reader written against 0-based arrays. Comment lines beginning with a percent sign appear before the size line, where the format requires them.
The twelve stored entries of the sparse matrix with both 1-based and 0-based indices in adjacent columns. It turns the Matrix Market indexing convention from a footnote into something a loader can be diffed against directly.
A 4x3 dense matrix where values run down each column rather than across each row, which is the Matrix Market array convention and the opposite of what most readers assume. Getting it wrong rearranges every element rather than raising an error.
A symmetric pattern matrix carrying only positions and only the lower triangle, so nine stored lines describe sixteen non-zeros. Both halves of that — no value column and an implied mirror — are places a reader can silently disagree with the file.
A Hermitian complex matrix where each line carries a real and an imaginary part and the implied mirror entry is the complex conjugate rather than a copy. Every diagonal entry has a zero imaginary part, which the Hermitian property requires and a validator should check.
A matrix whose banner declares an integer field, so the values are integers and must not be widened to floats on the way in. The stored range deliberately reaches the signed 16-bit limits, so a narrow integer type overflows visibly.
A valid Matrix Market file describing a 6x6 matrix with no stored entries, which is an all-zero matrix rather than an error. It separates readers that model an empty result from readers that treat a missing entry block as truncation.
An intentionally corrupt Matrix Market file whose banner and size line are perfectly valid and whose entry block stops seven lines short of the declared count. A reader that preallocates from the declared count and never checks ends up with seven silent zeros.
A GitHub Actions CI workflow with a two-axis build matrix (three Node versions across two runners), an npm cache, and a conditional artifact upload. Six matrix combinations, so a workflow linter or matrix expander has a documented answer to check against.
The called half of a reusable-workflow pair: a workflow_call trigger with typed inputs, a default value, and a declared output wired to a job output. Pair it with the caller fixture to test cross-workflow input and output resolution.
The calling half of a reusable-workflow pair: a workflow_dispatch trigger with a choice input, two jobs that call the same reusable workflow with different arguments, and a third that consumes their outputs through needs.
An action.yml-shaped composite action definition with typed inputs, a declared output bound to a step output, and a branding block. Distinct from a workflow file, and a common blind spot in workflow linters that only understand .github/workflows.
The workflow file that exposes the YAML 1.1 boolean resolver: a bare `on` key becomes True in PyYAML, SnakeYAML and Psych, so a round-trip through those loaders loses the trigger block. The env values repeat the trap with NO, yes and off alongside a quoted control.
A deprecated-syntax workflow: ::set-output, ::set-env and ::add-path markers, a retired runner label, and v2 action pins. Every construct here was removed from the runner, so an upgrade migrator can be scored on whether it rewrites all of them.
A deployment workflow exercising the blocks that governance tools care about: a concurrency group with cancel-in-progress, paths-ignore filters, a named environment with a URL, and a job timeout. All hosts are example.invalid.
An expression-dense workflow: fromJSON-generated matrix axes, hashFiles cache keys, format and join calls, a folded multi-line if condition, and the && / || coalescing idiom that stands in for a ternary. For testing template resolvers before any schema check.
The matrix case that expanders get wrong: a 3x3 base grid, two exclude rules, and one include entry that adds a combination and an extra key. Nine minus two plus one is eight jobs, documented in the specs so an expansion can be scored exactly.
A scheduled workflow with two cron entries plus a manual workflow_dispatch trigger carrying a boolean and a choice input. For testing cron parsers, trigger extraction, and input-type handling in workflow tooling.
A three-stage GitLab CI pipeline with a default block, global variables, artifact expiry, a needs-based DAG, and a coverage-extraction regex. The baseline the other GitLab fixtures vary from.
The two GitLab inheritance mechanisms in one file: YAML anchors with merge keys, which the loader resolves before GitLab sees the document, and `extends`, which GitLab resolves afterwards with a deep merge. Hidden .job keys carry both.
GitLab's `!reference` custom YAML tag used three ways: inside a script list, as a whole after_script value, and as a whole rules value. A stock YAML 1.2 loader has no constructor for it and raises; GitLab's loader resolves each key path.
Rule-driven GitLab CI: a workflow block with four ordered conditions ending in `when: never`, plus job rules combining changes patterns, regex tag matching, a null-branch comparison, and a manual allow-failure fallback.
Five include entries across the four include kinds — local path, local glob, another project at a pinned ref, a remote URL, and a bundled template. For testing include resolvers and dependency graphing without any file actually being fetched.
Both GitLab parallelisation forms in one file: a plain `parallel: 4` shard split and a `parallel: matrix` block whose two entries expand to seven combinations. Eleven jobs in total, documented so an expander can be checked exactly.
A deprecated-syntax GitLab CI file using `only`/`except` in both the array and keyed forms, plus the long-retired `type:` keyword. For scoring a migrator that must rewrite all of it to `rules` and `stage`.
Dynamic child pipelines and a cross-project downstream trigger: one job generates a pipeline file as an artifact and a trigger job includes it, while a second trigger job starts a downstream project's pipeline with strategy: depend.
A CircleCI 2.1 config with a two-job workflow, a fallback cache-key list, workspace persistence between jobs, and a test-results store. The baseline the other CircleCI fixtures vary from.
CircleCI orbs and reusable named executors: two orb imports, two executors at different resource classes, an orb-provided step, and a branch filter combining an exact name with a regex.
A reusable CircleCI command with string and boolean parameters, a conditional `when` step, and a job parameterised by an enum expanded through a workflow matrix. Exercises CircleCI's << >> template syntax, which is not YAML and not Jinja.
A CircleCI workflow matrix across three operating systems and two Go versions with one exclusion, plus a tag filter regex. Six combinations minus one is five jobs, documented so an expansion can be scored exactly.
The simplest Azure Pipelines shape: no stages or jobs, just a trigger with branch and path filters, a PR trigger, variables, and a flat step list mixing task and script steps. Baseline for the stage-based fixtures.
A three-stage Azure Pipelines definition with a build-number format expression, a variable group reference, stage conditions built from the expression functions, and a deployment job using the runOnce strategy against a named environment.
Compile-time template expressions: an `${{ each }}` loop over an object parameter, an `${{ if }}` conditional insertion, an `extends` template, and a step template with arguments. These resolve before runtime, which template-aware linters must model.
Azure's named-leg matrix form, where each leg is a mapping of variables rather than an axis product: three Python legs, a maxParallel cap, a job timeout, and a JUnit results publish step that runs on failure too.
A declarative Jenkinsfile with a docker agent, options, environment and parameters blocks, a parallel test stage gated by a when expression, and post conditions. The dialect most Jenkins linters target.
The scripted Jenkinsfile dialect: an imperative node block with Groovy variables, a for loop that builds a parallel branch map at runtime, and try/catch error collection. Structurally unlike the declarative form, and a common parser gap.
A declarative Jenkins matrix over two axes with a nested excludes block: six platform/arch combinations minus the windows arm64 pair leaves five cells, documented in the specs so an expansion can be scored exactly.
A Jenkinsfile importing a pinned shared library and calling three custom steps that no static parser can resolve locally. For testing how tooling reports unknown steps and whether it records the library dependency and its version pin.
Three Kubernetes objects in one YAML stream, the shape kubectl apply consumes. A loader that calls the single-document API returns only the first object and silently drops the other two, which is exactly the failure this fixture is for.
A StatefulSet with volumeClaimTemplates, an ordered pod-management policy, a partitioned rolling update, and a non-root pod security context. For testing manifest linters and admission policies that reason about storage and identity.
A CronJob with an explicit timeZone, Forbid concurrency, a starting deadline, and history limits on both success and failure. For testing cron parsing and the scheduling fields policy engines most often check.
An autoscaling/v2 HPA with both a Resource and a Pods metric, plus scaleUp and scaleDown behaviour policies. The v2 metric shape differs sharply from v1 and v2beta, which is what makes it a useful conversion fixture.
A NetworkPolicy with both policy types: an ingress rule combining namespace and pod selectors, and two egress rules, one of which uses an ipBlock with an except range. For testing policy engines that reason about allowed traffic.
A three-document governance bundle. Its real edge case is quantity handling: values like "8", 16Gi and 250m are Kubernetes quantity strings, and a parser that coerces the quoted ones to numbers or normalises the suffixed ones changes their meaning.
A Kustomize overlay with a name prefix and suffix, common labels, an image tag override, a configMapGenerator merge, and a JSON-6902 patch embedded as a block scalar — YAML inside YAML, which naive rewriters mangle.
A Helm v2 Chart.yaml with two conditional subchart dependencies, semver range constraints, a kubeVersion constraint, maintainers and annotations. Every repository and URL is example.invalid, so nothing resolves anywhere real.
The defaults half of a Helm values pair: nested maps, an empty map and an empty list, a list of env entries, and quoted booleans that must survive as strings. Pairs with the production overrides fixture for deep-merge testing.
The overrides half of a Helm values pair, built to exercise all three merge behaviours at once: maps merge key by key, the env list replaces the defaults wholesale, and an explicit null deletes the inherited podAnnotations map.
An Argo CD Application with automated sync, prune and self-heal, retry backoff, sync options, and an ignoreDifferences rule that exempts replica counts from drift detection. All Git and cluster endpoints are example.invalid.
An Argo CronWorkflow wrapping an inline workflowSpec: a cron schedule with an explicit timezone, Replace concurrency, history limits, and a suspend flag. Nested-spec shape that flat schedule extractors miss.
A Tekton Task declaring string and array params, a workspace, a result, and two steps that use Tekton's $(params.x) and $(workspaces.x.path) variable syntax, including the $(params.flags[*]) array expansion form.
A Tekton Pipeline chaining three tasks with runAfter, a when expression that consumes a prior task's result, and a finally task that runs regardless of outcome. The finally block is a common omission in Tekton graph extractors.
A Tekton PipelineRun as a run request: a pipelineRef, params, timeouts and a workspace binding, with no status block. A completed run's status is a record of what happened and belongs with test-report fixtures, not with pipeline definitions.
A CWL v1.2 CommandLineTool with typed inputs, positional and prefixed bindings, a JavaScript outputEval expression, resource requirements, a Docker hint, and an IANA $namespaces block. Inert: it describes an invocation and runs nothing.
A Compose Specification file with no top-level version key, condition-based depends_on, healthchecks, and a deploy resource limit. Parsers written against the older schema often require the version key, which is exactly what this fixture separates.
Compose with three x- extension fields carrying YAML anchors that are merged into services. The trap is ordering: a tool that strips x- keys before parsing the YAML destroys the anchors and the file stops resolving.
Five Compose services across three profiles, one of which belongs to two profiles at once. Services with no profiles key always start; the rest are opt-in, which is the selection logic this fixture exists to test.
A three-stage Dockerfile with a syntax directive, build args interpolated into FROM lines, a heredoc COPY, multi-line LABEL and ENV continuations, a non-root USER, and HEALTHCHECK in exec form. Inert: every base image is a fictional example.invalid reference.
A Makefile whose recipe lines are indented with real TAB characters, as make requires. Covers simple, conditional, appended and substitution-reference variables, .PHONY, and .DEFAULT_GOAL. Every recipe is echo-only, so running it does nothing.
Pattern rules with the automatic variables $@, $<, $^ and $*, ifeq/ifdef conditional directives, a vpath search path, and a define block invoked through $(call). All recipe lines are TAB-indented and echo-only.
A Gradle Groovy DSL build script with a plugins block, a Java toolchain, five dependency configurations, task configuration via named() and a registered task. Every coordinate and repository is fictional, so nothing resolves.
A Gradle settings script — the file that actually defines a multi-project build — with pluginManagement, a repositories mode, a version catalog declaring libraries, a bundle and a plugin, and one project remapped to a custom directory.
A gradle.properties exercising the .properties grammar rather than Gradle: a \uXXXX escape, a backslash line continuation, all three key/value separator forms, and a key containing escaped separator characters.
The .properties edge cases collected in one file: both comment markers, empty values, a value whose trailing spaces are significant, unescaped = and : inside values, a # that is not a comment, escape sequences, an escaped space in a key, and a duplicate key.
A build-tool configuration in TOML, chosen for the constructs YAML has no direct equivalent for: three [[build.step]] array-of-tables entries carrying an ordered pipeline, a quoted glob key, and all three TOML date-time flavours.
Anchors and aliases across mapping, sequence and scalar nodes, including an anchor nested inside another anchored node. The point most tooling misses: an alias is a reference to the same node, so a shallow-loading parser can share mutable state between jobs.
Merge keys with their full precedence rules: local keys beat merged ones, and in a merge sequence the earlier alias wins. The file publishes the expected merged values, and a strict YAML 1.2 loader produces none of them because 1.2 dropped << from the core schema.
Every block-scalar variation in one file: literal and folded styles, all three chomping indicators, an explicit indentation indicator, a folded block with a paragraph break, and an embedded shell-shaped script whose own indentation must survive.
The Norway problem in full: eleven bare words that a YAML 1.1 resolver turns into booleans, a matching quoted control group that survives, and a country-code list where position two silently becomes false. The definitive fixture for resolver-version behaviour.
Twenty-two unquoted values whose type depends entirely on the resolver. The worst is the leading zero: 0755 is 493 under YAML 1.1 and 755 under YAML 1.2, so both resolvers return a number and they return different ones. Also covers base-60 times, a version that loses its trailing zero, an integer past IEEE-754 precision, dates, and .inf / .nan.
Duplicate keys at three nesting levels, including a duplicated top-level sequence. The spec forbids them; most loaders keep the last silently, a few keep the first, and strict linters reject the document. The file publishes the last-wins answer.
A five-document stream with explicit end markers, a comment-only document that loads as null, and a bare sequence as a whole document. The single-document API returns only the first, which is how multi-object manifests silently lose objects.
Five spellings of null against the things routinely confused with it: empty strings, empty collections, and a key written with no value at all. Includes a sequence containing a hole, an empty string and two nulls in a row.
All three scalar quoting styles side by side: plain scalars and what they cannot contain, single quotes where backslashes stay literal and '' means one quote, and double quotes as the only style that processes \t, \n and \uXXXX escapes.
Flow (JSON-like) and block collections expressing the same structures, nested inside one another in both directions, plus a flow mapping wrapped across lines and a line of strict JSON — which is valid YAML, and a useful check on a parser's JSON-subset claim.
The indentation styles that all parse identically and that formatters fight over: sequences flush with their key versus indented under it, two-space against four-space maps, and deliberately irregular but legal nesting. For testing formatters and idempotency.
Non-ASCII keys and values across Latin, Cyrillic, Arabic, CJK and emoji, plus a key containing a zero-width space and a value distinguishing a combining acute from the precomposed character. Written as UTF-8 with no BOM.
A YAML file written with CRLF line endings, which the spec accepts as a line break. A parser that splits on \n alone leaves a stray carriage return at the end of every plain scalar, so "build" becomes "build\r" and equality checks quietly fail.
A YAML file beginning with a UTF-8 byte order mark, which the spec permits at the start of a stream. A parser that does not strip it reads the first key as \ufeffname, so the lookup misses and the document appears to be missing its name field.
Nested anchor reuse kept deliberately small: two anchors, six references, thirty-one expanded nodes. It is here to test alias resolution and expansion accounting on a safe input, and is explicitly not a billion-laughs expansion bomb.
Explicit tags across the standard set — !!str, !!float, !!int, !!bool, !!null, !!binary, !!timestamp, !!omap, !!set — alongside two application-local ! tags. CI dialects use local tags in the wild, so a pipeline parser has to decide whether to reject, ignore, or resolve them.
A two-document stream where each document declares its own %YAML directive and the second adds a %TAG handle used by a local tag. Comments appear in every position they are legal, and every one of them is lost by a non-round-tripping loader.
We use Google Analytics and show ads via Adsterra. Non-essential cookies and ad scripts run only after you allow the matching categories. See our cookie policy.
