hazendaz / jmockit1 / 398

Committed 29 Oct 2025 01:58PM UTC coverage: 72.206% (-0.02%) from 72.226%

Build # 398

Build Type

push

github

Committed by

web-flow

Commit Message

Merge pull request #395 from hazendaz/develop

Migrate jmockit tests away from javax to jakarta

Run Details

5683 of 8360 branches covered (67.98%)

Branch coverage included in aggregate %.

11946 of 16055 relevant lines covered (74.41%)

0.74 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

4.65

/main/src/main/java/mockit/internal/injection/full/ServletJavaxDependencies.java

/*
 * Copyright (c) 2006 JMockit developers
 * This file is subject to the terms of the MIT license (see LICENSE.txt).
 */
package mockit.internal.injection.full;

import static java.util.Collections.enumeration;

import edu.umd.cs.findbugs.annotations.NonNull;

import java.io.InputStream;
import java.net.URL;
import java.security.SecureRandom;
import java.util.Enumeration;
import java.util.EventListener;
import java.util.HashMap;
import java.util.Map;
import java.util.Set;

import javax.servlet.Filter;
import javax.servlet.FilterRegistration;
import javax.servlet.RequestDispatcher;
import javax.servlet.Servlet;
import javax.servlet.ServletContext;
import javax.servlet.ServletRegistration;
import javax.servlet.ServletRegistration.Dynamic;
import javax.servlet.SessionCookieConfig;
import javax.servlet.SessionTrackingMode;
import javax.servlet.descriptor.JspConfigDescriptor;
import javax.servlet.http.HttpSession;
import javax.servlet.http.HttpSessionContext;

import mockit.internal.injection.InjectionPoint;
import mockit.internal.injection.InjectionState;

/**
 * Detects and resolves dependencies belonging to the <code>javax.servlet</code> API, namely <code>ServletContext</code>
 * and <code>HttpSession</code>.
 */
final class ServletJavaxDependencies {
    static boolean isApplicable(@NonNull Class<?> dependencyType) {
        return dependencyType == HttpSession.class || dependencyType == ServletContext.class;
    }

    @NonNull
    private final InjectionState injectionState;

    ServletJavaxDependencies(@NonNull InjectionState injectionState) {
        this.injectionState = injectionState;
    }

    @NonNull
    Object createAndRegisterDependency(@NonNull Class<?> dependencyType) {
        if (dependencyType == ServletContext.class) {
            return createAndRegisterServletContext();
        }

        return createAndRegisterHttpSession();
    }

    @NonNull
    private ServletContext createAndRegisterServletContext() {
        ServletContext context = new ServletContext() {
            private final Map<String, String> init = new HashMap<>();
            private final Map<String, Object> attrs = new HashMap<>();

            @Override
            public String getContextPath() {
                return "";
            }

            @Override
            public ServletContext getContext(String uriPath) {
                return null;
            }

            @Override
            public int getMajorVersion() {
                return 3;
            }

            @Override
            public int getMinorVersion() {
                return 0;
            }

            @Override
            public int getEffectiveMajorVersion() {
                return 3;
            }

            @Override
            public int getEffectiveMinorVersion() {
                return 0;
            }

            @Override
            public String getMimeType(String file) {
                return null;
            }

            @Override
            public String getRealPath(String path) {
                return null;
            }

            @Override
            public Set<String> getResourcePaths(String path) {
                return null;
            }

            @Override
            public URL getResource(String path) {
                return getClass().getResource(path);
            }

            @Override
            public InputStream getResourceAsStream(String path) {
                return getClass().getResourceAsStream(path);
            }

            @Override
            public RequestDispatcher getRequestDispatcher(String path) {
                return null;
            }

            @Override
            public RequestDispatcher getNamedDispatcher(String name) {
                return null;
            }

            @Override
            public String getServletContextName() {
                return null;
            }

            @Override
            public String getServerInfo() {
                return "JMockit 1.x";
            }

            @Override
            public ClassLoader getClassLoader() {
                return getClass().getClassLoader();
            }

            // Deprecated/logging methods: do nothing.
            @Override
            public Servlet getServlet(String name) {
                return null;
            }

            @Override
            public Enumeration<Servlet> getServlets() {
                return null;
            }

            @Override
            public Enumeration<String> getServletNames() {
                return null;
            }

            @Override
            public void log(String msg) {
            }

            @Override
            public void log(Exception exception, String msg) {
            }

            @Override
            public void log(String message, Throwable throwable) {
            }

            // Context initialization parameters.
            @Override
            public Enumeration<String> getInitParameterNames() {
                return enumeration(init.keySet());
            }

            @Override
            public String getInitParameter(String name) {
                return init.get(name);
            }

            @Override
            public boolean setInitParameter(String name, String value) {
                return init.put(name, value) == null;
            }

            // Context attributes.
            @Override
            public Enumeration<String> getAttributeNames() {
                return enumeration(attrs.keySet());
            }

            @Override
            public Object getAttribute(String name) {
                return attrs.get(name);
            }

            @Override
            public void setAttribute(String name, Object value) {
                attrs.put(name, value);
            }

            @Override
            public void removeAttribute(String name) {
                attrs.remove(name);
            }

            // Un-implemented methods, which may get a non-empty implementation eventually.
            @Override
            public ServletRegistration.Dynamic addServlet(String name, String className) {
                return null;
            }

            @Override
            public ServletRegistration.Dynamic addServlet(String name, Servlet servlet) {
                return null;
            }

            @Override
            public ServletRegistration.Dynamic addServlet(String nm, Class<? extends Servlet> c) {
                return null;
            }

            @Override
            public <T extends Servlet> T createServlet(Class<T> clazz) {
                return null;
            }

            @Override
            public ServletRegistration getServletRegistration(String servletName) {
                return null;
            }

            @Override
            public Map<String, ? extends ServletRegistration> getServletRegistrations() {
                return null;
            }

            @Override
            public FilterRegistration.Dynamic addFilter(String name, String className) {
                return null;
            }

            @Override
            public FilterRegistration.Dynamic addFilter(String name, Filter filter) {
                return null;
            }

            @Override
            public FilterRegistration.Dynamic addFilter(String name, Class<? extends Filter> cl) {
                return null;
            }

            @Override
            public <T extends Filter> T createFilter(Class<T> clazz) {
                return null;
            }

            @Override
            public FilterRegistration getFilterRegistration(String filterName) {
                return null;
            }

            @Override
            public Map<String, ? extends FilterRegistration> getFilterRegistrations() {
                return null;
            }

            @Override
            public SessionCookieConfig getSessionCookieConfig() {
                return null;
            }

            @Override
            public void setSessionTrackingModes(Set<SessionTrackingMode> sessionTrackingModes) {
            }

            @Override
            public Set<SessionTrackingMode> getDefaultSessionTrackingModes() {
                return null;
            }

            @Override
            public Set<SessionTrackingMode> getEffectiveSessionTrackingModes() {
                return null;
            }

            @Override
            public void addListener(String className) {
            }

            @Override
            public <T extends EventListener> void addListener(T t) {
            }

            @Override
            public void addListener(Class<? extends EventListener> listenerClass) {
            }

            @Override
            public <T extends EventListener> T createListener(Class<T> clazz) {
                return null;
            }

            @Override
            public JspConfigDescriptor getJspConfigDescriptor() {
                return null;
            }

            @Override
            public void declareRoles(String... roleNames) {
            }

            @Override
            public String getVirtualServerName() {
                return null;
            }

            // Allow older servlet still (no overrides)
            @Override
            public Dynamic addJspFile(String servletName, String jspFile) {
                return null;
            }

            @Override
            public int getSessionTimeout() {
                return 0;
            }

            @Override
            public void setSessionTimeout(int sessionTimeout) {
            }

            @Override
            public String getRequestCharacterEncoding() {
                return null;
            }

            @Override
            public void setRequestCharacterEncoding(String encoding) {
            }

            @Override
            public String getResponseCharacterEncoding() {
                return null;
            }

            @Override
            public void setResponseCharacterEncoding(String encoding) {
            }
        };

        InjectionPoint injectionPoint = new InjectionPoint(ServletContext.class);
        InjectionState.saveGlobalDependency(injectionPoint, context);
        return context;
    }

    @NonNull
    private HttpSession createAndRegisterHttpSession() {
        HttpSession session = new HttpSession() {
            private final String id = String.valueOf(new SecureRandom().nextInt(Integer.MAX_VALUE));
            private final long creationTime = System.currentTimeMillis();
            private final Map<String, Object> attrs = new HashMap<>();
            private int maxInactiveInterval;
            private boolean invalidated;

            @Override
            public String getId() {
                return id;
            }

            @Override
            public int getMaxInactiveInterval() {
                return maxInactiveInterval;
            }

            @Override
            public void setMaxInactiveInterval(int interval) {
                maxInactiveInterval = interval;
            }

            @Override
            public long getCreationTime() {
                checkValid();
                return creationTime;
            }

            @Override
            public long getLastAccessedTime() {
                checkValid();
                return creationTime;
            }

            @Override
            public boolean isNew() {
                checkValid();
                return false;
            }

            @Override
            public Enumeration<String> getAttributeNames() {
                checkValid();
                return enumeration(attrs.keySet());
            }

            @Override
            public Object getAttribute(String name) {
                checkValid();
                return attrs.get(name);
            }

            @Override
            public void setAttribute(String name, Object value) {
                checkValid();
                attrs.put(name, value);
            }

            @Override
            public void removeAttribute(String name) {
                checkValid();
                attrs.remove(name);
            }

            @Override
            public void invalidate() {
                checkValid();
                attrs.clear();
                invalidated = true;
            }

            private void checkValid() {
                if (invalidated) {
                    throw new IllegalStateException("Session is invalid");
                }
            }

            @Override
            public ServletContext getServletContext() {
                ServletContext context = InjectionState.getGlobalDependency(new InjectionPoint(ServletContext.class));

                if (context == null) {
                    context = createAndRegisterServletContext();
                }

                return context;
            }

            // Deprecated methods: do nothing.
            @Override
            public Object getValue(String name) {
                return null;
            }

            @Override
            public void putValue(String name, Object value) {
            }

            @Override
            public void removeValue(String name) {
            }

            @Override
            public String[] getValueNames() {
                return null;
            }

            @SuppressWarnings("deprecation")
            @Override
            public HttpSessionContext getSessionContext() {
                return null;
            }
        };

        InjectionPoint injectionPoint = new InjectionPoint(HttpSession.class);
        injectionState.saveInstantiatedDependency(injectionPoint, session);
        return session;
    }
}

1	/*
2	* Copyright (c) 2006 JMockit developers
3	* This file is subject to the terms of the MIT license (see LICENSE.txt).
4	*/
5	package mockit.internal.injection.full;
6
7	import static java.util.Collections.enumeration;
8
9	import edu.umd.cs.findbugs.annotations.NonNull;
10
11	import java.io.InputStream;
12	import java.net.URL;
13	import java.security.SecureRandom;
14	import java.util.Enumeration;
15	import java.util.EventListener;
16	import java.util.HashMap;
17	import java.util.Map;
18	import java.util.Set;
19
20	import javax.servlet.Filter;
21	import javax.servlet.FilterRegistration;
22	import javax.servlet.RequestDispatcher;
23	import javax.servlet.Servlet;
24	import javax.servlet.ServletContext;
25	import javax.servlet.ServletRegistration;
26	import javax.servlet.ServletRegistration.Dynamic;
27	import javax.servlet.SessionCookieConfig;
28	import javax.servlet.SessionTrackingMode;
29	import javax.servlet.descriptor.JspConfigDescriptor;
30	import javax.servlet.http.HttpSession;
31	import javax.servlet.http.HttpSessionContext;
32
33	import mockit.internal.injection.InjectionPoint;
34	import mockit.internal.injection.InjectionState;
35
36	/**
37	* Detects and resolves dependencies belonging to the <code>javax.servlet</code> API, namely <code>ServletContext</code>
38	* and <code>HttpSession</code>.
39	*/
40	final class ServletJavaxDependencies {
41	static boolean isApplicable(@NonNull Class<?> dependencyType) {
42	return dependencyType == HttpSession.class \|\| dependencyType == ServletContext.class;	1!
43	}
44
45	@NonNull
46	private final InjectionState injectionState;
47
48	ServletJavaxDependencies(@NonNull InjectionState injectionState) {	1✔
49	this.injectionState = injectionState;	1✔
50	}	1✔
51
52	@NonNull
53	Object createAndRegisterDependency(@NonNull Class<?> dependencyType) {
54	if (dependencyType == ServletContext.class) {	×
55	return createAndRegisterServletContext();	×
56	}
57
58	return createAndRegisterHttpSession();	×
59	}
60
61	@NonNull
62	private ServletContext createAndRegisterServletContext() {
63	ServletContext context = new ServletContext() {	×
64	private final Map<String, String> init = new HashMap<>();	×
65	private final Map<String, Object> attrs = new HashMap<>();	×
66
67	@Override
68	public String getContextPath() {
69	return "";	×
70	}
71
72	@Override
73	public ServletContext getContext(String uriPath) {
74	return null;	×
75	}
76
77	@Override
78	public int getMajorVersion() {
79	return 3;	×
80	}
81
82	@Override
83	public int getMinorVersion() {
84	return 0;	×
85	}
86
87	@Override
88	public int getEffectiveMajorVersion() {
89	return 3;	×
90	}
91
92	@Override
93	public int getEffectiveMinorVersion() {
94	return 0;	×
95	}
96
97	@Override
98	public String getMimeType(String file) {
99	return null;	×
100	}
101
102	@Override
103	public String getRealPath(String path) {
104	return null;	×
105	}
106
107	@Override
108	public Set<String> getResourcePaths(String path) {
109	return null;	×
110	}
111
112	@Override
113	public URL getResource(String path) {
114	return getClass().getResource(path);	×
115	}
116
117	@Override
118	public InputStream getResourceAsStream(String path) {
119	return getClass().getResourceAsStream(path);	×
120	}
121
122	@Override
123	public RequestDispatcher getRequestDispatcher(String path) {
124	return null;	×
125	}
126
127	@Override
128	public RequestDispatcher getNamedDispatcher(String name) {
129	return null;	×
130	}
131
132	@Override
133	public String getServletContextName() {
134	return null;	×
135	}
136
137	@Override
138	public String getServerInfo() {
139	return "JMockit 1.x";	×
140	}
141
142	@Override
143	public ClassLoader getClassLoader() {
144	return getClass().getClassLoader();	×
145	}
146
147	// Deprecated/logging methods: do nothing.
148	@Override
149	public Servlet getServlet(String name) {
150	return null;	×
151	}
152
153	@Override
154	public Enumeration<Servlet> getServlets() {
155	return null;	×
156	}
157
158	@Override
159	public Enumeration<String> getServletNames() {
160	return null;	×
161	}
162
163	@Override
164	public void log(String msg) {
165	}	×
166
167	@Override
168	public void log(Exception exception, String msg) {
169	}	×
170
171	@Override
172	public void log(String message, Throwable throwable) {
173	}	×
174
175	// Context initialization parameters.
176	@Override
177	public Enumeration<String> getInitParameterNames() {
178	return enumeration(init.keySet());	×
179	}
180
181	@Override
182	public String getInitParameter(String name) {
183	return init.get(name);	×
184	}
185
186	@Override
187	public boolean setInitParameter(String name, String value) {
188	return init.put(name, value) == null;	×
189	}
190
191	// Context attributes.
192	@Override
193	public Enumeration<String> getAttributeNames() {
194	return enumeration(attrs.keySet());	×
195	}
196
197	@Override
198	public Object getAttribute(String name) {
199	return attrs.get(name);	×
200	}
201
202	@Override
203	public void setAttribute(String name, Object value) {
204	attrs.put(name, value);	×
205	}	×
206
207	@Override
208	public void removeAttribute(String name) {
209	attrs.remove(name);	×
210	}	×
211
212	// Un-implemented methods, which may get a non-empty implementation eventually.
213	@Override
214	public ServletRegistration.Dynamic addServlet(String name, String className) {
215	return null;	×
216	}
217
218	@Override
219	public ServletRegistration.Dynamic addServlet(String name, Servlet servlet) {
220	return null;	×
221	}
222
223	@Override
224	public ServletRegistration.Dynamic addServlet(String nm, Class<? extends Servlet> c) {
225	return null;	×
226	}
227
228	@Override
229	public <T extends Servlet> T createServlet(Class<T> clazz) {
230	return null;	×
231	}
232
233	@Override
234	public ServletRegistration getServletRegistration(String servletName) {
235	return null;	×
236	}
237
238	@Override
239	public Map<String, ? extends ServletRegistration> getServletRegistrations() {
240	return null;	×
241	}
242
243	@Override
244	public FilterRegistration.Dynamic addFilter(String name, String className) {
245	return null;	×
246	}
247
248	@Override
249	public FilterRegistration.Dynamic addFilter(String name, Filter filter) {
250	return null;	×
251	}
252
253	@Override
254	public FilterRegistration.Dynamic addFilter(String name, Class<? extends Filter> cl) {
255	return null;	×
256	}
257
258	@Override
259	public <T extends Filter> T createFilter(Class<T> clazz) {
260	return null;	×
261	}
262
263	@Override
264	public FilterRegistration getFilterRegistration(String filterName) {
265	return null;	×
266	}
267
268	@Override
269	public Map<String, ? extends FilterRegistration> getFilterRegistrations() {
270	return null;	×
271	}
272
273	@Override
274	public SessionCookieConfig getSessionCookieConfig() {
275	return null;	×
276	}
277
278	@Override
279	public void setSessionTrackingModes(Set<SessionTrackingMode> sessionTrackingModes) {
280	}	×
281
282	@Override
283	public Set<SessionTrackingMode> getDefaultSessionTrackingModes() {
284	return null;	×
285	}
286
287	@Override
288	public Set<SessionTrackingMode> getEffectiveSessionTrackingModes() {
289	return null;	×
290	}
291
292	@Override
293	public void addListener(String className) {
294	}	×
295
296	@Override
297	public <T extends EventListener> void addListener(T t) {
298	}	×
299
300	@Override
301	public void addListener(Class<? extends EventListener> listenerClass) {
302	}	×
303
304	@Override
305	public <T extends EventListener> T createListener(Class<T> clazz) {
306	return null;	×
307	}
308
309	@Override
310	public JspConfigDescriptor getJspConfigDescriptor() {
311	return null;	×
312	}
313
314	@Override
315	public void declareRoles(String... roleNames) {
316	}	×
317
318	@Override
319	public String getVirtualServerName() {
320	return null;	×
321	}
322
323	// Allow older servlet still (no overrides)
324	@Override
325	public Dynamic addJspFile(String servletName, String jspFile) {
326	return null;	×
327	}
328
329	@Override
330	public int getSessionTimeout() {
331	return 0;	×
332	}
333
334	@Override
335	public void setSessionTimeout(int sessionTimeout) {
336	}	×
337
338	@Override
339	public String getRequestCharacterEncoding() {
340	return null;	×
341	}
342
343	@Override
344	public void setRequestCharacterEncoding(String encoding) {
345	}	×
346
347	@Override
348	public String getResponseCharacterEncoding() {
349	return null;	×
350	}
351
352	@Override
353	public void setResponseCharacterEncoding(String encoding) {
354	}	×
355	};
356
357	InjectionPoint injectionPoint = new InjectionPoint(ServletContext.class);	×
358	InjectionState.saveGlobalDependency(injectionPoint, context);	×
359	return context;	×
360	}
361
362	@NonNull
363	private HttpSession createAndRegisterHttpSession() {
364	HttpSession session = new HttpSession() {	×
365	private final String id = String.valueOf(new SecureRandom().nextInt(Integer.MAX_VALUE));	×
366	private final long creationTime = System.currentTimeMillis();	×
367	private final Map<String, Object> attrs = new HashMap<>();	×
368	private int maxInactiveInterval;
369	private boolean invalidated;
370
371	@Override
372	public String getId() {
373	return id;	×
374	}
375
376	@Override
377	public int getMaxInactiveInterval() {
378	return maxInactiveInterval;	×
379	}
380
381	@Override
382	public void setMaxInactiveInterval(int interval) {
383	maxInactiveInterval = interval;	×
384	}	×
385
386	@Override
387	public long getCreationTime() {
388	checkValid();	×
389	return creationTime;	×
390	}
391
392	@Override
393	public long getLastAccessedTime() {
394	checkValid();	×
395	return creationTime;	×
396	}
397
398	@Override
399	public boolean isNew() {
400	checkValid();	×
401	return false;	×
402	}
403
404	@Override
405	public Enumeration<String> getAttributeNames() {
406	checkValid();	×
407	return enumeration(attrs.keySet());	×
408	}
409
410	@Override
411	public Object getAttribute(String name) {
412	checkValid();	×
413	return attrs.get(name);	×
414	}
415
416	@Override
417	public void setAttribute(String name, Object value) {
418	checkValid();	×
419	attrs.put(name, value);	×
420	}	×
421
422	@Override
423	public void removeAttribute(String name) {
424	checkValid();	×
425	attrs.remove(name);	×
426	}	×
427
428	@Override
429	public void invalidate() {
430	checkValid();	×
431	attrs.clear();	×
432	invalidated = true;	×
433	}	×
434
435	private void checkValid() {
436	if (invalidated) {	×
437	throw new IllegalStateException("Session is invalid");	×
438	}
439	}	×
440
441	@Override
442	public ServletContext getServletContext() {
443	ServletContext context = InjectionState.getGlobalDependency(new InjectionPoint(ServletContext.class));	×
444
445	if (context == null) {	×
446	context = createAndRegisterServletContext();	×
447	}
448
449	return context;	×
450	}
451
452	// Deprecated methods: do nothing.
453	@Override
454	public Object getValue(String name) {
455	return null;	×
456	}
457
458	@Override
459	public void putValue(String name, Object value) {
460	}	×
461
462	@Override
463	public void removeValue(String name) {
464	}	×
465
466	@Override
467	public String[] getValueNames() {
468	return null;	×
469	}
470
471	@SuppressWarnings("deprecation")
472	@Override
473	public HttpSessionContext getSessionContext() {
474	return null;	×
475	}
476	};
477
478	InjectionPoint injectionPoint = new InjectionPoint(HttpSession.class);	×
479	injectionState.saveInstantiatedDependency(injectionPoint, session);	×
480	return session;	×
481	}
482	}

hazendaz / jmockit1 / 398

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous