Shorten long test names

Long Android.run-test.mk targets cause testing framework to
misbehave. Issues occur in no-prebuild mode when --output-path
parameter generated by the make system is too long. When this
happens oat generation fails silently in oat_file_assistant.cc
during creation of empty vdex and oat files.

Creation fails because file names, which are as long as absolute path
to source dex file, are longer than 255 characters Linux file name
limit.

Because oat generation fails silently affected tests pass even though
they were effectively ran in interpreter mode, instead of intended
default mode.

This CL shortens test names to be at most 35 characters. This helps
make the tests more reliable.

Test: m test-art-run-test
Bug: 31597671
Change-Id: Ic68408ae0c98ffca0c64ca4f5535f4e683a296f0

3 files changed, 474 insertions, 0 deletions

diff --git a/test/201-built-in-except-detail-messages/expected.txt b/test/201-built-in-except-detail-messages/expected.txt
new file mode 100644
index 0000000000..e69de29bb2
--- /dev/null
+++ b/test/201-built-in-except-detail-messages/expected.txt
diff --git a/test/201-built-in-except-detail-messages/info.txt b/test/201-built-in-except-detail-messages/info.txt
new file mode 100644
index 0000000000..a01b7277de
--- /dev/null
+++ b/test/201-built-in-except-detail-messages/info.txt
@@ -0,0 +1 @@
+Tests of the built-in exceptions' detail messages.
diff --git a/test/201-built-in-except-detail-messages/src/Main.java b/test/201-built-in-except-detail-messages/src/Main.java
new file mode 100644
index 0000000000..dc58819924
--- /dev/null
+++ b/test/201-built-in-except-detail-messages/src/Main.java
@@ -0,0 +1,473 @@
+/*
+ * Copyright (C) 2012 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import java.lang.reflect.Array;
+import java.lang.reflect.Field;
+import java.lang.reflect.Method;
+
+public class Main {
+  public static void main(String[] args) throws Exception {
+    arrayAccess();
+    arrayStore();
+    classCast();
+    classNotFound();
+    negativeArraySize();
+    nullPointers();
+    reflection();
+    stringIndex();
+  }
+
+  private static void assertEquals(String expected, String actual) {
+    if (expected == null && actual == null) {
+      return;
+    }
+    if (expected != null && expected.equals(actual)) {
+      return;
+    }
+    throw new AssertionError("not equal\n" +
+                                 "expected: " + expected + "\n" +
+                                 "actual:   " + actual);
+  }
+
+  private static void fail() {
+    throw new AssertionError();
+  }
+
+  private static void arrayAccess() throws Exception {
+    byte[] bs = new byte[1];
+    double[] ds = new double[1];
+    Object[] os = new Object[1];
+
+    // aput
+    try {
+      bs[2] = 0;
+      fail();
+    } catch (ArrayIndexOutOfBoundsException ex) {
+      assertEquals("length=1; index=2", ex.getMessage());
+    }
+
+    // aget
+    try {
+      byte b = bs[2];
+      fail();
+    } catch (ArrayIndexOutOfBoundsException ex) {
+      assertEquals("length=1; index=2", ex.getMessage());
+    }
+
+    // aput-wide
+    try {
+      ds[2] = 0.0;
+      fail();
+    } catch (ArrayIndexOutOfBoundsException ex) {
+      assertEquals("length=1; index=2", ex.getMessage());
+    }
+
+    // aget-wide
+    try {
+      double d = ds[2];
+      fail();
+    } catch (ArrayIndexOutOfBoundsException ex) {
+      assertEquals("length=1; index=2", ex.getMessage());
+    }
+
+    // aput-object
+    try {
+      os[2] = null;
+      fail();
+    } catch (ArrayIndexOutOfBoundsException ex) {
+      assertEquals("length=1; index=2", ex.getMessage());
+    }
+
+    // aget-object
+    try {
+      Object o = os[2];
+      fail();
+    } catch (ArrayIndexOutOfBoundsException ex) {
+      assertEquals("length=1; index=2", ex.getMessage());
+    }
+  }
+
+  private static void arrayStore() throws Exception {
+    try {
+      Object[] array = new String[10];
+      Object o = new Exception();
+      array[0] = o;
+      fail();
+    } catch (ArrayStoreException ex) {
+      assertEquals("java.lang.Exception cannot be stored in an array of type java.lang.String[]",
+                   ex.getMessage());
+    }
+
+    try {
+      Object[] array = new C[10][];
+      Object o = new Integer(5);
+      array[0] = o;
+      fail();
+    } catch (ArrayStoreException ex) {
+      assertEquals("java.lang.Integer cannot be stored in an array of type Main$C[][]",
+                   ex.getMessage());
+    }
+
+    try {
+      Object[] array = new Float[10][];
+      Object o = new C[4];
+      array[0] = o;
+      fail();
+    } catch (ArrayStoreException ex) {
+      assertEquals("Main$C[] cannot be stored in an array of type java.lang.Float[][]",
+                   ex.getMessage());
+    }
+
+    try {
+      String[] src = new String[] { null, null, null, null, "hello", "goodbye" };
+      Integer[] dst = new Integer[10];
+      System.arraycopy(src, 1, dst, 0, 5);
+    } catch (ArrayStoreException ex) {
+      assertEquals("source[4] of type java.lang.String cannot be stored in destination array of type java.lang.Integer[]",
+                   ex.getMessage());
+    }
+
+    try {
+      String[] src = new String[1];
+      int[] dst = new int[1];
+      System.arraycopy(src, 0, dst, 0, 1);
+    } catch (ArrayStoreException ex) {
+      assertEquals("Incompatible types: src=java.lang.String[], dst=int[]", ex.getMessage());
+    }
+
+    try {
+      float[] src = new float[1];
+      Runnable[] dst = new Runnable[1];
+      System.arraycopy(src, 0, dst, 0, 1);
+    } catch (ArrayStoreException ex) {
+      assertEquals("Incompatible types: src=float[], dst=java.lang.Runnable[]", ex.getMessage());
+    }
+
+    try {
+      boolean[] src = new boolean[1];
+      double[][] dst = new double[1][];
+      System.arraycopy(src, 0, dst, 0, 1);
+    } catch (ArrayStoreException ex) {
+      assertEquals("Incompatible types: src=boolean[], dst=double[][]", ex.getMessage());
+    }
+
+    try {
+      String src = "hello";
+      Object[] dst = new Object[1];
+      System.arraycopy(src, 0, dst, 0, 1);
+    } catch (ArrayStoreException ex) {
+      assertEquals("source of type java.lang.String is not an array", ex.getMessage());
+    }
+
+    try {
+      Object[] src = new Object[1];
+      Integer dst = new Integer(5);
+      System.arraycopy(src, 0, dst, 0, 1);
+    } catch (ArrayStoreException ex) {
+      assertEquals("destination of type java.lang.Integer is not an array", ex.getMessage());
+    }
+
+    // This test demonstrates that the exception message complains
+    // about the source in cases where neither source nor
+    // destination is an array.
+    try {
+      System.arraycopy(new C(), 0, "hello", 0, 1);
+    } catch (ArrayStoreException ex) {
+      assertEquals("source of type Main$C is not an array", ex.getMessage());
+    }
+  }
+
+  private static void classCast() throws Exception {
+    // Reference types.
+    try {
+      Object o = new Exception();
+      String s = (String) o;
+      fail();
+    } catch (ClassCastException ex) {
+      assertEquals("java.lang.Exception cannot be cast to java.lang.String", ex.getMessage());
+    }
+
+    // Arrays of reference types.
+    try {
+      Object o = (C) makeArray(String.class);
+      fail();
+    } catch (ClassCastException ex) {
+      assertEquals("java.lang.String[] cannot be cast to Main$C", ex.getMessage());
+    }
+
+    // Arrays of primitives.
+    try {
+      Object o = (C) makeArray(float.class);
+      fail();
+    } catch (ClassCastException ex) {
+      assertEquals("float[] cannot be cast to Main$C", ex.getMessage());
+    }
+
+    // Multi-dimensional arrays of primitives.
+    try {
+      Object o = (C) makeArray(char[].class);
+      fail();
+    } catch (ClassCastException ex) {
+      assertEquals("char[][] cannot be cast to Main$C", ex.getMessage());
+    }
+
+    // Multi-dimensional arrays of references.
+    try {
+      Object o = (Object[][][]) makeInteger();
+      fail();
+    } catch (ClassCastException ex) {
+      assertEquals("java.lang.Integer cannot be cast to java.lang.Object[][][]", ex.getMessage());
+    }
+  }
+
+  static class C { }
+
+  /**
+   * Helper for testCastOperator and testCastOperatorWithArrays. It's important that the
+   * return type is Object, since otherwise the compiler will just reject the code.
+   */
+  private static Object makeInteger() {
+    return new Integer(5);
+  }
+
+  /**
+   * Helper for testCastOperatorWithArrays. It's important that
+   * the return type is Object.
+   */
+  private static Object makeArray(Class<?> c) {
+    return Array.newInstance(c, 1);
+  }
+
+  private static void classNotFound() throws Exception {
+    try {
+      // There is no such thing as an array of void.
+      Class.forName("[V");
+      fail();
+    } catch (ClassNotFoundException ex) {
+      assertEquals("Invalid name: [V", ex.getMessage());
+    }
+
+    try {
+      // This class name is valid, but doesn't exist.
+      Class.forName("package.Class");
+      fail();
+    } catch (ClassNotFoundException ex) {
+      assertEquals("package.Class", ex.getMessage());
+    }
+
+    try {
+      // This array class name is valid, but the type doesn't exist.
+      Class.forName("[[Lpackage.Class;");
+      fail();
+    } catch (ClassNotFoundException ex) {
+      assertEquals("[[Lpackage.Class;", ex.getMessage());
+    }
+  }
+
+  private static void negativeArraySize() throws Exception {
+    try {
+      int[] is = new int[-123];
+      fail();
+    } catch (NegativeArraySizeException ex) {
+      assertEquals("-123", ex.getMessage());
+    }
+  }
+
+  // Defeat the fact that null's are untyped for precise detail message creation with quickening.
+  private static Object returnNullObject() {
+    return null;
+  }
+
+  private static A returnNullA() {
+    return null;
+  }
+
+  private static void nullPointers() throws Exception {
+    // Invoke method.
+    try {
+      Object o = returnNullObject();
+      o.hashCode();
+      fail();
+    } catch (NullPointerException ex) {
+      assertEquals("Attempt to invoke virtual method 'int java.lang.Object.hashCode()' on a null object reference", ex.getMessage());
+    }
+
+    // Read field.
+    try {
+      A a = returnNullA();
+      int i = a.i;
+      fail();
+    } catch (NullPointerException ex) {
+      assertEquals("Attempt to read from field 'int A.i' on a null object reference", ex.getMessage());
+    }
+
+    // Write field.
+    try {
+      A a = returnNullA();
+      a.i = 1;
+      fail();
+    } catch (NullPointerException ex) {
+      assertEquals("Attempt to write to field 'int A.i' on a null object reference", ex.getMessage());
+    }
+
+    // Read array.
+    try {
+      int[] is = null;
+      int i = is[0];
+      fail();
+    } catch (NullPointerException ex) {
+      assertEquals("Attempt to read from null array", ex.getMessage());
+    }
+
+    // Write array.
+    try {
+      int[] is = null;
+      is[0] = 1;
+      fail();
+    } catch (NullPointerException ex) {
+      assertEquals("Attempt to write to null array", ex.getMessage());
+    }
+
+    // Array length.
+    try {
+      int[] is = null;
+      int i = is.length;
+      fail();
+    } catch (NullPointerException ex) {
+      assertEquals("Attempt to get length of null array", ex.getMessage());
+    }
+  }
+
+  private static void reflection() throws Exception {
+    // Can't assign Integer to a String field.
+    try {
+      Field field = A.class.getField("b");
+      field.set(new A(), 5);
+      fail();
+    } catch (IllegalArgumentException expected) {
+      assertEquals("field A.b has type java.lang.String, got java.lang.Integer",
+          expected.getMessage());
+    }
+
+    // Can't unbox null to a primitive.
+    try {
+      Field field = A.class.getField("i");
+      field.set(new A(), null);
+      fail();
+    } catch (IllegalArgumentException expected) {
+      assertEquals("field A.i has type int, got null", expected.getMessage());
+    }
+
+    // Can't unbox String to a primitive.
+    try {
+      Field field = A.class.getField("i");
+      field.set(new A(), "hello, world!");
+      fail();
+    } catch (IllegalArgumentException expected) {
+      assertEquals("field A.i has type int, got java.lang.String", expected.getMessage());
+    }
+
+    // Can't pass an Integer as a String.
+    try {
+      Method m = A.class.getMethod("m", int.class, String.class);
+      m.invoke(new A(), 2, 2);
+      fail();
+    } catch (IllegalArgumentException expected) {
+      assertEquals("method A.m argument 2 has type java.lang.String, got java.lang.Integer",
+          expected.getMessage());
+    }
+
+    // Can't pass null as an int.
+    try {
+      Method m = A.class.getMethod("m", int.class, String.class);
+      m.invoke(new A(), null, "");
+      fail();
+    } catch (IllegalArgumentException expected) {
+      assertEquals("method A.m argument 1 has type int, got null", expected.getMessage());
+    }
+
+    try {
+      Method m = String.class.getMethod("charAt", int.class);
+      m.invoke("hello"); // Wrong number of arguments.
+      fail();
+    } catch (IllegalArgumentException iae) {
+      assertEquals("Wrong number of arguments; expected 1, got 0", iae.getMessage());
+    }
+    try {
+      Method m = String.class.getMethod("charAt", int.class);
+      m.invoke("hello", "world"); // Wrong type.
+      fail();
+    } catch (IllegalArgumentException iae) {
+      assertEquals("method java.lang.String.charAt! argument 1 has type int, got java.lang.String",
+          iae.getMessage());
+    }
+    try {
+      Method m = String.class.getMethod("charAt", int.class);
+      m.invoke("hello", (Object) null); // Null for a primitive argument.
+      fail();
+    } catch (IllegalArgumentException iae) {
+      assertEquals("method java.lang.String.charAt! argument 1 has type int, got null",
+          iae.getMessage());
+    }
+    try {
+      Method m = String.class.getMethod("charAt", int.class);
+      m.invoke(new Integer(5)); // Wrong type for 'this'.
+      fail();
+    } catch (IllegalArgumentException iae) {
+      assertEquals("Expected receiver of type java.lang.String, but got java.lang.Integer",
+          iae.getMessage());
+    }
+    try {
+      Method m = String.class.getMethod("charAt", int.class);
+      m.invoke(null); // Null for 'this'.
+      fail();
+    } catch (NullPointerException npe) {
+      assertEquals("null receiver", npe.getMessage());
+    }
+  }
+
+  private static void stringIndex() throws Exception {
+    // charAt too small.
+    try {
+      "hello".charAt(-1);
+      fail();
+    } catch (StringIndexOutOfBoundsException ex) {
+      assertEquals("length=5; index=-1", ex.getMessage());
+    }
+
+    // charAt too big.
+    try {
+      "hello".charAt(7);
+      fail();
+    } catch (StringIndexOutOfBoundsException ex) {
+      assertEquals("length=5; index=7", ex.getMessage());
+    }
+
+    // substring too big.
+    try {
+      "hello there".substring(9,14);
+      fail();
+    } catch (StringIndexOutOfBoundsException ex) {
+      assertEquals("length=11; index=14", ex.getMessage());
+    }
+  }
+}
+
+class A {
+  public String b;
+  public int i;
+  public void m(int i, String s) {}
+}