Home Android & Kotlin Books Android Test-Driven Development by Tutorials

Other Related Techniques Written by Fernando Sproviero

TDD focuses on writing tests for classes and methods before writing code to support the app’s features. While this approach might be useful for the developers, some argue that it doesn’t consider the end user since they tend to focus on the expected behavior of the app or its use cases. Writing tests for functionality may even be easier to validate with the users.

After exploring TDD and reading this chapter, you’ll discover that other techniques and frameworks exist to enhance or complement TDD.

Acceptance test-driven development

In Acceptance test-driven development (ATDD) the entire team first defines what the acceptance criteria of a feature is before development on that feature starts.

Here’s how it works: The team collaborates with the end users. Based on that collaboration, the team writes one or more acceptance tests for each requirement. After that, the development team writes the code needed for the requirement to pass those acceptance tests.

ATDD focuses on the acceptance criteria agreed upon with the users. If these tests pass, you can assume the users will be happy with your app. This process gives you an idea of the feature development progress and also avoids gold-plating, which means to over-develop features or add functionality that end users don’t need or want.

With ATDD, you can take each requirement and write it in the user story format. Once you have that, you can write the acceptance tests for each one. That’s why, sometimes, this technique is also called Story Test Driven Development (STDD).

Here’s an example template you might use to write a user story:

As a <role> I can <capability>, so that <receive benefit>.

Once you have that, you can turn it into this:

As a seller, I can publish an item so that I can sell it.
As a buyer, I can search for an item so that I can purchase it.

You can write user acceptance tests (UATs), also known as Story Tests, in a plain document or even a spreadsheet. Because these tests are not technical, any non-technical person can read and modify them. Once the team is satisfied, developers can use these tests as input to translate into test code. For example, in an app that has a login feature:

  1. Open the application.
  2. Log in with invalid <username> and <password>.
  3. Verify an error message is shown: “Invalid <username> and/or <password>!”

Or you may have a spreadsheet with inputs and expected output, for example, in a calculator app:

Number  Operator   Number  Expected
1       +          2       3
2       *          0       0

These story tests provide the following advantages:

  • You can use them to communicate between all of the roles of the team.
  • They’re easier to agree with the final user.
  • The examples are concrete.
  • Analysts, developers, testers and the end users have a more active role. They’re more involved and they all work together in creating possible scenarios. They understand the stories, the examples and the acceptance criteria.

Behavior-driven development

Behavior Driven Development (BDD) is an extension of TDD. You might think of BDD as an enhanced version of TDD.

Given [a context]
When [an event happens]
Then [assert something]
Feature: Calculate a result
  Perform an arithmetic operation on two numbers using a mathematical operator

  Scenario Outline: Enter a digit, an operator and another digit
    Given I have a CalculatorActivity
    When I press <num1>
    And I press <op>
    And I press <num2>
    And I press =
    Then I should see "<result>" on the display

    | num1 | num2 | op | result   |
    | 9    | 8    | +  | 17.0     |
    | 7    | 6    | –  | 1.0      |
    | 5    | 4    | x  | 20.0     |
    | 3    | 2    | /  | 1.5      |
    | 1    | 0    | /  | Infinity |
@When("I press {operator}")
fun i_press_op(op: Char) {
  when (op) {
    '+' -> onView(withId(R.id.btn_op_add)).perform(click())
    '–' -> onView(withId(R.id.btn_op_subtract)).perform(click())
    'x' -> onView(withId(R.id.btn_op_multiply)).perform(click())
    '/' -> onView(withId(R.id.btn_op_divide)).perform(click())
    '=' -> onView(withId(R.id.btn_op_equals)).perform(click())


You may find that some people consider both techniques the same thing since they focus on the end user requirements, understanding behaviors and generating similar outcomes.

Key points

  • In TDD, you need to write tests before adding or modifying features.
  • You write tests in a technical language such as Java or Kotlin.
  • The people involved in TDD need to have a technical background. But in BDD or ATDD, both technical and non-technical people on the team can get involved.
  • TDD focuses on the implementation of the features. BDD focuses on the behavior. ATDD focuses on capturing the requirements and the acceptance criteria.
  • Each of the techniques outlined in this chapter enforces creating tests before adding or modifying features. This is in contrast to traditional development.

Where to go from here?

If you want to learn more about other TDD techniques, look at the following:

Have a technical question? Want to report a bug? You can ask questions and report bugs to the book authors in our official book forum here.

Have feedback to share about the online reading experience? If you have feedback about the UI, UX, highlighting, or other features of our online readers, you can send them to the design team with the form below:

© 2021 Razeware LLC

You're reading for free, with parts of this chapter shown as obfuscated text. Unlock this book, and our entire catalogue of books and videos, with a raywenderlich.com Professional subscription.

Unlock Now

To highlight or take notes, you’ll need to own this book in a subscription or purchased by itself.