TestMu Conference is Back! Future of Testing + AI LambdaTest G2 Announcement

How to use AutoCleanableListener class of org.mockito.internal.listeners package

Best Mockito code snippet using org.mockito.internal.listeners.AutoCleanableListener

Source:MockingProgressImpl.java

...5import org.mockito.internal.configuration.GlobalConfiguration;6import org.mockito.internal.debugging.Localized;7import org.mockito.internal.debugging.LocationImpl;8import org.mockito.internal.exceptions.Reporter;9import org.mockito.internal.listeners.AutoCleanableListener;10import org.mockito.invocation.Location;11import org.mockito.listeners.MockCreationListener;12import org.mockito.listeners.MockitoListener;13import org.mockito.listeners.VerificationListener;14import org.mockito.mock.MockCreationSettings;15import org.mockito.stubbing.OngoingStubbing;16import org.mockito.verification.VerificationMode;17import org.mockito.verification.VerificationStrategy;18public class MockingProgressImpl implements MockingProgress {19    private final ArgumentMatcherStorage argumentMatcherStorage = new ArgumentMatcherStorageImpl();20    private final Set<MockitoListener> listeners = new LinkedHashSet();21    private OngoingStubbing<?> ongoingStubbing;22    private Location stubbingInProgress = null;23    private Localized<VerificationMode> verificationMode;24    private VerificationStrategy verificationStrategy = getDefaultVerificationStrategy();25    public static VerificationStrategy getDefaultVerificationStrategy() {26        return new VerificationStrategy() {27            public VerificationMode maybeVerifyLazily(VerificationMode verificationMode) {28                return verificationMode;29            }30        };31    }32    public void reportOngoingStubbing(OngoingStubbing ongoingStubbing2) {33        this.ongoingStubbing = ongoingStubbing2;34    }35    public OngoingStubbing<?> pullOngoingStubbing() {36        OngoingStubbing<?> ongoingStubbing2 = this.ongoingStubbing;37        this.ongoingStubbing = null;38        return ongoingStubbing2;39    }40    public Set<VerificationListener> verificationListeners() {41        LinkedHashSet linkedHashSet = new LinkedHashSet();42        for (MockitoListener next : this.listeners) {43            if (next instanceof VerificationListener) {44                linkedHashSet.add((VerificationListener) next);45            }46        }47        return linkedHashSet;48    }49    public void verificationStarted(VerificationMode verificationMode2) {50        validateState();51        resetOngoingStubbing();52        this.verificationMode = new Localized<>(verificationMode2);53    }54    public void resetOngoingStubbing() {55        this.ongoingStubbing = null;56    }57    public VerificationMode pullVerificationMode() {58        Localized<VerificationMode> localized = this.verificationMode;59        if (localized == null) {60            return null;61        }62        VerificationMode object = localized.getObject();63        this.verificationMode = null;64        return object;65    }66    public void stubbingStarted() {67        validateState();68        this.stubbingInProgress = new LocationImpl();69    }70    public void validateState() {71        validateMostStuff();72        Location location = this.stubbingInProgress;73        if (location != null) {74            this.stubbingInProgress = null;75            throw Reporter.unfinishedStubbing(location);76        }77    }78    private void validateMostStuff() {79        GlobalConfiguration.validate();80        Localized<VerificationMode> localized = this.verificationMode;81        if (localized == null) {82            getArgumentMatcherStorage().validateState();83            return;84        }85        Location location = localized.getLocation();86        this.verificationMode = null;87        throw Reporter.unfinishedVerificationException(location);88    }89    public void stubbingCompleted() {90        this.stubbingInProgress = null;91    }92    public String toString() {93        return "ongoingStubbing: " + this.ongoingStubbing + ", verificationMode: " + this.verificationMode + ", stubbingInProgress: " + this.stubbingInProgress;94    }95    public void reset() {96        this.stubbingInProgress = null;97        this.verificationMode = null;98        getArgumentMatcherStorage().reset();99    }100    public ArgumentMatcherStorage getArgumentMatcherStorage() {101        return this.argumentMatcherStorage;102    }103    public void mockingStarted(Object obj, MockCreationSettings mockCreationSettings) {104        for (MockitoListener next : this.listeners) {105            if (next instanceof MockCreationListener) {106                ((MockCreationListener) next).onMockCreated(obj, mockCreationSettings);107            }108        }109        validateMostStuff();110    }111    public void addListener(MockitoListener mockitoListener) {112        addListener(mockitoListener, this.listeners);113    }114    static void addListener(MockitoListener mockitoListener, Set<MockitoListener> set) {115        LinkedList<MockitoListener> linkedList = new LinkedList<>();116        for (MockitoListener next : set) {117            if (next.getClass().equals(mockitoListener.getClass())) {118                if (!(next instanceof AutoCleanableListener) || !((AutoCleanableListener) next).isListenerDirty()) {119                    Reporter.redundantMockitoListener(mockitoListener.getClass().getSimpleName());120                } else {121                    linkedList.add(next);122                }123            }124        }125        for (MockitoListener remove : linkedList) {126            set.remove(remove);127        }128        set.add(mockitoListener);129    }130    public void removeListener(MockitoListener mockitoListener) {131        this.listeners.remove(mockitoListener);132    }...

Source:UniversalTestListener.java

1package org.mockito.internal.junit;2import org.mockito.internal.creation.settings.CreationSettings;3import org.mockito.internal.listeners.AutoCleanableListener;4import org.mockito.plugins.MockitoLogger;5import org.mockito.mock.MockCreationSettings;6import org.mockito.quality.Strictness;7import java.util.Collection;8import java.util.IdentityHashMap;9import java.util.Map;10/**11 * Universal test listener that behaves accordingly to current setting of strictness.12 * Will come handy when we offer tweaking strictness at the method level with annotation.13 * Should be relatively easy to improve and offer tweaking strictness per mock.14 */15public class UniversalTestListener implements MockitoTestListener, AutoCleanableListener {16    private Strictness currentStrictness;17    private final MockitoLogger logger;18    private Map<Object, MockCreationSettings> mocks = new IdentityHashMap<Object, MockCreationSettings>();19    private DefaultStubbingLookupListener stubbingLookupListener;20    private boolean listenerDirty;21    public UniversalTestListener(Strictness initialStrictness, MockitoLogger logger) {22        this.currentStrictness = initialStrictness;23        this.logger = logger;24        //creating single stubbing lookup listener per junit rule instance / test method25        //this way, when strictness is updated in the middle of the test it will affect the behavior of the stubbing listener26        this.stubbingLookupListener = new DefaultStubbingLookupListener(currentStrictness);27    }28    @Override29    public void testFinished(TestFinishedEvent event) {30        Collection<Object> createdMocks = mocks.keySet();31        //At this point, we don't need the mocks any more and we can mark all collected mocks for gc32        //TODO make it better, it's easy to forget to clean up mocks and we still create new instance of list that nobody will read, it's also duplicated33        //TODO clean up all other state, null out stubbingLookupListener34        mocks = new IdentityHashMap<Object, MockCreationSettings>();35        switch (currentStrictness) {36            case WARN: emitWarnings(logger, event, createdMocks); break;37            case STRICT_STUBS: reportUnusedStubs(event, createdMocks); break;38            case LENIENT: break;39            default: throw new IllegalStateException("Unknown strictness: " + currentStrictness);40        }41    }42    private void reportUnusedStubs(TestFinishedEvent event, Collection<Object> mocks) {43        //If there is some other failure (or mismatches were detected) don't report another exception to avoid confusion44        if (event.getFailure() == null && !stubbingLookupListener.isMismatchesReported()) {45            UnusedStubbings unused = new UnusedStubbingsFinder().getUnusedStubbings(mocks);46            unused.reportUnused();47        }48    }49    private static void emitWarnings(MockitoLogger logger, TestFinishedEvent event, Collection<Object> mocks) {50        if (event.getFailure() != null) {51            //print stubbing mismatches only when there is a test failure52            //to avoid false negatives. Give hint only when test fails.53            new ArgMismatchFinder().getStubbingArgMismatches(mocks).format(event.getTestName(), logger);54        } else {55            //print unused stubbings only when test succeeds to avoid reporting multiple problems and confusing users56            new UnusedStubbingsFinder().getUnusedStubbings(mocks).format(event.getTestName(), logger);57        }58    }59    @Override60    public void onMockCreated(Object mock, MockCreationSettings settings) {61        this.mocks.put(mock, settings);62        //It is not ideal that we modify the state of MockCreationSettings object63        //MockCreationSettings is intended to be an immutable view of the creation settings64        //In future, we should start passing MockSettings object to the creation listener65        //TODO #793 - when completed, we should be able to get rid of the CreationSettings casting below66        ((CreationSettings) settings).getStubbingLookupListeners().add(stubbingLookupListener);67    }68    public void setStrictness(Strictness strictness) {69        this.currentStrictness = strictness;70        this.stubbingLookupListener.setCurrentStrictness(strictness);71    }72    /**73     * See {@link AutoCleanableListener#isListenerDirty()}74     */75    @Override76    public boolean isListenerDirty() {77        return listenerDirty;78    }79    /**80     * Marks listener as dirty, scheduled for cleanup when the next session starts81     */82    public void setListenerDirty() {83        this.listenerDirty = true;84    }85}...

Source:MockingProgressImplTest.java

...15import org.junit.Before;16import org.junit.Test;17import org.mockito.exceptions.base.MockitoException;18import org.mockito.exceptions.misusing.RedundantListenerException;19import org.mockito.internal.listeners.AutoCleanableListener;20import org.mockito.internal.verification.VerificationModeFactory;21import org.mockito.listeners.MockitoListener;22import org.mockito.verification.VerificationMode;23import org.mockitoutil.TestBase;24public class MockingProgressImplTest extends TestBase {25    private MockingProgress mockingProgress;26    @Before27    public void setup() {28        mockingProgress = new MockingProgressImpl();29    }30    @Test31    public void shouldStartVerificationAndPullVerificationMode() throws Exception {32        assertNull(mockingProgress.pullVerificationMode());33        VerificationMode mode = VerificationModeFactory.times(19);34        mockingProgress.verificationStarted(mode);35        assertSame(mode, mockingProgress.pullVerificationMode());36        assertNull(mockingProgress.pullVerificationMode());37    }38    @Test39    public void shouldCheckIfVerificationWasFinished() throws Exception {40        mockingProgress.verificationStarted(VerificationModeFactory.atLeastOnce());41        try {42            mockingProgress.verificationStarted(VerificationModeFactory.atLeastOnce());43            fail();44        } catch (MockitoException e) {45        }46    }47    @Test48    public void shouldNotifyListenerSafely() throws Exception {49        // when50        mockingProgress.addListener(null);51        // then no exception is thrown:52        mockingProgress.mockingStarted(null, null);53    }54    @Test55    public void should_not_allow_redundant_listeners() {56        MockitoListener listener1 = mock(MockitoListener.class);57        final MockitoListener listener2 = mock(MockitoListener.class);58        final Set<MockitoListener> listeners = new LinkedHashSet<MockitoListener>();59        // when60        MockingProgressImpl.addListener(listener1, listeners);61        // then62        Assertions.assertThatThrownBy(63                        new ThrowableAssert.ThrowingCallable() {64                            public void call() {65                                MockingProgressImpl.addListener(listener2, listeners);66                            }67                        })68                .isInstanceOf(RedundantListenerException.class);69    }70    @Test71    public void should_clean_up_listeners_automatically() {72        MockitoListener someListener = mock(MockitoListener.class);73        MyListener cleanListener = mock(MyListener.class);74        MyListener dirtyListener =75                when(mock(MyListener.class).isListenerDirty()).thenReturn(true).getMock();76        Set<MockitoListener> listeners = new LinkedHashSet<MockitoListener>();77        // when78        MockingProgressImpl.addListener(someListener, listeners);79        MockingProgressImpl.addListener(dirtyListener, listeners);80        // then81        Assertions.assertThat(listeners).containsExactlyInAnyOrder(someListener, dirtyListener);82        // when83        MockingProgressImpl.addListener(cleanListener, listeners);84        // then dirty listener was removed automatically85        Assertions.assertThat(listeners).containsExactlyInAnyOrder(someListener, cleanListener);86    }87    interface MyListener extends MockitoListener, AutoCleanableListener {}88}...

AutoCleanableListener

Using AI Code Generation

1import org.mockito.Mock;2import org.mockito.MockitoAnnotations;3import org.mockito.internal.listeners.AutoCleanableListener;4import org.mockito.invocation.InvocationOnMock;5import org.mockito.stubbing.Answer;6import java.util.ArrayList;7import java.util.List;8import static org.mockito.Mockito.doAnswer;9import static org.mockito.Mockito.verify;10public class AutoCleanableListenerTest {11    private List list;12    public AutoCleanableListenerTest() {13        MockitoAnnotations.initMocks(this);14        AutoCleanableListener listener = new AutoCleanableListener();15        listener.add(list);16    }17    public void test() {18        doAnswer(new Answer() {19            public Object answer(InvocationOnMock invocation) throws Throwable {20                return null;21            }22        }).when(list).add("hello");23        list.add("hello");24        verify(list).add("hello");25    }26}27-> at AutoCleanableListenerTest.test(AutoCleanableListenerTest.java:29)28    when(mock.isOk()).thenReturn(true);29    when(mock.isOk()).thenThrow(exception);30    doThrow(exception).when(mock).someVoidMethod();31-> at AutoCleanableListenerTest.test(AutoCleanableListenerTest.java:29)32at org.mockito.internal.listeners.AutoCleanableListener.cleanUp(AutoCleanableListener.java:38)33at org.mockito.internal.listeners.CollectingListener.cleanUp(CollectingListener.java:34)34at org.mockito.internal.MockitoCore.verify(MockitoCore.java:63)35at org.mockito.Mockito.verify(Mockito.java:190)36at AutoCleanableListenerTest.test(AutoCleanableListenerTest.java:29)

AutoCleanableListener

Using AI Code Generation

1package org.mockito.internal.listeners;2import org.mockito.listeners.InvocationListener;3import org.mockito.listeners.MethodInvocationReport;4public class AutoCleanableListener implements InvocationListener {5    public void reportInvocation(MethodInvocationReport methodInvocationReport) {6        System.out.println("AutoCleanableListener invoked");7    }8}9package org.mockito.internal.listeners;10import org.mockito.listeners.InvocationListener;11import org.mockito.listeners.MethodInvocationReport;12public class AutoCleanableListener implements InvocationListener {13    public void reportInvocation(MethodInvocationReport methodInvocationReport) {14        System.out.println("AutoCleanableListener invoked");15    }16}17package org.mockito.internal.listeners;18import org.mockito.listeners.InvocationListener;19import org.mockito.listeners.MethodInvocationReport;20public class AutoCleanableListener implements InvocationListener {21    public void reportInvocation(MethodInvocationReport methodInvocationReport) {22        System.out.println("AutoCleanableListener invoked");23    }24}25package org.mockito.internal.listeners;26import org.mockito.listeners.InvocationListener;27import org.mockito.listeners.MethodInvocationReport;28public class AutoCleanableListener implements InvocationListener {29    public void reportInvocation(MethodInvocationReport methodInvocationReport) {30        System.out.println("AutoCleanableListener invoked");31    }32}33package org.mockito.internal.listeners;34import org.mockito.listeners.InvocationListener;35import org.mockito.listeners.MethodInvocationReport;36public class AutoCleanableListener implements InvocationListener {37    public void reportInvocation(MethodInvocationReport methodInvocationReport) {38        System.out.println("AutoCleanableListener invoked");39    }40}41package org.mockito.internal.listeners;42import org.mockito.listeners.InvocationListener;43import org.mockito.listeners.MethodInvocationReport;44public class AutoCleanableListener implements InvocationListener {45    public void reportInvocation(MethodInvocationReport methodInvocationReport) {46        System.out.println("AutoCleanableListener invoked");47    }48}49package org.mockito.internal.listeners;50import org.mockito.listeners.InvocationListener;51import org.mockito.listeners.MethodInvocationReport;52public class AutoCleanableListener implements InvocationListener {53    public void reportInvocation(MethodInvocationReport methodInvocationReport) {54        System.out.println("AutoCleanableListener invoked");55    }56}57package org.mockito.internal.listeners;58import org.mockito.listeners.InvocationListener;59import org.mockito.listeners.MethodInvocationReport;60public class AutoCleanableListener implements InvocationListener {

AutoCleanableListener

Using AI Code Generation

1public class AutoCleanableListenerTest {2    public void test() throws Exception {3        AutoCleanableListener listener = new AutoCleanableListener();4        Mockito.mockingDetails(listener).getInvocations();5        listener.cleanUp();6    }7}8Hi, I am using Mockito 1.9.5 and I have a problem with AutoCleanableListener class. I am trying to use it in my test code, but it is not working. I am getting the following exception: org.mockito.exceptions.base.MockitoException: Mockito cannot mock this class: class org.mockito.internal.listeners.AutoCleanableListener. Mockito can only mock non-private & non-final classes. at org.mockito.internal.util.MockUtil.createMock(MockUtil.java:32) at org.mockito.internal.MockitoCore.mock(MockitoCore.java:64) at org.mockito.Mockito.mock(Mockito.java:1204) at org.mockito.Mockito.mock(Mockito.java:1166) at org.mockito.internal.listeners.AutoCleanableListenerTest.test(AutoCleanableListenerTest.java:12) at sun.reflect.NativeMethodAccessorImpl.invoke0(Native Method) at sun.reflect.NativeMethodAccessorImpl.invoke(NativeMethodAccessorImpl.java:57) at sun.reflect.DelegatingMethodAccessorImpl.invoke(DelegatingMethodAccessorImpl.java:43) at java.lang.reflect.Method.invoke(Method.java:606) at org.junit.runners.model.FrameworkMethod$1.runReflectiveCall(FrameworkMethod.java:44) at org.junit.internal.runners.model.ReflectiveCallable.run(ReflectiveCallable.java:15) at org.junit.runners.model.FrameworkMethod.invokeExplosively(FrameworkMethod.java:41) at org.junit.internal.runners.statements.InvokeMethod.evaluate(InvokeMethod.java:20) at org.junit.internal.runners.statements.RunBefores.evaluate(RunBefores.java:28) at org.junit.internal.runners.statements.RunAfters.evaluate(RunAfters.java:31) at org.junit.runners.ParentRunner.runLeaf(ParentRunner.java:263) at org.junit.runners.BlockJUnit4ClassRunner.runChild(BlockJUnit4ClassRunner.java:68) at org.junit.runners.BlockJUnit4ClassRunner.runChild(BlockJUnit4ClassRunner.java:47) at org.junit.runners.ParentRunner$3.run(ParentRunner.java:231) at org.junit.runners.ParentRunner$1.schedule(ParentRunner.java:60) at org.junit.runners.ParentRunner.runChildren(ParentRunner.java:229) at org.junit.runners.ParentRunner.access$000(P

AutoCleanableListener

Using AI Code Generation

1import org.mockito.internal.listeners.*;2import org.mockito.invocation.*;3import org.mockito.stubbing.*;4import org.mockito.*;5import org.junit.*;6import static org.junit.Assert.*;7import org.hamcrest.*;8import java.util.*;9import static org.mockito.Mockito.*;10public class AutoCleanableListenerTest {11    public void test() {12        AutoCleanableListener listener = new AutoCleanableListener();13        Mockito.mockingDetails(listener).getInvocations();14        listener.onMockCreated(null, null);15        listener.onMockReset(null);16        listener.onMockVerified(null, null, null);17        listener.onStubbingCompleted(null);18    }19}20import org.mockito.internal.listeners.*;21import org.mockito.invocation.*;22import org.mockito.stubbing.*;23import org.mockito.*;24import org.junit.*;25import static org.junit.Assert.*;26import org.hamcrest.*;27import java.util.*;28import static org.mockito.Mockito.*;29public class AutoCleanableListenerTest {30    public void test() {31        AutoCleanableListener listener = new AutoCleanableListener();32        listener.onMockCreated(null, null);33        listener.onMockReset(null);34        listener.onMockVerified(null, null, null);35        listener.onStubbingCompleted(null);36    }37}38import org.mockito.internal.listeners.*;39import org.mockito.invocation.*;40import org.mockito.stubbing.*;41import org.mockito.*;42import org.junit.*;43import static org.junit.Assert.*;44import org.hamcrest.*;45import java.util.*;46import static org.mockito.Mockito.*;47public class AutoCleanableListenerTest {48    public void test() {49        AutoCleanableListener listener = new AutoCleanableListener();50        listener.onMockCreated(null, null);51        listener.onMockReset(null);52        listener.onMockVerified(null, null, null);53        listener.onStubbingCompleted(null);54        Mockito.mockingDetails(listener).getInvocations();55    }56}57import org.mockito.internal.listeners.*;58import org.mockito.invocation.*;59import org.mockito.stubbing.*;60import org.mockito.*;61import org.junit.*;62import static org.junit.Assert.*;63import org.hamcrest.*;64import java.util.*;65import static org.mockito.Mockito.*;66public class AutoCleanableListenerTest {

AutoCleanableListener

Using AI Code Generation

1import org.mockito.Mockito;2import org.mockito.internal.listeners.AutoCleanableListener;3import org.mockito.internal.util.MockUtil;4import org.mockito.listeners.MockCreationListener;5import org.mockito.listeners.MethodInvocationReport;6import org.mockito.listeners.StubbingReport;7import org.mockito.stubbing.Answer;8import org.mockito.stubbing.Stubbing;9import org.mockito.internal.stubbing.StubbedInvocationMatcher;10public class AutoCleanableListenerTest {11	public static void main(String[] args) {12		List<String> list = Mockito.mock(List.class);13		AutoCleanableListener listener = new AutoCleanableListener();14		Mockito.framework().addListener(listener);15		Mockito.when(list.get(Mockito.anyInt())).thenReturn("Hello");16		Stubbing stubbing = MockUtil.getMockHandler(list).getMockSettings().getStubbings().get(0);17		StubbedInvocationMatcher stubbedInvocationMatcher = (StubbedInvocationMatcher)stubbing.getInvocation();18		System.out.println("Stubbed method: " + stubbedInvocationMatcher.getInvocation().getMethod());19		System.out.println("Stubbed answer: " + stubbing.getAnswer().answer(stubbedInvocationMatcher.getInvocation()));20		Mockito.framework().clearListeners();21		Mockito.clearInvocations(list);22		System.out.println("Stubbed method: " + stubbedInvocationMatcher.getInvocation().getMethod());23		System.out.println("Stubbed answer: " + stubbing.getAnswer().answer(stubbedInvocationMatcher.getInvocation()));24	}25}

AutoCleanableListener

Using AI Code Generation

1import org.mockito.internal.listeners.*;2import org.mockito.*;3import org.mockito.exceptions.*;4import org.mockito.invocation.*;5import org.mockito.listeners.*;6import org.mockito.stubbing.*;7public class AutoCleanableListener implements MockitoListener {8    private int mockCount = 0;9    public void onMockCreated(Object mock, MockCreationSettings settings) {10        mockCount++;11    }12    public void onMockReset(Object mock, MockCreationSettings settings) {13        mockCount--;14    }15    public void onMockingStarted(Object mock, MockCreationSettings settings) {16    }17    public void onMockingStopped(Object mock, MockCreationSettings settings) {18    }19    public void onSpyCalled() {20    }21    public void onStubbingAdded(Stubbing stubbing) {22    }23    public void onStubbingUsed(Stubbing stubbing) {24    }25    public void onInvocation(MethodInvocation invocation) {26    }27    public void onVerificationStarted(VerificationMode mode) {28    }29    public void onVerificationCompleted(VerificationMode mode) {30    }

AutoCleanableListener

Using AI Code Generation

1public class 1 {2    public void test() {3        SimpleClass mock = mock(SimpleClass.class, withSettings().useConstructor().defaultAnswer(CALLS_REAL_METHODS).name("mock"));4        verify(mock).someMethod();5    }6}

AutoCleanableListener

Using AI Code Generation

1package org.mockito.internal.listeners;2import org.mockito.listeners.InvocationListener;3import org.mockito.listeners.MethodInvocationReport;4import java.util.ArrayList;5import java.util.List;6public class AutoCleanableListener implements InvocationListener {7    private final List<Object> mocks = new ArrayList<Object>();8    public void reportInvocation(MethodInvocationReport report) {9        if (report.isStubbing()) {10            mocks.add(report.getMock());11        }12    }13    public void testFinished() {14        for (Object mock : mocks) {15            MockitoCleaner.cleanUpMock(mock);16        }17    }18}19package org.mockito.internal.listeners;20import org.mockito.internal.util.reflection.LenientCopyTool;21import org.mockito.internal.util.reflection.LenientSetter;22import java.lang.reflect.Field;23import java.util.ArrayList;24import java.util.List;25public class MockitoCleaner {26    public static void cleanUpMock(Object mock) {27        if (mock == null) {28            return;29        }30        List<Field> fields = new ArrayList<Field>();31        Class<?> clazz = mock.getClass();32        while (clazz != null) {33            for (Field field : clazz.getDeclaredFields()) {34                if (field.getType().isAssignableFrom(mock.getClass())) {35                    fields.add(field);36                }37            }38            clazz = clazz.getSuperclass();39        }40        for (Field field : fields) {41            field.setAccessible(true);42            try {43                new LenientSetter().set(field, mock, new LenientCopyTool().copy(null));44            } catch (Exception e) {45            }46        }47    }48}

Automation Testing Tutorials

Learn to execute automation testing from scratch with LambdaTest Learning Hub. Right from setting up the prerequisites to run your first automation test, to following best practices and diving deeper into advanced test scenarios. LambdaTest Learning Hubs compile a list of step-by-step guides to help you be proficient with different test automation frameworks i.e. Selenium, Cypress, TestNG etc.