View Javadoc
1   /*
2    * Licensed to the Apache Software Foundation (ASF) under one or more
3    * contributor license agreements.  See the NOTICE file distributed with
4    * this work for additional information regarding copyright ownership.
5    * The ASF licenses this file to You under the Apache License, Version 2.0
6    * (the "License"); you may not use this file except in compliance with
7    * the License.  You may obtain a copy of the License at
8    *
9    *      http://www.apache.org/licenses/LICENSE-2.0
10   *
11   * Unless required by applicable law or agreed to in writing, software
12   * distributed under the License is distributed on an "AS IS" BASIS,
13   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
14   * See the License for the specific language governing permissions and
15   * limitations under the License.
16   */
17  package org.apache.juneau.commons.lang;
18  
19  import static org.apache.juneau.commons.lang.StateEnum.*;
20  import static org.junit.jupiter.api.Assertions.*;
21  
22  import org.apache.juneau.*;
23  import org.junit.jupiter.api.*;
24  
25  /**
26   * Tests for {@link StateEnum}.
27   */
28  class StateEnum_Test extends TestBase {
29  
30  	//====================================================================================================
31  	// Enum values() tests
32  	//====================================================================================================
33  
34  	@Test
35  	void a01_values_returnsAllStates() {
36  		var values = StateEnum.values();
37  		assertEquals(50, values.length);
38  		assertEquals(S1, values[0]);
39  		assertEquals(S50, values[49]);
40  	}
41  
42  	@Test
43  	void a02_values_containsAllStates() {
44  		var values = StateEnum.values();
45  		assertEquals(S1, values[0]);
46  		assertEquals(S2, values[1]);
47  		assertEquals(S3, values[2]);
48  		assertEquals(S10, values[9]);
49  		assertEquals(S25, values[24]);
50  		assertEquals(S50, values[49]);
51  	}
52  
53  	//====================================================================================================
54  	// valueOf() tests
55  	//====================================================================================================
56  
57  	@Test
58  	void b01_valueOf_validNames() {
59  		assertEquals(S1, StateEnum.valueOf("S1"));
60  		assertEquals(S2, StateEnum.valueOf("S2"));
61  		assertEquals(S10, StateEnum.valueOf("S10"));
62  		assertEquals(S25, StateEnum.valueOf("S25"));
63  		assertEquals(S50, StateEnum.valueOf("S50"));
64  	}
65  
66  	@Test
67  	void b02_valueOf_invalidName() {
68  		assertThrows(IllegalArgumentException.class, () -> {
69  			StateEnum.valueOf("INVALID");
70  		});
71  	}
72  
73  	@Test
74  	void b03_valueOf_null() {
75  		assertThrows(NullPointerException.class, () -> {
76  			StateEnum.valueOf(null);
77  		});
78  	}
79  
80  	@Test
81  	void b04_valueOf_caseSensitive() {
82  		assertThrows(IllegalArgumentException.class, () -> {
83  			StateEnum.valueOf("s1");
84  		});
85  		assertThrows(IllegalArgumentException.class, () -> {
86  			StateEnum.valueOf("S51");
87  		});
88  	}
89  
90  	//====================================================================================================
91  	// isAny() tests
92  	//====================================================================================================
93  
94  	@Test
95  	void c01_isAny_singleMatch() {
96  		assertTrue(S1.isAny(S1));
97  		assertTrue(S2.isAny(S2));
98  		assertTrue(S10.isAny(S10));
99  		assertTrue(S50.isAny(S50));
100 	}
101 
102 	@Test
103 	void c02_isAny_singleNoMatch() {
104 		assertFalse(S1.isAny(S2));
105 		assertFalse(S2.isAny(S1));
106 		assertFalse(S10.isAny(S20));
107 		assertFalse(S50.isAny(S1));
108 	}
109 
110 	@Test
111 	void c03_isAny_multipleMatch() {
112 		assertTrue(S1.isAny(S1, S2, S3));
113 		assertTrue(S2.isAny(S1, S2, S3));
114 		assertTrue(S3.isAny(S1, S2, S3));
115 	}
116 
117 	@Test
118 	void c04_isAny_multipleNoMatch() {
119 		assertFalse(S1.isAny(S2, S3, S4));
120 		assertFalse(S10.isAny(S1, S2, S3));
121 		assertFalse(S50.isAny(S1, S2, S3));
122 	}
123 
124 	@Test
125 	void c05_isAny_matchInMiddle() {
126 		assertTrue(S2.isAny(S1, S2, S3));
127 		assertTrue(S25.isAny(S10, S25, S40));
128 	}
129 
130 	@Test
131 	void c06_isAny_matchAtEnd() {
132 		assertTrue(S3.isAny(S1, S2, S3));
133 		assertTrue(S50.isAny(S1, S10, S50));
134 	}
135 
136 	@Test
137 	void c07_isAny_matchAtStart() {
138 		assertTrue(S1.isAny(S1, S2, S3));
139 		assertTrue(S1.isAny(S1, S10, S50));
140 	}
141 
142 	@Test
143 	void c08_isAny_emptyArray() {
144 		assertFalse(S1.isAny());
145 		assertFalse(S10.isAny());
146 		assertFalse(S50.isAny());
147 	}
148 
149 	@Test
150 	void c09_isAny_duplicateValues() {
151 		assertTrue(S1.isAny(S1, S1, S1));
152 		assertTrue(S2.isAny(S1, S2, S2, S3));
153 		assertFalse(S3.isAny(S1, S1, S2, S2));
154 	}
155 
156 	@Test
157 	void c10_isAny_allStates() {
158 		var allStates = StateEnum.values();
159 		for (var state : allStates) {
160 			assertTrue(state.isAny(allStates));
161 		}
162 	}
163 
164 	@Test
165 	void c11_isAny_sameStateMultipleTimes() {
166 		assertTrue(S1.isAny(S1, S1, S1, S1));
167 		assertTrue(S25.isAny(S25, S25, S25));
168 	}
169 
170 	@Test
171 	void c12_isAny_largeArray() {
172 		assertTrue(S10.isAny(S1, S2, S3, S4, S5, S6, S7, S8, S9, S10));
173 		assertFalse(S11.isAny(S1, S2, S3, S4, S5, S6, S7, S8, S9, S10));
174 	}
175 
176 	//====================================================================================================
177 	// Enum standard methods tests
178 	//====================================================================================================
179 
180 	@Test
181 	void d01_name_returnsCorrectName() {
182 		assertEquals("S1", S1.name());
183 		assertEquals("S2", S2.name());
184 		assertEquals("S10", S10.name());
185 		assertEquals("S50", S50.name());
186 	}
187 
188 	@Test
189 	void d02_ordinal_returnsCorrectOrdinal() {
190 		assertEquals(0, S1.ordinal());
191 		assertEquals(1, S2.ordinal());
192 		assertEquals(9, S10.ordinal());
193 		assertEquals(24, S25.ordinal());
194 		assertEquals(49, S50.ordinal());
195 	}
196 
197 	@Test
198 	void d03_equals_sameInstance() {
199 		assertEquals(S1, S1);
200 		assertEquals(S10, S10);
201 		assertEquals(S50, S50);
202 	}
203 
204 	@Test
205 	void d04_equals_differentInstances() {
206 		assertNotEquals(S1, S2);
207 		assertNotEquals(S10, S20);
208 		assertNotEquals(S1, S50);
209 	}
210 
211 	@Test
212 	void d05_hashCode_consistency() {
213 		assertEquals(S1.hashCode(), S1.hashCode());
214 		assertEquals(S10.hashCode(), S10.hashCode());
215 		assertEquals(S50.hashCode(), S50.hashCode());
216 	}
217 
218 	@Test
219 	void d06_hashCode_differentStates() {
220 		// Different states may have same hashcode, but same state should have same hashcode
221 		assertEquals(S1.hashCode(), S1.hashCode());
222 	}
223 
224 	@Test
225 	void d07_compareTo_ordering() {
226 		assertTrue(S1.compareTo(S2) < 0);
227 		assertTrue(S2.compareTo(S1) > 0);
228 		assertTrue(S1.compareTo(S1) == 0);
229 		assertTrue(S10.compareTo(S20) < 0);
230 		assertTrue(S50.compareTo(S1) > 0);
231 	}
232 
233 	@Test
234 	void d08_compareTo_allStates() {
235 		var values = StateEnum.values();
236 		for (var i = 0; i < values.length - 1; i++) {
237 			assertTrue(values[i].compareTo(values[i + 1]) < 0);
238 		}
239 	}
240 
241 	@Test
242 	void d09_toString_returnsName() {
243 		assertEquals("S1", S1.toString());
244 		assertEquals("S2", S2.toString());
245 		assertEquals("S10", S10.toString());
246 		assertEquals("S50", S50.toString());
247 	}
248 
249 	//====================================================================================================
250 	// Edge cases
251 	//====================================================================================================
252 
253 	@Test
254 	void e01_edgeCase_firstAndLast() {
255 		assertTrue(S1.isAny(S1, S50));
256 		assertTrue(S50.isAny(S1, S50));
257 		assertFalse(S25.isAny(S1, S50));
258 	}
259 
260 	@Test
261 	void e02_edgeCase_allStatesInOrder() {
262 		var allStates = StateEnum.values();
263 		for (var i = 0; i < allStates.length; i++) {
264 			assertTrue(allStates[i].isAny(allStates));
265 		}
266 	}
267 
268 	@Test
269 	void e03_edgeCase_singleStateArray() {
270 		assertTrue(S1.isAny(S1));
271 		assertTrue(S25.isAny(S25));
272 		assertTrue(S50.isAny(S50));
273 	}
274 
275 	@Test
276 	void e04_edgeCase_sequentialStates() {
277 		assertTrue(S5.isAny(S1, S2, S3, S4, S5, S6, S7, S8, S9, S10));
278 		assertFalse(S15.isAny(S1, S2, S3, S4, S5, S6, S7, S8, S9, S10));
279 	}
280 
281 	@Test
282 	void e05_edgeCase_nonSequentialStates() {
283 		assertTrue(S10.isAny(S1, S5, S10, S15, S20));
284 		assertFalse(S12.isAny(S1, S5, S10, S15, S20));
285 	}
286 }
287