Learning Android Application Testing电子书

Learning Android Application Testing

Table of Contents

Learning Android Application Testing

Credits

About the Authors

About the Reviewers

www.PacktPub.com

Support files, eBooks, discount offers, and more

Why subscribe?

Free access for Packt account holders

Preface

What this book covers

What you need for this book

Who this book is for

Conventions

Reader feedback

Customer support

Downloading the example code

Errata

Piracy

Questions

Questions

1. Getting Started with Testing

Why, what, how, and when to test?

What to test

Activity lifecycle events

Database and filesystem operations

Physical characteristics of the device

Types of tests

Unit tests

The setUp() method

The tearDown() method

Outside the test method

Inside the test method

Mock objects

Integration tests

UI tests

Functional or acceptance tests

Test case scenario

Performance tests

System tests

Android Studio and other IDE support

Java testing framework

Android testing framework

Instrumentation

Gradle

Test targets

Creating the Android project

Package explorer

Creating a test case

Test annotations

Running the tests

Running all tests from Android Studio

Running a single test case from your IDE

Running from the emulator

Running tests from the command line

Running all tests

Running tests from a specific test case

Running a specific test by name

Running specific tests by category

Running tests using Gradle

Creating a custom annotation

Running performance tests

Dry run

Debugging tests

Other command-line options

Summary

2. Understanding Testing with the Android SDK

The demonstration application

Assertions in depth

Custom messages

Static imports

View assertions

Even more assertions

The TouchUtils class

Mock objects

An overview of MockContext

The IsolatedContext class

Alternate route to file and database operations

The MockContentResolver class

The TestCase base class

The default constructor

The given name constructor

The setName() method

The AndroidTestCase base class

The assertActivityRequiresPermission() method

Description

Example

The assertReadingContentUriRequiresPermission method

Description

Example

The assertWritingContentUriRequiresPermission() method

Description

Example

Instrumentation

The ActivityMonitor inner class

Example

The InstrumentationTestCase class

The launchActivity and launchActivityWithIntent methods

The sendKeys and sendRepeatedKeys methods

The runTestOnUiThread helper method

The ActivityTestCase class

The scrubClass method

The ActivityInstrumentationTestCase2 class

The constructor

The setUp method

The tearDown method

The ProviderTestCase2<T> class

The constructor

An example

The ServiceTestCase<T>

The constructor

The TestSuiteBuilder.FailedToCreateTests class

Using libraries in test projects

Summary

3. Baking with Testing Recipes

Android unit tests

Testing activities and applications

Mocking applications and preferences

The RenamingMockContext class

Mocking contexts

Testing activities

Testing files, databases, and content providers

The BrowserProvider tests

Testing exceptions

Testing local and remote services

Extensive use of mock objects

Importing libraries

Mockito usage example

The EditNumber filter tests

Testing views in isolation

Testing parsers

Android assets

The parser test

Testing for memory usage

Testing with Espresso

Summary

4. Managing Your Android Testing Environment

Creating Android Virtual Devices

Running AVDs from the command line

Headless emulator

Disabling the keyguard

Cleaning up

Terminating the emulator

Additional emulator configurations

Simulating network conditions

Speeding up your AVD with HAXM

Alternatives to the AVD

Running monkey

The client-server monkey

Test scripting with monkeyrunner

Getting test screenshots

Record and playback

Summary

5. Discovering Continuous Integration

Building Android applications manually using Gradle

Git – the fast version control system

Creating a local Git repository

Continuous integration with Jenkins

Installing and configuring Jenkins

Creating the jobs

Obtaining Android test results

Summary

6. Practicing Test-driven Development

Getting started with TDD

Writing a test case

Running all tests

Refactoring the code

Advantages of TDD

Understanding the requirements

Creating a sample project – the temperature converter

List of requirements

User interface concept design

Creating the project

Creating a Java module

Creating the TemperatureConverterActivityTests class

Creating the fixture

Creating the user interface

Testing the existence of the user interface components

Getting the IDs defined

Translating requirements to tests

Empty fields

View properties

Screen layout

Adding functionality

Temperature conversion

The EditNumber class

The TemperatureConverter unit tests

The EditNumber tests

The TemperatureChangeWatcher class

More TemperatureConverter tests

The InputFilter tests

Viewing our final application

Summary

7. Behavior-driven Development

Given, When, and Then

FitNesse

Running FitNesse from the command line

Creating a TemperatureConverterTests subwiki

Adding child pages to the subwiki

Adding the acceptance test fixture

Adding the supporting test classes

GivWenZen

Creating the test scenario

Summary

8. Testing and Profiling Performance

Ye Olde Logge method

Timing logger

Performance tests in Android SDK

Launching the performance test

Creating the LaunchPerformanceBase instrumentation

Creating the TemperatureConverterActivityLaunchPerformance class

Running the tests

Using the Traceview and dmtracedump platform tools

Dmtracedump

Microbenchmarks

Caliper microbenchmarks

Benchmarking the temperature converter

Running Caliper

Summary

9. Alternative Testing Tactics

Code coverage

Jacoco features

Temperature converter code coverage

Generating code coverage analysis report

Covering the exceptions

Introducing Robotium

Adding Robotium

Creating the test cases

The testFahrenheitToCelsiusConversion() test

Testing between Activities

Testing on the host's JVM

Comparing the performance gain

Adding Android to the picture

Introducing Robolectric

Installing Robolectric

Adding resources

Writing some tests

Google's march on shadows

Introducing Fest

Introducing Spoon

Introducing Fork

Summary

Index