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

6.82

/main/src/main/java/mockit/internal/injection/full/JPAJavaxDependencies.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 java.io.IOException;
import java.io.InputStream;
import java.lang.annotation.Annotation;

import javax.persistence.EntityManager;
import javax.persistence.EntityManagerFactory;
import javax.persistence.Persistence;
import javax.persistence.PersistenceContext;
import javax.persistence.PersistenceUnit;
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>javax.persistence</code> API, namely
 * <code>EntityManagerFactory</code> and <code>EntityManager</code>.
 */
final class JPAJavaxDependencies {
    static boolean isApplicable(@NonNull Class<?> dependencyType) {
        return dependencyType == EntityManager.class || dependencyType == EntityManagerFactory.class;
    }

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

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

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