hazendaz / jmockit1 / 396

Committed 29 Oct 2025 01:10PM UTC coverage: 72.206% (-0.02%) from 72.226%

Build # 396

Build Type

Pull #395

github

Committed by

hazendaz

Commit Message

Migrate jmockit tests away from javax to jakarta

Pull Request Pull Request #395: Migrate jmockit tests away from javax to jakarta

Run Details

5683 of 8360 branches covered (67.98%)

Branch coverage included in aggregate %.

11946 of 16055 relevant lines covered (74.41%)

0.74 hits per line

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

75.41

/main/src/main/java/mockit/internal/injection/full/FullInjection.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.lang.reflect.Modifier.isStatic;

import static mockit.internal.injection.InjectionPoint.JAKARTA_CONVERSATION_CLASS;
import static mockit.internal.injection.InjectionPoint.JAKARTA_INJECT_CLASS;
import static mockit.internal.injection.InjectionPoint.JAKARTA_PERSISTENCE_UNIT_CLASS;
import static mockit.internal.injection.InjectionPoint.JAKARTA_RESOURCE_CLASS;
import static mockit.internal.injection.InjectionPoint.JAKARTA_SERVLET_CLASS;
import static mockit.internal.injection.InjectionPoint.JAVAX_CONVERSATION_CLASS;
import static mockit.internal.injection.InjectionPoint.JAVAX_INJECT_CLASS;
import static mockit.internal.injection.InjectionPoint.JAVAX_PERSISTENCE_UNIT_CLASS;
import static mockit.internal.injection.InjectionPoint.JAVAX_RESOURCE_CLASS;
import static mockit.internal.injection.InjectionPoint.JAVAX_SERVLET_CLASS;
import static mockit.internal.reflection.ConstructorReflection.newInstanceUsingDefaultConstructorIfAvailable;
import static mockit.internal.util.Utilities.getClassType;

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

import java.lang.annotation.Annotation;
import java.lang.reflect.ParameterizedType;
import java.lang.reflect.Type;
import java.lang.reflect.TypeVariable;
import java.util.logging.Logger;

import javax.sql.CommonDataSource;

import mockit.asm.jvmConstants.Access;
import mockit.internal.injection.InjectionPoint;
import mockit.internal.injection.InjectionProvider;
import mockit.internal.injection.InjectionState;
import mockit.internal.injection.Injector;
import mockit.internal.injection.TestedClass;
import mockit.internal.injection.TestedObjectCreation;

/**
 * Responsible for recursive injection of dependencies into a <code>@Tested(fullyInitialized = true)</code> object.
 */
public final class FullInjection {
    private static final int INVALID_TYPES = Access.ABSTRACT + Access.ANNOTATION + Access.ENUM;

    @NonNull
    private final InjectionState injectionState;

    @NonNull
    private final String testedClassName;

    @NonNull
    private final String testedName;

    @Nullable
    private final ServletJakartaDependencies servletJakartaDependencies;
    @Nullable
    private final ServletJavaxDependencies servletJavaxDependencies;

    @Nullable
    private final JPAJakartaDependencies jpaJakartaDependencies;
    @Nullable
    private final JPAJavaxDependencies jpaJavaxDependencies;

    @Nullable
    private Class<?> dependencyClass;

    @Nullable
    private InjectionProvider parentInjectionProvider;

    public FullInjection(@NonNull InjectionState injectionState, @NonNull Class<?> testedClass,
            @NonNull String testedName) {
        this.injectionState = injectionState;
        testedClassName = testedClass.getSimpleName();
        this.testedName = testedName;
        servletJakartaDependencies = JAKARTA_SERVLET_CLASS == null ? null
                : new ServletJakartaDependencies(injectionState);
        servletJavaxDependencies = JAVAX_SERVLET_CLASS == null ? null : new ServletJavaxDependencies(injectionState);
        jpaJakartaDependencies = JAKARTA_PERSISTENCE_UNIT_CLASS == null ? null
                : new JPAJakartaDependencies(injectionState);
        jpaJavaxDependencies = JAVAX_PERSISTENCE_UNIT_CLASS == null ? null : new JPAJavaxDependencies(injectionState);
    }

    @Nullable
    public Object createOrReuseInstance(@NonNull TestedClass testedClass, @NonNull Injector injector,
            @Nullable InjectionProvider injectionProvider, @Nullable String qualifiedName) {
        setInjectionProvider(injectionProvider);

        InjectionPoint injectionPoint = getInjectionPoint(testedClass, injectionProvider, qualifiedName);
        Object dependency = injectionState.getInstantiatedDependency(testedClass, injectionPoint);

        if (dependency != null) {
            return dependency;
        }

        Class<?> typeToInject = dependencyClass;

        if (typeToInject == Logger.class) {
            return createLogger(testedClass);
        }

        if (typeToInject == null || !isInstantiableType(typeToInject)) {
            return null;
        }

        return createInstance(testedClass, injector, injectionProvider, injectionPoint);
    }

    public void setInjectionProvider(@Nullable InjectionProvider injectionProvider) {
        if (injectionProvider != null) {
            injectionProvider.parent = parentInjectionProvider;
        }

        parentInjectionProvider = injectionProvider;
    }

    @NonNull
    private InjectionPoint getInjectionPoint(@NonNull TestedClass testedClass,
            @Nullable InjectionProvider injectionProvider, @Nullable String qualifiedName) {
        if (injectionProvider == null) {
            dependencyClass = testedClass.targetClass;
            return new InjectionPoint(dependencyClass, qualifiedName, true);
        }

        Type dependencyType = injectionProvider.getDeclaredType();

        if (dependencyType instanceof TypeVariable<?>) {
            dependencyType = testedClass.reflection.resolveTypeVariable((TypeVariable<?>) dependencyType);
            dependencyClass = getClassType(dependencyType);
        } else {
            dependencyClass = injectionProvider.getClassOfDeclaredType();
        }

        if (qualifiedName != null && !qualifiedName.isEmpty()) {
            return new InjectionPoint(dependencyClass, qualifiedName, true);
        }

        if (jpaJakartaDependencies != null && JPAJakartaDependencies.isApplicable(dependencyClass)) {
            for (Annotation annotation : injectionProvider.getAnnotations()) {
                InjectionPoint injectionPoint = jpaJakartaDependencies.getInjectionPointIfAvailable(annotation);

                if (injectionPoint != null) {
                    return injectionPoint;
                }
            }
        }

        if (jpaJavaxDependencies != null && JPAJavaxDependencies.isApplicable(dependencyClass)) {
            for (Annotation annotation : injectionProvider.getAnnotations()) {
                InjectionPoint injectionPoint = jpaJavaxDependencies.getInjectionPointIfAvailable(annotation);

                if (injectionPoint != null) {
                    return injectionPoint;
                }
            }
        }

        return new InjectionPoint(dependencyType, injectionProvider.getName(), false);
    }

    @NonNull
    private static Object createLogger(@NonNull TestedClass testedClass) {
        TestedClass testedClassWithLogger = testedClass.parent;
        assert testedClassWithLogger != null;
        return Logger.getLogger(testedClassWithLogger.nameOfTestedClass);
    }

    public static boolean isInstantiableType(@NonNull Class<?> type) {
        if (type.isPrimitive() || type.isArray() || type.isAnnotation()) {
            return false;
        }

        if (type.isInterface()) {
            return true;
        }

        int typeModifiers = type.getModifiers();

        if ((typeModifiers & INVALID_TYPES) != 0 || !isStatic(typeModifiers) && type.isMemberClass()) {
            return false;
        }

        return type.getClassLoader() != null;
    }

    @Nullable
    private Object createInstance(@NonNull TestedClass testedClass, @NonNull Injector injector,
            @Nullable InjectionProvider injectionProvider, @NonNull InjectionPoint injectionPoint) {
        @SuppressWarnings("ConstantConditions")
        @NonNull
        Class<?> typeToInject = dependencyClass;
        Object dependency = null;

        if (typeToInject.isInterface()) {
            dependency = createInstanceOfSupportedInterfaceIfApplicable(testedClass, typeToInject, injectionPoint,
                    injectionProvider);

            if (dependency == null && typeToInject.getClassLoader() != null) {
                Class<?> resolvedType = injectionState.resolveInterface(typeToInject);

                if (resolvedType != null && !resolvedType.isInterface()) {
                    // noinspection AssignmentToMethodParameter
                    testedClass = new TestedClass(resolvedType, resolvedType);
                    typeToInject = resolvedType;
                }
            }
        }

        if (dependency == null) {
            dependency = createAndRegisterNewInstance(typeToInject, testedClass, injector, injectionPoint,
                    injectionProvider);
        }

        return dependency;
    }

    @Nullable
    private Object createInstanceOfSupportedInterfaceIfApplicable(@NonNull TestedClass testedClass,
            @NonNull Class<?> typeToInject, @NonNull InjectionPoint injectionPoint,
            @Nullable InjectionProvider injectionProvider) {
        Object dependency = null;

        if (CommonDataSource.class.isAssignableFrom(typeToInject)) {
            dependency = createAndRegisterDataSource(testedClass, injectionPoint, injectionProvider);
        } else if (JAKARTA_INJECT_CLASS != null && typeToInject == jakarta.inject.Provider.class) {
            assert injectionProvider != null;
            dependency = createProviderJakartaInstance(injectionProvider);
        } else if (JAVAX_INJECT_CLASS != null && typeToInject == javax.inject.Provider.class) {
            assert injectionProvider != null;
            dependency = createProviderJavaxInstance(injectionProvider);
        } else if (JAKARTA_CONVERSATION_CLASS != null
                && typeToInject == jakarta.enterprise.context.Conversation.class) {
            dependency = createAndRegisterConversationJakartaInstance();
        } else if (JAVAX_CONVERSATION_CLASS != null && typeToInject == javax.enterprise.context.Conversation.class) {
            dependency = createAndRegisterConversationJavaxInstance();
        } else if (servletJakartaDependencies != null && ServletJakartaDependencies.isApplicable(typeToInject)) {
            dependency = servletJakartaDependencies.createAndRegisterDependency(typeToInject);
        } else if (servletJavaxDependencies != null && ServletJavaxDependencies.isApplicable(typeToInject)) {
            dependency = servletJavaxDependencies.createAndRegisterDependency(typeToInject);
        } else if (jpaJakartaDependencies != null && JPAJakartaDependencies.isApplicable(typeToInject)) {
            dependency = jpaJakartaDependencies.createAndRegisterDependency(typeToInject, injectionPoint,
                    injectionProvider);
        } else if (jpaJavaxDependencies != null && JPAJavaxDependencies.isApplicable(typeToInject)) {
            dependency = jpaJavaxDependencies.createAndRegisterDependency(typeToInject, injectionPoint,
                    injectionProvider);
        }

        return dependency;
    }

    @Nullable
    private Object createAndRegisterDataSource(@NonNull TestedClass testedClass, @NonNull InjectionPoint injectionPoint,
            @Nullable InjectionProvider injectionProvider) {
        if (injectionProvider == null) {
            return null;
        }

        // Check annotation is present (both jars)
        if ((JAKARTA_RESOURCE_CLASS != null && injectionProvider.hasAnnotation(jakarta.annotation.Resource.class))
                || (JAVAX_RESOURCE_CLASS != null && injectionProvider.hasAnnotation(javax.annotation.Resource.class))) {
            TestDataSource dsCreation = new TestDataSource(injectionPoint);
            CommonDataSource dataSource = dsCreation.createIfDataSourceDefinitionAvailable(testedClass);

            if (dataSource != null) {
                injectionState.saveInstantiatedDependency(injectionPoint, dataSource);
            }

            return dataSource;
        }

        return null;
    }

    @NonNull
    private Object createProviderJakartaInstance(@NonNull InjectionProvider injectionProvider) {
        ParameterizedType genericType = (ParameterizedType) injectionProvider.getDeclaredType();
        final Class<?> providedClass = (Class<?>) genericType.getActualTypeArguments()[0];

        if (providedClass.isAnnotationPresent(jakarta.inject.Singleton.class)) {
            return new jakarta.inject.Provider<Object>() {
                private Object dependency;

                @Override
                public synchronized Object get() {
                    if (dependency == null) {
                        dependency = createNewInstance(providedClass, true);
                    }

                    return dependency;
                }
            };
        }

        return (jakarta.inject.Provider<Object>) () -> createNewInstance(providedClass, false);
    }

    @NonNull
    private Object createProviderJavaxInstance(@NonNull InjectionProvider injectionProvider) {
        ParameterizedType genericType = (ParameterizedType) injectionProvider.getDeclaredType();
        final Class<?> providedClass = (Class<?>) genericType.getActualTypeArguments()[0];

        if (providedClass.isAnnotationPresent(javax.inject.Singleton.class)) {
            return new javax.inject.Provider<Object>() {
                private Object dependency;

                @Override
                public synchronized Object get() {
                    if (dependency == null) {
                        dependency = createNewInstance(providedClass, true);
                    }

                    return dependency;
                }
            };
        }

        return (javax.inject.Provider<Object>) () -> createNewInstance(providedClass, false);
    }

    @Nullable
    private Object createNewInstance(@NonNull Class<?> classToInstantiate, boolean required) {
        if (classToInstantiate.isInterface()) {
            return null;
        }

        if (classToInstantiate.getClassLoader() == null) {
            return newInstanceUsingDefaultConstructorIfAvailable(classToInstantiate);
        }

        return new TestedObjectCreation(injectionState, this, classToInstantiate).create(required, false);
    }

    @NonNull
    private Object createAndRegisterConversationJakartaInstance() {
        jakarta.enterprise.context.Conversation conversation = new TestConversationJakarta();

        InjectionPoint injectionPoint = new InjectionPoint(jakarta.enterprise.context.Conversation.class);
        injectionState.saveInstantiatedDependency(injectionPoint, conversation);
        return conversation;
    }

    @NonNull
    private Object createAndRegisterConversationJavaxInstance() {
        javax.enterprise.context.Conversation conversation = new TestConversationJavax();

        InjectionPoint injectionPoint = new InjectionPoint(javax.enterprise.context.Conversation.class);
        injectionState.saveInstantiatedDependency(injectionPoint, conversation);
        return conversation;
    }

    @Nullable
    private Object createAndRegisterNewInstance(@NonNull Class<?> typeToInstantiate, @NonNull TestedClass testedClass,
            @NonNull Injector injector, @NonNull InjectionPoint injectionPoint,
            @Nullable InjectionProvider injectionProvider) {
        Object dependency = createNewInstance(typeToInstantiate,
                injectionProvider != null && injectionProvider.isRequired());

        if (dependency != null) {
            if (injectionPoint.name == null) {
                assert injectionProvider != null;
                injectionPoint = new InjectionPoint(injectionPoint.type, injectionProvider.getName());
            }

            registerNewInstance(testedClass, injector, injectionPoint, dependency);
        }

        return dependency;
    }

    private void registerNewInstance(@NonNull TestedClass testedClass, @NonNull Injector injector,
            @NonNull InjectionPoint injectionPoint, @NonNull Object dependency) {
        injectionState.saveInstantiatedDependency(injectionPoint, dependency);

        Class<?> instantiatedClass = dependency.getClass();

        if (testedClass.isClassFromSameModuleOrSystemAsTestedClass(instantiatedClass)) {
            injector.fillOutDependenciesRecursively(dependency, testedClass);
            injectionState.lifecycleMethods.findLifecycleMethods(instantiatedClass);
            injectionState.lifecycleMethods.executeInitializationMethodsIfAny(instantiatedClass, dependency);
        }
    }

    @Override
    public String toString() {
        String description = "@Tested object \"" + testedClassName + ' ' + testedName + '"';

        if (parentInjectionProvider != null) {
            InjectionProvider injectionProvider = parentInjectionProvider.parent;

            if (injectionProvider != null) {
                description = injectionProvider + "\r\n  of " + description;
            }
        }

        return description;
    }

    public void clear() {
        parentInjectionProvider = null;
    }
}

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.lang.reflect.Modifier.isStatic;
8
9	import static mockit.internal.injection.InjectionPoint.JAKARTA_CONVERSATION_CLASS;
10	import static mockit.internal.injection.InjectionPoint.JAKARTA_INJECT_CLASS;
11	import static mockit.internal.injection.InjectionPoint.JAKARTA_PERSISTENCE_UNIT_CLASS;
12	import static mockit.internal.injection.InjectionPoint.JAKARTA_RESOURCE_CLASS;
13	import static mockit.internal.injection.InjectionPoint.JAKARTA_SERVLET_CLASS;
14	import static mockit.internal.injection.InjectionPoint.JAVAX_CONVERSATION_CLASS;
15	import static mockit.internal.injection.InjectionPoint.JAVAX_INJECT_CLASS;
16	import static mockit.internal.injection.InjectionPoint.JAVAX_PERSISTENCE_UNIT_CLASS;
17	import static mockit.internal.injection.InjectionPoint.JAVAX_RESOURCE_CLASS;
18	import static mockit.internal.injection.InjectionPoint.JAVAX_SERVLET_CLASS;
19	import static mockit.internal.reflection.ConstructorReflection.newInstanceUsingDefaultConstructorIfAvailable;
20	import static mockit.internal.util.Utilities.getClassType;
21
22	import edu.umd.cs.findbugs.annotations.NonNull;
23	import edu.umd.cs.findbugs.annotations.Nullable;
24
25	import java.lang.annotation.Annotation;
26	import java.lang.reflect.ParameterizedType;
27	import java.lang.reflect.Type;
28	import java.lang.reflect.TypeVariable;
29	import java.util.logging.Logger;
30
31	import javax.sql.CommonDataSource;
32
33	import mockit.asm.jvmConstants.Access;
34	import mockit.internal.injection.InjectionPoint;
35	import mockit.internal.injection.InjectionProvider;
36	import mockit.internal.injection.InjectionState;
37	import mockit.internal.injection.Injector;
38	import mockit.internal.injection.TestedClass;
39	import mockit.internal.injection.TestedObjectCreation;
40
41	/**
42	* Responsible for recursive injection of dependencies into a <code>@Tested(fullyInitialized = true)</code> object.
43	*/
44	public final class FullInjection {	1✔
45	private static final int INVALID_TYPES = Access.ABSTRACT + Access.ANNOTATION + Access.ENUM;
46
47	@NonNull
48	private final InjectionState injectionState;
49
50	@NonNull
51	private final String testedClassName;
52
53	@NonNull
54	private final String testedName;
55
56	@Nullable
57	private final ServletJakartaDependencies servletJakartaDependencies;
58	@Nullable
59	private final ServletJavaxDependencies servletJavaxDependencies;
60
61	@Nullable
62	private final JPAJakartaDependencies jpaJakartaDependencies;
63	@Nullable
64	private final JPAJavaxDependencies jpaJavaxDependencies;
65
66	@Nullable
67	private Class<?> dependencyClass;
68
69	@Nullable
70	private InjectionProvider parentInjectionProvider;
71
72	public FullInjection(@NonNull InjectionState injectionState, @NonNull Class<?> testedClass,
73	@NonNull String testedName) {	1✔
74	this.injectionState = injectionState;	1✔
75	testedClassName = testedClass.getSimpleName();	1✔
76	this.testedName = testedName;	1✔
77	servletJakartaDependencies = JAKARTA_SERVLET_CLASS == null ? null	1!
78	: new ServletJakartaDependencies(injectionState);	1✔
79	servletJavaxDependencies = JAVAX_SERVLET_CLASS == null ? null : new ServletJavaxDependencies(injectionState);	1!
80	jpaJakartaDependencies = JAKARTA_PERSISTENCE_UNIT_CLASS == null ? null	1!
81	: new JPAJakartaDependencies(injectionState);	1✔
82	jpaJavaxDependencies = JAVAX_PERSISTENCE_UNIT_CLASS == null ? null : new JPAJavaxDependencies(injectionState);	1!
83	}	1✔
84
85	@Nullable
86	public Object createOrReuseInstance(@NonNull TestedClass testedClass, @NonNull Injector injector,
87	@Nullable InjectionProvider injectionProvider, @Nullable String qualifiedName) {
88	setInjectionProvider(injectionProvider);	1✔
89
90	InjectionPoint injectionPoint = getInjectionPoint(testedClass, injectionProvider, qualifiedName);	1✔
91	Object dependency = injectionState.getInstantiatedDependency(testedClass, injectionPoint);	1✔
92
93	if (dependency != null) {	1✔
94	return dependency;	1✔
95	}
96
97	Class<?> typeToInject = dependencyClass;	1✔
98
99	if (typeToInject == Logger.class) {	1✔
100	return createLogger(testedClass);	1✔
101	}
102
103	if (typeToInject == null \|\| !isInstantiableType(typeToInject)) {	1!
104	return null;	1✔
105	}
106
107	return createInstance(testedClass, injector, injectionProvider, injectionPoint);	1✔
108	}
109
110	public void setInjectionProvider(@Nullable InjectionProvider injectionProvider) {
111	if (injectionProvider != null) {	1✔
112	injectionProvider.parent = parentInjectionProvider;	1✔
113	}
114
115	parentInjectionProvider = injectionProvider;	1✔
116	}	1✔
117
118	@NonNull
119	private InjectionPoint getInjectionPoint(@NonNull TestedClass testedClass,
120	@Nullable InjectionProvider injectionProvider, @Nullable String qualifiedName) {
121	if (injectionProvider == null) {	1✔
122	dependencyClass = testedClass.targetClass;	1✔
123	return new InjectionPoint(dependencyClass, qualifiedName, true);	1✔
124	}
125
126	Type dependencyType = injectionProvider.getDeclaredType();	1✔
127
128	if (dependencyType instanceof TypeVariable<?>) {	1✔
129	dependencyType = testedClass.reflection.resolveTypeVariable((TypeVariable<?>) dependencyType);	1✔
130	dependencyClass = getClassType(dependencyType);	1✔
131	} else {
132	dependencyClass = injectionProvider.getClassOfDeclaredType();	1✔
133	}
134
135	if (qualifiedName != null && !qualifiedName.isEmpty()) {	1!
136	return new InjectionPoint(dependencyClass, qualifiedName, true);	1✔
137	}
138
139	if (jpaJakartaDependencies != null && JPAJakartaDependencies.isApplicable(dependencyClass)) {	1!
140	for (Annotation annotation : injectionProvider.getAnnotations()) {	1✔
141	InjectionPoint injectionPoint = jpaJakartaDependencies.getInjectionPointIfAvailable(annotation);	1✔
142
143	if (injectionPoint != null) {	1!
144	return injectionPoint;	1✔
145	}
146	}
147	}
148
149	if (jpaJavaxDependencies != null && JPAJavaxDependencies.isApplicable(dependencyClass)) {	1!
150	for (Annotation annotation : injectionProvider.getAnnotations()) {	×
151	InjectionPoint injectionPoint = jpaJavaxDependencies.getInjectionPointIfAvailable(annotation);	×
152
153	if (injectionPoint != null) {	×
154	return injectionPoint;	×
155	}
156	}
157	}
158
159	return new InjectionPoint(dependencyType, injectionProvider.getName(), false);	1✔
160	}
161
162	@NonNull
163	private static Object createLogger(@NonNull TestedClass testedClass) {
164	TestedClass testedClassWithLogger = testedClass.parent;	1✔
165	assert testedClassWithLogger != null;	1!
166	return Logger.getLogger(testedClassWithLogger.nameOfTestedClass);	1✔
167	}
168
169	public static boolean isInstantiableType(@NonNull Class<?> type) {
170	if (type.isPrimitive() \|\| type.isArray() \|\| type.isAnnotation()) {	1!
171	return false;	1✔
172	}
173
174	if (type.isInterface()) {	1✔
175	return true;	1✔
176	}
177
178	int typeModifiers = type.getModifiers();	1✔
179
180	if ((typeModifiers & INVALID_TYPES) != 0 \|\| !isStatic(typeModifiers) && type.isMemberClass()) {	1!
181	return false;	1✔
182	}
183
184	return type.getClassLoader() != null;	1✔
185	}
186
187	@Nullable
188	private Object createInstance(@NonNull TestedClass testedClass, @NonNull Injector injector,
189	@Nullable InjectionProvider injectionProvider, @NonNull InjectionPoint injectionPoint) {
190	@SuppressWarnings("ConstantConditions")
191	@NonNull
192	Class<?> typeToInject = dependencyClass;	1✔
193	Object dependency = null;	1✔
194
195	if (typeToInject.isInterface()) {	1✔
196	dependency = createInstanceOfSupportedInterfaceIfApplicable(testedClass, typeToInject, injectionPoint,	1✔
197	injectionProvider);
198
199	if (dependency == null && typeToInject.getClassLoader() != null) {	1✔
200	Class<?> resolvedType = injectionState.resolveInterface(typeToInject);	1✔
201
202	if (resolvedType != null && !resolvedType.isInterface()) {	1!
203	// noinspection AssignmentToMethodParameter
204	testedClass = new TestedClass(resolvedType, resolvedType);	1✔
205	typeToInject = resolvedType;	1✔
206	}
207	}
208	}
209
210	if (dependency == null) {	1✔
211	dependency = createAndRegisterNewInstance(typeToInject, testedClass, injector, injectionPoint,	1✔
212	injectionProvider);
213	}
214
215	return dependency;	1✔
216	}
217
218	@Nullable
219	private Object createInstanceOfSupportedInterfaceIfApplicable(@NonNull TestedClass testedClass,
220	@NonNull Class<?> typeToInject, @NonNull InjectionPoint injectionPoint,
221	@Nullable InjectionProvider injectionProvider) {
222	Object dependency = null;	1✔
223
224	if (CommonDataSource.class.isAssignableFrom(typeToInject)) {	1✔
225	dependency = createAndRegisterDataSource(testedClass, injectionPoint, injectionProvider);	1✔
226	} else if (JAKARTA_INJECT_CLASS != null && typeToInject == jakarta.inject.Provider.class) {	1!
227	assert injectionProvider != null;	1!
228	dependency = createProviderJakartaInstance(injectionProvider);	1✔
229	} else if (JAVAX_INJECT_CLASS != null && typeToInject == javax.inject.Provider.class) {	1!
230	assert injectionProvider != null;	×
231	dependency = createProviderJavaxInstance(injectionProvider);	×
232	} else if (JAKARTA_CONVERSATION_CLASS != null	1!
233	&& typeToInject == jakarta.enterprise.context.Conversation.class) {
234	dependency = createAndRegisterConversationJakartaInstance();	1✔
235	} else if (JAVAX_CONVERSATION_CLASS != null && typeToInject == javax.enterprise.context.Conversation.class) {	1!
236	dependency = createAndRegisterConversationJavaxInstance();	×
237	} else if (servletJakartaDependencies != null && ServletJakartaDependencies.isApplicable(typeToInject)) {	1!
238	dependency = servletJakartaDependencies.createAndRegisterDependency(typeToInject);	1✔
239	} else if (servletJavaxDependencies != null && ServletJavaxDependencies.isApplicable(typeToInject)) {	1!
240	dependency = servletJavaxDependencies.createAndRegisterDependency(typeToInject);	×
241	} else if (jpaJakartaDependencies != null && JPAJakartaDependencies.isApplicable(typeToInject)) {	1!
242	dependency = jpaJakartaDependencies.createAndRegisterDependency(typeToInject, injectionPoint,	1✔
243	injectionProvider);
244	} else if (jpaJavaxDependencies != null && JPAJavaxDependencies.isApplicable(typeToInject)) {	1!
245	dependency = jpaJavaxDependencies.createAndRegisterDependency(typeToInject, injectionPoint,	×
246	injectionProvider);
247	}
248
249	return dependency;	1✔
250	}
251
252	@Nullable
253	private Object createAndRegisterDataSource(@NonNull TestedClass testedClass, @NonNull InjectionPoint injectionPoint,
254	@Nullable InjectionProvider injectionProvider) {
255	if (injectionProvider == null) {	1!
256	return null;	×
257	}
258
259	// Check annotation is present (both jars)
260	if ((JAKARTA_RESOURCE_CLASS != null && injectionProvider.hasAnnotation(jakarta.annotation.Resource.class))	1!
261	\|\| (JAVAX_RESOURCE_CLASS != null && injectionProvider.hasAnnotation(javax.annotation.Resource.class))) {	1!
262	TestDataSource dsCreation = new TestDataSource(injectionPoint);	1✔
263	CommonDataSource dataSource = dsCreation.createIfDataSourceDefinitionAvailable(testedClass);	1✔
264
265	if (dataSource != null) {	1!
266	injectionState.saveInstantiatedDependency(injectionPoint, dataSource);	1✔
267	}
268
269	return dataSource;	1✔
270	}
271
272	return null;	1✔
273	}
274
275	@NonNull
276	private Object createProviderJakartaInstance(@NonNull InjectionProvider injectionProvider) {
277	ParameterizedType genericType = (ParameterizedType) injectionProvider.getDeclaredType();	1✔
278	final Class<?> providedClass = (Class<?>) genericType.getActualTypeArguments()[0];	1✔
279
280	if (providedClass.isAnnotationPresent(jakarta.inject.Singleton.class)) {	1✔
281	return new jakarta.inject.Provider<Object>() {	1✔
282	private Object dependency;
283
284	@Override
285	public synchronized Object get() {
286	if (dependency == null) {	1✔
287	dependency = createNewInstance(providedClass, true);	1✔
288	}
289
290	return dependency;	1✔
291	}
292	};
293	}
294
295	return (jakarta.inject.Provider<Object>) () -> createNewInstance(providedClass, false);	1✔
296	}
297
298	@NonNull
299	private Object createProviderJavaxInstance(@NonNull InjectionProvider injectionProvider) {
300	ParameterizedType genericType = (ParameterizedType) injectionProvider.getDeclaredType();	×
301	final Class<?> providedClass = (Class<?>) genericType.getActualTypeArguments()[0];	×
302
303	if (providedClass.isAnnotationPresent(javax.inject.Singleton.class)) {	×
304	return new javax.inject.Provider<Object>() {	×
305	private Object dependency;
306
307	@Override
308	public synchronized Object get() {
309	if (dependency == null) {	×
310	dependency = createNewInstance(providedClass, true);	×
311	}
312
313	return dependency;	×
314	}
315	};
316	}
317
318	return (javax.inject.Provider<Object>) () -> createNewInstance(providedClass, false);	×
319	}
320
321	@Nullable
322	private Object createNewInstance(@NonNull Class<?> classToInstantiate, boolean required) {
323	if (classToInstantiate.isInterface()) {	1✔
324	return null;	1✔
325	}
326
327	if (classToInstantiate.getClassLoader() == null) {	1!
328	return newInstanceUsingDefaultConstructorIfAvailable(classToInstantiate);	×
329	}
330
331	return new TestedObjectCreation(injectionState, this, classToInstantiate).create(required, false);	1✔
332	}
333
334	@NonNull
335	private Object createAndRegisterConversationJakartaInstance() {
336	jakarta.enterprise.context.Conversation conversation = new TestConversationJakarta();	1✔
337
338	InjectionPoint injectionPoint = new InjectionPoint(jakarta.enterprise.context.Conversation.class);	1✔
339	injectionState.saveInstantiatedDependency(injectionPoint, conversation);	1✔
340	return conversation;	1✔
341	}
342
343	@NonNull
344	private Object createAndRegisterConversationJavaxInstance() {
345	javax.enterprise.context.Conversation conversation = new TestConversationJavax();	×
346
347	InjectionPoint injectionPoint = new InjectionPoint(javax.enterprise.context.Conversation.class);	×
348	injectionState.saveInstantiatedDependency(injectionPoint, conversation);	×
349	return conversation;	×
350	}
351
352	@Nullable
353	private Object createAndRegisterNewInstance(@NonNull Class<?> typeToInstantiate, @NonNull TestedClass testedClass,
354	@NonNull Injector injector, @NonNull InjectionPoint injectionPoint,
355	@Nullable InjectionProvider injectionProvider) {
356	Object dependency = createNewInstance(typeToInstantiate,	1✔
357	injectionProvider != null && injectionProvider.isRequired());	1✔
358
359	if (dependency != null) {	1✔
360	if (injectionPoint.name == null) {	1!
361	assert injectionProvider != null;	×
362	injectionPoint = new InjectionPoint(injectionPoint.type, injectionProvider.getName());	×
363	}
364
365	registerNewInstance(testedClass, injector, injectionPoint, dependency);	1✔
366	}
367
368	return dependency;	1✔
369	}
370
371	private void registerNewInstance(@NonNull TestedClass testedClass, @NonNull Injector injector,
372	@NonNull InjectionPoint injectionPoint, @NonNull Object dependency) {
373	injectionState.saveInstantiatedDependency(injectionPoint, dependency);	1✔
374
375	Class<?> instantiatedClass = dependency.getClass();	1✔
376
377	if (testedClass.isClassFromSameModuleOrSystemAsTestedClass(instantiatedClass)) {	1!
378	injector.fillOutDependenciesRecursively(dependency, testedClass);	1✔
379	injectionState.lifecycleMethods.findLifecycleMethods(instantiatedClass);	1✔
380	injectionState.lifecycleMethods.executeInitializationMethodsIfAny(instantiatedClass, dependency);	1✔
381	}
382	}	1✔
383
384	@Override
385	public String toString() {
386	String description = "@Tested object \"" + testedClassName + ' ' + testedName + '"';	1✔
387
388	if (parentInjectionProvider != null) {	1!
389	InjectionProvider injectionProvider = parentInjectionProvider.parent;	1✔
390
391	if (injectionProvider != null) {	1!
392	description = injectionProvider + "\r\n of " + description;	1✔
393	}
394	}
395
396	return description;	1✔
397	}
398
399	public void clear() {
400	parentInjectionProvider = null;	1✔
401	}	1✔
402	}

hazendaz / jmockit1 / 396

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