View Javadoc
1   /*
2    * Copyright (C) 2022-2023 Dipl.-Inform. Kai Hofmann. All rights reserved!
3    */
4   package de.powerstat.validation.containers.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.assertIterableEquals;
11  import static org.junit.jupiter.api.Assertions.assertNotEquals;
12  import static org.junit.jupiter.api.Assertions.assertNotNull;
13  import static org.junit.jupiter.api.Assertions.assertThrows;
14  import static org.junit.jupiter.api.Assertions.assertTrue;
15  
16  import java.time.OffsetDateTime;
17  import java.time.ZoneOffset;
18  import java.util.ArrayList;
19  import java.util.List;
20  import java.util.NoSuchElementException;
21  import java.util.SortedMap;
22  import java.util.concurrent.TimeUnit;
23  
24  import org.junit.jupiter.api.Test;
25  
26  import de.powerstat.validation.containers.HistoryOf;
27  import de.powerstat.validation.values.Lastname;
28  import edu.umd.cs.findbugs.annotations.SuppressFBWarnings;
29  
30  
31  /**
32   * HistoryOf tests.
33   */
34  @SuppressFBWarnings({"EC_NULL_ARG", "RV_NEGATING_RESULT_OF_COMPARETO", "RV_RETURN_VALUE_IGNORED_NO_SIDE_EFFECT", "SPP_USE_ZERO_WITH_COMPARATOR", "CE_CLASS_ENVY"})
35  @SuppressWarnings("java:S2925")
36  final class HistoryOfTests
37   {
38    /**
39     * Lastname constant.
40     */
41    private static final String HOFMANN = "Hofmann"; //$NON-NLS-1$
42  
43    /**
44     * Lastname constant.
45     */
46    private static final String LASTNAME = "Lastname"; //$NON-NLS-1$
47  
48    /**
49     * Test has code constant.
50     */
51    private static final String TEST_HASH_CODE = "testHashCode"; //$NON-NLS-1$
52  
53    /**
54     * toString not equal constant.
55     */
56    private static final String TO_STRING_NOT_EQUAL = "toString not equal"; //$NON-NLS-1$
57  
58    /**
59     * Null pointer exception expected constant.
60     */
61    private static final String NULL_POINTER_EXCEPTION = "Null pointer exception expected"; //$NON-NLS-1$
62  
63    /**
64     * No such element exception expected constant.
65     */
66    private static final String NO_SUCH_ELEMENT_EXCEPTION = "No such element exception expected"; //$NON-NLS-1$
67  
68    /**
69     * History of value constant.
70     */
71    private static final String HISTORY_OF1 = "HistoryOf<>[2022-01-13T20:25:00+01:00=Lastname[lastname=Hofmann]]"; //$NON-NLS-1$
72  
73    /**
74     * GetFirstEntry result is wrong constant.
75     */
76    private static final String GET_FIRST_ENTRY = "GetFirstEntry result is wrong!"; //$NON-NLS-1$
77  
78    /**
79     * GetLatestEntry result is wrong constant.
80     */
81    private static final String GET_LATEST_ENTRY = "GetLatestEntry result is wrong!"; //$NON-NLS-1$
82  
83    /**
84     * GetPreviousEntry result is wrong constant.
85     */
86    private static final String GET_PREVIOUS_ENTRY = "GetPreviousEntry result is wrong!"; //$NON-NLS-1$
87  
88    /**
89     * History not as expected constant.
90     */
91    private static final String HISTORY_NOT_AS_EXPECTED = "History not as expected!"; //$NON-NLS-1$
92  
93    /**
94     * History correct constant.
95     */
96    private static final String HISTORY_CORRECT = "History correct!"; //$NON-NLS-1$
97  
98  
99    /**
100    * Default constructor.
101    */
102   /* default */ HistoryOfTests()
103    {
104     super();
105    }
106 
107 
108   /**
109    * Constructor test.
110    */
111   @Test
112   /* default */ void testConstructor1()
113    {
114     final HistoryOf<Lastname> lastname = new HistoryOf<>();
115     assertNotNull(lastname, "Constructor failed!"); //$NON-NLS-1$
116    }
117 
118 
119   /**
120    * Hash code test.
121    */
122   @Test
123   /* default */ void testHashCode1()
124    {
125     final HistoryOf<Lastname> lastname = new HistoryOf<>();
126     final int hc1 = lastname.hashCode();
127     lastname.addEntry(OffsetDateTime.now(), Lastname.of(HistoryOfTests.HOFMANN));
128     final int hc2 = lastname.hashCode();
129     assertAll(HistoryOfTests.TEST_HASH_CODE,
130       () -> assertEquals(0, hc1, "hc1 not as expected"), //$NON-NLS-1$
131       () -> assertEquals(-1543832814, hc2, "hc2 not as expected") //$NON-NLS-1$
132     );
133    }
134 
135 
136   /**
137    * Hash code test.
138    */
139   @Test
140   /* default */ void testHashCode2()
141    {
142     final HistoryOf<Lastname> lastname1 = new HistoryOf<>();
143     lastname1.addEntry(OffsetDateTime.now(), Lastname.of(HistoryOfTests.HOFMANN));
144     final HistoryOf<Lastname> lastname2 = new HistoryOf<>();
145     lastname2.addEntry(OffsetDateTime.now(), Lastname.of(HistoryOfTests.HOFMANN));
146     final HistoryOf<Lastname> lastname3 = new HistoryOf<>();
147     lastname3.addEntry(OffsetDateTime.now(), Lastname.of(HistoryOfTests.LASTNAME));
148     assertAll(HistoryOfTests.TEST_HASH_CODE,
149       () -> assertEquals(lastname1.hashCode(), lastname2.hashCode(), "hashCodes are not equal"), //$NON-NLS-1$
150       () -> assertNotEquals(lastname1.hashCode(), lastname3.hashCode(), "hashCodes are equal") //$NON-NLS-1$
151     );
152    }
153 
154 
155   /**
156    * Test equals.
157    */
158   @Test
159   @SuppressWarnings("java:S5785")
160   /* default */ void testEquals()
161    {
162     final HistoryOf<Lastname> lastname1 = new HistoryOf<>();
163     lastname1.addEntry(OffsetDateTime.now(), Lastname.of(HistoryOfTests.HOFMANN));
164     final HistoryOf<Lastname> lastname2 = new HistoryOf<>();
165     lastname2.addEntry(OffsetDateTime.now(), Lastname.of(HistoryOfTests.HOFMANN));
166     final HistoryOf<Lastname> lastname3 = new HistoryOf<>();
167     lastname3.addEntry(OffsetDateTime.now(), Lastname.of(HistoryOfTests.LASTNAME));
168     final HistoryOf<Lastname> lastname4 = new HistoryOf<>();
169     lastname4.addEntry(OffsetDateTime.now(), Lastname.of(HistoryOfTests.HOFMANN));
170     final HistoryOf<Lastname> lastname5 = new HistoryOf<>();
171     assertAll("testEquals", //$NON-NLS-1$
172       () -> assertTrue(lastname1.equals(lastname1), "lastname11 is not equal"), //$NON-NLS-1$
173       () -> assertTrue(lastname1.equals(lastname2), "lastname12 are not equal"), //$NON-NLS-1$
174       () -> assertTrue(lastname2.equals(lastname1), "lastname21 are not equal"), //$NON-NLS-1$
175       () -> assertTrue(lastname2.equals(lastname4), "lastname24 are not equal"), //$NON-NLS-1$
176       () -> assertTrue(lastname1.equals(lastname4), "lastname14 are not equal"), //$NON-NLS-1$
177       () -> assertFalse(lastname1.equals(lastname3), "lastname13 are equal"), //$NON-NLS-1$
178       () -> assertFalse(lastname3.equals(lastname1), "lastname31 are equal"), //$NON-NLS-1$
179       () -> assertFalse(lastname1.equals(null), "lastname10 is equal"), //$NON-NLS-1$
180       () -> assertFalse(lastname1.equals(new Object()), "lastname1obj is equal"), //$NON-NLS-1$
181       () -> assertFalse(lastname1.equals(lastname5), "lastname15 is equal"), //$NON-NLS-1$
182       () -> assertFalse(lastname5.equals(lastname1), "lastname51 is equal") //$NON-NLS-1$
183     );
184    }
185 
186 
187   /**
188    * Test toString.
189    */
190   @Test
191   /* default */ void testToString()
192    {
193     final HistoryOf<Lastname> lastname = new HistoryOf<>();
194     final OffsetDateTime datetime = OffsetDateTime.of(2022, 1, 13, 20, 25, 0, 0, ZoneOffset.ofHours(1));
195     lastname.addEntry(datetime, Lastname.of(HistoryOfTests.HOFMANN));
196     assertEquals(HistoryOfTests.HISTORY_OF1, lastname.toString(), HistoryOfTests.TO_STRING_NOT_EQUAL);
197    }
198 
199 
200   /**
201    * Test isEmpty.
202    */
203   @Test
204   /* default */ void testIsEmpty1()
205    {
206     final HistoryOf<Lastname> lastname = new HistoryOf<>();
207     assertTrue(lastname.isEmpty(), "Not empty");
208    }
209 
210 
211   /**
212    * Test isEmpty.
213    */
214   @Test
215   /* default */ void testIsEmpty2()
216    {
217     final HistoryOf<Lastname> lastname = new HistoryOf<>();
218     final OffsetDateTime datetime = OffsetDateTime.of(2022, 1, 13, 20, 25, 0, 0, ZoneOffset.ofHours(1));
219     lastname.addEntry(datetime, Lastname.of(HistoryOfTests.HOFMANN));
220     assertFalse(lastname.isEmpty(), "Empty");
221    }
222 
223 
224   /**
225    * Test addEntry.
226    */
227   @Test
228   /* default */ void testAddEntry1()
229    {
230     final HistoryOf<Lastname> lastname = new HistoryOf<>();
231     final OffsetDateTime datetime = OffsetDateTime.of(2022, 1, 13, 20, 25, 0, 0, ZoneOffset.ofHours(1));
232     lastname.addEntry(datetime, Lastname.of(HistoryOfTests.HOFMANN));
233     assertEquals(HistoryOfTests.HISTORY_OF1, lastname.toString(), HistoryOfTests.TO_STRING_NOT_EQUAL);
234    }
235 
236 
237   /**
238    * Test addEntry.
239    */
240   @Test
241   /* default */ void testAddEntry2()
242    {
243     final HistoryOf<Lastname> lastnameHistory = new HistoryOf<>();
244     final Lastname lastname = Lastname.of(HistoryOfTests.HOFMANN);
245     assertThrows(NullPointerException.class, () ->
246      {
247       lastnameHistory.addEntry(null, lastname);
248      }, HistoryOfTests.NULL_POINTER_EXCEPTION
249     );
250    }
251 
252 
253   /**
254    * Test addEntry.
255    */
256   @Test
257   /* default */ void testAddEntry3()
258    {
259     final HistoryOf<Lastname> lastname = new HistoryOf<>();
260     final OffsetDateTime now = OffsetDateTime.now();
261     assertThrows(NullPointerException.class, () ->
262      {
263       lastname.addEntry(now, null);
264      }, HistoryOfTests.NULL_POINTER_EXCEPTION
265     );
266    }
267 
268 
269   /**
270    * Test addEntry.
271    */
272   @Test
273   /* default */ void testAddEntry4()
274    {
275     final HistoryOf<Lastname> lastnameHistory = new HistoryOf<>();
276     final OffsetDateTime nowPlusOneDay = OffsetDateTime.now().plusDays(1);
277     final Lastname lastname = Lastname.of(HistoryOfTests.HOFMANN);
278     assertThrows(IndexOutOfBoundsException.class, () ->
279      {
280       lastnameHistory.addEntry(nowPlusOneDay, lastname);
281      }, "Index out of bounds exception expected" //$NON-NLS-1$
282     );
283    }
284 
285 
286   /**
287    * Test addEntry.
288    */
289   @Test
290   /* default */ void testAddEntry5()
291    {
292     final HistoryOf<Lastname> lastnameHistory = new HistoryOf<>();
293     lastnameHistory.addEntry(OffsetDateTime.now(), Lastname.of(HistoryOfTests.HOFMANN));
294     final OffsetDateTime now = OffsetDateTime.now();
295     final Lastname lastname = Lastname.of(HistoryOfTests.HOFMANN);
296     assertThrows(IllegalArgumentException.class, () ->
297      {
298       lastnameHistory.addEntry(now, lastname);
299      }, "Illegal argument exception expected" //$NON-NLS-1$
300     );
301    }
302 
303 
304   /**
305    * Test getFirstEntry.
306    */
307   @Test
308   /* default */ void testGetFirstEntry1()
309    {
310     final HistoryOf<Lastname> lastname = new HistoryOf<>();
311     lastname.addEntry(OffsetDateTime.now(), Lastname.of(HistoryOfTests.HOFMANN));
312     final Lastname name = lastname.getFirstEntry();
313     assertEquals(HistoryOfTests.HOFMANN, name.stringValue(), HistoryOfTests.GET_FIRST_ENTRY);
314    }
315 
316 
317   /**
318    * Test getFirstEntry.
319    *
320    * @throws InterruptedException Interrupted sleep
321    */
322   @Test
323   /* default */ void testGetFirstEntry2() throws InterruptedException
324    {
325     final HistoryOf<Lastname> lastname = new HistoryOf<>();
326     lastname.addEntry(OffsetDateTime.now(), Lastname.of(HistoryOfTests.LASTNAME));
327     TimeUnit.MICROSECONDS.sleep(1);
328     lastname.addEntry(OffsetDateTime.now(), Lastname.of(HistoryOfTests.HOFMANN));
329     final Lastname name = lastname.getFirstEntry();
330     assertEquals(HistoryOfTests.LASTNAME, name.stringValue(), HistoryOfTests.GET_FIRST_ENTRY);
331    }
332 
333 
334   /**
335    * Test getFirstEntry.
336    */
337   @Test
338   /* default */ void testGetFirstEntry3()
339    {
340     final HistoryOf<Lastname> lastname = new HistoryOf<>();
341     assertThrows(NoSuchElementException.class, () ->
342      {
343       /* final Lastname name = */ lastname.getFirstEntry();
344      }, HistoryOfTests.NO_SUCH_ELEMENT_EXCEPTION
345     );
346    }
347 
348 
349   /**
350    * Test getLastEntry.
351    */
352   @Test
353   /* default */ void testGetLatestEntry1()
354    {
355     final HistoryOf<Lastname> lastname = new HistoryOf<>();
356     lastname.addEntry(OffsetDateTime.now(), Lastname.of(HistoryOfTests.HOFMANN));
357     final Lastname name = lastname.getLatestEntry();
358     assertEquals(HistoryOfTests.HOFMANN, name.stringValue(), HistoryOfTests.GET_LATEST_ENTRY);
359    }
360 
361 
362   /**
363    * Test getLatestEntry.
364    *
365    * @throws InterruptedException Interrupted sleep
366    */
367   @Test
368   /* default */ void testGetLatestEntry2() throws InterruptedException
369    {
370     final HistoryOf<Lastname> lastname = new HistoryOf<>();
371     lastname.addEntry(OffsetDateTime.now(), Lastname.of(HistoryOfTests.LASTNAME));
372     TimeUnit.MICROSECONDS.sleep(1);
373     lastname.addEntry(OffsetDateTime.now(), Lastname.of(HistoryOfTests.HOFMANN));
374     final Lastname name = lastname.getLatestEntry();
375     assertEquals(HistoryOfTests.HOFMANN, name.stringValue(), HistoryOfTests.GET_LATEST_ENTRY);
376    }
377 
378 
379   /**
380    * Test getLatestEntry.
381    */
382   @Test
383   /* default */ void testGetLatestEntry3()
384    {
385     final HistoryOf<Lastname> lastname = new HistoryOf<>();
386     assertThrows(NoSuchElementException.class, () ->
387      {
388       /* final Lastname name = */ lastname.getLatestEntry();
389      }, HistoryOfTests.NO_SUCH_ELEMENT_EXCEPTION
390     );
391    }
392 
393 
394   /**
395    * Test getPreviousEntry.
396    */
397   @Test
398   /* default */ void testGetPreviousEntry1()
399    {
400     final HistoryOf<Lastname> lastname = new HistoryOf<>();
401     lastname.addEntry(OffsetDateTime.now(), Lastname.of(HistoryOfTests.HOFMANN));
402     final Lastname name = lastname.getPreviousEntry();
403     assertEquals(HistoryOfTests.HOFMANN, name.stringValue(), HistoryOfTests.GET_PREVIOUS_ENTRY);
404    }
405 
406 
407   /**
408    * Test getPreviousEntry.
409    *
410    * @throws InterruptedException Interrupted sleep
411    */
412   @Test
413   /* default */ void testGetPreviousEntry2() throws InterruptedException
414    {
415     final HistoryOf<Lastname> lastname = new HistoryOf<>();
416     lastname.addEntry(OffsetDateTime.now(), Lastname.of(HistoryOfTests.LASTNAME));
417     TimeUnit.MICROSECONDS.sleep(1);
418     lastname.addEntry(OffsetDateTime.now(), Lastname.of(HistoryOfTests.HOFMANN));
419     final Lastname name = lastname.getPreviousEntry();
420     assertEquals(HistoryOfTests.LASTNAME, name.stringValue(), HistoryOfTests.GET_PREVIOUS_ENTRY);
421    }
422 
423 
424   /**
425    * Test getPreviousEntry.
426    */
427   @Test
428   /* default */ void testGetPreviousEntry3()
429    {
430     final HistoryOf<Lastname> lastname = new HistoryOf<>();
431     assertThrows(NoSuchElementException.class, () ->
432      {
433       /* final Lastname name = */ lastname.getPreviousEntry();
434      }, HistoryOfTests.NO_SUCH_ELEMENT_EXCEPTION
435     );
436    }
437 
438 
439   /**
440    * Test getHistory.
441    */
442   @Test
443   /* default */ void testGetHistory1()
444    {
445     final HistoryOf<Lastname> lastname = new HistoryOf<>();
446     final SortedMap<OffsetDateTime, Lastname> history = lastname.getHistory();
447     assertTrue(history.isEmpty(), "History not empty!"); //$NON-NLS-1$
448    }
449 
450 
451   /**
452    * Test getHistory.
453    */
454   @Test
455   /* default */ void testGetHistory2()
456    {
457     final List<Lastname> expected = new ArrayList<>();
458     expected.add(Lastname.of(HistoryOfTests.HOFMANN));
459     final HistoryOf<Lastname> lastname = new HistoryOf<>();
460     lastname.addEntry(OffsetDateTime.now(), Lastname.of(HistoryOfTests.HOFMANN));
461     final SortedMap<OffsetDateTime, Lastname> history = lastname.getHistory();
462     assertEquals(1, history.size(), HistoryOfTests.HISTORY_CORRECT);
463     assertIterableEquals(expected, history.values(), HistoryOfTests.HISTORY_NOT_AS_EXPECTED);
464    }
465 
466 
467   /**
468    * Test getHistory.
469    *
470    * @throws InterruptedException Interrupted sleep
471    */
472   @Test
473   /* default */ void testGetHistory3() throws InterruptedException
474    {
475     final List<Lastname> expected = new ArrayList<>();
476     expected.add(Lastname.of(HistoryOfTests.HOFMANN));
477     expected.add(Lastname.of(HistoryOfTests.LASTNAME));
478     final HistoryOf<Lastname> lastname = new HistoryOf<>();
479     lastname.addEntry(OffsetDateTime.now(), Lastname.of(HistoryOfTests.HOFMANN));
480     TimeUnit.MICROSECONDS.sleep(1);
481     lastname.addEntry(OffsetDateTime.now(), Lastname.of(HistoryOfTests.LASTNAME));
482     final SortedMap<OffsetDateTime, Lastname> history = lastname.getHistory();
483     assertEquals(2, history.size(), HistoryOfTests.HISTORY_CORRECT);
484     assertIterableEquals(expected, history.values(), HistoryOfTests.HISTORY_NOT_AS_EXPECTED);
485    }
486 
487  }