Download as
Browse Code »

Commit d9ae974360c4e326d274173d9ce9cad8fbb55fc3

Authored by Ednara Oliveira
1 parent d76ee5a9
Exists in master

Refatoração de teste unitário: ParamenterImplTest

Showing 1 changed file with 371 additions and 325 deletions   Show diff stats
impl/extension/jsf/src/test/java/br/gov/frameworkdemoiselle/internal/implementation/ParameterImplTest.java
  Diff comments   View file @d9ae974
1 -///*  
2 -// * Demoiselle Framework  
3 -// * Copyright (C) 2010 SERPRO  
4 -// * ----------------------------------------------------------------------------  
5 -// * This file is part of Demoiselle Framework.  
6 -// *  
7 -// * Demoiselle Framework is free software; you can redistribute it and/or  
8 -// * modify it under the terms of the GNU Lesser General Public License version 3  
9 -// * as published by the Free Software Foundation.  
10 -// *  
11 -// * This program is distributed in the hope that it will be useful,  
12 -// * but WITHOUT ANY WARRANTY; without even the implied warranty of  
13 -// * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the  
14 -// * GNU General Public License for more details.  
15 -// *  
16 -// * You should have received a copy of the GNU Lesser General Public License version 3  
17 -// * along with this program; if not, see <http://www.gnu.org/licenses/>  
18 -// * or write to the Free Software Foundation, Inc., 51 Franklin Street,  
19 -// * Fifth Floor, Boston, MA 02110-1301, USA.  
20 -// * ----------------------------------------------------------------------------  
21 -// * Este arquivo é parte do Framework Demoiselle.  
22 -// *  
23 -// * O Framework Demoiselle é um software livre; você pode redistribuí-lo e/ou  
24 -// * modificá-lo dentro dos termos da GNU LGPL versão 3 como publicada pela Fundação  
25 -// * do Software Livre (FSF).  
26 -// *  
27 -// * Este programa é distribuído na esperança que possa ser útil, mas SEM NENHUMA  
28 -// * GARANTIA; sem uma garantia implícita de ADEQUAÇÃO a qualquer MERCADO ou  
29 -// * APLICAÇÃO EM PARTICULAR. Veja a Licença Pública Geral GNU/LGPL em português  
30 -// * para maiores detalhes.  
31 -// *  
32 -// * Você deve ter recebido uma cópia da GNU LGPL versão 3, sob o título  
33 -// * "LICENCA.txt", junto com esse programa. Se não, acesse <http://www.gnu.org/licenses/>  
34 -// * ou escreva para a Fundação do Software Livre (FSF) Inc.,  
35 -// * 51 Franklin St, Fifth Floor, Boston, MA 02111-1301, USA.  
36 -// */  
37 -//package br.gov.frameworkdemoiselle.internal.implementation;  
38 -//  
39 -//import static org.easymock.EasyMock.expect;  
40 -//import static org.junit.Assert.assertEquals;  
41 -//import static org.powermock.api.easymock.PowerMock.createMock;  
42 -//import static org.powermock.api.easymock.PowerMock.mockStatic;  
43 -//import static org.powermock.api.easymock.PowerMock.replayAll;  
44 -//import static org.powermock.api.easymock.PowerMock.verifyAll;  
45 -//  
46 -//import java.lang.reflect.Member;  
47 -//import java.util.HashMap;  
48 -//import java.util.Map;  
49 -//  
50 -//import javax.enterprise.context.RequestScoped;  
51 -//import javax.enterprise.context.SessionScoped;  
52 -//import javax.enterprise.inject.spi.Annotated;  
53 -//import javax.enterprise.inject.spi.InjectionPoint;  
54 -//import javax.faces.convert.Converter;  
55 -//import javax.servlet.http.HttpServletRequest;  
56 -//import javax.servlet.http.HttpSession;  
57 -//  
58 -//import org.easymock.EasyMock;  
59 -//import org.junit.Before;  
60 -//import org.junit.Test;  
61 -//import org.junit.runner.RunWith;  
62 -//import org.powermock.core.classloader.annotations.PrepareForTest;  
63 -//import org.powermock.modules.junit4.PowerMockRunner;  
64 -//import org.powermock.reflect.Whitebox;  
65 -//  
66 -//import br.gov.frameworkdemoiselle.annotation.Name;  
67 -//import br.gov.frameworkdemoiselle.annotation.ViewScoped;  
68 -//import br.gov.frameworkdemoiselle.util.Faces;  
69 -//import br.gov.frameworkdemoiselle.util.Reflections;  
70 -//  
71 -//@RunWith(PowerMockRunner.class)  
72 -//@PrepareForTest({ Reflections.class, Faces.class })  
73 -//public class ParameterImplTest {  
74 -//  
75 -// private ParameterImpl<Long> param;  
76 -//  
77 -// private HttpServletRequest request;  
78 -//  
79 -// private InjectionPoint ip;  
80 -//  
81 -// private Converter converter;  
82 -//  
83 -// private Annotated annotated;  
84 -//  
85 -// private Name name;  
86 -//  
87 -// private HttpSession session;  
88 -//  
89 -// private Member member;  
90 -//  
91 -// @Before  
92 -// public void before() {  
93 -// ip = createMock(InjectionPoint.class);  
94 -// request = createMock(HttpServletRequest.class);  
95 -// session = createMock(HttpSession.class);  
96 -// annotated = createMock(Annotated.class);  
97 -// name = createMock(Name.class);  
98 -// converter = createMock(Converter.class);  
99 -// member = createMock(Member.class);  
100 -//  
101 -// mockStatic(Reflections.class);  
102 -// mockStatic(Faces.class);  
103 -// }  
104 -//  
105 -// private void prepareForTestWithKeyFromNameAnnotation() {  
106 -// expect(ip.getAnnotated()).andReturn(annotated).anyTimes();  
107 -// expect(ip.getMember()).andReturn(null);  
108 -// expect(annotated.isAnnotationPresent(Name.class)).andReturn(true);  
109 -// expect(annotated.getAnnotation(Name.class)).andReturn(name);  
110 -// expect(name.value()).andReturn("name");  
111 -// expect(Reflections.getGenericTypeArgument(EasyMock.anyObject(Member.class), EasyMock.anyInt())).andReturn(  
112 -// Object.class);  
113 -// expect(Faces.getConverter(EasyMock.anyObject(Class.class))).andReturn(converter);  
114 -// }  
115 -//  
116 -// @Test  
117 -// public void testConstructorCase1() {  
118 -// this.prepareForTestWithKeyFromNameAnnotation();  
119 -//  
120 -// replayAll();  
121 -// param = new ParameterImpl<Long>(ip, request);  
122 -// assertEquals("name", param.getKey());  
123 -// assertEquals(Object.class, Whitebox.getInternalState(param, "type"));  
124 -// assertEquals(converter, param.getConverter());  
125 -// verifyAll();  
126 -// }  
127 -//  
128 -// @Test  
129 -// public void testConstructorCase2() {  
130 -// expect(member.getName()).andReturn("memberName");  
131 -// expect(ip.getAnnotated()).andReturn(annotated).anyTimes();  
132 -// expect(ip.getMember()).andReturn(member).anyTimes();  
133 -// expect(annotated.isAnnotationPresent(Name.class)).andReturn(false);  
134 -// expect(Reflections.getGenericTypeArgument(EasyMock.anyObject(Member.class), EasyMock.anyInt())).andReturn(  
135 -// Object.class);  
136 -// expect(Faces.getConverter(EasyMock.anyObject(Class.class))).andReturn(converter);  
137 -//  
138 -// replayAll();  
139 -// param = new ParameterImpl<Long>(ip, request);  
140 -// assertEquals("memberName", param.getKey());  
141 -// assertEquals(Object.class, Whitebox.getInternalState(param, "type"));  
142 -// assertEquals(converter, param.getConverter());  
143 -// verifyAll();  
144 -// }  
145 -//  
146 -// @Test  
147 -// public void testGetValueWhenSessionScopedAndParameterValueNotNull() {  
148 -// this.prepareForTestWithKeyFromNameAnnotation();  
149 -//  
150 -// expect(Faces.convert("1", converter)).andReturn("return");  
151 -// expect(request.getSession()).andReturn(session).anyTimes();  
152 -// expect(request.getParameter(EasyMock.anyObject(String.class))).andReturn("1");  
153 -// expect(annotated.isAnnotationPresent(SessionScoped.class)).andReturn(true);  
154 -// expect(session.getAttribute("name")).andReturn("return");  
155 -//  
156 -// session.setAttribute("name", "return");  
157 -//  
158 -// replayAll();  
159 -// param = new ParameterImpl<Long>(ip, request);  
160 -// assertEquals("return", param.getValue());  
161 -// verifyAll();  
162 -// }  
163 -//  
164 -// @Test  
165 -// public void testGetValueWhenSessionScopedAndParameterValueNull() {  
166 -// this.prepareForTestWithKeyFromNameAnnotation();  
167 -//  
168 -// expect(request.getSession()).andReturn(session).anyTimes();  
169 -// expect(request.getParameter(EasyMock.anyObject(String.class))).andReturn(null);  
170 -// expect(annotated.isAnnotationPresent(SessionScoped.class)).andReturn(true);  
171 -// expect(session.getAttribute("name")).andReturn("return");  
172 -//  
173 -// replayAll();  
174 -// param = new ParameterImpl<Long>(ip, request);  
175 -// assertEquals("return", param.getValue());  
176 -// verifyAll();  
177 -// }  
178 -//  
179 -// @Test  
180 -// public void testGetValueWhenRequestScoped() {  
181 -// this.prepareForTestWithKeyFromNameAnnotation();  
182 -//  
183 -// expect(annotated.isAnnotationPresent(SessionScoped.class)).andReturn(false);  
184 -// expect(annotated.isAnnotationPresent(RequestScoped.class)).andReturn(true);  
185 -// expect(request.getParameter(EasyMock.anyObject(String.class))).andReturn("1");  
186 -// expect(Faces.convert("1", converter)).andReturn("return");  
187 -//  
188 -// replayAll();  
189 -// param = new ParameterImpl<Long>(ip, request);  
190 -// assertEquals("return", param.getValue());  
191 -// verifyAll();  
192 -// }  
193 -//  
194 -// @Test  
195 -// public void testGetValueWhenViewScopedWithParamValueNotNull() {  
196 -// this.prepareForTestWithKeyFromNameAnnotation();  
197 -// Map<String, Object> map = new HashMap<String,Object>();  
198 -//  
199 -// expect(annotated.isAnnotationPresent(SessionScoped.class)).andReturn(false);  
200 -// expect(annotated.isAnnotationPresent(RequestScoped.class)).andReturn(false);  
201 -// expect(annotated.isAnnotationPresent(ViewScoped.class)).andReturn(true);  
202 -// expect(request.getParameter(EasyMock.anyObject(String.class))).andReturn("1");  
203 -// expect(Faces.getViewMap()).andReturn(map);  
204 -// expect(Faces.convert("1", converter)).andReturn("return");  
205 -//  
206 -// replayAll();  
207 -// param = new ParameterImpl<Long>(ip, request);  
208 -// assertEquals("return", param.getValue());  
209 -// assertEquals("return", map.get("name"));  
210 -// verifyAll();  
211 -// }  
212 -//  
213 -// @Test  
214 -// public void testGetValueWhenViewScopedWithParamValueNull() {  
215 -// this.prepareForTestWithKeyFromNameAnnotation();  
216 -// Map<String, Object> map = new HashMap<String,Object>();  
217 -// map.put("name", "ops");  
218 -//  
219 -// expect(annotated.isAnnotationPresent(SessionScoped.class)).andReturn(false);  
220 -// expect(annotated.isAnnotationPresent(RequestScoped.class)).andReturn(false);  
221 -// expect(annotated.isAnnotationPresent(ViewScoped.class)).andReturn(true);  
222 -// expect(request.getParameter(EasyMock.anyObject(String.class))).andReturn(null);  
223 -// expect(Faces.getViewMap()).andReturn(map);  
224 -//  
225 -// replayAll();  
226 -// param = new ParameterImpl<Long>(ip, request);  
227 -// assertEquals("ops", param.getValue());  
228 -// assertEquals("ops", map.get("name"));  
229 -// verifyAll();  
230 -// }  
231 -//  
232 -// @Test  
233 -// public void testGetValueElseWithValueNull() {  
234 -// this.prepareForTestWithKeyFromNameAnnotation();  
235 -//  
236 -// expect(annotated.isAnnotationPresent(SessionScoped.class)).andReturn(false);  
237 -// expect(annotated.isAnnotationPresent(RequestScoped.class)).andReturn(false);  
238 -// expect(annotated.isAnnotationPresent(ViewScoped.class)).andReturn(false);  
239 -// expect(request.getParameter(EasyMock.anyObject(String.class))).andReturn("1");  
240 -// expect(Faces.convert("1", converter)).andReturn("return");  
241 -//  
242 -// replayAll();  
243 -// param = new ParameterImpl<Long>(ip, request);  
244 -// assertEquals("return", param.getValue());  
245 -// verifyAll();  
246 -// }  
247 -//  
248 -// @Test  
249 -// public void testGetValueElseWithValueNotNull() {  
250 -// this.prepareForTestWithKeyFromNameAnnotation();  
251 -//  
252 -// expect(annotated.isAnnotationPresent(SessionScoped.class)).andReturn(false);  
253 -// expect(annotated.isAnnotationPresent(RequestScoped.class)).andReturn(false);  
254 -// expect(annotated.isAnnotationPresent(ViewScoped.class)).andReturn(false);  
255 -// expect(request.getParameter(EasyMock.anyObject(String.class))).andReturn("1");  
256 -//  
257 -// replayAll();  
258 -// param = new ParameterImpl<Long>(ip, request);  
259 -// Whitebox.setInternalState(param, "value", "myvalue");  
260 -// assertEquals("myvalue", param.getValue());  
261 -// verifyAll();  
262 -// }  
263 -//  
264 -// @Test  
265 -// public void testSetValueIsSessionScoped() {  
266 -// this.prepareForTestWithKeyFromNameAnnotation();  
267 -//  
268 -// expect(annotated.isAnnotationPresent(SessionScoped.class)).andReturn(true);  
269 -// expect(request.getSession()).andReturn(session);  
270 -//  
271 -// session.setAttribute("name", 1L);  
272 -//  
273 -// replayAll();  
274 -// param = new ParameterImpl<Long>(ip, request);  
275 -// param.setValue(1L);  
276 -// verifyAll();  
277 -// }  
278 -//  
279 -// @Test  
280 -// public void testSetValueIsViewScoped() {  
281 -// this.prepareForTestWithKeyFromNameAnnotation();  
282 -//  
283 -// Map<String, Object> map = new HashMap<String, Object>();  
284 -//  
285 -// expect(annotated.isAnnotationPresent(SessionScoped.class)).andReturn(false);  
286 -// expect(annotated.isAnnotationPresent(RequestScoped.class)).andReturn(false);  
287 -// expect(annotated.isAnnotationPresent(ViewScoped.class)).andReturn(true);  
288 -// expect(Faces.getViewMap()).andReturn(map);  
289 -//  
290 -// replayAll();  
291 -// param = new ParameterImpl<Long>(ip, request);  
292 -// param.setValue(1L);  
293 -// assertEquals(1L, map.get("name"));  
294 -// verifyAll();  
295 -// }  
296 -//  
297 -// @Test  
298 -// public void testSetValueElse() {  
299 -// this.prepareForTestWithKeyFromNameAnnotation();  
300 -//  
301 -// expect(annotated.isAnnotationPresent(SessionScoped.class)).andReturn(false);  
302 -// expect(annotated.isAnnotationPresent(RequestScoped.class)).andReturn(false);  
303 -// expect(annotated.isAnnotationPresent(ViewScoped.class)).andReturn(false);  
304 -//  
305 -// replayAll();  
306 -// param = new ParameterImpl<Long>(ip, request);  
307 -// param.setValue(1L);  
308 -// assertEquals(1L, Whitebox.getInternalState(param, "value"));  
309 -// verifyAll();  
310 -// }  
311 -//  
312 -// @Test  
313 -// public void testOthers() {  
314 -// this.prepareForTestWithKeyFromNameAnnotation();  
315 -//  
316 -// expect(annotated.isAnnotationPresent(SessionScoped.class)).andReturn(false);  
317 -// expect(annotated.isAnnotationPresent(RequestScoped.class)).andReturn(true);  
318 -//  
319 -// replayAll();  
320 -// param = new ParameterImpl<Long>(ip, request);  
321 -// param.setValue(1L);  
322 -// verifyAll();  
323 -// }  
324 -//  
325 -//} 1 +/*
  2 + * Demoiselle Framework
  3 + * Copyright (C) 2010 SERPRO
  4 + * ----------------------------------------------------------------------------
  5 + * This file is part of Demoiselle Framework.
  6 + *
  7 + * Demoiselle Framework is free software; you can redistribute it and/or
  8 + * modify it under the terms of the GNU Lesser General Public License version 3
  9 + * as published by the Free Software Foundation.
  10 + *
  11 + * This program is distributed in the hope that it will be useful,
  12 + * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13 + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPaOSE. See the
  14 + * GNU General Public License for more details.
  15 + *
  16 + * You should have received a copy of the GNU Lesser General Public License version 3
  17 + * along with this program; if not, see <http://www.gnu.org/licenses/>
  18 + * or write to the Free Software Foundation, Inc., 51 Franklin Street,
  19 + * Fifth Floor, Boston, MA 02110-1301, USA.
  20 + * ----------------------------------------------------------------------------
  21 + * Este arquivo é parte do Framework Demoiselle.
  22 + *
  23 + * O Framework Demoiselle é um software livre; você pode redistribuí-lo e/ou
  24 + * modificá-lo dentro dos termos da GNU LGPL versão 3 como publicada pela Fundação
  25 + * do Software Livre (FSF).
  26 + *
  27 + * Este programa é distribuído na esperança que possa ser útil, mas SEM NENHUMA
  28 + * GARANTIA; sem uma garantia implícita de ADEQUAÇÃO a qualquer MERCADO ou
  29 + * APLICAÇÃO EM PARTICULAR. Veja a Licença Pública Geral GNU/LGPL em português
  30 + * para maiores detalhes.
  31 + *
  32 + * Você deve ter recebido uma cópia da GNU LGPL versão 3, sob o título
  33 + * "LICENCA.txt", junto com esse programa. Se não, acesse <http://www.gnu.org/licenses/>
  34 + * ou escreva para a Fundação do Software Livre (FSF) Inc.,
  35 + * 51 Franklin St, Fifth Floor, Boston, MA 02111-1301, USA.
  36 + */
  37 +package br.gov.frameworkdemoiselle.internal.implementation;
  38 +
  39 +import static org.easymock.EasyMock.expect;
  40 +import static org.junit.Assert.assertEquals;
  41 +import static org.powermock.api.easymock.PowerMock.createMock;
  42 +import static org.powermock.api.easymock.PowerMock.mockStatic;
  43 +import static org.powermock.api.easymock.PowerMock.replayAll;
  44 +import static org.powermock.api.easymock.PowerMock.verifyAll;
  45 +
  46 +import java.lang.reflect.Member;
  47 +import java.util.HashMap;
  48 +import java.util.Map;
  49 +
  50 +import javax.enterprise.context.RequestScoped;
  51 +import javax.enterprise.context.SessionScoped;
  52 +import javax.enterprise.inject.spi.Annotated;
  53 +import javax.enterprise.inject.spi.InjectionPoint;
  54 +import javax.faces.convert.Converter;
  55 +import javax.servlet.http.HttpServletRequest;
  56 +import javax.servlet.http.HttpSession;
  57 +import javax.swing.text.View;
  58 +
  59 +import org.easymock.EasyMock;
  60 +import org.junit.Before;
  61 +import org.junit.Test;
  62 +import org.junit.runner.RunWith;
  63 +import org.powermock.core.classloader.annotations.PrepareForTest;
  64 +import org.powermock.modules.junit4.PowerMockRunner;
  65 +import org.powermock.reflect.Whitebox;
  66 +
  67 +import br.gov.frameworkdemoiselle.annotation.Name;
  68 +import br.gov.frameworkdemoiselle.annotation.ViewScoped;
  69 +import br.gov.frameworkdemoiselle.util.Beans;
  70 +import br.gov.frameworkdemoiselle.util.Faces;
  71 +import br.gov.frameworkdemoiselle.util.Reflections;
  72 +
  73 +@RunWith(PowerMockRunner.class)
  74 +@PrepareForTest({ Reflections.class, Faces.class, Beans.class })
  75 +public class ParameterImplTest {
  76 +
  77 + private ParameterImpl<Long> param;
  78 +
  79 + private HttpServletRequest request;
  80 +
  81 + private InjectionPoint ip;
  82 +
  83 + private Converter converter;
  84 +
  85 + private Annotated annotated;
  86 +
  87 + private Name name;
  88 +
  89 + private HttpSession session;
  90 +
  91 + private Member member;
  92 +
  93 + @Before
  94 + public void before() {
  95 + ip = createMock(InjectionPoint.class);
  96 + request = createMock(HttpServletRequest.class);
  97 + session = createMock(HttpSession.class);
  98 + annotated = createMock(Annotated.class);
  99 + name = createMock(Name.class);
  100 + converter = createMock(Converter.class);
  101 + member = createMock(Member.class);
  102 +
  103 + mockStatic(Reflections.class);
  104 + mockStatic(Faces.class);
  105 + }
  106 +
  107 + private void prepareForTestWithKeyFromNameAnnotation() {
  108 + expect(ip.getAnnotated()).andReturn(annotated).anyTimes();
  109 + expect(ip.getMember()).andReturn(null);
  110 + expect(annotated.isAnnotationPresent(Name.class)).andReturn(true);
  111 + expect(annotated.getAnnotation(Name.class)).andReturn(name);
  112 + expect(name.value()).andReturn("name");
  113 + expect(Reflections.getGenericTypeArgument(EasyMock.anyObject(Member.class), EasyMock.anyInt())).andReturn(
  114 + Object.class);
  115 + }
  116 +
  117 + @Test
  118 + public void testConstructorCase1() {
  119 + this.prepareForTestWithKeyFromNameAnnotation();
  120 + expect(Faces.getConverter(EasyMock.anyObject(Class.class))).andReturn(converter);
  121 + expect(annotated.isAnnotationPresent(ViewScoped.class)).andReturn(true);
  122 + expect(annotated.isAnnotationPresent(RequestScoped.class)).andReturn(true);
  123 + expect(annotated.isAnnotationPresent(SessionScoped.class)).andReturn(true);
  124 +
  125 + replayAll();
  126 + param = new ParameterImpl<Long>(ip);
  127 + assertEquals("name", param.getKey());
  128 + assertEquals(Object.class, Whitebox.getInternalState(param, "type"));
  129 + assertEquals(converter, param.getConverter());
  130 + verifyAll();
  131 + }
  132 +
  133 + @Test
  134 + public void testConstructorCase2() {
  135 + expect(member.getName()).andReturn("memberName");
  136 + expect(ip.getAnnotated()).andReturn(annotated).anyTimes();
  137 + expect(ip.getMember()).andReturn(member).anyTimes();
  138 + expect(annotated.isAnnotationPresent(Name.class)).andReturn(false);
  139 + expect(annotated.isAnnotationPresent(ViewScoped.class)).andReturn(true);
  140 + expect(annotated.isAnnotationPresent(RequestScoped.class)).andReturn(true);
  141 + expect(annotated.isAnnotationPresent(SessionScoped.class)).andReturn(true);
  142 + expect(Reflections.getGenericTypeArgument(EasyMock.anyObject(Member.class), EasyMock.anyInt())).andReturn(
  143 + Object.class);
  144 + expect(Faces.getConverter(EasyMock.anyObject(Class.class))).andReturn(converter);
  145 +
  146 + replayAll();
  147 + param = new ParameterImpl<Long>(ip);
  148 + assertEquals("memberName", param.getKey());
  149 + assertEquals(Object.class, Whitebox.getInternalState(param, "type"));
  150 + assertEquals(converter, param.getConverter());
  151 + verifyAll();
  152 + }
  153 +
  154 + @Test
  155 + public void testGetValueWhenSessionScopedAndParameterValueNotNull() {
  156 + this.prepareForTestWithKeyFromNameAnnotation();
  157 + expect(Faces.getConverter(EasyMock.anyObject(Class.class))).andReturn(converter);
  158 +
  159 + mockStatic(Beans.class);
  160 + expect(Beans.getReference(HttpServletRequest.class)).andReturn(request).anyTimes();
  161 +
  162 + expect(Faces.convert("1", converter)).andReturn("return");
  163 + expect(request.getSession()).andReturn(session).anyTimes();
  164 + expect(request.getParameter(EasyMock.anyObject(String.class))).andReturn("1");
  165 + expect(annotated.isAnnotationPresent(SessionScoped.class)).andReturn(true);
  166 + expect(annotated.isAnnotationPresent(ViewScoped.class)).andReturn(false);
  167 + expect(annotated.isAnnotationPresent(RequestScoped.class)).andReturn(false);
  168 +
  169 + expect(session.getAttribute("name")).andReturn("return");
  170 +
  171 + session.setAttribute("name", "return");
  172 +
  173 + replayAll();
  174 + param = new ParameterImpl<Long>(ip);
  175 + assertEquals("return", param.getValue());
  176 + verifyAll();
  177 + }
  178 +
  179 + @Test
  180 + public void testGetValueWhenSessionScopedAndParameterValueNull() {
  181 + this.prepareForTestWithKeyFromNameAnnotation();
  182 +
  183 + mockStatic(Beans.class);
  184 + expect(Beans.getReference(HttpServletRequest.class)).andReturn(request).anyTimes();
  185 +
  186 + expect(request.getSession()).andReturn(session).anyTimes();
  187 + expect(request.getParameter(EasyMock.anyObject(String.class))).andReturn(null);
  188 + expect(annotated.isAnnotationPresent(SessionScoped.class)).andReturn(true);
  189 + expect(annotated.isAnnotationPresent(RequestScoped.class)).andReturn(false);
  190 + expect(annotated.isAnnotationPresent(ViewScoped.class)).andReturn(false);
  191 + expect(session.getAttribute("name")).andReturn("return");
  192 +
  193 + replayAll();
  194 + param = new ParameterImpl<Long>(ip);
  195 + assertEquals("return", param.getValue());
  196 + verifyAll();
  197 + }
  198 +
  199 + @Test
  200 + public void testGetValueWhenRequestScoped() {
  201 + this.prepareForTestWithKeyFromNameAnnotation();
  202 + expect(Faces.getConverter(EasyMock.anyObject(Class.class))).andReturn(converter);
  203 +
  204 + mockStatic(Beans.class);
  205 + expect(Beans.getReference(HttpServletRequest.class)).andReturn(request).anyTimes();
  206 +
  207 + expect(annotated.isAnnotationPresent(SessionScoped.class)).andReturn(false);
  208 + expect(annotated.isAnnotationPresent(RequestScoped.class)).andReturn(true);
  209 + expect(annotated.isAnnotationPresent(ViewScoped.class)).andReturn(false);
  210 + expect(request.getParameter(EasyMock.anyObject(String.class))).andReturn("1");
  211 + expect(request.getSession()).andReturn(session).anyTimes();
  212 + expect(Faces.convert("1", converter)).andReturn("return");
  213 +
  214 + replayAll();
  215 + param = new ParameterImpl<Long>(ip);
  216 + assertEquals("return", param.getValue());
  217 + verifyAll();
  218 + }
  219 +
  220 + @Test
  221 + public void testGetValueWhenViewScopedWithParamValueNotNull() {
  222 + this.prepareForTestWithKeyFromNameAnnotation();
  223 + expect(Faces.getConverter(EasyMock.anyObject(Class.class))).andReturn(converter);
  224 + Map<String, Object> map = new HashMap<String,Object>();
  225 +
  226 + mockStatic(Beans.class);
  227 + expect(Beans.getReference(HttpServletRequest.class)).andReturn(request).anyTimes();
  228 +
  229 + expect(annotated.isAnnotationPresent(SessionScoped.class)).andReturn(false);
  230 + expect(annotated.isAnnotationPresent(RequestScoped.class)).andReturn(false);
  231 + expect(annotated.isAnnotationPresent(ViewScoped.class)).andReturn(true);
  232 + expect(request.getParameter(EasyMock.anyObject(String.class))).andReturn("1");
  233 + expect(Faces.getViewMap()).andReturn(map);
  234 + expect(Faces.convert("1", converter)).andReturn("return");
  235 +
  236 + replayAll();
  237 + param = new ParameterImpl<Long>(ip);
  238 + assertEquals("return", param.getValue());
  239 + assertEquals("return", map.get("name"));
  240 + verifyAll();
  241 + }
  242 +
  243 + @Test
  244 + public void testGetValueWhenViewScopedWithParamValueNull() {
  245 + this.prepareForTestWithKeyFromNameAnnotation();
  246 + Map<String, Object> map = new HashMap<String,Object>();
  247 + map.put("name", "ops");
  248 +
  249 + mockStatic(Beans.class);
  250 + expect(Beans.getReference(HttpServletRequest.class)).andReturn(request).anyTimes();
  251 +
  252 + expect(annotated.isAnnotationPresent(SessionScoped.class)).andReturn(false);
  253 + expect(annotated.isAnnotationPresent(RequestScoped.class)).andReturn(false);
  254 + expect(annotated.isAnnotationPresent(ViewScoped.class)).andReturn(true);
  255 + expect(request.getParameter(EasyMock.anyObject(String.class))).andReturn(null);
  256 + expect(Faces.getViewMap()).andReturn(map);
  257 +
  258 + replayAll();
  259 + param = new ParameterImpl<Long>(ip);
  260 + assertEquals("ops", param.getValue());
  261 + assertEquals("ops", map.get("name"));
  262 + verifyAll();
  263 + }
  264 +
  265 + @Test
  266 + public void testGetValueElseWithValueNull() {
  267 + this.prepareForTestWithKeyFromNameAnnotation();
  268 + expect(Faces.getConverter(EasyMock.anyObject(Class.class))).andReturn(converter);
  269 +
  270 + mockStatic(Beans.class);
  271 + expect(Beans.getReference(HttpServletRequest.class)).andReturn(request).anyTimes();
  272 +
  273 + expect(annotated.isAnnotationPresent(SessionScoped.class)).andReturn(false);
  274 + expect(annotated.isAnnotationPresent(RequestScoped.class)).andReturn(false);
  275 + expect(annotated.isAnnotationPresent(ViewScoped.class)).andReturn(false);
  276 + expect(request.getParameter(EasyMock.anyObject(String.class))).andReturn("1");
  277 + expect(Faces.convert("1", converter)).andReturn("return");
  278 +
  279 + replayAll();
  280 + param = new ParameterImpl<Long>(ip);
  281 + assertEquals("return", param.getValue());
  282 + verifyAll();
  283 + }
  284 +
  285 + @Test
  286 + public void testGetValueElseWithValueNotNull() {
  287 + this.prepareForTestWithKeyFromNameAnnotation();
  288 +
  289 + mockStatic(Beans.class);
  290 + expect(Beans.getReference(HttpServletRequest.class)).andReturn(request).anyTimes();
  291 +
  292 + expect(annotated.isAnnotationPresent(SessionScoped.class)).andReturn(false);
  293 + expect(annotated.isAnnotationPresent(RequestScoped.class)).andReturn(false);
  294 + expect(annotated.isAnnotationPresent(ViewScoped.class)).andReturn(false);
  295 + expect(request.getParameter(EasyMock.anyObject(String.class))).andReturn("1");
  296 +
  297 + replayAll();
  298 + param = new ParameterImpl<Long>(ip);
  299 + Whitebox.setInternalState(param, "value", "myvalue");
  300 + assertEquals("myvalue", param.getValue());
  301 + verifyAll();
  302 + }
  303 +
  304 + @Test
  305 + public void testSetValueIsSessionScoped() {
  306 + this.prepareForTestWithKeyFromNameAnnotation();
  307 +
  308 + mockStatic(Beans.class);
  309 + expect(Beans.getReference(HttpServletRequest.class)).andReturn(request).anyTimes();
  310 +
  311 + expect(annotated.isAnnotationPresent(SessionScoped.class)).andReturn(true);
  312 + expect(annotated.isAnnotationPresent(RequestScoped.class)).andReturn(false);
  313 + expect(annotated.isAnnotationPresent(ViewScoped.class)).andReturn(false);
  314 + expect(request.getSession()).andReturn(session);
  315 +
  316 + session.setAttribute("name", 1L);
  317 +
  318 + replayAll();
  319 + param = new ParameterImpl<Long>(ip);
  320 + param.setValue(1L);
  321 + verifyAll();
  322 + }
  323 +
  324 + @Test
  325 + public void testSetValueIsViewScoped() {
  326 + this.prepareForTestWithKeyFromNameAnnotation();
  327 +
  328 + Map<String, Object> map = new HashMap<String, Object>();
  329 +
  330 + expect(annotated.isAnnotationPresent(SessionScoped.class)).andReturn(false);
  331 + expect(annotated.isAnnotationPresent(RequestScoped.class)).andReturn(false);
  332 + expect(annotated.isAnnotationPresent(ViewScoped.class)).andReturn(true);
  333 + expect(Faces.getViewMap()).andReturn(map);
  334 +
  335 + replayAll();
  336 + param = new ParameterImpl<Long>(ip);
  337 + param.setValue(1L);
  338 + assertEquals(1L, map.get("name"));
  339 + verifyAll();
  340 + }
  341 +
  342 + @Test
  343 + public void testSetValueElse() {
  344 + this.prepareForTestWithKeyFromNameAnnotation();
  345 +
  346 + expect(annotated.isAnnotationPresent(SessionScoped.class)).andReturn(false);
  347 + expect(annotated.isAnnotationPresent(RequestScoped.class)).andReturn(false);
  348 + expect(annotated.isAnnotationPresent(ViewScoped.class)).andReturn(false);
  349 +
  350 + replayAll();
  351 + param = new ParameterImpl<Long>(ip);
  352 + param.setValue(1L);
  353 + assertEquals(1L, Whitebox.getInternalState(param, "value"));
  354 + verifyAll();
  355 + }
  356 +
  357 + @Test
  358 + public void testOthers() {
  359 + this.prepareForTestWithKeyFromNameAnnotation();
  360 +
  361 + expect(annotated.isAnnotationPresent(SessionScoped.class)).andReturn(false);
  362 + expect(annotated.isAnnotationPresent(RequestScoped.class)).andReturn(true);
  363 + expect(annotated.isAnnotationPresent(ViewScoped.class)).andReturn(false);
  364 +
  365 + replayAll();
  366 + param = new ParameterImpl<Long>(ip);
  367 + param.setValue(1L);
  368 + verifyAll();
  369 + }
  370 +
  371 +}