1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21 package org.apache.struts2.views.jsp;
22
23 import java.util.ArrayList;
24 import java.util.Collection;
25 import java.util.HashMap;
26 import java.util.List;
27 import java.util.Map;
28
29 import javax.servlet.jsp.JspException;
30 import javax.servlet.jsp.tagext.TagSupport;
31
32 import com.mockobjects.servlet.MockBodyContent;
33 import com.mockobjects.servlet.MockJspWriter;
34
35
36 /***
37 * Test Case for Iterator Tag
38 *
39 */
40 public class IteratorTagTest extends AbstractUITagTest {
41
42 IteratorTag tag;
43
44
45 public void testIteratingWithIdSpecified() throws Exception {
46 List list = new ArrayList();
47 list.add("one");
48 list.add("two");
49 list.add("three");
50 list.add("four");
51 list.add("five");
52
53 Foo foo = new Foo();
54 foo.setList(list);
55
56 stack.push(foo);
57
58 tag.setValue("list");
59 tag.setId("myId");
60
61
62 int result = tag.doStartTag();
63 assertEquals(result, TagSupport.EVAL_BODY_INCLUDE);
64 assertEquals(stack.peek(), "one");
65 assertEquals(stack.getContext().get("myId"), "one");
66
67
68 tag.doInitBody();
69
70
71 result = tag.doAfterBody();
72 assertEquals(result, TagSupport.EVAL_BODY_AGAIN);
73 assertEquals(stack.peek(), "two");
74 assertEquals(stack.getContext().get("myId"), "two");
75
76
77
78 result = tag.doAfterBody();
79 assertEquals(result, TagSupport.EVAL_BODY_AGAIN);
80 assertEquals(stack.peek(), "three");
81 assertEquals(stack.getContext().get("myId"), "three");
82
83
84
85 result = tag.doAfterBody();
86 assertEquals(result, TagSupport.EVAL_BODY_AGAIN);
87 assertEquals(stack.peek(), "four");
88 assertEquals(stack.getContext().get("myId"), "four");
89
90
91
92 result = tag.doAfterBody();
93 assertEquals(result, TagSupport.EVAL_BODY_AGAIN);
94 assertEquals(stack.peek(), "five");
95 assertEquals(stack.getContext().get("myId"), "five");
96
97
98 result = tag.doAfterBody();
99 assertEquals(result, TagSupport.SKIP_BODY);
100
101 result = tag.doEndTag();
102 assertEquals(result, TagSupport.EVAL_PAGE);
103 }
104
105
106 public void testArrayIterator() {
107 Foo foo = new Foo();
108 foo.setArray(new String[]{"test1", "test2", "test3"});
109
110 stack.push(foo);
111
112 tag.setValue("array");
113
114 iterateThreeStrings();
115 }
116
117 public void testCollectionIterator() {
118 Foo foo = new Foo();
119 ArrayList list = new ArrayList();
120 list.add("test1");
121 list.add("test2");
122 list.add("test3");
123 foo.setList(list);
124
125 stack.push(foo);
126
127 tag.setValue("list");
128
129 iterateThreeStrings();
130 }
131
132 public void testIteratorWithDefaultValue() {
133 stack.push(new String[]{"test1", "test2", "test3"});
134 iterateThreeStrings();
135 }
136
137 public void testMapIterator() {
138 Foo foo = new Foo();
139 HashMap map = new HashMap();
140 map.put("test1", "123");
141 map.put("test2", "456");
142 map.put("test3", "789");
143 foo.setMap(map);
144
145 stack.push(foo);
146
147 tag.setValue("map");
148
149 int result = 0;
150
151 try {
152 result = tag.doStartTag();
153 } catch (JspException e) {
154 e.printStackTrace();
155 fail();
156 }
157
158 assertEquals(TagSupport.EVAL_BODY_INCLUDE, result);
159 assertEquals(4, stack.size());
160 assertTrue(stack.getRoot().peek() instanceof Map.Entry);
161
162 try {
163 result = tag.doAfterBody();
164 } catch (JspException e) {
165 e.printStackTrace();
166 fail();
167 }
168
169 assertEquals(TagSupport.EVAL_BODY_AGAIN, result);
170 assertEquals(4, stack.size());
171 assertTrue(stack.getRoot().peek() instanceof Map.Entry);
172
173 try {
174 result = tag.doAfterBody();
175 } catch (JspException e) {
176 e.printStackTrace();
177 fail();
178 }
179
180 assertEquals(TagSupport.EVAL_BODY_AGAIN, result);
181 assertEquals(4, stack.size());
182 assertTrue(stack.getRoot().peek() instanceof Map.Entry);
183
184 try {
185 result = tag.doAfterBody();
186 } catch (JspException e) {
187 e.printStackTrace();
188 fail();
189 }
190
191 assertEquals(TagSupport.SKIP_BODY, result);
192 assertEquals(3, stack.size());
193 }
194
195 public void testStatus() {
196 Foo foo = new Foo();
197 foo.setArray(new String[]{"test1", "test2", "test3"});
198
199 stack.push(foo);
200
201 tag.setValue("array");
202 tag.setStatus("fooStatus");
203
204 int result = 0;
205
206 try {
207 result = tag.doStartTag();
208 } catch (JspException e) {
209 e.printStackTrace();
210 fail();
211 }
212
213 assertEquals(result, TagSupport.EVAL_BODY_INCLUDE);
214 assertEquals("test1", stack.getRoot().peek());
215 assertEquals(4, stack.size());
216
217 IteratorStatus status = (IteratorStatus) context.get("fooStatus");
218 assertNotNull(status);
219 assertFalse(status.isLast());
220 assertTrue(status.isFirst());
221 assertEquals(0, status.getIndex());
222 assertEquals(1, status.getCount());
223 assertTrue(status.isOdd());
224 assertFalse(status.isEven());
225
226 try {
227 result = tag.doAfterBody();
228 } catch (JspException e) {
229 e.printStackTrace();
230 fail();
231 }
232
233 assertEquals(result, TagSupport.EVAL_BODY_AGAIN);
234 assertEquals("test2", stack.getRoot().peek());
235 assertEquals(4, stack.size());
236
237 status = (IteratorStatus) context.get("fooStatus");
238 assertNotNull(status);
239 assertFalse(status.isLast());
240 assertFalse(status.isFirst());
241 assertEquals(1, status.getIndex());
242 assertEquals(2, status.getCount());
243 assertFalse(status.isOdd());
244 assertTrue(status.isEven());
245
246 try {
247 result = tag.doAfterBody();
248 } catch (JspException e) {
249 e.printStackTrace();
250 fail();
251 }
252
253 assertEquals(result, TagSupport.EVAL_BODY_AGAIN);
254 assertEquals("test3", stack.getRoot().peek());
255 assertEquals(4, stack.size());
256
257 status = (IteratorStatus) context.get("fooStatus");
258 assertNotNull(status);
259 assertTrue(status.isLast());
260 assertFalse(status.isFirst());
261 assertEquals(2, status.getIndex());
262 assertEquals(3, status.getCount());
263 assertTrue(status.isOdd());
264 assertFalse(status.isEven());
265 }
266
267 public void testEmptyArray() {
268 Foo foo = new Foo();
269 foo.setArray(new String[]{});
270
271 stack.push(foo);
272
273 tag.setValue("array");
274
275 validateSkipBody();
276 }
277
278 public void testNullArray() {
279 Foo foo = new Foo();
280 foo.setArray(null);
281
282 stack.push(foo);
283
284 tag.setValue("array");
285
286 validateSkipBody();
287 }
288
289 public void testEmptyCollection() {
290 Foo foo = new Foo();
291 foo.setList(new ArrayList());
292
293 stack.push(foo);
294
295 tag.setValue("list");
296
297 validateSkipBody();
298 }
299
300 public void testNullCollection() {
301 Foo foo = new Foo();
302 foo.setList(null);
303
304 stack.push(foo);
305
306 tag.setValue("list");
307
308 validateSkipBody();
309 }
310
311 protected void setUp() throws Exception {
312 super.setUp();
313
314
315 tag = new IteratorTag();
316
317 MockBodyContent mockBodyContent = new TestMockBodyContent();
318 mockBodyContent.setupGetEnclosingWriter(new MockJspWriter());
319 tag.setBodyContent(mockBodyContent);
320
321
322 tag.setPageContext(pageContext);
323 }
324
325 private void iterateThreeStrings() {
326 int result = 0;
327
328 try {
329 result = tag.doStartTag();
330 } catch (JspException e) {
331 e.printStackTrace();
332 fail();
333 }
334
335 assertEquals(result, TagSupport.EVAL_BODY_INCLUDE);
336 assertEquals("test1", stack.getRoot().peek());
337 assertEquals(4, stack.size());
338
339 try {
340 result = tag.doAfterBody();
341 } catch (JspException e) {
342 e.printStackTrace();
343 fail();
344 }
345
346 assertEquals(result, TagSupport.EVAL_BODY_AGAIN);
347 assertEquals("test2", stack.getRoot().peek());
348 assertEquals(4, stack.size());
349
350 try {
351 result = tag.doAfterBody();
352 } catch (JspException e) {
353 e.printStackTrace();
354 fail();
355 }
356
357 assertEquals(result, TagSupport.EVAL_BODY_AGAIN);
358 assertEquals("test3", stack.getRoot().peek());
359 assertEquals(4, stack.size());
360
361 try {
362 result = tag.doAfterBody();
363 } catch (JspException e) {
364 e.printStackTrace();
365 fail();
366 }
367
368 assertEquals(result, TagSupport.SKIP_BODY);
369 assertEquals(3, stack.size());
370 }
371
372 private void validateSkipBody() {
373 int result = 0;
374
375 try {
376 result = tag.doStartTag();
377 } catch (JspException e) {
378 e.printStackTrace();
379 fail();
380 }
381
382 assertEquals(result, TagSupport.SKIP_BODY);
383 try {
384 result = tag.doEndTag();
385 } catch (JspException e) {
386 e.printStackTrace();
387 fail();
388 }
389 }
390
391 class Foo {
392 private Collection list;
393 private Map map;
394 private String[] array;
395
396 public void setArray(String[] array) {
397 this.array = array;
398 }
399
400 public String[] getArray() {
401 return array;
402 }
403
404 public void setList(Collection list) {
405 this.list = list;
406 }
407
408 public Collection getList() {
409 return list;
410 }
411
412 public void setMap(Map map) {
413 this.map = map;
414 }
415
416 public Map getMap() {
417 return map;
418 }
419 }
420
421 class TestMockBodyContent extends MockBodyContent {
422 public String getString() {
423 return ".-.";
424 }
425 }
426 }