From 1a9cae682d7c5078a9f0634113ab9ae691f7cb33 Mon Sep 17 00:00:00 2001 From: --global Date: Sun, 12 Aug 2018 18:03:15 +0200 Subject: [PATCH 1/5] #66 Add inflection group to word form - Added inflection group property to the word form interface --- .../ukp/jwktl/api/IWiktionaryWordForm.java | 10 + .../jwktl/api/entry/WiktionaryWordForm.java | 13 + .../parser/de/DEWordFormHandlerTest.java | 419 +++++++++--------- 3 files changed, 233 insertions(+), 209 deletions(-) diff --git a/src/main/java/de/tudarmstadt/ukp/jwktl/api/IWiktionaryWordForm.java b/src/main/java/de/tudarmstadt/ukp/jwktl/api/IWiktionaryWordForm.java index de48ace..be6ac60 100644 --- a/src/main/java/de/tudarmstadt/ukp/jwktl/api/IWiktionaryWordForm.java +++ b/src/main/java/de/tudarmstadt/ukp/jwktl/api/IWiktionaryWordForm.java @@ -86,6 +86,16 @@ public interface IWiktionaryWordForm { /** Returns the {@link GrammaticalGender} of this word form or * null if no gender is specified or applicable. */ GrammaticalGender getGender(); + + /** + * Returns the index of the inflection group this word form belong to. + * Semantics of this property may differ from language to language. + * Roughly speaking, inflection group corresponds to the column in + * the inflection table. + * @return Index of the inflection group, -1 if there this word form + * does not belong to an inflection group. + */ + int getInflectionGroup(); /** Returns the {@link GrammaticalPerson} of this word form or * null if no person is specified or applicable. */ diff --git a/src/main/java/de/tudarmstadt/ukp/jwktl/api/entry/WiktionaryWordForm.java b/src/main/java/de/tudarmstadt/ukp/jwktl/api/entry/WiktionaryWordForm.java index 86e3b1e..8d58b0e 100644 --- a/src/main/java/de/tudarmstadt/ukp/jwktl/api/entry/WiktionaryWordForm.java +++ b/src/main/java/de/tudarmstadt/ukp/jwktl/api/entry/WiktionaryWordForm.java @@ -42,6 +42,7 @@ public class WiktionaryWordForm implements IWiktionaryWordForm { protected GrammaticalNumber grammaticalNumber; protected GrammaticalCase grammaticalCase; protected GrammaticalGender grammaticalGender; + protected int inflectionGroup = -1; protected GrammaticalPerson grammaticalPerson; protected GrammaticalTense grammaticalTense; protected GrammaticalMood grammaticalMood; @@ -93,6 +94,18 @@ public void setGender(final GrammaticalGender grammaticalGender) { this.grammaticalGender = grammaticalGender; } + @Override + public int getInflectionGroup() { + return this.inflectionGroup; + } + + /** Assigns the given inflection group to this word form. + * @param inflectionGroup index of the inflection group. + */ + public void setInflectionGroup(int inflectionGroup) { + this.inflectionGroup = inflectionGroup; + } + public GrammaticalPerson getPerson() { return grammaticalPerson; } diff --git a/src/test/java/de/tudarmstadt/ukp/jwktl/parser/de/DEWordFormHandlerTest.java b/src/test/java/de/tudarmstadt/ukp/jwktl/parser/de/DEWordFormHandlerTest.java index 2f42a82..94dcf39 100644 --- a/src/test/java/de/tudarmstadt/ukp/jwktl/parser/de/DEWordFormHandlerTest.java +++ b/src/test/java/de/tudarmstadt/ukp/jwktl/parser/de/DEWordFormHandlerTest.java @@ -55,8 +55,8 @@ public void testAberration() throws Exception { IWiktionaryPage page = parse("Aberration.txt"); IWiktionaryEntry entry = page.getEntry(0); Iterator actualIter = entry.getWordForms().iterator(); - assertWordFormNoun("Aberration", null, SINGULAR, null, actualIter.next()); - assertWordFormNoun("Aberrationen", null, PLURAL, null, actualIter.next()); + assertWordFormNoun("Aberration", null, SINGULAR, null, -1, actualIter.next()); + assertWordFormNoun("Aberrationen", null, PLURAL, null, -1, actualIter.next()); assertFalse(actualIter.hasNext()); } @@ -65,14 +65,14 @@ public void testHallo() throws Exception { IWiktionaryPage page = parse("Hallo.txt"); IWiktionaryEntry entry = page.getEntry(0); Iterator actualIter = entry.getWordForms().iterator(); - assertWordFormNoun("das Hallo", NOMINATIVE, SINGULAR, null, actualIter.next()); - assertWordFormNoun("die Hallos", NOMINATIVE, PLURAL, null, actualIter.next()); - assertWordFormNoun("des Hallos", GENITIVE, SINGULAR, null, actualIter.next()); - assertWordFormNoun("der Hallos", GENITIVE, PLURAL, null, actualIter.next()); - assertWordFormNoun("dem Hallo", DATIVE, SINGULAR, null, actualIter.next()); - assertWordFormNoun("den Hallos", DATIVE, PLURAL, null, actualIter.next()); - assertWordFormNoun("das Hallo", ACCUSATIVE, SINGULAR, null, actualIter.next()); - assertWordFormNoun("die Hallos", ACCUSATIVE, PLURAL, null, actualIter.next()); + assertWordFormNoun("das Hallo", NOMINATIVE, SINGULAR, null, -1, actualIter.next()); + assertWordFormNoun("die Hallos", NOMINATIVE, PLURAL, null, -1, actualIter.next()); + assertWordFormNoun("des Hallos", GENITIVE, SINGULAR, null, -1, actualIter.next()); + assertWordFormNoun("der Hallos", GENITIVE, PLURAL, null, -1, actualIter.next()); + assertWordFormNoun("dem Hallo", DATIVE, SINGULAR, null, -1, actualIter.next()); + assertWordFormNoun("den Hallos", DATIVE, PLURAL, null, -1, actualIter.next()); + assertWordFormNoun("das Hallo", ACCUSATIVE, SINGULAR, null, -1, actualIter.next()); + assertWordFormNoun("die Hallos", ACCUSATIVE, PLURAL, null, -1, actualIter.next()); assertFalse(actualIter.hasNext()); } @@ -81,19 +81,19 @@ public void testKiefer() throws Exception { IWiktionaryPage page = parse("Kiefer.txt"); IWiktionaryEntry entry = page.getEntry(0); Iterator actualIter = entry.getWordForms().iterator(); - assertWordFormNoun("die Kiefer", NOMINATIVE, SINGULAR, null, actualIter.next()); - assertWordFormNoun("die Kiefern", NOMINATIVE, PLURAL, null, actualIter.next()); - assertWordFormNoun("der Kiefer", GENITIVE, SINGULAR, null, actualIter.next()); - assertWordFormNoun("der Kiefern", GENITIVE, PLURAL, null, actualIter.next()); - assertWordFormNoun("der Kiefer", DATIVE, SINGULAR, null, actualIter.next()); - assertWordFormNoun("den Kiefern", DATIVE, PLURAL, null, actualIter.next()); - assertWordFormNoun("die Kiefer", ACCUSATIVE, SINGULAR, null, actualIter.next()); - assertWordFormNoun("die Kiefern", ACCUSATIVE, PLURAL, null, actualIter.next()); + assertWordFormNoun("die Kiefer", NOMINATIVE, SINGULAR, null, -1, actualIter.next()); + assertWordFormNoun("die Kiefern", NOMINATIVE, PLURAL, null, -1, actualIter.next()); + assertWordFormNoun("der Kiefer", GENITIVE, SINGULAR, null, -1, actualIter.next()); + assertWordFormNoun("der Kiefern", GENITIVE, PLURAL, null, -1, actualIter.next()); + assertWordFormNoun("der Kiefer", DATIVE, SINGULAR, null, -1, actualIter.next()); + assertWordFormNoun("den Kiefern", DATIVE, PLURAL, null, -1, actualIter.next()); + assertWordFormNoun("die Kiefer", ACCUSATIVE, SINGULAR, null, -1, actualIter.next()); + assertWordFormNoun("die Kiefern", ACCUSATIVE, PLURAL, null, -1, actualIter.next()); assertFalse(actualIter.hasNext()); entry = page.getEntry(1); actualIter = entry.getWordForms().iterator(); - assertWordFormNoun("Kiefer", null, SINGULAR, null, actualIter.next()); - assertWordFormNoun("Kiefer", null, PLURAL, null, actualIter.next()); + assertWordFormNoun("Kiefer", null, SINGULAR, null, -1, actualIter.next()); + assertWordFormNoun("Kiefer", null, PLURAL, null, -1, actualIter.next()); assertFalse(actualIter.hasNext()); } @@ -102,28 +102,28 @@ public void testStaat() throws Exception { IWiktionaryPage page = parse("Staat.txt"); IWiktionaryEntry entry = page.getEntry(0); Iterator actualIter = entry.getWordForms().iterator(); - assertWordFormNoun("der Staat", NOMINATIVE, SINGULAR, null, actualIter.next()); - assertWordFormNoun("die Staaten", NOMINATIVE, PLURAL, null, actualIter.next()); - assertWordFormNoun("die Stäte", NOMINATIVE, PLURAL, null, actualIter.next()); - assertWordFormNoun("die Staat", NOMINATIVE, PLURAL, null, actualIter.next()); - assertWordFormNoun("die Staate", NOMINATIVE, PLURAL, null, actualIter.next()); - assertWordFormNoun("des Staates", GENITIVE, SINGULAR, null, actualIter.next()); - assertWordFormNoun("des Staats", GENITIVE, SINGULAR, null, actualIter.next()); - assertWordFormNoun("der Staaten", GENITIVE, PLURAL, null, actualIter.next()); - assertWordFormNoun("der Stäte", GENITIVE, PLURAL, null, actualIter.next()); - assertWordFormNoun("der Staat", GENITIVE, PLURAL, null, actualIter.next()); - assertWordFormNoun("der Staate", GENITIVE, PLURAL, null, actualIter.next()); - assertWordFormNoun("dem Staate", DATIVE, SINGULAR, null, actualIter.next()); - assertWordFormNoun("dem Staat", DATIVE, SINGULAR, null, actualIter.next()); - assertWordFormNoun("den Staaten", DATIVE, PLURAL, null, actualIter.next()); - assertWordFormNoun("den Stäten", DATIVE, PLURAL, null, actualIter.next()); - assertWordFormNoun("den Staaten", DATIVE, PLURAL, null, actualIter.next()); - assertWordFormNoun("den Staaten", DATIVE, PLURAL, null, actualIter.next()); - assertWordFormNoun("den Staat", ACCUSATIVE, SINGULAR, null, actualIter.next()); - assertWordFormNoun("die Staaten", ACCUSATIVE, PLURAL, null, actualIter.next()); - assertWordFormNoun("die Stäte", ACCUSATIVE, PLURAL, null, actualIter.next()); - assertWordFormNoun("die Staat", ACCUSATIVE, PLURAL, null, actualIter.next()); - assertWordFormNoun("die Staate", ACCUSATIVE, PLURAL, null, actualIter.next()); + assertWordFormNoun("der Staat", NOMINATIVE, SINGULAR, null, -1, actualIter.next()); + assertWordFormNoun("die Staaten", NOMINATIVE, PLURAL, null, -1, actualIter.next()); + assertWordFormNoun("die Stäte", NOMINATIVE, PLURAL, null, -1, actualIter.next()); + assertWordFormNoun("die Staat", NOMINATIVE, PLURAL, null, -1, actualIter.next()); + assertWordFormNoun("die Staate", NOMINATIVE, PLURAL, null, -1, actualIter.next()); + assertWordFormNoun("des Staates", GENITIVE, SINGULAR, null, -1, actualIter.next()); + assertWordFormNoun("des Staats", GENITIVE, SINGULAR, null, -1, actualIter.next()); + assertWordFormNoun("der Staaten", GENITIVE, PLURAL, null, -1, actualIter.next()); + assertWordFormNoun("der Stäte", GENITIVE, PLURAL, null, -1, actualIter.next()); + assertWordFormNoun("der Staat", GENITIVE, PLURAL, null, -1, actualIter.next()); + assertWordFormNoun("der Staate", GENITIVE, PLURAL, null, -1, actualIter.next()); + assertWordFormNoun("dem Staate", DATIVE, SINGULAR, null, -1, actualIter.next()); + assertWordFormNoun("dem Staat", DATIVE, SINGULAR, null, -1, actualIter.next()); + assertWordFormNoun("den Staaten", DATIVE, PLURAL, null, -1, actualIter.next()); + assertWordFormNoun("den Stäten", DATIVE, PLURAL, null, -1, actualIter.next()); + assertWordFormNoun("den Staaten", DATIVE, PLURAL, null, -1, actualIter.next()); + assertWordFormNoun("den Staaten", DATIVE, PLURAL, null, -1, actualIter.next()); + assertWordFormNoun("den Staat", ACCUSATIVE, SINGULAR, null, -1, actualIter.next()); + assertWordFormNoun("die Staaten", ACCUSATIVE, PLURAL, null, -1, actualIter.next()); + assertWordFormNoun("die Stäte", ACCUSATIVE, PLURAL, null, -1, actualIter.next()); + assertWordFormNoun("die Staat", ACCUSATIVE, PLURAL, null, -1, actualIter.next()); + assertWordFormNoun("die Staate", ACCUSATIVE, PLURAL, null, -1, actualIter.next()); assertFalse(actualIter.hasNext()); } @@ -132,14 +132,14 @@ public void testThulium() throws Exception { IWiktionaryPage page = parse("Thulium.txt"); IWiktionaryEntry entry = page.getEntry(0); Iterator actualIter = entry.getWordForms().iterator(); - assertWordFormNoun("das Thulium", NOMINATIVE, SINGULAR, null, actualIter.next()); - assertWordFormNoun(null, NOMINATIVE, PLURAL, null, actualIter.next()); - assertWordFormNoun("des Thuliums", GENITIVE, SINGULAR, null, actualIter.next()); - assertWordFormNoun(null, GENITIVE, PLURAL, null, actualIter.next()); - assertWordFormNoun("dem Thulium", DATIVE, SINGULAR, null, actualIter.next()); - assertWordFormNoun(null, DATIVE, PLURAL, null, actualIter.next()); - assertWordFormNoun("das Thulium", ACCUSATIVE, SINGULAR, null, actualIter.next()); - assertWordFormNoun(null, ACCUSATIVE, PLURAL, null, actualIter.next()); + assertWordFormNoun("das Thulium", NOMINATIVE, SINGULAR, null, -1, actualIter.next()); + assertWordFormNoun(null, NOMINATIVE, PLURAL, null, -1, actualIter.next()); + assertWordFormNoun("des Thuliums", GENITIVE, SINGULAR, null, -1, actualIter.next()); + assertWordFormNoun(null, GENITIVE, PLURAL, null, -1, actualIter.next()); + assertWordFormNoun("dem Thulium", DATIVE, SINGULAR, null, -1, actualIter.next()); + assertWordFormNoun(null, DATIVE, PLURAL, null, -1, actualIter.next()); + assertWordFormNoun("das Thulium", ACCUSATIVE, SINGULAR, null, -1, actualIter.next()); + assertWordFormNoun(null, ACCUSATIVE, PLURAL, null, -1, actualIter.next()); assertFalse(actualIter.hasNext()); } @@ -148,14 +148,14 @@ public void testTier() throws Exception { IWiktionaryPage page = parse("Tier.txt"); IWiktionaryEntry entry = page.getEntry(0); Iterator actualIter = entry.getWordForms().iterator(); - assertWordFormNoun("das Tier", NOMINATIVE, SINGULAR, null, actualIter.next()); - assertWordFormNoun("die Tiere", NOMINATIVE, PLURAL, null, actualIter.next()); - assertWordFormNoun("des Tier(e)s", GENITIVE, SINGULAR, null, actualIter.next()); - assertWordFormNoun("der Tiere", GENITIVE, PLURAL, null, actualIter.next()); - assertWordFormNoun("dem Tier(e)", DATIVE, SINGULAR, null, actualIter.next()); - assertWordFormNoun("den Tieren", DATIVE, PLURAL, null, actualIter.next()); - assertWordFormNoun("das Tier", ACCUSATIVE, SINGULAR, null, actualIter.next()); - assertWordFormNoun("die Tiere", ACCUSATIVE, PLURAL, null, actualIter.next()); + assertWordFormNoun("das Tier", NOMINATIVE, SINGULAR, null, -1, actualIter.next()); + assertWordFormNoun("die Tiere", NOMINATIVE, PLURAL, null, -1, actualIter.next()); + assertWordFormNoun("des Tier(e)s", GENITIVE, SINGULAR, null, -1, actualIter.next()); + assertWordFormNoun("der Tiere", GENITIVE, PLURAL, null, -1, actualIter.next()); + assertWordFormNoun("dem Tier(e)", DATIVE, SINGULAR, null, -1, actualIter.next()); + assertWordFormNoun("den Tieren", DATIVE, PLURAL, null, -1, actualIter.next()); + assertWordFormNoun("das Tier", ACCUSATIVE, SINGULAR, null, -1, actualIter.next()); + assertWordFormNoun("die Tiere", ACCUSATIVE, PLURAL, null, -1, actualIter.next()); assertFalse(actualIter.hasNext()); } @@ -164,14 +164,14 @@ public void testTun() throws Exception { IWiktionaryPage page = parse("Tun.txt"); IWiktionaryEntry entry = page.getEntry(1); Iterator actualIter = entry.getWordForms().iterator(); - assertWordFormNoun("das Tun", NOMINATIVE, SINGULAR, null, actualIter.next()); - assertWordFormNoun(null, NOMINATIVE, PLURAL, null, actualIter.next()); - assertWordFormNoun("des Tuns", GENITIVE, SINGULAR, null, actualIter.next()); - assertWordFormNoun(null, GENITIVE, PLURAL, null, actualIter.next()); - assertWordFormNoun("dem Tun", DATIVE, SINGULAR, null, actualIter.next()); - assertWordFormNoun(null, DATIVE, PLURAL, null, actualIter.next()); - assertWordFormNoun("das Tun", ACCUSATIVE, SINGULAR, null, actualIter.next()); - assertWordFormNoun(null, ACCUSATIVE, PLURAL, null, actualIter.next()); + assertWordFormNoun("das Tun", NOMINATIVE, SINGULAR, null, -1, actualIter.next()); + assertWordFormNoun(null, NOMINATIVE, PLURAL, null, -1, actualIter.next()); + assertWordFormNoun("des Tuns", GENITIVE, SINGULAR, null, -1, actualIter.next()); + assertWordFormNoun(null, GENITIVE, PLURAL, null, -1, actualIter.next()); + assertWordFormNoun("dem Tun", DATIVE, SINGULAR, null, -1, actualIter.next()); + assertWordFormNoun(null, DATIVE, PLURAL, null, -1, actualIter.next()); + assertWordFormNoun("das Tun", ACCUSATIVE, SINGULAR, null, -1, actualIter.next()); + assertWordFormNoun(null, ACCUSATIVE, PLURAL, null, -1, actualIter.next()); assertFalse(actualIter.hasNext()); } @@ -291,18 +291,18 @@ public void testGelb() throws Exception { IWiktionaryPage page = parse("Gelb.txt"); IWiktionaryEntry entry = page.getEntry(0); Iterator actualIter = entry.getWordForms().iterator(); - assertWordFormNoun("Gelb", NOMINATIVE, SINGULAR, NEUTER, actualIter.next()); - assertWordFormNoun("Gelbs", NOMINATIVE, PLURAL, null, actualIter.next()); - assertWordFormNoun("Gelbtöne", NOMINATIVE, PLURAL, null, actualIter.next()); - assertWordFormNoun("Gelbs", GENITIVE, SINGULAR, NEUTER, actualIter.next()); - assertWordFormNoun("Gelbs", GENITIVE, PLURAL, null, actualIter.next()); - assertWordFormNoun("Gelbtöne", GENITIVE, PLURAL, null, actualIter.next()); - assertWordFormNoun("Gelb", DATIVE, SINGULAR, NEUTER, actualIter.next()); - assertWordFormNoun("Gelbs", DATIVE, PLURAL, null, actualIter.next()); - assertWordFormNoun("Gelbtönen", DATIVE, PLURAL, null, actualIter.next()); - assertWordFormNoun("Gelb", ACCUSATIVE, SINGULAR, NEUTER, actualIter.next()); - assertWordFormNoun("Gelbs", ACCUSATIVE, PLURAL, null, actualIter.next()); - assertWordFormNoun("Gelbtöne", ACCUSATIVE, PLURAL, null, actualIter.next()); + assertWordFormNoun("Gelb", NOMINATIVE, SINGULAR, NEUTER, -1, actualIter.next()); + assertWordFormNoun("Gelbs", NOMINATIVE, PLURAL, null, -1, actualIter.next()); + assertWordFormNoun("Gelbtöne", NOMINATIVE, PLURAL, null, -1, actualIter.next()); + assertWordFormNoun("Gelbs", GENITIVE, SINGULAR, NEUTER, -1, actualIter.next()); + assertWordFormNoun("Gelbs", GENITIVE, PLURAL, null, -1, actualIter.next()); + assertWordFormNoun("Gelbtöne", GENITIVE, PLURAL, null, -1, actualIter.next()); + assertWordFormNoun("Gelb", DATIVE, SINGULAR, NEUTER, -1, actualIter.next()); + assertWordFormNoun("Gelbs", DATIVE, PLURAL, null, -1, actualIter.next()); + assertWordFormNoun("Gelbtönen", DATIVE, PLURAL, null, -1, actualIter.next()); + assertWordFormNoun("Gelb", ACCUSATIVE, SINGULAR, NEUTER, -1, actualIter.next()); + assertWordFormNoun("Gelbs", ACCUSATIVE, PLURAL, null, -1, actualIter.next()); + assertWordFormNoun("Gelbtöne", ACCUSATIVE, PLURAL, null, -1, actualIter.next()); assertFalse(actualIter.hasNext()); } @@ -311,17 +311,17 @@ public void testMaerz() throws Exception { IWiktionaryPage page = parse("Maerz.txt"); IWiktionaryEntry entry = page.getEntry(0); Iterator actualIter = entry.getWordForms().iterator(); - assertWordFormNoun("März", NOMINATIVE, SINGULAR, MASCULINE, actualIter.next()); - assertWordFormNoun("Märze", NOMINATIVE, PLURAL, null, actualIter.next()); - assertWordFormNoun("März", GENITIVE, SINGULAR, MASCULINE, actualIter.next()); - assertWordFormNoun("Märzes", GENITIVE, SINGULAR, MASCULINE, actualIter.next()); - assertWordFormNoun("Märzen", GENITIVE, SINGULAR, MASCULINE, actualIter.next()); - assertWordFormNoun("Märze", GENITIVE, PLURAL, null, actualIter.next()); - assertWordFormNoun("März", DATIVE, SINGULAR, MASCULINE, actualIter.next()); - assertWordFormNoun("Märzen", DATIVE, SINGULAR, MASCULINE, actualIter.next()); - assertWordFormNoun("Märzen", DATIVE, PLURAL, null, actualIter.next()); - assertWordFormNoun("März", ACCUSATIVE, SINGULAR, MASCULINE, actualIter.next()); - assertWordFormNoun("Märze", ACCUSATIVE, PLURAL, null, actualIter.next()); + assertWordFormNoun("März", NOMINATIVE, SINGULAR, MASCULINE, -1, actualIter.next()); + assertWordFormNoun("Märze", NOMINATIVE, PLURAL, null, -1, actualIter.next()); + assertWordFormNoun("März", GENITIVE, SINGULAR, MASCULINE, -1, actualIter.next()); + assertWordFormNoun("Märzes", GENITIVE, SINGULAR, MASCULINE, -1, actualIter.next()); + assertWordFormNoun("Märzen", GENITIVE, SINGULAR, MASCULINE, -1, actualIter.next()); + assertWordFormNoun("Märze", GENITIVE, PLURAL, null, -1, actualIter.next()); + assertWordFormNoun("März", DATIVE, SINGULAR, MASCULINE, -1, actualIter.next()); + assertWordFormNoun("Märzen", DATIVE, SINGULAR, MASCULINE, -1, actualIter.next()); + assertWordFormNoun("Märzen", DATIVE, PLURAL, null, -1, actualIter.next()); + assertWordFormNoun("März", ACCUSATIVE, SINGULAR, MASCULINE, -1, actualIter.next()); + assertWordFormNoun("Märze", ACCUSATIVE, PLURAL, null, -1, actualIter.next()); assertFalse(actualIter.hasNext()); } @@ -330,24 +330,24 @@ public void testMockumentary() throws Exception { IWiktionaryPage page = parse("Mockumentary.txt"); IWiktionaryEntry entry = page.getEntry(0); Iterator actualIter = entry.getWordForms().iterator(); - assertWordFormNoun("Mockumentary", NOMINATIVE, SINGULAR, MASCULINE, actualIter.next()); - assertWordFormNoun("Mockumentary", NOMINATIVE, SINGULAR, FEMININE, actualIter.next()); - assertWordFormNoun("Mockumentary", NOMINATIVE, SINGULAR, NEUTER, actualIter.next()); - assertWordFormNoun("Mockumentarys", NOMINATIVE, PLURAL, null, actualIter.next()); - assertWordFormNoun("Mockumentary", GENITIVE, SINGULAR, MASCULINE, actualIter.next()); - assertWordFormNoun("Mockumentary", GENITIVE, SINGULAR, FEMININE, actualIter.next()); - assertWordFormNoun("Mockumentarys", GENITIVE, SINGULAR, FEMININE, actualIter.next()); - assertWordFormNoun("Mockumentary", GENITIVE, SINGULAR, NEUTER, actualIter.next()); - assertWordFormNoun("Mockumentarys", GENITIVE, SINGULAR, NEUTER, actualIter.next()); - assertWordFormNoun("Mockumentarys", GENITIVE, PLURAL, null, actualIter.next()); - assertWordFormNoun("Mockumentary", DATIVE, SINGULAR, MASCULINE, actualIter.next()); - assertWordFormNoun("Mockumentary", DATIVE, SINGULAR, FEMININE, actualIter.next()); - assertWordFormNoun("Mockumentary", DATIVE, SINGULAR, NEUTER, actualIter.next()); - assertWordFormNoun("Mockumentarys", DATIVE, PLURAL, null, actualIter.next()); - assertWordFormNoun("Mockumentary", ACCUSATIVE, SINGULAR, MASCULINE, actualIter.next()); - assertWordFormNoun("Mockumentary", ACCUSATIVE, SINGULAR, FEMININE, actualIter.next()); - assertWordFormNoun("Mockumentary", ACCUSATIVE, SINGULAR, NEUTER, actualIter.next()); - assertWordFormNoun("Mockumentarys", ACCUSATIVE, PLURAL, null, actualIter.next()); + assertWordFormNoun("Mockumentary", NOMINATIVE, SINGULAR, MASCULINE, -1, actualIter.next()); + assertWordFormNoun("Mockumentary", NOMINATIVE, SINGULAR, FEMININE, -1, actualIter.next()); + assertWordFormNoun("Mockumentary", NOMINATIVE, SINGULAR, NEUTER, -1, actualIter.next()); + assertWordFormNoun("Mockumentarys", NOMINATIVE, PLURAL, null, -1, actualIter.next()); + assertWordFormNoun("Mockumentary", GENITIVE, SINGULAR, MASCULINE, -1, actualIter.next()); + assertWordFormNoun("Mockumentary", GENITIVE, SINGULAR, FEMININE, -1, actualIter.next()); + assertWordFormNoun("Mockumentarys", GENITIVE, SINGULAR, FEMININE, -1, actualIter.next()); + assertWordFormNoun("Mockumentary", GENITIVE, SINGULAR, NEUTER, -1, actualIter.next()); + assertWordFormNoun("Mockumentarys", GENITIVE, SINGULAR, NEUTER, -1, actualIter.next()); + assertWordFormNoun("Mockumentarys", GENITIVE, PLURAL, null, -1, actualIter.next()); + assertWordFormNoun("Mockumentary", DATIVE, SINGULAR, MASCULINE, -1, actualIter.next()); + assertWordFormNoun("Mockumentary", DATIVE, SINGULAR, FEMININE, -1, actualIter.next()); + assertWordFormNoun("Mockumentary", DATIVE, SINGULAR, NEUTER, -1, actualIter.next()); + assertWordFormNoun("Mockumentarys", DATIVE, PLURAL, null, -1, actualIter.next()); + assertWordFormNoun("Mockumentary", ACCUSATIVE, SINGULAR, MASCULINE, -1, actualIter.next()); + assertWordFormNoun("Mockumentary", ACCUSATIVE, SINGULAR, FEMININE, -1, actualIter.next()); + assertWordFormNoun("Mockumentary", ACCUSATIVE, SINGULAR, NEUTER, -1, actualIter.next()); + assertWordFormNoun("Mockumentarys", ACCUSATIVE, PLURAL, null, -1, actualIter.next()); assertFalse(actualIter.hasNext()); } @@ -357,23 +357,23 @@ public void testKeks() throws Exception { IWiktionaryPage page = parse("Keks.txt"); IWiktionaryEntry entry = page.getEntry(0); Iterator actualIter = entry.getWordForms().iterator(); - assertWordFormNoun("Keks", NOMINATIVE, SINGULAR, MASCULINE, actualIter.next()); - assertWordFormNoun("Keks", NOMINATIVE, SINGULAR, NEUTER, actualIter.next()); - assertWordFormNoun("Kekse", NOMINATIVE, PLURAL, null, actualIter.next()); + assertWordFormNoun("Keks", NOMINATIVE, SINGULAR, MASCULINE, -1, actualIter.next()); + assertWordFormNoun("Keks", NOMINATIVE, SINGULAR, NEUTER, -1, actualIter.next()); + assertWordFormNoun("Kekse", NOMINATIVE, PLURAL, null, -1, actualIter.next()); - assertWordFormNoun("Kekses", GENITIVE, SINGULAR, MASCULINE, actualIter.next()); - assertWordFormNoun("Kekses", GENITIVE, SINGULAR, NEUTER, actualIter.next()); - assertWordFormNoun("Kekse", GENITIVE, PLURAL, null, actualIter.next()); + assertWordFormNoun("Kekses", GENITIVE, SINGULAR, MASCULINE, -1, actualIter.next()); + assertWordFormNoun("Kekses", GENITIVE, SINGULAR, NEUTER, -1, actualIter.next()); + assertWordFormNoun("Kekse", GENITIVE, PLURAL, null, -1, actualIter.next()); - assertWordFormNoun("Keks", DATIVE, SINGULAR, MASCULINE, actualIter.next()); - assertWordFormNoun("Kekse", DATIVE, SINGULAR, MASCULINE, actualIter.next()); - assertWordFormNoun("Keks", DATIVE, SINGULAR, NEUTER, actualIter.next()); - assertWordFormNoun("Kekse", DATIVE, SINGULAR, NEUTER, actualIter.next()); - assertWordFormNoun("Keksen", DATIVE, PLURAL, null, actualIter.next()); + assertWordFormNoun("Keks", DATIVE, SINGULAR, MASCULINE, -1, actualIter.next()); + assertWordFormNoun("Kekse", DATIVE, SINGULAR, MASCULINE, -1, actualIter.next()); + assertWordFormNoun("Keks", DATIVE, SINGULAR, NEUTER, -1, actualIter.next()); + assertWordFormNoun("Kekse", DATIVE, SINGULAR, NEUTER, -1, actualIter.next()); + assertWordFormNoun("Keksen", DATIVE, PLURAL, null, -1, actualIter.next()); - assertWordFormNoun("Keks", ACCUSATIVE, SINGULAR, MASCULINE, actualIter.next()); - assertWordFormNoun("Keks", ACCUSATIVE, SINGULAR, NEUTER, actualIter.next()); - assertWordFormNoun("Kekse", ACCUSATIVE, PLURAL, null, actualIter.next()); + assertWordFormNoun("Keks", ACCUSATIVE, SINGULAR, MASCULINE, -1, actualIter.next()); + assertWordFormNoun("Keks", ACCUSATIVE, SINGULAR, NEUTER, -1, actualIter.next()); + assertWordFormNoun("Kekse", ACCUSATIVE, PLURAL, null, -1, actualIter.next()); assertFalse(actualIter.hasNext()); } @@ -383,18 +383,18 @@ public void testFreischurf() throws Exception { IWiktionaryPage page = parse("Freischurf.txt"); IWiktionaryEntry entry = page.getEntry(0); Iterator actualIter = entry.getWordForms().iterator(); - assertWordFormNoun("Freischurf", NOMINATIVE, SINGULAR, MASCULINE, actualIter.next()); - assertWordFormNoun("Freischürfe", NOMINATIVE, PLURAL, null, actualIter.next()); + assertWordFormNoun("Freischurf", NOMINATIVE, SINGULAR, MASCULINE, -1, actualIter.next()); + assertWordFormNoun("Freischürfe", NOMINATIVE, PLURAL, null, -1, actualIter.next()); - assertWordFormNoun("Freischurfes", GENITIVE, SINGULAR, MASCULINE, actualIter.next()); - assertWordFormNoun("Freischurfs", GENITIVE, SINGULAR, MASCULINE, actualIter.next()); - assertWordFormNoun("Freischürfe", GENITIVE, PLURAL, null, actualIter.next()); + assertWordFormNoun("Freischurfes", GENITIVE, SINGULAR, MASCULINE, -1, actualIter.next()); + assertWordFormNoun("Freischurfs", GENITIVE, SINGULAR, MASCULINE, -1, actualIter.next()); + assertWordFormNoun("Freischürfe", GENITIVE, PLURAL, null, -1, actualIter.next()); - assertWordFormNoun("Freischurf", DATIVE, SINGULAR, MASCULINE, actualIter.next()); - assertWordFormNoun("Freischürfen", DATIVE, PLURAL, null, actualIter.next()); + assertWordFormNoun("Freischurf", DATIVE, SINGULAR, MASCULINE, -1, actualIter.next()); + assertWordFormNoun("Freischürfen", DATIVE, PLURAL, null, -1, actualIter.next()); - assertWordFormNoun("Freischurf", ACCUSATIVE, SINGULAR, MASCULINE, actualIter.next()); - assertWordFormNoun("Freischürfe", ACCUSATIVE, PLURAL, null, actualIter.next()); + assertWordFormNoun("Freischurf", ACCUSATIVE, SINGULAR, MASCULINE, -1, actualIter.next()); + assertWordFormNoun("Freischürfe", ACCUSATIVE, PLURAL, null, -1, actualIter.next()); assertFalse(actualIter.hasNext()); } @@ -404,23 +404,23 @@ public void testFels() throws Exception { IWiktionaryPage page = parse("Fels.txt"); IWiktionaryEntry entry = page.getEntry(0); Iterator actualIter = entry.getWordForms().iterator(); - assertWordFormNoun("Fels", NOMINATIVE, SINGULAR, MASCULINE, actualIter.next()); - assertWordFormNoun("Fels", NOMINATIVE, SINGULAR, MASCULINE, actualIter.next()); - assertWordFormNoun("Felsen", NOMINATIVE, PLURAL, null, actualIter.next()); - - assertWordFormNoun("Fels", GENITIVE, SINGULAR, MASCULINE, actualIter.next()); - assertWordFormNoun("Felses", GENITIVE, SINGULAR, MASCULINE, actualIter.next()); - assertWordFormNoun("Felsens", GENITIVE, SINGULAR, MASCULINE, actualIter.next()); - assertWordFormNoun("Felsen", GENITIVE, SINGULAR, MASCULINE, actualIter.next()); - assertWordFormNoun("Felsen", GENITIVE, PLURAL, null, actualIter.next()); - - assertWordFormNoun("Fels", DATIVE, SINGULAR, MASCULINE, actualIter.next()); - assertWordFormNoun("Felsen", DATIVE, SINGULAR, MASCULINE, actualIter.next()); - assertWordFormNoun("Felsen", DATIVE, PLURAL, null, actualIter.next()); - - assertWordFormNoun("Fels", ACCUSATIVE, SINGULAR, MASCULINE, actualIter.next()); - assertWordFormNoun("Felsen", ACCUSATIVE, SINGULAR, MASCULINE, actualIter.next()); - assertWordFormNoun("Felsen", ACCUSATIVE, PLURAL, null, actualIter.next()); + assertWordFormNoun("Fels", NOMINATIVE, SINGULAR, MASCULINE, -1, actualIter.next()); + assertWordFormNoun("Fels", NOMINATIVE, SINGULAR, MASCULINE, -1, actualIter.next()); + assertWordFormNoun("Felsen", NOMINATIVE, PLURAL, null, -1, actualIter.next()); + + assertWordFormNoun("Fels", GENITIVE, SINGULAR, MASCULINE, -1, actualIter.next()); + assertWordFormNoun("Felses", GENITIVE, SINGULAR, MASCULINE, -1, actualIter.next()); + assertWordFormNoun("Felsens", GENITIVE, SINGULAR, MASCULINE, -1, actualIter.next()); + assertWordFormNoun("Felsen", GENITIVE, SINGULAR, MASCULINE, -1, actualIter.next()); + assertWordFormNoun("Felsen", GENITIVE, PLURAL, null, -1, actualIter.next()); + + assertWordFormNoun("Fels", DATIVE, SINGULAR, MASCULINE, -1, actualIter.next()); + assertWordFormNoun("Felsen", DATIVE, SINGULAR, MASCULINE, -1, actualIter.next()); + assertWordFormNoun("Felsen", DATIVE, PLURAL, null, -1, actualIter.next()); + + assertWordFormNoun("Fels", ACCUSATIVE, SINGULAR, MASCULINE, -1, actualIter.next()); + assertWordFormNoun("Felsen", ACCUSATIVE, SINGULAR, MASCULINE, -1, actualIter.next()); + assertWordFormNoun("Felsen", ACCUSATIVE, PLURAL, null, -1, actualIter.next()); assertFalse(actualIter.hasNext()); } @@ -429,23 +429,23 @@ public void testUnschlitt() throws Exception { IWiktionaryPage page = parse("Unschlitt.txt"); IWiktionaryEntry entry = page.getEntry(0); Iterator actualIter = entry.getWordForms().iterator(); - assertWordFormNoun("Unschlitt", NOMINATIVE, SINGULAR, NEUTER, actualIter.next()); - assertWordFormNoun("Unschlitt", NOMINATIVE, SINGULAR, MASCULINE, actualIter.next()); - assertWordFormNoun("Unschlitte", NOMINATIVE, PLURAL, null, actualIter.next()); - - assertWordFormNoun("Unschlitts", GENITIVE, SINGULAR, NEUTER, actualIter.next()); - assertWordFormNoun("Unschlittes", GENITIVE, SINGULAR, NEUTER, actualIter.next()); - assertWordFormNoun("Unschlitts", GENITIVE, SINGULAR, MASCULINE, actualIter.next()); - assertWordFormNoun("Unschlittes", GENITIVE, SINGULAR, MASCULINE, actualIter.next()); - assertWordFormNoun("Unschlitte", GENITIVE, PLURAL, null, actualIter.next()); - - assertWordFormNoun("Unschlitt", DATIVE, SINGULAR, NEUTER, actualIter.next()); - assertWordFormNoun("Unschlitt", DATIVE, SINGULAR, MASCULINE, actualIter.next()); - assertWordFormNoun("Unschlitten", DATIVE, PLURAL, null, actualIter.next()); - - assertWordFormNoun("Unschlitt", ACCUSATIVE, SINGULAR, NEUTER, actualIter.next()); - assertWordFormNoun("Unschlitt", ACCUSATIVE, SINGULAR, MASCULINE, actualIter.next()); - assertWordFormNoun("Unschlitte", ACCUSATIVE, PLURAL, null, actualIter.next()); + assertWordFormNoun("Unschlitt", NOMINATIVE, SINGULAR, NEUTER, -1, actualIter.next()); + assertWordFormNoun("Unschlitt", NOMINATIVE, SINGULAR, MASCULINE, -1, actualIter.next()); + assertWordFormNoun("Unschlitte", NOMINATIVE, PLURAL, null, -1, actualIter.next()); + + assertWordFormNoun("Unschlitts", GENITIVE, SINGULAR, NEUTER, -1, actualIter.next()); + assertWordFormNoun("Unschlittes", GENITIVE, SINGULAR, NEUTER, -1, actualIter.next()); + assertWordFormNoun("Unschlitts", GENITIVE, SINGULAR, MASCULINE, -1, actualIter.next()); + assertWordFormNoun("Unschlittes", GENITIVE, SINGULAR, MASCULINE, -1, actualIter.next()); + assertWordFormNoun("Unschlitte", GENITIVE, PLURAL, null, -1, actualIter.next()); + + assertWordFormNoun("Unschlitt", DATIVE, SINGULAR, NEUTER, -1, actualIter.next()); + assertWordFormNoun("Unschlitt", DATIVE, SINGULAR, MASCULINE, -1, actualIter.next()); + assertWordFormNoun("Unschlitten", DATIVE, PLURAL, null, -1, actualIter.next()); + + assertWordFormNoun("Unschlitt", ACCUSATIVE, SINGULAR, NEUTER, -1, actualIter.next()); + assertWordFormNoun("Unschlitt", ACCUSATIVE, SINGULAR, MASCULINE, -1, actualIter.next()); + assertWordFormNoun("Unschlitte", ACCUSATIVE, PLURAL, null, -1, actualIter.next()); assertFalse(actualIter.hasNext()); } @@ -454,8 +454,8 @@ public void testFote() throws Exception { IWiktionaryPage page = parse("Fote.txt"); IWiktionaryEntry entry = page.getEntry(0); Iterator actualIter = entry.getWordForms().iterator(); - assertWordFormNoun("de Fote", null, SINGULAR, null, actualIter.next()); - assertWordFormNoun("de Foten", null, PLURAL, null, actualIter.next()); + assertWordFormNoun("de Fote", null, SINGULAR, null, -1, actualIter.next()); + assertWordFormNoun("de Foten", null, PLURAL, null, -1, actualIter.next()); assertFalse(actualIter.hasNext()); } @@ -464,22 +464,22 @@ public void testGeneraladmiral() throws Exception { IWiktionaryPage page = parse("Generaladmiral.txt"); IWiktionaryEntry entry = page.getEntry(0); Iterator actualIter = entry.getWordForms().iterator(); - assertWordFormNoun("Generaladmiral", NOMINATIVE, SINGULAR, MASCULINE, actualIter.next()); - assertWordFormNoun("Generaladmirale", NOMINATIVE, PLURAL, null, actualIter.next()); - assertWordFormNoun("Generaladmiräle", NOMINATIVE, PLURAL, null, actualIter.next()); - - assertWordFormNoun("Generaladmirals", GENITIVE, SINGULAR, MASCULINE, actualIter.next()); - assertWordFormNoun("Generaladmirale", GENITIVE, PLURAL, null, actualIter.next()); - assertWordFormNoun("Generaladmiräle", GENITIVE, PLURAL, null, actualIter.next()); - - assertWordFormNoun("Generaladmiral", DATIVE, SINGULAR, MASCULINE, actualIter.next()); - assertWordFormNoun("Generaladmirale", DATIVE, SINGULAR, MASCULINE, actualIter.next()); - assertWordFormNoun("Generaladmiralen", DATIVE, PLURAL, null, actualIter.next()); - assertWordFormNoun("Generaladmirälen", DATIVE, PLURAL, null, actualIter.next()); - - assertWordFormNoun("Generaladmiral", ACCUSATIVE, SINGULAR, MASCULINE, actualIter.next()); - assertWordFormNoun("Generaladmirale", ACCUSATIVE, PLURAL, null, actualIter.next()); - assertWordFormNoun("Generaladmiräle", ACCUSATIVE, PLURAL, null, actualIter.next()); + assertWordFormNoun("Generaladmiral", NOMINATIVE, SINGULAR, MASCULINE, -1, actualIter.next()); + assertWordFormNoun("Generaladmirale", NOMINATIVE, PLURAL, null, -1, actualIter.next()); + assertWordFormNoun("Generaladmiräle", NOMINATIVE, PLURAL, null, -1, actualIter.next()); + + assertWordFormNoun("Generaladmirals", GENITIVE, SINGULAR, MASCULINE, -1, actualIter.next()); + assertWordFormNoun("Generaladmirale", GENITIVE, PLURAL, null, -1, actualIter.next()); + assertWordFormNoun("Generaladmiräle", GENITIVE, PLURAL, null, -1, actualIter.next()); + + assertWordFormNoun("Generaladmiral", DATIVE, SINGULAR, MASCULINE, -1, actualIter.next()); + assertWordFormNoun("Generaladmirale", DATIVE, SINGULAR, MASCULINE, -1, actualIter.next()); + assertWordFormNoun("Generaladmiralen", DATIVE, PLURAL, null, -1, actualIter.next()); + assertWordFormNoun("Generaladmirälen", DATIVE, PLURAL, null, -1, actualIter.next()); + + assertWordFormNoun("Generaladmiral", ACCUSATIVE, SINGULAR, MASCULINE, -1, actualIter.next()); + assertWordFormNoun("Generaladmirale", ACCUSATIVE, PLURAL, null, -1, actualIter.next()); + assertWordFormNoun("Generaladmiräle", ACCUSATIVE, PLURAL, null, -1, actualIter.next()); assertFalse(actualIter.hasNext()); } @@ -488,42 +488,43 @@ public void testGams() throws Exception { IWiktionaryPage page = parse("Gams.txt"); IWiktionaryEntry entry = page.getEntry(0); Iterator actualIter = entry.getWordForms().iterator(); - assertWordFormNoun("Gams", NOMINATIVE, SINGULAR, FEMININE, actualIter.next()); - assertWordFormNoun("Gams", NOMINATIVE, SINGULAR, MASCULINE, actualIter.next()); - assertWordFormNoun("Gams", NOMINATIVE, SINGULAR, NEUTER, actualIter.next()); - assertWordFormNoun("Gams", GENITIVE, SINGULAR, NEUTER, actualIter.next()); - assertWordFormNoun("Gams", GENITIVE, SINGULAR, MASCULINE, actualIter.next()); - assertWordFormNoun("Gamsen", GENITIVE, SINGULAR, MASCULINE, actualIter.next()); - assertWordFormNoun("Gamsen", DATIVE, SINGULAR, MASCULINE, actualIter.next()); - assertWordFormNoun("Gamsen", ACCUSATIVE, SINGULAR, MASCULINE, actualIter.next()); - assertWordFormNoun("Gamsen", GENITIVE, SINGULAR, NEUTER, actualIter.next()); - assertWordFormNoun("Gamsen", DATIVE, SINGULAR, NEUTER, actualIter.next()); - assertWordFormNoun("Gamsen", ACCUSATIVE, SINGULAR, NEUTER, actualIter.next()); - assertWordFormNoun("Gams", DATIVE, SINGULAR, NEUTER, actualIter.next()); - assertWordFormNoun("Gams", DATIVE, SINGULAR, MASCULINE, actualIter.next()); - assertWordFormNoun("Gams", ACCUSATIVE, SINGULAR, NEUTER, actualIter.next()); - assertWordFormNoun("Gams", ACCUSATIVE, SINGULAR, MASCULINE, actualIter.next()); - assertWordFormNoun("Gams", NOMINATIVE, PLURAL, null, actualIter.next()); - assertWordFormNoun("Gamsen", NOMINATIVE, PLURAL, null, actualIter.next()); - assertWordFormNoun("Gams", GENITIVE, SINGULAR, FEMININE, actualIter.next()); - assertWordFormNoun("Gams", GENITIVE, PLURAL, null, actualIter.next()); - assertWordFormNoun("Gamsen", GENITIVE, PLURAL, null, actualIter.next()); - assertWordFormNoun("Gams", DATIVE, SINGULAR, FEMININE, actualIter.next()); - assertWordFormNoun("Gams", DATIVE, PLURAL, null, actualIter.next()); - assertWordFormNoun("Gamsen", DATIVE, PLURAL, null, actualIter.next()); - assertWordFormNoun("Gams", ACCUSATIVE, SINGULAR, FEMININE, actualIter.next()); - assertWordFormNoun("Gams", ACCUSATIVE, PLURAL, null, actualIter.next()); - assertWordFormNoun("Gamsen", ACCUSATIVE, PLURAL, null, actualIter.next()); + assertWordFormNoun("Gams", NOMINATIVE, SINGULAR, FEMININE, -1, actualIter.next()); + assertWordFormNoun("Gams", NOMINATIVE, SINGULAR, MASCULINE, -1, actualIter.next()); + assertWordFormNoun("Gams", NOMINATIVE, SINGULAR, NEUTER, -1, actualIter.next()); + assertWordFormNoun("Gams", GENITIVE, SINGULAR, NEUTER, -1, actualIter.next()); + assertWordFormNoun("Gams", GENITIVE, SINGULAR, MASCULINE, -1, actualIter.next()); + assertWordFormNoun("Gamsen", GENITIVE, SINGULAR, MASCULINE, -1, actualIter.next()); + assertWordFormNoun("Gamsen", DATIVE, SINGULAR, MASCULINE, -1, actualIter.next()); + assertWordFormNoun("Gamsen", ACCUSATIVE, SINGULAR, MASCULINE, -1, actualIter.next()); + assertWordFormNoun("Gamsen", GENITIVE, SINGULAR, NEUTER, -1, actualIter.next()); + assertWordFormNoun("Gamsen", DATIVE, SINGULAR, NEUTER, -1, actualIter.next()); + assertWordFormNoun("Gamsen", ACCUSATIVE, SINGULAR, NEUTER, -1, actualIter.next()); + assertWordFormNoun("Gams", DATIVE, SINGULAR, NEUTER, -1, actualIter.next()); + assertWordFormNoun("Gams", DATIVE, SINGULAR, MASCULINE, -1, actualIter.next()); + assertWordFormNoun("Gams", ACCUSATIVE, SINGULAR, NEUTER, -1, actualIter.next()); + assertWordFormNoun("Gams", ACCUSATIVE, SINGULAR, MASCULINE, -1, actualIter.next()); + assertWordFormNoun("Gams", NOMINATIVE, PLURAL, null, -1, actualIter.next()); + assertWordFormNoun("Gamsen", NOMINATIVE, PLURAL, null, -1, actualIter.next()); + assertWordFormNoun("Gams", GENITIVE, SINGULAR, FEMININE, -1, actualIter.next()); + assertWordFormNoun("Gams", GENITIVE, PLURAL, null, -1, actualIter.next()); + assertWordFormNoun("Gamsen", GENITIVE, PLURAL, null, -1, actualIter.next()); + assertWordFormNoun("Gams", DATIVE, SINGULAR, FEMININE, -1, actualIter.next()); + assertWordFormNoun("Gams", DATIVE, PLURAL, null, -1, actualIter.next()); + assertWordFormNoun("Gamsen", DATIVE, PLURAL, null, -1, actualIter.next()); + assertWordFormNoun("Gams", ACCUSATIVE, SINGULAR, FEMININE, -1, actualIter.next()); + assertWordFormNoun("Gams", ACCUSATIVE, PLURAL, null, -1, actualIter.next()); + assertWordFormNoun("Gamsen", ACCUSATIVE, PLURAL, null, -1, actualIter.next()); assertFalse(actualIter.hasNext()); } protected void assertWordFormNoun(final String expectedForm, final GrammaticalCase expectedCase, final GrammaticalNumber expectedNumber, GrammaticalGender expectedGender, - final IWiktionaryWordForm actual) { + int expectedInflectionGroup, final IWiktionaryWordForm actual) { assertEquals(expectedForm, actual.getWordForm()); assertEquals(expectedCase, actual.getCase()); assertEquals(expectedNumber, actual.getNumber()); assertEquals(expectedGender, actual.getGender()); + assertEquals(expectedInflectionGroup, actual.getInflectionGroup()); } protected void assertWordFormVerb(final String expectedForm, final GrammaticalPerson expectedPerson, From 604f727811a545fb5c8d92aacc58ebb32640c677 Mon Sep 17 00:00:00 2001 From: --global Date: Sun, 12 Aug 2018 20:37:52 +0200 Subject: [PATCH 2/5] #66 Add inflection group to word form - Setting inflection group in gender handlers --- .../components/nountable/EinzahlHandler.java | 1 + .../components/nountable/MehrzahlHandler.java | 1 + .../components/nountable/PluralHandler.java | 1 + .../components/nountable/SingularHandler.java | 1 + .../parser/de/DEWordFormHandlerTest.java | 416 +++++++++--------- 5 files changed, 212 insertions(+), 208 deletions(-) diff --git a/src/main/java/de/tudarmstadt/ukp/jwktl/parser/de/components/nountable/EinzahlHandler.java b/src/main/java/de/tudarmstadt/ukp/jwktl/parser/de/components/nountable/EinzahlHandler.java index 73219c5..2c25075 100644 --- a/src/main/java/de/tudarmstadt/ukp/jwktl/parser/de/components/nountable/EinzahlHandler.java +++ b/src/main/java/de/tudarmstadt/ukp/jwktl/parser/de/components/nountable/EinzahlHandler.java @@ -41,6 +41,7 @@ public EinzahlHandler(DEWordFormNounTableHandler nounTableHandler) { public void handleIfFound(WiktionaryWordForm wordForm, String label, int index, String value, Matcher matcher, ParsingContext context) { wordForm.setNumber(GrammaticalNumber.SINGULAR); + wordForm.setInflectionGroup(index); final DEGenderText genderText = this.nounTableHandler.getGenusByIndex(index); if (genderText != null) { wordForm.setGender(genderText.asGrammaticalGender()); diff --git a/src/main/java/de/tudarmstadt/ukp/jwktl/parser/de/components/nountable/MehrzahlHandler.java b/src/main/java/de/tudarmstadt/ukp/jwktl/parser/de/components/nountable/MehrzahlHandler.java index d22b33d..30d2b47 100644 --- a/src/main/java/de/tudarmstadt/ukp/jwktl/parser/de/components/nountable/MehrzahlHandler.java +++ b/src/main/java/de/tudarmstadt/ukp/jwktl/parser/de/components/nountable/MehrzahlHandler.java @@ -40,5 +40,6 @@ public MehrzahlHandler(DEWordFormNounTableHandler nounTableHandler) { public void handleIfFound(WiktionaryWordForm wordForm, String label, int index, String value, Matcher matcher, ParsingContext context) { wordForm.setNumber(GrammaticalNumber.PLURAL); + wordForm.setInflectionGroup(index); } } diff --git a/src/main/java/de/tudarmstadt/ukp/jwktl/parser/de/components/nountable/PluralHandler.java b/src/main/java/de/tudarmstadt/ukp/jwktl/parser/de/components/nountable/PluralHandler.java index b867e47..2d9db7d 100644 --- a/src/main/java/de/tudarmstadt/ukp/jwktl/parser/de/components/nountable/PluralHandler.java +++ b/src/main/java/de/tudarmstadt/ukp/jwktl/parser/de/components/nountable/PluralHandler.java @@ -61,5 +61,6 @@ public PluralHandler(DEWordFormNounTableHandler nounTableHandler) { public void handleIfFound(WiktionaryWordForm wordForm, String label, int index, String value, Matcher matcher, ParsingContext context) { wordForm.setNumber(GrammaticalNumber.PLURAL); + wordForm.setInflectionGroup(index); } } diff --git a/src/main/java/de/tudarmstadt/ukp/jwktl/parser/de/components/nountable/SingularHandler.java b/src/main/java/de/tudarmstadt/ukp/jwktl/parser/de/components/nountable/SingularHandler.java index b4d0468..350549a 100644 --- a/src/main/java/de/tudarmstadt/ukp/jwktl/parser/de/components/nountable/SingularHandler.java +++ b/src/main/java/de/tudarmstadt/ukp/jwktl/parser/de/components/nountable/SingularHandler.java @@ -68,6 +68,7 @@ public SingularHandler(DEWordFormNounTableHandler nounTableHandler) { public void handleIfFound(WiktionaryWordForm wordForm, String label, int index, String value, Matcher matcher, ParsingContext context) { wordForm.setNumber(GrammaticalNumber.SINGULAR); + wordForm.setInflectionGroup(index); final DEGenderText genderText = this.nounTableHandler.getGenusByIndex(index); if (genderText != null) { wordForm.setGender(genderText.asGrammaticalGender()); diff --git a/src/test/java/de/tudarmstadt/ukp/jwktl/parser/de/DEWordFormHandlerTest.java b/src/test/java/de/tudarmstadt/ukp/jwktl/parser/de/DEWordFormHandlerTest.java index 94dcf39..6547ea0 100644 --- a/src/test/java/de/tudarmstadt/ukp/jwktl/parser/de/DEWordFormHandlerTest.java +++ b/src/test/java/de/tudarmstadt/ukp/jwktl/parser/de/DEWordFormHandlerTest.java @@ -55,8 +55,8 @@ public void testAberration() throws Exception { IWiktionaryPage page = parse("Aberration.txt"); IWiktionaryEntry entry = page.getEntry(0); Iterator actualIter = entry.getWordForms().iterator(); - assertWordFormNoun("Aberration", null, SINGULAR, null, -1, actualIter.next()); - assertWordFormNoun("Aberrationen", null, PLURAL, null, -1, actualIter.next()); + assertWordFormNoun("Aberration", null, SINGULAR, null, 1, actualIter.next()); + assertWordFormNoun("Aberrationen", null, PLURAL, null, 1, actualIter.next()); assertFalse(actualIter.hasNext()); } @@ -65,14 +65,14 @@ public void testHallo() throws Exception { IWiktionaryPage page = parse("Hallo.txt"); IWiktionaryEntry entry = page.getEntry(0); Iterator actualIter = entry.getWordForms().iterator(); - assertWordFormNoun("das Hallo", NOMINATIVE, SINGULAR, null, -1, actualIter.next()); - assertWordFormNoun("die Hallos", NOMINATIVE, PLURAL, null, -1, actualIter.next()); - assertWordFormNoun("des Hallos", GENITIVE, SINGULAR, null, -1, actualIter.next()); - assertWordFormNoun("der Hallos", GENITIVE, PLURAL, null, -1, actualIter.next()); - assertWordFormNoun("dem Hallo", DATIVE, SINGULAR, null, -1, actualIter.next()); - assertWordFormNoun("den Hallos", DATIVE, PLURAL, null, -1, actualIter.next()); - assertWordFormNoun("das Hallo", ACCUSATIVE, SINGULAR, null, -1, actualIter.next()); - assertWordFormNoun("die Hallos", ACCUSATIVE, PLURAL, null, -1, actualIter.next()); + assertWordFormNoun("das Hallo", NOMINATIVE, SINGULAR, null, 1, actualIter.next()); + assertWordFormNoun("die Hallos", NOMINATIVE, PLURAL, null, 1, actualIter.next()); + assertWordFormNoun("des Hallos", GENITIVE, SINGULAR, null, 1, actualIter.next()); + assertWordFormNoun("der Hallos", GENITIVE, PLURAL, null, 1, actualIter.next()); + assertWordFormNoun("dem Hallo", DATIVE, SINGULAR, null, 1, actualIter.next()); + assertWordFormNoun("den Hallos", DATIVE, PLURAL, null, 1, actualIter.next()); + assertWordFormNoun("das Hallo", ACCUSATIVE, SINGULAR, null, 1, actualIter.next()); + assertWordFormNoun("die Hallos", ACCUSATIVE, PLURAL, null, 1, actualIter.next()); assertFalse(actualIter.hasNext()); } @@ -81,19 +81,19 @@ public void testKiefer() throws Exception { IWiktionaryPage page = parse("Kiefer.txt"); IWiktionaryEntry entry = page.getEntry(0); Iterator actualIter = entry.getWordForms().iterator(); - assertWordFormNoun("die Kiefer", NOMINATIVE, SINGULAR, null, -1, actualIter.next()); - assertWordFormNoun("die Kiefern", NOMINATIVE, PLURAL, null, -1, actualIter.next()); - assertWordFormNoun("der Kiefer", GENITIVE, SINGULAR, null, -1, actualIter.next()); - assertWordFormNoun("der Kiefern", GENITIVE, PLURAL, null, -1, actualIter.next()); - assertWordFormNoun("der Kiefer", DATIVE, SINGULAR, null, -1, actualIter.next()); - assertWordFormNoun("den Kiefern", DATIVE, PLURAL, null, -1, actualIter.next()); - assertWordFormNoun("die Kiefer", ACCUSATIVE, SINGULAR, null, -1, actualIter.next()); - assertWordFormNoun("die Kiefern", ACCUSATIVE, PLURAL, null, -1, actualIter.next()); + assertWordFormNoun("die Kiefer", NOMINATIVE, SINGULAR, null, 1, actualIter.next()); + assertWordFormNoun("die Kiefern", NOMINATIVE, PLURAL, null, 1, actualIter.next()); + assertWordFormNoun("der Kiefer", GENITIVE, SINGULAR, null, 1, actualIter.next()); + assertWordFormNoun("der Kiefern", GENITIVE, PLURAL, null, 1, actualIter.next()); + assertWordFormNoun("der Kiefer", DATIVE, SINGULAR, null, 1, actualIter.next()); + assertWordFormNoun("den Kiefern", DATIVE, PLURAL, null, 1, actualIter.next()); + assertWordFormNoun("die Kiefer", ACCUSATIVE, SINGULAR, null, 1, actualIter.next()); + assertWordFormNoun("die Kiefern", ACCUSATIVE, PLURAL, null, 1, actualIter.next()); assertFalse(actualIter.hasNext()); entry = page.getEntry(1); actualIter = entry.getWordForms().iterator(); - assertWordFormNoun("Kiefer", null, SINGULAR, null, -1, actualIter.next()); - assertWordFormNoun("Kiefer", null, PLURAL, null, -1, actualIter.next()); + assertWordFormNoun("Kiefer", null, SINGULAR, null, 1, actualIter.next()); + assertWordFormNoun("Kiefer", null, PLURAL, null, 1, actualIter.next()); assertFalse(actualIter.hasNext()); } @@ -102,28 +102,28 @@ public void testStaat() throws Exception { IWiktionaryPage page = parse("Staat.txt"); IWiktionaryEntry entry = page.getEntry(0); Iterator actualIter = entry.getWordForms().iterator(); - assertWordFormNoun("der Staat", NOMINATIVE, SINGULAR, null, -1, actualIter.next()); - assertWordFormNoun("die Staaten", NOMINATIVE, PLURAL, null, -1, actualIter.next()); - assertWordFormNoun("die Stäte", NOMINATIVE, PLURAL, null, -1, actualIter.next()); - assertWordFormNoun("die Staat", NOMINATIVE, PLURAL, null, -1, actualIter.next()); - assertWordFormNoun("die Staate", NOMINATIVE, PLURAL, null, -1, actualIter.next()); - assertWordFormNoun("des Staates", GENITIVE, SINGULAR, null, -1, actualIter.next()); - assertWordFormNoun("des Staats", GENITIVE, SINGULAR, null, -1, actualIter.next()); - assertWordFormNoun("der Staaten", GENITIVE, PLURAL, null, -1, actualIter.next()); - assertWordFormNoun("der Stäte", GENITIVE, PLURAL, null, -1, actualIter.next()); - assertWordFormNoun("der Staat", GENITIVE, PLURAL, null, -1, actualIter.next()); - assertWordFormNoun("der Staate", GENITIVE, PLURAL, null, -1, actualIter.next()); - assertWordFormNoun("dem Staate", DATIVE, SINGULAR, null, -1, actualIter.next()); - assertWordFormNoun("dem Staat", DATIVE, SINGULAR, null, -1, actualIter.next()); - assertWordFormNoun("den Staaten", DATIVE, PLURAL, null, -1, actualIter.next()); - assertWordFormNoun("den Stäten", DATIVE, PLURAL, null, -1, actualIter.next()); - assertWordFormNoun("den Staaten", DATIVE, PLURAL, null, -1, actualIter.next()); - assertWordFormNoun("den Staaten", DATIVE, PLURAL, null, -1, actualIter.next()); - assertWordFormNoun("den Staat", ACCUSATIVE, SINGULAR, null, -1, actualIter.next()); - assertWordFormNoun("die Staaten", ACCUSATIVE, PLURAL, null, -1, actualIter.next()); - assertWordFormNoun("die Stäte", ACCUSATIVE, PLURAL, null, -1, actualIter.next()); - assertWordFormNoun("die Staat", ACCUSATIVE, PLURAL, null, -1, actualIter.next()); - assertWordFormNoun("die Staate", ACCUSATIVE, PLURAL, null, -1, actualIter.next()); + assertWordFormNoun("der Staat", NOMINATIVE, SINGULAR, null, 1, actualIter.next()); + assertWordFormNoun("die Staaten", NOMINATIVE, PLURAL, null, 1, actualIter.next()); + assertWordFormNoun("die Stäte", NOMINATIVE, PLURAL, null, 2, actualIter.next()); + assertWordFormNoun("die Staat", NOMINATIVE, PLURAL, null, 3, actualIter.next()); + assertWordFormNoun("die Staate", NOMINATIVE, PLURAL, null, 4, actualIter.next()); + assertWordFormNoun("des Staates", GENITIVE, SINGULAR, null, 1, actualIter.next()); + assertWordFormNoun("des Staats", GENITIVE, SINGULAR, null, 1, actualIter.next()); + assertWordFormNoun("der Staaten", GENITIVE, PLURAL, null, 1, actualIter.next()); + assertWordFormNoun("der Stäte", GENITIVE, PLURAL, null, 2, actualIter.next()); + assertWordFormNoun("der Staat", GENITIVE, PLURAL, null, 3, actualIter.next()); + assertWordFormNoun("der Staate", GENITIVE, PLURAL, null, 4, actualIter.next()); + assertWordFormNoun("dem Staate", DATIVE, SINGULAR, null, 1, actualIter.next()); + assertWordFormNoun("dem Staat", DATIVE, SINGULAR, null, 1, actualIter.next()); + assertWordFormNoun("den Staaten", DATIVE, PLURAL, null, 1, actualIter.next()); + assertWordFormNoun("den Stäten", DATIVE, PLURAL, null, 2, actualIter.next()); + assertWordFormNoun("den Staaten", DATIVE, PLURAL, null, 3, actualIter.next()); + assertWordFormNoun("den Staaten", DATIVE, PLURAL, null, 4, actualIter.next()); + assertWordFormNoun("den Staat", ACCUSATIVE, SINGULAR, null, 1, actualIter.next()); + assertWordFormNoun("die Staaten", ACCUSATIVE, PLURAL, null, 1, actualIter.next()); + assertWordFormNoun("die Stäte", ACCUSATIVE, PLURAL, null, 2, actualIter.next()); + assertWordFormNoun("die Staat", ACCUSATIVE, PLURAL, null, 3, actualIter.next()); + assertWordFormNoun("die Staate", ACCUSATIVE, PLURAL, null, 4, actualIter.next()); assertFalse(actualIter.hasNext()); } @@ -132,14 +132,14 @@ public void testThulium() throws Exception { IWiktionaryPage page = parse("Thulium.txt"); IWiktionaryEntry entry = page.getEntry(0); Iterator actualIter = entry.getWordForms().iterator(); - assertWordFormNoun("das Thulium", NOMINATIVE, SINGULAR, null, -1, actualIter.next()); - assertWordFormNoun(null, NOMINATIVE, PLURAL, null, -1, actualIter.next()); - assertWordFormNoun("des Thuliums", GENITIVE, SINGULAR, null, -1, actualIter.next()); - assertWordFormNoun(null, GENITIVE, PLURAL, null, -1, actualIter.next()); - assertWordFormNoun("dem Thulium", DATIVE, SINGULAR, null, -1, actualIter.next()); - assertWordFormNoun(null, DATIVE, PLURAL, null, -1, actualIter.next()); - assertWordFormNoun("das Thulium", ACCUSATIVE, SINGULAR, null, -1, actualIter.next()); - assertWordFormNoun(null, ACCUSATIVE, PLURAL, null, -1, actualIter.next()); + assertWordFormNoun("das Thulium", NOMINATIVE, SINGULAR, null, 1, actualIter.next()); + assertWordFormNoun(null, NOMINATIVE, PLURAL, null, 1, actualIter.next()); + assertWordFormNoun("des Thuliums", GENITIVE, SINGULAR, null, 1, actualIter.next()); + assertWordFormNoun(null, GENITIVE, PLURAL, null, 1, actualIter.next()); + assertWordFormNoun("dem Thulium", DATIVE, SINGULAR, null, 1, actualIter.next()); + assertWordFormNoun(null, DATIVE, PLURAL, null, 1, actualIter.next()); + assertWordFormNoun("das Thulium", ACCUSATIVE, SINGULAR, null, 1, actualIter.next()); + assertWordFormNoun(null, ACCUSATIVE, PLURAL, null, 1, actualIter.next()); assertFalse(actualIter.hasNext()); } @@ -148,14 +148,14 @@ public void testTier() throws Exception { IWiktionaryPage page = parse("Tier.txt"); IWiktionaryEntry entry = page.getEntry(0); Iterator actualIter = entry.getWordForms().iterator(); - assertWordFormNoun("das Tier", NOMINATIVE, SINGULAR, null, -1, actualIter.next()); - assertWordFormNoun("die Tiere", NOMINATIVE, PLURAL, null, -1, actualIter.next()); - assertWordFormNoun("des Tier(e)s", GENITIVE, SINGULAR, null, -1, actualIter.next()); - assertWordFormNoun("der Tiere", GENITIVE, PLURAL, null, -1, actualIter.next()); - assertWordFormNoun("dem Tier(e)", DATIVE, SINGULAR, null, -1, actualIter.next()); - assertWordFormNoun("den Tieren", DATIVE, PLURAL, null, -1, actualIter.next()); - assertWordFormNoun("das Tier", ACCUSATIVE, SINGULAR, null, -1, actualIter.next()); - assertWordFormNoun("die Tiere", ACCUSATIVE, PLURAL, null, -1, actualIter.next()); + assertWordFormNoun("das Tier", NOMINATIVE, SINGULAR, null, 1, actualIter.next()); + assertWordFormNoun("die Tiere", NOMINATIVE, PLURAL, null, 1, actualIter.next()); + assertWordFormNoun("des Tier(e)s", GENITIVE, SINGULAR, null, 1, actualIter.next()); + assertWordFormNoun("der Tiere", GENITIVE, PLURAL, null, 1, actualIter.next()); + assertWordFormNoun("dem Tier(e)", DATIVE, SINGULAR, null, 1, actualIter.next()); + assertWordFormNoun("den Tieren", DATIVE, PLURAL, null, 1, actualIter.next()); + assertWordFormNoun("das Tier", ACCUSATIVE, SINGULAR, null, 1, actualIter.next()); + assertWordFormNoun("die Tiere", ACCUSATIVE, PLURAL, null, 1, actualIter.next()); assertFalse(actualIter.hasNext()); } @@ -164,14 +164,14 @@ public void testTun() throws Exception { IWiktionaryPage page = parse("Tun.txt"); IWiktionaryEntry entry = page.getEntry(1); Iterator actualIter = entry.getWordForms().iterator(); - assertWordFormNoun("das Tun", NOMINATIVE, SINGULAR, null, -1, actualIter.next()); - assertWordFormNoun(null, NOMINATIVE, PLURAL, null, -1, actualIter.next()); - assertWordFormNoun("des Tuns", GENITIVE, SINGULAR, null, -1, actualIter.next()); - assertWordFormNoun(null, GENITIVE, PLURAL, null, -1, actualIter.next()); - assertWordFormNoun("dem Tun", DATIVE, SINGULAR, null, -1, actualIter.next()); - assertWordFormNoun(null, DATIVE, PLURAL, null, -1, actualIter.next()); - assertWordFormNoun("das Tun", ACCUSATIVE, SINGULAR, null, -1, actualIter.next()); - assertWordFormNoun(null, ACCUSATIVE, PLURAL, null, -1, actualIter.next()); + assertWordFormNoun("das Tun", NOMINATIVE, SINGULAR, null, 1, actualIter.next()); + assertWordFormNoun(null, NOMINATIVE, PLURAL, null, 1, actualIter.next()); + assertWordFormNoun("des Tuns", GENITIVE, SINGULAR, null, 1, actualIter.next()); + assertWordFormNoun(null, GENITIVE, PLURAL, null, 1, actualIter.next()); + assertWordFormNoun("dem Tun", DATIVE, SINGULAR, null, 1, actualIter.next()); + assertWordFormNoun(null, DATIVE, PLURAL, null, 1, actualIter.next()); + assertWordFormNoun("das Tun", ACCUSATIVE, SINGULAR, null, 1, actualIter.next()); + assertWordFormNoun(null, ACCUSATIVE, PLURAL, null, 1, actualIter.next()); assertFalse(actualIter.hasNext()); } @@ -291,18 +291,18 @@ public void testGelb() throws Exception { IWiktionaryPage page = parse("Gelb.txt"); IWiktionaryEntry entry = page.getEntry(0); Iterator actualIter = entry.getWordForms().iterator(); - assertWordFormNoun("Gelb", NOMINATIVE, SINGULAR, NEUTER, -1, actualIter.next()); - assertWordFormNoun("Gelbs", NOMINATIVE, PLURAL, null, -1, actualIter.next()); - assertWordFormNoun("Gelbtöne", NOMINATIVE, PLURAL, null, -1, actualIter.next()); - assertWordFormNoun("Gelbs", GENITIVE, SINGULAR, NEUTER, -1, actualIter.next()); - assertWordFormNoun("Gelbs", GENITIVE, PLURAL, null, -1, actualIter.next()); - assertWordFormNoun("Gelbtöne", GENITIVE, PLURAL, null, -1, actualIter.next()); - assertWordFormNoun("Gelb", DATIVE, SINGULAR, NEUTER, -1, actualIter.next()); - assertWordFormNoun("Gelbs", DATIVE, PLURAL, null, -1, actualIter.next()); - assertWordFormNoun("Gelbtönen", DATIVE, PLURAL, null, -1, actualIter.next()); - assertWordFormNoun("Gelb", ACCUSATIVE, SINGULAR, NEUTER, -1, actualIter.next()); - assertWordFormNoun("Gelbs", ACCUSATIVE, PLURAL, null, -1, actualIter.next()); - assertWordFormNoun("Gelbtöne", ACCUSATIVE, PLURAL, null, -1, actualIter.next()); + assertWordFormNoun("Gelb", NOMINATIVE, SINGULAR, NEUTER, 1, actualIter.next()); + assertWordFormNoun("Gelbs", NOMINATIVE, PLURAL, null, 1, actualIter.next()); + assertWordFormNoun("Gelbtöne", NOMINATIVE, PLURAL, null, 1, actualIter.next()); + assertWordFormNoun("Gelbs", GENITIVE, SINGULAR, NEUTER, 1, actualIter.next()); + assertWordFormNoun("Gelbs", GENITIVE, PLURAL, null, 1, actualIter.next()); + assertWordFormNoun("Gelbtöne", GENITIVE, PLURAL, null, 1, actualIter.next()); + assertWordFormNoun("Gelb", DATIVE, SINGULAR, NEUTER, 1, actualIter.next()); + assertWordFormNoun("Gelbs", DATIVE, PLURAL, null, 1, actualIter.next()); + assertWordFormNoun("Gelbtönen", DATIVE, PLURAL, null, 1, actualIter.next()); + assertWordFormNoun("Gelb", ACCUSATIVE, SINGULAR, NEUTER, 1, actualIter.next()); + assertWordFormNoun("Gelbs", ACCUSATIVE, PLURAL, null, 1, actualIter.next()); + assertWordFormNoun("Gelbtöne", ACCUSATIVE, PLURAL, null, 1, actualIter.next()); assertFalse(actualIter.hasNext()); } @@ -311,17 +311,17 @@ public void testMaerz() throws Exception { IWiktionaryPage page = parse("Maerz.txt"); IWiktionaryEntry entry = page.getEntry(0); Iterator actualIter = entry.getWordForms().iterator(); - assertWordFormNoun("März", NOMINATIVE, SINGULAR, MASCULINE, -1, actualIter.next()); - assertWordFormNoun("Märze", NOMINATIVE, PLURAL, null, -1, actualIter.next()); - assertWordFormNoun("März", GENITIVE, SINGULAR, MASCULINE, -1, actualIter.next()); - assertWordFormNoun("Märzes", GENITIVE, SINGULAR, MASCULINE, -1, actualIter.next()); - assertWordFormNoun("Märzen", GENITIVE, SINGULAR, MASCULINE, -1, actualIter.next()); - assertWordFormNoun("Märze", GENITIVE, PLURAL, null, -1, actualIter.next()); - assertWordFormNoun("März", DATIVE, SINGULAR, MASCULINE, -1, actualIter.next()); - assertWordFormNoun("Märzen", DATIVE, SINGULAR, MASCULINE, -1, actualIter.next()); - assertWordFormNoun("Märzen", DATIVE, PLURAL, null, -1, actualIter.next()); - assertWordFormNoun("März", ACCUSATIVE, SINGULAR, MASCULINE, -1, actualIter.next()); - assertWordFormNoun("Märze", ACCUSATIVE, PLURAL, null, -1, actualIter.next()); + assertWordFormNoun("März", NOMINATIVE, SINGULAR, MASCULINE, 1, actualIter.next()); + assertWordFormNoun("Märze", NOMINATIVE, PLURAL, null, 1, actualIter.next()); + assertWordFormNoun("März", GENITIVE, SINGULAR, MASCULINE, 1, actualIter.next()); + assertWordFormNoun("Märzes", GENITIVE, SINGULAR, MASCULINE, 1, actualIter.next()); + assertWordFormNoun("Märzen", GENITIVE, SINGULAR, MASCULINE, 1, actualIter.next()); + assertWordFormNoun("Märze", GENITIVE, PLURAL, null, 1, actualIter.next()); + assertWordFormNoun("März", DATIVE, SINGULAR, MASCULINE, 1, actualIter.next()); + assertWordFormNoun("Märzen", DATIVE, SINGULAR, MASCULINE, 1, actualIter.next()); + assertWordFormNoun("Märzen", DATIVE, PLURAL, null, 1, actualIter.next()); + assertWordFormNoun("März", ACCUSATIVE, SINGULAR, MASCULINE, 1, actualIter.next()); + assertWordFormNoun("Märze", ACCUSATIVE, PLURAL, null, 1, actualIter.next()); assertFalse(actualIter.hasNext()); } @@ -330,24 +330,24 @@ public void testMockumentary() throws Exception { IWiktionaryPage page = parse("Mockumentary.txt"); IWiktionaryEntry entry = page.getEntry(0); Iterator actualIter = entry.getWordForms().iterator(); - assertWordFormNoun("Mockumentary", NOMINATIVE, SINGULAR, MASCULINE, -1, actualIter.next()); - assertWordFormNoun("Mockumentary", NOMINATIVE, SINGULAR, FEMININE, -1, actualIter.next()); - assertWordFormNoun("Mockumentary", NOMINATIVE, SINGULAR, NEUTER, -1, actualIter.next()); - assertWordFormNoun("Mockumentarys", NOMINATIVE, PLURAL, null, -1, actualIter.next()); - assertWordFormNoun("Mockumentary", GENITIVE, SINGULAR, MASCULINE, -1, actualIter.next()); - assertWordFormNoun("Mockumentary", GENITIVE, SINGULAR, FEMININE, -1, actualIter.next()); - assertWordFormNoun("Mockumentarys", GENITIVE, SINGULAR, FEMININE, -1, actualIter.next()); - assertWordFormNoun("Mockumentary", GENITIVE, SINGULAR, NEUTER, -1, actualIter.next()); - assertWordFormNoun("Mockumentarys", GENITIVE, SINGULAR, NEUTER, -1, actualIter.next()); - assertWordFormNoun("Mockumentarys", GENITIVE, PLURAL, null, -1, actualIter.next()); - assertWordFormNoun("Mockumentary", DATIVE, SINGULAR, MASCULINE, -1, actualIter.next()); - assertWordFormNoun("Mockumentary", DATIVE, SINGULAR, FEMININE, -1, actualIter.next()); - assertWordFormNoun("Mockumentary", DATIVE, SINGULAR, NEUTER, -1, actualIter.next()); - assertWordFormNoun("Mockumentarys", DATIVE, PLURAL, null, -1, actualIter.next()); - assertWordFormNoun("Mockumentary", ACCUSATIVE, SINGULAR, MASCULINE, -1, actualIter.next()); - assertWordFormNoun("Mockumentary", ACCUSATIVE, SINGULAR, FEMININE, -1, actualIter.next()); - assertWordFormNoun("Mockumentary", ACCUSATIVE, SINGULAR, NEUTER, -1, actualIter.next()); - assertWordFormNoun("Mockumentarys", ACCUSATIVE, PLURAL, null, -1, actualIter.next()); + assertWordFormNoun("Mockumentary", NOMINATIVE, SINGULAR, MASCULINE, 1, actualIter.next()); + assertWordFormNoun("Mockumentary", NOMINATIVE, SINGULAR, FEMININE, 2, actualIter.next()); + assertWordFormNoun("Mockumentary", NOMINATIVE, SINGULAR, NEUTER, 3, actualIter.next()); + assertWordFormNoun("Mockumentarys", NOMINATIVE, PLURAL, null, 1, actualIter.next()); + assertWordFormNoun("Mockumentary", GENITIVE, SINGULAR, MASCULINE, 1, actualIter.next()); + assertWordFormNoun("Mockumentary", GENITIVE, SINGULAR, FEMININE, 2, actualIter.next()); + assertWordFormNoun("Mockumentarys", GENITIVE, SINGULAR, FEMININE, 2, actualIter.next()); + assertWordFormNoun("Mockumentary", GENITIVE, SINGULAR, NEUTER, 3, actualIter.next()); + assertWordFormNoun("Mockumentarys", GENITIVE, SINGULAR, NEUTER, 3, actualIter.next()); + assertWordFormNoun("Mockumentarys", GENITIVE, PLURAL, null, 1, actualIter.next()); + assertWordFormNoun("Mockumentary", DATIVE, SINGULAR, MASCULINE, 1, actualIter.next()); + assertWordFormNoun("Mockumentary", DATIVE, SINGULAR, FEMININE, 2, actualIter.next()); + assertWordFormNoun("Mockumentary", DATIVE, SINGULAR, NEUTER, 3, actualIter.next()); + assertWordFormNoun("Mockumentarys", DATIVE, PLURAL, null, 1, actualIter.next()); + assertWordFormNoun("Mockumentary", ACCUSATIVE, SINGULAR, MASCULINE, 1, actualIter.next()); + assertWordFormNoun("Mockumentary", ACCUSATIVE, SINGULAR, FEMININE, 2, actualIter.next()); + assertWordFormNoun("Mockumentary", ACCUSATIVE, SINGULAR, NEUTER, 3, actualIter.next()); + assertWordFormNoun("Mockumentarys", ACCUSATIVE, PLURAL, null, 1, actualIter.next()); assertFalse(actualIter.hasNext()); } @@ -357,23 +357,23 @@ public void testKeks() throws Exception { IWiktionaryPage page = parse("Keks.txt"); IWiktionaryEntry entry = page.getEntry(0); Iterator actualIter = entry.getWordForms().iterator(); - assertWordFormNoun("Keks", NOMINATIVE, SINGULAR, MASCULINE, -1, actualIter.next()); - assertWordFormNoun("Keks", NOMINATIVE, SINGULAR, NEUTER, -1, actualIter.next()); - assertWordFormNoun("Kekse", NOMINATIVE, PLURAL, null, -1, actualIter.next()); + assertWordFormNoun("Keks", NOMINATIVE, SINGULAR, MASCULINE, 1, actualIter.next()); + assertWordFormNoun("Keks", NOMINATIVE, SINGULAR, NEUTER, 2, actualIter.next()); + assertWordFormNoun("Kekse", NOMINATIVE, PLURAL, null, 1, actualIter.next()); - assertWordFormNoun("Kekses", GENITIVE, SINGULAR, MASCULINE, -1, actualIter.next()); - assertWordFormNoun("Kekses", GENITIVE, SINGULAR, NEUTER, -1, actualIter.next()); - assertWordFormNoun("Kekse", GENITIVE, PLURAL, null, -1, actualIter.next()); + assertWordFormNoun("Kekses", GENITIVE, SINGULAR, MASCULINE, 1, actualIter.next()); + assertWordFormNoun("Kekses", GENITIVE, SINGULAR, NEUTER, 2, actualIter.next()); + assertWordFormNoun("Kekse", GENITIVE, PLURAL, null, 1, actualIter.next()); - assertWordFormNoun("Keks", DATIVE, SINGULAR, MASCULINE, -1, actualIter.next()); - assertWordFormNoun("Kekse", DATIVE, SINGULAR, MASCULINE, -1, actualIter.next()); - assertWordFormNoun("Keks", DATIVE, SINGULAR, NEUTER, -1, actualIter.next()); - assertWordFormNoun("Kekse", DATIVE, SINGULAR, NEUTER, -1, actualIter.next()); - assertWordFormNoun("Keksen", DATIVE, PLURAL, null, -1, actualIter.next()); + assertWordFormNoun("Keks", DATIVE, SINGULAR, MASCULINE, 1, actualIter.next()); + assertWordFormNoun("Kekse", DATIVE, SINGULAR, MASCULINE, 1, actualIter.next()); + assertWordFormNoun("Keks", DATIVE, SINGULAR, NEUTER, 2, actualIter.next()); + assertWordFormNoun("Kekse", DATIVE, SINGULAR, NEUTER, 2, actualIter.next()); + assertWordFormNoun("Keksen", DATIVE, PLURAL, null, 1, actualIter.next()); - assertWordFormNoun("Keks", ACCUSATIVE, SINGULAR, MASCULINE, -1, actualIter.next()); - assertWordFormNoun("Keks", ACCUSATIVE, SINGULAR, NEUTER, -1, actualIter.next()); - assertWordFormNoun("Kekse", ACCUSATIVE, PLURAL, null, -1, actualIter.next()); + assertWordFormNoun("Keks", ACCUSATIVE, SINGULAR, MASCULINE, 1, actualIter.next()); + assertWordFormNoun("Keks", ACCUSATIVE, SINGULAR, NEUTER, 2, actualIter.next()); + assertWordFormNoun("Kekse", ACCUSATIVE, PLURAL, null, 1, actualIter.next()); assertFalse(actualIter.hasNext()); } @@ -383,18 +383,18 @@ public void testFreischurf() throws Exception { IWiktionaryPage page = parse("Freischurf.txt"); IWiktionaryEntry entry = page.getEntry(0); Iterator actualIter = entry.getWordForms().iterator(); - assertWordFormNoun("Freischurf", NOMINATIVE, SINGULAR, MASCULINE, -1, actualIter.next()); - assertWordFormNoun("Freischürfe", NOMINATIVE, PLURAL, null, -1, actualIter.next()); + assertWordFormNoun("Freischurf", NOMINATIVE, SINGULAR, MASCULINE, 1, actualIter.next()); + assertWordFormNoun("Freischürfe", NOMINATIVE, PLURAL, null, 1, actualIter.next()); - assertWordFormNoun("Freischurfes", GENITIVE, SINGULAR, MASCULINE, -1, actualIter.next()); - assertWordFormNoun("Freischurfs", GENITIVE, SINGULAR, MASCULINE, -1, actualIter.next()); - assertWordFormNoun("Freischürfe", GENITIVE, PLURAL, null, -1, actualIter.next()); + assertWordFormNoun("Freischurfes", GENITIVE, SINGULAR, MASCULINE, 1, actualIter.next()); + assertWordFormNoun("Freischurfs", GENITIVE, SINGULAR, MASCULINE, 1, actualIter.next()); + assertWordFormNoun("Freischürfe", GENITIVE, PLURAL, null, 1, actualIter.next()); - assertWordFormNoun("Freischurf", DATIVE, SINGULAR, MASCULINE, -1, actualIter.next()); - assertWordFormNoun("Freischürfen", DATIVE, PLURAL, null, -1, actualIter.next()); + assertWordFormNoun("Freischurf", DATIVE, SINGULAR, MASCULINE, 1, actualIter.next()); + assertWordFormNoun("Freischürfen", DATIVE, PLURAL, null, 1, actualIter.next()); - assertWordFormNoun("Freischurf", ACCUSATIVE, SINGULAR, MASCULINE, -1, actualIter.next()); - assertWordFormNoun("Freischürfe", ACCUSATIVE, PLURAL, null, -1, actualIter.next()); + assertWordFormNoun("Freischurf", ACCUSATIVE, SINGULAR, MASCULINE, 1, actualIter.next()); + assertWordFormNoun("Freischürfe", ACCUSATIVE, PLURAL, null, 1, actualIter.next()); assertFalse(actualIter.hasNext()); } @@ -404,23 +404,23 @@ public void testFels() throws Exception { IWiktionaryPage page = parse("Fels.txt"); IWiktionaryEntry entry = page.getEntry(0); Iterator actualIter = entry.getWordForms().iterator(); - assertWordFormNoun("Fels", NOMINATIVE, SINGULAR, MASCULINE, -1, actualIter.next()); - assertWordFormNoun("Fels", NOMINATIVE, SINGULAR, MASCULINE, -1, actualIter.next()); - assertWordFormNoun("Felsen", NOMINATIVE, PLURAL, null, -1, actualIter.next()); - - assertWordFormNoun("Fels", GENITIVE, SINGULAR, MASCULINE, -1, actualIter.next()); - assertWordFormNoun("Felses", GENITIVE, SINGULAR, MASCULINE, -1, actualIter.next()); - assertWordFormNoun("Felsens", GENITIVE, SINGULAR, MASCULINE, -1, actualIter.next()); - assertWordFormNoun("Felsen", GENITIVE, SINGULAR, MASCULINE, -1, actualIter.next()); - assertWordFormNoun("Felsen", GENITIVE, PLURAL, null, -1, actualIter.next()); - - assertWordFormNoun("Fels", DATIVE, SINGULAR, MASCULINE, -1, actualIter.next()); - assertWordFormNoun("Felsen", DATIVE, SINGULAR, MASCULINE, -1, actualIter.next()); - assertWordFormNoun("Felsen", DATIVE, PLURAL, null, -1, actualIter.next()); - - assertWordFormNoun("Fels", ACCUSATIVE, SINGULAR, MASCULINE, -1, actualIter.next()); - assertWordFormNoun("Felsen", ACCUSATIVE, SINGULAR, MASCULINE, -1, actualIter.next()); - assertWordFormNoun("Felsen", ACCUSATIVE, PLURAL, null, -1, actualIter.next()); + assertWordFormNoun("Fels", NOMINATIVE, SINGULAR, MASCULINE, 1, actualIter.next()); + assertWordFormNoun("Fels", NOMINATIVE, SINGULAR, MASCULINE, 2, actualIter.next()); + assertWordFormNoun("Felsen", NOMINATIVE, PLURAL, null, 1, actualIter.next()); + + assertWordFormNoun("Fels", GENITIVE, SINGULAR, MASCULINE, 1, actualIter.next()); + assertWordFormNoun("Felses", GENITIVE, SINGULAR, MASCULINE, 1, actualIter.next()); + assertWordFormNoun("Felsens", GENITIVE, SINGULAR, MASCULINE, 1, actualIter.next()); + assertWordFormNoun("Felsen", GENITIVE, SINGULAR, MASCULINE, 2, actualIter.next()); + assertWordFormNoun("Felsen", GENITIVE, PLURAL, null, 1, actualIter.next()); + + assertWordFormNoun("Fels", DATIVE, SINGULAR, MASCULINE, 1, actualIter.next()); + assertWordFormNoun("Felsen", DATIVE, SINGULAR, MASCULINE, 2, actualIter.next()); + assertWordFormNoun("Felsen", DATIVE, PLURAL, null, 1, actualIter.next()); + + assertWordFormNoun("Fels", ACCUSATIVE, SINGULAR, MASCULINE, 1, actualIter.next()); + assertWordFormNoun("Felsen", ACCUSATIVE, SINGULAR, MASCULINE, 2, actualIter.next()); + assertWordFormNoun("Felsen", ACCUSATIVE, PLURAL, null, 1, actualIter.next()); assertFalse(actualIter.hasNext()); } @@ -429,23 +429,23 @@ public void testUnschlitt() throws Exception { IWiktionaryPage page = parse("Unschlitt.txt"); IWiktionaryEntry entry = page.getEntry(0); Iterator actualIter = entry.getWordForms().iterator(); - assertWordFormNoun("Unschlitt", NOMINATIVE, SINGULAR, NEUTER, -1, actualIter.next()); - assertWordFormNoun("Unschlitt", NOMINATIVE, SINGULAR, MASCULINE, -1, actualIter.next()); - assertWordFormNoun("Unschlitte", NOMINATIVE, PLURAL, null, -1, actualIter.next()); - - assertWordFormNoun("Unschlitts", GENITIVE, SINGULAR, NEUTER, -1, actualIter.next()); - assertWordFormNoun("Unschlittes", GENITIVE, SINGULAR, NEUTER, -1, actualIter.next()); - assertWordFormNoun("Unschlitts", GENITIVE, SINGULAR, MASCULINE, -1, actualIter.next()); - assertWordFormNoun("Unschlittes", GENITIVE, SINGULAR, MASCULINE, -1, actualIter.next()); - assertWordFormNoun("Unschlitte", GENITIVE, PLURAL, null, -1, actualIter.next()); - - assertWordFormNoun("Unschlitt", DATIVE, SINGULAR, NEUTER, -1, actualIter.next()); - assertWordFormNoun("Unschlitt", DATIVE, SINGULAR, MASCULINE, -1, actualIter.next()); - assertWordFormNoun("Unschlitten", DATIVE, PLURAL, null, -1, actualIter.next()); - - assertWordFormNoun("Unschlitt", ACCUSATIVE, SINGULAR, NEUTER, -1, actualIter.next()); - assertWordFormNoun("Unschlitt", ACCUSATIVE, SINGULAR, MASCULINE, -1, actualIter.next()); - assertWordFormNoun("Unschlitte", ACCUSATIVE, PLURAL, null, -1, actualIter.next()); + assertWordFormNoun("Unschlitt", NOMINATIVE, SINGULAR, NEUTER, 1, actualIter.next()); + assertWordFormNoun("Unschlitt", NOMINATIVE, SINGULAR, MASCULINE, 2, actualIter.next()); + assertWordFormNoun("Unschlitte", NOMINATIVE, PLURAL, null, 1, actualIter.next()); + + assertWordFormNoun("Unschlitts", GENITIVE, SINGULAR, NEUTER, 1, actualIter.next()); + assertWordFormNoun("Unschlittes", GENITIVE, SINGULAR, NEUTER, 1, actualIter.next()); + assertWordFormNoun("Unschlitts", GENITIVE, SINGULAR, MASCULINE, 2, actualIter.next()); + assertWordFormNoun("Unschlittes", GENITIVE, SINGULAR, MASCULINE, 2, actualIter.next()); + assertWordFormNoun("Unschlitte", GENITIVE, PLURAL, null, 1, actualIter.next()); + + assertWordFormNoun("Unschlitt", DATIVE, SINGULAR, NEUTER, 1, actualIter.next()); + assertWordFormNoun("Unschlitt", DATIVE, SINGULAR, MASCULINE, 2, actualIter.next()); + assertWordFormNoun("Unschlitten", DATIVE, PLURAL, null, 1, actualIter.next()); + + assertWordFormNoun("Unschlitt", ACCUSATIVE, SINGULAR, NEUTER, 1, actualIter.next()); + assertWordFormNoun("Unschlitt", ACCUSATIVE, SINGULAR, MASCULINE, 2, actualIter.next()); + assertWordFormNoun("Unschlitte", ACCUSATIVE, PLURAL, null, 1, actualIter.next()); assertFalse(actualIter.hasNext()); } @@ -454,8 +454,8 @@ public void testFote() throws Exception { IWiktionaryPage page = parse("Fote.txt"); IWiktionaryEntry entry = page.getEntry(0); Iterator actualIter = entry.getWordForms().iterator(); - assertWordFormNoun("de Fote", null, SINGULAR, null, -1, actualIter.next()); - assertWordFormNoun("de Foten", null, PLURAL, null, -1, actualIter.next()); + assertWordFormNoun("de Fote", null, SINGULAR, null, 1, actualIter.next()); + assertWordFormNoun("de Foten", null, PLURAL, null, 1, actualIter.next()); assertFalse(actualIter.hasNext()); } @@ -464,22 +464,22 @@ public void testGeneraladmiral() throws Exception { IWiktionaryPage page = parse("Generaladmiral.txt"); IWiktionaryEntry entry = page.getEntry(0); Iterator actualIter = entry.getWordForms().iterator(); - assertWordFormNoun("Generaladmiral", NOMINATIVE, SINGULAR, MASCULINE, -1, actualIter.next()); - assertWordFormNoun("Generaladmirale", NOMINATIVE, PLURAL, null, -1, actualIter.next()); - assertWordFormNoun("Generaladmiräle", NOMINATIVE, PLURAL, null, -1, actualIter.next()); - - assertWordFormNoun("Generaladmirals", GENITIVE, SINGULAR, MASCULINE, -1, actualIter.next()); - assertWordFormNoun("Generaladmirale", GENITIVE, PLURAL, null, -1, actualIter.next()); - assertWordFormNoun("Generaladmiräle", GENITIVE, PLURAL, null, -1, actualIter.next()); - - assertWordFormNoun("Generaladmiral", DATIVE, SINGULAR, MASCULINE, -1, actualIter.next()); - assertWordFormNoun("Generaladmirale", DATIVE, SINGULAR, MASCULINE, -1, actualIter.next()); - assertWordFormNoun("Generaladmiralen", DATIVE, PLURAL, null, -1, actualIter.next()); - assertWordFormNoun("Generaladmirälen", DATIVE, PLURAL, null, -1, actualIter.next()); - - assertWordFormNoun("Generaladmiral", ACCUSATIVE, SINGULAR, MASCULINE, -1, actualIter.next()); - assertWordFormNoun("Generaladmirale", ACCUSATIVE, PLURAL, null, -1, actualIter.next()); - assertWordFormNoun("Generaladmiräle", ACCUSATIVE, PLURAL, null, -1, actualIter.next()); + assertWordFormNoun("Generaladmiral", NOMINATIVE, SINGULAR, MASCULINE, 1, actualIter.next()); + assertWordFormNoun("Generaladmirale", NOMINATIVE, PLURAL, null, 1, actualIter.next()); + assertWordFormNoun("Generaladmiräle", NOMINATIVE, PLURAL, null, 2, actualIter.next()); + + assertWordFormNoun("Generaladmirals", GENITIVE, SINGULAR, MASCULINE, 1, actualIter.next()); + assertWordFormNoun("Generaladmirale", GENITIVE, PLURAL, null, 1, actualIter.next()); + assertWordFormNoun("Generaladmiräle", GENITIVE, PLURAL, null, 2, actualIter.next()); + + assertWordFormNoun("Generaladmiral", DATIVE, SINGULAR, MASCULINE, 1, actualIter.next()); + assertWordFormNoun("Generaladmirale", DATIVE, SINGULAR, MASCULINE, 1, actualIter.next()); + assertWordFormNoun("Generaladmiralen", DATIVE, PLURAL, null, 1, actualIter.next()); + assertWordFormNoun("Generaladmirälen", DATIVE, PLURAL, null, 2, actualIter.next()); + + assertWordFormNoun("Generaladmiral", ACCUSATIVE, SINGULAR, MASCULINE, 1, actualIter.next()); + assertWordFormNoun("Generaladmirale", ACCUSATIVE, PLURAL, null, 1, actualIter.next()); + assertWordFormNoun("Generaladmiräle", ACCUSATIVE, PLURAL, null, 2, actualIter.next()); assertFalse(actualIter.hasNext()); } @@ -488,32 +488,32 @@ public void testGams() throws Exception { IWiktionaryPage page = parse("Gams.txt"); IWiktionaryEntry entry = page.getEntry(0); Iterator actualIter = entry.getWordForms().iterator(); - assertWordFormNoun("Gams", NOMINATIVE, SINGULAR, FEMININE, -1, actualIter.next()); - assertWordFormNoun("Gams", NOMINATIVE, SINGULAR, MASCULINE, -1, actualIter.next()); - assertWordFormNoun("Gams", NOMINATIVE, SINGULAR, NEUTER, -1, actualIter.next()); - assertWordFormNoun("Gams", GENITIVE, SINGULAR, NEUTER, -1, actualIter.next()); - assertWordFormNoun("Gams", GENITIVE, SINGULAR, MASCULINE, -1, actualIter.next()); - assertWordFormNoun("Gamsen", GENITIVE, SINGULAR, MASCULINE, -1, actualIter.next()); - assertWordFormNoun("Gamsen", DATIVE, SINGULAR, MASCULINE, -1, actualIter.next()); - assertWordFormNoun("Gamsen", ACCUSATIVE, SINGULAR, MASCULINE, -1, actualIter.next()); - assertWordFormNoun("Gamsen", GENITIVE, SINGULAR, NEUTER, -1, actualIter.next()); - assertWordFormNoun("Gamsen", DATIVE, SINGULAR, NEUTER, -1, actualIter.next()); - assertWordFormNoun("Gamsen", ACCUSATIVE, SINGULAR, NEUTER, -1, actualIter.next()); - assertWordFormNoun("Gams", DATIVE, SINGULAR, NEUTER, -1, actualIter.next()); - assertWordFormNoun("Gams", DATIVE, SINGULAR, MASCULINE, -1, actualIter.next()); - assertWordFormNoun("Gams", ACCUSATIVE, SINGULAR, NEUTER, -1, actualIter.next()); - assertWordFormNoun("Gams", ACCUSATIVE, SINGULAR, MASCULINE, -1, actualIter.next()); - assertWordFormNoun("Gams", NOMINATIVE, PLURAL, null, -1, actualIter.next()); - assertWordFormNoun("Gamsen", NOMINATIVE, PLURAL, null, -1, actualIter.next()); - assertWordFormNoun("Gams", GENITIVE, SINGULAR, FEMININE, -1, actualIter.next()); - assertWordFormNoun("Gams", GENITIVE, PLURAL, null, -1, actualIter.next()); - assertWordFormNoun("Gamsen", GENITIVE, PLURAL, null, -1, actualIter.next()); - assertWordFormNoun("Gams", DATIVE, SINGULAR, FEMININE, -1, actualIter.next()); - assertWordFormNoun("Gams", DATIVE, PLURAL, null, -1, actualIter.next()); - assertWordFormNoun("Gamsen", DATIVE, PLURAL, null, -1, actualIter.next()); - assertWordFormNoun("Gams", ACCUSATIVE, SINGULAR, FEMININE, -1, actualIter.next()); - assertWordFormNoun("Gams", ACCUSATIVE, PLURAL, null, -1, actualIter.next()); - assertWordFormNoun("Gamsen", ACCUSATIVE, PLURAL, null, -1, actualIter.next()); + assertWordFormNoun("Gams", NOMINATIVE, SINGULAR, FEMININE, 1, actualIter.next()); + assertWordFormNoun("Gams", NOMINATIVE, SINGULAR, MASCULINE, 2, actualIter.next()); + assertWordFormNoun("Gams", NOMINATIVE, SINGULAR, NEUTER, 3, actualIter.next()); + assertWordFormNoun("Gams", GENITIVE, SINGULAR, NEUTER, 3, actualIter.next()); + assertWordFormNoun("Gams", GENITIVE, SINGULAR, MASCULINE, 2, actualIter.next()); + assertWordFormNoun("Gamsen", GENITIVE, SINGULAR, MASCULINE, 2, actualIter.next()); + assertWordFormNoun("Gamsen", DATIVE, SINGULAR, MASCULINE, 2, actualIter.next()); + assertWordFormNoun("Gamsen", ACCUSATIVE, SINGULAR, MASCULINE, 2, actualIter.next()); + assertWordFormNoun("Gamsen", GENITIVE, SINGULAR, NEUTER, 3, actualIter.next()); + assertWordFormNoun("Gamsen", DATIVE, SINGULAR, NEUTER, 3, actualIter.next()); + assertWordFormNoun("Gamsen", ACCUSATIVE, SINGULAR, NEUTER, 3, actualIter.next()); + assertWordFormNoun("Gams", DATIVE, SINGULAR, NEUTER, 3, actualIter.next()); + assertWordFormNoun("Gams", DATIVE, SINGULAR, MASCULINE, 2, actualIter.next()); + assertWordFormNoun("Gams", ACCUSATIVE, SINGULAR, NEUTER, 3, actualIter.next()); + assertWordFormNoun("Gams", ACCUSATIVE, SINGULAR, MASCULINE, 2, actualIter.next()); + assertWordFormNoun("Gams", NOMINATIVE, PLURAL, null, 1, actualIter.next()); + assertWordFormNoun("Gamsen", NOMINATIVE, PLURAL, null, 1, actualIter.next()); + assertWordFormNoun("Gams", GENITIVE, SINGULAR, FEMININE, 1, actualIter.next()); + assertWordFormNoun("Gams", GENITIVE, PLURAL, null, 1, actualIter.next()); + assertWordFormNoun("Gamsen", GENITIVE, PLURAL, null, 1, actualIter.next()); + assertWordFormNoun("Gams", DATIVE, SINGULAR, FEMININE, 1, actualIter.next()); + assertWordFormNoun("Gams", DATIVE, PLURAL, null, 1, actualIter.next()); + assertWordFormNoun("Gamsen", DATIVE, PLURAL, null, 1, actualIter.next()); + assertWordFormNoun("Gams", ACCUSATIVE, SINGULAR, FEMININE, 1, actualIter.next()); + assertWordFormNoun("Gams", ACCUSATIVE, PLURAL, null, 1, actualIter.next()); + assertWordFormNoun("Gamsen", ACCUSATIVE, PLURAL, null, 1, actualIter.next()); assertFalse(actualIter.hasNext()); } From 41651361b5afbe9a00562c706c000e78d3baa076 Mon Sep 17 00:00:00 2001 From: Alexey Valikov Date: Sun, 12 Aug 2018 21:59:01 +0200 Subject: [PATCH 3/5] #66 Add inflection group to word form - Added a test to check the default value of inflection group --- .../api/entry/WiktionaryWordFormTest.java | 29 +++++++++++++++++++ 1 file changed, 29 insertions(+) create mode 100644 src/test/java/de/tudarmstadt/ukp/jwktl/api/entry/WiktionaryWordFormTest.java diff --git a/src/test/java/de/tudarmstadt/ukp/jwktl/api/entry/WiktionaryWordFormTest.java b/src/test/java/de/tudarmstadt/ukp/jwktl/api/entry/WiktionaryWordFormTest.java new file mode 100644 index 0000000..83808d6 --- /dev/null +++ b/src/test/java/de/tudarmstadt/ukp/jwktl/api/entry/WiktionaryWordFormTest.java @@ -0,0 +1,29 @@ +/******************************************************************************* + * Copyright 2013 + * Ubiquitous Knowledge Processing (UKP) Lab + * Technische Universität Darmstadt + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + ******************************************************************************/ +package de.tudarmstadt.ukp.jwktl.api.entry; + +import de.tudarmstadt.ukp.jwktl.api.IWiktionaryWordForm; +import junit.framework.TestCase; + +public class WiktionaryWordFormTest extends TestCase { + + public void testDefaultInflectionGroupValue() { + IWiktionaryWordForm wordForm = new WiktionaryWordForm("test"); + assertEquals(-1, wordForm.getInflectionGroup()); + } +} From 744c7f776f4fd805dede424828f25078d88046e0 Mon Sep 17 00:00:00 2001 From: Alexey Valikov Date: Sun, 26 Aug 2018 20:50:29 +0200 Subject: [PATCH 4/5] #66 Add inflection group to word form - Added a test case for multiple declension tables - Corrected index generation for the mutliple declention tables case --- .../nountable/DEWordFormNounTableHandler.java | 26 +++--- .../PatternBasedIndexedParameterHandler.java | 25 ++++- .../parser/de/DEWordFormHandlerTest.java | 25 +++++ .../DEWordFormNounTableHandlerTest.java | 33 +------ .../nountable/EinzahlHandlerTest.java | 49 +++++----- .../nountable/GenusHandlerTest.java | 37 ++++---- .../nountable/MehrzahlHandlerTest.java | 49 +++++----- .../nountable/PluralHandlerTest.java | 93 ++++++++++--------- .../nountable/SingularHandlerTest.java | 93 ++++++++++--------- .../resources/articles-de/Apfelschorle.txt | 71 ++++++++++++++ 10 files changed, 302 insertions(+), 199 deletions(-) create mode 100644 src/test/resources/articles-de/Apfelschorle.txt diff --git a/src/main/java/de/tudarmstadt/ukp/jwktl/parser/de/components/nountable/DEWordFormNounTableHandler.java b/src/main/java/de/tudarmstadt/ukp/jwktl/parser/de/components/nountable/DEWordFormNounTableHandler.java index 71d9c8b..f3cd189 100644 --- a/src/main/java/de/tudarmstadt/ukp/jwktl/parser/de/components/nountable/DEWordFormNounTableHandler.java +++ b/src/main/java/de/tudarmstadt/ukp/jwktl/parser/de/components/nountable/DEWordFormNounTableHandler.java @@ -18,7 +18,9 @@ package de.tudarmstadt.ukp.jwktl.parser.de.components.nountable; import java.util.Arrays; +import java.util.HashMap; import java.util.List; +import java.util.Map; import de.tudarmstadt.ukp.jwktl.api.entry.WiktionaryWordForm; import de.tudarmstadt.ukp.jwktl.parser.de.components.DEGenderText; @@ -26,9 +28,11 @@ import de.tudarmstadt.ukp.jwktl.parser.util.ParsingContext; public class DEWordFormNounTableHandler implements IWiktionaryWordFormTemplateParameterHandler { + + public static final int MAX_INFLECTION_GROUP_COUNT = 4; public void reset() { - this.genera = new DEGenderText[4]; + this.genera = new HashMap<>(DEWordFormNounTableHandler.MAX_INFLECTION_GROUP_COUNT); } private List handlers = Arrays.asList( @@ -51,32 +55,24 @@ public void reset() { // Accusative new AccusativeHandler()); - protected DEGenderText[] genera = new DEGenderText[4]; + protected Map genera = new HashMap<>(DEWordFormNounTableHandler.MAX_INFLECTION_GROUP_COUNT); /** * Returns genus by index. - * @param index index of the genus, must be between 1 and 4. + * @param index index of the genus. * @return Genus by index or null if genus by this index was not set yet. - * @throws IllegalArgumentException If index is not between 1 and 4. */ DEGenderText getGenusByIndex(int index) { - if (index < 1 || index > 4) { - throw new IllegalArgumentException("Genus index must be 1, 2, 3 or 4."); - } - return genera[index - 1]; + return genera.get(index - 1); } /** * Sets genus by index * @param genderText genus. - * @param index index of the genus, must be between 1 and 4. - * @throws IllegalArgumentException If index is not between 1 and 4. + * @param index index of the genus. */ - void setGenusByIndex(DEGenderText genderText, Integer index) { - if (index < 1 || index > 4) { - throw new IllegalArgumentException("Genus index must be 1, 2, 3 or 4."); - } - this.genera[index - 1] = genderText; + void setGenusByIndex(DEGenderText genderText, int index) { + this.genera.put(index - 1, genderText); } @Override diff --git a/src/main/java/de/tudarmstadt/ukp/jwktl/parser/de/components/nountable/PatternBasedIndexedParameterHandler.java b/src/main/java/de/tudarmstadt/ukp/jwktl/parser/de/components/nountable/PatternBasedIndexedParameterHandler.java index 5ed787b..159ff8c 100644 --- a/src/main/java/de/tudarmstadt/ukp/jwktl/parser/de/components/nountable/PatternBasedIndexedParameterHandler.java +++ b/src/main/java/de/tudarmstadt/ukp/jwktl/parser/de/components/nountable/PatternBasedIndexedParameterHandler.java @@ -17,9 +17,12 @@ ******************************************************************************/ package de.tudarmstadt.ukp.jwktl.parser.de.components.nountable; +import java.util.List; import java.util.Objects; import java.util.regex.Matcher; +import de.tudarmstadt.ukp.jwktl.api.IWiktionaryWordForm; +import de.tudarmstadt.ukp.jwktl.api.entry.WiktionaryEntry; import de.tudarmstadt.ukp.jwktl.api.entry.WiktionaryWordForm; import de.tudarmstadt.ukp.jwktl.parser.util.ParsingContext; import de.tudarmstadt.ukp.jwktl.parser.util.PatternUtils; @@ -36,14 +39,28 @@ public PatternBasedIndexedParameterHandler(DEWordFormNounTableHandler nounTableH public void handle(String label, String value, WiktionaryWordForm wordForm, ParsingContext context) { final Matcher matcher = pattern.matcher(label); + + WiktionaryEntry wiktionaryEntry = context.findEntry(); + + List wordForms = wiktionaryEntry.getWordForms(); + final int indexOffset; + if (wordForms == null) { + indexOffset = 0; + } else { + final int maxInflectionGroup = wordForms.stream().mapToInt(IWiktionaryWordForm::getInflectionGroup).max() + .orElse(0); + indexOffset = (((maxInflectionGroup - 1) / DEWordFormNounTableHandler.MAX_INFLECTION_GROUP_COUNT) + 1) + * DEWordFormNounTableHandler.MAX_INFLECTION_GROUP_COUNT; + } + if (matcher.find()) { final Integer index = PatternUtils.extractIndex(matcher); - final int i = index == null ? 1 : index.intValue(); - handleIfFound(wordForm, label, i, value, matcher, context); + final int i = index == null ? 1 : index.intValue(); + handleIfFound(wordForm, label, i + indexOffset, value, matcher, context); } } - public abstract void handleIfFound(WiktionaryWordForm wordForm, String label, int index, String value, Matcher matcher, - ParsingContext context); + public abstract void handleIfFound(WiktionaryWordForm wordForm, String label, int index, String value, + Matcher matcher, ParsingContext context); } diff --git a/src/test/java/de/tudarmstadt/ukp/jwktl/parser/de/DEWordFormHandlerTest.java b/src/test/java/de/tudarmstadt/ukp/jwktl/parser/de/DEWordFormHandlerTest.java index 6547ea0..5ce8171 100644 --- a/src/test/java/de/tudarmstadt/ukp/jwktl/parser/de/DEWordFormHandlerTest.java +++ b/src/test/java/de/tudarmstadt/ukp/jwktl/parser/de/DEWordFormHandlerTest.java @@ -516,6 +516,31 @@ public void testGams() throws Exception { assertWordFormNoun("Gamsen", ACCUSATIVE, PLURAL, null, 1, actualIter.next()); assertFalse(actualIter.hasNext()); } + + /***/ + public void testApfelschorle() throws Exception { + IWiktionaryPage page = parse("Apfelschorle.txt"); + IWiktionaryEntry entry = page.getEntry(0); + Iterator actualIter = entry.getWordForms().iterator(); + assertWordFormNoun("Apfelschorle", NOMINATIVE, SINGULAR, NEUTER, 1, actualIter.next()); + assertWordFormNoun("Apfelschorles", NOMINATIVE, PLURAL, null, 1, actualIter.next()); + assertWordFormNoun("Apfelschorles", GENITIVE, SINGULAR, NEUTER, 1, actualIter.next()); + assertWordFormNoun("Apfelschorles", GENITIVE, PLURAL, null, 1, actualIter.next()); + assertWordFormNoun("Apfelschorle", DATIVE, SINGULAR, NEUTER, 1, actualIter.next()); + assertWordFormNoun("Apfelschorles", DATIVE, PLURAL, null, 1, actualIter.next()); + assertWordFormNoun("Apfelschorle", ACCUSATIVE, SINGULAR, NEUTER, 1, actualIter.next()); + assertWordFormNoun("Apfelschorles", ACCUSATIVE, PLURAL, null, 1, actualIter.next()); + + assertWordFormNoun("Apfelschorle", NOMINATIVE, SINGULAR, FEMININE, 5, actualIter.next()); + assertWordFormNoun("Apfelschorlen", NOMINATIVE, PLURAL, null, 5, actualIter.next()); + assertWordFormNoun("Apfelschorle", GENITIVE, SINGULAR, FEMININE, 5, actualIter.next()); + assertWordFormNoun("Apfelschorlen", GENITIVE, PLURAL, null, 5, actualIter.next()); + assertWordFormNoun("Apfelschorle", DATIVE, SINGULAR, FEMININE, 5, actualIter.next()); + assertWordFormNoun("Apfelschorlen", DATIVE, PLURAL, null, 5, actualIter.next()); + assertWordFormNoun("Apfelschorle", ACCUSATIVE, SINGULAR, FEMININE, 5, actualIter.next()); + assertWordFormNoun("Apfelschorlen", ACCUSATIVE, PLURAL, null, 5, actualIter.next()); + assertFalse(actualIter.hasNext()); + } protected void assertWordFormNoun(final String expectedForm, final GrammaticalCase expectedCase, final GrammaticalNumber expectedNumber, GrammaticalGender expectedGender, diff --git a/src/test/java/de/tudarmstadt/ukp/jwktl/parser/de/components/nountable/DEWordFormNounTableHandlerTest.java b/src/test/java/de/tudarmstadt/ukp/jwktl/parser/de/components/nountable/DEWordFormNounTableHandlerTest.java index dd541dd..19ed829 100644 --- a/src/test/java/de/tudarmstadt/ukp/jwktl/parser/de/components/nountable/DEWordFormNounTableHandlerTest.java +++ b/src/test/java/de/tudarmstadt/ukp/jwktl/parser/de/components/nountable/DEWordFormNounTableHandlerTest.java @@ -37,35 +37,4 @@ public void testGetsSetGenus() { public void testGetsNotSetGenus() { assertNull(nounTableHandler.getGenusByIndex(3)); } - - public void testThrowsExceptionSettingGenusWithInvalidIndex() { - try { - nounTableHandler.setGenusByIndex(DEGenderText.F, 0); - fail(); - } catch (IllegalArgumentException expected) { - assertTrue(true); - } - try { - nounTableHandler.setGenusByIndex(DEGenderText.F, 5); - fail(); - } catch (IllegalArgumentException expected) { - assertTrue(true); - } - } - - public void testThrowsExceptionGettingGenusWithInvalidIndex() { - try { - nounTableHandler.getGenusByIndex(0); - fail(); - } catch (IllegalArgumentException expected) { - assertTrue(true); - } - try { - nounTableHandler.getGenusByIndex(5); - fail(); - } catch (IllegalArgumentException expected) { - assertTrue(true); - } - } - -} +} \ No newline at end of file diff --git a/src/test/java/de/tudarmstadt/ukp/jwktl/parser/de/components/nountable/EinzahlHandlerTest.java b/src/test/java/de/tudarmstadt/ukp/jwktl/parser/de/components/nountable/EinzahlHandlerTest.java index 9fe120b..c53e1b0 100644 --- a/src/test/java/de/tudarmstadt/ukp/jwktl/parser/de/components/nountable/EinzahlHandlerTest.java +++ b/src/test/java/de/tudarmstadt/ukp/jwktl/parser/de/components/nountable/EinzahlHandlerTest.java @@ -17,9 +17,12 @@ ******************************************************************************/ package de.tudarmstadt.ukp.jwktl.parser.de.components.nountable; +import de.tudarmstadt.ukp.jwktl.api.entry.WiktionaryPage; import de.tudarmstadt.ukp.jwktl.api.entry.WiktionaryWordForm; import de.tudarmstadt.ukp.jwktl.api.util.GrammaticalGender; import de.tudarmstadt.ukp.jwktl.api.util.GrammaticalNumber; +import de.tudarmstadt.ukp.jwktl.parser.de.components.DEEntryFactory; +import de.tudarmstadt.ukp.jwktl.parser.util.ParsingContext; import junit.framework.TestCase; public class EinzahlHandlerTest extends TestCase { @@ -27,69 +30,71 @@ public class EinzahlHandlerTest extends TestCase { private DEWordFormNounTableHandler nounTableHandler; private GenusHandler genusHandler; private EinzahlHandler einzahlHandler; + private ParsingContext parsingContext; @Override protected void setUp() throws Exception { nounTableHandler = new DEWordFormNounTableHandler(); genusHandler = new GenusHandler(nounTableHandler); einzahlHandler = new EinzahlHandler(nounTableHandler); + parsingContext = new ParsingContext(new WiktionaryPage(), new DEEntryFactory()); } public void testCanHandle() { - assertFalse(einzahlHandler.canHandle(null, null, null, null)); - assertFalse(einzahlHandler.canHandle("Wer oder was?", null, null, null)); - assertTrue(einzahlHandler.canHandle("Wer oder was? (Einzahl)", null, null, null)); - assertTrue(einzahlHandler.canHandle("Wer oder was? (Einzahl 1)", null, null, null)); - assertTrue(einzahlHandler.canHandle("Wer oder was? (Einzahl 2)", null, null, null)); - assertTrue(einzahlHandler.canHandle("Wer oder was? (Einzahl 3)", null, null, null)); - assertTrue(einzahlHandler.canHandle("Wer oder was? (Einzahl 4)", null, null, null)); - assertFalse(einzahlHandler.canHandle("Wer oder was? (Einzahl 5)", null, null, null)); + assertFalse(einzahlHandler.canHandle(null, null, null, parsingContext)); + assertFalse(einzahlHandler.canHandle("Wer oder was?", null, null, parsingContext)); + assertTrue(einzahlHandler.canHandle("Wer oder was? (Einzahl)", null, null, parsingContext)); + assertTrue(einzahlHandler.canHandle("Wer oder was? (Einzahl 1)", null, null, parsingContext)); + assertTrue(einzahlHandler.canHandle("Wer oder was? (Einzahl 2)", null, null, parsingContext)); + assertTrue(einzahlHandler.canHandle("Wer oder was? (Einzahl 3)", null, null, parsingContext)); + assertTrue(einzahlHandler.canHandle("Wer oder was? (Einzahl 4)", null, null, parsingContext)); + assertFalse(einzahlHandler.canHandle("Wer oder was? (Einzahl 5)", null, null, parsingContext)); } public void testEinzahlWithGenus() { WiktionaryWordForm wordForm = new WiktionaryWordForm("test"); - genusHandler.handle("Genus", "m", wordForm, null); - einzahlHandler.handle("Wer oder was? (Einzahl)", "test", wordForm, null); + genusHandler.handle("Genus", "m", wordForm, parsingContext); + einzahlHandler.handle("Wer oder was? (Einzahl)", "test", wordForm, parsingContext); assertEquals(GrammaticalNumber.SINGULAR, wordForm.getNumber()); assertEquals(GrammaticalGender.MASCULINE, wordForm.getGender()); } public void testEinzahlWithGenus_1() { WiktionaryWordForm wordForm = new WiktionaryWordForm("test"); - genusHandler.handle("Genus 1", "n", wordForm, null); - einzahlHandler.handle("Wer oder was? (Einzahl)", "test", wordForm, null); + genusHandler.handle("Genus 1", "n", wordForm, parsingContext); + einzahlHandler.handle("Wer oder was? (Einzahl)", "test", wordForm, parsingContext); assertEquals(GrammaticalNumber.SINGULAR, wordForm.getNumber()); assertEquals(GrammaticalGender.NEUTER, wordForm.getGender()); } public void testEinzahl_1WithGenus_1() { WiktionaryWordForm wordForm = new WiktionaryWordForm("test"); - genusHandler.handle("Genus 1", "f", wordForm, null); - einzahlHandler.handle("Wer oder was? (Einzahl 1)", "test", wordForm, null); + genusHandler.handle("Genus 1", "f", wordForm, parsingContext); + einzahlHandler.handle("Wer oder was? (Einzahl 1)", "test", wordForm, parsingContext); assertEquals(GrammaticalNumber.SINGULAR, wordForm.getNumber()); assertEquals(GrammaticalGender.FEMININE, wordForm.getGender()); } public void testEinzahl_2WithGenus_2() { WiktionaryWordForm wordForm = new WiktionaryWordForm("test"); - genusHandler.handle("Genus 2", "x", wordForm, null); - einzahlHandler.handle("Wer oder was? (Einzahl 2)", "test", wordForm, null); + genusHandler.handle("Genus 2", "x", wordForm, parsingContext); + einzahlHandler.handle("Wer oder was? (Einzahl 2)", "test", wordForm, parsingContext); assertEquals(GrammaticalNumber.SINGULAR, wordForm.getNumber()); assertNull(wordForm.getGender()); } public void testEinzahl_3WithGenus_3() { WiktionaryWordForm wordForm = new WiktionaryWordForm("test"); - genusHandler.handle("Genus 3", "m", wordForm, null); - einzahlHandler.handle("Wer oder was? (Einzahl 3)", "test", wordForm, null); + genusHandler.handle("Genus 3", "m", wordForm, parsingContext); + einzahlHandler.handle("Wer oder was? (Einzahl 3)", "test", wordForm, parsingContext); assertEquals(GrammaticalNumber.SINGULAR, wordForm.getNumber()); assertEquals(GrammaticalGender.MASCULINE, wordForm.getGender()); } public void testEinzahl_3WithGenus_2() { WiktionaryWordForm wordForm = new WiktionaryWordForm("test"); - genusHandler.handle("Genus 2", "m", wordForm, null); - einzahlHandler.handle("Wer oder was? (Einzahl 3)", "test", wordForm, null); + genusHandler.handle("Genus 2", "m", wordForm, parsingContext); + einzahlHandler.handle("Wer oder was? (Einzahl 3)", "test", wordForm, parsingContext); assertEquals(GrammaticalNumber.SINGULAR, wordForm.getNumber()); assertNull(wordForm.getGender()); } @@ -97,8 +102,8 @@ public void testEinzahl_3WithGenus_2() { public void testEinzahl_4WithGenus_4() { WiktionaryWordForm wordForm = new WiktionaryWordForm("test"); - genusHandler.handle("Genus 4", "n", wordForm, null); - einzahlHandler.handle("Wer oder was? (Einzahl 4)", "test", wordForm, null); + genusHandler.handle("Genus 4", "n", wordForm, parsingContext); + einzahlHandler.handle("Wer oder was? (Einzahl 4)", "test", wordForm, parsingContext); assertEquals(GrammaticalNumber.SINGULAR, wordForm.getNumber()); assertEquals(GrammaticalGender.NEUTER, wordForm.getGender()); } diff --git a/src/test/java/de/tudarmstadt/ukp/jwktl/parser/de/components/nountable/GenusHandlerTest.java b/src/test/java/de/tudarmstadt/ukp/jwktl/parser/de/components/nountable/GenusHandlerTest.java index 2758c91..3544277 100644 --- a/src/test/java/de/tudarmstadt/ukp/jwktl/parser/de/components/nountable/GenusHandlerTest.java +++ b/src/test/java/de/tudarmstadt/ukp/jwktl/parser/de/components/nountable/GenusHandlerTest.java @@ -17,61 +17,66 @@ ******************************************************************************/ package de.tudarmstadt.ukp.jwktl.parser.de.components.nountable; +import de.tudarmstadt.ukp.jwktl.api.entry.WiktionaryPage; +import de.tudarmstadt.ukp.jwktl.parser.de.components.DEEntryFactory; import de.tudarmstadt.ukp.jwktl.parser.de.components.DEGenderText; +import de.tudarmstadt.ukp.jwktl.parser.util.ParsingContext; import junit.framework.TestCase; public class GenusHandlerTest extends TestCase { private DEWordFormNounTableHandler nounTableHandler; private GenusHandler genusHandler; + private ParsingContext parsingContext; @Override protected void setUp() throws Exception { nounTableHandler = new DEWordFormNounTableHandler(); genusHandler = new GenusHandler(nounTableHandler); + parsingContext = new ParsingContext(new WiktionaryPage(), new DEEntryFactory()); } public void testCanHandle() { - assertFalse(genusHandler.canHandle(null, null, null, null)); - assertFalse(genusHandler.canHandle("Suneg", null, null, null)); - assertTrue(genusHandler.canHandle("Genus", null, null, null)); - assertFalse(genusHandler.canHandle("Genus ", null, null, null)); - assertFalse(genusHandler.canHandle("Genus 0", null, null, null)); - assertTrue(genusHandler.canHandle("Genus 1", null, null, null)); - assertTrue(genusHandler.canHandle("Genus 2", null, null, null)); - assertTrue(genusHandler.canHandle("Genus 3", null, null, null)); - assertTrue(genusHandler.canHandle("Genus 4", null, null, null)); - assertFalse(genusHandler.canHandle("Genus 4.5", null, null, null)); - assertFalse(genusHandler.canHandle("Genus 5", null, null, null)); + assertFalse(genusHandler.canHandle(null, null, null, parsingContext)); + assertFalse(genusHandler.canHandle("Suneg", null, null, parsingContext)); + assertTrue(genusHandler.canHandle("Genus", null, null, parsingContext)); + assertFalse(genusHandler.canHandle("Genus ", null, null, parsingContext)); + assertFalse(genusHandler.canHandle("Genus 0", null, null, parsingContext)); + assertTrue(genusHandler.canHandle("Genus 1", null, null, parsingContext)); + assertTrue(genusHandler.canHandle("Genus 2", null, null, parsingContext)); + assertTrue(genusHandler.canHandle("Genus 3", null, null, parsingContext)); + assertTrue(genusHandler.canHandle("Genus 4", null, null, parsingContext)); + assertFalse(genusHandler.canHandle("Genus 4.5", null, null, parsingContext)); + assertFalse(genusHandler.canHandle("Genus 5", null, null, parsingContext)); } public void testGenus() { - genusHandler.handle("Genus", "m", null, null); + genusHandler.handle("Genus", "m", null, parsingContext); assertEquals(DEGenderText.M, nounTableHandler.getGenusByIndex(1)); assertNull(nounTableHandler.getGenusByIndex(2)); } public void testGenus1() { - genusHandler.handle("Genus 1", "n", null, null); + genusHandler.handle("Genus 1", "n", null, parsingContext); assertEquals(DEGenderText.N, nounTableHandler.getGenusByIndex(1)); assertNull(nounTableHandler.getGenusByIndex(2)); } public void testGenus2() { - genusHandler.handle("Genus 2", "pl", null, null); + genusHandler.handle("Genus 2", "pl", null, parsingContext); assertNull(nounTableHandler.getGenusByIndex(1)); assertEquals(DEGenderText.PL, nounTableHandler.getGenusByIndex(2)); assertNull(nounTableHandler.getGenusByIndex(3)); } public void testGenus3() { - genusHandler.handle("Genus 3", "0", null, null); + genusHandler.handle("Genus 3", "0", null, parsingContext); assertNull(nounTableHandler.getGenusByIndex(2)); assertEquals(DEGenderText._0, nounTableHandler.getGenusByIndex(3)); assertNull(nounTableHandler.getGenusByIndex(4)); } public void testGenus4() { - genusHandler.handle("Genus 4", "x", null, null); + genusHandler.handle("Genus 4", "x", null, parsingContext); assertNull(nounTableHandler.getGenusByIndex(3)); assertEquals(DEGenderText.X, nounTableHandler.getGenusByIndex(4)); } diff --git a/src/test/java/de/tudarmstadt/ukp/jwktl/parser/de/components/nountable/MehrzahlHandlerTest.java b/src/test/java/de/tudarmstadt/ukp/jwktl/parser/de/components/nountable/MehrzahlHandlerTest.java index 0716702..e3baac6 100644 --- a/src/test/java/de/tudarmstadt/ukp/jwktl/parser/de/components/nountable/MehrzahlHandlerTest.java +++ b/src/test/java/de/tudarmstadt/ukp/jwktl/parser/de/components/nountable/MehrzahlHandlerTest.java @@ -17,8 +17,11 @@ ******************************************************************************/ package de.tudarmstadt.ukp.jwktl.parser.de.components.nountable; +import de.tudarmstadt.ukp.jwktl.api.entry.WiktionaryPage; import de.tudarmstadt.ukp.jwktl.api.entry.WiktionaryWordForm; import de.tudarmstadt.ukp.jwktl.api.util.GrammaticalNumber; +import de.tudarmstadt.ukp.jwktl.parser.de.components.DEEntryFactory; +import de.tudarmstadt.ukp.jwktl.parser.util.ParsingContext; import junit.framework.TestCase; public class MehrzahlHandlerTest extends TestCase { @@ -26,77 +29,79 @@ public class MehrzahlHandlerTest extends TestCase { private DEWordFormNounTableHandler nounTableHandler; private GenusHandler genusHandler; private MehrzahlHandler einzahlHandler; + private ParsingContext parsingContext; @Override protected void setUp() throws Exception { nounTableHandler = new DEWordFormNounTableHandler(); genusHandler = new GenusHandler(nounTableHandler); einzahlHandler = new MehrzahlHandler(nounTableHandler); + parsingContext = new ParsingContext(new WiktionaryPage(), new DEEntryFactory()); } public void testCanHandle() { - assertFalse(einzahlHandler.canHandle(null, null, null, null)); - assertFalse(einzahlHandler.canHandle("Wer oder was?", null, null, null)); - assertTrue(einzahlHandler.canHandle("Wer oder was? (Mehrzahl)", null, null, null)); - assertTrue(einzahlHandler.canHandle("Wer oder was? (Mehrzahl 1)", null, null, null)); - assertTrue(einzahlHandler.canHandle("Wer oder was? (Mehrzahl 2)", null, null, null)); - assertTrue(einzahlHandler.canHandle("Wer oder was? (Mehrzahl 3)", null, null, null)); - assertTrue(einzahlHandler.canHandle("Wer oder was? (Mehrzahl 4)", null, null, null)); - assertFalse(einzahlHandler.canHandle("Wer oder was? (Mehrzahl 5)", null, null, null)); + assertFalse(einzahlHandler.canHandle(null, null, null, parsingContext)); + assertFalse(einzahlHandler.canHandle("Wer oder was?", null, null, parsingContext)); + assertTrue(einzahlHandler.canHandle("Wer oder was? (Mehrzahl)", null, null, parsingContext)); + assertTrue(einzahlHandler.canHandle("Wer oder was? (Mehrzahl 1)", null, null, parsingContext)); + assertTrue(einzahlHandler.canHandle("Wer oder was? (Mehrzahl 2)", null, null, parsingContext)); + assertTrue(einzahlHandler.canHandle("Wer oder was? (Mehrzahl 3)", null, null, parsingContext)); + assertTrue(einzahlHandler.canHandle("Wer oder was? (Mehrzahl 4)", null, null, parsingContext)); + assertFalse(einzahlHandler.canHandle("Wer oder was? (Mehrzahl 5)", null, null, parsingContext)); } public void testMehrzahlWithGenus() { WiktionaryWordForm wordForm = new WiktionaryWordForm("test"); - genusHandler.handle("Genus", "m", wordForm, null); - einzahlHandler.handle("Wer oder was? (Mehrzahl)", "test", wordForm, null); + genusHandler.handle("Genus", "m", wordForm, parsingContext); + einzahlHandler.handle("Wer oder was? (Mehrzahl)", "test", wordForm, parsingContext); assertEquals(GrammaticalNumber.PLURAL, wordForm.getNumber()); assertNull(wordForm.getGender()); } public void testMehrzahlWithGenus_1() { WiktionaryWordForm wordForm = new WiktionaryWordForm("test"); - genusHandler.handle("Genus 1", "n", wordForm, null); - einzahlHandler.handle("Wer oder was? (Mehrzahl)", "test", wordForm, null); + genusHandler.handle("Genus 1", "n", wordForm, parsingContext); + einzahlHandler.handle("Wer oder was? (Mehrzahl)", "test", wordForm, parsingContext); assertEquals(GrammaticalNumber.PLURAL, wordForm.getNumber()); assertNull(wordForm.getGender()); } public void testMehrzahl_1WithGenus_1() { WiktionaryWordForm wordForm = new WiktionaryWordForm("test"); - genusHandler.handle("Genus 1", "f", wordForm, null); - einzahlHandler.handle("Wer oder was? (Mehrzahl 1)", "test", wordForm, null); + genusHandler.handle("Genus 1", "f", wordForm, parsingContext); + einzahlHandler.handle("Wer oder was? (Mehrzahl 1)", "test", wordForm, parsingContext); assertEquals(GrammaticalNumber.PLURAL, wordForm.getNumber()); assertNull(wordForm.getGender()); } public void testMehrzahl_2WithGenus_2() { WiktionaryWordForm wordForm = new WiktionaryWordForm("test"); - genusHandler.handle("Genus 2", "x", wordForm, null); - einzahlHandler.handle("Wer oder was? (Mehrzahl 2)", "test", wordForm, null); + genusHandler.handle("Genus 2", "x", wordForm, parsingContext); + einzahlHandler.handle("Wer oder was? (Mehrzahl 2)", "test", wordForm, parsingContext); assertEquals(GrammaticalNumber.PLURAL, wordForm.getNumber()); assertNull(wordForm.getGender()); } public void testMehrzahl_3WithGenus_3() { WiktionaryWordForm wordForm = new WiktionaryWordForm("test"); - genusHandler.handle("Genus 3", "m", wordForm, null); - einzahlHandler.handle("Wer oder was? (Mehrzahl 3)", "test", wordForm, null); + genusHandler.handle("Genus 3", "m", wordForm, parsingContext); + einzahlHandler.handle("Wer oder was? (Mehrzahl 3)", "test", wordForm, parsingContext); assertEquals(GrammaticalNumber.PLURAL, wordForm.getNumber()); assertNull(wordForm.getGender()); } public void testMehrzahl_3WithGenus_2() { WiktionaryWordForm wordForm = new WiktionaryWordForm("test"); - genusHandler.handle("Genus 2", "m", wordForm, null); - einzahlHandler.handle("Wer oder was? (Mehrzahl 3)", "test", wordForm, null); + genusHandler.handle("Genus 2", "m", wordForm, parsingContext); + einzahlHandler.handle("Wer oder was? (Mehrzahl 3)", "test", wordForm, parsingContext); assertEquals(GrammaticalNumber.PLURAL, wordForm.getNumber()); assertNull(wordForm.getGender()); } public void testMehrzahl_4WithGenus_4() { WiktionaryWordForm wordForm = new WiktionaryWordForm("test"); - genusHandler.handle("Genus 4", "n", wordForm, null); - einzahlHandler.handle("Wer oder was? (Mehrzahl 4)", "test", wordForm, null); + genusHandler.handle("Genus 4", "n", wordForm, parsingContext); + einzahlHandler.handle("Wer oder was? (Mehrzahl 4)", "test", wordForm, parsingContext); assertEquals(GrammaticalNumber.PLURAL, wordForm.getNumber()); assertNull(wordForm.getGender()); } diff --git a/src/test/java/de/tudarmstadt/ukp/jwktl/parser/de/components/nountable/PluralHandlerTest.java b/src/test/java/de/tudarmstadt/ukp/jwktl/parser/de/components/nountable/PluralHandlerTest.java index 014476a..20b9a28 100644 --- a/src/test/java/de/tudarmstadt/ukp/jwktl/parser/de/components/nountable/PluralHandlerTest.java +++ b/src/test/java/de/tudarmstadt/ukp/jwktl/parser/de/components/nountable/PluralHandlerTest.java @@ -17,9 +17,12 @@ ******************************************************************************/ package de.tudarmstadt.ukp.jwktl.parser.de.components.nountable; +import de.tudarmstadt.ukp.jwktl.api.entry.WiktionaryPage; import de.tudarmstadt.ukp.jwktl.api.entry.WiktionaryWordForm; import de.tudarmstadt.ukp.jwktl.api.util.GrammaticalNumber; +import de.tudarmstadt.ukp.jwktl.parser.de.components.DEEntryFactory; import de.tudarmstadt.ukp.jwktl.parser.de.components.DEGenderText; +import de.tudarmstadt.ukp.jwktl.parser.util.ParsingContext; import junit.framework.TestCase; public class PluralHandlerTest extends TestCase { @@ -27,88 +30,90 @@ public class PluralHandlerTest extends TestCase { private DEWordFormNounTableHandler nounTableHandler; private GenusHandler genusHandler; private PluralHandler pluralHandler; + private ParsingContext parsingContext; @Override protected void setUp() throws Exception { nounTableHandler = new DEWordFormNounTableHandler(); genusHandler = new GenusHandler(nounTableHandler); pluralHandler = new PluralHandler(nounTableHandler); + parsingContext = new ParsingContext(new WiktionaryPage(), new DEEntryFactory()); } public void testCanHandle() { - assertFalse(pluralHandler.canHandle(null, null, null, null)); - assertFalse(pluralHandler.canHandle("Larulp", null, null, null)); - assertTrue(pluralHandler.canHandle("Plural", null, null, null)); - assertFalse(pluralHandler.canHandle("Plural ", null, null, null)); + assertFalse(pluralHandler.canHandle(null, null, null, parsingContext)); + assertFalse(pluralHandler.canHandle("Larulp", null, null, parsingContext)); + assertTrue(pluralHandler.canHandle("Plural", null, null, parsingContext)); + assertFalse(pluralHandler.canHandle("Plural ", null, null, parsingContext)); - assertTrue(pluralHandler.canHandle("PLURAL", null, null, null)); - assertFalse(pluralHandler.canHandle(" PLURAL", null, null, null)); - assertFalse(pluralHandler.canHandle("PLURAL ", null, null, null)); + assertTrue(pluralHandler.canHandle("PLURAL", null, null, parsingContext)); + assertFalse(pluralHandler.canHandle(" PLURAL", null, null, parsingContext)); + assertFalse(pluralHandler.canHandle("PLURAL ", null, null, parsingContext)); - assertTrue(pluralHandler.canHandle(" Plural", null, null, null)); - assertFalse(pluralHandler.canHandle(" Plural ", null, null, null)); + assertTrue(pluralHandler.canHandle(" Plural", null, null, parsingContext)); + assertFalse(pluralHandler.canHandle(" Plural ", null, null, parsingContext)); - assertTrue(pluralHandler.canHandle(" Plural*", null, null, null)); - assertFalse(pluralHandler.canHandle("Plural*", null, null, null)); - assertTrue(pluralHandler.canHandle(" Plural**", null, null, null)); - assertFalse(pluralHandler.canHandle("Plural**", null, null, null)); + assertTrue(pluralHandler.canHandle(" Plural*", null, null, parsingContext)); + assertFalse(pluralHandler.canHandle("Plural*", null, null, parsingContext)); + assertTrue(pluralHandler.canHandle(" Plural**", null, null, parsingContext)); + assertFalse(pluralHandler.canHandle("Plural**", null, null, parsingContext)); - assertTrue(pluralHandler.canHandle(" Plural?", null, null, null)); - assertFalse(pluralHandler.canHandle("Plural? ", null, null, null)); - assertFalse(pluralHandler.canHandle(" Plural? ", null, null, null)); + assertTrue(pluralHandler.canHandle(" Plural?", null, null, parsingContext)); + assertFalse(pluralHandler.canHandle("Plural? ", null, null, parsingContext)); + assertFalse(pluralHandler.canHandle(" Plural? ", null, null, parsingContext)); - assertTrue(pluralHandler.canHandle(" Plural *", null, null, null)); - assertFalse(pluralHandler.canHandle("Plural *", null, null, null)); + assertTrue(pluralHandler.canHandle(" Plural *", null, null, parsingContext)); + assertFalse(pluralHandler.canHandle("Plural *", null, null, parsingContext)); - assertTrue(pluralHandler.canHandle(" Plural 1", null, null, null)); - assertTrue(pluralHandler.canHandle(" Plural 2", null, null, null)); - assertTrue(pluralHandler.canHandle(" Plural 3", null, null, null)); - assertTrue(pluralHandler.canHandle(" Plural 4", null, null, null)); + assertTrue(pluralHandler.canHandle(" Plural 1", null, null, parsingContext)); + assertTrue(pluralHandler.canHandle(" Plural 2", null, null, parsingContext)); + assertTrue(pluralHandler.canHandle(" Plural 3", null, null, parsingContext)); + assertTrue(pluralHandler.canHandle(" Plural 4", null, null, parsingContext)); - assertTrue(pluralHandler.canHandle(" Plural 1*", null, null, null)); - assertTrue(pluralHandler.canHandle(" Plural 2*", null, null, null)); - assertTrue(pluralHandler.canHandle(" Plural 3*", null, null, null)); - assertTrue(pluralHandler.canHandle(" Plural 4*", null, null, null)); + assertTrue(pluralHandler.canHandle(" Plural 1*", null, null, parsingContext)); + assertTrue(pluralHandler.canHandle(" Plural 2*", null, null, parsingContext)); + assertTrue(pluralHandler.canHandle(" Plural 3*", null, null, parsingContext)); + assertTrue(pluralHandler.canHandle(" Plural 4*", null, null, parsingContext)); - assertTrue(pluralHandler.canHandle(" Plural 1**", null, null, null)); - assertTrue(pluralHandler.canHandle(" Plural 2**", null, null, null)); - assertTrue(pluralHandler.canHandle(" Plural 3**", null, null, null)); - assertTrue(pluralHandler.canHandle(" Plural 4**", null, null, null)); + assertTrue(pluralHandler.canHandle(" Plural 1**", null, null, parsingContext)); + assertTrue(pluralHandler.canHandle(" Plural 2**", null, null, parsingContext)); + assertTrue(pluralHandler.canHandle(" Plural 3**", null, null, parsingContext)); + assertTrue(pluralHandler.canHandle(" Plural 4**", null, null, parsingContext)); - assertTrue(pluralHandler.canHandle(" Plural* 1", null, null, null)); - assertTrue(pluralHandler.canHandle(" Plural* 2", null, null, null)); - assertTrue(pluralHandler.canHandle(" Plural* 3", null, null, null)); - assertTrue(pluralHandler.canHandle(" Plural* 4", null, null, null)); + assertTrue(pluralHandler.canHandle(" Plural* 1", null, null, parsingContext)); + assertTrue(pluralHandler.canHandle(" Plural* 2", null, null, parsingContext)); + assertTrue(pluralHandler.canHandle(" Plural* 3", null, null, parsingContext)); + assertTrue(pluralHandler.canHandle(" Plural* 4", null, null, parsingContext)); } public void testPluralWithGenus() { WiktionaryWordForm wordForm = new WiktionaryWordForm("test"); - genusHandler.handle("Genus", "m", wordForm, null); - pluralHandler.handle("Nominativ Plural", "test", wordForm, null); + genusHandler.handle("Genus", "m", wordForm, parsingContext); + pluralHandler.handle("Nominativ Plural", "test", wordForm, parsingContext); assertEquals(GrammaticalNumber.PLURAL, wordForm.getNumber()); assertNull(wordForm.getGender()); } public void testPLURALWithGenus_1() { WiktionaryWordForm wordForm = new WiktionaryWordForm("test"); - genusHandler.handle("Genus 1", "n", wordForm, null); - pluralHandler.handle("PLURAL", "test", wordForm, null); + genusHandler.handle("Genus 1", "n", wordForm, parsingContext); + pluralHandler.handle("PLURAL", "test", wordForm, parsingContext); assertEquals(GrammaticalNumber.PLURAL, wordForm.getNumber()); assertNull(wordForm.getGender()); } public void testPlural_2_SternWithGenus_2() { WiktionaryWordForm wordForm = new WiktionaryWordForm("test"); - genusHandler.handle("Genus 2", "f", wordForm, null); - pluralHandler.handle("Nominativ Plural 2*", "test", wordForm, null); + genusHandler.handle("Genus 2", "f", wordForm, parsingContext); + pluralHandler.handle("Nominativ Plural 2*", "test", wordForm, parsingContext); assertEquals(GrammaticalNumber.PLURAL, wordForm.getNumber()); assertNull(wordForm.getGender()); } public void testPlural_3_Stern_SternWithGenus_3() { WiktionaryWordForm wordForm = new WiktionaryWordForm("test"); - genusHandler.handle("Genus 3", "x", wordForm, null); - pluralHandler.handle("Nominativ Plural 3**", "test", wordForm, null); + genusHandler.handle("Genus 3", "x", wordForm, parsingContext); + pluralHandler.handle("Nominativ Plural 3**", "test", wordForm, parsingContext); assertEquals(GrammaticalNumber.PLURAL, wordForm.getNumber()); assertEquals(DEGenderText.X, nounTableHandler.getGenusByIndex(3)); assertNull(wordForm.getGender()); @@ -116,8 +121,8 @@ public void testPlural_3_Stern_SternWithGenus_3() { public void testPlural_Stern_4WithGenus_4() { WiktionaryWordForm wordForm = new WiktionaryWordForm("test"); - genusHandler.handle("Genus 4", "pl", wordForm, null); - pluralHandler.handle("Nominativ Plural* 4", "test", wordForm, null); + genusHandler.handle("Genus 4", "pl", wordForm, parsingContext); + pluralHandler.handle("Nominativ Plural* 4", "test", wordForm, parsingContext); assertEquals(GrammaticalNumber.PLURAL, wordForm.getNumber()); assertEquals(DEGenderText.PL, nounTableHandler.getGenusByIndex(4)); assertNull(wordForm.getGender()); diff --git a/src/test/java/de/tudarmstadt/ukp/jwktl/parser/de/components/nountable/SingularHandlerTest.java b/src/test/java/de/tudarmstadt/ukp/jwktl/parser/de/components/nountable/SingularHandlerTest.java index ec66535..da1c8c6 100644 --- a/src/test/java/de/tudarmstadt/ukp/jwktl/parser/de/components/nountable/SingularHandlerTest.java +++ b/src/test/java/de/tudarmstadt/ukp/jwktl/parser/de/components/nountable/SingularHandlerTest.java @@ -17,10 +17,13 @@ ******************************************************************************/ package de.tudarmstadt.ukp.jwktl.parser.de.components.nountable; +import de.tudarmstadt.ukp.jwktl.api.entry.WiktionaryPage; import de.tudarmstadt.ukp.jwktl.api.entry.WiktionaryWordForm; import de.tudarmstadt.ukp.jwktl.api.util.GrammaticalGender; import de.tudarmstadt.ukp.jwktl.api.util.GrammaticalNumber; +import de.tudarmstadt.ukp.jwktl.parser.de.components.DEEntryFactory; import de.tudarmstadt.ukp.jwktl.parser.de.components.DEGenderText; +import de.tudarmstadt.ukp.jwktl.parser.util.ParsingContext; import junit.framework.TestCase; public class SingularHandlerTest extends TestCase { @@ -28,88 +31,90 @@ public class SingularHandlerTest extends TestCase { private DEWordFormNounTableHandler nounTableHandler; private GenusHandler genusHandler; private SingularHandler singularHandler; + private ParsingContext parsingContext; @Override protected void setUp() throws Exception { nounTableHandler = new DEWordFormNounTableHandler(); genusHandler = new GenusHandler(nounTableHandler); singularHandler = new SingularHandler(nounTableHandler); + parsingContext = new ParsingContext(new WiktionaryPage(), new DEEntryFactory()); } public void testCanHandle() { - assertFalse(singularHandler.canHandle(null, null, null, null)); - assertFalse(singularHandler.canHandle("Ralugnis", null, null, null)); - assertTrue(singularHandler.canHandle("Singular", null, null, null)); - assertFalse(singularHandler.canHandle("Singular ", null, null, null)); + assertFalse(singularHandler.canHandle(null, null, null, parsingContext)); + assertFalse(singularHandler.canHandle("Ralugnis", null, null, parsingContext)); + assertTrue(singularHandler.canHandle("Singular", null, null, parsingContext)); + assertFalse(singularHandler.canHandle("Singular ", null, null, parsingContext)); - assertTrue(singularHandler.canHandle("SINGULAR", null, null, null)); - assertFalse(singularHandler.canHandle(" SINGULAR", null, null, null)); - assertFalse(singularHandler.canHandle("SINGULAR ", null, null, null)); + assertTrue(singularHandler.canHandle("SINGULAR", null, null, parsingContext)); + assertFalse(singularHandler.canHandle(" SINGULAR", null, null, parsingContext)); + assertFalse(singularHandler.canHandle("SINGULAR ", null, null, parsingContext)); - assertTrue(singularHandler.canHandle(" Singular", null, null, null)); - assertFalse(singularHandler.canHandle(" Singular ", null, null, null)); + assertTrue(singularHandler.canHandle(" Singular", null, null, parsingContext)); + assertFalse(singularHandler.canHandle(" Singular ", null, null, parsingContext)); - assertTrue(singularHandler.canHandle(" Singular*", null, null, null)); - assertFalse(singularHandler.canHandle("Singular*", null, null, null)); - assertTrue(singularHandler.canHandle(" Singular**", null, null, null)); - assertFalse(singularHandler.canHandle("Singular**", null, null, null)); + assertTrue(singularHandler.canHandle(" Singular*", null, null, parsingContext)); + assertFalse(singularHandler.canHandle("Singular*", null, null, parsingContext)); + assertTrue(singularHandler.canHandle(" Singular**", null, null, parsingContext)); + assertFalse(singularHandler.canHandle("Singular**", null, null, parsingContext)); - assertTrue(singularHandler.canHandle(" Singular?", null, null, null)); - assertFalse(singularHandler.canHandle("Singular? ", null, null, null)); - assertFalse(singularHandler.canHandle(" Singular? ", null, null, null)); + assertTrue(singularHandler.canHandle(" Singular?", null, null, parsingContext)); + assertFalse(singularHandler.canHandle("Singular? ", null, null, parsingContext)); + assertFalse(singularHandler.canHandle(" Singular? ", null, null, parsingContext)); - assertTrue(singularHandler.canHandle(" Singular *", null, null, null)); - assertFalse(singularHandler.canHandle("Singular *", null, null, null)); + assertTrue(singularHandler.canHandle(" Singular *", null, null, parsingContext)); + assertFalse(singularHandler.canHandle("Singular *", null, null, parsingContext)); - assertTrue(singularHandler.canHandle(" Singular 1", null, null, null)); - assertTrue(singularHandler.canHandle(" Singular 2", null, null, null)); - assertTrue(singularHandler.canHandle(" Singular 3", null, null, null)); - assertTrue(singularHandler.canHandle(" Singular 4", null, null, null)); + assertTrue(singularHandler.canHandle(" Singular 1", null, null, parsingContext)); + assertTrue(singularHandler.canHandle(" Singular 2", null, null, parsingContext)); + assertTrue(singularHandler.canHandle(" Singular 3", null, null, parsingContext)); + assertTrue(singularHandler.canHandle(" Singular 4", null, null, parsingContext)); - assertTrue(singularHandler.canHandle(" Singular 1*", null, null, null)); - assertTrue(singularHandler.canHandle(" Singular 2*", null, null, null)); - assertTrue(singularHandler.canHandle(" Singular 3*", null, null, null)); - assertTrue(singularHandler.canHandle(" Singular 4*", null, null, null)); + assertTrue(singularHandler.canHandle(" Singular 1*", null, null, parsingContext)); + assertTrue(singularHandler.canHandle(" Singular 2*", null, null, parsingContext)); + assertTrue(singularHandler.canHandle(" Singular 3*", null, null, parsingContext)); + assertTrue(singularHandler.canHandle(" Singular 4*", null, null, parsingContext)); - assertTrue(singularHandler.canHandle(" Singular 1**", null, null, null)); - assertTrue(singularHandler.canHandle(" Singular 2**", null, null, null)); - assertTrue(singularHandler.canHandle(" Singular 3**", null, null, null)); - assertTrue(singularHandler.canHandle(" Singular 4**", null, null, null)); + assertTrue(singularHandler.canHandle(" Singular 1**", null, null, parsingContext)); + assertTrue(singularHandler.canHandle(" Singular 2**", null, null, parsingContext)); + assertTrue(singularHandler.canHandle(" Singular 3**", null, null, parsingContext)); + assertTrue(singularHandler.canHandle(" Singular 4**", null, null, parsingContext)); - assertTrue(singularHandler.canHandle(" Singular* 1", null, null, null)); - assertTrue(singularHandler.canHandle(" Singular* 2", null, null, null)); - assertTrue(singularHandler.canHandle(" Singular* 3", null, null, null)); - assertTrue(singularHandler.canHandle(" Singular* 4", null, null, null)); + assertTrue(singularHandler.canHandle(" Singular* 1", null, null, parsingContext)); + assertTrue(singularHandler.canHandle(" Singular* 2", null, null, parsingContext)); + assertTrue(singularHandler.canHandle(" Singular* 3", null, null, parsingContext)); + assertTrue(singularHandler.canHandle(" Singular* 4", null, null, parsingContext)); } public void testSingularWithGenus() { WiktionaryWordForm wordForm = new WiktionaryWordForm("test"); - genusHandler.handle("Genus", "m", wordForm, null); - singularHandler.handle("Nominativ Singular", "test", wordForm, null); + genusHandler.handle("Genus", "m", wordForm, parsingContext); + singularHandler.handle("Nominativ Singular", "test", wordForm, parsingContext); assertEquals(GrammaticalNumber.SINGULAR, wordForm.getNumber()); assertEquals(GrammaticalGender.MASCULINE, wordForm.getGender()); } public void testSINGULARWithGenus_1() { WiktionaryWordForm wordForm = new WiktionaryWordForm("test"); - genusHandler.handle("Genus 1", "n", wordForm, null); - singularHandler.handle("SINGULAR", "test", wordForm, null); + genusHandler.handle("Genus 1", "n", wordForm, parsingContext); + singularHandler.handle("SINGULAR", "test", wordForm, parsingContext); assertEquals(GrammaticalNumber.SINGULAR, wordForm.getNumber()); assertEquals(GrammaticalGender.NEUTER, wordForm.getGender()); } public void testSingular_2_SternWithGenus_2() { WiktionaryWordForm wordForm = new WiktionaryWordForm("test"); - genusHandler.handle("Genus 2", "f", wordForm, null); - singularHandler.handle("Nominativ Singular 2*", "test", wordForm, null); + genusHandler.handle("Genus 2", "f", wordForm, parsingContext); + singularHandler.handle("Nominativ Singular 2*", "test", wordForm, parsingContext); assertEquals(GrammaticalNumber.SINGULAR, wordForm.getNumber()); assertEquals(GrammaticalGender.FEMININE, wordForm.getGender()); } public void testSingular_3_Stern_SternWithGenus_3() { WiktionaryWordForm wordForm = new WiktionaryWordForm("test"); - genusHandler.handle("Genus 3", "x", wordForm, null); - singularHandler.handle("Nominativ Singular 3**", "test", wordForm, null); + genusHandler.handle("Genus 3", "x", wordForm, parsingContext); + singularHandler.handle("Nominativ Singular 3**", "test", wordForm, parsingContext); assertEquals(GrammaticalNumber.SINGULAR, wordForm.getNumber()); assertEquals(DEGenderText.X, nounTableHandler.getGenusByIndex(3)); assertNull(wordForm.getGender()); @@ -117,8 +122,8 @@ public void testSingular_3_Stern_SternWithGenus_3() { public void testSingular_Stern_4WithGenus_4() { WiktionaryWordForm wordForm = new WiktionaryWordForm("test"); - genusHandler.handle("Genus 4", "pl", wordForm, null); - singularHandler.handle("Nominativ Singular* 4", "test", wordForm, null); + genusHandler.handle("Genus 4", "pl", wordForm, parsingContext); + singularHandler.handle("Nominativ Singular* 4", "test", wordForm, parsingContext); assertEquals(GrammaticalNumber.SINGULAR, wordForm.getNumber()); assertEquals(DEGenderText.PL, nounTableHandler.getGenusByIndex(4)); assertNull(wordForm.getGender()); diff --git a/src/test/resources/articles-de/Apfelschorle.txt b/src/test/resources/articles-de/Apfelschorle.txt new file mode 100644 index 0000000..b500ac8 --- /dev/null +++ b/src/test/resources/articles-de/Apfelschorle.txt @@ -0,0 +1,71 @@ +== Apfelschorle ({{Sprache|Deutsch}}) == +=== {{Wortart|Substantiv|Deutsch}}, {{fn}} === + +{{Deutsch Substantiv Übersicht +|Genus=n +|Nominativ Singular=Apfelschorle +|Nominativ Plural=Apfelschorles +|Genitiv Singular=Apfelschorles +|Genitiv Plural=Apfelschorles +|Dativ Singular=Apfelschorle +|Dativ Plural=Apfelschorles +|Akkusativ Singular=Apfelschorle +|Akkusativ Plural=Apfelschorles +}} + +{{Deutsch Substantiv Übersicht +|Genus=f +|Nominativ Singular=Apfelschorle +|Nominativ Plural=Apfelschorlen +|Genitiv Singular=Apfelschorle +|Genitiv Plural=Apfelschorlen +|Dativ Singular=Apfelschorle +|Dativ Plural=Apfelschorlen +|Akkusativ Singular=Apfelschorle +|Akkusativ Plural=Apfelschorlen +}} + +{{Anmerkung}} +:''Genus:'' Das Substantiv ''Apfelschorle'' wird in der Regel als weiblich betrachtet und entsprechend gebeugt. Selten kommt auch neutrales Genus vor, landschaftlich gebräuchlich ist das maskuline Geschlecht. + +{{Worttrennung}} +:Ap·fel·schor·le, {{Pl.}} Ap·fel·schor·len (Ap·fel·schor·les) + +{{Aussprache}} +:{{IPA}} {{Lautschrift|ˈapfl̩ˌʃɔʁlə}} +:{{Hörbeispiele}} {{Audio|De-Apfelschorle.ogg}} + +{{Bedeutungen}} +:[1] Mischgetränk, das aus [[Apfelsaft]] und [[Mineralwasser]] hergestellt wird + +{{Herkunft}} +:[[Determinativkompositum]], zusammengesetzt aus ''[[Apfel]]'' und ''[[Schorle]]'' + +{{Synonyme}} +:[1] [[Apfelsaftschorle]], ''in Österreich:'' [[Apfelsaft gespritzt]], [[Obi gespritzt]] + +{{Oberbegriffe}} +:[1] [[Getränk]] + +{{Beispiele}} +:[1] „Ich habe etwa zwei Liter ''Apfelschorle'' im Ziel zu mir genommen, dazu nochmal einen Liter Joghurtdrinks.“<ref>Internetbeleg</ref> + +{{Charakteristische Wortkombinationen}} +:[1] eine ~ [[trinken]] + +==== {{Übersetzungen}} ==== +{{Ü-Tabelle|Ü-links= +*{{en}}: [1] {{Ü|en|apple spritzer}}, {{Ü|en|apple juice spritzer}}, {{Ü|en|appletiser}} +*{{it}}: [1] ''(keine wörtliche Übersetzung:)'' una bevanda fatta da succo di mele ed acqua gassata +|Ü-rechts= +*{{es}}: [1] ''(keine wörtliche Übersetzung:)'' una bebida hecha de zumo de manzana y agua mineral +*{{cs}}: [1] {{Ü|cs|jablečný střik}} {{m}} +}} + +{{Referenzen}} +:[1] {{Wikipedia|Apfelschorle}} +:[1] {{Ref-DWDS|Apfelschorle}} +:[1] {{Ref-Canoo|Apfelschorle}} +:[1] {{Ref-UniLeipzig|Apfelschorle}} + +{{Quellen}} \ No newline at end of file From 523dca4663c8fdf4a7638fb61fbae64ea69c512b Mon Sep 17 00:00:00 2001 From: Alexey Valikov Date: Wed, 19 Dec 2018 15:18:40 +0100 Subject: [PATCH 5/5] #66 Add inflection group to word form - Fixed JavaDocs --- .../de/tudarmstadt/ukp/jwktl/api/IWiktionaryWordForm.java | 2 +- .../ukp/jwktl/api/entry/WiktionaryWordForm.java | 1 - .../util/IWiktionaryWordFormTemplateParameterHandler.java | 8 ++++---- 3 files changed, 5 insertions(+), 6 deletions(-) diff --git a/src/main/java/de/tudarmstadt/ukp/jwktl/api/IWiktionaryWordForm.java b/src/main/java/de/tudarmstadt/ukp/jwktl/api/IWiktionaryWordForm.java index be6ac60..3182b91 100644 --- a/src/main/java/de/tudarmstadt/ukp/jwktl/api/IWiktionaryWordForm.java +++ b/src/main/java/de/tudarmstadt/ukp/jwktl/api/IWiktionaryWordForm.java @@ -92,7 +92,7 @@ public interface IWiktionaryWordForm { * Semantics of this property may differ from language to language. * Roughly speaking, inflection group corresponds to the column in * the inflection table. - * @return Index of the inflection group, -1 if there this word form + * @return Index of the inflection group, -1 if there this word form * does not belong to an inflection group. */ int getInflectionGroup(); diff --git a/src/main/java/de/tudarmstadt/ukp/jwktl/api/entry/WiktionaryWordForm.java b/src/main/java/de/tudarmstadt/ukp/jwktl/api/entry/WiktionaryWordForm.java index 8d58b0e..73fec97 100644 --- a/src/main/java/de/tudarmstadt/ukp/jwktl/api/entry/WiktionaryWordForm.java +++ b/src/main/java/de/tudarmstadt/ukp/jwktl/api/entry/WiktionaryWordForm.java @@ -94,7 +94,6 @@ public void setGender(final GrammaticalGender grammaticalGender) { this.grammaticalGender = grammaticalGender; } - @Override public int getInflectionGroup() { return this.inflectionGroup; } diff --git a/src/main/java/de/tudarmstadt/ukp/jwktl/parser/util/IWiktionaryWordFormTemplateParameterHandler.java b/src/main/java/de/tudarmstadt/ukp/jwktl/parser/util/IWiktionaryWordFormTemplateParameterHandler.java index c81ffb6..f74e3f2 100644 --- a/src/main/java/de/tudarmstadt/ukp/jwktl/parser/util/IWiktionaryWordFormTemplateParameterHandler.java +++ b/src/main/java/de/tudarmstadt/ukp/jwktl/parser/util/IWiktionaryWordFormTemplateParameterHandler.java @@ -43,15 +43,15 @@ public interface IWiktionaryWordFormTemplateParameterHandler { * word form. * @param context * parsing context. - * @return true if this handler can handle the given parameter, - * false otherwise. + * @return true if this handler can handle the given parameter, + * false otherwise. */ public boolean canHandle(String label, String value, WiktionaryWordForm wordForm, ParsingContext context); /** * Handles the given parameter. This should only be called if - * {@see #canHandle(String, String, WiktionaryWordForm, ParsingContext)} - * returned true. + * @see #canHandle(String, String, WiktionaryWordForm, ParsingContext) + * returned true. * * @param label * parameter label.