public void CommonSingularNounConstructorTest()
{
var text = "cat";
var target = new CommonSingularNoun(text);
Check.That(target.Text).IsEqualTo(text);
}
public void IndirectReferencesTest()
{
var target = new CommonSingularNoun("dog");
IEnumerable <IReferencer> actual = target.Referencers;
Check.That(actual).IsNotNull().And.IsEmpty();
}
public void GetSynonymsOfNounIsReflexive()
{
var hobby = new CommonSingularNoun("hobby");
var pastime = new CommonSingularNoun("pastime");
Check.That(hobby.GetSynonyms()).Contains("pastime");
Check.That(pastime.GetSynonyms()).Contains("hobby");
}
public void PrepositionOnRightTest()
{
IPrepositionLinkable target = new CommonSingularNoun("bacon");
IPrepositional prepositional = new Preposition("with");
target.BindRightPrepositional(prepositional);
Check.That(target.RightPrepositional).IsEqualTo(prepositional);
}
public void PossessedTest()
{
var target = new CommonSingularNoun("dog");
IEnumerable <IPossessable> actual;
actual = target.Possessions;
Check.That(actual).IsNotNull().And.IsEmpty();
}
public void BindDescriptorTest()
{
var target = new CommonSingularNoun("dog");
IDescriptor descriptor = new Adjective("red");
target.BindDescriptor(descriptor);
Check.That(target.Descriptors).Contains(descriptor).Only();
Check.That(descriptor.Describes).IsEqualTo(target);
}
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 BindDescriberTest()
{
var target = new CommonSingularNoun("dog");
IDescriptor adjective = new Adjective("rambunctious");
target.BindDescriptor(adjective);
Check.That(target.Descriptors).Contains(adjective).Only();
Check.That(adjective.Describes).IsEqualTo(target);
}
public void BindPronounTest()
{
var target = new CommonSingularNoun("dog");
Pronoun pronoun = new PersonalPronoun("it");
target.BindReferencer(pronoun);
Check.That(target.Referencers).Contains(pronoun).Only();
Check.That(pronoun.RefersTo).Contains(target);
}
public void BindDeterminerTest()
{
var target = new CommonSingularNoun("dog");
var determiner = new Determiner("the");
target.BindDeterminer(determiner);
Check.That(target.Determiner).IsEqualTo(determiner);
Check.That(determiner.Determines).IsEqualTo(target);
}
public void BindReferencerTest()
{
var target = new CommonSingularNoun("dog");
var pronoun = new PersonalPronoun("it");
target.BindReferencer(pronoun);
Check.That(target.Referencers).Contains(pronoun).Only();
Check.That(target.Referencers.All(r => r.RefersTo == target || r.RefersTo.Contains(target))).IsTrue();
}
public void SubjectOfTest()
{
var target = new CommonSingularNoun("dog");
IVerbal expected = new SingularPresentVerb("runs");
IVerbal actual;
target.BindAsSubjectOf(expected);
actual = target.SubjectOf;
Check.That(actual).IsEqualTo(expected);
}
public void SuperTaxonomicNounTest()
{
Noun target = new CommonSingularNoun("dog");
Noun expected = new ProperSingularNoun("Highland");
target.PrecedingAdjunctNoun = expected;
Noun actual = target.PrecedingAdjunctNoun;
Check.That(actual).IsEqualTo(expected);
}
public void IndirectObjectOfTest()
{
var target = new CommonSingularNoun("dog");
IVerbal expected = new PastTenseVerb("gave");
target.BindAsIndirectObjectOf(expected);
var actual = target.IndirectObjectOf;
Check.That(actual).IsEqualTo(expected);
}
public void SubTaxonomicNounTest()
{
var target = new CommonSingularNoun("dog");
Noun expected = new CommonSingularNoun("food");
Noun actual;
target.FollowingAdjunctNoun = expected;
actual = target.FollowingAdjunctNoun;
Check.That(actual).IsEqualTo(expected);
}
public void PossessorTest()
{
var target = new CommonSingularNoun("dog");
var possessor = new NounPhrase(new Adjective("Red"), new CommonSingularNoun("Team"));
target.Possessor = possessor;
var actual = target.Possessor;
Check.That(actual).IsEqualTo(possessor);
}
public void QuantifiedByTest()
{
var target = new CommonSingularNoun("dog");
var quantifying = new Quantifier("3");
target.QuantifiedBy = quantifying;
var actual = target.QuantifiedBy;
Check.That(actual).IsEqualTo(quantifying);
Check.That(target.QuantifiedBy.Quantifies).IsEqualTo(target);
}
public void DeterminesTest()
{
var text = "the";
var target = new Determiner(text);
IEntity expected = new CommonSingularNoun("organization");
IEntity actual;
target.Determines = expected;
actual = target.Determines;
Check.That(actual).IsEqualTo(expected);
}
public void DescribesTest()
{
IEnumerable <Word> composedWords = new Word[] { new Adverb("very"), new Adjective("tall") };
var target = new AdjectivePhrase(composedWords);
IEntity expected = new CommonSingularNoun("tree");
IEntity actual;
target.Describes = expected;
actual = target.Describes;
Assert.Equal(expected, actual);
}
public void RefereesTest()
{
var target = new CommonSingularNoun("dog");
IEnumerable <IReferencer> actual;
actual = target.Referencers;
Check.That(actual).IsEmpty();
Pronoun pro = new PersonalPronoun("it");
target.BindReferencer(pro);
Check.That(target.Referencers).Contains(pro).Only();
Check.That(target.Referencers.All(r => r.RefersTo == target || r.RefersTo.Contains(target))).IsTrue();
}
public void DescriptorsTest()
{
var target = new CommonSingularNoun("dog");
Check.That(target.Descriptors).IsEmpty();
var descriptors = new[] { new Adjective("red"), new Adjective("slow") };
foreach (var descriptor in descriptors)
{
target.BindDescriptor(descriptor);
}
var boundDescriptors = target.Descriptors;
Check.That(boundDescriptors).Contains(descriptors).Only();
}
public void DescribesTest()
{
var text = "funny";
var target = new Adjective(text);
IEntity expected = new CommonSingularNoun("man");
IEntity actual;
target.Describes = expected;
actual = target.Describes;
Check.That(actual).IsEqualTo(expected);
expected = new NounPhrase(new Determiner("the"), new CommonSingularNoun("woman"));
target.Describes = expected;
actual = target.Describes;
Check.That(actual).IsEqualTo(expected);
}
public void DescribedByTest()
{
var target = new CommonSingularNoun("dog");
Check.That(target.Descriptors).IsNotNull().And.IsEmpty();
}
public void EntityKindTest()
{
IEntity target = new CommonSingularNoun("cat");
Check.That(target.EntityKind).IsEqualTo(EntityKind.Thing);
}
public void GetSynonymsOfNounIncludesOwnText()
{
Noun ball = new CommonSingularNoun("ball");
Check.That(ball.GetSynonyms().Contains(ball.Text, StringComparer.OrdinalIgnoreCase)).IsTrue();
}
