Merge branch 'master' into master

tests/test_cz.py

@@ -32,6 +32,14 @@ class Num2WordsCZTest(TestCase):
         self.assertEqual(num2words(1000, lang='cz'), "tisíc")
         self.assertEqual(num2words(1001, lang='cz'), "tisíc jedna")
         self.assertEqual(num2words(2012, lang='cz'), "dva tisíce dvanáct")
+        self.assertEqual(
+            num2words(10.02, lang='cz'),
+            "deset celá nula dva"
+        )
+        self.assertEqual(
+            num2words(15.007, lang='cz'),
+            "patnáct celá nula nula sedm"
+        )
         self.assertEqual(
             num2words(12519.85, lang='cz'),
             "dvanáct tisíc pětset devatenáct celá osmdesát pět"

tests/test_kz.py

@@ -44,6 +44,14 @@ class Num2WordsKZTest(TestCase):
         self.assertEqual(num2words(100.67, lang="kz"), "жүз бүтін алпыс жеті")
         self.assertEqual(num2words(0.7, lang="kz"), "нөл бүтін жеті")
         self.assertEqual(num2words(1.73, lang="kz"), "бір бүтін жетпіс үш")
+        self.assertEqual(
+            num2words(10.02, lang='kz'),
+            "он бүтін нөл екі"
+        )
+        self.assertEqual(
+            num2words(15.007, lang='kz'),
+            "он бес бүтін нөл нөл жеті"
+        )
 
     def test_to_ordinal(self):
         with self.assertRaises(NotImplementedError):

tests/test_lt.py

@@ -68,6 +68,14 @@ class Num2WordsLTTest(TestCase):
             num2words(-5000.22, lang='lt'),
             'minus penki tūkstančiai kablelis dvidešimt du',
         )
+        self.assertEqual(
+            num2words(10.02, lang='lt'),
+            "dešimt kablelis nulis du"
+        )
+        self.assertEqual(
+            num2words(15.007, lang='lt'),
+            "penkiolika kablelis nulis nulis septyni"
+        )
 
     def test_to_ordinal(self):
         # @TODO: implement to_ordinal

tests/test_lv.py

@@ -63,6 +63,14 @@ class Num2WordsLVTest(TestCase):
             num2words(-5000.22, lang='lv'),
             'mīnus pieci tūkstoši komats divdesmit divi',
         )
+        self.assertEqual(
+            num2words(10.02, lang='lv'),
+            "desmit komats nulle divi"
+        )
+        self.assertEqual(
+            num2words(15.007, lang='lv'),
+            "piecpadsmit komats nulle nulle septiņi"
+        )
 
         self.assertEqual(num2words(0, lang='lv'), 'nulle')
         self.assertEqual(num2words(5, lang='lv'), "pieci")

tests/test_pl.py

@@ -32,6 +32,14 @@ class Num2WordsPLTest(TestCase):
         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(10.02, lang='pl'),
+            "dziesięć przecinek zero dwa"
+        )
+        self.assertEqual(
+            num2words(15.007, lang='pl'),
+            "piętnaście przecinek zero zero siedem"
+        )
         self.assertEqual(
             num2words(12519.85, lang='pl'),
             "dwanaście tysięcy pięćset dziewiętnaście przecinek "
@@ -83,9 +91,32 @@ class Num2WordsPLTest(TestCase):
         )
 
     def test_to_ordinal(self):
-        # @TODO: implement to_ordinal
-        with self.assertRaises(NotImplementedError):
-            num2words(1, lang='pl', to='ordinal')
+        self.assertEqual(num2words(100, lang='pl', to='ordinal'), "setny")
+        self.assertEqual(
+            num2words(101, lang='pl', to='ordinal'), "sto pierwszy")
+        self.assertEqual(num2words(121, lang='pl', to='ordinal'),
+                         "sto dwudziesty pierwszy")
+        self.assertEqual(
+            num2words(115, lang='pl', to='ordinal'), "sto piętnasty")
+        self.assertEqual(
+            num2words(25, lang='pl', to='ordinal'), "dwudziesty piąty")
+        self.assertEqual(num2words(1021, lang='pl', to='ordinal'),
+                         "tysiąc dwudziesty pierwszy")
+        self.assertEqual(
+            num2words(120, lang='pl', to='ordinal'), "sto dwudziesty")
+        self.assertEqual(num2words(1000021, lang='pl',
+                                   to='ordinal'), "milion dwudziesty pierwszy")
+        self.assertEqual(num2words(1000, lang='pl', to='ordinal'), "tysięczny")
+        self.assertEqual(num2words(10000, lang='pl',
+                                   to='ordinal'), "dziesięciotysięczny")
+        self.assertEqual(num2words(100000000, lang='pl',
+                                   to='ordinal'), "stumilionowy")
+        self.assertEqual(num2words(1002000, lang='pl',
+                                   to='ordinal'), "milion dwutysięczny")
+        self.assertEqual(num2words(1001000, lang='pl',
+                                   to='ordinal'), "milion tysięczny")
+        self.assertEqual(num2words(1000000, lang='pl',
+                                   to='ordinal'), "milionowy")
 
     def test_currency(self):
         self.assertEqual(

tests/test_ru.py

@@ -75,6 +75,14 @@ class Num2WordsRUTest(TestCase):
 
     def test_floating_point(self):
         self.assertEqual(num2words(5.2, lang='ru'), "пять запятая два")
+        self.assertEqual(
+            num2words(10.02, lang='ru'),
+            "десять запятая ноль два"
+        )
+        self.assertEqual(
+            num2words(15.007, lang='ru'),
+            "пятнадцать запятая ноль ноль семь"
+        )
         self.assertEqual(
             num2words(561.42, lang='ru'),
             "пятьсот шестьдесят один запятая сорок два"
@@ -160,6 +168,10 @@ class Num2WordsRUTest(TestCase):
             num2words(1.0, lang='ru', to='currency', currency='RUB'),
             'один рубль, ноль копеек'
         )
+        self.assertEqual(
+            num2words(1.0, lang='ru', to='currency', currency='UAH'),
+            'одна гривна, ноль копеек'
+        )
         self.assertEqual(
             num2words(1234.56, lang='ru', to='currency', currency='EUR'),
             'одна тысяча двести тридцать четыре евро, пятьдесят шесть центов'
@@ -168,36 +180,85 @@ class Num2WordsRUTest(TestCase):
             num2words(1234.56, lang='ru', to='currency', currency='RUB'),
             'одна тысяча двести тридцать четыре рубля, пятьдесят шесть копеек'
         )
+        self.assertEqual(
+            num2words(1234.56, lang='ru', to='currency', currency='UAH'),
+            'одна тысяча двести тридцать четыре гривны, пятьдесят шесть копеек'
+        )
         self.assertEqual(
             num2words(10111, lang='ru', to='currency', currency='EUR',
                       separator=' и'),
             'сто один евро и одиннадцать центов'
         )
         self.assertEqual(
-            num2words(10121, lang='ru', to='currency', currency='RUB',
+            num2words(10111, lang='ru', to='currency', currency='RUB',
                       separator=' и'),
-            'сто один рубль и двадцать одна копейка'
+            'сто один рубль и одиннадцать копеек'
         )
         self.assertEqual(
-            num2words(10122, lang='ru', to='currency', currency='RUB',
+            num2words(10111, lang='ru', to='currency', currency='UAH',
                       separator=' и'),
-            'сто один рубль и двадцать две копейки'
+            'сто одна гривна и одиннадцать копеек'
         )
         self.assertEqual(
             num2words(10121, lang='ru', to='currency', currency='EUR',
                       separator=' и'),
             'сто один евро и двадцать один цент'
         )
+        self.assertEqual(
+            num2words(10121, lang='ru', to='currency', currency='RUB',
+                      separator=' и'),
+            'сто один рубль и двадцать одна копейка'
+        )
+        self.assertEqual(
+            num2words(10121, lang='ru', to='currency', currency='UAH',
+                      separator=' и'),
+            'сто одна гривна и двадцать одна копейка'
+        )
+        self.assertEqual(
+            num2words(10122, lang='ru', to='currency', currency='EUR',
+                      separator=' и'),
+            'сто один евро и двадцать два цента'
+        )
+        self.assertEqual(
+            num2words(10122, lang='ru', to='currency', currency='RUB',
+                      separator=' и'),
+            'сто один рубль и двадцать две копейки'
+        )
+        self.assertEqual(
+            num2words(10122, lang='ru', to='currency', currency='UAH',
+                      separator=' и'),
+            'сто одна гривна и двадцать две копейки'
+        )
         self.assertEqual(
             num2words(-1251985, lang='ru', to='currency', currency='EUR',
                       cents=False),
             'минус двенадцать тысяч пятьсот девятнадцать евро, 85 центов'
         )
+        self.assertEqual(
+            num2words(-1251985, lang='ru', to='currency', currency='RUB',
+                      cents=False),
+            'минус двенадцать тысяч пятьсот девятнадцать рублей, 85 копеек'
+        )
+        self.assertEqual(
+            num2words(-1251985, lang='ru', to='currency', currency='UAH',
+                      cents=False),
+            'минус двенадцать тысяч пятьсот девятнадцать гривен, 85 копеек'
+        )
         self.assertEqual(
             num2words('38.4', lang='ru', to='currency', separator=' и',
                       cents=False, currency='EUR'),
             "тридцать восемь евро и 40 центов"
         )
+        self.assertEqual(
+            num2words('38.4', lang='ru', to='currency', separator=' и',
+                      cents=False, currency='RUB'),
+            "тридцать восемь рублей и 40 копеек"
+        )
+        self.assertEqual(
+            num2words('38.4', lang='ru', to='currency', separator=' и',
+                      cents=False, currency='UAH'),
+            "тридцать восемь гривен и 40 копеек"
+        )
         self.assertEqual(
             num2words('1230.56', lang='ru', to='currency', currency='USD'),
             'одна тысяча двести тридцать долларов, пятьдесят шесть центов'

tests/test_sr.py

@@ -86,6 +86,14 @@ class Num2WordsSRTest(TestCase):
 
     def test_floating_point(self):
         self.assertEqual("pet zapeta dva", num2words(5.2, lang='sr'))
+        self.assertEqual(
+            num2words(10.02, lang='sr'),
+            "deset zapeta nula dva"
+        )
+        self.assertEqual(
+            num2words(15.007, lang='sr'),
+            "petnaest zapeta nula nula sedam"
+        )
         self.assertEqual(
             "petsto šezdeset jedan zapeta četrdeset dva",
             num2words(561.42, lang='sr')

tests/test_sv.py

@@ -0,0 +1,70 @@
+# 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 Num2WordsSVTest(TestCase):
+    def test_ordinal(self):
+        self.assertEqual(num2words(14, to="ordinal", lang="sv"), "fjortonde")
+        self.assertEqual(num2words(1435, to="ordinal", lang="sv"),
+                         "etttusen fyrahundratrettiofemte")
+        self.assertEqual(num2words(32, to="ordinal", lang="sv"),
+                         "trettioandra")
+        self.assertEqual(num2words(1, to="ordinal", lang="sv"), "första")
+        self.assertEqual(num2words(5, to="ordinal", lang="sv"), "femte")
+        self.assertEqual(num2words(10, to="ordinal", lang="sv"), "tionde")
+
+    def test_cardinal(self):
+        self.assertEqual(num2words(0, to="cardinal", lang="sv"), "noll")
+        self.assertEqual(num2words(1, to="cardinal", lang="sv"), "ett")
+        self.assertEqual(num2words(3, to="cardinal", lang="sv"), "tre")
+        self.assertEqual(num2words(5, to="cardinal", lang="sv"), "fem")
+        self.assertEqual(num2words(18, to="cardinal", lang="sv"), "arton")
+        self.assertEqual(num2words(45, to="cardinal", lang="sv"), "förtiofem")
+        self.assertEqual(num2words(1345, to="cardinal", lang="sv"),
+                         "etttusen trehundraförtiofem")
+        self.assertEqual(num2words(4435, to="cardinal", lang="sv"),
+                         "fyratusen fyrahundratrettiofem")
+        self.assertEqual(num2words(1004135, to="cardinal", lang="sv"),
+                         "en miljon fyratusen etthundratrettiofem")
+        self.assertEqual(num2words(4335000, to="cardinal", lang="sv"),
+                         "fyra miljoner trehundratrettiofemtusen")
+        self.assertEqual(num2words(14004535, to="cardinal", lang="sv"),
+                         "fjorton miljoner fyratusen femhundratrettiofem")
+        self.assertEqual(num2words(1.5, to="cardinal", lang="sv"),
+                         "ett komma fem")
+
+    def test_not_implemented_options(self):
+        with self.assertRaises(NotImplementedError) as context:
+            num2words(1235, to="year", lang="sv")
+        self.assertTrue("'year' is not implemented for swedish language"
+                        in str(context.exception))
+
+        with self.assertRaises(NotImplementedError) as context:
+            num2words(1235, to="currency", lang="sv")
+        self.assertTrue("'currency' is not implemented for swedish language"
+                        in str(context.exception))
+
+        with self.assertRaises(NotImplementedError) as context:
+            num2words(1235, to="ordinal_num", lang="sv")
+        self.assertTrue("'ordinal_num' is not implemented for swedish language"
+                        in str(context.exception))

tests/test_tr.py

@@ -36,6 +36,7 @@ class Num2WordsTRTest(TestCase):
              "expected": u"birmilyonikibinbirlira"},
             {"test": 1100000, "to": "currency",
              "expected": u"birmilyonyüzbinlira"},
+            {"test": 0, "to": "ordinal", "expected": u"sıfırıncı"},
             {"test": 1, "to": "ordinal", "expected": u"birinci"},
             {"test": 2, "to": "ordinal", "expected": u"ikinci"},
             {"test": 9, "to": "ordinal", "expected": u"dokuzuncu"},
@@ -108,6 +109,7 @@ class Num2WordsTRTest(TestCase):
              "expected": u"birmilyonüçbininci"},
             {"test": 1200000, "to": "ordinal",
              "expected": u"birmilyonikiyüzbininci"},
+            {"test": 0, "to": "cardinal", "expected": u"sıfır"},
             {"test": 1, "to": "cardinal", "expected": u"bir"},
             {"test": 2, "to": "cardinal", "expected": u"iki"},
             {"test": 9, "to": "cardinal", "expected": u"dokuz"},