C# (CSharp) org.apache.lucene.analysis.bg BulgarianAnalyzer示例

示例#1

文件： TestBulgarianStemmer.cs 项目： zfxsss/lucenenet

        /// <summary>
        /// Test showing how neuter noun forms conflate an example noun for each common
        /// plural pattern is listed
        /// </summary>
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in .NET:
//ORIGINAL LINE: public void testNeuterNouns() throws java.io.IOException
        public virtual void testNeuterNouns()
        {
            BulgarianAnalyzer a = new BulgarianAnalyzer(TEST_VERSION_CURRENT);

            // -а pattern
            assertAnalyzesTo(a, "дърво", new string[] { "дърв" });
            assertAnalyzesTo(a, "дървото", new string[] { "дърв" });
            assertAnalyzesTo(a, "дърва", new string[] { "дърв" });
            assertAnalyzesTo(a, "дървета", new string[] { "дърв" });
            assertAnalyzesTo(a, "дървата", new string[] { "дърв" });
            assertAnalyzesTo(a, "дърветата", new string[] { "дърв" });

            // -та pattern
            assertAnalyzesTo(a, "море", new string[] { "мор" });
            assertAnalyzesTo(a, "морето", new string[] { "мор" });
            assertAnalyzesTo(a, "морета", new string[] { "мор" });
            assertAnalyzesTo(a, "моретата", new string[] { "мор" });

            // -я pattern
            assertAnalyzesTo(a, "изключение", new string[] { "изключени" });
            assertAnalyzesTo(a, "изключението", new string[] { "изключени" });
            assertAnalyzesTo(a, "изключенията", new string[] { "изключени" });
            /* note the below form in this example does not conflate with the rest */
            assertAnalyzesTo(a, "изключения", new string[] { "изключн" });
        }

示例#2

//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in .NET:
//ORIGINAL LINE: public void testReusableTokenStream() throws java.io.IOException
        public virtual void testReusableTokenStream()
        {
            Analyzer a = new BulgarianAnalyzer(TEST_VERSION_CURRENT);

            assertAnalyzesTo(a, "документи", new string[] { "документ" });
            assertAnalyzesTo(a, "документ", new string[] { "документ" });
        }

示例#3

//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in .NET:
//ORIGINAL LINE: public void testWithStemExclusionSet() throws java.io.IOException
        public virtual void testWithStemExclusionSet()
        {
            CharArraySet set = new CharArraySet(TEST_VERSION_CURRENT, 1, true);

            set.add("строеве");
            Analyzer a = new BulgarianAnalyzer(TEST_VERSION_CURRENT, CharArraySet.EMPTY_SET, set);

            assertAnalyzesTo(a, "строевете строеве", new string[] { "строй", "строеве" });
        }

示例#4

文件： TestBulgarianStemmer.cs 项目： zfxsss/lucenenet

        /// <summary>
        /// Test showing how feminine noun forms conflate
        /// </summary>
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in .NET:
//ORIGINAL LINE: public void testFeminineNouns() throws java.io.IOException
        public virtual void testFeminineNouns()
        {
            BulgarianAnalyzer a = new BulgarianAnalyzer(TEST_VERSION_CURRENT);

            assertAnalyzesTo(a, "вест", new string[] { "вест" });
            assertAnalyzesTo(a, "вестта", new string[] { "вест" });
            assertAnalyzesTo(a, "вести", new string[] { "вест" });
            assertAnalyzesTo(a, "вестите", new string[] { "вест" });
        }

示例#5

文件： TestBulgarianStemmer.cs 项目： zfxsss/lucenenet

        /// <summary>
        /// Test some exceptional rules, implemented as rewrites.
        /// </summary>
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in .NET:
//ORIGINAL LINE: public void testExceptions() throws java.io.IOException
        public virtual void testExceptions()
        {
            BulgarianAnalyzer a = new BulgarianAnalyzer(TEST_VERSION_CURRENT);

            // ци -> к
            assertAnalyzesTo(a, "собственик", new string[] { "собственик" });
            assertAnalyzesTo(a, "собственика", new string[] { "собственик" });
            assertAnalyzesTo(a, "собственикът", new string[] { "собственик" });
            assertAnalyzesTo(a, "собственици", new string[] { "собственик" });
            assertAnalyzesTo(a, "собствениците", new string[] { "собственик" });

            // зи -> г
            assertAnalyzesTo(a, "подлог", new string[] { "подлог" });
            assertAnalyzesTo(a, "подлога", new string[] { "подлог" });
            assertAnalyzesTo(a, "подлогът", new string[] { "подлог" });
            assertAnalyzesTo(a, "подлози", new string[] { "подлог" });
            assertAnalyzesTo(a, "подлозите", new string[] { "подлог" });

            // си -> х
            assertAnalyzesTo(a, "кожух", new string[] { "кожух" });
            assertAnalyzesTo(a, "кожуха", new string[] { "кожух" });
            assertAnalyzesTo(a, "кожухът", new string[] { "кожух" });
            assertAnalyzesTo(a, "кожуси", new string[] { "кожух" });
            assertAnalyzesTo(a, "кожусите", new string[] { "кожух" });

            // ъ deletion
            assertAnalyzesTo(a, "център", new string[] { "центр" });
            assertAnalyzesTo(a, "центъра", new string[] { "центр" });
            assertAnalyzesTo(a, "центърът", new string[] { "центр" });
            assertAnalyzesTo(a, "центрове", new string[] { "центр" });
            assertAnalyzesTo(a, "центровете", new string[] { "центр" });

            // е*и -> я*
            assertAnalyzesTo(a, "промяна", new string[] { "промян" });
            assertAnalyzesTo(a, "промяната", new string[] { "промян" });
            assertAnalyzesTo(a, "промени", new string[] { "промян" });
            assertAnalyzesTo(a, "промените", new string[] { "промян" });

            // ен -> н
            assertAnalyzesTo(a, "песен", new string[] { "песн" });
            assertAnalyzesTo(a, "песента", new string[] { "песн" });
            assertAnalyzesTo(a, "песни", new string[] { "песн" });
            assertAnalyzesTo(a, "песните", new string[] { "песн" });

            // -еве -> й
            // note: this is the only word i think this rule works for.
            // most -еве pluralized nouns are monosyllabic,
            // and the stemmer requires length > 6...
            assertAnalyzesTo(a, "строй", new string[] { "строй" });
            assertAnalyzesTo(a, "строеве", new string[] { "строй" });
            assertAnalyzesTo(a, "строевете", new string[] { "строй" });
            /* note the below forms conflate with each other, but not the rest */
            assertAnalyzesTo(a, "строя", new string[] { "стр" });
            assertAnalyzesTo(a, "строят", new string[] { "стр" });
        }

示例#6

文件： TestBulgarianStemmer.cs 项目： Cefa68000/lucenenet

        /// <summary>
        /// Test some exceptional rules, implemented as rewrites.
        /// </summary>
        //JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in .NET:
        //ORIGINAL LINE: public void testExceptions() throws java.io.IOException
        public virtual void testExceptions()
        {
            BulgarianAnalyzer a = new BulgarianAnalyzer(TEST_VERSION_CURRENT);

            // ци -> к
            assertAnalyzesTo(a, "собственик", new string[] {"собственик"});
            assertAnalyzesTo(a, "собственика", new string[] {"собственик"});
            assertAnalyzesTo(a, "собственикът", new string[] {"собственик"});
            assertAnalyzesTo(a, "собственици", new string[] {"собственик"});
            assertAnalyzesTo(a, "собствениците", new string[] {"собственик"});

            // зи -> г
            assertAnalyzesTo(a, "подлог", new string[] {"подлог"});
            assertAnalyzesTo(a, "подлога", new string[] {"подлог"});
            assertAnalyzesTo(a, "подлогът", new string[] {"подлог"});
            assertAnalyzesTo(a, "подлози", new string[] {"подлог"});
            assertAnalyzesTo(a, "подлозите", new string[] {"подлог"});

            // си -> х
            assertAnalyzesTo(a, "кожух", new string[] {"кожух"});
            assertAnalyzesTo(a, "кожуха", new string[] {"кожух"});
            assertAnalyzesTo(a, "кожухът", new string[] {"кожух"});
            assertAnalyzesTo(a, "кожуси", new string[] {"кожух"});
            assertAnalyzesTo(a, "кожусите", new string[] {"кожух"});

            // ъ deletion
            assertAnalyzesTo(a, "център", new string[] {"центр"});
            assertAnalyzesTo(a, "центъра", new string[] {"центр"});
            assertAnalyzesTo(a, "центърът", new string[] {"центр"});
            assertAnalyzesTo(a, "центрове", new string[] {"центр"});
            assertAnalyzesTo(a, "центровете", new string[] {"центр"});

            // е*и -> я*
            assertAnalyzesTo(a, "промяна", new string[] {"промян"});
            assertAnalyzesTo(a, "промяната", new string[] {"промян"});
            assertAnalyzesTo(a, "промени", new string[] {"промян"});
            assertAnalyzesTo(a, "промените", new string[] {"промян"});

            // ен -> н
            assertAnalyzesTo(a, "песен", new string[] {"песн"});
            assertAnalyzesTo(a, "песента", new string[] {"песн"});
            assertAnalyzesTo(a, "песни", new string[] {"песн"});
            assertAnalyzesTo(a, "песните", new string[] {"песн"});

            // -еве -> й
            // note: this is the only word i think this rule works for.
            // most -еве pluralized nouns are monosyllabic,
            // and the stemmer requires length > 6...
            assertAnalyzesTo(a, "строй", new string[] {"строй"});
            assertAnalyzesTo(a, "строеве", new string[] {"строй"});
            assertAnalyzesTo(a, "строевете", new string[] {"строй"});
            /* note the below forms conflate with each other, but not the rest */
            assertAnalyzesTo(a, "строя", new string[] {"стр"});
            assertAnalyzesTo(a, "строят", new string[] {"стр"});
        }

示例#7

文件： TestBulgarianAnalyzer.cs 项目： Cefa68000/lucenenet

        /// <summary>
        /// Test some examples from the paper
        /// </summary>
        //JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in .NET:
        //ORIGINAL LINE: public void testBasicExamples() throws java.io.IOException
        public virtual void testBasicExamples()
        {
            Analyzer a = new BulgarianAnalyzer(TEST_VERSION_CURRENT);
            assertAnalyzesTo(a, "енергийни кризи", new string[] {"енергийн", "криз"});
            assertAnalyzesTo(a, "Атомната енергия", new string[] {"атомн", "енерг"});

            assertAnalyzesTo(a, "компютри", new string[] {"компютр"});
            assertAnalyzesTo(a, "компютър", new string[] {"компютр"});

            assertAnalyzesTo(a, "градове", new string[] {"град"});
        }

示例#8

        /// <summary>
        /// Test some examples from the paper
        /// </summary>
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in .NET:
//ORIGINAL LINE: public void testBasicExamples() throws java.io.IOException
        public virtual void testBasicExamples()
        {
            Analyzer a = new BulgarianAnalyzer(TEST_VERSION_CURRENT);

            assertAnalyzesTo(a, "енергийни кризи", new string[] { "енергийн", "криз" });
            assertAnalyzesTo(a, "Атомната енергия", new string[] { "атомн", "енерг" });

            assertAnalyzesTo(a, "компютри", new string[] { "компютр" });
            assertAnalyzesTo(a, "компютър", new string[] { "компютр" });

            assertAnalyzesTo(a, "градове", new string[] { "град" });
        }

示例#9

文件： TestBulgarianStemmer.cs 项目： Cefa68000/lucenenet

 /// <summary>
 /// Test showing how adjectival forms conflate
 /// </summary>
 //JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in .NET:
 //ORIGINAL LINE: public void testAdjectives() throws java.io.IOException
 public virtual void testAdjectives()
 {
     BulgarianAnalyzer a = new BulgarianAnalyzer(TEST_VERSION_CURRENT);
     assertAnalyzesTo(a, "красив", new string[] {"красив"});
     assertAnalyzesTo(a, "красивия", new string[] {"красив"});
     assertAnalyzesTo(a, "красивият", new string[] {"красив"});
     assertAnalyzesTo(a, "красива", new string[] {"красив"});
     assertAnalyzesTo(a, "красивата", new string[] {"красив"});
     assertAnalyzesTo(a, "красиво", new string[] {"красив"});
     assertAnalyzesTo(a, "красивото", new string[] {"красив"});
     assertAnalyzesTo(a, "красиви", new string[] {"красив"});
     assertAnalyzesTo(a, "красивите", new string[] {"красив"});
 }

示例#10

文件： TestBulgarianStemmer.cs 项目： zfxsss/lucenenet

        /// <summary>
        /// Test showing how adjectival forms conflate
        /// </summary>
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in .NET:
//ORIGINAL LINE: public void testAdjectives() throws java.io.IOException
        public virtual void testAdjectives()
        {
            BulgarianAnalyzer a = new BulgarianAnalyzer(TEST_VERSION_CURRENT);

            assertAnalyzesTo(a, "красив", new string[] { "красив" });
            assertAnalyzesTo(a, "красивия", new string[] { "красив" });
            assertAnalyzesTo(a, "красивият", new string[] { "красив" });
            assertAnalyzesTo(a, "красива", new string[] { "красив" });
            assertAnalyzesTo(a, "красивата", new string[] { "красив" });
            assertAnalyzesTo(a, "красиво", new string[] { "красив" });
            assertAnalyzesTo(a, "красивото", new string[] { "красив" });
            assertAnalyzesTo(a, "красиви", new string[] { "красив" });
            assertAnalyzesTo(a, "красивите", new string[] { "красив" });
        }

示例#11

文件： TestBulgarianStemmer.cs 项目： Cefa68000/lucenenet

        /// <summary>
        /// Test showing how feminine noun forms conflate
        /// </summary>
        //JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in .NET:
        //ORIGINAL LINE: public void testFeminineNouns() throws java.io.IOException
        public virtual void testFeminineNouns()
        {
            BulgarianAnalyzer a = new BulgarianAnalyzer(TEST_VERSION_CURRENT);

            assertAnalyzesTo(a, "вест", new string[] {"вест"});
            assertAnalyzesTo(a, "вестта", new string[] {"вест"});
            assertAnalyzesTo(a, "вести", new string[] {"вест"});
            assertAnalyzesTo(a, "вестите", new string[] {"вест"});
        }

示例#12

//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in .NET:
//ORIGINAL LINE: public void testCustomStopwords() throws java.io.IOException
        public virtual void testCustomStopwords()
        {
            Analyzer a = new BulgarianAnalyzer(TEST_VERSION_CURRENT, CharArraySet.EMPTY_SET);

            assertAnalyzesTo(a, "Как се казваш?", new string[] { "как", "се", "казваш" });
        }

示例#13

//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in .NET:
//ORIGINAL LINE: public void testStopwords() throws java.io.IOException
        public virtual void testStopwords()
        {
            Analyzer a = new BulgarianAnalyzer(TEST_VERSION_CURRENT);

            assertAnalyzesTo(a, "Как се казваш?", new string[] { "казваш" });
        }

示例#14

文件： TestBulgarianStemmer.cs 项目： Cefa68000/lucenenet

        /// <summary>
        /// Test showing how neuter noun forms conflate an example noun for each common
        /// plural pattern is listed
        /// </summary>
        //JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in .NET:
        //ORIGINAL LINE: public void testNeuterNouns() throws java.io.IOException
        public virtual void testNeuterNouns()
        {
            BulgarianAnalyzer a = new BulgarianAnalyzer(TEST_VERSION_CURRENT);

            // -а pattern
            assertAnalyzesTo(a, "дърво", new string[] {"дърв"});
            assertAnalyzesTo(a, "дървото", new string[] {"дърв"});
            assertAnalyzesTo(a, "дърва", new string[] {"дърв"});
            assertAnalyzesTo(a, "дървета", new string[] {"дърв"});
            assertAnalyzesTo(a, "дървата", new string[] {"дърв"});
            assertAnalyzesTo(a, "дърветата", new string[] {"дърв"});

            // -та pattern
            assertAnalyzesTo(a, "море", new string[] {"мор"});
            assertAnalyzesTo(a, "морето", new string[] {"мор"});
            assertAnalyzesTo(a, "морета", new string[] {"мор"});
            assertAnalyzesTo(a, "моретата", new string[] {"мор"});

            // -я pattern
            assertAnalyzesTo(a, "изключение", new string[] {"изключени"});
            assertAnalyzesTo(a, "изключението", new string[] {"изключени"});
            assertAnalyzesTo(a, "изключенията", new string[] {"изключени"});
            /* note the below form in this example does not conflate with the rest */
            assertAnalyzesTo(a, "изключения", new string[] {"изключн"});
        }

示例#15

文件： TestBulgarianStemmer.cs 项目： Cefa68000/lucenenet

        /// <summary>
        /// Test showing how masculine noun forms conflate. An example noun for each
        /// common (and some rare) plural pattern is listed.
        /// </summary>
        //JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in .NET:
        //ORIGINAL LINE: public void testMasculineNouns() throws java.io.IOException
        public virtual void testMasculineNouns()
        {
            BulgarianAnalyzer a = new BulgarianAnalyzer(TEST_VERSION_CURRENT);

            // -и pattern
            assertAnalyzesTo(a, "град", new string[] {"град"});
            assertAnalyzesTo(a, "града", new string[] {"град"});
            assertAnalyzesTo(a, "градът", new string[] {"град"});
            assertAnalyzesTo(a, "градове", new string[] {"град"});
            assertAnalyzesTo(a, "градовете", new string[] {"град"});

            // -ове pattern
            assertAnalyzesTo(a, "народ", new string[] {"народ"});
            assertAnalyzesTo(a, "народа", new string[] {"народ"});
            assertAnalyzesTo(a, "народът", new string[] {"народ"});
            assertAnalyzesTo(a, "народи", new string[] {"народ"});
            assertAnalyzesTo(a, "народите", new string[] {"народ"});
            assertAnalyzesTo(a, "народе", new string[] {"народ"});

            // -ища pattern
            assertAnalyzesTo(a, "път", new string[] {"път"});
            assertAnalyzesTo(a, "пътя", new string[] {"път"});
            assertAnalyzesTo(a, "пътят", new string[] {"път"});
            assertAnalyzesTo(a, "пътища", new string[] {"път"});
            assertAnalyzesTo(a, "пътищата", new string[] {"път"});

            // -чета pattern
            assertAnalyzesTo(a, "градец", new string[] {"градец"});
            assertAnalyzesTo(a, "градеца", new string[] {"градец"});
            assertAnalyzesTo(a, "градецът", new string[] {"градец"});
            /* note the below forms conflate with each other, but not the rest */
            assertAnalyzesTo(a, "градовце", new string[] {"градовц"});
            assertAnalyzesTo(a, "градовцете", new string[] {"градовц"});

            // -овци pattern
            assertAnalyzesTo(a, "дядо", new string[] {"дяд"});
            assertAnalyzesTo(a, "дядото", new string[] {"дяд"});
            assertAnalyzesTo(a, "дядовци", new string[] {"дяд"});
            assertAnalyzesTo(a, "дядовците", new string[] {"дяд"});

            // -е pattern
            assertAnalyzesTo(a, "мъж", new string[] {"мъж"});
            assertAnalyzesTo(a, "мъжа", new string[] {"мъж"});
            assertAnalyzesTo(a, "мъже", new string[] {"мъж"});
            assertAnalyzesTo(a, "мъжете", new string[] {"мъж"});
            assertAnalyzesTo(a, "мъжо", new string[] {"мъж"});
            /* word is too short, will not remove -ът */
            assertAnalyzesTo(a, "мъжът", new string[] {"мъжът"});

            // -а pattern
            assertAnalyzesTo(a, "крак", new string[] {"крак"});
            assertAnalyzesTo(a, "крака", new string[] {"крак"});
            assertAnalyzesTo(a, "кракът", new string[] {"крак"});
            assertAnalyzesTo(a, "краката", new string[] {"крак"});

            // брат
            assertAnalyzesTo(a, "брат", new string[] {"брат"});
            assertAnalyzesTo(a, "брата", new string[] {"брат"});
            assertAnalyzesTo(a, "братът", new string[] {"брат"});
            assertAnalyzesTo(a, "братя", new string[] {"брат"});
            assertAnalyzesTo(a, "братята", new string[] {"брат"});
            assertAnalyzesTo(a, "брате", new string[] {"брат"});
        }

示例#16

文件： TestBulgarianAnalyzer.cs 项目： Cefa68000/lucenenet

 //JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in .NET:
 //ORIGINAL LINE: public void testWithStemExclusionSet() throws java.io.IOException
 public virtual void testWithStemExclusionSet()
 {
     CharArraySet set = new CharArraySet(TEST_VERSION_CURRENT, 1, true);
     set.add("строеве");
     Analyzer a = new BulgarianAnalyzer(TEST_VERSION_CURRENT, CharArraySet.EMPTY_SET, set);
     assertAnalyzesTo(a, "строевете строеве", new string[] {"строй", "строеве"});
 }

示例#17

文件： TestBulgarianAnalyzer.cs 项目： Cefa68000/lucenenet

 //JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in .NET:
 //ORIGINAL LINE: public void testStopwords() throws java.io.IOException
 public virtual void testStopwords()
 {
     Analyzer a = new BulgarianAnalyzer(TEST_VERSION_CURRENT);
     assertAnalyzesTo(a, "Как се казваш?", new string[] {"казваш"});
 }

示例#18

文件： TestBulgarianAnalyzer.cs 项目： Cefa68000/lucenenet

 //JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in .NET:
 //ORIGINAL LINE: public void testReusableTokenStream() throws java.io.IOException
 public virtual void testReusableTokenStream()
 {
     Analyzer a = new BulgarianAnalyzer(TEST_VERSION_CURRENT);
     assertAnalyzesTo(a, "документи", new string[] {"документ"});
     assertAnalyzesTo(a, "документ", new string[] {"документ"});
 }

示例#19

文件： TestBulgarianAnalyzer.cs 项目： Cefa68000/lucenenet

 //JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in .NET:
 //ORIGINAL LINE: public void testCustomStopwords() throws java.io.IOException
 public virtual void testCustomStopwords()
 {
     Analyzer a = new BulgarianAnalyzer(TEST_VERSION_CURRENT, CharArraySet.EMPTY_SET);
     assertAnalyzesTo(a, "Как се казваш?", new string[] {"как", "се", "казваш"});
 }

示例#20

文件： TestBulgarianStemmer.cs 项目： zfxsss/lucenenet

        /// <summary>
        /// Test showing how masculine noun forms conflate. An example noun for each
        /// common (and some rare) plural pattern is listed.
        /// </summary>
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in .NET:
//ORIGINAL LINE: public void testMasculineNouns() throws java.io.IOException
        public virtual void testMasculineNouns()
        {
            BulgarianAnalyzer a = new BulgarianAnalyzer(TEST_VERSION_CURRENT);

            // -и pattern
            assertAnalyzesTo(a, "град", new string[] { "град" });
            assertAnalyzesTo(a, "града", new string[] { "град" });
            assertAnalyzesTo(a, "градът", new string[] { "град" });
            assertAnalyzesTo(a, "градове", new string[] { "град" });
            assertAnalyzesTo(a, "градовете", new string[] { "град" });

            // -ове pattern
            assertAnalyzesTo(a, "народ", new string[] { "народ" });
            assertAnalyzesTo(a, "народа", new string[] { "народ" });
            assertAnalyzesTo(a, "народът", new string[] { "народ" });
            assertAnalyzesTo(a, "народи", new string[] { "народ" });
            assertAnalyzesTo(a, "народите", new string[] { "народ" });
            assertAnalyzesTo(a, "народе", new string[] { "народ" });

            // -ища pattern
            assertAnalyzesTo(a, "път", new string[] { "път" });
            assertAnalyzesTo(a, "пътя", new string[] { "път" });
            assertAnalyzesTo(a, "пътят", new string[] { "път" });
            assertAnalyzesTo(a, "пътища", new string[] { "път" });
            assertAnalyzesTo(a, "пътищата", new string[] { "път" });

            // -чета pattern
            assertAnalyzesTo(a, "градец", new string[] { "градец" });
            assertAnalyzesTo(a, "градеца", new string[] { "градец" });
            assertAnalyzesTo(a, "градецът", new string[] { "градец" });
            /* note the below forms conflate with each other, but not the rest */
            assertAnalyzesTo(a, "градовце", new string[] { "градовц" });
            assertAnalyzesTo(a, "градовцете", new string[] { "градовц" });

            // -овци pattern
            assertAnalyzesTo(a, "дядо", new string[] { "дяд" });
            assertAnalyzesTo(a, "дядото", new string[] { "дяд" });
            assertAnalyzesTo(a, "дядовци", new string[] { "дяд" });
            assertAnalyzesTo(a, "дядовците", new string[] { "дяд" });

            // -е pattern
            assertAnalyzesTo(a, "мъж", new string[] { "мъж" });
            assertAnalyzesTo(a, "мъжа", new string[] { "мъж" });
            assertAnalyzesTo(a, "мъже", new string[] { "мъж" });
            assertAnalyzesTo(a, "мъжете", new string[] { "мъж" });
            assertAnalyzesTo(a, "мъжо", new string[] { "мъж" });
            /* word is too short, will not remove -ът */
            assertAnalyzesTo(a, "мъжът", new string[] { "мъжът" });

            // -а pattern
            assertAnalyzesTo(a, "крак", new string[] { "крак" });
            assertAnalyzesTo(a, "крака", new string[] { "крак" });
            assertAnalyzesTo(a, "кракът", new string[] { "крак" });
            assertAnalyzesTo(a, "краката", new string[] { "крак" });

            // брат
            assertAnalyzesTo(a, "брат", new string[] { "брат" });
            assertAnalyzesTo(a, "брата", new string[] { "брат" });
            assertAnalyzesTo(a, "братът", new string[] { "брат" });
            assertAnalyzesTo(a, "братя", new string[] { "брат" });
            assertAnalyzesTo(a, "братята", new string[] { "брат" });
            assertAnalyzesTo(a, "брате", new string[] { "брат" });
        }