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

7.14

/main/src/main/java/mockit/internal/injection/full/JPAJakartaDependencies.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 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 {
                SAXParser parser = SAXParserFactory.newInstance().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	* 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 edu.umd.cs.findbugs.annotations.NonNull;
8	import edu.umd.cs.findbugs.annotations.Nullable;
9
10	import jakarta.persistence.EntityManager;
11	import jakarta.persistence.EntityManagerFactory;
12	import jakarta.persistence.Persistence;
13	import jakarta.persistence.PersistenceContext;
14	import jakarta.persistence.PersistenceUnit;
15
16	import java.io.IOException;
17	import java.io.InputStream;
18	import java.lang.annotation.Annotation;
19
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>jakarta.persistence</code> API, namely
34	* <code>EntityManagerFactory</code> and <code>EntityManager</code>.
35	*/
36	final class JPAJakartaDependencies {
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	JPAJakartaDependencies(@NonNull InjectionState injectionState) {	1✔
47	this.injectionState = injectionState;	1✔
48	}	1✔
49
50	@Nullable
51	InjectionPoint getInjectionPointIfAvailable(@NonNull Annotation jpaAnnotation) {
NEW 52	Class<? extends Annotation> annotationType = jpaAnnotation.annotationType();	×
53	Class<?> jpaClass;
54	String unitName;
55
NEW 56	if (annotationType == PersistenceUnit.class) {	×
NEW 57	jpaClass = EntityManagerFactory.class;	×
NEW 58	unitName = ((PersistenceUnit) jpaAnnotation).unitName();	×
NEW 59	} else if (annotationType == PersistenceContext.class) {	×
NEW 60	jpaClass = EntityManager.class;	×
NEW 61	unitName = ((PersistenceContext) jpaAnnotation).unitName();	×
62	} else {
NEW 63	return null;	×
64	}
65
NEW 66	if (unitName.isEmpty()) {	×
NEW 67	unitName = discoverNameOfDefaultPersistenceUnit();	×
68	}
69
NEW 70	return new InjectionPoint(jpaClass, unitName, true);	×
71	}
72
73	@NonNull
74	private String discoverNameOfDefaultPersistenceUnit() {
NEW 75	if (defaultPersistenceUnitName != null) {	×
NEW 76	return defaultPersistenceUnitName;	×
77	}
78
NEW 79	defaultPersistenceUnitName = "<unknown>";	×
NEW 80	InputStream xmlFile = getClass().getResourceAsStream("/META-INF/persistence.xml");	×
81
NEW 82	if (xmlFile != null) {	×
83	try {
NEW 84	SAXParser parser = SAXParserFactory.newInstance().newSAXParser();	×
NEW 85	parser.parse(xmlFile, new DefaultHandler() {	×
86	@Override
87	public void startElement(String uri, String localName, String qName, Attributes attributes) {
NEW 88	if ("persistence-unit".equals(qName)) {	×
NEW 89	defaultPersistenceUnitName = attributes.getValue("name");	×
90	}
NEW 91	}	×
92	});
NEW 93	xmlFile.close();	×
NEW 94	} catch (ParserConfigurationException \| SAXException \| IOException ignore) {	×
NEW 95	}	×
96	}
97
NEW 98	return defaultPersistenceUnitName;	×
99	}
100
101	@Nullable
102	Object createAndRegisterDependency(@NonNull Class<?> dependencyType, @NonNull InjectionPoint dependencyKey,
103	@Nullable InjectionProvider injectionProvider) {
NEW 104	if (injectionProvider != null) {	×
NEW 105	if (dependencyType == EntityManagerFactory.class	×
NEW 106	&& injectionProvider.hasAnnotation(PersistenceUnit.class)) {	×
NEW 107	InjectionPoint injectionPoint = createFactoryInjectionPoint(dependencyKey);	×
NEW 108	return createAndRegisterEntityManagerFactory(injectionPoint);	×
109	}
110
NEW 111	if (dependencyType == EntityManager.class && injectionProvider.hasAnnotation(PersistenceContext.class)) {	×
NEW 112	return createAndRegisterEntityManager(dependencyKey);	×
113	}
114	}
115
NEW 116	return null;	×
117	}
118
119	@NonNull
120	private InjectionPoint createFactoryInjectionPoint(@NonNull InjectionPoint injectionPoint) {
NEW 121	String persistenceUnitName = getNameOfPersistentUnit(injectionPoint.name);	×
NEW 122	return new InjectionPoint(EntityManagerFactory.class, persistenceUnitName, injectionPoint.qualified);	×
123	}
124
125	@NonNull
126	private String getNameOfPersistentUnit(@Nullable String injectionPointName) {
NEW 127	return injectionPointName != null && !injectionPointName.isEmpty() ? injectionPointName	×
NEW 128	: discoverNameOfDefaultPersistenceUnit();	×
129	}
130
131	@NonNull
132	private static EntityManagerFactory createAndRegisterEntityManagerFactory(@NonNull InjectionPoint injectionPoint) {
NEW 133	String persistenceUnitName = injectionPoint.name;	×
NEW 134	EntityManagerFactory emFactory = Persistence.createEntityManagerFactory(persistenceUnitName);	×
NEW 135	InjectionState.saveGlobalDependency(injectionPoint, emFactory);	×
NEW 136	return emFactory;	×
137	}
138
139	@NonNull
140	private EntityManager createAndRegisterEntityManager(@NonNull InjectionPoint injectionPoint) {
NEW 141	InjectionPoint emFactoryKey = createFactoryInjectionPoint(injectionPoint);	×
NEW 142	EntityManagerFactory emFactory = InjectionState.getGlobalDependency(emFactoryKey);	×
143
NEW 144	if (emFactory == null) {	×
NEW 145	emFactory = createAndRegisterEntityManagerFactory(emFactoryKey);	×
146	}
147
NEW 148	EntityManager entityManager = emFactory.createEntityManager();	×
NEW 149	injectionState.saveInstantiatedDependency(injectionPoint, entityManager);	×
NEW 150	return entityManager;	×
151	}
152	}

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