View Javadoc
1   /*
2    * Copyright (C) 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.assertNotNull;
11  import static org.junit.jupiter.api.Assertions.assertThrows;
12  import static org.junit.jupiter.api.Assertions.assertTrue;
13  
14  import java.util.ArrayList;
15  import java.util.Iterator;
16  
17  import org.junit.jupiter.api.Test;
18  import org.junit.jupiter.params.ParameterizedTest;
19  import org.junit.jupiter.params.provider.ValueSource;
20  
21  import de.powerstat.validation.containers.GroupOf;
22  import de.powerstat.validation.entities.Person;
23  import de.powerstat.validation.values.Gender;
24  import de.powerstat.validation.values.Lastname;
25  
26  
27  /**
28   * GroupOf tests.
29   */
30  public class GroupOfTests
31   {
32    /**
33     * Default constructor.
34     */
35    /* default */ GroupOfTests()
36     {
37      super();
38     }
39  
40  
41    /**
42     * Constructor test.
43     */
44    @Test
45    /* default */ void testConstructor1()
46     {
47      final GroupOf<Person> groups = new GroupOf<>("developers");
48      assertAll("GroupOf constructor",
49        () -> assertNotNull(groups, "Constructor failed!"), //$NON-NLS-1$
50        () -> assertEquals("developers", groups.name(), "Wrong group name") //$NON-NLS-1$
51      );
52     }
53  
54  
55    /**
56     * Constructor test.
57     */
58    @Test
59    /* default */ void testConstructor2()
60     {
61      assertThrows(NullPointerException.class, () ->
62       {
63        final GroupOf<Person> groups = new GroupOf<>(null);
64       }, "Null pointer exception"
65      );
66     }
67  
68  
69    /**
70     * Test constructor.
71     *
72     * @param name Group name
73     */
74    @ParameterizedTest
75    @ValueSource(strings = {"", "12345678901234567890123456789012345678901", "!!!"})
76    /* default */ void testConstructor3(final String name)
77     {
78      assertThrows(IllegalArgumentException.class, () ->
79       {
80        final GroupOf<Person> groups = new GroupOf<>(name);
81       }, "Illegal argument exception"
82      );
83     }
84  
85  
86    /**
87     * Test name.
88     */
89    @Test
90    /* default */ void testName()
91     {
92      final GroupOf<Person> groups = new GroupOf<>("developers");
93      assertEquals("developers", groups.name(), "Wrong group name");
94     }
95  
96  
97    /**
98     * Hash code test.
99     */
100   @Test
101   /* default */ void testHashCode()
102    {
103     final GroupOf<Person> developers = new GroupOf<>("developers");
104     final int hc1 = developers.hashCode();
105     assertAll("HashCode",
106       () -> assertEquals(-225038600, hc1, "hc1 not as expected") //$NON-NLS-1$
107     );
108    }
109 
110 
111   /**
112    * Test equals.
113    */
114   @Test
115   @SuppressWarnings("java:S5785")
116   /* default */ void testEquals()
117    {
118     final GroupOf<Person> group1 = new GroupOf<>("developers");
119     final GroupOf<Person> group2 = new GroupOf<>("developers");
120     group2.add(Person.of());
121     final GroupOf<Person> group3 = new GroupOf<>("family");
122     final GroupOf<Person> group4 = new GroupOf<>("family");
123     group4.add(Person.of());
124     assertAll("testEquals", //$NON-NLS-1$
125       () -> assertTrue(group1.equals(group1), "group11 is not equal"), //$NON-NLS-1$
126       () -> assertFalse(group1.equals(group2), "group12 are not equal"), //$NON-NLS-1$
127       () -> assertFalse(group2.equals(group1), "group21 are not equal"), //$NON-NLS-1$
128       () -> assertFalse(group2.equals(group4), "group24 are not equal"), //$NON-NLS-1$
129       () -> assertFalse(group1.equals(group4), "group14 are not equal"), //$NON-NLS-1$
130       () -> assertFalse(group1.equals(group3), "group13 are equal"), //$NON-NLS-1$
131       () -> assertFalse(group3.equals(group1), "group31 are equal"), //$NON-NLS-1$
132       () -> assertFalse(group1.equals(null), "group10 is equal"), //$NON-NLS-1$
133       () -> assertFalse(group1.equals(new Object()), "group1obj is equal") //$NON-NLS-1$
134     );
135    }
136 
137 
138   /**
139    * Test toString.
140    */
141   @Test
142   /* default */ void testToString1()
143    {
144     final GroupOf<Person> developers = new GroupOf<>("developers");
145     assertEquals("GroupOf<>[name=developers]", developers.toString(), "toString() not equal");
146    }
147 
148 
149   /**
150    * Test toString.
151    */
152   @Test
153   /* default */ void testToString2()
154    {
155     final GroupOf<Person> developers = new GroupOf<>("developers");
156     developers.add(Person.of(Lastname.of("Hofmann"), Gender.MALE));
157     assertEquals("GroupOf<>[name=developers, Person[lastname=Lastname[lastname=Hofmann], gender=MALE]]", developers.toString(), "toString() not equal");
158    }
159 
160 
161   /**
162    * Test size.
163    */
164   @Test
165   /* default */ void testSize()
166    {
167     final GroupOf<Person> developers = new GroupOf<>("developers");
168     assertEquals(0, developers.size(), "size() not equal");
169    }
170 
171 
172   /**
173    * Test isEmpty.
174    */
175   @Test
176   /* default */ void testIsEmpty()
177    {
178     final GroupOf<Person> developers = new GroupOf<>("developers");
179     assertTrue(developers.isEmpty(), "is not empty");
180    }
181 
182 
183   /**
184    * Test contains.
185    */
186   @Test
187   /* default */ void testContains()
188    {
189     final GroupOf<Person> developers = new GroupOf<>("developers");
190     final Person person = Person.of(Lastname.of("Hofmann"), Gender.MALE);
191     developers.add(person);
192     assertTrue(developers.contains(person), "does not contain");
193    }
194 
195 
196   /**
197    * Test iterator.
198    */
199   @Test
200   /* default */ void testIterator()
201    {
202     final GroupOf<Person> developers = new GroupOf<>("developers");
203     developers.add(Person.of(Lastname.of("Hofmann"), Gender.MALE));
204     final Iterator<Person> iter = developers.iterator();
205     assertTrue(iter.hasNext(), "iter has no next");
206    }
207 
208 
209   /**
210    * Test toArray.
211    */
212   @Test
213   /* default */ void testToArray1()
214    {
215     final GroupOf<Person> developers = new GroupOf<>("developers");
216     developers.add(Person.of(Lastname.of("Hofmann"), Gender.MALE));
217     final Object[] arr = developers.toArray();
218     assertEquals(1, arr.length, "array != 1");
219    }
220 
221 
222   /**
223    * Test toArray.
224    */
225   @Test
226   /* default */ void testToArray2()
227    {
228     final GroupOf<Person> developers = new GroupOf<>("developers");
229     developers.add(Person.of(Lastname.of("Hofmann"), Gender.MALE));
230     final Person[] arr = developers.toArray(new Person[1]);
231     assertEquals(1, arr.length, "array != 1");
232    }
233 
234 
235   /**
236    * Test add.
237    */
238   @Test
239   /* default */ void testAdd()
240    {
241     final GroupOf<Person> developers = new GroupOf<>("developers");
242     developers.add(Person.of(Lastname.of("Hofmann"), Gender.MALE));
243     assertFalse(developers.isEmpty(), "is empty");
244    }
245 
246 
247   /**
248    * Test remove.
249    */
250   @Test
251   /* default */ void testRemove()
252    {
253     final GroupOf<Person> developers = new GroupOf<>("developers");
254     final Person person = Person.of(Lastname.of("Hofmann"), Gender.MALE);
255     developers.add(person);
256     developers.remove(person);
257     assertTrue(developers.isEmpty(), "is empty");
258    }
259 
260 
261   /**
262    * Test containsAll.
263    */
264   @Test
265   /* default */ void testContainsAll()
266    {
267     final GroupOf<Person> developers = new GroupOf<>("developers");
268     final ArrayList<Person> list = new ArrayList<>();
269     list.add(Person.of(Lastname.of("Hofmann"), Gender.MALE));
270     developers.addAll(list);
271     assertTrue(developers.containsAll(list), "is empty");
272    }
273 
274 
275   /**
276    * Test addAll.
277    */
278   @Test
279   /* default */ void testAddAll()
280    {
281     final GroupOf<Person> developers = new GroupOf<>("developers");
282     final ArrayList<Person> list = new ArrayList<>();
283     list.add(Person.of(Lastname.of("Hofmann"), Gender.MALE));
284     developers.addAll(list);
285     assertFalse(developers.isEmpty(), "is empty");
286    }
287 
288 
289   /**
290    * Test retainAll.
291    */
292   @Test
293   /* default */ void testRetainAll()
294    {
295     final GroupOf<Person> developers = new GroupOf<>("developers");
296     developers.add(Person.of(Lastname.of("Hofmann"), Gender.MALE));
297     final boolean result = developers.retainAll(new ArrayList<>());
298     assertAll("testRetainAll", //$NON-NLS-1$
299       () -> assertTrue(result, "not changed"), //$NON-NLS-1$
300       () -> assertTrue(developers.isEmpty(), "is not empty") //$NON-NLS-1$
301     );
302    }
303 
304 
305   /**
306    * Test removeAll.
307    */
308   @Test
309   /* default */ void testRemoveAll()
310    {
311     final GroupOf<Person> developers = new GroupOf<>("developers");
312     final ArrayList<Person> list = new ArrayList<>();
313     list.add(Person.of(Lastname.of("Hofmann"), Gender.MALE));
314     developers.addAll(list);
315     developers.removeAll(list);
316     assertTrue(developers.isEmpty(), "is not empty");
317    }
318 
319 
320   /**
321    * Test clear.
322    */
323   @Test
324   /* default */ void testClear()
325    {
326     final GroupOf<Person> developers = new GroupOf<>("developers");
327     developers.add(Person.of(Lastname.of("Hofmann"), Gender.MALE));
328     developers.clear();
329     assertTrue(developers.isEmpty(), "is not empty");
330    }
331 
332  }