Added in API level 1

TestCase

abstract class TestCase : Assert, Test

kotlin.Any
↳	junit.framework.Assert
	↳	junit.framework.TestCase

Known Direct Subclasses

AndroidTestCase, InstrumentationTestCase, TestSuiteBuilder.FailedToCreateTests

AndroidTestCase	Extend this if you need to access Resources or other things that depend on Activity Context.
InstrumentationTestCase	A test case that has access to `Instrumentation`.
TestSuiteBuilder.FailedToCreateTests	A special `junit.framework.TestCase` used to indicate a failure during the build() step.

Known Indirect Subclasses

ActivityInstrumentationTestCase, ActivityInstrumentationTestCase2, ActivityTestCase, ActivityUnitTestCase, ApplicationTestCase, LoaderTestCase, ProviderTestCase, ProviderTestCase2, ServiceTestCase, SingleLaunchActivityTestCase, SyncBaseInstrumentation

ActivityInstrumentationTestCase	This class provides functional testing of a single activity.
ActivityInstrumentationTestCase2	This class provides functional testing of a single activity.
ActivityTestCase	This is common code used to support Activity test cases.
ActivityUnitTestCase	This class provides isolated testing of a single activity.
ApplicationTestCase	This test case provides a framework in which you can test Application classes in a controlled environment.
LoaderTestCase	A convenience class for testing `Loader`s.
ProviderTestCase	If you would like to test a single content provider with an `InstrumentationTestCase`, this provides some of the boiler plate in `setUp` and `tearDown`.
ProviderTestCase2	This test case class provides a framework for testing a single `ContentProvider` and for testing your app code with an isolated content provider.
ServiceTestCase	This test case provides a framework in which you can test Service classes in a controlled environment.
SingleLaunchActivityTestCase	If you would like to test a single activity with an `android.test.InstrumentationTestCase`, this provides some of the boiler plate to launch and finish the activity in `setUp` and `tearDown`.
SyncBaseInstrumentation	If you would like to test sync a single provider with an `InstrumentationTestCase`, this provides some of the boiler plate in `setUp` and `tearDown`.

A test case defines the fixture to run multiple tests. To define a test case

implement a subclass of TestCase
define instance variables that store the state of the fixture
initialize the fixture state by overriding setUp()
clean-up after a test by overriding tearDown().

Each test runs in its own fixture so there can be no side effects among test runs. Here is an example:

public class MathTest extends TestCase {
     protected double fValue1;
     protected double fValue2;
 
     protected void setUp() {
        fValue1= 2.0;
        fValue2= 3.0;
     }
  }

For each test implement a method which interacts with the fixture. Verify the expected results with assertions specified by calling junit.framework.Assert#assertTrue(String, boolean) with a boolean.

public void testAdd() {
        double result= fValue1 + fValue2;
        assertTrue(result == 5.0);
     }

Once the methods are defined you can run them. The framework supports both a static type safe and more dynamic way to run a test. In the static way you override the runTest method and define the method to be invoked. A convenient way to do so is with an anonymous inner class.

TestCase test= new MathTest("add") {
     public void runTest() {
        testAdd();
     }
  };
  test.run();

The dynamic way uses reflection to implement runTest(). It dynamically finds and invokes a method. In this case the name of the test case has to correspond to the test method to be run.

TestCase test= new MathTest("testAdd");
  test.run();

The tests to be run can be collected into a TestSuite. JUnit provides different test runners which can run a test suite and collect the results. A test runner either expects a static method suite as the entry point to get a test to run or it will extract the suite automatically.

public static Test suite() {
     suite.addTest(new MathTest("testAdd"));
     suite.addTest(new MathTest("testDivideByZero"));
     return suite;
  }

Summary

Public constructors
`<init>()` No-arg constructor to enable serialization.
`<init>(name: String!)` Constructs a test case with the given name.

Public methods
open Int	`countTestCases()` Counts the number of test cases executed by run(TestResult result).
open String!	`getName()` Gets the name of a TestCase
open TestResult!	`run()` A convenience method to run this test, collecting the results with a default TestResult object.
open Unit	`run(result: TestResult!)` Runs the test case and collects the results in TestResult.
open Unit	`runBare()` Runs the bare test sequence.
open Unit	`setName(name: String!)` Sets the name of a TestCase
open String	`toString()` Returns a string representation of the test case

Protected methods
open TestResult!	`createResult()` Creates a default TestResult object
open Unit	`runTest()` Override to run the test and assert its state.
open Unit	`setUp()` Sets up the fixture, for example, open a network connection.
open Unit	`tearDown()` Tears down the fixture, for example, close a network connection.

Inherited functions

From class Assert

`Unit`	`assertEquals(message: String!, expected: Any!, actual: Any!)` Asserts that two objects are equal. If they are not an AssertionFailedError is thrown with the given message.
`Unit`	`assertEquals(expected: Any!, actual: Any!)` Asserts that two objects are equal. If they are not an AssertionFailedError is thrown.
`Unit`	`assertEquals(message: String!, expected: String!, actual: String!)` Asserts that two Strings are equal.
`Unit`	`assertEquals(expected: String!, actual: String!)` Asserts that two Strings are equal.
`Unit`	`assertEquals(message: String!, expected: Double, actual: Double, delta: Double)` Asserts that two doubles are equal concerning a delta. If they are not an AssertionFailedError is thrown with the given message. If the expected value is infinity then the delta value is ignored.
`Unit`	`assertEquals(expected: Double, actual: Double, delta: Double)` Asserts that two doubles are equal concerning a delta. If the expected value is infinity then the delta value is ignored.
`Unit`	`assertEquals(message: String!, expected: Float, actual: Float, delta: Float)` Asserts that two floats are equal concerning a positive delta. If they are not an AssertionFailedError is thrown with the given message. If the expected value is infinity then the delta value is ignored.
`Unit`	`assertEquals(expected: Float, actual: Float, delta: Float)` Asserts that two floats are equal concerning a delta. If the expected value is infinity then the delta value is ignored.
`Unit`	`assertEquals(message: String!, expected: Long, actual: Long)` Asserts that two longs are equal. If they are not an AssertionFailedError is thrown with the given message.
`Unit`	`assertEquals(expected: Long, actual: Long)` Asserts that two longs are equal.
`Unit`	`assertEquals(message: String!, expected: Boolean, actual: Boolean)` Asserts that two booleans are equal. If they are not an AssertionFailedError is thrown with the given message.
`Unit`	`assertEquals(expected: Boolean, actual: Boolean)` Asserts that two booleans are equal.
`Unit`	`assertEquals(message: String!, expected: Byte, actual: Byte)` Asserts that two bytes are equal. If they are not an AssertionFailedError is thrown with the given message.
`Unit`	`assertEquals(expected: Byte, actual: Byte)` Asserts that two bytes are equal.
`Unit`	`assertEquals(message: String!, expected: Char, actual: Char)` Asserts that two chars are equal. If they are not an AssertionFailedError is thrown with the given message.
`Unit`	`assertEquals(expected: Char, actual: Char)` Asserts that two chars are equal.
`Unit`	`assertEquals(message: String!, expected: Short, actual: Short)` Asserts that two shorts are equal. If they are not an AssertionFailedError is thrown with the given message.
`Unit`	`assertEquals(expected: Short, actual: Short)` Asserts that two shorts are equal.
`Unit`	`assertEquals(message: String!, expected: Int, actual: Int)` Asserts that two ints are equal. If they are not an AssertionFailedError is thrown with the given message.
`Unit`	`assertEquals(expected: Int, actual: Int)` Asserts that two ints are equal.
`Unit`	`assertFalse(message: String!, condition: Boolean)` Asserts that a condition is false. If it isn't it throws an AssertionFailedError with the given message.
`Unit`	`assertFalse(condition: Boolean)` Asserts that a condition is false. If it isn't it throws an AssertionFailedError.
`Unit`	`assertNotNull(object: Any!)` Asserts that an object isn't null.
`Unit`	`assertNotNull(message: String!, object: Any!)` Asserts that an object isn't null. If it is an AssertionFailedError is thrown with the given message.
`Unit`	`assertNotSame(message: String!, expected: Any!, actual: Any!)` Asserts that two objects do not refer to the same object. If they do refer to the same object an AssertionFailedError is thrown with the given message.
`Unit`	`assertNotSame(expected: Any!, actual: Any!)` Asserts that two objects do not refer to the same object. If they do refer to the same object an AssertionFailedError is thrown.
`Unit`	`assertNull(object: Any!)` Asserts that an object is null. If it isn't an `AssertionError` is thrown. Message contains: Expected: but was: object
`Unit`	`assertNull(message: String!, object: Any!)` Asserts that an object is null. If it is not an AssertionFailedError is thrown with the given message.
`Unit`	`assertSame(message: String!, expected: Any!, actual: Any!)` Asserts that two objects refer to the same object. If they are not an AssertionFailedError is thrown with the given message.
`Unit`	`assertSame(expected: Any!, actual: Any!)` Asserts that two objects refer to the same object. If they are not the same an AssertionFailedError is thrown.
`Unit`	`assertTrue(message: String!, condition: Boolean)` Asserts that a condition is true. If it isn't it throws an AssertionFailedError with the given message.
`Unit`	`assertTrue(condition: Boolean)` Asserts that a condition is true. If it isn't it throws an AssertionFailedError.
`Unit`	`fail(message: String!)` Fails a test with the given message.
`Unit`	`fail()` Fails a test with no message.
`Unit`	`failNotEquals(message: String!, expected: Any!, actual: Any!)`
`Unit`	`failNotSame(message: String!, expected: Any!, actual: Any!)`
`Unit`	`failSame(message: String!)`
`String!`	`format(message: String!, expected: Any!, actual: Any!)`

Public constructors

<init>

Added in API level 1

TestCase()

No-arg constructor to enable serialization. This method is not intended to be used by mere mortals without calling setName().

<init>

Added in API level 1

TestCase(name: String!)

Constructs a test case with the given name.

Public methods

countTestCases

Added in API level 1

open fun countTestCases(): Int

Counts the number of test cases executed by run(TestResult result).

getName

Added in API level 1

open fun getName(): String!

Gets the name of a TestCase

Return
`String!`	the name of the TestCase

run

Added in API level 1

open fun run(): TestResult!

A convenience method to run this test, collecting the results with a default TestResult object.

See Also

junit.framework.TestResult

run

Added in API level 1

open fun run(result: TestResult!): Unit

Runs the test case and collects the results in TestResult.

runBare

Added in API level 1

open fun runBare(): Unit

Runs the bare test sequence.

Exceptions
`java.lang.Throwable`	if any exception is thrown

setName

Added in API level 1

open fun setName(name: String!): Unit

Sets the name of a TestCase

Parameters
`name`	String!: the name to set

toString

Added in API level 1

open fun toString(): String

Returns a string representation of the test case

Return
`String`	a string representation of the object.

Protected methods

createResult

Added in API level 1

protected open fun createResult(): TestResult!

Creates a default TestResult object

See Also

junit.framework.TestResult

runTest

Added in API level 1

protected open fun runTest(): Unit

Override to run the test and assert its state.

Exceptions
`java.lang.Throwable`	if any exception is thrown

setUp

Added in API level 1

protected open fun setUp(): Unit

Sets up the fixture, for example, open a network connection. This method is called before a test is executed.

tearDown

Added in API level 1

protected open fun tearDown(): Unit

Tears down the fixture, for example, close a network connection. This method is called after a test is executed.