tests.py

# -*- coding: utf-8 -*-
'''
Created on
@author:
'''
import unittest
from grammar_be.num2t4be import num2text_ordinal, num2text_numerical

from ru_number_to_text.num2t4ru import num2text, decimal2text
from grammar_be.num2t4be import vars

class TestStrToText(unittest.TestCase):
    def test_units(self):
        self.assertEqual(num2text(0), u'нуль')
        self.assertEqual(num2text(1), u'адзін')
        self.assertEqual(num2text(9), u'дзевяць')

    def test_gender(self):
        self.assertEqual(num2text(1000), u'адна тысяча')
        self.assertEqual(num2text(2000), u'дзве тысячы')
        self.assertEqual(num2text(1000000), u'адзін мільён')
        self.assertEqual(num2text(2000000), u'два мільёны')

    def test_teens(self):
        self.assertEqual(num2text(10), u'дзесяць')
        self.assertEqual(num2text(11), u'адзінаццаць')
        self.assertEqual(num2text(19), u'дзевятнаццаць')

    def test_tens(self):
        self.assertEqual(num2text(20), u'дваццаць')
        self.assertEqual(num2text(90), u'дзевяноста')

    def test_hundreeds(self):
        self.assertEqual(num2text(100), u'сто')
        self.assertEqual(num2text(900), u'дзевяцьсот')

    def test_orders(self):
        self.assertEqual(num2text(1000), u'адна тысяча')
        self.assertEqual(num2text(2000), u'дзве тысячы')
        self.assertEqual(num2text(5000), u'пяць тысяч')
        self.assertEqual(num2text(1000000), u'адзін мільён')
        self.assertEqual(num2text(2000000), u'два мільёны')
        self.assertEqual(num2text(5000000), u'пяць мільёнаў')
        self.assertEqual(num2text(1000000000), u'адзін мільярд')
        self.assertEqual(num2text(2000000000), u'два мільярды')
        self.assertEqual(num2text(5000000000), u'пяць мільярдаў')

    def test_inter_orders(self):
        self.assertEqual(num2text(1100), u'адна тысяча сто')
        self.assertEqual(num2text(2001), u'дзве тысячы адзін')
        self.assertEqual(num2text(5011), u'пяць тысяч адзінаццаць')
        self.assertEqual(num2text(1002000), u'адзін мільён дзве тысячы')
        self.assertEqual(num2text(2020000), u'два мільёны дваццаць тысяч')
        self.assertEqual(num2text(5300600), u'пяць мільёнаў трыста тысяч шэсцьсот')
        self.assertEqual(num2text(1002000000), u'адзін мільярд два мільёны')
        self.assertEqual(num2text(2030000000), u'два мільярды трыццаць мільёнаў')
        self.assertEqual(num2text(1234567891),
                         u'адзін мільярд дзвесце трыццаць чатыры мільёны '
                         u'пяцьсот шэсцьдзясят сем тысяч '
                         u'восемсот дзевяноста адзін')

    def test_main_units(self):
        male_units = ((u'рубель', u'рублі', u'рублёў'), 'm')
        female_units = ((u'капейка', u'капейкі', u'капеек'), 'f')
        self.assertEqual(num2text(101, male_units), u'сто адзін рубель')
        self.assertEqual(num2text(102, male_units), u'сто два рублі')
        self.assertEqual(num2text(105, male_units), u'сто пяць рублёў')

        self.assertEqual(num2text(101, female_units), u'сто адна капейка')
        self.assertEqual(num2text(102, female_units), u'сто дзве капейкі')
        self.assertEqual(num2text(105, female_units), u'сто пяць капеек')

        self.assertEqual(num2text(0, male_units), u'нуль рублёў')
        self.assertEqual(num2text(0, female_units), u'нуль капеек')

        self.assertEqual(num2text(3000, male_units), u'тры тысячы рублёў')

    def test_decimal2text(self):
        int_units = ((u'рубель', u'рублі', u'рублёў'), 'm')
        exp_units = ((u'капейка', u'капейкі', u'капеек'), 'f')
        self.assertEqual(
            decimal2text(
                '105.245',
                int_units=int_units,
                exp_units=exp_units),
            u'сто пяць рублёў дваццаць чатыры капейкі')
        self.assertEqual(
            decimal2text(
                '101.26',
                int_units=int_units,
                exp_units=exp_units),
            u'сто адзін рубель дваццаць шэсць капеек')
        self.assertEqual(
            decimal2text(
                '102.2450',
                places=4,
                int_units=int_units,
                exp_units=exp_units),
            u'сто два рублі дзве тысячы чатырыста пяцьдзясят капеек')
        self.assertEqual(
            decimal2text(
                '111',
                int_units=int_units,
                exp_units=exp_units),
            u'сто адзінаццаць рублёў нуль капеек')
        self.assertEqual(
            decimal2text(
                '3000.00',
                int_units=int_units,
                exp_units=exp_units),
            u'тры тысячы рублёў нуль капеек')

    def test_negative(self):
        self.assertEqual(num2text(-12345),
                         u"мінус дванаццаць тысяч трыста сорак пяць")
        self.assertEqual(
            decimal2text('-123.45'),
            u'мінус сто дваццаць тры сорак пяць')

# генерацыя целага ліка ў парадкавы лічэбнік
    def test_units_ord(self):
        self.assertEqual(num2text_ordinal(0), None)
        self.assertEqual(num2text_ordinal(1), u'першы')
        self.assertEqual(num2text_ordinal(9), u'дзявяты')

    def test_gender_ord(self):
        self.assertEqual(num2text_ordinal(1000), u'тысячны')
        self.assertEqual(num2text_ordinal(2000), u'двухтысячны')
        self.assertEqual(num2text_ordinal(1000000), u'мільённы')
        self.assertEqual(num2text_ordinal(2000000), u'двухмільённы')

    def test_teens_ord(self):
        self.assertEqual(num2text_ordinal(10), u'дзясяты')
        self.assertEqual(num2text_ordinal(11), u'адзінаццаты')
        self.assertEqual(num2text_ordinal(19), u'дзевятнаццаты')

    def test_tens_ord(self):
        self.assertEqual(num2text_ordinal(20), u'дваццаты')
        self.assertEqual(num2text_ordinal(50), u'пяцідзясяты')
        self.assertEqual(num2text_ordinal(70), u'сямідзясяты')
        self.assertEqual(num2text_ordinal(80), u'васьмідзясяты')
        self.assertEqual(num2text_ordinal(90), u'дзевяносты')

    def test_hundreeds_ord(self):
        self.assertEqual(num2text_ordinal(100), u'соты')
        self.assertEqual(num2text_ordinal(300), u'трохсоты')
        self.assertEqual(num2text_ordinal(900), u'дзевяцісоты')

    def test_orders_ord(self):
        self.assertEqual(num2text_ordinal(1000), u'тысячны')
        self.assertEqual(num2text_ordinal(2000), u'двухтысячны')
        self.assertEqual(num2text_ordinal(5000), u'пяцітысячны')
        self.assertEqual(num2text_ordinal(1000000), u'мільённы')
        self.assertEqual(num2text_ordinal(2000000), u'двухмільённы')
        self.assertEqual(num2text_ordinal(5000000), u'пяцімільённы')
        self.assertEqual(num2text_ordinal(1000000000), u'мільярдны')
        self.assertEqual(num2text_ordinal(2000000000), u'двухмільярдны')
        self.assertEqual(num2text_ordinal(5000000000), u'пяцімільярдны')

    def test_inter_orders_ord(self):
        self.assertEqual(num2text_ordinal(33), u'трыццаць трэці')
        self.assertEqual(num2text_ordinal(125), u'сто дваццаць пяты')
        self.assertEqual(num2text_ordinal(2001), u'дзве тысячы першы')
        self.assertEqual(num2text_ordinal(5011), u'пяць тысяч адзінаццаты')
        self.assertEqual(num2text_ordinal(121151), u'сто дваццаць адна тысяча сто пяцьдзясят першы')
        self.assertEqual(num2text_ordinal(2020000), u'два мільёны дваццацітысячны')
        self.assertEqual(num2text_ordinal(5300600), u'пяць мільёнаў трыста тысяч шасцісоты')
        self.assertEqual(num2text_ordinal(285000000), u'двухсотвасьмідзесяціпяцімільённы')
        self.assertEqual(num2text_ordinal(2030000000), u'два мільярды трыццацімільённы')
        self.assertEqual(num2text_ordinal(1234567891),
                         u'мільярд дзвесце трыццаць чатыры мільёны '
                         u'пяцьсот шэсцьдзясят сем тысяч '
                         u'восемсот дзевяноста першы')

    def test_cuts_ordinal(self):
        self.assertEqual(num2text_ordinal(1100), u'тысяча соты')
        self.assertEqual(num2text_ordinal(1501), u'тысяча пяцьсот першы')
        self.assertEqual(num2text_ordinal(1002000), u'мільён двухтысячны')
        self.assertEqual(num2text_ordinal(1512000), u'мільён пяцісотдванаццацітысячны')
        self.assertEqual(num2text_ordinal(1002000000), u'мільярд двухмільённы')

    def test_ordinal_skl(self):
        self.assertEqual(num2text_ordinal(1121),u'тысяча сто дваццаць першы')
        self.assertEqual(num2text_ordinal(1121, tag='MGS', options='inanim'), u'тысяча сто дваццаць першага')
        self.assertEqual(num2text_ordinal(1121, tag='MDS', options='inanim'), u'тысяча сто дваццаць першаму')
        self.assertEqual(num2text_ordinal(1121, tag='MIS', options='inanim'), u'тысяча сто дваццаць першым')
        self.assertEqual(num2text_ordinal(1121, tag='PNP', options='inanim'), u'тысяча сто дваццаць першыя')
        self.assertEqual(num2text_ordinal(2340121, tag='PNP', options='inanim'), u'два мільёны трыста сорак тысяч сто дваццаць першыя')
        self.assertEqual(num2text_ordinal(2000, tag='PNP', options='inanim'), u'двухтысячныя')
        self.assertEqual(num2text_ordinal(1960, tag='PNP', options='inanim'), u'тысяча дзевяцьсот шасцідзясятыя')

    def test_units_declension_numerals(self):
        self.assertEqual(num2text_numerical(0,tag='MNS'), u'нуль')
        self.assertEqual(num2text_numerical(0,tag='MGS'), u'нуля')
        self.assertEqual(num2text_numerical(0,tag='MDS'), u'нулю')
        self.assertEqual(num2text_numerical(0,tag='MAS'), u'нуль')
        self.assertEqual(num2text_numerical(0,tag='MIS'), u'нулём')
        self.assertEqual(num2text_numerical(0,tag='MLS'), u'нулі')

        self.assertEqual(num2text_numerical(1,tag='MNS'), u'адзін')
        self.assertEqual(num2text_numerical(1,tag='MGS'), u'аднаго')
        self.assertEqual(num2text_numerical(1,tag='MDS'), u'аднаму')
        self.assertEqual(num2text_numerical(1,tag='MAS'), u'адзін')
        self.assertEqual(num2text_numerical(1,tag='MIS'), u'адным')
        self.assertEqual(num2text_numerical(1,tag='MLS'), u'адным')

        self.assertEqual(num2text_numerical(9,tag='PNP'), u'дзевяць')
        self.assertEqual(num2text_numerical(9,tag='PGP'), u'дзевяці')
        self.assertEqual(num2text_numerical(9,tag='PDP'), u'дзевяці')
        self.assertEqual(num2text_numerical(9,tag='PAP'), u'дзевяць')
        self.assertEqual(num2text_numerical(9,tag='PIP'), u'дзевяццю')
        self.assertEqual(num2text_numerical(9,tag='PLP'), u'дзевяці')

    def test_gender_declension_numerals(self):
        self.assertEqual(num2text_numerical(1000,tag='FNS'), u'адна тысяча')
        self.assertEqual(num2text_numerical(1000,tag='FGS'), u'адной тысячы')
        self.assertEqual(num2text_numerical(1000,tag='FDS'), u'адной тысячы')
        self.assertEqual(num2text_numerical(1000,tag='FAS'), u'адну тысячу')
        self.assertEqual(num2text_numerical(1000,tag='FIS'), u'адной тысячай')
        self.assertEqual(num2text_numerical(1000,tag='FLS'), u'адной тысячы')

        self.assertEqual(num2text_numerical(2000,tag='FNP'), u'дзве тысячы')
        self.assertEqual(num2text_numerical(2000,tag='FGP'), u'дзвюх тысяч')
        self.assertEqual(num2text_numerical(2000,tag='FDP'), u'дзвюм тысячам')
        self.assertEqual(num2text_numerical(2000,tag='FAP'), u'дзве тысячы')
        self.assertEqual(num2text_numerical(2000,tag='FIP'), u'дзвюма тысячамі')
        self.assertEqual(num2text_numerical(2000,tag='FLP'), u'дзвюх тысячах')

        self.assertEqual(num2text_numerical(1000000,tag='MNS'), u'адзін мільён')
        self.assertEqual(num2text_numerical(1000000,tag='MGS'), u'аднаго мільёна')
        self.assertEqual(num2text_numerical(1000000,tag='MDS'), u'аднаму мільёну')
        self.assertEqual(num2text_numerical(1000000,tag='MAS'), u'адзін мільён')
        self.assertEqual(num2text_numerical(1000000,tag='MIS'), u'адным мільёнам')
        self.assertEqual(num2text_numerical(1000000,tag='MLS'), u'адным мільёне')

        self.assertEqual(num2text_numerical(2000000,tag='MNP'), u'два мільёны')
        self.assertEqual(num2text_numerical(2000000,tag='MGP'), u'двух мільёнаў')
        self.assertEqual(num2text_numerical(2000000,tag='MDP'), u'двум мільёнам')
        self.assertEqual(num2text_numerical(2000000,tag='MAP'), u'два мільёны')
        self.assertEqual(num2text_numerical(2000000,tag='MIP'), u'двума мільёнамі')
        self.assertEqual(num2text_numerical(2000000,tag='MLP'), u'двух мільёнах')


    def test_teens_declension_numerals(self):
        self.assertEqual(num2text_numerical(10,tag='PNP'), u'дзесяць')
        self.assertEqual(num2text_numerical(10,tag='PGP'), u'дзесяці')
        self.assertEqual(num2text_numerical(10,tag='PDP'), u'дзесяці')
        self.assertEqual(num2text_numerical(10,tag='PAP'), u'дзесяць')
        self.assertEqual(num2text_numerical(10,tag='PIP'), u'дзесяццю')
        self.assertEqual(num2text_numerical(10,tag='PLP'), u'дзесяці')

        self.assertEqual(num2text_numerical(11,tag='PNP'), u'адзінаццаць')
        self.assertEqual(num2text_numerical(11,tag='PGP'), u'адзінаццаці')
        self.assertEqual(num2text_numerical(11,tag='PDP'), u'адзінаццаці')
        self.assertEqual(num2text_numerical(11,tag='PAP'), u'адзінаццаць')
        self.assertEqual(num2text_numerical(11,tag='PIP'), u'адзінаццаццю')
        self.assertEqual(num2text_numerical(11,tag='PLP'), u'адзінаццаці')

        self.assertEqual(num2text_numerical(19,tag='PNP'), u'дзевятнаццаць')
        self.assertEqual(num2text_numerical(19,tag='PGP'), u'дзевятнаццаці')
        self.assertEqual(num2text_numerical(19,tag='PDP'), u'дзевятнаццаці')
        self.assertEqual(num2text_numerical(19,tag='PAP'), u'дзевятнаццаць')
        self.assertEqual(num2text_numerical(19,tag='PIP'), u'дзевятнаццаццю')
        self.assertEqual(num2text_numerical(19,tag='PLP'), u'дзевятнаццаці')

    def test_tens_declension_numerals(self):
        self.assertEqual(num2text_numerical(20,tag='PNP'), u'дваццаць')
        self.assertEqual(num2text_numerical(20,tag='PGP'), u'дваццаці')
        self.assertEqual(num2text_numerical(20,tag='PDP'), u'дваццаці')
        self.assertEqual(num2text_numerical(20,tag='PAP'), u'дваццаць')
        self.assertEqual(num2text_numerical(20,tag='PIP'), u'дваццаццю')
        self.assertEqual(num2text_numerical(20,tag='PLP'), u'дваццаці')

        self.assertEqual(num2text_numerical(90,tag='PNP'), u'дзевяноста')
        self.assertEqual(num2text_numerical(90,tag='PGP'), u'дзевяноста')
        self.assertEqual(num2text_numerical(90,tag='PDP'), u'дзевяноста')
        self.assertEqual(num2text_numerical(90,tag='PAP'), u'дзевяноста')
        self.assertEqual(num2text_numerical(90,tag='PIP'), u'дзевяноста')
        self.assertEqual(num2text_numerical(90,tag='PLP'), u'дзевяноста')

    def test_hundreeds_declension_numerals(self):
        self.assertEqual(num2text_numerical(100,tag='PNP'), u'сто')
        self.assertEqual(num2text_numerical(100,tag='PGP'), u'ста')
        self.assertEqual(num2text_numerical(100,tag='PDP'), u'ста')
        self.assertEqual(num2text_numerical(100,tag='PAP'), u'сто')
        self.assertEqual(num2text_numerical(100,tag='PIP'), u'ста')
        self.assertEqual(num2text_numerical(100,tag='PLP'), u'ста')

        self.assertEqual(num2text_numerical(900,tag='PNP'), u'дзевяцьсот')
        self.assertEqual(num2text_numerical(900,tag='PGP'), u'дзевяцісот')
        self.assertEqual(num2text_numerical(900,tag='PDP'), u'дзевяцістам')
        self.assertEqual(num2text_numerical(900,tag='PAP'), u'дзевяцьсот')
        self.assertEqual(num2text_numerical(900,tag='PIP'), u'дзевяцістамі')
        self.assertEqual(num2text_numerical(900,tag='PLP'), u'дзевяцістах')

    def test_orders_declension_numerals(self):
        self.assertEqual(num2text_numerical(1000,tag='FNS'), u'адна тысяча')
        self.assertEqual(num2text_numerical(1000,tag='FGS'), u'адной тысячы')
        self.assertEqual(num2text_numerical(1000,tag='FDS'), u'адной тысячы')
        self.assertEqual(num2text_numerical(1000,tag='FAS'), u'адну тысячу')
        self.assertEqual(num2text_numerical(1000,tag='FIS'), u'адной тысячай')
        self.assertEqual(num2text_numerical(1000,tag='FLS'), u'адной тысячы')

        self.assertEqual(num2text_numerical(2000,tag='FNP'), u'дзве тысячы')
        self.assertEqual(num2text_numerical(2000,tag='FGP'), u'дзвюх тысяч')
        self.assertEqual(num2text_numerical(2000,tag='FDP'), u'дзвюм тысячам')
        self.assertEqual(num2text_numerical(2000,tag='FAP'), u'дзве тысячы')
        self.assertEqual(num2text_numerical(2000,tag='FIP'), u'дзвюма тысячамі')
        self.assertEqual(num2text_numerical(2000,tag='FLP'), u'дзвюх тысячах')

        self.assertEqual(num2text_numerical(5000,tag='FNP'), u'пяць тысяч')
        self.assertEqual(num2text_numerical(5000,tag='FGP'), u'пяці тысяч')
        self.assertEqual(num2text_numerical(5000,tag='FDP'), u'пяці тысячам')
        self.assertEqual(num2text_numerical(5000,tag='FAP'), u'пяць тысяч')
        self.assertEqual(num2text_numerical(5000,tag='FIP'), u'пяццю тысячамі')
        self.assertEqual(num2text_numerical(5000,tag='FLP'), u'пяці тысячах')

        self.assertEqual(num2text_numerical(1000000,tag='MNS'), u'адзін мільён')
        self.assertEqual(num2text_numerical(1000000,tag='MGS'), u'аднаго мільёна')
        self.assertEqual(num2text_numerical(1000000,tag='MDS'), u'аднаму мільёну')
        self.assertEqual(num2text_numerical(1000000,tag='MAS'), u'адзін мільён')
        self.assertEqual(num2text_numerical(1000000,tag='MIS'), u'адным мільёнам')
        self.assertEqual(num2text_numerical(1000000,tag='MLS'), u'адным мільёне')

        self.assertEqual(num2text_numerical(2000000,tag='MNP'), u'два мільёны')
        self.assertEqual(num2text_numerical(2000000,tag='MGP'), u'двух мільёнаў')
        self.assertEqual(num2text_numerical(2000000,tag='MDP'), u'двум мільёнам')
        self.assertEqual(num2text_numerical(2000000,tag='MAP'), u'два мільёны')
        self.assertEqual(num2text_numerical(2000000,tag='MIP'), u'двума мільёнамі')
        self.assertEqual(num2text_numerical(2000000,tag='MLP'), u'двух мільёнах')

        self.assertEqual(num2text_numerical(5000000,tag='MNP'), u'пяць мільёнаў')
        self.assertEqual(num2text_numerical(5000000,tag='MGP'), u'пяці мільёнаў')
        self.assertEqual(num2text_numerical(5000000,tag='MDP'), u'пяці мільёнам')
        self.assertEqual(num2text_numerical(5000000,tag='MAP'), u'пяць мільёнаў')
        self.assertEqual(num2text_numerical(5000000,tag='MIP'), u'пяццю мільёнамі')
        self.assertEqual(num2text_numerical(5000000,tag='MLP'), u'пяці мільёнах')

        self.assertEqual(num2text_numerical(1000000000,tag='MNS'), u'адзін мільярд')
        self.assertEqual(num2text_numerical(1000000000,tag='MGS'), u'аднаго мільярда')
        self.assertEqual(num2text_numerical(1000000000,tag='MDS'), u'аднаму мільярду')
        self.assertEqual(num2text_numerical(1000000000,tag='MAS'), u'адзін мільярд')
        self.assertEqual(num2text_numerical(1000000000,tag='MIS'), u'адным мільярдам')
        self.assertEqual(num2text_numerical(1000000000,tag='MLS'), u'адным мільярдзе')

        self.assertEqual(num2text_numerical(2000000000,tag='PNP'), u'два мільярды')
        self.assertEqual(num2text_numerical(2000000000,tag='PGP'), u'двух мільярдаў')
        self.assertEqual(num2text_numerical(2000000000,tag='PDP'), u'двум мільярдам')
        self.assertEqual(num2text_numerical(2000000000,tag='PAP'), u'два мільярды')
        self.assertEqual(num2text_numerical(2000000000,tag='PIP'), u'двума мільярдамі')
        self.assertEqual(num2text_numerical(2000000000,tag='PLP'), u'двух мільярдах')

        self.assertEqual(num2text_numerical(5000000000,tag='PNP'), u'пяць мільярдаў')
        self.assertEqual(num2text_numerical(5000000000,tag='PGP'), u'пяці мільярдаў')
        self.assertEqual(num2text_numerical(5000000000,tag='PDP'), u'пяці мільярдам')
        self.assertEqual(num2text_numerical(5000000000,tag='PAP'), u'пяць мільярдаў')
        self.assertEqual(num2text_numerical(5000000000,tag='PIP'), u'пяццю мільярдамі')
        self.assertEqual(num2text_numerical(5000000000,tag='PLP'), u'пяці мільярдах')

    def test_inter_orders_declension_numerals(self):
        self.assertEqual(num2text_numerical(1100,tag='PNP'), u'адна тысяча сто')
        self.assertEqual(num2text_numerical(1100,tag='PGP'), u'адной тысячы ста')
        self.assertEqual(num2text_numerical(1100,tag='PDP'), u'адной тысячы ста')
        self.assertEqual(num2text_numerical(1100,tag='PAP'), u'адну тысячу сто')
        self.assertEqual(num2text_numerical(1100,tag='PIP'), u'адной тысячай ста')
        self.assertEqual(num2text_numerical(1100,tag='PLP'), u'адной тысячы ста')

        self.assertEqual(num2text_numerical(2001,tag='MNS'), u'дзве тысячы адзін')
        self.assertEqual(num2text_numerical(2001,tag='MGS'), u'дзвюх тысяч аднаго')
        self.assertEqual(num2text_numerical(2001,tag='MDS'), u'дзвюм тысячам аднаму')
        self.assertEqual(num2text_numerical(2001,tag='MAS'), u'дзве тысячы адзін')
        self.assertEqual(num2text_numerical(2001,tag='MIS'), u'дзвюма тысячамі адным')
        self.assertEqual(num2text_numerical(2001,tag='MLS'), u'дзвюх тысячах адным')

        self.assertEqual(num2text_numerical(5011,tag='PNP'), u'пяць тысяч адзінаццаць')
        self.assertEqual(num2text_numerical(5011,tag='PGP'), u'пяці тысяч адзінаццаці')
        self.assertEqual(num2text_numerical(5011,tag='PDP'), u'пяці тысячам адзінаццаці')
        self.assertEqual(num2text_numerical(5011,tag='PAP'), u'пяць тысяч адзінаццаць')
        self.assertEqual(num2text_numerical(5011,tag='PIP'), u'пяццю тысячамі адзінаццаццю')
        self.assertEqual(num2text_numerical(5011,tag='PLP'), u'пяці тысячах адзінаццаці')

        self.assertEqual(num2text_numerical(1002000,tag='FNP'), u'адзін мільён дзве тысячы')
        self.assertEqual(num2text_numerical(1002000,tag='FGP'), u'аднаго мільёна дзвюх тысяч')
        self.assertEqual(num2text_numerical(1002000,tag='FDP'), u'аднаму мільёну дзвюм тысячам')
        self.assertEqual(num2text_numerical(1002000,tag='FAP'), u'адзін мільён дзве тысячы')
        self.assertEqual(num2text_numerical(1002000,tag='FIP'), u'адным мільёнам дзвюма тысячамі')
        self.assertEqual(num2text_numerical(1002000,tag='FLP'), u'адным мільёне дзвюх тысячах')

        self.assertEqual(num2text_numerical(2020000,tag='FNP'), u'два мільёны дваццаць тысяч')
        self.assertEqual(num2text_numerical(2020000,tag='FGP'), u'двух мільёнаў дваццаці тысяч')
        self.assertEqual(num2text_numerical(2020000,tag='FDP'), u'двум мільёнам дваццаці тысячам')
        self.assertEqual(num2text_numerical(2020000,tag='FAP'), u'два мільёны дваццаць тысяч')
        self.assertEqual(num2text_numerical(2020000,tag='FIP'), u'двума мільёнамі дваццаццю тысячамі')
        self.assertEqual(num2text_numerical(2020000,tag='FLP'), u'двух мільёнах дваццаці тысячах')

        self.assertEqual(num2text_numerical(5300600,tag='PNP'), u'пяць мільёнаў трыста тысяч шэсцьсот')
        self.assertEqual(num2text_numerical(5300600,tag='PGP'), u'пяці мільёнаў трохсот тысяч шасцісот')
        self.assertEqual(num2text_numerical(5300600,tag='PDP'), u'пяці мільёнам тромстам тысячам шасцістам')
        self.assertEqual(num2text_numerical(5300600,tag='PAP'), u'пяць мільёнаў трыста тысяч шэсцьсот')
        self.assertEqual(num2text_numerical(5300600,tag='PIP'), u'пяццю мільёнамі трымастамі тысячамі шасцюстамі')
        self.assertEqual(num2text_numerical(5300600,tag='PLP'), u'пяці мільёнах трохстах тысячах шасцістах')

        self.assertEqual(num2text_numerical(1002000000,tag='MNP'), u'адзін мільярд два мільёны')
        self.assertEqual(num2text_numerical(1002000000,tag='MGP'), u'аднаго мільярда двух мільёнаў')
        self.assertEqual(num2text_numerical(1002000000,tag='MDP'), u'аднаму мільярду двум мільёнам')
        self.assertEqual(num2text_numerical(1002000000,tag='MAP'), u'адзін мільярд два мільёны')
        self.assertEqual(num2text_numerical(1002000000,tag='MIP'), u'адным мільярдам двума мільёнамі')
        self.assertEqual(num2text_numerical(1002000000,tag='MLP'), u'адным мільярдзе двух мільёнах')

        self.assertEqual(num2text_numerical(2030000000,tag='MNP'), u'два мільярды трыццаць мільёнаў')
        self.assertEqual(num2text_numerical(2030000000,tag='MGP'), u'двух мільярдаў трыццаці мільёнаў')
        self.assertEqual(num2text_numerical(2030000000,tag='MDP'), u'двум мільярдам трыццаці мільёнам')
        self.assertEqual(num2text_numerical(2030000000,tag='MAP'), u'два мільярды трыццаць мільёнаў')
        self.assertEqual(num2text_numerical(2030000000,tag='MIP'), u'двума мільярдамі трыццаццю мільёнамі')
        self.assertEqual(num2text_numerical(2030000000,tag='MLP'), u'двух мільярдах трыццаці мільёнах')

        self.assertEqual(num2text_numerical(5030000000,tag='MNP'), u'пяць мільярдаў трыццаць мільёнаў')
        self.assertEqual(num2text_numerical(5030000000,tag='MGP'), u'пяці мільярдаў трыццаці мільёнаў')
        self.assertEqual(num2text_numerical(5030000000,tag='MDP'), u'пяці мільярдам трыццаці мільёнам')
        self.assertEqual(num2text_numerical(5030000000,tag='MAP'), u'пяць мільярдаў трыццаць мільёнаў')
        self.assertEqual(num2text_numerical(5030000000,tag='MIP'), u'пяццю мільярдамі трыццаццю мільёнамі')
        self.assertEqual(num2text_numerical(5030000000,tag='MLP'), u'пяці мільярдах трыццаці мільёнах')

        self.assertEqual(num2text_numerical(1234567891,tag='MNS'),
                         u'адзін мільярд дзвесце трыццаць чатыры мільёны '
                         u'пяцьсот шэсцьдзясят сем тысяч '
                         u'восемсот дзевяноста адзін')
        self.assertEqual(num2text_numerical(1234567891,tag='MGS'),
                         u'аднаго мільярда двухсот трыццаці чатырох мільёнаў '
                         u'пяцісот шасцідзесяці сямі тысяч '
                         u'васьмісот дзевяноста аднаго')
        self.assertEqual(num2text_numerical(1234567891,tag='MDS'),
                         u'аднаму мільярду двумстам трыццаці чатыром мільёнам '
                         u'пяцістам шасцідзесяці сямі тысячам '
                         u'васьмістам дзевяноста аднаму')
        self.assertEqual(num2text_numerical(1234567891,tag='MAS'),
                         u'адзін мільярд дзвесце трыццаць чатыры мільёны '
                         u'пяцьсот шэсцьдзясят сем тысяч '
                         u'восемсот дзевяноста адзін')
        self.assertEqual(num2text_numerical(1234567891,tag='MIS'),
                         u'адным мільярдам двумастамі трыццаццю чатырма мільёнамі '
                         u'пяццюстамі шасцюдзесяццю сямю тысячамі '
                         u'васьмюстамі дзевяноста адным')
        self.assertEqual(num2text_numerical(1234567891,tag='MLS'),
                         u'адным мільярдзе двухстах трыццаці чатырох мільёнах '
                         u'пяцістах шасцідзесяці сямі тысячах '
                         u'васьмістах дзевяноста адным')

if __name__ == '__main__':
    import sys
    if len(sys.argv) > 1:
        try:
            num = sys.argv[1]
            if len(sys.argv)>2:
               tag = sys.argv[2]
            else:
               tag = None
            if len(sys.argv)>3:
               options = sys.argv[3]
            else:
               options='inanim'
            print(num2text_ordinal(int(num) , tag=tag, options=options))
        except ValueError:
            print (sys.stderr, "Invalid argument {}".format(sys.argv[1]))
        sys.exit()
    unittest.main()