Java 类android.support.test.espresso.FailureHandler 实例源码

@Test
public void testForCoverage() {
    espScreenshotFailureHandler.delegate = new FailureHandler() {
        @Override
        public void handle(Throwable error, Matcher<View> viewMatcher) {
            // avoid that exception is thrown by default failure handler
        }
    };

    espScreenshotFailureHandler.handle(new TestException(), isRoot());
    File screenshot = new File(InstrumentationRegistry.getTargetContext().getFilesDir(), "test-screenshots/Failed-EspScreenshotFailureHandlerTest.testForCoverage.png");
    assertThat(screenshot.exists(), is(true));

    //noinspection ResultOfMethodCallIgnored
    screenshot.delete();
}

@Test
public void testScreenshotFailure() {
    espScreenshotFailureHandler.delegate = new FailureHandler() {
        @Override
        public void handle(Throwable error, Matcher<View> viewMatcher) {
            // avoid that exception is thrown by default failure handler
            wasDelegateCalled = true;
        }
    };

    InstrumentationRegistry.getInstrumentation().runOnMainSync(new Runnable() {
        @Override
        public void run() {
            espScreenshotFailureHandler.handle(new TestException(), isRoot());
        }
    });

    assertTrue(wasDelegateCalled);
}

public void setupFailureHandler(Description description) {
    final String testClassName = description.getClassName();
    final String testMethodName = description.getMethodName();
    final Context context = InstrumentationRegistry.getTargetContext();
    Espresso.setFailureHandler(new FailureHandler() {
        @Override
        public void handle(Throwable throwable, Matcher<View> matcher) {
            SpoonScreenshotAction.perform("espresso_assertion_failed", testClassName, testMethodName);
            new DefaultFailureHandler(context).handle(throwable, matcher);
        }
    });
}

@Override
public Statement apply(final Statement base, final Description description) {
    Espresso.setFailureHandler(new FailureHandler() {
        @Override
        public void handle(Throwable error, Matcher<View> viewMatcher) {
            Spoon.screenshot(SpoonTestRule.this.getActivity(), error.getClass().getSimpleName(), description.getClassName(), description.getMethodName());
            new DefaultFailureHandler(SpoonTestRule.this.getActivity()).handle(error, viewMatcher);
        }
    });
    return super.apply(base, description);
}

/** 
 * Replaces NoMatchingViewException with MySpecialException (to be caught in the test)
 */
@Override
public void onFailure(FailureHandler delegate, Throwable error, Matcher<View> viewMatcher) {
    try {
        delegate.handle(error, viewMatcher);
    } catch (NoMatchingViewException e) {
        throw new MySpecialException(e);
    }
}

/**
 * <b>Modifies the given ViewInteraction</b> to have a no-op FailureHandler. Use this, e.g.,
 * to perform an action on a View if it's visible and not complain if it isn't.
 *
 * @return the modified ViewInteraction
 */
static ViewInteraction ignoringFailures(@NonNull ViewInteraction interaction) {
    return interaction.withFailureHandler(new FailureHandler() {
        @Override
        public void handle(Throwable error, Matcher<View> viewMatcher) {
        }
    });
}

/** @see android.support.test.espresso.Espresso#setFailureHandler(android.support.test.espresso.FailureHandler) */
protected void onFailure(FailureHandler delegate, Throwable error, Matcher<View> viewMatcher) {
    delegate.handle(error, viewMatcher);
}