/**
* deze methode koppelt de opgegeven trainer aan de opgegeven ploeg
*
* @param naam de naam van de trainer
* @param voornaam de voornaam van de trainer
* @param ploegnaam de ploegnaam van de ploeg
* @throws DBException
* @throws ApplicationException
*/
public void toevoegenTrainerPloeg(String naam, String voornaam, String ploegnaam)
throws DBException, ApplicationException {
Persoon persoon = persoonDB.zoekPersoon(naam, voornaam);
Ploeg ploeg = zoekPloeg(ploegnaam);
toevoegenTrainerPloeg(persoon.getId(), ploeg.getId());
}
void toonPersoonsgegevens() {
Persoon p = selecteerPersoon();
if (p == null) {
System.out.println("persoon onbekend");
} else {
System.out.println(p.beschrijving());
}
}
@Test
public void testGetNaam() {
/**
* @return de initialen gevolgd door een eventueel tussenvoegsel en afgesloten door de
* achternaam
*/
assertEquals("naam incorrect", "P.F. Swinkels", piet.getNaam());
assertEquals("naam incorrect", "T. de Vries", teuntje.getNaam());
}
private void showStamboom() {
Persoon p = selecteerPersoon();
if (p == null) {
System.out.println("persoon onbekend");
} else {
System.out.println(String.format("Stamboom heeft %s personen", p.afmetingStamboom()));
System.out.println(p.stamboomAlsString());
}
}
Persoon selecteerPersoon() {
String naam = readString("wat is de achternaam");
ArrayList<Persoon> personen = getAdmin().getPersonenMetAchternaam(naam);
for (Persoon p : personen) {
System.out.println(p.getNr() + "\t" + p.getNaam() + " " + datumString(p.getGebDat()));
}
int invoer = readInt("selecteer persoonsnummer");
input.nextLine();
Persoon p = getAdmin().getPersoon(invoer);
return p;
}
Gezin selecteerGezin() {
String naam = readString("gezin van persoon met welke achternaam");
ArrayList<Persoon> kandidaten = getAdmin().getPersonenMetAchternaam(naam);
for (Persoon p : kandidaten) {
List<Gezin> gezinnen = p.getAlsOuderBetrokkenIn();
System.out.print(p.getNr() + "\t" + p.getNaam() + " " + datumString(p.getGebDat()));
System.out.print(" gezinnen: ");
for (Gezin gezin : gezinnen) {
System.out.print(" " + gezin.getNr());
}
System.out.println();
}
int invoer = readInt("selecteer gezinsnummer");
input.nextLine();
return getAdmin().getGezin(invoer);
}
/**
* deze methode zoekt de trainer op van de opgegeven ploeg
*
* @param ploegnaam de naam van de ploeg waarvan je de trainer wilt zoeken
* @return
* @throws DBException
*/
public Persoon getTrainer(String ploegnaam) throws DBException {
try (Connection conn = ConnectionManager.getConnection(); ) {
// preparedStatement opstellen (en automtisch sluiten)
try (PreparedStatement stmt =
conn.prepareStatement(
"select id,naam,voornaam,geboortedatum,isTrainer,opmerking from persoon where id in (select trainer_id from ploeg where id in (select id from ploeg where naam='?'))"); ) {
// execute voert elke sql-statement uit, executeQuery enkel de eenvoudige
stmt.execute();
// result opvragen (en automatisch sluiten)
try (ResultSet r = stmt.getResultSet()) {
Persoon k = new Persoon();
while (r.next()) {
k.setId(r.getInt("id"));
k.setNaam(r.getString("naam"));
k.setVoornaam(r.getString("voornaam"));
k.setGeboortedatum(r.getDate("geboortedatum"));
k.setTrainer(r.getBoolean("isTrainer"));
k.setOpmerking(r.getString("opmerking"));
}
return k;
} catch (SQLException sqlEx) {
throw new DBException(
"SQL-exception in getTrainer (String ploegnaam) - resultset" + sqlEx);
}
} catch (SQLException sqlEx) {
throw new DBException("SQL-exception in getTrainer (String ploegnaam) - statement" + sqlEx);
}
} catch (SQLException sqlEx) {
throw new DBException("SQL-exception in getTrainer (String ploegnaam) - connection" + sqlEx);
}
}
/**
* deze methode koppelt de opgegeven speler aan de opgegeven ploeg
*
* @param ploegnaam De ploeg waaraan je een speler wilt koppelen.
* @param persoon De persoon die je aan een ploeg wilt koppelen.
* @throws DBException
* @throws exception.ApplicationException
*/
public void toevoegenSpelerPloeg(String ploegnaam, Persoon persoon)
throws DBException, ApplicationException {
Persoon p = persoonDB.zoekPersoon(persoon);
// connectie tot stand brengen (en automatisch sluiten)
try (Connection conn = ConnectionManager.getConnection(); ) {
// preparedStatement opstellen (en automtisch sluiten)
try (PreparedStatement stmt =
conn.prepareStatement(
"update persoon set ploeg_id=(select id from ploeg where naam=?) where id=?;"); ) {
stmt.setString(1, ploegnaam);
stmt.setInt(2, p.getId());
stmt.execute();
} catch (SQLException sqlEx) {
throw new DBException(
"SQL-exception in toevoegenSpelerPloeg(String naam,PersoonBag p) - statement" + sqlEx);
}
} catch (SQLException sqlEx) {
throw new DBException(
"SQL-exception in toevoegenSpelerPloeg(String naam,PersoonBag p) - connection" + sqlEx);
}
}
@Test
public void testSetOuders() {
/**
* als het ouderlijk gezin van deze persoon nog onbekend is dan wordt deze persoon een kind van
* ouderlijkGezin en tevens wordt deze persoon als kind in dat gezin geregistreerd
*/
Persoon mark =
adm.addPersoon(
Geslacht.MAN,
new String[] {"Markus", "Anna"},
"sWinkelS",
"",
new GregorianCalendar(1986, Calendar.APRIL, 13),
"venLO",
null);
int aantalKinderen = pietEnTeuntje.aantalKinderen();
mark.setOuders(pietEnTeuntje);
assertEquals("ouders onbekend", pietEnTeuntje, mark.getOuderlijkGezin());
assertEquals("ouders geen kind erbij", aantalKinderen + 1, pietEnTeuntje.aantalKinderen());
List<Persoon> kinderen = pietEnTeuntje.getKinderen();
boolean gevonden = false;
for (Persoon kind : kinderen) {
if (kind == mark) {
gevonden = true;
}
}
assertTrue("ouders geen kind erbij", gevonden);
/*
* als de ouders bij aanroep al
* bekend zijn, verandert er niets
*/
aantalKinderen = pietEnTeuntje.aantalKinderen();
mark.setOuders(pietEnTeuntje);
assertEquals("ouders ten onrechte kind erbij", aantalKinderen, pietEnTeuntje.aantalKinderen());
}
/**
* deze methode geeft een ArrayList terug waarin alle spelers van de opgegeven ploeg zitten
*
* @param id het id van de ploeg waarvan je alle spelers wilt opvragen
* @return
* @throws DBException
*/
public ArrayList<Persoon> zoekSpelersPloeg(int id) throws DBException {
ArrayList<Persoon> sp = new ArrayList<>();
// connectie tot stand brengen (en automatisch sluiten)
try (Connection conn = ConnectionManager.getConnection(); ) {
// preparedStatement opstellen (en automtisch sluiten)
try (PreparedStatement stmt =
conn.prepareStatement(
"select id, naam, voornaam, geboortedatum, isTrainer,ploeg_id from persoon where isTrainer=\"false\" and ploeg_id in(select id from ploeg where id=?)"); ) {
stmt.setInt(1, id);
// execute voert elke sql-statement uit, executeQuery enkel de eenvoudige
stmt.execute();
// result opvragen (en automatisch sluiten)
try (ResultSet r = stmt.getResultSet()) {
// van alle spelers uit de database Persoon-objecten maken
while (r.next()) {
Persoon k = new Persoon();
k.setId(r.getInt("id"));
k.setNaam(r.getString("naam"));
k.setVoornaam(r.getString("voornaam"));
k.setGeboortedatum(r.getDate("geboortedatum"));
k.setTrainer(r.getBoolean("isTrainer"));
if (r.getObject("ploeg_id") == null) {
k.setPloegid(null);
} else {
k.setPloegid(r.getInt("ploeg_id"));
}
sp.add(k);
}
return sp;
} catch (SQLException sqlEx) {
throw new DBException("SQL-exception in zoekSpelersPloeg(int id) - resultset" + sqlEx);
}
} catch (SQLException sqlEx) {
throw new DBException("SQL-exception in zoekSpelersPloeg(int id)n - statement" + sqlEx);
}
} catch (SQLException sqlEx) {
throw new DBException("SQL-exception in zoekSpelersPloeg(int id) - connection" + sqlEx);
}
}
/** Test van addPersoon methode in class Administratie. */
@Test
public void testAddPersoon() {
/* er wordt een persoon met een gegeven geslacht, met als voornamen vnamen,
* achternaam anaam, tussenvoegsel tvoegsel, geboortedatum gebdat,
* geboorteplaats gebplaats en een gegeven ouderlijk gezin;*/
assertEquals("geslacht onjuist", Geslacht.VROUW, teuntje.getGeslacht());
assertEquals("voornamen onjuist", "Teuntje", teuntje.getVoornamen());
assertEquals("voornamen onjuist", "Piet Franciscus", piet.getVoornamen());
assertEquals("tussenvoegsel onjuist", "", piet.getTussenvoegsel());
assertEquals("tussenvoegsel onjuist", "de", teuntje.getTussenvoegsel());
assertEquals(
"geboortedatum onjuist", "23-4-1950", StringUtilities.datumString(piet.getGebDat()));
assertEquals("geboorteplaats onjuist", "Ede", piet.getGebPlaats());
assertEquals("ouderlijk gezin onjuist", null, piet.getOuderlijkGezin());
Persoon jan =
adm.addPersoon(
Geslacht.MAN,
new String[] {"Jan", "Jacobus"},
"Peters",
"",
new GregorianCalendar(1980, Calendar.APRIL, 23),
"Venray",
pietEnTeuntje);
assertEquals("ouderlijk gezin onjuist", pietEnTeuntje, jan.getOuderlijkGezin());
/* de persoon
* krijgt een uniek nummer toegewezen de persoon is voortaan ook bij het
* ouderlijk gezin bekend.
*/
assertEquals("persoonsnummering onjuist", 1, piet.getNr());
assertEquals("persoonsnummering onjuist", 3, jan.getNr());
assertFalse(
"kind niet bij ouderlijk gezin geregistreerd", pietEnTeuntje.getKinderen().isEmpty());
assertEquals(
"kind niet bij ouderlijk gezin geregistreerd", jan, pietEnTeuntje.getKinderen().get(0));
/* Voor de voornamen, achternaam en gebplaats geldt
* dat de eerste letter naar een hoofdletter en de resterende letters naar
* een kleine letter zijn geconverteerd; het tussenvoegsel is zo nodig in
* zijn geheel geconverteerd naar kleine letters.*/
Persoon tom =
adm.addPersoon(
Geslacht.MAN,
new String[] {"tom", "JACOBUS"},
"sWinkelS",
"VaN deR",
new GregorianCalendar(1971, Calendar.APRIL, 13),
"venLO",
pietEnTeuntje);
ArrayList<Persoon> swinkelsen = adm.getPersonenMetAchternaam("Swinkels");
assertEquals("zoeken op achternaam onjuist", 2, swinkelsen.size());
assertEquals("voornamen niet correct weergegeven", "Tom Jacobus", tom.getVoornamen());
assertEquals("achternaam niet correct weergegeven", "Swinkels", tom.getAchternaam());
assertEquals("geboorteplaats niet correct weergegeven", "Venlo", tom.getGebPlaats());
assertEquals("tussenvoegsel niet correct weergegeven", "van der", tom.getTussenvoegsel());
/* @return als de persoon al bekend was (op basis van combinatie van naam,
* geboorteplaats en geboortedatum), wordt er null
* geretourneerd, anders de nieuwe persoon*/
Persoon tom2 =
adm.addPersoon(
Geslacht.VROUW,
new String[] {"t", "J"},
"sWinkelS",
"VaN deR",
new GregorianCalendar(1971, Calendar.APRIL, 13),
"venLO",
null);
assertNull("unieke identificatie persoon onjuist", tom2);
List<Persoon> kinderen = pietEnTeuntje.getKinderen();
assertEquals("aantal kinderen onjuist", 2, kinderen.size());
assertEquals("eerste kind ontbreekt", jan, kinderen.get(0));
assertEquals("tweede kind ontbreekt", tom, kinderen.get(1));
}
@Test
public void testAddHuwelijk() {
/** als er al een ongehuwd gezin voor dit koppel bestaat, wordt het huwelijk voltrokken */
Persoon annie =
adm.addPersoon(
Geslacht.VROUW,
new String[] {"Annie", "Gedula"},
"Dael",
"",
new GregorianCalendar(1981, Calendar.APRIL, 3),
"Bergen op Zoom",
null);
Persoon jan =
adm.addPersoon(
Geslacht.MAN,
new String[] {"Jan", "Jacobus"},
"Peters",
"",
new GregorianCalendar(1980, Calendar.APRIL, 23),
"Venray",
pietEnTeuntje);
Gezin annieEnJan = adm.addOngehuwdGezin(annie, jan);
Gezin huwelijk = adm.addHuwelijk(jan, annie, nu);
assertEquals("ongehuwd gezin trouwt", huwelijk, annieEnJan);
assertEquals("huwelijksdatum bekend", nu, huwelijk.getHuwelijksdatum());
assertNull("scheidingsdatum onbekend", huwelijk.getScheidingsdatum());
/* anders wordt er zo mogelijk (zie return) een
* (kinderloos) gehuwd gezin met ouder1 en ouder2 als ouders gecreeerd;
* de scheidingsdatum is onbekend (null); */
Persoon trees =
adm.addPersoon(
Geslacht.VROUW,
new String[] {"trees", "Gedula"},
"Dael",
"van",
new GregorianCalendar(1981, Calendar.APRIL, 3),
"Sevenum",
null);
Persoon jaap =
adm.addPersoon(
Geslacht.MAN,
new String[] {"Jaap"},
"Giesbers",
"",
new GregorianCalendar(1980, Calendar.APRIL, 23),
"Venray",
null);
Gezin treesEnJaap =
adm.addHuwelijk(trees, jaap, new GregorianCalendar(2013, Calendar.APRIL, 23));
assertTrue("geen kinderen", treesEnJaap.getKinderen().isEmpty());
assertTrue("gehuwd gezin", treesEnJaap.isHuwelijkOp(nu));
assertEquals("ouder1 is trees", trees, treesEnJaap.getOuder1());
assertEquals("ouder2 is jaap", jaap, treesEnJaap.getOuder2());
/*
* scheidingsdatum is onbekend (null);
*/
assertNull("scheidingsdatum onbekend", treesEnJaap.getScheidingsdatum());
/* het gezin krijgt een uniek nummer toegewezen */
assertEquals("nummering van gezin lijkt onjuist", 3, treesEnJaap.getNr());
/* dit gezin wordt ook bij de afzonderlijke ouders geregistreerd;
*/
assertFalse("registratie bij ouders onjuist", trees.getAlsOuderBetrokkenIn().isEmpty());
assertFalse("registratie bij ouders onjuist", jaap.getAlsOuderBetrokkenIn().isEmpty());
assertEquals(
"registratie bij ouders onjuist", treesEnJaap, jaap.getAlsOuderBetrokkenIn().get(0));
assertEquals(
"registratie bij ouders onjuist", treesEnJaap, trees.getAlsOuderBetrokkenIn().get(0));
Persoon petra =
adm.addPersoon(
Geslacht.VROUW,
new String[] {"Petra", "Gedula"},
"Dael",
"",
new GregorianCalendar(1981, Calendar.APRIL, 3),
"Bergen op Zoom",
null);
Persoon roel =
adm.addPersoon(
Geslacht.MAN,
new String[] {"Roel", "Jacobus"},
"Peters",
"",
new GregorianCalendar(1983, Calendar.APRIL, 23),
"Venray",
pietEnTeuntje);
Gezin petraEnRoel = adm.addOngehuwdGezin(petra, roel);
Persoon john =
adm.addPersoon(
Geslacht.MAN,
new String[] {"John", "Adriaan"},
"Krop",
"",
new GregorianCalendar(1973, Calendar.JANUARY, 3),
"Eindhoven",
pietEnTeuntje);
Gezin johnEnRoel = adm.addHuwelijk(john, roel, nu);
assertNotNull(
"huwelijk waarvoor een van de partners bij een ongehuwd gezin betrokken is", johnEnRoel);
/*het gezin krijgt een uniek nummer toegewezen;*/
assertEquals("nummering van gezin lijkt onjuist", petraEnRoel.getNr() + 1, johnEnRoel.getNr());
/**
* @return null als ouder1 = ouder2 of als een van de ouders getrouwd is anders het gehuwde
* gezin
*/
Persoon pim =
adm.addPersoon(
Geslacht.MAN,
new String[] {"Pim"},
"sWinkelS",
"VaN deR",
new GregorianCalendar(1995, Calendar.APRIL, 13),
"venLO",
pietEnTeuntje);
assertNull("ouders verschillend", adm.addHuwelijk(pim, pim, nu));
assertNull("ouders ongehuwd", adm.addHuwelijk(roel, pim, Calendar.getInstance()));
assertNull("ouders ongehuwd", adm.addHuwelijk(pim, roel, Calendar.getInstance()));
Calendar datum1 = new GregorianCalendar(1995, Calendar.APRIL, 13);
Calendar datum2 = new GregorianCalendar(1996, Calendar.APRIL, 13);
Calendar datum3 = new GregorianCalendar(1996, Calendar.APRIL, 14);
Calendar datum4 = new GregorianCalendar(1996, Calendar.APRIL, 15);
// merk op: datum1 < datum2 < datum3 < datum4
Persoon miep =
adm.addPersoon(
Geslacht.VROUW,
new String[] {"miep"},
"Dael",
"",
new GregorianCalendar(1981, Calendar.APRIL, 3),
"Bergen op Zoom",
null);
Persoon jacco =
adm.addPersoon(
Geslacht.MAN,
new String[] {"Jacco", "Jacobus"},
"Hop",
"",
new GregorianCalendar(1983, Calendar.APRIL, 23),
"Venray",
null);
Gezin miepEnJacco = adm.addHuwelijk(miep, jacco, datum1);
miepEnJacco.setScheiding(datum3);
Persoon aafke =
adm.addPersoon(
Geslacht.VROUW,
new String[] {"aafke"},
"Dael",
"",
new GregorianCalendar(1981, Calendar.APRIL, 3),
"Bergen op Zoom",
null);
assertNull("jacco is nog getrouwd", adm.addHuwelijk(aafke, jacco, datum2));
assertNotNull("jacco is niet meer getrouwd", adm.addHuwelijk(aafke, jacco, datum4));
Persoon frank =
adm.addPersoon(
Geslacht.MAN,
new String[] {"Frank", "Johan"},
"Kroes",
"",
new GregorianCalendar(1983, Calendar.APRIL, 23),
"Helmond",
null);
assertNull("aafke is naderhand getrouwd", adm.addHuwelijk(aafke, frank, datum1));
}
@Test
public void testAddOngehuwdGezin() {
/**
* er wordt, zo mogelijk (zie return) een (kinderloos) ongehuwd gezin met ouder1 en ouder2 als
* ouders gecreeerd;
*/
Persoon annie =
adm.addPersoon(
Geslacht.VROUW,
new String[] {"Annie", "Gedula"},
"Dael",
"",
new GregorianCalendar(1981, Calendar.APRIL, 3),
"Bergen op Zoom",
null);
Persoon jan =
adm.addPersoon(
Geslacht.MAN,
new String[] {"Jan", "Jacobus"},
"Peters",
"",
new GregorianCalendar(1980, Calendar.APRIL, 23),
"Venray",
pietEnTeuntje);
Gezin annieEnJan = adm.addOngehuwdGezin(annie, jan);
assertTrue("geen kinderen", annieEnJan.getKinderen().isEmpty());
assertFalse("ongehuwd gezin", annieEnJan.isHuwelijkOp(nu));
assertEquals("ouder1 is annie", annie, annieEnJan.getOuder1());
assertEquals("ouder2 is jan", jan, annieEnJan.getOuder2());
/*de huwelijks- en
* scheidingsdatum zijn onbekend (null);
*/
assertNull("huwelijksdatum onbekend", annieEnJan.getHuwelijksdatum());
assertNull("scheidingsdatum onbekend", annieEnJan.getScheidingsdatum());
/* het gezin krijgt een uniek nummer toegewezen */
assertEquals(
"nummering van gezin lijkt onjuist", pietEnTeuntje.getNr() + 1, annieEnJan.getNr());
/* dit gezin wordt ook bij de afzonderlijke ouders geregistreerd;
*/
assertFalse("registratie bij ouders onjuist", jan.getAlsOuderBetrokkenIn().isEmpty());
assertFalse("registratie bij ouders onjuist", annie.getAlsOuderBetrokkenIn().isEmpty());
assertEquals("registratie bij ouders onjuist", annieEnJan, jan.getAlsOuderBetrokkenIn().get(0));
assertEquals(
"registratie bij ouders onjuist", annieEnJan, annie.getAlsOuderBetrokkenIn().get(0));
/*
* @param ouder1
* @param ouder2 mag null zijn
*/
Persoon toos =
adm.addPersoon(
Geslacht.VROUW,
new String[] {"t", "J"},
"sWinkelS",
"VaN deR",
new GregorianCalendar(1971, Calendar.APRIL, 13),
"venLO",
null);
Gezin eenoudergezin = adm.addOngehuwdGezin(toos, null);
assertTrue("geen kinderen", eenoudergezin.getKinderen().isEmpty());
assertFalse("ongehuwd gezin", eenoudergezin.isHuwelijkOp(nu));
assertEquals("ouder1 is toos", toos, eenoudergezin.getOuder1());
assertNull("ouder2 is onbekend", eenoudergezin.getOuder2());
/*de huwelijks- en
* scheidingsdatum zijn onbekend (null);
*/
assertNull("huwelijksdatum onbekend", eenoudergezin.getHuwelijksdatum());
assertNull("scheidingsdatum onbekend", eenoudergezin.getScheidingsdatum());
/* het gezin krijgt een uniek nummer toegewezen */
assertEquals(
"nummering van gezin lijkt onjuist", annieEnJan.getNr() + 1, eenoudergezin.getNr());
/* dit gezin wordt ook bij de afzonderlijke ouders geregistreerd;
*/
assertFalse("registratie bij ouder onjuist", toos.getAlsOuderBetrokkenIn().isEmpty());
assertEquals(
"registratie bij ouder onjuist", eenoudergezin, toos.getAlsOuderBetrokkenIn().get(0));
/* @return null als ouder1 = ouder2
*/
Persoon pim =
adm.addPersoon(
Geslacht.MAN,
new String[] {"Pim"},
"sWinkelS",
"VaN deR",
new GregorianCalendar(1995, Calendar.APRIL, 13),
"venLO",
pietEnTeuntje);
assertNull("ouders verschillend", adm.addOngehuwdGezin(pim, pim));
assertEquals("ouders verschillend", eenoudergezin.getNr(), adm.aantalGeregistreerdeGezinnen());
/* of als de volgende voorwaarden worden
* overtreden: 1) een van de ouders is op dit moment getrouwd 2) het koppel
* uit een ongehuwd gezin kan niet tegelijkertijd als koppel bij een ander ongehuwd
* gezin betrokken zijn*/
assertNull("een van de ouders is op dit moment getrouwd", adm.addOngehuwdGezin(piet, toos));
assertNull("een van de ouders is op dit moment getrouwd", adm.addOngehuwdGezin(toos, piet));
assertNull(
"het koppel uit een ongehuwd gezin kan niet tegelijkertijd bij"
+ " een ander ongehuwd gezin betrokken zijn",
adm.addOngehuwdGezin(annie, jan));
assertNull(
"het koppel uit een ongehuwd gezin kan niet tegelijkertijd bij"
+ " een ander ongehuwd gezin betrokken zijn",
adm.addOngehuwdGezin(jan, annie));
/* anders het gewenste gezin
*/
Gezin annieEnToos = adm.addOngehuwdGezin(toos, annie);
assertNotNull("gezin met een van de partners verschillend", annieEnToos);
List<Gezin> gezinnenToos = toos.getAlsOuderBetrokkenIn();
List<Gezin> gezinnenAnnie = annie.getAlsOuderBetrokkenIn();
assertFalse("registratie bij ouders onjuist", gezinnenToos.isEmpty());
assertFalse("registratie bij ouders onjuist", gezinnenAnnie.isEmpty());
/*
* test heeftOngehuwdGezin
*/
assertEquals("", annieEnToos, annie.heeftOngehuwdGezinMet(toos));
assertEquals("", annieEnToos, toos.heeftOngehuwdGezinMet(annie));
}
public static void main(String[] args) {
// TODO Auto-generated method stub
Persoon p = new Persoon();
p.setNaam("Reinert");
p.setVoornaam("Sacha");
p.setGeboorteJaar(1995);
p.setGewicht(86);
p.setLengte(1.86);
System.out.println(p.getVoornaam() + "," + p.getNaam());
p.print();
p.printBMI();
p.voegNamentoe("Henry", "Richard");
p.print();
System.out.println("Leeftijd: " + p.getLeeftijd());
}
@Test
public void testStamboom() {
Administratie adm = new Administratie();
Persoon piet =
adm.addPersoon(
Geslacht.MAN,
new String[] {"Piet"},
"Swinkels",
"",
new GregorianCalendar(1924, Calendar.APRIL, 23),
"Den Haag",
null);
Persoon teuntje =
adm.addPersoon(
Geslacht.VROUW,
new String[] {"Teuntje"},
"Vries",
"de",
new GregorianCalendar(1927, Calendar.MAY, 5),
"Doesburg",
null);
Gezin teuntjeEnPiet = adm.addOngehuwdGezin(teuntje, piet);
Persoon gijs =
adm.addPersoon(
Geslacht.MAN,
new String[] {"Gijs", "Jozef"},
"Swinkels",
"",
new GregorianCalendar(1944, Calendar.APRIL, 21),
"Geldrop",
teuntjeEnPiet);
Persoon ferdinand =
adm.addPersoon(
Geslacht.MAN,
new String[] {"Ferdinand", "Karel", "Helene"},
"Vuiter",
"de",
new GregorianCalendar(1901, Calendar.JULY, 14),
"Amsterdam",
null);
Persoon annalouise =
adm.addPersoon(
Geslacht.VROUW,
new String[] {"Annalouise", "Isabel", "Teuntje"},
"Vuiter",
"de",
new GregorianCalendar(1902, Calendar.OCTOBER, 1),
"Amsterdam",
null);
Gezin ferdinandEnAnnalouise =
adm.addHuwelijk(ferdinand, annalouise, new GregorianCalendar(1921, Calendar.MAY, 5));
Persoon louise =
adm.addPersoon(
Geslacht.VROUW,
new String[] {"Louise", "Isabel", "Helene"},
"Vuiter",
"de",
new GregorianCalendar(1927, Calendar.JANUARY, 15),
"Amsterdam",
ferdinandEnAnnalouise);
Gezin louiseAlleen = adm.addOngehuwdGezin(louise, null);
Persoon mary =
adm.addPersoon(
Geslacht.VROUW,
new String[] {"mary"},
"Vuiter",
"de",
new GregorianCalendar(1943, Calendar.MAY, 25),
"Rotterdam",
louiseAlleen);
Gezin gijsEnMary = adm.addOngehuwdGezin(gijs, mary);
Persoon jaron =
adm.addPersoon(
Geslacht.MAN,
new String[] {"Jaron"},
"Swinkels",
"",
new GregorianCalendar(1962, Calendar.JULY, 22),
"Velp",
gijsEnMary);
assertEquals("afmeting boom onjuist", 8, jaron.afmetingStamboom());
String stamboomstring = jaron.stamboomAlsString();
String[] regels = stamboomstring.split(System.getProperty("line.separator"));
assertEquals("aantal regels", 8, regels.length);
assertEquals("regel 3 onjuist", " T. de Vries (VROUW) 5-5-1927", regels[2]);
System.out.println(stamboomstring);
}
/**
* deze methode ontkoppelt de opgegeven speler aan de opgegeven ploeg
*
* @param p De speler die je wilt ontkoppelen
* @throws DBException
* @throws ApplicationException
*/
public void verwijderSpelerPloeg(Persoon p) throws DBException, ApplicationException {
verwijderSpelerPloeg(p.getNaam(), p.getVoornaam());
}
/**
* deze methode koppelt de opgegeven trainer aan de opgegeven ploeg
*
* @param persoon Het persoon object van de trainer die je wilt toevoegen.
* @param ploeg Het ploeg object waraan je een trainer wilt toevoegen.
* @throws DBException
* @throws ApplicationException
*/
public void toevoegenTrainerPloeg(Persoon persoon, Ploeg ploeg)
throws DBException, ApplicationException {
toevoegenTrainerPloeg(persoon.getNaam(), persoon.getVoornaam(), ploeg.getNaam());
}
/**
* deze methode ontkoppelt de opgegeven speler van de ploegen waarin hij zit
*
* @param naam De naam van de speler die je wilt ontkoppelen
* @param voornaam De voornaam van de speler die je wilt ontkoppelen
* @throws DBException
* @throws exception.ApplicationException
*/
public void verwijderSpelerPloeg(String naam, String voornaam)
throws DBException, ApplicationException {
Persoon p = persoonDB.zoekPersoon(naam, voornaam);
verwijderSpelerPloeg(p.getId());
}