Added in API level 1
Deprecated in API level 24

Summary: Inherited Fields | Ctors | Methods | Protected Methods | Inherited Methods

ApplicationTestCase

Kotlin |Java

public abstract class ApplicationTestCase
extends AndroidTestCase

java.lang.Object
↳	android.test.AndroidTestCase
	↳	android.test.ApplicationTestCase<T extends android.app.Application>

This class was deprecated in API level 24.
Use InstrumentationRegistry instead. New tests should be written using the Android Testing Support Library.

This test case provides a framework in which you can test Application classes in a controlled environment. It provides basic support for the lifecycle of a Application, and hooks by which you can inject various dependencies and control the environment in which your Application is tested.

Lifecycle Support. Every Application is designed to be accessed within a specific sequence of method calls (see Application for more details). In order to support the lifecycle of a Application, this test case will make the following calls at the following times.

The test case will not call onCreate() until your test calls createApplication(). This gives you a chance to set up or adjust any additional framework or test logic before onCreate().
After your test completes, the test case tearDown() method is automatically called, and it will stop & destroy your application by calling its onDestroy() method.

Dependency Injection. Every Application has one inherent dependency, the Context in which it runs. This framework allows you to inject a modified, mock, or isolated replacement for this dependencies, and thus perform a true unit test.

If simply run your tests as-is, your Application will be injected with a fully-functional Context. You can create and inject alternative types of Contexts by calling setContext(). You must do this before calling createApplication(). The test framework provides a number of alternatives for Context, including MockContext, RenamingDelegatingContext, and ContextWrapper.

Summary

Inherited fields

From class android.test.AndroidTestCase


    protected
    
    
    Context

mContext

Public constructors
`ApplicationTestCase(Class<T> applicationClass)`

Public methods
`T`	`getApplication()`
`Context`	`getSystemContext()` Return a real (not mocked or instrumented) system Context that can be used when generating Mock or other Context objects for your Application under test.
`final void`	`testApplicationTestCaseSetUpProperly()` This test simply confirms that the Application class can be instantiated properly.

Protected methods
`final void`	`createApplication()` Start the Application under test, in the same way as if it was started by the system.
`void`	`setUp()` This will do the work to instantiate the Application under test.
`void`	`tearDown()` Shuts down the Application under test.
`final void`	`terminateApplication()` This will make the necessary calls to terminate the Application under test (it will call onTerminate().

Inherited methods

From class


        
          android.test.AndroidTestCase

`void`	`assertActivityRequiresPermission(String packageName, String className, String permission)` Asserts that launching a given activity is protected by a particular permission by attempting to start the activity and validating that a `SecurityException` is thrown that mentions the permission in its error message.
`void`	`assertReadingContentUriRequiresPermission(Uri uri, String permission)` Asserts that reading from the content uri requires a particular permission by querying the uri and ensuring a `SecurityException` is thrown mentioning the particular permission.
`void`	`assertWritingContentUriRequiresPermission(Uri uri, String permission)` Asserts that writing to the content uri requires a particular permission by inserting into the uri and ensuring a `SecurityException` is thrown mentioning the particular permission.
`Context`	`getContext()`
`Context`	`getTestContext()` Returns the test context that was set via `setTestContext(android.content.Context)`.
`void`	`scrubClass(Class<?> testCaseClass)` This function is called by various TestCase implementations, at tearDown() time, in order to scrub out any class variables.
`void`	`setContext(Context context)`
`void`	`setTestContext(Context context)` Test context can be used to access resources from the test's own package as opposed to the resources from the test target package.
`void`	`setUp()`
`void`	`tearDown()`
`void`	`testAndroidTestCaseSetupProperly()`

From class


        
          java.lang.Object

`Object`	`clone()` Creates and returns a copy of this object.
`boolean`	`equals(Object obj)` Indicates whether some other object is "equal to" this one.
`void`	`finalize()` Called by the garbage collector on an object when garbage collection determines that there are no more references to the object.
`final Class<?>`	`getClass()` Returns the runtime class of this `Object`.
`int`	`hashCode()` Returns a hash code value for the object.
`final void`	`notify()` Wakes up a single thread that is waiting on this object's monitor.
`final void`	`notifyAll()` Wakes up all threads that are waiting on this object's monitor.
`String`	`toString()` Returns a string representation of the object.
`final void`	`wait(long timeoutMillis, int nanos)` Causes the current thread to wait until it is awakened, typically by being notified or interrupted, or until a certain amount of real time has elapsed.
`final void`	`wait(long timeoutMillis)` Causes the current thread to wait until it is awakened, typically by being notified or interrupted, or until a certain amount of real time has elapsed.
`final void`	`wait()` Causes the current thread to wait until it is awakened, typically by being notified or interrupted.

Public constructors

ApplicationTestCase

Added in API level 1

public ApplicationTestCase (Class<T> applicationClass)

Parameters
`applicationClass`	`Class`

Public methods

getApplication

Added in API level 1

public T getApplication ()

Returns
`T`	Returns the actual Application under test.

getSystemContext

Added in API level 1

public Context getSystemContext ()

Return a real (not mocked or instrumented) system Context that can be used when generating Mock or other Context objects for your Application under test.

Returns
`Context`	Returns a reference to a normal Context.

testApplicationTestCaseSetUpProperly

Added in API level 1

public final void testApplicationTestCaseSetUpProperly ()

This test simply confirms that the Application class can be instantiated properly.

Throws
	java.lang.Exception
`Exception`

Protected methods

createApplication

Added in API level 1

protected final void createApplication ()

Start the Application under test, in the same way as if it was started by the system. If you use this method to start the Application, it will automatically be stopped by tearDown(). If you wish to inject a specialized Context for your test, by calling setContext(), you must do so before calling this method.

setUp

Added in API level 1

protected void setUp ()

This will do the work to instantiate the Application under test. After this, your test code must also start and stop the Application.

Throws
`Exception`

tearDown

Added in API level 1

protected void tearDown ()

Shuts down the Application under test. Also makes sure all resources are cleaned up and garbage collected before moving on to the next test. Subclasses that override this method should make sure they call super.tearDown() at the end of the overriding method.

Throws
	java.lang.Exception
`Exception`

terminateApplication

Added in API level 1

protected final void terminateApplication ()

This will make the necessary calls to terminate the Application under test (it will call onTerminate(). Ordinarily this will be called automatically (by tearDown(), but you can call it directly from your test in order to check for proper shutdown behaviors.