def test_adjective_definition(self):
     # Artificial sentence
     sentence = u'The Great Pyramid of Giza is the oldest of the three pyramids in Gyza.'
     expected = [u'pyramid', u'oldest pyramid', 'gyza pyramid']
     actual, entry = get_assertion_definitions(sentence, get_rep=True)
     self.assertItemsEqual(expected, actual)
     self.assertTrue(u'[mod: oldest' in entry)

 def test_proper_noun(self):
     # artificial sentence
     sentence = u'Lee is an American engineer, computer scientist and iOS and internet expert'
     expected = [u'internet expert', u'computer scientist', u'expert', u'american',
                 u'scientist', u'american engineer', u'engineer']  # filtered out 'iOS'
     actual = get_assertion_definitions(sentence)
     self.assertItemsEqual(expected, actual)

 def test_one_word_entity(self):
     sentence = u'Alan Mathison Turing was a British pioneering computer scientist, mathematician, logician, cryptanalyst, philosopher, mathematical biologist, and marathon and ultra distance runner.'
     expected = [u'computer scientist', u'ultra runner', u'mathematician', u'distance runner',
                 u'mathematical biologist', u'philosopher', u'runner', u'logician', u'scientist',
                 u'british', u'british scientist', u'pioneering scientist', u'biologist']  # filtered out 'marathon'
     actual = get_assertion_definitions(sentence)
     self.assertItemsEqual(expected, actual)

 def test_compound_noun_whole(self):
     # artificial sentence
     sentence = u'Lee is an American engineer, computer scientist and computer system and internet expert.'
     expected = [u'internet expert', u'computer scientist', u'expert', u'american', u'scientist',
                 u'american engineer', u'engineer']  # filtered out 'system' and 'computer system'
     actual = get_assertion_definitions(sentence)
     self.assertItemsEqual(expected, actual)

 def test_two_of(self):
     # Artificial sentence
     sentence = u'Ben and Jerry were two of the most successful ice cream makers in the world.'
     expected = [u'maker', u'cream maker', u'ice cream maker', u'successful maker', u'world maker']
     actual, entry = get_assertion_definitions(sentence, get_rep=True)
     self.assertItemsEqual(expected, actual)
     self.assertTrue(u'[nummod: two' in entry)

 def test_plural_subject(self):
     sentence = u'Business method patents are a class of patents which disclose and claim new methods of doing business.'
     expected = [u'class', u'patent']
     actual, entry = get_assertion_definitions(sentence, subject=[u'Business method patent'], get_rep=True)
     self.assertItemsEqual(expected, actual)
     self.assertFalse(u'subject: subject_number' in entry)
     self.assertTrue(u'subject: Business method patents' in entry)

 def test_cardinal(self):
     sentence = u'Certis CISCO Security Private Limited, formerly CISCO Security Private Limited, is one of the five commercial Auxiliary Police forces authorized to provide armed security officers to government organizations as well as private companies or individuals in Singapore.'
     # Spacy awkwardly attaches [commercial] to [auxiliary police] rather
     # than to [force]
     expected = [u'commercial auxiliary police force', u'auxiliary police force', u'force', u'police force']
     actual = get_assertion_definitions(sentence, get_rep=False)
     self.assertItemsEqual(expected, actual)

 def test_ordinals_word_number_date(self):
     sentence = u'The 2001 French Open was the second Grand Slam event of 2001 and the 100th edition of the French Open.'
     expected = [u'event', u'grand slam event', u'2001 event', u'edition', u'french open edition']
     # TODO-someday: [2001] in the subject [The 2001 French Open] is
     # recognized as ROOT, so we need to help whoami by telling what the
     # subject is. Maybe try undoing this in future spacy versions.
     actual, entry = get_assertion_definitions(sentence, get_rep=True, subject=[u'The 2001 French Open'])
     self.assertItemsEqual(expected, actual)
     self.assertTrue(u'[mod: second' in entry)
     self.assertTrue(u'[mod: 100th' in entry)

 def test_phrasal_norp(self):
     sentence = u'Municipal Pérez Zeledón is a Costa Rican football team playing at the top level in the Primera Division.'
     expected = [u'costa rican team', u'team', u'football team']
     actual = get_assertion_definitions(sentence, get_rep=False)
     self.assertItemsEqual(expected, actual)

 def test_person_longer(self):
     sentence = u'Richard Harry Chapura Jr. is a former American professional football player who was a defensive tackle in the National Football League and the World League of American Football.'
     expected = [u'player', u'football player', u'former player', u'professional player', 'american player', u'american']
     actual = get_assertion_definitions(sentence, get_rep=False)
     self.assertItemsEqual(expected, actual)

 def test_number_written(self):
     sentence = u'One is the smallest integer that is strictly positive.'
     expected = [u'integer', u'smallest integer']
     actual = get_assertion_definitions(sentence, get_rep=False)
     self.assertItemsEqual(expected, actual)

 def test_number(self):
     sentence = u'5 is a lovely number.'
     expected = [u'number', u'lovely number']
     actual = get_assertion_definitions(sentence, get_rep=False)
     self.assertItemsEqual(expected, actual)

 def test_year(self):
     sentence = u'1066 (MLXVI) was a common year starting on Sunday of the Julian calendar.'
     expected = [u'common year', 'year']
     actual = get_assertion_definitions(sentence, get_rep=False)
     self.assertItemsEqual(expected, actual)

 def test_prep_before_beverb(self):
     sentence = u"Titanic Quarter in Belfast, Northern Ireland is a large-scale waterfront regeneration, comprising historic maritime landmarks, film studios, education facilities, apartments, a riverside entertainment district, and the world's largest Titanic-themed attraction centred on land in Belfast Harbour, known until 1995 as Queen's Island."
     expected = [u'waterfront regeneration', u'large-scale waterfront regeneration', u'belfast regeneration', u'regeneration']
     actual = get_assertion_definitions(sentence, get_rep=False)
     self.assertItemsEqual(expected, actual)

 def test_multiple_spaces(self):
     sentence = u'Wolfgang Amadeus Mozart, baptised as Johannes Chrysostomus Wolfgangus Theophilus Mozart, was a prolific and influential composer of the Classical era.'
     subject = [u'Wolfgang Amadeus Mozart  ', u'Johannes Chrysostomus Wolfgangus Theophilus Mozart']
     expected = [u'era composer', u'influential composer', u'prolific composer', u'composer', u'classical era composer']
     actual = get_assertion_definitions(sentence, subject)

 def test_multiple_prepositions(self):
     sentence = u"Toby Purcell or Tobias Purcell was an Irish soldier in the Williamite War in Ireland."
     expected = [u'irish soldier', u'soldier', u'irish', u'williamite war soldier', u'ireland williamite war soldier']
     actual = get_assertion_definitions(sentence, get_rep=False)
     self.assertItemsEqual(expected, actual)

 def test_species(self):
     sentence = u"Teladoma helianthi is a moth in the Cosmopterigidae family."
     expected = [u'moth', u'cosmopterigidae family moth', u'family moth']
     actual = get_assertion_definitions(sentence, get_rep=False)
     self.assertItemsEqual(expected, actual)

 def test_semicolon_separated_sentence(self):
     sentence = u'Slate Run is a tributary to the Scioto River; it flows through the Northwest corner of Upper Arlington, Ohio.'
     expected = [u'tributary']
     actual = get_assertion_definitions(sentence, get_rep=False)
     self.assertItemsEqual(expected, actual)

 def test_named_entity(self):
     sentence = u'The Son of Odin is a fictional character.'
     expected = [u'fictional character', u'character']
     actual = get_assertion_definitions(sentence, get_rep=False)
     self.assertItemsEqual(expected, actual)

 def test_complex_noun_phrases(self):
     sentence = u'Anna is a talented, smart student; avid, focused reader; and terrific listener.'
     expected = [u'talented student', u'smart student', u'terrific listener', u'focused reader', u'avid reader', u'listener', u'student', u'reader']
     actual = get_assertion_definitions(sentence, get_rep=False)
     self.assertItemsEqual(expected, actual)