What kinds of typos does it introduce?

Each affected item gets exactly one random mutation: swapping two adjacent characters, dropping a random character, or duplicating a random character, the three most common real-world typo patterns.

How does the error rate work?

The error rate (0-100%) is the probability that any given item is affected; it's applied independently per item, so with a large list the actual affected count will be close to, but not always exactly, that percentage.

Why does the result change every time I click Regenerate?

Mutations use random character positions and random mutation choices, so re-running the tool on the same input produces different typos each time, useful for generating varied test batches.

Can single-character items get typos too?

Yes, but only a drop or duplicate mutation applies to them, since there's no adjacent character pair to swap in a one-character item.

List Error Injector - Add Random Typos to a List for Testing

Overview

Introduction

Testing fuzzy search, spell-checkers, or input validation logic works a lot better with realistic typos than with random garbage, real typos come from swapped, dropped, or duplicated characters, not arbitrary noise.

This tool generates that kind of realistic noisy test data from a clean list, letting you dial in exactly what percentage of items should be corrupted.

What Is List Error Injector?

The List Error Injector is a randomized test-data generator: it walks your list and, for a chosen percentage of items, applies one of three realistic typo mutations, an adjacent character swap, a dropped character, or a duplicated character.

Each run produces a different result since the affected items and exact mutation are chosen randomly, use the Regenerate button to get a fresh batch from the same input.

How List Error Injector Works

The list is split on your chosen separator, trimmed, and blank items dropped; each remaining item is independently affected with probability equal to your chosen error rate.

An affected item receives one randomly chosen mutation: two adjacent characters are swapped, a random character is deleted, or a random character is duplicated in place, then all items (mutated or not) are rejoined with your chosen separator.

When To Use List Error Injector

Use this to generate realistic misspelled test data for fuzzy search, spell-check, or autocorrect features.

It's also useful for stress-testing input validation or deduplication logic against near-duplicate, typo-laden values.

Often used alongside Zalgo List Destroyer, List Visualizer and List Cloud Generator.

Features

Advantages

Produces realistic typo patterns (swap/drop/duplicate) instead of arbitrary random noise.
Configurable error rate lets you dial in a light dusting of typos or heavy corruption.
The Regenerate button produces a fresh random batch instantly from the same input list.

Limitations

Doesn't support more exotic typo types like keyboard-adjacent substitution (e.g. "teh" from a nearby key press), only swap/drop/duplicate.
Because affected items are chosen probabilistically per item, the exact count of typo'd items can vary slightly from the requested percentage, especially on short lists.

Examples

A 50% error rate on a short list

Input

apple
banana
cherry
date

Output

aplpe
banana
cherry
daet

Roughly half the items are mutated, here "apple" had two characters swapped and "date" had two characters swapped, while "banana" and "cherry" happened to be unaffected.

A 0% error rate

Input

one
two
three

Output

one
two
three

With the error rate set to 0%, no item is ever mutated, so the output exactly matches the input.

Best Practices & Notes

Best Practices

Use a low error rate (5-15%) to simulate realistic occasional typos, and a high rate (50%+) to stress-test worst-case fuzzy-matching scenarios.
Click Regenerate a few times to get several different noisy batches from the same clean source list.

Developer Notes

Uses `Math.random()` (matching this codebase's convention for whimsical, non-security-sensitive randomness, see `fisherYatesShuffle` in the random category's shared `prng.ts`) with an injectable `rand` parameter defaulting to `Math.random`, so the mutation logic itself stays unit-testable with a deterministic source.

List Error Injector Use Cases

Generating realistic misspelled test data for a fuzzy search or spell-checker feature
Stress-testing deduplication or matching logic against near-duplicate, typo'd values
Producing training or demo data for autocorrect and "did you mean" features

Common Mistakes

Expecting exactly N% of items to be mutated on every run, the error rate is a per-item probability, so small lists can deviate noticeably from the target percentage by chance.
Assuming the same input always produces the same output, mutations are randomized, use a fixed test fixture if you need reproducible output.

Tips

Run a very high error rate (near 100%) if you want to guarantee every item gets a typo.
Combine with Zalgo List Destroyer for a different, more visually extreme kind of intentional list corruption.

List Error Injector