Cross Reference: /frameworks/base/test-runner/src/android/test/MoreAsserts.java

Lines Matching refs:actual
41      * {@code actual}. This verifies {@code expected} is a parent class or a
42      * interface that {@code actual} implements.
44     public static void assertAssignableFrom(Class<?> expected, Object actual) {
45         assertAssignableFrom(expected, actual.getClass());
50      * {@code actual}. This verifies {@code expected} is a parent class or a
51      * interface that {@code actual} implements.
53     public static void assertAssignableFrom(Class<?> expected, Class<?> actual) {
56                         " to be assignable from actual class " + actual.getCanonicalName(),
57                 expected.isAssignableFrom(actual));
61      * Asserts that {@code actual} is not equal {@code unexpected}, according
65             String message, Object unexpected, Object actual) {
66         if (equal(unexpected, actual)) {
75     public static void assertNotEqual(Object unexpected, Object actual) {
76         assertNotEqual(null, unexpected, actual);
80      * Asserts that array {@code actual} is the same size and every element equals
85             String message, byte[] expected, byte[] actual) {
86         if (expected.length != actual.length) {
87             failWrongLength(message, expected.length, actual.length);
90             if (expected[i] != actual[i]) {
91                 failWrongElement(message, i, expected[i], actual[i]);
97      * Asserts that array {@code actual} is the same size and every element equals
101     public static void assertEquals(byte[] expected, byte[] actual) {
102         assertEquals(null, expected, actual);
106      * Asserts that array {@code actual} is the same size and every element equals
111             String message, int[] expected, int[] actual) {
112         if (expected.length != actual.length) {
113             failWrongLength(message, expected.length, actual.length);
116             if (expected[i] != actual[i]) {
117                 failWrongElement(message, i, expected[i], actual[i]);
123      * Asserts that array {@code actual} is the same size and every element equals
127     public static void assertEquals(int[] expected, int[] actual) {
128         assertEquals(null, expected, actual);
132      * Asserts that array {@code actual} is the same size and every element equals
137             String message, double[] expected, double[] actual) {
138         if (expected.length != actual.length) {
139             failWrongLength(message, expected.length, actual.length);
142             if (expected[i] != actual[i]) {
143                 failWrongElement(message, i, expected[i], actual[i]);
149      * Asserts that array {@code actual} is the same size and every element equals
153     public static void assertEquals(double[] expected, double[] actual) {
154         assertEquals(null, expected, actual);
158      * Asserts that array {@code actual} is the same size and every element
165             String message, Object[] expected, Object[] actual) {
166         if (expected.length != actual.length) {
167             failWrongLength(message, expected.length, actual.length);
171             Object act = actual[i];
180      * Asserts that array {@code actual} is the same size and every element
185     public static void assertEquals(Object[] expected, Object[] actual) {
186         assertEquals(null, expected, actual);
191             String message, Set<? extends Object> expected, Set<? extends Object> actual) {
193         onlyInExpected.removeAll(actual);
194         Set<Object> onlyInActual = new HashSet<Object>(actual);
198             intersection.retainAll(actual);
202                     + "\nOnly in actual: " + onlyInActual
208     public static void assertEquals(Set<? extends Object> expected, Set<? extends Object> actual) {
209         assertEquals(null, expected, actual);
213      * Asserts that {@code expectedRegex} exactly matches {@code actual} and
220             String message, String expectedRegex, String actual) {
221         if (actual == null) {
222             failNotMatches(message, expectedRegex, actual);
224         Matcher matcher = getMatcher(expectedRegex, actual);
226             failNotMatches(message, expectedRegex, actual);
236             String expectedRegex, String actual) {
237         return assertMatchesRegex(null, expectedRegex, actual);
241      * Asserts that {@code expectedRegex} matches any substring of {@code actual}
248             String message, String expectedRegex, String actual) {
249         if (actual == null) {
250             failNotContains(message, expectedRegex, actual);
252         Matcher matcher = getMatcher(expectedRegex, actual);
254             failNotContains(message, expectedRegex, actual);
264             String expectedRegex, String actual) {
265         return assertContainsRegex(null, expectedRegex, actual);
269      * Asserts that {@code expectedRegex} does not exactly match {@code actual},
275             String message, String expectedRegex, String actual) {
276         Matcher matcher = getMatcher(expectedRegex, actual);
278             failMatch(message, expectedRegex, actual);
287             String expectedRegex, String actual) {
288         assertNotMatchesRegex(null, expectedRegex, actual);
293      * {@code actual}, and fails with {@code message} if it does.  Note that you
298             String message, String expectedRegex, String actual) {
299         Matcher matcher = getMatcher(expectedRegex, actual);
301             failContains(message, expectedRegex, actual);
310             String expectedRegex, String actual) {
311         assertNotContainsRegex(null, expectedRegex, actual);
315      * Asserts that {@code actual} contains precisely the elements
319             String message, Iterable<?> actual, Object... expected) {
321         for (Object o : actual) {
332             Iterable<?> actual, Object... expected) {
333         assertContentsInOrder((String) null, actual, expected);
337      * Asserts that {@code actual} contains precisely the elements
340     public static void assertContentsInAnyOrder(String message, Iterable<?> actual,
347         for (Object actualObj : actual) {
349                 failWithMessage(message, "Extra object in actual: (" + actualObj.toString() + ")");
362     public static void assertContentsInAnyOrder(Iterable<?> actual, Object... expected) {
363         assertContentsInAnyOrder((String)null, actual, expected);
489     private static Matcher getMatcher(String expectedRegex, String actual) {
491         return pattern.matcher(actual);
499             String message, int expected, int actual) {
501                 + "> but was:<" + actual + '>');
505             String message, int index, Object expected, Object actual) {
507                 + expected + "> but was:<" + actual + '>');
511             String message, String expectedRegex, String actual) {
512         String actualDesc = (actual == null) ? "null" : ('<' + actual + '>');
518             String message, String expectedRegex, String actual) {
519         String actualDesc = (actual == null) ? "null" : ('<' + actual + '>');
525             String message, String expectedRegex, String actual) {
527                 + "> but was:<" + actual + '>');
531             String message, String expectedRegex, String actual) {
533                 + "> but was:<" + actual + '>');
537             String message, String actual) {
539                 + actual + ">");