Fix up library versions and classpath
[java-idp.git] / tests / com / mockrunner / mock / web / MockPageContext.java
1 /*
2  * Modified copy of Mockrunner 0.3.6 class with JSP 2.0 dependencies 
3  * removed so Shibboleth project doesn't require newer Servlet API to 
4  * compile and test. (Howard Gilbert)
5  */
6 package com.mockrunner.mock.web;
7
8 import java.io.IOException;
9 import java.io.Writer;
10 import java.util.Enumeration;
11 import java.util.HashMap;
12 import java.util.Iterator;
13 import java.util.NoSuchElementException;
14 import java.util.Stack;
15
16 import javax.servlet.RequestDispatcher;
17 import javax.servlet.Servlet;
18 import javax.servlet.ServletConfig;
19 import javax.servlet.ServletContext;
20 import javax.servlet.ServletException;
21 import javax.servlet.ServletRequest;
22 import javax.servlet.ServletResponse;
23 import javax.servlet.http.HttpServletRequest;
24 import javax.servlet.http.HttpSession;
25 import javax.servlet.jsp.JspWriter;
26 import javax.servlet.jsp.PageContext;
27 import javax.servlet.jsp.tagext.BodyContent;
28
29 /**
30  * Mock implementation of <code>PageContext</code>.
31  */
32 //Some methods of this class were copied from org.apache.struts.mock.MockPageContext
33 //and modified
34 public class MockPageContext extends PageContext
35 {
36     protected ServletConfig config;
37     protected ServletRequest request;
38     protected ServletResponse response;
39     private JspWriter jspWriter;
40     private Stack outStack;
41     private Exception exception;
42     private Object page;
43     private HashMap attributes;
44 //    private ExpressionEvaluator evaluator;
45 //    private VariableResolver resolver;
46     
47     public MockPageContext()
48     {
49         this(null, null, null);
50     }
51
52     public MockPageContext(ServletConfig config, ServletRequest request, ServletResponse response)
53     {
54         this.config = config;
55         this.request = request;
56         this.response = response;
57         jspWriter = new MockJspWriter();
58         outStack = new Stack();
59         attributes = new HashMap();
60 //        evaluator = new MockExpressionEvaluator();
61 //        resolver = new MockVariableResolver();
62     }
63     
64     /**
65      * This method allows to set custom implementations
66      * of <code>JspWriter</code>. Per default, {@link MockJspWriter}
67      * is used.
68      * @param jspWriter the <code>JspWriter</code>
69      */
70     public void setJspWriter(JspWriter jspWriter)
71     {
72         this.jspWriter = jspWriter;
73     }
74     
75     public void setPage(Object page) 
76     {
77         this.page = page;
78     }
79     
80     public void setServletConfig(ServletConfig config)
81     {
82         this.config = config;
83     }
84     
85     public void setServletRequest(ServletRequest request)
86     {
87         this.request = request;
88     }
89     
90     public void setServletResponse(ServletResponse response)
91     {
92         this.response = response;
93     }
94     
95     public void setException(Exception exception) 
96     {
97         this.exception = exception;
98     }
99     
100     public Object findAttribute(String name) 
101     {
102         Object value = getAttribute(name, PageContext.PAGE_SCOPE);
103         if(value == null) 
104         {
105             value = getAttribute(name, PageContext.REQUEST_SCOPE);
106         }
107         if(value == null) 
108         {
109             value = getAttribute(name, PageContext.SESSION_SCOPE);
110         }
111         if(value == null) 
112         {
113             value = getAttribute(name, PageContext.APPLICATION_SCOPE);
114         }
115         return value;
116     }
117     
118     public Object getAttribute(String name) 
119     {
120         return getAttribute(name, PageContext.PAGE_SCOPE);
121     }
122
123     public Object getAttribute(String name, int scope) 
124     {
125         if(scope == PageContext.PAGE_SCOPE) 
126         {
127             return attributes.get(name);
128         } 
129         else if(scope == PageContext.REQUEST_SCOPE) 
130         {
131             if(null == request) return null;
132             return request.getAttribute(name);
133         } 
134         else if(scope == PageContext.SESSION_SCOPE) 
135         {
136             if(null == getSession()) return null;
137             return getSession().getAttribute(name);
138         } 
139         else if(scope == PageContext.APPLICATION_SCOPE) 
140         {
141             if(null == getServletContext()) return null;
142             return getServletContext().getAttribute(name);
143         } 
144         else 
145         {
146             throw new IllegalArgumentException("Invalid scope " + scope);
147         }
148     }
149     
150     public void removeAttribute(String name) 
151     {
152         int scope = getAttributesScope(name);
153         if (scope != 0) 
154         {
155             removeAttribute(name, scope);
156         }
157     }
158
159     public void removeAttribute(String name, int scope) 
160     {
161         if(scope == PageContext.PAGE_SCOPE) 
162         {
163             attributes.remove(name);
164         } 
165         else if(scope == PageContext.REQUEST_SCOPE) 
166         {
167             if(request != null) 
168             {
169                 request.removeAttribute(name);
170             }
171         } 
172         else if(scope == PageContext.SESSION_SCOPE) 
173         {
174             if(getSession() != null) 
175             {
176                 getSession().removeAttribute(name);
177             }
178         } 
179         else if(scope == PageContext.APPLICATION_SCOPE) 
180         {
181             if(getServletContext() != null) 
182             {
183                 getServletContext().removeAttribute(name);
184             }
185         } 
186         else 
187         {
188             throw new IllegalArgumentException("Invalid scope " + scope);
189         }
190     }
191     
192     public void setAttribute(String name, Object value) 
193     {
194         setAttribute(name, value, PageContext.PAGE_SCOPE);
195     }
196
197
198     public void setAttribute(String name, Object value, int scope) 
199     {
200         if(scope == PageContext.PAGE_SCOPE) 
201         {
202             attributes.put(name, value);
203         } 
204         else if(scope == PageContext.REQUEST_SCOPE) 
205         {
206             if(request != null) 
207             {
208                 request.setAttribute(name, value);
209             }
210         } 
211         else if(scope == PageContext.SESSION_SCOPE) 
212         {
213             if(getSession() != null) 
214             {
215                 getSession().setAttribute(name, value);
216             }
217         } 
218         else if(scope == PageContext.APPLICATION_SCOPE) 
219         {
220             if(getServletContext() != null) 
221             {
222                 getServletContext().setAttribute(name, value);
223             }
224         } 
225         else 
226         {
227             throw new IllegalArgumentException("Invalid scope " + scope);
228         }
229     }
230     
231     public int getAttributesScope(String name) 
232     {
233         if(getAttribute(name, PageContext.PAGE_SCOPE) != null) 
234         {
235             return PageContext.PAGE_SCOPE;
236         } 
237         else if(getAttribute(name, PageContext.REQUEST_SCOPE) != null) 
238         {
239             return PageContext.REQUEST_SCOPE;
240         } 
241         else if(getAttribute(name, PageContext.SESSION_SCOPE) != null)
242         {
243             return PageContext.SESSION_SCOPE;
244         } 
245         else if(getAttribute(name, PageContext.APPLICATION_SCOPE) != null) 
246         {
247             return PageContext.APPLICATION_SCOPE;
248         } 
249         return 0;
250     }
251     
252     public Enumeration getAttributeNamesInScope(int scope) 
253     {
254         if(scope == PageContext.PAGE_SCOPE) 
255         {
256             return new WrappedEnumeration(attributes.keySet().iterator());
257         } 
258         else if(scope == PageContext.REQUEST_SCOPE) 
259         {
260             if(request == null) return new NullEnumeration();
261             return request.getAttributeNames();
262         } 
263         else if(scope == PageContext.SESSION_SCOPE) 
264         {
265             if(getSession() == null) return new NullEnumeration();
266             return getSession().getAttributeNames();
267         } 
268         else if(scope == PageContext.APPLICATION_SCOPE) 
269         {
270             if(getServletContext() == null) return new NullEnumeration();
271             return getServletContext().getAttributeNames();
272         } 
273         else 
274         {
275             throw new IllegalArgumentException("Invalid scope " + scope);
276         }
277     }
278     
279     public JspWriter getOut()
280     {
281         return jspWriter;
282     }
283     
284     public Exception getException() 
285     {
286         return exception;
287     }
288     
289     public Object getPage() 
290     {
291         return page;
292     }
293
294     public ServletRequest getRequest() 
295     {
296         return request;
297     }
298
299     public ServletResponse getResponse() 
300     {
301         return response;
302     }
303
304     public ServletConfig getServletConfig() 
305     {
306         return config;
307     }
308
309     public ServletContext getServletContext() 
310     {
311         if(null == config) return null;
312         return config.getServletContext();
313     }
314
315
316     public HttpSession getSession() 
317     {
318         if(null == request) return null;
319         return ((HttpServletRequest)request).getSession();
320     }
321     
322     public void handlePageException(Exception exc) 
323     {
324         
325     }
326
327     public void handlePageException(Throwable thr) 
328     {
329     
330     }
331     
332     public void forward(String path) throws ServletException, IOException
333     {
334         if(null != request)
335         {
336             RequestDispatcher dispatcher = request.getRequestDispatcher(path);
337             if(null != dispatcher)
338             {
339                 dispatcher.forward(request, response); 
340             }
341         }
342     }
343
344     public void include(String path) throws ServletException, IOException
345     {
346         if(null != request)
347         {
348             RequestDispatcher dispatcher = request.getRequestDispatcher(path);
349             if(null != dispatcher)
350             {
351                 dispatcher.include(request, response); 
352             }
353         }
354     }
355     
356     public void include(String path, boolean flush) throws ServletException, IOException
357     {
358         if(flush)
359         {
360             jspWriter.flush();
361         }
362         include(path);
363     }
364
365     public void initialize(Servlet servlet, ServletRequest request,
366                            ServletResponse response, String errorPageURL,
367                            boolean needsSession, int bufferSize,
368                            boolean autoFlush) 
369     {
370         this.config = servlet.getServletConfig();
371         this.request = request;
372         this.response = response;
373         jspWriter = new MockJspWriter();
374         outStack = new Stack();
375         attributes = new HashMap();
376     }
377
378     public JspWriter popBody() 
379     {
380         jspWriter = (JspWriter)outStack.pop();
381         return jspWriter;
382     }
383     
384     public BodyContent pushBody() 
385     {
386         outStack.push(jspWriter);
387         jspWriter = new MockBodyContent(jspWriter);
388         return (BodyContent)jspWriter;
389     }
390     
391     public JspWriter pushBody(Writer writer)
392     {
393         outStack.push(jspWriter);
394         jspWriter = new MockJspWriter(writer);
395         return jspWriter;
396     }
397     
398     public void release() 
399     {
400         jspWriter = new MockJspWriter();
401         outStack = new Stack();
402     }
403     
404 //    /**
405 //     * Sets the expression evaluator. The default expression evaluator
406 //     * is {@link MockExpressionEvaluator}.
407 //     * @param evaluator the <code>ExpressionEvaluator</code>
408 //     */
409 //    public void setExpressionEvaluator(ExpressionEvaluator evaluator)
410 //    {
411 //        this.evaluator = evaluator;
412 //    }
413 //
414 //    /**
415 //     * Sets the variable resolver. The default variable resolver
416 //     * is {@link MockVariableResolver}.
417 //     * @param resolver the <code>VariableResolver</code>
418 //     */
419 //    public void setVariableResolver(VariableResolver resolver)
420 //    {
421 //        this.resolver = resolver;
422 //    }
423 //    
424 //    public ExpressionEvaluator getExpressionEvaluator()
425 //    {
426 //        return evaluator;
427 //    }
428 //
429 //    public VariableResolver getVariableResolver()
430 //    {
431 //        return resolver;
432 //    }
433     
434     private class NullEnumeration implements Enumeration 
435     {
436         public boolean hasMoreElements() 
437         {
438             return false;
439         }
440
441         public Object nextElement() 
442         {
443             throw new NoSuchElementException();
444         }
445     }
446     
447     private class WrappedEnumeration implements Enumeration 
448     {
449         private Iterator iterator;
450         
451         public WrappedEnumeration(Iterator iterator) 
452         {
453             this.iterator = iterator;
454         }
455
456         public boolean hasMoreElements() 
457         {
458             return iterator.hasNext();
459         }
460
461         public Object nextElement() 
462         {
463             return iterator.next();
464         }
465     }
466 }