def test_find_encyclopedic_informations(self): # Create several definitions def1 = Definition() def2 = Definition() self.sense.definition = [def1, def2] # Create several statements with different encyclopedic informations and languages state1 = Statement().set_encyclopedicInformation("info1", "eng") state2 = Statement().set_encyclopedicInformation("info2", "fra") state3 = Statement().set_encyclopedicInformation("info3", "eng") self.sense.definition[0].statement = [state1, state2] self.sense.definition[1].statement = [state3] # Test find encyclopedic informations self.assertListEqual(self.sense.find_encyclopedic_informations("fra"), [state2.encyclopedicInformation]) # List is randomly ordered => create a set to avoid random results self.assertEqual( set(self.sense.find_encyclopedic_informations("eng")), set([ state1.encyclopedicInformation, state3.encyclopedicInformation ])) # Release created instances del self.sense.definition[0].statement[:] del self.sense.definition[1].statement[:] del state1, state2, state3 del self.sense.definition[:] del def1, def2
def test_add_statement(self): # Create statements state1 = Statement() state2 = Statement() # Test add statements to the definition self.assertIs(self.definition.add_statement(state1), self.definition) self.assertListEqual(self.definition.statement, [state1]) self.assertIs(self.definition.add_statement(state2), self.definition) self.assertListEqual(self.definition.statement, [state1, state2]) # Release Statement instances del self.definition.statement[:] del state1, state2
def test_get_statements(self): # List of Statement instances is empty self.assertListEqual(self.definition.get_statements(), []) # Create Statement instances and add them to the list state1 = Statement() state2 = Statement() self.definition.statement = [state1, state2] # Test get statements self.assertListEqual(self.definition.get_statements(), [state1, state2]) # Delete Statement instances del self.definition.statement[:] del state1, state2
def test_get_etymology_comment(self): comment = "etymology" # Create definition and add it to the sense definition = Definition() self.sense.definition = [definition] # Create a statement and add it to the definition state = Statement() self.sense.definition[0].statement = [state] # Set etymology self.sense.definition[0].statement[0].etymologyComment = comment # Test get etymology self.assertEqual(self.sense.get_etymology_comment(), comment) # Test with a language filter language = "eng" self.sense.definition[0].statement[0].termSourceLanguage = language self.assertIsNone( self.sense.get_etymology_comment(term_source_language="fra")) self.assertEqual( self.sense.get_etymology_comment(term_source_language=language), comment) # Release created instances del self.sense.definition[0].statement[:] del state del self.sense.definition[:] del definition
def test_find_notes(self): # Create several statements with different notes, types and languages state1 = Statement().set_note("note1", "comparison", "eng") state2 = Statement().set_note("note2", "general", "fra") state3 = Statement().set_note("note3", "comparison") state4 = Statement().set_note("note4", "history") # Add statements to the definition self.definition.statement = [state1, state2, state3, state4] # Test find notes self.assertListEqual(self.definition.find_notes("general"), [state2.note]) # List is randomly ordered => create a set to avoid random results self.assertEqual(set(self.definition.find_notes("comparison")), set([state1.note, state3.note])) # Release Statement instances del self.definition.statement[:] del state1, state2, state3, state4
def test_find_restrictions(self): # Create several statements with different restrictions and languages state1 = Statement().set_restriction("only1", "eng") state2 = Statement().set_restriction("only2", "fra") state3 = Statement().set_restriction("only3", "eng") state4 = Statement().set_restriction("only4") # Add statements to the definition self.definition.statement = [state1, state2, state3, state4] # Test find usage notes self.assertListEqual(self.definition.find_restrictions("fra"), [state2.restriction]) # List is randomly ordered => create a set to avoid random results self.assertEqual(set(self.definition.find_restrictions("eng")), set([state1.restriction, state3.restriction])) # Release Statement instances del self.definition.statement[:] del state1, state2, state3, state4
def test_find_encyclopedic_informations(self): # Create several statements with different encyclopedic informations and languages state1 = Statement().set_encyclopedicInformation("info1", "eng") state2 = Statement().set_encyclopedicInformation("info2", "fra") state3 = Statement().set_encyclopedicInformation("info3", "eng") state4 = Statement().set_encyclopedicInformation("info4") # Add statements to the definition self.definition.statement = [state1, state2, state3, state4] # Test find usage notes self.assertListEqual( self.definition.find_encyclopedic_informations("fra"), [state2.encyclopedicInformation]) # List is randomly ordered => create a set to avoid random results self.assertEqual( set(self.definition.find_encyclopedic_informations("eng")), set([ state1.encyclopedicInformation, state3.encyclopedicInformation ])) # Release Statement instances del self.definition.statement[:] del state1, state2, state3, state4
def test_find_notes(self): # Create several definitions def1 = Definition() def2 = Definition() self.sense.definition = [def1, def2] # Create several statements with different notes and types state1 = Statement().set_note("note1", "comparison") state2 = Statement().set_note("note2", "general") state3 = Statement().set_note("note3", "comparison") self.sense.definition[0].statement = [state1, state2] self.sense.definition[1].statement = [state3] # Test find notes self.assertListEqual(self.sense.find_notes("general"), [state2.note]) # List is randomly ordered => create a set to avoid random results self.assertEqual(set(self.sense.find_notes("comparison")), set([state1.note, state3.note])) # Release created instances del self.sense.definition[0].statement[:] del self.sense.definition[1].statement[:] del state1, state2, state3 del self.sense.definition[:] del def1, def2
def test_get_etymology_source(self): source = "etymology" # Create a statement state = Statement() # Add statement to the definition self.definition.statement = [state] # Set etymology source self.definition.statement[0].etymologySource = source # Test get etymology source self.assertEqual(self.definition.get_etymology_source(), source) # Release Statement instance del self.definition.statement[:] del state
def test_get_scientific_name(self): name = "Maximus" # Create a statement state = Statement() # Add statement to the definition self.definition.statement = [state] # Set scientific name self.definition.statement[0].scientificName = name # Test get scientific name self.assertEqual(self.definition.get_scientific_name(), name) # Release Statement instance del self.definition.statement[:] del state
def test_get_writtenForm(self): form = "written" # Create a statement state = Statement() # Add statement to the definition self.definition.statement = [state] # Set written form self.definition.statement[0].writtenForm = form # Test get written form self.assertEqual(self.definition.get_written_form(), form) # Release Statement instance del self.definition.statement[:] del state
def test_get_etymology_gloss(self): gloss = "GLOSS" # Create a statement state = Statement() # Add statement to the definition self.definition.statement = [state] # Set etymology gloss self.definition.statement[0].etymologyGloss = gloss # Test get etymology gloss self.assertEqual(self.definition.get_etymology_gloss(), gloss) # Release Statement instance del self.definition.statement[:] del state
def test_get_etymology(self): etymology = "etymology" # Create a statement state = Statement() # Add statement to the definition self.definition.statement = [state] # Set etymology self.definition.statement[0].etymology = etymology # Test get etymology self.assertEqual(self.definition.get_etymology(), etymology) # Release Statement instance del self.definition.statement[:] del state
def test_get_borrowed_word(self): word = "borrowed" # Create a statement state = Statement() # Add statement to the definition self.definition.statement = [state] # Set borrowed word self.definition.statement[0].borrowedWord = word # Test get borrowed word self.assertEqual(self.definition.get_borrowed_word(), word) # Release Statement instance del self.definition.statement[:] del state
def test_find_usage_notes(self): # Create several definitions def1 = Definition() def2 = Definition() self.sense.definition = [def1, def2] # Create several statements with different usage notes and languages state1 = Statement().set_usageNote("note1", "eng") state2 = Statement().set_usageNote("note2", "fra") state3 = Statement().set_usageNote("note3", "eng") self.sense.definition[0].statement = [state1, state2] self.sense.definition[1].statement = [state3] # Test find usage notes self.assertListEqual(self.sense.find_usage_notes("fra"), [state2.usageNote]) # List is randomly ordered => create a set to avoid random results self.assertEqual(set(self.sense.find_usage_notes("eng")), set([state1.usageNote, state3.usageNote])) # Release created instances del self.sense.definition[0].statement[:] del self.sense.definition[1].statement[:] del state1, state2, state3 del self.sense.definition[:] del def1, def2
def test_get_borrowed_word(self): word = "borrowed" # Create definition and add it to the sense definition = Definition() self.sense.definition = [definition] # Create a statement and add it to the definition state = Statement() self.sense.definition[0].statement = [state] # Set borrowed word self.sense.definition[0].statement[0].borrowedWord = word # Test get borrowed word self.assertEqual(self.sense.get_borrowed_word(), word) # Release created instances del self.sense.definition[0].statement[:] del state del self.sense.definition[:] del definition
def test_get_writtenForm(self): form = "written" # Create definition and add it to the sense definition = Definition() self.sense.definition = [definition] # Create a statement and add it to the definition state = Statement() self.sense.definition[0].statement = [state] # Set written form self.sense.definition[0].statement[0].writtenForm = form # Test get written form self.assertEqual(self.sense.get_written_form(), form) # Release created instances del self.sense.definition[0].statement[:] del state del self.sense.definition[:] del definition
def test_get_etymology_gloss(self): gloss = "GLOSS" # Create definition and add it to the sense definition = Definition() self.sense.definition = [definition] # Create a statement and add it to the definition state = Statement() self.sense.definition[0].statement = [state] # Set etymology self.sense.definition[0].statement[0].etymologyGloss = gloss # Test get etymology self.assertEqual(self.sense.get_etymology_gloss(), gloss) # Release created instances del self.sense.definition[0].statement[:] del state del self.sense.definition[:] del definition
def test_get_etymology_source(self): source = "etymology" # Create definition and add it to the sense definition = Definition() self.sense.definition = [definition] # Create a statement and add it to the definition state = Statement() self.sense.definition[0].statement = [state] # Set etymology self.sense.definition[0].statement[0].etymologySource = source # Test get etymology self.assertEqual(self.sense.get_etymology_source(), source) # Release created instances del self.sense.definition[0].statement[:] del state del self.sense.definition[:] del definition
def test_get_scientific_name(self): name = "Nameus" # Create definition and add it to the sense definition = Definition() self.sense.definition = [definition] # Create a statement and add it to the definition state = Statement() self.sense.definition[0].statement = [state] # Set scientific name self.sense.definition[0].statement[0].scientificName = name # Test get scientific name self.assertEqual(self.sense.get_scientific_name(), name) # Release created instances del self.sense.definition[0].statement[:] del state del self.sense.definition[:] del definition
def test_get_etymology_comment(self): comment = "etymology" # Create a statement state = Statement() # Add statement to the definition self.definition.statement = [state] # Set etymology comment self.definition.statement[0].etymologyComment = comment # Test get etymology comment self.assertEqual(self.definition.get_etymology_comment(), comment) # Test with a language filter language = "eng" self.definition.statement[0].termSourceLanguage = language self.assertIsNone( self.definition.get_etymology_comment(term_source_language="fra")) self.assertEqual( self.definition.get_etymology_comment( term_source_language=language), comment) # Release Statement instance del self.definition.statement[:] del state
def setUp(self): # Instantiate a Statement object self.statement = Statement()
class TestStatementFunctions(unittest.TestCase): def setUp(self): # Instantiate a Statement object self.statement = Statement() def tearDown(self): # Release instantiated objects del self.statement def test_init(self): self.assertIsNone(self.statement.noteType) self.assertIsNone(self.statement.note) self.assertIsNone(self.statement.language) self.assertIsNone(self.statement.encyclopedicInformation) self.assertIsNone(self.statement.usageNote) self.assertIsNone(self.statement.restriction) self.assertIsNone(self.statement.derivation) self.assertIsNone(self.statement.borrowedWord) self.assertIsNone(self.statement.writtenForm) self.assertIsNone(self.statement.sense) self.assertIsNone(self.statement.etymology) self.assertIsNone(self.statement.etymologyComment) self.assertIsNone(self.statement.etymologyGloss) self.assertIsNone(self.statement.etymologySource) self.assertIsNone(self.statement.termSourceLanguage) self.assertIsNone(self.statement.targetLexicalEntry) self.assertIsNone(self.statement.scientificName) self.assertListEqual(self.statement.text_representation, []) def test_set_note(self): # Test note only note = "blablabla" self.assertIs(self.statement.set_note(note), self.statement) self.assertEqual(self.statement.note, note) # Test note and type note = "This is a note." type = "discourse" self.assertIs(self.statement.set_note(note, type), self.statement) self.assertEqual(self.statement.note, note) self.assertEqual(self.statement.noteType, type) # Test note and language note = "This is another note." language = "eng" self.assertIs(self.statement.set_note(note, language=language), self.statement) self.assertEqual(self.statement.note, note) self.assertEqual(self.statement.language, language) # Test with type and language note = "note" type = "general" language = "fra" self.assertIs(self.statement.set_note(note, type, language), self.statement) self.assertEqual(self.statement.note, note) self.assertEqual(self.statement.noteType, type) self.assertEqual(self.statement.language, language) def test_get_note(self): # Set note note = "whatever" self.statement.note = note # Test get note self.assertEqual(self.statement.get_note(), note) # Test with a type filter type = "anthropology" self.statement.noteType = type self.assertIsNone(self.statement.get_note("sociolinguistics")) self.assertEqual(self.statement.get_note(type), note) # Test with a language filter language = "eng" self.statement.language = language self.assertIsNone(self.statement.get_note(language="fra")) self.assertEqual(self.statement.get_note(language=language), note) # Test with both filters type = "comment" language = "bla" self.statement.noteType = type self.statement.language = language self.assertIsNone(self.statement.get_note("usage", "eng")) self.assertIsNone(self.statement.get_note(type, "eng")) self.assertIsNone(self.statement.get_note("usage", language)) self.assertEqual(self.statement.get_note(type, language), note) def test_set_language(self): lang = "Python" self.assertIs(self.statement.set_language(lang), self.statement) self.assertEqual(self.statement.language, lang) def test_get_language(self): # Set language lang = "python" self.statement.language = lang # Test get language self.assertEqual(self.statement.get_language(), lang) def test_set_noteType(self): # Test error case self.statement.set_noteType("whatever") # Test nominal case type = "phonology" self.assertIs(self.statement.set_noteType(type), self.statement) self.assertEqual(self.statement.noteType, type) def test_get_noteType(self): # Set note type type = "whatever" self.statement.noteType = type # Test get note type self.assertEqual(self.statement.get_noteType(), type) def test_set_usageNote(self): # Test usage note only note = "blablabla" self.assertIs(self.statement.set_usageNote(note), self.statement) self.assertEqual(self.statement.usageNote, note) # Test usage note and language note = "This is another usage note." language = "eng" self.assertIs(self.statement.set_usageNote(note, language=language), self.statement) self.assertEqual(self.statement.usageNote, note) self.assertEqual(self.statement.language, language) def test_get_usageNote(self): # Set usage note note = "whatever" self.statement.usageNote = note # Test get usage note self.assertEqual(self.statement.get_usageNote(), note) # Test with a language filter language = "eng" self.statement.language = language self.assertIsNone(self.statement.get_usageNote(language="fra")) self.assertEqual(self.statement.get_usageNote(language=language), note) def test_set_encyclopedicInformation(self): # Test encyclopedic information only info = "blablabla" self.assertIs(self.statement.set_encyclopedicInformation(info), self.statement) self.assertEqual(self.statement.encyclopedicInformation, info) # Test encyclopedic information and language info = "This is another encyclopedic information." language = "eng" self.assertIs(self.statement.set_encyclopedicInformation(info, language=language), self.statement) self.assertEqual(self.statement.encyclopedicInformation, info) self.assertEqual(self.statement.language, language) def test_get_encyclopedicInformation(self): # Set encyclopedic information info = "whatever" self.statement.encyclopedicInformation = info # Test get encyclopedic information self.assertEqual(self.statement.get_encyclopedicInformation(), info) # Test with a language filter language = "eng" self.statement.language = language self.assertIsNone(self.statement.get_encyclopedicInformation(language="fra")) self.assertEqual(self.statement.get_encyclopedicInformation(language=language), info) def test_set_restriction(self): # Test restriction only only = "blablabla" self.assertIs(self.statement.set_restriction(only), self.statement) self.assertEqual(self.statement.restriction, only) # Test encyclopedic information and language only = "This is another restriction." language = "eng" self.assertIs(self.statement.set_restriction(only, language=language), self.statement) self.assertEqual(self.statement.restriction, only) self.assertEqual(self.statement.language, language) def test_get_restriction(self): # Set restriction only = "whatever" self.statement.restriction = only # Test get restriction self.assertEqual(self.statement.get_restriction(), only) # Test with a language filter language = "eng" self.statement.language = language self.assertIsNone(self.statement.get_restriction(language="fra")) self.assertEqual(self.statement.get_restriction(language=language), only) def test_set_borrowedWord(self): word = "borrowed" self.assertIs(self.statement.set_borrowedWord(word), self.statement) self.assertEqual(self.statement.borrowedWord, word) def test_get_borrowedWord(self): # Set borrowed word word = "borrowed" self.statement.borrowedWord = word # Test get borrowed word self.assertEqual(self.statement.get_borrowedWord(), word) def test_set_writtenForm(self): form = "written" self.assertIs(self.statement.set_writtenForm(form), self.statement) self.assertEqual(self.statement.writtenForm, form) def test_get_writtenForm(self): # Set written form form = "written" self.statement.writtenForm = form # Test get written form self.assertEqual(self.statement.get_writtenForm(), form) def test_set_etymology(self): etymology = "etymology" self.assertIs(self.statement.set_etymology(etymology), self.statement) self.assertEqual(self.statement.etymology, etymology) def test_get_etymology(self): # Set etymology etymology = "etymology" self.statement.etymology = etymology # Test get etymology self.assertEqual(self.statement.get_etymology(), etymology) def test_set_etymologyComment(self): # Test etymology comment only comment = "etymology" self.assertIs(self.statement.set_etymologyComment(comment), self.statement) self.assertEqual(self.statement.etymologyComment, comment) # Test etymology comment and language commentaire = "etymologie" langage = "fra" self.assertIs(self.statement.set_etymologyComment(commentaire, term_source_language=langage), self.statement) self.assertEqual(self.statement.etymologyComment, commentaire) self.assertEqual(self.statement.termSourceLanguage, langage) def test_get_etymologyComment(self): # Set etymology comment comment = "etymology" self.statement.etymologyComment = comment # Test get etymology self.assertEqual(self.statement.get_etymologyComment(), comment) # Test with a language filter language = "eng" self.statement.termSourceLanguage = language self.assertIsNone(self.statement.get_etymologyComment(term_source_language="fra")) self.assertEqual(self.statement.get_etymologyComment(term_source_language=language), comment) def test_set_termSourceLanguage(self): lang = "source" self.assertIs(self.statement.set_termSourceLanguage(lang), self.statement) self.assertEqual(self.statement.termSourceLanguage, lang) def test_get_termSourceLanguage(self): # Set language lang = "source" self.statement.termSourceLanguage = lang # Test get language self.assertEqual(self.statement.get_termSourceLanguage(), lang) def test_set_etymologyGloss(self): gloss = "GLOSS" self.assertIs(self.statement.set_etymologyGloss(gloss), self.statement) self.assertEqual(self.statement.etymologyGloss, gloss) def test_get_etymologyGloss(self): # Set etymology gloss gloss = "GLOSS" self.statement.etymologyGloss = gloss # Test get etymology gloss self.assertEqual(self.statement.get_etymologyGloss(), gloss) def test_set_etymologySource(self): source = "etymology" self.assertIs(self.statement.set_etymologySource(source), self.statement) self.assertEqual(self.statement.etymologySource, source) def test_get_etymologySource(self): # Set etymology source source = "etymology" self.statement.etymologySource = source # Test get etymology source self.assertEqual(self.statement.get_etymologySource(), source) def test_set_scientificName(self): name = "Latinus" self.assertIs(self.statement.set_scientificName(name), self.statement) self.assertEqual(self.statement.scientificName, name) def test_get_scientificName(self): # Set scientific name name = "Grecus" self.statement.scientificName = name # Test get scientific name self.assertEqual(self.statement.get_scientificName(), name)
def create_statement(self): """! @brief Create a Statement instance. @return Statement instance. """ return Statement()