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 remote-tracking branch 'upstream/master'

Browse Source
This commit is contained in:
Krzysztof Socha
2017-02-27 18:14:11 +01:00
parent c459d9ba82 f29e792757
commit 1667511ff3
30 changed files with 2149 additions and 76 deletions
Download Patch File Download Diff File Expand all files Collapse all files

51
tests/test_de.py Normal file
View File

@@ -0,0 +1,51 @@
# -*- encoding: utf-8 -*-
# Copyright (c) 2015, 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 Num2WordsDETest(TestCase):
def test_ordinal_less_than_twenty(self):
self.assertEqual(num2words(7, ordinal=True, lang='de'), "siebte")
self.assertEqual(num2words(8, ordinal=True, lang='de'), "achte")
self.assertEqual(num2words(12, ordinal=True, lang='de'), "zwölfte")
self.assertEqual(num2words(17, ordinal=True, lang='de'), "siebzehnte")
def test_ordinal_more_than_twenty(self):
self.assertEqual(num2words(81, ordinal=True, lang='de'), "einundachtzigste")
def test_ordinal_at_crucial_number(self):
self.assertEqual(num2words(100, ordinal=True, lang='de'), "hundertste")
self.assertEqual(num2words(1000, ordinal=True, lang='de'), "tausendste")
self.assertEqual(num2words(4000, ordinal=True, lang='de'), "viertausendste")
self.assertEqual(num2words(2000000, ordinal=True, lang='de'), "zwei millionenste")
self.assertEqual(num2words(5000000000, ordinal=True, lang='de'), "fünf milliardenste")
def test_cardinal_at_some_numbers(self):
self.assertEqual(num2words(2000000, lang='de'), "zwei millionen")
self.assertEqual(num2words(4000000000, lang='de'), "vier milliarden")
def test_cardinal_for_decimal_number(self):
self.assertEqual(num2words(3.486, lang='de'), "drei Komma vier acht")
def test_ordinal_for_negative_numbers(self):
self.assertRaises(TypeError, num2words, -12, ordinal=True, lang='de')
def test_ordinal_for_floating_numbers(self):
self.assertRaises(TypeError, num2words, 2.453, ordinal=True, lang='de')

7
tests/test_en.py
View File

@@ -21,3 +21,10 @@ class Num2WordsENTest(TestCase):
def test_and_join_199(self):
# ref https://github.com/savoirfairelinux/num2words/issues/8
self.assertEqual(num2words(199), "one hundred and ninety-nine")
def test_cardinal_for_float_number(self):
# issue 24
self.assertEqual(num2words(12.50), "twelve point five zero")
self.assertEqual(num2words(12.51), "twelve point five one")
self.assertEqual(num2words(12.53), "twelve point five three")
self.assertEqual(num2words(12.59), "twelve point five nine")

36
tests/test_fr_ch.py Normal file
View File

@@ -0,0 +1,36 @@
# -*- encoding: utf-8 -*-
# Copyright (c) 2015, 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 Num2WordsENTest(TestCase):
def test_ordinal_special_joins(self):
self.assertEqual(num2words(5, ordinal=True, lang='fr_CH'), "cinquième")
self.assertEqual(num2words(6, ordinal=True, lang='fr_CH'), "sixième")
self.assertEqual(num2words(35, ordinal=True, lang='fr_CH'), "trente-cinquième")
self.assertEqual(num2words(9, ordinal=True, lang='fr_CH'), "neuvième")
self.assertEqual(num2words(49, ordinal=True, lang='fr_CH'), "quarante-neuvième")
self.assertEqual(num2words(71, lang='fr_CH'), "septante et un")
self.assertEqual(num2words(81, lang='fr_CH'), "huitante et un")
self.assertEqual(num2words(80, lang='fr_CH'), "huitante")
self.assertEqual(num2words(880, lang='fr_CH'), "huit cents huitante")
self.assertEqual(num2words(91, ordinal=True, lang='fr_CH'), "nonante et unième")
self.assertEqual(num2words(53, lang='fr_CH'), "cinquante-trois")

49
tests/test_id.py Normal file
View File

@@ -0,0 +1,49 @@
# 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 unittest import TestCase
from num2words import num2words
class Num2WordsIDTest(TestCase):
def test_cardinal_for_natural_number(self):
self.assertEqual(num2words(10, lang='id'), "sepuluh")
self.assertEqual(num2words(11, lang='id'), "sebelas")
self.assertEqual(num2words(108, lang='id'), "seratus delapan")
self.assertEqual(num2words(1075, lang='id'), "seribu tujuh puluh lima")
self.assertEqual(num2words(1087231, lang='id'), "satu juta delapan puluh tujuh ribu dua ratus tiga puluh satu")
self.assertEqual(num2words(1000000408, lang='id'), "satu miliar empat ratus delapan")
def test_cardinal_for_decimal_number(self):
self.assertEqual(num2words(12.234, lang='id'), "dua belas koma dua tiga empat")
self.assertEqual(num2words(9.076, lang='id'), "sembilan koma nol tujuh enam")
def test_cardinal_for_negative_number(self):
self.assertEqual(num2words(-923, lang='id'), "min sembilan ratus dua puluh tiga")
self.assertEqual(num2words(-0.234, lang='id'), "min nol koma dua tiga empat")
def test_ordinal_for_natural_number(self):
self.assertEqual(num2words(1, ordinal=True, lang='id'), "pertama")
self.assertEqual(num2words(10, ordinal=True, lang='id'), "kesepuluh")
#def test_ordinal_numeric_for_natural_number(self):
# self.assertEqual(num2words(1, ordinal=True, lang='id'), "ke-1")
# self.assertEqual(num2words(10, ordinal=True, lang='id'), "ke-10")
def test_ordinal_for_negative_number(self):
self.assertRaises(TypeError, num2words, -12, ordinal=True, lang='id')
def test_ordinal_for_floating_number(self):
self.assertRaises(TypeError, num2words, 3.243, ordinal=True, lang='id')

96
tests/test_it.py Normal file
View File

@@ -0,0 +1,96 @@
# -*- encoding: utf-8 -*-
# Copyright (c) 2015, 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 Num2WordsITTest(TestCase):
def test_number(self):
test_cases = (
(1,'uno'),
(2,'due'),
(3,'tre'),
(11,'undici'),
(12,'dodici'),
(16,'sedici'),
(19,'diciannove'),
(20,'venti'),
(21,'ventuno'),
(26,'ventisei'),
(28,'ventotto'),
(30,'trenta'),
(31,'trentuno'),
(40,'quaranta'),
(43,'quarantatre'),
(50,'cinquanta'),
(55,'cinquantacinque'),
(60,'sessanta'),
(67,'sessantasette'),
(70,'settanta'),
(79,'settantanove'),
(100,'cento'),
(101,'centouno'),
(199,'centonovantanove'),
(203,'duecentotre'),
(287,'duecentoottantasette'),
(300,'trecento'),
(356,'trecentocinquantasei'),
(410,'quattrocentodieci'),
(434,'quattrocentotrentaquattro'),
(578,'cinquecentosettantotto'),
(689,'seicentoottantanove'),
(729,'settecentoventinove'),
(894,'ottocentonovantaquattro'),
(999,'novecentonovantanove'),
(1000,'mille'),
(1001,'milleuno'),
(1097,'millenovantasette'),
(1104,'millecentoquattro'),
(1243,'milleduecentoquarantatre'),
(2385,'duemilatrecentoottantacinque'),
(3766,'tremilasettecentosessantasei'),
(4196,'quattromilacentonovantasei'),
(5846,'cinquemilaottocentoquarantasei'),
(6459,'seimilaquattrocentocinquantanove'),
(7232,'settemiladuecentotrentadue'),
(8569,'ottomilacinquecentosessantanove'),
(9539,'novemilacinquecentotrentanove'),
(1000000,'un milione'),
(1000001,'un milioneuno'),
# (1000000100,'un miliardocento'), # DOES NOT WORK TODO: FIX
)
for test in test_cases:
self.assertEqual(num2words(test[0], lang='it'), test[1])
def test_ordinal(self):
test_cases = (
(1,'primo'),
(8,'ottavo'),
(12,'dodicesimo'),
(14,'quattordicesimo'),
(28,'ventottesimo'),
(100,'centesimo'),
)
for test in test_cases:
self.assertEqual(num2words(test[0], lang='it', ordinal=True), test[1])

219
tests/test_pt_BR.py Normal file
View File

@@ -0,0 +1,219 @@
# -*- encoding: utf-8 -*-
# Copyright (c) 2015, 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 decimal import Decimal
from unittest import TestCase
from num2words import num2words
from num2words.lang_PT_BR import Num2Word_PT_BR
class Num2WordsPTBRTest(TestCase):
def setUp(self):
super(Num2WordsPTBRTest, self).setUp()
self.n2w = Num2Word_PT_BR()
def test_cardinal_integer(self):
self.assertEqual(num2words(1, lang='pt_BR'), 'um')
self.assertEqual(num2words(2, lang='pt_BR'), 'dois')
self.assertEqual(num2words(3, lang='pt_BR'), 'três')
self.assertEqual(num2words(4, lang='pt_BR'), 'quatro')
self.assertEqual(num2words(5, lang='pt_BR'), 'cinco')
self.assertEqual(num2words(6, lang='pt_BR'), 'seis')
self.assertEqual(num2words(7, lang='pt_BR'), 'sete')
self.assertEqual(num2words(8, lang='pt_BR'), 'oito')
self.assertEqual(num2words(9, lang='pt_BR'), 'nove')
self.assertEqual(num2words(10, lang='pt_BR'), 'dez')
self.assertEqual(num2words(11, lang='pt_BR'), 'onze')
self.assertEqual(num2words(12, lang='pt_BR'), 'doze')
self.assertEqual(num2words(13, lang='pt_BR'), 'treze')
self.assertEqual(num2words(14, lang='pt_BR'), 'catorze')
self.assertEqual(num2words(15, lang='pt_BR'), 'quinze')
self.assertEqual(num2words(16, lang='pt_BR'), 'dezesseis')
self.assertEqual(num2words(17, lang='pt_BR'), 'dezessete')
self.assertEqual(num2words(18, lang='pt_BR'), 'dezoito')
self.assertEqual(num2words(19, lang='pt_BR'), 'dezenove')
self.assertEqual(num2words(20, lang='pt_BR'), 'vinte')
self.assertEqual(num2words(21, lang='pt_BR'), 'vinte e um')
self.assertEqual(num2words(22, lang='pt_BR'), 'vinte e dois')
self.assertEqual(num2words(35, lang='pt_BR'), 'trinta e cinco')
self.assertEqual(num2words(99, lang='pt_BR'), 'noventa e nove')
self.assertEqual(num2words(100, lang='pt_BR'), 'cem')
self.assertEqual(num2words(101, lang='pt_BR'), 'cento e um')
self.assertEqual(num2words(128, lang='pt_BR'), 'cento e vinte e oito')
self.assertEqual(num2words(713, lang='pt_BR'), 'setecentos e treze')
self.assertEqual(num2words(1000, lang='pt_BR'), 'mil')
self.assertEqual(num2words(1001, lang='pt_BR'), 'mil e um')
self.assertEqual(num2words(1111, lang='pt_BR'), 'mil, cento e onze')
self.assertEqual(num2words(2114, lang='pt_BR'), 'dois mil, cento e catorze')
self.assertEqual(num2words(73421, lang='pt_BR'), 'setenta e três mil, quatrocentos e vinte e um')
self.assertEqual(num2words(100000, lang='pt_BR'), 'cem mil')
self.assertEqual(num2words(250050, lang='pt_BR'), 'duzentos e cinquenta mil e cinquenta')
self.assertEqual(num2words(6000000, lang='pt_BR'), 'seis milhões')
self.assertEqual(num2words(19000000000, lang='pt_BR'), 'dezenove bilhões')
self.assertEqual(num2words(145000000002, lang='pt_BR'), 'cento e quarenta e cinco bilhões e dois')
def test_cardinal_integer_negative(self):
self.assertEqual(num2words(-1, lang='pt_BR'), 'menos um')
self.assertEqual(num2words(-256, lang='pt_BR'), 'menos duzentos e cinquenta e seis')
self.assertEqual(num2words(-1000, lang='pt_BR'), 'menos mil')
self.assertEqual(num2words(-1000000, lang='pt_BR'), 'menos um milhão')
self.assertEqual(num2words(-1234567, lang='pt_BR'), 'menos um milhão, duzentos e trinta e quatro mil, quinhentos e sessenta e sete')
def test_cardinal_float(self):
self.assertEqual(num2words(Decimal('1.00'), lang='pt_BR'), 'um')
self.assertEqual(num2words(Decimal('1.01'), lang='pt_BR'), 'um vírgula zero um')
self.assertEqual(num2words(Decimal('1.035'), lang='pt_BR'), 'um vírgula zero três')
self.assertEqual(num2words(Decimal('1.35'), lang='pt_BR'), 'um vírgula três cinco')
self.assertEqual(num2words(Decimal('3.14159'), lang='pt_BR'), 'três vírgula um quatro')
self.assertEqual(num2words(Decimal('101.22'), lang='pt_BR'), 'cento e um vírgula dois dois')
self.assertEqual(num2words(Decimal('2345.75'), lang='pt_BR'), 'dois mil, trezentos e quarenta e cinco vírgula sete cinco')
def test_cardinal_float_negative(self):
self.assertEqual(num2words(Decimal('-2.34'), lang='pt_BR'), 'menos dois vírgula três quatro')
self.assertEqual(num2words(Decimal('-9.99'), lang='pt_BR'), 'menos nove vírgula nove nove')
self.assertEqual(num2words(Decimal('-7.01'), lang='pt_BR'), 'menos sete vírgula zero um')
self.assertEqual(num2words(Decimal('-222.22'), lang='pt_BR'), 'menos duzentos e vinte e dois vírgula dois dois')
def test_ordinal(self):
self.assertEqual(num2words(1, lang='pt_BR', ordinal=True), 'primeiro')
self.assertEqual(num2words(2, lang='pt_BR', ordinal=True), 'segundo')
self.assertEqual(num2words(3, lang='pt_BR', ordinal=True), 'terceiro')
self.assertEqual(num2words(4, lang='pt_BR', ordinal=True), 'quarto')
self.assertEqual(num2words(5, lang='pt_BR', ordinal=True), 'quinto')
self.assertEqual(num2words(6, lang='pt_BR', ordinal=True), 'sexto')
self.assertEqual(num2words(7, lang='pt_BR', ordinal=True), 'sétimo')
self.assertEqual(num2words(8, lang='pt_BR', ordinal=True), 'oitavo')
self.assertEqual(num2words(9, lang='pt_BR', ordinal=True), 'nono')
self.assertEqual(num2words(10, lang='pt_BR', ordinal=True), 'décimo')
self.assertEqual(num2words(11, lang='pt_BR', ordinal=True), 'décimo primeiro')
self.assertEqual(num2words(12, lang='pt_BR', ordinal=True), 'décimo segundo')
self.assertEqual(num2words(13, lang='pt_BR', ordinal=True), 'décimo terceiro')
self.assertEqual(num2words(14, lang='pt_BR', ordinal=True), 'décimo quarto')
self.assertEqual(num2words(15, lang='pt_BR', ordinal=True), 'décimo quinto')
self.assertEqual(num2words(16, lang='pt_BR', ordinal=True), 'décimo sexto')
self.assertEqual(num2words(17, lang='pt_BR', ordinal=True), 'décimo sétimo')
self.assertEqual(num2words(18, lang='pt_BR', ordinal=True), 'décimo oitavo')
self.assertEqual(num2words(19, lang='pt_BR', ordinal=True), 'décimo nono')
self.assertEqual(num2words(20, lang='pt_BR', ordinal=True), 'vigésimo')
self.assertEqual(num2words(21, lang='pt_BR', ordinal=True), 'vigésimo primeiro')
self.assertEqual(num2words(22, lang='pt_BR', ordinal=True), 'vigésimo segundo')
self.assertEqual(num2words(35, lang='pt_BR', ordinal=True), 'trigésimo quinto')
self.assertEqual(num2words(99, lang='pt_BR', ordinal=True), 'nonagésimo nono')
self.assertEqual(num2words(100, lang='pt_BR', ordinal=True), 'centésimo')
self.assertEqual(num2words(101, lang='pt_BR', ordinal=True), 'centésimo primeiro')
self.assertEqual(num2words(128, lang='pt_BR', ordinal=True), 'centésimo vigésimo oitavo')
self.assertEqual(num2words(713, lang='pt_BR', ordinal=True), 'septigentésimo décimo terceiro')
self.assertEqual(num2words(1000, lang='pt_BR', ordinal=True), 'milésimo')
self.assertEqual(num2words(1001, lang='pt_BR', ordinal=True), 'milésimo primeiro')
self.assertEqual(num2words(1111, lang='pt_BR', ordinal=True), 'milésimo centésimo décimo primeiro')
self.assertEqual(num2words(2114, lang='pt_BR', ordinal=True), 'segundo milésimo centésimo décimo quarto')
self.assertEqual(num2words(73421, lang='pt_BR', ordinal=True), 'septuagésimo terceiro milésimo quadrigentésimo vigésimo primeiro')
self.assertEqual(num2words(100000, lang='pt_BR', ordinal=True), 'centésimo milésimo')
self.assertEqual(num2words(250050, lang='pt_BR', ordinal=True), 'ducentésimo quinquagésimo milésimo quinquagésimo')
self.assertEqual(num2words(6000000, lang='pt_BR', ordinal=True), 'sexto milionésimo')
self.assertEqual(num2words(19000000000, lang='pt_BR', ordinal=True), 'décimo nono bilionésimo')
self.assertEqual(num2words(145000000002, lang='pt_BR', ordinal=True), 'centésimo quadragésimo quinto bilionésimo segundo')
def test_currency_integer(self):
self.assertEqual(self.n2w.to_currency(1), 'um real')
self.assertEqual(self.n2w.to_currency(2), 'dois reais')
self.assertEqual(self.n2w.to_currency(3), 'três reais')
self.assertEqual(self.n2w.to_currency(4), 'quatro reais')
self.assertEqual(self.n2w.to_currency(5), 'cinco reais')
self.assertEqual(self.n2w.to_currency(6), 'seis reais')
self.assertEqual(self.n2w.to_currency(7), 'sete reais')
self.assertEqual(self.n2w.to_currency(8), 'oito reais')
self.assertEqual(self.n2w.to_currency(9), 'nove reais')
self.assertEqual(self.n2w.to_currency(10), 'dez reais')
self.assertEqual(self.n2w.to_currency(11), 'onze reais')
self.assertEqual(self.n2w.to_currency(12), 'doze reais')
self.assertEqual(self.n2w.to_currency(13), 'treze reais')
self.assertEqual(self.n2w.to_currency(14), 'catorze reais')
self.assertEqual(self.n2w.to_currency(15), 'quinze reais')
self.assertEqual(self.n2w.to_currency(16), 'dezesseis reais')
self.assertEqual(self.n2w.to_currency(17), 'dezessete reais')
self.assertEqual(self.n2w.to_currency(18), 'dezoito reais')
self.assertEqual(self.n2w.to_currency(19), 'dezenove reais')
self.assertEqual(self.n2w.to_currency(20), 'vinte reais')
self.assertEqual(self.n2w.to_currency(21), 'vinte e um reais')
self.assertEqual(self.n2w.to_currency(22), 'vinte e dois reais')
self.assertEqual(self.n2w.to_currency(35), 'trinta e cinco reais')
self.assertEqual(self.n2w.to_currency(99), 'noventa e nove reais')
self.assertEqual(self.n2w.to_currency(100), 'cem reais')
self.assertEqual(self.n2w.to_currency(101), 'cento e um reais')
self.assertEqual(self.n2w.to_currency(128), 'cento e vinte e oito reais')
self.assertEqual(self.n2w.to_currency(713), 'setecentos e treze reais')
self.assertEqual(self.n2w.to_currency(1000), 'mil reais')
self.assertEqual(self.n2w.to_currency(1001), 'mil e um reais')
self.assertEqual(self.n2w.to_currency(1111), 'mil, cento e onze reais')
self.assertEqual(self.n2w.to_currency(2114), 'dois mil, cento e catorze reais')
self.assertEqual(self.n2w.to_currency(73421), 'setenta e três mil, quatrocentos e vinte e um reais')
self.assertEqual(self.n2w.to_currency(100000), 'cem mil reais')
self.assertEqual(self.n2w.to_currency(250050), 'duzentos e cinquenta mil e cinquenta reais')
self.assertEqual(self.n2w.to_currency(6000000), 'seis milhões de reais')
self.assertEqual(self.n2w.to_currency(19000000000), 'dezenove bilhões de reais')
self.assertEqual(self.n2w.to_currency(145000000002), 'cento e quarenta e cinco bilhões e dois reais')
def test_currency_integer_negative(self):
self.assertEqual(self.n2w.to_currency(-1), 'menos um real')
self.assertEqual(self.n2w.to_currency(-256), 'menos duzentos e cinquenta e seis reais')
self.assertEqual(self.n2w.to_currency(-1000), 'menos mil reais')
self.assertEqual(self.n2w.to_currency(-1000000), 'menos um milhão de reais')
self.assertEqual(self.n2w.to_currency(-1234567), 'menos um milhão, duzentos e trinta e quatro mil, quinhentos e sessenta e sete reais')
def test_currency_float(self):
self.assertEqual(self.n2w.to_currency(Decimal('1.00')), 'um real')
self.assertEqual(self.n2w.to_currency(Decimal('1.01')), 'um real e um centavo')
self.assertEqual(self.n2w.to_currency(Decimal('1.035')), 'um real e três centavos')
self.assertEqual(self.n2w.to_currency(Decimal('1.35')), 'um real e trinta e cinco centavos')
self.assertEqual(self.n2w.to_currency(Decimal('3.14159')), 'três reais e catorze centavos')
self.assertEqual(self.n2w.to_currency(Decimal('101.22')), 'cento e um reais e vinte e dois centavos')
self.assertEqual(self.n2w.to_currency(Decimal('2345.75')), 'dois mil, trezentos e quarenta e cinco reais e setenta e cinco centavos')
def test_currency_float_negative(self):
self.assertEqual(self.n2w.to_currency(Decimal('-2.34')), 'menos dois reais e trinta e quatro centavos')
self.assertEqual(self.n2w.to_currency(Decimal('-9.99')), 'menos nove reais e noventa e nove centavos')
self.assertEqual(self.n2w.to_currency(Decimal('-7.01')), 'menos sete reais e um centavo')
self.assertEqual(self.n2w.to_currency(Decimal('-222.22')), 'menos duzentos e vinte e dois reais e vinte e dois centavos')
def test_year(self):
self.assertEqual(self.n2w.to_year(1001), 'mil e um')
self.assertEqual(self.n2w.to_year(1789), 'mil, setecentos e oitenta e nove')
self.assertEqual(self.n2w.to_year(1942), 'mil, novecentos e quarenta e dois')
self.assertEqual(self.n2w.to_year(1984), 'mil, novecentos e oitenta e quatro')
self.assertEqual(self.n2w.to_year(2000), 'dois mil')
self.assertEqual(self.n2w.to_year(2001), 'dois mil e um')
self.assertEqual(self.n2w.to_year(2016), 'dois mil e dezesseis')
def test_year_negative(self):
self.assertEqual(self.n2w.to_year(-30), 'trinta antes de Cristo')
self.assertEqual(self.n2w.to_year(-744), 'setecentos e quarenta e quatro antes de Cristo')
self.assertEqual(self.n2w.to_year(-10000), 'dez mil antes de Cristo')

31
tests/test_ru.py Normal file
View File

@@ -0,0 +1,31 @@
# -*- encoding: utf-8 -*-
# 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 unittest import TestCase
from num2words import num2words
class Num2WordsRUTest(TestCase):
def test_cardinal(self):
self.assertEqual(num2words(5, lang='ru'), u"пять")
self.assertEqual(num2words(15, lang='ru'), u"пятнадцать")
self.assertEqual(num2words(154, lang='ru'), u"сто пятьдесят четыре")
self.assertEqual(num2words(418531, lang='ru'), u"четыреста восемнадцать тысяч пятьсот тридцать один")
def test_floating_point(self):
self.assertEqual(num2words(5.2, lang='ru'), u"пять запятая два")
self.assertEqual(num2words(561.42, lang='ru'), u"пятьсот шестьдесят один запятая сорок два")