mirror of
https://github.com/bblaz/num2words.git
synced 2025-12-06 06:42:25 +00:00
53b4518afb
Some maintainers for different linux distribution are having some problems with the encoding on different python versions. This change intents to make all python files define explicitly the encoding, license and unix line separators. Remove one example of the README.rst file where a possible non UTF-8 character is used.
396 lines
16 KiB
Python
396 lines
16 KiB
Python
# -*- 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 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 cinco'
|
|
)
|
|
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 um cinco nove'
|
|
)
|
|
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.03')), '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.14')),
|
|
'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')
|