def testDwight(self): # Rachel Dwight's test self.phraseFactory.setLexicon(self.lexicon) noun4 = self.phraseFactory.createNounPhrase("FGFR3 gene in every cell") noun4.setSpecifier("the") prep1 = self.phraseFactory.createPrepositionPhrase("of", noun4) noun1 = self.phraseFactory.createNounPhrase("the", "patient's mother") noun2 = self.phraseFactory.createNounPhrase("the", "patient's father") noun3 = self.phraseFactory.createNounPhrase("changed copy") noun3.addPreModifier("one") noun3.addComplement(prep1) coordNoun1 = CoordinatedPhraseElement(noun1, noun2) coordNoun1.setConjunction("or") verbPhrase1 = self.phraseFactory.createVerbPhrase("have") verbPhrase1.setFeature(Feature.TENSE, Tense.PRESENT) sentence1 = self.phraseFactory.createClause(coordNoun1, verbPhrase1, noun3) #realiser.setDebugMode(True) string = "the patient's mother or the patient's father has one changed copy of the FGFR3 gene in every cell" self.assertEqual(string, self.realiser.realise(sentence1).getRealisation()) # Rachel's second test noun3 = self.phraseFactory.createNounPhrase("a", "gene test") noun2 = self.phraseFactory.createNounPhrase("an", "LDL test") noun1 = self.phraseFactory.createNounPhrase("the", "clinic") verbPhrase1 = self.phraseFactory.createVerbPhrase("perform") coord1 = CoordinatedPhraseElement(noun2, noun3) sentence1 = self.phraseFactory.createClause(noun1, verbPhrase1, coord1) sentence1.setFeature(Feature.TENSE, Tense.PAST) self.assertEqual("the clinic performed an LDL test and a gene test", \ self.realiser.realise(sentence1).getRealisation())
def testCoordination(self): cnp1 = CoordinatedPhraseElement(self.dog, self.woman) # simple coordination self.assertEqual("the dog and the woman", self.realiser.realise(cnp1).getRealisation()) # simple coordination with complementation of entire coordinate NP cnp1.addComplement(self.behindTheCurtain) self.assertEqual("the dog and the woman behind the curtain", \ self.realiser.realise(cnp1).getRealisation())
def testComplexSentence1(self): self.setUp() # the man's giving the woman John's flower upset Peter complexS = self.phraseFactory.createClause() complexS.setVerbPhrase(self.phraseFactory.createVerbPhrase("upset")) complexS.setFeature(Feature.TENSE, Tense.PAST) complexS.setObject(self.phraseFactory.createNounPhrase("Peter")) self.s3.setFeature(Feature.PERFECT, True) complexS.setSubject(self.s3) # check the realisation: subject should be genitive self.assertEqual("the man's having given the woman John's flower upset Peter", \ self.realiser.realise(complexS).getRealisation()) self.setUp() # coordinate sentences in subject position s5 = self.phraseFactory.createClause() s5.setSubject(self.phraseFactory.createNounPhrase("some", "person")) s5.setVerbPhrase(self.phraseFactory.createVerbPhrase("stroke")) s5.setObject(self.phraseFactory.createNounPhrase("the", "cat")) coord = CoordinatedPhraseElement(self.s3, s5) complexS = self.phraseFactory.createClause() complexS.setVerbPhrase(self.phraseFactory.createVerbPhrase("upset")) complexS.setFeature(Feature.TENSE, Tense.PAST) complexS.setObject(self.phraseFactory.createNounPhrase("Peter")) complexS.setSubject(coord) self.s3.setFeature(Feature.PERFECT, True) self.assertEqual("the man's having given the woman John's flower " \ + "and some person's stroking the cat upset Peter", \ self.realiser.realise(complexS).getRealisation()) self.setUp() # now subordinate the complex sentence # coord.setClauseStatus(SPhraseSpec.ClauseType.MAIN) s6 = self.phraseFactory.createClause() s6.setVerbPhrase(self.phraseFactory.createVerbPhrase("tell")) s6.setFeature(Feature.TENSE, Tense.PAST) s6.setSubject(self.phraseFactory.createNounPhrase("the", "boy")) # ER - switched indirect and direct object indirect = self.phraseFactory.createNounPhrase("every", "girl") s6.setIndirectObject(indirect) complexS = self.phraseFactory.createClause() complexS.setVerbPhrase(self.phraseFactory.createVerbPhrase("upset")) complexS.setFeature(Feature.TENSE, Tense.PAST) complexS.setObject(self.phraseFactory.createNounPhrase("Peter")) s6.setObject(complexS) coord = CoordinatedPhraseElement(self.s3, s5) complexS.setSubject(coord) self.s3.setFeature(Feature.PERFECT, True) self.assertEqual("the boy told every girl that the man's having given the woman " \ + "John's flower and some person's stroking the cat " \ + "upset Peter", self.realiser.realise(s6).getRealisation())
def testForm2(self): # set s4 as subject of a new sentence temp = self.phraseFactory.createClause(self.s4, "be", "recommended") self.assertEqual("however tomorrow Jane and Andrew's picking up the " + \ "balls in the shop is recommended", \ self.realiser.realise(temp).getRealisation()) # compose self with a new sentence # ER - switched direct and indirect object in sentence temp2 = self.phraseFactory.createClause("I", "tell", temp) temp2.setFeature(Feature.TENSE, Tense.FUTURE) indirectObject = self.phraseFactory.createNounPhrase("John") temp2.setIndirectObject(indirectObject) self.assertEqual("I will tell John that however tomorrow Jane and " + \ "Andrew's picking up the balls in the shop is recommended", \ self.realiser.realise(temp2).getRealisation()) # turn s4 to imperative and put it in indirect object position self.s4 = self.phraseFactory.createClause() self.s4.setFeature(Feature.CUE_PHRASE, "however") self.s4.addFrontModifier("tomorrow") subject = CoordinatedPhraseElement(self.phraseFactory.createNounPhrase("Jane"), \ self.phraseFactory.createNounPhrase("Andrew")) self.s4.setSubject(subject) pick = self.phraseFactory.createVerbPhrase("pick up") self.s4.setVerbPhrase(pick) self.s4.setObject("the balls") self.s4.addPostModifier("in the shop") self.s4.setFeature(Feature.TENSE, Tense.FUTURE) self.s4.setFeature(Feature.FORM, Form.IMPERATIVE) temp2 = self.phraseFactory.createClause("I", "tell", self.s4) indirectObject = self.phraseFactory.createNounPhrase("John") temp2.setIndirectObject(indirectObject) temp2.setFeature(Feature.TENSE, Tense.FUTURE) self.assertEqual("I will tell John however to pick up the balls " \ + "in the shop tomorrow", self.realiser.realise(temp2).getRealisation())
def testComplementation(self): self.inTheRoom.clearComplements() self.inTheRoom.addComplement(CoordinatedPhraseElement( \ self.phraseFactory.createNounPhrase("the", "room"), self.phraseFactory.createNounPhrase("a", "car"))) self.assertEqual("in the room and a car", \ self.realiser.realise(self.inTheRoom).getRealisation())
def testComplementation2(self): # give the woman the dog self.woman.setFeature(InternalFeature.DISCOURSE_FUNCTION, DiscourseFunction.INDIRECT_OBJECT) self.dog.setFeature(InternalFeature.DISCOURSE_FUNCTION, DiscourseFunction.OBJECT) self.give.clearComplements() self.give.addComplement(self.dog) self.give.addComplement(self.woman) self.assertEqual("gives the woman the dog", \ self.realiser.realise(self.give).getRealisation()) # add a few premodifiers and postmodifiers self.give.addPreModifier("slowly") self.give.addPostModifier(self.behindTheCurtain) self.give.addPostModifier(self.inTheRoom) self.assertEqual("slowly gives the woman the dog behind the curtain in the room", \ self.realiser.realise(self.give).getRealisation()) # reset the arguments self.give.clearComplements() self.give.addComplement(self.dog) womanBoy = CoordinatedPhraseElement(self.woman, self.boy) womanBoy.setFeature(InternalFeature.DISCOURSE_FUNCTION, DiscourseFunction.INDIRECT_OBJECT) self.give.addComplement(womanBoy) # if we unset the passive, we should get the indirect objects # they won't be coordinated self.give.setFeature(Feature.PASSIVE, False) self.assertEqual("slowly gives the woman and the boy the dog behind the curtain in the room", \ self.realiser.realise(self.give).getRealisation()) # set them to a coordinate instead # set ONLY the complement INDIRECT_OBJECT, leaves OBJECT intact self.give.clearComplements() self.give.addComplement(womanBoy) self.give.addComplement(self.dog) complements = self.give.getFeatureAsElementList( InternalFeature.COMPLEMENTS) indirectCount = 0 for eachElement in complements: if DiscourseFunction.INDIRECT_OBJECT == eachElement.getFeature( InternalFeature.DISCOURSE_FUNCTION): indirectCount += 1 self.assertEqual(1, indirectCount) # only one indirect object # where # there were two before self.assertEqual("slowly gives the woman and the boy the dog behind the curtain in the room", \ self.realiser.realise(self.give).getRealisation())
def testData2TextTest(self): # Data2Text tests # test OK to have number at end of sentence p = self.phraseFactory.createClause("the dog", "weigh", "12") self.assertEqual("The dog weighes 12.", self.realiser.realiseSentence(p)) # test OK to have "there be" sentence with "there" as a StringElement dataDropout2 = self.phraseFactory.createNLGElement("data dropouts") dataDropout2.setPlural(True) sentence2 = self.phraseFactory.createClause() sentence2.setSubject(self.phraseFactory.createStringElement("there")) sentence2.setVerb("be") sentence2.setObject(dataDropout2) self.assertEqual("There are data dropouts.", self.realiser.realiseSentence(sentence2)) # test OK to have gerund form verb weather1 = self.phraseFactory.createClause("SE 10-15", "veer", "S 15-20") weather1.setFeature(Feature.FORM, Form.GERUND) self.assertEqual("SE 10-15 veering S 15-20.", self.realiser.realiseSentence(weather1)) # test OK to have subject only weather2 = self.phraseFactory.createClause("cloudy and misty", "be", "XXX") weather2.getVerbPhrase().setFeature(Feature.ELIDED, True) self.assertEqual("Cloudy and misty.", self.realiser.realiseSentence(weather2)) # test OK to have VP only weather3 = self.phraseFactory.createClause("S 15-20", "increase", "20-25") weather3.setFeature(Feature.FORM, Form.GERUND) weather3.getSubject().setFeature(Feature.ELIDED, True) self.assertEqual("Increasing 20-25.", self.realiser.realiseSentence(weather3)) # conjoined test weather4 = self.phraseFactory.createClause("S 20-25", "back", "SSE") weather4.setFeature(Feature.FORM, Form.GERUND) weather4.getSubject().setFeature(Feature.ELIDED, True) coord = CoordinatedPhraseElement() coord.addCoordinate(weather1) coord.addCoordinate(weather3) coord.addCoordinate(weather4) coord.setConjunction("then") self.assertEqual( "SE 10-15 veering S 15-20, increasing 20-25 then backing SSE.", self.realiser.realiseSentence(coord)) # no verb weather5 = self.phraseFactory.createClause("rain", None, "likely") self.assertEqual("Rain likely.", self.realiser.realiseSentence(weather5))
def testComplexSentence3(self): self.setUp() self.s1 = self.phraseFactory.createClause() self.s1.setSubject(self.woman) self.s1.setVerb("kiss") self.s1.setObject(self.man) _man = self.phraseFactory.createNounPhrase("the", "man") self.s3 = self.phraseFactory.createClause() self.s3.setSubject(_man) self.s3.setVerb("give") flower = self.phraseFactory.createNounPhrase("flower") john = self.phraseFactory.createNounPhrase("John") john.setFeature(Feature.POSSESSIVE, True) flower.setSpecifier(john) self.s3.setObject(flower) _woman = self.phraseFactory.createNounPhrase("the", "woman") self.s3.setIndirectObject(_woman) # the coordinate sentence allows us to raise and lower complementiser coord2 = CoordinatedPhraseElement(self.s1, self.s3) coord2.setFeature(Feature.TENSE, Tense.PAST) #self.realiser.setDebugMode(True) self.assertEqual("the woman kissed the man and the man gave the woman John's flower", \ self.realiser.realise(coord2).getRealisation())
def testCoordination(self): # simple coordination coord1 = CoordinatedPhraseElement(self.inTheRoom, self.behindTheCurtain) self.assertEqual("in the room and behind the curtain", \ self.realiser.realise(coord1).getRealisation()) # change the conjunction coord1.setFeature(Feature.CONJUNCTION, "or") self.assertEqual("in the room or behind the curtain", \ self.realiser.realise(coord1).getRealisation()) # new coordinate coord2 = CoordinatedPhraseElement(self.onTheRock, self.underTheTable) coord2.setFeature(Feature.CONJUNCTION, "or") self.assertEqual("on the rock or under the table", \ self.realiser.realise(coord2).getRealisation()) # coordinate two coordinates coord3 = CoordinatedPhraseElement(coord1, coord2) text = self.realiser.realise(coord3).getRealisation() self.assertEqual( "in the room or behind the curtain and on the rock or under the table", text)
def testPossessiveCoordinate(self): # simple coordination cnp2 = CoordinatedPhraseElement(self.dog, self.woman) self.assertEqual("the dog and the woman", self.realiser.realise(cnp2).getRealisation()) # set possessive -- wide-scope by default cnp2.setFeature(Feature.POSSESSIVE, True) self.assertEqual("the dog and the woman's", self.realiser.realise(cnp2).getRealisation()) # set possessive with pronoun self.dog.setFeature(Feature.PRONOMINAL, True) self.dog.setFeature(Feature.POSSESSIVE, True) cnp2.setFeature(Feature.POSSESSIVE, True) self.assertEqual("its and the woman's", self.realiser.realise(cnp2).getRealisation())
def testComplementiserFeatureInACoordinatePhrase_PastTense(self): self.phraseFactory.setLexicon(self.lexicon) dave = self.phraseFactory.createWord("Dave Bus", LexicalCategory.NOUN) albert = self.phraseFactory.createWord("Albert", LexicalCategory.NOUN) coord1 = CoordinatedPhraseElement(dave, albert) born = self.phraseFactory.createClause(coord1, "be", "born") born.setFeature(Feature.TENSE,Tense.PAST) born.addPostModifier("in") born.setFeature(Feature.COMPLEMENTISER, "which") theHouse = self.phraseFactory.createNounPhrase("the", "house") theHouse.addComplement(born) clause = self.phraseFactory.createClause(theHouse, "be", \ self.phraseFactory.createPrepositionPhrase("in", "Edinburgh")) sentence = self.docFactory.createSentence(clause) realised = self.realiser.realise(sentence) # Retrieve the realisation and dump it to the console self.assertEqual("The house which Dave Bus and Albert were born in is in Edinburgh.", \ realised.getRealisation())
def testForm(self): # check the getter method self.assertEqual(Form.NORMAL, self.s1.getFeatureAsElement( \ InternalFeature.VERB_PHRASE).getFeature(Feature.FORM)) # infinitive self.s1.setFeature(Feature.FORM, Form.INFINITIVE) self.assertEqual("to kiss the man", self.realiser.realise(self.s1).getRealisation()) # gerund with "there" self.s2.setFeature(Feature.FORM, Form.GERUND) self.assertEqual("there being the dog on the rock", self.realiser.realise(self.s2).getRealisation()) # gerund with possessive self.s3.setFeature(Feature.FORM, Form.GERUND) self.assertEqual("the man's giving the woman John's flower", \ self.realiser.realise(self.s3).getRealisation()) # imperative self.s3.setFeature(Feature.FORM, Form.IMPERATIVE) self.assertEqual("give the woman John's flower", self.realiser.realise(self.s3).getRealisation()) # subordinating the imperative to a verb should turn it to infinitive self.say.addComplement(self.s3) self.assertEqual("says to give the woman John's flower", \ self.realiser.realise(self.say).getRealisation()) # imperative -- case II self.s4.setFeature(Feature.FORM, Form.IMPERATIVE) self.assertEqual("however tomorrow pick up the balls in the shop", \ self.realiser.realise(self.s4).getRealisation()) # infinitive -- case II self.s4 = self.phraseFactory.createClause() self.s4.setFeature(Feature.CUE_PHRASE, "however") self.s4.addFrontModifier("tomorrow") subject = CoordinatedPhraseElement(self.phraseFactory.createNounPhrase("Jane"), \ self.phraseFactory.createNounPhrase("Andrew")) self.s4.setFeature(InternalFeature.SUBJECTS, subject) pick = self.phraseFactory.createVerbPhrase("pick up") self.s4.setFeature(InternalFeature.VERB_PHRASE, pick) self.s4.setObject("the balls") self.s4.addPostModifier("in the shop") self.s4.setFeature(Feature.TENSE, Tense.FUTURE) self.s4.setFeature(Feature.FORM, Form.INFINITIVE) self.assertEqual("however to pick up the balls in the shop tomorrow", \ self.realiser.realise(self.s4).getRealisation())
def testComplementation1(self): # was kissing Mary mary = self.phraseFactory.createNounPhrase("Mary") mary.setFeature(InternalFeature.DISCOURSE_FUNCTION, DiscourseFunction.OBJECT) self.kiss.clearComplements() self.kiss.addComplement(mary) self.kiss.setFeature(Feature.PROGRESSIVE, True) self.kiss.setFeature(Feature.TENSE, Tense.PAST) self.assertEqual("was kissing Mary", \ self.realiser.realise(self.kiss).getRealisation()) mary2 = CoordinatedPhraseElement( mary, self.phraseFactory.createNounPhrase("Susan")) # add another complement -- should come out as "Mary and Susan" self.kiss.clearComplements() self.kiss.addComplement(mary2) self.assertEqual("was kissing Mary and Susan", \ self.realiser.realise(self.kiss).getRealisation()) # passivise -- should make the direct object complement disappear # Note: The verb doesn't come out as plural because agreement # is determined by the sentential subjects and self VP isn't inside a # sentence self.kiss.setFeature(Feature.PASSIVE, True) self.assertEqual("was being kissed", \ self.realiser.realise(self.kiss).getRealisation()) # make it plural (self is usually taken care of in SPhraseSpec) self.kiss.setFeature(Feature.NUMBER, NumberAgreement.PLURAL) self.assertEqual("were being kissed", self.realiser.realise(self.kiss).getRealisation()) # depassivise and add post-mod: yields "was kissing Mary in the room" self.kiss.addPostModifier(self.inTheRoom) self.kiss.setFeature(Feature.PASSIVE, False) self.kiss.setFeature(Feature.NUMBER, NumberAgreement.SINGULAR) self.assertEqual("was kissing Mary and Susan in the room", \ self.realiser.realise(self.kiss).getRealisation()) # passivise again: should make direct object disappear, but not postMod # ="was being kissed in the room" self.kiss.setFeature(Feature.PASSIVE, True) self.kiss.setFeature(Feature.NUMBER, NumberAgreement.PLURAL) self.assertEqual("were being kissed in the room", \ self.realiser.realise(self.kiss).getRealisation())
def testCoordination(self): # simple case self.kiss.addComplement(self.dog) self.kick.addComplement(self.boy) coord1 = CoordinatedPhraseElement(self.kiss, self.kick) coord1.setFeature(Feature.PERSON, Person.THIRD) coord1.setFeature(Feature.TENSE, Tense.PAST) self.assertEqual("kissed the dog and kicked the boy", \ self.realiser.realise(coord1).getRealisation()) # with negation: should be inherited by all components coord1.setFeature(Feature.NEGATED, True) self.realiser.setLexicon(self.lexicon) self.assertEqual("did not kiss the dog and did not kick the boy", \ self.realiser.realise(coord1).getRealisation()) # set a modal coord1.setFeature(Feature.MODAL, "could") self.assertEqual("could not have kissed the dog and could not have kicked the boy", \ self.realiser.realise(coord1).getRealisation()) # set perfect and progressive coord1.setFeature(Feature.PERFECT, True) coord1.setFeature(Feature.PROGRESSIVE, True) self.assertEqual("could not have been kissing the dog and " \ + "could not have been kicking the boy", self.realiser.realise(coord1).getRealisation()) # now aggregate coord1.setFeature(Feature.AGGREGATE_AUXILIARY, True) self.assertEqual("could not have been kissing the dog and kicking the boy", \ self.realiser.realise(coord1).getRealisation())
def testClausalComplement(self): self.phraseFactory.setLexicon(self.lexicon) s = self.phraseFactory.createClause() s.setSubject(self.phraseFactory.createNounPhrase("John")) # Create a sentence first maryAndSusan = CoordinatedPhraseElement(self.phraseFactory.createNounPhrase("Mary"), \ self.phraseFactory.createNounPhrase("Susan")) self.kiss.clearComplements() s.setVerbPhrase(self.kiss) s.setObject(maryAndSusan) s.setFeature(Feature.PROGRESSIVE, True) s.setFeature(Feature.TENSE, Tense.PAST) s.addPostModifier(self.inTheRoom) self.assertEqual("John was kissing Mary and Susan in the room", \ self.realiser.realise(s).getRealisation()) # make the main VP past self.say.setFeature(Feature.TENSE, Tense.PAST) self.assertEqual("said", self.realiser.realise(self.say).getRealisation()) # now add the sentence as complement of "say". Should make the sentence # subordinate # note that sentential punctuation is suppressed self.say.addComplement(s) self.assertEqual("said that John was kissing Mary and Susan in the room", \ self.realiser.realise(self.say).getRealisation()) # add a postModifier to the main VP # yields [says [that John was kissing Mary and Susan in the room] # [behind the curtain]] self.say.addPostModifier(self.behindTheCurtain) self.assertEqual("said that John was kissing Mary and Susan in the room behind the curtain", \ self.realiser.realise(self.say).getRealisation()) # create a sentential complement s2 = self.phraseFactory.createClause(self.phraseFactory.createNounPhrase("all"), \ "be", self.phraseFactory.createAdjectivePhrase("fine")) s2.setFeature(Feature.TENSE, Tense.FUTURE) self.assertEqual("all will be fine", self.realiser.realise(s2).getRealisation()) # add the complement to the VP # yields [said [that John was kissing Mary and Susan in the room and # all will be fine] [behind the curtain]] s3 = CoordinatedPhraseElement(s, s2) self.say.clearComplements() self.say.addComplement(s3) # first with outer complementiser suppressed s3.setFeature(Feature.SUPRESSED_COMPLEMENTISER, True) self.assertEqual("said that John was kissing Mary and Susan in the room " \ + "and all will be fine behind the curtain", self.realiser.realise(self.say).getRealisation()) self.setUp() s = self.phraseFactory.createClause() s.setSubject(self.phraseFactory.createNounPhrase("John")) # Create a sentence first maryAndSusan = CoordinatedPhraseElement(self.phraseFactory.createNounPhrase("Mary"), \ self.phraseFactory.createNounPhrase("Susan")) s.setVerbPhrase(self.kiss) s.setObject(maryAndSusan) s.setFeature(Feature.PROGRESSIVE, True) s.setFeature(Feature.TENSE, Tense.PAST) s.addPostModifier(self.inTheRoom) s2 = self.phraseFactory.createClause(self.phraseFactory.createNounPhrase("all"), "be", \ self.phraseFactory.createAdjectivePhrase("fine")) s2.setFeature(Feature.TENSE, Tense.FUTURE) # then with complementiser not suppressed and not aggregated s3 = CoordinatedPhraseElement(s, s2) self.say.addComplement(s3) self.say.setFeature(Feature.TENSE, Tense.PAST) self.say.addPostModifier(self.behindTheCurtain) self.assertEqual("said that John was kissing Mary and Susan in the room and " \ + "that all will be fine behind the curtain", #$NON-NLS-1$ self.realiser.realise(self.say).getRealisation())
def testAdj(self): # form the adjphrase "incredibly salacious" self.salacious.addPreModifier( self.phraseFactory.createAdverbPhrase("incredibly")) self.assertEqual( "incredibly salacious", self.realiser.realise(self.salacious).getRealisation()) # form the adjphrase "incredibly beautiful" self.beautiful.addPreModifier("amazingly") self.assertEqual( "amazingly beautiful", self.realiser.realise(self.beautiful).getRealisation()) # coordinate the two aps coordap = CoordinatedPhraseElement(self.salacious, self.beautiful) self.assertEqual("incredibly salacious and amazingly beautiful", \ self.realiser.realise(coordap).getRealisation()) # changing the inner conjunction coordap.setFeature(Feature.CONJUNCTION, "or") self.assertEqual("incredibly salacious or amazingly beautiful", \ self.realiser.realise(coordap).getRealisation()) # coordinate self with a new AdjPhraseSpec coord2 = CoordinatedPhraseElement(coordap, self.stunning) self.assertEqual("incredibly salacious or amazingly beautiful and stunning", \ self.realiser.realise(coord2).getRealisation()) # add a premodifier the coordinate phrase, yielding # "seriously and undeniably incredibly salacious or amazingly beautiful # and stunning" preMod = CoordinatedPhraseElement(StringElement("seriously"), StringElement("undeniably")) coord2.addPreModifier(preMod) self.assertEqual("seriously and undeniably incredibly salacious or amazingly beautiful and stunning", \ self.realiser.realise(coord2).getRealisation()) # adding a coordinate rather than coordinating should give a different # result coordap.addCoordinate(self.stunning) self.assertEqual("incredibly salacious, amazingly beautiful or stunning", \ self.realiser.realise(coordap).getRealisation())
def testCoordination2(self): # simple coordination of complementised nps self.dog.clearComplements() self.woman.clearComplements() cnp1 = CoordinatedPhraseElement(self.dog, self.woman) cnp1.setFeature(Feature.RAISE_SPECIFIER, True) realised = self.realiser.realise(cnp1) self.assertEqual("the dog and woman", realised.getRealisation()) # self.dog.addComplement(self.onTheRock) self.woman.addComplement(self.behindTheCurtain) # cnp2 = CoordinatedPhraseElement(self.dog, self.woman) self.woman.setFeature(InternalFeature.RAISED, False) self.assertEqual("the dog on the rock and the woman behind the curtain", \ self.realiser.realise(cnp2).getRealisation()) # complementised coordinates + outer pp modifier cnp2.addPostModifier(self.inTheRoom) self.assertEqual("the dog on the rock and the woman behind the curtain in the room", \ self.realiser.realise(cnp2).getRealisation()) # set the specifier for self cnp should unset specifiers for all inner coordinates every = self.phraseFactory.createWord("every", LexicalCategory.DETERMINER) cnp2.setFeature(InternalFeature.SPECIFIER, every) self.assertEqual("every dog on the rock and every woman behind the curtain in the room", \ self.realiser.realise(cnp2).getRealisation()) # pronominalise one of the constituents self.dog.setFeature(Feature.PRONOMINAL, True) # ="it" self.dog.setFeature(InternalFeature.SPECIFIER, \ self.phraseFactory.createWord("the", LexicalCategory.DETERMINER)) # raising spec still returns True as spec has been set cnp2.setFeature(Feature.RAISE_SPECIFIER, True) # CNP should be realised with pronominal internal const self.assertEqual("it and every woman behind the curtain in the room", \ self.realiser.realise(cnp2).getRealisation())
def testPassive(self): # passive with just complement _s1 = self.phraseFactory.createClause(None, "intubate", \ self.phraseFactory.createNounPhrase("the", "baby")) _s1.setFeature(Feature.PASSIVE, True) self.assertEqual("the baby is intubated", self.realiser.realise(_s1).getRealisation()) # passive with subject and complement _s1 = self.phraseFactory.createClause(None, "intubate", \ self.phraseFactory.createNounPhrase("the", "baby")) _s1.setSubject(self.phraseFactory.createNounPhrase("the nurse")) _s1.setFeature(Feature.PASSIVE, True) self.assertEqual("the baby is intubated by the nurse", \ self.realiser.realise(_s1).getRealisation()) # passive with subject and indirect object _s2 = self.phraseFactory.createClause(None, "give",\ self.phraseFactory.createNounPhrase("the", "baby")) morphine = self.phraseFactory.createNounPhrase("50ug of morphine") _s2.setIndirectObject(morphine) _s2.setFeature(Feature.PASSIVE, True) self.assertEqual("the baby is given 50ug of morphine", \ self.realiser.realise(_s2).getRealisation()) # passive with subject, complement and indirect object _s2 = self.phraseFactory.createClause(self.phraseFactory.createNounPhrase("the", "nurse"), \ "give", self.phraseFactory.createNounPhrase("the", "baby")) morphine = self.phraseFactory.createNounPhrase("50ug of morphine") _s2.setIndirectObject(morphine) _s2.setFeature(Feature.PASSIVE, True) self.assertEqual("the baby is given 50ug of morphine by the nurse", \ self.realiser.realise(_s2).getRealisation()) # test agreement in passive _s3 = self.phraseFactory.createClause(\ CoordinatedPhraseElement("my dog", "your cat"), "chase", "George") _s3.setFeature(Feature.TENSE, Tense.PAST) _s3.addFrontModifier("yesterday") self.assertEqual("yesterday my dog and your cat chased George", \ self.realiser.realise(_s3).getRealisation()) _s3 = self.phraseFactory.createClause(CoordinatedPhraseElement( \ "my dog", "your cat"), "chase", self.phraseFactory.createNounPhrase("George")) _s3.setFeature(Feature.TENSE, Tense.PAST) _s3.addFrontModifier("yesterday") _s3.setFeature(Feature.PASSIVE, True) self.assertEqual("yesterday George was chased by my dog and your cat", \ self.realiser.realise(_s3).getRealisation()) # test correct pronoun forms _s4 = self.phraseFactory.createClause(self.phraseFactory.createNounPhrase("he"), "chase", \ self.phraseFactory.createNounPhrase("I")) self.assertEqual("he chases me", self.realiser.realise(_s4).getRealisation()) _s4 = self.phraseFactory.createClause(\ self.phraseFactory.createNounPhrase("he"), "chase", self.phraseFactory.createNounPhrase("me")) _s4.setFeature(Feature.PASSIVE, True) self.assertEqual("I am chased by him", self.realiser.realise(_s4).getRealisation()) # same thing, but giving the S constructor "me". Should recognise correct pro anyway _s5 = self.phraseFactory.createClause("him", "chase", "I") self.assertEqual("he chases me", self.realiser.realise(_s5).getRealisation()) _s5 = self.phraseFactory.createClause("him", "chase", "I") _s5.setFeature(Feature.PASSIVE, True) self.assertEqual("I am chased by him", self.realiser.realise(_s5).getRealisation())