Really fix tests.

Remove extra line in Android.run-test.mk.
Update junit code in 082 and 021.
Set correct bootclasspath for --no-image.
Make host core.art depend on dex files being installed.
Make 118 pass in the correct bootclasspath.

Bug: 17290452

Change-Id: I415eddfa3632ec7eda927abe95925202de193749

13 files changed, 898 insertions, 707 deletions

diff --git a/test/021-string2/src/junit/framework/Assert.java b/test/021-string2/src/junit/framework/Assert.java
index 364e646..3dcc23d 100644
--- a/test/021-string2/src/junit/framework/Assert.java
+++ b/test/021-string2/src/junit/framework/Assert.java
@@ -5,287 +5,292 @@ package junit.framework;
  */
 
 public class Assert {
-    /**
-     * Protect constructor since it is a static only class
-     */
-    protected Assert() {
-    }
+	/**
+	 * Protect constructor since it is a static only class
+	 */
+	protected Assert() {
+	}
 
-    /**
-     * Asserts that a condition is true. If it isn't it throws
-     * an AssertionFailedError with the given message.
-     */
-    static public void assertTrue(String message, boolean condition) {
-        if (!condition)
-            fail(message);
-    }
-    /**
-     * Asserts that a condition is true. If it isn't it throws
-     * an AssertionFailedError.
-     */
-    static public void assertTrue(boolean condition) {
-        assertTrue(null, condition);
-    }
-    /**
-     * Asserts that a condition is false. If it isn't it throws
-     * an AssertionFailedError with the given message.
-     */
-    static public void assertFalse(String message, boolean condition) {
-        assertTrue(message, !condition);
-    }
-    /**
-     * Asserts that a condition is false. If it isn't it throws
-     * an AssertionFailedError.
-     */
-    static public void assertFalse(boolean condition) {
-        assertFalse(null, condition);
-    }
-    /**
-     * Fails a test with the given message.
-     */
-    static public void fail(String message) {
-        throw new AssertionFailedError(message);
-    }
-    /**
-     * Fails a test with no message.
-     */
-    static public void fail() {
-        fail(null);
-    }
-    /**
-     * Asserts that two objects are equal. If they are not
-     * an AssertionFailedError is thrown with the given message.
-     */
-    static public void assertEquals(String message, Object expected, Object actual) {
-        if (expected == null && actual == null)
-            return;
-        if (expected != null && expected.equals(actual))
-            return;
-        failNotEquals(message, expected, actual);
-    }
-    /**
-     * Asserts that two objects are equal. If they are not
-     * an AssertionFailedError is thrown.
-     */
-    static public void assertEquals(Object expected, Object actual) {
-        assertEquals(null, expected, actual);
-    }
-    /**
-     * Asserts that two Strings are equal.
-     */
-    static public void assertEquals(String message, String expected, String actual) {
-        if (expected == null && actual == null)
-            return;
-        if (expected != null && expected.equals(actual))
-            return;
-        throw new ComparisonFailure(message, expected, actual);
-    }
-    /**
-     * Asserts that two Strings are equal.
-     */
-    static public void assertEquals(String expected, String actual) {
-        assertEquals(null, expected, actual);
-    }
-    /**
-     * Asserts that two doubles are equal concerning a delta.  If they are not
-     * an AssertionFailedError is thrown with the given message.  If the expected
-     * value is infinity then the delta value is ignored.
-     */
-    static public void assertEquals(String message, double expected, double actual, double delta) {
-        // handle infinity specially since subtracting to infinite values gives NaN and the
-        // the following test fails
-        if (Double.isInfinite(expected)) {
-            if (!(expected == actual))
-                failNotEquals(message, new Double(expected), new Double(actual));
-        } else if (!(Math.abs(expected-actual) <= delta)) // Because comparison with NaN always returns false
-            failNotEquals(message, new Double(expected), new Double(actual));
-    }
-    /**
-     * Asserts that two doubles are equal concerning a delta. If the expected
-     * value is infinity then the delta value is ignored.
-     */
-    static public void assertEquals(double expected, double actual, double delta) {
-        assertEquals(null, expected, actual, delta);
-    }
-    /**
-     * Asserts that two floats are equal concerning a delta. If they are not
-     * an AssertionFailedError is thrown with the given message.  If the expected
-     * value is infinity then the delta value is ignored.
-     */
-    static public void assertEquals(String message, float expected, float actual, float delta) {
-         // handle infinity specially since subtracting to infinite values gives NaN and the
-        // the following test fails
-        if (Float.isInfinite(expected)) {
-            if (!(expected == actual))
-                failNotEquals(message, new Float(expected), new Float(actual));
-        } else if (!(Math.abs(expected-actual) <= delta))
-              failNotEquals(message, new Float(expected), new Float(actual));
-    }
-    /**
-     * Asserts that two floats are equal concerning a delta. If the expected
-     * value is infinity then the delta value is ignored.
-     */
-    static public void assertEquals(float expected, float actual, float delta) {
-        assertEquals(null, expected, actual, delta);
-    }
-    /**
-     * Asserts that two longs are equal. If they are not
-     * an AssertionFailedError is thrown with the given message.
-     */
-    static public void assertEquals(String message, long expected, long actual) {
-        assertEquals(message, new Long(expected), new Long(actual));
-    }
-    /**
-     * Asserts that two longs are equal.
-     */
-    static public void assertEquals(long expected, long actual) {
-        assertEquals(null, expected, actual);
-    }
-    /**
-     * Asserts that two booleans are equal. If they are not
-     * an AssertionFailedError is thrown with the given message.
-     */
-    static public void assertEquals(String message, boolean expected, boolean actual) {
-            assertEquals(message, new Boolean(expected), new Boolean(actual));
-      }
-    /**
-     * Asserts that two booleans are equal.
-      */
-    static public void assertEquals(boolean expected, boolean actual) {
-        assertEquals(null, expected, actual);
-    }
-    /**
-     * Asserts that two bytes are equal. If they are not
-     * an AssertionFailedError is thrown with the given message.
-     */
-      static public void assertEquals(String message, byte expected, byte actual) {
-        assertEquals(message, new Byte(expected), new Byte(actual));
-    }
-    /**
-        * Asserts that two bytes are equal.
-     */
-    static public void assertEquals(byte expected, byte actual) {
-        assertEquals(null, expected, actual);
-    }
-    /**
-     * Asserts that two chars are equal. If they are not
-     * an AssertionFailedError is thrown with the given message.
-     */
-      static public void assertEquals(String message, char expected, char actual) {
-            assertEquals(message, new Character(expected), new Character(actual));
-      }
-    /**
-     * Asserts that two chars are equal.
-     */
-      static public void assertEquals(char expected, char actual) {
-        assertEquals(null, expected, actual);
-    }
-    /**
-     * Asserts that two shorts are equal. If they are not
-     * an AssertionFailedError is thrown with the given message.
-     */
-    static public void assertEquals(String message, short expected, short actual) {
-            assertEquals(message, new Short(expected), new Short(actual));
-    }
-      /**
-     * Asserts that two shorts are equal.
-     */
-    static public void assertEquals(short expected, short actual) {
-        assertEquals(null, expected, actual);
-    }
-    /**
-     * Asserts that two ints are equal. If they are not
-     * an AssertionFailedError is thrown with the given message.
-     */
-      static public void assertEquals(String message, int expected, int actual) {
-        assertEquals(message, new Integer(expected), new Integer(actual));
-      }
-      /**
-        * Asserts that two ints are equal.
-     */
-      static public void assertEquals(int expected, int actual) {
-          assertEquals(null, expected, actual);
-    }
-    /**
-     * Asserts that an object isn't null.
-     */
-    static public void assertNotNull(Object object) {
-        assertNotNull(null, object);
-    }
-    /**
-     * Asserts that an object isn't null. If it is
-     * an AssertionFailedError is thrown with the given message.
-     */
-    static public void assertNotNull(String message, Object object) {
-        assertTrue(message, object != null);
-    }
-    /**
-     * Asserts that an object is null.
-     */
-    static public void assertNull(Object object) {
-        assertNull(null, object);
-    }
-    /**
-     * Asserts that an object is null.  If it is not
-     * an AssertionFailedError is thrown with the given message.
-     */
-    static public void assertNull(String message, Object object) {
-        assertTrue(message, object == null);
-    }
-    /**
-     * Asserts that two objects refer to the same object. If they are not
-     * an AssertionFailedError is thrown with the given message.
-     */
-    static public void assertSame(String message, Object expected, Object actual) {
-        if (expected == actual)
-            return;
-        failNotSame(message, expected, actual);
-    }
-    /**
-     * Asserts that two objects refer to the same object. If they are not
-     * the same an AssertionFailedError is thrown.
-     */
-    static public void assertSame(Object expected, Object actual) {
-        assertSame(null, expected, actual);
-    }
-     /**
-      * Asserts that two objects refer to the same object. If they are not
-      * an AssertionFailedError is thrown with the given message.
-      */
-    static public void assertNotSame(String message, Object expected, Object actual) {
-        if (expected == actual)
-            failSame(message);
-    }
-    /**
-     * Asserts that two objects refer to the same object. If they are not
-     * the same an AssertionFailedError is thrown.
-     */
-    static public void assertNotSame(Object expected, Object actual) {
-        assertNotSame(null, expected, actual);
-    }
+	/**
+	 * Asserts that a condition is true. If it isn't it throws
+	 * an AssertionFailedError with the given message.
+	 */
+	static public void assertTrue(String message, boolean condition) {
+		if (!condition)
+			fail(message);
+	}
+	/**
+	 * Asserts that a condition is true. If it isn't it throws
+	 * an AssertionFailedError.
+	 */
+	static public void assertTrue(boolean condition) {
+		assertTrue(null, condition);
+	}
+	/**
+	 * Asserts that a condition is false. If it isn't it throws
+	 * an AssertionFailedError with the given message.
+	 */
+	static public void assertFalse(String message, boolean condition) {
+		assertTrue(message, !condition);
+	}
+	/**
+	 * Asserts that a condition is false. If it isn't it throws
+	 * an AssertionFailedError.
+	 */
+	static public void assertFalse(boolean condition) {
+		assertFalse(null, condition);
+	}
+	/**
+	 * Fails a test with the given message.
+	 */
+	static public void fail(String message) {
+		if (message == null) {
+			throw new AssertionFailedError();
+		}
+		throw new AssertionFailedError(message);
+	}
+	/**
+	 * Fails a test with no message.
+	 */
+	static public void fail() {
+		fail(null);
+	}
+	/**
+	 * Asserts that two objects are equal. If they are not
+	 * an AssertionFailedError is thrown with the given message.
+	 */
+	static public void assertEquals(String message, Object expected, Object actual) {
+		if (expected == null && actual == null)
+			return;
+		if (expected != null && expected.equals(actual))
+			return;
+		failNotEquals(message, expected, actual);
+	}
+	/**
+	 * Asserts that two objects are equal. If they are not
+	 * an AssertionFailedError is thrown.
+	 */
+	static public void assertEquals(Object expected, Object actual) {
+	    assertEquals(null, expected, actual);
+	}
+	/**
+	 * Asserts that two Strings are equal. 
+	 */
+	static public void assertEquals(String message, String expected, String actual) {
+		if (expected == null && actual == null)
+			return;
+		if (expected != null && expected.equals(actual))
+			return;
+		String cleanMessage= message == null ? "" : message;
+		throw new ComparisonFailure(cleanMessage, expected, actual);
+	}
+	/**
+	 * Asserts that two Strings are equal. 
+	 */
+	static public void assertEquals(String expected, String actual) {
+	    assertEquals(null, expected, actual);
+	}
+	/**
+	 * Asserts that two doubles are equal concerning a delta.  If they are not
+	 * an AssertionFailedError is thrown with the given message.  If the expected
+	 * value is infinity then the delta value is ignored.
+	 */
+	static public void assertEquals(String message, double expected, double actual, double delta) {
+		if (Double.compare(expected, actual) == 0)
+			return;
+		if (!(Math.abs(expected-actual) <= delta))
+			failNotEquals(message, new Double(expected), new Double(actual));
+	}
+	/**
+	 * Asserts that two doubles are equal concerning a delta. If the expected
+	 * value is infinity then the delta value is ignored.
+	 */
+	static public void assertEquals(double expected, double actual, double delta) {
+	    assertEquals(null, expected, actual, delta);
+	}
+	/**
+	 * Asserts that two floats are equal concerning a positive delta. If they
+	 * are not an AssertionFailedError is thrown with the given message. If the
+	 * expected value is infinity then the delta value is ignored.
+	 */
+	static public void assertEquals(String message, float expected, float actual, float delta) {
+		if (Float.compare(expected, actual) == 0)
+			return;
+		if (!(Math.abs(expected - actual) <= delta))
+				failNotEquals(message, new Float(expected), new Float(actual));
+	}
+	/**
+	 * Asserts that two floats are equal concerning a delta. If the expected
+	 * value is infinity then the delta value is ignored.
+	 */
+	static public void assertEquals(float expected, float actual, float delta) {
+		assertEquals(null, expected, actual, delta);
+	}
+	/**
+	 * Asserts that two longs are equal. If they are not
+	 * an AssertionFailedError is thrown with the given message.
+	 */
+	static public void assertEquals(String message, long expected, long actual) {
+	    assertEquals(message, new Long(expected), new Long(actual));
+	}
+	/**
+	 * Asserts that two longs are equal.
+	 */
+	static public void assertEquals(long expected, long actual) {
+	    assertEquals(null, expected, actual);
+	}
+	/**
+	 * Asserts that two booleans are equal. If they are not
+	 * an AssertionFailedError is thrown with the given message.
+	 */
+	static public void assertEquals(String message, boolean expected, boolean actual) {
+    		assertEquals(message, Boolean.valueOf(expected), Boolean.valueOf(actual));
+  	}
+	/**
+	 * Asserts that two booleans are equal.
+ 	 */
+	static public void assertEquals(boolean expected, boolean actual) {
+		assertEquals(null, expected, actual);
+	}
+	/**
+	 * Asserts that two bytes are equal. If they are not
+	 * an AssertionFailedError is thrown with the given message.
+	 */
+  	static public void assertEquals(String message, byte expected, byte actual) {
+		assertEquals(message, new Byte(expected), new Byte(actual));
+	}
+	/**
+   	 * Asserts that two bytes are equal.
+	 */
+	static public void assertEquals(byte expected, byte actual) {
+		assertEquals(null, expected, actual);
+	}
+	/**
+	 * Asserts that two chars are equal. If they are not
+	 * an AssertionFailedError is thrown with the given message.
+	 */
+  	static public void assertEquals(String message, char expected, char actual) {
+    		assertEquals(message, new Character(expected), new Character(actual));
+  	}
+	/**
+	 * Asserts that two chars are equal.
+	 */
+  	static public void assertEquals(char expected, char actual) {
+		assertEquals(null, expected, actual);
+	}
+	/**
+	 * Asserts that two shorts are equal. If they are not
+	 * an AssertionFailedError is thrown with the given message.
+	 */
+	static public void assertEquals(String message, short expected, short actual) {
+    		assertEquals(message, new Short(expected), new Short(actual));
+	}
+  	/**
+	 * Asserts that two shorts are equal.
+	 */
+	static public void assertEquals(short expected, short actual) {
+		assertEquals(null, expected, actual);
+	}
+	/**
+	 * Asserts that two ints are equal. If they are not
+	 * an AssertionFailedError is thrown with the given message.
+	 */
+  	static public void assertEquals(String message, int expected, int actual) {
+		assertEquals(message, new Integer(expected), new Integer(actual));
+  	}
+  	/**
+   	 * Asserts that two ints are equal.
+	 */
+  	static public void assertEquals(int expected, int actual) {
+  		assertEquals(null, expected, actual);
+	}
+	/**
+	 * Asserts that an object isn't null.
+	 */
+	static public void assertNotNull(Object object) {
+		assertNotNull(null, object);
+	}
+	/**
+	 * Asserts that an object isn't null. If it is
+	 * an AssertionFailedError is thrown with the given message.
+	 */
+	static public void assertNotNull(String message, Object object) {
+		assertTrue(message, object != null);
+	}
+	/**
+	 * Asserts that an object is null. If it isn't an {@link AssertionError} is
+	 * thrown.
+	 * Message contains: Expected: <null> but was: object
+	 * 
+	 * @param object
+	 *            Object to check or <code>null</code>
+	 */
+	static public void assertNull(Object object) {
+		String message = "Expected: <null> but was: " + String.valueOf(object);
+		assertNull(message, object);
+	}
+	/**
+	 * Asserts that an object is null.  If it is not
+	 * an AssertionFailedError is thrown with the given message.
+	 */
+	static public void assertNull(String message, Object object) {
+		assertTrue(message, object == null);
+	}
+	/**
+	 * Asserts that two objects refer to the same object. If they are not
+	 * an AssertionFailedError is thrown with the given message.
+	 */
+	static public void assertSame(String message, Object expected, Object actual) {
+		if (expected == actual)
+			return;
+		failNotSame(message, expected, actual);
+	}
+	/**
+	 * Asserts that two objects refer to the same object. If they are not
+	 * the same an AssertionFailedError is thrown.
+	 */
+	static public void assertSame(Object expected, Object actual) {
+	    assertSame(null, expected, actual);
+	}
+	/**
+	 * Asserts that two objects do not refer to the same object. If they do
+	 * refer to the same object an AssertionFailedError is thrown with the
+	 * given message.
+	 */
+	static public void assertNotSame(String message, Object expected, Object actual) {
+		if (expected == actual)
+			failSame(message);
+	}
+	/**
+	 * Asserts that two objects do not refer to the same object. If they do
+	 * refer to the same object an AssertionFailedError is thrown.
+	 */
+	static public void assertNotSame(Object expected, Object actual) {
+		assertNotSame(null, expected, actual);
+	}
 
-    static private void failSame(String message) {
-        String formatted= "";
-         if (message != null)
-             formatted= message+" ";
-         fail(formatted+"expected not same");
-    }
+	static public void failSame(String message) {
+		String formatted= "";
+ 		if (message != null)
+ 			formatted= message+" ";
+ 		fail(formatted+"expected not same");
+	}
 
-    static private void failNotSame(String message, Object expected, Object actual) {
-        String formatted= "";
-        if (message != null)
-            formatted= message+" ";
-        fail(formatted+"expected same:<"+expected+"> was not:<"+actual+">");
-    }
+	static public void failNotSame(String message, Object expected, Object actual) {
+		String formatted= "";
+		if (message != null)
+			formatted= message+" ";
+		fail(formatted+"expected same:<"+expected+"> was not:<"+actual+">");
+	}
 
-    static private void failNotEquals(String message, Object expected, Object actual) {
-        fail(format(message, expected, actual));
-    }
+	static public void failNotEquals(String message, Object expected, Object actual) {
+		fail(format(message, expected, actual));
+	}
 
-    static String format(String message, Object expected, Object actual) {
-        String formatted= "";
-        if (message != null)
-            formatted= message+" ";
-        return formatted+"expected:<"+expected+"> but was:<"+actual+">";
-    }
+	public static String format(String message, Object expected, Object actual) {
+		String formatted= "";
+		if (message != null && message.length() > 0)
+			formatted= message+" ";
+		return formatted+"expected:<"+expected+"> but was:<"+actual+">";
+	}
 }
diff --git a/test/021-string2/src/junit/framework/AssertionFailedError.java b/test/021-string2/src/junit/framework/AssertionFailedError.java
index e9cb3a3..0d7802c 100644
--- a/test/021-string2/src/junit/framework/AssertionFailedError.java
+++ b/test/021-string2/src/junit/framework/AssertionFailedError.java
@@ -3,11 +3,18 @@ package junit.framework;
 /**
  * Thrown when an assertion failed.
  */
-public class AssertionFailedError extends Error {
-
-    public AssertionFailedError () {
-    }
-    public AssertionFailedError (String message) {
-        super (message);
-    }
-}
+public class AssertionFailedError extends AssertionError {
+
+	private static final long serialVersionUID= 1L;
+
+	public AssertionFailedError() {
+	}
+
+	public AssertionFailedError(String message) {
+		super(defaultString(message));
+	}
+
+	private static String defaultString(String message) {
+		return message == null ? "" : message;
+	}
+}
\ No newline at end of file
diff --git a/test/021-string2/src/junit/framework/ComparisonCompactor.java b/test/021-string2/src/junit/framework/ComparisonCompactor.java
new file mode 100644
index 0000000..e540f03
--- /dev/null
+++ b/test/021-string2/src/junit/framework/ComparisonCompactor.java
@@ -0,0 +1,87 @@
+package junit.framework;
+
+// android-changed add @hide
+/**
+ * @hide not needed for public API
+ */
+public class ComparisonCompactor {
+
+	private static final String ELLIPSIS= "...";
+	private static final String DELTA_END= "]";
+	private static final String DELTA_START= "[";
+	
+	private int fContextLength;
+	private String fExpected;
+	private String fActual;
+	private int fPrefix;
+	private int fSuffix;
+
+	public ComparisonCompactor(int contextLength, String expected, String actual) {
+		fContextLength= contextLength;
+		fExpected= expected;
+		fActual= actual;
+	}
+
+	public String compact(String message) {
+		if (fExpected == null || fActual == null || areStringsEqual()) {
+			// android-changed use local method instead of Assert.format, since
+			// the later is not part of Android API till API 16
+			return format(message, fExpected, fActual);
+		}
+		findCommonPrefix();
+		findCommonSuffix();
+		String expected= compactString(fExpected);
+		String actual= compactString(fActual);
+		// android-changed use local format method
+		return format(message, expected, actual);
+	}
+
+	private String compactString(String source) {
+		String result= DELTA_START + source.substring(fPrefix, source.length() - fSuffix + 1) + DELTA_END;
+		if (fPrefix > 0)
+			result= computeCommonPrefix() + result;
+		if (fSuffix > 0)
+			result= result + computeCommonSuffix();
+		return result;
+	}
+
+	private void findCommonPrefix() {
+		fPrefix= 0;
+		int end= Math.min(fExpected.length(), fActual.length());
+		for (; fPrefix < end; fPrefix++) {
+			if (fExpected.charAt(fPrefix) != fActual.charAt(fPrefix))
+				break;
+		}
+	}
+
+	private void findCommonSuffix() {
+		int expectedSuffix= fExpected.length() - 1;
+		int actualSuffix= fActual.length() - 1;
+		for (; actualSuffix >= fPrefix && expectedSuffix >= fPrefix; actualSuffix--, expectedSuffix--) {
+			if (fExpected.charAt(expectedSuffix) != fActual.charAt(actualSuffix))
+				break;
+		}
+		fSuffix=  fExpected.length() - expectedSuffix;
+	}
+
+	private String computeCommonPrefix() {
+		return (fPrefix > fContextLength ? ELLIPSIS : "") + fExpected.substring(Math.max(0, fPrefix - fContextLength), fPrefix);
+	}
+
+	private String computeCommonSuffix() {
+		int end= Math.min(fExpected.length() - fSuffix + 1 + fContextLength, fExpected.length());
+		return fExpected.substring(fExpected.length() - fSuffix + 1, end) + (fExpected.length() - fSuffix + 1 < fExpected.length() - fContextLength ? ELLIPSIS : "");
+	}
+
+	private boolean areStringsEqual() {
+		return fExpected.equals(fActual);
+	}
+
+	// android-changed copy of Assert.format for reasons described above
+	private static String format(String message, Object expected, Object actual) {
+        	String formatted= "";
+        	if (message != null && message.length() > 0)
+            		formatted= message+" ";
+        	return formatted+"expected:<"+expected+"> but was:<"+actual+">";
+	}
+}
diff --git a/test/021-string2/src/junit/framework/ComparisonFailure.java b/test/021-string2/src/junit/framework/ComparisonFailure.java
index ccd476b..5077993 100644
--- a/test/021-string2/src/junit/framework/ComparisonFailure.java
+++ b/test/021-string2/src/junit/framework/ComparisonFailure.java
@@ -2,67 +2,51 @@ package junit.framework;
 
 /**
  * Thrown when an assert equals for Strings failed.
- *
+ * 
  * Inspired by a patch from Alex Chaffee mailto:alex@purpletech.com
  */
 public class ComparisonFailure extends AssertionFailedError {
-    private String fExpected;
-    private String fActual;
+	private static final int MAX_CONTEXT_LENGTH= 20;
+	private static final long serialVersionUID= 1L;
+	
+	private String fExpected;
+	private String fActual;
 
-    /**
-     * Constructs a comparison failure.
-     * @param message the identifying message or null
-     * @param expected the expected string value
-     * @param actual the actual string value
-     */
-    public ComparisonFailure (String message, String expected, String actual) {
-        super (message);
-        fExpected= expected;
-        fActual= actual;
-    }
-
-    /**
-     * Returns "..." in place of common prefix and "..." in
-     * place of common suffix between expected and actual.
-     *
-     * @see java.lang.Throwable#getMessage()
-     */
-    public String getMessage() {
-        if (fExpected == null || fActual == null)
-            return Assert.format(super.getMessage(), fExpected, fActual);
-
-        int end= Math.min(fExpected.length(), fActual.length());
-
-        int i= 0;
-        for (; i < end; i++) {
-            if (fExpected.charAt(i) != fActual.charAt(i))
-                break;
-        }
-        int j= fExpected.length()-1;
-        int k= fActual.length()-1;
-        for (; k >= i && j >= i; k--,j--) {
-            if (fExpected.charAt(j) != fActual.charAt(k))
-                break;
-        }
-        String actual, expected;
-
-        // equal strings
-        if (j < i && k < i) {
-            expected= fExpected;
-            actual= fActual;
-        } else {
-            expected= fExpected.substring(i, j+1);
-            actual= fActual.substring(i, k+1);
-            if (i <= end && i > 0) {
-                expected= "..."+expected;
-                actual= "..."+actual;
-            }
-
-            if (j < fExpected.length()-1)
-                expected= expected+"...";
-            if (k < fActual.length()-1)
-                actual= actual+"...";
-        }
-        return Assert.format(super.getMessage(), expected, actual);
-    }
-}
+	/**
+	 * Constructs a comparison failure.
+	 * @param message the identifying message or null
+	 * @param expected the expected string value
+	 * @param actual the actual string value
+	 */
+	public ComparisonFailure (String message, String expected, String actual) {
+		super (message);
+		fExpected= expected;
+		fActual= actual;
+	}
+	
+	/**
+	 * Returns "..." in place of common prefix and "..." in
+	 * place of common suffix between expected and actual.
+	 * 
+	 * @see Throwable#getMessage()
+	 */
+	@Override
+	public String getMessage() {
+		return new ComparisonCompactor(MAX_CONTEXT_LENGTH, fExpected, fActual).compact(super.getMessage());
+	}
+	
+	/**
+	 * Gets the actual string value
+	 * @return the actual string value
+	 */
+	public String getActual() {
+		return fActual;
+	}
+	/**
+	 * Gets the expected string value
+	 * @return the expected string value
+	 */
+	public String getExpected() {
+		return fExpected;
+	}
+}
\ No newline at end of file
diff --git a/test/082-inline-execute/src/junit/framework/Assert.java b/test/082-inline-execute/src/junit/framework/Assert.java
index 364e646..3dcc23d 100644
--- a/test/082-inline-execute/src/junit/framework/Assert.java
+++ b/test/082-inline-execute/src/junit/framework/Assert.java
@@ -5,287 +5,292 @@ package junit.framework;
  */
 
 public class Assert {
-    /**
-     * Protect constructor since it is a static only class
-     */
-    protected Assert() {
-    }
+	/**
+	 * Protect constructor since it is a static only class
+	 */
+	protected Assert() {
+	}
 
-    /**
-     * Asserts that a condition is true. If it isn't it throws
-     * an AssertionFailedError with the given message.
-     */
-    static public void assertTrue(String message, boolean condition) {
-        if (!condition)
-            fail(message);
-    }
-    /**
-     * Asserts that a condition is true. If it isn't it throws
-     * an AssertionFailedError.
-     */
-    static public void assertTrue(boolean condition) {
-        assertTrue(null, condition);
-    }
-    /**
-     * Asserts that a condition is false. If it isn't it throws
-     * an AssertionFailedError with the given message.
-     */
-    static public void assertFalse(String message, boolean condition) {
-        assertTrue(message, !condition);
-    }
-    /**
-     * Asserts that a condition is false. If it isn't it throws
-     * an AssertionFailedError.
-     */
-    static public void assertFalse(boolean condition) {
-        assertFalse(null, condition);
-    }
-    /**
-     * Fails a test with the given message.
-     */
-    static public void fail(String message) {
-        throw new AssertionFailedError(message);
-    }
-    /**
-     * Fails a test with no message.
-     */
-    static public void fail() {
-        fail(null);
-    }
-    /**
-     * Asserts that two objects are equal. If they are not
-     * an AssertionFailedError is thrown with the given message.
-     */
-    static public void assertEquals(String message, Object expected, Object actual) {
-        if (expected == null && actual == null)
-            return;
-        if (expected != null && expected.equals(actual))
-            return;
-        failNotEquals(message, expected, actual);
-    }
-    /**
-     * Asserts that two objects are equal. If they are not
-     * an AssertionFailedError is thrown.
-     */
-    static public void assertEquals(Object expected, Object actual) {
-        assertEquals(null, expected, actual);
-    }
-    /**
-     * Asserts that two Strings are equal.
-     */
-    static public void assertEquals(String message, String expected, String actual) {
-        if (expected == null && actual == null)
-            return;
-        if (expected != null && expected.equals(actual))
-            return;
-        throw new ComparisonFailure(message, expected, actual);
-    }
-    /**
-     * Asserts that two Strings are equal.
-     */
-    static public void assertEquals(String expected, String actual) {
-        assertEquals(null, expected, actual);
-    }
-    /**
-     * Asserts that two doubles are equal concerning a delta.  If they are not
-     * an AssertionFailedError is thrown with the given message.  If the expected
-     * value is infinity then the delta value is ignored.
-     */
-    static public void assertEquals(String message, double expected, double actual, double delta) {
-        // handle infinity specially since subtracting to infinite values gives NaN and the
-        // the following test fails
-        if (Double.isInfinite(expected)) {
-            if (!(expected == actual))
-                failNotEquals(message, new Double(expected), new Double(actual));
-        } else if (!(Math.abs(expected-actual) <= delta)) // Because comparison with NaN always returns false
-            failNotEquals(message, new Double(expected), new Double(actual));
-    }
-    /**
-     * Asserts that two doubles are equal concerning a delta. If the expected
-     * value is infinity then the delta value is ignored.
-     */
-    static public void assertEquals(double expected, double actual, double delta) {
-        assertEquals(null, expected, actual, delta);
-    }
-    /**
-     * Asserts that two floats are equal concerning a delta. If they are not
-     * an AssertionFailedError is thrown with the given message.  If the expected
-     * value is infinity then the delta value is ignored.
-     */
-    static public void assertEquals(String message, float expected, float actual, float delta) {
-         // handle infinity specially since subtracting to infinite values gives NaN and the
-        // the following test fails
-        if (Float.isInfinite(expected)) {
-            if (!(expected == actual))
-                failNotEquals(message, new Float(expected), new Float(actual));
-        } else if (!(Math.abs(expected-actual) <= delta))
-              failNotEquals(message, new Float(expected), new Float(actual));
-    }
-    /**
-     * Asserts that two floats are equal concerning a delta. If the expected
-     * value is infinity then the delta value is ignored.
-     */
-    static public void assertEquals(float expected, float actual, float delta) {
-        assertEquals(null, expected, actual, delta);
-    }
-    /**
-     * Asserts that two longs are equal. If they are not
-     * an AssertionFailedError is thrown with the given message.
-     */
-    static public void assertEquals(String message, long expected, long actual) {
-        assertEquals(message, new Long(expected), new Long(actual));
-    }
-    /**
-     * Asserts that two longs are equal.
-     */
-    static public void assertEquals(long expected, long actual) {
-        assertEquals(null, expected, actual);
-    }
-    /**
-     * Asserts that two booleans are equal. If they are not
-     * an AssertionFailedError is thrown with the given message.
-     */
-    static public void assertEquals(String message, boolean expected, boolean actual) {
-            assertEquals(message, new Boolean(expected), new Boolean(actual));
-      }
-    /**
-     * Asserts that two booleans are equal.
-      */
-    static public void assertEquals(boolean expected, boolean actual) {
-        assertEquals(null, expected, actual);
-    }
-    /**
-     * Asserts that two bytes are equal. If they are not
-     * an AssertionFailedError is thrown with the given message.
-     */
-      static public void assertEquals(String message, byte expected, byte actual) {
-        assertEquals(message, new Byte(expected), new Byte(actual));
-    }
-    /**
-        * Asserts that two bytes are equal.
-     */
-    static public void assertEquals(byte expected, byte actual) {
-        assertEquals(null, expected, actual);
-    }
-    /**
-     * Asserts that two chars are equal. If they are not
-     * an AssertionFailedError is thrown with the given message.
-     */
-      static public void assertEquals(String message, char expected, char actual) {
-            assertEquals(message, new Character(expected), new Character(actual));
-      }
-    /**
-     * Asserts that two chars are equal.
-     */
-      static public void assertEquals(char expected, char actual) {
-        assertEquals(null, expected, actual);
-    }
-    /**
-     * Asserts that two shorts are equal. If they are not
-     * an AssertionFailedError is thrown with the given message.
-     */
-    static public void assertEquals(String message, short expected, short actual) {
-            assertEquals(message, new Short(expected), new Short(actual));
-    }
-      /**
-     * Asserts that two shorts are equal.
-     */
-    static public void assertEquals(short expected, short actual) {
-        assertEquals(null, expected, actual);
-    }
-    /**
-     * Asserts that two ints are equal. If they are not
-     * an AssertionFailedError is thrown with the given message.
-     */
-      static public void assertEquals(String message, int expected, int actual) {
-        assertEquals(message, new Integer(expected), new Integer(actual));
-      }
-      /**
-        * Asserts that two ints are equal.
-     */
-      static public void assertEquals(int expected, int actual) {
-          assertEquals(null, expected, actual);
-    }
-    /**
-     * Asserts that an object isn't null.
-     */
-    static public void assertNotNull(Object object) {
-        assertNotNull(null, object);
-    }
-    /**
-     * Asserts that an object isn't null. If it is
-     * an AssertionFailedError is thrown with the given message.
-     */
-    static public void assertNotNull(String message, Object object) {
-        assertTrue(message, object != null);
-    }
-    /**
-     * Asserts that an object is null.
-     */
-    static public void assertNull(Object object) {
-        assertNull(null, object);
-    }
-    /**
-     * Asserts that an object is null.  If it is not
-     * an AssertionFailedError is thrown with the given message.
-     */
-    static public void assertNull(String message, Object object) {
-        assertTrue(message, object == null);
-    }
-    /**
-     * Asserts that two objects refer to the same object. If they are not
-     * an AssertionFailedError is thrown with the given message.
-     */
-    static public void assertSame(String message, Object expected, Object actual) {
-        if (expected == actual)
-            return;
-        failNotSame(message, expected, actual);
-    }
-    /**
-     * Asserts that two objects refer to the same object. If they are not
-     * the same an AssertionFailedError is thrown.
-     */
-    static public void assertSame(Object expected, Object actual) {
-        assertSame(null, expected, actual);
-    }
-     /**
-      * Asserts that two objects refer to the same object. If they are not
-      * an AssertionFailedError is thrown with the given message.
-      */
-    static public void assertNotSame(String message, Object expected, Object actual) {
-        if (expected == actual)
-            failSame(message);
-    }
-    /**
-     * Asserts that two objects refer to the same object. If they are not
-     * the same an AssertionFailedError is thrown.
-     */
-    static public void assertNotSame(Object expected, Object actual) {
-        assertNotSame(null, expected, actual);
-    }
+	/**
+	 * Asserts that a condition is true. If it isn't it throws
+	 * an AssertionFailedError with the given message.
+	 */
+	static public void assertTrue(String message, boolean condition) {
+		if (!condition)
+			fail(message);
+	}
+	/**
+	 * Asserts that a condition is true. If it isn't it throws
+	 * an AssertionFailedError.
+	 */
+	static public void assertTrue(boolean condition) {
+		assertTrue(null, condition);
+	}
+	/**
+	 * Asserts that a condition is false. If it isn't it throws
+	 * an AssertionFailedError with the given message.
+	 */
+	static public void assertFalse(String message, boolean condition) {
+		assertTrue(message, !condition);
+	}
+	/**
+	 * Asserts that a condition is false. If it isn't it throws
+	 * an AssertionFailedError.
+	 */
+	static public void assertFalse(boolean condition) {
+		assertFalse(null, condition);
+	}
+	/**
+	 * Fails a test with the given message.
+	 */
+	static public void fail(String message) {
+		if (message == null) {
+			throw new AssertionFailedError();
+		}
+		throw new AssertionFailedError(message);
+	}
+	/**
+	 * Fails a test with no message.
+	 */
+	static public void fail() {
+		fail(null);
+	}
+	/**
+	 * Asserts that two objects are equal. If they are not
+	 * an AssertionFailedError is thrown with the given message.
+	 */
+	static public void assertEquals(String message, Object expected, Object actual) {
+		if (expected == null && actual == null)
+			return;
+		if (expected != null && expected.equals(actual))
+			return;
+		failNotEquals(message, expected, actual);
+	}
+	/**
+	 * Asserts that two objects are equal. If they are not
+	 * an AssertionFailedError is thrown.
+	 */
+	static public void assertEquals(Object expected, Object actual) {
+	    assertEquals(null, expected, actual);
+	}
+	/**
+	 * Asserts that two Strings are equal. 
+	 */
+	static public void assertEquals(String message, String expected, String actual) {
+		if (expected == null && actual == null)
+			return;
+		if (expected != null && expected.equals(actual))
+			return;
+		String cleanMessage= message == null ? "" : message;
+		throw new ComparisonFailure(cleanMessage, expected, actual);
+	}
+	/**
+	 * Asserts that two Strings are equal. 
+	 */
+	static public void assertEquals(String expected, String actual) {
+	    assertEquals(null, expected, actual);
+	}
+	/**
+	 * Asserts that two doubles are equal concerning a delta.  If they are not
+	 * an AssertionFailedError is thrown with the given message.  If the expected
+	 * value is infinity then the delta value is ignored.
+	 */
+	static public void assertEquals(String message, double expected, double actual, double delta) {
+		if (Double.compare(expected, actual) == 0)
+			return;
+		if (!(Math.abs(expected-actual) <= delta))
+			failNotEquals(message, new Double(expected), new Double(actual));
+	}
+	/**
+	 * Asserts that two doubles are equal concerning a delta. If the expected
+	 * value is infinity then the delta value is ignored.
+	 */
+	static public void assertEquals(double expected, double actual, double delta) {
+	    assertEquals(null, expected, actual, delta);
+	}
+	/**
+	 * Asserts that two floats are equal concerning a positive delta. If they
+	 * are not an AssertionFailedError is thrown with the given message. If the
+	 * expected value is infinity then the delta value is ignored.
+	 */
+	static public void assertEquals(String message, float expected, float actual, float delta) {
+		if (Float.compare(expected, actual) == 0)
+			return;
+		if (!(Math.abs(expected - actual) <= delta))
+				failNotEquals(message, new Float(expected), new Float(actual));
+	}
+	/**
+	 * Asserts that two floats are equal concerning a delta. If the expected
+	 * value is infinity then the delta value is ignored.
+	 */
+	static public void assertEquals(float expected, float actual, float delta) {
+		assertEquals(null, expected, actual, delta);
+	}
+	/**
+	 * Asserts that two longs are equal. If they are not
+	 * an AssertionFailedError is thrown with the given message.
+	 */
+	static public void assertEquals(String message, long expected, long actual) {
+	    assertEquals(message, new Long(expected), new Long(actual));
+	}
+	/**
+	 * Asserts that two longs are equal.
+	 */
+	static public void assertEquals(long expected, long actual) {
+	    assertEquals(null, expected, actual);
+	}
+	/**
+	 * Asserts that two booleans are equal. If they are not
+	 * an AssertionFailedError is thrown with the given message.
+	 */
+	static public void assertEquals(String message, boolean expected, boolean actual) {
+    		assertEquals(message, Boolean.valueOf(expected), Boolean.valueOf(actual));
+  	}
+	/**
+	 * Asserts that two booleans are equal.
+ 	 */
+	static public void assertEquals(boolean expected, boolean actual) {
+		assertEquals(null, expected, actual);
+	}
+	/**
+	 * Asserts that two bytes are equal. If they are not
+	 * an AssertionFailedError is thrown with the given message.
+	 */
+  	static public void assertEquals(String message, byte expected, byte actual) {
+		assertEquals(message, new Byte(expected), new Byte(actual));
+	}
+	/**
+   	 * Asserts that two bytes are equal.
+	 */
+	static public void assertEquals(byte expected, byte actual) {
+		assertEquals(null, expected, actual);
+	}
+	/**
+	 * Asserts that two chars are equal. If they are not
+	 * an AssertionFailedError is thrown with the given message.
+	 */
+  	static public void assertEquals(String message, char expected, char actual) {
+    		assertEquals(message, new Character(expected), new Character(actual));
+  	}
+	/**
+	 * Asserts that two chars are equal.
+	 */
+  	static public void assertEquals(char expected, char actual) {
+		assertEquals(null, expected, actual);
+	}
+	/**
+	 * Asserts that two shorts are equal. If they are not
+	 * an AssertionFailedError is thrown with the given message.
+	 */
+	static public void assertEquals(String message, short expected, short actual) {
+    		assertEquals(message, new Short(expected), new Short(actual));
+	}
+  	/**
+	 * Asserts that two shorts are equal.
+	 */
+	static public void assertEquals(short expected, short actual) {
+		assertEquals(null, expected, actual);
+	}
+	/**
+	 * Asserts that two ints are equal. If they are not
+	 * an AssertionFailedError is thrown with the given message.
+	 */
+  	static public void assertEquals(String message, int expected, int actual) {
+		assertEquals(message, new Integer(expected), new Integer(actual));
+  	}
+  	/**
+   	 * Asserts that two ints are equal.
+	 */
+  	static public void assertEquals(int expected, int actual) {
+  		assertEquals(null, expected, actual);
+	}
+	/**
+	 * Asserts that an object isn't null.
+	 */
+	static public void assertNotNull(Object object) {
+		assertNotNull(null, object);
+	}
+	/**
+	 * Asserts that an object isn't null. If it is
+	 * an AssertionFailedError is thrown with the given message.
+	 */
+	static public void assertNotNull(String message, Object object) {
+		assertTrue(message, object != null);
+	}
+	/**
+	 * Asserts that an object is null. If it isn't an {@link AssertionError} is
+	 * thrown.
+	 * Message contains: Expected: <null> but was: object
+	 * 
+	 * @param object
+	 *            Object to check or <code>null</code>
+	 */
+	static public void assertNull(Object object) {
+		String message = "Expected: <null> but was: " + String.valueOf(object);
+		assertNull(message, object);
+	}
+	/**
+	 * Asserts that an object is null.  If it is not
+	 * an AssertionFailedError is thrown with the given message.
+	 */
+	static public void assertNull(String message, Object object) {
+		assertTrue(message, object == null);
+	}
+	/**
+	 * Asserts that two objects refer to the same object. If they are not
+	 * an AssertionFailedError is thrown with the given message.
+	 */
+	static public void assertSame(String message, Object expected, Object actual) {
+		if (expected == actual)
+			return;
+		failNotSame(message, expected, actual);
+	}
+	/**
+	 * Asserts that two objects refer to the same object. If they are not
+	 * the same an AssertionFailedError is thrown.
+	 */
+	static public void assertSame(Object expected, Object actual) {
+	    assertSame(null, expected, actual);
+	}
+	/**
+	 * Asserts that two objects do not refer to the same object. If they do
+	 * refer to the same object an AssertionFailedError is thrown with the
+	 * given message.
+	 */
+	static public void assertNotSame(String message, Object expected, Object actual) {
+		if (expected == actual)
+			failSame(message);
+	}
+	/**
+	 * Asserts that two objects do not refer to the same object. If they do
+	 * refer to the same object an AssertionFailedError is thrown.
+	 */
+	static public void assertNotSame(Object expected, Object actual) {
+		assertNotSame(null, expected, actual);
+	}
 
-    static private void failSame(String message) {
-        String formatted= "";
-         if (message != null)
-             formatted= message+" ";
-         fail(formatted+"expected not same");
-    }
+	static public void failSame(String message) {
+		String formatted= "";
+ 		if (message != null)
+ 			formatted= message+" ";
+ 		fail(formatted+"expected not same");
+	}
 
-    static private void failNotSame(String message, Object expected, Object actual) {
-        String formatted= "";
-        if (message != null)
-            formatted= message+" ";
-        fail(formatted+"expected same:<"+expected+"> was not:<"+actual+">");
-    }
+	static public void failNotSame(String message, Object expected, Object actual) {
+		String formatted= "";
+		if (message != null)
+			formatted= message+" ";
+		fail(formatted+"expected same:<"+expected+"> was not:<"+actual+">");
+	}
 
-    static private void failNotEquals(String message, Object expected, Object actual) {
-        fail(format(message, expected, actual));
-    }
+	static public void failNotEquals(String message, Object expected, Object actual) {
+		fail(format(message, expected, actual));
+	}
 
-    static String format(String message, Object expected, Object actual) {
-        String formatted= "";
-        if (message != null)
-            formatted= message+" ";
-        return formatted+"expected:<"+expected+"> but was:<"+actual+">";
-    }
+	public static String format(String message, Object expected, Object actual) {
+		String formatted= "";
+		if (message != null && message.length() > 0)
+			formatted= message+" ";
+		return formatted+"expected:<"+expected+"> but was:<"+actual+">";
+	}
 }
diff --git a/test/082-inline-execute/src/junit/framework/AssertionFailedError.java b/test/082-inline-execute/src/junit/framework/AssertionFailedError.java
index e9cb3a3..0d7802c 100644
--- a/test/082-inline-execute/src/junit/framework/AssertionFailedError.java
+++ b/test/082-inline-execute/src/junit/framework/AssertionFailedError.java
@@ -3,11 +3,18 @@ package junit.framework;
 /**
  * Thrown when an assertion failed.
  */
-public class AssertionFailedError extends Error {
-
-    public AssertionFailedError () {
-    }
-    public AssertionFailedError (String message) {
-        super (message);
-    }
-}
+public class AssertionFailedError extends AssertionError {
+
+	private static final long serialVersionUID= 1L;
+
+	public AssertionFailedError() {
+	}
+
+	public AssertionFailedError(String message) {
+		super(defaultString(message));
+	}
+
+	private static String defaultString(String message) {
+		return message == null ? "" : message;
+	}
+}
\ No newline at end of file
diff --git a/test/082-inline-execute/src/junit/framework/ComparisonCompactor.java b/test/082-inline-execute/src/junit/framework/ComparisonCompactor.java
new file mode 100644
index 0000000..e540f03
--- /dev/null
+++ b/test/082-inline-execute/src/junit/framework/ComparisonCompactor.java
@@ -0,0 +1,87 @@
+package junit.framework;
+
+// android-changed add @hide
+/**
+ * @hide not needed for public API
+ */
+public class ComparisonCompactor {
+
+	private static final String ELLIPSIS= "...";
+	private static final String DELTA_END= "]";
+	private static final String DELTA_START= "[";
+	
+	private int fContextLength;
+	private String fExpected;
+	private String fActual;
+	private int fPrefix;
+	private int fSuffix;
+
+	public ComparisonCompactor(int contextLength, String expected, String actual) {
+		fContextLength= contextLength;
+		fExpected= expected;
+		fActual= actual;
+	}
+
+	public String compact(String message) {
+		if (fExpected == null || fActual == null || areStringsEqual()) {
+			// android-changed use local method instead of Assert.format, since
+			// the later is not part of Android API till API 16
+			return format(message, fExpected, fActual);
+		}
+		findCommonPrefix();
+		findCommonSuffix();
+		String expected= compactString(fExpected);
+		String actual= compactString(fActual);
+		// android-changed use local format method
+		return format(message, expected, actual);
+	}
+
+	private String compactString(String source) {
+		String result= DELTA_START + source.substring(fPrefix, source.length() - fSuffix + 1) + DELTA_END;
+		if (fPrefix > 0)
+			result= computeCommonPrefix() + result;
+		if (fSuffix > 0)
+			result= result + computeCommonSuffix();
+		return result;
+	}
+
+	private void findCommonPrefix() {
+		fPrefix= 0;
+		int end= Math.min(fExpected.length(), fActual.length());
+		for (; fPrefix < end; fPrefix++) {
+			if (fExpected.charAt(fPrefix) != fActual.charAt(fPrefix))
+				break;
+		}
+	}
+
+	private void findCommonSuffix() {
+		int expectedSuffix= fExpected.length() - 1;
+		int actualSuffix= fActual.length() - 1;
+		for (; actualSuffix >= fPrefix && expectedSuffix >= fPrefix; actualSuffix--, expectedSuffix--) {
+			if (fExpected.charAt(expectedSuffix) != fActual.charAt(actualSuffix))
+				break;
+		}
+		fSuffix=  fExpected.length() - expectedSuffix;
+	}
+
+	private String computeCommonPrefix() {
+		return (fPrefix > fContextLength ? ELLIPSIS : "") + fExpected.substring(Math.max(0, fPrefix - fContextLength), fPrefix);
+	}
+
+	private String computeCommonSuffix() {
+		int end= Math.min(fExpected.length() - fSuffix + 1 + fContextLength, fExpected.length());
+		return fExpected.substring(fExpected.length() - fSuffix + 1, end) + (fExpected.length() - fSuffix + 1 < fExpected.length() - fContextLength ? ELLIPSIS : "");
+	}
+
+	private boolean areStringsEqual() {
+		return fExpected.equals(fActual);
+	}
+
+	// android-changed copy of Assert.format for reasons described above
+	private static String format(String message, Object expected, Object actual) {
+        	String formatted= "";
+        	if (message != null && message.length() > 0)
+            		formatted= message+" ";
+        	return formatted+"expected:<"+expected+"> but was:<"+actual+">";
+	}
+}
diff --git a/test/082-inline-execute/src/junit/framework/ComparisonFailure.java b/test/082-inline-execute/src/junit/framework/ComparisonFailure.java
index ccd476b..5077993 100644
--- a/test/082-inline-execute/src/junit/framework/ComparisonFailure.java
+++ b/test/082-inline-execute/src/junit/framework/ComparisonFailure.java
@@ -2,67 +2,51 @@ package junit.framework;
 
 /**
  * Thrown when an assert equals for Strings failed.
- *
+ * 
  * Inspired by a patch from Alex Chaffee mailto:alex@purpletech.com
  */
 public class ComparisonFailure extends AssertionFailedError {
-    private String fExpected;
-    private String fActual;
+	private static final int MAX_CONTEXT_LENGTH= 20;
+	private static final long serialVersionUID= 1L;
+	
+	private String fExpected;
+	private String fActual;
 
-    /**
-     * Constructs a comparison failure.
-     * @param message the identifying message or null
-     * @param expected the expected string value
-     * @param actual the actual string value
-     */
-    public ComparisonFailure (String message, String expected, String actual) {
-        super (message);
-        fExpected= expected;
-        fActual= actual;
-    }
-
-    /**
-     * Returns "..." in place of common prefix and "..." in
-     * place of common suffix between expected and actual.
-     *
-     * @see java.lang.Throwable#getMessage()
-     */
-    public String getMessage() {
-        if (fExpected == null || fActual == null)
-            return Assert.format(super.getMessage(), fExpected, fActual);
-
-        int end= Math.min(fExpected.length(), fActual.length());
-
-        int i= 0;
-        for (; i < end; i++) {
-            if (fExpected.charAt(i) != fActual.charAt(i))
-                break;
-        }
-        int j= fExpected.length()-1;
-        int k= fActual.length()-1;
-        for (; k >= i && j >= i; k--,j--) {
-            if (fExpected.charAt(j) != fActual.charAt(k))
-                break;
-        }
-        String actual, expected;
-
-        // equal strings
-        if (j < i && k < i) {
-            expected= fExpected;
-            actual= fActual;
-        } else {
-            expected= fExpected.substring(i, j+1);
-            actual= fActual.substring(i, k+1);
-            if (i <= end && i > 0) {
-                expected= "..."+expected;
-                actual= "..."+actual;
-            }
-
-            if (j < fExpected.length()-1)
-                expected= expected+"...";
-            if (k < fActual.length()-1)
-                actual= actual+"...";
-        }
-        return Assert.format(super.getMessage(), expected, actual);
-    }
-}
+	/**
+	 * Constructs a comparison failure.
+	 * @param message the identifying message or null
+	 * @param expected the expected string value
+	 * @param actual the actual string value
+	 */
+	public ComparisonFailure (String message, String expected, String actual) {
+		super (message);
+		fExpected= expected;
+		fActual= actual;
+	}
+	
+	/**
+	 * Returns "..." in place of common prefix and "..." in
+	 * place of common suffix between expected and actual.
+	 * 
+	 * @see Throwable#getMessage()
+	 */
+	@Override
+	public String getMessage() {
+		return new ComparisonCompactor(MAX_CONTEXT_LENGTH, fExpected, fActual).compact(super.getMessage());
+	}
+	
+	/**
+	 * Gets the actual string value
+	 * @return the actual string value
+	 */
+	public String getActual() {
+		return fActual;
+	}
+	/**
+	 * Gets the expected string value
+	 * @return the expected string value
+	 */
+	public String getExpected() {
+		return fExpected;
+	}
+}
\ No newline at end of file
diff --git a/test/118-noimage-dex2oat/run b/test/118-noimage-dex2oat/run
index 911abdf..92a4ec2 100644
--- a/test/118-noimage-dex2oat/run
+++ b/test/118-noimage-dex2oat/run
@@ -21,21 +21,30 @@ flags="${@/--no-relocate/--relocate}"
 RUN="${RUN/push-and-run-prebuilt-test-jar/push-and-run-test-jar}"
 
 if [ $(basename $RUN) == 'host-run-test-jar' ]; then
-  BPATH="--runtime-option -Xbootclasspath:$ANDROID_HOST_OUT/../common/obj/JAVA_LIBRARIES/core-libart-hostdex_intermediates/javalib.jar"
-  # Remove prebuild from the flags, this test is for testing not having oat files.
-  flags="${flags/--prebuild/}"
+    framework="${ANDROID_HOST_OUT}/framework"
+    bpath_suffix="-hostdex"
+    # Remove prebuild from the flags, this test is for testing not having oat files.
+    flags="${flags/--prebuild/}"
 else
-  BPATH="--runtime-option -Xbootclasspath:/system/framework/core-libart.jar"
+    framework="/system/framework"
+    bpath_suffix=""
 fi
+bpath="${framework}/core-libart${bpath_suffix}.jar"
+bpath="${bpath}:${framework}/conscrypt${bpath_suffix}.jar"
+bpath="${bpath}:${framework}/okhttp${bpath_suffix}.jar"
+bpath="${bpath}:${framework}/core-junit${bpath_suffix}.jar"
+bpath="${bpath}:${framework}/bouncycastle${bpath_suffix}.jar"
+bpath_arg="--runtime-option -Xbootclasspath:${bpath}"
+
 
 # Make sure we can run without an oat file,
 echo "Run -Xnoimage-dex2oat"
-${RUN} ${flags} ${BPATH} --runtime-option -Xnoimage-dex2oat --runtime-option -Xnodex2oat
+${RUN} ${flags} ${bpath_arg} --runtime-option -Xnoimage-dex2oat --runtime-option -Xnodex2oat
 
 # Make sure we can run with the oat file.
 echo "Run -Ximage-dex2oat"
-${RUN} ${flags} ${BPATH} --runtime-option -Ximage-dex2oat
+${RUN} ${flags} ${bpath_arg} --runtime-option -Ximage-dex2oat
 
 # Make sure we can run with the default settings.
 echo "Run default"
-${RUN} ${flags} ${BPATH}
+${RUN} ${flags} ${bpath_arg}
diff --git a/test/etc/host-run-test-jar b/test/etc/host-run-test-jar
index bce34f6..54a0865 100755
--- a/test/etc/host-run-test-jar
+++ b/test/etc/host-run-test-jar
@@ -171,10 +171,8 @@ if [ "$INTERPRETER" = "y" ]; then
 fi
 
 if [ "$HAVE_IMAGE" = "n" ]; then
-    # Set image to a place were there isn't one and then set the bootclasspath
-    # so we can create it.
-    BOOT_OPT="-Ximage:/system/framework/boot.art"
-    BOOT_OPT="${BOOT_OPT} -Xbootclasspath:$ANDROID_HOST_OUT/../common/obj/JAVA_LIBRARIES/core-libart-hostdex_intermediates/javalib.jar"
+    # Set image to a place were there isn't one.
+    BOOT_OPT="-Ximage:/system/non-existant/core.art"
 fi
 
 if [ "$RELOCATE" = "y" ]; then
diff --git a/test/etc/push-and-run-prebuilt-test-jar b/test/etc/push-and-run-prebuilt-test-jar
index c1d407d..91b8a0f 100755
--- a/test/etc/push-and-run-prebuilt-test-jar
+++ b/test/etc/push-and-run-prebuilt-test-jar
@@ -150,8 +150,7 @@ fi
 msg "------------------------------"
 
 if [ "$HAVE_IMAGE" = "n" ]; then
-    BOOT_OPT="-Ximage:/system/non-existant/boot.art"
-    BOOT_OPT="${BOOT_OPT} -Xbootclasspath:/system/framework/core-libart.jar"
+    BOOT_OPT="-Ximage:/system/non-existant/core.art"
 fi
 
 ARCH=$(adb shell ls -F /data/dalvik-cache | grep -Ewo "${ARCHITECTURES_PATTERN}")
diff --git a/test/etc/push-and-run-test-jar b/test/etc/push-and-run-test-jar
index 9e63bed..e398b5d 100755
--- a/test/etc/push-and-run-test-jar
+++ b/test/etc/push-and-run-test-jar
@@ -143,8 +143,7 @@ fi
 msg "------------------------------"
 
 if [ "$HAVE_IMAGE" = "n" ]; then
-    BOOT_OPT="-Ximage:/system/non-existant/boot.art"
-    BOOT_OPT="${BOOT_OPT} -Xbootclasspath:/system/framework/core-libart.jar"
+    BOOT_OPT="-Ximage:/system/non-existant/core.art"
 fi
 
 if [ "$QUIET" = "n" ]; then
diff --git a/test/run-test b/test/run-test
index 2b4a41d..eed28a5 100755
--- a/test/run-test
+++ b/test/run-test
@@ -317,6 +317,26 @@ elif [ "$runtime" = "art" ]; then
 fi
 
 if [ "$have_image" = "no" ]; then
+    if [ "$runtime" != "art" ]; then
+        echo "--no-image is only supported on the art runtime"
+        exit 1
+    fi
+    if [ "$target_mode" = "no" ]; then
+        framework="${ANDROID_HOST_OUT}/framework"
+        bpath_suffix="-hostdex"
+    else
+        framework="/system/framework"
+        bpath_suffix=""
+    fi
+    # TODO If the target was compiled WITH_DEXPREOPT=true then these tests will
+    # fail since these jar files will be stripped.
+    bpath="${framework}/core-libart${bpath_suffix}.jar"
+    bpath="${bpath}:${framework}/conscrypt${bpath_suffix}.jar"
+    bpath="${bpath}:${framework}/okhttp${bpath_suffix}.jar"
+    bpath="${bpath}:${framework}/core-junit${bpath_suffix}.jar"
+    bpath="${bpath}:${framework}/bouncycastle${bpath_suffix}.jar"
+    # Pass down the bootclasspath
+    run_args="${run_args} --runtime-option -Xbootclasspath:${bpath}"
     run_args="${run_args} --no-image"
 fi