public void novelliTest() { // Nicole Novelli's test SPhraseSpec p = SetupForExternalTest.phraseFactory.createClause( "Mary", "chase", "George"); PPPhraseSpec pp = SetupForExternalTest.phraseFactory.createPrepositionPhrase( "in", "the park"); p.addPostModifier(pp); Assert.AreEqual("Mary chases George in the park", SetupForExternalTest.realiser .realise(p).getRealisation()); // another question from Nicole SPhraseSpec run = SetupForExternalTest.phraseFactory.createClause( "you", "go", "running"); run.setFeature(Feature.MODAL.ToString(), "should"); run.addPreModifier("really"); SPhraseSpec think = SetupForExternalTest.phraseFactory.createClause("I", "think"); think.setObject(run); run.setFeature(Feature.SUPRESSED_COMPLEMENTISER.ToString(), true); var text = SetupForExternalTest.realiser.realise(think).getRealisation(); Assert.AreEqual("I think you should really go running", text); }
public void dwightTest() { // Rachel Dwight's test SetupForExternalTest.phraseFactory.setLexicon(SetupForExternalTest.lexicon); NPPhraseSpec noun4 = SetupForExternalTest.phraseFactory .createNounPhrase("FGFR3 gene in every cell"); noun4.setSpecifier("the"); PPPhraseSpec prep1 = SetupForExternalTest.phraseFactory.createPrepositionPhrase( "of", noun4); NPPhraseSpec noun1 = SetupForExternalTest.phraseFactory.createNounPhrase( "the", "patient's mother"); NPPhraseSpec noun2 = SetupForExternalTest.phraseFactory.createNounPhrase( "the", "patient's father"); NPPhraseSpec noun3 = SetupForExternalTest.phraseFactory .createNounPhrase("changed copy"); noun3.addPreModifier("one"); noun3.addComplement(prep1); var coordNoun1 = new CoordinatedPhraseElement( noun1, noun2); coordNoun1.setConjunction("or"); VPPhraseSpec verbPhrase1 = SetupForExternalTest.phraseFactory.createVerbPhrase("have"); verbPhrase1.setFeature(Feature.TENSE.ToString(), Tense.PRESENT); SPhraseSpec sentence1 = SetupForExternalTest.phraseFactory.createClause(coordNoun1, verbPhrase1, noun3); Assert .AreEqual( "the patient's mother or the patient's father has one changed copy of the FGFR3 gene in every cell", SetupForExternalTest.realiser.realise(sentence1).getRealisation()); // Rachel's second test noun3 = SetupForExternalTest.phraseFactory.createNounPhrase("a", "gene test"); noun2 = SetupForExternalTest.phraseFactory.createNounPhrase("an", "LDL test"); noun1 = SetupForExternalTest.phraseFactory.createNounPhrase("the", "clinic"); verbPhrase1 = SetupForExternalTest.phraseFactory.createVerbPhrase("perform"); var coord1 = new CoordinatedPhraseElement(noun2, noun3); sentence1 = SetupForExternalTest.phraseFactory.createClause(noun1, verbPhrase1, coord1); sentence1.setFeature(Feature.TENSE.ToString(), Tense.PAST); Assert .AreEqual( "the clinic performed an LDL test and a gene test", SetupForExternalTest.realiser .realise(sentence1).getRealisation()); }
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 testSPhraseSpec() { // simple test of methods SPhraseSpec c1 = (SPhraseSpec)phraseFactory.createClause(); c1.setVerb("give"); c1.setSubject("John"); c1.setObject("an apple"); c1.setIndirectObject("Mary"); c1.setFeature(Feature.TENSE, Tense.PAST); c1.setFeature(Feature.NEGATED, true); // check getXXX methods Assert.AreEqual("give", getBaseForm(c1.getVerb())); Assert.AreEqual("John", getBaseForm(c1.getSubject())); Assert.AreEqual("an apple", getBaseForm(c1.getObject())); Assert.AreEqual("Mary", getBaseForm(c1.getIndirectObject())); Assert.AreEqual("John did not give Mary an apple", realiser.realise(c1).Realisation); //$NON-NLS-1$ // test modifier placement SPhraseSpec c2 = (SPhraseSpec)phraseFactory.createClause(); c2.setVerb("see"); c2.setSubject("the man"); c2.setObject("me"); c2.addModifier("fortunately"); c2.addModifier("quickly"); c2.addModifier("in the park"); // try setting tense directly as a feature c2.setFeature(Feature.TENSE, Tense.PAST); Assert.AreEqual("fortunately the man quickly saw me in the park", realiser.realise(c2).Realisation); //$NON-NLS-1$ }
public virtual void testCommaSeparatedFrontModifiers() { NPPhraseSpec subject = phraseFactory.createNounPhrase("I"); NPPhraseSpec @object = phraseFactory.createNounPhrase("a bag"); SPhraseSpec _s1 = phraseFactory.createClause(subject, "carry", @object); // add a PP complement PPPhraseSpec pp1 = phraseFactory.createPrepositionPhrase("on", phraseFactory.createNounPhrase("most", "Tuesdays")); _s1.addFrontModifier(pp1); PPPhraseSpec pp2 = phraseFactory.createPrepositionPhrase("since", phraseFactory.createNounPhrase("1991")); _s1.addFrontModifier(pp2); pp1.setFeature(Feature.APPOSITIVE, true); pp2.setFeature(Feature.APPOSITIVE, true); //without setCommaSepCuephrase Assert.AreEqual("on most Tuesdays since 1991 I carry a bag", realiser.realise(_s1).Realisation); //with setCommaSepCuephrase realiser.CommaSepCuephrase = true; Assert.AreEqual("on most Tuesdays, since 1991, I carry a bag", realiser.realise(_s1).Realisation); }
public virtual void testNoDoubledCommas() { NPPhraseSpec subject = phraseFactory.createNounPhrase("I"); NPPhraseSpec @object = phraseFactory.createNounPhrase("a bag"); SPhraseSpec _s1 = phraseFactory.createClause(subject, "carry", @object); PPPhraseSpec pp1 = phraseFactory.createPrepositionPhrase("on", phraseFactory.createNounPhrase("most", "Tuesdays")); _s1.addFrontModifier(pp1); PPPhraseSpec pp2 = phraseFactory.createPrepositionPhrase("since", phraseFactory.createNounPhrase("1991")); PPPhraseSpec pp3 = phraseFactory.createPrepositionPhrase("except", phraseFactory.createNounPhrase("yesterday")); pp2.setFeature(Feature.APPOSITIVE, true); pp3.setFeature(Feature.APPOSITIVE, true); pp1.addPostModifier(pp2); pp1.addPostModifier(pp3); realiser.CommaSepCuephrase = true; Assert.AreEqual("on most Tuesdays, since 1991, except yesterday, I carry a bag", realiser.realise(_s1).Realisation); // without my fix (that we're testing here), you'd end up with // "on most Tuesdays, since 1991,, except yesterday, I carry a bag" }
public virtual void testPassiveWithPPMod() { // passive with just complement NPPhraseSpec subject = phraseFactory.createNounPhrase("wave"); subject.setFeature(Feature.NUMBER, NumberAgreement.PLURAL); NPPhraseSpec @object = phraseFactory.createNounPhrase("surfer"); @object.setFeature(Feature.NUMBER, NumberAgreement.PLURAL); SPhraseSpec _s1 = phraseFactory.createClause(subject, "carry", @object); //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$ // add a PP complement PPPhraseSpec pp = phraseFactory.createPrepositionPhrase("to", phraseFactory.createNounPhrase("the", "shore")); _s1.addPostModifier(pp); _s1.setFeature(Feature.PASSIVE, true); Assert.AreEqual("surfers are carried to the shore by waves", realiser.realise(_s1).Realisation); //$NON-NLS-1$ }
public virtual void testCuePhrase() { NPPhraseSpec subject = phraseFactory.createNounPhrase("wave"); subject.setFeature(Feature.NUMBER, NumberAgreement.PLURAL); NPPhraseSpec @object = phraseFactory.createNounPhrase("surfer"); @object.setFeature(Feature.NUMBER, NumberAgreement.PLURAL); SPhraseSpec _s1 = phraseFactory.createClause(subject, "carry", @object); //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$ // add a PP complement PPPhraseSpec pp = phraseFactory.createPrepositionPhrase("to", phraseFactory.createNounPhrase("the", "shore")); _s1.addPostModifier(pp); _s1.setFeature(Feature.PASSIVE, true); _s1.addFrontModifier("however"); //without comma separation of cue phrase Assert.AreEqual("however surfers are carried to the shore by waves", realiser.realise(_s1).Realisation); //$NON-NLS-1$ realiser.CommaSepCuephrase = true; Assert.AreEqual("however, surfers are carried to the shore by waves", realiser.realise(_s1).Realisation); //$NON-NLS-1$ }
public virtual void testComplexSentence3() { setUp(); s1 = phraseFactory.createClause(); s1.setSubject(woman); s1.setVerb("kiss"); s1.setObject(man); PhraseElement _man = phraseFactory.createNounPhrase("the", "man"); //$NON-NLS-1$ //$NON-NLS-2$ s3 = phraseFactory.createClause(); s3.setSubject(_man); s3.setVerb("give"); NPPhraseSpec flower = phraseFactory.createNounPhrase("flower"); //$NON-NLS-1$ NPPhraseSpec john = phraseFactory.createNounPhrase("John"); //$NON-NLS-1$ john.setFeature(Feature.POSSESSIVE, true); flower.setSpecifier(john); s3.setObject(flower); PhraseElement _woman = phraseFactory.createNounPhrase("the", "woman"); //$NON-NLS-1$ //$NON-NLS-2$ s3.setIndirectObject(_woman); // the coordinate sentence allows us to raise and lower complementiser CoordinatedPhraseElement coord2 = new CoordinatedPhraseElement(s1, s3); coord2.setFeature(Feature.TENSE, Tense.PAST); realiser.DebugMode = true; Assert.AreEqual("the woman kissed the man and the man gave the woman John's flower", realiser.realise(coord2).Realisation); //$NON-NLS-1$ }
public virtual void testPassiveWithPPCompl() { // passive with just complement NPPhraseSpec subject = phraseFactory.createNounPhrase("wave"); subject.setFeature(Feature.NUMBER, NumberAgreement.PLURAL); NPPhraseSpec @object = phraseFactory.createNounPhrase("surfer"); @object.setFeature(Feature.NUMBER, NumberAgreement.PLURAL); SPhraseSpec _s1 = phraseFactory.createClause(subject, "carry", @object); //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$ // add a PP complement PPPhraseSpec pp = phraseFactory.createPrepositionPhrase("to", phraseFactory.createNounPhrase("the", "shore")); pp.setFeature(InternalFeature.DISCOURSE_FUNCTION, DiscourseFunction.INDIRECT_OBJECT); _s1.addComplement(pp); _s1.setFeature(Feature.PASSIVE, true); Assert.AreEqual("surfers are carried to the shore by waves", realiser.realise(_s1).Realisation); //$NON-NLS-1$ }
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 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 override void tearDown() { base.tearDown(); p1 = null; p2 = null; p3 = null; }
public void testNegatedQuestions() { setUp(); this.phraseFactory.setLexicon(this.lexicon); this.realiser.setLexicon(this.lexicon); // sentence: "the woman did not kiss the man" s1 = this.phraseFactory.createClause(this.woman, "kiss", this.man); s1.setFeature(Feature.TENSE.ToString(), Tense.PAST); s1.setFeature(Feature.NEGATED.ToString(), true); s1.setFeature(Feature.INTERROGATIVE_TYPE.ToString(), InterrogativeType.YES_NO); Assert.AreEqual("did the woman not kiss the man", this.realiser .realise(s1).getRealisation()); // sentence: however, tomorrow, Jane and Andrew will not pick up the // balls in the shop var subjects = new CoordinatedPhraseElement( this.phraseFactory.createNounPhrase("Jane"), this.phraseFactory.createNounPhrase("Andrew")); s4 = this.phraseFactory.createClause(subjects, "pick up", "the balls"); s4.addPostModifier("in the shop"); s4.setFeature(Feature.CUE_PHRASE.ToString(), "however,"); s4.addFrontModifier("tomorrow"); s4.setFeature(Feature.NEGATED.ToString(), true); s4.setFeature(Feature.TENSE.ToString(), Tense.FUTURE); s4.setFeature(Feature.INTERROGATIVE_TYPE.ToString(), InterrogativeType.YES_NO); Assert.AreEqual( "however, will Jane and Andrew not pick up the balls in the shop tomorrow", this.realiser.realise(s4).getRealisation()); }
public override void setUp() { base.setUp(); p1 = phraseFactory.createClause("you", "be", "happy"); p2 = phraseFactory.createClause("I", "be", "sad"); p3 = phraseFactory.createClause("they", "be", "nervous"); }
public virtual void novelliTest() { PhraseElement p = phraseFactory.createClause("Mary", "chase", "George"); //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$ PhraseElement pp = phraseFactory.createPrepositionPhrase("in", "the park"); //$NON-NLS-1$ //$NON-NLS-2$ p.addPostModifier(pp); Assert.AreEqual("Mary chases George in the park", realiser.realise(p).Realisation); //$NON-NLS-1$ SPhraseSpec run = phraseFactory.createClause("you", "go", "running"); //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$ run.setFeature(Feature.MODAL, "should"); //$NON-NLS-1$ run.addPreModifier("really"); //$NON-NLS-1$ SPhraseSpec think = phraseFactory.createClause("I", "think"); //$NON-NLS-1$ //$NON-NLS-2$ think.setObject(run); run.setFeature(Feature.SUPRESSED_COMPLEMENTISER, true); string text = realiser.realise(think).Realisation; Assert.AreEqual("I think you should really go running", text); //$NON-NLS-1$ }
/** * Creates a clause with the given subject, verb or verb phrase and direct * object but no indirect object. * * @param subject * the subject for the clause as a <code>NLGElement</code> or * <code>String</code>. This forms a noun phrase. * @param verb * the verb for the clause as a <code>NLGElement</code> or * <code>String</code>. This forms a verb phrase. * @param directObject * the direct object for the clause as a <code>NLGElement</code> * or <code>String</code>. This forms a complement for the * clause. * @return a <code>SPhraseSpec</code> representing this phrase. */ public virtual SPhraseSpec createClause(object subject, object verb, object directObject) { SPhraseSpec phraseElement = new SPhraseSpec(this); if (verb != null) { // AG: fix here: check if "verb" is a VPPhraseSpec or a Verb if (verb is PhraseElement) { phraseElement.VerbPhrase = (PhraseElement)verb; } else { phraseElement.setVerb(verb); } } if (subject != null) { phraseElement.setSubject(subject); } if (directObject != null) { phraseElement.setObject(directObject); } return(phraseElement); }
public virtual void testComplementiserPassivePerfectFeatures_PastTense() { setUp(); realiser.Lexicon = lexicon; PhraseElement inner = phraseFactory.createClause("I", "play", "poker"); inner.setFeature(Feature.TENSE, Tense.PAST); inner.setFeature(Feature.COMPLEMENTISER, "where"); PhraseElement house = phraseFactory.createNounPhrase("the", "house"); house.addComplement(inner); SPhraseSpec outer = phraseFactory.createClause(null, "abandon", house); outer.addPostModifier("since 1986"); outer.setFeature(Feature.PASSIVE, true); outer.setFeature(Feature.PERFECT, true); DocumentElement sentence = docFactory.createSentence(outer); NLGElement realised = realiser.realise(sentence); // Retrieve the realisation and dump it to the console Assert.AreEqual("The house where I played poker has been abandoned since 1986.", realised.Realisation); }
public virtual void testFutureTense() { SPhraseSpec test = phraseFactory.createClause(); NPPhraseSpec subj = phraseFactory.createNounPhrase("I"); VPPhraseSpec verb = phraseFactory.createVerbPhrase("go"); AdvPhraseSpec adverb = phraseFactory.createAdverbPhrase("tomorrow"); test.setSubject(subj); test.VerbPhrase = verb; test.setFeature(Feature.TENSE, Tense.FUTURE); test.addPostModifier(adverb); string sentence = realiser.realiseSentence(test); Assert.AreEqual("I will go tomorrow.", sentence); SPhraseSpec test2 = phraseFactory.createClause(); NLGElement vb = phraseFactory.createWord("go", new LexicalCategory(LexicalCategory.LexicalCategoryEnum.VERB)); test2.setSubject(subj); test2.setVerb(vb); test2.setFeature(Feature.TENSE, Tense.FUTURE); test2.addPostModifier(adverb); string sentence2 = realiser.realiseSentence(test); Assert.AreEqual("I will go tomorrow.", sentence2); }
public virtual void testAuxWHObjectQuestion() { SPhraseSpec p = phraseFactory.createClause(dog, "upset", man); // first without any aux p.setFeature(Feature.TENSE, Tense.PAST); p.setFeature(Feature.INTERROGATIVE_TYPE, InterrogativeType.WHAT_OBJECT); Assert.AreEqual("what did the dog upset", realiser.realise(p).Realisation); p.setFeature(Feature.INTERROGATIVE_TYPE, InterrogativeType.WHO_OBJECT); Assert.AreEqual("who did the dog upset", realiser.realise(p).Realisation); p.setFeature(Feature.TENSE, Tense.PRESENT); p.setFeature(Feature.PERFECT, true); p.setFeature(Feature.INTERROGATIVE_TYPE, InterrogativeType.WHO_OBJECT); Assert.AreEqual("who has the dog upset", realiser.realise(p).Realisation); p.setFeature(Feature.INTERROGATIVE_TYPE, InterrogativeType.WHAT_OBJECT); Assert.AreEqual("what has the dog upset", realiser.realise(p).Realisation); p.setFeature(Feature.TENSE, Tense.FUTURE); p.setFeature(Feature.PERFECT, true); p.setFeature(Feature.INTERROGATIVE_TYPE, InterrogativeType.WHO_OBJECT); Assert.AreEqual("who will the dog have upset", realiser.realise(p).Realisation); p.setFeature(Feature.INTERROGATIVE_TYPE, InterrogativeType.WHAT_OBJECT); Assert.AreEqual("what will the dog have upset", realiser.realise(p).Realisation); }
public virtual void testBeQuestionsPast() { SPhraseSpec p = phraseFactory.createClause(phraseFactory.createNounPhrase("a", "ball"), phraseFactory.createWord("be", new LexicalCategory(LexicalCategory.LexicalCategoryEnum.VERB)), phraseFactory.createNounPhrase("a", "toy")); p.setFeature(Feature.TENSE, Tense.PAST); p.setFeature(Feature.INTERROGATIVE_TYPE, InterrogativeType.WHAT_OBJECT); Assert.AreEqual("what was a ball", realiser.realise(p).Realisation); p.setFeature(Feature.INTERROGATIVE_TYPE, InterrogativeType.YES_NO); Assert.AreEqual("was a ball a toy", realiser.realise(p).Realisation); p.setFeature(Feature.INTERROGATIVE_TYPE, InterrogativeType.WHAT_SUBJECT); Assert.AreEqual("what was a toy", realiser.realise(p).Realisation); SPhraseSpec p2 = phraseFactory.createClause("Mary", "be", "beautiful"); p2.setFeature(Feature.TENSE, Tense.PAST); p2.setFeature(Feature.INTERROGATIVE_TYPE, InterrogativeType.WHY); Assert.AreEqual("why was Mary beautiful", realiser.realise(p2).Realisation); p2.setFeature(Feature.INTERROGATIVE_TYPE, InterrogativeType.WHERE); Assert.AreEqual("where was Mary beautiful", realiser.realise(p2).Realisation); p2.setFeature(Feature.INTERROGATIVE_TYPE, InterrogativeType.WHO_SUBJECT); Assert.AreEqual("who was beautiful", realiser.realise(p2).Realisation); }
public virtual void testModalWHSubjectQuestion() { SPhraseSpec p = phraseFactory.createClause(dog, "upset", man); p.setFeature(Feature.TENSE, Tense.PAST); Assert.AreEqual("the dog upset the man", realiser.realise(p).Realisation); // first without modal p.setFeature(Feature.INTERROGATIVE_TYPE, InterrogativeType.WHO_SUBJECT); Assert.AreEqual("who upset the man", realiser.realise(p).Realisation); p.setFeature(Feature.INTERROGATIVE_TYPE, InterrogativeType.WHAT_SUBJECT); Assert.AreEqual("what upset the man", realiser.realise(p).Realisation); // now with modal auxiliary p.setFeature(Feature.MODAL, "may"); p.setFeature(Feature.INTERROGATIVE_TYPE, InterrogativeType.WHO_SUBJECT); Assert.AreEqual("who may have upset the man", realiser.realise(p).Realisation); p.setFeature(Feature.TENSE, Tense.FUTURE); Assert.AreEqual("who may upset the man", realiser.realise(p).Realisation); p.setFeature(Feature.TENSE, Tense.PAST); p.setFeature(Feature.INTERROGATIVE_TYPE, InterrogativeType.WHAT_SUBJECT); Assert.AreEqual("what may have upset the man", realiser.realise(p).Realisation); p.setFeature(Feature.TENSE, Tense.FUTURE); Assert.AreEqual("what may upset the man", realiser.realise(p).Realisation); }
public virtual void testNegatedQuestions() { setUp(); phraseFactory.Lexicon = lexicon; realiser.Lexicon = lexicon; // sentence: "the woman did not kiss the man" s1 = phraseFactory.createClause(woman, "kiss", man); s1.setFeature(Feature.TENSE, Tense.PAST); s1.setFeature(Feature.NEGATED, true); s1.setFeature(Feature.INTERROGATIVE_TYPE, InterrogativeType.YES_NO); Assert.AreEqual("did the woman not kiss the man", realiser.realise(s1).Realisation); //$NON-NLS-1$ // sentence: however, tomorrow, Jane and Andrew will not pick up the // balls in the shop CoordinatedPhraseElement subjects = new CoordinatedPhraseElement(phraseFactory.createNounPhrase("Jane"), phraseFactory.createNounPhrase("Andrew")); //$NON-NLS-1$ - $NON-NLS-1$ s4 = phraseFactory.createClause(subjects, "pick up", "the balls"); //$NON-NLS-1$ - $NON-NLS-1$ s4.addPostModifier("in the shop"); //$NON-NLS-1$ s4.setFeature(Feature.CUE_PHRASE, "however,"); //$NON-NLS-1$ s4.addFrontModifier("tomorrow"); //$NON-NLS-1$ s4.setFeature(Feature.NEGATED, true); s4.setFeature(Feature.TENSE, Tense.FUTURE); s4.setFeature(Feature.INTERROGATIVE_TYPE, InterrogativeType.YES_NO); Assert.AreEqual("however, will Jane and Andrew not pick up the balls in the shop tomorrow", realiser.realise(s4).Realisation); //$NON-NLS-1$ }
public void forcherTest() { // Bjorn Forcher's tests SetupForExternalTest.phraseFactory.setLexicon(SetupForExternalTest.lexicon); SPhraseSpec s1 = SetupForExternalTest.phraseFactory.createClause(null, "associate", "Marie"); s1.setFeature(Feature.PASSIVE.ToString(), true); PPPhraseSpec pp1 = SetupForExternalTest.phraseFactory.createPrepositionPhrase("with"); pp1.addComplement("Peter"); pp1.addComplement("Paul"); s1.addPostModifier(pp1); SetupForExternalTest.realiser.setDebugMode(true); var r = SetupForExternalTest.realiser.realise(s1).getRealisation(); Assert.AreEqual("Marie is associated with Peter and Paul", r); SPhraseSpec s2 = SetupForExternalTest.phraseFactory.createClause(); s2.setSubject((NPPhraseSpec)SetupForExternalTest.phraseFactory.createNounPhrase("Peter")); s2.setVerb("have"); s2.setObject("something to do"); s2.addPostModifier((PPPhraseSpec)SetupForExternalTest.phraseFactory.createPrepositionPhrase( "with", "Paul")); Assert.AreEqual("Peter has something to do with Paul", SetupForExternalTest.realiser.realise(s2).getRealisation()); }
public void data2TextTest() { // Data2Text tests // test OK to have number at end of sentence SPhraseSpec p = SetupForExternalTest.phraseFactory.createClause("the dog", "weigh", "12"); Assert.AreEqual("The dog weighs 12.", SetupForExternalTest.realiser.realiseSentence(p)); // test OK to have "there be" sentence with "there" as a StringElement var dataDropout2 = SetupForExternalTest.phraseFactory.createNLGElement("data dropouts"); dataDropout2.setPlural(true); var sentence2 = SetupForExternalTest.phraseFactory.createClause(); sentence2.setSubject(SetupForExternalTest.phraseFactory.createStringElement("there")); sentence2.setVerb("be"); sentence2.setObject(dataDropout2); Assert.AreEqual("There are data dropouts.", SetupForExternalTest.realiser.realiseSentence(sentence2)); // test OK to have gerund form verb SPhraseSpec weather1 = SetupForExternalTest.phraseFactory.createClause("SE 10-15", "veer", "S 15-20"); weather1.setFeature(Feature.FORM.ToString(), Form.GERUND); Assert.AreEqual("SE 10-15 veering S 15-20.", SetupForExternalTest.realiser.realiseSentence(weather1)); // test OK to have subject only SPhraseSpec weather2 = SetupForExternalTest.phraseFactory.createClause("cloudy and misty", "be", "XXX"); weather2.getVerbPhrase().setFeature(Feature.ELIDED.ToString(), true); Assert.AreEqual("Cloudy and misty.", SetupForExternalTest.realiser.realiseSentence(weather2)); // test OK to have VP only SPhraseSpec weather3 = SetupForExternalTest.phraseFactory.createClause("S 15-20", "increase", "20-25"); weather3.setFeature(Feature.FORM.ToString(), Form.GERUND); weather3.getSubject().setFeature(Feature.ELIDED.ToString(), true); Assert.AreEqual("Increasing 20-25.", SetupForExternalTest.realiser.realiseSentence(weather3)); // conjoined test SPhraseSpec weather4 = SetupForExternalTest.phraseFactory.createClause("S 20-25", "back", "SSE"); weather4.setFeature(Feature.FORM.ToString(), Form.GERUND); weather4.getSubject().setFeature(Feature.ELIDED.ToString(), true); var coord = new CoordinatedPhraseElement(); coord.addCoordinate(weather1); coord.addCoordinate(weather3); coord.addCoordinate(weather4); coord.setConjunction("then"); Assert.AreEqual("SE 10-15 veering S 15-20, increasing 20-25 then backing SSE.", SetupForExternalTest.realiser.realiseSentence(coord)); // no verb SPhraseSpec weather5 = SetupForExternalTest.phraseFactory.createClause("rain", null, "likely"); Assert.AreEqual("Rain likely.", SetupForExternalTest.realiser.realiseSentence(weather5)); }
public virtual void leanTest() { SPhraseSpec sentence = phraseFactory.createClause(); sentence.setVerb("be"); sentence.setObject("a ball"); sentence.setFeature(Feature.INTERROGATIVE_TYPE, InterrogativeType.WHAT_SUBJECT); Assert.AreEqual("What is a ball?", realiser.realiseSentence(sentence)); sentence = phraseFactory.createClause(); sentence.setVerb("be"); NPPhraseSpec @object = phraseFactory.createNounPhrase("example"); @object.Plural = true; @object.addModifier("of jobs"); sentence.setFeature(Feature.INTERROGATIVE_TYPE, InterrogativeType.WHAT_SUBJECT); sentence.setObject(@object); Assert.AreEqual("What are examples of jobs?", realiser.realiseSentence(sentence)); SPhraseSpec p = phraseFactory.createClause(); NPPhraseSpec sub1 = phraseFactory.createNounPhrase("Mary"); sub1.setFeature(LexicalFeature.GENDER, Gender.FEMININE); sub1.setFeature(Feature.PRONOMINAL, true); sub1.setFeature(Feature.PERSON, Person.FIRST); p.setSubject(sub1); p.setVerb("chase"); p.setObject("the monkey"); string output2 = realiser.realiseSentence(p); // Realiser created earlier. Assert.AreEqual("I chase the monkey.", output2); SPhraseSpec test = phraseFactory.createClause(); NPPhraseSpec subject = phraseFactory.createNounPhrase("Mary"); subject.setFeature(Feature.PRONOMINAL, true); subject.setFeature(Feature.PERSON, Person.SECOND); test.setSubject(subject); test.setVerb("cry"); test.setFeature(Feature.INTERROGATIVE_TYPE, InterrogativeType.WHY); test.setFeature(Feature.TENSE, Tense.PRESENT); Assert.AreEqual("Why do you cry?", realiser.realiseSentence(test)); test = phraseFactory.createClause(); subject = phraseFactory.createNounPhrase("Mary"); subject.setFeature(Feature.PRONOMINAL, true); subject.setFeature(Feature.PERSON, Person.SECOND); test.setSubject(subject); test.setVerb("be"); test.setObject("crying"); test.setFeature(Feature.INTERROGATIVE_TYPE, InterrogativeType.WHY); test.setFeature(Feature.TENSE, Tense.PRESENT); Assert.AreEqual("Why are you crying?", realiser.realiseSentence(test)); }
public virtual void stringElementAsVPTest() { SPhraseSpec s = phraseFactory.createClause(); s.VerbPhrase = phraseFactory.createStringElement("eats and drinks"); s.setSubject(phraseFactory.createStringElement("the big fat man")); Assert.AreEqual("the big fat man eats and drinks", realiser.realise(s).Realisation); }
public void testDidNot() { SPhraseSpec o = this.phraseFactory.createClause("John", "eat"); o.setFeature(Feature.TENSE.ToString(), Tense.PAST); o.setFeature(Feature.NEGATED.ToString(), true); this.realiser.setLexicon(this.lexicon); Assert.AreEqual("John did not eat", this.realiser.realise(o).getRealisation()); }
public void tearDown() { s1 = null; s2 = null; s3 = null; s4 = null; s5 = null; s6 = null; }