A form is usually verified with values like these: an ordinary name, a date that really exists, a number that fits. Then it meets real data – someone pastes a name with a trailing space, someone’s country code happens to be NO, someone opens an exported table in a spreadsheet program. Defect reports then come back from users one by one, long after the code was written.
These values are neither secret nor clever; they are a short and stable list. The reason they go untested for so long is mundane: nobody remembers them all, and typing them in by hand is too much trouble. The way this has been engineered is well worth borrowing – not another “list of bad strings”, but packaging the value, what it usually breaks, and what correct behaviour should be into an executable catalog that can be sent into any input field in a fixed order with one keystroke.
What Is Actually in the Catalog
A publicly available open-source catalog organises 246 values into 20 packs, and every value carries two explanatory fields: breaks (what it usually breaks, and why) and expect (what a correct implementation should do). A value missing the breaks field is rejected outright during validation – because the point of this catalog is explanation, not mere listing.
| Category | The failure surface it targets |
|---|---|
| Whitespace | Characters that occupy a position (or claim to) yet are completely invisible in the interface |
| Unicode text | Looks harmless, yet breaks counting, comparison and display |
| Length bombs | Built around common limits, and the gap between character count and byte count |
| Magic values | Words humans read as text but parsers read as booleans, nulls or numbers |
| Extreme numbers | Type boundaries, foreign numeral systems, the point where precision runs out |
| Impossible dates | Dates that do not exist, are ambiguous, or are written differently from the field’s assumption |
| Export breakers | Values that pass validation and only go wrong in the exported file |
| Localized identifiers | Language-specific identifiers and formats that globally sold products cannot handle |
| File names and paths | Names that a file system, archive or server will reject, rewrite or misread |
| Homoglyph pairs | Paired values that look identical on screen and differ in storage |
| Complex emoji | Characters beyond the basic plane and combining sequences that break counting and truncation |
| Encoding mojibake | Text that went through a wrong encoding and can never come back |
| Pasted from documents | Characters attached when copying from a word processor or a web page |
| Emails and URLs | Formally valid but extreme addresses, and addresses that only look valid |
| Names and identity | Names that break the “normal name” assumption |
| Time zones | Hours that do not exist, hours that appear twice, times with no time zone stated |
| Currency and separators | How people and spreadsheets write amounts, and where precision ends |
| Pseudo-localization | Common internationalization testing techniques compressed into paste-ready values |
| JSON payloads | Request bodies that parsers and databases read differently; field names can be adapted to your own API |
| Injection checks | Classic escaping checks such as quotes, tags, template expressions and paths, flagged separately as sensitive |
Two design details are very practical. Overlong values are not stored as literal strings but as “recipes” expanded at send time, so one pack can hold a hundred-thousand-character length bomb in a few lines; time values that must stay ahead are also stored as rules, so the time zone pack always sends the next clock adjustment rather than a date already in the past.

Twenty categories of values mapped to the failure surfaces they hit along the input → validation → storage → export chain
Try These Eight First: Value, Consequence, Correct Behaviour
If you only have ten minutes, the eight values below cover the most common and most expensive class of omission. The left side is the value, the right side is where it usually lands and what a correct implementation should do.
| Value | What it usually breaks / correct behaviour |
|---|---|
Kowalski with a trailing space | Browser and server compare differently, so the account is created but cannot be found; trim consistently at every step, or preserve consistently at every step – never register with one rule and log in with another |
=1+1 | The spreadsheet treats it as a formula and the exported file shows the computed result rather than the data; escape according to the target format on export |
no | YAML 1.1 and several config parsers read it as boolean false, while NO is also the country code for Norway; declare types explicitly and never guess |
30.02.2026 | A naive parser rolls it over to March 2 instead of rejecting it; it should simply be judged an invalid date |
| A single zero-width space | The field looks empty but is not, so the required-field check is bypassed; normalize before validating |
| 128 characters but 256 bytes | The interface lets it through by character count while storage rejects it by byte length, or the reverse; counting must use one basis end to end |
007 | The spreadsheet treats the column as numeric and immediately drops the leading zeros; preserve the text type on export |
| 65,535 characters | The limit of a common text column type; going over usually throws a raw database error; the server should validate explicitly and return a readable error |
The most instructive of these are 30.02.2026 and 007: they are not “malicious input” but completely normal real data that simply falls outside the implementer’s assumptions. Precisely for that reason, random fuzzing will not reliably hit them, whereas a catalog with explanations hits them faster.
Turning It Into a Ten-Minute Manual Test
The catalog’s interaction design revolves around one goal: never interrupt the tester’s attention.
- One key combination clears the current line and sends the next value of the current pack into the focused input; previous value and back-to-pack-start each have their own combination, all of them rebindable;
- The display panel never takes focus, the caret stays in the field under test, and values never get typed into the panel itself;
- Invisible characters are drawn in the panel as a visible marker (such as
␣), and counted four ways at once: grapheme clusters, code points, bytes, UTF-16 units; - The panel shows the next value and the current position within the pack, and a separate search window looks across all packs;
- On finding a problem, one key combination copies a report block that pastes straight into a defect ticket: which value, from which pack version, in what form it was sent, how large it was, whether it arrived intact; the value is written in a form someone else can retype, not as the placeholder marker from the panel;
- The GUI and the command line share the same engine, and the command line also supports a clipboard mode, putting the value on the clipboard for the tester to paste.
Every value carrying its own breaks and expect is the most essential difference between this flow and “a plain text list”: the tester never has to recall what a zero-width space does, because the panel, the command-line view and the report block all state it directly. Exploratory testing then shifts from “try whatever you remember” to “walk through in a fixed order”, which makes coverage reproducible and much easier to hand to a newcomer.
Wiring It Into Automation: Don’t Copy the List Into an Array
The GUI suits exploration; automation needs a machine-readable outlet of the same data. The catalog tool can export any pack as JSON or CSV or one value per line, optionally escaped or raw, optionally base64; diagnostics go to standard error, so a redirected file contains only values and can be used directly as a test data file.
A typical integration exports the “magic values” pack to line-delimited text and feeds it to the same validation function through parameterized tests:
| |
Putting breaks straight into the assertion failure message means the defect description almost never has to be rewritten; expect is good material to settle into a team’s test case template fields. Compared with hard-coding a long list of strings in test files, upgrading the catalog means re-exporting once.
The command-line injection mode also demonstrates the restraint that boundary handling deserves: it gives the tester a few seconds to click the target field before executing; it does not type while Ctrl/Alt/Shift/Win is held, when the target window has higher privilege than itself, or when focus sits on a button, link or list item; pressing Escape stops it immediately; and all these cases return a dedicated exit code rather than “guessing”. Custom packs are described in TOML, with companion lint, fmt and new-pack subcommands for validation, normalization and skeleton generation – the validator currently covers 41 of 47 format rules, with the remaining few explicitly listing why.

One value catalog driving manual exploration, parameterized tests and defect reports at the same time
Stating the Boundaries Honestly
A tool description that proactively lists its own limits is more trustworthy than one that only talks about capabilities. This approach has six boundaries, all of which must be counted when evaluating whether to adopt it:
- It does not judge outcomes. It only sends values into controls and does not read what the window displays; whether the value was handled well is for a human to judge. A result-marking feature is not yet available, and the report block is the only record.
- The system may rewrite input. On some operating systems, text replacement changes the sent value into another value; the tool warns when it detects the relevant setting is on and could affect the current value.
- Cross-platform capability is asymmetric. Sending keys to other windows requires system authorization: one platform needs accessibility permission, another under Wayland needs an input method daemon and cannot confirm whether focus really landed in the input field. When conditions are missing, the tool reports an explicit error and falls back to clipboard mode rather than silently degrading.
- Custom packs can currently be written but not loaded. Validation, formatting and skeleton generation all work, but reading your own pack directory into the panel and command line is not yet wired up; the pack format is also not frozen and may change in later versions.
- The 246 values are only a starting point. They are a curated selection of “the most expensive ones to miss”, not a complete list in any sense.
- It is not an attack tool. The vast majority of values come from real users and real data; the only pack containing classic escaping checks is flagged separately as sensitive, it contains no exploit code for known vulnerabilities, and any input must be actively triggered by a person. Its purpose is verifying systems you are responsible for.
How Teams Can Land This Locally
Copying the English packs directly would miss local scenarios. Adapt them into your own catalog like this:
- Map each of the 20 categories onto your system’s field inventory, and state clearly which page and which API is responsible for verifying each category, so you do not end up with a catalog nobody owns;
- Prioritize covering cross-system boundaries: import and export, form to database, server to reports, open API to downstream. These are where counting bases and type assumptions most easily diverge;
- Write the
breaksandexpectfields into the team’s test case template, so every boundary case must answer “what does it break” and “what is correct behaviour”; - Export packs as CSV or JSON and use that as the single data source for parameterized tests; re-export when the catalog updates rather than maintaining copies in several places;
- Add local-language values: full-width spaces, name lengths and rare characters, nicknames containing emoji, leading zeros in phone and employee numbers, the trailing
Xin ID numbers, thousands separators and full-width symbols in amounts, and scenarios involving local collation and case-insensitivity; - Contribute newly found values back to the team catalog in the form “value + what it breaks + where we saw it” – an input that cost one person an afternoon is worth costing everyone only once.
What really needs to change is not the tool but the status of test data: it should not be a few “normal values plus one or two empties” improvised on the spot, but an asset with explanations, ordering, versioning, and the ability to drive both manual exploration and automated suites. Inputs the form has never seen, users will eventually send in for you.
