hazendaz / jmockit1 / 381

Committed 28 Oct 2025 02:00PM UTC coverage: 72.226% (-1.0%) from 73.269%

Build # 381

Build Type

push

github

Committed by

web-flow

Commit Message

Merge pull request #393 from hazendaz/full-jakarta-support

Jakarta Full Migration

Run Details

5686 of 8360 branches covered (68.01%)

Branch coverage included in aggregate %.

145 of 408 new or added lines in 14 files covered. (35.54%)

19 existing lines in 4 files now uncovered.

11948 of 16055 relevant lines covered (74.42%)

0.74 hits per line

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

5.0

/main/src/main/java/mockit/internal/injection/full/ServletJakartaDependencies.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 jakarta.servlet.Filter;
import jakarta.servlet.FilterRegistration;
import jakarta.servlet.RequestDispatcher;
import jakarta.servlet.Servlet;
import jakarta.servlet.ServletContext;
import jakarta.servlet.ServletRegistration;
import jakarta.servlet.ServletRegistration.Dynamic;
import jakarta.servlet.SessionCookieConfig;
import jakarta.servlet.SessionTrackingMode;
import jakarta.servlet.descriptor.JspConfigDescriptor;
import jakarta.servlet.http.HttpSession;

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 mockit.internal.injection.InjectionPoint;
import mockit.internal.injection.InjectionState;

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

    @NonNull
    private final InjectionState injectionState;

    ServletJakartaDependencies(@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();
            }

            @Override
            public void log(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;
            }

        };

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

hazendaz / jmockit1 / 381

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