Fix primitives support in GenericArrayReturnType for Android (#3753)

jselbo · Joshua Selbo · web-flow · commit 8564b43fbbdf · 2025-10-22T18:56:16.000+02:00
Fixes #3752 --------- Co-authored-by: Joshua Selbo <jselbo@meta.com>
diff --git a/mockito-core/src/main/java/org/mockito/internal/util/Primitives.java b/mockito-core/src/main/java/org/mockito/internal/util/Primitives.java
@@ -14,6 +14,9 @@ public final class Primitives {
     private static final Map<Class<?>, Object> PRIMITIVE_OR_WRAPPER_DEFAULT_VALUES =
             new HashMap<>();
 
+    /** Older JVM environments do not have {@link Class#descriptorString()}, so build our own mapping. */
+    private static final Map<Class<?>, Character> PRIMITIVE_DESCRIPTORS = new HashMap<>();
+
     /**
      * Returns the primitive type of the given class.
      * <p/>
@@ -61,6 +64,11 @@ public static <T> T defaultValue(Class<T> primitiveOrWrapperType) {
         return (T) PRIMITIVE_OR_WRAPPER_DEFAULT_VALUES.get(primitiveOrWrapperType);
     }
 
+    /** Returns the code corresponding to the given primitive type according to JVMS 4.3.2. */
+    public static char getPrimitiveDescriptor(Class<?> primitiveType) {
+        return PRIMITIVE_DESCRIPTORS.get(primitiveType);
+    }
+
     static {
         PRIMITIVE_TYPES.put(Boolean.class, Boolean.TYPE);
         PRIMITIVE_TYPES.put(Character.class, Character.TYPE);
@@ -70,6 +78,15 @@ public static <T> T defaultValue(Class<T> primitiveOrWrapperType) {
         PRIMITIVE_TYPES.put(Long.class, Long.TYPE);
         PRIMITIVE_TYPES.put(Float.class, Float.TYPE);
         PRIMITIVE_TYPES.put(Double.class, Double.TYPE);
+
+        PRIMITIVE_DESCRIPTORS.put(boolean.class, 'Z');
+        PRIMITIVE_DESCRIPTORS.put(char.class, 'C');
+        PRIMITIVE_DESCRIPTORS.put(byte.class, 'B');
+        PRIMITIVE_DESCRIPTORS.put(short.class, 'S');
+        PRIMITIVE_DESCRIPTORS.put(int.class, 'I');
+        PRIMITIVE_DESCRIPTORS.put(long.class, 'J');
+        PRIMITIVE_DESCRIPTORS.put(float.class, 'F');
+        PRIMITIVE_DESCRIPTORS.put(double.class, 'D');
     }
 
     static {
diff --git a/mockito-core/src/main/java/org/mockito/internal/util/reflection/GenericMetadataSupport.java b/mockito-core/src/main/java/org/mockito/internal/util/reflection/GenericMetadataSupport.java
@@ -23,6 +23,7 @@
 import java.util.Set;
 import org.mockito.exceptions.base.MockitoException;
 import org.mockito.internal.util.Checks;
+import org.mockito.internal.util.Primitives;
 
 /**
  * This class can retrieve generic meta-data that the compiler stores on classes
@@ -273,6 +274,8 @@ protected Type getActualTypeArgumentFor(TypeVariable<?> typeParameter) {
      * @return {@link GenericMetadataSupport} representing this generic return type.
      */
     public GenericMetadataSupport resolveGenericReturnType(Method method) {
+        // Note for primitive arrays, some JVMs return a Class (e.g. byte[].class) while some
+        // (notably Android) return GenericArrayType for this.
         Type genericReturnType = method.getGenericReturnType();
         // logger.log("Method '" + method.toGenericString() + "' has return type : " +
         // genericReturnType.getClass().getInterfaces()[0].getSimpleName() + " : " +
@@ -552,15 +555,14 @@ public Class<?> rawType() {
             for (int i = 0; i < arity; i++) {
                 stringBuilder.append("[");
             }
+            if (rawComponentType.isPrimitive()) {
+                stringBuilder.append(Primitives.getPrimitiveDescriptor(rawComponentType));
+            } else {
+                stringBuilder.append("L").append(rawComponentType.getName()).append(";");
+            }
             try {
                 return Class.forName(
-                        stringBuilder
-                                .append("L")
-                                .append(rawComponentType.getName())
-                                .append(";")
-                                .toString(),
-                        false,
-                        rawComponentType.getClassLoader());
+                        stringBuilder.toString(), false, rawComponentType.getClassLoader());
             } catch (ClassNotFoundException e) {
                 throw new IllegalStateException("This was not supposed to happen.", e);
             }
diff --git a/mockito-integration-tests/android-tests/src/androidTest/java/org/mockitousage/androidtest/BasicInstrumentedTests.kt b/mockito-integration-tests/android-tests/src/androidTest/java/org/mockitousage/androidtest/BasicInstrumentedTests.kt
@@ -2,13 +2,16 @@ package org.mockitousage.androidtest
 
 import androidx.test.ext.junit.runners.AndroidJUnit4
 import org.junit.After
+import org.junit.Assert.assertArrayEquals
 import org.junit.Before
 import org.junit.Test
 import org.junit.runner.RunWith
+import org.mockito.ArgumentMatchers.anyList
 import org.mockito.Mock
 import org.mockito.MockitoAnnotations
 import org.mockito.Mockito.mock
 import org.mockito.Mockito.verify
+import org.mockito.Mockito.`when`
 
 @RunWith(AndroidJUnit4::class)
 class BasicInstrumentedTests {
@@ -74,4 +77,16 @@ class BasicInstrumentedTests {
         receiver.callInterfaceMethod()
         verify(basicInterface).interfaceMethod()
     }
+
+//Regression test for issue #3752
+
+    @Test
+    fun mockMethodWithArrayOfPrimitiveReturnType() {
+        val mock = mock(HasArrayOfPrimitivesReturnType::class.java)
+        `when`(mock.getData(anyList())).thenReturn(byteArrayOf(1, 2, 3))
+
+        val actual = mock.getData(emptyList())
+
+        assertArrayEquals(byteArrayOf(1, 2, 3), actual)
+    }
 }
diff --git a/mockito-integration-tests/android-tests/src/main/java/org/mockitousage/androidtest/BasicClassesForTesting.kt b/mockito-integration-tests/android-tests/src/main/java/org/mockitousage/androidtest/BasicClassesForTesting.kt
@@ -33,3 +33,9 @@ class BasicInterfaceReceiver(private val basicInterface: BasicInterface) {
         basicInterface.interfaceMethod()
     }
 }
+
+interface HasArrayOfPrimitivesReturnType {
+
+    // Issue #3752 is reproducible only when method has a generic parameter
+    fun getData(args: List<String>): ByteArray
+}

Original file line number	Diff line number	Diff line change
`@@ -33,3 +33,9 @@ class BasicInterfaceReceiver(private val basicInterface: BasicInterface) {`
`33`	`33`	`basicInterface.interfaceMethod()`
`34`	`34`	`}`
`35`	`35`	`}`
	`36`	`+`
	`37`	`+interface HasArrayOfPrimitivesReturnType {`
	`38`	`+`
	`39`	`+ // Issue #3752 is reproducible only when method has a generic parameter`
	`40`	`+ fun getData(args: List<String>): ByteArray`
	`41`	`+}`