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 addEntry.
202    */
203   @Test
204   /* default */ void testAddEntry1()
205    {
206     final HistoryOf<Lastname> lastname = new HistoryOf<>();
207     final OffsetDateTime datetime = OffsetDateTime.of(2022, 1, 13, 20, 25, 0, 0, ZoneOffset.ofHours(1));
208     lastname.addEntry(datetime, Lastname.of(HistoryOfTests.HOFMANN));
209     assertEquals(HistoryOfTests.HISTORY_OF1, lastname.toString(), HistoryOfTests.TO_STRING_NOT_EQUAL);
210    }
211 
212 
213   /**
214    * Test addEntry.
215    */
216   @Test
217   /* default */ void testAddEntry2()
218    {
219     final HistoryOf<Lastname> lastnameHistory = new HistoryOf<>();
220     final Lastname lastname = Lastname.of(HistoryOfTests.HOFMANN);
221     assertThrows(NullPointerException.class, () ->
222      {
223       lastnameHistory.addEntry(null, lastname);
224      }, HistoryOfTests.NULL_POINTER_EXCEPTION
225     );
226    }
227 
228 
229   /**
230    * Test addEntry.
231    */
232   @Test
233   /* default */ void testAddEntry3()
234    {
235     final HistoryOf<Lastname> lastname = new HistoryOf<>();
236     final OffsetDateTime now = OffsetDateTime.now();
237     assertThrows(NullPointerException.class, () ->
238      {
239       lastname.addEntry(now, null);
240      }, HistoryOfTests.NULL_POINTER_EXCEPTION
241     );
242    }
243 
244 
245   /**
246    * Test addEntry.
247    */
248   @Test
249   /* default */ void testAddEntry4()
250    {
251     final HistoryOf<Lastname> lastnameHistory = new HistoryOf<>();
252     final OffsetDateTime nowPlusOneDay = OffsetDateTime.now().plusDays(1);
253     final Lastname lastname = Lastname.of(HistoryOfTests.HOFMANN);
254     assertThrows(IndexOutOfBoundsException.class, () ->
255      {
256       lastnameHistory.addEntry(nowPlusOneDay, lastname);
257      }, "Index out of bounds exception expected" //$NON-NLS-1$
258     );
259    }
260 
261 
262   /**
263    * Test addEntry.
264    */
265   @Test
266   /* default */ void testAddEntry5()
267    {
268     final HistoryOf<Lastname> lastnameHistory = new HistoryOf<>();
269     lastnameHistory.addEntry(OffsetDateTime.now(), Lastname.of(HistoryOfTests.HOFMANN));
270     final OffsetDateTime now = OffsetDateTime.now();
271     final Lastname lastname = Lastname.of(HistoryOfTests.HOFMANN);
272     assertThrows(IllegalArgumentException.class, () ->
273      {
274       lastnameHistory.addEntry(now, lastname);
275      }, "Illegal argument exception expected" //$NON-NLS-1$
276     );
277    }
278 
279 
280   /**
281    * Test getFirstEntry.
282    */
283   @Test
284   /* default */ void testGetFirstEntry1()
285    {
286     final HistoryOf<Lastname> lastname = new HistoryOf<>();
287     lastname.addEntry(OffsetDateTime.now(), Lastname.of(HistoryOfTests.HOFMANN));
288     final Lastname name = lastname.getFirstEntry();
289     assertEquals(HistoryOfTests.HOFMANN, name.stringValue(), HistoryOfTests.GET_FIRST_ENTRY);
290    }
291 
292 
293   /**
294    * Test getFirstEntry.
295    *
296    * @throws InterruptedException Interrupted sleep
297    */
298   @Test
299   /* default */ void testGetFirstEntry2() throws InterruptedException
300    {
301     final HistoryOf<Lastname> lastname = new HistoryOf<>();
302     lastname.addEntry(OffsetDateTime.now(), Lastname.of(HistoryOfTests.LASTNAME));
303     TimeUnit.MICROSECONDS.sleep(1);
304     lastname.addEntry(OffsetDateTime.now(), Lastname.of(HistoryOfTests.HOFMANN));
305     final Lastname name = lastname.getFirstEntry();
306     assertEquals(HistoryOfTests.LASTNAME, name.stringValue(), HistoryOfTests.GET_FIRST_ENTRY);
307    }
308 
309 
310   /**
311    * Test getFirstEntry.
312    */
313   @Test
314   /* default */ void testGetFirstEntry3()
315    {
316     final HistoryOf<Lastname> lastname = new HistoryOf<>();
317     assertThrows(NoSuchElementException.class, () ->
318      {
319       /* final Lastname name = */ lastname.getFirstEntry();
320      }, HistoryOfTests.NO_SUCH_ELEMENT_EXCEPTION
321     );
322    }
323 
324 
325   /**
326    * Test getLastEntry.
327    */
328   @Test
329   /* default */ void testGetLatestEntry1()
330    {
331     final HistoryOf<Lastname> lastname = new HistoryOf<>();
332     lastname.addEntry(OffsetDateTime.now(), Lastname.of(HistoryOfTests.HOFMANN));
333     final Lastname name = lastname.getLatestEntry();
334     assertEquals(HistoryOfTests.HOFMANN, name.stringValue(), HistoryOfTests.GET_LATEST_ENTRY);
335    }
336 
337 
338   /**
339    * Test getLatestEntry.
340    *
341    * @throws InterruptedException Interrupted sleep
342    */
343   @Test
344   /* default */ void testGetLatestEntry2() throws InterruptedException
345    {
346     final HistoryOf<Lastname> lastname = new HistoryOf<>();
347     lastname.addEntry(OffsetDateTime.now(), Lastname.of(HistoryOfTests.LASTNAME));
348     TimeUnit.MICROSECONDS.sleep(1);
349     lastname.addEntry(OffsetDateTime.now(), Lastname.of(HistoryOfTests.HOFMANN));
350     final Lastname name = lastname.getLatestEntry();
351     assertEquals(HistoryOfTests.HOFMANN, name.stringValue(), HistoryOfTests.GET_LATEST_ENTRY);
352    }
353 
354 
355   /**
356    * Test getLatestEntry.
357    */
358   @Test
359   /* default */ void testGetLatestEntry3()
360    {
361     final HistoryOf<Lastname> lastname = new HistoryOf<>();
362     assertThrows(NoSuchElementException.class, () ->
363      {
364       /* final Lastname name = */ lastname.getLatestEntry();
365      }, HistoryOfTests.NO_SUCH_ELEMENT_EXCEPTION
366     );
367    }
368 
369 
370   /**
371    * Test getPreviousEntry.
372    */
373   @Test
374   /* default */ void testGetPreviousEntry1()
375    {
376     final HistoryOf<Lastname> lastname = new HistoryOf<>();
377     lastname.addEntry(OffsetDateTime.now(), Lastname.of(HistoryOfTests.HOFMANN));
378     final Lastname name = lastname.getPreviousEntry();
379     assertEquals(HistoryOfTests.HOFMANN, name.stringValue(), HistoryOfTests.GET_PREVIOUS_ENTRY);
380    }
381 
382 
383   /**
384    * Test getPreviousEntry.
385    *
386    * @throws InterruptedException Interrupted sleep
387    */
388   @Test
389   /* default */ void testGetPreviousEntry2() throws InterruptedException
390    {
391     final HistoryOf<Lastname> lastname = new HistoryOf<>();
392     lastname.addEntry(OffsetDateTime.now(), Lastname.of(HistoryOfTests.LASTNAME));
393     TimeUnit.MICROSECONDS.sleep(1);
394     lastname.addEntry(OffsetDateTime.now(), Lastname.of(HistoryOfTests.HOFMANN));
395     final Lastname name = lastname.getPreviousEntry();
396     assertEquals(HistoryOfTests.LASTNAME, name.stringValue(), HistoryOfTests.GET_PREVIOUS_ENTRY);
397    }
398 
399 
400   /**
401    * Test getPreviousEntry.
402    */
403   @Test
404   /* default */ void testGetPreviousEntry3()
405    {
406     final HistoryOf<Lastname> lastname = new HistoryOf<>();
407     assertThrows(NoSuchElementException.class, () ->
408      {
409       /* final Lastname name = */ lastname.getPreviousEntry();
410      }, HistoryOfTests.NO_SUCH_ELEMENT_EXCEPTION
411     );
412    }
413 
414 
415   /**
416    * Test getHistory.
417    */
418   @Test
419   /* default */ void testGetHistory1()
420    {
421     final HistoryOf<Lastname> lastname = new HistoryOf<>();
422     final SortedMap<OffsetDateTime, Lastname> history = lastname.getHistory();
423     assertTrue(history.isEmpty(), "History not empty!"); //$NON-NLS-1$
424    }
425 
426 
427   /**
428    * Test getHistory.
429    */
430   @Test
431   /* default */ void testGetHistory2()
432    {
433     final List<Lastname> expected = new ArrayList<>();
434     expected.add(Lastname.of(HistoryOfTests.HOFMANN));
435     final HistoryOf<Lastname> lastname = new HistoryOf<>();
436     lastname.addEntry(OffsetDateTime.now(), Lastname.of(HistoryOfTests.HOFMANN));
437     final SortedMap<OffsetDateTime, Lastname> history = lastname.getHistory();
438     assertEquals(1, history.size(), HistoryOfTests.HISTORY_CORRECT);
439     assertIterableEquals(expected, history.values(), HistoryOfTests.HISTORY_NOT_AS_EXPECTED);
440    }
441 
442 
443   /**
444    * Test getHistory.
445    *
446    * @throws InterruptedException Interrupted sleep
447    */
448   @Test
449   /* default */ void testGetHistory3() throws InterruptedException
450    {
451     final List<Lastname> expected = new ArrayList<>();
452     expected.add(Lastname.of(HistoryOfTests.HOFMANN));
453     expected.add(Lastname.of(HistoryOfTests.LASTNAME));
454     final HistoryOf<Lastname> lastname = new HistoryOf<>();
455     lastname.addEntry(OffsetDateTime.now(), Lastname.of(HistoryOfTests.HOFMANN));
456     TimeUnit.MICROSECONDS.sleep(1);
457     lastname.addEntry(OffsetDateTime.now(), Lastname.of(HistoryOfTests.LASTNAME));
458     final SortedMap<OffsetDateTime, Lastname> history = lastname.getHistory();
459     assertEquals(2, history.size(), HistoryOfTests.HISTORY_CORRECT);
460     assertIterableEquals(expected, history.values(), HistoryOfTests.HISTORY_NOT_AS_EXPECTED);
461    }
462 
463  }