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.http.message;
29
30 import java.util.NoSuchElementException;
31
32 import org.apache.http.Header;
33 import org.apache.http.HeaderIterator;
34 import org.apache.http.ParseException;
35 import org.apache.http.TokenIterator;
36 import org.junit.Assert;
37 import org.junit.Test;
38
39
40
41
42
43
44 public class TestBasicTokenIterator {
45
46 @Test
47 public void testSingleHeader() {
48 Header[] headers = new Header[]{
49 new BasicHeader("Name", "token0,token1, token2 , token3")
50 };
51 HeaderIterator hit = new BasicHeaderIterator(headers, null);
52 TokenIterator ti = new BasicTokenIterator(hit);
53
54 Assert.assertTrue(ti.hasNext());
55 Assert.assertEquals("token0", "token0", ti.nextToken());
56 Assert.assertTrue(ti.hasNext());
57 Assert.assertEquals("token1", "token1", ti.nextToken());
58 Assert.assertTrue(ti.hasNext());
59 Assert.assertEquals("token2", "token2", ti.nextToken());
60 Assert.assertTrue(ti.hasNext());
61 Assert.assertEquals("token3", "token3", ti.nextToken());
62 Assert.assertFalse(ti.hasNext());
63
64
65 headers = new Header[]{
66 new BasicHeader("Name", "token0")
67 };
68 hit = new BasicHeaderIterator(headers, null);
69 ti = new BasicTokenIterator(hit);
70
71 Assert.assertTrue(ti.hasNext());
72 Assert.assertEquals("token0", "token0", ti.nextToken());
73 Assert.assertFalse(ti.hasNext());
74 }
75
76
77 @Test
78 public void testMultiHeader() {
79 final Header[] headers = new Header[]{
80 new BasicHeader("Name", "token0,token1"),
81 new BasicHeader("Name", ""),
82 new BasicHeader("Name", "token2"),
83 new BasicHeader("Name", " "),
84 new BasicHeader("Name", "token3 "),
85 new BasicHeader("Name", ","),
86 new BasicHeader("Name", "token4"),
87 };
88 final HeaderIterator hit = new BasicHeaderIterator(headers, null);
89 final TokenIterator ti = new BasicTokenIterator(hit);
90
91 Assert.assertTrue(ti.hasNext());
92 Assert.assertEquals("token0", "token0", ti.nextToken());
93 Assert.assertTrue(ti.hasNext());
94 Assert.assertEquals("token1", "token1", ti.nextToken());
95 Assert.assertTrue(ti.hasNext());
96 Assert.assertEquals("token2", "token2", ti.nextToken());
97 Assert.assertTrue(ti.hasNext());
98 Assert.assertEquals("token3", "token3", ti.nextToken());
99 Assert.assertTrue(ti.hasNext());
100 Assert.assertEquals("token4", "token4", ti.nextToken());
101 Assert.assertFalse(ti.hasNext());
102 }
103
104
105 @Test
106 public void testEmpty() {
107 final Header[] headers = new Header[]{
108 new BasicHeader("Name", " "),
109 new BasicHeader("Name", ""),
110 new BasicHeader("Name", ","),
111 new BasicHeader("Name", " ,, "),
112 };
113 HeaderIterator hit = new BasicHeaderIterator(headers, null);
114 TokenIterator ti = new BasicTokenIterator(hit);
115
116 Assert.assertFalse(ti.hasNext());
117
118
119 hit = new BasicHeaderIterator(headers, "empty");
120 ti = new BasicTokenIterator(hit);
121
122 Assert.assertFalse(ti.hasNext());
123 }
124
125
126 @Test
127 public void testValueStart() {
128 final Header[] headers = new Header[]{
129 new BasicHeader("Name", "token0"),
130 new BasicHeader("Name", " token1"),
131 new BasicHeader("Name", ",token2"),
132 new BasicHeader("Name", " ,token3"),
133 new BasicHeader("Name", ", token4"),
134 new BasicHeader("Name", " , token5"),
135 };
136 final HeaderIterator hit = new BasicHeaderIterator(headers, null);
137 final TokenIterator ti = new BasicTokenIterator(hit);
138
139 Assert.assertTrue(ti.hasNext());
140 Assert.assertEquals("token0", "token0", ti.nextToken());
141 Assert.assertTrue(ti.hasNext());
142 Assert.assertEquals("token1", "token1", ti.nextToken());
143 Assert.assertTrue(ti.hasNext());
144 Assert.assertEquals("token2", "token2", ti.nextToken());
145 Assert.assertTrue(ti.hasNext());
146 Assert.assertEquals("token3", "token3", ti.nextToken());
147 Assert.assertTrue(ti.hasNext());
148 Assert.assertEquals("token4", "token4", ti.nextToken());
149 Assert.assertTrue(ti.hasNext());
150 Assert.assertEquals("token5", "token5", ti.nextToken());
151 Assert.assertFalse(ti.hasNext());
152 }
153
154
155 @Test
156 public void testValueEnd() {
157 final Header[] headers = new Header[]{
158 new BasicHeader("Name", "token0"),
159 new BasicHeader("Name", "token1 "),
160 new BasicHeader("Name", "token2,"),
161 new BasicHeader("Name", "token3 ,"),
162 new BasicHeader("Name", "token4, "),
163 new BasicHeader("Name", "token5 , "),
164 };
165 final HeaderIterator hit = new BasicHeaderIterator(headers, null);
166 final TokenIterator ti = new BasicTokenIterator(hit);
167
168 Assert.assertTrue(ti.hasNext());
169 Assert.assertEquals("token0", "token0", ti.nextToken());
170 Assert.assertTrue(ti.hasNext());
171 Assert.assertEquals("token1", "token1", ti.nextToken());
172 Assert.assertTrue(ti.hasNext());
173 Assert.assertEquals("token2", "token2", ti.nextToken());
174 Assert.assertTrue(ti.hasNext());
175 Assert.assertEquals("token3", "token3", ti.nextToken());
176 Assert.assertTrue(ti.hasNext());
177 Assert.assertEquals("token4", "token4", ti.nextToken());
178 Assert.assertTrue(ti.hasNext());
179 Assert.assertEquals("token5", "token5", ti.nextToken());
180 Assert.assertFalse(ti.hasNext());
181 }
182
183
184 @Test
185 public void testTokenChar() {
186 final Header[] headers = new Header[]{
187 new BasicHeader("Name", "token0")
188 };
189 final HeaderIterator hit = new BasicHeaderIterator(headers, null);
190 final BasicTokenIterator bti = new BasicTokenIterator(hit);
191
192 Assert.assertTrue ("letter" , bti.isTokenChar('j'));
193 Assert.assertFalse("control" , bti.isTokenChar('\b'));
194 Assert.assertFalse("separator", bti.isTokenChar('?'));
195 Assert.assertTrue ("other" , bti.isTokenChar('-'));
196 }
197
198
199 @Test
200 public void testInvalid() {
201 final Header[] headers = new Header[]{
202 new BasicHeader("in", "token0=token1"),
203 new BasicHeader("no", "token0 token1"),
204 new BasicHeader("pre", "<token0,token1"),
205 new BasicHeader("post", "token0,token1="),
206 };
207 HeaderIterator hit = new BasicHeaderIterator(headers, "in");
208 TokenIterator ti = new BasicTokenIterator(hit);
209
210
211 Assert.assertTrue(ti.hasNext());
212 try {
213 ti.nextToken();
214 Assert.fail("invalid infix character not detected");
215 } catch (final ParseException px) {
216
217 }
218
219
220
221 hit = new BasicHeaderIterator(headers, "no");
222 ti = new BasicTokenIterator(hit);
223 Assert.assertTrue(ti.hasNext());
224 try {
225 ti.nextToken();
226 Assert.fail("missing token separator not detected");
227 } catch (final ParseException px) {
228
229 }
230
231
232
233 hit = new BasicHeaderIterator(headers, "pre");
234 try {
235 new BasicTokenIterator(hit);
236 Assert.fail("invalid prefix character not detected");
237 } catch (final ParseException px) {
238
239 }
240
241
242 hit = new BasicHeaderIterator(headers, "post");
243 ti = new BasicTokenIterator(hit);
244
245 Assert.assertTrue(ti.hasNext());
246 Assert.assertEquals("token0", "token0", ti.nextToken());
247 Assert.assertTrue(ti.hasNext());
248
249 try {
250 ti.nextToken();
251 Assert.fail("invalid postfix character not detected");
252 } catch (final ParseException px) {
253
254 }
255 }
256
257
258 @Test
259 public void testWrongPublic() {
260
261 try {
262 new BasicTokenIterator(null);
263 Assert.fail("null argument not detected");
264 } catch (final IllegalArgumentException iax) {
265
266 }
267
268 final Header[] headers = new Header[]{
269 new BasicHeader("Name", " "),
270 new BasicHeader("Name", ""),
271 new BasicHeader("Name", ","),
272 new BasicHeader("Name", " ,, "),
273 };
274 final HeaderIterator hit = new BasicHeaderIterator(headers, null);
275 final TokenIterator ti = new BasicTokenIterator(hit);
276
277 try {
278
279 ti.next();
280 Assert.fail("next after end not detected");
281 } catch (final NoSuchElementException nsx) {
282
283 }
284
285 try {
286 ti.remove();
287 Assert.fail("unsupported remove not detected");
288 } catch (final UnsupportedOperationException uox) {
289
290 }
291 }
292
293
294 @Test
295 public void testWrongProtected() {
296
297 final Header[] headers = new Header[]{
298 new BasicHeader("Name", "token1,token2")
299 };
300 final HeaderIterator hit = new BasicHeaderIterator(headers, null);
301 final BasicTokenIterator bti = new BasicTokenIterator(hit);
302
303 try {
304 bti.findTokenStart(-1);
305 Assert.fail("tokenStart: negative index not detected");
306 } catch (final IllegalArgumentException iax) {
307
308 }
309
310 try {
311 bti.findTokenSeparator(-1);
312 Assert.fail("tokenSeparator: negative index not detected");
313 } catch (final IllegalArgumentException iax) {
314
315 }
316
317 try {
318 bti.findTokenEnd(-1);
319 Assert.fail("tokenEnd: negative index not detected");
320 } catch (final IllegalArgumentException iax) {
321
322 }
323 }
324
325 }