hazendaz / jmockit1 / 551

Committed 29 Nov 2025 11:34PM UTC coverage: 72.096% (-0.1%) from 72.2%

Build # 551

Build Type

push

github

Committed by

web-flow

Commit Message

Merge pull request #424 from hazendaz/expectedExceptionAnnotation

Introduction of 'ExpectedException' annotation

Run Details

5685 of 8390 branches covered (67.76%)

Branch coverage included in aggregate %.

22 of 30 new or added lines in 1 file covered. (73.33%)

14 existing lines in 3 files now uncovered.

11933 of 16047 relevant lines covered (74.36%)

0.74 hits per line

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

79.61

/main/src/main/java/mockit/integration/junit4/JUnit4TestRunnerDecorator.java

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

import static mockit.internal.util.StackTrace.filterStackTrace;

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

import java.lang.reflect.Method;

import mockit.integration.TestRunnerDecorator;
import mockit.internal.expectations.RecordAndReplayExecution;
import mockit.internal.faking.FakeInvocation;
import mockit.internal.state.SavePoint;
import mockit.internal.state.TestRun;

import org.junit.After;
import org.junit.AfterClass;
import org.junit.Before;
import org.junit.BeforeClass;
import org.junit.Test;
import org.junit.runners.model.FrameworkMethod;

final class JUnit4TestRunnerDecorator extends TestRunnerDecorator {
    @Nullable
    Object invokeExplosively(@NonNull FakeInvocation invocation, @Nullable Object target, Object... params)
            throws Throwable {
        FrameworkMethod it = invocation.getInvokedInstance();
        assert it != null;

        // A @BeforeClass/@AfterClass method:
        if (target == null) {
            try {
                return executeClassMethod(invocation, params);
            } catch (Throwable t) {
                filterStackTrace(t);
                throw t;
            }
        }

        handleMockingOutsideTestMethods(target);

        // A @Before/@After method:
        if (it.getAnnotation(Test.class) == null) {
            if (shouldPrepareForNextTest && it.getAnnotation(Before.class) != null) {
                prepareToExecuteSetupMethod(target);
            }

            TestRun.setRunningIndividualTest(target);

            try {
                invocation.prepareToProceedFromNonRecursiveMock();
                return it.invokeExplosively(target, params);
            } catch (Throwable t) {
                // noinspection ThrowableNotThrown
                RecordAndReplayExecution.endCurrentReplayIfAny();
                filterStackTrace(t);
                throw t;
            } finally {
                if (it.getAnnotation(After.class) != null) {
                    shouldPrepareForNextTest = true;
                }
            }
        }

        if (shouldPrepareForNextTest) {
            prepareForNextTest();
        }

        shouldPrepareForNextTest = true;

        try {
            executeTestMethod(invocation, target, params);
            return null; // it's a test method, therefore has void return type
        } catch (Throwable t) {
            filterStackTrace(t);
            throw t;
        } finally {
            TestRun.finishCurrentTestExecution();
        }
    }

    @Nullable
    private static Object executeClassMethod(@NonNull FakeInvocation inv, @NonNull Object[] params) throws Throwable {
        FrameworkMethod method = inv.getInvokedInstance();
        assert method != null;
        handleMockingOutsideTests(method);

        TestRun.clearCurrentTestInstance();
        inv.prepareToProceedFromNonRecursiveMock();

        return method.invokeExplosively(null, params);
    }

    private void prepareToExecuteSetupMethod(@NonNull Object target) {
        discardTestLevelMockedTypes();
        prepareForNextTest();
        shouldPrepareForNextTest = false;
        createInstancesForTestedFieldsBeforeSetup(target);
    }

    private static void handleMockingOutsideTests(@NonNull FrameworkMethod it) {
        Class<?> testClass = it.getMethod().getDeclaringClass();

        TestRun.enterNoMockingZone();

        try {
            Class<?> currentTestClass = TestRun.getCurrentTestClass();

            if (currentTestClass != null && testClass.isAssignableFrom(currentTestClass)
                    && it.getAnnotation(AfterClass.class) != null) {
                cleanUpMocksFromPreviousTest();
            }

            if (it.getAnnotation(BeforeClass.class) != null) {
                updateTestClassState(null, testClass);
            }
        } finally {
            TestRun.exitNoMockingZone();
        }
    }

    private static void handleMockingOutsideTestMethods(@NonNull Object target) {
        Class<?> testClass = target.getClass();

        TestRun.enterNoMockingZone();

        try {
            updateTestClassState(target, testClass);
        } finally {
            TestRun.exitNoMockingZone();
        }
    }

    private static void executeTestMethod(@NonNull FakeInvocation invocation, @NonNull Object testInstance,
            @Nullable Object... parameters) throws Throwable {
        SavePoint savePoint = new SavePoint();

        TestRun.setRunningIndividualTest(testInstance);

        FrameworkMethod it = invocation.getInvokedInstance();
        assert it != null;
        Method testMethod = it.getMethod();
        Throwable testFailure = null;
        boolean testFailureExpected = false;

        try {
            createInstancesForTestedFieldsFromBaseClasses(testInstance);
            Object[] annotatedParameters = createInstancesForAnnotatedParameters(testInstance, testMethod, parameters);
            createInstancesForTestedFields(testInstance);

            invocation.prepareToProceedFromNonRecursiveMock();

            Object[] params = annotatedParameters == null ? parameters : annotatedParameters;
            it.invokeExplosively(testInstance, params);
        } catch (Throwable thrownByTest) {
            testFailure = thrownByTest;
            Class<?> expectedType = testMethod.getAnnotation(Test.class).expected();
            testFailureExpected = expectedType.isAssignableFrom(thrownByTest.getClass());
        } finally {
            concludeTestMethodExecution(savePoint, testFailure, testFailureExpected);
        }
    }
}

1	/*
2	* MIT License
3	* Copyright (c) 2006-2025 JMockit developers
4	* See LICENSE file for full license text.
5	*/
6	package mockit.integration.junit4;
7
8	import static mockit.internal.util.StackTrace.filterStackTrace;
9
10	import edu.umd.cs.findbugs.annotations.NonNull;
11	import edu.umd.cs.findbugs.annotations.Nullable;
12
13	import java.lang.reflect.Method;
14
15	import mockit.integration.TestRunnerDecorator;
16	import mockit.internal.expectations.RecordAndReplayExecution;
17	import mockit.internal.faking.FakeInvocation;
18	import mockit.internal.state.SavePoint;
19	import mockit.internal.state.TestRun;
20
21	import org.junit.After;
22	import org.junit.AfterClass;
23	import org.junit.Before;
24	import org.junit.BeforeClass;
25	import org.junit.Test;
26	import org.junit.runners.model.FrameworkMethod;
27
28	final class JUnit4TestRunnerDecorator extends TestRunnerDecorator {	1✔
29	@Nullable
30	Object invokeExplosively(@NonNull FakeInvocation invocation, @Nullable Object target, Object... params)
31	throws Throwable {
32	FrameworkMethod it = invocation.getInvokedInstance();	1✔
33	assert it != null;	1!
34
35	// A @BeforeClass/@AfterClass method:
36	if (target == null) {	1✔
37	try {
38	return executeClassMethod(invocation, params);	1✔
39	} catch (Throwable t) {	×
40	filterStackTrace(t);	×
41	throw t;	×
42	}
43	}
44
45	handleMockingOutsideTestMethods(target);	1✔
46
47	// A @Before/@After method:
48	if (it.getAnnotation(Test.class) == null) {	1✔
49	if (shouldPrepareForNextTest && it.getAnnotation(Before.class) != null) {	1!
50	prepareToExecuteSetupMethod(target);	1✔
51	}
52
53	TestRun.setRunningIndividualTest(target);	1✔
54
55	try {
56	invocation.prepareToProceedFromNonRecursiveMock();	1✔
57	return it.invokeExplosively(target, params);	1✔
58	} catch (Throwable t) {	×
59	// noinspection ThrowableNotThrown
60	RecordAndReplayExecution.endCurrentReplayIfAny();	×
61	filterStackTrace(t);	×
62	throw t;	×
63	} finally {
64	if (it.getAnnotation(After.class) != null) {	1✔
65	shouldPrepareForNextTest = true;	1✔
66	}
67	}
68	}
69
70	if (shouldPrepareForNextTest) {	1✔
71	prepareForNextTest();	1✔
72	}
73
74	shouldPrepareForNextTest = true;	1✔
75
76	try {
77	executeTestMethod(invocation, target, params);	1✔
78	return null; // it's a test method, therefore has void return type	1✔
UNCOV 79	} catch (Throwable t) {	×
UNCOV 80	filterStackTrace(t);	×
UNCOV 81	throw t;	×
82	} finally {
83	TestRun.finishCurrentTestExecution();	1✔
84	}
85	}
86
87	@Nullable
88	private static Object executeClassMethod(@NonNull FakeInvocation inv, @NonNull Object[] params) throws Throwable {
89	FrameworkMethod method = inv.getInvokedInstance();	1✔
90	assert method != null;	1!
91	handleMockingOutsideTests(method);	1✔
92
93	TestRun.clearCurrentTestInstance();	1✔
94	inv.prepareToProceedFromNonRecursiveMock();	1✔
95
96	return method.invokeExplosively(null, params);	1✔
97	}
98
99	private void prepareToExecuteSetupMethod(@NonNull Object target) {
100	discardTestLevelMockedTypes();	1✔
101	prepareForNextTest();	1✔
102	shouldPrepareForNextTest = false;	1✔
103	createInstancesForTestedFieldsBeforeSetup(target);	1✔
104	}	1✔
105
106	private static void handleMockingOutsideTests(@NonNull FrameworkMethod it) {
107	Class<?> testClass = it.getMethod().getDeclaringClass();	1✔
108
109	TestRun.enterNoMockingZone();	1✔
110
111	try {
112	Class<?> currentTestClass = TestRun.getCurrentTestClass();	1✔
113
114	if (currentTestClass != null && testClass.isAssignableFrom(currentTestClass)	1✔
115	&& it.getAnnotation(AfterClass.class) != null) {	1✔
116	cleanUpMocksFromPreviousTest();	1✔
117	}
118
119	if (it.getAnnotation(BeforeClass.class) != null) {	1✔
120	updateTestClassState(null, testClass);	1✔
121	}
122	} finally {
123	TestRun.exitNoMockingZone();	1✔
124	}
125	}	1✔
126
127	private static void handleMockingOutsideTestMethods(@NonNull Object target) {
128	Class<?> testClass = target.getClass();	1✔
129
130	TestRun.enterNoMockingZone();	1✔
131
132	try {
133	updateTestClassState(target, testClass);	1✔
134	} finally {
135	TestRun.exitNoMockingZone();	1✔
136	}
137	}	1✔
138
139	private static void executeTestMethod(@NonNull FakeInvocation invocation, @NonNull Object testInstance,
140	@Nullable Object... parameters) throws Throwable {
141	SavePoint savePoint = new SavePoint();	1✔
142
143	TestRun.setRunningIndividualTest(testInstance);	1✔
144
145	FrameworkMethod it = invocation.getInvokedInstance();	1✔
146	assert it != null;	1!
147	Method testMethod = it.getMethod();	1✔
148	Throwable testFailure = null;	1✔
149	boolean testFailureExpected = false;	1✔
150
151	try {
152	createInstancesForTestedFieldsFromBaseClasses(testInstance);	1✔
153	Object[] annotatedParameters = createInstancesForAnnotatedParameters(testInstance, testMethod, parameters);	1✔
154	createInstancesForTestedFields(testInstance);	1✔
155
156	invocation.prepareToProceedFromNonRecursiveMock();	1✔
157
158	Object[] params = annotatedParameters == null ? parameters : annotatedParameters;	1✔
159	it.invokeExplosively(testInstance, params);	1✔
UNCOV 160	} catch (Throwable thrownByTest) {	×
UNCOV 161	testFailure = thrownByTest;	×
UNCOV 162	Class<?> expectedType = testMethod.getAnnotation(Test.class).expected();	×
UNCOV 163	testFailureExpected = expectedType.isAssignableFrom(thrownByTest.getClass());	×
164	} finally {
165	concludeTestMethodExecution(savePoint, testFailure, testFailureExpected);	1✔
166	}
167	}	1✔
168	}

hazendaz / jmockit1 / 551

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