Avoid clearing stale weak entries from critical code segments (#2780)

raphw · web-flow · commit 0052e2f5f78c · 2022-11-11T22:45:40.000+01:00
This reduces the probability of checking for mocked from from the
mock-checking code what can lead to infinitive loops.
diff --git a/src/main/java/org/mockito/internal/creation/bytebuddy/InlineBytecodeGenerator.java b/src/main/java/org/mockito/internal/creation/bytebuddy/InlineBytecodeGenerator.java
@@ -94,8 +94,8 @@ public InlineBytecodeGenerator(
                         .with(Implementation.Context.Disabled.Factory.INSTANCE)
                         .with(MethodGraph.Compiler.ForDeclaredMethods.INSTANCE)
                         .ignore(isSynthetic().and(not(isConstructor())).or(isDefaultFinalizer()));
-        mocked = new WeakConcurrentSet<>(WeakConcurrentSet.Cleaner.INLINE);
-        flatMocked = new WeakConcurrentSet<>(WeakConcurrentSet.Cleaner.INLINE);
+        mocked = new WeakConcurrentSet<>(WeakConcurrentSet.Cleaner.MANUAL);
+        flatMocked = new WeakConcurrentSet<>(WeakConcurrentSet.Cleaner.MANUAL);
         String identifier = RandomString.make();
         subclassEngine =
                 new TypeCachingBytecodeGenerator(
@@ -299,6 +299,9 @@ private <T> void triggerRetransformation(Set<Class<?>> types, boolean flat) {
                 lastException = null;
             }
         }
+
+        mocked.expungeStaleEntries();
+        flatMocked.expungeStaleEntries();
     }
 
     private void assureCanReadMockito(Set<Class<?>> types) {
diff --git a/src/main/java/org/mockito/internal/creation/bytebuddy/InlineDelegateByteBuddyMockMaker.java b/src/main/java/org/mockito/internal/creation/bytebuddy/InlineDelegateByteBuddyMockMaker.java
@@ -192,13 +192,13 @@ class InlineDelegateByteBuddyMockMaker
     private final BytecodeGenerator bytecodeGenerator;
 
     private final WeakConcurrentMap<Object, MockMethodInterceptor> mocks =
-            new WeakConcurrentMap.WithInlinedExpunction<Object, MockMethodInterceptor>();
+            new WeakConcurrentMap<>(false);
 
     private final DetachedThreadLocal<Map<Class<?>, MockMethodInterceptor>> mockedStatics =
-            new DetachedThreadLocal<>(DetachedThreadLocal.Cleaner.INLINE);
+            new DetachedThreadLocal<>(DetachedThreadLocal.Cleaner.MANUAL);
 
     private final DetachedThreadLocal<Map<Class<?>, BiConsumer<Object, MockedConstruction.Context>>>
-            mockedConstruction = new DetachedThreadLocal<>(DetachedThreadLocal.Cleaner.INLINE);
+            mockedConstruction = new DetachedThreadLocal<>(DetachedThreadLocal.Cleaner.MANUAL);
 
     private final ThreadLocal<Boolean> mockitoConstruction = ThreadLocal.withInitial(() -> false);
 
@@ -382,6 +382,7 @@ private <T> T doCreateMock(
             if (instance instanceof MockAccess) {
                 ((MockAccess) instance).setMockitoInterceptor(mockMethodInterceptor);
             }
+            mocks.expungeStaleEntries();
             return instance;
         } catch (InstantiationException e) {
             throw new MockitoException(
@@ -496,6 +497,7 @@ public void resetMock(Object mock, MockHandler newHandler, MockCreationSettings
             if (mock instanceof MockAccess) {
                 ((MockAccess) mock).setMockitoInterceptor(mockMethodInterceptor);
             }
+            mocks.expungeStaleEntries();
         }
     }
 
@@ -570,6 +572,7 @@ public <T> StaticMockControl<T> createStaticMock(
             interceptors = new WeakHashMap<>();
             mockedStatics.set(interceptors);
         }
+        mockedStatics.getBackingMap().expungeStaleEntries();
 
         return new InlineStaticMockControl<>(type, interceptors, settings, handler);
     }
@@ -598,6 +601,7 @@ public <T> ConstructionMockControl<T> createConstructionMock(
             interceptors = new WeakHashMap<>();
             mockedConstruction.set(interceptors);
         }
+        mockedConstruction.getBackingMap().expungeStaleEntries();
 
         return new InlineConstructionMockControl<>(
                 type, settingsFactory, handlerFactory, mockInitializer, interceptors);

Original file line number	Diff line number	Diff line change
`@@ -94,8 +94,8 @@ public InlineBytecodeGenerator(`
`94`	`94`	`.with(Implementation.Context.Disabled.Factory.INSTANCE)`
`95`	`95`	`.with(MethodGraph.Compiler.ForDeclaredMethods.INSTANCE)`
`96`	`96`	`.ignore(isSynthetic().and(not(isConstructor())).or(isDefaultFinalizer()));`
`97`		`- mocked = new WeakConcurrentSet<>(WeakConcurrentSet.Cleaner.INLINE);`
`98`		`- flatMocked = new WeakConcurrentSet<>(WeakConcurrentSet.Cleaner.INLINE);`
	`97`	`+ mocked = new WeakConcurrentSet<>(WeakConcurrentSet.Cleaner.MANUAL);`
	`98`	`+ flatMocked = new WeakConcurrentSet<>(WeakConcurrentSet.Cleaner.MANUAL);`
`99`	`99`	`String identifier = RandomString.make();`
`100`	`100`	`subclassEngine =`
`101`	`101`	`new TypeCachingBytecodeGenerator(`
`@@ -299,6 +299,9 @@ private <T> void triggerRetransformation(Set<Class<?>> types, boolean flat) {`
`299`	`299`	`lastException = null;`
`300`	`300`	`}`
`301`	`301`	`}`
	`302`	`+`
	`303`	`+ mocked.expungeStaleEntries();`
	`304`	`+ flatMocked.expungeStaleEntries();`
`302`	`305`	`}`
`303`	`306`
`304`	`307`	`private void assureCanReadMockito(Set<Class<?>> types) {`
Original file line number	Diff line number	Diff line change
`@@ -192,13 +192,13 @@ class InlineDelegateByteBuddyMockMaker`
`192`	`192`	`private final BytecodeGenerator bytecodeGenerator;`
`193`	`193`
`194`	`194`	`private final WeakConcurrentMap<Object, MockMethodInterceptor> mocks =`
`195`		`- new WeakConcurrentMap.WithInlinedExpunction<Object, MockMethodInterceptor>();`
	`195`	`+ new WeakConcurrentMap<>(false);`
`196`	`196`
`197`	`197`	`private final DetachedThreadLocal<Map<Class<?>, MockMethodInterceptor>> mockedStatics =`
`198`		`- new DetachedThreadLocal<>(DetachedThreadLocal.Cleaner.INLINE);`
	`198`	`+ new DetachedThreadLocal<>(DetachedThreadLocal.Cleaner.MANUAL);`
`199`	`199`
`200`	`200`	`private final DetachedThreadLocal<Map<Class<?>, BiConsumer<Object, MockedConstruction.Context>>>`
`201`		`- mockedConstruction = new DetachedThreadLocal<>(DetachedThreadLocal.Cleaner.INLINE);`
	`201`	`+ mockedConstruction = new DetachedThreadLocal<>(DetachedThreadLocal.Cleaner.MANUAL);`
`202`	`202`
`203`	`203`	`private final ThreadLocal<Boolean> mockitoConstruction = ThreadLocal.withInitial(() -> false);`
`204`	`204`
`@@ -382,6 +382,7 @@ private <T> T doCreateMock(`
`382`	`382`	`if (instance instanceof MockAccess) {`
`383`	`383`	`((MockAccess) instance).setMockitoInterceptor(mockMethodInterceptor);`
`384`	`384`	`}`
	`385`	`+ mocks.expungeStaleEntries();`
`385`	`386`	`return instance;`
`386`	`387`	`} catch (InstantiationException e) {`
`387`	`388`	`throw new MockitoException(`
`@@ -496,6 +497,7 @@ public void resetMock(Object mock, MockHandler newHandler, MockCreationSettings`
`496`	`497`	`if (mock instanceof MockAccess) {`
`497`	`498`	`((MockAccess) mock).setMockitoInterceptor(mockMethodInterceptor);`
`498`	`499`	`}`
	`500`	`+ mocks.expungeStaleEntries();`
`499`	`501`	`}`
`500`	`502`	`}`
`501`	`503`
`@@ -570,6 +572,7 @@ public <T> StaticMockControl<T> createStaticMock(`
`570`	`572`	`interceptors = new WeakHashMap<>();`
`571`	`573`	`mockedStatics.set(interceptors);`
`572`	`574`	`}`
	`575`	`+ mockedStatics.getBackingMap().expungeStaleEntries();`
`573`	`576`
`574`	`577`	`return new InlineStaticMockControl<>(type, interceptors, settings, handler);`
`575`	`578`	`}`
`@@ -598,6 +601,7 @@ public <T> ConstructionMockControl<T> createConstructionMock(`
`598`	`601`	`interceptors = new WeakHashMap<>();`
`599`	`602`	`mockedConstruction.set(interceptors);`
`600`	`603`	`}`
	`604`	`+ mockedConstruction.getBackingMap().expungeStaleEntries();`
`601`	`605`
`602`	`606`	`return new InlineConstructionMockControl<>(`
`603`	`607`	`type, settingsFactory, handlerFactory, mockInitializer, interceptors);`