diff --git "a/tests.py" "b/tests.py"
new file mode 100644--- /dev/null
+++ "b/tests.py"
@@ -0,0 +1,2182 @@
+import unittest
+from rules.dates import (
+    DateProcessor
+)
+from rules.times import TimeProcessor
+from rules.currency import CurrencyProcessor
+from rules.spaces import CurrencySpaceProcessor
+from rules.units import UnitProcessor
+from rules.fraction import FractionProcessor
+from rules.phone import PhoneNumberProcessor
+from rules.cards import CardNumberProcessor
+from rules.postal_national_id import PostalCodeAndNationalIdProcessor
+from rules.symbols import (
+    AmpersandProcessor,
+    MathOperatorProcessor,
+    NegativeSignProcessor,
+    RangeProcessor,
+    RomanNumeralProcessor,
+    roman_to_int,
+)
+from normalizer import Normalizer
+
+
+class MyTestCase(unittest.TestCase):
+    def setUp(self):
+        self.date_processor = DateProcessor()
+        self.time_processor = TimeProcessor()
+        self.normalizer = Normalizer()
+
+    def test_not_a_date(self):
+        inputs = ['1380', 'hello', '21 21 21', '12, 8, 20', "Sep 28 2020"]
+        for inp in inputs:
+            self.assertFalse(self.date_processor.is_date(inp), f'{inp} is not a date')
+
+    def test_date_to_text_gregorian(self):
+        inputs = ["9-28-2020", "1/1/1998", "2002/07/18"]
+        corrects = ["twenty-eighth of September, twenty twenty".lower(),
+                    "first of January, nineteen ninety-eight".lower(),
+                    "eighteenth of July, two thousand and two".lower()]
+        normalized = []
+
+        for i, c in zip(inputs, corrects):
+            text = self.date_processor.process(i, language='en')
+            normalized.append(text.lower())
+
+        self.assertListEqual(normalized, corrects)
+
+
+    def test_date_to_text_jalali(self):
+        inputs = ['1381/4/31', '۱۳۸۱/۰۴/27', "29/12/1305"]
+        corrects = ["سی و یک چهار یک هزار و سیصد و هشتاد و یک",
+                    "بیست و هفت چهار یک هزار و سیصد و هشتاد و یک",
+                    "بیست و نه دوازده یک هزار و سیصد و پنج"]
+        normalized = []
+
+        for i, c in zip(inputs, corrects):
+            text = self.date_processor.process(i, language='fa')
+            normalized.append(text.strip())
+
+        self.assertListEqual(normalized, corrects)
+
+    def test_englih_time(self):
+        inputs = ['1:35', '5:50', '15:20', '10:00:11', '3:12:01']
+        corrects = [
+            'one thirty-five',
+            'five fifty',
+            'three twenty pm',
+            'ten and eleven seconds',
+            'three twelve and one second']
+
+        normalized = []
+        for i, c in zip(inputs, corrects):
+            text = self.time_processor.process(i, language='en')
+            normalized.append(text.lower())
+
+        self.assertListEqual(normalized, corrects)
+
+    def test_farsi_time(self):
+        inputs = ['1:35', '5:50', '15:20', '10:00:11', '3:12:01']
+        corrects = [
+            'یک و سی و پنج دقیقه',
+            'پنج و پنجاه دقیقه',
+            'پانزده و بیست دقیقه',
+            'ده و یازده ثانیه',
+            'سه و دوازده دقیقه و یک ثانیه']
+
+        normalized = []
+        for i, c in zip(inputs, corrects):
+            text = self.time_processor.process(i, language='fa')
+            normalized.append(text.lower())
+
+        self.assertListEqual(normalized, corrects)
+
+    def test_overall_normalization(self):
+        inputs = [
+            "I was born on 2002/07/18 when it was pouring.",
+            "من متولد سال ۱۳۸۱/۴/۲۷ هستم و الان بیست و چهار سال دارم.",
+            "I have a date at 3:30 on 9/10/2026 and I have to be ready.",
+            "در تاریخ ۱۲/۶/۱۳۸۸ و در ساعت ۲:۵۱:۰۳ اتفاق افتاد."
+        ]
+        correct = [
+            "I was born on eighteenth of July, two thousand and two when it was pouring.".lower(),
+            "من متولد سال بیست و هفت چهار یک هزار و سیصد و هشتاد و یک هستم و الان بیست و چهار سال دارم.",
+            "I have a date at three thirty on tenth of September, twenty twenty-six and I have to be ready.".lower(),
+            "در تاریخ دوازده شش یک هزار و سیصد و هشتاد و هشت و در ساعت دو و پنجاه و یک دقیقه و سه ثانیه اتفاق افتاد."
+        ]
+        normalized = []
+
+        for i, c in zip(inputs, correct):
+            text = self.normalizer.process(i)
+            normalized.append(text.lower())
+        self.assertListEqual(normalized, correct)
+
+    def test_overall_normalization_currency(self):
+        inputs = [
+            "قیمت امروز ارز، ۳$ بود",
+            "قیمت امروز ارز، 3$ بود",
+            "I have 3$",
+            "I have 1 $",
+            "قیمت امروز ارز، ۳ $ بود",
+            "I want $12.50 today.",
+            "من ۱۲.۵۰$ می‌خواهم",
+            "It costs €12.50 or 10 £.",
+            "قیمت ۵ € و £۲.۵ است",
+            "۱۰۰۰$",
+            "1000$",
+            "۱۰۰۰ $",
+            "1000 $",
+        ]
+        correct = [
+            "قیمت امروز ارز، سه دلار بود",
+            "قیمت امروز ارز، سه دلار بود",
+            "I have three dollars",
+            "I have one dollar",
+            "قیمت امروز ارز، سه دلار بود",
+            "I want twelve dollars and fifty cents today.",
+            "من دوازده دلار و پنجاه سنت می‌خواهم",
+            "It costs twelve euros and fifty cents or ten pounds.",
+            "قیمت پنج یورو و دو پوند و پنجاه پنس است",
+            "یک هزار دلار",
+            "one thousand dollars",
+            "یک هزار دلار",
+            "one thousand dollars",
+        ]
+        normalized = [self.normalizer.process(i) for i in inputs]
+        self.assertListEqual(normalized, correct)
+
+
+    def test_overall_normalization_units(self):
+        inputs = [
+            "I ran 5km today",
+            "I ran 5 km today",
+            "وزن او ۷۵ kg است",
+            "من ۱۰km دویدم",
+            "It is 25°C outside",
+            "دما ۲۵ °C است",
+            "The car goes 60 km/h and weighs 1 kg",
+            "از اینجا تا آنجا ۱۰۰۰.۵m فاصله است",
+            "The movie is 1.5 hours long",
+            "این کار ۱۰ min طول می‌کشد",
+            "۱۰۰۰m",
+            "1000m",
+        ]
+        correct = [
+            "I ran five kilometres today",
+            "I ran five kilometres today",
+            "وزن او هفتاد و پنج کیلوگرم است",
+            "من ده کیلومتر دویدم",
+            "It is twenty-five degrees Celsius outside",
+            "دما بیست و پنج درجه سانتیگراد است",
+            "The car goes sixty kilometres per hour and weighs one kilogram",
+            "از اینجا تا آنجا یک هزار متر و پنجاه سانتیمتر فاصله است",
+            "The movie is one hour and thirty minutes long",
+            "این کار ده دقیقه طول می‌کشد",
+            "یک هزار متر",
+            "one thousand metres",
+        ]
+        normalized = [self.normalizer.process(i) for i in inputs]
+        self.assertListEqual(normalized, correct)
+
+    def test_overall_normalization_units_and_currency_together(self):
+        inputs = [
+            "It costs 3$ per 2 kg",
+            "قیمت هر ۲ kg برابر ۳$ است",
+        ]
+        correct = [
+            "It costs three dollars per two kilograms",
+            "قیمت هر دو کیلوگرم برابر سه دلار است",
+        ]
+        normalized = [self.normalizer.process(i) for i in inputs]
+        self.assertListEqual(normalized, correct)
+
+
+    def test_overall_normalization_fractions(self):
+        inputs = [
+            "I drank 1/3 of the bottle",
+            "من ۱/۳ بطری نوشیدم",
+            "Add 2 1/2 cups of flour",
+            "۱/۳",
+            "1/3",
+            "من ۵km و ۱/۳ بطری",
+            "۱/۲ kg",
+            "1,000/2 kg",
+            "Add 1/2 kg of rice",
+            "۲ ۱/۲ kg برنج",
+            "2 %",
+            "۲ ٪",
+            "Discount is 20% on 3$",
+            "تخفیف ۲۰٪ روی ۳$ است",
+            "از ۱/۲ kg برنج ۲.۵٪ باقی ماند",
+            "٪ ۵",
+            "% 5",
+            "5% kg",
+            "۵٪ kg",
+            "% 20 cm",
+            "٪ ۲۰ cm",
+        ]
+        correct = [
+            "I drank one third of the bottle",
+            "من یک سوم بطری نوشیدم",
+            "Add two and one half cups of flour",
+            "یک سوم",
+            "one third",
+            "من پنج کیلومتر و یک سوم بطری",
+            "یک دوم کیلوگرم",
+            "one thousand halves kilograms",
+            "Add one half kilogram of rice",
+            "دو و یک دوم کیلوگرم برنج",
+            "two percent",
+            "دو درصد",
+            "Discount is twenty percent on three dollars",
+            "تخفیف بیست درصد روی سه دلار است",
+            "از یک دوم کیلوگرم برنج دو و پنج دهم درصد باقی ماند",
+            "پنج درصد",
+            "five percent",
+            "five percent kilogram",
+            "پنج درصد کیلوگرم",
+            "twenty percent centimetre",
+            "بیست درصد سانتیمتر",
+        ]
+        normalized = [self.normalizer.process(i) for i in inputs]
+        self.assertListEqual(normalized, correct)
+
+
+    def test_overall_normalization_roman_numerals_and_ampersand(self):
+        inputs = [
+            "Henry VIII was king",
+            "Tom & Jerry read Chapter IV",
+            "قرن XX و R&D",
+            "تام & جری فصل IV را خواندند",
+            "جنگ جهانی II",
+            "Q&A about World War I",
+            "I think Washington DC is nice",
+            "3 & 4",
+            "۳ & ۴",
+            "1/2 & 1/3",
+            "۱/۲ & ۱/۳",
+            "5 km & 3 kg",
+            "۵ km & ۳ kg",
+            "5 & 3 kg",
+            "5% & 10%",
+        ]
+        correct = [
+            "Henry eight was king",
+            "Tom and Jerry read Chapter four",
+            "قرن بیست و R و D",
+            "تام و جری فصل چهار را خواندند",
+            "جنگ جهانی دو",
+            "Q and A about World War one",
+            "I think Washington DC is nice",
+            "three and four",
+            "سه و چهار",
+            "one half and one third",
+            "یک دوم و یک سوم",
+            "five kilometres and three kilograms",
+            "پنج کیلومتر و سه کیلوگرم",
+            "five and three kilograms",
+            "five percent and ten percent",
+        ]
+        normalized = [self.normalizer.process(i) for i in inputs]
+        self.assertListEqual(normalized, correct)
+
+
+    def test_overall_normalization_negative_sign_and_operators(self):
+        inputs = [
+            "-2 m",
+            "- 2 m",
+            "-۲ m",
+            "-2",
+            "-۲",
+            "The temp is -2 degrees",
+            "دما -۲ درجه است",
+            "-1/2 kg",
+            "-5%",
+            "-$5",
+            "x = -2",
+            "3 + 4",
+            "۳ + ۴",
+            "3+4",
+            "6 × 2",
+            "۶ × ۲",
+            "8 ÷ 2",
+            "۸ ÷ ۲",
+            "7 = 7",
+            "۷ = ۷",
+            "3 + 4 = 7",
+            "۳ + ۴ = ۷",
+            "5 - 3 = 2",
+            "۵ - ۳ = ۲",
+            "2 m + 3 m",
+            "1/2 + 1/3",
+            "$3 + $4",
+            "3 & 4 = 7",
+            "5 - 3",
+            "10 - 20 km",
+            "C++ is great",
+        ]
+        correct = [
+            "negative two metres",
+            "negative two metres",
+            "منفی دو متر",
+            "negative two",
+            "منفی دو",
+            "The temp is negative two degrees",
+            "دما منفی دو درجه است",
+            "negative one half kilogram",
+            "negative five percent",
+            "negative five dollars",
+            "x equals negative two",
+            "three plus four",
+            "سه بعلاوه چهار",
+            "three plus four",
+            "six times two",
+            "شش ضربدر دو",
+            "eight divided by two",
+            "هشت تقسیم بر دو",
+            "seven equals seven",
+            "هفت مساوی است با هفت",
+            "three plus four equals seven",
+            "سه بعلاوه چهار مساوی است با هفت",
+            "five minus three equals two",
+            "پنج منهای سه مساوی است با دو",
+            "two metres plus three metres",
+            "one half plus one third",
+            "three dollars plus four dollars",
+            "three and four equals seven",
+            "five to three",
+            "ten to twenty kilometres",
+            "C++ is great",
+        ]
+        for inp, expected in zip(inputs, correct):
+            self.assertEqual(self.normalizer.process(inp), expected, inp)
+
+
+    def test_overall_normalization_ranges(self):
+        inputs = [
+            "3 - 5",
+            "3-5",
+            "3 – 5",
+            "3–5",
+            "pages 3-5",
+            "2.5 - 3.5",
+            "3kg - 5 kg",
+            "3 kg-5 kg",
+            "3 - 5 kg",
+            "3 kg - 5",
+            "10 - 20 km",
+            "$3 - $5",
+            "3$ - 5$",
+            "1/2 - 3/4",
+            "5% - 10%",
+            "10 - 20%",
+            "1 - 2 - 3",
+            "Is it 3 - 5?",
+            "۳ - ۵",
+            "۳-۵",
+            "۳kg - ۵ kg",
+            "۱۰ - ۲۰ km",
+            "از ۳ - ۵ ساعت",
+            "۵٪ - ۱۰٪",
+            "5 - 3 = 2",
+            "2024-05",
+            "0912-123-4567",
+            "1990-2000",
+            "well - maybe",
+        ]
+        correct = [
+            "three to five",
+            "three to five",
+            "three to five",
+            "three to five",
+            "pages three to five",
+            "two point five to three point five",
+            "three kilograms to five kilograms",
+            "three kilograms to five kilograms",
+            "three to five kilograms",
+            "three kilograms to five",
+            "ten to twenty kilometres",
+            "three dollars to five dollars",
+            "three dollars to five dollars",
+            "one half to three quarters",
+            "five percent to ten percent",
+            "ten to twenty percent",
+            "one to two to three",
+            "Is it three to five?",
+            "سه تا پنج",
+            "سه تا پنج",
+            "سه کیلوگرم تا پنج کیلوگرم",
+            "ده تا بیست کیلومتر",
+            "از سه تا پنج ساعت",
+            "پنج درصد تا ده درصد",
+            "five minus three equals two",
+            "2024-05",
+            "zero nine one two, one two three, four five, six seven",
+            "1990-2000",
+            "well - maybe",
+        ]
+        for inp, expected in zip(inputs, correct):
+            self.assertEqual(self.normalizer.process(inp), expected, inp)
+
+
+    def test_overall_normalization_wrapped_symbols(self):
+        cases = {
+            "2 (kg)": "two (kilograms)",
+            "2(kg)": "two (kilograms)",
+            "2 [kg]": "two [kilograms]",
+            "3 {m}": "three {metres}",
+            '3 "m"': 'three "metres"',
+            "3 “m”": "three “metres”",
+            "(2 kg)": "(two kilograms)",
+            "(5) kg": "(five) kilograms",
+            "(1/2) kg": "(one half) kilogram",
+            "50 (%)": "fifty (percent)",
+            "2 (km/h)": "two (kilometres per hour)",
+            "2 (kg) and 3 (m)": "two (kilograms) and three (metres)",
+            "-2 (m)": "negative two (metres)",
+            "chapter (V)": "chapter (five)",
+            "Chapter [V]": "Chapter [five]",
+            "Part {I}": "Part {one}",
+            'Chapter "IV"': 'Chapter "four"',
+            "Henry (VIII)": "Henry (eight)",
+            "I think (I) am": "I think (I) am",
+            "Tom (&) Jerry": "Tom (and) Jerry",
+            "3 (&) 4": "three (and) four",
+            "(3) & (4)": "(three) and (four)",
+            "(3) + (4)": "(three) plus (four)",
+            "3 (+) 4": "three (plus) four",
+            "(3) - (5)": "(three) to (five)",
+            "3 (cm) - 5 (cm)": "three (centimetres) to five (centimetres)",
+            "(2) kg - (5) kg": "(two) kilograms to (five) kilograms",
+            "2 (kg) + 3 (kg)": "two (kilograms) plus three (kilograms)",
+            "3 (a)": "3 (a)",
+            "Section 2 (b)": "Section 2 (b)",
+            "۲ (kg)": "دو (کیلوگرم)",
+            "۳ {m}": "سه {متر}",
+            "۲ (kg) و ۳ (m)": "دو (کیلوگرم) و سه (متر)",
+            "فصل (V)": "فصل (پنج)",
+            "فصل «V»": "فصل «پنج»",
+            "(۳) + (۴)": "(سه) بعلاوه (چهار)",
+            "(۳) - (۵)": "(سه) تا (پنج)",
+            "۳ (+) ۴": "سه (بعلاوه) چهار",
+            "۳ (kg) - ۵ (kg)": "سه (کیلوگرم) تا پنج (کیلوگرم)",
+        }
+        for inp, expected in cases.items():
+            self.assertEqual(self.normalizer.process(inp), expected, inp)
+
+
+    def test_overall_normalization_phone_numbers(self):
+        mobile_en = "zero nine one two, four three three, eight one, three five"
+        mobile_plus_en = "plus nine eight, nine one two, four three three, eight one, three five"
+        landline_en = "zero two one, eight eight, zero six, nine eight, nine five"
+        mobile_fa = "صفر نهصد و دوازده، چهارصد و سی و سه، هشتاد و یک، سی و پنج"
+        mobile_plus_fa = "مثبت نود و هشت، نهصد و دوازده، چهارصد و سی و سه، هشتاد و یک، سی و پنج"
+        landline_fa = "صفر بیست و یک، هشتاد و هشت، صفر شش، نود و هشت، نود و پنج"
+        cases = {
+            "09124338135": mobile_en,
+            "+989124338135": mobile_plus_en,
+            "+98-912-4338135": mobile_plus_en,
+            "+98 912 433 8135": mobile_plus_en,
+            "021-88069895": landline_en,
+            "(021) 88069895": "(zero two one), eight eight, zero six, nine eight, nine five",
+            "(0915)6486320": "(zero nine one five), six four eight, six three, two zero",
+            "Call me at 09124338135.": f"Call me at {mobile_en}.",
+            "Call 09124338135, then 021-88069895.": f"Call {mobile_en}, then {landline_en}.",
+            "tel: 88069895": "tel: eight eight, zero six, nine eight, nine five",
+            "۰۹۱۲۴۳۳۸۱۳۵": mobile_fa,
+            "+۹۸-۹۱۲-۴۳۳۸۱۳۵": mobile_plus_fa,
+            "۰۲۱-۸۸۰۶۹۸۹۵": landline_fa,
+            "شماره من ۰۹۱۲۴۳۳۸۱۳۵ است": f"شماره من {mobile_fa} است",
+            "۰۰۱-۸۸۵۲۳۰۰۶": "دو صفر یک، هشتاد و هشت، پنجاه و دو، سی، صفر شش",
+            "با 09124338135 تماس بگیرید": f"با {mobile_fa} تماس بگیرید",
+            "تلفن: ۸۸۰۶۹۸۹۵": "تلفن: هشتاد و هشت، صفر شش، نود و هشت، نود و پنج",
+            "شماره تماس ۰۲۱-۸۸۰۶۹۸۹۵ و ۰۹۱۲۴۳۳۸۱۳۵": f"شماره تماس {landline_fa} و {mobile_fa}",
+            "4338135": "4338135",
+            "call 5 times": "call 5 times",
+        }
+        for inp, expected in cases.items():
+            self.assertEqual(self.normalizer.process(inp), expected, inp)
+
+
+class CurrencyProcessorTestCase(unittest.TestCase):
+    def setUp(self):
+        self.processor = CurrencyProcessor()
+
+    def test_is_currency(self):
+        valid = ['3$', '۳$', '3.5$', '1,000$', '(3$)', '3$.', '$3', '$12.50', '$12.50.', '€3', '3€', '£12.50', '۳£']
+        invalid = ['3', '$', 'hello', '3$a', '3 $', '3$$', '$3$', '$$3', '€3£', '3€€']
+        for inp in valid:
+            self.assertTrue(self.processor.is_currency(inp), f'{inp} is a currency')
+        for inp in invalid:
+            self.assertFalse(self.processor.is_currency(inp), f'{inp} is not a currency')
+
+    def test_persian(self):
+        inputs = ['۳$', '3$', '$3', '۱۲۰$', '1,000$']
+        corrects = ['سه دلار', 'سه دلار', 'سه دلار', 'یکصد و بیست دلار', 'یک هزار دلار']
+        normalized = [self.processor.process(i, language='fa') for i in inputs]
+        self.assertListEqual(normalized, corrects)
+
+    def test_english(self):
+        inputs = ['3$', '۳$', '$3', '1$', '0$', '25$', '1,000$']
+        corrects = [
+            'three dollars',
+            'three dollars',
+            'three dollars',
+            'one dollar',
+            'zero dollars',
+            'twenty-five dollars',
+            'one thousand dollars',
+        ]
+        normalized = [self.processor.process(i, language='en') for i in inputs]
+        self.assertListEqual(normalized, corrects)
+
+    def test_english_dollars_and_cents(self):
+        inputs = ['$12.50', '12.5$', '12.50$', '۱۲.۵۰$', '$1.01', '$12.05', '$0.50', '$0.01', '$12.00', '$1,000.75']
+        corrects = [
+            'twelve dollars and fifty cents',
+            'twelve dollars and fifty cents',
+            'twelve dollars and fifty cents',
+            'twelve dollars and fifty cents',
+            'one dollar and one cent',
+            'twelve dollars and five cents',
+            'fifty cents',
+            'one cent',
+            'twelve dollars',
+            'one thousand dollars and seventy-five cents',
+        ]
+        normalized = [self.processor.process(i, language='en') for i in inputs]
+        self.assertListEqual(normalized, corrects)
+
+    def test_persian_dollars_and_cents(self):
+        inputs = ['$12.50', '12.5$', '۱۲٫۵۰$', '$12.05', '$0.50', '$12.00']
+        corrects = [
+            'دوازده دلار و پنجاه سنت',
+            'دوازده دلار و پنجاه سنت',
+            'دوازده دلار و پنجاه سنت',
+            'دوازده دلار و پنج سنت',
+            'پنجاه سنت',
+            'دوازده دلار',
+        ]
+        normalized = [self.processor.process(i, language='fa') for i in inputs]
+        self.assertListEqual(normalized, corrects)
+
+    def test_more_than_two_decimals_is_read_as_decimal_number(self):
+        self.assertEqual(
+            self.processor.process('3.141$', language='en'),
+            'three point one four one dollars',
+        )
+
+    def test_dollars_and_cents_keep_surrounding_punctuation(self):
+        self.assertEqual(
+            self.processor.process('($12.50).', language='en'),
+            '(twelve dollars and fifty cents).',
+        )
+
+
+    def test_euro_english(self):
+        inputs = ['3€', '€3', '1€', '€12.50', '12.5€', '€1.01', '€0.50', '€12.00', '۳€']
+        corrects = [
+            'three euros',
+            'three euros',
+            'one euro',
+            'twelve euros and fifty cents',
+            'twelve euros and fifty cents',
+            'one euro and one cent',
+            'fifty cents',
+            'twelve euros',
+            'three euros',
+        ]
+        normalized = [self.processor.process(i, language='en') for i in inputs]
+        self.assertListEqual(normalized, corrects)
+
+    def test_pound_english(self):
+        inputs = ['3£', '£3', '1£', '£12.50', '12.5£', '£1.01', '£0.50', '£0.01', '£12.00']
+        corrects = [
+            'three pounds',
+            'three pounds',
+            'one pound',
+            'twelve pounds and fifty pence',
+            'twelve pounds and fifty pence',
+            'one pound and one penny',
+            'fifty pence',
+            'one penny',
+            'twelve pounds',
+        ]
+        normalized = [self.processor.process(i, language='en') for i in inputs]
+        self.assertListEqual(normalized, corrects)
+
+    def test_euro_persian(self):
+        inputs = ['3€', '€3', '۳€', '€12.50', '€0.50', '€12.00']
+        corrects = [
+            'سه یورو',
+            'سه یورو',
+            'سه یورو',
+            'دوازده یورو و پنجاه سنت',
+            'پنجاه سنت',
+            'دوازده یورو',
+        ]
+        normalized = [self.processor.process(i, language='fa') for i in inputs]
+        self.assertListEqual(normalized, corrects)
+
+    def test_pound_persian(self):
+        inputs = ['3£', '£3', '۳£', '£12.50', '£12.05', '£0.50', '£12.00']
+        corrects = [
+            'سه پوند',
+            'سه پوند',
+            'سه پوند',
+            'دوازده پوند و پنجاه پنس',
+            'دوازده پوند و پنج پنس',
+            'پنجاه پنس',
+            'دوازده پوند',
+        ]
+        normalized = [self.processor.process(i, language='fa') for i in inputs]
+        self.assertListEqual(normalized, corrects)
+
+    def test_more_than_two_decimals_uses_currency_name(self):
+        self.assertEqual(self.processor.process('3.141€', language='en'), 'three point one four one euros')
+        self.assertEqual(self.processor.process('3.141£', language='en'), 'three point one four one pounds')
+
+    def test_punctuation_is_preserved_for_all_symbols(self):
+        self.assertEqual(self.processor.process('(€12.50).', language='en'), '(twelve euros and fifty cents).')
+        self.assertEqual(self.processor.process('£3،', language='fa'), 'سه پوند،')
+
+
+    def test_surrounding_punctuation_is_preserved(self):
+        self.assertEqual(self.processor.process('3$.', language='en'), 'three dollars.')
+        self.assertEqual(self.processor.process('(3$)', language='en'), '(three dollars)')
+        self.assertEqual(self.processor.process('۳$،', language='fa'), 'سه دلار،')
+
+    def test_non_currency_is_unchanged(self):
+        inputs = ['hello', '3', '$', 'سلام', '3$a', '$3a']
+        for inp in inputs:
+            self.assertEqual(self.processor.process(inp, language='en'), inp)
+            self.assertEqual(self.processor.process(inp, language='fa'), inp)
+
+    def test_unsupported_language_is_unchanged(self):
+        for language in ('mixed', 'de'):
+            self.assertEqual(self.processor.process('3$', language=language), '3$')
+
+    def test_no_letters_language_is_decided_by_digits(self):
+        no_letters = 'Unknown / No letters found'
+        inputs = ['۱۰۰۰$', '1000$', '$۱۰۰۰', '$1000', '۱۲.۵۰€', '12.50€', '£۳', '£3']
+        corrects = [
+            'یک هزار دلار',
+            'one thousand dollars',
+            'یک هزار دلار',
+            'one thousand dollars',
+            'دوازده یورو و پنجاه سنت',
+            'twelve euros and fifty cents',
+            'سه پوند',
+            'three pounds',
+        ]
+        normalized = [self.processor.process(i, language=no_letters) for i in inputs]
+        self.assertListEqual(normalized, corrects)
+
+    def test_epsilon_zero_disables_processor(self):
+        processor = CurrencyProcessor(epsilon=0.0)
+        outputs = {processor.process('3$', language='en') for _ in range(50)}
+        self.assertEqual(outputs, {'3$'})
+
+
+class CurrencySpaceProcessorTestCase(unittest.TestCase):
+    def setUp(self):
+        self.processor = CurrencySpaceProcessor()
+
+    def test_removes_space_between_number_and_dollar(self):
+        inputs = ['I have 1 $', 'I have ۳ $', 'it is 2.5   $.', '1,000 $ total', '5 €', '۳ £', '2.5 €.']
+        corrects = ['I have 1$', 'I have ۳$', 'it is 2.5$.', '1,000$ total', '5€', '۳£', '2.5€.']
+        normalized = [self.processor.process(i) for i in inputs]
+        self.assertListEqual(normalized, corrects)
+
+    def test_already_adjacent_is_unchanged(self):
+        self.assertEqual(self.processor.process('I have 1$'), 'I have 1$')
+
+    def test_unrelated_dollar_signs_are_unchanged(self):
+        inputs = ['1 $5', 'price $ 5', 'hello $', 'a1 $', '1 $a', '1\n$', '1 €5', 'price £ 5', '1 £a']
+        for inp in inputs:
+            self.assertEqual(self.processor.process(inp), inp)
+
+    def test_multiple_occurrences(self):
+        self.assertEqual(self.processor.process('1 $ and 2 $'), '1$ and 2$')
+
+    def test_epsilon_zero_disables_processor(self):
+        processor = CurrencySpaceProcessor(epsilon=0.0)
+        outputs = {processor.process('1 $') for _ in range(50)}
+        self.assertEqual(outputs, {'1 $'})
+
+
+class UnitProcessorTestCase(unittest.TestCase):
+    def setUp(self):
+        self.processor = UnitProcessor()
+
+    def test_length_english(self):
+        inputs = ['5km', '5 km', '1 km', '2.5 km', '10 m', '3 cm', '7 mm', '1 mi', '6 ft', '1 ft']
+        corrects = [
+            'five kilometres',
+            'five kilometres',
+            'one kilometre',
+            'two kilometres and five hundred metres',
+            'ten metres',
+            'three centimetres',
+            'seven millimetres',
+            'one mile',
+            'six feet',
+            'one foot',
+        ]
+        normalized = [self.processor.process(i, language='en') for i in inputs]
+        self.assertListEqual(normalized, corrects)
+
+    def test_length_persian(self):
+        inputs = ['5km', '۵ km', '1 km', '10 m', '۳ cm', '7 mm', '2 mi']
+        corrects = [
+            'پنج کیلومتر',
+            'پنج کیلومتر',
+            'یک کیلومتر',
+            'ده متر',
+            'سه سانتیمتر',
+            'هفت میلیمتر',
+            'دو مایل',
+        ]
+        normalized = [self.processor.process(i, language='fa') for i in inputs]
+        self.assertListEqual(normalized, corrects)
+
+    def test_mass_and_volume_english(self):
+        inputs = ['2 kg', '1 kg', '2 KG', '500 g', '250 mg', '3 lb', '3 lbs', '8 oz', '2 l', '2 L', '330 ml', '1 mL']
+        corrects = [
+            'two kilograms',
+            'one kilogram',
+            'two kilograms',
+            'five hundred grams',
+            'two hundred and fifty milligrams',
+            'three pounds',
+            'three pounds',
+            'eight ounces',
+            'two litres',
+            'two litres',
+            'three hundred and thirty millilitres',
+            'one millilitre',
+        ]
+        normalized = [self.processor.process(i, language='en') for i in inputs]
+        self.assertListEqual(normalized, corrects)
+
+    def test_mass_and_volume_persian(self):
+        inputs = ['2 kg', '500 g', '250 mg', '3 lb', '8 oz', '2 l', '330 ml']
+        corrects = [
+            'دو کیلوگرم',
+            'پانصد گرم',
+            'دویست و پنجاه میلی‌گرم',
+            'سه پوند',
+            'هشت اونس',
+            'دو لیتر',
+            'سیصد و سی میلی‌لیتر',
+        ]
+        normalized = [self.processor.process(i, language='fa') for i in inputs]
+        self.assertListEqual(normalized, corrects)
+
+    def test_time_english(self):
+        inputs = ['10 sec', '1 sec', '5 secs', '5 min', '1 min', '3 mins', '2 h', '1 hr', '2 hrs', '2 hours', '1 hour', '250 ms', '3 days', '1 week', '2 years']
+        corrects = [
+            'ten seconds',
+            'one second',
+            'five seconds',
+            'five minutes',
+            'one minute',
+            'three minutes',
+            'two hours',
+            'one hour',
+            'two hours',
+            'two hours',
+            'one hour',
+            'two hundred and fifty milliseconds',
+            'three days',
+            'one week',
+            'two years',
+        ]
+        normalized = [self.processor.process(i, language='en') for i in inputs]
+        self.assertListEqual(normalized, corrects)
+
+    def test_time_persian(self):
+        inputs = ['10 sec', '۵ min', '2 h', '2 hours', '1 hr', '250 ms', '3 days', '1 week', '2 months', '2 years']
+        corrects = [
+            'ده ثانیه',
+            'پنج دقیقه',
+            'دو ساعت',
+            'دو ساعت',
+            'یک ساعت',
+            'دویست و پنجاه میلی‌ثانیه',
+            'سه روز',
+            'یک هفته',
+            'دو ماه',
+            'دو سال',
+        ]
+        normalized = [self.processor.process(i, language='fa') for i in inputs]
+        self.assertListEqual(normalized, corrects)
+
+    def test_time_decimals_are_split_into_smaller_units(self):
+        cases_en = {
+            '1.5 h': 'one hour and thirty minutes',
+            '0.5 h': 'thirty minutes',
+            '2.5 min': 'two minutes and thirty seconds',
+            '1.5 sec': 'one second and five hundred milliseconds',
+            '1.5 days': 'one day and twelve hours',
+            '1.5 weeks': 'one week, three days and twelve hours',
+            '1.5 months': 'one point five months',
+        }
+        for inp, correct in cases_en.items():
+            self.assertEqual(self.processor.process(inp, language='en'), correct, inp)
+
+        cases_fa = {
+            '1.5 h': 'یک ساعت و سی دقیقه',
+            '2.5 min': 'دو دقیقه و سی ثانیه',
+            '1.5 sec': 'یک ثانیه و پانصد میلی‌ثانیه',
+        }
+        for inp, correct in cases_fa.items():
+            self.assertEqual(self.processor.process(inp, language='fa'), correct, inp)
+
+    def test_speed_and_temperature(self):
+        self.assertEqual(self.processor.process('60 km/h', language='en'), 'sixty kilometres per hour')
+        self.assertEqual(self.processor.process('1 m/s', language='en'), 'one metre per second')
+        self.assertEqual(self.processor.process('60 km/h', language='fa'), 'شصت کیلومتر بر ساعت')
+        self.assertEqual(self.processor.process('10 m/s', language='fa'), 'ده متر بر ثانیه')
+        self.assertEqual(self.processor.process('25°C', language='en'), 'twenty-five degrees Celsius')
+        self.assertEqual(self.processor.process('1 °F', language='en'), 'one degree Fahrenheit')
+        self.assertEqual(self.processor.process('25 °C', language='fa'), 'بیست و پنج درجه سانتیگراد')
+        self.assertEqual(self.processor.process('۷۷°F', language='fa'), 'هفتاد و هفت درجه فارنهایت')
+
+    def test_thousand_separators(self):
+        self.assertEqual(self.processor.process('1,000 m', language='en'), 'one thousand metres')
+        self.assertEqual(self.processor.process('۱۰۰۰ m', language='fa'), 'یک هزار متر')
+
+    def test_decimals_are_split_into_smaller_units(self):
+        cases_en = {
+            '1000.5 m': 'one thousand metres and fifty centimetres',
+            '2.5 km': 'two kilometres and five hundred metres',
+            '2.75 kg': 'two kilograms and seven hundred and fifty grams',
+            '1.5 L': 'one litre and five hundred millilitres',
+            '2.5 cm': 'two centimetres and five millimetres',
+            '1.01 m': 'one metre and one centimetre',
+            '0.5 kg': 'five hundred grams',
+            '1.234 m': 'one metre, twenty-three centimetres and four millimetres',
+            '2.0 kg': 'two kilograms',
+        }
+        for inp, correct in cases_en.items():
+            self.assertEqual(self.processor.process(inp, language='en'), correct, inp)
+
+        cases_fa = {
+            '۱۰۰۰.۵m': 'یک هزار متر و پنجاه سانتیمتر',
+            '2.5 km': 'دو کیلومتر و پانصد متر',
+            '2.75 kg': 'دو کیلوگرم و هفتصد و پنجاه گرم',
+            '0.5 kg': 'پانصد گرم',
+            '1.234 m': 'یک متر و بیست و سه سانتیمتر و چهار میلیمتر',
+        }
+        for inp, correct in cases_fa.items():
+            self.assertEqual(self.processor.process(inp, language='fa'), correct, inp)
+
+    def test_decimals_without_smaller_unit_are_read_as_plain_numbers(self):
+        # `mi` has no smaller unit, and 1.2345 m does not end on a whole millimetre.
+        self.assertEqual(self.processor.process('2.5 mi', language='en'), 'two point five miles')
+        self.assertEqual(self.processor.process('2.5 mi', language='fa'), 'دو و پنج دهم مایل')
+        self.assertEqual(self.processor.process('36.6 °C', language='en'), 'thirty-six point six degrees Celsius')
+        self.assertEqual(
+            self.processor.process('1.2345 m', language='en'),
+            'one point two three four five metres',
+        )
+
+    def test_fraction_amounts_english(self):
+        cases = {
+            '1/2 kg': 'one half kilogram',
+            '1/2kg': 'one half kilogram',
+            '3/4 km': 'three quarters kilometre',
+            '1/3 L': 'one third litre',
+            '3/2 kg': 'three halves kilograms',
+            '1,000/2 kg': 'one thousand halves kilograms',
+            '2 1/2 kg': 'two and one half kilograms',
+            '1 1/2 hours': 'one and one half hours',
+            '½ kg': 'one half kilogram',
+            '1½ kg': 'one and one half kilograms',
+            '1/2 m/s': 'one half metre per second',
+            '3/4 km/h': 'three quarters kilometre per hour',
+        }
+        for inp, correct in cases.items():
+            self.assertEqual(self.processor.process(inp, language='en'), correct, inp)
+
+    def test_fraction_amounts_persian(self):
+        cases = {
+            '۱/۲ kg': 'یک دوم کیلوگرم',
+            '۱/۲kg': 'یک دوم کیلوگرم',
+            '۳/۴ km': 'سه چهارم کیلومتر',
+            '1/3 L': 'یک سوم لیتر',
+            '۱٬۰۰۰/۲ kg': 'یک هزار دوم کیلوگرم',
+            '۲ ۱/۲ kg': 'دو و یک دوم کیلوگرم',
+            '½ kg': 'یک دوم کیلوگرم',
+        }
+        for inp, correct in cases.items():
+            self.assertEqual(self.processor.process(inp, language='fa'), correct, inp)
+
+    def test_fraction_amounts_language_from_digits(self):
+        self.assertEqual(self.processor.process('۱/۲ kg', language='en'), 'یک دوم کیلوگرم')
+        self.assertEqual(self.processor.process('1/2 kg', language=None), 'one half kilogram')
+
+    def test_invalid_fraction_with_unit_is_unchanged(self):
+        for inp in ('1/0 kg', '1/1 kg', '3/1 km'):
+            self.assertEqual(self.processor.process(inp, language='en'), inp, inp)
+
+    def test_percent_english(self):
+        cases = {
+            '2 %': 'two percent',
+            '2%': 'two percent',
+            '1%': 'one percent',
+            '100%': 'one hundred percent',
+            '2 ٪': 'two percent',
+            '2.5%': 'two point five percent',
+            '0.5 %': 'zero point five percent',
+            '1/2 %': 'one half percent',
+            '2 1/2%': 'two and one half percent',
+            '1,000%': 'one thousand percent',
+        }
+        for inp, correct in cases.items():
+            self.assertEqual(self.processor.process(inp, language='en'), correct, inp)
+
+    def test_percent_persian(self):
+        cases = {
+            '۲ ٪': 'دو درصد',
+            '۲٪': 'دو درصد',
+            '۲ %': 'دو درصد',
+            '2 %': 'دو درصد',
+            '۱۰۰٪': 'یکصد درصد',
+            '۲٫۵٪': 'دو و پنج دهم درصد',
+            '۱/۲ ٪': 'یک دوم درصد',
+        }
+        for inp, correct in cases.items():
+            self.assertEqual(self.processor.process(inp, language='fa'), correct, inp)
+
+    def test_percent_sign_before_the_number(self):
+        self.assertEqual(self.processor.process('%20', language='en'), 'twenty percent')
+        self.assertEqual(self.processor.process('Save %20 today', language='en'), 'Save twenty percent today')
+        self.assertEqual(self.processor.process('٪۲۰', language='fa'), 'بیست درصد')
+        self.assertEqual(self.processor.process('تخفیف %۲۰ است', language='fa'), 'تخفیف بیست درصد است')
+
+    def test_percent_sign_before_the_number_with_space(self):
+        self.assertEqual(self.processor.process('% 5', language='en'), 'five percent')
+        self.assertEqual(self.processor.process('%   5', language='en'), 'five percent')
+        self.assertEqual(self.processor.process('Save % 20 today', language='en'), 'Save twenty percent today')
+        self.assertEqual(self.processor.process('% 2.5', language='en'), 'two point five percent')
+        self.assertEqual(self.processor.process('٪ ۵', language='fa'), 'پنج درصد')
+        self.assertEqual(self.processor.process('تخفیف ٪ ۲۰ است', language='fa'), 'تخفیف بیست درصد است')
+
+    def test_number_before_the_sign_wins_over_prefix_reading(self):
+        # In `5 % 2` the sign belongs to the 5.
+        self.assertEqual(self.processor.process('5 % 2', language='en'), 'five percent 2')
+
+    def test_unit_after_percent_is_read_as_singular(self):
+        cases_en = {
+            '5% kg': 'five percent kilogram',
+            '5 % kg': 'five percent kilogram',
+            '2.5% m': 'two point five percent metre',
+            '5% km/h': 'five percent kilometre per hour',
+            '1/2 % kg': 'one half percent kilogram',
+            '% 20 cm': 'twenty percent centimetre',
+            '%20 cm': 'twenty percent centimetre',
+            '% 2.5 kg': 'two point five percent kilogram',
+            '٪ 5 kg': 'five percent kilogram',
+        }
+        for inp, correct in cases_en.items():
+            self.assertEqual(self.processor.process(inp, language='en'), correct, inp)
+
+        self.assertEqual(self.processor.process('۵٪ kg', language='fa'), 'پنج درصد کیلوگرم')
+        self.assertEqual(self.processor.process('۵ ٪ km', language='fa'), 'پنج درصد کیلومتر')
+        self.assertEqual(self.processor.process('٪ ۲۰ cm', language='fa'), 'بیست درصد سانتیمتر')
+
+    def test_symbol_after_another_unit_is_not_consumed(self):
+        self.assertEqual(self.processor.process('5 km kg', language='en'), 'five kilometres kg')
+        self.assertEqual(self.processor.process('5 km 3 kg', language='en'), 'five kilometres three kilograms')
+        self.assertEqual(self.processor.process('10% of 2 kg', language='en'), 'ten percent of two kilograms')
+
+    def test_percent_language_from_digits(self):
+        self.assertEqual(self.processor.process('۲٪', language='en'), 'دو درصد')
+        self.assertEqual(self.processor.process('2%', language=None), 'two percent')
+
+    def test_percent_mixed_with_other_units(self):
+        self.assertEqual(
+            self.processor.process('Sales rose 5% and 2 kg of rice', language='en'),
+            'Sales rose five percent and two kilograms of rice',
+        )
+        self.assertEqual(
+            self.processor.process('فروش ۵٪ بیشتر شد و ۲ kg برنج', language='fa'),
+            'فروش پنج درصد بیشتر شد و دو کیلوگرم برنج',
+        )
+        self.assertEqual(
+            self.processor.process('5 km, 2 kg and 10 %.', language='en'),
+            'five kilometres, two kilograms and ten percent.',
+        )
+
+    def test_percent_sign_without_a_number_is_unchanged(self):
+        inputs = ['%', '٪', 'hello %', 'x % y', '% 1/2', 'printf %d and %s', '% d', '% 5d', 'a%20b', '%20b', '100%a', '1/0 % kg']
+        for inp in inputs:
+            self.assertEqual(self.processor.process(inp, language='en'), inp, inp)
+
+    def test_wrapped_units_and_amounts(self):
+        cases = {
+            '2 (kg)': 'two (kilograms)',
+            '2(kg)': 'two (kilograms)',
+            '2 [kg]': 'two [kilograms]',
+            '3 {m}': 'three {metres}',
+            '3 "m"': 'three "metres"',
+            '2 ( kg )': 'two (kilograms)',
+            '(5) kg': '(five) kilograms',
+            '(1/2) kg': '(one half) kilogram',
+            '50 (%)': 'fifty (percent)',
+            '2.5 (kg)': 'two (kilograms) and five hundred (grams)',
+            '2 (kg) and 3 (m)': 'two (kilograms) and three (metres)',
+            '(2 kg)': '(two kilograms)',
+        }
+        for inp, correct in cases.items():
+            self.assertEqual(self.processor.process(inp, language='en'), correct, inp)
+
+        self.assertEqual(self.processor.process('۲ (kg)', language='fa'), 'دو (کیلوگرم)')
+        self.assertEqual(self.processor.process('۳ {m}', language='fa'), 'سه {متر}')
+
+    def test_wrapped_non_units_are_unchanged(self):
+        for inp in ('3 (a)', '2 (kgx)', '2 (kg', '(5)', '3 (hello)'):
+            self.assertEqual(self.processor.process(inp, language='en'), inp, inp)
+
+    def test_multiple_units_and_punctuation(self):
+        self.assertEqual(
+            self.processor.process('I ran 5 km and lifted 3 kg.', language='en'),
+            'I ran five kilometres and lifted three kilograms.',
+        )
+        self.assertEqual(self.processor.process('(5km),', language='en'), '(five kilometres),')
+
+    def test_not_a_unit_is_unchanged(self):
+        inputs = [
+            'hello', 'km', '5', '5 s', '1990s', '3d', '5 mn', '5G', 'A5 km', '5 km²',
+            '5 kmh', 'size is 5 in', '5 KM', '5 K',
+        ]
+        for inp in inputs:
+            self.assertEqual(self.processor.process(inp, language='en'), inp)
+
+    def test_language_ignores_unit_symbols(self):
+        # `km` / `mm` are Latin letters, but the sentence itself is Persian.
+        self.assertEqual(
+            self.processor.process('من 10 km 20 mm', language='en'),
+            'من ده کیلومتر بیست میلیمتر',
+        )
+
+    def test_mixed_language_is_unchanged(self):
+        self.assertEqual(self.processor.process('hi ما 5 km', language='en'), 'hi ما 5 km')
+
+    def test_unsupported_fallback_language_is_unchanged(self):
+        for language in ('mixed', 'de'):
+            self.assertEqual(self.processor.process('5 km', language=language), '5 km')
+
+    def test_only_units_in_text_is_decided_by_digits(self):
+        # Normalizer detects "en" here because `m` / `km` are Latin letters.
+        inputs = ['۱۰۰۰m', '۱۰۰۰ m', '1000m', '1000 m', '۵ km', '5 km', '۲.۵ kg', '2.5 kg']
+        corrects = [
+            'یک هزار متر',
+            'یک هزار متر',
+            'one thousand metres',
+            'one thousand metres',
+            'پنج کیلومتر',
+            'five kilometres',
+            'دو کیلوگرم و پانصد گرم',
+            'two kilograms and five hundred grams',
+        ]
+        for language in ('en', None, 'Unknown / No letters found'):
+            normalized = [self.processor.process(i, language=language) for i in inputs]
+            self.assertListEqual(normalized, corrects, language)
+
+    def test_epsilon_zero_disables_processor(self):
+        processor = UnitProcessor(epsilon=0.0)
+        outputs = {processor.process('5 km', language='en') for _ in range(50)}
+        self.assertEqual(outputs, {'5 km'})
+
+
+class FractionProcessorTestCase(unittest.TestCase):
+    def setUp(self):
+        self.processor = FractionProcessor()
+
+    def test_english(self):
+        cases = {
+            '1/3': 'one third',
+            '2/3': 'two thirds',
+            '1/2': 'one half',
+            '3/2': 'three halves',
+            '1/4': 'one quarter',
+            '3/4': 'three quarters',
+            '5/8': 'five eighths',
+            '7/10': 'seven tenths',
+            '1/21': 'one twenty-first',
+            '1/100': 'one hundredth',
+            '3/100': 'three hundredths',
+            '1/1000': 'one thousandth',
+        }
+        for inp, correct in cases.items():
+            self.assertEqual(self.processor.process(inp, language='en'), correct, inp)
+
+    def test_persian(self):
+        cases = {
+            '۱/۳': 'یک سوم',
+            '۲/۳': 'دو سوم',
+            '۱/۲': 'یک دوم',
+            '۳/۴': 'سه چهارم',
+            '۵/۸': 'پنج هشتم',
+            '۷/۱۰': 'هفت دهم',
+            '۱/۲۳': 'یک بیست و سوم',
+            '۱/۳۰': 'یک سی\u200cام',
+            '۱/۱۰۰': 'یک صدم',
+            '۳/۱۰۰': 'سه صدم',
+            '۱/۱۰۰۰': 'یک هزارم',
+            '1/3': 'یک سوم',
+        }
+        for inp, correct in cases.items():
+            self.assertEqual(self.processor.process(inp, language='fa'), correct, inp)
+
+    def test_mixed_numbers(self):
+        cases_en = {
+            '2 1/2': 'two and one half',
+            '1 3/4': 'one and three quarters',
+            '10 2/3': 'ten and two thirds',
+        }
+        for inp, correct in cases_en.items():
+            self.assertEqual(self.processor.process(inp, language='en'), correct, inp)
+
+        cases_fa = {
+            '۲ ۱/۲': 'دو و یک دوم',
+            '۱ ۳/۴': 'یک و سه چهارم',
+        }
+        for inp, correct in cases_fa.items():
+            self.assertEqual(self.processor.process(inp, language='fa'), correct, inp)
+
+    def test_vulgar_fractions(self):
+        cases_en = {
+            '½': 'one half',
+            '¾': 'three quarters',
+            '⅔': 'two thirds',
+            '⅞': 'seven eighths',
+            '1½': 'one and one half',
+            '2 ¼': 'two and one quarter',
+        }
+        for inp, correct in cases_en.items():
+            self.assertEqual(self.processor.process(inp, language='en'), correct, inp)
+
+        self.assertEqual(self.processor.process('½', language='fa'), 'یک دوم')
+        self.assertEqual(self.processor.process('۱½', language='fa'), 'یک و یک دوم')
+
+    def test_thousands_separators(self):
+        cases_en = {
+            '1,000/2': 'one thousand halves',
+            '12,345/3': 'twelve thousand, three hundred and forty-five thirds',
+            '1,000 1/2': 'one thousand and one half',
+        }
+        for inp, correct in cases_en.items():
+            self.assertEqual(self.processor.process(inp, language='en'), correct, inp)
+
+        self.assertEqual(self.processor.process('۱٬۰۰۰/۲', language='fa'), 'یک هزار دوم')
+        self.assertEqual(self.processor.process('۱,۰۰۰/۲', language='fa'), 'یک هزار دوم')
+
+    def test_fractions_inside_a_sentence_and_punctuation(self):
+        self.assertEqual(
+            self.processor.process('I ate 1/3 and 2/3 more.', language='en'),
+            'I ate one third and two thirds more.',
+        )
+        self.assertEqual(self.processor.process('(1/3).', language='en'), '(one third).')
+        self.assertEqual(self.processor.process('1/2.', language='en'), 'one half.')
+        self.assertEqual(
+            self.processor.process('من ۱/۳ و ۲/۳ خوردم', language='fa'),
+            'من یک سوم و دو سوم خوردم',
+        )
+
+    def test_not_a_fraction_is_unchanged(self):
+        inputs = [
+            '1402/05/10', '2024/05/10', '10/05/2024', '3.1/2', '1/2.5', '1/0', '3/1',
+            'and/or', '1/2$', '1/2%', 'a1/2', '1/2a', '60 km/h', '12', 'hello', '1,00/2', '1,2/3',
+        ]
+        for inp in inputs:
+            self.assertEqual(self.processor.process(inp, language='en'), inp, inp)
+            self.assertEqual(self.processor.process(inp, language='fa'), inp, inp)
+
+    def test_no_letters_language_is_decided_by_digits(self):
+        no_letters = 'Unknown / No letters found'
+        for language in (None, no_letters):
+            self.assertEqual(self.processor.process('۱/۳', language=language), 'یک سوم')
+            self.assertEqual(self.processor.process('1/3', language=language), 'one third')
+            self.assertEqual(self.processor.process('2 1/2', language=language), 'two and one half')
+
+    def test_unsupported_language_is_unchanged(self):
+        for language in ('mixed', 'de'):
+            self.assertEqual(self.processor.process('1/3', language=language), '1/3')
+
+    def test_epsilon_zero_disables_processor(self):
+        processor = FractionProcessor(epsilon=0.0)
+        outputs = {processor.process('1/3', language='en') for _ in range(50)}
+        self.assertEqual(outputs, {'1/3'})
+
+
+class RomanNumeralProcessorTestCase(unittest.TestCase):
+    def setUp(self):
+        self.processor = RomanNumeralProcessor()
+
+    def test_roman_to_int(self):
+        valid = {'I': 1, 'IV': 4, 'IX': 9, 'XIV': 14, 'XL': 40, 'XCIX': 99, 'MCMXC': 1990, 'MMXXIV': 2024, 'MMMCMXCIX': 3999}
+        for token, value in valid.items():
+            self.assertEqual(roman_to_int(token), value, token)
+        for token in ('IIII', 'VX', 'IC', 'IIV', 'MMMM', 'ABC', 'iv', ''):
+            self.assertIsNone(roman_to_int(token), token)
+
+    def test_english(self):
+        cases = {
+            'Henry VIII was king': 'Henry eight was king',
+            'Louis XIV and Louis XVI': 'Louis fourteen and Louis sixteen',
+            'Chapter IV': 'Chapter four',
+            'World War II': 'World War two',
+            'World War I': 'World War one',
+            'Part V and Section X': 'Part five and Section ten',
+            'Napoleon III': 'Napoleon three',
+            'MMXXIV': 'two thousand and twenty-four',
+            'XIV': 'fourteen',
+            '(XIV).': '(fourteen).',
+        }
+        for inp, correct in cases.items():
+            self.assertEqual(self.processor.process(inp, language='en'), correct, inp)
+
+    def test_persian(self):
+        cases = {
+            'فصل IV': 'فصل چهار',
+            'قرن XX': 'قرن بیست',
+            'قرن XVIII': 'قرن هجده',
+            'جنگ جهانی II': 'جنگ جهانی دو',
+            'جنگ جهانی I': 'جنگ جهانی یک',
+            'بخش V را بخوان': 'بخش پنج را بخوان',
+        }
+        for inp, correct in cases.items():
+            self.assertEqual(self.processor.process(inp, language='fa'), correct, inp)
+
+    def test_wrapped_numerals_after_a_trigger_word(self):
+        cases = {
+            'chapter (V)': 'chapter (five)',
+            'Chapter [V]': 'Chapter [five]',
+            'Part {I}': 'Part {one}',
+            'Chapter "IV"': 'Chapter "four"',
+            'Chapter ( V )': 'Chapter ( five )',
+            'Henry (VIII)': 'Henry (eight)',
+            '(XIV)': '(fourteen)',
+        }
+        for inp, correct in cases.items():
+            self.assertEqual(self.processor.process(inp, language='en'), correct, inp)
+        self.assertEqual(self.processor.process('فصل (V)', language='fa'), 'فصل (پنج)')
+        self.assertEqual(self.processor.process('فصل «V»', language='fa'), 'فصل «پنج»')
+        # a pronoun or a label in a wrapper is still left alone
+        for inp in ('(I) think so', 'Vitamin (C)', 'Henry (V)'):
+            self.assertEqual(self.processor.process(inp, language='en'), inp, inp)
+
+    def test_language_ignores_the_numerals(self):
+        # `XVIII` has more letters than the Persian words, but the sentence is Persian.
+        self.assertEqual(self.processor.process('قرن XVIII', language='en'), 'قرن هجده')
+        self.assertEqual(self.processor.process('Chapter IV', language='fa'), 'Chapter four')
+
+    def test_pronoun_and_labels_are_unchanged(self):
+        inputs = [
+            'I think so', 'After the war I went home', 'Vitamin C', 'Hepatitis C',
+            'Appendix C', 'Part D', 'Section L', 'Henry V', 'Washington DC',
+            'Dr. Smith, MD', 'CD player', 'XL shirt', 'MIX the flour',
+        ]
+        for inp in inputs:
+            self.assertEqual(self.processor.process(inp, language='en'), inp, inp)
+
+    def test_invalid_and_lowercase_are_unchanged(self):
+        for inp in ('IIII', 'VX', 'IC', 'MMMM', 'iv', 'xiv', 'Xiv', 'XIVa', 'aXIV'):
+            self.assertEqual(self.processor.process(inp, language='en'), inp, inp)
+
+    def test_unsupported_language_is_unchanged(self):
+        for language in ('mixed', 'de', None):
+            self.assertEqual(self.processor.process('XIV', language=language), 'XIV')
+
+    def test_epsilon_zero_disables_processor(self):
+        processor = RomanNumeralProcessor(epsilon=0.0)
+        outputs = {processor.process('Chapter IV', language='en') for _ in range(50)}
+        self.assertEqual(outputs, {'Chapter IV'})
+
+
+class AmpersandProcessorTestCase(unittest.TestCase):
+    def setUp(self):
+        self.processor = AmpersandProcessor()
+
+    def test_english(self):
+        cases = {
+            'Tom & Jerry': 'Tom and Jerry',
+            'R&D': 'R and D',
+            'Q&A': 'Q and A',
+            'AT&T': 'AT and T',
+            'Tom &Jerry': 'Tom and Jerry',
+            '& Jerry': 'and Jerry',
+            'Tom &': 'Tom and',
+            '(R&D)': '(R and D)',
+            'salt & pepper & oil': 'salt and pepper and oil',
+        }
+        for inp, correct in cases.items():
+            self.assertEqual(self.processor.process(inp, language='en'), correct, inp)
+
+    def test_persian(self):
+        cases = {
+            'من & تو': 'من و تو',
+            'تام & جری': 'تام و جری',
+            'بخش R&D فعال است': 'بخش R و D فعال است',
+        }
+        for inp, correct in cases.items():
+            self.assertEqual(self.processor.process(inp, language='fa'), correct, inp)
+
+    def test_numbers_beside_ampersand_english(self):
+        cases = {
+            '3 & 4': 'three and four',
+            '3&4': 'three and four',
+            '1 & 2 & 3': 'one and two and three',
+            '2.5 & 3.5': 'two point five and three point five',
+            '1,000 & 2,000': 'one thousand and two thousand',
+            'Windows 10 & 11': 'Windows ten and eleven',
+            'Tom & 2 friends': 'Tom and two friends',
+            'What is 3 & 4?': 'What is three and four?',
+            '1 & 2.': 'one and two.',
+        }
+        for inp, correct in cases.items():
+            self.assertEqual(self.processor.process(inp, language='en'), correct, inp)
+
+    def test_numbers_beside_ampersand_persian(self):
+        cases = {
+            '۳ & ۴': 'سه و چهار',
+            '3 & 4': 'سه و چهار',
+            '۱ & ۲ & ۳': 'یک و دو و سه',
+            '۲٫۵ & ۳٫۵': 'دو و پنج دهم و سه و پنج دهم',
+            'سیب ۳ & ۴ پرتقال': 'سیب سه و چهار پرتقال',
+        }
+        for inp, correct in cases.items():
+            self.assertEqual(self.processor.process(inp, language='fa'), correct, inp)
+
+    def test_numbers_that_are_part_of_something_else_are_not_read_as_plain_numbers(self):
+        # Only the `&` is read; the dates, times and currency are left for their own processors.
+        cases = {
+            '10:30 & 11:30': '10:30 and 11:30',
+            '2024-05-10 & 2024-05-11': '2024-05-10 and 2024-05-11',
+            '5-6 & 7': '5-6 and seven',
+            'Q3 & Q4': 'Q3 and Q4',
+            '3rd & 4th': '3rd and 4th',
+            '$3 & $4': '$3 and $4',
+            '3$ & 4$': '3$ and 4$',
+        }
+        for inp, correct in cases.items():
+            self.assertEqual(self.processor.process(inp, language='en'), correct, inp)
+
+    def test_urls_and_non_ampersands_are_unchanged(self):
+        for inp in ('a=1&b=2', 'http://x.com/?a=1&2', '3 && 4', '& 3'):
+            self.assertEqual(self.processor.process(inp, language='en'), inp, inp)
+
+    def test_wrapped_ampersand_and_numbers(self):
+        cases = {
+            'Tom (&) Jerry': 'Tom (and) Jerry',
+            'Tom [&] Jerry': 'Tom [and] Jerry',
+            '3 (&) 4': 'three (and) four',
+            '(3) & (4)': '(three) and (four)',
+        }
+        for inp, correct in cases.items():
+            self.assertEqual(self.processor.process(inp, language='en'), correct, inp)
+        self.assertEqual(self.processor.process('من (&) تو', language='fa'), 'من (و) تو')
+        self.assertEqual(self.processor.process('(۳) & (۴)', language='fa'), '(سه) و (چهار)')
+
+    def test_question_mark_does_not_block_ampersand(self):
+        self.assertEqual(self.processor.process('Is it R&D?', language='en'), 'Is it R and D?')
+
+    def test_spacing_of_the_rest_of_the_text_is_kept(self):
+        self.assertEqual(self.processor.process('a  b & c\nd', language='en'), 'a  b and c\nd')
+
+    def test_not_an_ampersand_word_is_unchanged(self):
+        inputs = ['&', 'a & b', '&', '&', 'a && b', 'a=1&b=2', 'http://x.com?a=1&b=2', 'hello']
+        for inp in inputs:
+            self.assertEqual(self.processor.process(inp, language='en'), inp, inp)
+
+    def test_no_letters_language_is_decided_by_digits(self):
+        for language in (None, 'Unknown / No letters found'):
+            self.assertEqual(self.processor.process('1 & 2', language=language), 'one and two')
+            self.assertEqual(self.processor.process('۱ & ۲', language=language), 'یک و دو')
+
+    def test_unsupported_language_is_unchanged(self):
+        for language in ('mixed', 'de'):
+            self.assertEqual(self.processor.process('Tom & Jerry', language=language), 'Tom & Jerry')
+
+    def test_epsilon_zero_disables_processor(self):
+        processor = AmpersandProcessor(epsilon=0.0)
+        outputs = {processor.process('Tom & Jerry', language='en') for _ in range(50)}
+        self.assertEqual(outputs, {'Tom & Jerry'})
+
+
+class NegativeSignProcessorTestCase(unittest.TestCase):
+    def setUp(self):
+        self.processor = NegativeSignProcessor()
+
+    def test_bare_numbers_are_read_as_words(self):
+        cases_en = {
+            '-2': 'negative two',
+            '−2': 'negative two',
+            '(-2)': '(negative two)',
+            '= -2': '= negative two',
+            'The temp is -2 degrees': 'The temp is negative two degrees',
+            '-2.5': 'negative two point five',
+            '-1,000': 'negative one thousand',
+            '-2.': 'negative two.',
+        }
+        for inp, correct in cases_en.items():
+            self.assertEqual(self.processor.process(inp, language='en'), correct, inp)
+
+        self.assertEqual(self.processor.process('-۲', language='fa'), 'منفی دو')
+        self.assertEqual(self.processor.process('دما -۲ درجه است', language='fa'), 'دما منفی دو درجه است')
+
+    def test_number_with_unit_fraction_percent_or_currency_is_left_for_their_processors(self):
+        cases = {
+            '-2 m': 'negative 2 m',
+            '-2m': 'negative 2m',
+            '- 2 m': 'negative 2 m',
+            '-1/2 kg': 'negative 1/2 kg',
+            '-5%': 'negative 5%',
+            '-$5': 'negative $5',
+            '-5$': 'negative 5$',
+        }
+        for inp, correct in cases.items():
+            self.assertEqual(self.processor.process(inp, language='en'), correct, inp)
+
+        # The language comes from the Persian digits, not from the Latin `m`.
+        self.assertEqual(self.processor.process('-۲ m', language='en'), 'منفی ۲ m')
+        self.assertEqual(self.processor.process('- ۲ m', language='en'), 'منفی ۲ m')
+
+    def test_space_after_minus_needs_a_unit_or_an_operator(self):
+        self.assertEqual(self.processor.process('3 + - 2', language='en'), '3 + negative two')
+        self.assertEqual(self.processor.process('x = - 2', language='en'), 'x = negative two')
+        for inp in ('- 2024 report', '- 2', '- item', '10 - 20 km', 'He said - 2 m'):
+            self.assertEqual(self.processor.process(inp, language='en'), inp, inp)
+
+    def test_not_a_negative_number_is_unchanged(self):
+        inputs = [
+            '5-3', 'a-2', 'COVID-19', '2024-05-10', '0912-123-4567', '-10:30',
+            '-2nd', '-2x', '--2', '5--2', 'hello', '-', '- ',
+        ]
+        for inp in inputs:
+            self.assertEqual(self.processor.process(inp, language='en'), inp, inp)
+
+    def test_unsupported_language_is_unchanged(self):
+        for language in ('mixed', 'de'):
+            self.assertEqual(self.processor.process('-2', language=language), '-2')
+
+    def test_epsilon_zero_disables_processor(self):
+        processor = NegativeSignProcessor(epsilon=0.0)
+        outputs = {processor.process('-2', language='en') for _ in range(50)}
+        self.assertEqual(outputs, {'-2'})
+
+
+class MathOperatorProcessorTestCase(unittest.TestCase):
+    def setUp(self):
+        self.processor = MathOperatorProcessor()
+
+    def test_english(self):
+        cases = {
+            '3 + 4': 'three plus four',
+            '3+4': 'three plus four',
+            '6 × 2': 'six times two',
+            '6×2': 'six times two',
+            '3 * 4': 'three times four',
+            '8 ÷ 2': 'eight divided by two',
+            '7 = 7': 'seven equals seven',
+            '1+1=2': 'one plus one equals two',
+            '3 + 4 = 7': 'three plus four equals seven',
+            '1 + 2 + 3': 'one plus two plus three',
+            '2.5 + 1,000': 'two point five plus one thousand',
+            'Tom + Jerry': 'Tom plus Jerry',
+            'x + y = z': 'x plus y equals z',
+            'Is 2 + 2 = 4?': 'Is two plus two equals four?',
+        }
+        for inp, correct in cases.items():
+            self.assertEqual(self.processor.process(inp, language='en'), correct, inp)
+
+    def test_persian(self):
+        cases = {
+            '۳ + ۴': 'سه بعلاوه چهار',
+            '۳+۴': 'سه بعلاوه چهار',
+            '۶ × ۲': 'شش ضربدر دو',
+            '۸ ÷ ۲': 'هشت تقسیم بر دو',
+            '۷ = ۷': 'هفت مساوی است با هفت',
+            '۳ + ۴ = ۷': 'سه بعلاوه چهار مساوی است با هفت',
+            'حاصل ۲ + ۲ = ۴ است': 'حاصل دو بعلاوه دو مساوی است با چهار است',
+        }
+        for inp, correct in cases.items():
+            self.assertEqual(self.processor.process(inp, language='fa'), correct, inp)
+
+    def test_wrapped_operands_and_symbols(self):
+        self.assertEqual(self.processor.process('(3) + (4)', language='en'), '(three) plus (four)')
+        self.assertEqual(self.processor.process('3 (+) 4', language='en'), 'three (plus) four')
+        self.assertEqual(self.processor.process('[6] × [2]', language='en'), '[six] times [two]')
+        self.assertEqual(self.processor.process('(3 + 4)', language='en'), '(three plus four)')
+        self.assertEqual(self.processor.process('(۳) + (۴)', language='fa'), '(سه) بعلاوه (چهار)')
+        self.assertEqual(self.processor.process('۳ (+) ۴', language='fa'), 'سه (بعلاوه) چهار')
+
+    def test_minus(self):
+        self.assertEqual(self.processor.process('5 − 3', language='en'), 'five minus three')
+        self.assertEqual(self.processor.process('۵ − ۳', language='fa'), 'پنج منهای سه')
+        # an ASCII hyphen is a minus only in a spaced equation
+        self.assertEqual(self.processor.process('5 - 3 = 2', language='en'), 'five minus three equals two')
+        self.assertEqual(self.processor.process('۵ - ۳ = ۲', language='fa'), 'پنج منهای سه مساوی است با دو')
+        self.assertEqual(self.processor.process('x - y = z', language='en'), 'x minus y equals z')
+        for inp in ('5 - 3', '5-3', '10 - 20', 'well - maybe'):
+            self.assertEqual(self.processor.process(inp, language='en'), inp, inp)
+
+    def test_symbols_that_are_not_between_operands_are_unchanged(self):
+        inputs = [
+            '+98 912 123 4567', 'C++ is great', 'A+ grade', 'x=5', 'a=1&b=2',
+            'http://x.com/?a=1&b=2', 'a == b', 'a <= b', '* item', '+', '=', '3 +',
+            '+ 4', 'hello',
+        ]
+        for inp in inputs:
+            self.assertEqual(self.processor.process(inp, language='en'), inp, inp)
+
+    def test_units_and_currency_are_left_for_their_processors(self):
+        # Only the symbol is read here; `$3` and `3$` are read later by CurrencyProcessor.
+        self.assertEqual(self.processor.process('$3 + $4', language='en'), '$3 plus $4')
+        self.assertEqual(self.processor.process('3$ + 4$', language='en'), '3$ plus 4$')
+        self.assertEqual(self.processor.process('10:30 + 2', language='en'), '10:30 plus two')
+        self.assertEqual(self.processor.process('2024-05-10 + 3', language='en'), '2024-05-10 plus three')
+
+    def test_no_letters_language_is_decided_by_digits(self):
+        for language in (None, 'Unknown / No letters found'):
+            self.assertEqual(self.processor.process('3 + 4', language=language), 'three plus four')
+            self.assertEqual(self.processor.process('۳ + ۴', language=language), 'سه بعلاوه چهار')
+
+    def test_unsupported_language_is_unchanged(self):
+        for language in ('mixed', 'de'):
+            self.assertEqual(self.processor.process('3 + 4', language=language), '3 + 4')
+
+    def test_epsilon_zero_disables_processor(self):
+        processor = MathOperatorProcessor(epsilon=0.0)
+        outputs = {processor.process('3 + 4', language='en') for _ in range(50)}
+        self.assertEqual(outputs, {'3 + 4'})
+
+
+class RangeProcessorTestCase(unittest.TestCase):
+    def setUp(self):
+        self.processor = RangeProcessor()
+
+    def test_plain_numbers_english(self):
+        cases = {
+            '3 - 5': 'three to five',
+            '3-5': 'three to five',
+            '3 – 5': 'three to five',
+            '3–5': 'three to five',
+            '10 - 20': 'ten to twenty',
+            '2.5 - 3.5': 'two point five to three point five',
+            'pages 3-5': 'pages three to five',
+            'Is it 3 - 5?': 'Is it three to five?',
+            '1 - 2 - 3': 'one to two to three',
+            '1990 - 2000': 'one thousand, nine hundred and ninety to two thousand',
+            '1990–2000': 'one thousand, nine hundred and ninety to two thousand',
+        }
+        for inp, correct in cases.items():
+            self.assertEqual(self.processor.process(inp, language='en'), correct, inp)
+
+    def test_plain_numbers_persian(self):
+        cases = {
+            '۳ - ۵': 'سه تا پنج',
+            '۳-۵': 'سه تا پنج',
+            '۳ – ۵': 'سه تا پنج',
+            '3 - 5': 'سه تا پنج',
+            'از ۳ - ۵ ساعت': 'از سه تا پنج ساعت',
+        }
+        for inp, correct in cases.items():
+            self.assertEqual(self.processor.process(inp, language='fa'), correct, inp)
+
+    def test_amounts_with_units_fractions_percent_and_currency_are_left_for_their_processors(self):
+        # Only the dash (and a plain number beside it) is read here.
+        cases = {
+            '3kg - 5 kg': '3kg to 5 kg',
+            '3 kg-5 kg': '3 kg to 5 kg',
+            '3 - 5 kg': 'three to 5 kg',
+            '3 kg - 5': '3 kg to five',
+            '10 - 20 km': 'ten to 20 km',
+            '$3 - $5': '$3 to $5',
+            '3$ - 5$': '3$ to 5$',
+            '1/2 - 3/4': '1/2 to 3/4',
+            '5% - 10%': '5% to 10%',
+            '10 - 20%': 'ten to 20%',
+        }
+        for inp, correct in cases.items():
+            self.assertEqual(self.processor.process(inp, language='en'), correct, inp)
+
+        self.assertEqual(self.processor.process('۳kg - ۵ kg', language='fa'), '۳kg تا ۵ kg')
+
+    def test_wrapped_amounts(self):
+        self.assertEqual(self.processor.process('(3) - (5)', language='en'), '(three) to (five)')
+        self.assertEqual(self.processor.process('[3]-[5]', language='en'), '[three] to [five]')
+        self.assertEqual(self.processor.process('(3 - 5)', language='en'), '(three to five)')
+        self.assertEqual(self.processor.process('(۳) - (۵)', language='fa'), '(سه) تا (پنج)')
+        # wrapped amounts with units are left for UnitProcessor
+        self.assertEqual(self.processor.process('3 (cm) - 5 (cm)', language='en'), '3 (cm) to 5 (cm)')
+        self.assertEqual(self.processor.process('(2) kg - (5) kg', language='en'), '(2) kg to (5) kg')
+
+    def test_not_a_range_is_unchanged(self):
+        inputs = [
+            '2024-05-10', '2024-05', '05-10', '0912-123-4567', '555-1234', '1990-2000',
+            'COVID-19', 'A-5', 'a - b', 'well - maybe', '10:30 - 11:30',
+            '2024/05/10 - 2024/05/12', '3 -5', '3- 5', '- 5', '3 -', '3 –',
+            'http://x.com/3-5', '5 - 3 = 2', 'x = 3 - 5',
+        ]
+        for inp in inputs:
+            self.assertEqual(self.processor.process(inp, language='en'), inp, inp)
+
+    def test_no_letters_language_is_decided_by_digits(self):
+        for language in (None, 'Unknown / No letters found'):
+            self.assertEqual(self.processor.process('3 - 5', language=language), 'three to five')
+            self.assertEqual(self.processor.process('۳ - ۵', language=language), 'سه تا پنج')
+
+    def test_unsupported_language_is_unchanged(self):
+        for language in ('mixed', 'de'):
+            self.assertEqual(self.processor.process('3 - 5', language=language), '3 - 5')
+
+    def test_epsilon_zero_disables_processor(self):
+        processor = RangeProcessor(epsilon=0.0)
+        outputs = {processor.process('3 - 5', language='en') for _ in range(50)}
+        self.assertEqual(outputs, {'3 - 5'})
+
+
+class PhoneNumberProcessorTestCase(unittest.TestCase):
+    MOBILE_EN = 'zero nine one two, four three three, eight one, three five'
+    MOBILE_PLUS_EN = 'plus nine eight, nine one two, four three three, eight one, three five'
+    LANDLINE_EN = 'zero two one, eight eight, zero six, nine eight, nine five'
+    MOBILE_FA = 'صفر نهصد و دوازده، چهارصد و سی و سه، هشتاد و یک، سی و پنج'
+    MOBILE_PLUS_FA = 'مثبت نود و هشت، نهصد و دوازده، چهارصد و سی و سه، هشتاد و یک، سی و پنج'
+    LANDLINE_FA = 'صفر بیست و یک، هشتاد و هشت، صفر شش، نود و هشت، نود و پنج'
+
+    def setUp(self):
+        self.processor = PhoneNumberProcessor()
+
+    def test_iranian_mobile_english(self):
+        for inp in ('09124338135', '0912-433-8135', '0912 433 8135', '0912.433.8135', '0912-4338135'):
+            self.assertEqual(self.processor.process(inp, language='en'), self.MOBILE_EN, inp)
+
+    def test_international_english(self):
+        for inp in ('+989124338135', '+98-912-4338135', '+98 912 433 8135', '+98.912.433.8135', '(+98) 912 4338135'):
+            expected = self.MOBILE_PLUS_EN
+            if inp.startswith('('):
+                expected = '(plus nine eight), nine one two, four three three, eight one, three five'
+            self.assertEqual(self.processor.process(inp, language='en'), expected, inp)
+        self.assertEqual(
+            self.processor.process('0098 912 4338135', language='en'),
+            'zero zero nine eight, nine one two, four three three, eight one, three five',
+        )
+        self.assertEqual(
+            self.processor.process('+44 20 7946 0958', language='en'),
+            'plus four four, two zero, seven nine four six, zero nine five eight',
+        )
+        self.assertEqual(
+            self.processor.process('+1 (555) 123-4567', language='en'),
+            'plus one, (five five five), one two three, four five six seven',
+        )
+
+    def test_iranian_landline_english(self):
+        for inp in ('021-88069895', '021 88069895', '02188069895', '021.88069895'):
+            self.assertEqual(self.processor.process(inp, language='en'), self.LANDLINE_EN, inp)
+        self.assertEqual(
+            self.processor.process('(021) 88069895', language='en'),
+            '(zero two one), eight eight, zero six, nine eight, nine five',
+        )
+
+    def test_us_style_english(self):
+        cases = {
+            '555-123-4567': 'five five five, one two three, four five six seven',
+            '555.123.4567': 'five five five, one two three, four five six seven',
+            '(555) 123-4567': '(five five five), one two three, four five six seven',
+            '1-555-123-4567': 'one, five five five, one two three, four five six seven',
+        }
+        for inp, correct in cases.items():
+            self.assertEqual(self.processor.process(inp, language='en'), correct, inp)
+        # plain spaces are not enough: this could be a list of numbers
+        self.assertEqual(self.processor.process('555 123 4567', language='en'), '555 123 4567')
+
+    def test_persian_digits_and_persian_output(self):
+        cases = {
+            '۰۹۱۲۴۳۳۸۱۳۵': self.MOBILE_FA,
+            '۰۹۱۲-۴۳۳-۸۱۳۵': self.MOBILE_FA,
+            '+۹۸۹۱۲۴۳۳۸۱۳۵': self.MOBILE_PLUS_FA,
+            '+۹۸-۹۱۲-۴۳۳۸۱۳۵': self.MOBILE_PLUS_FA,
+            '۰۲۱-۸۸۰۶۹۸۹۵': self.LANDLINE_FA,
+            '٠٩١٢٤٣٣٨١٣٥': self.MOBILE_FA,
+            '09124338135': self.MOBILE_FA,
+            '+989124338135': self.MOBILE_PLUS_FA,
+            '021-88069895': self.LANDLINE_FA,
+        }
+        for inp, correct in cases.items():
+            self.assertEqual(self.processor.process(inp, language='fa'), correct, inp)
+        self.assertEqual(
+            self.processor.process('(۰۲۱) ۸۸۰۶۹۸۹۵', language='fa'),
+            '(صفر بیست و یک)، هشتاد و هشت، صفر شش، نود و هشت، نود و پنج',
+        )
+
+    def test_persian_reads_iranian_numbers_in_groups(self):
+        cases = {
+            '۰۹۱۲۴۳۳۸۱۳۵': 'صفر نهصد و دوازده، چهارصد و سی و سه، هشتاد و یک، سی و پنج',
+            '09124338135': 'صفر نهصد و دوازده، چهارصد و سی و سه، هشتاد و یک، سی و پنج',
+            '02188037395': 'صفر بیست و یک، هشتاد و هشت، صفر سه، هفتاد و سه، نود و پنج',
+            '۰۲۱-۸۸۰۳۷۳۹۵': 'صفر بیست و یک، هشتاد و هشت، صفر سه، هفتاد و سه، نود و پنج',
+            '۰۴۱۳۱۲۳۴۵۶۷': 'صفر چهل و یک، سی و یک، بیست و سه، چهل و پنج، شصت و هفت',
+            # a leading zero inside a group is said on its own
+            '۰۹۱۲۰۰۰۰۵۰۸': 'صفر نهصد و دوازده، سه صفر، صفر پنج، صفر هشت',
+        }
+        for inp, correct in cases.items():
+            self.assertEqual(self.processor.process(inp, language='fa'), correct, inp)
+
+    def test_persian_counts_repeated_leading_zeros(self):
+        cases = {
+            '۰۲۱-۸۸۵۲۳۰۰۶': 'صفر بیست و یک، هشتاد و هشت، پنجاه و دو، سی، صفر شش',
+            '۰۰۱-۸۸۵۲۳۰۰۶': 'دو صفر یک، هشتاد و هشت، پنجاه و دو، سی، صفر شش',
+            '00188523006': 'دو صفر یک، هشتاد و هشت، پنجاه و دو، سی، صفر شش',
+            '001 88 52 30 06': 'دو صفر یک، هشتاد و هشت، پنجاه و دو، سی، صفر شش',
+        }
+        for inp, correct in cases.items():
+            self.assertEqual(self.processor.process(inp, language='fa'), correct, inp)
+
+    def test_english_reads_the_same_groups_for_a_zero_area_code(self):
+        self.assertEqual(
+            self.processor.process('۰۰۱-۸۸۵۲۳۰۰۶', language='en'),
+            'zero zero one, eight eight, five two, three zero, zero six',
+        )
+
+    def test_persian_international_iranian_numbers(self):
+        cases = {
+            '+989124338135': 'مثبت نود و هشت، نهصد و دوازده، چهارصد و سی و سه، هشتاد و یک، سی و پنج',
+            '+98-912-4338135': 'مثبت نود و هشت، نهصد و دوازده، چهارصد و سی و سه، هشتاد و یک، سی و پنج',
+            '+98 21 88037395': 'مثبت نود و هشت، بیست و یک، هشتاد و هشت، صفر سه، هفتاد و سه، نود و پنج',
+            '0098 912 4338135': 'دو صفر نود و هشت، نهصد و دوازده، چهارصد و سی و سه، هشتاد و یک، سی و پنج',
+            '(+98) 912 4338135': '(مثبت نود و هشت)، نهصد و دوازده، چهارصد و سی و سه، هشتاد و یک، سی و پنج',
+            '(021) 88037395': '(صفر بیست و ی��)، هشتاد و هشت، صفر سه، هفتاد و سه، نود و پنج',
+        }
+        for inp, correct in cases.items():
+            self.assertEqual(self.processor.process(inp, language='fa'), correct, inp)
+
+    def test_persian_reads_other_numbers_digit_by_digit(self):
+        cases = {
+            '+44 20 7946 0958': 'مثبت چهار چهار دو صفر هفت نه چهار شش صفر نه پنج هشت',
+            '555-123-4567': 'پنج پنج پنج یک دو سه چهار پنج شش هفت',
+            '0012345678': 'صفر صفر یک دو سه چهار پنج شش هفت هشت',
+        }
+        for inp, correct in cases.items():
+            self.assertEqual(self.processor.process(inp, language='fa'), correct, inp)
+
+    def test_english_reads_iranian_numbers_in_groups_with_pauses(self):
+        cases = {
+            '09124338135': 'zero nine one two, four three three, eight one, three five',
+            '02188037395': 'zero two one, eight eight, zero three, seven three, nine five',
+            '+989124338135': 'plus nine eight, nine one two, four three three, eight one, three five',
+            '+98 21 88037395': 'plus nine eight, two one, eight eight, zero three, seven three, nine five',
+            '0098 912 4338135': 'zero zero nine eight, nine one two, four three three, eight one, three five',
+            '(021) 88037395': '(zero two one), eight eight, zero three, seven three, nine five',
+        }
+        for inp, correct in cases.items():
+            self.assertEqual(self.processor.process(inp, language='en'), correct, inp)
+
+    def test_english_other_numbers_use_the_written_groups(self):
+        cases = {
+            '+44 20 7946 0958': 'plus four four, two zero, seven nine four six, zero nine five eight',
+            '+1 (555) 123-4567': 'plus one, (five five five), one two three, four five six seven',
+            # no written groups: nothing to pause on
+            '+441234567890': 'plus four four one two three four five six seven eight nine zero',
+            '0012345678': 'zero zero one two three four five six seven eight',
+        }
+        for inp, correct in cases.items():
+            self.assertEqual(self.processor.process(inp, language='en'), correct, inp)
+
+    def test_no_space_needed_after_a_closing_parenthesis(self):
+        for inp in ('(0915) 6486320', '(0915)6486320'):
+            self.assertEqual(
+                self.processor.process(inp, language='en'),
+                '(zero nine one five), six four eight, six three, two zero',
+                inp,
+            )
+        cases_en = {
+            '(021)88069895': '(zero two one), eight eight, zero six, nine eight, nine five',
+            '(+98)9124338135': '(plus nine eight), nine one two, four three three, eight one, three five',
+            '(555)123-4567': '(five five five), one two three, four five six seven',
+            'Call (0915)6486320, ok': 'Call (zero nine one five), six four eight, six three, two zero, ok',
+            '(0915)6486320 and (021)88069895': (
+                '(zero nine one five), six four eight, six three, two zero and '
+                '(zero two one), eight eight, zero six, nine eight, nine five'
+            ),
+        }
+        for inp, correct in cases_en.items():
+            self.assertEqual(self.processor.process(inp, language='en'), correct, inp)
+
+        cases_fa = {
+            '(۰۹۱۵)۶۴۸۶۳۲۰': '(صفر نهصد و پانزده)، ششصد و چهل و هشت، شصت و سه، بیست',
+            '(۰۹۱۵) ۶۴۸۶۳۲۰': '(صفر نهصد و پانزده)، ششصد و چهل و هشت، شصت و سه، بیست',
+            '(021)۸۸۰۶۹۸۹۵': '(صفر بیست و یک)، هشتاد و هشت، صفر شش، نود و هشت، نود و پنج',
+        }
+        for inp, correct in cases_fa.items():
+            self.assertEqual(self.processor.process(inp, language='fa'), correct, inp)
+
+    def test_parentheses_without_a_phone_number_are_unchanged(self):
+        for inp in ('(1)23456789', '(2)(3)', '5 (kg)12', '(12)34'):
+            self.assertEqual(self.processor.process(inp, language='en'), inp, inp)
+
+    def test_numbers_inside_sentences(self):
+        self.assertEqual(
+            self.processor.process('Call me at 09124338135.', language='en'),
+            f'Call me at {self.MOBILE_EN}.',
+        )
+        self.assertEqual(
+            self.processor.process('Call 09124338135, then 021-88069895.', language='en'),
+            f'Call {self.MOBILE_EN}, then {self.LANDLINE_EN}.',
+        )
+        self.assertEqual(
+            self.processor.process('(+98 912 4338135)', language='en'),
+            '(plus nine eight, nine one two, four three three, eight one, three five)',
+        )
+        self.assertEqual(
+            self.processor.process('شماره من ۰۹۱۲۴۳۳۸۱۳۵ است', language='fa'),
+            f'شماره من {self.MOBILE_FA} است',
+        )
+        self.assertEqual(
+            self.processor.process('تماس: ۰۲۱-۸۸۰۶۹۸۹۵ و ۰۹۱۲۴۳۳۸۱۳۵', language='fa'),
+            f'تماس: {self.LANDLINE_FA} و {self.MOBILE_FA}',
+        )
+        self.assertEqual(
+            self.processor.process('In 2024 0912 433 8135', language='en'),
+            f'In 2024 {self.MOBILE_EN}',
+        )
+
+    def test_number_after_a_phone_word_may_be_shorter(self):
+        self.assertEqual(
+            self.processor.process('tel: 88069895', language='en'),
+            'tel: eight eight, zero six, nine eight, nine five',
+        )
+        self.assertEqual(
+            self.processor.process('Phone number 4338135', language='en'),
+            'Phone number four three three eight one three five',
+        )
+        self.assertEqual(
+            self.processor.process('تلفن: ۸۸۰۶۹۸۹۵', language='fa'),
+            'تلفن: هشتاد و هشت، صفر شش، نود و هشت، نود و پنج',
+        )
+        self.assertEqual(
+            self.processor.process('Call 1-800-555-1234', language='en'),
+            'Call one, eight zero zero, five five five, one two three four',
+        )
+        # too short, or no phone word: unchanged
+        for inp in ('call 911', 'call 5 times', '4338135', 'Tel 123456'):
+            self.assertEqual(self.processor.process(inp, language='en'), inp, inp)
+        self.assertEqual(self.processor.process('شماره 5', language='fa'), 'شماره 5')
+
+    def test_language_comes_from_digits_when_there_are_no_letters(self):
+        for language in (None, 'Unknown / No letters found'):
+            self.assertEqual(self.processor.process('09124338135', language=language), self.MOBILE_EN)
+            self.assertEqual(self.processor.process('۰۹۱۲۴۳۳۸۱۳۵', language=language), self.MOBILE_FA)
+
+    def test_not_a_phone_number_is_unchanged(self):
+        inputs = [
+            '4338135', '9124338135', '123456', '2024-05-10', '2024/05/10', '01-02-2024',
+            '01.02.2024', '0.123456789', '3.0912433813', '0912433813.5', '0912433813.55',
+            '09124338135abc', 'a09124338135', 'https://x.com/09124338135',
+            'user09124338135@mail.com', '1234 5678 9012 3456', '0912 433', '0912',
+            '021-88069895-12', '5 - 3', '1990 - 2000', '10:30', '1,000,000', 'hello',
+        ]
+        for inp in inputs:
+            self.assertEqual(self.processor.process(inp, language='en'), inp, inp)
+
+    def test_ten_digit_zero_prefixed_id_is_read_digit_by_digit(self):
+        self.assertEqual(
+            self.processor.process('0012345678', language='en'),
+            'zero zero one two three four five six seven eight',
+        )
+
+    def test_unsupported_language_is_unchanged(self):
+        for language in ('mixed', 'de'):
+            self.assertEqual(self.processor.process('09124338135', language=language), '09124338135')
+
+    def test_epsilon_zero_disables_processor(self):
+        processor = PhoneNumberProcessor(epsilon=0.0)
+        outputs = {processor.process('09124338135', language='en') for _ in range(50)}
+        self.assertEqual(outputs, {'09124338135'})
+
+
+class CardNumberProcessorTestCase(unittest.TestCase):
+    def setUp(self):
+        self.processor = CardNumberProcessor()
+
+    def assertFa(self, text, expected):
+        self.assertEqual(self.processor.process(text, language='fa'), expected)
+
+    def assertEn(self, text, expected):
+        self.assertEqual(self.processor.process(text, language='en'), expected)
+
+    # Persian
+    def test_persian_card_with_hyphens(self):
+        self.assertFa(
+            '۶۲۱۹ - ۸۷۶۵ - ۲۳۴۵ - ۹۰۳۱',
+            'شصت و دو، نوزده - هشتاد و هفت، شصت و پنج - بیست و سه، چهل و پنج - نود، سی و یک',
+        )
+
+    def test_persian_card_with_tight_hyphens_spaces_and_no_separator(self):
+        expected = 'شصت و دو، نوزده - هشتاد و هفت، شصت و پنج - بیست و سه، چهل و پنج - نود، سی و یک'
+        for text in ('۶۲۱۹-۸۷۶۵-۲۳۴۵-۹۰۳۱', '۶۲۱۹ ۸۷۶۵ ۲۳۴۵ ۹۰۳۱', '۶۲۱۹۸۷۶۵۲۳۴۵۹۰۳۱'):
+            self.assertFa(text, expected)
+
+    def test_persian_card_with_ascii_digits(self):
+        self.assertFa(
+            '6219 8765 2345 9031',
+            'شصت و دو، نوزده - هشتاد و هفت، شصت و پنج - بیست و سه، چهل و پنج - نود، سی و یک',
+        )
+
+    def test_persian_card_in_sentence(self):
+        self.assertFa(
+            'شماره کارت ۶۲۱۹ ۸۷۶۵ ۲۳۴۵ ۹۰۳۱ است',
+            'شماره کارت شصت و دو، نوزده - هشتاد و هفت، شصت و پنج - بیست و سه، چهل و پنج - نود، سی و یک است',
+        )
+
+    def test_persian_zero_pairs(self):
+        result = self.processor.process('۶۰۰۵ ۱۲۰۰ ۳۴۵۶ ۷۸۹۰', language='fa')
+        self.assertIn('صفر پنج', result)
+        self.assertIn('دو صفر', result)
+
+    # English
+    def test_english_card_with_spaces(self):
+        self.assertEn(
+            '4111 1111 1111 1111',
+            'forty-one, eleven - eleven, eleven - eleven, eleven - eleven, eleven',
+        )
+
+    def test_english_card_with_hyphens(self):
+        self.assertEn(
+            '5105-1051-0510-5100',
+            'fifty-one, oh five - ten, fifty-one - oh five, ten - fifty-one, double zero',
+        )
+
+    def test_english_card_without_separators(self):
+        self.assertEn(
+            '6219876523459031',
+            'sixty-two, nineteen - eighty-seven, sixty-five - twenty-three, forty-five - ninety, thirty-one',
+        )
+
+    def test_english_card_in_sentence(self):
+        self.assertEn(
+            'My card is 4111 1111 1111 1111 ok',
+            'My card is forty-one, eleven - eleven, eleven - eleven, eleven - eleven, eleven ok',
+        )
+
+    def test_english_card_with_persian_digits(self):
+        self.assertEn(
+            '۴۱۱۱ ۱۱۱۱ ۱۱۱۱ ۱۱۱۱',
+            'forty-one, eleven - eleven, eleven - eleven, eleven - eleven, eleven',
+        )
+
+    # Language detection
+    def test_language_detected_from_digits(self):
+        self.assertEqual(
+            self.processor.process('۶۲۱۹ ۸۷۶۵ ۲۳۴۵ ۹۰۳۱'),
+            'شصت و دو، نوزده - هشتاد و هفت، شصت و پنج - بیست و سه، چهل و پنج - نود، سی و یک',
+        )
+        self.assertEqual(
+            self.processor.process('4111 1111 1111 1111'),
+            'forty-one, eleven - eleven, eleven - eleven, eleven - eleven, eleven',
+        )
+
+    # Left alone
+    def test_non_cards_are_unchanged(self):
+        for text in (
+            '6219-****-****-9031',
+            '6219 8765 2345 9031.5',
+            '6219 8765 2345',
+            '6219 8765 2345 9031 1234',
+            '3782 822463 10005',
+            '09124338135',
+            'abc6219876523459031',
+        ):
+            self.assertEqual(self.processor.process(text, language='en'), text)
+
+    def test_any_first_digit_is_accepted(self):
+        self.assertEn(
+            '1234 5678 9012 3456',
+            'twelve, thirty-four - fifty-six, seventy-eight - ninety, twelve - thirty-four, fifty-six',
+        )
+        self.assertEn(
+            '0912 4338 1350 0000',
+            'oh nine, twelve - forty-three, thirty-eight - thirteen, fifty - double zero, double zero',
+        )
+        self.assertEn(
+            '8123 4567 8901 2345',
+            'eighty-one, twenty-three - forty-five, sixty-seven - eighty-nine, oh one - twenty-three, forty-five',
+        )
+
+    def test_unsupported_language_is_unchanged(self):
+        for language in ('mixed', 'de'):
+            self.assertEqual(
+                self.processor.process('4111 1111 1111 1111', language=language), '4111 1111 1111 1111')
+
+    def test_epsilon_zero_disables_processor(self):
+        processor = CardNumberProcessor(epsilon=0.0)
+        outputs = {processor.process('4111 1111 1111 1111', language='en') for _ in range(50)}
+        self.assertEqual(outputs, {'4111 1111 1111 1111'})
+
+    # Through the Normalizer
+    def test_normalizer_reads_card_not_phone(self):
+        normalizer = Normalizer()
+        self.assertEqual(
+            normalizer.process('شماره کارت ۶۲۱۹ ۸۷۶۵ ۲۳۴۵ ۹۰۳۱ است'),
+            'شماره کارت شصت و دو، نوزده - هشتاد و هفت، شصت و پنج - بیست و سه، چهل و پنج - نود، سی و یک است',
+        )
+        self.assertEqual(
+            normalizer.process('My card is 4111 1111 1111 1111 ok'),
+            'My card is forty-one, eleven - eleven, eleven - eleven, eleven - eleven, eleven ok',
+        )
+
+
+class PostalCodeAndNationalIdProcessorTestCase(unittest.TestCase):
+    def setUp(self):
+        self.processor = PostalCodeAndNationalIdProcessor()
+
+    def assertFa(self, text, expected):
+        self.assertEqual(self.processor.process(text, language='fa'), expected)
+
+    def assertEn(self, text, expected):
+        self.assertEqual(self.processor.process(text, language='en'), expected)
+
+    # Persian
+    def test_persian_postal_code(self):
+        self.assertFa('۱۵۱۴۷۱۷۱۱۸', 'پانزده، چهارده، هفتاد و یک، هفتاد و یک، هجده')
+
+    def test_persian_postal_code_with_ascii_digits(self):
+        self.assertFa('1514717118', 'پانزده، چهارده، هفتاد و یک، هفتاد و یک، هجده')
+
+    def test_persian_postal_code_split_in_two_halves(self):
+        expected = 'پانزده، چهارده، هفتاد و یک، هفتاد و یک، هجده'
+        for text in ('۱۵۱۴۷-۱۷۱۱۸', '۱۵۱۴۷ ۱۷۱۱۸', '۱۵۱۴۷ - ۱۷۱۱۸'):
+            self.assertFa(text, expected)
+
+    def test_persian_postal_code_in_sentence(self):
+        self.assertFa(
+            'کد پستی ۱۵۱۴۷۱۷۱۱۸ است',
+            'کد پستی پانزده، چهارده، هفتاد و یک، هفتاد و یک، هجده است',
+        )
+
+    def test_persian_zero_pairs(self):
+        result = self.processor.process('۱۵۱۴۷۰۰۰۰۵', language='fa')
+        self.assertIn('دو صفر', result)
+        self.assertIn('صفر پنج', result)
+
+    # English
+    def test_english_postal_code(self):
+        self.assertEn('1514717118', 'fifteen, fourteen, seventy-one, seventy-one, eighteen')
+
+    def test_english_postal_code_split_in_two_halves(self):
+        self.assertEn('15147-17118', 'fifteen, fourteen, seventy-one, seventy-one, eighteen')
+
+    def test_english_postal_code_with_persian_digits(self):
+        self.assertEn('۱۵۱۴۷۱۷۱۱۸', 'fifteen, fourteen, seventy-one, seventy-one, eighteen')
+
+    def test_english_postal_code_in_sentence(self):
+        self.assertEn(
+            'Postal code 1514717118 ok',
+            'Postal code fifteen, fourteen, seventy-one, seventy-one, eighteen ok',
+        )
+
+    def test_english_zero_pairs(self):
+        self.assertEn('1514700508', 'fifteen, fourteen, seventy, oh five, oh eight')
+        self.assertEn('1514700018', 'fifteen, fourteen, seventy, double zero, eighteen')
+
+    # National ID numbers
+    def test_persian_national_id_with_leading_zeros(self):
+        self.assertFa('۰۰۱۲۳۴۵۶۷۹', 'دو صفر، دوازده، سی و چهار، پنجاه و شش، هفتاد و نه')
+
+    def test_english_national_id_with_leading_zeros(self):
+        self.assertEn('0012345679', 'double zero, twelve, thirty-four, fifty-six, seventy-nine')
+
+    def test_national_id_with_one_leading_zero(self):
+        self.assertEn('0499370899', 'oh four, ninety-nine, thirty-seven, oh eight, ninety-nine')
+        self.assertFa('۰۴۹۹۳۷۰۸۹۹', 'صفر چهار، نود و نه، سی و هفت، صفر هشت، نود و نه')
+
+    def test_national_id_with_hyphens_3_6_1(self):
+        self.assertEn('001-234567-9', 'double zero, twelve, thirty-four, fifty-six, seventy-nine')
+        self.assertFa('۰۰۱-۲۳۴۵۶۷-۹', 'دو صفر، دوازده، سی و چهار، پنجاه و شش، هفتاد و نه')
+
+    def test_national_id_in_sentence(self):
+        self.assertFa(
+            'کد ملی ۰۰۱۲۳۴۵۶۷۹ را وارد کنید',
+            'کد ملی دو صفر، دوازده، سی و چهار، پنجاه و شش، هفتاد و نه را وارد کنید',
+        )
+        self.assertEn(
+            'National ID 0012345679 is valid',
+            'National ID double zero, twelve, thirty-four, fifty-six, seventy-nine is valid',
+        )
+
+    def test_invalid_national_id_is_unchanged(self):
+        for text in (
+            '0012345678',      # wrong check digit
+            '001-234567-8',    # wrong check digit, hyphenated layout
+            '0000000000',      # all the same digit (passes the checksum but is not a real ID)
+        ):
+            self.assertEn(text, text)
+
+    def test_hyphenated_3_6_1_layout_needs_valid_check_digit(self):
+        # Passes the postal-code rule when written as 5 + 5, but 3 + 6 + 1 is a national ID layout only.
+        self.assertEn('151-471711-8', '151-471711-8')
+
+    # Language detection
+    def test_language_detected_from_digits(self):
+        self.assertEqual(
+            self.processor.process('۱۵۱۴۷۱۷۱۱۸'),
+            'پانزده، چهارده، هفتاد و یک، هفتاد و یک، هجده',
+        )
+        self.assertEqual(
+            self.processor.process('1514717118'),
+            'fifteen, fourteen, seventy-one, seventy-one, eighteen',
+        )
+
+    # Left alone
+    def test_non_identifiers_are_unchanged(self):
+        for text in (
+            '9124338135',      # phone number without the leading zero (a 2 in the first five)
+            '1234567890',      # a 0 or 2 in the first five digits
+            '0514717118',      # starts with 0
+            '15147171189',     # 11 digits
+            '151471711',       # 9 digits
+            '1514717118.5',    # decimal
+            '1514 7171 18',    # wrong grouping
+            'abc1514717118',   # glued to a word
+        ):
+            self.assertEqual(self.processor.process(text, language='en'), text)
+
+    def test_card_number_is_not_read_as_postal_code(self):
+        self.assertEqual(self.processor.process('6219876523459031', language='en'), '6219876523459031')
+
+    def test_unsupported_language_is_unchanged(self):
+        for language in ('mixed', 'de'):
+            self.assertEqual(self.processor.process('1514717118', language=language), '1514717118')
+
+    def test_epsilon_zero_disables_processor(self):
+        processor = PostalCodeAndNationalIdProcessor(epsilon=0.0)
+        outputs = {processor.process('1514717118', language='en') for _ in range(50)}
+        self.assertEqual(outputs, {'1514717118'})
+
+    # Through the Normalizer
+    def test_normalizer_reads_postal_code(self):
+        normalizer = Normalizer()
+        self.assertEqual(
+            normalizer.process('کد پستی ۱۵۱۴۷۱۷۱۱۸ است'),
+            'کد پستی پانزده، چهارده، هفتاد و یک، هفتاد و یک، هجده است',
+        )
+        self.assertEqual(
+            normalizer.process('Postal code 1514717118 ok'),
+            'Postal code fifteen, fourteen, seventy-one, seventy-one, eighteen ok',
+        )
+
+    def test_normalizer_still_reads_phone_and_card(self):
+        normalizer = Normalizer()
+        self.assertEqual(
+            normalizer.process('call 09124338135'),
+            'call zero nine one two, four three three, eight one, three five',
+        )
+        self.assertIn('شصت و دو، نوزده', normalizer.process('کارت ۶۲۱۹ ۸۷۶۵ ۲۳۴۵ ۹۰۳۱'))
+
+
+if __name__ == '__main__':
+    unittest.main(verbosity=2)
\ No newline at end of file