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.Assert;
40 import org.junit.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(expected=IllegalArgumentException.class)
53 public void testArgCheckFail() {
54 Args.check(false, "Oopsie");
55 }
56
57 @Test
58 public void testArgNotNullPass() {
59 final String stuff = "stuff";
60 Assert.assertSame(stuff, Args.notNull(stuff, "Stuff"));
61 }
62
63 @Test(expected=NullPointerException.class)
64 public void testArgNotNullFail() {
65 Args.notNull(null, "Stuff");
66 }
67
68 @Test
69 public void testArgNotEmptyPass() {
70 final String stuff = "stuff";
71 Assert.assertSame(stuff, Args.notEmpty(stuff, "Stuff"));
72 }
73
74 @Test(expected=NullPointerException.class)
75 public void testArgNotEmptyFail1() {
76 Args.notEmpty((String) null, "Stuff");
77 }
78
79 @Test(expected=IllegalArgumentException.class)
80 public void testArgNotEmptyFail2() {
81 Args.notEmpty("", "Stuff");
82 }
83
84 @Test(expected=NullPointerException.class)
85 public void testArgNotBlankFail1() {
86 Args.notBlank((String) null, "Stuff");
87 }
88
89 @Test(expected=IllegalArgumentException.class)
90 public void testArgNotBlankFail2() {
91 Args.notBlank("", "Stuff");
92 }
93
94 @Test(expected=IllegalArgumentException.class)
95 public void testArgNotBlankFail3() {
96 Args.notBlank(" \t \n\r", "Stuff");
97 }
98
99 @Test
100 public void testArgCollectionNotEmptyPass() {
101 final List<String> list = Arrays.asList("stuff");
102 Assert.assertSame(list, Args.notEmpty(list, "List"));
103 }
104
105 @Test(expected=NullPointerException.class)
106 public void testArgCollectionNotEmptyFail1() {
107 Args.notEmpty((List<?>) null, "List");
108 }
109
110 @Test(expected=IllegalArgumentException.class)
111 public void testArgCollectionNotEmptyFail2() {
112 Args.notEmpty(Collections.emptyList(), "List");
113 }
114
115 @Test
116 public void testPositiveIntPass() {
117 Assert.assertEquals(1, Args.positive(1, "Number"));
118 }
119
120 @Test(expected=IllegalArgumentException.class)
121 public void testPositiveIntFail1() {
122 Args.positive(-1, "Number");
123 }
124
125 @Test(expected=IllegalArgumentException.class)
126 public void testPositiveIntFail2() {
127 Args.positive(0, "Number");
128 }
129
130 @Test
131 public void testPositiveLongPass() {
132 Assert.assertEquals(1L, Args.positive(1L, "Number"));
133 }
134
135 @Test
136 public void testPositiveTimeValuePass() throws ParseException {
137 final Timeout timeout = Timeout.parse("1200 MILLISECONDS");
138 Assert.assertEquals(timeout, Args.positive(timeout, "No Error"));
139 }
140 @Test(expected=IllegalArgumentException.class)
141 public void testPositiveLongFail1() {
142 Args.positive(-1L, "Number");
143 }
144
145 @Test(expected=IllegalArgumentException.class)
146 public void testPositiveLongFail2() {
147 Args.positive(0L, "Number");
148 }
149
150 @Test
151 public void testNotNegativeIntPass1() {
152 Assert.assertEquals(1, Args.notNegative(1, "Number"));
153 }
154
155 @Test
156 public void testNotNegativeIntPass2() {
157 Assert.assertEquals(0, Args.notNegative(0, "Number"));
158 }
159
160 @Test(expected=IllegalArgumentException.class)
161 public void testNotNegativeIntFail1() {
162 Args.notNegative(-1, "Number");
163 }
164
165 @Test
166 public void testNotNegativeLongPass1() {
167 Assert.assertEquals(1L, Args.notNegative(1L, "Number"));
168 }
169
170 @Test
171 public void testNotNegativeLongPass2() {
172 Assert.assertEquals(0L, Args.notNegative(0L, "Number"));
173 }
174
175 @Test(expected=IllegalArgumentException.class)
176 public void testNotNegativeLongFail1() {
177 Args.notNegative(-1L, "Number");
178 }
179
180
181 public void testIntSmallestRangeOK() {
182 Args.checkRange(0, 0, 0, "Number");
183 }
184
185 @Test(expected = IllegalArgumentException.class)
186 public void testIntSmallestRangeFailLow() {
187 Args.checkRange(-1, 0, 0, "Number");
188 }
189
190 @Test(expected = IllegalArgumentException.class)
191 public void testIntRangeFailLow() {
192 Args.checkRange(-101, -100, 100, "Number");
193 }
194
195 @Test(expected = IllegalArgumentException.class)
196 public void testIntRangeFailHigh() {
197 Args.checkRange(101, -100, 100, "Number");
198 }
199
200 @Test(expected = IllegalArgumentException.class)
201 public void testIntSmallestRangeFailHigh() {
202 Args.checkRange(1, 0, 0, "Number");
203 }
204
205 public void testIntFullRangeOK() {
206 Args.checkRange(0, Integer.MIN_VALUE, Integer.MAX_VALUE, "Number");
207 }
208
209
210 public void testLongSmallestRangeOK() {
211 Args.checkRange(0L, 0L, 0L, "Number");
212 }
213
214 @Test(expected = IllegalArgumentException.class)
215 public void testLongSmallestRangeFailLow() {
216 Args.checkRange(-1L, 0L, 0L, "Number");
217 }
218
219 @Test(expected = IllegalArgumentException.class)
220 public void testLongRangeFailLow() {
221 Args.checkRange(-101L, -100L, 100L, "Number");
222 }
223
224 @Test(expected = IllegalArgumentException.class)
225 public void testLongRangeFailHigh() {
226 Args.checkRange(101L, -100L, 100L, "Number");
227 }
228
229 @Test(expected = IllegalArgumentException.class)
230 public void testLongSmallestRangeFailHigh() {
231 Args.checkRange(1L, 0L, 0L, "Number");
232 }
233
234 public void testLongFullRangeOK() {
235 Args.checkRange(0L, Long.MIN_VALUE, Long.MAX_VALUE, "Number");
236 }
237
238 @Test
239 public void testIsEmpty() {
240
241 final String[] NON_EMPTY_ARRAY = new String[] { "ABG", "NML", };
242
243 final List<String> NON_EMPTY_LIST = Arrays.asList(NON_EMPTY_ARRAY);
244
245 final Set<String> NON_EMPTY_SET = new HashSet<>(NON_EMPTY_LIST);
246
247 final Map<String, String> NON_EMPTY_MAP = new HashMap<>();
248 NON_EMPTY_MAP.put("ABG", "MNL");
249
250 Assert.assertTrue(Args.isEmpty(null));
251 Assert.assertTrue(Args.isEmpty(""));
252 Assert.assertTrue(Args.isEmpty(new int[] {}));
253 Assert.assertTrue(Args.isEmpty(Collections.emptyList()));
254 Assert.assertTrue(Args.isEmpty(Collections.emptySet()));
255 Assert.assertTrue(Args.isEmpty(Collections.emptyMap()));
256
257 Assert.assertFalse(Args.isEmpty(" "));
258 Assert.assertFalse(Args.isEmpty("ab"));
259 Assert.assertFalse(Args.isEmpty(NON_EMPTY_ARRAY));
260 Assert.assertFalse(Args.isEmpty(NON_EMPTY_LIST));
261 Assert.assertFalse(Args.isEmpty(NON_EMPTY_SET));
262 Assert.assertFalse(Args.isEmpty(NON_EMPTY_MAP));
263 }
264
265 @Test
266 public void testcontainsNoBlanks() {
267 final String stuff = "abg";
268 Assert.assertSame(stuff, Args.containsNoBlanks(stuff, "abg"));
269 }
270
271 @Test(expected=IllegalArgumentException.class)
272 public void check() {
273 Args.check(false, "Error,", "ABG");
274 }
275
276 }