bblaz/num2words
1
0
Fork 0
mirror of https://github.com/bblaz/num2words.git synced 2025-12-06 06:42:25 +00:00
Code Issues Packages Projects Releases Wiki Activity

Merge branch 'master' into master

Browse Source
This commit is contained in:
Pierre Duchemin
2019-12-31 15:28:12 -05:00
committed by GitHub
parent 4bd2f0259f ca33d8ba98
commit 82418b2612
22 changed files with 606 additions and 272 deletions
Download Patch File Download Diff File Expand all files Collapse all files

26
tests/test_base.py
View File

@@ -32,3 +32,29 @@ class Num2WordBaseTest(TestCase):
def test_to_currency_not_implemented(self):
with self.assertRaises(NotImplementedError):
self.base.to_currency(Decimal('1.00'), currency='EUR')
def test_error_to_cardinal_float(self):
from num2words.base import Num2Word_Base
with self.assertRaises(TypeError):
Num2Word_Base.to_cardinal_float(9)
with self.assertRaises(TypeError):
Num2Word_Base.to_cardinal_float("a")
def test_error_merge(self):
from num2words.base import Num2Word_Base
self.base = Num2Word_Base()
with self.assertRaises(NotImplementedError):
self.base.merge(2, 3)
def test_is_title(self):
from num2words.base import Num2Word_Base
self.base = Num2Word_Base()
self.assertEqual(
self.base.title("one"),
"one"
)
self.base.is_title = True
self.assertEqual(
self.base.title("one"),
"One"
)

2
tests/test_cli.py
View File

@@ -102,7 +102,7 @@ class CliTestCase(unittest.TestCase):
)
def test_cli_with_lang_to(self):
"""You should be able to specify a language
"""You should be able to specify a language and currency
"""
output = self.cli.run_cmd(150.55, '--lang', 'es', '--to', 'currency')
self.assertEqual(output.return_code, 0)

37
tests/test_dk.py Normal file
View File

@@ -0,0 +1,37 @@
# coding: utf-8
# Copyright (c) 2003, Taro Ogawa. All Rights Reserved.
# Copyright (c) 2013, Savoir-faire Linux inc. All Rights Reserved.
# This library is free software; you can redistribute it and/or
# modify it under the terms of the GNU Lesser General Public
# License as published by the Free Software Foundation; either
# version 2.1 of the License, or (at your option) any later version.
# This library is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
# Lesser General Public License for more details.
# You should have received a copy of the GNU Lesser General Public
# License along with this library; if not, write to the Free Software
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,
# MA 02110-1301 USA
from __future__ import unicode_literals
from unittest import TestCase
from num2words import num2words
class Num2WordsDKTest(TestCase):
def test_ordinal(self):
self.assertEqual(num2words(1, to="ordinal", lang="dk"), "første")
self.assertEqual(num2words(5, to="ordinal", lang="dk"), "femte")
def test_cardinal(self):
self.assertEqual(num2words(0, to="cardinal", lang="dk"), "nul")
self.assertEqual(num2words(1, to="cardinal", lang="dk"), "et")
self.assertEqual(num2words(2, to="cardinal", lang="dk"), "to")
self.assertEqual(num2words(5, to="cardinal", lang="dk"), "fem")
self.assertEqual(num2words(8, to="cardinal", lang="dk"), "otte")
self.assertEqual(num2words(18, to="cardinal", lang="dk"), "atten")
self.assertEqual(num2words(45, to="cardinal", lang="dk"), "femogfyrre")

8
tests/test_en.py
View File

@@ -26,10 +26,18 @@ class Num2WordsENTest(TestCase):
self.assertEqual(num2words(199), "one hundred and ninety-nine")
def test_ordinal(self):
self.assertEqual(
num2words(0, lang='en', to='ordinal'),
'zeroth'
)
self.assertEqual(
num2words(1, lang='en', to='ordinal'),
'first'
)
self.assertEqual(
num2words(13, lang='en', to='ordinal'),
'thirteenth'
)
self.assertEqual(
num2words(22, lang='en', to='ordinal'),
'twenty-second'

29
tests/test_errors.py Normal file
View File

@@ -0,0 +1,29 @@
# -*- coding: utf-8 -*-
# Copyright (c) 2003, Taro Ogawa. All Rights Reserved.
# Copyright (c) 2013, Savoir-faire Linux inc. All Rights Reserved.
# This library is free software; you can redistribute it and/or
# modify it under the terms of the GNU Lesser General Public
# License as published by the Free Software Foundation; either
# version 2.1 of the License, or (at your option) any later version.
# This library is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
# Lesser General Public License for more details.
# You should have received a copy of the GNU Lesser General Public
# License along with this library; if not, write to the Free Software
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,
# MA 02110-1301 USA
from __future__ import unicode_literals
from unittest import TestCase
from num2words import num2words
class Num2WordsErrorsTest(TestCase):
def test_NotImplementedError(self):
with self.assertRaises(NotImplementedError):
num2words(100, lang="lalala")

1
tests/test_es.py
View File

@@ -95,6 +95,7 @@ TEST_CASES_ORDINAL = (
(28, 'vigésimo octavo'),
(100, 'centésimo'),
(1000, 'milésimo'),
(12345, 'docemilésimo tricentésimo quadragésimo quinto'),
(1000000, 'millonésimo'),
(1000000000000000, 'cuadrillonésimo'),
(1000000000000000000, 'un trillón') # over 1e18 is not supported

42
tests/test_es_ni.py Normal file
View File

@@ -0,0 +1,42 @@
# -*- coding: utf-8 -*-
# Copyright (c) 2003, Taro Ogawa. All Rights Reserved.
# Copyright (c) 2013, Savoir-faire Linux inc. All Rights Reserved.
# This library is free software; you can redistribute it and/or
# modify it under the terms of the GNU Lesser General Public
# License as published by the Free Software Foundation; either
# version 2.1 of the License, or (at your option) any later version.
# This library is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
# Lesser General Public License for more details.
# You should have received a copy of the GNU Lesser General Public
# License along with this library; if not, write to the Free Software
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,
# MA 02110-1301 USA
from __future__ import unicode_literals
from num2words import num2words
from . import test_es
TEST_NIO = (
(1.0, 'un córdoba con cero centavos'),
(2.0, 'dos córdobas con cero centavos'),
(8.0, 'ocho córdobas con cero centavos'),
(12.0, 'doce córdobas con cero centavos'),
(21.0, 'veintiun córdobas con cero centavos'),
(81.25, 'ochenta y un córdobas con veinticinco centavos'),
(100.00, 'cien córdobas con cero centavos'),
)
class Num2WordsESNITest(test_es.Num2WordsESTest):
def test_currency(self):
for test in TEST_NIO:
self.assertEqual(
num2words(test[0], lang='es_NI', to='currency'),
test[1]
)

73
tests/test_he.py Normal file
View File

@@ -0,0 +1,73 @@
# -*- coding: utf-8 -*-
# Copyright (c) 2003, Taro Ogawa. All Rights Reserved.
# Copyright (c) 2013, Savoir-faire Linux inc. All Rights Reserved.
# This library is free software; you can redistribute it and/or
# modify it under the terms of the GNU Lesser General Public
# License as published by the Free Software Foundation; either
# version 2.1 of the License, or (at your option) any later version.
# This library is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
# Lesser General Public License for more details.
# You should have received a copy of the GNU Lesser General Public
# License along with this library; if not, write to the Free Software
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,
# MA 02110-1301 USA
from __future__ import unicode_literals
from unittest import TestCase
from num2words import num2words
class Num2WordsHETest(TestCase):
maxDiff = None
def test_0(self):
self.assertEqual(num2words(0, lang="he"), u'אפס')
def test_1_to_10(self):
self.assertEqual(num2words(1, lang="he"), u'אחת')
self.assertEqual(num2words(2, lang="he"), u'שתים')
self.assertEqual(num2words(7, lang="he"), u'שבע')
self.assertEqual(num2words(10, lang="he"), u'עשר')
def test_11_to_19(self):
self.assertEqual(num2words(11, lang="he"), u'אחת עשרה')
self.assertEqual(num2words(13, lang="he"), u'שלש עשרה')
self.assertEqual(num2words(15, lang="he"), u'חמש עשרה')
self.assertEqual(num2words(16, lang="he"), u'שש עשרה')
self.assertEqual(num2words(19, lang="he"), u'תשע עשרה')
def test_20_to_99(self):
self.assertEqual(num2words(20, lang="he"), u'עשרים')
self.assertEqual(num2words(23, lang="he"), u'עשרים ושלש')
self.assertEqual(num2words(28, lang="he"), u'עשרים ושמונה')
self.assertEqual(num2words(31, lang="he"), u'שלשים ואחת')
self.assertEqual(num2words(40, lang="he"), u'ארבעים')
self.assertEqual(num2words(66, lang="he"), u'ששים ושש')
self.assertEqual(num2words(92, lang="he"), u'תשעים ושתים')
def test_100_to_999(self):
self.assertEqual(num2words(100, lang="he"), u'מאה')
self.assertEqual(num2words(111, lang="he"), u'מאה ואחת עשרה')
self.assertEqual(num2words(150, lang="he"), u'מאה וחמישים')
self.assertEqual(num2words(196, lang="he"), u'מאה תשעים ושש')
self.assertEqual(num2words(200, lang="he"), u'מאתיים')
self.assertEqual(num2words(210, lang="he"), u'מאתיים ועשר')
self.assertEqual(num2words(701, lang="he"), u'שבע מאות ואחת')
def test_1000_to_9999(self):
self.assertEqual(num2words(1000, lang="he"), u'אלף')
self.assertEqual(num2words(1001, lang="he"), u'אלף ואחת')
self.assertEqual(num2words(1500, lang="he"), u'אלף וחמש מאות')
self.assertEqual(
num2words(7378, lang="he"), u'שבעת אלפים שלש מאות שבעים ושמונה'
)
self.assertEqual(num2words(2000, lang="he"), u'אלפיים')
self.assertEqual(num2words(2100, lang="he"), u'אלפיים ומאה')
self.assertEqual(
num2words(6870, lang="he"), u'ששת אלפים שמונה מאות ושבעים'
)

7
tests/test_it.py
View File

@@ -78,6 +78,7 @@ class Num2WordsITTest(TestCase):
def test_20_to_99(self):
self.assertEqual(num2words(20, lang="it"), "venti")
self.assertEqual(num2words(21, lang="it"), "ventuno")
self.assertEqual(num2words(23, lang="it"), "ventitré")
self.assertEqual(num2words(28, lang="it"), "ventotto")
self.assertEqual(num2words(31, lang="it"), "trentuno")
@@ -154,6 +155,9 @@ class Num2WordsITTest(TestCase):
def test_nth_1_to_99(self):
self.assertEqual(num2words(1, lang="it", ordinal=True), "primo")
self.assertEqual(num2words(8, lang="it", ordinal=True), "ottavo")
self.assertEqual(
num2words(21, lang="it", ordinal=True), "ventunesimo"
)
self.assertEqual(
num2words(23, lang="it", ordinal=True), "ventitreesimo"
)
@@ -172,6 +176,9 @@ class Num2WordsITTest(TestCase):
self.assertEqual(
num2words(120, lang="it", ordinal=True), "centoventesimo"
)
self.assertEqual(
num2words(121, lang="it", ordinal=True), "centoventunesimo"
)
self.assertEqual(
num2words(316, lang="it", ordinal=True), "trecentosedicesimo"
)

40
tests/test_ro.py
View File

@@ -103,7 +103,7 @@ class Num2WordsROTest(TestCase):
)
self.assertEqual(
num2words(247000000000, lang="ro"),
u"două sute patruzeci și șapte miliarde"
u"două sute patruzeci și șapte de miliarde"
)
def test_overflow(self):
@@ -117,23 +117,45 @@ class Num2WordsROTest(TestCase):
def test_to_currency(self):
self.assertEqual(
num2words(38.4, lang='ro', to='currency'),
u'treizeci și opt lei și patruzeci bani'
num2words(1000, lang='ro', to='currency'),
u'una mie de lei'
)
self.assertEqual(
num2words(101, lang='ro', to='currency'),
u'una sută unu lei'
)
self.assertEqual(
num2words(100, lang='ro', to='currency'),
u'una sută de lei'
)
self.assertEqual(
num2words(38.4, lang='ro', to='currency'),
u'treizeci și opt de lei și patruzeci de bani'
)
self.assertEqual(
num2words(1.01, lang='ro', to='currency'),
u'un leu și un ban'
)
self.assertEqual(
num2words(4778.00, lang='ro', to='currency'),
u'patru mii șapte sute șaptezeci și opt lei')
u'patru mii șapte sute șaptezeci și opt de lei')
self.assertEqual(
num2words(4778.32, lang='ro', to='currency'),
u'patru mii șapte sute șaptezeci și opt lei'
u' și treizeci și doi bani')
u'patru mii șapte sute șaptezeci și opt de lei'
u' și treizeci și doi de bani')
self.assertEqual(
num2words(1207, lang='ro', to='currency'),
u'una mie două sute șapte lei')
self.assertEqual(
num2words(22000, lang='ro', to='currency'),
u'douăzeci și două de mii de lei')
self.assertEqual(
num2words(80000, lang='ro', to='currency'),
u'optzeci de mii de lei')
self.assertEqual(
num2words(123456789, lang='ro', to='currency'),
u'una sută douăzeci și trei milioane patru sute '
u'cincizeci și șase de mii șapte sute optzeci și nouă de lei')
def test_to_year(self):
self.assertEqual(num2words(1989, lang='ro', to='year'),

331
tests/test_tr.py
View File

@@ -24,171 +24,168 @@ from num2words import num2words
class Num2WordsTRTest(TestCase):
def test_tr(self):
# ref https://github.com/savoirfairelinux/num2words/issues/8
testlang = "tr"
testcases = [
{"test": 0, "to": "currency", "expected": u"bedelsiz"},
{"test": 1.1, "to": "currency", "expected": u"birliraonkuruş"},
{"test": 2000, "to": "currency", "expected": u"ikibinlira"},
{"test": 110000, "to": "currency", "expected": u"yüzonbinlira"},
{"test": 1002000, "to": "currency",
"expected": u"birmilyonikibinlira"},
{"test": 1002001, "to": "currency",
"expected": u"birmilyonikibinbirlira"},
{"test": 1100000, "to": "currency",
"expected": u"birmilyonyüzbinlira"},
{"test": 1, "to": "ordinal", "expected": u"birinci"},
{"test": 2, "to": "ordinal", "expected": u"ikinci"},
{"test": 9, "to": "ordinal", "expected": u"dokuzuncu"},
{"test": 10, "to": "ordinal", "expected": u"onuncu"},
{"test": 11, "to": "ordinal", "expected": u"onbirinci"},
{"test": 44, "to": "ordinal", "expected": u"kırkdördüncü"},
{"test": 100, "to": "ordinal", "expected": u"yüzüncü"},
{"test": 101, "to": "ordinal", "expected": u"yüzbirinci"},
{"test": 103, "to": "ordinal", "expected": u"yüzüçüncü"},
{"test": 110, "to": "ordinal", "expected": u"yüzonuncu"},
{"test": 111, "to": "ordinal", "expected": u"yüzonbirinci"},
{"test": 1000, "to": "ordinal", "expected": u"bininci"},
{"test": 1001, "to": "ordinal", "expected": u"binbirinci"},
{"test": 1010, "to": "ordinal", "expected": u"binonuncu"},
{"test": 1011, "to": "ordinal", "expected": u"binonbirinci"},
{"test": 1100, "to": "ordinal", "expected": u"binyüzüncü"},
{"test": 1110, "to": "ordinal", "expected": u"binyüzonuncu"},
{"test": 2341, "to": "ordinal",
"expected": u"ikibinüçyüzkırkbirinci"},
{"test": 10000, "to": "ordinal", "expected": u"onbininci"},
{"test": 10010, "to": "ordinal", "expected": u"onbinonuncu"},
{"test": 10100, "to": "ordinal", "expected": u"onbinyüzüncü"},
{"test": 10110, "to": "ordinal", "expected": u"onbinyüzonuncu"},
{"test": 11000, "to": "ordinal", "expected": u"onbirbininci"},
{"test": 35000, "to": "ordinal", "expected": u"otuzbeşbininci"},
{"test": 116331, "to": "ordinal",
"expected": u"yüzonaltıbinüçyüzotuzbirinci"},
{"test": 116330, "to": "ordinal",
"expected": u"yüzonaltıbinüçyüzotuzuncu"},
{"test": 100000, "to": "ordinal", "expected": u"yüzbininci"},
{"test": 501000, "to": "ordinal",
"expected": u"beşyüzbirbininci"},
{"test": 1000111, "to": "ordinal",
"expected": u"birmilyonyüzonbirinci"},
{"test": 111000111, "to": "ordinal",
"expected": u"yüzonbirmilyonyüzonbirinci"},
{"test": 111001111, "to": "ordinal",
"expected": u"yüzonbirmilyonbinyüzonbirinci"},
{"test": 111111111, "to": "ordinal",
"expected": u"yüzonbirmilyonyüzonbirbinyüzonbirinci"},
{"test": 100001000, "to": "ordinal",
"expected": u"yüzmilyonbininci"},
{"test": 100001001, "to": "ordinal",
"expected": u"yüzmilyonbinbirinci"},
{"test": 100010000, "to": "ordinal",
"expected": u"yüzmilyononbininci"},
{"test": 100010001, "to": "ordinal",
"expected": u"yüzmilyononbinbirinci"},
{"test": 100011000, "to": "ordinal",
"expected": u"yüzmilyononbirbininci"},
{"test": 100011001, "to": "ordinal",
"expected": u"yüzmilyononbirbinbirinci"},
{"test": 101011001, "to": "ordinal",
"expected": u"yüzbirmilyononbirbinbirinci"},
{"test": 101011010, "to": "ordinal",
"expected": u"yüzbirmilyononbirbinonuncu"},
{"test": 1101011010, "to": "ordinal",
"expected": u"birmilyaryüzbirmilyononbirbinonuncu"},
{"test": 101101011010, "to": "ordinal",
"expected": u"yüzbirmilyaryüzbirmilyononbirbinonuncu"},
{"test": 1000000000001, "to": "ordinal",
"expected": u"birtrilyonbirinci"},
{"test": 1.2, "to": "ordinal", "expected": u""},
{"test": 1.3, "to": "ordinal", "expected": u""},
{"test": 3000, "to": "ordinal", "expected": u"üçbininci"},
{"test": 120000, "to": "ordinal", "expected": u"yüzyirmibininci"},
{"test": 1002002, "to": "ordinal",
"expected": u"birmilyonikibinikinci"},
{"test": 1003000, "to": "ordinal",
"expected": u"birmilyonüçbininci"},
{"test": 1200000, "to": "ordinal",
"expected": u"birmilyonikiyüzbininci"},
{"test": 1, "to": "cardinal", "expected": u"bir"},
{"test": 2, "to": "cardinal", "expected": u"iki"},
{"test": 9, "to": "cardinal", "expected": u"dokuz"},
{"test": 10, "to": "cardinal", "expected": u"on"},
{"test": 11, "to": "cardinal", "expected": u"onbir"},
{"test": 44, "to": "cardinal", "expected": u"kırkdört"},
{"test": 100, "to": "cardinal", "expected": u"yüz"},
{"test": 101, "to": "cardinal", "expected": u"yüzbir"},
{"test": 103, "to": "cardinal", "expected": u"yüzüç"},
{"test": 110, "to": "cardinal", "expected": u"yüzon"},
{"test": 111, "to": "cardinal", "expected": u"yüzonbir"},
{"test": 1000, "to": "cardinal", "expected": u"bin"},
{"test": 1001, "to": "cardinal", "expected": u"binbir"},
{"test": 1010, "to": "cardinal", "expected": u"binon"},
{"test": 1011, "to": "cardinal", "expected": u"binonbir"},
{"test": 1100, "to": "cardinal", "expected": u"binyüz"},
{"test": 1110, "to": "cardinal", "expected": u"binyüzon"},
{"test": 2341, "to": "cardinal",
"expected": u"ikibinüçyüzkırkbir"},
{"test": 10000, "to": "cardinal", "expected": u"onbin"},
{"test": 10010, "to": "cardinal", "expected": u"onbinon"},
{"test": 10100, "to": "cardinal", "expected": u"onbinyüz"},
{"test": 10110, "to": "cardinal", "expected": u"onbinyüzon"},
{"test": 11000, "to": "cardinal", "expected": u"onbirbin"},
{"test": 35000, "to": "cardinal", "expected": u"otuzbeşbin"},
{"test": 116331, "to": "cardinal",
"expected": u"yüzonaltıbinüçyüzotuzbir"},
{"test": 116330, "to": "cardinal",
"expected": u"yüzonaltıbinüçyüzotuz"},
{"test": 500000, "to": "cardinal", "expected": u"beşyüzbin"},
{"test": 501000, "to": "cardinal", "expected": u"beşyüzbirbin"},
{"test": 1000111, "to": "cardinal",
"expected": u"birmilyonyüzonbir"},
{"test": 111000111, "to": "cardinal",
"expected": u"yüzonbirmilyonyüzonbir"},
{"test": 111001111, "to": "cardinal",
"expected": u"yüzonbirmilyonbinyüzonbir"},
{"test": 111111111, "to": "cardinal",
"expected": u"yüzonbirmilyonyüzonbirbinyüzonbir"},
{"test": 100001000, "to": "cardinal",
"expected": u"yüzmilyonbin"},
{"test": 100001001, "to": "cardinal",
"expected": u"yüzmilyonbinbir"},
{"test": 100010000, "to": "cardinal",
"expected": u"yüzmilyononbin"},
{"test": 100010001, "to": "cardinal",
"expected": u"yüzmilyononbinbir"},
{"test": 100011000, "to": "cardinal",
"expected": u"yüzmilyononbirbin"},
{"test": 100011001, "to": "cardinal",
"expected": u"yüzmilyononbirbinbir"},
{"test": 101011001, "to": "cardinal",
"expected": u"yüzbirmilyononbirbinbir"},
{"test": 101011010, "to": "cardinal",
"expected": u"yüzbirmilyononbirbinon"},
{"test": 1101011010, "to": "cardinal",
"expected": u"birmilyaryüzbirmilyononbirbinon"},
{"test": 101101011010, "to": "cardinal",
"expected": u"yüzbirmilyaryüzbirmilyononbirbinon"},
{"test": 1000000000001, "to": "cardinal",
"expected": u"birtrilyonbir"},
{"test": 0.01, "to": "cardinal", "expected": u"sıfırvirgülbir"},
{"test": 0.21, "to": "cardinal",
"expected": u"sıfırvirgülyirmibir"},
{"test": 0.1, "to": "cardinal", "expected": u"sıfırvirgülon"},
{"test": 1.01, "to": "cardinal", "expected": u"birvirgülbir"},
{"test": 1.1, "to": "cardinal", "expected": u"birvirgülon"},
{"test": 1.21, "to": "cardinal",
"expected": u"birvirgülyirmibir"},
{"test": 101101011010.02, "to": "cardinal",
"expected": u"yüzbirmilyaryüzbirmilyononbirbinonvirgüliki"},
{"test": 101101011010.2, "to": "cardinal",
"expected": u"yüzbirmilyaryüzbirmilyononbirbinonvirgülyirmi"}
]
self.assertEqual(num2words(1, True, "tr"), u"birinci")
self.assertEqual(num2words(2, True, "tr"), u"ikinci")
self.assertEqual(num2words(9, True, "tr"), u"dokuzuncu")
self.assertEqual(num2words(10, True, "tr"), u"onuncu")
self.assertEqual(num2words(11, True, "tr"), u"onbirinci")
self.assertEqual(num2words(44, True, "tr"), u"kırkdördüncü")
self.assertEqual(num2words(100, True, "tr"), u"yüzüncü")
self.assertEqual(num2words(101, True, "tr"), u"yüzbirinci")
self.assertEqual(num2words(103, True, "tr"), u"yüzüçüncü")
self.assertEqual(num2words(110, True, "tr"), u"yüzonuncu")
self.assertEqual(num2words(111, True, "tr"), u"yüzonbirinci")
self.assertEqual(num2words(1000, True, "tr"), u"bininci")
self.assertEqual(num2words(1001, True, "tr"), u"binbirinci")
self.assertEqual(num2words(1010, True, "tr"), u"binonuncu")
self.assertEqual(num2words(1011, True, "tr"), u"binonbirinci")
self.assertEqual(num2words(1100, True, "tr"), u"binyüzüncü")
self.assertEqual(num2words(1110, True, "tr"), u"binyüzonuncu")
self.assertEqual(
num2words(2341, True, "tr"), u"ikibinüçyüzkırkbirinci"
)
self.assertEqual(num2words(10000, True, "tr"), u"onbininci")
self.assertEqual(num2words(10010, True, "tr"), u"onbinonuncu")
self.assertEqual(num2words(10100, True, "tr"), u"onbinyüzüncü")
self.assertEqual(num2words(10110, True, "tr"), u"onbinyüzonuncu")
self.assertEqual(num2words(11000, True, "tr"), u"onbirbininci")
self.assertEqual(num2words(35000, True, "tr"), u"otuzbeşbininci")
self.assertEqual(
num2words(116331, True, "tr"), u"yüzonaltıbinüçyüzotuzbirinci"
)
self.assertEqual(
num2words(116330, True, "tr"), u"yüzonaltıbinüçyüzotuzuncu"
)
self.assertEqual(num2words(100000, True, "tr"), u"yüzbininci")
self.assertEqual(num2words(501000, True, "tr"), u"beşyüzbirbininci")
self.assertEqual(
num2words(1000111, True, "tr"), u"birmilyonyüzonbirinci"
)
self.assertEqual(
num2words(111000111, True, "tr"), u"yüzonbirmilyonyüzonbirinci"
)
self.assertEqual(
num2words(111001111, True, "tr"), u"yüzonbirmilyonbinyüzonbirinci"
)
self.assertEqual(
num2words(111111111, True, "tr"),
u"yüzonbirmilyonyüzonbirbinyüzonbirinci"
)
self.assertEqual(num2words(100001000, True, "tr"), u"yüzmilyonbininci")
self.assertEqual(
num2words(100001001, True, "tr"), u"yüzmilyonbinbirinci"
)
self.assertEqual(
num2words(100010000, True, "tr"), u"yüzmilyononbininci"
)
self.assertEqual(
num2words(100010001, True, "tr"), u"yüzmilyononbinbirinci"
)
self.assertEqual(
num2words(100011000, True, "tr"), u"yüzmilyononbirbininci"
)
self.assertEqual(
num2words(100011001, True, "tr"), u"yüzmilyononbirbinbirinci"
)
self.assertEqual(
num2words(101011001, True, "tr"), u"yüzbirmilyononbirbinbirinci"
)
self.assertEqual(
num2words(101011010, True, "tr"), u"yüzbirmilyononbirbinonuncu"
)
self.assertEqual(
num2words(1101011010, True, "tr"),
u"birmilyaryüzbirmilyononbirbinonuncu"
)
self.assertEqual(
num2words(101101011010, True, "tr"),
u"yüzbirmilyaryüzbirmilyononbirbinonuncu"
)
self.assertEqual(
num2words(1000000000001, True, "tr"), u"birtrilyonbirinci"
)
self.assertEqual(num2words(1, False, "tr"), u"bir")
self.assertEqual(num2words(2, False, "tr"), u"iki")
self.assertEqual(num2words(9, False, "tr"), u"dokuz")
self.assertEqual(num2words(10, False, "tr"), u"on")
self.assertEqual(num2words(11, False, "tr"), u"onbir")
self.assertEqual(num2words(44, False, "tr"), u"kırkdört")
self.assertEqual(num2words(100, False, "tr"), u"yüz")
self.assertEqual(num2words(101, False, "tr"), u"yüzbir")
self.assertEqual(num2words(103, False, "tr"), u"yüzüç")
self.assertEqual(num2words(110, False, "tr"), u"yüzon")
self.assertEqual(num2words(111, False, "tr"), u"yüzonbir")
self.assertEqual(num2words(1000, False, "tr"), u"bin")
self.assertEqual(num2words(1001, False, "tr"), u"binbir")
self.assertEqual(num2words(1010, False, "tr"), u"binon")
self.assertEqual(num2words(1011, False, "tr"), u"binonbir")
self.assertEqual(num2words(1100, False, "tr"), u"binyüz")
self.assertEqual(num2words(1110, False, "tr"), u"binyüzon")
self.assertEqual(num2words(2341, False, "tr"), u"ikibinüçyüzkırkbir")
self.assertEqual(num2words(10000, False, "tr"), u"onbin")
self.assertEqual(num2words(10010, False, "tr"), u"onbinon")
self.assertEqual(num2words(10100, False, "tr"), u"onbinyüz")
self.assertEqual(num2words(10110, False, "tr"), u"onbinyüzon")
self.assertEqual(num2words(11000, False, "tr"), u"onbirbin")
self.assertEqual(num2words(35000, False, "tr"), u"otuzbeşbin")
self.assertEqual(
num2words(116331, False, "tr"), u"yüzonaltıbinüçyüzotuzbir"
)
self.assertEqual(
num2words(116330, False, "tr"), u"yüzonaltıbinüçyüzotuz"
)
self.assertEqual(num2words(500000, False, "tr"), u"beşyüzbin")
self.assertEqual(num2words(501000, False, "tr"), u"beşyüzbirbin")
self.assertEqual(num2words(1000111, False, "tr"), u"birmilyonyüzonbir")
self.assertEqual(
num2words(111000111, False, "tr"), u"yüzonbirmilyonyüzonbir"
)
self.assertEqual(
num2words(111001111, False, "tr"), u"yüzonbirmilyonbinyüzonbir"
)
self.assertEqual(
num2words(111111111, False, "tr"),
u"yüzonbirmilyonyüzonbirbinyüzonbir"
)
self.assertEqual(num2words(100001000, False, "tr"), u"yüzmilyonbin")
self.assertEqual(num2words(100001001, False, "tr"), u"yüzmilyonbinbir")
self.assertEqual(num2words(100010000, False, "tr"), u"yüzmilyononbin")
self.assertEqual(
num2words(100010001, False, "tr"), u"yüzmilyononbinbir"
)
self.assertEqual(
num2words(100011000, False, "tr"), u"yüzmilyononbirbin"
)
self.assertEqual(
num2words(100011001, False, "tr"), u"yüzmilyononbirbinbir"
)
self.assertEqual(
num2words(101011001, False, "tr"), u"yüzbirmilyononbirbinbir"
)
self.assertEqual(
num2words(101011010, False, "tr"), u"yüzbirmilyononbirbinon"
)
self.assertEqual(
num2words(1101011010, False, "tr"),
u"birmilyaryüzbirmilyononbirbinon"
)
self.assertEqual(
num2words(101101011010, False, "tr"),
u"yüzbirmilyaryüzbirmilyononbirbinon"
)
self.assertEqual(
num2words(1000000000001, False, "tr"), u"birtrilyonbir"
)
self.assertEqual(num2words(0.01, False, "tr"), u"sıfırvirgülbir")
self.assertEqual(num2words(0.1, False, "tr"), u"sıfırvirgülon")
self.assertEqual(num2words(0.21, False, "tr"), u"sıfırvirgülyirmibir")
self.assertEqual(num2words(1.01, False, "tr"), u"birvirgülbir")
self.assertEqual(num2words(1.1, False, "tr"), u"birvirgülon")
self.assertEqual(num2words(1.21, False, "tr"), u"birvirgülyirmibir")
self.assertEqual(
num2words(101101011010.02, False, "tr"),
u"yüzbirmilyaryüzbirmilyononbirbinonvirgüliki"
)
self.assertEqual(
num2words(101101011010.2, False, "tr"),
u"yüzbirmilyaryüzbirmilyononbirbinonvirgülyirmi"
)
for casedata in testcases:
self.assertEqual(
num2words(casedata["test"],
lang=testlang,
to=casedata["to"]),
casedata["expected"])