1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16 package org.seasar.cubby.action.impl;
17
18 import static org.easymock.EasyMock.anyBoolean;
19 import static org.easymock.EasyMock.createMock;
20 import static org.easymock.EasyMock.eq;
21 import static org.easymock.EasyMock.expect;
22 import static org.easymock.EasyMock.expectLastCall;
23 import static org.easymock.EasyMock.getCurrentArguments;
24 import static org.easymock.EasyMock.isA;
25 import static org.easymock.EasyMock.replay;
26 import static org.easymock.EasyMock.verify;
27 import static org.junit.Assert.assertEquals;
28 import static org.junit.Assert.assertFalse;
29 import static org.junit.Assert.assertTrue;
30
31 import java.util.HashMap;
32 import java.util.Map;
33 import java.util.concurrent.ConcurrentHashMap;
34
35 import javax.servlet.http.HttpServletRequest;
36 import javax.servlet.http.HttpSession;
37
38 import org.easymock.IAnswer;
39 import org.junit.Test;
40 import org.seasar.cubby.action.impl.FlashMapImpl;
41
42
43
44
45
46
47 public class FlashMapTest {
48
49 @Test
50 public void sequence1() {
51 final State state = new State();
52 state.hasSession = false;
53 sequence(state);
54 }
55
56 @Test
57 public void sequence2() {
58 final State state = new State();
59 state.hasSession = true;
60 sequence(state);
61 }
62
63 private void sequence(final State state) {
64 final Map<String, Object> mapInSession = new ConcurrentHashMap<String, Object>();
65 final HttpServletRequest request = createMock(HttpServletRequest.class);
66 final HttpSession session = createMock(HttpSession.class);
67 expect(request.getSession(anyBoolean())).andStubAnswer(
68 new IAnswer<HttpSession>() {
69
70 public HttpSession answer() throws Throwable {
71 boolean create = (Boolean) getCurrentArguments()[0];
72 if (state.hasSession || create) {
73 state.hasSession = true;
74 return session;
75 }
76 return null;
77 }
78
79 });
80 expect(request.getSession()).andStubAnswer(new IAnswer<HttpSession>() {
81
82 public HttpSession answer() throws Throwable {
83 return request.getSession(true);
84 }
85
86 });
87 expect(session.getAttribute(FlashMapImpl.class.getName() + ".MAP"))
88 .andStubReturn(mapInSession);
89 session.setAttribute(eq(FlashMapImpl.class.getName() + ".MAP"),
90 isA(Map.class));
91 expectLastCall().andAnswer(new IAnswer<Object>() {
92
93 @SuppressWarnings("unchecked")
94 public Object answer() throws Throwable {
95 Map<String, Object> m = (Map<String, Object>) getCurrentArguments()[1];
96 assertEquals("abcde", m.get("value1"));
97 return null;
98 }
99
100 });
101 expectLastCall().andAnswer(new IAnswer<Object>() {
102
103 @SuppressWarnings("unchecked")
104 public Object answer() throws Throwable {
105 Map<String, Object> m = (Map<String, Object>) getCurrentArguments()[1];
106 assertEquals("abcde", m.get("value1"));
107 assertEquals("fghij", m.get("value2"));
108 return null;
109 }
110
111 });
112 expectLastCall().andAnswer(new IAnswer<Object>() {
113
114 @SuppressWarnings("unchecked")
115 public Object answer() throws Throwable {
116 Map<String, Object> m = (Map<String, Object>) getCurrentArguments()[1];
117 assertEquals("abcde", m.get("value1"));
118 return null;
119 }
120
121 });
122 expectLastCall().andAnswer(new IAnswer<Object>() {
123
124 @SuppressWarnings("unchecked")
125 public Object answer() throws Throwable {
126 Map<String, Object> m = (Map<String, Object>) getCurrentArguments()[1];
127 assertTrue(m.isEmpty());
128 return null;
129 }
130
131 });
132 replay(request, session);
133
134 Map<String, Object> map = new FlashMapImpl(request);
135 assertEquals(0, map.size());
136 assertTrue(map.isEmpty());
137 assertTrue(map.keySet().isEmpty());
138 assertTrue(map.values().isEmpty());
139 assertTrue(map.entrySet().isEmpty());
140
141 map.put("value1", "abcde");
142 Map<String, Object> child = new HashMap<String, Object>();
143 child.put("value2", "fghij");
144 map.putAll(child);
145
146 assertEquals(2, map.size());
147 assertFalse(map.isEmpty());
148 assertFalse(map.keySet().isEmpty());
149 assertFalse(map.values().isEmpty());
150 assertFalse(map.entrySet().isEmpty());
151 assertTrue(map.containsKey("value1"));
152 assertTrue(map.containsKey("value2"));
153 assertTrue(map.containsValue("abcde"));
154 assertTrue(map.containsValue("fghij"));
155 assertEquals("abcde", map.get("value1"));
156 assertEquals("fghij", map.get("value2"));
157
158 map.remove("value2");
159
160 assertEquals(1, map.size());
161 assertFalse(map.isEmpty());
162 assertFalse(map.keySet().isEmpty());
163 assertFalse(map.values().isEmpty());
164 assertFalse(map.entrySet().isEmpty());
165 assertTrue(map.containsKey("value1"));
166 assertFalse(map.containsKey("value2"));
167 assertTrue(map.containsValue("abcde"));
168 assertFalse(map.containsValue("fghij"));
169 assertEquals("abcde", map.get("value1"));
170
171 map.clear();
172
173 assertEquals(0, map.size());
174 assertTrue(map.isEmpty());
175 assertTrue(map.keySet().isEmpty());
176 assertTrue(map.values().isEmpty());
177 assertTrue(map.entrySet().isEmpty());
178
179 verify(request, session);
180 }
181
182 private static class State {
183 public boolean hasSession;
184 }
185
186 }