chore: Workaround for mockito #2860

AccessibilityInsightsForAndroidService/app/src/test/java/com/microsoft/accessibilityinsightsforandroidservice/ATFAResultsSerializerTest.java

@@ -3,9 +3,9 @@
 
 package com.microsoft.accessibilityinsightsforandroidservice;
 
-import static org.mockito.ArgumentMatchers.any;
 import static org.mockito.ArgumentMatchers.eq;
-import static org.mockito.Mockito.doAnswer;
+import static org.mockito.Mockito.RETURNS_SELF;
+import static org.mockito.Mockito.mock;
 import static org.mockito.Mockito.times;
 import static org.mockito.Mockito.verify;
 import static org.mockito.Mockito.when;
@@ -22,7 +22,6 @@
 import com.google.gson.JsonPrimitive;
 import com.google.gson.JsonSerializer;
 import java.lang.reflect.Field;
-import java.lang.reflect.Type;
 import java.util.Arrays;
 import java.util.Collections;
 import java.util.List;
@@ -31,18 +30,19 @@
 import org.junit.Before;
 import org.junit.Test;
 import org.junit.runner.RunWith;
-import org.mockito.AdditionalAnswers;
+import org.mockito.ArgumentCaptor;
+import org.mockito.Captor;
 import org.mockito.Mock;
 import org.mockito.junit.MockitoJUnitRunner;
 
 @RunWith(MockitoJUnitRunner.class)
 public class ATFAResultsSerializerTest {
 
-  @Mock GsonBuilder gsonBuilder;
+  GsonBuilder gsonBuilder = mock(GsonBuilder.class, RETURNS_SELF);
   @Mock Gson gson;
-  FieldNamingStrategy fieldNamingStrategy;
-  ExclusionStrategy exclusionStrategy;
-  JsonSerializer<Class> jsonSerializer;
+  @Captor ArgumentCaptor<FieldNamingStrategy> fieldNamingStrategy;
+  @Captor ArgumentCaptor<ExclusionStrategy> exclusionStrategy;
+  @Captor ArgumentCaptor<JsonSerializer<Class>> jsonSerializer;
   ATFAResultsSerializer testSubject;
 
   class TestClass {
@@ -51,36 +51,13 @@ class TestClass {
 
   @Before
   public void prepare() {
-    doAnswer(
-            AdditionalAnswers.answer(
-                (FieldNamingStrategy strategy) -> {
-                  fieldNamingStrategy = strategy;
-                  return gsonBuilder;
-                }))
-        .when(gsonBuilder)
-        .setFieldNamingStrategy(any());
-
-    doAnswer(
-            AdditionalAnswers.answer(
-                (ExclusionStrategy strategy) -> {
-                  exclusionStrategy = strategy;
-                  return gsonBuilder;
-                }))
-        .when(gsonBuilder)
-        .setExclusionStrategies(any());
-
-    doAnswer(
-            AdditionalAnswers.answer(
-                (Type type, JsonSerializer<Class> serializer) -> {
-                  jsonSerializer = serializer;
-                  return gsonBuilder;
-                }))
-        .when(gsonBuilder)
-        .registerTypeAdapter(eq(Class.class), any());
-
     when(gsonBuilder.create()).thenReturn(gson);
 
     testSubject = new ATFAResultsSerializer(gsonBuilder);
+
+    verify(gsonBuilder).setExclusionStrategies(exclusionStrategy.capture());
+    verify(gsonBuilder).setFieldNamingStrategy(fieldNamingStrategy.capture());
+    verify(gsonBuilder).registerTypeAdapter(eq(Class.class), jsonSerializer.capture());
   }
 
   @Test
@@ -90,8 +67,8 @@ class ExtendingClass extends TestClass {
     }
     Field[] testFields = ExtendingClass.class.getFields();
 
-    String testFieldExtendingClass = fieldNamingStrategy.translateName(testFields[0]);
-    String testFieldBaseClass = fieldNamingStrategy.translateName(testFields[1]);
+    String testFieldExtendingClass = fieldNamingStrategy.getValue().translateName(testFields[0]);
+    String testFieldBaseClass = fieldNamingStrategy.getValue().translateName(testFields[1]);
 
     Assert.assertEquals("TestClass.testField", testFieldBaseClass);
     Assert.assertEquals("ExtendingClass.testField", testFieldExtendingClass);
@@ -107,15 +84,18 @@ public void exclusionStrategyExcludesWindowHierarchyElements() {
             .filter(c -> !classesToExclude.contains(c))
             .collect(Collectors.toList());
 
-    classesToExclude.forEach(c -> Assert.assertTrue(exclusionStrategy.shouldSkipClass(c)));
-    classesToInclude.forEach(c -> Assert.assertFalse(exclusionStrategy.shouldSkipClass(c)));
+    classesToExclude.forEach(
+        c -> Assert.assertTrue(exclusionStrategy.getValue().shouldSkipClass(c)));
+    classesToInclude.forEach(
+        c -> Assert.assertFalse(exclusionStrategy.getValue().shouldSkipClass(c)));
   }
 
   @Test
   public void jsonSerializerSerializesClassName() {
     JsonPrimitive expectedJson = new JsonPrimitive(TestClass.class.getSimpleName());
 
-    JsonElement jsonElement = jsonSerializer.serialize(TestClass.class, Class.class, null);
+    JsonElement jsonElement =
+        jsonSerializer.getValue().serialize(TestClass.class, Class.class, null);
 
     Assert.assertEquals(expectedJson, jsonElement);
   }