public virtual void section14_Test()
{
Lexicon lexicon = Lexicon.DefaultLexicon; // default simplenlg lexicon
NLGFactory nlgFactory = new NLGFactory(lexicon); // factory based on lexicon
Realiser realiser = new Realiser(lexicon);
SPhraseSpec p1 = nlgFactory.createClause("Mary", "chase", "the monkey");
SPhraseSpec p2 = nlgFactory.createClause("The monkey", "fight back");
SPhraseSpec p3 = nlgFactory.createClause("Mary", "be", "nervous");
DocumentElement s1 = nlgFactory.createSentence(p1);
DocumentElement s2 = nlgFactory.createSentence(p2);
DocumentElement s3 = nlgFactory.createSentence(p3);
DocumentElement par1 = nlgFactory.createParagraph(new List <DocumentElement> {
s1, s2, s3
});
string output14a = realiser.realise(par1).Realisation;
Assert.AreEqual("Mary chases the monkey. The monkey fights back. Mary is nervous.\n\n", output14a);
DocumentElement section = nlgFactory.createSection("The Trials and Tribulation of Mary and the Monkey");
section.addComponent(par1);
string output14b = realiser.realise(section).Realisation;
Assert.AreEqual(
"The Trials and Tribulation of Mary and the Monkey\nMary chases the monkey. The monkey fights back. Mary is nervous.\n\n",
output14b);
}
public virtual void section13_Test()
{
Lexicon lexicon = Lexicon.DefaultLexicon; // default simplenlg lexicon
NLGFactory nlgFactory = new NLGFactory(lexicon); // factory based on lexicon
Realiser realiser = new Realiser(lexicon);
SPhraseSpec s1 = nlgFactory.createClause("my cat", "like", "fish");
SPhraseSpec s2 = nlgFactory.createClause("my dog", "like", "big bones");
SPhraseSpec s3 = nlgFactory.createClause("my horse", "like", "grass");
CoordinatedPhraseElement c = nlgFactory.createCoordinatedPhrase();
c.addCoordinate(s1);
c.addCoordinate(s2);
c.addCoordinate(s3);
string outputA = realiser.realiseSentence(c);
Assert.AreEqual("My cat likes fish, my dog likes big bones and my horse likes grass.", outputA);
SPhraseSpec p = nlgFactory.createClause("I", "be", "happy");
SPhraseSpec q = nlgFactory.createClause("I", "eat", "fish");
q.setFeature(Feature.COMPLEMENTISER, "because");
q.setFeature(Feature.TENSE, Tense.PAST);
p.addComplement(q);
string outputB = realiser.realiseSentence(p);
Assert.AreEqual("I am happy because I ate fish.", outputB);
}
public virtual void multipleNLGElementListRealiserTest()
{
List <NLGElement> elements = new List <NLGElement>();
// Create test NLGElements to realize:
// "The cat jumping on the counter."
DocumentElement sentence1 = nlgFactory.createSentence();
NPPhraseSpec subject_1 = nlgFactory.createNounPhrase("the", "cat");
VPPhraseSpec verb_1 = nlgFactory.createVerbPhrase("jump");
verb_1.setFeature(Feature.FORM, Form.PRESENT_PARTICIPLE);
PPPhraseSpec prep_1 = nlgFactory.createPrepositionPhrase();
NPPhraseSpec object_1 = nlgFactory.createNounPhrase();
object_1.setDeterminer("the");
object_1.setNoun("counter");
prep_1.addComplement(object_1);
prep_1.setPreposition("on");
SPhraseSpec clause_1 = nlgFactory.createClause();
clause_1.setSubject(subject_1);
clause_1.VerbPhrase = verb_1;
clause_1.setObject(prep_1);
sentence1.addComponent(clause_1);
// "The dog running on the counter."
DocumentElement sentence2 = nlgFactory.createSentence();
NPPhraseSpec subject_2 = nlgFactory.createNounPhrase("the", "dog");
VPPhraseSpec verb_2 = nlgFactory.createVerbPhrase("run");
verb_2.setFeature(Feature.FORM, Form.PRESENT_PARTICIPLE);
PPPhraseSpec prep_2 = nlgFactory.createPrepositionPhrase();
NPPhraseSpec object_2 = nlgFactory.createNounPhrase();
object_2.setDeterminer("the");
object_2.setNoun("counter");
prep_2.addComplement(object_2);
prep_2.setPreposition("on");
SPhraseSpec clause_2 = nlgFactory.createClause();
clause_2.setSubject(subject_2);
clause_2.VerbPhrase = verb_2;
clause_2.setObject(prep_2);
sentence2.addComponent(clause_2);
elements.Add(sentence1);
elements.Add(sentence2);
IList <NLGElement> realisedElements = realiser.realise(elements);
Assert.IsNotNull(realisedElements);
Assert.AreEqual(2, realisedElements.Count);
Assert.AreEqual("The cat jumping on the counter.", realisedElements[0].Realisation);
Assert.AreEqual("The dog running on the counter.", realisedElements[1].Realisation);
}
public virtual void xmlLexiconImmutabilityTest()
{
NLGFactory factory = new NLGFactory(lexicon);
Realiser realiser = new Realiser(lexicon);
// "wall" is singular.
NPPhraseSpec wall = factory.createNounPhrase("the", "wall");
Assert.AreEqual(NumberAgreement.SINGULAR, wall.getFeature(Feature.NUMBER));
// Realise a sentence with plural form of "wall"
wall.Plural = true;
SPhraseSpec sentence = factory.createClause("motion", "observe");
sentence.setFeature(Feature.TENSE, Tense.PAST);
PPPhraseSpec pp = factory.createPrepositionPhrase("in", wall);
sentence.addPostModifier(pp);
realiser.realiseSentence(sentence);
// Create a new 'the wall' NP and check to make sure that the syntax processor has
// not propagated plurality to the canonical XMLLexicon WordElement object.
wall = factory.createNounPhrase("the", "wall");
Assert.AreEqual(NumberAgreement.SINGULAR, wall.getFeature(Feature.NUMBER));
}
public virtual void section8_Test()
{
Lexicon lexicon = Lexicon.DefaultLexicon; // default simplenlg lexicon
NLGFactory nlgFactory = new NLGFactory(lexicon); // factory based on lexicon
Realiser realiser = new Realiser(lexicon);
NPPhraseSpec subject = nlgFactory.createNounPhrase("Mary");
NPPhraseSpec @object = nlgFactory.createNounPhrase("the monkey");
VPPhraseSpec verb = nlgFactory.createVerbPhrase("chase");
subject.addModifier("fast");
SPhraseSpec p = nlgFactory.createClause();
p.setSubject(subject);
p.setVerb(verb);
p.setObject(@object);
string outputA = realiser.realiseSentence(p);
Assert.AreEqual("Fast Mary chases the monkey.", outputA);
verb.addModifier("quickly");
string outputB = realiser.realiseSentence(p);
Assert.AreEqual("Fast Mary quickly chases the monkey.", outputB);
}
public void variantsTest()
{
var lexicon = Lexicon.getDefaultLexicon(); // default simplenlg lexicon
var nlgFactory = new NLGFactory(lexicon); // factory based on lexicon
var realiser = new Realiser(lexicon);
var p = nlgFactory.createClause();
p.setSubject("my dog");
p.setVerb("is"); // variant of be
p.setObject("George");
var output = realiser.realiseSentence(p);
Assert.AreEqual("My dog is George.", output);
p = nlgFactory.createClause();
p.setSubject("my dog");
p.setVerb("chases"); // variant of chase
p.setObject("George");
output = realiser.realiseSentence(p);
Assert.AreEqual("My dog chases George.", output);
p = nlgFactory.createClause();
p.setSubject(nlgFactory.createNounPhrase("the", "dogs")); // variant of "dog"
p.setVerb("is"); // variant of be
p.setObject("happy"); // variant of happy
output = realiser.realiseSentence(p);
Assert.AreEqual("The dog is happy.", output);
p = nlgFactory.createClause();
p.setSubject(nlgFactory.createNounPhrase("the", "children")); // variant of "child"
p.setVerb("is"); // variant of be
p.setObject("happy"); // variant of happy
output = realiser.realiseSentence(p);
Assert.AreEqual("The child is happy.", output);
// following functionality is enabled
p = nlgFactory.createClause();
p.setSubject(nlgFactory.createNounPhrase("the", "dogs")); // variant of "dog"
p.setVerb("is"); // variant of be
p.setObject("happy"); // variant of happy
output = realiser.realiseSentence(p);
Assert.AreEqual("The dog is happy.", output); //corrected automatically
}
public override void RunCommand(object sender)
{
var engine = (IAutomationEngineInstance)sender;
Lexicon lexicon = Lexicon.getDefaultLexicon();
NLGFactory nlgFactory = new NLGFactory(lexicon);
SPhraseSpec p = nlgFactory.createClause();
p.AddAppInstance(engine, v_InstanceName);
}
public async override Task RunCommand(object sender)
{
var engine = (IAutomationEngineInstance)sender;
Lexicon lexicon = Lexicon.getDefaultLexicon();
NLGFactory nlgFactory = new NLGFactory(lexicon);
SPhraseSpec p = nlgFactory.createClause();
new OBAppInstance(v_InstanceName, p).SetVariableValue(engine, v_InstanceName);
}
public virtual void section6A_Test()
{
Lexicon lexicon = Lexicon.DefaultLexicon; // default simplenlg lexicon
NLGFactory nlgFactory = new NLGFactory(lexicon); // factory based on lexicon
Realiser realiser = new Realiser(lexicon);
SPhraseSpec p = nlgFactory.createClause();
p.setSubject("Mary");
p.setVerb("chase");
p.setObject("the monkey");
p.setFeature(Feature.TENSE, Tense.PAST);
string output = realiser.realiseSentence(p);
Assert.AreEqual("Mary chased the monkey.", output);
p.setFeature(Feature.TENSE, Tense.FUTURE);
output = realiser.realiseSentence(p);
Assert.AreEqual("Mary will chase the monkey.", output);
p.setFeature(Feature.NEGATED, true);
output = realiser.realiseSentence(p);
Assert.AreEqual("Mary will not chase the monkey.", output);
p = nlgFactory.createClause();
p.setSubject("Mary");
p.setVerb("chase");
p.setObject("the monkey");
p.setFeature(Feature.INTERROGATIVE_TYPE, InterrogativeType.YES_NO);
output = realiser.realiseSentence(p);
Assert.AreEqual("Does Mary chase the monkey?", output);
p.setSubject("Mary");
p.setVerb("chase");
p.setFeature(Feature.INTERROGATIVE_TYPE, InterrogativeType.WHO_OBJECT);
output = realiser.realiseSentence(p);
Assert.AreEqual("Who does Mary chase?", output);
}
public virtual void spellingVariantsInVPTest()
{
WordElement eth = (WordElement)factory.createWord("etherise",
new LexicalCategory(LexicalCategory.LexicalCategoryEnum.VERB));
Assert.AreEqual("etherize", eth.DefaultSpellingVariant);
eth.DefaultSpellingVariant = "etherise";
Assert.AreEqual("etherise", eth.DefaultSpellingVariant);
SPhraseSpec s = factory.createClause(factory.createNounPhrase("the", "doctor"), eth,
factory.createNounPhrase("the patient"));
Assert.AreEqual("the doctor etherises the patient", realiser.realise(s).Realisation);
}
public void section5A_Test()
{
var lexicon = Lexicon.getDefaultLexicon(); // default simplenlg lexicon
var nlgFactory = new NLGFactory(lexicon); // factory based on lexicon
var realiser = new Realiser(lexicon);
var p = nlgFactory.createClause();
p.setSubject("Mary");
p.setVerb("chase");
p.setObject("the monkey");
var output = realiser.realiseSentence(p);
Assert.AreEqual("Mary chases the monkey.", output);
} // testSection5A
public virtual void section5_Test()
{
Lexicon lexicon = Lexicon.DefaultLexicon; // default simplenlg lexicon
NLGFactory nlgFactory = new NLGFactory(lexicon); // factory based on lexicon
Realiser realiser = new Realiser(lexicon);
SPhraseSpec p = nlgFactory.createClause();
p.setSubject("my dog");
p.setVerb("chase");
p.setObject("George");
string output = realiser.realiseSentence(p);
Assert.AreEqual("My dog chases George.", output);
}
public static void Main(string[] args)
{
var ss = new XMLLexicon();
var Factory = new NLGFactory(ss);
var Realiser = new Realiser(ss);
// Instructions will be given to you by the director.
var verbp = Factory.createVerbPhrase("be given");
verbp.setFeature(Feature.TENSE.ToString(), Tense.FUTURE);
var subj = Factory.createNounPhrase("The Director");
var oobj = Factory.createNounPhrase("Instruction");
var ioobj = Factory.createNounPhrase("you");
subj.setPlural(false);
oobj.setPlural(true);
var s = new List <INLGElement>()
{
verbp, subj, oobj, ioobj
};
var clause = Factory.createClause();
clause.setVerb(verbp);
clause.setSubject(subj);
clause.setObject(oobj);
clause.setIndirectObject(ioobj);
var sentence = Factory.createSentence(clause);
sentence.setFeature(Feature.TENSE.ToString(), Tense.FUTURE);
var active = Realiser.realise(sentence).ToString();
Console.WriteLine($"{active}");
Console.WriteLine("done");
Console.ReadLine();
}
public virtual void testWhatObjectInterrogative()
{
Lexicon lexicon = Lexicon.DefaultLexicon;
NLGFactory nlg = new NLGFactory(lexicon);
Realiser realiser = new Realiser(lexicon);
// Case 1, no object is explicitly given:
SPhraseSpec clause = nlg.createClause("you", "think");
PPPhraseSpec aboutJohn = nlg.createPrepositionPhrase("about", "John");
clause.addPostModifier(aboutJohn);
clause.setFeature(Feature.INTERROGATIVE_TYPE, InterrogativeType.WHAT_OBJECT);
string realisation = realiser.realiseSentence(clause);
Console.WriteLine(realisation);
Assert.AreEqual("What do you think about John?", realisation);
// Case 2:
// Add "bad things" as the object so the object doesn't remain null:
clause.setObject("bad things");
realisation = realiser.realiseSentence(clause);
Console.WriteLine(realiser.realiseSentence(clause));
Assert.AreEqual("What do you think about John?", realisation);
}
/**
* Unwrap a <code>simplenlg.xmlrealiser.wrapper.NLGElement</code> and map it
* to a <code>simplenlg.framework.NLGElement</code>
*
* @param wps
* The wrapper object
* @return the NLGElement
*/
public virtual NLGElement UnwrapNLGElement(wrapper.XmlNLGElement wps)
{
if (wps == null)
{
return(null);
}
if (wps is wrapper.XmlDocumentElement)
{
return((NLGElement)UnwrapDocumentElement((wrapper.XmlDocumentElement)wps));
}
// Handle coordinate phrase specs first, which will cause recursion.
NLGElement cp = UnwrapCoordinatePhraseSpec(wps);
if (cp != null)
{
return(cp);
}
// Literal text.
if (wps is wrapper.XmlStringElement)
{
wrapper.XmlStringElement wp = (wrapper.XmlStringElement)wps;
NLGElement p = factory.createStringElement(wp.Val);
return(p);
}
// WordElements (delegate to UnwrapWordElement) -- useful to have
// because it is called by unWrapPhraseComponents, and pre/post mods
// might be WordElements
if (wps is XmlWordElement)
{
return(UnwrapWordElement((XmlWordElement)wps));
}
// Sentence
else if (wps is wrapper.XmlSPhraseSpec)
{
wrapper.XmlSPhraseSpec wp = (wrapper.XmlSPhraseSpec)wps;
SPhraseSpec sp = factory.createClause();
NLGElement vp = null;
List <NLGElement> subjects = new List <NLGElement>();
foreach (wrapper.XmlNLGElement p in wp.Subj)
{
NLGElement p1 = UnwrapNLGElement(p);
checkFunction(DiscourseFunction.SUBJECT, p1);
subjects.Add(p1);
}
if (subjects.Any())
{
sp.setFeature(InternalFeature.SUBJECTS, subjects);
}
if (wp.Vp != null)
{
vp = UnwrapNLGElement(wp.Vp);
sp.VerbPhrase = vp;
}
if (wp.CuePhrase != null)
{
NLGElement cue = UnwrapNLGElement(wp.CuePhrase);
cue.setFeature(InternalFeature.DISCOURSE_FUNCTION, DiscourseFunction.CUE_PHRASE);
sp.setFeature(Feature.CUE_PHRASE, cue);
}
if (wp.COMPLEMENTISER != null)
{
sp.setFeature(Feature.COMPLEMENTISER, wp.COMPLEMENTISER);
}
setSFeatures(wp, sp, vp);
// Common phrase components.
UnwrapPhraseComponents(sp, wps);
return(sp);
}
// Phrases
else if (wps is wrapper.XmlPhraseElement)
{
wrapper.XmlPhraseElement we = (wrapper.XmlPhraseElement)wps;
PhraseElement hp = null;
XmlWordElement w = we.Head;
NLGElement head = UnwrapWordElement(w);
// NLGElement head;
// simplenlg.xmlrealiser.wrapper.XmlNLGElement w =
// we.getHeadstring();
// check whether we have a stringelement or wordelement as head
// if(w == null) {
// w = we.getHeadword();
// head = UnwrapWordElement((XmlWordElement) w);
//
// } else {
// head = factory.createStringElement(((XmlStringElement)
// w).getVal());
// }
// Noun Phrase
if (wps is wrapper.XmlNPPhraseSpec)
{
wrapper.XmlNPPhraseSpec wp = (wrapper.XmlNPPhraseSpec)wps;
NPPhraseSpec p = factory.createNounPhrase(head);
hp = p;
if (wp.Spec != null)
{
// p.setSpecifier(UnwrapWordElement(wp.getSpec()));
wrapper.XmlNLGElement spec = wp.Spec;
if (spec is XmlWordElement)
{
WordElement specifier = (WordElement)UnwrapWordElement((XmlWordElement)spec);
if (specifier != null)
{
p.setSpecifier(specifier);
}
}
else
{
p.setSpecifier(UnwrapNLGElement(spec));
}
}
setNPFeatures(wp, p);
}
// Adjective Phrase
else if (wps is wrapper.XmlAdjPhraseSpec)
{
wrapper.XmlAdjPhraseSpec wp = (wrapper.XmlAdjPhraseSpec)wps;
AdjPhraseSpec p = factory.createAdjectivePhrase(head);
hp = p;
p.setFeature(Feature.IS_COMPARATIVE, wp.ISCOMPARATIVE);
p.setFeature(Feature.IS_SUPERLATIVE, wp.ISSUPERLATIVE);
}
// Prepositional Phrase
else if (wps is wrapper.XmlPPPhraseSpec)
{
PPPhraseSpec p = factory.createPrepositionPhrase(head);
hp = p;
}
// Adverb Phrase
else if (wps is wrapper.XmlAdvPhraseSpec)
{
wrapper.XmlAdvPhraseSpec wp = (wrapper.XmlAdvPhraseSpec)wps;
AdvPhraseSpec p = factory.createAdverbPhrase();
p.setHead(head);
hp = p;
p.setFeature(Feature.IS_COMPARATIVE, wp.ISCOMPARATIVE);
p.setFeature(Feature.IS_SUPERLATIVE, wp.ISSUPERLATIVE);
}
// Verb Phrase
else if (wps is wrapper.XmlVPPhraseSpec)
{
wrapper.XmlVPPhraseSpec wp = (wrapper.XmlVPPhraseSpec)wps;
VPPhraseSpec p = factory.createVerbPhrase(head);
hp = p;
setVPFeatures(wp, p);
}
// Common phrase components.
UnwrapPhraseComponents(hp, wps);
// set the discourse function, if defined
if (we.DiscourseFunction != null)
{
DiscourseFunction func;
Enum.TryParse(we.DiscourseFunction.ToString(), out func);
hp.setFeature(InternalFeature.DISCOURSE_FUNCTION, func);
}
// check the appositive feature
bool?appositive = we.Appositive;
if (appositive != null)
{
hp.setFeature(Feature.APPOSITIVE, appositive);
}
return(hp);
}
return(null);
}
