| java.lang.Object | |||
| ↳ | android.app.Instrumentation | ||
| ↳ | android.support.test.runner.MonitoringInstrumentation | ||
| ↳ | android.support.test.runner.AndroidJUnitRunner | ||
An Instrumentation that runs JUnit3 and JUnit4 tests against
 an Android package (application).
 
InstrumentationTestRunner. Supports a superset
 of InstrumentationTestRunner features,
 while maintaining command/output format compatibility with that class.
 TestCases and/or JUnit4 style
 
 Tests that perform tests against the classes in your package.
 Make use of the InstrumentationRegistry if needed.
 
 In an appropriate AndroidManifest.xml, define an instrumentation with android:name set to
 AndroidJUnitRunner and the appropriate android:targetPackage
 set.
 
 Execution options:
 
 Running all tests: adb shell am instrument -w
 com.android.foo/android.support.test.runner.AndroidJUnitRunner
 
 Running all tests in a class: adb shell am instrument -w
 -e class com.android.foo.FooTest
 com.android.foo/android.support.test.runner.AndroidJUnitRunner
 
 Running a single test: adb shell am instrument -w
 -e class com.android.foo.FooTest#testFoo
 com.android.foo/android.support.test.runner.AndroidJUnitRunner
 
 Running all tests in multiple classes: adb shell am instrument -w
 -e class com.android.foo.FooTest,com.android.foo.TooTest
 com.android.foo/android.support.test.runner.AndroidJUnitRunner
 
 Running all tests listed in a file: adb shell am instrument -w
 -e testFile /sdcard/tmp/testFile.txt com.android.foo/com.android.test.runner.AndroidJUnitRunner
 The file should contain a list of line separated test classes and optionally methods (expected
 format: com.android.foo.FooClassName#testMethodName).
 
 Running all tests in a java package: adb shell am instrument -w
 -e package com.android.foo.bar
 com.android.foo/android.support.test.runner.AndroidJUnitRunner
 To debug your tests, set a break point in your code and pass:
 -e debug true
 
 Running a specific test size i.e. annotated with
 SmallTest or
 MediumTest or
 LargeTest:
 adb shell am instrument -w -e size [small|medium|large]
 com.android.foo/android.support.test.runner.AndroidJUnitRunner
 
 Filter test run to tests with given annotation: adb shell am instrument -w
 -e annotation com.android.foo.MyAnnotation
 com.android.foo/android.support.test.runner.AndroidJUnitRunner
 
 If used with other options, the resulting test run will contain the intersection of the two
 options.
 e.g. "-e size large -e annotation com.android.foo.MyAnnotation" will run only tests with both
 the LargeTest and "com.android.foo.MyAnnotation" annotations.
 
 Filter test run to tests without given annotation: adb shell am instrument -w
 -e notAnnotation com.android.foo.MyAnnotation
 com.android.foo/android.support.test.runner.AndroidJUnitRunner
 
 As above, if used with other options, the resulting test run will contain the intersection of
 the two options.
 e.g. "-e size large -e notAnnotation com.android.foo.MyAnnotation" will run tests with
 the LargeTest annotation that do NOT have the "com.android.foo.MyAnnotation" annotations.
 
 Filter test run to tests without any of a list of annotations: adb shell am
 instrument -w -e notAnnotation com.android.foo.MyAnnotation,com.android.foo.AnotherAnnotation
 com.android.foo/android.support.test.runner.AndroidJUnitRunner
 
 Filter test run to a shard of all tests, where numShards is an integer greater than 0 and
 shardIndex is an integer between 0 (inclusive) and numShards (exclusive): adb shell am
 instrument -w -e numShards 4 -e shardIndex 1
 com.android.foo/android.support.test.runner.AndroidJUnitRunner
 
 To run in 'log only' mode
 -e log true
 This option will load and iterate through all test classes and methods, but will bypass actual
 test execution. Useful for quickly obtaining info on the tests to be executed by an
 instrumentation command.
 
 To generate EMMA code coverage:
 -e coverage true
 Note: this requires an emma instrumented build. By default, the code coverage results file
 will be saved in a /data/RunListeners to observe the test run:
 -e listener com.foo.Listener,com.foo.Listener2
 
 Set timeout (in milliseconds) that will be applied to each test:
 -e timeout_msec 5000
 
 Supported for both JUnit3 and JUnit4 style tests. For JUnit3 tests, this flag is the only way
 to specify timeouts. For JUnit4 tests, this flag overrides timeouts specified via
 
 org.junit.rules.Timeout. Please note that in JUnit4
 
 org.junit.Test#timeout()
 annotation take precedence over both, this flag and
 
 org.junit.Test#timeout()
 annotation.
 
 To disable Google Analytics:
 -e disableAnalytics true
 
 In order to make sure we are on the right track with each new release,
 the test runner collects analytics. More specifically, it uploads a hash of the package name
 of the application under test for each invocation. This allows us to measure both the count of
 unique packages using this library as well as the volume of usage.
 
 All arguments can also be specified in the in the AndroidManifest via a meta-data tag:
 eg. using listeners:
 instrumentation android:name="android.support.test.runner.AndroidJUnitRunner" ...
    meta-data android:name="listener"
              android:value="com.foo.Listener,com.foo.Listener2"
 Arguments specified via shell will take override manifest specified arguments.
| [Expand] Inherited Constants | |||||||||||
|---|---|---|---|---|---|---|---|---|---|---|---|
|  From class
android.app.Instrumentation | |||||||||||
| Public Constructors | |||||||||||
|---|---|---|---|---|---|---|---|---|---|---|---|
| Public Methods | |||||||||||
|---|---|---|---|---|---|---|---|---|---|---|---|
| 
          Ensures all activities launched in this instrumentation are finished before the
 instrumentation exits.
         | |||||||||||
| 
          Sets up lifecycle monitoring, and argument registry.
         | |||||||||||
| 
          This implementation of onStart() will guarantee that the Application's onCreate method
 has completed when it returns.
         | |||||||||||
| [Expand] Inherited Methods | |||||||||||
|---|---|---|---|---|---|---|---|---|---|---|---|
|  From class
  android.support.test.runner.MonitoringInstrumentation | |||||||||||
|  From class
  android.app.Instrumentation | |||||||||||
|  From class
  java.lang.Object | |||||||||||
Ensures all activities launched in this instrumentation are finished before the instrumentation exits.
Subclasses who override this method should do their finish processing and then call super.finish to invoke this logic. Not waiting for all activities to finish() before exiting can cause device wide instability.
Sets up lifecycle monitoring, and argument registry.
Subclasses must call up to onCreate(). This onCreate method does not call start() it is the subclasses responsibility to call start if it desires.
This implementation of onStart() will guarantee that the Application's onCreate method has completed when it returns.
Subclasses should call super.onStart() before executing any code that touches the application and it's state.