public void LexEntriesComboHandler_ItemsInComboForInflVariant()
{
using (var sandbox = SetupSandbox(() =>
{
const string wff = "blonde";
var mockText = MakeText(wff);
var wf = MakeWordform(wff);
var wa = MakeAnalysis(wf);
var options = new MakeBundleOptions();
options.LexEntryForm = wff;
options.MakeMorph = (mff) =>
{
Guid slotType = GetSlotType(mff);
IMoMorphSynAnalysis msa1;
var mainEntry = MakeEntry("blondEntry", "", slotType, out msa1);
var mainSense = MakeSense(mainEntry, "fair haired", msa1);
IMoMorphSynAnalysis msa2;
var variantEntry = MakeEntry("blondeEntry", "", slotType, out msa2);
ILexEntryType letDialectalVariantType = Cache.ServiceLocator.GetInstance <ILexEntryTypeRepository>().GetObject(LexEntryTypeTags.kguidLexTypDialectalVar);
letDialectalVariantType.Abbreviation.set_String(Cache.DefaultAnalWs, "dial.var. of");
letDialectalVariantType.Name.set_String(Cache.DefaultAnalWs, "Dialectal Variant");
letDialectalVariantType.ReverseAbbr.set_String(Cache.DefaultAnalWs, "dial.var.");
variantEntry.MakeVariantOf(mainSense, letDialectalVariantType);
return(variantEntry.LexemeFormOA);
};
options.MakeSense = (entry) =>
{
var entryRef = entry.EntryRefsOS.First();
return(entryRef.ComponentLexemesRS.First() as ILexSense);
};
options.MakeMsa = (sense) => { return(sense.MorphoSyntaxAnalysisRA); };
var wmb = MakeBundle(wa, options);
var para = (IStTxtPara)mockText.ContentsOA.ParagraphsOS[0];
var seg = para.SegmentsOS[0];
seg.AnalysesRS.Add(wa);
return(new AnalysisOccurrence(seg, 0));
}))
{
var initialAnalysisStack = sandbox.CurrentAnalysisTree;
using (var handler = GetComboHandler(sandbox, InterlinLineChoices.kflidLexEntries, 0) as SandboxBase.IhMissingEntry)
{
var imorphItemCurrentSandboxState = handler.IndexOfCurrentItem;
Assert.That(imorphItemCurrentSandboxState, Is.EqualTo(1));
var handlerList = handler.ComboList.Items;
Assert.That(handlerList[0].ToString(), Is.EqualTo("Add New Sense for blondeEntry ..."));
Assert.That(handlerList[1].ToString(), Is.EqualTo(" fair haired, ???, blondEntry+dial.var."));
Assert.That(handlerList[2].ToString(), Is.EqualTo(" Add New Sense..."));
}
}
}
public void LexEntriesComboHandler_IndexOfCurrentLexSenseAndMsa()
{
using (var sandbox = SetupSandbox(() =>
{
const string wff = "monomorphemicstem";
var mockText = MakeText(wff);
var wf = MakeWordform(wff);
var wa = MakeAnalysis(wf);
var options = new MakeBundleOptions();
options.LexEntryForm = wff;
options.MakeMorph = (mff) =>
{
Guid slotType = GetSlotType(mff);
IMoMorphSynAnalysis msa;
var entry = MakeEntry(mff.Replace("-", ""), "V:(Imperative)", slotType, out msa);
var sense2 = MakeSense(entry, "gloss1", msa);
return(entry.LexemeFormOA);
};
options.MakeSense = (entry) =>
{
var msa = entry.MorphoSyntaxAnalysesOC.ToList()[0];
var sense2 = MakeSense(entry, "gloss2", msa);
return(sense2);
};
options.MakeMsa = (sense) => { return(sense.MorphoSyntaxAnalysisRA); };
var wmb = MakeBundle(wa, options);
var para = (IStTxtPara)mockText.ContentsOA.ParagraphsOS[0];
var seg = para.SegmentsOS[0];
seg.AnalysesRS.Add(wa);
return(new AnalysisOccurrence(seg, 0));
}))
{
var initialAnalysisStack = sandbox.CurrentAnalysisTree;
using (var handler = GetComboHandler(sandbox, InterlinLineChoices.kflidLexEntries, 0) as SandboxBase.IhMissingEntry)
{
var imorphItemCurrentSandboxState = handler.IndexOfCurrentItem;
Assert.That(imorphItemCurrentSandboxState, Is.GreaterThan(-1));
var items = handler.MorphItems;
var miCurrentSandboxState = items[imorphItemCurrentSandboxState];
Assert.That(miCurrentSandboxState.m_hvoMorph,
Is.EqualTo(initialAnalysisStack.WfiAnalysis.MorphBundlesOS[0].MorphRA.Hvo));
Assert.That(miCurrentSandboxState.m_hvoSense,
Is.EqualTo(initialAnalysisStack.WfiAnalysis.MorphBundlesOS[0].SenseRA.Hvo));
Assert.That(miCurrentSandboxState.m_hvoMsa,
Is.EqualTo(initialAnalysisStack.WfiAnalysis.MorphBundlesOS[0].MsaRA.Hvo));
Assert.That(miCurrentSandboxState.m_hvoMainEntryOfVariant, Is.EqualTo(0));
}
}
}
private IWfiMorphBundle MakeBundleDefault(IWfiAnalysis wa, string form, string gloss, string pos)
{
var options = new MakeBundleOptions();
options.LexEntryForm = form;
options.MakeMorph = (mff) =>
{
Guid slotType = GetSlotType(mff);
IMoMorphSynAnalysis msa;
var entry = MakeEntry(mff.Replace("-", ""), pos, slotType, out msa);
return(entry.LexemeFormOA);
};
options.MakeSense = (entry) =>
{
var msa = entry.MorphoSyntaxAnalysesOC.ToList()[0];
var sense = MakeSense(entry, gloss, msa);
return(sense);
};
options.MakeMsa = (sense) => { return(sense.MorphoSyntaxAnalysisRA); };
return(MakeBundle(wa, options));
}
private IWfiMorphBundle MakeBundle(IWfiAnalysis wa, MakeBundleOptions mbOptions)
{
var bundle = Cache.ServiceLocator.GetInstance <IWfiMorphBundleFactory>().Create();
wa.MorphBundlesOS.Add(bundle);
var morph = mbOptions.MakeMorph(mbOptions.LexEntryForm);
bundle.MorphRA = morph;
var sense = mbOptions.MakeSense(morph.Owner as ILexEntry);
bundle.SenseRA = sense;
var msa = mbOptions.MakeMsa(sense);
bundle.MsaRA = msa;
if (mbOptions.MakeInflType != null)
{
var inflType = mbOptions.MakeInflType(morph);
bundle.InflTypeRA = inflType;
}
return(bundle);
}
public void LexEntriesComboHandler_InflTypeOptions_GlossAppendSenseNames_Ordered_PST_PL()
{
using (var sandbox = SetupSandbox(() =>
{
const string wff = "variantEntry";
var mockText = MakeText(wff);
var wf = MakeWordform(wff);
var wa = MakeAnalysis(wf);
var options = new MakeBundleOptions();
options.LexEntryForm = wff;
options.MakeMorph = (mff) =>
{
Guid slotType = GetSlotType(mff);
IMoMorphSynAnalysis msa1;
const string mainEntryForm = "mainEntry";
var mainEntry = MakeEntry(mainEntryForm.Replace("-", ""), "V:(Imperative)", slotType, out msa1);
var mainSense = MakeSense(mainEntry, "mainGloss", msa1);
IMoMorphSynAnalysis msa2;
var variantEntry = MakeEntry(mff.Replace("-", ""), "V:(Imperative)", slotType, out msa2);
var letPlural =
Cache.ServiceLocator.GetInstance <ILexEntryInflTypeRepository>().GetObject(
LexEntryTypeTags.kguidLexTypPluralVar);
letPlural.GlossAppend.set_String(Cache.DefaultAnalWs, "pl");
var letPst =
Cache.ServiceLocator.GetInstance <ILexEntryInflTypeRepository>().GetObject(
LexEntryTypeTags.kguidLexTypPastVar);
letPst.GlossAppend.set_String(Cache.DefaultAnalWs, "pst");
// add types to entryRef in the order of "pst" followed by "pl"
var ler = variantEntry.MakeVariantOf(mainSense, letPst);
ler.VariantEntryTypesRS.Add(letPlural);
return(variantEntry.LexemeFormOA);
};
options.MakeSense = (entry) =>
{
var entryRef = entry.EntryRefsOS.First();
return(entryRef.ComponentLexemesRS.First() as ILexSense);
};
options.MakeMsa = (sense) => { return(sense.MorphoSyntaxAnalysisRA); };
options.MakeInflType = (mf) =>
{
var entry = mf.Owner as ILexEntry;
var entryRef = entry.EntryRefsOS.First();
var vet = entryRef.VariantEntryTypesRS.First() as ILexEntryInflType;
return(vet);
};
var wmb = MakeBundle(wa, options);
var para = (IStTxtPara)mockText.ContentsOA.ParagraphsOS[0];
var seg = para.SegmentsOS[0];
seg.AnalysesRS.Add(wa);
return(new AnalysisOccurrence(seg, 0));
}))
{
var letPlural =
Cache.ServiceLocator.GetInstance <ILexEntryInflTypeRepository>().GetObject(
LexEntryTypeTags.kguidLexTypPluralVar);
var letPst =
Cache.ServiceLocator.GetInstance <ILexEntryInflTypeRepository>().GetObject(
LexEntryTypeTags.kguidLexTypPastVar);
using (var handler = GetComboHandler(sandbox, InterlinLineChoices.kflidLexEntries, 0) as SandboxBase.IhMissingEntry)
{
var sortedMorphItems = handler.MorphItems;
sortedMorphItems.Sort();
// menu items should be ordered according to entryRef.VariantEntryTypesRS
{
var mi0 = sortedMorphItems[0];
Assert.That(mi0.m_inflType, Is.EqualTo(letPst));
Assert.That(mi0.m_nameSense, Is.EqualTo("mainGloss.pst"));
}
{
var mi1 = sortedMorphItems[1];
Assert.That(mi1.m_inflType, Is.EqualTo(letPlural));
Assert.That(mi1.m_nameSense, Is.EqualTo("mainGloss.pl"));
}
}
}
}
public void LexEntriesComboHandler_IndexOfCurrentInflVariant_InflTypeChosen()
{
using (var sandbox = SetupSandbox(() =>
{
const string wff = "variantEntry";
var mockText = MakeText(wff);
var wf = MakeWordform(wff);
var wa = MakeAnalysis(wf);
var options = new MakeBundleOptions();
options.LexEntryForm = wff;
options.MakeMorph = (mff) =>
{
Guid slotType = GetSlotType(mff);
IMoMorphSynAnalysis msa1;
const string mainEntryForm = "mainEntry";
var mainEntry = MakeEntry(mainEntryForm.Replace("-", ""), "V:(Imperative)", slotType, out msa1);
var mainSense = MakeSense(mainEntry, "mainGloss", msa1);
IMoMorphSynAnalysis msa2;
var variantEntry = MakeEntry(mff.Replace("-", ""), "V:(Imperative)", slotType, out msa2);
var letPlural =
Cache.ServiceLocator.GetInstance <ILexEntryInflTypeRepository>().GetObject(
LexEntryTypeTags.kguidLexTypPluralVar);
letPlural.GlossAppend.set_String(Cache.DefaultAnalWs, "pl");
variantEntry.MakeVariantOf(mainSense, letPlural);
return(variantEntry.LexemeFormOA);
};
options.MakeSense = (entry) =>
{
var entryRef = entry.EntryRefsOS.First();
return(entryRef.ComponentLexemesRS.First() as ILexSense);
};
options.MakeMsa = (sense) => { return(sense.MorphoSyntaxAnalysisRA); };
options.MakeInflType = (mf) =>
{
var entry = mf.Owner as ILexEntry;
var entryRef = entry.EntryRefsOS.First();
var vet = entryRef.VariantEntryTypesRS.First() as ILexEntryInflType;
return(vet);
};
var wmb = MakeBundle(wa, options);
var para = (IStTxtPara)mockText.ContentsOA.ParagraphsOS[0];
var seg = para.SegmentsOS[0];
seg.AnalysesRS.Add(wa);
return(new AnalysisOccurrence(seg, 0));
}))
{
var initialAnalysisStack = sandbox.CurrentAnalysisTree;
using (var handler = GetComboHandler(sandbox, InterlinLineChoices.kflidLexEntries, 0) as SandboxBase.IhMissingEntry)
{
var imorphItemCurrentSandboxState = handler.IndexOfCurrentItem;
var items = handler.MorphItems;
var miCurrentSandboxState = items[imorphItemCurrentSandboxState];
Assert.That(miCurrentSandboxState.m_hvoMorph,
Is.EqualTo(initialAnalysisStack.WfiAnalysis.MorphBundlesOS[0].MorphRA.Hvo));
Assert.That(miCurrentSandboxState.m_hvoSense,
Is.EqualTo(initialAnalysisStack.WfiAnalysis.MorphBundlesOS[0].SenseRA.Hvo));
Assert.That(miCurrentSandboxState.m_hvoMsa,
Is.EqualTo(initialAnalysisStack.WfiAnalysis.MorphBundlesOS[0].MsaRA.Hvo));
var variantEntry = initialAnalysisStack.WfiAnalysis.MorphBundlesOS[0].MorphRA.Owner as ILexEntry;
var variantType = variantEntry.VariantEntryRefs.First().VariantEntryTypesRS.First();
Assert.That(miCurrentSandboxState.m_inflType, Is.EqualTo(variantType));
Assert.That(miCurrentSandboxState.m_hvoMainEntryOfVariant, Is.EqualTo(initialAnalysisStack.WfiAnalysis.MorphBundlesOS[0].SenseRA.Entry.Hvo));
}
}
}
private IWfiMorphBundle MakeBundle(IWfiAnalysis wa, MakeBundleOptions mbOptions)
{
var bundle = Cache.ServiceLocator.GetInstance<IWfiMorphBundleFactory>().Create();
wa.MorphBundlesOS.Add(bundle);
var morph = mbOptions.MakeMorph(mbOptions.LexEntryForm);
bundle.MorphRA = morph;
var sense = mbOptions.MakeSense(morph.Owner as ILexEntry);
bundle.SenseRA = sense;
var msa = mbOptions.MakeMsa(sense);
bundle.MsaRA = msa;
if (mbOptions.MakeInflType != null)
{
var inflType = mbOptions.MakeInflType(morph);
bundle.InflTypeRA = inflType;
}
return bundle;
}
private IWfiMorphBundle MakeBundleDefault(IWfiAnalysis wa, string form, string gloss, string pos)
{
var options = new MakeBundleOptions();
options.LexEntryForm = form;
options.MakeMorph = (mff) =>
{
Guid slotType = GetSlotType(mff);
IMoMorphSynAnalysis msa;
var entry = MakeEntry(mff.Replace("-", ""), pos, slotType, out msa);
return entry.LexemeFormOA;
};
options.MakeSense = (entry) =>
{
var msa = entry.MorphoSyntaxAnalysesOC.ToList()[0];
var sense = MakeSense(entry, gloss, msa);
return sense;
};
options.MakeMsa = (sense) => { return sense.MorphoSyntaxAnalysisRA; };
return MakeBundle(wa, options);
}
public void LexEntriesComboHandler_InflTypeOptions_GlossAppendSenseNames_Ordered_PST_PL()
{
using (var sandbox = SetupSandbox(() =>
{
const string wff = "variantEntry";
var mockText = MakeText(wff);
var wf = MakeWordform(wff);
var wa = MakeAnalysis(wf);
var options = new MakeBundleOptions();
options.LexEntryForm = wff;
options.MakeMorph = (mff) =>
{
Guid slotType = GetSlotType(mff);
IMoMorphSynAnalysis msa1;
const string mainEntryForm = "mainEntry";
var mainEntry = MakeEntry(mainEntryForm.Replace("-", ""), "V:(Imperative)", slotType, out msa1);
var mainSense = MakeSense(mainEntry, "mainGloss", msa1);
IMoMorphSynAnalysis msa2;
var variantEntry = MakeEntry(mff.Replace("-", ""), "V:(Imperative)", slotType, out msa2);
var letPlural =
Cache.ServiceLocator.GetInstance<ILexEntryInflTypeRepository>().GetObject(
LexEntryTypeTags.kguidLexTypPluralVar);
letPlural.GlossAppend.set_String(Cache.DefaultAnalWs, "pl");
var letPst =
Cache.ServiceLocator.GetInstance<ILexEntryInflTypeRepository>().GetObject(
LexEntryTypeTags.kguidLexTypPastVar);
letPst.GlossAppend.set_String(Cache.DefaultAnalWs, "pst");
// add types to entryRef in the order of "pst" followed by "pl"
var ler = variantEntry.MakeVariantOf(mainSense, letPst);
ler.VariantEntryTypesRS.Add(letPlural);
return variantEntry.LexemeFormOA;
};
options.MakeSense = (entry) =>
{
var entryRef = entry.EntryRefsOS.First();
return entryRef.ComponentLexemesRS.First() as ILexSense;
};
options.MakeMsa = (sense) => { return sense.MorphoSyntaxAnalysisRA; };
options.MakeInflType = (mf) =>
{
var entry = mf.Owner as ILexEntry;
var entryRef = entry.EntryRefsOS.First();
var vet = entryRef.VariantEntryTypesRS.First() as ILexEntryInflType;
return vet;
};
var wmb = MakeBundle(wa, options);
var para = (IStTxtPara)mockText.ContentsOA.ParagraphsOS[0];
var seg = para.SegmentsOS[0];
seg.AnalysesRS.Add(wa);
return new AnalysisOccurrence(seg, 0);
}))
{
var letPlural =
Cache.ServiceLocator.GetInstance<ILexEntryInflTypeRepository>().GetObject(
LexEntryTypeTags.kguidLexTypPluralVar);
var letPst =
Cache.ServiceLocator.GetInstance<ILexEntryInflTypeRepository>().GetObject(
LexEntryTypeTags.kguidLexTypPastVar);
using (var handler = GetComboHandler(sandbox, InterlinLineChoices.kflidLexEntries, 0) as SandboxBase.IhMissingEntry)
{
var sortedMorphItems = handler.MorphItems;
sortedMorphItems.Sort();
// menu items should be ordered according to entryRef.VariantEntryTypesRS
{
var mi0 = sortedMorphItems[0];
Assert.That(mi0.m_inflType, Is.EqualTo(letPst));
Assert.That(mi0.m_nameSense, Is.EqualTo("mainGloss.pst"));
}
{
var mi1 = sortedMorphItems[1];
Assert.That(mi1.m_inflType, Is.EqualTo(letPlural));
Assert.That(mi1.m_nameSense, Is.EqualTo("mainGloss.pl"));
}
}
}
}
public void LexEntriesComboHandler_IndexOfCurrentInflVariant_InflTypeChosen()
{
using (var sandbox = SetupSandbox(() =>
{
const string wff = "variantEntry";
var mockText = MakeText(wff);
var wf = MakeWordform(wff);
var wa = MakeAnalysis(wf);
var options = new MakeBundleOptions();
options.LexEntryForm = wff;
options.MakeMorph = (mff) =>
{
Guid slotType = GetSlotType(mff);
IMoMorphSynAnalysis msa1;
const string mainEntryForm = "mainEntry";
var mainEntry = MakeEntry(mainEntryForm.Replace("-", ""), "V:(Imperative)", slotType, out msa1);
var mainSense = MakeSense(mainEntry, "mainGloss", msa1);
IMoMorphSynAnalysis msa2;
var variantEntry = MakeEntry(mff.Replace("-", ""), "V:(Imperative)", slotType, out msa2);
var letPlural =
Cache.ServiceLocator.GetInstance<ILexEntryInflTypeRepository>().GetObject(
LexEntryTypeTags.kguidLexTypPluralVar);
letPlural.GlossAppend.set_String(Cache.DefaultAnalWs, "pl");
variantEntry.MakeVariantOf(mainSense, letPlural);
return variantEntry.LexemeFormOA;
};
options.MakeSense = (entry) =>
{
var entryRef = entry.EntryRefsOS.First();
return entryRef.ComponentLexemesRS.First() as ILexSense;
};
options.MakeMsa = (sense) => { return sense.MorphoSyntaxAnalysisRA; };
options.MakeInflType = (mf) =>
{
var entry = mf.Owner as ILexEntry;
var entryRef = entry.EntryRefsOS.First();
var vet = entryRef.VariantEntryTypesRS.First() as ILexEntryInflType;
return vet;
};
var wmb = MakeBundle(wa, options);
var para = (IStTxtPara)mockText.ContentsOA.ParagraphsOS[0];
var seg = para.SegmentsOS[0];
seg.AnalysesRS.Add(wa);
return new AnalysisOccurrence(seg, 0);
}))
{
var initialAnalysisStack = sandbox.CurrentAnalysisTree;
using (var handler = GetComboHandler(sandbox, InterlinLineChoices.kflidLexEntries, 0) as SandboxBase.IhMissingEntry)
{
var imorphItemCurrentSandboxState = handler.IndexOfCurrentItem;
var items = handler.MorphItems;
var miCurrentSandboxState = items[imorphItemCurrentSandboxState];
Assert.That(miCurrentSandboxState.m_hvoMorph,
Is.EqualTo(initialAnalysisStack.WfiAnalysis.MorphBundlesOS[0].MorphRA.Hvo));
Assert.That(miCurrentSandboxState.m_hvoSense,
Is.EqualTo(initialAnalysisStack.WfiAnalysis.MorphBundlesOS[0].SenseRA.Hvo));
Assert.That(miCurrentSandboxState.m_hvoMsa,
Is.EqualTo(initialAnalysisStack.WfiAnalysis.MorphBundlesOS[0].MsaRA.Hvo));
var variantEntry = initialAnalysisStack.WfiAnalysis.MorphBundlesOS[0].MorphRA.Owner as ILexEntry;
var variantType = variantEntry.VariantEntryRefs.First().VariantEntryTypesRS.First();
Assert.That(miCurrentSandboxState.m_inflType, Is.EqualTo(variantType));
Assert.That(miCurrentSandboxState.m_hvoMainEntryOfVariant, Is.EqualTo(initialAnalysisStack.WfiAnalysis.MorphBundlesOS[0].SenseRA.Entry.Hvo));
}
}
}
public void LexEntriesComboHandler_ItemsInComboForInflVariant()
{
using (var sandbox = SetupSandbox(() =>
{
const string wff = "blonde";
var mockText = MakeText(wff);
var wf = MakeWordform(wff);
var wa = MakeAnalysis(wf);
var options = new MakeBundleOptions();
options.LexEntryForm = wff;
options.MakeMorph = (mff) =>
{
Guid slotType = GetSlotType(mff);
IMoMorphSynAnalysis msa1;
var mainEntry = MakeEntry("blondEntry", "", slotType, out msa1);
var mainSense = MakeSense(mainEntry, "fair haired", msa1);
IMoMorphSynAnalysis msa2;
var variantEntry = MakeEntry("blondeEntry", "", slotType, out msa2);
ILexEntryType letDialectalVariantType = Cache.ServiceLocator.GetInstance<ILexEntryTypeRepository>().GetObject(LexEntryTypeTags.kguidLexTypDialectalVar);
letDialectalVariantType.Abbreviation.set_String(Cache.DefaultAnalWs, "dial.var. of");
letDialectalVariantType.Name.set_String(Cache.DefaultAnalWs, "Dialectal Variant");
letDialectalVariantType.ReverseAbbr.set_String(Cache.DefaultAnalWs, "dial.var.");
variantEntry.MakeVariantOf(mainSense, letDialectalVariantType);
return variantEntry.LexemeFormOA;
};
options.MakeSense = (entry) =>
{
var entryRef = entry.EntryRefsOS.First();
return entryRef.ComponentLexemesRS.First() as ILexSense;
};
options.MakeMsa = (sense) => { return sense.MorphoSyntaxAnalysisRA; };
var wmb = MakeBundle(wa, options);
var para = (IStTxtPara)mockText.ContentsOA.ParagraphsOS[0];
var seg = para.SegmentsOS[0];
seg.AnalysesRS.Add(wa);
return new AnalysisOccurrence(seg, 0);
}))
{
var initialAnalysisStack = sandbox.CurrentAnalysisTree;
using (var handler = GetComboHandler(sandbox, InterlinLineChoices.kflidLexEntries, 0) as SandboxBase.IhMissingEntry)
{
var imorphItemCurrentSandboxState = handler.IndexOfCurrentItem;
Assert.That(imorphItemCurrentSandboxState, Is.EqualTo(1));
var handlerList = handler.ComboList.Items;
Assert.That(handlerList[0].ToString(), Is.EqualTo("Add New Sense for blondeEntry ..."));
Assert.That(handlerList[1].ToString(), Is.EqualTo(" fair haired, ??? , blondEntry+dial.var."));
Assert.That(handlerList[2].ToString(), Is.EqualTo(" Add New Sense..."));
}
}
}
public void LexEntriesComboHandler_IndexOfCurrentLexSenseAndMsa()
{
using (var sandbox = SetupSandbox(() =>
{
const string wff = "monomorphemicstem";
var mockText = MakeText(wff);
var wf = MakeWordform(wff);
var wa = MakeAnalysis(wf);
var options = new MakeBundleOptions();
options.LexEntryForm = wff;
options.MakeMorph = (mff) =>
{
Guid slotType = GetSlotType(mff);
IMoMorphSynAnalysis msa;
var entry = MakeEntry(mff.Replace("-", ""), "V:(Imperative)", slotType, out msa);
var sense2 = MakeSense(entry, "gloss1", msa);
return entry.LexemeFormOA;
};
options.MakeSense = (entry) =>
{
var msa = entry.MorphoSyntaxAnalysesOC.ToList()[0];
var sense2 = MakeSense(entry, "gloss2", msa);
return sense2;
};
options.MakeMsa = (sense) => { return sense.MorphoSyntaxAnalysisRA; };
var wmb = MakeBundle(wa, options);
var para = (IStTxtPara)mockText.ContentsOA.ParagraphsOS[0];
var seg = para.SegmentsOS[0];
seg.AnalysesRS.Add(wa);
return new AnalysisOccurrence(seg, 0);
}))
{
var initialAnalysisStack = sandbox.CurrentAnalysisTree;
using (var handler = GetComboHandler(sandbox, InterlinLineChoices.kflidLexEntries, 0) as SandboxBase.IhMissingEntry)
{
var imorphItemCurrentSandboxState = handler.IndexOfCurrentItem;
Assert.That(imorphItemCurrentSandboxState, Is.GreaterThan(-1));
var items = handler.MorphItems;
var miCurrentSandboxState = items[imorphItemCurrentSandboxState];
Assert.That(miCurrentSandboxState.m_hvoMorph,
Is.EqualTo(initialAnalysisStack.WfiAnalysis.MorphBundlesOS[0].MorphRA.Hvo));
Assert.That(miCurrentSandboxState.m_hvoSense,
Is.EqualTo(initialAnalysisStack.WfiAnalysis.MorphBundlesOS[0].SenseRA.Hvo));
Assert.That(miCurrentSandboxState.m_hvoMsa,
Is.EqualTo(initialAnalysisStack.WfiAnalysis.MorphBundlesOS[0].MsaRA.Hvo));
Assert.That(miCurrentSandboxState.m_hvoMainEntryOfVariant, Is.EqualTo(0));
}
}
}
