public void ToStringTest()
{
var target = new NounPhrase(new ProperSingularNoun("LASI"), new Conjunction("and"), new ProperSingularNoun("Timmy"));
var expected = "NounPhrase \"LASI and Timmy\"";
Check.That(target.ToString()).IsEqualTo(expected);
}
private static Label CreateLabelForWeightedView(NounPhrase nounPhrase)
{
var gender = nounPhrase.GetGender();
var label = new Label
{
Tag = nounPhrase,
Content = $"Weight : {nounPhrase.Weight} \"{nounPhrase.Text}\"",
Foreground = Brushes.Black,
Padding = new Thickness(1, 1, 1, 1),
ContextMenu = new ContextMenu(),
ToolTip = $"{nounPhrase.GetType().Name}{(gender.IsMaleOrFemale() ? "\nprevialing gender: " + gender : string.Empty)}"
};
var menuItem1 = new MenuItem {
Header = "View definition"
};
menuItem1.Click += (s, e) => Process.Start(string.Format("http://www.dictionary.reference.com/browse/{0}?s=t", nounPhrase.Text));
label.ContextMenu.Items.Add(menuItem1);
var menuItem2 = new MenuItem {
Header = "Copy"
};
menuItem2.Click += (s, e) => Clipboard.SetText((label.Tag as ILexical).Text);
label.ContextMenu.Items.Add(menuItem2);
return(label);
}
public void IsMaleFullTest()
{
var np = new NounPhrase(new ProperSingularNoun("Patrick"), new ProperPluralNoun("Roberts"));
Check.That(np.IsFullMaleName()).IsTrue();
Check.That(np.IsFullFemaleName()).IsFalse();
}
public void GetPhrasesAfterTest()
{
var startAfter = new NounPhrase(new Adjective("blue"), new CommonSingularNoun("team"));
IEnumerable <Sentence> sentences = new Sentence[] {
new Sentence(new Clause[] {
new Clause(new NounPhrase(new PersonalPronoun("We")),
new VerbPhrase(new ModalAuxilary("must"), new BaseVerb("attack")),
startAfter)
},
SentenceEnding.ExclamationPoint),
new Sentence(new Clause[] { new Clause(new Phrase[] {
new NounPhrase(new PersonalPronoun("We")),
new VerbPhrase(new ModalAuxilary("must"), new BaseVerb("do")),
new NounPhrase(new PersonalPronoun("this")),
new AdverbPhrase(new Adverb("quickly"))
}) },
SentenceEnding.ExclamationPoint)
};
var paragraphKind = ParagraphKind.Default;
var target = new Paragraph(paragraphKind, sentences);
var expected = sentences.Phrases().SkipWhile(p => p != startAfter).Skip(1);
IEnumerable <Phrase> actual;
actual = target.GetPhrasesAfter(startAfter);
Check.That(actual).ContainsExactly(expected);
}
public static IEnumerable <Stack <Token> > ReductionOptions(this IEnumerable <Token> proposedStack)
{
var stack = proposedStack.ToArray();
for (var j = 1; j <= stack.Length && j <= 4; j++)
{
var head = stack.Subarray(0, j);
var tail = stack.Subarray(j, stack.Length - j);
if (Sentence.Propose(head))
{
var possibleStack = new List <Token>();
possibleStack.Add(new Sentence(head));
possibleStack.AddRange(tail);
yield return(possibleStack.ToStack());
}
if (VerbPhrase.Propose(head))
{
var possibleStack = new List <Token>();
possibleStack.Add(new VerbPhrase(head));
possibleStack.AddRange(tail);
yield return(possibleStack.ToStack());
}
if (NounPhrase.Propose(head))
{
var possibleStack = new List <Token>();
possibleStack.Add(new NounPhrase(head));
possibleStack.AddRange(tail);
yield return(possibleStack.ToStack());
}
}
}
public void IsFemaleFullTest()
{
var noun = new NounPhrase(new ProperSingularNoun("Julia"), new ProperPluralNoun("Roberts"));
Check.That(noun.IsFullFemaleName()).IsTrue();
Check.That(noun.IsFullMaleName()).IsFalse();
}
public void BindObjectOfPrepositionTest()
{
var target = new ParticlePhrase(new Particle("about"));
ILexical prepositionalObject = new NounPhrase(new Determiner("the"), new CommonSingularNoun("house"));
target.BindObject(prepositionalObject);
Check.That(target.BoundObject).IsEqualTo(prepositionalObject);
}
public void BindIndirectObjectTest()
{
var target = CreateIInderectObjectTaker();
IEntity indirectObject = new NounPhrase(new PossessivePronoun("my"), new CommonSingularNoun("friend"));
target.BindIndirectObject(indirectObject);
Check.That(indirectObject).Satisfies(target.IndirectObjects.Contains).And.Satisfies(target.AggregateIndirectObject.Contains);
}
public void BindReferencerTest()
{
var target = new NounPhrase(new Determiner("the"), new Adjective("large"), new CommonSingularNoun("elephant"));
IReferencer pro = new RelativePronoun("which");
target.BindReferencer(pro);
Check.That(target.Referencers.All(r => r.RefersTo.Contains(target))).IsTrue();
}
public void FullNameGenderIsSameAsFirstNameGender()
{
var patrickRoberts = new NounPhrase(new ProperSingularNoun("Patrick"), new ProperPluralNoun("Roberts"));
var patrick = new ProperSingularNoun("Patrick");
Check.That(patrickRoberts.GetGender()).IsEqualTo(patrick.GetGender());
Check.That(((IEntity)patrickRoberts).GetGender()).IsEqualTo(patrick.GetGender());
}
public void FullNameWithPrefixGenderIsSameAsFirstNameGender()
{
var patrick = new ProperSingularNoun("Patrick");
var drPatrickRachels = new NounPhrase(new ProperSingularNoun("Dr."), new ProperSingularNoun("Patrick"), new ProperPluralNoun("Rachels"));
Check.That(drPatrickRachels.GetGender()).IsEqualTo(patrick.Gender);
}
void BindBuiltupAdjectivePhrases(NounPhrase phrase)
{
foreach (var adjp in this.lastAdjectivals)
{
phrase.BindDescriptor(adjp);
}
this.lastAdjectivals.Clear();
}
public void BindDirectObjectTest()
{
var target = CreateVerbPhrase();
IEntity directObject = new NounPhrase(new Determiner("the"), new CommonSingularNoun("forest"));
target.BindDirectObject(directObject);
Check.That(target.HasDirectObject(e => e == directObject)).IsTrue();
}
public void BindDescriberTest()
{
var target = new NounPhrase(new ProperPluralNoun("Americans"), new Conjunction("and"), new ProperPluralNoun("Canadians"));
IDescriptor adj = new AdjectivePhrase(new CommonSingularNoun("peace"), new PresentParticiple("loving"));
target.BindDescriptor(adj);
Check.That(target.Descriptors).Contains(adj);
}
public void ItemTest2()
{
var target = CreatePhraseTagsetMap();
Phrase phrase = new NounPhrase(new PersonalPronoun("he"));
string actual;
actual = target[phrase];
Check.That("NP").IsEqualTo(actual);
}
public void AddPossessionTest()
{
var target = new CommonSingularNoun("dog");
IEntity possession = new NounPhrase(new CommonSingularNoun("chew"), new CommonSingularNoun("toy"));
target.AddPossession(possession);
Check.That(target.Possessions).Contains(possession);
Check.That(possession.Possessor).IsEqualTo(target);
}
public void AddPossessionTest()
{
var target = new NounPhrase(new ProperPluralNoun("Americans"), new Conjunction("and"), new ProperPluralNoun("Canadians"));
IEntity possession = new NounPhrase(new Adverb("relatively"), new Adjective("affluent"), new CommonPluralNoun("lifestyles"));
target.AddPossession(possession);
Check.That(target.Possessions).Contains(possession);
Check.That(possession.Possessor).IsEqualTo(target);
}
public void BindPronounTest()
{
var target = new NounPhrase(new ProperPluralNoun("Americans"), new Conjunction("and"), new ProperPluralNoun("Canadians"));
Pronoun pro = new PersonalPronoun("they");
target.BindReferencer(pro);
Check.That(target.Referencers).Contains(pro);
Check.That(pro.RefersTo).Contains(target);
}
public void BindDescriptorTest()
{
var target = new NounPhrase(new Determiner("the"), new Adjective("large"), new CommonSingularNoun("elephants"));
IDescriptor descriptor = new Adjective("hungry");
target.BindDescriptor(descriptor);
Check.That(target.Descriptors).Contains(descriptor);
Check.That(descriptor.Describes).IsEqualTo(target);
}
public void NounPhraseTest1()
{
var actual = false;
var target = new NounPhrase(new Determiner("The"), new CommonSingularNoun("truth"));
target.MatchSequence()
.Case((Determiner d, IEntity e) => actual = true);
Check.That(actual).IsTrue();
}
public void BindObjectOfPrepositionTest()
{
var text = "about";
var target = new Particle(text);
ILexical prepositionalObject = new NounPhrase(new[] { new ProperSingularNoun("Ayn"), new ProperSingularNoun("Rand") });
target.BindObject(prepositionalObject);
Check.That(target.BoundObject).IsEqualTo(prepositionalObject);
}
public void BindObjectOfPrepositionTest()
{
var text = "into";
var target = new Preposition(text);
ILexical prepositionalObject = new NounPhrase(new Determiner("the"), new CommonSingularNoun("drawer"));
target.BindObject(prepositionalObject);
Check.That(target.BoundObject).IsEqualTo(prepositionalObject);
}
public void OnLeftSideTest()
{
var target = new PrepositionalPhrase(new Preposition("for"));
ILexical expected = new NounPhrase(new PersonalPronoun("it"));
ILexical actual;
target.ToTheLeftOf = expected;
actual = target.ToTheLeftOf;
Check.That(actual).IsEqualTo(expected);
}
public void ToTheLeftOfTest()
{
var target = new PrepositionalPhrase(new Preposition("on"));
ILexical expected = new NounPhrase(new Determiner("the"), new CommonSingularNoun("table"));
ILexical actual;
target.ToTheLeftOf = expected;
actual = target.ToTheLeftOf;
Assert.Equal(expected, actual);
}
public void ToTheRightOfTest()
{
var target = new ParticlePhrase(new Particle("off"), new Preposition("of"));
ILexical expected = new NounPhrase(new Determiner("the"), new CommonSingularNoun("world"));
ILexical actual;
target.ToTheRightOf = expected;
actual = target.ToTheRightOf;
Check.That(actual).IsEqualTo(expected);
}
public void InnerAttributiveTest()
{
var target = new NounPhrase(new ProperSingularNoun("Felis"));
var expected = new NounPhrase(new ProperSingularNoun("Catus"));
NounPhrase actual;
target.InnerAttributive = expected;
actual = target.InnerAttributive;
Check.That(actual).IsEqualTo(expected);
}
public void DirectObjectOfTest()
{
var target = new NounPhrase(new ProperPluralNoun("Americans"), new Conjunction("and"), new ProperPluralNoun("Canadians"));
IVerbal expected = new BaseVerb("insult");
target.BindAsDirectObjectOf(expected);
var actual = target.DirectObjectOf;
Check.That(actual).IsEqualTo(expected);
}
public void AttachObjectViaPrepositionTest()
{
var target = new VerbPhrase(new BaseVerb("consume"));
IPrepositional prepositional = new Preposition("with");
ILexical prepositionalObject = new NounPhrase(new Adjective("great"), new CommonSingularNoun("haste"));
prepositional.BindObject(prepositionalObject);
target.AttachObjectViaPreposition(prepositional);
Check.That(target.ObjectOfThePreposition).IsEqualTo(prepositionalObject);
}
public void AggregateEntityConstructorTest1()
{
IEntity americans = new NounPhrase(new ProperPluralNoun("Americans"));
IEntity canadians = new NounPhrase(new ProperPluralNoun("Canadians"));
var target = new AggregateEntity(americans, canadians);
Check.That(target).Contains(americans);
Check.That(target).Contains(canadians);
}
public void BindDirectObjectTest()
{
var text = "gave";
Verb target = new PastTenseVerb(text);
IEntity directObject = new NounPhrase(new Determiner("a"), new CommonSingularNoun("cake"));
target.BindDirectObject(directObject);
Check.That(target.DirectObjects).Contains(directObject).And.HasSize(1);
}
