def test_check_spouses_exist(self):
""" Unit test for checking that both spouses exist """
fam_dict = {}
family = familyClass("F1")
family.husb_id = "I1"
family.wife_id = "I2"
fam_dict[family.fid] = family
value = check_spouses_exist(fam_dict)
self.assertEqual(len(value), 1)
self.assertEqual(list(value.keys()), ["F1"])
family2 = familyClass("F2")
family2.husb_id = "I3"
family2.wife_id = "NA"
fam_dict[family2.fid] = family2
self.assertEqual(list(fam_dict.keys()), ["F1", "F2"])
check_spouses_exist(fam_dict)
self.assertEqual(len(fam_dict), 1)
self.assertEqual(list(fam_dict.keys()), ["F1"])
family3 = familyClass("F3")
family3.husb_id = "NA"
family3.wife_id = "I6"
fam_dict[family3.fid] = family3
self.assertEqual(list(fam_dict.keys()), ["F1", "F3"])
check_spouses_exist(fam_dict)
self.assertEqual(len(fam_dict), 1)
self.assertEqual(list(fam_dict.keys()), ["F1"])
def test_validate_male_lastname(self):
""" Test cases for US16 --- All male members of the family should have the same last name"""
indi_dict = {}
fam_dict = {}
indi_I3 = individualPerson("I3")
indi_I3.name = "John Hernandez"
indi_I3.sex = 'M'
indi_dict[indi_I3.uid] = indi_I3
indi_I4 = individualPerson("I4")
indi_I4.name = "Sam Jackson"
indi_I4.sex = 'M'
indi_dict[indi_I4.uid] = indi_I4
fam_F1 = familyClass("F1")
fam_F1.chil = ["I3", "I4"]
fam_F1.husb = "David Hernandez"
fam_F1.wife = "Sofia Martinez"
fam_dict[fam_F1.fid] = fam_F1
self.assertEqual(validate_male_lastname(indi_dict, fam_dict), ({
'F1': ['Hernandez', 'I4', 'Jackson']
}))
self.assertNotEqual(validate_male_lastname(indi_dict, fam_dict),
{'F1': 'I5'})
self.assertIsNotNone(validate_male_lastname(indi_dict, fam_dict))
self.assertIsNot(validate_male_lastname(indi_dict, fam_dict),
{'F1': 'I5'})
self.assertCountEqual(validate_male_lastname(indi_dict, fam_dict), ({
'F1': ['Hernandez', 'I4', 'Jackson']
}))
indi_dict = {}
fam_dict = {}
indi_I8 = individualPerson("I8")
indi_I8.name = "John Hernandez"
indi_I8.sex = 'M'
indi_dict[indi_I8.uid] = indi_I8
indi_I9 = individualPerson("I9")
indi_I9.name = "Sonia Jackson"
indi_I9.sex = 'F'
indi_dict[indi_I9.uid] = indi_I9
fam_F2 = familyClass("F2")
fam_F2.chil = ["I9", "I9"]
fam_F2.husb = "David Hernandez"
fam_F2.wife = "Sofia Martinez"
fam_dict[fam_F2.fid] = fam_F2
self.assertEqual(validate_male_lastname(indi_dict, fam_dict), ({}))
self.assertNotEqual(validate_male_lastname(indi_dict, fam_dict),
{'F1': 'I5'})
self.assertIsNotNone(validate_male_lastname(indi_dict, fam_dict))
self.assertIsNot(validate_male_lastname(indi_dict, fam_dict),
{'F1': 'I5'})
self.assertCountEqual(validate_male_lastname(indi_dict, fam_dict),
({}))
def test_unique_families_by_spouses(self):
""" Unit tests for US24 - No more than one family with the same spouses
by name and the same marriage date should appear in a GEDCOM file """
fam_dict = {}
f1 = familyClass("F1")
f1.fid = "F1"
f1.husb = "Kyle"
f1.wife = "Eleni"
f1.marr = "1 JAN 2004"
fam_dict[f1.fid] = f1
f2 = familyClass("F2")
f2.fid = "F2"
f2.husb = "Kyle"
f2.wife = "Eleni"
f2.marr = "1 JAN 2004"
fam_dict[f2.fid] = f2
self.assertEqual(unique_families_by_spouses(fam_dict), [["F1", "F2"]])
self.assertNotEqual(unique_families_by_spouses(fam_dict), [])
f3 = familyClass("F3")
f3.fid = "F3"
f3.husb = "Joe"
f3.wife = "Anna"
f3.marr = "1 JAN 2008"
fam_dict[f3.fid] = f3
f4 = familyClass("F4")
f4.fid = "F4"
f4.husb = "Joe"
f4.wife = "Anna"
f4.marr = "1 JAN 2008"
fam_dict[f4.fid] = f4
self.assertEqual(unique_families_by_spouses(fam_dict),
[["F1", "F2"], ["F3", "F4"]])
self.assertNotEqual(unique_families_by_spouses(fam_dict),
[["F1", "F2"]])
f5 = familyClass("F5")
f5.fid = "F5"
f5.husb = "Joe"
f5.wife = "Anna"
f5.marr = "1 JAN 2008"
fam_dict[f5.fid] = f5
self.assertEqual(
unique_families_by_spouses(fam_dict),
[["F1", "F2"], ["F3", "F4"], ["F3", "F5"], ["F4", "F5"]])
self.assertNotEqual(unique_families_by_spouses(fam_dict),
[["F1", "F2"], ["F3", "F4"]])
def test_dates_before_currentDate(self):
""" Unit test for US01 -- Dates (birth, marriage, divorce, death) should not be after the current date """
indi_dict = {}
fam_dict = {}
indi_I7 = individualPerson("I7")
indi_I7.birt = "1 JUL 2019"
indi_I7.deat = "22 JUL 2060"
indi_dict[indi_I7.uid] = indi_I7
fam_F7 = familyClass("F7")
fam_F7.marr = "5 DEC 2050"
fam_dict[fam_F7.fid] = fam_F7
indi_I10 = individualPerson("I10")
indi_I10.birt = "25 AUG 2030"
indi_dict[indi_I10.uid] = indi_I10
fam_F10 = familyClass("F10")
fam_F10.marr = "11 OCT 2064"
fam_F10.div = "13 MAR 2065"
fam_dict[fam_F10.fid] = fam_F10
indi_I12 = individualPerson("I12")
indi_I12.birt = "25 AUG 1920"
indi_I12.deat = "13 MAR 1955"
indi_dict[indi_I12.uid] = indi_I12
fam_F12 = familyClass("F12")
fam_F12.marr = "3 MAR 1950"
fam_F12.div = "27 NOV 1954"
fam_dict[fam_F12.fid] = fam_F12
output = {
'I7': ['birth', 'death'],
'I10': ['birth'],
'F7': ['marriage'],
'F10': ['marriage', 'divorce']
}
self.assertEqual(allDates_before_currentDate(indi_dict, fam_dict),
(output))
self.assertNotEqual(allDates_before_currentDate(indi_dict, fam_dict),
({
'I1': ['death before birth'],
'I6': ['death before birth']
}))
self.assertIsNotNone(allDates_before_currentDate(indi_dict, fam_dict))
self.assertIsNot(allDates_before_currentDate(indi_dict, fam_dict), "")
self.assertCountEqual(allDates_before_currentDate(indi_dict, fam_dict),
(output))
def test_unique_first_names(self):
""" Unit tests for US25 Unique First Names - No more than one child
with the same name and birth date should appear in a family """
indi_dict = {}
fam_dict = {}
i1 = individualPerson("I1")
i1.uid = "I1"
i1.name = "Tyler"
i1.birt = "26 Oct 1995"
indi_dict[i1.uid] = i1
i2 = individualPerson("I2")
i2.uid = "I2"
i1.name = "Quinn"
i1.birt = "26 Oct 1995"
indi_dict[i2.uid] = i2
f1 = familyClass("F1")
f1.chil = ["I1", "I2"]
fam_dict[f1.fid] = f1
self.assertEqual(unique_first_names(fam_dict, indi_dict), set())
self.assertNotEqual(unique_first_names(fam_dict, indi_dict), {"F1"})
indi_dict = {}
fam_dict = {}
i3 = individualPerson("I3")
i3.uid = "I3"
i3.name = "Ryan"
i3.birt = "13 Apr 1994"
indi_dict[i3.uid] = i3
i4 = individualPerson("I4")
i4.uid = "I4"
i4.name = "Ryan"
i4.birt = "13 Apr 1994"
indi_dict[i4.uid] = i4
f2 = familyClass("F2")
f2.chil = ["I3", "I4"]
fam_dict[f2.fid] = f2
self.assertEqual(unique_first_names(fam_dict, indi_dict), {"F2"})
self.assertNotEqual(unique_first_names(fam_dict, indi_dict), {"F1"})
def test_siblings_should_not_marry(self):
""" Test cases for US18 --- Siblings should not marry"""
fam_dict = {}
ind_dict = {}
individual = individualPerson("I1")
individual.uid = "I1"
individual.fams = ['F1']
individual.famc = ["F4"]
ind_dict[individual.uid] = individual
individual2 = individualPerson("I2")
individual2.uid = "I2"
individual2.fams = ['F1']
individual2.famc = ["F5"]
ind_dict[individual2.uid] = individual2
family = familyClass("F1")
family.husb_id = "I1"
family.wife_id = "I2"
family.chil = ["I3", "I6"]
fam_dict[family.fid] = family
self.assertEqual(get_spouse(fam_dict, "F1", "I1"), "I2", True)
self.assertEqual(get_spouse(fam_dict, "F1", "I2"), "I1", True)
individual3 = individualPerson("I3")
individual3.uid = "I3"
individual3.fams = ['F2']
individual3.famc = ["F1"]
ind_dict[individual3.uid] = individual3
individual4 = individualPerson("I4")
individual4.uid = "I4"
individual4.fams = ['F2']
individual4.famc = ["F1"]
ind_dict[individual4.uid] = individual4
family = familyClass("F2")
family.husb_id = "I1"
family.wife_id = "I2"
family.chil = ["I5", "I7"]
fam_dict[family.fid] = family
self.assertEqual(get_children(fam_dict, "F2"), ["I5", "I7"], True)
self.assertEqual(get_children(fam_dict, "F1"), ["I3", "I6"], True)
self.assertEqual(len(siblings_should_not_marry(fam_dict, ind_dict)), 0,
True)
def test_marriage_after_14(self):
""" Unit tests for US10 Marriage After 14 - Marriage should be at least
14 years after birth of both spouses (parents must be at least 14 years old) """
indi_dict = {}
fam_dict = {}
indi_I1 = individualPerson("I1")
indi_I1.sex = "M"
indi_I1.birt = "12 JUL 1991"
indi_dict[indi_I1.uid] = indi_I1
indi_I2 = individualPerson("I2")
indi_I2.sex = "F"
indi_I2.birt = "9 JAN 1988"
indi_dict[indi_I2.uid] = indi_I2
fam1 = familyClass("F1")
fam1.husb_id = "I1"
fam1.wife_id = "I2"
fam1.marr = "1 FEB 1995"
fam_dict[fam1.fid] = fam1
self.assertEqual(marriage_after_14(fam_dict, indi_dict), {
"I1": ["M", "F1"],
"I2": ["F", "F1"]
})
self.assertNotEqual(marriage_after_14(fam_dict, indi_dict),
{"I1": ["M", "F1"]})
def test_list_recent_survivals(self):
""" US37 --- Test cases to validate recent survivors """
fam_dict = {}
ind_dict = {}
individual = individualPerson("I1")
individual.uid = "I1"
individual.alive = False
individual.birt = "1 JAN 1991"
individual.deat = "1 OCT 2018"
individual.name = "Fernando"
individual.fams = ["F1"]
individual.sex = "M"
ind_dict[individual.uid] = individual
individual2 = individualPerson("I2")
individual2.uid = "I2"
individual2.fams = ["F1"]
individual2.alive = True
individual2.birt = "1 JAN 1991"
individual2.name = "Laura"
individual2.sex = "F"
ind_dict[individual2.uid] = individual2
family = familyClass("F1")
family.husb_id = "I1"
family.wife_id = "I2"
family.chil = ["I4", "I6"]
family.marr = "1 JAN 2005"
fam_dict[family.fid] = family
self.assertEqual(len(list_recent_survivals(ind_dict, fam_dict)), 0,
True)
def test_list_orphans(self):
""" US33 -- Test cases to validate the list of orphans """
ind_dict = {}
fam_dict = {}
individual = individualPerson("I1")
individual.uid = "I1"
individual.alive = False
ind_dict[individual.uid] = individual
individual2 = individualPerson("I2")
individual2.uid = "I2"
individual2.alive = False
ind_dict[individual2.uid] = individual2
individual3 = individualPerson("I3")
individual3.uid = "I3"
individual3.age = 2
ind_dict[individual3.uid] = individual3
family = familyClass("F1")
family.husb_id = "I1"
family.wife_id = "I2"
family.chil = ["I3"]
fam_dict[family.fid] = family
self.assertEqual(len(list_orphans(fam_dict, ind_dict)), 1)
def test_child_birth(self):
"""Test cases for US08 -- Children should be born after marriage of parents (and not more than 9 months after their divorce)"""
indi_dict = {}
fam_dict = {}
indi_I10 = individualPerson("I10")
indi_I10.birt = "25 AUG 1990"
indi_dict[indi_I10.uid] = indi_I10
indi_I11 = individualPerson("I11")
indi_I11.birt = "13 MAR 1996"
indi_dict[indi_I11.uid] = indi_I11
fam_F10 = familyClass("F10")
fam_F10.marr = "11 OCT 1995"
fam_F10.chil = ["I10", "I11"]
fam_dict[fam_F10.fid] = fam_F10
indi_I12 = individualPerson("I12")
indi_I12.birt = "11 OCT 1953"
indi_dict[indi_I12.uid] = indi_I12
indi_I13 = individualPerson("I13")
indi_I13.birt = "25 DEC 1955"
indi_dict[indi_I13.uid] = indi_I13
fam_F12 = familyClass("F12")
fam_F12.marr = "3 MAR 1950"
fam_F12.div = "27 NOV 1954"
fam_F12.chil = ["I12", "I13"]
fam_dict[fam_F12.fid] = fam_F12
self.assertEqual(validate_child_birth(indi_dict, fam_dict),
({
'F10': 'I10'
}, {
'F12': 'I13'
}))
self.assertNotEqual(validate_child_birth(indi_dict, fam_dict),
{'F1': 'I5'})
self.assertIsNotNone(validate_child_birth(indi_dict, fam_dict))
self.assertIsNot(validate_child_birth(indi_dict, fam_dict),
{'F1': 'I5'})
self.assertCountEqual(validate_child_birth(indi_dict, fam_dict),
({
'F10': 'I10'
}, {
'F12': 'I13'
}))
def test_birth_before_marriage(self):
""" US02 --- Unit testing to check birth before marriages """
fam_dict = {}
ind_dict = {}
individual = individualPerson("I1")
individual.uid = "I1"
individual.alive = True
individual.birt = "1 JAN 2001"
ind_dict[individual.uid] = individual
individual2 = individualPerson("I2")
individual2.uid = "I2"
individual2.alive = True
individual2.birt = "1 JAN 2010"
ind_dict[individual2.uid] = individual2
family = familyClass("F1")
family.husb_id = "I1"
family.wife_id = "I2"
family.marr = "1 JAN 2000"
fam_dict[family.fid] = family
self.assertEqual(len(birth_before_marriage(fam_dict, ind_dict)), 1,
True)
individual = individualPerson("I3")
individual.uid = "I3"
individual.alive = True
individual.birt = "20 OCT 1990"
ind_dict[individual.uid] = individual
individual2 = individualPerson("I4")
individual2.uid = "I4"
individual2.alive = True
individual2.birt = "1 JAN 1991"
ind_dict[individual2.uid] = individual2
family = familyClass("F2")
family.husb_id = "I3"
family.wife_id = "I4"
family.marr = "1 JAN 2000"
fam_dict[family.fid] = family
self.assertEqual(len(birth_before_marriage(fam_dict, ind_dict)), 1,
True)
def test_check_marriage_before_divorce(self):
""" Unit test for US04 for checking that marriage occured before divorce """
fam_dict = {}
family = familyClass("F1")
family.marr = "1 JAN 2000"
family.div = "1 JAN 2005"
fam_dict[family.fid] = family
self.assertNotEqual(len(check_marriage_before_divorce(fam_dict)), 1,
True)
family2 = familyClass("F2")
family2.marr = "1 JAN 2005"
family2.div = "1 JAN 2000"
fam_dict[family2.fid] = family2
self.assertEqual(len(check_marriage_before_divorce(fam_dict)), 1, True)
self.assertEqual(check_marriage_before_divorce(fam_dict), ["F2"], True)
family3 = familyClass("F3")
family3.marr = "1 JAN 2000"
family3.div = "1 JAN 2000"
fam_dict[family3.fid] = family3
self.assertEqual(len(check_marriage_before_divorce(fam_dict)), 1, True)
self.assertEqual(check_marriage_before_divorce(fam_dict), ["F2"], True)
family4 = familyClass("F4")
family4.marr = "1 JAN 2000"
family4.div = "NA"
fam_dict[family4.fid] = family4
self.assertEqual(len(check_marriage_before_divorce(fam_dict)), 1, True)
self.assertEqual(check_marriage_before_divorce(fam_dict), ["F2"], True)
family5 = familyClass("F5")
family5.marr = "1 DEC 2000"
family5.div = "30 NOV 2000"
fam_dict[family5.fid] = family5
self.assertEqual(len(check_marriage_before_divorce(fam_dict)), 2, True)
self.assertEqual(check_marriage_before_divorce(fam_dict), ["F2", "F5"],
True)
def test_multiple_births(self):
""" US32 --- Test cases to validate multiple births """
fam_dict = {}
ind_dict = {}
individual = individualPerson("I1")
individual.uid = "I1"
individual.birt = '10 SEP 1998'
ind_dict[individual.uid] = individual
individual2 = individualPerson("I2")
individual2.uid = "I2"
individual2.birt = '10 SEP 1998'
ind_dict[individual2.uid] = individual2
individual3 = individualPerson("I3")
individual3.uid = "I3"
individual3.birt = '10 SEP 1988'
ind_dict[individual3.uid] = individual3
individual4 = individualPerson("I4")
individual4.uid = "I4"
individual4.birt = '10 SEP 1998'
ind_dict[individual4.uid] = individual4
family = familyClass("F1")
family.chil = ['I1', 'I2', 'I3', 'I4']
fam_dict[family.fid] = family
individual31 = individualPerson("I31")
individual31.uid = "I31"
individual31.birt = '9 JAN 1988'
ind_dict[individual31.uid] = individual31
individual41 = individualPerson("I41")
individual41.uid = "I41"
individual41.birt = '9 JAN 1988'
ind_dict[individual41.uid] = individual41
family1 = familyClass("F2")
family1.chil = ['I31', 'I41']
fam_dict[family1.fid] = family1
self.assertEqual(len(multiple_births(fam_dict, ind_dict)), 5, True)
def test_no_bigamy(self):
""" Test cases for US11 --- Marriage should not occur during marriage to another spouse"""
fam_dict = {}
fam_F1 = familyClass("F1")
fam_F1.husb_id = "I1"
fam_F1.wife_id = "I2"
fam_dict[fam_F1.fid] = fam_F1
fam_F2 = familyClass("F2")
fam_F2.husb_id = "I1"
fam_F2.wife_id = "I3"
fam_dict[fam_F2.fid] = fam_F2
fam_F3 = familyClass("F3")
fam_F3.husb_id = "I1"
fam_F3.wife_id = "I4"
fam_dict[fam_F3.fid] = fam_F3
fam_F4 = familyClass("F4")
fam_F4.husb_id = "I5"
fam_F4.wife_id = "I3"
fam_dict[fam_F4.fid] = fam_F4
fam_F5 = familyClass("F5")
fam_F5.husb_id = "I6"
fam_F5.wife_id = "I7"
fam_dict[fam_F5.fid] = fam_F5
self.assertEqual(no_bigamy(fam_dict), ({
'I1': ['I4', 'I2', 'I3'],
'I3': ['I5', 'I1']
}))
self.assertNotEqual(no_bigamy(fam_dict), {'F1': 'I5'})
self.assertIsNotNone(no_bigamy(fam_dict))
self.assertIsNot(no_bigamy(fam_dict), {'F1': 'I5'})
self.assertCountEqual(no_bigamy(fam_dict), ({
'I1': ['I4', 'I2', 'I3'],
'I3': ['I5', 'I1']
}))
fam_dict = {}
fam_F6 = familyClass("F6")
fam_F6.husb_id = "I8"
fam_F6.wife_id = "I9"
fam_dict[fam_F6.fid] = fam_F6
fam_F7 = familyClass("F7")
fam_F7.husb_id = "I10"
fam_F7.wife_id = "I11"
fam_dict[fam_F7.fid] = fam_F7
self.assertEqual(no_bigamy(fam_dict), ({}))
self.assertNotEqual(no_bigamy(fam_dict), {'F1': 'I5'})
self.assertIsNotNone(no_bigamy(fam_dict))
self.assertIsNot(no_bigamy(fam_dict), {'F1': 'I5'})
self.assertCountEqual(no_bigamy(fam_dict), ({}))
def test_living_married(self):
""" US30 --- Test cases to validate living married"""
fam_dict = {}
ind_dict = {}
individual = individualPerson("I1")
individual.uid = "I1"
individual.alive = True
individual.deat = "NA"
ind_dict[individual.uid] = individual
individual2 = individualPerson("I2")
individual2.uid = "I2"
individual2.alive = True
individual2.deat = 'NA'
ind_dict[individual2.uid] = individual2
individual3 = individualPerson("I3")
individual3.uid = "I3"
individual3.alive = True
individual3.deat = 'NA'
ind_dict[individual3.uid] = individual3
individual4 = individualPerson("I4")
individual4.uid = "I4"
individual4.alive = True
individual4.deat = 'NA'
ind_dict[individual4.uid] = individual4
family = familyClass("F1")
family.husb_id = "I1"
family.wife_id = "I2"
family.marr = "1 JAN 2000"
fam_dict[family.fid] = family
family2 = familyClass("F2")
family2.husb_id = "I3"
family2.wife_id = "I4"
family2.marr = "1 FEB 2004"
fam_dict[family2.fid] = family2
self.assertEqual(len(living_married_list(fam_dict, ind_dict)), 4, True)
def test_check_marriage_status(self):
""" Unit test for checking that the marriage date for a family is not 'NA' """
fam_dict = {}
family = familyClass("F1")
family.marr = "1 JAN 2000"
fam_dict[family.fid] = family
value = check_marriage_status(fam_dict)
self.assertEqual(len(value), 0)
self.assertEqual(value, [])
family2 = familyClass("F2")
family2.marr = "NA"
fam_dict[family2.fid] = family2
self.assertEqual(list(fam_dict.keys()), ["F1", "F2"])
value = check_marriage_status(fam_dict)
self.assertEqual(len(fam_dict), 2)
self.assertEqual(list(fam_dict.keys()), ["F1", "F2"])
def test_sibling_spacing(self):
""" US13 --- Test cases for validating sibling spacing """
fam_dict = {}
ind_dict = {}
individual = individualPerson("I1")
individual.uid = "I1"
individual.birt = '15 AUG 2018'
ind_dict[individual.uid] = individual
individual2 = individualPerson("I2")
individual2.uid = "I2"
individual2.birt = '15 AUG 2018'
ind_dict[individual2.uid] = individual2
individual3 = individualPerson("I3")
individual3.uid = "I3"
individual3.birt = '16 AUG 2018'
ind_dict[individual3.uid] = individual3
family = familyClass("F2")
family.chil = ['I1', 'I2', 'I3']
fam_dict[family.fid] = family
i1 = individualPerson('I11')
i1.uid = 'I11'
i1.birt = '29 SEP 2018'
ind_dict[i1.uid] = i1
i2 = individualPerson('I12')
i2.udi = 'I12'
i2.birt = '15 AUG 2018'
ind_dict[i2.uid] = i2
family = familyClass("F2")
family.chil = ['I11', 'I12']
fam_dict[family.fid] = family
self.assertFalse(sibling_spacing(fam_dict, ind_dict))
def test_fewer_than15_siblings(self):
"Test cases -- US15 -- There should be fewer than 15 siblings in a family"
fam_dict = dict()
family = familyClass("F2")
family.chil = [
'i1', 'i2', 'i3', 'i4', 'i5', 'i6', 'i7', 'i8', 'i9', 'i10', 'i11',
'i12', 'i13', 'i14', 'i15', 'i16'
]
fam_dict[family.fid] = family
self.assertEqual(fewer_than15_siblings(fam_dict), ['F2'])
self.assertNotEqual(fewer_than15_siblings(fam_dict),
['F4', 'F7', 'F9'])
self.assertIsNotNone(fewer_than15_siblings)
self.assertIsNot(fewer_than15_siblings(fam_dict), ['F4', 'F7', 'F9'])
fam_dict = dict()
family = familyClass("F1")
family.chil = [
'i1', 'i2', 'i3', 'i4', 'i5', 'i6', 'i7', 'i8', 'i9', 'i10', 'i11',
'i12', 'i13', 'i14', 'i15'
]
fam_dict[family.fid] = family
self.assertEqual(fewer_than15_siblings(fam_dict), [])
self.assertNotEqual(fewer_than15_siblings(fam_dict),
['F4', 'F7', 'F9'])
self.assertIsNotNone(fewer_than15_siblings)
self.assertIsNot(fewer_than15_siblings(fam_dict), ['F4', 'F7', 'F9'])
fam_dict = dict()
family = familyClass("F3")
family.chil = []
fam_dict[family.fid] = family
self.assertEqual(fewer_than15_siblings(fam_dict), [])
self.assertNotEqual(fewer_than15_siblings(fam_dict),
['F4', 'F7', 'F9'])
self.assertIsNotNone(fewer_than15_siblings)
self.assertIsNot(fewer_than15_siblings(fam_dict), ['F4', 'F7', 'F9'])
def test_check_unique_ids(self):
""" Test cases for US22 - Unique IDs - All individual IDs should be
unique and all family IDs should be unique. """
indi_dict = {}
fam_dict = {}
i1 = individualPerson('I1')
indi_dict[i1.uid] = i1
i2 = individualPerson('I2')
indi_dict[i2.uid] = i2
family = familyClass("F1")
fam_dict[family.fid] = family
family2 = familyClass("F2")
fam_dict[family2.fid] = family2
self.assertEqual(check_unique_ids(indi_dict, fam_dict), ([], []))
self.assertNotEqual(check_unique_ids(indi_dict, fam_dict),
(["I2"], ["F2"]))
self.assertIsNotNone(check_unique_ids(indi_dict, fam_dict))
self.assertIsNot(check_unique_ids(indi_dict, fam_dict),
(["I2"], ["F2"]))
def test_divorce_brfore_death(self):
""" US06 --- Tests cases for validating if divorce occured before death of both spouses """
family_dict = {}
individual_dict = {}
family1 = familyClass('F12')
family1.div = '1 JAN 2009'
family1.husb_id = 'I11'
family1.wife_id = 'I10'
family_dict[family1.fid] = family1
indi1 = individualPerson('I11')
indi1.alive = False
indi1.deat = '2 MAR 2007'
individual_dict[indi1.uid] = indi1
indi2 = individualPerson('I10')
indi2.alive = True
indi2.deat = 'NA'
individual_dict[indi2.uid] = indi2
self.assertEqual(
len(divorce_before_death(family_dict, individual_dict)), 1, True)
self.assertEqual(divorce_before_death(family_dict, individual_dict),
["F12"], True)
def test_list_spouse_large_age_difference(self):
"""Test case for US34 - List all couples who were married when the older spouse was more than twice as old as the younger spouse"""
fam_dict = {}
ind_dict = {}
individual3 = individualPerson("I3")
individual3.uid = "I3"
individual3.age = 78
ind_dict[individual3.uid] = individual3
individual4 = individualPerson("I4")
individual4.uid = "I4"
individual4.age = 25
ind_dict[individual4.uid] = individual4
family = familyClass("F2")
family.husb_id = "I3"
family.wife_id = "I4"
family.marr = "9 NOV 2016"
fam_dict[family.fid] = family
self.assertEqual(
len(list_spouse_large_age_difference(fam_dict, ind_dict)), 1, True)
def test_list_upcoming_anniversaries(self):
"""Test Case for US39 - List all living couples in a GEDCOM file whose marriage anniversaries occur in the next 30 days"""
fam_dict = {}
ind_dict = {}
individual = individualPerson("I1")
individual.uid = "I1"
individual.age = 87
ind_dict[individual.uid] = individual
individual2 = individualPerson("I2")
individual2.uid = "I2"
individual2.age = 35
ind_dict[individual2.uid] = individual2
family = familyClass("F1")
family.husb_id = "I1"
family.wife_id = "I2"
family.marr = "29 NOV 2000"
fam_dict[family.fid] = family
self.assertEqual(len(list_upcoming_anniversaries(fam_dict, ind_dict)),
1, True)
def test_single_over_30(self):
""" US31 --- Test cases for living singles """
fam_dict = {}
ind_dict = {}
individual = individualPerson("I1")
individual.uid = "I1"
individual.age = 27
ind_dict[individual.uid] = individual
individual2 = individualPerson("I2")
individual2.uid = "I2"
individual2.age = 35
ind_dict[individual2.uid] = individual2
individual3 = individualPerson("I3")
individual3.uid = "I3"
individual3.age = 45
ind_dict[individual3.uid] = individual3
individual4 = individualPerson("I4")
individual4.uid = "I4"
individual4.age = 15
ind_dict[individual4.uid] = individual4
individual5 = individualPerson("I5")
individual5.uid = "I5"
individual5.age = 55
ind_dict[individual5.uid] = individual5
family = familyClass("F1")
family.husb_id = "I1"
family.wife_id = "I2"
fam_dict[family.fid] = family
self.assertEqual(len(single_over_30(fam_dict, ind_dict)), 2, True)
def test_validate_childBirth_with_parentsDeath(self):
"""Test cases for US09 -- Child should be born before death of mother and before nine months after death of father"""
indi_dict = {}
fam_dict = {}
indi_I10 = individualPerson("I10")
indi_I10.birt = "25 AUG 1990"
indi_dict[indi_I10.uid] = indi_I10
indi_I11 = individualPerson("I11")
indi_I11.birt = "13 MAR 1960"
indi_I11.deat = "19 JUL 1990"
indi_dict[indi_I11.uid] = indi_I11
indi_I12 = individualPerson("I12")
indi_I12.birt = "16 DEC 1959"
indi_dict[indi_I12.uid] = indi_I12
fam_F10 = familyClass("F10")
fam_F10.marr = "11 OCT 1988"
fam_F10.chil = ["I10"]
fam_F10.husb_id = "I12"
fam_F10.wife_id = "I11"
fam_dict[fam_F10.fid] = fam_F10
self.assertEqual(
validate_childBirth_with_parentsDeath(indi_dict, fam_dict), ({
'F10': ['I10', 'I11']
}, {}))
self.assertNotEqual(
validate_childBirth_with_parentsDeath(indi_dict, fam_dict),
{'F1': 'I5'})
self.assertIsNotNone(
validate_childBirth_with_parentsDeath(indi_dict, fam_dict))
self.assertIsNot(
validate_childBirth_with_parentsDeath(indi_dict, fam_dict),
{'F1': 'I5'})
self.assertCountEqual(
validate_childBirth_with_parentsDeath(indi_dict, fam_dict), ({
'F10': ['I10', 'I11']
}, {}))
indi_dict = {}
fam_dict = {}
indi_I1 = individualPerson("I1")
indi_I1.birt = "25 AUG 1990"
indi_dict[indi_I1.uid] = indi_I1
indi_I2 = individualPerson("I2")
indi_I2.birt = "13 MAR 1960"
indi_dict[indi_I2.uid] = indi_I2
indi_I3 = individualPerson("I3")
indi_I3.birt = "16 DEC 1959"
indi_I3.deat = "13 OCT 1989"
indi_dict[indi_I3.uid] = indi_I3
fam_F1 = familyClass("F1")
fam_F1.marr = "11 OCT 1988"
fam_F1.chil = ["I1"]
fam_F1.husb_id = "I3"
fam_F1.wife_id = "I2"
fam_dict[fam_F1.fid] = fam_F1
self.assertEqual(
validate_childBirth_with_parentsDeath(indi_dict, fam_dict), ({}, {
'F1': ['I1', 'I3']
}))
self.assertNotEqual(
validate_childBirth_with_parentsDeath(indi_dict, fam_dict),
{'F1': 'I5'})
self.assertIsNotNone(
validate_childBirth_with_parentsDeath(indi_dict, fam_dict))
self.assertIsNot(
validate_childBirth_with_parentsDeath(indi_dict, fam_dict),
{'F1': 'I5'})
self.assertCountEqual(
validate_childBirth_with_parentsDeath(indi_dict, fam_dict), ({}, {
'F1': ['I1', 'I3']
}))
indi_dict = {}
fam_dict = {}
indi_I1 = individualPerson("I1")
indi_I1.birt = "25 AUG 1990"
indi_dict[indi_I1.uid] = indi_I1
indi_I2 = individualPerson("I2")
indi_I2.birt = "13 MAR 1960"
indi_dict[indi_I2.uid] = indi_I2
indi_I3 = individualPerson("I3")
indi_I3.birt = "16 DEC 1959"
indi_I3.deat = "13 OCT 1995"
indi_dict[indi_I3.uid] = indi_I3
fam_F1 = familyClass("F1")
fam_F1.marr = "11 OCT 1988"
fam_F1.chil = ["I1"]
fam_F1.husb_id = "I3"
fam_F1.wife_id = "I2"
fam_dict[fam_F1.fid] = fam_F1
self.assertEqual(
validate_childBirth_with_parentsDeath(indi_dict, fam_dict),
({}, {}))
self.assertNotEqual(
validate_childBirth_with_parentsDeath(indi_dict, fam_dict),
{'F1': 'I5'})
self.assertIsNotNone(
validate_childBirth_with_parentsDeath(indi_dict, fam_dict))
self.assertIsNot(
validate_childBirth_with_parentsDeath(indi_dict, fam_dict),
{'F1': 'I5'})
self.assertCountEqual(
validate_childBirth_with_parentsDeath(indi_dict, fam_dict),
({}, {}))
def test_check_marriage_before_death(self):
""" Unit test for US05 for checking that marriage occured before death
of either spouse """
fam_dict = {}
ind_dict = {}
individual = individualPerson("I1")
individual.uid = "I1"
individual.alive = True
individual.deat = "NA"
ind_dict[individual.uid] = individual
individual2 = individualPerson("I2")
individual2.uid = "I2"
individual2.alive = False
individual2.deat = "1 JAN 2010"
ind_dict[individual2.uid] = individual2
family = familyClass("F1")
family.husb_id = "I1"
family.wife_id = "I2"
family.marr = "1 JAN 2000"
fam_dict[family.fid] = family
self.assertEqual(len(check_marriage_before_death(fam_dict, ind_dict)),
0, True)
self.assertEqual(check_marriage_before_death(fam_dict, ind_dict), [],
True)
individual3 = individualPerson("I3")
individual3.uid = "I3"
individual3.alive = True
individual3.deat = "NA"
ind_dict[individual3.uid] = individual3
individual4 = individualPerson("I4")
individual4.uid = "I4"
individual4.alive = False
individual4.deat = "1 JAN 1999"
ind_dict[individual4.uid] = individual4
family2 = familyClass("F2")
family2.husb_id = "I3"
family2.wife_id = "I4"
family2.marr = "1 JAN 2000"
fam_dict[family2.fid] = family2
self.assertEqual(len(check_marriage_before_death(fam_dict, ind_dict)),
1, True)
self.assertEqual(check_marriage_before_death(fam_dict, ind_dict),
["F2"], True)
individual5 = individualPerson("I5")
individual5.uid = "I5"
individual5.alive = True
individual5.deat = "NA"
ind_dict[individual5.uid] = individual5
individual6 = individualPerson("I6")
individual6.uid = "I6"
individual6.alive = False
individual6.deat = "1 JAN 1999"
ind_dict[individual6.uid] = individual6
family3 = familyClass("F3")
family3.husb_id = "I6"
family3.wife_id = "I5"
family3.marr = "1 JAN 2000"
fam_dict[family3.fid] = family3
self.assertEqual(len(check_marriage_before_death(fam_dict, ind_dict)),
2, True)
self.assertEqual(check_marriage_before_death(fam_dict, ind_dict),
["F2", "F3"], True)
def test_check_multiple_births(self):
""" Unit tests for US14 Multiple Births <= 5 - No more than five siblings should be born
at the same time """
indi_dict = {}
fam_dict = {}
i1 = individualPerson('I1')
i1.uid = 'I1'
i1.birt = '1 JAN 1980'
indi_dict[i1.uid] = i1
i2 = individualPerson('I2')
i2.uid = 'I2'
i2.birt = '1 JAN 1980'
indi_dict[i2.uid] = i2
i3 = individualPerson('I3')
i3.uid = 'I3'
i3.birt = '1 JAN 1980'
indi_dict[i3.uid] = i3
i4 = individualPerson('I4')
i4.uid = 'I4'
i4.birt = '1 JAN 1980'
indi_dict[i4.uid] = i4
i5 = individualPerson('I5')
i5.uid = 'I5'
i5.birt = '1 JAN 1980'
indi_dict[i5.uid] = i5
i6 = individualPerson('I6')
i6.uid = 'I6'
i6.birt = '1 JAN 1980'
indi_dict[i6.uid] = i6
f1 = familyClass("F1")
f1.chil = ["I1", "I2", "I3", "I4", "I5", "I6"]
fam_dict[f1.fid] = f1
self.assertEqual(check_multiple_births(fam_dict, indi_dict),
{"F1": ["I1", "I2", "I3", "I4", "I5", "I6"]})
self.assertNotEqual(check_multiple_births(fam_dict, indi_dict), {})
i7 = individualPerson('I7')
i7.uid = 'I7'
i7.birt = '1 JAN 1980'
indi_dict[i7.uid] = i7
i8 = individualPerson('I8')
i8.uid = 'I8'
i8.birt = '1 JAN 1980'
indi_dict[i8.uid] = i8
i9 = individualPerson('I9')
i9.uid = 'I9'
i9.birt = '1 JAN 1980'
indi_dict[i9.uid] = i9
i10 = individualPerson('I10')
i10.uid = 'I10'
i10.birt = '1 JAN 1980'
indi_dict[i10.uid] = i10
i11 = individualPerson('I11')
i11.uid = 'I11'
i11.birt = '1 JAN 1980'
indi_dict[i11.uid] = i11
i12 = individualPerson('I12')
i12.uid = 'I12'
i12.birt = '1 JAN 1985'
indi_dict[i12.uid] = i12
f2 = familyClass("F2")
f2.chil = ["I7", "I8", "I9", "I10", "I11", "I12"]
fam_dict[f2.fid] = f2
self.assertEqual(check_multiple_births(fam_dict, indi_dict),
{"F1": ["I1", "I2", "I3", "I4", "I5", "I6"]})
self.assertNotEqual(
check_multiple_births(fam_dict, indi_dict), {
"F1": ["I1", "I2", "I3", "I4", "I5", "I6"],
"F2": ["I7", "I8", "I9", "I10", "I11", "I12"]
})
self.assertNotEqual(check_multiple_births(fam_dict, indi_dict), {})
def test_check_parents_not_too_old(self):
""" Unit tests for US12 Parents Not Too Old - checks that the mother is less
than 60 years older than her children and the father is less than 80 years
older than his children """
indi_dict = {}
fam_dict = {}
i1 = individualPerson('I1')
i1.sex = "M"
i1.uid = 'I1'
i1.name = "Mark"
i1.birt = '1 JAN 1980'
indi_dict[i1.uid] = i1
i2 = individualPerson('I2')
i2.sex = "F"
i2.uid = 'I2'
i2.name = "Cecily"
i2.birt = '1 JUN 1980'
indi_dict[i2.uid] = i2
i3 = individualPerson('I3')
i3.uid = 'I3'
i3.name = "Tom"
i3.birt = '1 MAR 2010'
indi_dict[i3.uid] = i3
f1 = familyClass("F1")
f1.husb_id = "I1"
f1.wife_id = "I2"
f1.chil = ["I3"]
fam_dict[f1.fid] = f1
self.assertEqual(check_parents_not_too_old(fam_dict, indi_dict), {})
self.assertNotEqual(check_parents_not_too_old(fam_dict, indi_dict), {
"F1":
["F", "I2", "Cecily", "1 JUN 1980", "I3", "Tom", "1 MAR 2010"]
})
i4 = individualPerson('I4')
i4.sex = "M"
i4.uid = 'I4'
i4.name = "John"
i4.birt = '1 JAN 1940'
indi_dict[i4.uid] = i4
i5 = individualPerson('I5')
i5.sex = "F"
i5.uid = 'I5'
i5.name = "Kyra"
i5.birt = '1 JUN 1940'
indi_dict[i5.uid] = i5
i6 = individualPerson('I6')
i6.uid = 'I6'
i6.name = "Julia"
i6.birt = '1 MAR 2010'
indi_dict[i6.uid] = i6
f2 = familyClass("F2")
f2.husb_id = "I4"
f2.wife_id = "I5"
f2.chil = ["I6"]
fam_dict[f2.fid] = f2
self.assertEqual(check_parents_not_too_old(fam_dict, indi_dict), {
"F2":
["F", "I5", "Kyra", "1 JUN 1940", "I6", "Julia", "1 MAR 2010"]
})
self.assertNotEqual(check_parents_not_too_old(fam_dict, indi_dict), {})
i7 = individualPerson('I7')
i7.sex = "M"
i7.uid = 'I7'
i7.name = "Ryan"
i7.birt = '1 JAN 1929'
indi_dict[i7.uid] = i7
i8 = individualPerson('I8')
i8.sex = "F"
i8.uid = 'I8'
i8.name = "Amanda"
i8.birt = '1 JUN 1960'
indi_dict[i8.uid] = i8
i9 = individualPerson('I9')
i9.uid = 'I9'
i9.name = "Kevin"
i9.birt = '1 JUN 2010'
indi_dict[i9.uid] = i9
f3 = familyClass("F3")
f3.husb_id = "I7"
f3.wife_id = "I8"
f3.chil = ["I9"]
fam_dict[f3.fid] = f3
self.assertEqual(
check_parents_not_too_old(fam_dict, indi_dict), {
"F2":
["F", "I5", "Kyra", "1 JUN 1940", "I6", "Julia", "1 MAR 2010"],
"F3":
["M", "I7", "Ryan", "1 JAN 1929", "I9", "Kevin", "1 JUN 2010"]
})
self.assertNotEqual(check_parents_not_too_old(fam_dict, indi_dict), {})
def test_not_to_marry_firstCousin(self):
"""Test Cases for US19 --- First cousins should not marry one another"""
fam_dict = {}
fam_F1 = familyClass("F1")
fam_F1.husb_id = "I1"
fam_F1.wife_id = "I2"
fam_F1.chil = ["I3", "I4", "I5"]
fam_dict[fam_F1.fid] = fam_F1
fam_F2 = familyClass("F2")
fam_F2.husb_id = "I3"
fam_F2.wife_id = "I6"
fam_F2.chil = ["I9", "I10"]
fam_dict[fam_F2.fid] = fam_F2
fam_F3 = familyClass("F3")
fam_F3.husb_id = "I4"
fam_F3.wife_id = "I7"
fam_F3.chil = ["I11"]
fam_dict[fam_F3.fid] = fam_F3
fam_F4 = familyClass("F4")
fam_F4.husb_id = "I5"
fam_F4.wife_id = "I8"
fam_F4.chil = ["I12"]
fam_dict[fam_F4.fid] = fam_F4
fam_F5 = familyClass("F5")
fam_F5.husb_id = "I9"
fam_F5.wife_id = "I11"
fam_dict[fam_F5.fid] = fam_F5
fam_F6 = familyClass("F6")
fam_F6.husb_id = "I10"
fam_F6.wife_id = "I12"
fam_dict[fam_F6.fid] = fam_F6
self.assertEqual(not_to_marry_firstCousin(fam_dict), ({
'F5': ['I9', 'I11'],
'F6': ['I10', 'I12']
}))
self.assertNotEqual(not_to_marry_firstCousin(fam_dict), {'F1': 'I5'})
self.assertIsNotNone(not_to_marry_firstCousin(fam_dict))
self.assertIsNot(not_to_marry_firstCousin(fam_dict), {'F1': 'I5'})
self.assertCountEqual(not_to_marry_firstCousin(fam_dict), ({
'F5': ['I9', 'I11'],
'F6': ['I10', 'I12']
}))
fam_dict = {}
fam_F1 = familyClass("F1")
fam_F1.husb_id = "I1"
fam_F1.wife_id = "I2"
fam_F1.chil = ["I3", "I4", "I5"]
fam_dict[fam_F1.fid] = fam_F1
fam_F2 = familyClass("F2")
fam_F2.husb_id = "I3"
fam_F2.wife_id = "I6"
fam_F2.chil = ["I9", "I10"]
fam_dict[fam_F2.fid] = fam_F2
fam_F3 = familyClass("F3")
fam_F3.husb_id = "I4"
fam_F3.wife_id = "I7"
fam_F3.chil = ["I11"]
fam_dict[fam_F3.fid] = fam_F3
fam_F4 = familyClass("F4")
fam_F4.husb_id = "I5"
fam_F4.wife_id = "I8"
fam_F4.chil = ["I12"]
fam_dict[fam_F4.fid] = fam_F4
fam_F5 = familyClass("F5")
fam_F5.husb_id = "I9"
fam_F5.wife_id = "I13"
fam_dict[fam_F5.fid] = fam_F5
fam_F6 = familyClass("F6")
fam_F6.husb_id = "I10"
fam_F6.wife_id = "I14"
fam_dict[fam_F6.fid] = fam_F6
self.assertEqual(not_to_marry_firstCousin(fam_dict), ({}))
self.assertNotEqual(not_to_marry_firstCousin(fam_dict), {'F1': 'I5'})
self.assertIsNotNone(not_to_marry_firstCousin(fam_dict))
self.assertIsNot(not_to_marry_firstCousin(fam_dict), {'F1': 'I5'})
self.assertCountEqual(not_to_marry_firstCousin(fam_dict), ({}))
def test_order_siblings_by_age(self):
""" Unit tests for US28 - List siblings in families by decreasing age """
indi_dict = {}
fam_dict = {}
i1 = individualPerson("I1")
i1.uid = "I1"
i1.name = "Kyle"
i1.birt = "15 Jul 1992"
indi_dict[i1.uid] = i1
i2 = individualPerson("I2")
i2.uid = "I2"
i2.name = "Ryan"
i2.birt = "13 Apr 1994"
indi_dict[i2.uid] = i2
i3 = individualPerson("I3")
i3.uid = "I3"
i3.name = "Tyler"
i3.birt = "26 Oct 1995"
indi_dict[i3.uid] = i3
i4 = individualPerson("I4")
i4.uid = "I4"
i4.name = "Quinn"
i4.birt = "27 Oct 1997"
indi_dict[i4.uid] = i4
f1 = familyClass("F1")
f1.chil = ["I1", "I2", "I3", "I4"]
fam_dict[f1.fid] = f1
self.assertEqual(
order_siblings_by_age(fam_dict, indi_dict), {
"F1": [["I1", "15 Jul 1992"], ["I2", "13 Apr 1994"],
["I3", "26 Oct 1995"], ["I4", "27 Oct 1997"]]
})
self.assertNotEqual(
order_siblings_by_age(fam_dict, indi_dict), {
"F1": [["I4", "27 Oct 1997"], ["I3", "26 Oct 1995"],
["I2", "13 Apr 1994"], ["I1", "15 Jul 1992"]]
})
i5 = individualPerson("I5")
i5.uid = "I5"
i5.name = "Kyle"
i5.birt = "1 Jan 2003"
indi_dict[i5.uid] = i5
i6 = individualPerson("I6")
i6.uid = "I6"
i6.name = "Ryan"
i6.birt = "1 Jan 2002"
indi_dict[i6.uid] = i6
i7 = individualPerson("I7")
i7.uid = "I7"
i7.name = "Tyler"
i7.birt = "1 Jan 2001"
indi_dict[i7.uid] = i7
f2 = familyClass("F2")
f2.chil = ["I5", "I6", "I7"]
fam_dict[f2.fid] = f2
self.assertEqual(
order_siblings_by_age(fam_dict, indi_dict), {
"F1": [["I1", "15 Jul 1992"], ["I2", "13 Apr 1994"],
["I3", "26 Oct 1995"], ["I4", "27 Oct 1997"]],
"F2": [["I7", "1 Jan 2001"], ["I6", "1 Jan 2002"],
["I5", "1 Jan 2003"]]
})
self.assertNotEqual(
order_siblings_by_age(fam_dict, indi_dict), {
"F1": [["I4", "27 Oct 1997"], ["I3", "26 Oct 1995"],
["I2", "13 Apr 1994"], ["I1", "15 Jul 1992"]]
})
def test_correct_gender_for_role(self):
""" Unit tests for US21 Correct Gender for Role - Husband in family
should be male and wife in family should be female """
indi_dict = {}
fam_dict = {}
i1 = individualPerson('I1')
i1.sex = "M"
i1.uid = 'I1'
indi_dict[i1.uid] = i1
i2 = individualPerson('I2')
i2.sex = "F"
i2.uid = 'I2'
indi_dict[i2.uid] = i2
f1 = familyClass("F1")
f1.husb_id = "I1"
f1.wife_id = "I2"
fam_dict[f1.fid] = f1
self.assertEqual(correct_gender_for_role(fam_dict, indi_dict), {})
self.assertNotEqual(correct_gender_for_role(fam_dict, indi_dict),
{"F1": ["F", "M", "I1"]})
i3 = individualPerson('I3')
i3.sex = "F"
i3.uid = 'I3'
indi_dict[i3.uid] = i3
i4 = individualPerson('I4')
i4.sex = "F"
i4.uid = 'I4'
indi_dict[i4.uid] = i4
f2 = familyClass("F2")
f2.husb_id = "I3"
f2.wife_id = "I4"
fam_dict[f2.fid] = f2
self.assertEqual(correct_gender_for_role(fam_dict, indi_dict),
{"F2": ["F", "M", "I3"]})
self.assertNotEqual(correct_gender_for_role(fam_dict, indi_dict), {})
i5 = individualPerson('I5')
i5.sex = "M"
i5.uid = 'I5'
indi_dict[i5.uid] = i5
i6 = individualPerson('I6')
i6.sex = "M"
i6.uid = 'I6'
indi_dict[i6.uid] = i6
f3 = familyClass("F3")
f3.husb_id = "I5"
f3.wife_id = "I6"
fam_dict[f3.fid] = f3
self.assertEqual(correct_gender_for_role(fam_dict, indi_dict), {
"F2": ["F", "M", "I3"],
"F3": ["M", "F", "I6"]
})
self.assertNotEqual(correct_gender_for_role(fam_dict, indi_dict),
{"F2": ["F", "M", "I3"]})
i7 = individualPerson('I7')
i7.sex = "M"
i7.uid = 'I7'
indi_dict[i7.uid] = i7
i8 = individualPerson('I8')
i8.sex = "NA"
i8.uid = 'I8'
indi_dict[i8.uid] = i8
f4 = familyClass("F4")
f4.husb_id = "I7"
f4.wife_id = "I8"
fam_dict[f4.fid] = f4
self.assertEqual(
correct_gender_for_role(fam_dict, indi_dict), {
"F2": ["F", "M", "I3"],
"F3": ["M", "F", "I6"],
"F4": ["NA", "F", "I8"]
})
self.assertNotEqual(correct_gender_for_role(fam_dict, indi_dict), {
"F2": ["F", "M", "I3"],
"F3": ["M", "F", "I6"]
})
