Testing Android Applications

-

Android Testing

testing in Android application can be really tricky, there’s a lot to test if we want to deliver a proper application which supports as much users as posible,

here are a few tips on the what to test and how to test:

Testing in Android:

· Screen sizes

Testing how the app is shown in different screen sizes

· OS versions

Apps can behave differently or even crush in some OSD versions due to lack of targeting to specific device

· Densities

Screen densities change from device to device, and from a UI point of view this can be real issues, having apps to look far from the designers aim

· Resolutions

When not targeting a specific resolution the graphics are used with OS manipulations like stretch and scale, which can be resulting in a disastrous UI and UX for the user

· Functionality

Basic functionality testing of the app in terms of business logic

· Usability

The usability angle is very important once we are handling a small device, a lack of attention to the UI and user experience can result in an unsuccessful app

· Accessibility

A lack of attention to “what happens if the phone doesn’t have a front camera” etc. can result on a malfunctioned application

· Performance

Games for example require a lot of CPU in order to present a good experience

· Load

What happens when RAM or battery are running low as result of usage in the app? Are you taking care of those situations?

For example (Waze alerts the user once the battery is below 30% juice)

Tools:

Testing with tools which come out of the box with the Android SDK

The Android SDK provides a testing framework which comes out of the box.

The API allows running test projects with the targeted app which is similar to jUnit testing, with usage of the Android specific APIS.

The android developer website suggests some standard tests which can be done easily:

Such as change in orientation, content provider testing, accessibility testing, battery usage and overall statistics from the device such as data usage etc...

Other testing tools:

Robotium

Allows running black box scenarios by sending events to the emulator without the need for the source code.

Simple to use and open source.

Robolectric

Allows running tests inside the IDE without using the emulator by modifying code at runtime to change returned values in order to intercept without using the emulator.

Comments

Post a Comment

Popular posts from this blog

Spinner VS AutoCompleteTextView

-
Image
       We’ve all been in a situation where we needed to show a list of some sort, a list which should be triggered by a user interaction (click, tap, etc..) A list is simple enough, probably even a spinner if we don’t want to spend that much screen real-estate on showing a list which the user clicks once and probably doesn’t need to see it after that. A spinner can be a real bug once there are too much entries for the user to choose from, how much is too much? that’s a good question – probably it differs from user to user, and probably this will have some performance issues with areal large number of entries, you cannot scroll forever to find what you’re looking for. A simple solutions for the problems mentioned above is an AutoCompleteTextView. it’s a control which is basically a combination of a TextView, EditText, and a Spinner all wrapped up in a single easy to use and configurable control. let’s see how it’s done:   first, in the layout file, create an AutoCompleteTextView
Read more

How to update UI from a different thread

-
     Google has set it’s tone on some tough guidelines for developing android apps, basically there aren’t any strict rules but one very easy to misunderstand. there is a single Thread which is called the “main” thread, or “UI thread” on some places. this is the thread which is in charge on the views and interaction with the users gestures. based on the guidelines of any mobile platform at the moment, all the work that shouldn’t be done on the main thread should be done on background thread. this can be achieved in many ways, you can use AsyncTask, Or A Handler, Or a simple thread with an implementation of the   run() method within the declaration of the runnable. ok, so if I’m pulling some server data, or performing long calculations, pulling stuff from or to the Sqlite database I’ll probably use an AsyncTask. but let’s say for instance that I want to simply update the UI once every couple of seconds (update a TextView or an ImageView’s content etc..), here’s a simple example of i
Read more

Utilizing Http response cache

-
     A typical mobile application will probably consume some resources from a web server using http requests. This repeated task has some drawbacks: Bandwidth has a cost, polling the same data over and over again results in a waste of user’s quota. the responsiveness and user experience is compromised once the user keeps waiting for data. If the requested data hasn’t changed on the server, then there’s no reason for us to fetch it. Of course, local caching of data is a must, but we also need to be able to refresh the data if it has changed on the server. A simple solution which comes out of the box for API 4+ is http response caching. Http response caching is a mechanism which enables us as developers to save a footprint of the response utilizing the abilities of the Http protocol. Basically, is holds a simple cache of the response which can be defined and enabled in code, and it prevents from fetching unchanged data from the server which was already fetched and processed into t
Read more