hazendaz / jmockit1 / 422

Committed 30 Oct 2025 09:23PM UTC coverage: 72.22% (+0.02%) from 72.198%

Build # 422

Build Type

push

github

Committed by

hazendaz

Commit Message

Combine catches

Run Details

5674 of 8356 branches covered (67.9%)

Branch coverage included in aggregate %.

0 of 1 new or added line in 1 file covered. (0.0%)

52 existing lines in 8 files now uncovered.

11929 of 16018 relevant lines covered (74.47%)

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

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

hazendaz / jmockit1 / 422

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