View Javadoc
1   /*
2    * Copyright (C) 2020-2023 Dipl.-Inform. Kai Hofmann. All rights reserved!
3    */
4   package de.powerstat.validation.entities.test;
5   
6   
7   import static org.junit.jupiter.api.Assertions.assertAll;
8   import static org.junit.jupiter.api.Assertions.assertEquals;
9   import static org.junit.jupiter.api.Assertions.assertFalse;
10  import static org.junit.jupiter.api.Assertions.assertNotEquals;
11  import static org.junit.jupiter.api.Assertions.assertNotNull;
12  import static org.junit.jupiter.api.Assertions.assertThrows;
13  import static org.junit.jupiter.api.Assertions.assertTrue;
14  
15  import java.time.OffsetDateTime;
16  import java.time.ZoneOffset;
17  import java.util.ArrayList;
18  import java.util.List;
19  import java.util.concurrent.TimeUnit;
20  import java.util.stream.Collectors;
21  
22  import org.junit.jupiter.api.Test;
23  
24  import de.powerstat.validation.entities.Person;
25  import de.powerstat.validation.values.BloodGroup;
26  import de.powerstat.validation.values.Firstname;
27  import de.powerstat.validation.values.Gender;
28  import de.powerstat.validation.values.Lastname;
29  import edu.umd.cs.findbugs.annotations.SuppressFBWarnings;
30  
31  
32  /**
33   * Person tests.
34   */
35  @SuppressFBWarnings({"EC_NULL_ARG", "RV_NEGATING_RESULT_OF_COMPARETO", "RV_RETURN_VALUE_IGNORED_NO_SIDE_EFFECT", "SPP_USE_ZERO_WITH_COMPARATOR"})
36  @SuppressWarnings("java:S2925")
37  final class PersonTests
38   {
39    /**
40     * Lastname constant.
41     */
42    private static final String HOFMANN = "Hofmann"; //$NON-NLS-1$
43  
44    /**
45     * Lastname constant.
46     */
47    private static final String LASTNAME = "Lastname"; //$NON-NLS-1$
48  
49    /**
50     * Firstname constant.
51     */
52    private static final String KAI = "Kai"; //$NON-NLS-1$
53  
54    /**
55     * Firstname constant.
56     */
57    private static final String SECONDNAME = "Secondname"; //$NON-NLS-1$
58  
59    /**
60     * Firstnames constant.
61     */
62    private static final String KAI_SECONDNAME = "Kai Secondname"; //$NON-NLS-1$
63  
64    /**
65     * Firstname constant.
66     */
67    private static final String THIRDNAME = "Thirdname"; //$NON-NLS-1$
68  
69    /**
70     * Middlename constant.
71     */
72    private static final String MIDDLENAME = "Middlename"; //$NON-NLS-1$
73  
74    /**
75     * Birthname constant.
76     */
77    private static final String BIRTHNAME = "Birthname"; //$NON-NLS-1$
78  
79    /**
80     * Birthday.
81     */
82    private static final String BIRTHDAY = "1970-09-18T00:00+01:00"; //$NON-NLS-1$
83  
84    /**
85     * 1971.
86     */
87    private static final String Y1971_01_01T00_00_01_00 = "1971-01-01T00:00+01:00"; //$NON-NLS-1$
88  
89    /**
90     * Unknown constant.
91     */
92    private static final String UNKNOWN = "Unknown"; //$NON-NLS-1$
93  
94    /**
95     * Space.
96     */
97    private static final String SPACE = " "; //$NON-NLS-1$
98  
99    /**
100    * Lastname not as expected message.
101    */
102   private static final String LASTNAME_NOT_AS_EXPECTED = "Lastname not as expected!"; //$NON-NLS-1$
103 
104   /**
105    * Gender not as expected message.
106    */
107   private static final String GENDER_NOT_AS_EXPECTED = "Gender not as expected!"; //$NON-NLS-1$
108 
109   /**
110    * Firstnames not as expected message.
111    */
112   private static final String FIRSTNAMES_NOT_AS_EXPECTED = "Firstnames not as expected!"; //$NON-NLS-1$
113 
114   /**
115    * Wrong date constant.
116    */
117   private static final String WRONG_DATE = "Wrong date!"; //$NON-NLS-1$
118 
119   /**
120    * Wrong blood group constant.
121    */
122   private static final String WRONG_BLOOD_GROUP = "Wrong blood group!"; //$NON-NLS-1$
123 
124   /**
125    * Is not empty constant.
126    */
127   private static final String IS_NOT_EMPTY = "Is not empty"; //$NON-NLS-1$
128 
129 
130   /**
131    * Default constructor.
132    */
133   /* default */ PersonTests()
134    {
135     super();
136    }
137 
138 
139   /**
140    * Constructor/factory test.
141    */
142   @Test
143   /* default */ void testConstructor1()
144    {
145     final Person person = Person.of(Lastname.of(PersonTests.HOFMANN), Gender.MALE);
146     assertAll("constructor", //$NON-NLS-1$
147       () -> assertNotNull(person, "Person is null") //$NON-NLS-1$
148     );
149    }
150 
151 
152   /**
153    * Test hash code.
154    */
155   @Test
156   /* default */ void testHashCode()
157    {
158     final Person person1 = Person.of(Lastname.of(PersonTests.HOFMANN), Gender.MALE);
159     final Person person2 = Person.of(Lastname.of(PersonTests.HOFMANN), Gender.MALE);
160     final Person person3 = Person.of(Lastname.of(PersonTests.LASTNAME), Gender.UNKNOWN);
161     assertAll("testHashCode", //$NON-NLS-1$
162       () -> assertEquals(person1.hashCode(), person2.hashCode(), "hashCodes are not equal"), //$NON-NLS-1$
163       () -> assertNotEquals(person1.hashCode(), person3.hashCode(), "hashCodes are equal") //$NON-NLS-1$
164     );
165    }
166 
167 
168   /**
169    * Test equals.
170    */
171   @Test
172   @SuppressWarnings("java:S5785")
173   /* default */ void testEquals()
174    {
175     final Person person1 = Person.of(Lastname.of(PersonTests.HOFMANN), Gender.MALE);
176     final Person person2 = Person.of(Lastname.of(PersonTests.HOFMANN), Gender.MALE);
177     final Person person3 = Person.of(Lastname.of(PersonTests.LASTNAME), Gender.UNKNOWN);
178     final Person person4 = Person.of(Lastname.of(PersonTests.HOFMANN), Gender.MALE);
179     final Person person5 = Person.of(Lastname.of(PersonTests.HOFMANN), Gender.FEMALE);
180     final List<Firstname> firstnames = new ArrayList<>();
181     firstnames.add(Firstname.of(PersonTests.KAI));
182     final Person person6 = Person.of(Lastname.of(PersonTests.HOFMANN), Gender.MALE, firstnames);
183     final Person person7 = Person.of(Lastname.of(PersonTests.HOFMANN), Gender.MALE);
184     person7.setBirthday(OffsetDateTime.of(1970, 9, 18, 0, 0, 0, 0, ZoneOffset.ofHours(1)));
185     final Person person8 = Person.of(Lastname.of(PersonTests.HOFMANN), Gender.MALE);
186     person8.setDeathdate(OffsetDateTime.of(2070, 9, 18, 0, 0, 0, 0, ZoneOffset.ofHours(2)));
187     assertAll("testEquals", //$NON-NLS-1$
188       () -> assertTrue(person1.equals(person1), "person11 is not equal"), //$NON-NLS-1$
189       () -> assertTrue(person1.equals(person2), "person12 are not equal"), //$NON-NLS-1$
190       () -> assertTrue(person2.equals(person1), "person21 are not equal"), //$NON-NLS-1$
191       () -> assertTrue(person2.equals(person4), "person24 are not equal"), //$NON-NLS-1$
192       () -> assertTrue(person1.equals(person4), "person14 are not equal"), //$NON-NLS-1$
193       () -> assertFalse(person1.equals(person3), "person13 are equal"), //$NON-NLS-1$
194       () -> assertFalse(person3.equals(person1), "person31 are equal"), //$NON-NLS-1$
195       () -> assertFalse(person1.equals(null), "person10 is equal"), //$NON-NLS-1$
196       () -> assertFalse(person1.equals(person5), "person15 equal"), //$NON-NLS-1$
197       () -> assertFalse(person1.equals(person6), "person16 equal"), //$NON-NLS-1$
198       () -> assertFalse(person1.equals(person7), "person17 equal"), //$NON-NLS-1$
199       () -> assertFalse(person1.equals(person8), "person18 equal") //$NON-NLS-1$
200     );
201    }
202 
203 
204   /**
205    * Test toString.
206    */
207   @Test
208   /* default */ void testToString()
209    {
210     final Person person = Person.of();
211     person.addLastname(OffsetDateTime.of(2022, 1, 16, 11, 38, 0, 0, ZoneOffset.ofHours(1)), Lastname.of(PersonTests.HOFMANN));
212     person.addGender(OffsetDateTime.of(2022, 1, 16, 11, 38, 0, 0, ZoneOffset.ofHours(1)), Gender.MALE);
213     assertEquals("Person[lastname=Lastname[lastname=Hofmann], gender=MALE]", person.toString(), "toString not equal"); //$NON-NLS-1$ //$NON-NLS-2$
214    }
215 
216 
217   /**
218    * Test compareTo.
219    */
220   @Test
221   @SuppressWarnings("java:S5785")
222   /* default */ void testCompareTo()
223    {
224     final Person person1 = Person.of(Lastname.of(PersonTests.HOFMANN), Gender.MALE);
225     final Person person2 = Person.of(Lastname.of(PersonTests.HOFMANN), Gender.MALE);
226     final Person person3 = Person.of(Lastname.of(PersonTests.LASTNAME), Gender.UNKNOWN);
227     final Person person4 = Person.of(Lastname.of(PersonTests.MIDDLENAME), Gender.UNKNOWN);
228     final Person person5 = Person.of(Lastname.of(PersonTests.HOFMANN), Gender.MALE);
229     assertAll("testCompareTo", //$NON-NLS-1$
230       () -> assertTrue(person1.compareTo(person2) == -person2.compareTo(person1), "reflexive1"), //$NON-NLS-1$
231       () -> assertTrue(person1.compareTo(person3) == -person3.compareTo(person1), "reflexive2"), //$NON-NLS-1$
232       () -> assertTrue((person4.compareTo(person3) > 0) && (person3.compareTo(person1) > 0) && (person4.compareTo(person1) > 0), "transitive1"), //$NON-NLS-1$
233       () -> assertTrue((person1.compareTo(person2) == 0) && (Math.abs(person1.compareTo(person5)) == Math.abs(person2.compareTo(person5))), "sgn1"), //$NON-NLS-1$
234       () -> assertTrue((person1.compareTo(person2) == 0) && person1.equals(person2), "equals") //$NON-NLS-1$
235     );
236    }
237 
238 
239   /**
240    * Test compareTo.
241    */
242   @Test
243   @SuppressWarnings("java:S5785")
244   /* default */ void testCompareTo2()
245    {
246     final Person person1 = Person.of(Lastname.of(PersonTests.HOFMANN), Gender.MALE);
247     final Person person2 = Person.of(Lastname.of(PersonTests.HOFMANN), Gender.FEMALE);
248     final List<Firstname> firstnames = new ArrayList<>();
249     firstnames.add(Firstname.of(PersonTests.KAI));
250     final Person person3 = Person.of(Lastname.of(PersonTests.HOFMANN), Gender.MALE, firstnames, OffsetDateTime.of(1970, 9, 18, 0, 0, 0, 0, ZoneOffset.ofHours(1)));
251     final Person person4 = Person.of(Lastname.of(PersonTests.HOFMANN), Gender.MALE, firstnames, OffsetDateTime.of(1971, 9, 18, 0, 0, 0, 0, ZoneOffset.ofHours(1)));
252     final Person person5 = Person.of(Lastname.of(PersonTests.HOFMANN), Gender.MALE, firstnames);
253     final Person person6 = Person.of(Lastname.of(PersonTests.HOFMANN), Gender.MALE);
254     person6.setDeathdate(OffsetDateTime.of(1971, 9, 18, 0, 0, 0, 0, ZoneOffset.ofHours(1)));
255     final Person person7 = Person.of(Lastname.of(PersonTests.HOFMANN), Gender.MALE);
256     person7.setBloodGroup(BloodGroup.ON);
257     assertAll("testCompareTo2", //$NON-NLS-1$
258       () -> assertTrue(person1.compareTo(person2) != 0, "equal12"), //$NON-NLS-1$
259       () -> assertTrue(person1.compareTo(person3) != 0, "equal13"), //$NON-NLS-1$
260       () -> assertTrue(person3.compareTo(person3) == 0, "not equal33"), //$NON-NLS-1$
261       () -> assertTrue(person3.compareTo(person4) != 0, "equal34"), //$NON-NLS-1$
262       () -> assertTrue(person3.compareTo(person5) != 0, "equal35"), //$NON-NLS-1$
263       () -> assertTrue(person5.compareTo(person3) != 0, "equal53"), //$NON-NLS-1$
264       () -> assertTrue(person6.compareTo(person6) == 0, "equal66"), //$NON-NLS-1$
265       () -> assertTrue(person6.compareTo(person1) != 0, "equal61"), //$NON-NLS-1$
266       () -> assertTrue(person1.compareTo(person6) != 0, "equal16"), //$NON-NLS-1$
267       () -> assertTrue(person7.compareTo(person7) == 0, "equal77"), //$NON-NLS-1$
268       () -> assertTrue(person7.compareTo(person1) != 0, "equal71"), //$NON-NLS-1$
269       () -> assertTrue(person1.compareTo(person7) != 0, "equal17") //$NON-NLS-1$
270     );
271    }
272 
273 
274   /**
275    * Get lastname at birth test.
276    *
277    * @throws InterruptedException Interrupted sleep
278    */
279   @Test
280   /* default */ void testGetLastnameAtBirth() throws InterruptedException
281    {
282     final Person person = Person.of(Lastname.of(PersonTests.HOFMANN), Gender.MALE);
283     TimeUnit.MICROSECONDS.sleep(1);
284     person.addLastname(OffsetDateTime.now(), Lastname.of(PersonTests.MIDDLENAME));
285     TimeUnit.MICROSECONDS.sleep(1);
286     person.addLastname(OffsetDateTime.now(), Lastname.of(PersonTests.LASTNAME));
287     final Lastname name = person.getLastnameAtBirth();
288     assertEquals(PersonTests.HOFMANN, name.stringValue(), PersonTests.LASTNAME_NOT_AS_EXPECTED);
289    }
290 
291 
292   /**
293    * Get lastname actual test.
294    */
295   @Test
296   /* default */ void testGetLastnameActual()
297    {
298     final Person person = Person.of(Lastname.of(PersonTests.LASTNAME), Gender.MALE);
299     person.addLastname(OffsetDateTime.now(), Lastname.of(PersonTests.HOFMANN));
300     final Lastname name = person.getLastnameActual();
301     assertEquals(PersonTests.HOFMANN, name.stringValue(), PersonTests.LASTNAME_NOT_AS_EXPECTED);
302    }
303 
304 
305   /**
306    * Get lastname previous test.
307    *
308    * @throws InterruptedException Interrupted sleep
309    */
310   @Test
311   /* default */ void testGetLastnamePrevious() throws InterruptedException
312    {
313     final Person person = Person.of(Lastname.of(PersonTests.BIRTHNAME), Gender.UNKNOWN);
314     TimeUnit.MICROSECONDS.sleep(1);
315     person.addLastname(OffsetDateTime.now(), Lastname.of(PersonTests.HOFMANN));
316     TimeUnit.MICROSECONDS.sleep(1);
317     person.addLastname(OffsetDateTime.now(), Lastname.of(PersonTests.LASTNAME));
318     final Lastname name = person.getLastnamePrevious();
319     assertEquals(PersonTests.HOFMANN, name.stringValue(), PersonTests.LASTNAME_NOT_AS_EXPECTED);
320    }
321 
322 
323   /**
324    * Add lastname test.
325    */
326   @Test
327   /* default */ void testAddLastname()
328    {
329     final Person person = Person.of(Lastname.of(PersonTests.HOFMANN), Gender.MALE);
330     final Lastname name = person.getLastnameActual();
331     assertEquals(PersonTests.HOFMANN, name.stringValue(), PersonTests.LASTNAME_NOT_AS_EXPECTED);
332    }
333 
334 
335   /**
336    * Get gender at birth test.
337    *
338    * @throws InterruptedException Interrupted sleep
339    */
340   @Test
341   /* default */ void testGetGenderAtBirth() throws InterruptedException
342    {
343     final Person person = Person.of(Lastname.of(PersonTests.HOFMANN), Gender.MALE);
344     TimeUnit.MICROSECONDS.sleep(1);
345     person.addGender(OffsetDateTime.now(), Gender.NEUTRAL);
346     final Gender gender = person.getGenderAtBirth();
347     assertEquals(Gender.MALE, gender, PersonTests.GENDER_NOT_AS_EXPECTED);
348    }
349 
350 
351   /**
352    * Get gender actual test.
353    */
354   @Test
355   /* default */ void testGetGenderActual()
356    {
357     final Person person = Person.of(Lastname.of(PersonTests.LASTNAME), Gender.MALE);
358     person.addGender(OffsetDateTime.now(), Gender.NEUTRAL);
359     final Gender gender = person.getGenderActual();
360     assertEquals(Gender.NEUTRAL, gender, PersonTests.GENDER_NOT_AS_EXPECTED);
361    }
362 
363 
364   /**
365    * Get gender previous test.
366    *
367    * @throws InterruptedException Interrupted sleep
368    */
369   @Test
370   /* default */ void testGetGenderPrevious() throws InterruptedException
371    {
372     final Person person = Person.of(Lastname.of(PersonTests.BIRTHNAME), Gender.UNKNOWN);
373     TimeUnit.MICROSECONDS.sleep(1);
374     person.addGender(OffsetDateTime.now(), Gender.FEMALE);
375     TimeUnit.MICROSECONDS.sleep(1);
376     person.addGender(OffsetDateTime.now(), Gender.NEUTRAL);
377     final Gender gender = person.getGenderPrevious();
378     assertEquals(Gender.FEMALE, gender, PersonTests.GENDER_NOT_AS_EXPECTED);
379    }
380 
381 
382   /**
383    * Add gender test.
384    */
385   @Test
386   /* default */ void testAddGender()
387    {
388     final Person person = Person.of(Lastname.of(PersonTests.HOFMANN), Gender.MALE);
389     final Gender gender = person.getGenderActual();
390     assertEquals(Gender.MALE, gender, PersonTests.GENDER_NOT_AS_EXPECTED);
391    }
392 
393 
394   /**
395    * Get firstname at birth test.
396    *
397    * @throws InterruptedException Interrupted sleep
398    */
399   @Test
400   /* default */ void testGetFirstnamesAtBirth() throws InterruptedException
401    {
402     final List<Firstname> firstnames = new ArrayList<>();
403     firstnames.add(Firstname.of(PersonTests.KAI));
404     firstnames.add(Firstname.of(PersonTests.SECONDNAME));
405     final Person person = Person.of(Lastname.of(PersonTests.BIRTHNAME), Gender.UNKNOWN, firstnames);
406     TimeUnit.MICROSECONDS.sleep(1);
407     final List<Firstname> firstnames2 = new ArrayList<>();
408     firstnames2.add(Firstname.of(PersonTests.THIRDNAME));
409     person.addFirstnames(OffsetDateTime.now(), firstnames2);
410     final List<Firstname> names = person.getFirstnamesAtBirth();
411     assertEquals(PersonTests.KAI_SECONDNAME, names.stream().map(Firstname::stringValue).collect(Collectors.joining(PersonTests.SPACE)), PersonTests.FIRSTNAMES_NOT_AS_EXPECTED);
412    }
413 
414 
415   /**
416    * Get firstnames actual test.
417    */
418   @Test
419   /* default */ void testGetFirstnamesActual()
420    {
421     final List<Firstname> firstnames = new ArrayList<>();
422     firstnames.add(Firstname.of(PersonTests.KAI));
423     firstnames.add(Firstname.of(PersonTests.SECONDNAME));
424     final Person person = Person.of(Lastname.of(PersonTests.BIRTHNAME), Gender.UNKNOWN, firstnames);
425     final List<Firstname> firstnames2 = new ArrayList<>();
426     firstnames2.add(Firstname.of(PersonTests.THIRDNAME));
427     person.addFirstnames(OffsetDateTime.now(), firstnames2);
428     final List<Firstname> names = person.getFirstnamesActual();
429     assertEquals(PersonTests.THIRDNAME, names.stream().map(Firstname::stringValue).collect(Collectors.joining(PersonTests.SPACE)), PersonTests.FIRSTNAMES_NOT_AS_EXPECTED);
430    }
431 
432 
433   /**
434    * Get firstnames previous test.
435    *
436    * @throws InterruptedException Interrupted sleep
437    */
438   @Test
439   /* default */ void testGetFirstnamesPrevious() throws InterruptedException
440    {
441     final List<Firstname> firstnames = new ArrayList<>();
442     firstnames.add(Firstname.of(PersonTests.KAI));
443     firstnames.add(Firstname.of(PersonTests.SECONDNAME));
444     final Person person = Person.of(Lastname.of(PersonTests.BIRTHNAME), Gender.UNKNOWN, firstnames);
445     TimeUnit.MICROSECONDS.sleep(1);
446     final List<Firstname> firstnames2 = new ArrayList<>();
447     firstnames2.add(Firstname.of(PersonTests.THIRDNAME));
448     person.addFirstnames(OffsetDateTime.now(), firstnames2);
449     final List<Firstname> names = person.getFirstnamesPrevious();
450     assertEquals(PersonTests.KAI_SECONDNAME, names.stream().map(Firstname::stringValue).collect(Collectors.joining(PersonTests.SPACE)), PersonTests.FIRSTNAMES_NOT_AS_EXPECTED);
451    }
452 
453 
454   /**
455    * Add firstnames test.
456    */
457   @Test
458   /* default */ void testAddFirstnames()
459    {
460     final List<Firstname> firstnames = new ArrayList<>();
461     firstnames.add(Firstname.of(PersonTests.KAI));
462     firstnames.add(Firstname.of(PersonTests.SECONDNAME));
463     final Person person = Person.of(Lastname.of(PersonTests.HOFMANN), Gender.MALE, firstnames);
464     final List<Firstname> names = person.getFirstnamesActual();
465     assertEquals(PersonTests.KAI_SECONDNAME, names.stream().map(Firstname::stringValue).collect(Collectors.joining(PersonTests.SPACE)), PersonTests.FIRSTNAMES_NOT_AS_EXPECTED);
466    }
467 
468 
469   /**
470    * Set birthday test.
471    */
472   @Test
473   /* default */ void testSetBirthday()
474    {
475     final List<Firstname> firstnames = new ArrayList<>();
476     firstnames.add(Firstname.of(PersonTests.KAI));
477     final Person person = Person.of(Lastname.of(PersonTests.HOFMANN), Gender.MALE, firstnames);
478     person.setBirthday(OffsetDateTime.of(1970, 9, 18, 0, 0, 0, 0, ZoneOffset.ofHours(1)));
479     assertEquals(PersonTests.BIRTHDAY, person.getBirthday().get().toString(), PersonTests.WRONG_DATE);
480    }
481 
482 
483   /**
484    * Get birthday test.
485    */
486   @Test
487   /* default */ void testGetBirthday()
488    {
489     final List<Firstname> firstnames = new ArrayList<>();
490     firstnames.add(Firstname.of(PersonTests.KAI));
491     final Person person = Person.of(Lastname.of(PersonTests.HOFMANN), Gender.MALE, firstnames, OffsetDateTime.of(1970, 9, 18, 0, 0, 0, 0, ZoneOffset.ofHours(1)));
492     assertEquals(PersonTests.BIRTHDAY, person.getBirthday().get().toString(), PersonTests.WRONG_DATE);
493    }
494 
495 
496   /**
497    * Get birthday test.
498    */
499   @Test
500   /* default */ void testGetBirthdayUnset()
501    {
502     final List<Firstname> firstnames = new ArrayList<>();
503     firstnames.add(Firstname.of(PersonTests.KAI));
504     final Person person = Person.of(Lastname.of(PersonTests.HOFMANN), Gender.MALE, firstnames);
505     assertTrue(person.getBirthday().isEmpty(), PersonTests.IS_NOT_EMPTY);
506    }
507 
508 
509   /**
510    * Set death date test.
511    */
512   @Test
513   /* default */ void testSetDeathdate1()
514    {
515     final List<Firstname> firstnames = new ArrayList<>();
516     firstnames.add(Firstname.of(PersonTests.UNKNOWN));
517     final Person person = Person.of(Lastname.of(PersonTests.UNKNOWN), Gender.MALE, firstnames);
518     person.setDeathdate(OffsetDateTime.of(1971, 1, 1, 0, 0, 0, 0, ZoneOffset.ofHours(1)));
519     assertEquals(PersonTests.Y1971_01_01T00_00_01_00, person.getDeathdate().get().toString(), PersonTests.WRONG_DATE);
520    }
521 
522 
523   /**
524    * Set death date test.
525    */
526   @Test
527   /* default */ void testSetDeathdate2()
528    {
529     final List<Firstname> firstnames = new ArrayList<>();
530     firstnames.add(Firstname.of(PersonTests.UNKNOWN));
531     final Person person = Person.of(Lastname.of(PersonTests.UNKNOWN), Gender.MALE, firstnames, OffsetDateTime.of(1972, 1, 1, 0, 0, 0, 0, ZoneOffset.ofHours(1)));
532     final OffsetDateTime deathdate = OffsetDateTime.of(1971, 1, 1, 0, 0, 0, 0, ZoneOffset.ofHours(1));
533     assertThrows(IllegalArgumentException.class, () ->
534      {
535       person.setDeathdate(deathdate);
536      }, "Illegal argument exception expected" //$NON-NLS-1$
537     );
538    }
539 
540 
541   /**
542    * Get death date test.
543    */
544   @Test
545   /* default */ void testGetDeathdate()
546    {
547     final List<Firstname> firstnames = new ArrayList<>();
548     firstnames.add(Firstname.of(PersonTests.UNKNOWN));
549     final Person person = Person.of(Lastname.of(PersonTests.UNKNOWN), Gender.MALE, firstnames, OffsetDateTime.of(1971, 1, 1, 0, 0, 0, 0, ZoneOffset.ofHours(1)));
550     person.setDeathdate(OffsetDateTime.of(1971, 1, 1, 0, 0, 0, 0, ZoneOffset.ofHours(1)));
551     assertEquals(PersonTests.Y1971_01_01T00_00_01_00, person.getDeathdate().get().toString(), PersonTests.WRONG_DATE);
552    }
553 
554 
555   /**
556    * Get death date test.
557    */
558   @Test
559   /* default */ void testGetDeathdateUnset()
560    {
561     final List<Firstname> firstnames = new ArrayList<>();
562     firstnames.add(Firstname.of(PersonTests.UNKNOWN));
563     final Person person = Person.of(Lastname.of(PersonTests.UNKNOWN), Gender.MALE, firstnames, OffsetDateTime.of(1971, 1, 1, 0, 0, 0, 0, ZoneOffset.ofHours(1)));
564     assertTrue(person.getDeathdate().isEmpty(), PersonTests.IS_NOT_EMPTY);
565    }
566 
567 
568   /**
569    * Set blood group test.
570    */
571   @Test
572   /* default */ void testSetBloodGroup()
573    {
574     final List<Firstname> firstnames = new ArrayList<>();
575     firstnames.add(Firstname.of(PersonTests.UNKNOWN));
576     final Person person = Person.of(Lastname.of(PersonTests.UNKNOWN), Gender.MALE, firstnames);
577     person.setBloodGroup(BloodGroup.OP);
578     assertEquals("Optional[OP]", person.getBloodGroup().toString(), PersonTests.WRONG_BLOOD_GROUP); //$NON-NLS-1$
579    }
580 
581 
582   /**
583    * Get blood group test.
584    */
585   @Test
586   /* default */ void testGetBloodGroup()
587    {
588     final List<Firstname> firstnames = new ArrayList<>();
589     firstnames.add(Firstname.of(PersonTests.UNKNOWN));
590     final Person person = Person.of(Lastname.of(PersonTests.UNKNOWN), Gender.MALE, firstnames);
591     person.setBloodGroup(BloodGroup.AP);
592     assertEquals("Optional[AP]", person.getBloodGroup().toString(), PersonTests.WRONG_BLOOD_GROUP); //$NON-NLS-1$
593    }
594 
595 
596   /**
597    * Get blood group test.
598    */
599   @Test
600   /* default */ void testGetBloodGroupUnset()
601    {
602     final List<Firstname> firstnames = new ArrayList<>();
603     firstnames.add(Firstname.of(PersonTests.UNKNOWN));
604     final Person person = Person.of(Lastname.of(PersonTests.UNKNOWN), Gender.MALE, firstnames);
605     assertTrue(person.getBloodGroup().isEmpty(), PersonTests.IS_NOT_EMPTY);
606    }
607 
608  }