hazendaz / jmockit1 / 496

Committed 15 Nov 2025 05:33PM UTC coverage: 72.192% (-0.008%) from 72.2%

Build # 496

Build Type

push

github

Committed by

web-flow

Commit Message

Merge pull request #412 from hazendaz/renovate/major-spring-core

Update spring core to v7 (major)

Run Details

5677 of 8360 branches covered (67.91%)

Branch coverage included in aggregate %.

11922 of 16018 relevant lines covered (74.43%)

0.74 hits per line

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

90.91

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

/*
 * MIT License
 * Copyright (c) 2006-2025 JMockit developers
 * See LICENSE file for full license text.
 */
package mockit.internal.injection.full;

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

import jakarta.persistence.EntityManager;
import jakarta.persistence.EntityManagerFactory;
import jakarta.persistence.Persistence;
import jakarta.persistence.PersistenceContext;
import jakarta.persistence.PersistenceUnit;

import java.io.IOException;
import java.io.InputStream;
import java.lang.annotation.Annotation;

import javax.xml.parsers.ParserConfigurationException;
import javax.xml.parsers.SAXParser;
import javax.xml.parsers.SAXParserFactory;

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

import org.xml.sax.Attributes;
import org.xml.sax.SAXException;
import org.xml.sax.helpers.DefaultHandler;

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

    @NonNull
    private final InjectionState injectionState;
    @Nullable
    private String defaultPersistenceUnitName;

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

    @Nullable
    InjectionPoint getInjectionPointIfAvailable(@NonNull Annotation jpaAnnotation) {
        Class<? extends Annotation> annotationType = jpaAnnotation.annotationType();
        Class<?> jpaClass;
        String unitName;

        if (annotationType == PersistenceUnit.class) {
            jpaClass = EntityManagerFactory.class;
            unitName = ((PersistenceUnit) jpaAnnotation).unitName();
        } else if (annotationType == PersistenceContext.class) {
            jpaClass = EntityManager.class;
            unitName = ((PersistenceContext) jpaAnnotation).unitName();
        } else {
            return null;
        }

        if (unitName.isEmpty()) {
            unitName = discoverNameOfDefaultPersistenceUnit();
        }

        return new InjectionPoint(jpaClass, unitName, true);
    }

    @NonNull
    private String discoverNameOfDefaultPersistenceUnit() {
        if (defaultPersistenceUnitName != null) {
            return defaultPersistenceUnitName;
        }

        defaultPersistenceUnitName = "<unknown>";
        InputStream xmlFile = getClass().getResourceAsStream("/META-INF/persistence.xml");

        if (xmlFile != null) {
            try {
                SAXParserFactory factory = SAXParserFactory.newInstance();
                factory.setFeature("http://xml.org/sax/features/external-general-entities", false);
                factory.setFeature("http://xml.org/sax/features/external-parameter-entities", false);
                factory.setFeature("http://apache.org/xml/features/nonvalidating/load-external-dtd", false);
                SAXParser parser = factory.newSAXParser();
                parser.parse(xmlFile, new DefaultHandler() {
                    @Override
                    public void startElement(String uri, String localName, String qName, Attributes attributes) {
                        if ("persistence-unit".equals(qName)) {
                            defaultPersistenceUnitName = attributes.getValue("name");
                        }
                    }
                });
                xmlFile.close();
            } catch (ParserConfigurationException | SAXException | IOException ignore) {
            }
        }

        return defaultPersistenceUnitName;
    }

    @Nullable
    Object createAndRegisterDependency(@NonNull Class<?> dependencyType, @NonNull InjectionPoint dependencyKey,
            @Nullable InjectionProvider injectionProvider) {
        if (injectionProvider != null) {
            if (dependencyType == EntityManagerFactory.class
                    && injectionProvider.hasAnnotation(PersistenceUnit.class)) {
                InjectionPoint injectionPoint = createFactoryInjectionPoint(dependencyKey);
                return createAndRegisterEntityManagerFactory(injectionPoint);
            }

            if (dependencyType == EntityManager.class && injectionProvider.hasAnnotation(PersistenceContext.class)) {
                return createAndRegisterEntityManager(dependencyKey);
            }
        }

        return null;
    }

    @NonNull
    private InjectionPoint createFactoryInjectionPoint(@NonNull InjectionPoint injectionPoint) {
        String persistenceUnitName = getNameOfPersistentUnit(injectionPoint.name);
        return new InjectionPoint(EntityManagerFactory.class, persistenceUnitName, injectionPoint.qualified);
    }

    @NonNull
    private String getNameOfPersistentUnit(@Nullable String injectionPointName) {
        return injectionPointName != null && !injectionPointName.isEmpty() ? injectionPointName
                : discoverNameOfDefaultPersistenceUnit();
    }

    @NonNull
    private static EntityManagerFactory createAndRegisterEntityManagerFactory(@NonNull InjectionPoint injectionPoint) {
        String persistenceUnitName = injectionPoint.name;
        EntityManagerFactory emFactory = Persistence.createEntityManagerFactory(persistenceUnitName);
        InjectionState.saveGlobalDependency(injectionPoint, emFactory);
        return emFactory;
    }

    @NonNull
    private EntityManager createAndRegisterEntityManager(@NonNull InjectionPoint injectionPoint) {
        InjectionPoint emFactoryKey = createFactoryInjectionPoint(injectionPoint);
        EntityManagerFactory emFactory = InjectionState.getGlobalDependency(emFactoryKey);

        if (emFactory == null) {
            emFactory = createAndRegisterEntityManagerFactory(emFactoryKey);
        }

        EntityManager entityManager = emFactory.createEntityManager();
        injectionState.saveInstantiatedDependency(injectionPoint, entityManager);
        return entityManager;
    }
}

1	/*
2	* MIT License
3	* Copyright (c) 2006-2025 JMockit developers
4	* See LICENSE file for full license text.
5	*/
6	package mockit.internal.injection.full;
7
8	import edu.umd.cs.findbugs.annotations.NonNull;
9	import edu.umd.cs.findbugs.annotations.Nullable;
10
11	import jakarta.persistence.EntityManager;
12	import jakarta.persistence.EntityManagerFactory;
13	import jakarta.persistence.Persistence;
14	import jakarta.persistence.PersistenceContext;
15	import jakarta.persistence.PersistenceUnit;
16
17	import java.io.IOException;
18	import java.io.InputStream;
19	import java.lang.annotation.Annotation;
20
21	import javax.xml.parsers.ParserConfigurationException;
22	import javax.xml.parsers.SAXParser;
23	import javax.xml.parsers.SAXParserFactory;
24
25	import mockit.internal.injection.InjectionPoint;
26	import mockit.internal.injection.InjectionProvider;
27	import mockit.internal.injection.InjectionState;
28
29	import org.xml.sax.Attributes;
30	import org.xml.sax.SAXException;
31	import org.xml.sax.helpers.DefaultHandler;
32
33	/**
34	* Detects and resolves dependencies belonging to the <code>jakarta.persistence</code> API, namely
35	* <code>EntityManagerFactory</code> and <code>EntityManager</code>.
36	*/
37	final class JPAJakartaDependencies {
38	static boolean isApplicable(@NonNull Class<?> dependencyType) {
39	return dependencyType == EntityManager.class \|\| dependencyType == EntityManagerFactory.class;	1✔
40	}
41
42	@NonNull
43	private final InjectionState injectionState;
44	@Nullable
45	private String defaultPersistenceUnitName;
46
47	JPAJakartaDependencies(@NonNull InjectionState injectionState) {	1✔
48	this.injectionState = injectionState;	1✔
49	}	1✔
50
51	@Nullable
52	InjectionPoint getInjectionPointIfAvailable(@NonNull Annotation jpaAnnotation) {
53	Class<? extends Annotation> annotationType = jpaAnnotation.annotationType();	1✔
54	Class<?> jpaClass;
55	String unitName;
56
57	if (annotationType == PersistenceUnit.class) {	1✔
58	jpaClass = EntityManagerFactory.class;	1✔
59	unitName = ((PersistenceUnit) jpaAnnotation).unitName();	1✔
60	} else if (annotationType == PersistenceContext.class) {	1!
61	jpaClass = EntityManager.class;	1✔
62	unitName = ((PersistenceContext) jpaAnnotation).unitName();	1✔
63	} else {
64	return null;	×
65	}
66
67	if (unitName.isEmpty()) {	1✔
68	unitName = discoverNameOfDefaultPersistenceUnit();	1✔
69	}
70
71	return new InjectionPoint(jpaClass, unitName, true);	1✔
72	}
73
74	@NonNull
75	private String discoverNameOfDefaultPersistenceUnit() {
76	if (defaultPersistenceUnitName != null) {	1✔
77	return defaultPersistenceUnitName;	1✔
78	}
79
80	defaultPersistenceUnitName = "<unknown>";	1✔
81	InputStream xmlFile = getClass().getResourceAsStream("/META-INF/persistence.xml");	1✔
82
83	if (xmlFile != null) {	1!
84	try {
85	SAXParserFactory factory = SAXParserFactory.newInstance();	1✔
86	factory.setFeature("http://xml.org/sax/features/external-general-entities", false);	1✔
87	factory.setFeature("http://xml.org/sax/features/external-parameter-entities", false);	1✔
88	factory.setFeature("http://apache.org/xml/features/nonvalidating/load-external-dtd", false);	1✔
89	SAXParser parser = factory.newSAXParser();	1✔
90	parser.parse(xmlFile, new DefaultHandler() {	1✔
91	@Override
92	public void startElement(String uri, String localName, String qName, Attributes attributes) {
93	if ("persistence-unit".equals(qName)) {	1✔
94	defaultPersistenceUnitName = attributes.getValue("name");	1✔
95	}
96	}	1✔
97	});
98	xmlFile.close();	1✔
99	} catch (ParserConfigurationException \| SAXException \| IOException ignore) {	×
100	}	1✔
101	}
102
103	return defaultPersistenceUnitName;	1✔
104	}
105
106	@Nullable
107	Object createAndRegisterDependency(@NonNull Class<?> dependencyType, @NonNull InjectionPoint dependencyKey,
108	@Nullable InjectionProvider injectionProvider) {
109	if (injectionProvider != null) {	1!
110	if (dependencyType == EntityManagerFactory.class	1✔
111	&& injectionProvider.hasAnnotation(PersistenceUnit.class)) {	1✔
112	InjectionPoint injectionPoint = createFactoryInjectionPoint(dependencyKey);	1✔
113	return createAndRegisterEntityManagerFactory(injectionPoint);	1✔
114	}
115
116	if (dependencyType == EntityManager.class && injectionProvider.hasAnnotation(PersistenceContext.class)) {	1✔
117	return createAndRegisterEntityManager(dependencyKey);	1✔
118	}
119	}
120
121	return null;	1✔
122	}
123
124	@NonNull
125	private InjectionPoint createFactoryInjectionPoint(@NonNull InjectionPoint injectionPoint) {
126	String persistenceUnitName = getNameOfPersistentUnit(injectionPoint.name);	1✔
127	return new InjectionPoint(EntityManagerFactory.class, persistenceUnitName, injectionPoint.qualified);	1✔
128	}
129
130	@NonNull
131	private String getNameOfPersistentUnit(@Nullable String injectionPointName) {
132	return injectionPointName != null && !injectionPointName.isEmpty() ? injectionPointName	1!
133	: discoverNameOfDefaultPersistenceUnit();	×
134	}
135
136	@NonNull
137	private static EntityManagerFactory createAndRegisterEntityManagerFactory(@NonNull InjectionPoint injectionPoint) {
138	String persistenceUnitName = injectionPoint.name;	1✔
139	EntityManagerFactory emFactory = Persistence.createEntityManagerFactory(persistenceUnitName);	1✔
140	InjectionState.saveGlobalDependency(injectionPoint, emFactory);	1✔
141	return emFactory;	1✔
142	}
143
144	@NonNull
145	private EntityManager createAndRegisterEntityManager(@NonNull InjectionPoint injectionPoint) {
146	InjectionPoint emFactoryKey = createFactoryInjectionPoint(injectionPoint);	1✔
147	EntityManagerFactory emFactory = InjectionState.getGlobalDependency(emFactoryKey);	1✔
148
149	if (emFactory == null) {	1✔
150	emFactory = createAndRegisterEntityManagerFactory(emFactoryKey);	1✔
151	}
152
153	EntityManager entityManager = emFactory.createEntityManager();	1✔
154	injectionState.saveInstantiatedDependency(injectionPoint, entityManager);	1✔
155	return entityManager;	1✔
156	}
157	}

hazendaz / jmockit1 / 496

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