public void TwoWordKeyTerm()
{
KeyTermMatchBuilder bldr = new KeyTermMatchBuilder(AddMockedKeyTerm("fun stuff"));
Assert.AreEqual(1, bldr.Matches.Count());
VerifyKeyTermMatch(bldr, 0, "fun", "stuff");
}
public void OptionalFinal()
{
KeyTermMatchBuilder bldr = new KeyTermMatchBuilder(AddMockedKeyTerm("kind(ness)"));
Assert.AreEqual(2, bldr.Matches.Count());
VerifyKeyTermMatch(bldr, 0, "kind");
VerifyKeyTermMatch(bldr, 1, "kindness");
}
public void OptionalMiddlePart()
{
KeyTermMatchBuilder bldr = new KeyTermMatchBuilder(AddMockedKeyTerm("anti(dis)establishment"));
Assert.AreEqual(2, bldr.Matches.Count());
VerifyKeyTermMatch(bldr, 0, "antiestablishment");
VerifyKeyTermMatch(bldr, 1, "antidisestablishment");
}
public void OptionalInitialPart()
{
KeyTermMatchBuilder bldr = new KeyTermMatchBuilder(AddMockedKeyTerm("(loving)kindness"));
Assert.AreEqual(2, bldr.Matches.Count());
VerifyKeyTermMatch(bldr, 0, "kindness");
VerifyKeyTermMatch(bldr, 1, "lovingkindness");
}
public void OptionalPhrase()
{
KeyTermMatchBuilder bldr = new KeyTermMatchBuilder(AddMockedKeyTerm("(things of this) life"));
Assert.AreEqual(2, bldr.Matches.Count());
VerifyKeyTermMatch(bldr, 0, "life");
VerifyKeyTermMatch(bldr, 1, "things", "of", "this", "life");
}
public void RealData5()
{
KeyTermMatchBuilder bldr = new KeyTermMatchBuilder(AddMockedKeyTerm("dreadful event or sight"));
Assert.AreEqual(2, bldr.Matches.Count());
VerifyKeyTermMatch(bldr, 0, "dreadful", "event");
VerifyKeyTermMatch(bldr, 1, "dreadful", "sight");
}
public void OptionalMiddleWord()
{
KeyTermMatchBuilder bldr = new KeyTermMatchBuilder(AddMockedKeyTerm("really (fun) stuff"));
Assert.AreEqual(2, bldr.Matches.Count());
VerifyKeyTermMatch(bldr, 0, "really", "stuff");
VerifyKeyTermMatch(bldr, 1, "really", "fun", "stuff");
}
public void RealData9()
{
KeyTermMatchBuilder bldr = new KeyTermMatchBuilder(AddMockedKeyTerm("to be favorably disposed to someone, or to experience an emotion of compassion towards other people"));
Assert.AreEqual(2, bldr.Matches.Count());
VerifyKeyTermMatch(bldr, 0, "be", "favorably", "disposed", "to", "someone");
VerifyKeyTermMatch(bldr, 1, "to", "be", "favorably", "disposed", "to", "someone");
}
public void RealData16()
{
KeyTermMatchBuilder bldr = new KeyTermMatchBuilder(AddMockedKeyTerm("laurustinus; or, pine tree"));
Assert.AreEqual(2, bldr.Matches.Count());
VerifyKeyTermMatch(bldr, 0, "laurustinus");
VerifyKeyTermMatch(bldr, 1, "pine", "tree");
}
public void RealData14()
{
KeyTermMatchBuilder bldr = new KeyTermMatchBuilder(AddMockedKeyTerm("(one's own) burial-place"));
Assert.AreEqual(2, bldr.Matches.Count());
VerifyKeyTermMatch(bldr, 0, "burial-place");
VerifyKeyTermMatch(bldr, 1, "one's", "own", "burial-place");
}
public void RealData12()
{
KeyTermMatchBuilder bldr = new KeyTermMatchBuilder(AddMockedKeyTerm("olive oil (used as food"));
Assert.AreEqual(2, bldr.Matches.Count());
VerifyKeyTermMatch(bldr, 0, "olive", "oil");
VerifyKeyTermMatch(bldr, 1, "olive", "oil", "used", "as", "food");
}
public void TwoWordKeyTermWithImplicitOptionalInfinitiveMarker()
{
KeyTermMatchBuilder bldr = new KeyTermMatchBuilder(AddMockedKeyTerm("to cry"));
Assert.AreEqual(2, bldr.Matches.Count());
VerifyKeyTermMatch(bldr, 0, "cry");
VerifyKeyTermMatch(bldr, 1, "to", "cry");
}
public void RealDataWithOr1()
{
KeyTermMatchBuilder bldr = new KeyTermMatchBuilder(AddMockedKeyTerm("courtyard or sheepfold"));
Assert.AreEqual(2, bldr.Matches.Count());
VerifyKeyTermMatch(bldr, 0, "courtyard");
VerifyKeyTermMatch(bldr, 1, "sheepfold");
}
public void RealData6()
{
KeyTermMatchBuilder bldr = new KeyTermMatchBuilder(AddMockedKeyTerm("exempt, free from"));
Assert.AreEqual(2, bldr.Matches.Count());
VerifyKeyTermMatch(bldr, 0, "exempt");
VerifyKeyTermMatch(bldr, 1, "free", "from");
}
public void RealData8()
{
KeyTermMatchBuilder bldr = new KeyTermMatchBuilder(AddMockedKeyTerm("state of fearing, standing in awe"));
Assert.AreEqual(2, bldr.Matches.Count());
VerifyKeyTermMatch(bldr, 0, "state", "of", "fearing");
VerifyKeyTermMatch(bldr, 1, "standing", "in", "awe");
}
public void RealData4()
{
KeyTermMatchBuilder bldr = new KeyTermMatchBuilder(AddMockedKeyTerm("Canaanean = Zealot"));
Assert.AreEqual(2, bldr.Matches.Count());
VerifyKeyTermMatch(bldr, 0, "canaanean");
VerifyKeyTermMatch(bldr, 1, "zealot");
}
public void OptionalTrailingWord()
{
KeyTermMatchBuilder bldr = new KeyTermMatchBuilder(AddMockedKeyTerm("morning (star)"));
Assert.AreEqual(2, bldr.Matches.Count());
VerifyKeyTermMatch(bldr, 0, "morning");
VerifyKeyTermMatch(bldr, 1, "morning", "star");
}
public void RealData1()
{
KeyTermMatchBuilder bldr = new KeyTermMatchBuilder(AddMockedKeyTerm("worm, maggot"));
Assert.AreEqual(2, bldr.Matches.Count());
VerifyKeyTermMatch(bldr, 0, "worm");
VerifyKeyTermMatch(bldr, 1, "maggot");
}
public void RealData15()
{
KeyTermMatchBuilder bldr = new KeyTermMatchBuilder(AddMockedKeyTerm("bridal chamber (marriage bed)"));
Assert.AreEqual(2, bldr.Matches.Count());
VerifyKeyTermMatch(bldr, 0, "bridal", "chamber");
VerifyKeyTermMatch(bldr, 1, "bridal", "chamber", "marriage", "bed");
}
public void RealDataWithOr2()
{
KeyTermMatchBuilder bldr = new KeyTermMatchBuilder(AddMockedKeyTerm("give up or lay aside what one possesses"));
Assert.AreEqual(2, bldr.Matches.Count());
VerifyKeyTermMatch(bldr, 0, "give", "up", "what", "one", "possesses");
VerifyKeyTermMatch(bldr, 1, "lay", "aside", "what", "one", "possesses");
}
public void RealData13()
{
KeyTermMatchBuilder bldr = new KeyTermMatchBuilder(AddMockedKeyTerm("(Lord, LORD, God of) hosts"));
Assert.AreEqual(3, bldr.Matches.Count());
VerifyKeyTermMatch(bldr, 0, "hosts");
VerifyKeyTermMatch(bldr, 1, "lord", "of", "hosts");
VerifyKeyTermMatch(bldr, 2, "god", "of", "hosts");
}
public void RealData2()
{
KeyTermMatchBuilder bldr = new KeyTermMatchBuilder(AddMockedKeyTerm("castor oil plant (FF 106, 107)"));
Assert.LessOrEqual(1, bldr.Matches.Count());
VerifyKeyTermMatch(bldr, 0, "castor", "oil", "plant");
// Ideally, we don't want to get anything for the junk in parentheses, but it
// shouldn't really hurt anything, so we'll live with it.
}
public void ThreeWordPhrasesSeparatedWithOr()
{
KeyTermMatchBuilder bldr = new KeyTermMatchBuilder(AddMockedKeyTerm("to remove the state of guilt or uncleanness from oneself"));
Assert.AreEqual(4, bldr.Matches.Count());
VerifyKeyTermMatch(bldr, 0, true, "remove", "the", "state", "of", "guilt");
VerifyKeyTermMatch(bldr, 1, "to", "remove", "the", "state", "of", "guilt");
VerifyKeyTermMatch(bldr, 2, "remove", "the", "uncleanness", "from", "oneself");
VerifyKeyTermMatch(bldr, 3, "to", "remove", "the", "uncleanness", "from", "oneself");
}
public void RealDataWithEmptyParentheses()
{
KeyTermMatchBuilder bldr = new KeyTermMatchBuilder(AddMockedKeyTerm("receive, welcome; pay attention to, recognize ()"));
Assert.AreEqual(4, bldr.Matches.Count());
VerifyKeyTermMatch(bldr, 0, "receive");
VerifyKeyTermMatch(bldr, 1, "welcome");
VerifyKeyTermMatch(bldr, 2, "pay", "attention", "to");
VerifyKeyTermMatch(bldr, 3, "recognize");
}
public void RealData3()
{
KeyTermMatchBuilder bldr = new KeyTermMatchBuilder(AddMockedKeyTerm("(loving)kindness, solidarity, joint liability, grace"));
Assert.AreEqual(5, bldr.Matches.Count());
VerifyKeyTermMatch(bldr, 0, "kindness");
VerifyKeyTermMatch(bldr, 1, "lovingkindness");
VerifyKeyTermMatch(bldr, 2, "solidarity");
VerifyKeyTermMatch(bldr, 3, "joint", "liability");
VerifyKeyTermMatch(bldr, 4, "grace");
}
public void RealData10()
{
KeyTermMatchBuilder bldr = new KeyTermMatchBuilder(AddMockedKeyTerm("to recompense, to reward, to pay"));
Assert.AreEqual(6, bldr.Matches.Count());
VerifyKeyTermMatch(bldr, 0, "recompense");
VerifyKeyTermMatch(bldr, 1, "to", "recompense");
VerifyKeyTermMatch(bldr, 2, "reward");
VerifyKeyTermMatch(bldr, 3, "to", "reward");
VerifyKeyTermMatch(bldr, 4, "pay");
VerifyKeyTermMatch(bldr, 5, "to", "pay");
}
public void RuleToExcludeTermCompletely()
{
Dictionary <string, KeyTermRule> rules = new Dictionary <string, KeyTermRule>();
KeyTermRule rule = new KeyTermRule();
rule.id = "Jesus";
rule.Rule = KeyTermRule.RuleType.Exclude;
rules[rule.id] = rule;
KeyTermMatchBuilder bldr = new KeyTermMatchBuilder(AddMockedKeyTerm("Jesus"),
new ReadonlyDictionary <string, KeyTermRule>(rules), null);
Assert.AreEqual(0, bldr.Matches.Count());
}
public void RealData11()
{
KeyTermMatchBuilder bldr = new KeyTermMatchBuilder(AddMockedKeyTerm("to lift up (one's hand, heart, or soul) = to worship, pray"));
Assert.AreEqual(7, bldr.Matches.Count());
VerifyKeyTermMatch(bldr, 0, "lift", "up");
VerifyKeyTermMatch(bldr, 1, "to", "lift", "up");
VerifyKeyTermMatch(bldr, 2, "lift", "up", "one's", "hand", "heart", "soul");
VerifyKeyTermMatch(bldr, 3, "to", "lift", "up", "one's", "hand", "heart", "soul");
VerifyKeyTermMatch(bldr, 4, "worship");
VerifyKeyTermMatch(bldr, 5, "to", "worship");
VerifyKeyTermMatch(bldr, 6, "pray");
}
public void RuleToExcludeTermBasedOnRegularExpression()
{
Regex regexRule = new Regex(@".*\(div1 type=", RegexOptions.Compiled);
KeyTermMatchBuilder bldr = new KeyTermMatchBuilder(
AddMockedKeyTerm("(qal) crush; (pi) crush to pieces; (pu) be crushed to pieces; (hi) scatter; (ho) be crushed to pieces, be scattered.(div1 type=letter id=LET.12)(head)ל"), null,
new[] { regexRule });
Assert.AreEqual(0, bldr.Matches.Count());
bldr = new KeyTermMatchBuilder(
AddMockedKeyTerm("(qal) crumble.(div1 type=letter id=LET.18)(head)ץ"), null,
new[] { regexRule });
Assert.AreEqual(0, bldr.Matches.Count());
}
public void RuleToKeepOriginalTermAndAddAnAlternate()
{
Dictionary <string, KeyTermRule> rules = new Dictionary <string, KeyTermRule>();
KeyTermRule rule = new KeyTermRule();
rule.id = "Jesus";
rule.Alternates = new [] { new KeyTermRulesKeyTermRuleAlternate() };
rule.Alternates[0].Name = "Jesus Christ";
rules[rule.id] = rule;
KeyTermMatchBuilder bldr = new KeyTermMatchBuilder(AddMockedKeyTerm("Jesus"),
new ReadonlyDictionary <string, KeyTermRule>(rules), null);
Assert.AreEqual(2, bldr.Matches.Count());
VerifyKeyTermMatch(bldr, 0, "jesus", "christ");
VerifyKeyTermMatch(bldr, 1, "jesus");
}
