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_birth_before_death(self):
""" Unit test for US03 -- Birth should occur before death of an individual """
indi_dict = {}
fam_dict = {}
indi_I7 = individualPerson("I7")
indi_I7.birt = "1 JUL 2000"
indi_I7.deat = "5 DEC 1995"
indi_dict[indi_I7.uid] = indi_I7
indi_I10 = individualPerson("I10")
indi_I10.birt = "25 AUG 1980"
indi_I10.deat = "13 MAR 1955"
indi_dict[indi_I10.uid] = indi_I10
indi_I12 = individualPerson("I12")
indi_I12.birt = "25 AUG 1920"
indi_I12.deat = "13 MAR 1955"
indi_dict[indi_I12.uid] = indi_I12
self.assertEqual(death_before_birth(indi_dict, fam_dict), ({
'I7': ['death before birth'],
'I10': ['death before birth']
}))
self.assertNotEqual(death_before_birth(indi_dict, fam_dict), ({
'I1': ['death before birth'],
'I6': ['death before birth']
}))
self.assertIsNotNone(death_before_birth(indi_dict, fam_dict))
self.assertIsNot(death_before_birth(indi_dict, fam_dict), "")
self.assertCountEqual(death_before_birth(indi_dict, fam_dict), ({
'I7': ['death before birth'],
'I10': ['death before birth']
}))
def test_agemorethan150(self):
"""US07 --- Unit test to validate if the person is more than 150 yrs old"""
individual_dict = {}
i1 = individualPerson('I1')
i1.alive = True
i1.birt = '17 AUG 1954'
i1.age = 64
individual_dict[i1.uid] = i1
self.assertTrue(agemorethan_150(individual_dict))
person2 = individualPerson('I34')
person2.birt = '23 SEP 1921'
person2.age = 152
person2.alive = False
individual_dict[person2.uid] = person2
self.assertFalse(agemorethan_150(individual_dict))
person3 = individualPerson('I3')
person3.birt = '12 JUL 1991'
person3.age = 27
person3.alive = True
individual_dict[person3.uid] = person3
self.assertEqual(agemorethan_150(individual_dict), True)
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_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_upcoming_birthdays(self):
""" US38 --- Test cases to validate upcoming birthdays """
indi_dict = {}
i1 = individualPerson('I1')
i1.uid = 'I1'
i1.birt = '19 NOV 2017'
indi_dict[i1.uid] = i1
i2 = individualPerson('I2')
i2.udi = 'I2'
i2.birt = '30 OCT 1955'
indi_dict[i2.uid] = i2
self.assertEqual(len(list_upcoming_birthdays(indi_dict)), 1, True)
i3 = individualPerson('I3')
i3.udi = 'I3'
i3.birt = '31 OCT 1960'
indi_dict[i3.uid] = i3
i4 = individualPerson('I4')
i4.udi = 'I4'
i4.birt = '29 NOV 1989'
indi_dict[i4.uid] = i4
self.assertEqual(len(list_upcoming_birthdays(indi_dict)), 2, True)
def test_deceased_list(self):
""" US29 --- Unit test to validate return of list of deceased people"""
ind_dict = dict()
individual = individualPerson('I123')
individual.alive = False
ind_dict[individual.uid] = individual
individual2 = individualPerson('I456')
ind_dict[individual2.uid] = individual2
self.assertEqual(len(deceased_list(ind_dict)), 1, True)
individual3 = individualPerson('I789')
ind_dict[individual3.uid] = individual3
individual3.alive = False
self.assertEqual(len(deceased_list(ind_dict)), 2, True)
individual4 = individualPerson('I987')
ind_dict[individual4.uid] = individual4
individual4.alive = True
self.assertEqual(len(deceased_list(ind_dict)), 2, True)
individual5 = individualPerson('I744')
ind_dict[individual5.uid] = individual5
individual5.alive = False
self.assertEqual(len(deceased_list(ind_dict)), 3, True)
def test_get_age(self):
individual = individualPerson('I123')
individual.birt = '7 MAY 2017'
self.assertEqual(1, individual.get_age(), True)
individual = individualPerson('I456')
individual.birt = '10 SEP 1998'
self.assertEqual(20, individual.get_age(), False)
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_recent_deaths(self):
""" US36 --- Unit Test for Checking recent deaths """
indi_dict = {}
i1 = individualPerson('I1')
i1.uid = 'I1'
i1.deat = '29 OCT 2018'
indi_dict[i1.uid] = i1
i2 = individualPerson('I2')
i2.udi = 'I2'
i2.deat = '15 AUG 2018'
indi_dict[i2.uid] = i2
self.assertEqual(len(list_recent_death(indi_dict)), 1, True)
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_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_recent_births(self):
""" US35 --- Unit Test for Checking recent births """
indi_dict = {}
i1 = individualPerson('I11')
i1.uid = 'I11'
i1.birt = '29 SEP 2017'
indi_dict[i1.uid] = i1
i2 = individualPerson('I12')
i2.udi = 'I12'
i2.birt = '15 AUG 2018'
indi_dict[i2.uid] = i2
i3 = individualPerson('I13')
i3.udi = 'I13'
i3.birt = '30 SEP 2018'
indi_dict[i3.uid] = i3
self.assertEqual(len(list_recent_births(indi_dict)), 0, True)
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_life_status(self):
""" Unit test for checking a person's life status and whether their death date
occurred before their marriage date; if yes, return True else, return False. """
ind_dict = {}
individual = individualPerson("I1")
individual.uid = "I1"
individual.alive = False
individual.deat = "1 JAN 2000"
ind_dict[individual.uid] = individual
individual2 = individualPerson("I2")
individual2.uid = "I2"
individual2.alive = True
individual2.deat = "NA"
ind_dict[individual2.uid] = individual2
self.assertTrue(check_life_status(ind_dict["I1"], "1 JAN 2005"))
self.assertFalse(check_life_status(ind_dict["I2"], "1 JAN 2005"))
def test_validate_unique_name_birthdate(self):
""" Test cases for US23 --- No more than one individual with the same name and birth date should appear in a GEDCOM file"""
indi_dict = {}
indi_I3 = individualPerson("I3")
indi_I3.name = "John Hernandez"
indi_I3.birt = "15 AUG 1947"
indi_dict[indi_I3.uid] = indi_I3
indi_I4 = individualPerson("I4")
indi_I4.name = "Ricky Pointing"
indi_I4.birt = "09 NOV 1949"
indi_dict[indi_I4.uid] = indi_I4
indi_I5 = individualPerson("I5")
indi_I5.name = "John Hernandez"
indi_I5.birt = "15 AUG 1947"
indi_dict[indi_I5.uid] = indi_I5
indi_I6 = individualPerson("I6")
indi_I6.name = "John Hernandez"
indi_I6.birt = "15 AUG 1947"
indi_dict[indi_I6.uid] = indi_I6
indi_I7 = individualPerson("I7")
indi_I7.name = "John Hernandez"
indi_I7.birt = "15 AUG 1947"
indi_dict[indi_I7.uid] = indi_I7
self.assertEqual(
validate_unique_name_birthdate(indi_dict),
([['I3', 'I5', 'I6', 'I7', 'John Hernandez', '1947-08-15']]))
self.assertNotEqual(validate_unique_name_birthdate(indi_dict),
{'F1': 'I5'})
self.assertIsNotNone(validate_unique_name_birthdate(indi_dict))
self.assertIsNot(validate_unique_name_birthdate(indi_dict),
{'F1': 'I5'})
self.assertCountEqual(
validate_unique_name_birthdate(indi_dict),
([['I3', 'I5', 'I6', 'I7', 'John Hernandez', '1947-08-15']]))
indi_dict = {}
indi_I8 = individualPerson("I8")
indi_I8.name = "John Hernandez"
indi_I8.birt = "15 AUG 1947"
indi_dict[indi_I8.uid] = indi_I8
indi_I9 = individualPerson("I9")
indi_I9.name = "Ricky Pointing"
indi_I9.birt = "09 FEB 1935"
indi_dict[indi_I9.uid] = indi_I9
self.assertEqual(validate_unique_name_birthdate(indi_dict), ([]))
self.assertNotEqual(validate_unique_name_birthdate(indi_dict),
{'F1': 'I5'})
self.assertIsNotNone(validate_unique_name_birthdate(indi_dict))
self.assertIsNot(validate_unique_name_birthdate(indi_dict),
{'F1': 'I5'})
self.assertCountEqual(validate_unique_name_birthdate(indi_dict), ([]))
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))
class TestindividualPerson(unittest.TestCase):
"""Unit test for individualPerson class"""
individual = individualPerson('I123')
def test_get_age(self):
individual = individualPerson('I123')
individual.birt = '7 MAY 2017'
self.assertEqual(1, individual.get_age(), True)
individual = individualPerson('I456')
individual.birt = '10 SEP 1998'
self.assertEqual(20, individual.get_age(), False)
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_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_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_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_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_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), {})
