package com.example.familymap; import static org.junit.Assert.assertEquals; import static org.junit.Assert.assertFalse; import static org.junit.Assert.assertNotNull; import static org.junit.Assert.assertNull; import static org.junit.Assert.assertTrue; import org.junit.After; import org.junit.jupiter.api.AfterAll; import org.junit.jupiter.api.AfterEach; import org.junit.jupiter.api.BeforeEach; import org.junit.jupiter.api.Test; import java.util.ArrayList; import java.util.List; import model.Event; import model.Person; public class DataCacheTests { private DataCache dataCache; @BeforeEach public void setUp() { dataCache = dataCache.getInstance(); } @AfterEach public void tearDown() { dataCache.clearInstance(); } @Test public void calculateFamilyRelationshipsPass() { //First, we create a list of persons to calculate the immediate family of our testPerson List<Person> family = new ArrayList<>(); //We will add persons up to the grandparents of our testPerson Person testPerson = new Person("Daniel_A", "DanielA", "Daniel", "Adams", "m", "David_B", "Sally_B", null); family.add(testPerson); Person father = new Person("David_B", "DanielA", "David", "Brooks", "m", "Adam_S", "Alice_S", "Sally_B"); family.add(father); Person mother = new Person("Sally_B", "DanielA", "Sally", "Brooks", "f", null, null, "David_B"); family.add(mother); Person grandFather1 = new Person("Adam_S", "DanielA", "Adam", "Savage", "m", null, null, "Alice_S"); family.add(grandFather1); Person grandMother1 = new Person("Alice_S", "DanielA", "Alice", "Savage", "f", null, null, "Adam_S"); family.add(grandMother1); Person grandFather2 = new Person("John_R", "DanielA", "John", "Ransburg", "m", null, null, "Susan_R"); family.add(grandMother1); Person grandMother2 = new Person("Susan_R", "DanielA", "Susan", "Ransburg", "f", null, null, "John_R"); family.add(grandMother2); //We now call the function from our dataCache to create a map where a personID is mapped to their immediate family dataCache.populateImmediateFamily(family); //Our test person should be mapped to two family members, their mom and their dad List<Person> immediateFamily = dataCache.getPersonFamilyMap().get(testPerson.getPersonID()); assertEquals(immediateFamily.size(), 2); //We now check the persons in immediateFamily to make sure that they are the parents of the testPerson for (int i = 0; i < immediateFamily.size(); i++) { if (immediateFamily.get(i).getGender().equals("m")) { assertEquals(immediateFamily.get(i).getPersonID(), father.getPersonID()); } else { assertEquals(immediateFamily.get(i).getPersonID(), mother.getPersonID()); } } } @Test public void calculateFamilyRelationshipsAbnormal() { //Here we will test a user that has no immediate family Person testPerson = new Person("Daniel_A", "DanielA", "Daniel", "Adams", "m", null, null, null); String personID = testPerson.getPersonID(); List<Person> persons = new ArrayList<>(); persons.add(testPerson); dataCache.populateImmediateFamily(persons); //The list associated with the testPerson should be null since they have no immediate family members assertNull(dataCache.getPersonFamilyMap().get(personID)); } @Test public void filterEventsPass() { //Here we will test that our dataCache filters out maleEvents when the showMaleEvents setting is turned off Event maleEvent1 = new Event("maleEvent1", "DanielA", "Daniel_A", 82, -61, "Canada", "Alert", "male", 1970); Event maleEvent2 = new Event("maleEvent2", "DanielA", "John_C", 81, -15, "Denmark", "Nord", "male", 1980); Event femaleEvent1 = new Event("femaleEvent1", "DanielA", "Alice_A", 71, -155, "United States", "Barrow", "female", 2000); Event femaleEvent2 = new Event("femaleEvent2", "DanielA", "Jamie_C", 70, 23, "Norway", "Hammerfest", "female", 2012); dataCache.getMaleEvents().add(maleEvent1); dataCache.getMaleEvents().add(maleEvent2); dataCache.getFemaleEvents().add(femaleEvent1); dataCache.getFemaleEvents().add(femaleEvent2); dataCache.getAllEvents().addAll(dataCache.getMaleEvents()); dataCache.getAllEvents().addAll(dataCache.getFemaleEvents()); dataCache.setShowMaleEvents(false); List<Event> filteredEvents = dataCache.filterEvents(); //Since we filtered out the male events, the size of our array should be 2 assertEquals(filteredEvents.size(), 2); //We set the event type to either male or female as a way to check the gender for each event //Makes sure that every event is a female event for (int i = 0; i < filteredEvents.size(); i++) { assertEquals(filteredEvents.get(i).getEventType(), "female"); } //Now if we turn on male events again, the size of our filtered events should be 4 dataCache.setShowMaleEvents(true); filteredEvents = dataCache.filterEvents(); assertEquals(filteredEvents.size(), 4); } @Test public void filterEventsAbnormal() { //Here we test our filterEvents function if all of the settings are turned off //Our filteredEvents should contain no elements Event maleEvent = new Event("maleEvent", "DanielA", "Daniel_A", 82, -61, "Canada", "Alert", "male", 1970); Event femaleEvent = new Event("femaleEvent", "DanielA", "Alice_A", 71, -155, "United States", "Barrow", "female", 2000); Event paternalEvent = new Event("paternalEvent", "DanielA", "John_C", 81, -15, "Denmark", "Nord", "male", 1980); Event maternalEvent = new Event("maternalEvent", "DanielA", "Jamie_C", 70, 23, "Norway", "Hammerfest", "female", 2012); dataCache.getMaleEvents().add(maleEvent); dataCache.getMalePaternalEvents().add(maleEvent); dataCache.getFemaleEvents().add(femaleEvent); dataCache.getFemaleMaternalEvents().add(femaleEvent); dataCache.getAllEvents().add(maleEvent); dataCache.getAllEvents().add(femaleEvent); dataCache.getAllEvents().add(paternalEvent); dataCache.getAllEvents().add(maternalEvent); dataCache.setShowMaleEvents(false); dataCache.setShowFemaleEvents(false); dataCache.setShowFathersSide(false); dataCache.setShowMothersSide(false); List<Event> filteredEvents = dataCache.filterEvents(); assertEquals(filteredEvents.size(), 0); //Now if we turn on all the settings again, the size of filteredEvents should be 4 dataCache.setShowMaleEvents(true); dataCache.setShowFemaleEvents(true); dataCache.setShowFathersSide(true); dataCache.setShowMothersSide(true); filteredEvents = dataCache.filterEvents(); assertEquals(filteredEvents.size(), 4); } @Test public void sortEventsPass() { //The filterEvents function that I created also sorts the events of each person in the personEvents map Person testPerson = new Person("Daniel_A", "DanielA", "Daniel", "Adams", "m", null, null, null); String personID = testPerson.getPersonID(); Event event1 = new Event("event1", "DanielA", "Daniel_A", 82, -61, "Canada", "Alert", "baptism", 1974); Event event2 = new Event("event2", "DanielA", "Daniel_A", 81, -15, "Denmark", "Nord", "death", 2021); Event event3 = new Event("event3", "DanielA", "Daniel_A", 71, -155, "United States", "Barrow", "birth", 1963); //We add all of the test events to a list and put them as the value in the personEvents map List<Event> testEvents = new ArrayList<>(); testEvents.add(event1); testEvents.add(event2); testEvents.add(event3); dataCache.getPersonEventsMap().put(personID, testEvents); //At first, the order of the years in our events should be 1974, 2021, 1963 List<Event> oldEvents = dataCache.getPersonEventsMap().get(personID); assertEquals(oldEvents.get(0).getYear(), 1974); assertEquals(oldEvents.get(1).getYear(), 2021); assertEquals(oldEvents.get(2).getYear(), 1963); //After filtering the events, the order should be 1963, 1974, 2021 dataCache.filterEvents(); List<Event> newPersonEvents = dataCache.getPersonEventsMap().get(personID); assertEquals(newPersonEvents.get(0).getYear(), 1963); assertEquals(newPersonEvents.get(1).getYear(), 1974); assertEquals(newPersonEvents.get(2).getYear(), 2021); } @Test public void sortEventsAbnormal() { //Here we test what happens when two events with identical years are sorted by the dataCache //I sorted my events so that an event with a lowercase letter as its first character would come before an event with an uppercase letter Person testPerson = new Person("Daniel_A", "DanielA", "Daniel", "Adams", "m", null, null, null); String personID = testPerson.getPersonID(); Event event1 = new Event("event1", "DanielA", "Daniel_A", 82, -61, "Canada", "Alert", "Birth", 1970); Event event2 = new Event("event2", "DanielA", "Daniel_A", 81, -15, "Denmark", "Nord", "birth", 1970); //We add all of the test events to a list and put them as the value in the personEvents map List<Event> testEvents = new ArrayList<>(); testEvents.add(event1); testEvents.add(event2); dataCache.getPersonEventsMap().put(personID, testEvents); //The first event should be the one with the "Birth" event type and the second should be the one with the "birth" event type List<Event> oldEvents = dataCache.getPersonEventsMap().get(personID); assertEquals(oldEvents.get(0).getYear(), oldEvents.get(1).getYear()); assertEquals(oldEvents.get(0).getEventType(), "Birth"); assertEquals(oldEvents.get(1).getEventType(), "birth"); //After filtering the events, the order should is now the "birth" event, followed by the "Birth" event dataCache.filterEvents(); List<Event> newPersonEvents = dataCache.getPersonEventsMap().get(personID); assertEquals(newPersonEvents.get(0).getEventType(), "birth"); assertEquals(newPersonEvents.get(1).getEventType(), "Birth"); } @Test public void searchPass() { //Since the search I used implemented the default Filter interface, I will use the exact code used in the overridden functions to test the search //I didn't actually have a search function within my dataCache List<String> searchResults = new ArrayList<>(); Person person = new Person("Daniel_A", "DanielA", "Daniel", "Adams", "m", "David_B", "Sally_B", null); String fullName = person.getFirstName() + " " + person.getLastName(); searchResults.add(fullName); Event event1 = new Event("maleEvent", "DanielA", "Daniel_A", 82, -61, "Canada", "Alert", "death", 1970); String event1Info = event1.getEventType() + ": " + event1.getCity() + ", " + event1.getCountry() + " (" + event1.getYear() + ")"; searchResults.add(event1Info); Event event2 = new Event("femaleEvent", "DanielA", "Alice_A", 71, -155, "United States", "Barrow", "birth", 2000); String event2Info = event2.getEventType() + ": " + event2.getCity() + ", " + event2.getCountry() + " (" + event2.getYear() + ")"; searchResults.add(event2Info); String searchText = "th"; List<String> filteredResults = new ArrayList<>(); //There are two results that contain a "th" (event1 and event2) so they will be the results when we do our search filter for (int i = 0; i < searchResults.size(); i++) { if (searchResults.get(i).contains(searchText.toLowerCase())) { filteredResults.add(searchResults.get(i)); } } assertEquals(filteredResults.size(), 2); assertEquals(event1Info, filteredResults.get(0)); assertEquals(event2Info, filteredResults.get(1)); } @Test public void searchAbnormal() { //Here we test what would happen if none of the results matched up with the search text List<String> searchResults = new ArrayList<>(); Person person = new Person("Daniel_A", "DanielA", "Daniel", "Adams", "m", "David_B", "Sally_B", null); String fullName = person.getFirstName() + " " + person.getLastName(); searchResults.add(fullName); Event event1 = new Event("maleEvent", "DanielA", "Daniel_A", 82, -61, "Canada", "Alert", "death", 1970); String event1Info = event1.getEventType() + ": " + event1.getCity() + ", " + event1.getCountry() + " (" + event1.getYear() + ")"; searchResults.add(event1Info); Event event2 = new Event("femaleEvent", "DanielA", "Alice_A", 71, -155, "United States", "Barrow", "birth", 2000); String event2Info = event2.getEventType() + ": " + event2.getCity() + ", " + event2.getCountry() + " (" + event2.getYear() + ")"; searchResults.add(event2Info); String searchText = "invalid"; List<String> filteredResults = new ArrayList<>(); for (int i = 0; i < searchResults.size(); i++) { if (searchResults.get(i).contains(searchText.toLowerCase())) { filteredResults.add(searchResults.get(i)); } } //Here we check to make sure that the size of the filteredResults list is 0 (since no persons/events matched the search text) //This means that in our recycler view we would not display anything assertEquals(filteredResults.size(), 0); } }