mirror of
https://github.com/bblaz/num2words.git
synced 2025-12-06 06:42:25 +00:00
Merge branch 'master' into master
This commit is contained in:
dazre
GitHub
51
tests/test_de.py
Normal file
51
tests/test_de.py
Normal 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')
|
||||
135
tests/test_it.py
Normal file
135
tests/test_it.py
Normal file
@@ -0,0 +1,135 @@
|
||||
# -*- 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):
|
||||
|
||||
maxDiff = None
|
||||
|
||||
def test_negative(self):
|
||||
number = 648972145
|
||||
pos_crd = num2words(+number, lang="it")
|
||||
neg_crd = num2words(-number, lang="it")
|
||||
pos_ord = num2words(+number, lang="it", ordinal=True)
|
||||
neg_ord = num2words(-number, lang="it", ordinal=True)
|
||||
self.assertEqual("meno " + pos_crd, neg_crd)
|
||||
self.assertEqual("meno " + pos_ord, neg_ord)
|
||||
|
||||
def test_float_to_cardinal(self):
|
||||
self.assertTrue("tre virgola uno quattro uno" in num2words(3.1415, lang="it"))
|
||||
self.assertTrue("meno cinque virgola uno" in num2words(-5.15, lang="it"))
|
||||
self.assertTrue("meno zero virgola uno" in num2words(-0.15, lang="it"))
|
||||
|
||||
def test_float_to_ordinal(self):
|
||||
self.assertTrue("terzo virgola uno quattro uno" in num2words(3.1415, lang="it", ordinal=True))
|
||||
self.assertTrue("meno quinto virgola uno" in num2words(-5.15, lang="it", ordinal=True))
|
||||
self.assertTrue("meno zero virgola uno" in num2words(-0.15, lang="it", ordinal=True))
|
||||
|
||||
def test_0(self):
|
||||
self.assertEqual(num2words(0, lang="it"), "zero")
|
||||
self.assertEqual(num2words(0, lang="it", ordinal=True), "zero")
|
||||
|
||||
def test_1_to_10(self):
|
||||
self.assertEqual(num2words(1, lang="it"), "uno")
|
||||
self.assertEqual(num2words(2, lang="it"), "due")
|
||||
self.assertEqual(num2words(7, lang="it"), "sette")
|
||||
self.assertEqual(num2words(10, lang="it"), "dieci")
|
||||
|
||||
def test_11_to_19(self):
|
||||
self.assertEqual(num2words(11, lang="it"), "undici")
|
||||
self.assertEqual(num2words(13, lang="it"), "tredici")
|
||||
self.assertEqual(num2words(15, lang="it"), "quindici")
|
||||
self.assertEqual(num2words(16, lang="it"), "sedici")
|
||||
self.assertEqual(num2words(19, lang="it"), "diciannove")
|
||||
|
||||
def test_20_to_99(self):
|
||||
self.assertEqual(num2words(20, lang="it"), "venti")
|
||||
self.assertEqual(num2words(23, lang="it"), "ventitré")
|
||||
self.assertEqual(num2words(28, lang="it"), "ventotto")
|
||||
self.assertEqual(num2words(31, lang="it"), "trentuno")
|
||||
self.assertEqual(num2words(40, lang="it"), "quaranta")
|
||||
self.assertEqual(num2words(66, lang="it"), "sessantasei")
|
||||
self.assertEqual(num2words(92, lang="it"), "novantadue")
|
||||
|
||||
def test_100_to_999(self):
|
||||
self.assertEqual(num2words(100, lang="it"), "cento")
|
||||
self.assertEqual(num2words(111, lang="it"), "centoundici")
|
||||
self.assertEqual(num2words(150, lang="it"), "centocinquanta")
|
||||
self.assertEqual(num2words(196, lang="it"), "centonovantasei")
|
||||
self.assertEqual(num2words(200, lang="it"), "duecento")
|
||||
self.assertEqual(num2words(210, lang="it"), "duecentodieci")
|
||||
self.assertEqual(num2words(701, lang="it"), "settecentouno")
|
||||
|
||||
def test_1000_to_9999(self):
|
||||
self.assertEqual(num2words(1000, lang="it"), "mille")
|
||||
self.assertEqual(num2words(1001, lang="it"), "milleuno")
|
||||
self.assertEqual(num2words(1500, lang="it"), "millecinquecento")
|
||||
self.assertEqual(num2words(7378, lang="it"), "settemilatrecentosettantotto")
|
||||
self.assertEqual(num2words(2000, lang="it"), "duemila")
|
||||
self.assertEqual(num2words(2100, lang="it"), "duemilacento")
|
||||
self.assertEqual(num2words(6870, lang="it"), "seimilaottocentosettanta")
|
||||
self.assertEqual(num2words(10000, lang="it"), "diecimila")
|
||||
self.assertEqual(num2words(98765, lang="it"), "novantottomilasettecentosessantacinque")
|
||||
self.assertEqual(num2words(100000, lang="it"), "centomila")
|
||||
self.assertEqual(num2words(523456, lang="it"), "cinquecentoventitremilaquattrocentocinquantasei")
|
||||
|
||||
def test_big(self):
|
||||
self.assertEqual(num2words(1000000, lang="it"), "un milione")
|
||||
self.assertEqual(num2words(1000007, lang="it"), "un milione e sette")
|
||||
self.assertEqual(num2words(1200000, lang="it"), "un milione e duecentomila")
|
||||
self.assertEqual(num2words(3000000, lang="it"), "tre milioni")
|
||||
self.assertEqual(num2words(3000005, lang="it"), "tre milioni e cinque")
|
||||
self.assertEqual(num2words(3800000, lang="it"), "tre milioni e ottocentomila")
|
||||
self.assertEqual(num2words(1000000000, lang="it"), "un miliardo")
|
||||
self.assertEqual(num2words(1000000017, lang="it"), "un miliardo e diciassette")
|
||||
self.assertEqual(num2words(2000000000, lang="it"), "due miliardi")
|
||||
self.assertEqual(num2words(2000001000, lang="it"), "due miliardi e mille")
|
||||
self.assertEqual(num2words(1234567890, lang="it"), "un miliardo, duecentotrentaquattro milioni e cinquecentosessantasettemilaottocentonovanta")
|
||||
self.assertEqual(num2words(1000000000000, lang="it"), "un bilione")
|
||||
self.assertEqual(num2words(123456789012345678901234567890, lang="it"), "centoventitré quadriliardi, quattrocentocinquantasei quadrilioni, settecentottantanove triliardi, dodici trilioni, trecentoquarantacinque biliardi, seicentosettantotto bilioni, novecentouno miliardi, duecentotrentaquattro milioni e cinquecentosessantasettemilaottocentonovanta")
|
||||
|
||||
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(23, lang="it", ordinal=True), "ventitreesimo")
|
||||
self.assertEqual(num2words(47, lang="it", ordinal=True), "quarantasettesimo")
|
||||
self.assertEqual(num2words(99, lang="it", ordinal=True), "novantanovesimo")
|
||||
|
||||
def test_nth_100_to_999(self):
|
||||
self.assertEqual(num2words(100, lang="it", ordinal=True), "centesimo")
|
||||
self.assertEqual(num2words(112, lang="it", ordinal=True), "centododicesimo")
|
||||
self.assertEqual(num2words(120, lang="it", ordinal=True), "centoventesimo")
|
||||
self.assertEqual(num2words(316, lang="it", ordinal=True), "trecentosedicesimo")
|
||||
self.assertEqual(num2words(700, lang="it", ordinal=True), "settecentesimo")
|
||||
self.assertEqual(num2words(803, lang="it", ordinal=True), "ottocentotreesimo")
|
||||
self.assertEqual(num2words(923, lang="it", ordinal=True), "novecentoventitreesimo")
|
||||
|
||||
def test_nth_1000_to_999999(self):
|
||||
self.assertEqual(num2words(1000, lang="it", ordinal=True), "millesimo")
|
||||
self.assertEqual(num2words(1001, lang="it", ordinal=True), "milleunesimo")
|
||||
self.assertEqual(num2words(1003, lang="it", ordinal=True), "milletreesimo")
|
||||
self.assertEqual(num2words(1200, lang="it", ordinal=True), "milleduecentesimo")
|
||||
self.assertEqual(num2words(8640, lang="it", ordinal=True), "ottomilaseicentoquarantesimo")
|
||||
self.assertEqual(num2words(14000, lang="it", ordinal=True), "quattordicimillesimo")
|
||||
self.assertEqual(num2words(123456, lang="it", ordinal=True), "centoventitremilaquattrocentocinquantaseiesimo")
|
||||
self.assertEqual(num2words(987654, lang="it", ordinal=True), "novecentottantasettemilaseicentocinquantaquattresimo")
|
||||
|
||||
def test_nth_big(self):
|
||||
self.assertEqual(num2words(1000000001, lang="it", ordinal=True), "un miliardo e unesimo")
|
||||
self.assertEqual(num2words(123456789012345678901234567890, lang="it", ordinal=True), "centoventitré quadriliardi, quattrocentocinquantasei quadrilioni, settecentottantanove triliardi, dodici trilioni, trecentoquarantacinque biliardi, seicentosettantotto bilioni, novecentouno miliardi, duecentotrentaquattro milioni e cinquecentosessantasettemilaottocentonovantesimo")
|
||||
49
tests/test_pl.py
Normal file
49
tests/test_pl.py
Normal file
@@ -0,0 +1,49 @@
|
||||
# -*- 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
|
||||
from num2words.lang_PL import to_currency
|
||||
|
||||
class Num2WordsPLTest(TestCase):
|
||||
def test_cardinal(self):
|
||||
self.assertEqual(num2words(100, lang='pl'), "sto")
|
||||
self.assertEqual(num2words(101, lang='pl'), "sto jeden")
|
||||
self.assertEqual(num2words(110, lang='pl'), "sto dziesięć")
|
||||
self.assertEqual(num2words(115, lang='pl'), "sto piętnaście")
|
||||
self.assertEqual(num2words(123, lang='pl'), "sto dwadzieścia trzy")
|
||||
self.assertEqual(num2words(1000, lang='pl'), "tysiąc")
|
||||
self.assertEqual(num2words(1001, lang='pl'), "tysiąc jeden")
|
||||
self.assertEqual(num2words(2012, lang='pl'), "dwa tysiące dwanaście")
|
||||
self.assertEqual(num2words(12519.85, lang='pl'), "dwanaście tysięcy pięćset dziewiętnaście przecinek osiemdziesiąt pięć")
|
||||
self.assertEqual(num2words(123.50, lang='pl'), "sto dwadzieścia trzy przecinek pięć")
|
||||
self.assertEqual(num2words(1234567890, lang='pl'), "miliard dwieście trzydzieści cztery miliony pięćset sześćdziesiąt siedem tysięcy osiemset dziewięćdzisiąt")
|
||||
self.assertEqual(num2words(215461407892039002157189883901676, lang='pl'), "dwieście piętnaście kwintylionów czterysta sześćdziesiąt jeden kwadryliardów czterysta siedem kwadrylionów osiemset dziewięćdzisiąt dwa tryliardy trzydzieści dziewięć trylionów dwa biliardy sto pięćdziesiąt siedem bilionów sto osiemdziesiąt dziewięć miliardów osiemset osiemdziesiąt trzy miliony dziewęćset jeden tysięcy sześćset siedemdziesiąt sześć")
|
||||
self.assertEqual(num2words(719094234693663034822824384220291, lang='pl'), "siedemset dziewiętnaście kwintylionów dziewięćdzisiąt cztery kwadryliardy dwieście trzydzieści cztery kwadryliony sześćset dziewięćdzisiąt trzy tryliardy sześćset sześćdziesiąt trzy tryliony trzydzieści cztery biliardy osiemset dwadzieścia dwa biliony osiemset dwadzieścia cztery miliardy trzysta osiemdziesiąt cztery miliony dwieście dwadzieścia tysięcy dwieście dziewięćdzisiąt jeden")
|
||||
|
||||
def test_currency(self):
|
||||
self.assertEqual(to_currency(1.0, 'EUR'), "jeden euro, zero centów")
|
||||
self.assertEqual(to_currency(1.0, 'PLN'), "jeden złoty, zero groszy")
|
||||
self.assertEqual(to_currency(1234.56, 'EUR'), "tysiąc dwieście trzydzieści cztery euro, pięćdziesiąt sześć centów")
|
||||
self.assertEqual(to_currency(1234.56, 'PLN'), "tysiąc dwieście trzydzieści cztery złote, pięćdziesiąt sześć groszy")
|
||||
self.assertEqual(to_currency(10111, 'EUR', seperator=' i'), "sto jeden euro i jedenaście centów")
|
||||
self.assertEqual(to_currency(10121, 'PLN', seperator=' i'), "sto jeden złotych i dwadzieścia jeden groszy")
|
||||
self.assertEqual(to_currency(-1251985, cents = False), "minus dwanaście tysięcy pięćset dziewiętnaście euro, 85 centów")
|
||||
self.assertEqual(to_currency(123.50, 'PLN', seperator=' i'), "sto dwadzieścia trzy złote i pięćdziesiąt groszy")
|
||||
self.assertEqual(to_currency(1950, cents = False), "dziewiętnaście euro, 50 centów")
|
||||
@@ -29,191 +29,191 @@ class Num2WordsPTBRTest(TestCase):
|
||||
self.n2w = Num2Word_PT_BR()
|
||||
|
||||
def test_cardinal_integer(self):
|
||||
self.assertEquals(num2words(1, lang='pt_BR'), 'um')
|
||||
self.assertEquals(num2words(2, lang='pt_BR'), 'dois')
|
||||
self.assertEquals(num2words(3, lang='pt_BR'), 'três')
|
||||
self.assertEquals(num2words(4, lang='pt_BR'), 'quatro')
|
||||
self.assertEquals(num2words(5, lang='pt_BR'), 'cinco')
|
||||
self.assertEquals(num2words(6, lang='pt_BR'), 'seis')
|
||||
self.assertEquals(num2words(7, lang='pt_BR'), 'sete')
|
||||
self.assertEquals(num2words(8, lang='pt_BR'), 'oito')
|
||||
self.assertEquals(num2words(9, lang='pt_BR'), 'nove')
|
||||
self.assertEquals(num2words(10, lang='pt_BR'), 'dez')
|
||||
self.assertEquals(num2words(11, lang='pt_BR'), 'onze')
|
||||
self.assertEquals(num2words(12, lang='pt_BR'), 'doze')
|
||||
self.assertEquals(num2words(13, lang='pt_BR'), 'treze')
|
||||
self.assertEquals(num2words(14, lang='pt_BR'), 'catorze')
|
||||
self.assertEquals(num2words(15, lang='pt_BR'), 'quinze')
|
||||
self.assertEquals(num2words(16, lang='pt_BR'), 'dezesseis')
|
||||
self.assertEquals(num2words(17, lang='pt_BR'), 'dezessete')
|
||||
self.assertEquals(num2words(18, lang='pt_BR'), 'dezoito')
|
||||
self.assertEquals(num2words(19, lang='pt_BR'), 'dezenove')
|
||||
self.assertEquals(num2words(20, lang='pt_BR'), 'vinte')
|
||||
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.assertEquals(num2words(21, lang='pt_BR'), 'vinte e um')
|
||||
self.assertEquals(num2words(22, lang='pt_BR'), 'vinte e dois')
|
||||
self.assertEquals(num2words(35, lang='pt_BR'), 'trinta e cinco')
|
||||
self.assertEquals(num2words(99, lang='pt_BR'), 'noventa e nove')
|
||||
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.assertEquals(num2words(100, lang='pt_BR'), 'cem')
|
||||
self.assertEquals(num2words(101, lang='pt_BR'), 'cento e um')
|
||||
self.assertEquals(num2words(128, lang='pt_BR'), 'cento e vinte e oito')
|
||||
self.assertEquals(num2words(713, lang='pt_BR'), 'setecentos e treze')
|
||||
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.assertEquals(num2words(1000, lang='pt_BR'), 'mil')
|
||||
self.assertEquals(num2words(1001, lang='pt_BR'), 'mil e um')
|
||||
self.assertEquals(num2words(1111, lang='pt_BR'), 'mil, cento e onze')
|
||||
self.assertEquals(num2words(2114, lang='pt_BR'), 'dois mil, cento e catorze')
|
||||
self.assertEquals(num2words(73421, lang='pt_BR'), 'setenta e três mil, quatrocentos e vinte e um')
|
||||
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.assertEquals(num2words(100000, lang='pt_BR'), 'cem mil')
|
||||
self.assertEquals(num2words(250050, lang='pt_BR'), 'duzentos e cinquenta mil e cinquenta')
|
||||
self.assertEquals(num2words(6000000, lang='pt_BR'), 'seis milhões')
|
||||
self.assertEquals(num2words(19000000000, lang='pt_BR'), 'dezenove bilhões')
|
||||
self.assertEquals(num2words(145000000002, lang='pt_BR'), 'cento e quarenta e cinco bilhões e dois')
|
||||
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.assertEquals(num2words(-1, lang='pt_BR'), 'menos um')
|
||||
self.assertEquals(num2words(-256, lang='pt_BR'), 'menos duzentos e cinquenta e seis')
|
||||
self.assertEquals(num2words(-1000, lang='pt_BR'), 'menos mil')
|
||||
self.assertEquals(num2words(-1000000, lang='pt_BR'), 'menos um milhão')
|
||||
self.assertEquals(num2words(-1234567, lang='pt_BR'), 'menos um milhão, duzentos e trinta e quatro mil, quinhentos e sessenta e sete')
|
||||
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.assertEquals(num2words(Decimal('1.00'), lang='pt_BR'), 'um')
|
||||
self.assertEquals(num2words(Decimal('1.01'), lang='pt_BR'), 'um ponto zero um')
|
||||
self.assertEquals(num2words(Decimal('1.035'), lang='pt_BR'), 'um ponto zero três')
|
||||
self.assertEquals(num2words(Decimal('1.35'), lang='pt_BR'), 'um ponto três cinco')
|
||||
self.assertEquals(num2words(Decimal('3.14159'), lang='pt_BR'), 'três ponto um quatro')
|
||||
self.assertEquals(num2words(Decimal('101.22'), lang='pt_BR'), 'cento e um ponto dois dois')
|
||||
self.assertEquals(num2words(Decimal('2345.75'), lang='pt_BR'), 'dois mil, trezentos e quarenta e cinco ponto sete cinco')
|
||||
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.assertEquals(num2words(Decimal('-2.34'), lang='pt_BR'), 'menos dois ponto três quatro')
|
||||
self.assertEquals(num2words(Decimal('-9.99'), lang='pt_BR'), 'menos nove ponto nove nove')
|
||||
self.assertEquals(num2words(Decimal('-7.01'), lang='pt_BR'), 'menos sete ponto zero um')
|
||||
self.assertEquals(num2words(Decimal('-222.22'), lang='pt_BR'), 'menos duzentos e vinte e dois ponto dois dois')
|
||||
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.assertEquals(num2words(1, lang='pt_BR', ordinal=True), 'primeiro')
|
||||
self.assertEquals(num2words(2, lang='pt_BR', ordinal=True), 'segundo')
|
||||
self.assertEquals(num2words(3, lang='pt_BR', ordinal=True), 'terceiro')
|
||||
self.assertEquals(num2words(4, lang='pt_BR', ordinal=True), 'quarto')
|
||||
self.assertEquals(num2words(5, lang='pt_BR', ordinal=True), 'quinto')
|
||||
self.assertEquals(num2words(6, lang='pt_BR', ordinal=True), 'sexto')
|
||||
self.assertEquals(num2words(7, lang='pt_BR', ordinal=True), 'sétimo')
|
||||
self.assertEquals(num2words(8, lang='pt_BR', ordinal=True), 'oitavo')
|
||||
self.assertEquals(num2words(9, lang='pt_BR', ordinal=True), 'nono')
|
||||
self.assertEquals(num2words(10, lang='pt_BR', ordinal=True), 'décimo')
|
||||
self.assertEquals(num2words(11, lang='pt_BR', ordinal=True), 'décimo primeiro')
|
||||
self.assertEquals(num2words(12, lang='pt_BR', ordinal=True), 'décimo segundo')
|
||||
self.assertEquals(num2words(13, lang='pt_BR', ordinal=True), 'décimo terceiro')
|
||||
self.assertEquals(num2words(14, lang='pt_BR', ordinal=True), 'décimo quarto')
|
||||
self.assertEquals(num2words(15, lang='pt_BR', ordinal=True), 'décimo quinto')
|
||||
self.assertEquals(num2words(16, lang='pt_BR', ordinal=True), 'décimo sexto')
|
||||
self.assertEquals(num2words(17, lang='pt_BR', ordinal=True), 'décimo sétimo')
|
||||
self.assertEquals(num2words(18, lang='pt_BR', ordinal=True), 'décimo oitavo')
|
||||
self.assertEquals(num2words(19, lang='pt_BR', ordinal=True), 'décimo nono')
|
||||
self.assertEquals(num2words(20, lang='pt_BR', ordinal=True), 'vigésimo')
|
||||
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.assertEquals(num2words(21, lang='pt_BR', ordinal=True), 'vigésimo primeiro')
|
||||
self.assertEquals(num2words(22, lang='pt_BR', ordinal=True), 'vigésimo segundo')
|
||||
self.assertEquals(num2words(35, lang='pt_BR', ordinal=True), 'trigésimo quinto')
|
||||
self.assertEquals(num2words(99, lang='pt_BR', ordinal=True), 'nonagésimo nono')
|
||||
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.assertEquals(num2words(100, lang='pt_BR', ordinal=True), 'centésimo')
|
||||
self.assertEquals(num2words(101, lang='pt_BR', ordinal=True), 'centésimo primeiro')
|
||||
self.assertEquals(num2words(128, lang='pt_BR', ordinal=True), 'centésimo vigésimo oitavo')
|
||||
self.assertEquals(num2words(713, lang='pt_BR', ordinal=True), 'septigentésimo décimo terceiro')
|
||||
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.assertEquals(num2words(1000, lang='pt_BR', ordinal=True), 'milésimo')
|
||||
self.assertEquals(num2words(1001, lang='pt_BR', ordinal=True), 'milésimo primeiro')
|
||||
self.assertEquals(num2words(1111, lang='pt_BR', ordinal=True), 'milésimo centésimo décimo primeiro')
|
||||
self.assertEquals(num2words(2114, lang='pt_BR', ordinal=True), 'segundo milésimo centésimo décimo quarto')
|
||||
self.assertEquals(num2words(73421, lang='pt_BR', ordinal=True), 'septuagésimo terceiro milésimo quadrigentésimo vigésimo primeiro')
|
||||
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.assertEquals(num2words(100000, lang='pt_BR', ordinal=True), 'centésimo milésimo')
|
||||
self.assertEquals(num2words(250050, lang='pt_BR', ordinal=True), 'ducentésimo quinquagésimo milésimo quinquagésimo')
|
||||
self.assertEquals(num2words(6000000, lang='pt_BR', ordinal=True), 'sexto milionésimo')
|
||||
self.assertEquals(num2words(19000000000, lang='pt_BR', ordinal=True), 'décimo nono bilionésimo')
|
||||
self.assertEquals(num2words(145000000002, lang='pt_BR', ordinal=True), 'centésimo quadragésimo quinto bilionésimo segundo')
|
||||
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.assertEquals(self.n2w.to_currency(1), 'um real')
|
||||
self.assertEquals(self.n2w.to_currency(2), 'dois reais')
|
||||
self.assertEquals(self.n2w.to_currency(3), 'três reais')
|
||||
self.assertEquals(self.n2w.to_currency(4), 'quatro reais')
|
||||
self.assertEquals(self.n2w.to_currency(5), 'cinco reais')
|
||||
self.assertEquals(self.n2w.to_currency(6), 'seis reais')
|
||||
self.assertEquals(self.n2w.to_currency(7), 'sete reais')
|
||||
self.assertEquals(self.n2w.to_currency(8), 'oito reais')
|
||||
self.assertEquals(self.n2w.to_currency(9), 'nove reais')
|
||||
self.assertEquals(self.n2w.to_currency(10), 'dez reais')
|
||||
self.assertEquals(self.n2w.to_currency(11), 'onze reais')
|
||||
self.assertEquals(self.n2w.to_currency(12), 'doze reais')
|
||||
self.assertEquals(self.n2w.to_currency(13), 'treze reais')
|
||||
self.assertEquals(self.n2w.to_currency(14), 'catorze reais')
|
||||
self.assertEquals(self.n2w.to_currency(15), 'quinze reais')
|
||||
self.assertEquals(self.n2w.to_currency(16), 'dezesseis reais')
|
||||
self.assertEquals(self.n2w.to_currency(17), 'dezessete reais')
|
||||
self.assertEquals(self.n2w.to_currency(18), 'dezoito reais')
|
||||
self.assertEquals(self.n2w.to_currency(19), 'dezenove reais')
|
||||
self.assertEquals(self.n2w.to_currency(20), 'vinte reais')
|
||||
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.assertEquals(self.n2w.to_currency(21), 'vinte e um reais')
|
||||
self.assertEquals(self.n2w.to_currency(22), 'vinte e dois reais')
|
||||
self.assertEquals(self.n2w.to_currency(35), 'trinta e cinco reais')
|
||||
self.assertEquals(self.n2w.to_currency(99), 'noventa e nove 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.assertEquals(self.n2w.to_currency(100), 'cem reais')
|
||||
self.assertEquals(self.n2w.to_currency(101), 'cento e um reais')
|
||||
self.assertEquals(self.n2w.to_currency(128), 'cento e vinte e oito reais')
|
||||
self.assertEquals(self.n2w.to_currency(713), 'setecentos e treze 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.assertEquals(self.n2w.to_currency(1000), 'mil reais')
|
||||
self.assertEquals(self.n2w.to_currency(1001), 'mil e um reais')
|
||||
self.assertEquals(self.n2w.to_currency(1111), 'mil, cento e onze reais')
|
||||
self.assertEquals(self.n2w.to_currency(2114), 'dois mil, cento e catorze reais')
|
||||
self.assertEquals(self.n2w.to_currency(73421), 'setenta e três mil, quatrocentos e vinte e um 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.assertEquals(self.n2w.to_currency(100000), 'cem mil reais')
|
||||
self.assertEquals(self.n2w.to_currency(250050), 'duzentos e cinquenta mil e cinquenta reais')
|
||||
self.assertEquals(self.n2w.to_currency(6000000), 'seis milhões de reais')
|
||||
self.assertEquals(self.n2w.to_currency(19000000000), 'dezenove bilhões de reais')
|
||||
self.assertEquals(self.n2w.to_currency(145000000002), 'cento e quarenta e cinco bilhões e dois 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.assertEquals(self.n2w.to_currency(-1), 'menos um real')
|
||||
self.assertEquals(self.n2w.to_currency(-256), 'menos duzentos e cinquenta e seis reais')
|
||||
self.assertEquals(self.n2w.to_currency(-1000), 'menos mil reais')
|
||||
self.assertEquals(self.n2w.to_currency(-1000000), 'menos um milhão de reais')
|
||||
self.assertEquals(self.n2w.to_currency(-1234567), 'menos um milhão, duzentos e trinta e quatro mil, quinhentos e sessenta e sete reais')
|
||||
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.assertEquals(self.n2w.to_currency(Decimal('1.00')), 'um real')
|
||||
self.assertEquals(self.n2w.to_currency(Decimal('1.01')), 'um real e um centavo')
|
||||
self.assertEquals(self.n2w.to_currency(Decimal('1.035')), 'um real e três centavos')
|
||||
self.assertEquals(self.n2w.to_currency(Decimal('1.35')), 'um real e trinta e cinco centavos')
|
||||
self.assertEquals(self.n2w.to_currency(Decimal('3.14159')), 'três reais e catorze centavos')
|
||||
self.assertEquals(self.n2w.to_currency(Decimal('101.22')), 'cento e um reais e vinte e dois centavos')
|
||||
self.assertEquals(self.n2w.to_currency(Decimal('2345.75')), 'dois mil, trezentos e quarenta e cinco reais e setenta e cinco centavos')
|
||||
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.assertEquals(self.n2w.to_currency(Decimal('-2.34')), 'menos dois reais e trinta e quatro centavos')
|
||||
self.assertEquals(self.n2w.to_currency(Decimal('-9.99')), 'menos nove reais e noventa e nove centavos')
|
||||
self.assertEquals(self.n2w.to_currency(Decimal('-7.01')), 'menos sete reais e um centavo')
|
||||
self.assertEquals(self.n2w.to_currency(Decimal('-222.22')), 'menos duzentos e vinte e dois reais e vinte e dois centavos')
|
||||
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.assertEquals(self.n2w.to_year(1001), 'mil e um')
|
||||
self.assertEquals(self.n2w.to_year(1789), 'mil, setecentos e oitenta e nove')
|
||||
self.assertEquals(self.n2w.to_year(1942), 'mil, novecentos e quarenta e dois')
|
||||
self.assertEquals(self.n2w.to_year(1984), 'mil, novecentos e oitenta e quatro')
|
||||
self.assertEquals(self.n2w.to_year(2000), 'dois mil')
|
||||
self.assertEquals(self.n2w.to_year(2001), 'dois mil e um')
|
||||
self.assertEquals(self.n2w.to_year(2016), 'dois mil e dezesseis')
|
||||
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.assertEquals(self.n2w.to_year(-30), 'trinta antes de Cristo')
|
||||
self.assertEquals(self.n2w.to_year(-744), 'setecentos e quarenta e quatro antes de Cristo')
|
||||
self.assertEquals(self.n2w.to_year(-10000), 'dez mil antes de Cristo')
|
||||
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')
|
||||
|
||||
106
tests/test_vn.py
Normal file
106
tests/test_vn.py
Normal file
@@ -0,0 +1,106 @@
|
||||
# -*- 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 Num2WordsVNTest(TestCase):
|
||||
|
||||
|
||||
def test_0(self):
|
||||
self.assertEqual(num2words(0, lang="vi_VN"), "không")
|
||||
|
||||
def test_1_to_10(self):
|
||||
self.assertEqual(num2words(1, lang="vi_VN"), "một")
|
||||
self.assertEqual(num2words(2, lang="vi_VN"), "hai")
|
||||
self.assertEqual(num2words(7, lang="vi_VN"), "bảy")
|
||||
self.assertEqual(num2words(10, lang="vi_VN"), "mười")
|
||||
|
||||
def test_11_to_19(self):
|
||||
self.assertEqual(num2words(11, lang="vi_VN"), "mười một")
|
||||
self.assertEqual(num2words(13, lang="vi_VN"), "mười ba")
|
||||
self.assertEqual(num2words(14, lang="vi_VN"), "mười bốn")
|
||||
self.assertEqual(num2words(15, lang="vi_VN"), "mười lăm")
|
||||
self.assertEqual(num2words(16, lang="vi_VN"), "mười sáu")
|
||||
self.assertEqual(num2words(19, lang="vi_VN"), "mười chín")
|
||||
|
||||
def test_20_to_99(self):
|
||||
self.assertEqual(num2words(20, lang="vi_VN"), "hai mươi")
|
||||
self.assertEqual(num2words(23, lang="vi_VN"), "hai mươi ba")
|
||||
self.assertEqual(num2words(28, lang="vi_VN"), "hai mươi tám")
|
||||
self.assertEqual(num2words(31, lang="vi_VN"), "ba mươi mốt")
|
||||
self.assertEqual(num2words(40, lang="vi_VN"), "bốn mươi")
|
||||
self.assertEqual(num2words(66, lang="vi_VN"), "sáu mươi sáu")
|
||||
self.assertEqual(num2words(92, lang="vi_VN"), "chín mươi hai")
|
||||
|
||||
def test_100_to_999(self):
|
||||
self.assertEqual(num2words(100, lang="vi_VN"), "một trăm")
|
||||
self.assertEqual(num2words(150, lang="vi_VN"), "một trăm năm mươi")
|
||||
self.assertEqual(num2words(196, lang="vi_VN"), "một trăm chín mươi sáu")
|
||||
self.assertEqual(num2words(200, lang="vi_VN"), "hai trăm")
|
||||
self.assertEqual(num2words(210, lang="vi_VN"), "hai trăm mười")
|
||||
|
||||
def test_1000_to_9999(self):
|
||||
self.assertEqual(num2words(1000, lang="vi_VN"), "một nghìn")
|
||||
self.assertEqual(num2words(1500, lang="vi_VN"), "một nghìn năm trăm")
|
||||
self.assertEqual(num2words(7378, lang="vi_VN"), "bảy nghìn ba trăm bảy mươi tám")
|
||||
self.assertEqual(num2words(2000, lang="vi_VN"), "hai nghìn")
|
||||
self.assertEqual(num2words(2100, lang="vi_VN"), "hai nghìn một trăm")
|
||||
self.assertEqual(num2words(6870, lang="vi_VN"), "sáu nghìn tám trăm bảy mươi")
|
||||
self.assertEqual(num2words(10000, lang="vi_VN"), "mười nghìn")
|
||||
self.assertEqual(num2words(100000, lang="vi_VN"), "một trăm nghìn")
|
||||
self.assertEqual(num2words(523456, lang="vi_VN"), "năm trăm hai mươi ba nghìn bốn trăm năm mươi sáu")
|
||||
|
||||
def test_big(self):
|
||||
self.assertEqual(num2words(1000000, lang="vi_VN"), "một triệu")
|
||||
self.assertEqual(num2words(1200000, lang="vi_VN"), "một triệu hai trăm nghìn")
|
||||
self.assertEqual(num2words(3000000, lang="vi_VN"), "ba triệu")
|
||||
self.assertEqual(num2words(3800000, lang="vi_VN"), "ba triệu tám trăm nghìn")
|
||||
self.assertEqual(num2words(1000000000, lang="vi_VN"), "một tỷ")
|
||||
self.assertEqual(num2words(2000000000, lang="vi_VN"), "hai tỷ")
|
||||
self.assertEqual(num2words(2000001000, lang="vi_VN"), "hai tỷ một nghìn")
|
||||
self.assertEqual(num2words(1234567890, lang="vi_VN"), "một tỷ hai trăm ba mươi bốn triệu năm trăm sáu mươi bảy nghìn tám trăm chín mươi")
|
||||
|
||||
|
||||
def test_decimal_number(self):
|
||||
self.assertEqual(num2words(1000.11, lang="vi_VN"), "một nghìn phẩy mười một")
|
||||
self.assertEqual(num2words(1000.21, lang="vi_VN"), "một nghìn phẩy hai mươi mốt")
|
||||
|
||||
def test_special_number(self):
|
||||
"""
|
||||
Some number will have some specail rule
|
||||
"""
|
||||
self.assertEqual(num2words(21, lang="vi_VN"), "hai mươi mốt")
|
||||
self.assertEqual(num2words(25, lang="vi_VN"), "hai mươi lăm")
|
||||
# >100
|
||||
self.assertEqual(num2words(101, lang="vi_VN"), "một trăm lẻ một")
|
||||
self.assertEqual(num2words(105, lang="vi_VN"), "một trăm lẻ năm")
|
||||
self.assertEqual(num2words(701, lang="vi_VN"), "bảy trăm lẻ một")
|
||||
self.assertEqual(num2words(705, lang="vi_VN"), "bảy trăm lẻ năm")
|
||||
|
||||
# >1000
|
||||
self.assertEqual(num2words(1001, lang="vi_VN"), "một nghìn lẻ một")
|
||||
self.assertEqual(num2words(1005, lang="vi_VN"), "một nghìn lẻ năm")
|
||||
self.assertEqual(num2words(98765, lang="vi_VN"), "chín mươi tám nghìn bảy trăm sáu mươi lăm")
|
||||
|
||||
# > 1000000
|
||||
self.assertEqual(num2words(3000005, lang="vi_VN"), "ba triệu lẻ năm")
|
||||
self.assertEqual(num2words(1000007, lang="vi_VN"), "một triệu lẻ bảy")
|
||||
|
||||
# > 1000000000
|
||||
self.assertEqual(num2words(1000000017, lang="vi_VN"), "một tỷ lẻ mười bảy")
|
||||
self.assertEqual(num2words(1000101017, lang="vi_VN"), "một tỷ một trăm lẻ một nghìn lẻ mười bảy")
|
||||
Reference in New Issue
Block a user