- \n
- Improved code quality: Unit tests help to catch bugs early in the development cycle, making it easier to fix them before they become more complex and harder to solve.<\/li>\n
- Faster development: Unit tests can reduce the time it takes to develop features by helping to identify and isolate issues early, reducing the need for manual testing and debugging.<\/li>\n
- Reduced risk: By catching bugs early and ensuring that each unit of code is working correctly, the overall stability of the application is improved, reducing the risk of crashes and other errors.<\/li>\n
- Better collaboration: Unit tests help to create a shared understanding of the code between developers, making it easier to collaborate on complex projects and reducing the likelihood of miscommunication.<\/li>\n<\/ol>\n
Best Practices for Android Unit Testing<\/h2>\n
- \n
- Test only one thing at a time: Each test should focus on a single unit or component of the code, to ensure that it is working as expected in isolation.<\/li>\n
- Test both positive and negative scenarios: It’s important to test both scenarios where the code is expected to work as well as where it is expected to fail, to ensure that it is robust and resilient.<\/li>\n
- Use mocking and stubbing: Mocking and stubbing allow developers to create fake objects and data that simulate real-world scenarios, helping to test code that depends on external dependencies.<\/li>\n
- Keep tests simple and readable: Tests should be easy to read and understand, with clear and concise assertions that are easy to interpret.<\/li>\n
- Use a testing framework: Testing frameworks provide a range of tools and functionality to help with unit testing, including setup and teardown methods, assertions, and test runners.<\/li>\n<\/ol>\n
Popular Android Unit Testing Frameworks<\/h2>\n
- \n
- JUnit: JUnit is a widely used testing framework for Java applications, and it is also supported by Android. It provides a range of tools and features for writing and running unit tests, including assertions, test fixtures, and test runners.<\/li>\n
- Mockito: Mockito is a popular mocking framework for Java applications, and it is widely used in Android unit testing. It allows developers to create fake objects and data to simulate real-world scenarios, helping to test code that depends on external dependencies.<\/li>\n
- Espresso: Espresso is a testing framework specifically designed for Android UI testing. It provides a range of tools and functionality to help with UI testing, including UI interaction testing, screenshot comparisons, and performance testing.<\/li>\n
- Robolectric: Robolectric is a popular testing framework for Android applications, which allows developers to run tests on a simulated Android device. This can help to speed up the testing process and reduce the need for manual testing on physical devices.<\/li>\n<\/ol>\n
Examples<\/h2>\n
- \n
- \n
Testing a simple calculation function<\/strong><\/h4>\n<\/li>\n<\/ol>\n
\n
public<\/span> class<\/span> CalculationTest<\/span> {\r\n @Test\r\n public<\/span> void<\/span> testAddition<\/span>()<\/span> {\r\n int<\/span> result = Calculation.addition(2<\/span>, 3<\/span>);\r\n assertEquals(5<\/span>, result);\r\n }\r\n}<\/code><\/pre>\n<\/blockquote>\nIn this example, we are testing a simple addition function
addition()<\/code> in a class calledCalculation<\/code>. We create a unit test case that calls this function with two arguments, and then we use theassertEquals()<\/code> method to check if the result is equal to the expected value (5).<\/p>\n- \n
- \n
Testing a function that throws an exception<\/h4>\n<\/li>\n<\/ul>\n
\n
public<\/span> class<\/span> ExceptionTest<\/span> {\r\n @Test(expected = IllegalArgumentException.class)<\/span>\r\n public<\/span> void<\/span> testException<\/span>()<\/span> {\r\n User<\/span> user<\/span> =<\/span> new<\/span> User<\/span>(null<\/span>, \"password\"<\/span>);\r\n }\r\n}<\/code><\/pre>\n<\/blockquote>\nIn this example, we are testing a function that throws an exception if an argument is null. We use the
@Test(expected = ...)<\/code> annotation to specify that we expect anIllegalArgumentException<\/code> to be thrown when we create a newUser<\/code> object with a null username. If the exception is not thrown, the test case will fail.<\/p>\n- \n
- \n
Testing a function that depends on external data<\/h4>\n<\/li>\n<\/ul>\n
\n
public<\/span> class<\/span> DatabaseTest<\/span> {\r\n private<\/span> DatabaseHelper dbHelper;\r\n\r\n @Before<\/span>\r\n public<\/span> void<\/span> setUp<\/span>()<\/span> throws<\/span> Exception {\r\n Context<\/span> context<\/span> =<\/span> ApplicationProvider.getApplicationContext();\r\n dbHelper = new<\/span> DatabaseHelper<\/span>(context);\r\n }\r\n\r\n @Test<\/span>\r\n public<\/span> void<\/span> testGetUser<\/span>()<\/span> {\r\n User<\/span> user<\/span> =<\/span> dbHelper.getUser(1<\/span>);\r\n assertNotNull(user);\r\n assertEquals(\"John Doe\"<\/span>, user.getName());\r\n }\r\n}<\/code><\/pre>\n<\/blockquote>\nIn this example, we are testing a function that throws an exception if an argument is null. We use the
@Test(expected = ...)<\/code> annotation to specify that we expect anIllegalArgumentException<\/code> to be thrown when we create a newUser<\/code> object with a null username. If the exception is not thrown, the test case will fail Testing a function that depends on external data<\/p>\n- \n
- \n
\u00a0Testing a ViewModel with a mocked Repository<\/h4>\n<\/li>\n<\/ul>\n
\n
@RunWith<\/span>(MockitoJUnitRunner.class)\r\npublic class MyViewModelTest {\r\n\r\n @Mock<\/span>\r\n private MyRepository myRepository;\r\n\r\n private MyViewModel myViewModel;\r\n\r\n @Before<\/span>\r\n public void setUp() {\r\n myViewModel = new MyViewModel<\/span>(myRepository);\r\n }\r\n\r\n @Test<\/span>\r\n public void testGetItems() {\r\n List<MyItem> items = Arrays.asList<\/span>(\r\n new MyItem(1<\/span>, \"Item 1<\/span>\"),\r\n new MyItem<\/span>(2<\/span>, \"Item 2<\/span>\")\r\n );\r\n\r\n when<\/span>(myRepository.getItems()).thenReturn<\/span>(items);\r\n\r\n LiveData<List<MyItem>> liveData = myViewModel.getItems<\/span>();\r\n List<MyItem> result = liveData.getValue<\/span>();\r\n\r\n assertEquals<\/span>(items.size(), result.size<\/span>());\r\n assertEquals<\/span>(items.get(0<\/span>).getName<\/span>(), result.get<\/span>(0<\/span>).getName<\/span>());\r\n assertEquals<\/span>(items.get(1<\/span>).getName<\/span>(), result.get<\/span>(1<\/span>).getName<\/span>());\r\n }\r\n}<\/code><\/pre>\n<\/blockquote>\nIn this example, we are testing a ViewModel MyViewModel that depends on a Repository MyRepository. We use the Mockito library to mock the Repository and set it up in the setUp() method. Then, we use the when() method to define the behavior of the Repository’s getItems() method and return a list of test items. Finally, we call the ViewModel’s getItems() method and use assertions to verify that the returned list of items matches the expected values.<\/p>\n
- \n
- \n
Testing a LiveData transformation function<\/h4>\n<\/li>\n<\/ul>\n
\n
@RunWith<\/span>(MockitoJUnitRunner.class)\r\npublic class MyViewModelTest {\r\n\r\n @Mock<\/span>\r\n private MyRepository myRepository;\r\n\r\n private MyViewModel myViewModel;\r\n\r\n @Before<\/span>\r\n public void setUp() {\r\n myViewModel = new MyViewModel<\/span>(myRepository);\r\n }\r\n\r\n @Test<\/span>\r\n public void testGetItemNames() {\r\n List<MyItem> items = Arrays.asList<\/span>(\r\n new MyItem(1<\/span>, \"Item 1<\/span>\"),\r\n new MyItem<\/span>(2<\/span>, \"Item 2<\/span>\")\r\n );\r\n\r\n MutableLiveData<List<MyItem>> liveData = new MutableLiveData<>();\r\n liveData.setValue<\/span>(items);\r\n\r\n LiveData<List<String>> result = myViewModel.getItemNames<\/span>(liveData);\r\n List<String> expected = Arrays.asList<\/span>(\"Item 1<\/span>\", \"Item 2<\/span>\");\r\n\r\n assertEquals<\/span>(expected.size(), result.getValue<\/span>().size<\/span>());\r\n assertEquals<\/span>(expected.get(0<\/span>), result.getValue<\/span>().get<\/span>(0<\/span>));\r\n assertEquals<\/span>(expected.get(1<\/span>), result.getValue<\/span>().get<\/span>(1<\/span>));\r\n }\r\n}<\/code><\/pre>\n<\/blockquote>\nIn this example, we are testing a transformation function in a ViewModel
MyViewModel<\/code> that converts a list ofMyItem<\/code> objects to a list of their names. We set up a test list of items, create a LiveData object with this list, and pass it to the ViewModel’sgetItemNames()<\/code> method. We use assertions to verify that the returned list of names matches the expected values.<\/p>\nThese are just a few examples of writing unit test cases in Android using the JUnit & Mockito framework. Unit tests can be written for any function or component in an Android application, and they are a valuable tool for ensuring code quality and catching bugs early in the development process.<\/p>\n
Code Coverage using Kover in Android<\/h2>\n
Code coverage in Android refers to the measurement and analysis of how much of your application’s source code is executed by your tests. It provides insights into which your tests are exercising parts of your code and identifies areas that may lack sufficient test coverage. Code coverage is a metric that helps you assess the effectiveness of your test suite and can be used to improve the quality and reliability of your Android application.<\/p>\n
Code coverage analysis can be performed at different levels, including:<\/p>\n
- \n
- Line coverage<\/strong>: Measures the percentage of individual lines of code executed by the tests.<\/li>\n
- Branch coverage<\/strong>: Measures the percentage of decision points (branches) in your code that have been taken by the tests. It determines whether both true and false branches of conditional statements have been executed.<\/li>\n
- Method coverage<\/strong>: Measures the percentage of methods or functions that the tests have called.<\/li>\n<\/ol>\n
To measure code coverage in Android using the Kover library, you can follow these steps:<\/p>\n
- \n
- Add dependencies to your project. Include the Kover plugin and dependencies in your project’s build.gradle file:<\/li>\n<\/ul>\n
\n
buildscript {\r\n dependencies {\r\n \/\/ Other dependencies\r\n classpath 'com.vanniktech:gradle-android-kover:0.6.0'\r\n }\r\n}\r\n\r\napply plugin: 'kover'\r\n<\/code><\/pre>\n<\/blockquote>\n- \n
- Configure kover in your module’s build.gradle file. Inside the module’s build.gradle file, apply the kover plugin and configure it:<\/li>\n<\/ul>\n
\n
apply plugin: 'kover'<\/code><\/pre>\nkover {\r\n jacocoVersion = '0.8.7'\r\n reportDir = \"${project.buildDir}\/kover\"\r\n enabled = true\r\n}\r\n\r\nandroid {\r\n \/\/ Other Android configuration\r\n testOptions {\r\n unitTests.all {\r\n jacoco {\r\n includeNoLocationClasses = true\r\n }\r\n }\r\n }\r\n}<\/code><\/pre>\napply plugin: 'kover'<\/code><\/pre>\n<\/blockquote>\n- \n
- Run your tests with code coverage. To run your tests with code coverage, execute the following command in the terminal. Below command runs your unit tests and generates a code coverage report.<\/li>\n<\/ul>\n
.\/gradlew testDebugUnitTestCoverage<\/code><\/p><\/blockquote>\n- \n
- View the code coverage report. After running the tests, you can find the generated code coverage report in the specified
reportDir<\/code> folder (e.g.,${project.buildDir}\/kover<\/code>). Open the HTML report in your web browser to view the code coverage metrics.The kover library uses the JaCoCo code coverage tool under the hood, and the generated report will show information about the percentage of code coverage for each class and method in your project.\n![\"\"](\"\/blog\/wp-ttn-blog\/uploads\/2023\/06\/Screenshot-2023-06-20-at-11.35.44-AM.png\")
<\/li>\n<\/ul>\n
- View the code coverage report. After running the tests, you can find the generated code coverage report in the specified
- Run your tests with code coverage. To run your tests with code coverage, execute the following command in the terminal. Below command runs your unit tests and generates a code coverage report.<\/li>\n<\/ul>\n
- Configure kover in your module’s build.gradle file. Inside the module’s build.gradle file, apply the kover plugin and configure it:<\/li>\n<\/ul>\n
- Branch coverage<\/strong>: Measures the percentage of decision points (branches) in your code that have been taken by the tests. It determines whether both true and false branches of conditional statements have been executed.<\/li>\n
- Line coverage<\/strong>: Measures the percentage of individual lines of code executed by the tests.<\/li>\n
- \n
- \n
- \n
- \n
- \n