Learn more Download now Shop now Learn more Shop now Shop now Shop now Shop now Shop now Shop now Shop now Shop now Learn More Shop now Shop now Shop now Learn more Shop Fire Shop Kindle Playlist - Acoustic Christmas Shop now Shop Women's Shop Men's

Customer reviews

3.0 out of 5 stars
4
Android Application Testing Guide
Format: Paperback|Change
Price:£27.99+ Free shipping with Amazon Prime

on 18 March 2012
I've read a lot of books on programming, and the problem with a great number of them is that the author knows their subject well, but is lacking the skills required to teach it well to others. I don't care how much the author knows if they can't clearly communicate it to me. Unfortunately this book falls into the latter category. The grammar and writing style is stilted and uncomfortable to read. It's like swimming through treacle trying to read it. I keep having to re-read paragraphs because they make little sense on first reading. The author jumps around from subject to subject with a lack of flow. Sentences are too long. He provides little context, delivering solutions before explaining the problem, and dives into a subjects seemingly assuming you know what he knows. Obviously the reader doesn't know, or they wouldn't be reading the book.

As an example: "To demonstrate its usage and to establish a style that can be later reproduced for other tests we are completing and expanding test cases produced before for our application". I mean, what? Where's the punctuation? I read it and my brain goes "whaaa?". That sentence communicates little to me. I find I'm having to re-read many sections of the book, and it's frustrating to find some of the content I can't make any sense out of at all.

Huge great big blocks of sample code are thrown into the text. The author hasn't removed the Apache 2.0 licensing comments or IDE method insertion template comments from the code. He then follows it with text like "The first code snippet has nothing more than the required copyrights and imports". Seriously? He includes irrelevant and distracting sections of the code that have nothing to do with the subject of the book, and has to add a comment to explain what they are? He has also failed to include any source code indentation so reading the samples on a Kindle requires mental gymnastics of the highest order, trying to work out which { pairs with which }. The books on programming I enjoy carefully introduce code and interweave it with the text so there's a nice flow of explanation and practice, with manageable sized chunks of code. For example Michael Feathers book on legacy code shows just enough code to explain the point being discussed, and no more. Whereas the author of this book seems to have decided to pad it out by copy and pasting as much code into it as possible. It's a pretty big waste of the reader's time.

The book uses that tiresome, waste of time, language fluff: "As you may have already realised" (nope). "As we explained before" - if you explained it, why mention it again? "In previous chapters" - I KNOW, I just read them!

The author introduces tool after tool after tool, but doesn't clearly explain why each is better, or when to use each. It's like a laundry list of testing tools, but I expect a book like this to give guidance, an overview, paint a picture of the main areas of need and the problems that need solving, and to then explain which to use in what scenario. He introduces EasyMock without explaining what benefits it provides or examples of scenarios its most useful, he delivers lots of implementation detail and then immediately introduces Hamcrest, saying it's better than EasyMock because it's "more generic"! a) What do you mean by "more generic", and b) if it's better, why have you taken up many pages telling me all about EasyMock?

Books like "Refactoring" or "Clean Code" are wonderful examples of great programming books - not just for the content, but the friendly, accessible and easy to read style. This book is not written in that way. I wish more books were written like those two. I asked another Android dev recently if he'd read this testing book. He said he tried, but gave up as it was such a struggle to read it. It seems I'm not alone. I don't understand the high ratings for this book. The coverage is good, the author clearly has a very good understanding of the subject matter, but unfortunately even after reading the book I am not sure I've learnt much.

If you need a book on Android testing I'd suggest that if possible you wait for one to be published by another author. This one is difficult to read. It's a great shame as testing is a very important part of developing great Android apps, and I had high hopes this book would teach me a great deal. Unfortunately I wish I'd just gone online to read the docs for the tools.
0Comment| 4 people found this helpful. Was this review helpful to you? Report abuse
on 6 September 2012
Unfortunately this book was not enjoyable to read and the content is largely repetition of readily available documentation. I found myself wading through pages of sample code listings. There must be a thousand lines of license headers and boilerplate printed in there. I picked up a few techniques but generally found it tedious to extract much practical value. The book introduced various tools and frameworks but these often just felt like filler.
0Comment| 2 people found this helpful. Was this review helpful to you? Report abuse
on 22 September 2011
Recently I have fallen for Unit Testing. They are really cool. However, it is very hard to find good books covering this topic. When it comes to Android, it is even harder. Check out any on-line store. It will turn out that this book is the only one that covers this topic. Diego tries to provide you with the basic knowledge related to application testing at Android platform. At first chapter, you are presented various kinds of tests: Unit Tests, Mock objects and UI Tests, Integration tests, Functional tests, System test, Instrumentation, etc. Each of them are slightly different from others thus it is good to know what part of software development they cover. Second chapter covers different aspects of tests execution. You will learn here how to start test for single file for the whole suite, how to group tests using annotations and eventually, how to start tests from command line. At first glance, running tests from command line might seem to be not quite good idea - after all, you have an IDE. However, this may allow you to integrate test phase into your auto building process. This way, you can have your code build and tested at the same place. Third part makes you familiar with assertions and mock objects. Assertions make a lot of troubles for newcomers because they are slightly unintuitive at the very beginning. Diego explains this topic quite easily and provides description of most common used assertion related methods. Mock objects are something different. They allow you to pretend the actual objects. This is quite important especially in case of database related testing. Fourth chapter is devoted to Test Driven Development. This approach is really cool. At first it looks slightly awkward - you have to write something that tests things that do not exist. However, after you start using it, you won't be able to imagine any other way of development. Well, I exaggerate a little bit, but there is part of true in this statement. Keep in mind that each approach has its flaws and there is no silver bullet, how Mr. Brooks used to say. TDD may not be applicable to your particular use case. But still, it is worth considering. Chapter eight covers very interesting topic related to continuous integration. In any sufficiently large project it is more than required to have continuous integration provided by automatic build and automatic test processes. One issue here is that this topic is not covered very extensively. If you read the book, it might look like a quite easy thing to do. Believe me it is not. Usually it turns out that you have lots of exceptions from the general build rules and you have to deal with them. However, this is nice introduction to the topic. Profiling is not covered perfectly as well. This is a biggest issue of all the books that cover testing related contents. They tend to show you how to measure things but they doesn't explain how to interpret them. In fact it may end up with using R and some statistic related topics to get things well interpreted.

Drawbacks? There are always some. I think, in case of this book there are few but these are not the major flaws for the content. Book is slightly outdated, it doesn't cover most recent release of Eclipse and Android related SDKs. If you will use most recent Android SDK and most recent Eclipse release you will definitely be abel to tell the difference. Sometimes it is hard to follow the book because of these small differences. For example, you will notice that screen shoots represent something different from what you see on your screen. However, Diego provides you with detailed configuration he has used during book composition, this way you can install everything that is needed and you can configure environment exactly the same way as Diego did - this is a big plus for the author. Another issue are missing, so called, flavors of the topic. I miss here detailed description of how to test mock data from the database. This is really big topic. And it looks like everybody avoids it. How to create sample data, how to create good database related tests, how to combine artificial and real data during development. Diego doesn't cover this topic, however as an excuse for the author, I can say that there are very few places you can find description of this issue.
0Comment|Was this review helpful to you? Report abuse
on 25 October 2011
I have to say that for a novice Android developer like I am, I learn a lot from reading the Android Application Testing Guide. Best-in-class testing techniques are covered in this book which are commonly practiced in the agile development. These include Test Driven Development, Behavior Driven Development, Continuous Integration, etc. They in generally oppose to the traditional approach of doing test and integration at the end of development cycle. However, as author states in the book, there is no silver bullets in software development - the suggested testing approaches might not apply to certain needs or projects. But I can see that for a large complex project, applying these methodologies and techniques will likely increase in the productivity and quality.

Numerous tools are introduced in this book. This may be one of the big issues for those who are less-advanced in Android development. Since there is no common repository of these tools, extended knowledge of a varieties of open-source tools, and ability to incorporate them with the development process are required. I wish that there would be consolidated repository for all testing tools or even better all required testing functionality would be built-in in the SDK. Well, before when that would happen, this Android Application Testing Guide book is probably one of a few reference books that has the complete collection of Android testing topics.
0Comment|Was this review helpful to you? Report abuse


Customers also viewed these items


Need customer service? Click here

Sponsored Links

  (What is this?)