def test_format_rf(self): sense = Sense() expected = "" self.assertEqual(format_rf(sense, font), expected) del sense
def setUp(self): # Instantiate a Sense object self.sense = Sense()
class TestSenseFunctions(unittest.TestCase): def setUp(self): # Instantiate a Sense object self.sense = Sense() def tearDown(self): # Release instantiated objects del self.sense def test_init(self): self.assertIsNone(self.sense.senseNumber) self.assertEqual(self.sense.id, 0) self.assertListEqual(self.sense.definition, []) self.assertListEqual(self.sense.sense, []) self.assertListEqual(self.sense.equivalent, []) self.assertListEqual(self.sense.context, []) self.assertListEqual(self.sense.subject_field, []) self.assertListEqual(self.sense.paradigm, []) def test_get_id(self): self.assertIs(self.sense.get_id(), self.sense.id) def test_set_senseNumber(self): nb = 123 self.assertIs(self.sense.set_senseNumber(nb), self.sense) self.assertEqual(self.sense.senseNumber, nb) def test_get_senseNumner(self): nb = 456 self.sense.senseNumber = nb self.assertEqual(self.sense.get_senseNumber(), nb) def test_create_definition(self): # Test create definition definition = self.sense.create_definition() self.assertIsInstance(definition, Definition) # Release Definition instance del definition def test_add_definition(self): # Create definitions def1 = Definition() def2 = Definition() # Test add definitions to the sense self.assertIs(self.sense.add_definition(def1), self.sense) self.assertListEqual(self.sense.definition, [def1]) self.assertIs(self.sense.add_definition(def2), self.sense) self.assertListEqual(self.sense.definition, [def1, def2]) # Release Definition instances del self.sense.definition[:] del def1, def2 def test_get_definitions(self): # List of Definition instances is empty self.assertListEqual(self.sense.get_definitions(), []) # Create Definition instances and add them to the list def1 = Definition() def2 = Definition() self.sense.definition = [def1, def2] # Test get definitions self.assertListEqual(self.sense.get_definitions(), [def1, def2]) # Delete Definition instances del self.sense.definition[:] del def1, def2 def test_get_last_definition(self): # List of Definition instances is empty self.assertIsNone(self.sense.get_last_definition()) # Create Definition instances and add them to the list def1 = Definition() def2 = Definition() self.sense.definition = [def1, def2] # Test get last definition self.assertIs(self.sense.get_last_definition(), def2) self.sense.definition.pop() self.assertIs(self.sense.get_last_definition(), def1) # Release Definition instances del self.sense.definition[:] del def1, def2 def test_find_definitions(self): # Create several definitions with different languages def1 = Definition().set_definition("def1").set_language("fra") def2 = Definition().set_definition("def2").set_language("eng") def3 = Definition().set_definition("def3").set_language("fra") def4 = Definition().set_definition("def4").set_language("srp") # Add definitions to the sense self.sense.definition = [def1, def2, def3, def4] # Test find definitions self.assertListEqual(self.sense.find_definitions("eng"), [def2.definition]) # List is randomly ordered => create a set to avoid random results self.assertEqual(set(self.sense.find_definitions("fra")), set([def1.definition, def3.definition])) # Release Definition instances del self.sense.definition[:] del def1, def2, def3, def4 def test_set_definition(self): definition = "#define" # There is no Definition instance self.assertIs(self.sense.set_definition(definition), self.sense) self.assertEqual(len(self.sense.definition), 1) self.assertEqual(self.sense.definition[0].definition, definition) # Test set a second definition language = "C++" self.assertIs(self.sense.set_definition(definition, language), self.sense) self.assertEqual(len(self.sense.definition), 2) self.assertEqual(self.sense.definition[1].definition, definition) self.assertEqual(self.sense.definition[1].language, language) def test_find_glosses(self): # Create several definitions with different glosses and languages def1 = Definition().set_gloss("DEF1").set_language("fra") def2 = Definition().set_gloss("DEF2").set_language("eng") def3 = Definition().set_gloss("DEF3").set_language("fra") def4 = Definition().set_gloss("DEF4").set_language("srp") # Add definitions to the sense self.sense.definition = [def1, def2, def3, def4] # Test find glosses self.assertListEqual(self.sense.find_glosses("eng"), [def2.gloss]) # List is randomly ordered => create a set to avoid random results self.assertEqual(set(self.sense.find_glosses("fra")), set([def1.gloss, def3.gloss])) # Release Definition instances del self.sense.definition[:] del def1, def2, def3, def4 def test_set_gloss(self): gloss = "GLOSS" # There is no Definition instance self.assertIs(self.sense.set_gloss(gloss), self.sense) self.assertEqual(len(self.sense.definition), 1) self.assertEqual(self.sense.definition[0].gloss, gloss) # Test set a second gloss language = "C++" self.assertIs(self.sense.set_gloss(gloss, language), self.sense) self.assertEqual(len(self.sense.definition), 2) self.assertEqual(self.sense.definition[1].gloss, gloss) self.assertEqual(self.sense.definition[1].language, language) def test_set_note(self): note = "note" # There is no Definition instance self.assertIs(self.sense.set_note(note), self.sense) self.assertEqual(len(self.sense.definition), 1) self.assertEqual(len(self.sense.definition[0].statement), 1) self.assertEqual(self.sense.definition[0].statement[0].note, note) # Test set a second note language = "C++" self.assertIs(self.sense.set_note(note, language=language), self.sense) self.assertEqual(len(self.sense.definition), 1) self.assertEqual(len(self.sense.definition[0].statement), 2) self.assertEqual(self.sense.definition[0].statement[1].note, note) self.assertEqual(self.sense.definition[0].statement[1].language, language) 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_set_usage_note(self): note = "note" # There is no Definition instance self.assertIs(self.sense.set_usage_note(note), self.sense) self.assertEqual(len(self.sense.definition), 1) self.assertEqual(len(self.sense.definition[0].statement), 1) self.assertEqual(self.sense.definition[0].statement[0].usageNote, note) # Test set a second usage note language = "C++" self.assertIs(self.sense.set_usage_note(note, language=language), self.sense) self.assertEqual(len(self.sense.definition), 1) self.assertEqual(len(self.sense.definition[0].statement), 2) self.assertEqual(self.sense.definition[0].statement[1].usageNote, note) self.assertEqual(self.sense.definition[0].statement[1].language, language) 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_set_encyclopedic_information(self): info = "encyclopedic" # There is no Definition instance self.assertIs(self.sense.set_encyclopedic_information(info), self.sense) self.assertEqual(len(self.sense.definition), 1) self.assertEqual(len(self.sense.definition[0].statement), 1) self.assertEqual(self.sense.definition[0].statement[0].encyclopedicInformation, info) # Test set a second encyclopedic information language = "C++" self.assertIs(self.sense.set_encyclopedic_information(info, language=language), self.sense) self.assertEqual(len(self.sense.definition), 1) self.assertEqual(len(self.sense.definition[0].statement), 2) self.assertEqual(self.sense.definition[0].statement[1].encyclopedicInformation, info) self.assertEqual(self.sense.definition[0].statement[1].language, language) 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_set_restriction(self): only = "restriction" # There is no Definition instance self.assertIs(self.sense.set_restriction(only), self.sense) self.assertEqual(len(self.sense.definition), 1) self.assertEqual(len(self.sense.definition[0].statement), 1) self.assertEqual(self.sense.definition[0].statement[0].restriction, only) # Test set a second restriction language = "C++" self.assertIs(self.sense.set_restriction(only, language=language), self.sense) self.assertEqual(len(self.sense.definition), 1) self.assertEqual(len(self.sense.definition[0].statement), 2) self.assertEqual(self.sense.definition[0].statement[1].restriction, only) self.assertEqual(self.sense.definition[0].statement[1].language, language) def test_find_restrictions(self): # Create several definitions def1 = Definition() def2 = Definition() self.sense.definition = [def1, def2] # 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") self.sense.definition[0].statement = [state1, state2] self.sense.definition[1].statement = [state3] # Test find restrictions self.assertListEqual(self.sense.find_restrictions("fra"), [state2.restriction]) # List is randomly ordered => create a set to avoid random results self.assertEqual(set(self.sense.find_restrictions("eng")), set([state1.restriction, state3.restriction])) # 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_set_borrowed_word(self): word = "borrowed" # There is no Definition instance self.assertIs(self.sense.set_borrowed_word(word), self.sense) self.assertEqual(len(self.sense.definition), 1) self.assertEqual(len(self.sense.definition[0].statement), 1) self.assertEqual(self.sense.definition[0].statement[0].borrowedWord, word) 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_set_writtenForm(self): form = "written" # There is no Definition instance self.assertIs(self.sense.set_written_form(form), self.sense) self.assertEqual(len(self.sense.definition), 1) self.assertEqual(len(self.sense.definition[0].statement), 1) self.assertEqual(self.sense.definition[0].statement[0].writtenForm, form) 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_set_etymology(self): etymology = "etymology" # There is no Definition instance self.assertIs(self.sense.set_etymology(etymology), self.sense) self.assertEqual(len(self.sense.definition), 1) self.assertEqual(len(self.sense.definition[0].statement), 1) self.assertEqual(self.sense.definition[0].statement[0].etymology, etymology) def test_get_etymology(self): etymology = "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].etymology = etymology # Test get etymology self.assertEqual(self.sense.get_etymology(), etymology) # Release created instances del self.sense.definition[0].statement[:] del state del self.sense.definition[:] del definition def test_set_etymology_comment(self): # Test etymology comment only comment = "etymology" # There is no Definition instance self.assertIs(self.sense.set_etymology_comment(comment), self.sense) self.assertEqual(len(self.sense.definition), 1) self.assertEqual(len(self.sense.definition[0].statement), 1) self.assertEqual(self.sense.definition[0].statement[0].etymologyComment, comment) # Test etymology comment and language commentaire = "etymologie" langage = "fra" self.assertIs(self.sense.set_etymology_comment(commentaire, term_source_language=langage), self.sense) self.assertEqual(self.sense.definition[0].statement[0].etymologyComment, commentaire) self.assertEqual(self.sense.definition[0].statement[0].termSourceLanguage, langage) 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_set_etymology_gloss(self): gloss = "GLOSS" # There is no Definition instance self.assertIs(self.sense.set_etymology_gloss(gloss), self.sense) self.assertEqual(len(self.sense.definition), 1) self.assertEqual(len(self.sense.definition[0].statement), 1) self.assertEqual(self.sense.definition[0].statement[0].etymologyGloss, gloss) 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_set_etymology_source(self): source = "etymology" # There is no Definition instance self.assertIs(self.sense.set_etymology_source(source), self.sense) self.assertEqual(len(self.sense.definition), 1) self.assertEqual(len(self.sense.definition[0].statement), 1) self.assertEqual(self.sense.definition[0].statement[0].etymologySource, source) 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_set_scientific_name(self): name = "Scientificus" # There is no Definition instance self.assertIs(self.sense.set_scientific_name(name), self.sense) self.assertEqual(len(self.sense.definition), 1) self.assertEqual(len(self.sense.definition[0].statement), 1) self.assertEqual(self.sense.definition[0].statement[0].scientificName, name) 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_create_paradigm(self): # Test create paradigm paradigm = self.sense.create_paradigm() self.assertIsInstance(paradigm, Paradigm) # Release Paradigm instance del paradigm def test_add_paradigm(self): # Create paradigms para1 = Paradigm() para2 = Paradigm() # Test add paradigms to the sense self.assertIs(self.sense.add_paradigm(para1), self.sense) self.assertListEqual(self.sense.paradigm, [para1]) self.assertIs(self.sense.add_paradigm(para2), self.sense) self.assertListEqual(self.sense.paradigm, [para1, para2]) # Release Paradigm instances del self.sense.paradigm[:] del para1, para2 def test_get_paradigms(self): # List of Paradigm instances is empty self.assertListEqual(self.sense.get_paradigms(), []) # Create Paradigm instances and add them to the list para1 = Paradigm() para2 = Paradigm() self.sense.paradigm = [para1, para2] # Test get paradigms self.assertListEqual(self.sense.get_paradigms(), [para1, para2]) # Delete Paradigm instances del self.sense.paradigm[:] del para1, para2 def test_get_last_paradigm(self): # List of Paradigm instances is empty self.assertIsNone(self.sense.get_last_paradigm()) # Create Paradigm instances and add them to the list para1 = Paradigm() para2 = Paradigm() self.sense.paradigm = [para1, para2] # Test get last paradigm self.assertIs(self.sense.get_last_paradigm(), para2) self.sense.paradigm.pop() self.assertIs(self.sense.get_last_paradigm(), para1) # Release Paradigm instances del self.sense.paradigm[:] del para1, para2 def test_set_paradigm_label(self): label = "construction" # There is no Paradigm instance self.assertIs(self.sense.set_paradigm_label(label), self.sense) self.assertEqual(len(self.sense.paradigm), 1) self.assertEqual(self.sense.paradigm[0].paradigmLabel, label) # Test error case label = "whatever" self.sense.set_paradigm_label(label) def test_set_paradigm_form(self): # Test paradigm form only form = "paradigm" # There is no Paradigm instance self.assertIs(self.sense.set_paradigm_form(form), self.sense) self.assertEqual(len(self.sense.paradigm), 1) self.assertEqual(self.sense.paradigm[0].paradigm, form) # Test paradigm form and language form = "paradigme" langage = "fra" self.assertIs(self.sense.set_paradigm_form(form, langage), self.sense) self.assertEqual(len(self.sense.paradigm), 2) self.assertEqual(self.sense.paradigm[1].paradigm, form) self.assertEqual(self.sense.paradigm[1].language, langage) def test_set_morphology(self): morpho = "morpho" # There is no Paradigm instance self.assertIs(self.sense.set_morphology(morpho), self.sense) self.assertEqual(len(self.sense.paradigm), 1) self.assertEqual(self.sense.paradigm[0].morphology, morpho) def test_create_and_add_context(self): # Test create context context1 = self.sense.create_and_add_context() self.assertIsInstance(context1, Context) # Create another context context2 = self.sense.create_and_add_context() self.assertIsInstance(context2, Context) # Test add context self.assertListEqual(self.sense.context, [context1, context2]) # Release Context instances del self.sense.context[:] del context1, context2 def test_get_contexts(self): # List of Context instances is empty self.assertListEqual(self.sense.get_contexts(), []) # Create Context instances and add them to the list ctx1 = Context() ctx2 = Context() self.sense.context = [ctx1, ctx2] # Test get contexts self.assertListEqual(self.sense.get_contexts(), [ctx1, ctx2]) # Delete Context instances del self.sense.context[:] del ctx1, ctx2 def test_get_last_context(self): # List of Context instances is empty self.assertIsNone(self.sense.get_last_context()) # Create Context instances and add them to the list ctx1 = Context() ctx2 = Context() self.sense.context = [ctx1, ctx2] # Test get last context self.assertIs(self.sense.get_last_context(), ctx2) self.sense.context.pop() self.assertIs(self.sense.get_last_context(), ctx1) # Release Context instances del self.sense.context[:] del ctx1, ctx2 def test_create_example(self): ref = "toto" self.assertIs(self.sense.create_example(ref), self.sense) self.assertEqual(len(self.sense.context), 1) self.assertEqual(self.sense.context[0].type, "example") self.assertEqual(self.sense.context[0].targets, ref) self.assertEqual(len(self.sense.context[0].text_representation), 0) def test_create_and_add_example(self): form = "written" self.assertIs(self.sense.create_and_add_example(form), self.sense) self.assertEqual(len(self.sense.context), 1) self.assertEqual(self.sense.context[0].type, "example") self.assertEqual(len(self.sense.context[0].text_representation), 1) self.assertEqual(self.sense.context[0].text_representation[0].writtenForm, form) # Test with language form = "form with lang" lang = "lang" self.assertIs(self.sense.create_and_add_example(form, lang), self.sense) self.assertEqual(len(self.sense.context), 2) self.assertEqual(self.sense.context[1].type, "example") self.assertEqual(len(self.sense.context[1].text_representation), 1) self.assertEqual(self.sense.context[1].text_representation[0].writtenForm, form) self.assertEqual(self.sense.context[1].text_representation[0].language, lang) def test_add_example(self): form = "written" self.assertIs(self.sense.add_example(form), self.sense) self.assertEqual(len(self.sense.context), 1) self.assertEqual(self.sense.context[0].type, "example") self.assertEqual(len(self.sense.context[0].text_representation), 1) self.assertEqual(self.sense.context[0].text_representation[0].writtenForm, form) # Test with language form = "form with lang" lang = "lang" self.assertIs(self.sense.add_example(form, lang), self.sense) self.assertEqual(len(self.sense.context), 1) self.assertEqual(self.sense.context[0].type, "example") self.assertEqual(len(self.sense.context[0].text_representation), 2) self.assertEqual(self.sense.context[0].text_representation[1].writtenForm, form) self.assertEqual(self.sense.context[0].text_representation[1].language, lang) def test_set_example_comment(self): comment = "example" self.assertIs(self.sense.set_example_comment(comment), self.sense) self.assertEqual(len(self.sense.context), 1) self.assertEqual(self.sense.context[0].type, "example") self.assertEqual(len(self.sense.context[0].text_representation), 1) self.assertEqual(self.sense.context[0].text_representation[0].comment, comment) # Test with a second comment comment = "another" self.assertIs(self.sense.set_example_comment(comment), self.sense) self.assertEqual(len(self.sense.context), 1) self.assertEqual(self.sense.context[0].type, "example") self.assertEqual(len(self.sense.context[0].text_representation), 2) self.assertEqual(self.sense.context[0].text_representation[1].comment, comment) def test_create_and_add_subject_field(self): # Test create subject field subject = self.sense.create_and_add_subject_field() self.assertIsInstance(subject, SubjectField) # Create another subject field field = self.sense.create_and_add_subject_field() self.assertIsInstance(field, SubjectField) # Test add subject fields self.assertListEqual(self.sense.subject_field, [subject, field]) # Release SubjectField instances del self.sense.subject_field[:] del subject, field def test_get_subject_fields(self): # List of SubjectField instances is empty self.assertListEqual(self.sense.get_subject_fields(), []) # Create SubjectField instances and add them to the list subject = SubjectField() field = SubjectField() self.sense.subject_field = [subject, field] # Test get subject fields self.assertListEqual(self.sense.get_subject_fields(), [subject, field]) # Delete SubjectField instances del self.sense.subject_field[:] del subject, field def test_set_semantic_domain(self): domain = "semantic" self.assertIs(self.sense.set_semantic_domain(domain), self.sense) self.assertEqual(len(self.sense.subject_field), 1) self.assertEqual(self.sense.subject_field[0].semanticDomain, domain) # Test with language domain = "domain with lang" lang = "lang" self.assertIs(self.sense.set_semantic_domain(domain, lang), self.sense) self.assertEqual(len(self.sense.subject_field), 2) self.assertEqual(self.sense.subject_field[1].semanticDomain, domain) self.assertEqual(self.sense.subject_field[1].language, lang) def test_create_and_add_equivalent(self): # Test create equivalent equivalent1 = self.sense.create_and_add_equivalent() self.assertIsInstance(equivalent1, Equivalent) # Create another equivalent equivalent2 = self.sense.create_and_add_equivalent() self.assertIsInstance(equivalent2, Equivalent) # Test add equivalents self.assertListEqual(self.sense.equivalent, [equivalent1, equivalent2]) # Release Equivalent instances del self.sense.equivalent[:] del equivalent1, equivalent2 def test_get_equivalents(self): # List of Equivalent instances is empty self.assertListEqual(self.sense.get_equivalents(), []) # Create Equivalent instances and add them to the list equivalent1 = Equivalent() equivalent2 = Equivalent() self.sense.equivalent = [equivalent1, equivalent2] # Test get equivalents self.assertListEqual(self.sense.get_equivalents(), [equivalent1, equivalent2]) # Delete Equivalent instances del self.sense.equivalent[:] del equivalent1, equivalent2 def test_set_translation(self): trans = "trans" self.assertIs(self.sense.set_translation(trans), self.sense) self.assertEqual(len(self.sense.equivalent), 1) self.assertEqual(self.sense.equivalent[0].translation, trans) # Test with language trans = "trans with lang" lang = "lang" self.assertIs(self.sense.set_translation(trans, lang), self.sense) self.assertEqual(len(self.sense.equivalent), 2) self.assertEqual(self.sense.equivalent[1].translation, trans) self.assertEqual(self.sense.equivalent[1].language, lang) def test_get_translations(self): # List of Equivalent instances is empty self.assertListEqual(self.sense.get_translations(), []) # Create Equivalent instances and add them to the list equivalent1 = Equivalent() equivalent2 = Equivalent() self.sense.equivalent = [equivalent1, equivalent2] # Set their translations trans1 = "trans1" trans2 = "trans2" equivalent1.translation = trans1 # Test get translations self.assertListEqual(self.sense.get_translations(), [trans1]) equivalent2.translation = trans2 self.assertListEqual(self.sense.get_translations(), [trans1, trans2]) # Test with a language filter lang = "lang" equivalent2.language = lang self.assertListEqual(self.sense.get_translations(), [trans1, trans2]) self.assertListEqual(self.sense.get_translations("eng"), []) self.assertListEqual(self.sense.get_translations(lang), [trans2]) # Delete Equivalent instances del self.sense.equivalent[:] del equivalent1, equivalent2
def create_sense(self, id=0): """! @brief Create a sense. @param id Identifier. @return Sense instance. """ return Sense(id)
class TestSenseFunctions(unittest.TestCase): def setUp(self): # Instantiate a Sense object self.sense = Sense() def tearDown(self): # Release instantiated objects del self.sense def test_init(self): self.assertIsNone(self.sense.senseNumber) self.assertEqual(self.sense.id, 0) self.assertListEqual(self.sense.definition, []) self.assertListEqual(self.sense.sense, []) self.assertListEqual(self.sense.equivalent, []) self.assertListEqual(self.sense.context, []) self.assertListEqual(self.sense.subject_field, []) self.assertListEqual(self.sense.paradigm, []) def test_get_id(self): self.assertIs(self.sense.get_id(), self.sense.id) def test_set_senseNumber(self): nb = 123 self.assertIs(self.sense.set_senseNumber(nb), self.sense) self.assertEqual(self.sense.senseNumber, nb) def test_get_senseNumner(self): nb = 456 self.sense.senseNumber = nb self.assertEqual(self.sense.get_senseNumber(), nb) def test_create_definition(self): # Test create definition definition = self.sense.create_definition() self.assertIsInstance(definition, Definition) # Release Definition instance del definition def test_add_definition(self): # Create definitions def1 = Definition() def2 = Definition() # Test add definitions to the sense self.assertIs(self.sense.add_definition(def1), self.sense) self.assertListEqual(self.sense.definition, [def1]) self.assertIs(self.sense.add_definition(def2), self.sense) self.assertListEqual(self.sense.definition, [def1, def2]) # Release Definition instances del self.sense.definition[:] del def1, def2 def test_get_definitions(self): # List of Definition instances is empty self.assertListEqual(self.sense.get_definitions(), []) # Create Definition instances and add them to the list def1 = Definition() def2 = Definition() self.sense.definition = [def1, def2] # Test get definitions self.assertListEqual(self.sense.get_definitions(), [def1, def2]) # Delete Definition instances del self.sense.definition[:] del def1, def2 def test_get_last_definition(self): # List of Definition instances is empty self.assertIsNone(self.sense.get_last_definition()) # Create Definition instances and add them to the list def1 = Definition() def2 = Definition() self.sense.definition = [def1, def2] # Test get last definition self.assertIs(self.sense.get_last_definition(), def2) self.sense.definition.pop() self.assertIs(self.sense.get_last_definition(), def1) # Release Definition instances del self.sense.definition[:] del def1, def2 def test_find_definitions(self): # Create several definitions with different languages def1 = Definition().set_definition("def1").set_language("fra") def2 = Definition().set_definition("def2").set_language("eng") def3 = Definition().set_definition("def3").set_language("fra") def4 = Definition().set_definition("def4").set_language("srp") # Add definitions to the sense self.sense.definition = [def1, def2, def3, def4] # Test find definitions self.assertListEqual(self.sense.find_definitions("eng"), [def2.definition]) # List is randomly ordered => create a set to avoid random results self.assertEqual(set(self.sense.find_definitions("fra")), set([def1.definition, def3.definition])) # Release Definition instances del self.sense.definition[:] del def1, def2, def3, def4 def test_set_definition(self): definition = "#define" # There is no Definition instance self.assertIs(self.sense.set_definition(definition), self.sense) self.assertEqual(len(self.sense.definition), 1) self.assertEqual(self.sense.definition[0].definition, definition) # Test set a second definition language = "C++" self.assertIs(self.sense.set_definition(definition, language), self.sense) self.assertEqual(len(self.sense.definition), 2) self.assertEqual(self.sense.definition[1].definition, definition) self.assertEqual(self.sense.definition[1].language, language) def test_find_glosses(self): # Create several definitions with different glosses and languages def1 = Definition().set_gloss("DEF1").set_language("fra") def2 = Definition().set_gloss("DEF2").set_language("eng") def3 = Definition().set_gloss("DEF3").set_language("fra") def4 = Definition().set_gloss("DEF4").set_language("srp") # Add definitions to the sense self.sense.definition = [def1, def2, def3, def4] # Test find glosses self.assertListEqual(self.sense.find_glosses("eng"), [def2.gloss]) # List is randomly ordered => create a set to avoid random results self.assertEqual(set(self.sense.find_glosses("fra")), set([def1.gloss, def3.gloss])) # Release Definition instances del self.sense.definition[:] del def1, def2, def3, def4 def test_set_gloss(self): gloss = "GLOSS" # There is no Definition instance self.assertIs(self.sense.set_gloss(gloss), self.sense) self.assertEqual(len(self.sense.definition), 1) self.assertEqual(self.sense.definition[0].gloss, gloss) # Test set a second gloss language = "C++" self.assertIs(self.sense.set_gloss(gloss, language), self.sense) self.assertEqual(len(self.sense.definition), 2) self.assertEqual(self.sense.definition[1].gloss, gloss) self.assertEqual(self.sense.definition[1].language, language) def test_set_note(self): note = "note" # There is no Definition instance self.assertIs(self.sense.set_note(note), self.sense) self.assertEqual(len(self.sense.definition), 1) self.assertEqual(len(self.sense.definition[0].statement), 1) self.assertEqual(self.sense.definition[0].statement[0].note, note) # Test set a second note language = "C++" self.assertIs(self.sense.set_note(note, language=language), self.sense) self.assertEqual(len(self.sense.definition), 1) self.assertEqual(len(self.sense.definition[0].statement), 2) self.assertEqual(self.sense.definition[0].statement[1].note, note) self.assertEqual(self.sense.definition[0].statement[1].language, language) 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_set_usage_note(self): note = "note" # There is no Definition instance self.assertIs(self.sense.set_usage_note(note), self.sense) self.assertEqual(len(self.sense.definition), 1) self.assertEqual(len(self.sense.definition[0].statement), 1) self.assertEqual(self.sense.definition[0].statement[0].usageNote, note) # Test set a second usage note language = "C++" self.assertIs(self.sense.set_usage_note(note, language=language), self.sense) self.assertEqual(len(self.sense.definition), 1) self.assertEqual(len(self.sense.definition[0].statement), 2) self.assertEqual(self.sense.definition[0].statement[1].usageNote, note) self.assertEqual(self.sense.definition[0].statement[1].language, language) 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_set_encyclopedic_information(self): info = "encyclopedic" # There is no Definition instance self.assertIs(self.sense.set_encyclopedic_information(info), self.sense) self.assertEqual(len(self.sense.definition), 1) self.assertEqual(len(self.sense.definition[0].statement), 1) self.assertEqual( self.sense.definition[0].statement[0].encyclopedicInformation, info) # Test set a second encyclopedic information language = "C++" self.assertIs( self.sense.set_encyclopedic_information(info, language=language), self.sense) self.assertEqual(len(self.sense.definition), 1) self.assertEqual(len(self.sense.definition[0].statement), 2) self.assertEqual( self.sense.definition[0].statement[1].encyclopedicInformation, info) self.assertEqual(self.sense.definition[0].statement[1].language, language) 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_set_restriction(self): only = "restriction" # There is no Definition instance self.assertIs(self.sense.set_restriction(only), self.sense) self.assertEqual(len(self.sense.definition), 1) self.assertEqual(len(self.sense.definition[0].statement), 1) self.assertEqual(self.sense.definition[0].statement[0].restriction, only) # Test set a second restriction language = "C++" self.assertIs(self.sense.set_restriction(only, language=language), self.sense) self.assertEqual(len(self.sense.definition), 1) self.assertEqual(len(self.sense.definition[0].statement), 2) self.assertEqual(self.sense.definition[0].statement[1].restriction, only) self.assertEqual(self.sense.definition[0].statement[1].language, language) def test_find_restrictions(self): # Create several definitions def1 = Definition() def2 = Definition() self.sense.definition = [def1, def2] # 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") self.sense.definition[0].statement = [state1, state2] self.sense.definition[1].statement = [state3] # Test find restrictions self.assertListEqual(self.sense.find_restrictions("fra"), [state2.restriction]) # List is randomly ordered => create a set to avoid random results self.assertEqual(set(self.sense.find_restrictions("eng")), set([state1.restriction, state3.restriction])) # 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_set_borrowed_word(self): word = "borrowed" # There is no Definition instance self.assertIs(self.sense.set_borrowed_word(word), self.sense) self.assertEqual(len(self.sense.definition), 1) self.assertEqual(len(self.sense.definition[0].statement), 1) self.assertEqual(self.sense.definition[0].statement[0].borrowedWord, word) 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_set_writtenForm(self): form = "written" # There is no Definition instance self.assertIs(self.sense.set_written_form(form), self.sense) self.assertEqual(len(self.sense.definition), 1) self.assertEqual(len(self.sense.definition[0].statement), 1) self.assertEqual(self.sense.definition[0].statement[0].writtenForm, form) 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_set_etymology(self): etymology = "etymology" # There is no Definition instance self.assertIs(self.sense.set_etymology(etymology), self.sense) self.assertEqual(len(self.sense.definition), 1) self.assertEqual(len(self.sense.definition[0].statement), 1) self.assertEqual(self.sense.definition[0].statement[0].etymology, etymology) def test_get_etymology(self): etymology = "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].etymology = etymology # Test get etymology self.assertEqual(self.sense.get_etymology(), etymology) # Release created instances del self.sense.definition[0].statement[:] del state del self.sense.definition[:] del definition def test_set_etymology_comment(self): # Test etymology comment only comment = "etymology" # There is no Definition instance self.assertIs(self.sense.set_etymology_comment(comment), self.sense) self.assertEqual(len(self.sense.definition), 1) self.assertEqual(len(self.sense.definition[0].statement), 1) self.assertEqual( self.sense.definition[0].statement[0].etymologyComment, comment) # Test etymology comment and language commentaire = "etymologie" langage = "fra" self.assertIs( self.sense.set_etymology_comment(commentaire, term_source_language=langage), self.sense) self.assertEqual( self.sense.definition[0].statement[0].etymologyComment, commentaire) self.assertEqual( self.sense.definition[0].statement[0].termSourceLanguage, langage) 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_set_etymology_gloss(self): gloss = "GLOSS" # There is no Definition instance self.assertIs(self.sense.set_etymology_gloss(gloss), self.sense) self.assertEqual(len(self.sense.definition), 1) self.assertEqual(len(self.sense.definition[0].statement), 1) self.assertEqual(self.sense.definition[0].statement[0].etymologyGloss, gloss) 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_set_etymology_source(self): source = "etymology" # There is no Definition instance self.assertIs(self.sense.set_etymology_source(source), self.sense) self.assertEqual(len(self.sense.definition), 1) self.assertEqual(len(self.sense.definition[0].statement), 1) self.assertEqual(self.sense.definition[0].statement[0].etymologySource, source) 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_set_scientific_name(self): name = "Scientificus" # There is no Definition instance self.assertIs(self.sense.set_scientific_name(name), self.sense) self.assertEqual(len(self.sense.definition), 1) self.assertEqual(len(self.sense.definition[0].statement), 1) self.assertEqual(self.sense.definition[0].statement[0].scientificName, name) 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_create_paradigm(self): # Test create paradigm paradigm = self.sense.create_paradigm() self.assertIsInstance(paradigm, Paradigm) # Release Paradigm instance del paradigm def test_add_paradigm(self): # Create paradigms para1 = Paradigm() para2 = Paradigm() # Test add paradigms to the sense self.assertIs(self.sense.add_paradigm(para1), self.sense) self.assertListEqual(self.sense.paradigm, [para1]) self.assertIs(self.sense.add_paradigm(para2), self.sense) self.assertListEqual(self.sense.paradigm, [para1, para2]) # Release Paradigm instances del self.sense.paradigm[:] del para1, para2 def test_get_paradigms(self): # List of Paradigm instances is empty self.assertListEqual(self.sense.get_paradigms(), []) # Create Paradigm instances and add them to the list para1 = Paradigm() para2 = Paradigm() self.sense.paradigm = [para1, para2] # Test get paradigms self.assertListEqual(self.sense.get_paradigms(), [para1, para2]) # Delete Paradigm instances del self.sense.paradigm[:] del para1, para2 def test_get_last_paradigm(self): # List of Paradigm instances is empty self.assertIsNone(self.sense.get_last_paradigm()) # Create Paradigm instances and add them to the list para1 = Paradigm() para2 = Paradigm() self.sense.paradigm = [para1, para2] # Test get last paradigm self.assertIs(self.sense.get_last_paradigm(), para2) self.sense.paradigm.pop() self.assertIs(self.sense.get_last_paradigm(), para1) # Release Paradigm instances del self.sense.paradigm[:] del para1, para2 def test_set_paradigm_label(self): label = "construction" # There is no Paradigm instance self.assertIs(self.sense.set_paradigm_label(label), self.sense) self.assertEqual(len(self.sense.paradigm), 1) self.assertEqual(self.sense.paradigm[0].paradigmLabel, label) # Test error case label = "whatever" self.sense.set_paradigm_label(label) def test_set_paradigm_form(self): # Test paradigm form only form = "paradigm" # There is no Paradigm instance self.assertIs(self.sense.set_paradigm_form(form), self.sense) self.assertEqual(len(self.sense.paradigm), 1) self.assertEqual(self.sense.paradigm[0].paradigm, form) # Test paradigm form and language form = "paradigme" langage = "fra" self.assertIs(self.sense.set_paradigm_form(form, langage), self.sense) self.assertEqual(len(self.sense.paradigm), 2) self.assertEqual(self.sense.paradigm[1].paradigm, form) self.assertEqual(self.sense.paradigm[1].language, langage) def test_set_morphology(self): morpho = "morpho" # There is no Paradigm instance self.assertIs(self.sense.set_morphology(morpho), self.sense) self.assertEqual(len(self.sense.paradigm), 1) self.assertEqual(self.sense.paradigm[0].morphology, morpho) def test_create_and_add_context(self): # Test create context context1 = self.sense.create_and_add_context() self.assertIsInstance(context1, Context) # Create another context context2 = self.sense.create_and_add_context() self.assertIsInstance(context2, Context) # Test add context self.assertListEqual(self.sense.context, [context1, context2]) # Release Context instances del self.sense.context[:] del context1, context2 def test_get_contexts(self): # List of Context instances is empty self.assertListEqual(self.sense.get_contexts(), []) # Create Context instances and add them to the list ctx1 = Context() ctx2 = Context() self.sense.context = [ctx1, ctx2] # Test get contexts self.assertListEqual(self.sense.get_contexts(), [ctx1, ctx2]) # Delete Context instances del self.sense.context[:] del ctx1, ctx2 def test_get_last_context(self): # List of Context instances is empty self.assertIsNone(self.sense.get_last_context()) # Create Context instances and add them to the list ctx1 = Context() ctx2 = Context() self.sense.context = [ctx1, ctx2] # Test get last context self.assertIs(self.sense.get_last_context(), ctx2) self.sense.context.pop() self.assertIs(self.sense.get_last_context(), ctx1) # Release Context instances del self.sense.context[:] del ctx1, ctx2 def test_create_example(self): ref = "toto" self.assertIs(self.sense.create_example(ref), self.sense) self.assertEqual(len(self.sense.context), 1) self.assertEqual(self.sense.context[0].type, "example") self.assertEqual(self.sense.context[0].targets, ref) self.assertEqual(len(self.sense.context[0].text_representation), 0) def test_create_and_add_example(self): form = "written" self.assertIs(self.sense.create_and_add_example(form), self.sense) self.assertEqual(len(self.sense.context), 1) self.assertEqual(self.sense.context[0].type, "example") self.assertEqual(len(self.sense.context[0].text_representation), 1) self.assertEqual( self.sense.context[0].text_representation[0].writtenForm, form) # Test with language form = "form with lang" lang = "lang" self.assertIs(self.sense.create_and_add_example(form, lang), self.sense) self.assertEqual(len(self.sense.context), 2) self.assertEqual(self.sense.context[1].type, "example") self.assertEqual(len(self.sense.context[1].text_representation), 1) self.assertEqual( self.sense.context[1].text_representation[0].writtenForm, form) self.assertEqual(self.sense.context[1].text_representation[0].language, lang) def test_add_example(self): form = "written" self.assertIs(self.sense.add_example(form), self.sense) self.assertEqual(len(self.sense.context), 1) self.assertEqual(self.sense.context[0].type, "example") self.assertEqual(len(self.sense.context[0].text_representation), 1) self.assertEqual( self.sense.context[0].text_representation[0].writtenForm, form) # Test with language form = "form with lang" lang = "lang" self.assertIs(self.sense.add_example(form, lang), self.sense) self.assertEqual(len(self.sense.context), 1) self.assertEqual(self.sense.context[0].type, "example") self.assertEqual(len(self.sense.context[0].text_representation), 2) self.assertEqual( self.sense.context[0].text_representation[1].writtenForm, form) self.assertEqual(self.sense.context[0].text_representation[1].language, lang) def test_set_example_comment(self): comment = "example" self.assertIs(self.sense.set_example_comment(comment), self.sense) self.assertEqual(len(self.sense.context), 1) self.assertEqual(self.sense.context[0].type, "example") self.assertEqual(len(self.sense.context[0].text_representation), 1) self.assertEqual(self.sense.context[0].text_representation[0].comment, comment) # Test with a second comment comment = "another" self.assertIs(self.sense.set_example_comment(comment), self.sense) self.assertEqual(len(self.sense.context), 1) self.assertEqual(self.sense.context[0].type, "example") self.assertEqual(len(self.sense.context[0].text_representation), 2) self.assertEqual(self.sense.context[0].text_representation[1].comment, comment) def test_create_and_add_subject_field(self): # Test create subject field subject = self.sense.create_and_add_subject_field() self.assertIsInstance(subject, SubjectField) # Create another subject field field = self.sense.create_and_add_subject_field() self.assertIsInstance(field, SubjectField) # Test add subject fields self.assertListEqual(self.sense.subject_field, [subject, field]) # Release SubjectField instances del self.sense.subject_field[:] del subject, field def test_get_subject_fields(self): # List of SubjectField instances is empty self.assertListEqual(self.sense.get_subject_fields(), []) # Create SubjectField instances and add them to the list subject = SubjectField() field = SubjectField() self.sense.subject_field = [subject, field] # Test get subject fields self.assertListEqual(self.sense.get_subject_fields(), [subject, field]) # Delete SubjectField instances del self.sense.subject_field[:] del subject, field def test_set_semantic_domain(self): domain = "semantic" self.assertIs(self.sense.set_semantic_domain(domain), self.sense) self.assertEqual(len(self.sense.subject_field), 1) self.assertEqual(self.sense.subject_field[0].semanticDomain, domain) # Test with language domain = "domain with lang" lang = "lang" self.assertIs(self.sense.set_semantic_domain(domain, lang), self.sense) self.assertEqual(len(self.sense.subject_field), 2) self.assertEqual(self.sense.subject_field[1].semanticDomain, domain) self.assertEqual(self.sense.subject_field[1].language, lang) def test_create_and_add_equivalent(self): # Test create equivalent equivalent1 = self.sense.create_and_add_equivalent() self.assertIsInstance(equivalent1, Equivalent) # Create another equivalent equivalent2 = self.sense.create_and_add_equivalent() self.assertIsInstance(equivalent2, Equivalent) # Test add equivalents self.assertListEqual(self.sense.equivalent, [equivalent1, equivalent2]) # Release Equivalent instances del self.sense.equivalent[:] del equivalent1, equivalent2 def test_get_equivalents(self): # List of Equivalent instances is empty self.assertListEqual(self.sense.get_equivalents(), []) # Create Equivalent instances and add them to the list equivalent1 = Equivalent() equivalent2 = Equivalent() self.sense.equivalent = [equivalent1, equivalent2] # Test get equivalents self.assertListEqual(self.sense.get_equivalents(), [equivalent1, equivalent2]) # Delete Equivalent instances del self.sense.equivalent[:] del equivalent1, equivalent2 def test_set_translation(self): trans = "trans" self.assertIs(self.sense.set_translation(trans), self.sense) self.assertEqual(len(self.sense.equivalent), 1) self.assertEqual(self.sense.equivalent[0].translation, trans) # Test with language trans = "trans with lang" lang = "lang" self.assertIs(self.sense.set_translation(trans, lang), self.sense) self.assertEqual(len(self.sense.equivalent), 2) self.assertEqual(self.sense.equivalent[1].translation, trans) self.assertEqual(self.sense.equivalent[1].language, lang) def test_get_translations(self): # List of Equivalent instances is empty self.assertListEqual(self.sense.get_translations(), []) # Create Equivalent instances and add them to the list equivalent1 = Equivalent() equivalent2 = Equivalent() self.sense.equivalent = [equivalent1, equivalent2] # Set their translations trans1 = "trans1" trans2 = "trans2" equivalent1.translation = trans1 # Test get translations self.assertListEqual(self.sense.get_translations(), [trans1]) equivalent2.translation = trans2 self.assertListEqual(self.sense.get_translations(), [trans1, trans2]) # Test with a language filter lang = "lang" equivalent2.language = lang self.assertListEqual(self.sense.get_translations(), [trans1, trans2]) self.assertListEqual(self.sense.get_translations("eng"), []) self.assertListEqual(self.sense.get_translations(lang), [trans2]) # Delete Equivalent instances del self.sense.equivalent[:] del equivalent1, equivalent2