1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28 package org.apache.hc.core5.util;
29
30 import java.text.ParseException;
31 import java.util.Arrays;
32 import java.util.Collections;
33 import java.util.HashMap;
34 import java.util.HashSet;
35 import java.util.List;
36 import java.util.Map;
37 import java.util.Set;
38
39 import org.junit.jupiter.api.Assertions;
40 import org.junit.jupiter.api.Test;
41
42
43
44
45 public class TestArgs {
46
47 @Test
48 public void testArgCheckPass() {
49 Args.check(true, "All is well");
50 }
51
52 @Test
53 public void testArgCheckFail() {
54 Assertions.assertThrows(IllegalArgumentException.class, () ->
55 Args.check(false, "Oopsie"));
56 }
57
58 @Test
59 public void testArgNotNullPass() {
60 final String stuff = "stuff";
61 Assertions.assertSame(stuff, Args.notNull(stuff, "Stuff"));
62 }
63
64 @Test
65 public void testArgNotNullFail() {
66 Assertions.assertThrows(NullPointerException.class, () ->
67 Args.notNull(null, "Stuff"));
68 }
69
70 @Test
71 public void testArgNotEmptyPass() {
72 final String stuff = "stuff";
73 Assertions.assertSame(stuff, Args.notEmpty(stuff, "Stuff"));
74 }
75
76 @Test
77 public void testArgNotEmptyFail1() {
78 Assertions.assertThrows(NullPointerException.class, () ->
79 Args.notEmpty((String) null, "Stuff"));
80 }
81
82 @Test
83 public void testArgNotEmptyFail2() {
84 Assertions.assertThrows(IllegalArgumentException.class, () ->
85 Args.notEmpty("", "Stuff"));
86 }
87
88 @Test
89 public void testArgNotBlankFail1() {
90 Assertions.assertThrows(NullPointerException.class, () ->
91 Args.notBlank((String) null, "Stuff"));
92 }
93
94 @Test
95 public void testArgNotBlankFail2() {
96 Assertions.assertThrows(IllegalArgumentException.class, () ->
97 Args.notBlank("", "Stuff"));
98 }
99
100 @Test
101 public void testArgNotBlankFail3() {
102 Assertions.assertThrows(IllegalArgumentException.class, () ->
103 Args.notBlank(" \t \n\r", "Stuff"));
104 }
105
106 @Test
107 public void testArgCollectionNotEmptyPass() {
108 final List<String> list = Collections.singletonList("stuff");
109 Assertions.assertSame(list, Args.notEmpty(list, "List"));
110 }
111
112 @Test
113 public void testArgCollectionNotEmptyFail1() {
114 Assertions.assertThrows(NullPointerException.class, () ->
115 Args.notEmpty((List<?>) null, "List"));
116 }
117
118 @Test
119 public void testArgCollectionNotEmptyFail2() {
120 Assertions.assertThrows(IllegalArgumentException.class, () ->
121 Args.notEmpty(Collections.emptyList(), "List"));
122 }
123
124 @Test
125 public void testPositiveIntPass() {
126 Assertions.assertEquals(1, Args.positive(1, "Number"));
127 }
128
129 @Test
130 public void testPositiveIntFail1() {
131 Assertions.assertThrows(IllegalArgumentException.class, () ->
132 Args.positive(-1, "Number"));
133 }
134
135 @Test
136 public void testPositiveIntFail2() {
137 Assertions.assertThrows(IllegalArgumentException.class, () ->
138 Args.positive(0, "Number"));
139 }
140
141 @Test
142 public void testPositiveLongPass() {
143 Assertions.assertEquals(1L, Args.positive(1L, "Number"));
144 }
145
146 @Test
147 public void testPositiveTimeValuePass() throws ParseException {
148 final Timeout timeout = Timeout.parse("1200 MILLISECONDS");
149 Assertions.assertEquals(timeout, Args.positive(timeout, "No Error"));
150 }
151 @Test
152 public void testPositiveLongFail1() {
153 Assertions.assertThrows(IllegalArgumentException.class, () ->
154 Args.positive(-1L, "Number"));
155 }
156
157 @Test
158 public void testPositiveLongFail2() {
159 Assertions.assertThrows(IllegalArgumentException.class, () ->
160 Args.positive(0L, "Number"));
161 }
162
163 @Test
164 public void testNotNegativeIntPass1() {
165 Assertions.assertEquals(1, Args.notNegative(1, "Number"));
166 }
167
168 @Test
169 public void testNotNegativeIntPass2() {
170 Assertions.assertEquals(0, Args.notNegative(0, "Number"));
171 }
172
173 @Test
174 public void testNotNegativeIntFail1() {
175 Assertions.assertThrows(IllegalArgumentException.class, () ->
176 Args.notNegative(-1, "Number"));
177 }
178
179 @Test
180 public void testNotNegativeLongPass1() {
181 Assertions.assertEquals(1L, Args.notNegative(1L, "Number"));
182 }
183
184 @Test
185 public void testNotNegativeLongPass2() {
186 Assertions.assertEquals(0L, Args.notNegative(0L, "Number"));
187 }
188
189 @Test
190 public void testNotNegativeLongFail1() {
191 Assertions.assertThrows(IllegalArgumentException.class, () ->
192 Args.notNegative(-1L, "Number"));
193 }
194
195 @Test
196 public void testIntSmallestRangeOK() {
197 Args.checkRange(0, 0, 0, "Number");
198 }
199
200 @Test
201 public void testIntSmallestRangeFailLow() {
202 Assertions.assertThrows(IllegalArgumentException.class, () ->
203 Args.checkRange(-1, 0, 0, "Number"));
204 }
205
206 @Test
207 public void testIntRangeFailLow() {
208 Assertions.assertThrows(IllegalArgumentException.class, () ->
209 Args.checkRange(-101, -100, 100, "Number"));
210 }
211
212 @Test
213 public void testIntRangeFailHigh() {
214 Assertions.assertThrows(IllegalArgumentException.class, () ->
215 Args.checkRange(101, -100, 100, "Number"));
216 }
217
218 @Test
219 public void testIntSmallestRangeFailHigh() {
220 Assertions.assertThrows(IllegalArgumentException.class, () ->
221 Args.checkRange(1, 0, 0, "Number"));
222 }
223
224 @Test
225 public void testIntFullRangeOK() {
226 Args.checkRange(0, Integer.MIN_VALUE, Integer.MAX_VALUE, "Number");
227 }
228
229 @Test
230 public void testLongSmallestRangeOK() {
231 Args.checkRange(0L, 0L, 0L, "Number");
232 }
233
234 @Test
235 public void testLongSmallestRangeFailLow() {
236 Assertions.assertThrows(IllegalArgumentException.class, () ->
237 Args.checkRange(-1L, 0L, 0L, "Number"));
238 }
239
240 @Test
241 public void testLongRangeFailLow() {
242 Assertions.assertThrows(IllegalArgumentException.class, () ->
243 Args.checkRange(-101L, -100L, 100L, "Number"));
244 }
245
246 @Test
247 public void testLongRangeFailHigh() {
248 Assertions.assertThrows(IllegalArgumentException.class, () ->
249 Args.checkRange(101L, -100L, 100L, "Number"));
250 }
251
252 @Test
253 public void testLongSmallestRangeFailHigh() {
254 Assertions.assertThrows(IllegalArgumentException.class, () ->
255 Args.checkRange(1L, 0L, 0L, "Number"));
256 }
257
258 @Test
259 public void testLongFullRangeOK() {
260 Args.checkRange(0L, Long.MIN_VALUE, Long.MAX_VALUE, "Number");
261 }
262
263 @Test
264 public void testIsEmpty() {
265
266 final String[] NON_EMPTY_ARRAY = new String[] { "ABG", "NML", };
267
268 final List<String> NON_EMPTY_LIST = Arrays.asList(NON_EMPTY_ARRAY);
269
270 final Set<String> NON_EMPTY_SET = new HashSet<>(NON_EMPTY_LIST);
271
272 final Map<String, String> NON_EMPTY_MAP = new HashMap<>();
273 NON_EMPTY_MAP.put("ABG", "MNL");
274
275 Assertions.assertTrue(Args.isEmpty(null));
276 Assertions.assertTrue(Args.isEmpty(""));
277 Assertions.assertTrue(Args.isEmpty(new int[] {}));
278 Assertions.assertTrue(Args.isEmpty(Collections.emptyList()));
279 Assertions.assertTrue(Args.isEmpty(Collections.emptySet()));
280 Assertions.assertTrue(Args.isEmpty(Collections.emptyMap()));
281
282 Assertions.assertFalse(Args.isEmpty(" "));
283 Assertions.assertFalse(Args.isEmpty("ab"));
284 Assertions.assertFalse(Args.isEmpty(NON_EMPTY_ARRAY));
285 Assertions.assertFalse(Args.isEmpty(NON_EMPTY_LIST));
286 Assertions.assertFalse(Args.isEmpty(NON_EMPTY_SET));
287 Assertions.assertFalse(Args.isEmpty(NON_EMPTY_MAP));
288 }
289
290 @Test
291 public void testcontainsNoBlanks() {
292 final String stuff = "abg";
293 Assertions.assertSame(stuff, Args.containsNoBlanks(stuff, "abg"));
294 }
295
296 @Test
297 public void check() {
298 Assertions.assertThrows(IllegalArgumentException.class, () ->
299 Args.check(false, "Error,", "ABG"));
300 }
301
302 }