Is it possible to find out if an Android application runs as part of an instrumentation test

Is there a runtime check for an application to find out if it runs as part of an instrumentation test?

Background: Our application performs a database sync when starting. But that should happen only when started regularly. It especia开发者_StackOverflow社区lly interferes with the instrumentation tests testing the db sync. Not surprisingly.

And with all the other tests it's just a waste of CPU cycles.

A much simpler solution is check for a class that would only be present in a test classpath, works with JUnit 4 (unlike the solution using ActivityUnitTestCase) and doesn't require to send custom intents to your Activities / Services (which might not even be possible in some cases)

private boolean isTesting() {
    try {
        Class.forName("com.company.SomeTestClass");
        return true;
    } catch (ClassNotFoundException e) {
        return false;
    }
}

Since API Level 11, the ActivityManager.isRunningInTestHarness() method is available. This might do what you want.

If you are using Robolectric, you can do something like this:

public boolean isUnitTest() {
        String device = Build.DEVICE;
        String product = Build.PRODUCT;
        if (device == null) {
            device = "";
        }

        if (product == null) {
            product = "";
        }
        return device.equals("robolectric") && product.equals("robolectric");
    }

If you're using ActivityUnitTestCase, you could set a custom Application object with setApplication, and have a flag in there to switch database sync on or off? There's an example of using a custom Application object on my blog:

http://www.paulbutcher.com/2011/03/mock-objects-on-android-with-borachio-part-3/

d= (◕‿↼ ) Great answer, but if some library developer (like me) wants to know if the Host (or App using the library) is being tested, then try:

import android.content.pm.ApplicationInfo;

// ...

private static int wasTestRun = 0xDEAD;

/**
 * Should only be used to speed up testing (no behavior change).
 * @return true in tests, if Gradle has the right dependencies.
 */
public static boolean isTestRun(@NonNull Context context) {
    if (wasTestRun != 0xDEAD) {
        return wasTestRun != 0;
    }
    // Ignore release builds (as App may be using JUnit by mistake).
    if (isDebuggable(context)) {
        try {
            Class.forName("org.junit.runner.Runner");
            wasTestRun = 1;
            return true;
        } catch (ClassNotFoundException ignored) {
        }
    }
    wasTestRun = 0;
    return false;
}

public static boolean isDebuggable(@Nullable Context context) {
    return context != null && (context.getApplicationContext()
            .getApplicationInfo().flags & ApplicationInfo.FLAG_DEBUGGABLE) != 0;
}

Note that I am not using any AtomicBoolean or other helpers, as it is already pretty fast (and locking may just bring the speed down).

You can pass an intent extra to your activity indicating it's under test.

1) In your test, pass "testMode" extra to your activity:

public void setUp() throws Exception {
    super.setUp();

    Intent activityIntent = new Intent();
    activityIntent.putExtra("testMode", true);
    setActivityIntent(activityIntent);
}

2) In your activity, check for testMode:

Bundle extras = getIntent().getExtras();
if (extras != null && extras.getBoolean("testMode")) {
    // disable your database sync
}

You can try this

if (isRunningTest == null) {
        isRunningTest = false;
        StackTraceElement[] stackTrace = Thread.currentThread().getStackTrace();
        List<StackTraceElement> list = Arrays.asList(stackTrace);
        for (StackTraceElement element : list) {
            if (element.getClassName().startsWith("androidx.test.runner.MonitoringInstrumentation")) {
                isRunningTest = true;
                break;
            }
        }
    }

This work for me because no actual device is running

public static boolean isUnitTest() {
    return Build.BRAND.startsWith(Build.UNKNOWN) && Build.DEVICE.startsWith(Build.UNKNOWN) && Build.DEVICE.startsWith(Build.UNKNOWN) && Build.PRODUCT.startsWith(Build.UNKNOWN);
}