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

1
.gitignore vendored
View File

@@ -4,3 +4,4 @@ dist
.idea/
*.egg-info
/.tox
.eggs/

11
num2words/__init__.py
View File

@@ -18,11 +18,11 @@
from __future__ import unicode_literals
from . import (lang_AR, lang_CZ, lang_DE, lang_DK, lang_EN, lang_EN_IN,
lang_ES, lang_ES_CO, lang_ES_VE, lang_FI, lang_FR, lang_FR_BE,
lang_FR_CH, lang_FR_DZ, lang_HE, lang_ID, lang_IT, lang_JA,
lang_KN, lang_KO, lang_LT, lang_LV, lang_NL, lang_NO, lang_PL,
lang_PT, lang_PT_BR, lang_RO, lang_RU, lang_SL, lang_SR,
lang_TE, lang_TH, lang_TR, lang_UK, lang_VI)
lang_ES, lang_ES_CO, lang_ES_NI, lang_ES_VE, lang_FI, lang_FR,
lang_FR_BE, lang_FR_CH, lang_FR_DZ, lang_HE, lang_ID, lang_IT,
lang_JA, lang_KN, lang_KO, lang_LT, lang_LV, lang_NL, lang_NO,
lang_PL, lang_PT, lang_PT_BR, lang_RO, lang_RU, lang_SL,
lang_SR, lang_TE, lang_TH, lang_TR, lang_UK, lang_VI)
CONVERTER_CLASSES = {
'ar': lang_AR.Num2Word_AR(),
@@ -37,6 +37,7 @@ CONVERTER_CLASSES = {
'fi': lang_FI.Num2Word_FI(),
'es': lang_ES.Num2Word_ES(),
'es_CO': lang_ES_CO.Num2Word_ES_CO(),
'es_NI': lang_ES_NI.Num2Word_ES_NI(),
'es_VE': lang_ES_VE.Num2Word_ES_VE(),
'id': lang_ID.Num2Word_ID(),
'ja': lang_JA.Num2Word_JA(),

2
num2words/base.py
View File

@@ -139,7 +139,7 @@ class Num2Word_Base(object):
def to_cardinal_float(self, value):
try:
float(value) == value
except (ValueError, TypeError, AssertionError):
except (ValueError, TypeError, AssertionError, AttributeError):
raise TypeError(self.errmsg_nonnum % value)
pre, post = self.float2tuple(float(value))

22
num2words/lang_ES.py
View File

@@ -15,7 +15,9 @@
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,
# MA 02110-1301 USA
from __future__ import print_function, unicode_literals
from __future__ import division, print_function, unicode_literals
import math
from .lang_EU import Num2Word_EU
@@ -120,7 +122,6 @@ class Num2Word_ES(Num2Word_EU):
def to_ordinal(self, value):
self.verify_ordinal(value)
try:
if value == 0:
text = ""
elif value <= 10:
@@ -143,25 +144,26 @@ class Num2Word_ES(Num2Word_EU):
self.to_ordinal(value - cen))
)
elif value < 1e18:
# Round down to the nearest 1e(3n)
# dec contains the following:
# [ 1e3, 1e6): 1e3
# [ 1e6, 1e9): 1e6
# [ 1e9, 1e12): 1e9
# [1e12, 1e15): 1e12
# [1e15, 1e18): 1e15
dec = 10 ** ((((len(str(int(value))) - 1) / 3 - 1) + 1) * 3)
part = int(float(value / dec) * dec)
cardinal = (
self.to_cardinal(part / dec) if part / dec != 1 else ""
)
dec = 1000 ** int(math.log(int(value), 1000))
# Split the parts before and after the word for 'dec'
# eg (12, 345) = divmod(12_345, 1_000)
high_part, low_part = divmod(value, dec)
cardinal = self.to_cardinal(high_part) if high_part != 1 else ""
text = (
"%s%s%s %s" % (cardinal, self.ords[dec], self.gender_stem,
self.to_ordinal(value - part))
self.to_ordinal(low_part))
)
else:
text = self.to_cardinal(value)
except KeyError:
text = self.to_cardinal(value)
return text.strip()
def to_ordinal_num(self, value):

33
num2words/lang_ES_NI.py Normal file
View File

@@ -0,0 +1,33 @@
# -*- 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 print_function, unicode_literals
from .lang_ES import Num2Word_ES
class Num2Word_ES_NI(Num2Word_ES):
CURRENCY_FORMS = {
'NIO': (('córdoba', 'córdobas'), ('centavo', 'centavos')),
}
def to_currency(self, val, currency='NIO', cents=True, separator=' con',
adjective=False):
result = super(Num2Word_ES, self).to_currency(
val, currency=currency, cents=cents, separator=separator,
adjective=adjective)
return result.replace("uno", "un")

2
num2words/lang_EU.py
View File

@@ -41,7 +41,7 @@ class Num2Word_EU(Num2Word_Base):
'NOK': (('krone', 'kroner'), ('øre', 'øre')),
'PLN': (('zloty', 'zlotys', 'zlotu'), ('grosz', 'groszy')),
'MXN': (('peso', 'pesos'), GENERIC_CENTS),
'RON': (('leu', 'lei'), ('ban', 'bani')),
'RON': (('leu', 'lei', 'de lei'), ('ban', 'bani', 'de bani')),
'INR': (('rupee', 'rupees'), ('paisa', 'paise'))
}

37
num2words/lang_HE.py
View File

@@ -18,32 +18,33 @@
from __future__ import print_function, unicode_literals
from .base import Num2Word_Base
from .utils import get_digits, splitbyx
ZERO = (u'אפס',)
ONES = {
1: (u'אחד',),
2: (u'שנים',),
1: (u'אחת',),
2: (u'שתים',),
3: (u'שלש',),
4: (u'ארבע',),
5: (u'חמש',),
6: (u'שש',),
7: (u'שבע',),
8: (u'שמנה',),
8: (u'שמונה',),
9: (u'תשע',),
}
TENS = {
0: (u'עשר',),
1: (u'אחד עשרה',),
2: (u'שנים עשרה',),
1: (u'אחת עשרה',),
2: (u'שתים עשרה',),
3: (u'שלש עשרה',),
4: (u'ארבע עשרה',),
5: (u'חמש עשרה',),
6: (u'שש עשרה',),
7: (u'שבע עשרה',),
8: (u'שמנה עשרה',),
8: (u'שמונה עשרה',),
9: (u'תשע עשרה',),
}
@@ -54,7 +55,7 @@ TWENTIES = {
5: (u'חמישים',),
6: (u'ששים',),
7: (u'שבעים',),
8: (u'שמנים',),
8: (u'שמונים',),
9: (u'תשעים',),
}
@@ -67,6 +68,13 @@ HUNDRED = {
THOUSANDS = {
1: (u'אלף',),
2: (u'אלפיים',),
3: (u'שלשת אלפים',),
4: (u'ארבעת אלפים',),
5: (u'חמשת אלפים',),
6: (u'ששת אלפים',),
7: (u'שבעת אלפים',),
8: (u'שמונת אלפים',),
9: (u'תשעת אלפים',),
}
AND = u'ו'
@@ -100,12 +108,15 @@ def int2word(n):
n1, n2, n3 = get_digits(x)
if i > 0:
words.append(THOUSANDS[n1][0])
continue
if n3 > 0:
if n3 <= 2:
words.append(HUNDRED[n3][0])
else:
words.append(ONES[n3][0])
words.append(HUNDRED[3][0])
words.append(ONES[n3][0] + ' ' + HUNDRED[3][0])
if n2 > 1:
words.append(TWENTIES[n2][0])
@@ -116,14 +127,12 @@ def int2word(n):
words.append(ONES[n1][0])
if i > 0:
if i <= 2:
words.append(THOUSANDS[i][0])
else:
words.append(ONES[i][0])
words.append(THOUSANDS[1][0])
# source: https://hebrew-academy.org.il/2017/01/30/ו-החיבור-במספרים/
if len(words) > 1:
words[-1] = AND + words[-1]
return ' '.join(words)
@@ -135,7 +144,7 @@ def to_currency(n, currency='EUR', cents=True, separator=','):
raise NotImplementedError()
class Num2Word_HE(object):
class Num2Word_HE(Num2Word_Base):
def to_cardinal(self, number):
return n2w(number)

1
num2words/lang_IT.py
View File

@@ -52,6 +52,7 @@ def phonetic_contraction(string):
.replace("ao", "o") # ex. "settantaotto"
.replace("io", "o") # ex. "ventiotto"
.replace("au", "u") # ex. "trentauno"
.replace("iu", "u") # ex. "ventiunesimo"
)

83
num2words/lang_RO.py
View File

@@ -23,8 +23,9 @@ from . import lang_EU
class Num2Word_RO(lang_EU.Num2Word_EU):
GIGA_SUFFIX = "iliard/e"
MEGA_SUFFIX = "ilion"
# inflection for million follows different rule
# inflection for mi/billion follows different rule
MEGA_SUFFIX_I = "ilioane"
GIGA_SUFFIX_I = "iliarde"
def setup(self):
super(Num2Word_RO, self).setup()
@@ -48,13 +49,13 @@ class Num2Word_RO(lang_EU.Num2Word_EU):
"unu", "zero"]
self.gen_numwords = ["", "o", "două", "trei", "patru", "cinci",
"șase", "șapte", "opt", "nouă"]
self.gen_numwords_m = ["", "un", "două", "trei", "patru", "cinci",
self.gen_numwords_n = ["", "un", "două", "trei", "patru", "cinci",
"șase", "șapte", "opt", "nouă"]
self.numwords_inflections = {
100: self.gen_numwords,
1000: self.gen_numwords,
1000000: self.gen_numwords_m,
1000000000: self.gen_numwords_m
1000000: self.gen_numwords_n,
1000000000: self.gen_numwords_n
}
self.ords = {"unu": "primul",
"doi": "al doilea",
@@ -67,24 +68,29 @@ class Num2Word_RO(lang_EU.Num2Word_EU):
def merge(self, lpair, rpair):
ltext, lnum = lpair
rtext, rnum = rpair
rtext_i = self.inflect(rnum, rtext)
if lnum > 1 and rtext_i.endswith(self.MEGA_SUFFIX):
rtext_i = rtext_i.replace(self.MEGA_SUFFIX, self.MEGA_SUFFIX_I)
rtext_i = self.inflect(rnum, rtext, lnum)
if 1 <= lnum < 10:
if rnum not in self.numwords_inflections:
return (rtext, rnum)
else:
rtext_i = self.inflect(lnum * rnum, rtext)
rtext_i = self.inflect(lnum * rnum, rtext, lnum)
lresult = (self.numwords_inflections[rnum][lnum], rtext_i)
return ("%s %s" % lresult, rnum)
elif 10 < lnum < 100:
if lnum % 10 == 0:
return ("%s și %s" % (ltext, rtext), lnum + rnum)
else:
if rnum in self.numwords_inflections:
rtext_i = self.inflect(lnum * rnum, rtext, lnum)
return ("%s %s" % (ltext, rtext_i), lnum * rnum)
else:
return ("%s și %s" % (ltext, rtext), lnum + rnum)
else:
rtext_i = self.inflect(lnum * rnum, rtext, lnum)
ltext_i = ltext if lnum % 10 != 2 \
else ltext.replace("doi", "două")
return ("%s %s" % (ltext_i, rtext_i), lnum * rnum)
else:
if rnum in self.numwords_inflections:
rtext_i = self.inflect(lnum * rnum, rtext)
rtext_i = self.inflect(lnum * rnum, rtext, lnum)
return ("%s %s" % (ltext, rtext_i), lnum * rnum)
def to_ordinal(self, value):
@@ -101,21 +107,52 @@ class Num2Word_RO(lang_EU.Num2Word_EU):
return "1-ul"
return "al %s-lea" % (value)
def inflect(self, value, text):
text = text.split("/")
if value in (1, 100, 1000, 100000, 1000000000):
return text[0]
if len(text) > 1 and text[0][-1] in "aăeiou":
text[0] = text[0][:-1]
return "".join(text)
def pluralize(self, n, forms):
if n == 1:
form = 0
elif n == 0 or (n % 100 > 0 and n % 100 < 20):
form = 1
else:
form = 2
return forms[form]
def to_currency(self, val, longval=True, old=False):
cents = int(round(val*100))
result = self.to_splitnum(cents, hightxt="leu/i", lowtxt="ban/i",
divisor=100, jointxt="și", longval=longval)
def inflect(self, value, text, side_effect=-1):
text = text.split("/")
result = text[0]
if len(text) > 1:
forms = [
text[0],
text[0][:-1] + text[1],
"de " + text[0][:-1] + text[1]
]
result = self.pluralize(side_effect, forms)
# mega inflections are different
if side_effect > 1 and result.endswith(self.MEGA_SUFFIX):
result = result.replace(self.MEGA_SUFFIX, self.MEGA_SUFFIX_I)
elif side_effect > 1 and result.endswith("iliare"):
result = result.replace("iliare", self.GIGA_SUFFIX_I)
return result
def to_currency(self, val, currency="RON", cents=False, separator=" și",
adjective=False):
# romanian currency has a particularity for numeral: one
self.gen_numwords[1] = "una"
result = super(Num2Word_RO, self).to_currency(
int(round(val*100)),
currency,
True,
separator,
adjective
)
self.gen_numwords[1] = "o" # revert numeral
return result.replace(
"unu leu", "un leu"
).replace("unu ban", "un ban")
).replace(
"unu ban", "un ban"
).replace(
# if the romanian low text is 0, it is not usually printed
separator + " zero bani", ""
)
def to_year(self, val, suffix=None, longval=True):
result = super(Num2Word_RO, self).to_year(

6
num2words/lang_RU.py
View File

@@ -107,6 +107,12 @@ class Num2Word_RU(Num2Word_Base):
'USD': (
('доллар', 'доллара', 'долларов'), ('цент', 'цента', 'центов')
),
'UAH': (
('гривна', 'гривны', 'гривен'), ('копейка', 'копейки', 'копеек')
),
'KZT': (
('тенге', 'тенге', 'тенге'), ('тиын', 'тиына', 'тиынов')
),
}
def setup(self):

20
num2words/lang_TR.py
View File

@@ -24,17 +24,17 @@ class Num2Word_TR(object):
self.precision = 2
self.negword = u"eksi"
self.pointword = u"virgül"
self.CURRENCY_UNIT = (u"lira",)
self.CURRENCY_SUBUNIT = (u"kuruş",)
self.CURRENCY_UNIT = u"lira"
self.CURRENCY_SUBUNIT = u"kuruş"
self.errmsg_nonnum = u"Sadece sayılar yazıya çevrilebilir."
self.errmsg_floatord = u"Tam sayı olmayan {} sıralamada kullanılamaz."
self.errmsg_negord = u"Pozitif olmayan {} sıralamada kullanılamaz."
self.errmsg_toobig = u"abs({}) sayı yazıya çevirmek için çok büyük. " \
u"Yazıya çevrilebilecek en büyük rakam {}."
self.exclude_title = []
self.DECIMAL_SIGN = (",",)
self.ORDINAL_SIGN = (".",)
self.ZERO = (u"sıfır",)
self.DECIMAL_SIGN = ","
self.ORDINAL_SIGN = "."
self.ZERO = u"sıfır"
self.CARDINAL_ONES = {
"1": u"bir",
"2": u"iki",
@@ -444,7 +444,7 @@ class Num2Word_TR(object):
wrd += self.CARDINAL_ONES.get(self.integers_to_read[1][1], "")
if self.integers_to_read[0] == "0":
wrd = self.ZERO[0] + wrd
wrd = self.ZERO + wrd
else:
wrd = self.to_cardinal(int(self.integers_to_read[0])) + wrd
return wrd
@@ -830,9 +830,11 @@ class Num2Word_TR(object):
found = 1
def to_currency(self, value):
if int(value) == 0:
return u"bedelsiz"
valueparts = self.to_cardinal(value).split(self.pointword)
if len(valueparts) == 1:
return valueparts[0] + self.CURRENCY_UNIT[0]
return valueparts[0] + self.CURRENCY_UNIT
if len(valueparts) == 2:
return self.CURRENCY_UNIT[0].join(valueparts) + \
self.CURRENCY_SUBUNIT[0]
return self.CURRENCY_UNIT.join(valueparts) + \
self.CURRENCY_SUBUNIT

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'),

329
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")
for casedata in testcases:
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"
)
num2words(casedata["test"],
lang=testlang,
to=casedata["to"]),
casedata["expected"])