Introduction to Android Application Development, Fourth Edition (2014)

Let’s take a look at the contents of the layout file for the PasswordMatcher application. The name of the file is activity_password_matcher.xml.

<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
xmlns:tools="http://schemas.android.com/tools"
android:layout_width="match_parent"
android:layout_height="match_parent"
android:orientation="vertical"
android:paddingBottom="@dimen/activity_vertical_margin"
android:paddingLeft="@dimen/activity_horizontal_margin"
android:paddingRight="@dimen/activity_horizontal_margin"
android:paddingTop="@dimen/activity_vertical_margin"
tools:context=".PasswordMatcherActivity" >
<TextView
android:id="@+id/title"
android:layout_width="match_parent"
android:layout_height="wrap_content"
android:contentDescription="@string/display_title"
android:text="@string/match_passwords_title" />
<EditText
android:id="@+id/password"
android:layout_width="match_parent"
android:layout_height="wrap_content"
android:hint="@string/password"
android:inputType="textPassword"
android:text="" />
<EditText
android:id="@+id/matchingPassword"
android:layout_width="match_parent"
android:layout_height="wrap_content"
android:hint="@string/matching_password"
android:inputType="textPassword"
android:text="" />
<Button
android:id="@+id/matchButton"
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:contentDescription="@string/submit_match_password_button"
android:text="@string/match_password_button" />
<TextView
android:id="@+id/passwordResult"
android:layout_width="match_parent"
android:layout_height="wrap_content"
android:contentDescription="@string/match_password_notice"
android:visibility="gone" />
</LinearLayout>

The layout is a LinearLayout that contains a TextView for displaying our application title, two EditText views with the text initially set to be an empty string, a Button, and a final TextView for displaying the results of our Button onClick response that has a visibility of GONE. This visibility setting means that the TextView will not appear when the application is first launched, nor will it take up any visual space.

The code for our PasswordMatcherActivity is as follows:

public class PasswordMatcherActivity extends Activity {
EditText password;
EditText matchingPassword;
TextView passwordResult;

@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_password_matcher);
password = (EditText) findViewById(R.id.password);
matchingPassword = (EditText) findViewById(R.id.matchingPassword);
passwordResult = (TextView) findViewById(R.id.passwordResult);
Button button = (Button) findViewById(R.id.matchButton);
button.setOnClickListener(new View.OnClickListener() {
@Override
public void onClick(View v) {
String p = password.getText().toString();
String mp = matchingPassword.getText().toString();
if (p.equals(mp) && !p.isEmpty() && !mp.isEmpty()) {
passwordResult.setVisibility(View.VISIBLE);
passwordResult.setText(R.string.passwords_match_notice);
passwordResult.setTextColor(getResources().getColor(
R.color.green));
} else {
passwordResult.setVisibility(View.VISIBLE);
passwordResult.setText(R.string.passwords_do_not_match_notice);
passwordResult.setTextColor(getResources().getColor(
R.color.red));
}
}
});
}
}

As you see, the onClick method checks to see that our two passwords are equal and that they are not empty. If either of the passwords is empty or they are not equal, we change the visibility setting of the TextView to View.VISIBLE, set the text to display an error message, and set the text color to red. If the passwords are equal and not empty, we change the visibility setting of the TextView to View.VISIBLE, set the text to display a success message, and set the text color to green.

Determining What Our Tests Should Prove

Let’s think about what results our application should produce. Our application requests the user to input data into two text fields, and then responds with a result when the user clicks the button. Here are the results that we would like our tests to make sure our application produces:

When a user leaves either one of the password fields empty or both password fields empty, assert that our application has displayed a red error message.

When a user enters two passwords that do not match, assert that our application has displayed a red error message.

When a user enters two matching passwords, assert that our application has displayed a green success message.

Now that we know what results our application should produce, we are set up pretty well for knowing how to write our tests. In order to make sure our application produces those results, we will write tests that assert these assumptions, and that the actual results are as expected.

Creating an Android Test Project

In order to write our tests, we must first create an Android test project. The test code is not part of our PasswordMatcher application. Instead, we create a PasswordMatcherTest package to house our test classes.

The steps for creating a test project are as follows:

1. In the Android IDE, go to File, New, Other, and under the Android folder, select Android Test Project, and press Next (see Figure 18.2).

Figure 18.2 Creating an Android test project in the Android IDE.

2. On the Create Android Project page, type the Project Name of PasswordMatcherTest and click Next (see Figure 18.3).

Figure 18.3 Naming the test project in the Android IDE.

3. On the Select Test Target page, make sure An existing Android Project is selected, choose the PasswordMatcher project, and click Next (see Figure 18.4).

Figure 18.4 Linking the test project to the PasswordMatcher application in the Android IDE.

4. On the Select Build Target page, choose Android 4.3 and click Finish (see Figure 18.5).

Figure 18.5 Selecting the Build Target of the test project within the Android IDE.

Now that our test project has been created, upon first glance the project looks very much like a regular Android application. As we can see in Figure 18.6, the folder structure is very similar and has many of the same files that we are used to seeing, such as the AndroidManifest.xml.

Figure 18.6 Viewing the test project directory structure within the Android IDE.

Upon looking at the contents of the manifest file, we can clearly see the differences (see Figure 18.7).

Figure 18.7 Viewing the manifest file of the test project within the Android IDE.

The manifest includes the following:

<instrumentation
android:name="android.test.InstrumentationTestRunner"
android:targetPackage="com.introtoandroid.passwordmatcher" />
<application
android:icon="@drawable/ic_launcher"
android:label="@string/app_name" >
<uses-library android:name="android.test.runner" />
</application>

The <instrumentation> element is required for our test projects. This declaration allows our test application to “hook” into the Android system. We specify the name of the InstrumentationTestRunner class and include our PasswordMatcher package as the targetPackage against which our tests will run. We can also see that this application has a <uses-library> element that references android.test.runner. Another important aspect is that the test package name is com.introtoandroid.passwordmatcher.test. This is almost the same as the target application package, except that.test has been added to the end of the package. All test projects created using the Android tools have .test appended to the name of the package under test.

We do not yet have a source file or any classes defined in our source package for this project. Let’s go ahead and create one within the Android IDE so we can begin writing code by following these steps:

1. From inside the Android IDE Package Explorer, right-click on the package com.introtoandroid.passwordmatcher.test found within the src folder of the project PasswordMatcherTest, choose New, and then choose Class. Type the name PasswordMatcherTest as the Class name (Figure 18.8). The Superclass default entry must be changed, so choose Browse, type android.test.ActivityInstrumentationTestCase2 into the “Choose a type” text field entry, and click OK (Figure 18.9). Finally, click Finish to create the Java class file.

Figure 18.8 Creating the PasswordMatcherTest.java file.

Figure 18.9 Choosing a superclass type for the test class.

2. Now that we have our class file created, there are a few errors that we need to fix. We must first import the PasswordMatcherActivity file and the resource files associated from our PasswordMatcher project. The import statements should be as follows:

import com.introtoandroid.passwordmatcher.PasswordMatcherActivity;
import com.introtoandroid.passwordmatcher.R;

3. We must also modify the extend class associated with the ActivityInstrumentationTestCase2<T> from T to PasswordMatcherActivity. Our new declaration should be ActivityInstrumentationTestCase2<PasswordMatcherActivity>.

4. We have one more error that needs to be fixed before we can write any code, and that is to add a class constructor. Go ahead and add the following code to your class:

public PasswordMatcherTest() {
super(PasswordMatcherActivity.class);
}

We are now ready to begin writing our tests for this project.

Writing the Tests

There are a few standard steps to take when writing tests. First, we need to create a setup method that will set up our test project with any information that we will need to access from within the tests. This is the place where we want to access our PasswordMatcherActivity, which will allow us to gain access to any of the views that we may need throughout the tests. We must create a few variables for accessing our views in addition to importing any classes that may be required. Here are the import statements:

import android.widget.Button;
import android.widget.EditText;
import android.widget.TextView;

Here are the variables we need to access in our test project:

TextView title;
EditText password;
EditText matchingPassword;
Button button;
TextView passwordResult;
PasswordMatcherActivity passwordMatcherActivity;

And here is our setUp() method:

protected void setUp() throws Exception {
super.setUp();
passwordMatcherActivity = getActivity();
title = (TextView) passwordMatcherActivity.findViewById(R.id.title);
password = (EditText) passwordMatcherActivity.findViewById(R.id.password);
matchingPassword = (EditText)
passwordMatcherActivity.findViewById(R.id.matchingPassword);
button = (Button) passwordMatcherActivity.findViewById(R.id.matchButton);
passwordResult = (TextView)
passwordMatcherActivity.findViewById(R.id.passwordResult);
}

This method gets the PasswordMatcherActivity using the getActivity() method, so that we can start accessing our views using the findViewById method.

Now we can begin writing test cases to ensure that our application is behaving correctly. We should start by testing the initial state of the application to make sure the starting state is correct. Even though the initial state will always be the same, it is a good idea to know that the application starts as expected, because if something is not working correctly when our application begins changing state, we have already verified that our starting state is as expected, and that rules out the starting state from being the culprit.