public void ExpectedGuess_MultipleAnalyses_EquallyApproved_NoneInTexts()
{
using (var setup = new AnalysisGuessBaseSetup(Cache))
{
var newAnalysisWag1 = WordAnalysisOrGlossServices.CreateNewAnalysisWAG(setup.Words_para0[1]);
var newAnalysisWag2 = WordAnalysisOrGlossServices.CreateNewAnalysisWAG(setup.Words_para0[1]);
var newAnalysis1 = newAnalysisWag1.Analysis;
var newAnalysis2 = newAnalysisWag2.Analysis;
setup.UserAgent.SetEvaluation(newAnalysis1, Opinions.approves);
setup.UserAgent.SetEvaluation(newAnalysis2, Opinions.approves);
var guessActual = setup.GuessServices.GetBestGuess(setup.Words_para0[1]);
Assert.AreNotEqual(new NullWAG(), guessActual);
}
}
public void ExpectedGuess_MultipleAnalyses_PreferUserAgentGuessOverMatchingEntryGuess()
{
using (var setup = new AnalysisGuessBaseSetup(Cache, AnalysisGuessBaseSetup.Flags.PartsOfSpeech))
{
// create an affix entry
var expectedMatch = setup.EntryFactory.Create("a", "astem", SandboxGenericMSA.Create(MsaType.kStem, setup.Pos_noun));
// expect a guess to be generated
setup.GuessServices.GenerateEntryGuesses(setup.StText);
// create user approved guess
var newWagUserApproves = WordAnalysisOrGlossServices.CreateNewAnalysisWAG(setup.Words_para0[1]);
setup.UserAgent.SetEvaluation(newWagUserApproves.Analysis, Opinions.approves);
var guessActual = setup.GuessServices.GetBestGuess(setup.Words_para0[1]);
Assert.AreEqual(newWagUserApproves.Analysis, guessActual);
}
}
public void NoExpectedGuessForAnalysis_NoAnalyses()
{
// don't make any analyses. so we don't expect any guesses.
using (var setup = new AnalysisGuessBaseSetup(Cache))
{
var guessActual = setup.GuessServices.GetBestGuess(setup.Words_para0[1]);
Assert.AreEqual(new NullWAG(), guessActual);
}
}
public void ExpectedGuessForAnalysis_OneGloss_NoOpinion()
{
using (var setup = new AnalysisGuessBaseSetup(Cache))
{
var newWagGloss = WordAnalysisOrGlossServices.CreateNewAnalysisTreeGloss(setup.Words_para0[1]);
setup.UserAgent.SetEvaluation(newWagGloss.WfiAnalysis, Opinions.noopinion); // should be equivalent to no evaluation.
var guessActual = setup.GuessServices.GetBestGuess(newWagGloss.WfiAnalysis);
Assert.AreEqual(newWagGloss.Gloss, guessActual);
}
}
public void ExpectedAnalysisGuess_ForSentenceInitialUppercaseWithAnalysis()
{
using (var setup = new AnalysisGuessBaseSetup(Cache))
{
var newWagUppercase = WordAnalysisOrGlossServices.CreateNewAnalysisTreeGloss(setup.Words_para0[0]);
WordAnalysisOrGlossServices.CreateNewAnalysisTreeGloss(setup.Words_para0[1]);
var wagUppercase = new TestModAnalysisOccurrence(setup.Para0.SegmentsOS[0], 0, newWagUppercase.WfiAnalysis);
var guessActual = setup.GuessServices.GetBestGuess(wagUppercase);
Assert.AreEqual(newWagUppercase.Gloss, guessActual);
}
}
public void ExpectedAnalysisGuessForAnalysis_PreferFrequentGlossOverLessFrequentGloss()
{
using (var setup = new AnalysisGuessBaseSetup(Cache))
{
var newWagFrequentGloss = WordAnalysisOrGlossServices.CreateNewAnalysisTreeGloss(setup.Words_para0[1]);
var newWagLessFrequentGloss = WordAnalysisOrGlossServices.CreateNewAnalysisTreeGloss(setup.Words_para0[1]);
setup.Para0.SetAnalysis(0, 1, newWagLessFrequentGloss.Gloss);
setup.Para0.SetAnalysis(0, 2, newWagFrequentGloss.Gloss);
setup.Para0.SetAnalysis(0, 3, newWagFrequentGloss.Gloss);
setup.UserAgent.SetEvaluation(newWagLessFrequentGloss.WfiAnalysis, Opinions.approves);
setup.UserAgent.SetEvaluation(newWagFrequentGloss.WfiAnalysis, Opinions.approves);
var guessActual = setup.GuessServices.GetBestGuess(newWagFrequentGloss.WfiAnalysis);
Assert.AreEqual(newWagFrequentGloss.Gloss, guessActual);
}
}
public void ExpectedGuessForWord_MatchingEntry()
{
using (var setup = new AnalysisGuessBaseSetup(Cache, AnalysisGuessBaseSetup.Flags.PartsOfSpeech))
{
// create an affix entry
var newEntry1 = setup.EntryFactory.Create("a-", "aPrefix", SandboxGenericMSA.Create(MsaType.kInfl, null));
var newEntry2 = setup.EntryFactory.Create("-a", "aSuffix", SandboxGenericMSA.Create(MsaType.kDeriv, null));
var newEntry3 = setup.EntryFactory.Create("-a-", "aInfix", SandboxGenericMSA.Create(MsaType.kUnclassified, null));
var newEntry4_expectedMatch = setup.EntryFactory.Create("a", "astem", SandboxGenericMSA.Create(MsaType.kStem, setup.Pos_noun));
var newEntry5 = setup.EntryFactory.Create("a", "aroot", SandboxGenericMSA.Create(MsaType.kRoot, null));
// expect a guess to be generated
setup.GuessServices.GenerateEntryGuesses(setup.StText);
var guessActual = setup.GuessServices.GetBestGuess(setup.Words_para0[1]);
Assert.AreNotEqual(new NullWAG(), guessActual);
Assert.AreEqual(newEntry4_expectedMatch.LexemeFormOA.Form.BestVernacularAlternative.Text, guessActual.Wordform.Form.BestVernacularAlternative.Text);
Assert.AreEqual(1, guessActual.Analysis.MorphBundlesOS.Count);
Assert.AreEqual(newEntry4_expectedMatch.LexemeFormOA, guessActual.Analysis.MorphBundlesOS[0].MorphRA);
Assert.AreEqual(newEntry4_expectedMatch.SensesOS[0], guessActual.Analysis.MorphBundlesOS[0].SenseRA);
Assert.AreEqual(newEntry4_expectedMatch.SensesOS[0].MorphoSyntaxAnalysisRA, guessActual.Analysis.MorphBundlesOS[0].MsaRA);
Assert.AreEqual(newEntry4_expectedMatch.SensesOS[0].Gloss.BestAnalysisAlternative.Text,
guessActual.Analysis.MeaningsOC.First().Form.BestAnalysisAlternative.Text);
Assert.AreEqual(setup.Pos_noun, guessActual.Analysis.CategoryRA);
int cAnalyses = Cache.ServiceLocator.GetInstance<IWfiAnalysisRepository>().Count;
Assert.AreEqual(1, cAnalyses, "Should have only generated one computer guess analysis.");
}
}
public void ExpectedAnalysisGuess_ForSentenceInitialPositionUpperCaseAlternative()
{
using (var setup = new AnalysisGuessBaseSetup(Cache))
{
var newWagUppercase = WordAnalysisOrGlossServices.CreateNewAnalysisWAG(setup.Words_para0[0]);
var wagUppercase = new AnalysisOccurrence(setup.Para0.SegmentsOS[0],0);
var guessActual = setup.GuessServices.GetBestGuess(wagUppercase);
Assert.AreEqual(newWagUppercase.Analysis, guessActual);
}
}
public void NoExpectedGuessForWord_DontMatchBoundedStemOrRoot()
{
using (var setup = new AnalysisGuessBaseSetup(Cache))
{
var morphTypeRepository = Cache.ServiceLocator.GetInstance<IMoMorphTypeRepository>();
var morphTypeBoundedRoot = morphTypeRepository.GetObject(MoMorphTypeTags.kguidMorphBoundRoot);
var morphTypeBoundedStem = morphTypeRepository.GetObject(MoMorphTypeTags.kguidMorphBoundStem);
// first make sure these types don't care about prefix/postfix markers
morphTypeBoundedRoot.Prefix = morphTypeBoundedRoot.Postfix = null;
morphTypeBoundedStem.Prefix = morphTypeBoundedStem.Postfix = null;
// create an affix entry
var newEntry1 = setup.EntryFactory.Create("a-", "aPrefix", SandboxGenericMSA.Create(MsaType.kInfl, null));
var newEntry2 = setup.EntryFactory.Create("-a", "aSuffix", SandboxGenericMSA.Create(MsaType.kDeriv, null));
var newEntry3 = setup.EntryFactory.Create("-a-", "aInfix", SandboxGenericMSA.Create(MsaType.kUnclassified, null));
var boundedStem = setup.EntryFactory.Create(morphTypeBoundedStem, TsStringUtils.MakeTss("a", Cache.DefaultVernWs),
"aboundedstem", SandboxGenericMSA.Create(MsaType.kStem, null));
var boundedRoot = setup.EntryFactory.Create(morphTypeBoundedRoot, TsStringUtils.MakeTss("a", Cache.DefaultVernWs),
"aboundedroot", SandboxGenericMSA.Create(MsaType.kRoot, null));
// try to generate analyses for matching entries (should have no results)
setup.GuessServices.GenerateEntryGuesses(setup.StText);
int cAnalyses = Cache.ServiceLocator.GetInstance<IWfiAnalysisRepository>().Count;
Assert.AreEqual(0, cAnalyses, "Should not have generated guesses.");
// make sure we don't actually make a guess.
var guessActual = setup.GuessServices.GetBestGuess(setup.Words_para0[1]);
Assert.AreEqual(new NullWAG(), guessActual);
}
}
public void NoExpectedGuessForAnalysis_DisapprovesParserApprovedAnalysis()
{
using (var setup = new AnalysisGuessBaseSetup(Cache))
{
var newWag = WordAnalysisOrGlossServices.CreateNewAnalysisWAG(setup.Words_para0[1]);
var newAnalysis = newWag.Analysis;
setup.ParserAgent.SetEvaluation(newAnalysis, Opinions.approves);
setup.UserAgent.SetEvaluation(newAnalysis, Opinions.disapproves);
var guessActual = setup.GuessServices.GetBestGuess(newWag.Analysis);
Assert.AreEqual(new NullWAG(), guessActual);
}
}
public void NoExpectedGuessForWord_NoMatchingEntries()
{
using (var setup = new AnalysisGuessBaseSetup(Cache))
{
// create an affix entry
var newEntry1= setup.EntryFactory.Create("a-", "aPrefix", SandboxGenericMSA.Create(MsaType.kInfl, null));
var newEntry2 = setup.EntryFactory.Create("-a", "aSuffix", SandboxGenericMSA.Create(MsaType.kDeriv, null));
var newEntry3 = setup.EntryFactory.Create("-a-", "aInfix", SandboxGenericMSA.Create(MsaType.kUnclassified, null));
var newEntry4 = setup.EntryFactory.Create("ay", "Astem", SandboxGenericMSA.Create(MsaType.kStem, null));
var newEntry5 = setup.EntryFactory.Create("ay", "Aroot", SandboxGenericMSA.Create(MsaType.kRoot, null));
// try to generate analyses for matching entries (should have no results)
setup.GuessServices.GenerateEntryGuesses(setup.StText);
int cAnalyses = Cache.ServiceLocator.GetInstance<IWfiAnalysisRepository>().Count;
Assert.AreEqual(0, cAnalyses, "Should not have generated guesses.");
// make sure we don't actually make a guess.
var guessActual = setup.GuessServices.GetBestGuess(setup.Words_para0[1]);
Assert.AreEqual(new NullWAG(), guessActual);
}
}
public void NoExpectedGuessForWord_DisapprovesHumanAnalysisOfGloss()
{
using (var setup = new AnalysisGuessBaseSetup(Cache))
{
var newGlossWag = WordAnalysisOrGlossServices.CreateNewAnalysisTreeGloss(setup.Words_para0[1]);
setup.UserAgent.SetEvaluation(newGlossWag.WfiAnalysis, Opinions.disapproves);
var guessActual = setup.GuessServices.GetBestGuess(setup.Words_para0[1]);
Assert.AreEqual(new NullWAG(), guessActual);
}
}
public void NoExpectedGuessForAnalysis_NoGlosses()
{
// make two analyses, but don't make any glosses. so we don't expect any guesses for one of the analyses.
using (var setup = new AnalysisGuessBaseSetup(Cache))
{
var newAnalysisWag = WordAnalysisOrGlossServices.CreateNewAnalysisWAG(setup.Words_para0[1]);
var newAnalysisWag2 = WordAnalysisOrGlossServices.CreateNewAnalysisWAG(setup.Words_para0[1]);
var guessActual = setup.GuessServices.GetBestGuess(newAnalysisWag2.Analysis);
Assert.AreEqual(new NullWAG(), guessActual);
}
}
public void ExpectedGuess_MultipleAnalyses_PreferOneApprovedInTextToMatchingEntry()
{
using (var setup = new AnalysisGuessBaseSetup(Cache, AnalysisGuessBaseSetup.Flags.PartsOfSpeech))
{
// create an affix entry
var expectedMatch = setup.EntryFactory.Create("a", "astem", SandboxGenericMSA.Create(MsaType.kStem, setup.Pos_noun));
// expect a guess to be generated
setup.GuessServices.GenerateEntryGuesses(setup.StText);
// create user approved guess
var newWagInText = WordAnalysisOrGlossServices.CreateNewAnalysisWAG(setup.Words_para0[1]);
// set the analysis at the appropriate location to be the one we created.
setup.Para0.SetAnalysis(0, 1, newWagInText.Analysis);
var guessActual = setup.GuessServices.GetBestGuess(setup.Words_para0[1]);
Assert.AreEqual(newWagInText.Analysis, guessActual);
}
}
public void ExpectedGuessForWord_MatchingVariantOfEntry()
{
using (var setup = new AnalysisGuessBaseSetup(Cache,
AnalysisGuessBaseSetup.Flags.PartsOfSpeech, AnalysisGuessBaseSetup.Flags.VariantEntryTypes))
{
// create an affix entry
var mainEntry = setup.EntryFactory.Create("aMain", "astem", SandboxGenericMSA.Create(MsaType.kStem, setup.Pos_noun));
ILexEntryRef ler1 = mainEntry.CreateVariantEntryAndBackRef(setup.Vet_DialectalVariant, TsStringUtils.MakeTss("a", Cache.DefaultVernWs));
var variantOfEntry = ler1.OwnerOfClass<ILexEntry>();
// try to generate analyses for matching entries (should have no results)
setup.GuessServices.GenerateEntryGuesses(setup.StText);
var guessVariantOfEntry = setup.GuessServices.GetBestGuess(setup.Words_para0[1]);
Assert.AreNotEqual(new NullWAG(), guessVariantOfEntry);
Assert.AreEqual(1, guessVariantOfEntry.Analysis.MorphBundlesOS.Count);
Assert.AreEqual(variantOfEntry.LexemeFormOA, guessVariantOfEntry.Analysis.MorphBundlesOS[0].MorphRA);
Assert.AreEqual(mainEntry.SensesOS[0], guessVariantOfEntry.Analysis.MorphBundlesOS[0].SenseRA);
Assert.AreEqual(mainEntry.SensesOS[0].MorphoSyntaxAnalysisRA, guessVariantOfEntry.Analysis.MorphBundlesOS[0].MsaRA);
Assert.AreEqual(mainEntry.SensesOS[0].Gloss.BestAnalysisAlternative.Text,
guessVariantOfEntry.Analysis.MeaningsOC.First().Form.BestAnalysisAlternative.Text);
Assert.AreEqual(setup.Pos_noun, guessVariantOfEntry.Analysis.CategoryRA);
int cAnalyses = Cache.ServiceLocator.GetInstance<IWfiAnalysisRepository>().Count;
Assert.AreEqual(1, cAnalyses, "Should have only generated one computer guess analysis.");
}
}
public void ExpectedAnalysisGuess_MultipleAnalyses_PreferAnalysisInText()
{
using (var setup = new AnalysisGuessBaseSetup(Cache))
{
var newWagOutsideTexts = WordAnalysisOrGlossServices.CreateNewAnalysisTreeGloss(setup.Words_para0[1]);
var newWagInText = WordAnalysisOrGlossServices.CreateNewAnalysisWAG(setup.Words_para0[1]);
// set the analysis at the appropriate location to be the one we created.
setup.Para0.SetAnalysis(0, 1, newWagInText.Analysis);
var guessActual = setup.GuessServices.GetBestGuess(setup.Words_para0[1]);
Assert.AreEqual(newWagInText.Analysis, guessActual);
}
}
public void ExpectedGuessForWord_MatchingVariantHavingSense()
{
using (var setup = new AnalysisGuessBaseSetup(Cache,
AnalysisGuessBaseSetup.Flags.PartsOfSpeech, AnalysisGuessBaseSetup.Flags.VariantEntryTypes))
{
// create an affix entry
var mainEntry = setup.EntryFactory.Create("aMain", "astem", SandboxGenericMSA.Create(MsaType.kStem, setup.Pos_noun));
ILexEntryRef ler = mainEntry.CreateVariantEntryAndBackRef(setup.Vet_FreeVariant, TsStringUtils.MakeTss("a", Cache.DefaultVernWs));
var variantOfEntry = ler.OwnerOfClass<ILexEntry>();
// make the variant have it's own gloss...should take precendence over main entry gloss info (cf. LT-9681)
var senseFactory = Cache.ServiceLocator.GetInstance<ILexSenseFactory>();
senseFactory.Create(variantOfEntry, SandboxGenericMSA.Create(MsaType.kStem, setup.Pos_verb), "variantOfSenseGloss");
// try to generate analyses for matching entries (should have no results)
setup.GuessServices.GenerateEntryGuesses(setup.StText);
var guessVariantOfSense = setup.GuessServices.GetBestGuess(setup.Words_para0[1]);
Assert.AreNotEqual(new NullWAG(), guessVariantOfSense);
Assert.AreEqual(1, guessVariantOfSense.Analysis.MorphBundlesOS.Count);
// (LT-9681) Not sure how the MorphRA/SenseRA/MsaRA data should be represented for this case.
// typically for variants, MorphRA points to the variant, and SenseRA points to the primary entry's sense.
// in this case, perhaps the SenseRA should point to the variant's sense.
Assert.AreEqual(variantOfEntry.LexemeFormOA, guessVariantOfSense.Analysis.MorphBundlesOS[0].MorphRA);
Assert.AreEqual(variantOfEntry.SensesOS[0], guessVariantOfSense.Analysis.MorphBundlesOS[0].SenseRA);
Assert.AreEqual(variantOfEntry.SensesOS[0].MorphoSyntaxAnalysisRA, guessVariantOfSense.Analysis.MorphBundlesOS[0].MsaRA);
Assert.AreEqual(variantOfEntry.SensesOS[0].Gloss.BestAnalysisAlternative.Text,
guessVariantOfSense.Analysis.MeaningsOC.First().Form.BestAnalysisAlternative.Text);
Assert.AreEqual(setup.Pos_noun, guessVariantOfSense.Analysis.CategoryRA);
int cAnalyses = Cache.ServiceLocator.GetInstance<IWfiAnalysisRepository>().Count;
Assert.AreEqual(1, cAnalyses, "Should have only generated one computer guess analysis.");
}
}
public void ExpectedAnalysisGuess_ForSentenceInitialOnlyLowercase()
{
using (var setup = new AnalysisGuessBaseSetup(Cache))
{
var wagUppercaseB = WordAnalysisOrGlossServices.CreateNewAnalysisWAG(setup.Words_para0[5]);
var wagLowercaseB = new AnalysisOccurrence(setup.Para0.SegmentsOS[1], 0);
var guessActual = setup.GuessServices.GetBestGuess(wagLowercaseB);
Assert.AreEqual(new NullWAG(), guessActual);
}
}
public void ExpectedGuessForAnalysis_OneGloss_HumanApprovesAnalysis()
{
using (var setup = new AnalysisGuessBaseSetup(Cache))
{
var newWagGloss = WordAnalysisOrGlossServices.CreateNewAnalysisTreeGloss(setup.Words_para0[1]);
setup.UserAgent.SetEvaluation(newWagGloss.WfiAnalysis, Opinions.approves);
var guessActual = setup.GuessServices.GetBestGuess(newWagGloss.WfiAnalysis);
Assert.AreEqual(newWagGloss.Gloss, guessActual);
}
}
public void ExpectedAnalysisGuessForWord_GlossOfApprovedAnalysis()
{
using (var setup = new AnalysisGuessBaseSetup(Cache))
{
var newWagApproves = WordAnalysisOrGlossServices.CreateNewAnalysisTreeGloss(setup.Words_para0[1]);
// set the analysis at the appropriate location to be the one we created.
setup.Para0.SetAnalysis(0, 1, newWagApproves.Gloss);
setup.UserAgent.SetEvaluation(newWagApproves.WfiAnalysis, Opinions.approves);
var guessActual = setup.GuessServices.GetBestGuess(setup.Words_para0[1]);
Assert.AreEqual(newWagApproves.Gloss, guessActual);
}
}
public void ExpectedGuess_OneAnalysis_NoOpinion()
{
using (var setup = new AnalysisGuessBaseSetup(Cache))
{
var newWag = WordAnalysisOrGlossServices.CreateNewAnalysisWAG(setup.Words_para0[1]);
var newAnalysis = newWag.Analysis;
setup.UserAgent.SetEvaluation(newAnalysis, Opinions.noopinion);
var guessActual = setup.GuessServices.GetBestGuess(setup.Words_para0[1]);
Assert.AreEqual(newWag.Analysis, guessActual);
}
}
public void ExpectedGuess_MultipleAnalyses_MostApprovedAfterDisapproved()
{
using (var setup = new AnalysisGuessBaseSetup(Cache))
{
var newWagDisapproved = WordAnalysisOrGlossServices.CreateNewAnalysisWAG(setup.Words_para0[1]);
var newWagApproved = WordAnalysisOrGlossServices.CreateNewAnalysisWAG(setup.Words_para0[1]);
setup.UserAgent.SetEvaluation(newWagDisapproved.Analysis, Opinions.disapproves);
setup.UserAgent.SetEvaluation(newWagApproved.Analysis, Opinions.approves);
var guessActual = setup.GuessServices.GetBestGuess(setup.Words_para0[1]);
Assert.AreEqual(newWagApproved.Analysis, guessActual);
}
}
public void ExpectedGuess_PreferUserApprovedAnalysisOverParserApprovedAnalysis()
{
using (var setup = new AnalysisGuessBaseSetup(Cache))
{
var newWagParserApproves = WordAnalysisOrGlossServices.CreateNewAnalysisWAG(setup.Words_para0[1]);
var newWagHumanApproves = WordAnalysisOrGlossServices.CreateNewAnalysisWAG(setup.Words_para0[1]);
setup.ParserAgent.SetEvaluation(newWagParserApproves.Analysis, Opinions.approves);
setup.UserAgent.SetEvaluation(newWagHumanApproves.Analysis, Opinions.approves);
var guessActual = setup.GuessServices.GetBestGuess(setup.Words_para0[1]);
Assert.AreEqual(newWagHumanApproves.Analysis, guessActual);
}
}
