Lines Matching refs:actual
40 * {@code actual}. This verifies {@code expected} is a parent class or a
41 * interface that {@code actual} implements.
43 public static void assertAssignableFrom(Class<?> expected, Object actual) {
44 assertAssignableFrom(expected, actual.getClass());
49 * {@code actual}. This verifies {@code expected} is a parent class or a
50 * interface that {@code actual} implements.
52 public static void assertAssignableFrom(Class<?> expected, Class<?> actual) {
55 " to be assignable from actual class " + actual.getCanonicalName(),
56 expected.isAssignableFrom(actual));
60 * Asserts that {@code actual} is not equal {@code unexpected}, according
64 String message, Object unexpected, Object actual) {
65 if (equal(unexpected, actual)) {
74 public static void assertNotEqual(Object unexpected, Object actual) {
75 assertNotEqual(null, unexpected, actual);
79 * Asserts that array {@code actual} is the same size and every element equals
84 String message, byte[] expected, byte[] actual) {
85 if (expected.length != actual.length) {
86 failWrongLength(message, expected.length, actual.length);
89 if (expected[i] != actual[i]) {
90 failWrongElement(message, i, expected[i], actual[i]);
96 * Asserts that array {@code actual} is the same size and every element equals
100 public static void assertEquals(byte[] expected, byte[] actual) {
101 assertEquals(null, expected, actual);
105 * Asserts that array {@code actual} is the same size and every element equals
110 String message, int[] expected, int[] actual) {
111 if (expected.length != actual.length) {
112 failWrongLength(message, expected.length, actual.length);
115 if (expected[i] != actual[i]) {
116 failWrongElement(message, i, expected[i], actual[i]);
122 * Asserts that array {@code actual} is the same size and every element equals
126 public static void assertEquals(int[] expected, int[] actual) {
127 assertEquals(null, expected, actual);
131 * @hide Asserts that array {@code actual} is the same size and every element equals
136 String message, long[] expected, long[] actual) {
137 if (expected.length != actual.length) {
138 failWrongLength(message, expected.length, actual.length);
141 if (expected[i] != actual[i]) {
142 failWrongElement(message, i, expected[i], actual[i]);
148 * @hide Asserts that array {@code actual} is the same size and every element equals
152 public static void assertEquals(long[] expected, long[] actual) {
153 assertEquals(null, expected, actual);
158 * Asserts that array {@code actual} is the same size and every element equals
163 String message, double[] expected, double[] actual) {
164 if (expected.length != actual.length) {
165 failWrongLength(message, expected.length, actual.length);
168 if (expected[i] != actual[i]) {
169 failWrongElement(message, i, expected[i], actual[i]);
175 * Asserts that array {@code actual} is the same size and every element equals
179 public static void assertEquals(double[] expected, double[] actual) {
180 assertEquals(null, expected, actual);
184 * Asserts that array {@code actual} is the same size and every element
191 String message, Object[] expected, Object[] actual) {
192 if (expected.length != actual.length) {
193 failWrongLength(message, expected.length, actual.length);
197 Object act = actual[i];
206 * Asserts that array {@code actual} is the same size and every element
211 public static void assertEquals(Object[] expected, Object[] actual) {
212 assertEquals(null, expected, actual);
217 String message, Set<? extends Object> expected, Set<? extends Object> actual) {
219 onlyInExpected.removeAll(actual);
220 Set<Object> onlyInActual = new HashSet<Object>(actual);
224 intersection.retainAll(actual);
228 + "\nOnly in actual: " + onlyInActual
234 public static void assertEquals(Set<? extends Object> expected, Set<? extends Object> actual) {
235 assertEquals(null, expected, actual);
239 * Asserts that {@code expectedRegex} exactly matches {@code actual} and
246 String message, String expectedRegex, String actual) {
247 if (actual == null) {
248 failNotMatches(message, expectedRegex, actual);
250 Matcher matcher = getMatcher(expectedRegex, actual);
252 failNotMatches(message, expectedRegex, actual);
262 String expectedRegex, String actual) {
263 return assertMatchesRegex(null, expectedRegex, actual);
267 * Asserts that {@code expectedRegex} matches any substring of {@code actual}
274 String message, String expectedRegex, String actual) {
275 if (actual == null) {
276 failNotContains(message, expectedRegex, actual);
278 Matcher matcher = getMatcher(expectedRegex, actual);
280 failNotContains(message, expectedRegex, actual);
290 String expectedRegex, String actual) {
291 return assertContainsRegex(null, expectedRegex, actual);
295 * Asserts that {@code expectedRegex} does not exactly match {@code actual},
301 String message, String expectedRegex, String actual) {
302 Matcher matcher = getMatcher(expectedRegex, actual);
304 failMatch(message, expectedRegex, actual);
313 String expectedRegex, String actual) {
314 assertNotMatchesRegex(null, expectedRegex, actual);
319 * {@code actual}, and fails with {@code message} if it does. Note that you
324 String message, String expectedRegex, String actual) {
325 Matcher matcher = getMatcher(expectedRegex, actual);
327 failContains(message, expectedRegex, actual);
336 String expectedRegex, String actual) {
337 assertNotContainsRegex(null, expectedRegex, actual);
341 * Asserts that {@code actual} contains precisely the elements
345 String message, Iterable<?> actual, Object... expected) {
347 for (Object o : actual) {
358 Iterable<?> actual, Object... expected) {
359 assertContentsInOrder((String) null, actual, expected);
363 * Asserts that {@code actual} contains precisely the elements
366 public static void assertContentsInAnyOrder(String message, Iterable<?> actual,
373 for (Object actualObj : actual) {
375 failWithMessage(message, "Extra object in actual: (" + actualObj.toString() + ")");
388 public static void assertContentsInAnyOrder(Iterable<?> actual, Object... expected) {
389 assertContentsInAnyOrder((String)null, actual, expected);
515 private static Matcher getMatcher(String expectedRegex, String actual) {
517 return pattern.matcher(actual);
525 String message, int expected, int actual) {
527 + "> but was:<" + actual + '>');
531 String message, int index, Object expected, Object actual) {
533 + expected + "> but was:<" + actual + '>');
537 String message, String expectedRegex, String actual) {
538 String actualDesc = (actual == null) ? "null" : ('<' + actual + '>');
544 String message, String expectedRegex, String actual) {
545 String actualDesc = (actual == null) ? "null" : ('<' + actual + '>');
551 String message, String expectedRegex, String actual) {
553 + "> but was:<" + actual + '>');
557 String message, String expectedRegex, String actual) {
559 + "> but was:<" + actual + '>');
563 String message, String actual) {
565 + actual + ">");
