nlptoolkit-morphologicalanalysis 1.0.0

package/source/tsconfig.json

@@ -0,0 +1,13 @@
+{
+  "compilerOptions": {
+    "outDir": "../dist",
+    "module": "umd",
+    "target": "es6",
+    "sourceMap": true,
+    "noImplicitAny": true,
+    "strictNullChecks": false,
+    "removeComments": false,
+    "moduleResolution": "node",
+    "declaration": true
+  }
+}

package/tests/DisambiguationCorpusTest.ts

@@ -0,0 +1,12 @@
+import {DisambiguationCorpus} from "../dist/Corpus/DisambiguationCorpus";
+import * as assert from "assert";
+
+describe('DisambiguationCorpusTest', function() {
+    describe('DisambiguationCorpusTest', function() {
+        it('testCorpus', function() {
+            let corpus = new DisambiguationCorpus("penntreebank.txt");
+            assert.strictEqual(19109, corpus.sentenceCount());
+            assert.strictEqual(170211, corpus.numberOfWords());
+        });
+    });
+});

package/tests/FiniteStateMachineTest.ts

@@ -0,0 +1,87 @@
+import * as assert from "assert";
+import {FiniteStateMachine} from "../dist/MorphologicalAnalysis/FiniteStateMachine";
+import {CounterHashMap} from "nlptoolkit-datastructure/dist/CounterHashMap";
+
+describe('FiniteStateMachineTest', function() {
+    describe('FiniteStateMachineTest', function() {
+        let fsm = new FiniteStateMachine("turkish_finite_state_machine.xml");
+        let stateList = fsm.getStates();
+        it('testStateCount', function() {
+            assert.strictEqual(139, stateList.length);
+        });
+        it('testStartEndStates', function() {
+            let endStateCount = 0;
+            for (let state of stateList){
+                if (state.isEndState()){
+                    endStateCount++;
+                }
+            }
+            assert.strictEqual(35, endStateCount);
+            let posCounts = new CounterHashMap<string>();
+            for (let state of stateList){
+                posCounts.put(state.getPos());
+            }
+            assert.strictEqual(1, posCounts.get("HEAD"));
+            assert.strictEqual(6, posCounts.get("PRON"));
+            assert.strictEqual(1, posCounts.get("PROP"));
+            assert.strictEqual(8, posCounts.get("NUM"));
+            assert.strictEqual(7, posCounts.get("ADJ"));
+            assert.strictEqual(1, posCounts.get("INTERJ"));
+            assert.strictEqual(1, posCounts.get("DET"));
+            assert.strictEqual(1, posCounts.get("ADVERB"));
+            assert.strictEqual(1, posCounts.get("QUES"));
+            assert.strictEqual(1, posCounts.get("CONJ"));
+            assert.strictEqual(26, posCounts.get("VERB"));
+            assert.strictEqual(1, posCounts.get("POSTP"));
+            assert.strictEqual(1, posCounts.get("DUP"));
+            assert.strictEqual(11, posCounts.get("NOUN"));
+        });
+        it('testTransitionCount', function() {
+            let transitionCount = 0;
+            for (let state of stateList){
+                transitionCount += fsm.getTransitions(state).length;
+            }
+            assert.strictEqual(779, transitionCount);
+        });
+        it('testTransitionWith', function() {
+            let transitionCounts = new CounterHashMap<string>();
+            for (let state of stateList){
+                let transitions = fsm.getTransitions(state);
+                for (let transition of transitions){
+                    transitionCounts.put(transition.toString());
+                }
+            }
+            let topList = transitionCounts.topN(5);
+            assert.strictEqual("0", topList[0][0]);
+            assert.strictEqual(111, topList[0][1]);
+            assert.strictEqual("lAr", topList[1][0]);
+            assert.strictEqual(37, topList[1][1]);
+            assert.strictEqual("DHr", topList[2][0]);
+            assert.strictEqual(28, topList[2][1]);
+            assert.strictEqual("Hn", topList[3][0]);
+            assert.strictEqual(24, topList[3][1]);
+            assert.strictEqual("lArH", topList[4][0]);
+            assert.strictEqual(23, topList[4][1]);
+        });
+        it('testTransitionWithName', function() {
+            let transitionCounts = new CounterHashMap<string>();
+            for (let state of stateList){
+                let transitions = fsm.getTransitions(state);
+                for (let transition of transitions){
+                    transitionCounts.put(transition.getWith());
+                }
+            }
+            let topList = transitionCounts.topN(5);
+            assert.strictEqual("", topList[0][0]);
+            assert.strictEqual(52, topList[0][1]);
+            assert.strictEqual("^DB+VERB+CAUS", topList[1][0]);
+            assert.strictEqual(33, topList[1][1]);
+            assert.strictEqual("^DB+VERB+PASS", topList[2][0]);
+            assert.strictEqual(31, topList[2][1]);
+            assert.strictEqual("A3PL", topList[3][0]);
+            assert.strictEqual(28, topList[3][1]);
+            assert.strictEqual("LOC", topList[4][0]);
+            assert.strictEqual(24, topList[4][1]);
+        });
+    });
+});

package/tests/FsmMorphologicalAnalyzerTest.ts

@@ -0,0 +1,204 @@
+import * as assert from "assert";
+import {FsmMorphologicalAnalyzer} from "../dist/MorphologicalAnalysis/FsmMorphologicalAnalyzer";
+import {TxtWord} from "nlptoolkit-dictionary/dist/Dictionary/TxtWord";
+import {State} from "../dist/MorphologicalAnalysis/State";
+import {Transition} from "../dist/MorphologicalAnalysis/Transition";
+import {Sentence} from "nlptoolkit-corpus/dist/Sentence";
+
+describe('FsmMorphologicalAnalyzerTest', function() {
+    describe('FsmMorphologicalAnalyzerTest', function() {
+        let fsm = new FsmMorphologicalAnalyzer();
+        it('morphologicalAnalysisDataTimeNumber', function() {
+            assert.ok(fsm.morphologicalAnalysis("3/4").size() != 0);
+            assert.ok(fsm.morphologicalAnalysis("3\\/4").size() != 0);
+            assert.ok(fsm.morphologicalAnalysis("4/2/1973").size() != 0);
+            assert.ok(fsm.morphologicalAnalysis("14/2/1993").size() != 0);
+            assert.ok(fsm.morphologicalAnalysis("14/12/1933").size() != 0);
+            assert.ok(fsm.morphologicalAnalysis("6/12/1903").size() != 0);
+            assert.ok(fsm.morphologicalAnalysis("%34.5").size() != 0);
+            assert.ok(fsm.morphologicalAnalysis("%3").size() != 0);
+            assert.ok(fsm.morphologicalAnalysis("%56").size() != 0);
+            assert.ok(fsm.morphologicalAnalysis("2:3").size() != 0);
+            assert.ok(fsm.morphologicalAnalysis("12:3").size() != 0);
+            assert.ok(fsm.morphologicalAnalysis("4:23").size() != 0);
+            assert.ok(fsm.morphologicalAnalysis("11:56").size() != 0);
+            assert.ok(fsm.morphologicalAnalysis("1:2:3").size() != 0);
+            assert.ok(fsm.morphologicalAnalysis("3:12:3").size() != 0);
+            assert.ok(fsm.morphologicalAnalysis("5:4:23").size() != 0);
+            assert.ok(fsm.morphologicalAnalysis("7:11:56").size() != 0);
+            assert.ok(fsm.morphologicalAnalysis("12:2:3").size() != 0);
+            assert.ok(fsm.morphologicalAnalysis("10:12:3").size() != 0);
+            assert.ok(fsm.morphologicalAnalysis("11:4:23").size() != 0);
+            assert.ok(fsm.morphologicalAnalysis("22:11:56").size() != 0);
+            assert.ok(fsm.morphologicalAnalysis("45").size() != 0);
+            assert.ok(fsm.morphologicalAnalysis("34.23").size() != 0);
+        });
+        it('morphologicalAnalysisProperNoun', function() {
+            let dictionary = fsm.getDictionary();
+            for (let i = 0; i < 30000; i++){
+                let word = <TxtWord> dictionary.getWord(Math.floor(Math.random() * dictionary.size()));
+                if (word.isProperNoun()){
+                    assert.ok(fsm.morphologicalAnalysis(word.getName().toLocaleUpperCase("tr")).size() != 0);
+                }
+            }
+        });
+        it('morphologicalAnalysisNounSoftenDuringSuffixation', function() {
+            let dictionary = fsm.getDictionary();
+            for (let i = 0; i < dictionary.size(); i++){
+                let word = <TxtWord> dictionary.getWord(i);
+                if (word.isNominal() && word.nounSoftenDuringSuffixation()){
+                    let transitionState = new State("Possessive", false, false);
+                    let startState = new State("NominalRoot", true, false);
+                    let transition = new Transition("yH", "ACC", transitionState);
+                    let surfaceForm = transition.makeTransition(word, word.getName(), startState);
+                    assert.ok(fsm.morphologicalAnalysis(surfaceForm).size() != 0);
+                }
+            }
+        });
+        it('morphologicalAnalysisVowelAChangesToIDuringYSuffixation', function() {
+            let dictionary = fsm.getDictionary();
+            for (let i = 0; i < dictionary.size(); i++){
+                let word = <TxtWord> dictionary.getWord(i);
+                if (word.isVerb() && word.vowelAChangesToIDuringYSuffixation()){
+                    let transitionState = new State("VerbalStem", false, false);
+                    let startState = new State("VerbalRoot", true, false);
+                    let transition = new Transition("Hyor", "PROG1", transitionState);
+                    let surfaceForm = transition.makeTransition(word, word.getName(), startState);
+                    assert.ok(fsm.morphologicalAnalysis(surfaceForm).size() != 0);
+                }
+            }
+        });
+        it('morphologicalAnalysisIsPortmanteau', function() {
+            let dictionary = fsm.getDictionary();
+            for (let i = 0; i < dictionary.size(); i++){
+                let word = <TxtWord> dictionary.getWord(i);
+                if (word.isNominal() && word.isPortmanteau() && !word.isPlural() && !word.isPortmanteauFacedVowelEllipsis()){
+                    let transitionState = new State("CompoundNounRoot", true, false);
+                    let startState = new State("CompoundNounRoot", true, false);
+                    let transition = new Transition("lArH", "A3PL+P3PL", transitionState);
+                    let exceptLast2 = word.getName().substring(0, word.getName().length - 2);
+                    let exceptLast = word.getName().substring(0, word.getName().length - 1);
+                    let rootForm
+                    if (word.isPortmanteauFacedSoftening()){
+                        switch (word.getName().charAt(word.getName().length - 2)) {
+                            case 'b':
+                                rootForm = exceptLast2 + 'p';
+                                break;
+                            case 'c':
+                                rootForm = exceptLast2 + 'ç';
+                                break;
+                            case 'd':
+                                rootForm = exceptLast2 + 't';
+                                break;
+                            case 'ğ':
+                                rootForm = exceptLast2 + 'k';
+                                break;
+                            default:
+                                rootForm = exceptLast;
+                        }
+                    } else {
+                        if (word.isPortmanteauEndingWithSI()){
+                            rootForm = exceptLast2;
+                        } else {
+                            rootForm = exceptLast;
+                        }
+                    }
+                    let surfaceForm = transition.makeTransition(word, rootForm, startState);
+                    assert.ok(fsm.morphologicalAnalysis(surfaceForm).size() != 0);
+                }
+            }
+        });
+        it('morphologicalAnalysisNotObeysVowelHarmonyDuringAgglutination', function() {
+            let dictionary = fsm.getDictionary();
+            for (let i = 0; i < dictionary.size(); i++){
+                let word = <TxtWord> dictionary.getWord(i);
+                if (word.isNominal() && word.notObeysVowelHarmonyDuringAgglutination()){
+                    let transitionState = new State("Possessive", false, false);
+                    let startState = new State("NominalRoot", true, false);
+                    let transition = new Transition("yH", "ACC", transitionState);
+                    let surfaceForm = transition.makeTransition(word, word.getName(), startState);
+                    assert.ok(fsm.morphologicalAnalysis(surfaceForm).size() != 0);
+                }
+            }
+        });
+        it('morphologicalAnalysisLastIdropsDuringSuffixation', function() {
+            let dictionary = fsm.getDictionary();
+            for (let i = 0; i < dictionary.size(); i++){
+                let word = <TxtWord> dictionary.getWord(i);
+                if (word.isNominal() && word.lastIdropsDuringSuffixation()){
+                    let transitionState = new State("Possessive", false, false);
+                    let startState = new State("NominalRoot", true, false);
+                    let transition = new Transition("yH", "ACC", transitionState);
+                    let surfaceForm = transition.makeTransition(word, word.getName(), startState);
+                    assert.ok(fsm.morphologicalAnalysis(surfaceForm).size() != 0);
+                }
+            }
+        });
+        it('morphologicalAnalysisVerbSoftenDuringSuffixation', function() {
+            let dictionary = fsm.getDictionary();
+            for (let i = 0; i < dictionary.size(); i++){
+                let word = <TxtWord> dictionary.getWord(i);
+                if (word.isVerb() && word.verbSoftenDuringSuffixation()){
+                    let transitionState = new State("VerbalStem", false, false);
+                    let startState = new State("VerbalRoot", true, false);
+                    let transition = new Transition("Hyor", "PROG1", transitionState);
+                    let surfaceForm = transition.makeTransition(word, word.getName(), startState);
+                    assert.ok(fsm.morphologicalAnalysis(surfaceForm).size() != 0);
+                }
+            }
+        });
+        it('morphologicalAnalysisDuplicatesDuringSuffixation', function() {
+            let dictionary = fsm.getDictionary();
+            for (let i = 0; i < dictionary.size(); i++){
+                let word = <TxtWord> dictionary.getWord(i);
+                if (word.isNominal() && word.duplicatesDuringSuffixation()){
+                    let transitionState = new State("Possessive", false, false);
+                    let startState = new State("NominalRoot", true, false);
+                    let transition = new Transition("yH", "ACC", transitionState);
+                    let surfaceForm = transition.makeTransition(word, word.getName(), startState);
+                    assert.ok(fsm.morphologicalAnalysis(surfaceForm).size() != 0);
+                }
+            }
+        });
+        it('morphologicalAnalysisEndingKChangesIntoG', function() {
+            let dictionary = fsm.getDictionary();
+            for (let i = 0; i < dictionary.size(); i++){
+                let word = <TxtWord> dictionary.getWord(i);
+                if (word.isNominal() && word.endingKChangesIntoG()){
+                    let transitionState = new State("Possessive", false, false);
+                    let startState = new State("NominalRoot", true, false);
+                    let transition = new Transition("yH", "ACC", transitionState);
+                    let surfaceForm = transition.makeTransition(word, word.getName(), startState);
+                    assert.ok(fsm.morphologicalAnalysis(surfaceForm).size() != 0);
+                }
+            }
+        });
+        it('morphologicalAnalysisLastIdropsDuringPassiveSuffixation', function() {
+            let dictionary = fsm.getDictionary();
+            for (let i = 0; i < dictionary.size(); i++){
+                let word = <TxtWord> dictionary.getWord(i);
+                if (word.isVerb() && word.lastIdropsDuringPassiveSuffixation()){
+                    let transitionState = new State("VerbalStem", false, false);
+                    let startState = new State("VerbalRoot", true, false);
+                    let transition = new Transition("Hl", "^DB+VERB+PASS", transitionState);
+                    let surfaceForm = transition.makeTransition(word, word.getName(), startState);
+                    assert.ok(fsm.morphologicalAnalysis(surfaceForm).size() != 0);
+                }
+            }
+        });
+        it('testReplaceWord', function() {
+            assert.strictEqual("Şvesterine söyle kazağı güzelmiş", fsm.replaceWord(new Sentence("Hemşirene söyle kazağı güzelmiş"), "hemşire", "şvester").toString());
+            assert.strictEqual("Burada çok abartma var", fsm.replaceWord(new Sentence("Burada çok mübalağa var"), "mübalağa", "abartma").toString());
+            assert.strictEqual("Bu bina çok kötü şekilsizleştirildi", fsm.replaceWord(new Sentence("Bu bina çok kötü biçimsizleştirildi"), "biçimsizleş", "şekilsizleş").toString());
+            assert.strictEqual("Abim geçen yıl ölmüştü gibi", fsm.replaceWord(new Sentence("Abim geçen yıl son yolculuğa çıkmıştı gibi"), "son yolculuğa çık", "öl").toString());
+            assert.strictEqual("Hemşirenle evlendim", fsm.replaceWord(new Sentence("Kız kardeşinle evlendim"), "kız kardeş", "hemşire").toString());
+            assert.strictEqual("Dün yaptığı güreş maçında yenildi", fsm.replaceWord(new Sentence("Dün yaptığı güreş maçında mağlup oldu"), "mağlup ol", "yenil").toString());
+            assert.strictEqual("Abim geçen yıl son yolculuğa çıkmıştı gibi", fsm.replaceWord(new Sentence("Abim geçen yıl ölmüştü gibi"), "öl", "son yolculuğa çık").toString());
+            assert.strictEqual("Kız kardeşinle evlendim", fsm.replaceWord(new Sentence("Hemşirenle evlendim"), "hemşire", "kız kardeş").toString());
+            assert.strictEqual("Dün yaptığı güreş maçında mağlup oldu", fsm.replaceWord(new Sentence("Dün yaptığı güreş maçında yenildi"), "yenil", "mağlup ol").toString());
+            assert.strictEqual("Dün yaptığı güreş maçında alt oldu sanki", fsm.replaceWord(new Sentence("Dün yaptığı güreş maçında mağlup oldu sanki"), "mağlup ol", "alt ol").toString());
+            assert.strictEqual("Yemin billah vermişlerdi vazoyu kırmadığına", fsm.replaceWord(new Sentence("Yemin etmişlerdi vazoyu kırmadığına"), "yemin et", "yemin billah ver").toString());
+            assert.strictEqual("Yemin etmişlerdi vazoyu kırmadığına", fsm.replaceWord(new Sentence("Yemin billah vermişlerdi vazoyu kırmadığına"), "yemin billah ver", "yemin et").toString());
+        });
+    });
+});

package/tests/FsmParseListTest.ts

@@ -0,0 +1,90 @@
+import * as assert from "assert";
+import {FsmMorphologicalAnalyzer} from "../dist/MorphologicalAnalysis/FsmMorphologicalAnalyzer";
+import {Word} from "nlptoolkit-dictionary/dist/Dictionary/Word";
+
+describe('FsmParseTest', function() {
+    describe('FsmParseTest', function() {
+        let fsm = new FsmMorphologicalAnalyzer();
+        let parse1 = fsm.morphologicalAnalysis("açılır");
+        let parse2 = fsm.morphologicalAnalysis("koparılarak");
+        let parse3 = fsm.morphologicalAnalysis("toplama");
+        let parse4 = fsm.morphologicalAnalysis("değerlendirmede");
+        let parse5 = fsm.morphologicalAnalysis("soruşturmasının");
+        let parse6 = fsm.morphologicalAnalysis("karşılaştırmalı");
+        let parse7 = fsm.morphologicalAnalysis("esaslarını");
+        let parse8 = fsm.morphologicalAnalysis("güçleriyle");
+        let parse9 = fsm.morphologicalAnalysis("bulmayacakları");
+        let parse10 = fsm.morphologicalAnalysis("kitabı");
+        let parse11 = fsm.morphologicalAnalysis("kitapları");
+        let parse12 = fsm.morphologicalAnalysis("o");
+        let parse13 = fsm.morphologicalAnalysis("arabası");
+        let parse14 = fsm.morphologicalAnalysis("sana");
+        it('testSize', function() {
+            assert.strictEqual(2, parse1.size());
+            assert.strictEqual(2, parse2.size());
+            assert.strictEqual(6, parse3.size());
+            assert.strictEqual(4, parse4.size());
+            assert.strictEqual(5, parse5.size());
+            assert.strictEqual(12, parse6.size());
+            assert.strictEqual(8, parse7.size());
+            assert.strictEqual(6, parse8.size());
+            assert.strictEqual(5, parse9.size());
+            assert.strictEqual(4, parse14.size());
+        });
+        it('testRootWords', function() {
+            assert.strictEqual("aç", parse1.rootWords());
+            assert.strictEqual("kop$kopar", parse2.rootWords());
+            assert.strictEqual("topla$toplam$toplama", parse3.rootWords());
+            assert.strictEqual("değer$değerlen$değerlendir$değerlendirme", parse4.rootWords());
+            assert.strictEqual("sor$soru$soruş$soruştur$soruşturma", parse5.rootWords());
+            assert.strictEqual("karşı$karşıla$karşılaş$karşılaştır$karşılaştırma$karşılaştırmalı", parse6.rootWords());
+            assert.strictEqual("esas", parse7.rootWords());
+            assert.strictEqual("güç", parse8.rootWords());
+            assert.strictEqual("bul", parse9.rootWords());
+        });
+        it('testGetParseWithLongestRootWord', function() {
+            assert.strictEqual("kopar", parse2.getParseWithLongestRootWord().getWord().getName());
+            assert.strictEqual("toplama", parse3.getParseWithLongestRootWord().getWord().getName());
+            assert.strictEqual("değerlendirme", parse4.getParseWithLongestRootWord().getWord().getName());
+            assert.strictEqual("soruşturma", parse5.getParseWithLongestRootWord().getWord().getName());
+            assert.strictEqual("karşılaştırmalı", parse6.getParseWithLongestRootWord().getWord().getName());
+        });
+        it('testReduceToParsesWithSameRootAndPos', function() {
+            parse2.reduceToParsesWithSameRootAndPos(new Word("kop+VERB"));
+            assert.strictEqual(1, parse2.size());
+            parse3.reduceToParsesWithSameRootAndPos(new Word("topla+VERB"));
+            assert.strictEqual(2, parse3.size());
+            parse6.reduceToParsesWithSameRootAndPos(new Word("karşıla+VERB"));
+            assert.strictEqual(2, parse6.size());
+        });
+        it('testReduceToParsesWithSameRoot', function() {
+            parse2.reduceToParsesWithSameRoot("kop");
+            assert.strictEqual(1, parse2.size());
+            parse3.reduceToParsesWithSameRoot("topla");
+            assert.strictEqual(3, parse3.size());
+            parse6.reduceToParsesWithSameRoot("karşı");
+            assert.strictEqual(4, parse6.size());
+            parse7.reduceToParsesWithSameRoot("esas");
+            assert.strictEqual(8, parse7.size());
+            parse8.reduceToParsesWithSameRoot("güç");
+            assert.strictEqual(6, parse8.size());
+        });
+        it('testConstructParseListForDifferentRootWithPos', function() {
+            assert.strictEqual(1, parse1.constructParseListForDifferentRootWithPos().length);
+            assert.strictEqual(2, parse2.constructParseListForDifferentRootWithPos().length);
+            assert.strictEqual(5, parse3.constructParseListForDifferentRootWithPos().length);
+            assert.strictEqual(4, parse4.constructParseListForDifferentRootWithPos().length);
+            assert.strictEqual(5, parse5.constructParseListForDifferentRootWithPos().length);
+            assert.strictEqual(7, parse6.constructParseListForDifferentRootWithPos().length);
+            assert.strictEqual(2, parse7.constructParseListForDifferentRootWithPos().length);
+            assert.strictEqual(2, parse8.constructParseListForDifferentRootWithPos().length);
+            assert.strictEqual(1, parse9.constructParseListForDifferentRootWithPos().length);
+        });
+        it('testParsesWithoutPrefixAndSuffix', function() {
+            assert.strictEqual("P3SG+NOM$PNON+ACC", parse10.parsesWithoutPrefixAndSuffix());
+            assert.strictEqual("A3PL+P3PL+NOM$A3PL+P3SG+NOM$A3PL+PNON+ACC$A3SG+P3PL+NOM", parse11.parsesWithoutPrefixAndSuffix());
+            assert.strictEqual("DET$PRON+DEMONSP+A3SG+PNON+NOM$PRON+PERS+A3SG+PNON+NOM", parse12.parsesWithoutPrefixAndSuffix());
+            assert.strictEqual("NOUN+A3SG+P3SG+NOM$NOUN^DB+ADJ+ALMOST", parse13.parsesWithoutPrefixAndSuffix());
+        });
+    });
+});

package/tests/FsmParseTest.ts

@@ -0,0 +1,66 @@
+import * as assert from "assert";
+import {FsmMorphologicalAnalyzer} from "../dist/MorphologicalAnalysis/FsmMorphologicalAnalyzer";
+
+describe('FsmParseTest', function() {
+    describe('FsmParseTest', function() {
+        let fsm = new FsmMorphologicalAnalyzer();
+        let parse1 = fsm.morphologicalAnalysis("açılır").getFsmParse(1);
+        let parse2 = fsm.morphologicalAnalysis("koparılarak").getFsmParse(0);
+        let parse3 = fsm.morphologicalAnalysis("toplama").getFsmParse(0);
+        let parse4 = fsm.morphologicalAnalysis("değerlendirmede").getFsmParse(0);
+        let parse5 = fsm.morphologicalAnalysis("soruşturmasının").getFsmParse(0);
+        let parse6 = fsm.morphologicalAnalysis("karşılaştırmalı").getFsmParse(1);
+        let parse7 = fsm.morphologicalAnalysis("esaslarını").getFsmParse(0);
+        let parse8 = fsm.morphologicalAnalysis("güçleriyle").getFsmParse(0);
+        let parse9 = fsm.morphologicalAnalysis("bulmayacakları").getFsmParse(0);
+        let parse10 = fsm.morphologicalAnalysis("mü").getFsmParse(0);
+        it('testGetLastLemmaWithTag', function() {
+            assert.strictEqual("açıl", parse1.getLastLemmaWithTag("VERB"));
+            assert.strictEqual("koparıl", parse2.getLastLemmaWithTag("VERB"));
+            assert.strictEqual("değerlendir", parse4.getLastLemmaWithTag("VERB"));
+            assert.strictEqual("soruştur", parse5.getLastLemmaWithTag("VERB"));
+            assert.strictEqual("karşı", parse6.getLastLemmaWithTag("ADJ"));
+        });
+        it('testGetLastLemma', function() {
+            assert.strictEqual("açıl", parse1.getLastLemma());
+            assert.strictEqual("koparılarak", parse2.getLastLemma());
+            assert.strictEqual("değerlendirme", parse4.getLastLemma());
+            assert.strictEqual("soruşturma", parse5.getLastLemma());
+            assert.strictEqual("karşılaştır", parse6.getLastLemma());
+        });
+        it('testGetTransitionList', function() {
+            assert.strictEqual("aç+VERB^DB+VERB+PASS+POS+AOR+A3SG", parse1.toString());
+            assert.strictEqual("kop+VERB^DB+VERB+CAUS^DB+VERB+PASS+POS^DB+ADV+BYDOINGSO", parse2.toString());
+            assert.strictEqual("topla+NOUN+A3SG+P1SG+DAT", parse3.toString());
+            assert.strictEqual("değer+NOUN+A3SG+PNON+NOM^DB+VERB+ACQUIRE^DB+VERB+CAUS+POS^DB+NOUN+INF2+A3SG+PNON+LOC", parse4.toString());
+            assert.strictEqual("sor+VERB+RECIP^DB+VERB+CAUS+POS^DB+NOUN+INF2+A3SG+P3SG+GEN", parse5.toString());
+            assert.strictEqual("karşı+ADJ^DB+VERB+BECOME^DB+VERB+CAUS+POS+NECES+A3SG", parse6.toString());
+            assert.strictEqual("esas+ADJ^DB+NOUN+ZERO+A3PL+P2SG+ACC", parse7.toString());
+            assert.strictEqual("güç+ADJ^DB+NOUN+ZERO+A3PL+P3PL+INS", parse8.toString());
+            assert.strictEqual("bul+VERB+NEG^DB+ADJ+FUTPART+P3PL", parse9.toString());
+            assert.strictEqual("mi+QUES+PRES+A3SG", parse10.toString());
+        });
+        it('testWithList', function() {
+            assert.strictEqual("aç+Hl+Hr", parse1.getWithList());
+            assert.strictEqual("kop+Ar+Hl+yArAk", parse2.getWithList());
+            assert.strictEqual("topla+Hm+yA", parse3.getWithList());
+            assert.strictEqual("değer+lAn+DHr+mA+DA", parse4.getWithList());
+            assert.strictEqual("sor+Hs+DHr+mA+sH+nHn", parse5.getWithList());
+            assert.strictEqual("karşı+lAs+DHr+mAlH", parse6.getWithList());
+            assert.strictEqual("esas+lAr+Hn+yH", parse7.getWithList());
+            assert.strictEqual("güç+lArH+ylA", parse8.getWithList());
+            assert.strictEqual("bul+mA+yAcAk+lArH", parse9.getWithList());
+        });
+        it('testSuffixList', function() {
+            assert.strictEqual("VerbalRoot(F5PR)(aç)+PassiveHl(açıl)+OtherTense2(açılır)", parse1.getSuffixList());
+            assert.strictEqual("VerbalRoot(F1P1)(kop)+CausativeAr(kopar)+PassiveHl(koparıl)+Adverb1(koparılarak)", parse2.getSuffixList());
+            assert.strictEqual("NominalRoot(topla)+Possessive(toplam)+Case1(toplama)", parse3.getSuffixList());
+            assert.strictEqual("NominalRoot(değer)+VerbalRoot(F5PR)(değerlen)+CausativeDHr(değerlendir)+NominalRoot(değerlendirme)+Case1(değerlendirmede)", parse4.getSuffixList());
+            assert.strictEqual("VerbalRoot(F5PR)(sor)+Reciprocal(soruş)+CausativeDHr(soruştur)+NominalRoot(soruşturma)+Possessive3(soruşturması)+Case1(soruşturmasının)", parse5.getSuffixList());
+            assert.strictEqual("AdjectiveRoot(karşı)+VerbalRoot(F5PR)(karşılaş)+CausativeDHr(karşılaştır)+OtherTense(karşılaştırmalı)", parse6.getSuffixList());
+            assert.strictEqual("AdjectiveRoot(esas)+Plural(esaslar)+Possessive(esasların)+AccusativeNoun(esaslarını)", parse7.getSuffixList());
+            assert.strictEqual("AdjectiveRoot(güç)+Possesive3(güçleri)+Case1(güçleriyle)", parse8.getSuffixList());
+            assert.strictEqual("VerbalRoot(F5PW)(bul)+Negativema(bulma)+AdjectiveParticiple(bulmayacak)+Adjective(bulmayacakları)", parse9.getSuffixList());
+        });
+    });
+});

package/tests/InflectionalGroupTest.ts

@@ -0,0 +1,84 @@
+import * as assert from "assert";
+import {InflectionalGroup} from "../dist/MorphologicalAnalysis/InflectionalGroup";
+import {MorphologicalTag} from "../dist/MorphologicalAnalysis/MorphologicalTag";
+
+describe('InflectionalGroupTest', function() {
+    describe('InflectionalGroupTest', function() {
+        it('testGetMorphologicalTag', function() {
+            assert.strictEqual(InflectionalGroup.getMorphologicalTag("noun"), MorphologicalTag.NOUN);
+            assert.strictEqual(InflectionalGroup.getMorphologicalTag("without"), MorphologicalTag.WITHOUT);
+            assert.strictEqual(InflectionalGroup.getMorphologicalTag("interj"), MorphologicalTag.INTERJECTION);
+            assert.strictEqual(InflectionalGroup.getMorphologicalTag("inf2"), MorphologicalTag.INFINITIVE2);
+        });
+        it('size', function() {
+            let inflectionalGroup1 = new InflectionalGroup("ADJ");
+            assert.strictEqual(1, inflectionalGroup1.size());
+            let inflectionalGroup2 = new InflectionalGroup("ADJ+JUSTLIKE");
+            assert.strictEqual(2, inflectionalGroup2.size());
+            let inflectionalGroup3 = new InflectionalGroup("ADJ+FUTPART+P1PL");
+            assert.strictEqual(3, inflectionalGroup3.size());
+            let inflectionalGroup4 = new InflectionalGroup("NOUN+A3PL+P1PL+ABL");
+            assert.strictEqual(4, inflectionalGroup4.size());
+            let inflectionalGroup5 = new InflectionalGroup("ADJ+WITH+A3SG+P3SG+ABL");
+            assert.strictEqual(5, inflectionalGroup5.size());
+            let inflectionalGroup6 = new InflectionalGroup("VERB+ABLE+NEG+FUT+A3PL+COP");
+            assert.strictEqual(6, inflectionalGroup6.size());
+            let inflectionalGroup7 = new InflectionalGroup("VERB+ABLE+NEG+AOR+A3SG+COND+A1SG");
+            assert.strictEqual(7, inflectionalGroup7.size());
+        });
+        it('containsCase', function() {
+            let inflectionalGroup1 = new InflectionalGroup("NOUN+ACTOF+A3PL+P1PL+NOM");
+            assert.notStrictEqual(undefined, inflectionalGroup1.containsCase());
+            let inflectionalGroup2 = new InflectionalGroup("NOUN+A3PL+P1PL+ACC");
+            assert.notStrictEqual(undefined, inflectionalGroup2.containsCase());
+            let inflectionalGroup3 = new InflectionalGroup("NOUN+ZERO+A3SG+P3PL+DAT");
+            assert.notStrictEqual(undefined, inflectionalGroup3.containsCase());
+            let inflectionalGroup4 = new InflectionalGroup("PRON+QUANTP+A1PL+P1PL+LOC");
+            assert.notStrictEqual(undefined, inflectionalGroup4.containsCase());
+            let inflectionalGroup5 = new InflectionalGroup("NOUN+AGT+A3SG+P2SG+ABL");
+            assert.notStrictEqual(undefined, inflectionalGroup5.containsCase());
+        });
+        it('containsPlural', function() {
+            let inflectionalGroup1 = new InflectionalGroup("VERB+NEG+NECES+A1PL");
+            assert.ok(inflectionalGroup1.containsPlural());
+            let inflectionalGroup2 = new InflectionalGroup("PRON+PERS+A2PL+PNON+NOM");
+            assert.ok(inflectionalGroup2.containsPlural());
+            let inflectionalGroup3 = new InflectionalGroup("NOUN+DIM+A3PL+P2SG+GEN");
+            assert.ok(inflectionalGroup3.containsPlural());
+            let inflectionalGroup4 = new InflectionalGroup("NOUN+A3PL+P1PL+GEN");
+            assert.ok(inflectionalGroup4.containsPlural());
+            let inflectionalGroup5 = new InflectionalGroup("NOUN+ZERO+A3SG+P2PL+INS");
+            assert.ok(inflectionalGroup5.containsPlural());
+            let inflectionalGroup6 = new InflectionalGroup("PRON+QUANTP+A3PL+P3PL+LOC");
+            assert.ok(inflectionalGroup6.containsPlural());
+        });
+        it('containsTag', function() {
+            let inflectionalGroup1 = new InflectionalGroup("NOUN+ZERO+A3SG+P1SG+NOM");
+            assert.ok(inflectionalGroup1.containsTag(MorphologicalTag.NOUN));
+            let inflectionalGroup2 = new InflectionalGroup("NOUN+AGT+A3PL+P2SG+ABL");
+            assert.ok(inflectionalGroup2.containsTag(MorphologicalTag.AGENT));
+            let inflectionalGroup3 = new InflectionalGroup("NOUN+INF2+A3PL+P3SG+NOM");
+            assert.ok(inflectionalGroup3.containsTag(MorphologicalTag.NOMINATIVE));
+            let inflectionalGroup4 = new InflectionalGroup("NOUN+ZERO+A3SG+P1PL+ACC");
+            assert.ok(inflectionalGroup4.containsTag(MorphologicalTag.ZERO));
+            let inflectionalGroup5 = new InflectionalGroup("NOUN+ZERO+A3SG+P2PL+INS");
+            assert.ok(inflectionalGroup5.containsTag(MorphologicalTag.P2PL));
+            let inflectionalGroup6 = new InflectionalGroup("PRON+QUANTP+A3PL+P3PL+LOC");
+            assert.ok(inflectionalGroup6.containsTag(MorphologicalTag.QUANTITATIVEPRONOUN));
+        });
+        it('containsPossessive', function() {
+            let inflectionalGroup1 = new InflectionalGroup("NOUN+ZERO+A3SG+P1SG+NOM");
+            assert.ok(inflectionalGroup1.containsPossessive());
+            let inflectionalGroup2 = new InflectionalGroup("NOUN+AGT+A3PL+P2SG+ABL");
+            assert.ok(inflectionalGroup2.containsPossessive());
+            let inflectionalGroup3 = new InflectionalGroup("NOUN+INF2+A3PL+P3SG+NOM");
+            assert.ok(inflectionalGroup3.containsPossessive());
+            let inflectionalGroup4 = new InflectionalGroup("NOUN+ZERO+A3SG+P1PL+ACC");
+            assert.ok(inflectionalGroup4.containsPossessive());
+            let inflectionalGroup5 = new InflectionalGroup("NOUN+ZERO+A3SG+P2PL+INS");
+            assert.ok(inflectionalGroup5.containsPossessive());
+            let inflectionalGroup6 = new InflectionalGroup("PRON+QUANTP+A3PL+P3PL+LOC");
+            assert.ok(inflectionalGroup6.containsPossessive());
+        });
+    });
+});