Merge "Renamed ExtendedMockito annotations." into main am: 9f2e02b806

Original change: https://android-review.googlesource.com/c/platform/frameworks/libs/modules-utils/+/2845417

Change-Id: Id105ebdc3380e92223b4d1ec699766ae05ec4552
Signed-off-by: Automerger Merge Worker <android-build-automerger-merge-worker@system.gserviceaccount.com>

3 files changed, 34 insertions, 35 deletions

diff --git a/java/com/android/modules/utils/testing/AbstractExtendedMockitoRule.java b/java/com/android/modules/utils/testing/AbstractExtendedMockitoRule.java
index 594551c..7a0f41b 100644
--- a/java/com/android/modules/utils/testing/AbstractExtendedMockitoRule.java
+++ b/java/com/android/modules/utils/testing/AbstractExtendedMockitoRule.java
@@ -23,9 +23,9 @@ import android.util.Log;
 import com.android.dx.mockito.inline.extended.StaticMockitoSessionBuilder;
 import com.android.internal.annotations.VisibleForTesting;
 import com.android.modules.utils.testing.AbstractExtendedMockitoRule.AbstractBuilder;
-import com.android.modules.utils.testing.ExtendedMockitoRule.MockStaticClass;
+import com.android.modules.utils.testing.ExtendedMockitoRule.MockStatic;
 import com.android.modules.utils.testing.ExtendedMockitoRule.MockStaticClasses;
-import com.android.modules.utils.testing.ExtendedMockitoRule.SpyStaticClass;
+import com.android.modules.utils.testing.ExtendedMockitoRule.SpyStatic;
 import com.android.modules.utils.testing.ExtendedMockitoRule.SpyStaticClasses;
 
 import org.junit.rules.TestRule;
@@ -63,11 +63,11 @@ public abstract class AbstractExtendedMockitoRule<R extends AbstractExtendedMock
 
     private static final String TAG = AbstractExtendedMockitoRule.class.getSimpleName();
 
-    private static final AnnotationFetcher<SpyStaticClass, SpyStaticClasses>
-        sSpyStaticAnnotationFetcher = new AnnotationFetcher<>(SpyStaticClass.class,
+    private static final AnnotationFetcher<SpyStatic, SpyStaticClasses>
+        sSpyStaticAnnotationFetcher = new AnnotationFetcher<>(SpyStatic.class,
                 SpyStaticClasses.class, r -> r.value());
-    private static final AnnotationFetcher<MockStaticClass, MockStaticClasses>
-        sMockStaticAnnotationFetcher = new AnnotationFetcher<>(MockStaticClass.class,
+    private static final AnnotationFetcher<MockStatic, MockStaticClasses>
+        sMockStaticAnnotationFetcher = new AnnotationFetcher<>(MockStatic.class,
                 MockStaticClasses.class, r -> r.value());
 
     private final Object mTestClassInstance;
@@ -109,7 +109,7 @@ public abstract class AbstractExtendedMockitoRule<R extends AbstractExtendedMock
      * Gets the mocked static classes present in the given test.
      *
      * <p>By default, it returns the classes defined by {@link AbstractBuilder#mockStatic(Class)}
-     * plus the classes present in the {@link MockStaticClass} and {@link MockStaticClasses}
+     * plus the classes present in the {@link MockStatic} and {@link MockStaticClasses}
      * annotations (presents in the test method, its class, or its superclasses).
      */
     protected Set<Class<?>> getMockedStaticClasses(Description description) {
@@ -123,7 +123,7 @@ public abstract class AbstractExtendedMockitoRule<R extends AbstractExtendedMock
      * Gets the spied static classes present in the given test.
      *
      * <p>By default, it returns the classes defined by {@link AbstractBuilder#spyStatic(Class)}
-     * plus the classes present in the {@link SpyStaticClass} and {@link SpyStaticClasses}
+     * plus the classes present in the {@link SpyStatic} and {@link SpyStaticClasses}
      * annotations (presents in the test method, its class, or its superclasses).
      */
     protected Set<Class<?>> getSpiedStaticClasses(Description description) {
diff --git a/java/com/android/modules/utils/testing/ExtendedMockitoRule.java b/java/com/android/modules/utils/testing/ExtendedMockitoRule.java
index 3d6a5bd..fa7d7fa 100644
--- a/java/com/android/modules/utils/testing/ExtendedMockitoRule.java
+++ b/java/com/android/modules/utils/testing/ExtendedMockitoRule.java
@@ -81,26 +81,26 @@ public final class ExtendedMockitoRule extends
     @Retention(RetentionPolicy.RUNTIME)
     @Target({ElementType.METHOD, ElementType.TYPE})
     @Repeatable(SpyStaticClasses.class)
-    public @interface SpyStaticClass {
+    public @interface SpyStatic {
         Class<?> value();
     }
 
     @Retention(RetentionPolicy.RUNTIME)
     @Target({ElementType.METHOD, ElementType.TYPE})
     public @interface SpyStaticClasses {
-        SpyStaticClass[] value();
+        SpyStatic[] value();
     }
 
     @Retention(RetentionPolicy.RUNTIME)
     @Target({ElementType.METHOD, ElementType.TYPE})
     @Repeatable(MockStaticClasses.class)
-    public @interface MockStaticClass {
+    public @interface MockStatic {
         Class<?> value();
     }
 
     @Retention(RetentionPolicy.RUNTIME)
     @Target({ElementType.METHOD, ElementType.TYPE})
     public @interface MockStaticClasses {
-        MockStaticClass[] value();
+        MockStatic[] value();
     }
 }
diff --git a/javatests/com/android/modules/utils/testing/ExtendedMockitoRuleTest.java b/javatests/com/android/modules/utils/testing/ExtendedMockitoRuleTest.java
index c671e78..6a80268 100644
--- a/javatests/com/android/modules/utils/testing/ExtendedMockitoRuleTest.java
+++ b/javatests/com/android/modules/utils/testing/ExtendedMockitoRuleTest.java
@@ -31,8 +31,8 @@ import android.util.Log;
 
 import androidx.annotation.Nullable;
 
-import com.android.modules.utils.testing.ExtendedMockitoRule.MockStaticClass;
-import com.android.modules.utils.testing.ExtendedMockitoRule.SpyStaticClass;
+import com.android.modules.utils.testing.ExtendedMockitoRule.MockStatic;
+import com.android.modules.utils.testing.ExtendedMockitoRule.SpyStatic;
 
 import org.junit.Test;
 import org.junit.runner.Description;
@@ -251,7 +251,7 @@ public final class ExtendedMockitoRuleTest {
                 assertWithMessage("AnotherStaticClass.water()")
                         .that(AnotherStaticClass.water()).isNull(); // not mocked
             }
-        }, newTestMethod(new MockStaticClassAnnotation(AnotherStaticClass.class))).evaluate();
+        }, newTestMethod(new MockStaticAnnotation(AnotherStaticClass.class))).evaluate();
     }
 
     // Ideally, we should test the annotations indirectly (i.e., by asserting their static classes
@@ -262,7 +262,7 @@ public final class ExtendedMockitoRuleTest {
         ExtendedMockitoRule rule = mBuilder.mockStatic(StaticClass.class).build();
 
         Set<Class<?>> mockedClasses = rule.getMockedStaticClasses(newTestMethod(SubClass.class,
-                new MockStaticClassAnnotation(AnotherStaticClass.class)));
+                new MockStaticAnnotation(AnotherStaticClass.class)));
 
         assertWithMessage("rule.getMockedStaticClasses()").that(mockedClasses).containsExactly(
                 StaticClass.class, AnotherStaticClass.class, StaticClassMockedBySuperClass.class,
@@ -349,7 +349,7 @@ public final class ExtendedMockitoRuleTest {
                 assertWithMessage("AnotherStaticClass.water()")
                         .that(AnotherStaticClass.water()).isEqualTo("POLO");
             }
-        }, newTestMethod(new SpyStaticClassAnnotation(AnotherStaticClass.class))).evaluate();
+        }, newTestMethod(new SpyStaticAnnotation(AnotherStaticClass.class))).evaluate();
     }
 
     // Ideally, we should test the annotations indirectly (i.e., by asserting their static classes
@@ -360,7 +360,7 @@ public final class ExtendedMockitoRuleTest {
         ExtendedMockitoRule rule = mBuilder.spyStatic(StaticClass.class).build();
 
         Set<Class<?>> spiedClasses = rule.getSpiedStaticClasses(newTestMethod(SubClass.class,
-                new SpyStaticClassAnnotation(AnotherStaticClass.class)));
+                new SpyStaticAnnotation(AnotherStaticClass.class)));
 
         assertWithMessage("rule.getSpiedStaticClasses()").that(spiedClasses).containsExactly(
                 StaticClass.class, AnotherStaticClass.class, StaticClassSpiedBySuperClass.class,
@@ -808,22 +808,21 @@ public final class ExtendedMockitoRuleTest {
         public String toString() {
             return getClass().getSimpleName() + "[" + mClass.getSimpleName() + "]";
         }
-
     }
 
-    private static final class SpyStaticClassAnnotation extends ClassAnnotation<SpyStaticClass>
-            implements SpyStaticClass {
+    private static final class SpyStaticAnnotation extends ClassAnnotation<SpyStatic>
+            implements SpyStatic {
 
-        private SpyStaticClassAnnotation(Class<?> clazz) {
-            super(SpyStaticClass.class, clazz);
+        private SpyStaticAnnotation(Class<?> clazz) {
+            super(SpyStatic.class, clazz);
         }
     }
 
-    private static final class MockStaticClassAnnotation extends ClassAnnotation<MockStaticClass>
-            implements MockStaticClass {
+    private static final class MockStaticAnnotation extends ClassAnnotation<MockStatic>
+            implements MockStatic {
 
-        private MockStaticClassAnnotation(Class<?> clazz) {
-            super(MockStaticClass.class, clazz);
+        private MockStaticAnnotation(Class<?> clazz) {
+            super(MockStatic.class, clazz);
         }
     }
 
@@ -838,10 +837,10 @@ public final class ExtendedMockitoRuleTest {
     private static final class AnotherStaticClassSpiedBySuperClass {
     }
 
-    @SpyStaticClass(StaticClassSpiedBySuperClass.class)
-    @SpyStaticClass(AnotherStaticClassSpiedBySuperClass.class)
-    @MockStaticClass(StaticClassMockedBySuperClass.class)
-    @MockStaticClass(AnotherStaticClassMockedBySuperClass.class)
+    @SpyStatic(StaticClassSpiedBySuperClass.class)
+    @SpyStatic(AnotherStaticClassSpiedBySuperClass.class)
+    @MockStatic(StaticClassMockedBySuperClass.class)
+    @MockStatic(AnotherStaticClassMockedBySuperClass.class)
     private static class SuperClass {
 
     }
@@ -858,10 +857,10 @@ public final class ExtendedMockitoRuleTest {
     private static final class AnotherStaticClassSpiedBySubClass {
     }
 
-    @SpyStaticClass(StaticClassSpiedBySubClass.class)
-    @SpyStaticClass(AnotherStaticClassSpiedBySubClass.class)
-    @MockStaticClass(StaticClassMockedBySubClass.class)
-    @MockStaticClass(AnotherStaticClassMockedBySubClass.class)
+    @SpyStatic(StaticClassSpiedBySubClass.class)
+    @SpyStatic(AnotherStaticClassSpiedBySubClass.class)
+    @MockStatic(StaticClassMockedBySubClass.class)
+    @MockStatic(AnotherStaticClassMockedBySubClass.class)
     private static final class SubClass extends SuperClass{
     }
 }
\ No newline at end of file