using System;
using System.Collections.Generic;
using System.Globalization;
using System.Threading;
using Developpez.Dotnet.Language;
using Developpez.Dotnet.Language.Grammar;
using Developpez.Dotnet.Properties;
using NUnit.Framework;

namespace Developpez.Dotnet.Tests.Language
{
    [TestFixture]
    public class FrenchNumberSpellerTest
    {

        #region Setup/Teardown

        private CultureInfo _previousCulture;

        [TestFixtureSetUp]
        public void Setup()
        {
            _previousCulture = Thread.CurrentThread.CurrentCulture;
            Thread.CurrentThread.CurrentCulture = CultureInfo.GetCultureInfo("fr-FR");
        }

        [TestFixtureTearDown]
        public void Teardown()
        {
            Thread.CurrentThread.CurrentCulture = _previousCulture;
        }

        #endregion



        #region Spell method with int values

        [Test]
        public void SpellMethodWithUnitsAndTens()
        {
            string[] unitsAndTens = new string[100]
            {
                string.Empty, "un", "deux", "trois", "quatre", "cinq", "six", "sept", "huit", "neuf",
                "dix", "onze", "douze", "treize", "quatorze", "quinze", "seize", "dix-sept", "dix-huit", "dix-neuf",
                "vingt", "vingt et un", "vingt-deux", "vingt-trois", "vingt-quatre", "vingt-cinq", "vingt-six", "vingt-sept", "vingt-huit", "vingt-neuf",
                "trente", "trente et un", "trente-deux", "trente-trois", "trente-quatre", "trente-cinq", "trente-six", "trente-sept", "trente-huit", "trente-neuf",
                "quarante", "quarante et un", "quarante-deux", "quarante-trois", "quarante-quatre", "quarante-cinq", "quarante-six", "quarante-sept", "quarante-huit", "quarante-neuf",
                "cinquante", "cinquante et un", "cinquante-deux", "cinquante-trois", "cinquante-quatre", "cinquante-cinq", "cinquante-six", "cinquante-sept", "cinquante-huit", "cinquante-neuf",
                "soixante", "soixante et un", "soixante-deux", "soixante-trois", "soixante-quatre", "soixante-cinq", "soixante-six", "soixante-sept", "soixante-huit", "soixante-neuf",
                "soixante-dix", "soixante et onze", "soixante-douze", "soixante-treize", "soixante-quatorze", "soixante-quinze", "soixante-seize", "soixante-dix-sept", "soixante-dix-huit", "soixante-dix-neuf",
                "quatre-vingts", "quatre-vingt-un", "quatre-vingt-deux", "quatre-vingt-trois", "quatre-vingt-quatre", "quatre-vingt-cinq", "quatre-vingt-six", "quatre-vingt-sept", "quatre-vingt-huit", "quatre-vingt-neuf",
                "quatre-vingt-dix", "quatre-vingt-onze", "quatre-vingt-douze", "quatre-vingt-treize", "quatre-vingt-quatorze", "quatre-vingt-quinze", "quatre-vingt-seize", "quatre-vingt-dix-sept", "quatre-vingt-dix-huit", "quatre-vingt-dix-neuf"
            };

            // Nombres positifs :
            Dictionary<int, string> unitsAndTensNumbers = new Dictionary<int, string>(100);
            unitsAndTensNumbers.Add(0, "zéro");
            for (int i = 1; i < unitsAndTens.Length; i++)
            {
                unitsAndTensNumbers.Add(i, unitsAndTens[i]);
            }

            foreach (int number in unitsAndTensNumbers.Keys)
            {
                Assert.AreEqual(unitsAndTensNumbers[number], NumberConverter.Spell(number));
            }
        }

        [Test]
        public void SpellMethodWithUnitsAndTensAndMinus()
        {
            string[] unitsAndTens = new string[100]
            {
                string.Empty, "un", "deux", "trois", "quatre", "cinq", "six", "sept", "huit", "neuf",
                "dix", "onze", "douze", "treize", "quatorze", "quinze", "seize", "dix-sept", "dix-huit", "dix-neuf",
                "vingt", "vingt et un", "vingt-deux", "vingt-trois", "vingt-quatre", "vingt-cinq", "vingt-six", "vingt-sept", "vingt-huit", "vingt-neuf",
                "trente", "trente et un", "trente-deux", "trente-trois", "trente-quatre", "trente-cinq", "trente-six", "trente-sept", "trente-huit", "trente-neuf",
                "quarante", "quarante et un", "quarante-deux", "quarante-trois", "quarante-quatre", "quarante-cinq", "quarante-six", "quarante-sept", "quarante-huit", "quarante-neuf",
                "cinquante", "cinquante et un", "cinquante-deux", "cinquante-trois", "cinquante-quatre", "cinquante-cinq", "cinquante-six", "cinquante-sept", "cinquante-huit", "cinquante-neuf",
                "soixante", "soixante et un", "soixante-deux", "soixante-trois", "soixante-quatre", "soixante-cinq", "soixante-six", "soixante-sept", "soixante-huit", "soixante-neuf",
                "soixante-dix", "soixante et onze", "soixante-douze", "soixante-treize", "soixante-quatorze", "soixante-quinze", "soixante-seize", "soixante-dix-sept", "soixante-dix-huit", "soixante-dix-neuf",
                "quatre-vingts", "quatre-vingt-un", "quatre-vingt-deux", "quatre-vingt-trois", "quatre-vingt-quatre", "quatre-vingt-cinq", "quatre-vingt-six", "quatre-vingt-sept", "quatre-vingt-huit", "quatre-vingt-neuf",
                "quatre-vingt-dix", "quatre-vingt-onze", "quatre-vingt-douze", "quatre-vingt-treize", "quatre-vingt-quatorze", "quatre-vingt-quinze", "quatre-vingt-seize", "quatre-vingt-dix-sept", "quatre-vingt-dix-huit", "quatre-vingt-dix-neuf"
            };

            // Nombres négatifs :
            Dictionary<int, string> unitsAndTensNumbers = new Dictionary<int, string>(100);
            unitsAndTensNumbers.Add(0, "zéro");
            for (int i = 1; i < unitsAndTens.Length; i++)
            {
                unitsAndTensNumbers.Add(-i, "moins " + unitsAndTens[i]);
            }

            foreach (int number in unitsAndTensNumbers.Keys)
            {
                Assert.AreEqual(unitsAndTensNumbers[number], NumberConverter.Spell(number));
            }
        }

        [Test]
        public void SpellMethodWithUnitsAndTensAndFeminine()
        {
            string[] unitsAndTens = new string[100]
            {
                string.Empty, "une", "deux", "trois", "quatre", "cinq", "six", "sept", "huit", "neuf",
                "dix", "onze", "douze", "treize", "quatorze", "quinze", "seize", "dix-sept", "dix-huit", "dix-neuf",
                "vingt", "vingt et une", "vingt-deux", "vingt-trois", "vingt-quatre", "vingt-cinq", "vingt-six", "vingt-sept", "vingt-huit", "vingt-neuf",
                "trente", "trente et une", "trente-deux", "trente-trois", "trente-quatre", "trente-cinq", "trente-six", "trente-sept", "trente-huit", "trente-neuf",
                "quarante", "quarante et une", "quarante-deux", "quarante-trois", "quarante-quatre", "quarante-cinq", "quarante-six", "quarante-sept", "quarante-huit", "quarante-neuf",
                "cinquante", "cinquante et une", "cinquante-deux", "cinquante-trois", "cinquante-quatre", "cinquante-cinq", "cinquante-six", "cinquante-sept", "cinquante-huit", "cinquante-neuf",
                "soixante", "soixante et une", "soixante-deux", "soixante-trois", "soixante-quatre", "soixante-cinq", "soixante-six", "soixante-sept", "soixante-huit", "soixante-neuf",
                "soixante-dix", "soixante et onze", "soixante-douze", "soixante-treize", "soixante-quatorze", "soixante-quinze", "soixante-seize", "soixante-dix-sept", "soixante-dix-huit", "soixante-dix-neuf",
                "quatre-vingts", "quatre-vingt-une", "quatre-vingt-deux", "quatre-vingt-trois", "quatre-vingt-quatre", "quatre-vingt-cinq", "quatre-vingt-six", "quatre-vingt-sept", "quatre-vingt-huit", "quatre-vingt-neuf",
                "quatre-vingt-dix", "quatre-vingt-onze", "quatre-vingt-douze", "quatre-vingt-treize", "quatre-vingt-quatorze", "quatre-vingt-quinze", "quatre-vingt-seize", "quatre-vingt-dix-sept", "quatre-vingt-dix-huit", "quatre-vingt-dix-neuf"
            };

            // Nombres positifs féminins :
            Dictionary<int, string> unitsAndTensNumbers = new Dictionary<int, string>(100);
            unitsAndTensNumbers.Add(0, "zéro");
            for (int i = 1; i < unitsAndTens.Length; i++)
            {
                unitsAndTensNumbers.Add(i, unitsAndTens[i]);
            }

            foreach (int number in unitsAndTensNumbers.Keys)
            {
                Assert.AreEqual(unitsAndTensNumbers[number], NumberConverter.Spell(number, Gender.Feminine));
            }
        }

        [Test]
        public void SpellMethodWithUnitsAndTensAndMinusAndFeminine()
        {
            string[] unitsAndTens = new string[100]
            {
                string.Empty, "une", "deux", "trois", "quatre", "cinq", "six", "sept", "huit", "neuf",
                "dix", "onze", "douze", "treize", "quatorze", "quinze", "seize", "dix-sept", "dix-huit", "dix-neuf",
                "vingt", "vingt et une", "vingt-deux", "vingt-trois", "vingt-quatre", "vingt-cinq", "vingt-six", "vingt-sept", "vingt-huit", "vingt-neuf",
                "trente", "trente et une", "trente-deux", "trente-trois", "trente-quatre", "trente-cinq", "trente-six", "trente-sept", "trente-huit", "trente-neuf",
                "quarante", "quarante et une", "quarante-deux", "quarante-trois", "quarante-quatre", "quarante-cinq", "quarante-six", "quarante-sept", "quarante-huit", "quarante-neuf",
                "cinquante", "cinquante et une", "cinquante-deux", "cinquante-trois", "cinquante-quatre", "cinquante-cinq", "cinquante-six", "cinquante-sept", "cinquante-huit", "cinquante-neuf",
                "soixante", "soixante et une", "soixante-deux", "soixante-trois", "soixante-quatre", "soixante-cinq", "soixante-six", "soixante-sept", "soixante-huit", "soixante-neuf",
                "soixante-dix", "soixante et onze", "soixante-douze", "soixante-treize", "soixante-quatorze", "soixante-quinze", "soixante-seize", "soixante-dix-sept", "soixante-dix-huit", "soixante-dix-neuf",
                "quatre-vingts", "quatre-vingt-une", "quatre-vingt-deux", "quatre-vingt-trois", "quatre-vingt-quatre", "quatre-vingt-cinq", "quatre-vingt-six", "quatre-vingt-sept", "quatre-vingt-huit", "quatre-vingt-neuf",
                "quatre-vingt-dix", "quatre-vingt-onze", "quatre-vingt-douze", "quatre-vingt-treize", "quatre-vingt-quatorze", "quatre-vingt-quinze", "quatre-vingt-seize", "quatre-vingt-dix-sept", "quatre-vingt-dix-huit", "quatre-vingt-dix-neuf"
            };

            // Nombres négatifs féminins :
            Dictionary<int, string> unitsAndTensNumbers = new Dictionary<int, string>(100);
            unitsAndTensNumbers.Add(0, "zéro");
            for (int i = 1; i < unitsAndTens.Length; i++)
            {
                unitsAndTensNumbers.Add(-i, "moins " + unitsAndTens[i]);
            }

            foreach (int number in unitsAndTensNumbers.Keys)
            {
                Assert.AreEqual(unitsAndTensNumbers[number], NumberConverter.Spell(number, Gender.Feminine));
            }
        }

        [Test]
        public void SpellMethodWithUnitsAndTensAndOrdinal()
        {
            string[] unitsAndTens = new string[100]
            {
                string.Empty, "premier", "deuxième", "troisième", "quatrième", "cinquième", "sixième", "septième", "huitième", "neuvième",
                "dixième", "onzième", "douzième", "treizième", "quatorzième", "quinzième", "seizième", "dix-septième", "dix-huitième", "dix-neuvième",
                "vingtième", "vingt et unième", "vingt-deuxième", "vingt-troisième", "vingt-quatrième", "vingt-cinquième", "vingt-sixième", "vingt-septième", "vingt-huitième", "vingt-neuvième",
                "trentième", "trente et unième", "trente-deuxième", "trente-troisième", "trente-quatrième", "trente-cinquième", "trente-sixième", "trente-septième", "trente-huitième", "trente-neuvième",
                "quarantième", "quarante et unième", "quarante-deuxième", "quarante-troisième", "quarante-quatrième", "quarante-cinquième", "quarante-sixième", "quarante-septième", "quarante-huitième", "quarante-neuvième",
                "cinquantième", "cinquante et unième", "cinquante-deuxième", "cinquante-troisième", "cinquante-quatrième", "cinquante-cinquième", "cinquante-sixième", "cinquante-septième", "cinquante-huitième", "cinquante-neuvième",
                "soixantième", "soixante et unième", "soixante-deuxième", "soixante-troisième", "soixante-quatrième", "soixante-cinquième", "soixante-sixième", "soixante-septième", "soixante-huitième", "soixante-neuvième",
                "soixante-dixième", "soixante et onzième", "soixante-douzième", "soixante-treizième", "soixante-quatorzième", "soixante-quinzième", "soixante-seizième", "soixante-dix-septième", "soixante-dix-huitième", "soixante-dix-neuvième",
                "quatre-vingtième", "quatre-vingt-unième", "quatre-vingt-deuxième", "quatre-vingt-troisième", "quatre-vingt-quatrième", "quatre-vingt-cinquième", "quatre-vingt-sixième", "quatre-vingt-septième", "quatre-vingt-huitième", "quatre-vingt-neuvième",
                "quatre-vingt-dixième", "quatre-vingt-onzième", "quatre-vingt-douzième", "quatre-vingt-treizième", "quatre-vingt-quatorzième", "quatre-vingt-quinzième", "quatre-vingt-seizième", "quatre-vingt-dix-septième", "quatre-vingt-dix-huitième", "quatre-vingt-dix-neuvième"
            };

            // Nombres positifs :
            Dictionary<int, string> unitsAndTensNumbers = new Dictionary<int, string>(100);
            unitsAndTensNumbers.Add(0, "zéro");
            for (int i = 1; i < unitsAndTens.Length; i++)
            {
                unitsAndTensNumbers.Add(i, unitsAndTens[i]);
            }

            foreach (int number in unitsAndTensNumbers.Keys)
            {
                if (number == 0)
                {
                    try
                    {
                        NumberConverter.Spell(number, Gender.Masculine, NumeralAdjective.Ordinal);
                    }
                    catch (Exception ex)
                    {
                        Assert.IsInstanceOf<ArgumentException>(ex);
                        Assert.AreEqual(ExceptionMessages.ZeroHasNoOrdinal, ex.Message);
                    }
                }
                else
                    Assert.AreEqual
                    (
                        unitsAndTensNumbers[number], 
                        NumberConverter.Spell(number, Gender.Masculine, NumeralAdjective.Ordinal), 
                        String.Format
                        (
                            "La méthode Spell a donné {0} pour le nombre {1}. Elle devait donner {2}.",
                            NumberConverter.Spell(number, Gender.Masculine, NumeralAdjective.Ordinal),
                            number,
                            unitsAndTensNumbers[number]
                        )
                    );
            }
        }

        [Test]
        public void SpellMethodWithTwenties()
        {
            Dictionary<int, string> twentiesNumbers = new Dictionary<int, string>();
            twentiesNumbers.Add(20, "vingt");
            twentiesNumbers.Add(25, "vingt-cinq");
            twentiesNumbers.Add(80, "quatre-vingts");
            twentiesNumbers.Add(85, "quatre-vingt-cinq");
            twentiesNumbers.Add(120, "cent vingt");
            twentiesNumbers.Add(180, "cent quatre-vingts");
            twentiesNumbers.Add(520, "cinq cent vingt");
            twentiesNumbers.Add(580, "cinq cent quatre-vingts");
            twentiesNumbers.Add(1020, "mille vingt");
            twentiesNumbers.Add(1080, "mille quatre-vingts");
            twentiesNumbers.Add(20000, "vingt mille");
            twentiesNumbers.Add(80000, "quatre-vingt mille");
            twentiesNumbers.Add(20000000, "vingt millions");
            twentiesNumbers.Add(80000000, "quatre-vingts millions");

            foreach (int number in twentiesNumbers.Keys)
            {
                Assert.AreEqual(twentiesNumbers[number], NumberConverter.Spell(number));
            }
        }

        [Test]
        public void SpellMethodWithTwentiesAndOrdinal()
        {
            Dictionary<int, string> twentiesNumbers = new Dictionary<int, string>();
            twentiesNumbers.Add(20, "vingtième");
            twentiesNumbers.Add(25, "vingt-cinquième");
            twentiesNumbers.Add(80, "quatre-vingtième");
            twentiesNumbers.Add(85, "quatre-vingt-cinquième");
            twentiesNumbers.Add(120, "cent vingtième");
            twentiesNumbers.Add(180, "cent quatre-vingtième");
            twentiesNumbers.Add(520, "cinq cent vingtième");
            twentiesNumbers.Add(580, "cinq cent quatre-vingtième");
            twentiesNumbers.Add(1020, "mille vingtième");
            twentiesNumbers.Add(1080, "mille quatre-vingtième");
            twentiesNumbers.Add(20000, "vingt millième");
            twentiesNumbers.Add(80000, "quatre-vingt millième");
            twentiesNumbers.Add(20000000, "vingt millionième");
            twentiesNumbers.Add(80000000, "quatre-vingt millionième");

            foreach (int number in twentiesNumbers.Keys)
            {
                Assert.AreEqual(twentiesNumbers[number], NumberConverter.Spell(number, Gender.Masculine, NumeralAdjective.Ordinal));
            }
        }

        [Test]
        public void SpellMethodWithHundreds()
        {
            Dictionary<long, string> hundredsNumbers = new Dictionary<long, string>(144);
            hundredsNumbers.Add(100, "cent"); hundredsNumbers.Add(101, "cent un"); hundredsNumbers.Add(110, "cent dix"); hundredsNumbers.Add(111, "cent onze");
            hundredsNumbers.Add(200, "deux cents"); hundredsNumbers.Add(202, "deux cent deux"); hundredsNumbers.Add(220, "deux cent vingt"); hundredsNumbers.Add(222, "deux cent vingt-deux");
            hundredsNumbers.Add(300, "trois cents"); hundredsNumbers.Add(303, "trois cent trois"); hundredsNumbers.Add(330, "trois cent trente"); hundredsNumbers.Add(333, "trois cent trente-trois");
            hundredsNumbers.Add(400, "quatre cents"); hundredsNumbers.Add(404, "quatre cent quatre"); hundredsNumbers.Add(440, "quatre cent quarante"); hundredsNumbers.Add(444, "quatre cent quarante-quatre");
            hundredsNumbers.Add(500, "cinq cents"); hundredsNumbers.Add(505, "cinq cent cinq"); hundredsNumbers.Add(550, "cinq cent cinquante"); hundredsNumbers.Add(555, "cinq cent cinquante-cinq");
            hundredsNumbers.Add(600, "six cents"); hundredsNumbers.Add(606, "six cent six"); hundredsNumbers.Add(660, "six cent soixante"); hundredsNumbers.Add(666, "six cent soixante-six");
            hundredsNumbers.Add(700, "sept cents"); hundredsNumbers.Add(707, "sept cent sept"); hundredsNumbers.Add(770, "sept cent soixante-dix"); hundredsNumbers.Add(777, "sept cent soixante-dix-sept");
            hundredsNumbers.Add(800, "huit cents"); hundredsNumbers.Add(808, "huit cent huit"); hundredsNumbers.Add(880, "huit cent quatre-vingts"); hundredsNumbers.Add(888, "huit cent quatre-vingt-huit");
            hundredsNumbers.Add(900, "neuf cents"); hundredsNumbers.Add(909, "neuf cent neuf"); hundredsNumbers.Add(990, "neuf cent quatre-vingt-dix"); hundredsNumbers.Add(999, "neuf cent quatre-vingt-dix-neuf");

            hundredsNumbers.Add(100000, "cent mille"); hundredsNumbers.Add(101000, "cent un mille"); hundredsNumbers.Add(110000, "cent dix mille"); hundredsNumbers.Add(111000, "cent onze mille");
            hundredsNumbers.Add(200000, "deux cent mille"); hundredsNumbers.Add(202000, "deux cent deux mille"); hundredsNumbers.Add(220000, "deux cent vingt mille"); hundredsNumbers.Add(222000, "deux cent vingt-deux mille");
            hundredsNumbers.Add(300000, "trois cent mille"); hundredsNumbers.Add(303000, "trois cent trois mille"); hundredsNumbers.Add(330000, "trois cent trente mille"); hundredsNumbers.Add(333000, "trois cent trente-trois mille");
            hundredsNumbers.Add(400000, "quatre cent mille"); hundredsNumbers.Add(404000, "quatre cent quatre mille"); hundredsNumbers.Add(440000, "quatre cent quarante mille"); hundredsNumbers.Add(444000, "quatre cent quarante-quatre mille");
            hundredsNumbers.Add(500000, "cinq cent mille"); hundredsNumbers.Add(505000, "cinq cent cinq mille"); hundredsNumbers.Add(550000, "cinq cent cinquante mille"); hundredsNumbers.Add(555000, "cinq cent cinquante-cinq mille");
            hundredsNumbers.Add(600000, "six cent mille"); hundredsNumbers.Add(606000, "six cent six mille"); hundredsNumbers.Add(660000, "six cent soixante mille"); hundredsNumbers.Add(666000, "six cent soixante-six mille");
            hundredsNumbers.Add(700000, "sept cent mille"); hundredsNumbers.Add(707000, "sept cent sept mille"); hundredsNumbers.Add(770000, "sept cent soixante-dix mille"); hundredsNumbers.Add(777000, "sept cent soixante-dix-sept mille");
            hundredsNumbers.Add(800000, "huit cent mille"); hundredsNumbers.Add(808000, "huit cent huit mille"); hundredsNumbers.Add(880000, "huit cent quatre-vingt mille"); hundredsNumbers.Add(888000, "huit cent quatre-vingt-huit mille");
            hundredsNumbers.Add(900000, "neuf cent mille"); hundredsNumbers.Add(909000, "neuf cent neuf mille"); hundredsNumbers.Add(990000, "neuf cent quatre-vingt-dix mille"); hundredsNumbers.Add(999000, "neuf cent quatre-vingt-dix-neuf mille");

            hundredsNumbers.Add(100000000, "cent millions"); hundredsNumbers.Add(101000000, "cent un millions"); hundredsNumbers.Add(110000000, "cent dix millions"); hundredsNumbers.Add(111000000, "cent onze millions");
            hundredsNumbers.Add(200000000, "deux cents millions"); hundredsNumbers.Add(202000000, "deux cent deux millions"); hundredsNumbers.Add(220000000, "deux cent vingt millions"); hundredsNumbers.Add(222000000, "deux cent vingt-deux millions");
            hundredsNumbers.Add(300000000, "trois cents millions"); hundredsNumbers.Add(303000000, "trois cent trois millions"); hundredsNumbers.Add(330000000, "trois cent trente millions"); hundredsNumbers.Add(333000000, "trois cent trente-trois millions");
            hundredsNumbers.Add(400000000, "quatre cents millions"); hundredsNumbers.Add(404000000, "quatre cent quatre millions"); hundredsNumbers.Add(440000000, "quatre cent quarante millions"); hundredsNumbers.Add(444000000, "quatre cent quarante-quatre millions");
            hundredsNumbers.Add(500000000, "cinq cents millions"); hundredsNumbers.Add(505000000, "cinq cent cinq millions"); hundredsNumbers.Add(550000000, "cinq cent cinquante millions"); hundredsNumbers.Add(555000000, "cinq cent cinquante-cinq millions");
            hundredsNumbers.Add(600000000, "six cents millions"); hundredsNumbers.Add(606000000, "six cent six millions"); hundredsNumbers.Add(660000000, "six cent soixante millions"); hundredsNumbers.Add(666000000, "six cent soixante-six millions");
            hundredsNumbers.Add(700000000, "sept cents millions"); hundredsNumbers.Add(707000000, "sept cent sept millions"); hundredsNumbers.Add(770000000, "sept cent soixante-dix millions"); hundredsNumbers.Add(777000000, "sept cent soixante-dix-sept millions");
            hundredsNumbers.Add(800000000, "huit cents millions"); hundredsNumbers.Add(808000000, "huit cent huit millions"); hundredsNumbers.Add(880000000, "huit cent quatre-vingts millions"); hundredsNumbers.Add(888000000, "huit cent quatre-vingt-huit millions");
            hundredsNumbers.Add(900000000, "neuf cents millions"); hundredsNumbers.Add(909000000, "neuf cent neuf millions"); hundredsNumbers.Add(990000000, "neuf cent quatre-vingt-dix millions"); hundredsNumbers.Add(999000000, "neuf cent quatre-vingt-dix-neuf millions");

            hundredsNumbers.Add(100000000000, "cent milliards"); hundredsNumbers.Add(101000000000, "cent un milliards"); hundredsNumbers.Add(110000000000, "cent dix milliards"); hundredsNumbers.Add(111000000000, "cent onze milliards");
            hundredsNumbers.Add(200000000000, "deux cents milliards"); hundredsNumbers.Add(202000000000, "deux cent deux milliards"); hundredsNumbers.Add(220000000000, "deux cent vingt milliards"); hundredsNumbers.Add(222000000000, "deux cent vingt-deux milliards");
            hundredsNumbers.Add(300000000000, "trois cents milliards"); hundredsNumbers.Add(303000000000, "trois cent trois milliards"); hundredsNumbers.Add(330000000000, "trois cent trente milliards"); hundredsNumbers.Add(333000000000, "trois cent trente-trois milliards");
            hundredsNumbers.Add(400000000000, "quatre cents milliards"); hundredsNumbers.Add(404000000000, "quatre cent quatre milliards"); hundredsNumbers.Add(440000000000, "quatre cent quarante milliards"); hundredsNumbers.Add(444000000000, "quatre cent quarante-quatre milliards");
            hundredsNumbers.Add(500000000000, "cinq cents milliards"); hundredsNumbers.Add(505000000000, "cinq cent cinq milliards"); hundredsNumbers.Add(550000000000, "cinq cent cinquante milliards"); hundredsNumbers.Add(555000000000, "cinq cent cinquante-cinq milliards");
            hundredsNumbers.Add(600000000000, "six cents milliards"); hundredsNumbers.Add(606000000000, "six cent six milliards"); hundredsNumbers.Add(660000000000, "six cent soixante milliards"); hundredsNumbers.Add(666000000000, "six cent soixante-six milliards");
            hundredsNumbers.Add(700000000000, "sept cents milliards"); hundredsNumbers.Add(707000000000, "sept cent sept milliards"); hundredsNumbers.Add(770000000000, "sept cent soixante-dix milliards"); hundredsNumbers.Add(777000000000, "sept cent soixante-dix-sept milliards");
            hundredsNumbers.Add(800000000000, "huit cents milliards"); hundredsNumbers.Add(808000000000, "huit cent huit milliards"); hundredsNumbers.Add(880000000000, "huit cent quatre-vingts milliards"); hundredsNumbers.Add(888000000000, "huit cent quatre-vingt-huit milliards");
            hundredsNumbers.Add(900000000000, "neuf cents milliards"); hundredsNumbers.Add(909000000000, "neuf cent neuf milliards"); hundredsNumbers.Add(990000000000, "neuf cent quatre-vingt-dix milliards"); hundredsNumbers.Add(999000000000, "neuf cent quatre-vingt-dix-neuf milliards");

            foreach (long number in hundredsNumbers.Keys)
            {
                Assert.AreEqual(hundredsNumbers[number], NumberConverter.Spell(number));
            }
        }

        [Test]
        public void SpellMethodWithHundredsAndOrdinal()
        {
            Dictionary<long, string> hundredsNumbers = new Dictionary<long, string>(144);
            hundredsNumbers.Add(100, "centième"); hundredsNumbers.Add(101, "cent unième"); hundredsNumbers.Add(110, "cent dixième"); hundredsNumbers.Add(111, "cent onzième");
            hundredsNumbers.Add(200, "deux centième"); hundredsNumbers.Add(202, "deux cent deuxième"); hundredsNumbers.Add(220, "deux cent vingtième"); hundredsNumbers.Add(222, "deux cent vingt-deuxième");
            hundredsNumbers.Add(300, "trois centième"); hundredsNumbers.Add(303, "trois cent troisième"); hundredsNumbers.Add(330, "trois cent trentième"); hundredsNumbers.Add(333, "trois cent trente-troisième");
            hundredsNumbers.Add(400, "quatre centième"); hundredsNumbers.Add(404, "quatre cent quatrième"); hundredsNumbers.Add(440, "quatre cent quarantième"); hundredsNumbers.Add(444, "quatre cent quarante-quatrième");
            hundredsNumbers.Add(500, "cinq centième"); hundredsNumbers.Add(505, "cinq cent cinquième"); hundredsNumbers.Add(550, "cinq cent cinquantième"); hundredsNumbers.Add(555, "cinq cent cinquante-cinquième");
            hundredsNumbers.Add(600, "six centième"); hundredsNumbers.Add(606, "six cent sixième"); hundredsNumbers.Add(660, "six cent soixantième"); hundredsNumbers.Add(666, "six cent soixante-sixième");
            hundredsNumbers.Add(700, "sept centième"); hundredsNumbers.Add(707, "sept cent septième"); hundredsNumbers.Add(770, "sept cent soixante-dixième"); hundredsNumbers.Add(777, "sept cent soixante-dix-septième");
            hundredsNumbers.Add(800, "huit centième"); hundredsNumbers.Add(808, "huit cent huitième"); hundredsNumbers.Add(880, "huit cent quatre-vingtième"); hundredsNumbers.Add(888, "huit cent quatre-vingt-huitième");
            hundredsNumbers.Add(900, "neuf centième"); hundredsNumbers.Add(909, "neuf cent neuvième"); hundredsNumbers.Add(990, "neuf cent quatre-vingt-dixième"); hundredsNumbers.Add(999, "neuf cent quatre-vingt-dix-neuvième");

            hundredsNumbers.Add(100000, "cent millième"); hundredsNumbers.Add(101000, "cent un millième"); hundredsNumbers.Add(110000, "cent dix millième"); hundredsNumbers.Add(111000, "cent onze millième");
            hundredsNumbers.Add(200000, "deux cent millième"); hundredsNumbers.Add(202000, "deux cent deux millième"); hundredsNumbers.Add(220000, "deux cent vingt millième"); hundredsNumbers.Add(222000, "deux cent vingt-deux millième");
            hundredsNumbers.Add(300000, "trois cent millième"); hundredsNumbers.Add(303000, "trois cent trois millième"); hundredsNumbers.Add(330000, "trois cent trente millième"); hundredsNumbers.Add(333000, "trois cent trente-trois millième");
            hundredsNumbers.Add(400000, "quatre cent millième"); hundredsNumbers.Add(404000, "quatre cent quatre millième"); hundredsNumbers.Add(440000, "quatre cent quarante millième"); hundredsNumbers.Add(444000, "quatre cent quarante-quatre millième");
            hundredsNumbers.Add(500000, "cinq cent millième"); hundredsNumbers.Add(505000, "cinq cent cinq millième"); hundredsNumbers.Add(550000, "cinq cent cinquante millième"); hundredsNumbers.Add(555000, "cinq cent cinquante-cinq millième");
            hundredsNumbers.Add(600000, "six cent millième"); hundredsNumbers.Add(606000, "six cent six millième"); hundredsNumbers.Add(660000, "six cent soixante millième"); hundredsNumbers.Add(666000, "six cent soixante-six millième");
            hundredsNumbers.Add(700000, "sept cent millième"); hundredsNumbers.Add(707000, "sept cent sept millième"); hundredsNumbers.Add(770000, "sept cent soixante-dix millième"); hundredsNumbers.Add(777000, "sept cent soixante-dix-sept millième");
            hundredsNumbers.Add(800000, "huit cent millième"); hundredsNumbers.Add(808000, "huit cent huit millième"); hundredsNumbers.Add(880000, "huit cent quatre-vingt millième"); hundredsNumbers.Add(888000, "huit cent quatre-vingt-huit millième");
            hundredsNumbers.Add(900000, "neuf cent millième"); hundredsNumbers.Add(909000, "neuf cent neuf millième"); hundredsNumbers.Add(990000, "neuf cent quatre-vingt-dix millième"); hundredsNumbers.Add(999000, "neuf cent quatre-vingt-dix-neuf millième");

            hundredsNumbers.Add(100000000, "cent millionième"); hundredsNumbers.Add(101000000, "cent un millionième"); hundredsNumbers.Add(110000000, "cent dix millionième"); hundredsNumbers.Add(111000000, "cent onze millionième");
            hundredsNumbers.Add(200000000, "deux cent millionième"); hundredsNumbers.Add(202000000, "deux cent deux millionième"); hundredsNumbers.Add(220000000, "deux cent vingt millionième"); hundredsNumbers.Add(222000000, "deux cent vingt-deux millionième");
            hundredsNumbers.Add(300000000, "trois cent millionième"); hundredsNumbers.Add(303000000, "trois cent trois millionième"); hundredsNumbers.Add(330000000, "trois cent trente millionième"); hundredsNumbers.Add(333000000, "trois cent trente-trois millionième");
            hundredsNumbers.Add(400000000, "quatre cent millionième"); hundredsNumbers.Add(404000000, "quatre cent quatre millionième"); hundredsNumbers.Add(440000000, "quatre cent quarante millionième"); hundredsNumbers.Add(444000000, "quatre cent quarante-quatre millionième");
            hundredsNumbers.Add(500000000, "cinq cent millionième"); hundredsNumbers.Add(505000000, "cinq cent cinq millionième"); hundredsNumbers.Add(550000000, "cinq cent cinquante millionième"); hundredsNumbers.Add(555000000, "cinq cent cinquante-cinq millionième");
            hundredsNumbers.Add(600000000, "six cent millionième"); hundredsNumbers.Add(606000000, "six cent six millionième"); hundredsNumbers.Add(660000000, "six cent soixante millionième"); hundredsNumbers.Add(666000000, "six cent soixante-six millionième");
            hundredsNumbers.Add(700000000, "sept cent millionième"); hundredsNumbers.Add(707000000, "sept cent sept millionième"); hundredsNumbers.Add(770000000, "sept cent soixante-dix millionième"); hundredsNumbers.Add(777000000, "sept cent soixante-dix-sept millionième");
            hundredsNumbers.Add(800000000, "huit cent millionième"); hundredsNumbers.Add(808000000, "huit cent huit millionième"); hundredsNumbers.Add(880000000, "huit cent quatre-vingt millionième"); hundredsNumbers.Add(888000000, "huit cent quatre-vingt-huit millionième");
            hundredsNumbers.Add(900000000, "neuf cent millionième"); hundredsNumbers.Add(909000000, "neuf cent neuf millionième"); hundredsNumbers.Add(990000000, "neuf cent quatre-vingt-dix millionième"); hundredsNumbers.Add(999000000, "neuf cent quatre-vingt-dix-neuf millionième");

            hundredsNumbers.Add(100000000000, "cent milliardième"); hundredsNumbers.Add(101000000000, "cent un milliardième"); hundredsNumbers.Add(110000000000, "cent dix milliardième"); hundredsNumbers.Add(111000000000, "cent onze milliardième");
            hundredsNumbers.Add(200000000000, "deux cent milliardième"); hundredsNumbers.Add(202000000000, "deux cent deux milliardième"); hundredsNumbers.Add(220000000000, "deux cent vingt milliardième"); hundredsNumbers.Add(222000000000, "deux cent vingt-deux milliardième");
            hundredsNumbers.Add(300000000000, "trois cent milliardième"); hundredsNumbers.Add(303000000000, "trois cent trois milliardième"); hundredsNumbers.Add(330000000000, "trois cent trente milliardième"); hundredsNumbers.Add(333000000000, "trois cent trente-trois milliardième");
            hundredsNumbers.Add(400000000000, "quatre cent milliardième"); hundredsNumbers.Add(404000000000, "quatre cent quatre milliardième"); hundredsNumbers.Add(440000000000, "quatre cent quarante milliardième"); hundredsNumbers.Add(444000000000, "quatre cent quarante-quatre milliardième");
            hundredsNumbers.Add(500000000000, "cinq cent milliardième"); hundredsNumbers.Add(505000000000, "cinq cent cinq milliardième"); hundredsNumbers.Add(550000000000, "cinq cent cinquante milliardième"); hundredsNumbers.Add(555000000000, "cinq cent cinquante-cinq milliardième");
            hundredsNumbers.Add(600000000000, "six cent milliardième"); hundredsNumbers.Add(606000000000, "six cent six milliardième"); hundredsNumbers.Add(660000000000, "six cent soixante milliardième"); hundredsNumbers.Add(666000000000, "six cent soixante-six milliardième");
            hundredsNumbers.Add(700000000000, "sept cent milliardième"); hundredsNumbers.Add(707000000000, "sept cent sept milliardième"); hundredsNumbers.Add(770000000000, "sept cent soixante-dix milliardième"); hundredsNumbers.Add(777000000000, "sept cent soixante-dix-sept milliardième");
            hundredsNumbers.Add(800000000000, "huit cent milliardième"); hundredsNumbers.Add(808000000000, "huit cent huit milliardième"); hundredsNumbers.Add(880000000000, "huit cent quatre-vingt milliardième"); hundredsNumbers.Add(888000000000, "huit cent quatre-vingt-huit milliardième");
            hundredsNumbers.Add(900000000000, "neuf cent milliardième"); hundredsNumbers.Add(909000000000, "neuf cent neuf milliardième"); hundredsNumbers.Add(990000000000, "neuf cent quatre-vingt-dix milliardième"); hundredsNumbers.Add(999000000000, "neuf cent quatre-vingt-dix-neuf milliardième");

            foreach (long number in hundredsNumbers.Keys)
            {
                Assert.AreEqual(hundredsNumbers[number], NumberConverter.Spell(number, Gender.Masculine, NumeralAdjective.Ordinal));
            }
        }

        #endregion



        #region Spell method with long values

        [Test]
        public void SpellMethodWithRoundNumbers()
        {
            Dictionary<ulong, string> roundNumbers = new Dictionary<ulong, string>(20);
            roundNumbers.Add(1, "un");
            roundNumbers.Add(10, "dix");
            roundNumbers.Add(100, "cent");
            roundNumbers.Add(1000, "mille");
            roundNumbers.Add(10000, "dix mille");
            roundNumbers.Add(100000, "cent mille");
            roundNumbers.Add(1000000, "un million");
            roundNumbers.Add(10000000, "dix millions");
            roundNumbers.Add(100000000, "cent millions");
            roundNumbers.Add(1000000000, "un milliard");
            roundNumbers.Add(10000000000, "dix milliards");
            roundNumbers.Add(100000000000, "cent milliards");
            roundNumbers.Add(1000000000000, "un billion");
            roundNumbers.Add(10000000000000, "dix billions");
            roundNumbers.Add(100000000000000, "cent billions");
            roundNumbers.Add(1000000000000000, "mille billions");
            roundNumbers.Add(10000000000000000, "dix mille billions");
            roundNumbers.Add(100000000000000000, "cent mille billions");
            roundNumbers.Add(1000000000000000000, "un trillion");
            roundNumbers.Add(10000000000000000000, "dix trillions");

            foreach (ulong number in roundNumbers.Keys)
            {
                Assert.AreEqual(roundNumbers[number], NumberConverter.Spell(number));
            }
        }

        #endregion



        #region Spell method with special values

        [Test]
        public void SpellMethodWithIntBoundaryValues()
        {
            Dictionary<int, string> borderNumbers = new Dictionary<int, string>(2);
            borderNumbers.Add(int.MinValue, "moins deux milliards cent quarante-sept millions quatre cent quatre-vingt-trois mille six cent quarante-huit");
            borderNumbers.Add(int.MaxValue, "deux milliards cent quarante-sept millions quatre cent quatre-vingt-trois mille six cent quarante-sept");

            foreach (int number in borderNumbers.Keys)
            {
                Assert.AreEqual(borderNumbers[number], NumberConverter.Spell(number));
            }
        }

        [Test]
        public void SpellMethodWithUIntBoundaryValues()
        {
            Dictionary<uint, string> borderNumbers = new Dictionary<uint, string>(2);
            borderNumbers.Add(uint.MinValue, "zéro");
            borderNumbers.Add(uint.MaxValue, "quatre milliards deux cent quatre-vingt-quatorze millions neuf cent soixante-sept mille deux cent quatre-vingt-quinze");

            foreach (uint number in borderNumbers.Keys)
            {
                Assert.AreEqual(borderNumbers[number], NumberConverter.Spell(number));
            }
        }

        [Test]
        public void SpellMethodWithLongBoundaryValues()
        {
            Dictionary<long, string> borderNumbers = new Dictionary<long, string>(2);
            borderNumbers.Add(long.MinValue, "moins neuf trillions deux cent vingt-trois mille trois cent soixante-douze billions trente-six milliards huit cent cinquante-quatre millions sept cent soixante-quinze mille huit cent huit");
            borderNumbers.Add(long.MaxValue, "neuf trillions deux cent vingt-trois mille trois cent soixante-douze billions trente-six milliards huit cent cinquante-quatre millions sept cent soixante-quinze mille huit cent sept");

            foreach (long number in borderNumbers.Keys)
            {
                Assert.AreEqual(borderNumbers[number], NumberConverter.Spell(number));
            }
        }

        [Test]
        public void SpellMethodWithULongBoundaryValues()
        {
            Dictionary<ulong, string> borderNumbers = new Dictionary<ulong, string>(2);
            borderNumbers.Add(ulong.MinValue, "zéro");
            borderNumbers.Add(ulong.MaxValue, "dix-huit trillions quatre cent quarante-six mille sept cent quarante-quatre billions soixante-treize milliards sept cent neuf millions cinq cent cinquante et un mille six cent quinze");

            foreach (ulong number in borderNumbers.Keys)
            {
                Assert.AreEqual(borderNumbers[number], NumberConverter.Spell(number));
            }
        }

        #endregion



        #region Spell method with decimal numbers

        [Test]
        public void SpellDecimalNoRoundingNeeded()
        {
            decimal value = 42.729m;
            int digits = 10;
            string expected = "quarante-deux virgule sept cent vingt-neuf";
            string actual = NumberConverter.Spell(value, digits);
            Assert.AreEqual(expected, actual);
        }

        [Test]
        public void SpellDecimalRounded()
        {
            decimal value = 42.729m;
            int digits = 2;
            string expected = "quarante-deux virgule soixante-treize";
            string actual = NumberConverter.Spell(value, digits);
            Assert.AreEqual(expected, actual);
        }

        [Test]
        public void SpellDecimalLessThanOne()
        {
            decimal value = 0.729m;
            int digits = 10;
            string expected = "zéro virgule sept cent vingt-neuf";
            string actual = NumberConverter.Spell(value, digits);
            Assert.AreEqual(expected, actual);
        }

        [Test]
        public void SpellDecimalLeadingDecimalZeros()
        {
            decimal value = 42.009m;
            int digits = 10;
            string expected = "quarante-deux virgule zéro zéro neuf";
            string actual = NumberConverter.Spell(value, digits);
            Assert.AreEqual(expected, actual);
        }

        [Test]
        public void SpellDecimalNoDecimalPart()
        {
            decimal value = 42.000m;
            int digits = 10;
            string expected = "quarante-deux";
            string actual = NumberConverter.Spell(value, digits);
            Assert.AreEqual(expected, actual);
        }

        [Test]
        public void SpellNegativeDecimalNoRoundingNeeded()
        {
            decimal value = -42.729m;
            int digits = 10;
            string expected = "moins quarante-deux virgule sept cent vingt-neuf";
            string actual = NumberConverter.Spell(value, digits);
            Assert.AreEqual(expected, actual);
        }

        [Test]
        public void SpellNegativeDecimalRounded()
        {
            decimal value = -42.729m;
            int digits = 2;
            string expected = "moins quarante-deux virgule soixante-treize";
            string actual = NumberConverter.Spell(value, digits);
            Assert.AreEqual(expected, actual);
        }

        [Test]
        public void SpellNegativeDecimalLessThanOne()
        {
            decimal value = -0.729m;
            int digits = 10;
            string expected = "moins zéro virgule sept cent vingt-neuf";
            string actual = NumberConverter.Spell(value, digits);
            Assert.AreEqual(expected, actual);
        }

        [Test]
        public void SpellNegativeDecimalLeadingDecimalZeros()
        {
            decimal value = -42.009m;
            int digits = 10;
            string expected = "moins quarante-deux virgule zéro zéro neuf";
            string actual = NumberConverter.Spell(value, digits);
            Assert.AreEqual(expected, actual);
        }

        [Test]
        public void SpellNegativeDecimalNoDecimalPart()
        {
            decimal value = -42.000m;
            int digits = 10;
            string expected = "moins quarante-deux";
            string actual = NumberConverter.Spell(value, digits);
            Assert.AreEqual(expected, actual);
        }

        [Test]
        public void SpellDecimalZero()
        {
            decimal value = 0.0m;
            int digits = 10;
            string expected = "zéro";
            string actual = NumberConverter.Spell(value, digits);
            Assert.AreEqual(expected, actual);
        }

        #endregion



        #region Spell method with double numbers

        [Test]
        public void SpellDoubleNoRoundingNeeded()
        {
            double value = 42.729;
            int digits = 10;
            string expected = "quarante-deux virgule sept cent vingt-neuf";
            string actual = NumberConverter.Spell(value, digits);
            Assert.AreEqual(expected, actual);
        }

        [Test]
        public void SpellDoubleRounded()
        {
            double value = 42.729;
            int digits = 2;
            string expected = "quarante-deux virgule soixante-treize";
            string actual = NumberConverter.Spell(value, digits);
            Assert.AreEqual(expected, actual);
        }

        [Test]
        public void SpellDoubleLessThanOne()
        {
            double value = 0.729;
            int digits = 10;
            string expected = "zéro virgule sept cent vingt-neuf";
            string actual = NumberConverter.Spell(value, digits);
            Assert.AreEqual(expected, actual);
        }

        [Test]
        public void SpellDoubleLeadingDecimalZeros()
        {
            double value = 42.009;
            int digits = 10;
            string expected = "quarante-deux virgule zéro zéro neuf";
            string actual = NumberConverter.Spell(value, digits);
            Assert.AreEqual(expected, actual);
        }

        [Test]
        public void SpellDoubleNoDecimalPart()
        {
            double value = 42.000;
            int digits = 10;
            string expected = "quarante-deux";
            string actual = NumberConverter.Spell(value, digits);
            Assert.AreEqual(expected, actual);
        }

        [Test]
        public void SpellNegativeDoubleNoRoundingNeeded()
        {
            double value = -42.729;
            int digits = 10;
            string expected = "moins quarante-deux virgule sept cent vingt-neuf";
            string actual = NumberConverter.Spell(value, digits);
            Assert.AreEqual(expected, actual);
        }

        [Test]
        public void SpellNegativeDoubleRounded()
        {
            double value = -42.729;
            int digits = 2;
            string expected = "moins quarante-deux virgule soixante-treize";
            string actual = NumberConverter.Spell(value, digits);
            Assert.AreEqual(expected, actual);
        }

        [Test]
        public void SpellNegativeDoubleLessThanOne()
        {
            double value = -0.729;
            int digits = 10;
            string expected = "moins zéro virgule sept cent vingt-neuf";
            string actual = NumberConverter.Spell(value, digits);
            Assert.AreEqual(expected, actual);
        }

        [Test]
        public void SpellNegativeDoubleLeadingDecimalZeros()
        {
            double value = -42.009;
            int digits = 10;
            string expected = "moins quarante-deux virgule zéro zéro neuf";
            string actual = NumberConverter.Spell(value, digits);
            Assert.AreEqual(expected, actual);
        }

        [Test]
        public void SpellNegativeDoubleNoDecimalPart()
        {
            double value = -42.000;
            int digits = 10;
            string expected = "moins quarante-deux";
            string actual = NumberConverter.Spell(value, digits);
            Assert.AreEqual(expected, actual);
        }

        [Test]
        public void SpellDoubleZero()
        {
            double value = 0.0;
            int digits = 10;
            string expected = "zéro";
            string actual = NumberConverter.Spell(value, digits);
            Assert.AreEqual(expected, actual);
        }

        #endregion



        #region SpellAmount method with decimal value

        private static readonly CurrencyDescriptor _euroFR = KnownCurrencies.GetCurrency("EUR", CultureInfo.GetCultureInfo("fr-FR"));

        private static readonly CurrencyDescriptor _poundFR = KnownCurrencies.GetCurrency("GBP", CultureInfo.GetCultureInfo("fr-FR"));

        [Test]
        public void SpellDecimalAmountNoRoundingNeeded()
        {
            decimal value = 42.72m;
            string expected = "quarante-deux euros et soixante-douze centimes";
            string actual = NumberConverter.SpellAmount(value, _euroFR);
            Assert.AreEqual(expected, actual);
        }

        [Test]
        public void SpellDecimalAmountRounded()
        {
            decimal value = 42.729m;
            string expected = "quarante-deux euros et soixante-treize centimes";
            string actual = NumberConverter.SpellAmount(value, _euroFR);
            Assert.AreEqual(expected, actual);
        }

        [Test]
        public void SpellDecimalAmountLessThanOne()
        {
            decimal value = 0.729m;
            string expected = "soixante-treize centimes";
            string actual = NumberConverter.SpellAmount(value, _euroFR);
            Assert.AreEqual(expected, actual);
        }

        [Test]
        public void SpellDecimalAmountLeadingDecimalZeros()
        {
            decimal value = 42.09m;
            string expected = "quarante-deux euros et neuf centimes";
            string actual = NumberConverter.SpellAmount(value, _euroFR);
            Assert.AreEqual(expected, actual);
        }

        [Test]
        public void SpellDecimalAmountNoDecimalPart()
        {
            decimal value = 42.000m;
            string expected = "quarante-deux euros";
            string actual = NumberConverter.SpellAmount(value, _euroFR);
            Assert.AreEqual(expected, actual);
        }

        [Test]
        public void SpellDecimalAmountZero()
        {
            decimal value = 0.0m;
            string expected = "zéro euro";
            string actual = NumberConverter.SpellAmount(value, _euroFR);
            Assert.AreEqual(expected, actual);
        }

        [Test]
        public void SpellDecimalAmountSingular()
        {
            decimal value = 1.01m;
            string expected = "un euro et un centime";
            string actual = NumberConverter.SpellAmount(value, _euroFR);
            Assert.AreEqual(expected, actual);

            expected = "une livre et un penny";
            actual = NumberConverter.SpellAmount(value, _poundFR);
            Assert.AreEqual(expected, actual);
        }

        [Test]
        public void SpellDecimalAmountWithCentsMultipleOfTen()
        {
            decimal value = 1.2m;
            string expected = "un euro et vingt centimes";
            string actual = NumberConverter.SpellAmount(value, _euroFR);
            Assert.AreEqual(expected, actual);
        }

        #endregion



        #region SpellAmount method with double value

        [Test]
        public void SpellDoubleAmountNoRoundingNeeded()
        {
            double value = 42.72;
            string expected = "quarante-deux euros et soixante-douze centimes";
            string actual = NumberConverter.SpellAmount(value, _euroFR);
            Assert.AreEqual(expected, actual);
        }

        [Test]
        public void SpellDoubleAmountRounded()
        {
            double value = 42.729;
            string expected = "quarante-deux euros et soixante-treize centimes";
            string actual = NumberConverter.SpellAmount(value, _euroFR);
            Assert.AreEqual(expected, actual);
        }

        [Test]
        public void SpellDoubleAmountLessThanOne()
        {
            double value = 0.729;
            string expected = "soixante-treize centimes";
            string actual = NumberConverter.SpellAmount(value, _euroFR);
            Assert.AreEqual(expected, actual);
        }

        [Test]
        public void SpellDoubleAmountLeadingDecimalZeros()
        {
            double value = 42.09;
            string expected = "quarante-deux euros et neuf centimes";
            string actual = NumberConverter.SpellAmount(value, _euroFR);
            Assert.AreEqual(expected, actual);
        }

        [Test]
        public void SpellDoubleAmountNoDecimalPart()
        {
            double value = 42.000;
            string expected = "quarante-deux euros";
            string actual = NumberConverter.SpellAmount(value, _euroFR);
            Assert.AreEqual(expected, actual);
        }

        [Test]
        public void SpellDoubleAmountZero()
        {
            double value = 0.0;
            string expected = "zéro euro";
            string actual = NumberConverter.SpellAmount(value, _euroFR);
            Assert.AreEqual(expected, actual);
        }

        [Test]
        public void SpellDoubleAmountSingular()
        {
            double value = 1.01;
            string expected = "un euro et un centime";
            string actual = NumberConverter.SpellAmount(value, _euroFR);
            Assert.AreEqual(expected, actual);

            expected = "une livre et un penny";
            actual = NumberConverter.SpellAmount(value, _poundFR);
            Assert.AreEqual(expected, actual);
        }

        [Test]
        public void SpellDoubleAmountWithCentsMultipleOfTen()
        {
            double value = 1.2;
            string expected = "un euro et vingt centimes";
            string actual = NumberConverter.SpellAmount(value, _euroFR);
            Assert.AreEqual(expected, actual);
        }

        #endregion

    }
}