Mock: Add multidimensional type class

While mocking native interface, it will fail with error such as:

```
Caused by: java.lang.ClassNotFoundException: Invalid name: [Lbyte[];
at java.lang.Class.classForName(Native Method)
at java.lang.Class.forName(Class.java:597)
at java.lang.Class.forName(Class.java:502)
at com.android.dx.mockito.inline.MockMethodAdvice.getOrigin(MockMethodAdvice.java:166)
```

Indeed "[Lbyte[]" is not correct as the class is a "[[B".
Adding entries in MockMethodAdvice to do the conversion with a non
specified number of dimension for primitive and qualified type

Author: wescande

dexmaker-mockito-inline/src/main/java/com/android/dx/mockito/inline/MockMethodAdvice.java

@@ -11,6 +11,7 @@
 import java.lang.reflect.Modifier;
 import java.util.ArrayList;
 import java.util.Map;
+import java.util.Optional;
 import java.util.concurrent.Callable;
 import java.util.regex.Matcher;
 import java.util.regex.Pattern;
@@ -25,6 +26,9 @@ class MockMethodAdvice {
     /** Pattern to decompose a instrumentedMethodWithTypeAndSignature */
     private final Pattern methodPattern = Pattern.compile("(.*)#(.*)\\((.*)\\)");
 
+    /** Pattern to verifies types description is ending only with array type */
+    private static final Pattern ARRAY_PATTERN = Pattern.compile("(\\[\\])+");
+
     @SuppressWarnings("ThreadLocalUsage")
     private final SelfCallInfo selfCallInfo = new SelfCallInfo();
 
@@ -86,6 +90,59 @@ private static Throwable hideRecursiveCall(Throwable throwable, int current,
         }
     }
 
+    private static final Map<String, String> PRIMITIVE_CLASS_TO_SIGNATURE =
+            Map.of(
+                    "byte", "B",
+                    "short", "S",
+                    "int", "I",
+                    "long", "J",
+                    "char", "C",
+                    "float", "F",
+                    "double", "D",
+                    "boolean", "Z");
+
+    /**
+     * Convert a type signature of an array to the corresponding class
+     *
+     * <p>It parse "foo[][][][]" into a jni signature "[[[[Lfoo;" and rely on Class.forName to do
+     * the conversion. Primivite type are converted using {@code PRIMITIVE_CLASS_TO_SIGNATURE}.
+     *
+     * @param argTypeName the type description (e.g: byte[])
+     * @return the class wrapped in Optional on success, or empty if the conversion failed
+     */
+    private static Optional<Class<?>> parseTypeName(String argTypeName) {
+        int index = argTypeName.indexOf("[");
+        if (index == -1) {
+            // not an Array type
+            return Optional.empty();
+        }
+
+        String typeName = argTypeName.substring(0, index);
+        String rest = argTypeName.substring(index, argTypeName.length());
+
+        if (!ARRAY_PATTERN.matcher(rest).matches()) {
+            return Optional.empty();
+        }
+        int dimensionCount = (int) argTypeName.chars().filter(ch -> ch == '[').count();
+
+        String classSignature =
+                PRIMITIVE_CLASS_TO_SIGNATURE.getOrDefault(typeName, "L" + typeName + ";");
+
+        StringBuilder sb = new StringBuilder();
+        // "[".repeat(dimensionCount) would be a shorter alternative but this is not available on
+        // all android test target. See b/396768441
+        for (int i = 0; i < dimensionCount; i++) {
+            sb.append("[");
+        }
+        sb.append(classSignature);
+        String fullTypeSignature = sb.toString();
+        try {
+            return Optional.of(Class.forName(fullTypeSignature));
+        } catch (ClassNotFoundException e) {
+            return Optional.empty();
+        }
+    }
+
     /**
      * Get the method of {@code instance} specified by {@code methodWithTypeAndSignature}.
      *
@@ -135,34 +192,10 @@ public Method getOrigin(Object instance, String methodWithTypeAndSignature) thro
                     case "boolean":
                         argTypes.add(Boolean.TYPE);
                         break;
-                    case "byte[]":
-                        argTypes.add(byte[].class);
-                        break;
-                    case "short[]":
-                        argTypes.add(short[].class);
-                        break;
-                    case "int[]":
-                        argTypes.add(int[].class);
-                        break;
-                    case "long[]":
-                        argTypes.add(long[].class);
-                        break;
-                    case "char[]":
-                        argTypes.add(char[].class);
-                        break;
-                    case "float[]":
-                        argTypes.add(float[].class);
-                        break;
-                    case "double[]":
-                        argTypes.add(double[].class);
-                        break;
-                    case "boolean[]":
-                        argTypes.add(boolean[].class);
-                        break;
                     default:
-                        if (argTypeName.endsWith("[]")) {
-                            argTypes.add(Class.forName("[L" + argTypeName.substring(0,
-                                    argTypeName.length() - 2) + ";"));
+                        Optional<Class<?>> arrayClass = parseTypeName(argTypeName);
+                        if (arrayClass.isPresent()) {
+                            argTypes.add(arrayClass.get());
                         } else {
                             argTypes.add(Class.forName(argTypeName));
                         }