Leanpub Header

Skip to main content
Go to Leanpub.com

Master Modern Android Testing

Master unit testing, Compose UI testing, screenshot testing, integration testing, end-to-end automation, and modern testing architecture used by professional Android teams.

This book is 100% completeLast updated on 2026-07-04
Mahmoud Ramadan

Master modern Android testing with Kotlin, Coroutines, Jetpack Compose, Hilt, Turbine, Paparazzi, Roborazzi, Maestro, and CI/CD. Learn production-ready testing strategies used by experienced Android teams through practical, real-world examples.

Minimum price

$19.99

$49.99

You pay

Author earns

$

Also available for 1 book credit with a Reader Membership

PDF
EPUB
WEB
APP
About

About

About the Book

Modern Android development has changed dramatically.

Jetpack Compose introduced a completely new UI toolkit.

Coroutines replaced callback-based programming.

StateFlow became the standard for state management.

Dependency Injection became easier with Hilt.

Continuous Integration now runs thousands of automated tests on every pull request.

Yet many Android developers still rely on outdated testing practices that no longer fit today's architecture.

This book is designed to bridge that gap.

You'll learn how professional Android teams build reliable testing pipelines—from fast unit tests all the way to screenshot testing, end-to-end automation, and production CI workflows.

Rather than teaching testing as isolated theory, every chapter focuses on realistic applications, production architecture, and clean code practices.

By the end of this book, you'll be able to design a complete testing strategy for any Android project with confidence.

What You'll Learn

✔ Build highly testable Android architectures

✔ Write clean and maintainable unit tests

✔ Test Coroutines correctly

✔ Master Flow testing using Turbine

✔ Test StateFlow and SharedFlow

✔ Create reliable ViewModel tests

✔ Build production-ready Compose UI tests

✔ Test Navigation in Compose

✔ Use Hilt inside UI tests

✔ Apply the Robot Pattern

✔ Master Screenshot Testing

✔ Compare Paparazzi vs Roborazzi

✔ Manage Golden Images

✔ Test Room databases

✔ Test DataStore

✔ Mock REST APIs with MockWebServer

✔ Test WorkManager

✔ Combine Espresso with Compose

✔ Build End-to-End testing pipelines

✔ Automate user journeys with Maestro

✔ Eliminate flaky tests

✔ Build fast CI/CD pipelines

✔ Use Test Driven Development

✔ Apply Property-Based Testing

✔ Test Multi-Module architectures

✔ Test Kotlin Multiplatform shared code

✔ Perform performance testing

✔ Build accessibility-first applications

Who This Book Is For

This book is perfect for:

  • Android Developers
  • Jetpack Compose Developers
  • Kotlin Developers
  • Mobile Software Engineers
  • Technical Leads
  • Senior Android Engineers
  • Freelancers
  • Students preparing for Android interviews
  • Teams adopting modern Android architecture

Prerequisites

You should already know:

  • Kotlin basics
  • Android Studio
  • Android fundamentals
  • Basic Jetpack Compose
  • Gradle

No previous testing experience is required.

Why This Book Is Different

Most Android testing resources focus on isolated examples.

This book teaches how testing works inside real production applications.

You'll build a complete testing toolkit covering:

  • Business logic
  • ViewModels
  • Compose UI
  • Screenshot testing
  • Network layer
  • Databases
  • WorkManager
  • Navigation
  • Accessibility
  • Continuous Integration
  • End-to-End automation

Everything is explained step by step with practical examples.

Table of Contents

Part I — Foundations

  • Why Modern Android Testing Is Different
  • The Testing Landscape
  • Setting Up a Testable Project
  • Anatomy of a Good Test
  • Test Doubles Explained
  • Assertion Libraries

Part II — Unit Testing

  • Domain Logic
  • Use Cases
  • Repositories
  • Coroutines
  • Dispatchers
  • Flow
  • StateFlow
  • SharedFlow
  • ViewModels

Part III — Compose Testing

  • Compose Testing
  • Semantics
  • Accessibility
  • Recomposition
  • Navigation
  • Hilt Testing
  • Robot Pattern

Part IV — Screenshot Testing

  • Paparazzi
  • Roborazzi
  • Preview Testing
  • Golden Images
  • Multi-device Testing

Part V — Integration Testing

  • Room
  • DataStore
  • MockWebServer
  • WorkManager
  • Espresso

Part VI — End-to-End Testing

  • Testing Strategy
  • Maestro
  • User Journeys
  • Scaling E2E

Part VII — CI/CD

  • TDD
  • Fighting Flaky Tests
  • Coverage
  • Fast Feedback
  • GitHub Actions
  • CI Pipelines

Part VIII — Advanced Testing

  • Kotest
  • Property-Based Testing
  • Multi-Module Testing
  • Kotlin Multiplatform Testing
  • Performance Testing
  • Accessibility Testing

Why Read This Book?

By reading this book you'll save hundreds of hours trying to piece together scattered tutorials.

Instead of learning one framework at a time, you'll understand how everything fits together into a professional testing strategy used by modern Android teams.

Included Technologies

  • Kotlin
  • Jetpack Compose
  • Coroutines
  • Flow
  • StateFlow
  • SharedFlow
  • JUnit 5
  • MockK
  • Mockito
  • Turbine
  • Hilt
  • Room
  • DataStore
  • WorkManager
  • Espresso
  • MockWebServer
  • Paparazzi
  • Roborazzi
  • Maestro
  • Kotest
  • GitHub Actions
  • CI/CD

Frequently Asked Questions

Is this book beginner friendly?

Yes. The book starts with testing fundamentals before moving into advanced production techniques.

Does it cover Jetpack Compose?

Absolutely. Compose testing is one of the primary focuses of the book.

Does it include complete code examples?

Yes. Every concept is demonstrated with production-quality Kotlin code.

Is this book updated for modern Android?

Yes. It focuses entirely on current Android development practices including Compose, Coroutines, Flow, Hilt, and modern testing libraries.

Will this help me prepare for interviews?

Yes. Many senior Android interviews include questions about testing architecture, ViewModels, Coroutines, Flow, and UI testing. This book prepares you for all of them.

Share this book

Categories

Computers and ProgrammingTesting

Feedback

Email the Author

Bundle

Bundles that include this book

Author

About the Author

Mahmoud Ramadan

I am Mahmoud Ramadan. I am Android Tech Lead with 12 years of experience in Android Development.

I developed many apps like chatting, augmented reality, streaming, video calling and more. I am passionate about android programming and teaching. https://www.linkedin.com/in/mahmoud-ramadan-abdelwahed/

Contents

Table of Contents

Chapter 1: Why Modern Android Testing Is Different

  1. 1.1 The Pyramid We Inherited
  2. 1.2 Why the Pyramid’s Assumptions Don’t Hold on Modern Android
  3. 1.3 The Testing Trophy
  4. 1.4 Confidence Per Millisecond
  5. 1.5 Implementation Detail Versus Behavior
  6. 1.6 What “Modern” Actually Means
  7. 1.7 Common Misconceptions
  8. 1.8 How This Book Is Organized
  9. Key Takeaways
  10. What’s Next

Chapter 2: The Testing Landscape

  1. 2.1 A Vocabulary Problem
  2. 2.2 The Five Categories
  3. 2.3 The Boundaries Are Fuzzy — On Purpose
  4. 2.4 A Decision Framework
  5. 2.5 One Feature, Five Ways
  6. 2.6 Anti-Patterns
  7. Key Takeaways
  8. What’s Next

Chapter 3: Setting Up a Testable Project

  1. 3.1 Meet Perch
  2. 3.2 Source Sets: Where Tests Live
  3. 3.3 The Gradle Setup
  4. 3.4 JUnit 4 or JUnit 5
  5. 3.5 Running on the JVM Versus a Device
  6. 3.6 A First Green Across the Board
  7. 3.7 Pitfalls
  8. Key Takeaways
  9. What’s Next

Chapter 4: Anatomy of a Good Test

  1. 4.1 A Test Is Read Far More Often Than It’s Written
  2. 4.2 Naming: A Failure Should Read Like a Sentence
  3. 4.3 Structure: Arrange, Act, Assert
  4. 4.4 One Reason to Fail
  5. 4.5 Readable Failures
  6. 4.6 The FIRST Properties
  7. 4.7 A Good Test, Fully Assembled
  8. 4.8 Pitfalls
  9. Key Takeaways
  10. What’s Next

Chapter 5: Test Doubles Explained

  1. 5.1 A Vocabulary for Stand-Ins
  2. 5.2 The Doubles, Concretely
  3. 5.3 Why Fakes Usually Win
  4. 5.4 When Mocks and Stubs Are Right
  5. 5.5 MockK, Properly
  6. 5.6 Building Fakes That Earn Their Keep
  7. 5.7 A Decision Guide
  8. 5.8 Pitfalls
  9. Key Takeaways
  10. What’s Next

Chapter 6: Assertion Libraries

  1. 6.1 Why the Built-In Assertions Aren’t Enough
  2. 6.2 The Three Contenders
  3. 6.3 Soft Assertions
  4. 6.4 Asserting on Exceptions
  5. 6.5 Custom Subjects for Domain Types
  6. 6.6 The House Pick
  7. 6.7 Pitfalls
  8. Key Takeaways
  9. What’s Next

Chapter 7: Testing Pure Kotlin and Domain Logic

  1. 7.1 The Easiest, Highest-Return Tests
  2. 7.2 Testing at the Boundaries
  3. 7.3 Purity as a Testability Strategy
  4. 7.4 Value Objects: Test the Logic, Not the Compiler
  5. 7.5 Mappers and Round-Trips
  6. 7.6 A Map of the Domain Layer
  7. 7.7 Pitfalls
  8. Key Takeaways
  9. What’s Next

Chapter 8: Testing Use Cases and Repositories with Fakes

  1. 8.1 Testing a Use Case
  2. 8.2 Where Interaction Verification Earns Its Place
  3. 8.3 Testing an Offline-First Repository
  4. 8.4 A Repository Behavior Checklist
  5. 8.5 Pitfalls
  6. Key Takeaways
  7. What’s Next

Chapter 9: Parameterized and Data-Driven Tests

  1. 9.1 When to Parameterize (and When Not To)
  2. 9.2 JUnit 4: Functional but Clunky
  3. 9.3 JUnit 5: The Reason the Carve-Out Exists
  4. 9.4 Kotest’s Data-Driven DSL
  5. 9.5 The Pragmatic Default: Table-Driven Kotlin
  6. 9.6 Choosing an Approach
  7. 9.7 A Note Toward Property-Based Testing
  8. 9.8 Pitfalls
  9. Key Takeaways
  10. What’s Next

Chapter 10: Testing Coroutines

  1. 10.1 Why Coroutines Need Special Testing
  2. 10.2 runTest and Virtual Time
  3. 10.3 The Two Test Dispatchers
  4. 10.4 The Dispatchers.Main Problem
  5. 10.5 The runTest Scheduler Versus the Main Dispatcher
  6. 10.6 Testing Exceptions and Cancellation
  7. 10.7 Comparison and Quick Reference
  8. 10.8 Pitfalls
  9. Key Takeaways
  10. What’s Next

Chapter 11: Injecting Dispatchers for Testability

  1. 11.1 Why Hardcoded Dispatchers Break Tests
  2. 11.2 The Dispatcher-Provider Pattern
  3. 11.3 Injecting Dispatchers with Hilt
  4. 11.4 Choosing an Injection Style
  5. 11.5 What Not to Inject
  6. 11.6 Pitfalls
  7. Key Takeaways
  8. What’s Next

Chapter 12: Testing Flows with Turbine

  1. 12.1 The Basic Shape
  2. 12.2 Terminal Events: Completion and Error
  3. 12.3 Testing Operators and Transformations
  4. 12.4 Testing Several Flows at Once
  5. 12.5 A Note on Hot Flows
  6. 12.6 Pitfalls
  7. Key Takeaways
  8. What’s Next

Chapter 13: Testing StateFlow and SharedFlow

  1. 13.1 Hot Versus Cold, and Why It Matters
  2. 13.2 The Conflation Trap
  3. 13.3 The WhileSubscribed Subscription Gotcha
  4. 13.4 SharedFlow and One-Shot Events
  5. 13.5 Hot-Flow Testing at a Glance
  6. 13.6 Pitfalls
  7. Key Takeaways
  8. What’s Next

Chapter 14: Testing ViewModels End to State

  1. 14.1 The Standard Setup
  2. 14.2 Driving the State Machine
  3. 14.3 Actions, Loading, and Errors
  4. 14.4 One-Shot Events
  5. 14.5 SavedStateHandle
  6. 14.6 Structuring for Readability
  7. 14.7 Pitfalls
  8. Key Takeaways
  9. What’s Next

Chapter 15: Compose Testing Fundamentals

  1. 15.1 The Test Rule and setContent
  2. 15.2 The Semantics Tree
  3. 15.3 Finders
  4. 15.4 Actions
  5. 15.5 Assertions
  6. 15.6 The Same API in Both Homes
  7. 15.7 Pitfalls
  8. Key Takeaways
  9. What’s Next

Chapter 16: Semantics and Accessibility as a Testing Contract

  1. 16.1 What the Semantics Tree Is
  2. 16.2 Merged Versus Unmerged Trees
  3. 16.3 Adding Semantics Deliberately
  4. 16.4 Custom Semantics Properties
  5. 16.5 testTagsAsResourceId and the Honest Use of Tags
  6. 16.6 The Contract Restated
  7. 16.7 Pitfalls
  8. Key Takeaways
  9. What’s Next

Chapter 17: Testing State, Recomposition, and Side Effects

  1. 17.1 Hoisted State Is Testable State
  2. 17.2 Testing That the UI Reacts to State
  3. 17.3 Testing Side Effects
  4. 17.4 Surviving Recomposition and Configuration Changes
  5. 17.5 A Note on Recomposition Counts
  6. 17.6 Pitfalls
  7. Key Takeaways
  8. What’s Next

Chapter 18: Synchronization and Idling

  1. 18.1 How Auto-Synchronization Works
  2. 18.2 When Auto-Sync Isn’t Enough
  3. 18.3 Taking Control of the Clock
  4. 18.4 Idling Resources for External Async
  5. 18.5 Synchronization Tools at a Glance
  6. 18.6 Pitfalls
  7. Key Takeaways
  8. What’s Next

Chapter 19: Testing Navigation

  1. 19.1 Two Levels of Navigation Testing
  2. 19.2 Testing Classic Navigation Compose
  3. 19.3 Testing Navigation 3
  4. 19.4 Testing Deep Links
  5. 19.5 Where Navigation Tests Belong
  6. 19.6 Pitfalls
  7. Key Takeaways
  8. What’s Next

Chapter 20: Testing Compose Screens with Hilt

  1. 20.1 Why Plain Construction Usually Wins
  2. 20.2 When Hilt in Tests Earns Its Cost
  3. 20.3 The Setup: Runner, Application, Rules
  4. 20.4 Substituting Fakes Two Ways
  5. 20.5 Hilt Tests Under Robolectric
  6. 20.6 A Decision Guide
  7. 20.7 Pitfalls
  8. Key Takeaways
  9. What’s Next

Chapter 21: The Robot Pattern for Readable UI Tests

  1. 21.1 The Problem, Concretely
  2. 21.2 A Robot
  3. 21.3 A Kotlin DSL Flavor
  4. 21.4 Composing Robots for Flows
  5. 21.5 Keeping Robots Honest
  6. 21.6 Pitfalls
  7. Key Takeaways
  8. What’s Next

Chapter 22: Why Screenshot Testing

  1. 22.1 The Bugs Semantic Tests Can’t See
  2. 22.2 How Screenshot Testing Works
  3. 22.3 What It Proves, and What It Doesn’t
  4. 22.4 When It’s Worth the Cost
  5. 22.5 The Landscape Ahead
  6. 22.6 Pitfalls
  7. Key Takeaways
  8. What’s Next

Chapter 23: Paparazzi

  1. 23.1 How Paparazzi Works
  2. 23.2 Setup
  3. 23.3 Recording and Verifying
  4. 23.4 Capturing Across Configurations
  5. 23.5 Determinism: The Fixed-Clock Discipline
  6. 23.6 Strengths and Limits
  7. 23.7 Pitfalls
  8. Key Takeaways
  9. What’s Next

Chapter 24: Roborazzi

  1. 24.1 How Roborazzi Works
  2. 24.2 Setup
  3. 24.3 The Differentiator: Capturing Interaction States
  4. 24.4 Recording and Verifying
  5. 24.5 Strengths and Limits
  6. 24.6 Pitfalls
  7. Key Takeaways
  8. What’s Next

Chapter 25: Compose Preview Screenshot Testing

  1. 25.1 The Idea: Previews You Already Have
  2. 25.2 Setup
  3. 25.3 Recording and Verifying
  4. 25.4 Multipreview: Configuration for Free
  5. 25.5 Strengths and Limits
  6. 25.6 Pitfalls
  7. Key Takeaways
  8. What’s Next

Chapter 26: Paparazzi vs. Roborazzi vs. Preview Screenshot Testing

  1. 26.1 The Decision Table
  2. 26.2 Choosing by Scenario
  3. 26.3 Combining Tools
  4. 26.4 This Book’s Stance
  5. 26.5 Pitfalls
  6. Key Takeaways
  7. What’s Next

Chapter 27: Testing Across Configurations

  1. 27.1 The Configuration Matrix
  2. 27.2 Expressing the Matrix with Multipreview
  3. 27.3 Expressing the Matrix with Parameterization
  4. 27.4 RTL and Long Text: The Undertested Cases
  5. 27.5 Avoiding the Combinatorial Explosion
  6. 27.6 Pitfalls
  7. Key Takeaways
  8. What’s Next

Chapter 28: Managing Golden Images

  1. 28.1 The Record–Review–Verify Workflow
  2. 28.2 The Determinism Problem
  3. 28.3 Tolerance Thresholds
  4. 28.4 Storage and Repository Health
  5. 28.5 The Review Experience
  6. 28.6 Preventing Rot
  7. 28.7 Pitfalls
  8. Key Takeaways
  9. What’s Next

Chapter 29: Testing Room and Migrations

  1. 29.1 Why Test the Real DAO
  2. 29.2 In-Memory Database Tests
  3. 29.3 What’s Worth Testing in a DAO
  4. 29.4 Migrations: The Highest-Stakes Test
  5. 29.5 Robolectric Versus Instrumented for Room
  6. 29.6 Pitfalls
  7. Key Takeaways
  8. What’s Next

Chapter 30: Testing DataStore and Preferences

  1. 30.1 The Layering, Restated
  2. 30.2 Testing a Preferences DataStore
  3. 30.3 The One-Instance-Per-File Rule
  4. 30.4 Proto DataStore
  5. 30.5 Testing SharedPreferences Migration
  6. 30.6 Pitfalls
  7. Key Takeaways
  8. What’s Next

Chapter 31: Network Testing with MockWebServer

  1. 31.1 What MockWebServer Is
  2. 31.2 Setup and a Successful Response
  3. 31.3 Testing Error Handling
  4. 31.4 Asserting the Request You Sent
  5. 31.5 Ktor’s MockEngine
  6. 31.6 Where This Fits
  7. 31.7 Pitfalls
  8. Key Takeaways
  9. What’s Next

Chapter 32: Testing WorkManager

  1. 32.1 Two Levels of WorkManager Testing
  2. 32.2 Testing Worker Logic
  3. 32.3 Testing Scheduling and Constraints
  4. 32.4 Robolectric Versus Instrumented
  5. 32.5 Pitfalls
  6. Key Takeaways
  7. What’s Next

Chapter 33: Espresso and View Interop

  1. 33.1 Espresso in One Paragraph
  2. 33.2 The Interop Point
  3. 33.3 Testing Views Inside Compose and Compose Inside Views
  4. 33.4 Espresso Intents for Navigation to Other Activities
  5. 33.5 The Migration Perspective
  6. 33.6 Pitfalls
  7. Key Takeaways
  8. What’s Next

Chapter 34: Designing an E2E Strategy

  1. 34.1 The Cost Profile
  2. 34.2 What Belongs at E2E
  3. 34.3 The Ice-Cream Cone, Revisited
  4. 34.4 Hermetic Versus Real-Backend E2E
  5. 34.5 The Two Tools Ahead
  6. 34.6 Pitfalls
  7. Key Takeaways
  8. What’s Next

Chapter 35: Full User Journeys with Compose

  1. 35.1 The Hermetic Setup
  2. 35.2 Composing Robots into a Journey
  3. 35.3 Test Tags for Journey Stability
  4. 35.4 Synchronization Across a Long Journey
  5. 35.5 State Between Tests
  6. 35.6 In-Process Versus Out-of-Process
  7. 35.7 Pitfalls
  8. Key Takeaways
  9. What’s Next

Chapter 36: Maestro

  1. 36.1 What Maestro Is and Why It’s Different
  2. 36.2 A First Flow
  3. 36.3 Resilience: The Selling Point
  4. 36.4 Reusable Sub-Flows
  5. 36.5 The Hermetic Challenge
  6. 36.6 Pitfalls
  7. Key Takeaways
  8. What’s Next

Chapter 37: Running E2E at Scale

  1. 37.1 Why a Device Matrix
  2. 37.2 Gradle Managed Devices
  3. 37.3 Firebase Test Lab
  4. 37.4 Sharding
  5. 37.5 Choosing a Representative Matrix
  6. 37.6 Flakiness and Triage at Scale
  7. 37.7 Pitfalls
  8. Key Takeaways
  9. What’s Next

Chapter 38: Test-Driven Development in a Compose Codebase

  1. 38.1 The Cycle
  2. 38.2 A Worked Example
  3. 38.3 Where TDD Shines
  4. 38.4 Where Test-First Is Awkward
  5. 38.5 TDD’s Real Payoff: Design
  6. 38.6 Pitfalls
  7. Key Takeaways
  8. What’s Next

Chapter 39: Fighting Flakiness

  1. 39.1 The Taxonomy of Causes
  2. 39.2 Diagnosing a Flaky Test
  3. 39.3 Fixing by Cause
  4. 39.4 The Retry Trap
  5. 39.5 Quarantine: The Right Middle Ground
  6. 39.6 The Culture
  7. 39.7 Pitfalls
  8. Key Takeaways
  9. What’s Next

Chapter 40: Coverage That Means Something

  1. 40.1 What Coverage Actually Measures
  2. 40.2 Why Chasing the Number Backfires
  3. 40.3 What Coverage Is Genuinely Good For
  4. 40.4 Setting Up Kover
  5. 40.5 Coverage in CI: Gate Carefully
  6. 40.6 Mutation Testing: Measuring What Coverage Can’t
  7. 40.7 What to Actually Target
  8. 40.8 Pitfalls
  9. Key Takeaways
  10. What’s Next

Chapter 41: Fast Feedback

  1. 41.1 Where Slowness Comes From
  2. 41.2 Parallelization
  3. 41.3 Sharding
  4. 41.4 Module Boundaries and Test Impact
  5. 41.5 Caching
  6. 41.6 Tiered Feedback Loops
  7. 41.7 Optimizing the Slow Tail
  8. 41.8 Pitfalls
  9. Key Takeaways
  10. What’s Next

Chapter 42: Wiring It All into CI/CD

  1. 42.1 The Staged Pipeline
  2. 42.2 A Concrete Pipeline
  3. 42.3 Gates: Fast and Trustworthy or Ignored
  4. 42.4 Surfacing Results Where Developers Look
  5. 42.5 Caching and Speed in CI
  6. 42.6 Branch Protection and Flaky Handling
  7. 42.7 Pitfalls
  8. Key Takeaways
  9. What’s Next

Chapter 43: Property-Based Testing with Kotest

  1. 43.1 From Examples to Properties
  2. 43.2 A First Property
  3. 43.3 The Round-Trip Property
  4. 43.4 Shrinking: The Killer Feature
  5. 43.5 What Makes a Good Property
  6. 43.6 Where It Fits in Perch
  7. 43.7 Pitfalls
  8. Key Takeaways
  9. What’s Next

Chapter 44: Testing Multi-Module Projects

  1. 44.1 Why Modules Help Testing
  2. 44.2 Sharing Test Code with test-fixtures
  3. 44.3 Contract Tests: Keeping Fakes Honest
  4. 44.4 Convention Plugins for Test Setup
  5. 44.5 Where Cross-Module Integration Is Tested
  6. 44.6 Pitfalls
  7. Key Takeaways
  8. What’s Next

Chapter 45: Testing Shared KMP/CMP Code

  1. 45.1 The Source-Set Model
  2. 45.2 The Multiplatform Test Toolkit
  3. 45.3 Testing expect/actual
  4. 45.4 Compose Multiplatform UI Testing
  5. 45.5 Running Tests Per Target
  6. 45.6 The Bridge to Perch
  7. 45.7 Pitfalls
  8. Key Takeaways
  9. What’s Next

Chapter 46: Performance Testing

  1. 46.1 What to Measure
  2. 46.2 Macrobenchmark
  3. 46.3 Baseline Profiles
  4. 46.4 The Determinism Problem, Again
  5. 46.5 Performance in CI
  6. 46.6 Pitfalls
  7. Key Takeaways
  8. What’s Next

Chapter 47: Accessibility Testing as a First-Class Concern

  1. 47.1 Why First-Class
  2. 47.2 What to Test
  3. 47.3 Automated Accessibility Checks
  4. 47.4 What Automation Can’t Catch
  5. 47.5 Weaving It Into the Suite
  6. 47.6 Pitfalls
  7. 47.7 Key Takeaways
  8. Closing: Testing as Serving Users

The Leanpub 60 Day 100% Happiness Guarantee

Within 60 days of purchase you can get a 100% refund on any Leanpub purchase, in two clicks.

See full terms...

Earn $8 on a $10 Purchase, and $16 on a $20 Purchase

We pay 80% royalties on purchases of $7.99 or more, and 80% royalties minus a 50 cent flat fee on purchases between $0.99 and $7.98. You earn $8 on a $10 sale, and $16 on a $20 sale. So, if we sell 5000 non-refunded copies of your book for $20, you'll earn $80,000.

(Yes, some authors have already earned much more than that on Leanpub.)

In fact, authors have earned over $15 million writing, publishing and selling on Leanpub.

Learn more about writing on Leanpub

Free Updates. DRM Free.

If you buy a Leanpub book, you get free updates for as long as the author updates the book! Many authors use Leanpub to publish their books in-progress, while they are writing them. All readers get free updates, regardless of when they bought the book or how much they paid (including free).

Most Leanpub books are available in PDF (for computers) and EPUB (for phones, tablets and Kindle). The formats that a book includes are shown at the top right corner of this page.

Finally, Leanpub books don't have any DRM copy-protection nonsense, so you can easily read them on any supported device.

Learn more about Leanpub's ebook formats and where to read them

Write and Publish on Leanpub

You can use Leanpub to easily write, publish and sell in-progress and completed ebooks and online courses!

Leanpub is a powerful platform for serious authors, combining a simple, elegant writing and publishing workflow with a store focused on selling in-progress ebooks.

Leanpub is a magical typewriter for authors: just write in plain text, and to publish your ebook, just click a button. (Or, if you are producing your ebook your own way, you can even upload your own PDF and/or EPUB files and then publish with one click!) It really is that easy.

Learn more about writing on Leanpub