Learning Android Application Testing

Read it now on the O’Reilly learning platform with a 10-day free trial.

O’Reilly members get unlimited access to books, live events, courses curated by job role, and more from O’Reilly and nearly 200 top publishers.

Book description

Improve your Android applications through intensive testing and debugging

This book is a practical introduction to readily available techniques, frameworks, and tools to thoroughly test your Android applications and improve project development.

You will learn the Java testing framework, how to create a test case and debug it. Next, you'll be walked through using the Android SDK to test using the ActivityTestCase and ActivityUnitTest classes as well as discussing popular testing libraries. Through examples you will test files, databases, ContentProviders, exceptions, services, and test your app using Espresso. You will discover how to manage your Android testing environment using Android emulators, deep dive into how adb and the emulator can super charge your testing automation, and also test user interactions with monkeyrunner. You will be guided through different testing methodologies including Test-driven Development and Behavior-driven Development and will learn how to perform Unit and Functional testing applying them to your Android projects. You will also use continuous integration techniques for ultimate application quality control using Gradle and Jenkins.

By the end of the book, you'll be looking through alternative testing tactics including Fest and Spoon to build upon and expand your Android testing range and finesse.

What You Will Learn

• Apply testing techniques and utilize tools to improve Android application development
• Get to grips with the nuances of testing on Android, including how to architect an application to facilitate better testing
• Explore the Android instrumentation testing framework to optimize your activities, services, content providers, and usage of other Android components
• Understand different development methodologies including Test-driven Development and Behavior-driven Development
• Apply the continuous integration technique for ultimate application quality control
• Improve application performance by analyzing the results returned from performance tests
• Expose your application to a wide range of conditions and configurations to simulate real-life network conditions and detect problems in the application
• Explore further tools to improve application quality such as micro benchmarks and code coverage

Table of contents

1. Learning Android Application Testing
   1. Table of Contents
   2. Learning Android Application Testing
   3. Credits
   4. About the Authors
   5. About the Reviewers
   6. www.PacktPub.com
      1. Support files, eBooks, discount offers, and more
         1. Why subscribe?
         2. Free access for Packt account holders
         1. What this book covers
         2. What you need for this book
         3. Who this book is for
         4. Conventions
         5. Reader feedback
         6. Customer support
            1. Downloading the example code
            2. Errata
            3. Piracy
            4. Questions
            5. Questions
            1. Why, what, how, and when to test?
               1. What to test
                  1. Activity lifecycle events
                  2. Database and filesystem operations
                  3. Physical characteristics of the device
                  1. Unit tests
                     1. The setUp() method
                     2. The tearDown() method
                     3. Outside the test method
                     4. Inside the test method
                        1. Mock objects
                        1. UI tests
                        1. Test case scenario
                        1. Android Studio and other IDE support
                        1. Instrumentation
                        2. Gradle
                        3. Test targets
                        1. Package explorer
                        2. Creating a test case
                        3. Test annotations
                        4. Running the tests
                           1. Running all tests from Android Studio
                           2. Running a single test case from your IDE
                           3. Running from the emulator
                           4. Running tests from the command line
                           5. Running all tests
                           6. Running tests from a specific test case
                           7. Running a specific test by name
                           8. Running specific tests by category
                           9. Running tests using Gradle
                              1. Creating a custom annotation
                              2. Running performance tests
                              3. Dry run
                              1. The demonstration application
                              2. Assertions in depth
                                 1. Custom messages
                                 2. Static imports
                                 1. An overview of MockContext
                                 2. The IsolatedContext class
                                 3. Alternate route to file and database operations
                                 4. The MockContentResolver class
                                 1. The default constructor
                                 2. The given name constructor
                                 3. The setName() method
                                 1. The assertActivityRequiresPermission() method
                                    1. Description
                                    2. Example
                                    1. Description
                                    2. Example
                                    1. Description
                                    2. Example
                                    1. The ActivityMonitor inner class
                                       1. Example
                                       1. The launchActivity and launchActivityWithIntent methods
                                       2. The sendKeys and sendRepeatedKeys methods
                                       3. The runTestOnUiThread helper method
                                       1. The scrubClass method
                                       1. The constructor
                                       2. The setUp method
                                       3. The tearDown method
                                       1. The constructor
                                       2. An example
                                       1. The constructor
                                       1. Android unit tests
                                       2. Testing activities and applications
                                          1. Mocking applications and preferences
                                             1. The RenamingMockContext class
                                             2. Mocking contexts
                                             1. The BrowserProvider tests
                                             1. Importing libraries
                                             2. Mockito usage example
                                             3. The EditNumber filter tests
                                             1. Android assets
                                             1. Creating Android Virtual Devices
                                             2. Running AVDs from the command line
                                                1. Headless emulator
                                                2. Disabling the keyguard
                                                3. Cleaning up
                                                4. Terminating the emulator
                                                1. Simulating network conditions
                                                1. The client-server monkey
                                                1. Getting test screenshots
                                                2. Record and playback
                                                1. Building Android applications manually using Gradle
                                                2. Git – the fast version control system
                                                   1. Creating a local Git repository
                                                   1. Installing and configuring Jenkins
                                                   2. Creating the jobs
                                                   3. Obtaining Android test results
                                                   1. Getting started with TDD
                                                      1. Writing a test case
                                                      2. Running all tests
                                                      3. Refactoring the code
                                                      4. Advantages of TDD
                                                      5. Understanding the requirements
                                                      1. List of requirements
                                                      2. User interface concept design
                                                         1. Creating the project
                                                         1. Creating the fixture
                                                         2. Creating the user interface
                                                         3. Testing the existence of the user interface components
                                                         4. Getting the IDs defined
                                                         5. Translating requirements to tests
                                                            1. Empty fields
                                                            2. View properties
                                                            1. Temperature conversion
                                                            2. The EditNumber class
                                                            3. The TemperatureConverter unit tests
                                                            4. The EditNumber tests
                                                            5. The TemperatureChangeWatcher class
                                                            6. More TemperatureConverter tests
                                                            7. The InputFilter tests
                                                            1. Given, When, and Then
                                                            2. FitNesse
                                                               1. Running FitNesse from the command line
                                                               2. Creating a TemperatureConverterTests subwiki
                                                                  1. Adding child pages to the subwiki
                                                                  2. Adding the acceptance test fixture
                                                                  3. Adding the supporting test classes
                                                                  1. Creating the test scenario
                                                                  1. Ye Olde Logge method
                                                                  2. Timing logger
                                                                  3. Performance tests in Android SDK
                                                                     1. Launching the performance test
                                                                        1. Creating the LaunchPerformanceBase instrumentation
                                                                        2. Creating the TemperatureConverterActivityLaunchPerformance class
                                                                        1. Caliper microbenchmarks
                                                                           1. Benchmarking the temperature converter
                                                                           2. Running Caliper
                                                                           1. Code coverage
                                                                              1. Jacoco features
                                                                              1. Generating code coverage analysis report
                                                                              2. Covering the exceptions
                                                                              1. Adding Robotium
                                                                              2. Creating the test cases
                                                                                 1. The testFahrenheitToCelsiusConversion() test
                                                                                 2. Testing between Activities
                                                                                 1. Comparing the performance gain
                                                                                 2. Adding Android to the picture
                                                                                 1. Installing Robolectric
                                                                                 2. Adding resources
                                                                                 3. Writing some tests
                                                                                 Show and hide more

                                                                                 Product information

                                                                                 • Title: Learning Android Application Testing
                                                                                 • Author(s): Paul Blundell, Diego Torres Milano
                                                                                 • Release date: March 2015
                                                                                 • Publisher(s): Packt Publishing
                                                                                 • ISBN: 9781784395339