Skip to main content

4000 pageviews and counting!

In this admittedly niche topic of software quality assurance, I'm impressed at the traffic this tiny little blog has received. I'm thankful for the feedback so far and nothing speaks more loudly than the popularity of the few posts I've made on the topic of UIAutomator. They are by far the biggest sources of traffic. In order to help serve the common good of other QAEs working in Android, I'd be happy to explore the topic more deeply so I'm going to start a list of a few subtopics worth digging into.


  1. WebViews - this is a common area of concern for many people, especially on projects with low budgets for native app development. Whether WebViews can ever be supported or to what extent that can be supported by UIAutomator.jar is a topic that should get regular treatment.
  2. Useful UiWatchers - because these handle asynchronous events it would be useful to generate a library of common interface event Watchers that tests should be able to use in a generic fashion. It would be handy to record these for various devices as well since the make/model/OS combination can throw an array of similar events at your UI tests depending on the environment.
  3. Patterns specific to emulators - most if not all of my UI automation is written with real devices in mind. I've barely touched the emulators and it is high time I change that and see what fun I can have with them.
These are just a few topics I have thought of lately. If there are any you can think of please leave a comment and I'll add them to the list. It is my intention to add individual blog posts on each topic as I can get time to investigate and write up my findings.

Thanks for all the comments and discussions so far.

~Russell
Labels:

Comments

Post a Comment

Popular posts from this blog

UiAutomator and Watchers: Adding Async Robustness to UI Automation

"I'm looking over your shoulder... only because I've got your back." ~ Stephen Colbert After my recent UiAutomator review a user brought up an important question about the use of UiWatcher. The watchers serve as async guardians of the test flow, making sure the odd dialog window doesn't completely frustrate your tests. Having a tool that automatically watches your back when you're focused on the functional flow of your tests is awesome. 100% pure awesomesauce. Since the API documentation on watchers is scant and the UI Testing tutorial on the Android dev guide doesn't cover their use in depth, I figured I should add a post here that goes over a simple scenario demonstrating how to use this fundamentally important UI automation tool. In my example code below, I'm using uiautomator to launch the API Demo app (meaning run this against an Emulator built in API level 17 - I used the Galaxy Nexus image included in the latest ADT and platform tools).
139 comments
Read more

UiAutomator.jar: What happened when Android's JUnit and MonkeyRunner got drunk and hooked up

"Drunkenness does not create vice; it merely brings it into view" ~Seneca So Jelly Bean 4.2 landed with much fanfare and tucked in amongst the neat new OS and SDK features (hello, multi-user tablets!) was this little gem for testers: UiAutomator.jar. I have it on good authority that it snuck in amongst the updates in the preview tools and OS updates sometime around 4.1 with r3 of the platform. As a code-monkey of a tester, I was intrigued. One of the best ways Google can support developers struggling with platform fragmentation is to make their OS more testable so I hold high hopes with every release to see effort spent in that area. I have spent a couple days testing out the new UiAutomator API  and the best way I can think of describing it is that Android's JUnit and MonkeyRunner got drunk and had a code baby. Let me explain what I mean before that phrase sinks down into "mental image" territory. JUnit, for all its power and access to every interface, e
21 comments
Read more

Run-As Like the Wind: Getting private app data off non-rooted devices using adb run-as and a debuggable app

"You're some kind of big, fat, smart-bug aren't you?" ~Johnny Rico, Starship Troopers (1997) One of the most important things about writing bugs is making them descriptive but concise. Screenshots, video, debug logging, and hardware snapshots are all fairly standard or available to Android testers these days and can save you enormously on text when communicating what constitutes the bug. Sometimes though, the app gets into a weird state due to some transient data issue where you may not own the API or the complexity with forcing the app data into a certain state is prohibitively high. In those cases it is very handy to directly inspect the data the app has in its own directories. Getting at this data is trivial on emulators and rooted devices but due to file system permissions, this data is otherwise completely private to the app itself. If you're like me, you tend to test using devices rather than emulators and you probably prefer not to root your devices sin
4 comments
Read more