Merge lp:~pwlars/ubuntu-test-cases/dialer-messaging-address-book into lp:ubuntu-test-cases

[Paul Larson]

[lp:~pwlars/ubuntu-test-cases/dialer-messaging-address-book]

85. By Paul Larson on 2013-08-29

rename phone-app tests to dialer-app and add messaging and address-book tests

Unmerged revisions

85. By Paul Larson on 2013-08-29

rename phone-app tests to dialer-app and add messaging and address-book tests

84. By Andy Doan on 2013-08-29

update to new phablet-network script

83. By Andy Doan on 2013-08-27

make systemsettle less verbose and host/target friendly

82. By Andy Doan on 2013-08-27

add ability to run apps from host rather than target

This allows the test be driven from either the target or the
host. To run from host simply add FROM_HOST=1 to the jenkins.sh
environment.

81. By Andy Doan on 2013-08-24

use common scripts for all tests

this moves the tests over to using some common scripts to do all their heavy lifting. with this in place, the next step is to provide equivalent scripts that can run from the host.

80. By Andy Doan on 2013-08-23

simplify touch test setup logic

79. By Paul Larson on 2013-08-20

change systemsettle percent to 97.5

78. By Paul Larson on 2013-08-19

Use top instead of vmstat and always output toplot

77. By Andy Doan on 2013-08-19

add test for sending sms

76. By Javier Collado on 2013-08-19

Merged use cnn url instead of launhpad one

Source branch: lp:~javier.collado/ubuntu-test-cases/memevent-update-url

=== added directory 'address-book-app-autopilot'
=== added file 'address-book-app-autopilot/master.run'
--- address-book-app-autopilot/master.run	1970-01-01 00:00:00 +0000
+++ address-book-app-autopilot/master.run	2013-08-29 18:33:39 +0000
@@ -0,0 +1,15 @@
+---
+testsuites:
+  - name: settle-before
+    fetch_method: dev
+    fetch_location: ../systemsettle
+    include_tests:
+      - systemsettle-before
+  - name: address-book-app-autopilot
+    fetch_method: dev
+    fetch_location: ./
+  - name: settle-after
+    fetch_method: dev
+    fetch_location: ../systemsettle
+    include_tests:
+      - systemsettle-after

=== added file 'address-book-app-autopilot/ts_control'
--- address-book-app-autopilot/ts_control	1970-01-01 00:00:00 +0000
+++ address-book-app-autopilot/ts_control	2013-08-29 18:33:39 +0000
@@ -0,0 +1,1 @@
+ts_setup: PKGS=address-book-app-autopilot prepare-autopilot-test.sh

=== added file 'address-book-app-autopilot/tslist.auto'
--- address-book-app-autopilot/tslist.auto	1970-01-01 00:00:00 +0000
+++ address-book-app-autopilot/tslist.auto	2013-08-29 18:33:39 +0000
@@ -0,0 +1,4 @@
+-
+  discovery_cmd: autopilot-list address_book_app
+  test_cmd: autopilot-run address_book_app.tests.{}
+

=== added directory 'calendar-app-autopilot'
=== added file 'calendar-app-autopilot/master.run'
--- calendar-app-autopilot/master.run	1970-01-01 00:00:00 +0000
+++ calendar-app-autopilot/master.run	2013-08-29 18:33:39 +0000
@@ -0,0 +1,15 @@
+---
+testsuites:
+  - name: settle-before
+    fetch_method: dev
+    fetch_location: ../systemsettle
+    include_tests:
+      - systemsettle-before
+  - name: calendar-app-autopilot
+    fetch_method: dev
+    fetch_location: ./
+  - name: settle-after
+    fetch_method: dev
+    fetch_location: ../systemsettle
+    include_tests:
+      - systemsettle-after

=== added file 'calendar-app-autopilot/ts_control'
--- calendar-app-autopilot/ts_control	1970-01-01 00:00:00 +0000
+++ calendar-app-autopilot/ts_control	2013-08-29 18:33:39 +0000
@@ -0,0 +1,1 @@
+ts_setup: PKGS=calendar-app-autopilot prepare-autopilot-test.sh

=== added file 'calendar-app-autopilot/tslist.auto'
--- calendar-app-autopilot/tslist.auto	1970-01-01 00:00:00 +0000
+++ calendar-app-autopilot/tslist.auto	2013-08-29 18:33:39 +0000
@@ -0,0 +1,4 @@
+-
+  discovery_cmd: autopilot-list calendar_app
+  test_cmd: autopilot-run calendar_app.tests.{}
+

=== added directory 'camera-app-autopilot'
=== added file 'camera-app-autopilot/master.run'
--- camera-app-autopilot/master.run	1970-01-01 00:00:00 +0000
+++ camera-app-autopilot/master.run	2013-08-29 18:33:39 +0000
@@ -0,0 +1,15 @@
+---
+testsuites:
+  - name: settle-before
+    fetch_method: dev
+    fetch_location: ../systemsettle
+    include_tests:
+      - systemsettle-before
+  - name: camera-app-autopilot
+    fetch_method: dev
+    fetch_location: ./
+  - name: settle-after
+    fetch_method: dev
+    fetch_location: ../systemsettle
+    include_tests:
+      - systemsettle-after

=== added file 'camera-app-autopilot/ts_control'
--- camera-app-autopilot/ts_control	1970-01-01 00:00:00 +0000
+++ camera-app-autopilot/ts_control	2013-08-29 18:33:39 +0000
@@ -0,0 +1,1 @@
+ts_setup: PKGS=camera-app-autopilot prepare-autopilot-test.sh

=== added file 'camera-app-autopilot/tslist.auto'
--- camera-app-autopilot/tslist.auto	1970-01-01 00:00:00 +0000
+++ camera-app-autopilot/tslist.auto	2013-08-29 18:33:39 +0000
@@ -0,0 +1,4 @@
+-
+  discovery_cmd: autopilot-list camera_app
+  test_cmd: autopilot-run camera_app.tests.{}
+

=== added directory 'dialer-app-autopilot'
=== added file 'dialer-app-autopilot/master.run'
--- dialer-app-autopilot/master.run	1970-01-01 00:00:00 +0000
+++ dialer-app-autopilot/master.run	2013-08-29 18:33:39 +0000
@@ -0,0 +1,15 @@
+---
+testsuites:
+  - name: settle-before
+    fetch_method: dev
+    fetch_location: ../systemsettle
+    include_tests:
+      - systemsettle-before
+  - name: phone-app-autopilot
+    fetch_method: dev
+    fetch_location: ./
+  - name: settle-after
+    fetch_method: dev
+    fetch_location: ../systemsettle
+    include_tests:
+      - systemsettle-after

=== added file 'dialer-app-autopilot/ts_control'
--- dialer-app-autopilot/ts_control	1970-01-01 00:00:00 +0000
+++ dialer-app-autopilot/ts_control	2013-08-29 18:33:39 +0000
@@ -0,0 +1,1 @@
+ts_setup: PKGS=phone-app-autopilot prepare-autopilot-test.sh

=== added file 'dialer-app-autopilot/tslist.auto'
--- dialer-app-autopilot/tslist.auto	1970-01-01 00:00:00 +0000
+++ dialer-app-autopilot/tslist.auto	2013-08-29 18:33:39 +0000
@@ -0,0 +1,4 @@
+-
+  discovery_cmd: autopilot-list phone_app
+  test_cmd: autopilot-run phone_app.tests.{}
+

=== added directory 'friends-app-autopilot'
=== added file 'friends-app-autopilot/master.run'
--- friends-app-autopilot/master.run	1970-01-01 00:00:00 +0000
+++ friends-app-autopilot/master.run	2013-08-29 18:33:39 +0000
@@ -0,0 +1,15 @@
+---
+testsuites:
+  - name: settle-before
+    fetch_method: dev
+    fetch_location: ../systemsettle
+    include_tests:
+      - systemsettle-before
+  - name: friends-app-autopilot
+    fetch_method: dev
+    fetch_location: ./
+  - name: settle-after
+    fetch_method: dev
+    fetch_location: ../systemsettle
+    include_tests:
+      - systemsettle-after

=== added file 'friends-app-autopilot/ts_control'
--- friends-app-autopilot/ts_control	1970-01-01 00:00:00 +0000
+++ friends-app-autopilot/ts_control	2013-08-29 18:33:39 +0000
@@ -0,0 +1,1 @@
+ts_setup: PKGS=friends-app-autopilot prepare-autopilot-test.sh

=== added file 'friends-app-autopilot/tslist.auto'
--- friends-app-autopilot/tslist.auto	1970-01-01 00:00:00 +0000
+++ friends-app-autopilot/tslist.auto	2013-08-29 18:33:39 +0000
@@ -0,0 +1,4 @@
+-
+  discovery_cmd: autopilot-list friends_app
+  test_cmd: autopilot-run friends_app.tests.{}
+

=== added directory 'gallery-app-autopilot'
=== added file 'gallery-app-autopilot/master.run'
--- gallery-app-autopilot/master.run	1970-01-01 00:00:00 +0000
+++ gallery-app-autopilot/master.run	2013-08-29 18:33:39 +0000
@@ -0,0 +1,15 @@
+---
+testsuites:
+  - name: settle-before
+    fetch_method: dev
+    fetch_location: ../systemsettle
+    include_tests:
+      - systemsettle-before
+  - name: gallery-app-autopilot
+    fetch_method: dev
+    fetch_location: ./
+  - name: settle-after
+    fetch_method: dev
+    fetch_location: ../systemsettle
+    include_tests:
+      - systemsettle-after

=== added file 'gallery-app-autopilot/ts_control'
--- gallery-app-autopilot/ts_control	1970-01-01 00:00:00 +0000
+++ gallery-app-autopilot/ts_control	2013-08-29 18:33:39 +0000
@@ -0,0 +1,1 @@
+ts_setup: PKGS=gallery-app-autopilot prepare-autopilot-test.sh

=== added file 'gallery-app-autopilot/tslist.auto'
--- gallery-app-autopilot/tslist.auto	1970-01-01 00:00:00 +0000
+++ gallery-app-autopilot/tslist.auto	2013-08-29 18:33:39 +0000
@@ -0,0 +1,4 @@
+-
+  discovery_cmd: autopilot-list gallery_app
+  test_cmd: autopilot-run gallery_app.tests.{}
+

=== added directory 'jenkins'
=== added file 'jenkins/jenkins.sh'
--- jenkins/jenkins.sh	1970-01-01 00:00:00 +0000
+++ jenkins/jenkins.sh	2013-08-29 18:33:39 +0000
@@ -0,0 +1,109 @@
+#!/bin/bash
+
+## This is the script jenkins should run to execute various touch applications
+## Intersting environment variables that must be set:
+##  ANDROID_SERIAL - specify another android device
+##  APP - the name of the app to test, ie share_app_autopilot
+##  QUICK - if set, skips the reboot and wait-for-network logic
+##  FROM_HOST - if set, runs the test from the host instead of the target
+
+set -e
+
+BASEDIR=$(dirname $(readlink -f $0))/..
+
+RESDIR=`pwd`/clientlogs
+UTAHFILE=${RESDIR}/utah.yaml
+UTAH_PHABLET_CMD="${UTAH_PHABLET_CMD-/usr/share/utah/examples/run_utah_phablet.py}"
+
+ANDROID_SERIAL="${ANDROID_SERIAL-015d1884b20c1c0f}"  #doanac's nexus7 at home
+
+TESTSUITE_HOST=$(readlink -f ${BASEDIR}/${APP})
+TESTSUITE_TARGET_BASE=/tmp/tests
+TESTSUITE_TARGET=${TESTSUITE_TARGET_BASE}/$(basename ${TESTSUITE_HOST})
+
+cleanup() {
+	set +e
+}
+
+test_from_target() {
+	# push the runlist over to the test
+	adb push ${BASEDIR} ${TESTSUITE_TARGET_BASE} &> /dev/null
+	${UTAH_PHABLET_CMD} \
+		-s ${ANDROID_SERIAL} \
+		--results-dir ${RESDIR} \
+		--skip-install --skip-network --skip-utah \
+		--pull /var/crash \
+		-l ${TESTSUITE_TARGET}/master.run
+}
+
+test_from_host() {
+	export ANDROID_SERIAL   # need for utils/hosts scripts
+
+	export PATH=${BASEDIR}/utils/host:${PATH}
+
+	# allow for certain commands to run from host/target
+	# see unity8-autopilot/ts_control for example
+	export TARGET_PREFIX=adb-shell
+
+	sudo TARGET_PREFIX=$TARGET_PREFIX PATH=$PATH ${UTAH_PHABLET_CMD} \
+		-s ${ANDROID_SERIAL} \
+		--from-host \
+		--results-dir ${RESDIR} \
+		--skip-install --skip-network --skip-utah \
+                --pull /var/crash \
+		-l ${TESTSUITE_HOST}/master.run
+}
+
+main() {
+	rm -rf clientlogs
+	mkdir clientlogs
+
+	# print the build date so the jenkins job can use it as the
+	# build description
+	adb -s ${ANDROID_SERIAL} pull /var/log/installer/media-info ${RESDIR}
+	BUILDID=`cat ${RESDIR}/media-info | awk '{ print $(NF)}' | sed -e 's/(//' -e 's/)//'`
+	echo "= TOUCH BUILD DATE:$BUILDID"
+
+	adb shell "top -n1 -b" > ${RESDIR}/top.log
+
+	set -x
+	adb shell 'rm -f /var/crash/*'
+	if [ -z $QUICK ] ; then
+		# get the phone in sane place
+		adb -s ${ANDROID_SERIAL} reboot
+		# sometimes reboot doesn't happen fast enough, so add a little
+		# delay to help ensure its actually rebooted and we didn't just
+		# connect back to the device before it rebooted
+		adb -s ${ANDROID_SERIAL} wait-for-device
+		sleep 5
+		adb -s ${ANDROID_SERIAL} wait-for-device
+		timeout 120s adb -s ${ANDROID_SERIAL} shell /usr/local/bin/utah-wait-for-network
+	else
+		echo "SKIPPING phone reboot..."
+	fi
+
+	if [ -z $FROM_HOST ] ; then
+		echo "launching test on the target...."
+		test_from_target
+	else
+		echo "launching test from the host...."
+		test_from_host
+	fi
+        adb shell 'rm -f /var/crash/*'
+
+	if ! `grep "^errors: [!0]" < $UTAHFILE >/dev/null` ; then
+		echo "errors found"
+		EXITCODE=1
+	fi
+	if ! `grep "^failures: [!0]" < $UTAHFILE >/dev/null` ; then
+		echo "failures found"
+		EXITCODE=2
+	fi
+	echo "Results Summary"
+	echo "---------------"
+	egrep '^(errors|failures|passes|fetch_errors):' $UTAHFILE
+	exit $EXITCODE
+}
+
+trap cleanup TERM INT EXIT
+main

=== added file 'jenkins/provision.sh'
--- jenkins/provision.sh	1970-01-01 00:00:00 +0000
+++ jenkins/provision.sh	2013-08-29 18:33:39 +0000
@@ -0,0 +1,26 @@
+#!/bin/bash
+
+## This is the script jenkins should run to provision a device in the lab
+## Intersting environment variables that must be set:
+##  ANDROID_SERIAL - specify another android device
+##  NETWORK_FILE - an alternative network file if you aren't in the lab
+##  TOUCH_IMAGE=--ubuntu-bootstrap   (provision with read-only system image)
+
+set -e
+set -x
+
+BASEDIR=$(dirname $(readlink -f $0))
+
+RESDIR=`pwd`/clientlogs
+UTAH_PHABLET_CMD="${UTAH_PHABLET_CMD-/usr/share/utah/examples/run_utah_phablet.py}"
+
+ANDROID_SERIAL="${ANDROID_SERIAL-015d1884b20c1c0f}"  #doanac's nexus7 at home
+NETWORK_FILE="${NETWORK_FILE-/home/ubuntu/magners-wifi}"
+
+rm -rf clientlogs
+mkdir clientlogs
+
+${UTAH_PHABLET_CMD} -s ${ANDROID_SERIAL} --results-dir ${RESDIR} --network-file=${NETWORK_FILE} ${TOUCH_IMAGE}
+
+# get our target-based utilities into our PATH
+adb -s ${ANDROID_SERIAL} push ${BASEDIR}/../utils/target /usr/local/bin/

=== added directory 'mediaplayer-app-autopilot'
=== added file 'mediaplayer-app-autopilot/master.run'
--- mediaplayer-app-autopilot/master.run	1970-01-01 00:00:00 +0000
+++ mediaplayer-app-autopilot/master.run	2013-08-29 18:33:39 +0000
@@ -0,0 +1,15 @@
+---
+testsuites:
+  - name: settle-before
+    fetch_method: dev
+    fetch_location: ../systemsettle
+    include_tests:
+      - systemsettle-before
+  - name: mediaplayer-app-autopilot
+    fetch_method: dev
+    fetch_location: ./
+  - name: settle-after
+    fetch_method: dev
+    fetch_location: ../systemsettle
+    include_tests:
+      - systemsettle-after

=== added file 'mediaplayer-app-autopilot/ts_control'
--- mediaplayer-app-autopilot/ts_control	1970-01-01 00:00:00 +0000
+++ mediaplayer-app-autopilot/ts_control	2013-08-29 18:33:39 +0000
@@ -0,0 +1,1 @@
+ts_setup: PKGS=mediaplayer-app-autopilot prepare-autopilot-test.sh

=== added file 'mediaplayer-app-autopilot/tslist.auto'
--- mediaplayer-app-autopilot/tslist.auto	1970-01-01 00:00:00 +0000
+++ mediaplayer-app-autopilot/tslist.auto	2013-08-29 18:33:39 +0000
@@ -0,0 +1,4 @@
+-
+  discovery_cmd: autopilot-list mediaplayer_app
+  test_cmd: autopilot-run mediaplayer_app.tests.{}
+

=== added directory 'memevent'
=== added file 'memevent/master.run'
--- memevent/master.run	1970-01-01 00:00:00 +0000
+++ memevent/master.run	2013-08-29 18:33:39 +0000
@@ -0,0 +1,5 @@
+---
+testsuites:
+  - name: memevent
+    fetch_method: dev
+    fetch_location: ./

=== added file 'memevent/setup.sh'
--- memevent/setup.sh	1970-01-01 00:00:00 +0000
+++ memevent/setup.sh	2013-08-29 18:33:39 +0000
@@ -0,0 +1,8 @@
+#!/bin/sh
+
+set -e
+
+# copy the autopilot scripts over if needed
+[ -z $ANDROID_SERIAL ] || adb push ./ubuntu_test_cases /home/phablet/autopilot/ubuntu_test_cases
+
+PKGS="camera-app-autopilot gallery-app-autopilot mediaplayer-app-autopilot webbrowser-app-autopilot" prepare-autopilot-test.sh

=== added file 'memevent/ts_control'
--- memevent/ts_control	1970-01-01 00:00:00 +0000
+++ memevent/ts_control	2013-08-29 18:33:39 +0000
@@ -0,0 +1,1 @@
+ts_setup: ./setup.sh

=== added file 'memevent/tslist.auto'
--- memevent/tslist.auto	1970-01-01 00:00:00 +0000
+++ memevent/tslist.auto	2013-08-29 18:33:39 +0000
@@ -0,0 +1,7 @@
+---
+# The discovery command is run from a directory containing the whole suite
+# The test command is run from a sub directory in that
+# We need to run each command in the directory that contains ubuntu_test_cases
+# so that autopilot can find our python modules
+- discovery_cmd: cd memevent; autopilot-list ubuntu_test_cases.memory_usage_measurement
+  test_cmd: cd ..; autopilot-run ubuntu_test_cases.memory_usage_measurement.tests.{}

=== added directory 'memevent/ubuntu_test_cases'
=== added file 'memevent/ubuntu_test_cases/__init__.py'
--- memevent/ubuntu_test_cases/__init__.py	1970-01-01 00:00:00 +0000
+++ memevent/ubuntu_test_cases/__init__.py	2013-08-29 18:33:39 +0000
@@ -0,0 +1,6 @@
+"""ubuntu_test_cases package
+
+Warning: This python package is installed by a different debian package in a
+different branch. It's been been created here only because it's convenient to
+run autopilot directly from the branch.
+"""

=== added directory 'memevent/ubuntu_test_cases/memory_usage_measurement'
=== added file 'memevent/ubuntu_test_cases/memory_usage_measurement/__init__.py'
--- memevent/ubuntu_test_cases/memory_usage_measurement/__init__.py	1970-01-01 00:00:00 +0000
+++ memevent/ubuntu_test_cases/memory_usage_measurement/__init__.py	2013-08-29 18:33:39 +0000
@@ -0,0 +1,1 @@
+"""Event based memory usage measurements test cases."""

=== added directory 'memevent/ubuntu_test_cases/memory_usage_measurement/apps'
=== added file 'memevent/ubuntu_test_cases/memory_usage_measurement/apps/__init__.py'
--- memevent/ubuntu_test_cases/memory_usage_measurement/apps/__init__.py	1970-01-01 00:00:00 +0000
+++ memevent/ubuntu_test_cases/memory_usage_measurement/apps/__init__.py	2013-08-29 18:33:39 +0000
@@ -0,0 +1,21 @@
+"""Application classes used to drive them easily with autopilot."""
+
+from autopilot.input import Keyboard, Mouse, Pointer, Touch
+from autopilot.platform import model
+
+
+class App(object):
+
+    """Application class with common code."""
+
+    def __init__(self, tc):
+        self.tc = tc
+        self.app = None
+        self.window = None
+
+        self.keyboard = Keyboard.create()
+        if model() == 'Desktop':
+            input_device = Mouse.create()
+        else:
+            input_device = Touch.create()
+        self.pointer = Pointer(input_device)

=== added file 'memevent/ubuntu_test_cases/memory_usage_measurement/apps/browser.py'
--- memevent/ubuntu_test_cases/memory_usage_measurement/apps/browser.py	1970-01-01 00:00:00 +0000
+++ memevent/ubuntu_test_cases/memory_usage_measurement/apps/browser.py	2013-08-29 18:33:39 +0000
@@ -0,0 +1,110 @@
+"""Browser application to write autopilot test cases easily."""
+
+from testtools.matchers import Contains, Equals
+
+from webbrowser_app.emulators.main_window import MainWindow as BrowserWindow
+
+from ubuntu_test_cases.memory_usage_measurement.apps import App
+from ubuntu_test_cases.memory_usage_measurement.matchers import (
+    DoesNotChange,
+    Eventually,
+)
+
+
+class BrowserApp(App):
+
+    """Browser application."""
+
+    TYPING_DELAY = 0.01
+
+    def assert_chrome_eventually_hidden(self):
+        """Make sure chrome is eventually hidden."""
+        view = self.window.get_qml_view()
+        chrome = self.window.get_chrome()
+        self.tc.assertThat(lambda: chrome.globalRect[1],
+                           Eventually(Equals(view.y + view.height)))
+
+    def assert_page_eventually_loaded(self, url):
+        """Make sure page is eventually loaded."""
+        webview = self.window.get_current_webview()
+        self.tc.assertThat(webview.url, Eventually(Equals(url)))
+        # loadProgress == 100 ensures that a page has actually loaded
+        self.tc.assertThat(webview.loadProgress, Eventually(Equals(100)))
+        self.tc.assertThat(webview.loading, Eventually(Equals(False)))
+
+    def clear_address_bar(self):
+        """Clear address bar."""
+        self.focus_address_bar()
+        clear_button = self.window.get_address_bar_clear_button()
+        self.tc.assertThat(lambda: (clear_button.x,
+                                    clear_button.y,
+                                    clear_button.y),
+                           Eventually(DoesNotChange()))
+        self.pointer.move_to_object(clear_button)
+        self.pointer.click()
+        text_field = self.window.get_address_bar_text_field()
+        self.tc.assertThat(text_field.text, Eventually(Equals("")))
+
+    def ensure_chrome_is_hidden(self):
+        """Make sure chrome is hidden."""
+        webview = self.window.get_current_webview()
+        self.pointer.move_to_object(webview)
+        self.pointer.click()
+        self.assert_chrome_eventually_hidden()
+
+    def focus_address_bar(self):
+        """Make sure address bar is focused."""
+        address_bar = self.window.get_address_bar()
+        self.pointer.move_to_object(address_bar)
+        self.pointer.click()
+        self.tc.assertThat(address_bar.activeFocus, Eventually(Equals(True)))
+
+    def go_to_url(self, url):
+        """Go to given url.
+
+        :param url: URL that should be loaded in the browser
+        :type url: str
+
+        """
+        self.ensure_chrome_is_hidden()
+        self.reveal_chrome()
+        self.clear_address_bar()
+        self.type_in_address_bar(url)
+        self.keyboard.press_and_release("Enter")
+
+    def launch(self):
+        """Launch application."""
+        args = [
+            'webbrowser-app',
+            '--fullscreen',
+            ('--desktop_file_hint='
+             '/usr/share/applications/webbrowser-app.desktop'),
+        ]
+        self.app = self.tc.launch_test_application(*args, app_type='qt')
+        self.window = BrowserWindow(self.app)
+        self.tc.assertThat(self.window.get_qml_view().visible,
+                           Eventually(Equals(True)))
+
+    def reveal_chrome(self):
+        """Reveal chrome."""
+        panel = self.window.get_panel()
+        distance = self.window.get_chrome().height
+        view = self.window.get_qml_view()
+        x_line = int(view.x + view.width * 0.5)
+        start_y = int(view.y + view.height - 1)
+        stop_y = int(start_y - distance)
+        self.pointer.drag(x_line, start_y, x_line, stop_y)
+        self.tc.assertThat(panel.state, Eventually(Equals('spread')))
+
+    def type_in_address_bar(self, text):
+        """Type text in address bar.
+
+        :param text: Text to be typed in the address bar.
+        :type text: str
+
+        """
+        address_bar = self.window.get_address_bar()
+        self.tc.assertThat(address_bar.activeFocus, Eventually(Equals(True)))
+        self.keyboard.type(text, delay=self.TYPING_DELAY)
+        text_field = self.window.get_address_bar_text_field()
+        self.tc.assertThat(text_field.text, Eventually(Contains(text)))

=== added file 'memevent/ubuntu_test_cases/memory_usage_measurement/apps/camera.py'
--- memevent/ubuntu_test_cases/memory_usage_measurement/apps/camera.py	1970-01-01 00:00:00 +0000
+++ memevent/ubuntu_test_cases/memory_usage_measurement/apps/camera.py	2013-08-29 18:33:39 +0000
@@ -0,0 +1,58 @@
+"""Camera application to write autopilot test cases easily."""
+
+import logging
+import os
+
+from glob import glob
+
+from camera_app.emulators.main_window import MainWindow as CameraWindow
+from testtools.matchers import Equals, HasLength
+
+from ubuntu_test_cases.memory_usage_measurement.apps import App
+from ubuntu_test_cases.memory_usage_measurement.matchers import Eventually
+
+LOGGER = logging.getLogger(__file__)
+
+
+class CameraApp(App):
+
+    """Camera application."""
+
+    IMAGE_FILENAME_PATTERN = os.path.expanduser('~/Pictures/image*')
+
+    def _remove_image_files(self):
+        """Remove all image files.
+
+        This is useful not only to cleanup, but also to check that just one
+        image file has been written to disk.
+
+        """
+        for filename in glob(self.IMAGE_FILENAME_PATTERN):
+            LOGGER.debug('Removing image file: {}'.format(filename))
+            os.remove(filename)
+
+    def launch(self):
+        """Launch application."""
+        args = [
+            'camera-app',
+            '--fullscreen',
+            ('--desktop_file_hint='
+             '/usr/share/applications/camera-app.desktop'),
+        ]
+        self.app = self.tc.launch_test_application(*args, app_type='qt')
+        self.window = CameraWindow(self.app)
+
+    def take_picture(self):
+        """Click on the exposure button to take picture."""
+        self._remove_image_files()
+
+        exposure_button = self.window.get_exposure_button()
+        self.tc.assertThat(exposure_button.enabled, Eventually(Equals(True)))
+
+        LOGGER.debug('Taking picture...')
+        self.pointer.move_to_object(exposure_button)
+        self.pointer.click()
+
+        # Wait for image file to be produced before memory usage measurement
+        self.tc.assertThat(lambda: glob(self.IMAGE_FILENAME_PATTERN),
+                           Eventually(HasLength(1)))

=== added file 'memevent/ubuntu_test_cases/memory_usage_measurement/apps/gallery.py'
--- memevent/ubuntu_test_cases/memory_usage_measurement/apps/gallery.py	1970-01-01 00:00:00 +0000
+++ memevent/ubuntu_test_cases/memory_usage_measurement/apps/gallery.py	2013-08-29 18:33:39 +0000
@@ -0,0 +1,41 @@
+"""Gallery application to write autopilot test cases easily."""
+
+import os
+import shutil
+import tempfile
+
+from ubuntu_test_cases.memory_usage_measurement.apps import App
+
+
+class GalleryApp(App):
+
+    """Gallery application."""
+
+    SAMPLE_DIR = '/usr/lib/python2.7/dist-packages/gallery_app/data/default'
+
+    def __init__(self, tc):
+        super(GalleryApp, self).__init__(tc)
+        self.temp_sample_dir = None
+        self._copy_sample_dir()
+
+    def _copy_sample_dir(self):
+        """Copy sample directory to a temporary location.
+
+        This is useful to provide some default content.
+
+        """
+        self.temp_sample_dir = tempfile.mkdtemp(prefix='gallery-app-test-')
+        self.tc.addCleanup(shutil.rmtree, self.temp_sample_dir)
+        self.temp_sample_dir = os.path.join(self.temp_sample_dir, 'data')
+        shutil.copytree(self.SAMPLE_DIR, self.temp_sample_dir)
+
+    def launch(self):
+        """Launch the application."""
+        args = [
+            'gallery-app',
+            ('--desktop_file_hint='
+             '/usr/share/applications/gallery-app.desktop'),
+            self.temp_sample_dir,
+        ]
+        self.app = self.tc.launch_test_application(*args,
+                                                   app_type='qt')

=== added file 'memevent/ubuntu_test_cases/memory_usage_measurement/apps/media_player.py'
--- memevent/ubuntu_test_cases/memory_usage_measurement/apps/media_player.py	1970-01-01 00:00:00 +0000
+++ memevent/ubuntu_test_cases/memory_usage_measurement/apps/media_player.py	2013-08-29 18:33:39 +0000
@@ -0,0 +1,53 @@
+"""Media player application to write autopilot test cases easily."""
+
+import os
+
+from testtools.matchers import Equals, GreaterThan
+
+from mediaplayer_app.emulators.main_window import (
+    MainWindow as MediaPlayerWindow)
+
+from ubuntu_test_cases.memory_usage_measurement.apps import App
+from ubuntu_test_cases.memory_usage_measurement.matchers import Eventually
+
+
+class MediaPlayerApp(App):
+
+    """Media player application."""
+
+    # Default content
+    VIDEOS_DIR = 'file:///usr/share/mediaplayer-app/videos/'
+
+    def assert_playback_finished(self):
+        """Media player memory usage after playing a file."""
+        time_line = self.window.get_object("Slider", "TimeLine.Slider")
+
+        # Time line value isn't set to maximum value after playback is finished
+        # (LP: #1190555)
+        maximum_value = time_line.maximumValue - 2.0
+        self.tc.assertThat(time_line.value,
+                           Eventually(GreaterThan(maximum_value)))
+
+    def launch(self, movie_file=None):
+        """Launch application.
+
+        :param movie_file:
+            Relative path to movie file (uses default content directory as
+            root).
+        :type movie_file: str
+
+        """
+        binary = 'mediaplayer-app'
+        args = [
+            binary,
+            '--fullscreen',
+            ('--desktop_file_hint='
+             '/usr/share/applications/mediaplayer-app.desktop'),
+        ]
+        if movie_file:
+            args.insert(1, os.path.join(self.VIDEOS_DIR, movie_file))
+
+        self.app = self.tc.launch_test_application(*args, app_type='qt')
+        self.window = MediaPlayerWindow(self.app)
+        self.tc.assertThat(self.window.get_qml_view().visible,
+                           Eventually(Equals(True)))

=== added file 'memevent/ubuntu_test_cases/memory_usage_measurement/matchers.py'
--- memevent/ubuntu_test_cases/memory_usage_measurement/matchers.py	1970-01-01 00:00:00 +0000
+++ memevent/ubuntu_test_cases/memory_usage_measurement/matchers.py	2013-08-29 18:33:39 +0000
@@ -0,0 +1,37 @@
+"""Custom matchers used by the tests."""
+
+from autopilot.matchers import Eventually as EventuallyMatcher
+from testtools.matchers import Mismatch
+
+
+def Eventually(matcher):
+    """Wrapper around autopilot.matchers.Eventually.
+
+    The aim of the wrapper is just use a different timeout default
+
+    :param matcher: A testools-like matcher that tests the desired condition
+    :type matcher: object
+    :returns: A value depending on the matcher protocol
+    :rtype: None | a mismatch object with information about the mismatch
+
+    """
+    return EventuallyMatcher(matcher, timeout=40)
+
+
+class DoesNotChange(object):
+    """Match if two consecutive values are equal."""
+    def __init__(self):
+        self.old_value = None
+        self.value = None
+
+    def __str__(self):
+        return 'DoesNotChange()'
+
+    def match(self, value):
+        self.old_value = self.value
+        self.value = value
+        if self.value != self.old_value:
+            return Mismatch('Current value ({}) does not match old value ({})'
+                            .format(self.value, self.old_value))
+
+        return None

=== added file 'memevent/ubuntu_test_cases/memory_usage_measurement/probes.py'
--- memevent/ubuntu_test_cases/memory_usage_measurement/probes.py	1970-01-01 00:00:00 +0000
+++ memevent/ubuntu_test_cases/memory_usage_measurement/probes.py	2013-08-29 18:33:39 +0000
@@ -0,0 +1,170 @@
+"""Probes used to take measurements4 while the tests are executed."""
+
+import itertools
+import logging
+import os
+import re
+import subprocess
+
+from contextlib import contextmanager
+from time import time
+
+LOGGER = logging.getLogger(__file__)
+
+
+class SmemProbe(object):
+
+    """Memory usage probe."""
+
+    BINARY = os.path.join(os.path.dirname(__file__), 'smem-tabs')
+    THRESHOLDS = {
+        'foreground': 262144,  # 256MB
+        'background': 131072,  # 128MB
+    }
+
+    def __init__(self):
+        self.pids = []  # List of pids that should be monitored
+        self.readings = []  # List of readings
+        self.current_reading = None
+        self.threshold_exceeded_summary = []
+
+    @contextmanager
+    def probe(self, event):
+        """Run start and stop methods in a contex manager."""
+        self.start(event)
+        yield
+        self.stop(event)
+
+    def start(self, event):
+        """Start measurement.
+
+        This method is not actually used, but defined to be consistent with the
+        probes API.
+
+        :param event: Event name
+        :type event: str
+        :returns: None
+
+        """
+        LOGGER.debug('smem start: {}'.format(event))
+        self.current_reading = {
+            'event': event,
+            'start_time': time(),
+        }
+
+    def stop(self, event):
+        """Stop measurement.
+
+        Run smem and get memory usage for a given set PIDs.
+
+        :param event: Event name
+        :type event: str
+        :returns: None
+
+        """
+        LOGGER.debug('smem stop: {}'.format(event))
+        LOGGER.debug('Running {!r}...'.format(self.BINARY))
+        output = subprocess.check_output(self.BINARY)
+        parser = SmemParser()
+        pids_info = parser.parse(output)
+        threshold_exceeded_pids = self._calculate_threshold_exceeded(pids_info)
+        print '{:-^72}'.format(event)
+        for pid in self.pids:
+            print('PID: {pid}, command: {command}, PSS: {pss}, USS: {uss}'
+                  .format(**pids_info[pid]))
+
+        self.current_reading['stop_time'] = time()
+        self.current_reading['data'] = pids_info
+        self.readings.append(self.current_reading)
+        if threshold_exceeded_pids:
+            self.threshold_exceeded_summary.append(
+                (event, threshold_exceeded_pids))
+        self.current_reading = None
+
+    def _calculate_threshold_exceeded(self, pids_info):
+        """Calculate thresholds for the given set of pids.
+
+        :param pids_info:
+            Memory usage data for a give set of pids.
+
+            ..note::
+                This parameter is modified in place to add a delta of the PSS
+                and the threshold.
+        :type pids_info: list(dict)
+
+        """
+        # It's assumed that the pid for the foreground application is the one
+        # that was last added to the probe
+        foreground_pid = self.pids[-1]
+        foreground_threshold = self.THRESHOLDS['foreground']
+        background_pids = self.pids[:-1]
+        background_threshold = self.THRESHOLDS['background']
+
+        pids_and_thresholds = itertools.chain(
+            [(foreground_pid, foreground_threshold)],
+            itertools.product(background_pids, [background_threshold]))
+
+        threshold_exceeded_pids = []
+        for pid, threshold in pids_and_thresholds:
+            if pid in pids_info:
+                pid_info = pids_info[pid]
+                delta = pid_info['pss'] - threshold
+                pid_info['threshold_exceeded'] = delta
+                if delta > 0:
+                    threshold_exceeded_pids.append(pid)
+        return threshold_exceeded_pids
+
+    @property
+    def report(self):
+        """Return report with all the readings that have been made."""
+        return {'pids': self.pids,
+                'thresholds': self.THRESHOLDS,
+                'readings': self.readings}
+
+
+class SmemParser(object):
+
+    """Parser object to map smem output to data structure."""
+
+    SMEM_LINE = re.compile(
+        r'\s*(?P<pid>\d+)'
+        r'\s+(?P<user>\w+)'
+        r'\s+(?P<command>.+?)'
+        r'\s+(?P<swap>\d+)'
+        r'\s+(?P<uss>\d+)'
+        r'\s+(?P<pss>\d+)'
+        r'\s+(?P<rss>\d+)')
+
+    def parse(self, output):
+        """Parse smem output.
+
+        :param output: The report printed to stdout by smem
+        :type output: str
+        :returns: Data structure that can be serialized
+        :rtype: dict(dict)
+
+        """
+        pids_info = filter(None,
+                           [self._parse_line(line)
+                            for line in output.splitlines()[1:]])
+        return {pid_info['pid']: pid_info for pid_info in pids_info}
+
+    def _parse_line(self, line):
+        """Parse a single smem output line.
+
+        :param line:
+            A single line containing all the fields to parse for a process.
+        :type line: str
+        :returns: Data structure with the parsed fields
+        :rtype: dict
+
+        """
+        match = self.SMEM_LINE.match(line)
+        if not match:
+            LOGGER.warning('Unable to parse smem output: {}'.format(line))
+            return None
+
+        pid_info = match.groupdict()
+        for key in ('pid', 'swap', 'uss', 'pss', 'rss'):
+            pid_info[key] = int(pid_info[key])
+        return pid_info

=== added file 'memevent/ubuntu_test_cases/memory_usage_measurement/smem-tabs'
--- memevent/ubuntu_test_cases/memory_usage_measurement/smem-tabs	1970-01-01 00:00:00 +0000
+++ memevent/ubuntu_test_cases/memory_usage_measurement/smem-tabs	2013-08-29 18:33:39 +0000
@@ -0,0 +1,687 @@
+#!/usr/bin/env python
+#
+# smem - a tool for meaningful memory reporting
+#
+# Copyright 2008-2009 Matt Mackall <[e-mail]>
+#
+# This software may be used and distributed according to the terms of
+# the GNU General Public License version 2 or later, incorporated
+# herein by reference.
+
+import re, os, sys, pwd, optparse, errno, tarfile
+
+warned = False
+
+class procdata(object):
+    def __init__(self, source):
+        self._ucache = {}
+        self._gcache = {}
+        self.source = source and source or ""
+        self._memdata = None
+    def _list(self):
+        return os.listdir(self.source + "/proc")
+    def _read(self, f):
+        return file(self.source + '/proc/' + f).read()
+    def _readlines(self, f):
+        return self._read(f).splitlines(True)
+    def _stat(self, f):
+        return os.stat(self.source + "/proc/" + f)
+
+    def pids(self):
+        '''get a list of processes'''
+        return [int(e) for e in self._list()
+                if e.isdigit() and not iskernel(e)]
+    def mapdata(self, pid):
+        return self._readlines('%s/smaps' % pid)
+    def memdata(self):
+        if self._memdata is None:
+            self._memdata = self._readlines('meminfo')
+        return self._memdata
+    def version(self):
+        return self._readlines('version')[0]
+    def pidname(self, pid):
+        try:
+            l = self.pidcmd(pid).split(' ')[0]
+            return os.path.basename(l)
+        except:
+            return '?'
+    def pidcmd(self, pid):
+        try:
+            c = self._read('%s/cmdline' % pid)[:-1]
+            return c.replace('\0', ' ')
+        except:
+            return '?'
+    def piduser(self, pid):
+        try:
+            return self._stat('%d' % pid).st_uid
+        except:
+            return -1
+    def pidgroup(self, pid):
+        try:
+            return self._stat('%d' % pid).st_gid
+        except:
+            return -1
+    def username(self, uid):
+        if uid == -1:
+            return '?'
+        if uid not in self._ucache:
+            try:
+                self._ucache[uid] = pwd.getpwuid(uid)[0]
+            except KeyError:
+                self._ucache[uid] = str(uid)
+        return self._ucache[uid]
+    def groupname(self, gid):
+        if gid == -1:
+            return '?'
+        if gid not in self._gcache:
+            try:
+                self._gcache[gid] = pwd.getgrgid(gid)[0]
+            except KeyError:
+                self._gcache[gid] = str(gid)
+        return self._gcache[gid]
+
+class tardata(procdata):
+    def __init__(self, source):
+        procdata.__init__(self, source)
+        self.tar = tarfile.open(source)
+    def _list(self):
+        for ti in self.tar:
+            if ti.name.endswith('/smaps'):
+                d,f = ti.name.split('/')
+                yield d
+    def _read(self, f):
+        return self.tar.extractfile(f).read()
+    def _readlines(self, f):
+        return self.tar.extractfile(f).readlines()
+    def piduser(self, p):
+        t = self.tar.getmember("%d" % p)
+        if t.uname:
+            self._ucache[t.uid] = t.uname
+        return t.uid
+    def pidgroup(self, p):
+        t = self.tar.getmember("%d" % p)
+        if t.gname:
+            self._gcache[t.gid] = t.gname
+        return t.gid
+    def username(self, u):
+        return self._ucache.get(u, str(u))
+    def groupname(self, g):
+        return self._gcache.get(g, str(g))
+
+_totalmem = 0
+def totalmem():
+    global _totalmem
+    if not _totalmem:
+        if options.realmem:
+            _totalmem = fromunits(options.realmem) / 1024
+        else:
+            _totalmem = memory()['memtotal']
+    return _totalmem
+
+_kernelsize = 0
+def kernelsize():
+    global _kernelsize
+    if not _kernelsize and options.kernel:
+        try:
+            d = os.popen("size %s" % options.kernel).readlines()[1]
+            _kernelsize = int(d.split()[3]) / 1024
+        except:
+            try:
+                # try some heuristic to find gzipped part in kernel image
+                packedkernel = open(options.kernel).read()
+                pos = packedkernel.find('\x1F\x8B')
+                if pos >= 0 and pos < 25000:
+                    sys.stderr.write("Maybe uncompressed kernel can be extracted by the command:\n"
+                            "  dd if=%s bs=1 skip=%d | gzip -d >%s.unpacked\n\n" % (options.kernel, pos, options.kernel))
+            except:
+                pass
+            sys.stderr.write("Parameter '%s' should be an original uncompressed compiled kernel file.\n\n" % options.kernel)
+    return _kernelsize
+
+def pidmaps(pid):
+    global warned
+    maps = {}
+    start = None
+    seen = False
+    for l in src.mapdata(pid):
+        f = l.split()
+        if f[-1] == 'kB':
+            if f[0].startswith('Pss'):
+                seen = True
+            maps[start][f[0][:-1].lower()] = int(f[1])
+        elif f[0] == 'VmFlags:':
+            continue
+        else:
+            start, end = f[0].split('-')
+            start = int(start, 16)
+            name = "<anonymous>"
+            if len(f) > 5:
+                name = f[5]
+            maps[start] = dict(end=int(end, 16), mode=f[1],
+                               offset=int(f[2], 16),
+                               device=f[3], inode=f[4], name=name)
+
+    if not seen and not warned:
+        sys.stderr.write('warning: kernel does not appear to support PSS measurement\n')
+        warned = True
+        if not options.sort:
+            options.sort = 'rss'
+
+    if options.mapfilter:
+        f = {}
+        for m in maps:
+            if not filter(options.mapfilter, m, lambda x: maps[x]['name']):
+                f[m] = maps[m]
+        return f
+
+    return maps
+
+def sortmaps(totals, key):
+    l = []
+    for pid in totals:
+        l.append((totals[pid][key], pid))
+    l.sort()
+    return [pid for pid,key in l]
+
+def iskernel(pid):
+    return src.pidcmd(pid) == ""
+
+def memory():
+    t = {}
+    f = re.compile('(\\S+):\\s+(\\d+) kB')
+    for l in src.memdata():
+        m = f.match(l)
+        if m:
+            t[m.group(1).lower()] = int(m.group(2))
+    return t
+
+def units(x):
+    s = ''
+    if x == 0:
+        return '0'
+    for s in ('', 'K', 'M', 'G', 'T'):
+        if x < 1024:
+            break
+        x /= 1024.0
+    return "%.1f%s" % (x, s)
+
+def fromunits(x):
+    s = dict(k=2**10, K=2**10, kB=2**10, KB=2**10,
+             M=2**20, MB=2**20, G=2**30, GB=2**30,
+             T=2**40, TB=2**40)
+    for k,v in s.items():
+        if x.endswith(k):
+            return int(float(x[:-len(k)])*v)
+    sys.stderr.write("Memory size should be written with units, for example 1024M\n")
+    sys.exit(-1)
+
+def pidusername(pid):
+    return src.username(src.piduser(pid))
+
+def showamount(a, total):
+    if options.abbreviate:
+        return units(a * 1024)
+    elif options.percent:
+        return "%.2f%%" % (100.0 * a / total)
+    return a
+
+def filter(opt, arg, *sources):
+    if not opt:
+        return False
+
+    for f in sources:
+        if re.search(opt, f(arg)):
+            return False
+    return True
+
+def pidtotals(pid):
+    maps = pidmaps(pid)
+    t = dict(size=0, rss=0, pss=0, shared_clean=0, shared_dirty=0,
+             private_clean=0, private_dirty=0, referenced=0, swap=0)
+    for m in maps.iterkeys():
+        for k in t:
+            t[k] += maps[m].get(k, 0)
+
+    t['uss'] = t['private_clean'] + t['private_dirty']
+    t['maps'] = len(maps)
+
+    return t
+
+def processtotals(pids):
+    totals = {}
+    for pid in pids:
+        if (filter(options.processfilter, pid, src.pidname, src.pidcmd) or
+                filter(options.userfilter, pid, pidusername)):
+            continue
+        try:
+            p = pidtotals(pid)
+            if p['maps'] != 0:
+                totals[pid] = p
+        except:
+            continue
+    return totals
+
+def showpids():
+    p = src.pids()
+    pt = processtotals(p)
+
+    def showuser(p):
+        if options.numeric:
+            return src.piduser(p)
+        return pidusername(p)
+
+    fields = dict(
+        pid=('PID', lambda n: n, '% 5s', lambda x: len(pt),
+             'process ID'),
+        user=('User', showuser, '%-8s', lambda x: len(dict.fromkeys(x)),
+              'owner of process'),
+        name=('Name', src.pidname, '%s', None,
+              'name of process'),
+        command=('Command', src.pidcmd, '%s', None,
+                 'process command line'),
+        maps=('Maps',lambda n: pt[n]['maps'], '% 5s', sum,
+              'total number of mappings'),
+        swap=('Swap',lambda n: pt[n]['swap'], '% 8a', sum,
+              'amount of swap space consumed (ignoring sharing)'),
+        uss=('USS', lambda n: pt[n]['uss'], '%a', sum,
+             'unique set size'),
+        rss=('RSS', lambda n: pt[n]['rss'], '%a', sum,
+             'resident set size (ignoring sharing)'),
+        pss=('PSS', lambda n: pt[n]['pss'], '%a', sum,
+             'proportional set size (including sharing)'),
+        vss=('VSS', lambda n: pt[n]['size'], '%a', sum,
+             'virtual set size (total virtual memory mapped)'),
+        )
+    columns = options.columns or 'pid user command swap uss pss rss'
+
+    showtable(pt.keys(), fields, columns.split(), options.sort or 'pss')
+
+def maptotals(pids):
+    totals = {}
+    for pid in pids:
+        if (filter(options.processfilter, pid, src.pidname, src.pidcmd) or
+                filter(options.userfilter, pid, pidusername)):
+            continue
+        try:
+            maps = pidmaps(pid)
+            seen = {}
+            for m in maps.iterkeys():
+                name = maps[m]['name']
+                if name not in totals:
+                    t = dict(size=0, rss=0, pss=0, shared_clean=0,
+                             shared_dirty=0, private_clean=0, count=0,
+                             private_dirty=0, referenced=0, swap=0, pids=0)
+                else:
+                    t = totals[name]
+
+                for k in t:
+                    t[k] += maps[m].get(k, 0)
+                t['count'] += 1
+                if name not in seen:
+                    t['pids'] += 1
+                    seen[name] = 1
+                totals[name] = t
+        except EnvironmentError:
+            continue
+    return totals
+
+def showmaps():
+    p = src.pids()
+    pt = maptotals(p)
+
+    fields = dict(
+        map=('Map', lambda n: n, '%-40.40s', len,
+             'mapping name'),
+        count=('Count', lambda n: pt[n]['count'], '% 5s', sum,
+               'number of mappings found'),
+        pids=('PIDs', lambda n: pt[n]['pids'], '% 5s', sum,
+              'number of PIDs using mapping'),
+        swap=('Swap',lambda n: pt[n]['swap'], '% 8a', sum,
+              'amount of swap space consumed (ignoring sharing)'),
+        uss=('USS', lambda n: pt[n]['private_clean']
+             + pt[n]['private_dirty'], '% 8a', sum,
+             'unique set size'),
+        rss=('RSS', lambda n: pt[n]['rss'], '% 8a', sum,
+             'resident set size (ignoring sharing)'),
+        pss=('PSS', lambda n: pt[n]['pss'], '% 8a', sum,
+             'proportional set size (including sharing)'),
+        vss=('VSS', lambda n: pt[n]['size'], '% 8a', sum,
+             'virtual set size (total virtual address space mapped)'),
+        avgpss=('AVGPSS', lambda n: int(1.0 * pt[n]['pss']/pt[n]['pids']),
+                '% 8a', sum,
+                'average PSS per PID'),
+        avguss=('AVGUSS', lambda n: int(1.0 * pt[n]['uss']/pt[n]['pids']),
+                '% 8a', sum,
+                'average USS per PID'),
+        avgrss=('AVGRSS', lambda n: int(1.0 * pt[n]['rss']/pt[n]['pids']),
+                '% 8a', sum,
+                'average RSS per PID'),
+        )
+    columns = options.columns or 'map pids avgpss pss'
+
+    showtable(pt.keys(), fields, columns.split(), options.sort or 'pss')
+
+def usertotals(pids):
+    totals = {}
+    for pid in pids:
+        if (filter(options.processfilter, pid, src.pidname, src.pidcmd) or
+                filter(options.userfilter, pid, pidusername)):
+            continue
+        try:
+            maps = pidmaps(pid)
+            if len(maps) == 0:
+                continue
+        except EnvironmentError:
+            continue
+        user = src.piduser(pid)
+        if user not in totals:
+            t = dict(size=0, rss=0, pss=0, shared_clean=0,
+                     shared_dirty=0, private_clean=0, count=0,
+                     private_dirty=0, referenced=0, swap=0)
+        else:
+            t = totals[user]
+
+        for m in maps.iterkeys():
+            for k in t:
+                t[k] += maps[m].get(k, 0)
+
+        t['count'] += 1
+        totals[user] = t
+    return totals
+
+def showusers():
+    p = src.pids()
+    pt = usertotals(p)
+
+    def showuser(u):
+        if options.numeric:
+            return u
+        return src.username(u)
+
+    fields = dict(
+        user=('User', showuser, '%-8s', None,
+              'user name or ID'),
+        count=('Count', lambda n: pt[n]['count'], '% 5s', sum,
+               'number of processes'),
+        swap=('Swap',lambda n: pt[n]['swap'], '% 8a', sum,
+              'amount of swapspace consumed (ignoring sharing)'),
+        uss=('USS', lambda n: pt[n]['private_clean']
+             + pt[n]['private_dirty'], '% 8a', sum,
+             'unique set size'),
+        rss=('RSS', lambda n: pt[n]['rss'], '% 8a', sum,
+             'resident set size (ignoring sharing)'),
+        pss=('PSS', lambda n: pt[n]['pss'], '% 8a', sum,
+             'proportional set size (including sharing)'),
+        vss=('VSS', lambda n: pt[n]['pss'], '% 8a', sum,
+             'virtual set size (total virtual memory mapped)'),
+        )
+    columns = options.columns or 'user count swap uss pss rss'
+
+    showtable(pt.keys(), fields, columns.split(), options.sort or 'pss')
+
+def showsystem():
+    t = totalmem()
+    ki = kernelsize()
+    m = memory()
+
+    mt = m['memtotal']
+    f = m['memfree']
+
+    # total amount used by hardware
+    fh = max(t - mt - ki, 0)
+
+    # total amount mapped into userspace (ie mapped an unmapped pages)
+    u = m['anonpages'] + m['mapped']
+
+    # total amount allocated by kernel not for userspace
+    kd = mt - f - u
+
+    # total amount in kernel caches
+    kdc = m['buffers'] + m['sreclaimable'] + (m['cached'] - m['mapped'])
+
+    l = [("firmware/hardware", fh, 0),
+         ("kernel image", ki, 0),
+         ("kernel dynamic memory", kd, kdc),
+         ("userspace memory", u, m['mapped']),
+         ("free memory", f, f)]
+
+    fields = dict(
+        order=('Order', lambda n: n, '% 1s', lambda x: '',
+             'hierarchical order'),
+        area=('Area', lambda n: l[n][0], '%-24s', lambda x: '',
+             'memory area'),
+        used=('Used', lambda n: l[n][1], '%10a', sum,
+              'area in use'),
+        cache=('Cache', lambda n: l[n][2], '%10a', sum,
+              'area used as reclaimable cache'),
+        noncache=('Noncache', lambda n: l[n][1] - l[n][2], '%10a', sum,
+              'area not reclaimable'))
+
+    columns = options.columns or 'area used cache noncache'
+    showtable(range(len(l)), fields, columns.split(), options.sort or 'order')
+
+def showfields(fields, f):
+    if f != list:
+        print "unknown field", f
+    print "known fields:"
+    for l in sorted(fields.keys()):
+        print "%-8s %s" % (l, fields[l][-1])
+
+def showtable(rows, fields, columns, sort):
+    header = ""
+    format = ""
+    formatter = []
+
+    if sort not in fields:
+            showfields(fields, sort)
+            sys.exit(-1)
+
+    if options.pie:
+        columns.append(options.pie)
+    if options.bar:
+        columns.append(options.bar)
+
+    mt = totalmem()
+    st = memory()['swaptotal']
+
+    for n in columns:
+        if n not in fields:
+            showfields(fields, n)
+            sys.exit(-1)
+
+        f = fields[n][2]
+        if 'a' in f:
+            if n == 'swap':
+                formatter.append(lambda x: showamount(x, st))
+            else:
+                formatter.append(lambda x: showamount(x, mt))
+            f = f.replace('a', 's')
+        else:
+            formatter.append(lambda x: x)
+        format += f + "\t"
+        header += f % fields[n][0] + "\t"
+
+    l = []
+    for n in rows:
+        r = [fields[c][1](n) for c in columns]
+        l.append((fields[sort][1](n), r))
+
+    l.sort(reverse=bool(options.reverse))
+
+    if options.pie:
+        showpie(l, sort)
+        return
+    elif options.bar:
+        showbar(l, columns, sort)
+        return
+
+    if not options.no_header:
+        print header
+
+    for k,r in l:
+        print format % tuple([f(v) for f,v in zip(formatter, r)])
+
+    if options.totals:
+        # totals
+        t = []
+        for c in columns:
+            f = fields[c][3]
+            if f:
+                t.append(f([fields[c][1](n) for n in rows]))
+            else:
+                t.append("")
+
+        print "-" * len(header)
+        print format % tuple([f(v) for f,v in zip(formatter, t)])
+
+def showpie(l, sort):
+    try:
+        import pylab
+    except ImportError:
+        sys.stderr.write("pie chart requires matplotlib\n")
+        sys.exit(-1)
+
+    if (l[0][0] < l[-1][0]):
+        l.reverse()
+
+    labels = [r[1][-1] for r in l]
+    values = [r[0] for r in l] # sort field
+
+    tm = totalmem()
+    s = sum(values)
+    unused = tm - s
+    t = 0
+    while values and (t + values[-1] < (tm * .02) or
+                      values[-1] < (tm * .005)):
+        t += values.pop()
+        labels.pop()
+
+    if t:
+        values.append(t)
+        labels.append('other')
+
+    explode = [0] * len(values)
+    if unused > 0:
+        values.insert(0, unused)
+        labels.insert(0, 'unused')
+        explode.insert(0, .05)
+
+    pylab.figure(1, figsize=(6,6))
+    ax = pylab.axes([0.1, 0.1, 0.8, 0.8])
+    pylab.pie(values, explode = explode, labels=labels,
+              autopct="%.2f%%", shadow=True)
+    pylab.title('%s by %s' % (options.pie, sort))
+    pylab.show()
+
+def showbar(l, columns, sort):
+    try:
+        import pylab, numpy
+    except ImportError:
+        sys.stderr.write("bar chart requires matplotlib\n")
+        sys.exit(-1)
+
+    if (l[0][0] < l[-1][0]):
+        l.reverse()
+
+    rc = []
+    key = []
+    for n in range(len(columns) - 1):
+        try:
+            if columns[n] in 'pid user group'.split():
+                continue
+            float(l[0][1][n])
+            rc.append(n)
+            key.append(columns[n])
+        except:
+            pass
+
+    width = 1.0 / (len(rc) + 1)
+    offset = width / 2
+
+    def gc(n):
+        return 'bgrcmyw'[n % 7]
+
+    pl = []
+    ind = numpy.arange(len(l))
+    for n in xrange(len(rc)):
+        pl.append(pylab.bar(ind + offset + width * n,
+                             [x[1][rc[n]] for x in l], width, color=gc(n)))
+
+    #plt.xticks(ind + .5, )
+    pylab.gca().set_xticks(ind + .5)
+    pylab.gca().set_xticklabels([x[1][-1] for x in l], rotation=45)
+    pylab.legend([p[0] for p in pl], key)
+    pylab.show()
+
+
+parser = optparse.OptionParser("%prog [options]")
+parser.add_option("-H", "--no-header", action="store_true",
+                  help="disable header line")
+parser.add_option("-c", "--columns", type="str",
+                  help="columns to show")
+parser.add_option("-t", "--totals", action="store_true",
+                  help="show totals")
+
+parser.add_option("-R", "--realmem", type="str",
+                  help="amount of physical RAM")
+parser.add_option("-K", "--kernel", type="str",
+                  help="path to kernel image")
+
+parser.add_option("-m", "--mappings", action="store_true",
+                  help="show mappings")
+parser.add_option("-u", "--users", action="store_true",
+                  help="show users")
+parser.add_option("-w", "--system", action="store_true",
+                  help="show whole system")
+
+parser.add_option("-P", "--processfilter", type="str",
+                  help="process filter regex")
+parser.add_option("-M", "--mapfilter", type="str",
+                  help="map filter regex")
+parser.add_option("-U", "--userfilter", type="str",
+                  help="user filter regex")
+
+parser.add_option("-n", "--numeric", action="store_true",
+                  help="numeric output")
+parser.add_option("-s", "--sort", type="str",
+                  help="field to sort on")
+parser.add_option("-r", "--reverse", action="store_true",
+                  help="reverse sort")
+
+parser.add_option("-p", "--percent", action="store_true",
+                  help="show percentage")
+parser.add_option("-k", "--abbreviate", action="store_true",
+                  help="show unit suffixes")
+
+parser.add_option("", "--pie", type='str',
+                  help="show pie graph")
+parser.add_option("", "--bar", type='str',
+                  help="show bar graph")
+
+parser.add_option("-S", "--source", type="str",
+                  help="/proc data source")
+
+
+defaults = {}
+parser.set_defaults(**defaults)
+(options, args) = parser.parse_args()
+
+try:
+    src = tardata(options.source)
+except:
+    src = procdata(options.source)
+
+try:
+    if options.mappings:
+        showmaps()
+    elif options.users:
+        showusers()
+    elif options.system:
+        showsystem()
+    else:
+        showpids()
+except IOError, e:
+    if e.errno == errno.EPIPE:
+        pass
+except KeyboardInterrupt:
+    pass

=== added directory 'memevent/ubuntu_test_cases/memory_usage_measurement/tests'
=== added file 'memevent/ubuntu_test_cases/memory_usage_measurement/tests/__init__.py'
--- memevent/ubuntu_test_cases/memory_usage_measurement/tests/__init__.py	1970-01-01 00:00:00 +0000
+++ memevent/ubuntu_test_cases/memory_usage_measurement/tests/__init__.py	2013-08-29 18:33:39 +0000
@@ -0,0 +1,1 @@
+"""Event based memory usage measurements test cases."""

=== added file 'memevent/ubuntu_test_cases/memory_usage_measurement/tests/test_memory_usage.py'
--- memevent/ubuntu_test_cases/memory_usage_measurement/tests/test_memory_usage.py	1970-01-01 00:00:00 +0000
+++ memevent/ubuntu_test_cases/memory_usage_measurement/tests/test_memory_usage.py	2013-08-29 18:33:39 +0000
@@ -0,0 +1,79 @@
+"""Measure touch applications memory usage."""
+
+import json
+import logging
+
+from autopilot.testcase import AutopilotTestCase
+
+from ubuntu_test_cases.memory_usage_measurement.apps.browser import BrowserApp
+from ubuntu_test_cases.memory_usage_measurement.apps.camera import CameraApp
+from ubuntu_test_cases.memory_usage_measurement.apps.gallery import GalleryApp
+from ubuntu_test_cases.memory_usage_measurement.apps.media_player import (
+    MediaPlayerApp,
+)
+from ubuntu_test_cases.memory_usage_measurement.probes import SmemProbe
+
+LOGGER = logging.getLogger(__file__)
+
+
+class MemoryUsageTests(AutopilotTestCase):
+
+    """Event based memory usage measurement scenario."""
+
+    def test_scenario(self):
+        """Scenario that takes measurements on some events."""
+        self.smem = SmemProbe()
+
+        # Make sure report is written with the data collected
+        # even if the test failed to complete
+        self.addCleanup(self._write_report)
+
+        browser = BrowserApp(self)
+        with self.smem.probe('Browser started'):
+            browser.launch()
+            self.smem.pids.append(browser.app.pid)
+
+        with self.smem.probe('Browser finished loading'):
+            url = 'http://www.cnn.com/'
+            browser.go_to_url(url)
+            browser.assert_page_eventually_loaded(url)
+
+        camera = CameraApp(self)
+        with self.smem.probe('Camera app started'):
+            camera.launch()
+            self.smem.pids.append(camera.app.pid)
+
+        with self.smem.probe('Camera app picture taken'):
+            camera.take_picture()
+
+        with self.smem.probe('Gallery app started'):
+            gallery = GalleryApp(self)
+            gallery.launch()
+            self.smem.pids.append(gallery.app.pid)
+
+        with self.smem.probe('Media player app started'):
+            media_player = MediaPlayerApp(self)
+            media_player.launch()
+            self.smem.pids.append(media_player.app.pid)
+
+        with self.smem.probe('Media player app finished playback'):
+            media_player = MediaPlayerApp(self)
+            media_player.launch('small.mp4')
+            self.smem.pids.append(media_player.app.pid)
+            media_player.assert_playback_finished()
+
+        summary_msg = '\n'.join(
+            ['- {}: {}'.format(event, pids)
+             for event, pids in self.smem.threshold_exceeded_summary])
+        self.assertListEqual(
+            self.smem.threshold_exceeded_summary,
+            [],
+            'Threshold(s) exceded:\n{}'.format(summary_msg))
+
+    def _write_report(self):
+        """Write report to to results directory."""
+        report_filename = '/var/cache/utah-probes/memory_usage.json'
+        with open(report_filename, 'w') as report_file:
+            json.dump(self.smem.report, report_file,
+                      indent=4, sort_keys=True)
+            LOGGER.debug('Report written to {}'.format(report_file.name))

=== added directory 'messaging-app-autopilot'
=== added file 'messaging-app-autopilot/master.run'
--- messaging-app-autopilot/master.run	1970-01-01 00:00:00 +0000
+++ messaging-app-autopilot/master.run	2013-08-29 18:33:39 +0000
@@ -0,0 +1,15 @@
+---
+testsuites:
+  - name: settle-before
+    fetch_method: dev
+    fetch_location: ../systemsettle
+    include_tests:
+      - systemsettle-before
+  - name: messaging-app-autopilot
+    fetch_method: dev
+    fetch_location: ./
+  - name: settle-after
+    fetch_method: dev
+    fetch_location: ../systemsettle
+    include_tests:
+      - systemsettle-after

=== added file 'messaging-app-autopilot/ts_control'
--- messaging-app-autopilot/ts_control	1970-01-01 00:00:00 +0000
+++ messaging-app-autopilot/ts_control	2013-08-29 18:33:39 +0000
@@ -0,0 +1,1 @@
+ts_setup: PKGS="messaging-app-autopilot ubuntu-ui-toolkit-autopilot" prepare-autopilot-test.sh

=== added file 'messaging-app-autopilot/tslist.auto'
--- messaging-app-autopilot/tslist.auto	1970-01-01 00:00:00 +0000
+++ messaging-app-autopilot/tslist.auto	2013-08-29 18:33:39 +0000
@@ -0,0 +1,4 @@
+-
+  discovery_cmd: autopilot-list messaging_app
+  test_cmd: autopilot-run messaging_app.tests.{}
+

=== added directory 'music-app-autopilot'
=== added file 'music-app-autopilot/master.run'
--- music-app-autopilot/master.run	1970-01-01 00:00:00 +0000
+++ music-app-autopilot/master.run	2013-08-29 18:33:39 +0000
@@ -0,0 +1,15 @@
+---
+testsuites:
+  - name: settle-before
+    fetch_method: dev
+    fetch_location: ../systemsettle
+    include_tests:
+      - systemsettle-before
+  - name: music-app-autopilot
+    fetch_method: dev
+    fetch_location: ./
+  - name: settle-after
+    fetch_method: dev
+    fetch_location: ../systemsettle
+    include_tests:
+      - systemsettle-after

=== added file 'music-app-autopilot/ts_control'
--- music-app-autopilot/ts_control	1970-01-01 00:00:00 +0000
+++ music-app-autopilot/ts_control	2013-08-29 18:33:39 +0000
@@ -0,0 +1,1 @@
+ts_setup: PKGS=music-app-autopilot prepare-autopilot-test.sh

=== added file 'music-app-autopilot/tslist.auto'
--- music-app-autopilot/tslist.auto	1970-01-01 00:00:00 +0000
+++ music-app-autopilot/tslist.auto	2013-08-29 18:33:39 +0000
@@ -0,0 +1,4 @@
+-
+  discovery_cmd: autopilot-list music_app
+  test_cmd: autopilot-run music_app.tests.{}
+

=== added directory 'notes-app-autopilot'
=== added file 'notes-app-autopilot/master.run'
--- notes-app-autopilot/master.run	1970-01-01 00:00:00 +0000
+++ notes-app-autopilot/master.run	2013-08-29 18:33:39 +0000
@@ -0,0 +1,15 @@
+---
+testsuites:
+  - name: settle-before
+    fetch_method: dev
+    fetch_location: ../systemsettle
+    include_tests:
+      - systemsettle-before
+  - name: notes-app-autopilot
+    fetch_method: dev
+    fetch_location: ./
+  - name: settle-after
+    fetch_method: dev
+    fetch_location: ../systemsettle
+    include_tests:
+      - systemsettle-after

=== added file 'notes-app-autopilot/ts_control'
--- notes-app-autopilot/ts_control	1970-01-01 00:00:00 +0000
+++ notes-app-autopilot/ts_control	2013-08-29 18:33:39 +0000
@@ -0,0 +1,1 @@
+ts_setup: PKGS=notes-app-autopilot prepare-autopilot-test.sh

=== added file 'notes-app-autopilot/tslist.auto'
--- notes-app-autopilot/tslist.auto	1970-01-01 00:00:00 +0000
+++ notes-app-autopilot/tslist.auto	2013-08-29 18:33:39 +0000
@@ -0,0 +1,4 @@
+-
+  discovery_cmd: autopilot-list notes_app
+  test_cmd: autopilot-run notes_app.tests.{}
+

=== added directory 'phone-app-connected-autopilot'
=== added file 'phone-app-connected-autopilot/master.run'
--- phone-app-connected-autopilot/master.run	1970-01-01 00:00:00 +0000
+++ phone-app-connected-autopilot/master.run	2013-08-29 18:33:39 +0000
@@ -0,0 +1,5 @@
+---
+testsuites:
+  - name: phone-app-connected-autopilot
+    fetch_method: dev
+    fetch_location: ./

=== added file 'phone-app-connected-autopilot/setup.sh'
--- phone-app-connected-autopilot/setup.sh	1970-01-01 00:00:00 +0000
+++ phone-app-connected-autopilot/setup.sh	2013-08-29 18:33:39 +0000
@@ -0,0 +1,36 @@
+#!/bin/sh
+
+set -ex
+
+# we have issues with running the test too soon, this is a hack:
+echo "SLEEPING 60 TO HELP MAKE SURE PHONE IS READY"
+sleep 60
+
+
+if [ -z $ANDROID_SERIAL ] ; then
+	# set up the config file for the test
+	NUMBER=$(./sms_self.py --list)
+	cat ./testnumbers.cfg | sed -e "s/TODO/+$NUMBER/" > /home/phablet/.testnumbers.cfg
+
+	# remove old logs so the receive test will work
+	rm /home/phablet/.local/share/TpLogger/logs/ofono_ofono_account0/* -rf
+
+	# now send an sms to ourself
+	./sms_self.py
+else
+	echo "test running from host"
+	adb push ./sms_self.py /home/phablet/autopilot/
+
+	# set up the config file for the test
+	NUMBER=$(adb-shell /home/phablet/autopilot/sms_self.py --list | head -n1)
+	cat ./testnumbers.cfg | sed -e "s/TODO/+$NUMBER/" > .testnumbers.cfg
+	adb push .testnumbers.cfg /home/phablet/.testnumbers.cfg
+	rm .testnumbers.cfg
+
+	# remove old logs so the receive test will work
+	adb-shell rm /home/phablet/.local/share/TpLogger/logs/ofono_ofono_account0/* -rf
+	adb-shell /home/phablet/autopilot/sms_self.py
+fi
+
+sleep 10s  # try and let the message come through
+PKGS="phone-app-connected-autopilot" prepare-autopilot-test.sh

=== added file 'phone-app-connected-autopilot/sms_self.py'
--- phone-app-connected-autopilot/sms_self.py	1970-01-01 00:00:00 +0000
+++ phone-app-connected-autopilot/sms_self.py	2013-08-29 18:33:39 +0000
@@ -0,0 +1,34 @@
+#!/usr/bin/env python
+
+import argparse
+import dbus
+
+
+def _get_parser():
+    parser = argparse.ArgumentParser(
+        description='Send an SMS message to yourself via the ofono API')
+    parser.add_argument('-m', '--modem', default='/ril_0',
+                        help='The modem to use. Default: %(default)s')
+    parser.add_argument('message', nargs='?', default='hello world',
+                        help='Message to send. Default "%(default)s"')
+    parser.add_argument('--list', action='store_true',
+                        help='Just print the number of this cell phone.')
+    return parser
+
+
+def _main(args):
+    bus = dbus.SystemBus()
+    obj = bus.get_object('org.ofono', args.modem)
+
+    mgr = dbus.Interface(obj, 'org.ofono.SimManager')
+    local_sms = str(mgr.GetProperties()['SubscriberNumbers'][0])
+
+    if args.list:
+        print local_sms
+    else:
+        mgr = dbus.Interface(obj, 'org.ofono.MessageManager')
+        mgr.SendMessage(local_sms, args.message)
+
+
+if __name__ == '__main__':
+    _main(_get_parser().parse_args())

=== added file 'phone-app-connected-autopilot/testnumbers.cfg'
--- phone-app-connected-autopilot/testnumbers.cfg	1970-01-01 00:00:00 +0000
+++ phone-app-connected-autopilot/testnumbers.cfg	2013-08-29 18:33:39 +0000
@@ -0,0 +1,23 @@
+[connected_variables]
+
+#number to dial
+dial_number = 77777
+
+#number to send sms to (doanac's google voice)
+sms_send_number = 4322350086
+
+#expected to receive sms from
+sms_receive_num = TODO
+
+#time (in seconds) allowed for the outgoing call
+outgoing_call_duration = 20
+
+#time (in seconds) to wait till the call is not received
+call_wait_time = 2
+
+#text to send in the sms
+sms_send_text = Hey there
+
+#expected text to be received in sms
+sms_expect_text = Ubuntu Rocks
+

=== added file 'phone-app-connected-autopilot/ts_control'
--- phone-app-connected-autopilot/ts_control	1970-01-01 00:00:00 +0000
+++ phone-app-connected-autopilot/ts_control	2013-08-29 18:33:39 +0000
@@ -0,0 +1,1 @@
+ts_setup: sh ./setup.sh

=== added file 'phone-app-connected-autopilot/tslist.auto'
--- phone-app-connected-autopilot/tslist.auto	1970-01-01 00:00:00 +0000
+++ phone-app-connected-autopilot/tslist.auto	2013-08-29 18:33:39 +0000
@@ -0,0 +1,4 @@
+-
+  discovery_cmd: autopilot-list connected_tests test_communication_panel
+  test_cmd: autopilot-run connected_tests.tests.{}
+

=== added directory 'share-app-autopilot'
=== added file 'share-app-autopilot/master.run'
--- share-app-autopilot/master.run	1970-01-01 00:00:00 +0000
+++ share-app-autopilot/master.run	2013-08-29 18:33:39 +0000
@@ -0,0 +1,15 @@
+---
+testsuites:
+  - name: settle-before
+    fetch_method: dev
+    fetch_location: ../systemsettle
+    include_tests:
+      - systemsettle-before
+  - name: share-app-autopilot
+    fetch_method: dev
+    fetch_location: ./
+  - name: settle-after
+    fetch_method: dev
+    fetch_location: ../systemsettle
+    include_tests:
+      - systemsettle-after

=== added file 'share-app-autopilot/ts_control'
--- share-app-autopilot/ts_control	1970-01-01 00:00:00 +0000
+++ share-app-autopilot/ts_control	2013-08-29 18:33:39 +0000
@@ -0,0 +1,1 @@
+ts_setup: PKGS=share-app-autopilot prepare-autopilot-test.sh

=== added file 'share-app-autopilot/tslist.auto'
--- share-app-autopilot/tslist.auto	1970-01-01 00:00:00 +0000
+++ share-app-autopilot/tslist.auto	2013-08-29 18:33:39 +0000
@@ -0,0 +1,4 @@
+-
+  discovery_cmd: autopilot-list share_app
+  test_cmd: autopilot-run share_app.tests.{}
+

=== added directory 'systemsettle'
=== added directory 'systemsettle/systemsettle-after'
=== added file 'systemsettle/systemsettle-after/tc_control'
--- systemsettle/systemsettle-after/tc_control	1970-01-01 00:00:00 +0000
+++ systemsettle/systemsettle-after/tc_control	2013-08-29 18:33:39 +0000
@@ -0,0 +1,9 @@
+description: check if system settles to idle average > 99.25%
+dependencies: none
+action: |
+  1. Take CPU load samples for 10s, do this up to 10 times until idle is over 99%
+expected_results: |
+  1. When doing nothing, system calms down to at least 99% idle level
+type: userland
+timeout: 120
+command: ../systemsettle.sh -c5 -d2 -p 97.5 -l _after

=== added directory 'systemsettle/systemsettle-before'
=== added file 'systemsettle/systemsettle-before/tc_control'
--- systemsettle/systemsettle-before/tc_control	1970-01-01 00:00:00 +0000
+++ systemsettle/systemsettle-before/tc_control	2013-08-29 18:33:39 +0000
@@ -0,0 +1,9 @@
+description: check if system settles to idle average > 99.25%
+dependencies: none
+action: |
+  1. Take CPU load samples for 10s, do this up to 10 times until idle is over 99%
+expected_results: |
+  1. When doing nothing, system calms down to at least 99% idle level
+type: userland
+timeout: 120
+command: ../systemsettle.sh -c5 -d2 -p 97.5 -l _before

=== added file 'systemsettle/systemsettle.sh'
--- systemsettle/systemsettle.sh	1970-01-01 00:00:00 +0000
+++ systemsettle/systemsettle.sh	2013-08-29 18:33:39 +0000
@@ -0,0 +1,119 @@
+#!/bin/bash
+
+# Configuration variables:
+#  TARGET_PREFIX - Allows this to be run from the host, by providings something
+#                  like TARGET_PREFIX="adb shell"
+#  UTAH_PROBE_DIR - optionally where to save log files so utah will grab them
+
+set -e
+
+[ -z $UTAH_PROBE_DIR ] && UTAH_PROBE_DIR="/tmp"
+
+# default exit code storage
+dump_error=1
+
+calc () { awk "BEGIN{ print $* }" ;}
+
+function show_usage() {
+   echo "Usage:"
+   echo " $0 [options]"
+   echo "Options:"
+   echo " -r  run forever without exiting"
+   echo " -p  minimum idle percent to wait for (Default: 99)"
+   echo " -c  number of times to run top at each iteration (Default: 10)"
+   echo " -d  seconds to delay between each top iteration (Default: 6)"
+   echo " -i  top measurements to ignore from each loop (Default: 1)"
+   echo " -m  maximum loops of top before giving up if minimum idle"
+   echo "     percent is not reached (Default: 10)"
+   echo " -l  label to include for the top_log file"
+   exit 129
+}
+
+while getopts "h?rp:c:d:i:m:l:" opt; do
+    case "$opt" in
+        h|\?) show_usage
+              ;;
+        r)    settle_prefix='-'
+              ;;
+        p)    idle_avg_min=$OPTARG
+              ;;
+        c)    top_repeat=$OPTARG
+              ;;
+        d)    top_wait=$OPTARG
+              ;;
+        i)    top_ignore=$OPTARG
+              ;;
+        m)    settle_max=$OPTARG
+              ;;
+        l)    top_log_label=$OPTARG
+              ;;
+    esac
+done
+
+# minimum average idle level required to succeed
+idle_avg_min=${idle_avg_min:-99}
+# measurement details: top $top_wait $top_repeat
+top_repeat=${top_repeat:-10}
+top_wait=${top_wait:-6}
+# how many samples to ignore
+top_ignore=${top_ignore:-1}
+# how many total attempts to settle the system
+settle_max=${settle_max:-10}
+
+top_log="$UTAH_PROBE_DIR/top$top_log_label.log"
+
+# set and calc more runtime values
+top_tail=`calc $top_repeat - $top_ignore`
+settle_count=0
+idle_avg=0
+
+echo "System Settle run - quiesce the system"
+echo "--------------------------------------"
+echo
+echo "  idle_avg_min   = '$idle_avg_min'"
+echo "  top_repeat  = '$top_repeat'"
+echo "  top_wait    = '$top_wait'"
+echo "  top_ignore  = '$top_ignore'"
+echo "  settle_max     = '$settle_max'"
+echo "  run_forever    = '$settle_prefix' (- = yes)"
+echo "  log files   = $top_log $top_log.reduced"
+echo
+
+while test `calc $idle_avg '<' $idle_avg_min` = 1 -a "$settle_prefix$settle_count" -lt "$settle_max"; do
+  echo -n "Starting system idle measurement (run: $settle_count) ... "
+
+  # get top
+  echo "TOP DUMP (after settle run: $settle_count)" >> $top_log
+  echo "========================" >> $top_log
+  ${TARGET_PREFIX} top -b -d $top_wait -n $top_repeat >> $top_log
+  cat $top_log | grep '.Cpu.*' | tail -n $top_tail > $top_log.reduced
+  echo >> $top_log
+
+  # calc average of idle field for this measurement
+  sum=0
+  count=0
+  while read line; do
+     idle=`echo $line | sed -e 's/.* \([0-9\.]*\) id.*/\1/'`
+     sum=`calc $sum + $idle`
+     count=`calc $count + 1`
+  done < $top_log.reduced
+
+  idle_avg=`calc $sum / $count`
+  settle_count=`calc $settle_count + 1`
+
+  echo " DONE."
+  echo
+  echo "Measurement:"
+  echo "  + idle level: $idle_avg"
+  echo "  + idle sum: $sum / count: $count"
+  echo
+done
+
+if test `calc $idle_avg '<' $idle_avg_min` = 1; then
+  echo "system not settled. FAIL"
+  exit 1
+else
+  echo "system settled. SUCCESS"
+  exit 0
+fi
+

=== added file 'systemsettle/tslist.run'
--- systemsettle/tslist.run	1970-01-01 00:00:00 +0000
+++ systemsettle/tslist.run	2013-08-29 18:33:39 +0000
@@ -0,0 +1,2 @@
+- test: systemsettle-before
+- test: systemsettle-after

=== added directory 'ubuntu-calculator-app-autopilot'
=== added file 'ubuntu-calculator-app-autopilot/master.run'
--- ubuntu-calculator-app-autopilot/master.run	1970-01-01 00:00:00 +0000
+++ ubuntu-calculator-app-autopilot/master.run	2013-08-29 18:33:39 +0000
@@ -0,0 +1,15 @@
+---
+testsuites:
+  - name: settle-before
+    fetch_method: dev
+    fetch_location: ../systemsettle
+    include_tests:
+      - systemsettle-before
+  - name: ubuntu-calculator-app-autopilot
+    fetch_method: dev
+    fetch_location: ./
+  - name: settle-after
+    fetch_method: dev
+    fetch_location: ../systemsettle
+    include_tests:
+      - systemsettle-after

=== added file 'ubuntu-calculator-app-autopilot/ts_control'
--- ubuntu-calculator-app-autopilot/ts_control	1970-01-01 00:00:00 +0000
+++ ubuntu-calculator-app-autopilot/ts_control	2013-08-29 18:33:39 +0000
@@ -0,0 +1,1 @@
+ts_setup: PKGS=ubuntu-calculator-app-autopilot prepare-autopilot-test.sh

=== added file 'ubuntu-calculator-app-autopilot/tslist.auto'
--- ubuntu-calculator-app-autopilot/tslist.auto	1970-01-01 00:00:00 +0000
+++ ubuntu-calculator-app-autopilot/tslist.auto	2013-08-29 18:33:39 +0000
@@ -0,0 +1,4 @@
+-
+  discovery_cmd: autopilot-list ubuntu_calculator_app
+  test_cmd: autopilot-run ubuntu_calculator_app.tests.{}
+

=== added directory 'ubuntu-clock-app-autopilot'
=== added file 'ubuntu-clock-app-autopilot/master.run'
--- ubuntu-clock-app-autopilot/master.run	1970-01-01 00:00:00 +0000
+++ ubuntu-clock-app-autopilot/master.run	2013-08-29 18:33:39 +0000
@@ -0,0 +1,15 @@
+---
+testsuites:
+  - name: settle-before
+    fetch_method: dev
+    fetch_location: ../systemsettle
+    include_tests:
+      - systemsettle-before
+  - name: ubuntu-clock-app-autopilot
+    fetch_method: dev
+    fetch_location: ./
+  - name: settle-after
+    fetch_method: dev
+    fetch_location: ../systemsettle
+    include_tests:
+      - systemsettle-after

=== added file 'ubuntu-clock-app-autopilot/ts_control'
--- ubuntu-clock-app-autopilot/ts_control	1970-01-01 00:00:00 +0000
+++ ubuntu-clock-app-autopilot/ts_control	2013-08-29 18:33:39 +0000
@@ -0,0 +1,1 @@
+ts_setup: PKGS=ubuntu-clock-app-autopilot prepare-autopilot-test.sh

=== added file 'ubuntu-clock-app-autopilot/tslist.auto'
--- ubuntu-clock-app-autopilot/tslist.auto	1970-01-01 00:00:00 +0000
+++ ubuntu-clock-app-autopilot/tslist.auto	2013-08-29 18:33:39 +0000
@@ -0,0 +1,4 @@
+-
+  discovery_cmd: autopilot-list ubuntu_clock_app
+  test_cmd: autopilot-run ubuntu_clock_app.tests.{}
+

=== added directory 'ubuntu-docviewer-app-autopilot'
=== added file 'ubuntu-docviewer-app-autopilot/master.run'
--- ubuntu-docviewer-app-autopilot/master.run	1970-01-01 00:00:00 +0000
+++ ubuntu-docviewer-app-autopilot/master.run	2013-08-29 18:33:39 +0000
@@ -0,0 +1,15 @@
+---
+testsuites:
+  - name: settle-before
+    fetch_method: dev
+    fetch_location: ../systemsettle
+    include_tests:
+      - systemsettle-before
+  - name: ubuntu-docviewer-app-autopilot
+    fetch_method: dev
+    fetch_location: ./
+  - name: settle-after
+    fetch_method: dev
+    fetch_location: ../systemsettle
+    include_tests:
+      - systemsettle-after

=== added file 'ubuntu-docviewer-app-autopilot/ts_control'
--- ubuntu-docviewer-app-autopilot/ts_control	1970-01-01 00:00:00 +0000
+++ ubuntu-docviewer-app-autopilot/ts_control	2013-08-29 18:33:39 +0000
@@ -0,0 +1,1 @@
+ts_setup: PKGS=ubuntu-docviewer-app-autopilot prepare-autopilot-test.sh

=== added file 'ubuntu-docviewer-app-autopilot/tslist.auto'
--- ubuntu-docviewer-app-autopilot/tslist.auto	1970-01-01 00:00:00 +0000
+++ ubuntu-docviewer-app-autopilot/tslist.auto	2013-08-29 18:33:39 +0000
@@ -0,0 +1,4 @@
+-
+  discovery_cmd: autopilot-list ubuntu_docviewer_app
+  test_cmd: autopilot-run ubuntu_docviewer_app.tests.{}
+

=== added directory 'ubuntu-filemanager-app-autopilot'
=== added file 'ubuntu-filemanager-app-autopilot/master.run'
--- ubuntu-filemanager-app-autopilot/master.run	1970-01-01 00:00:00 +0000
+++ ubuntu-filemanager-app-autopilot/master.run	2013-08-29 18:33:39 +0000
@@ -0,0 +1,15 @@
+---
+testsuites:
+  - name: settle-before
+    fetch_method: dev
+    fetch_location: ../systemsettle
+    include_tests:
+      - systemsettle-before
+  - name: ubuntu-filemanager-app-autopilot
+    fetch_method: dev
+    fetch_location: ./
+  - name: settle-after
+    fetch_method: dev
+    fetch_location: ../systemsettle
+    include_tests:
+      - systemsettle-after

=== added file 'ubuntu-filemanager-app-autopilot/ts_control'
--- ubuntu-filemanager-app-autopilot/ts_control	1970-01-01 00:00:00 +0000
+++ ubuntu-filemanager-app-autopilot/ts_control	2013-08-29 18:33:39 +0000
@@ -0,0 +1,1 @@
+ts_setup: PKGS=ubuntu-filemanager-app-autopilot prepare-autopilot-test.sh

=== added file 'ubuntu-filemanager-app-autopilot/tslist.auto'
--- ubuntu-filemanager-app-autopilot/tslist.auto	1970-01-01 00:00:00 +0000
+++ ubuntu-filemanager-app-autopilot/tslist.auto	2013-08-29 18:33:39 +0000
@@ -0,0 +1,4 @@
+-
+  discovery_cmd: autopilot-list ubuntu_filemanager_app
+  test_cmd: autopilot-run ubuntu_filemanager_app.tests.{}
+

=== added directory 'ubuntu-rssreader-app-autopilot'
=== added file 'ubuntu-rssreader-app-autopilot/master.run'
--- ubuntu-rssreader-app-autopilot/master.run	1970-01-01 00:00:00 +0000
+++ ubuntu-rssreader-app-autopilot/master.run	2013-08-29 18:33:39 +0000
@@ -0,0 +1,15 @@
+---
+testsuites:
+  - name: settle-before
+    fetch_method: dev
+    fetch_location: ../systemsettle
+    include_tests:
+      - systemsettle-before
+  - name: ubuntu-rssreader-app-autopilot
+    fetch_method: dev
+    fetch_location: ./
+  - name: settle-after
+    fetch_method: dev
+    fetch_location: ../systemsettle
+    include_tests:
+      - systemsettle-after

=== added file 'ubuntu-rssreader-app-autopilot/ts_control'
--- ubuntu-rssreader-app-autopilot/ts_control	1970-01-01 00:00:00 +0000
+++ ubuntu-rssreader-app-autopilot/ts_control	2013-08-29 18:33:39 +0000
@@ -0,0 +1,1 @@
+ts_setup: PKGS=ubuntu-rssreader-app-autopilot prepare-autopilot-test.sh

=== added file 'ubuntu-rssreader-app-autopilot/tslist.auto'
--- ubuntu-rssreader-app-autopilot/tslist.auto	1970-01-01 00:00:00 +0000
+++ ubuntu-rssreader-app-autopilot/tslist.auto	2013-08-29 18:33:39 +0000
@@ -0,0 +1,4 @@
+-
+  discovery_cmd: autopilot-list ubuntu_rssreader_app
+  test_cmd: autopilot-run ubuntu_rssreader_app.tests.{}
+

=== added directory 'ubuntu-terminal-app-autopilot'
=== added file 'ubuntu-terminal-app-autopilot/master.run'
--- ubuntu-terminal-app-autopilot/master.run	1970-01-01 00:00:00 +0000
+++ ubuntu-terminal-app-autopilot/master.run	2013-08-29 18:33:39 +0000
@@ -0,0 +1,15 @@
+---
+testsuites:
+  - name: settle-before
+    fetch_method: dev
+    fetch_location: ../systemsettle
+    include_tests:
+      - systemsettle-before
+  - name: ubuntu-terminal-app-autopilot
+    fetch_method: dev
+    fetch_location: ./
+  - name: settle-after
+    fetch_method: dev
+    fetch_location: ../systemsettle
+    include_tests:
+      - systemsettle-after

=== added file 'ubuntu-terminal-app-autopilot/ts_control'
--- ubuntu-terminal-app-autopilot/ts_control	1970-01-01 00:00:00 +0000
+++ ubuntu-terminal-app-autopilot/ts_control	2013-08-29 18:33:39 +0000
@@ -0,0 +1,1 @@
+ts_setup: PKGS=ubuntu-terminal-app-autopilot prepare-autopilot-test.sh

=== added file 'ubuntu-terminal-app-autopilot/tslist.auto'
--- ubuntu-terminal-app-autopilot/tslist.auto	1970-01-01 00:00:00 +0000
+++ ubuntu-terminal-app-autopilot/tslist.auto	2013-08-29 18:33:39 +0000
@@ -0,0 +1,4 @@
+-
+  discovery_cmd: autopilot-list ubuntu_terminal_app
+  test_cmd: autopilot-run ubuntu_terminal_app.tests.{}
+

=== added directory 'ubuntu-weather-app-autopilot'
=== added file 'ubuntu-weather-app-autopilot/master.run'
--- ubuntu-weather-app-autopilot/master.run	1970-01-01 00:00:00 +0000
+++ ubuntu-weather-app-autopilot/master.run	2013-08-29 18:33:39 +0000
@@ -0,0 +1,15 @@
+---
+testsuites:
+  - name: settle-before
+    fetch_method: dev
+    fetch_location: ../systemsettle
+    include_tests:
+      - systemsettle-before
+  - name: ubuntu-weather-app-autopilot
+    fetch_method: dev
+    fetch_location: ./
+  - name: settle-after
+    fetch_method: dev
+    fetch_location: ../systemsettle
+    include_tests:
+      - systemsettle-after

=== added file 'ubuntu-weather-app-autopilot/ts_control'
--- ubuntu-weather-app-autopilot/ts_control	1970-01-01 00:00:00 +0000
+++ ubuntu-weather-app-autopilot/ts_control	2013-08-29 18:33:39 +0000
@@ -0,0 +1,1 @@
+ts_setup: PKGS=ubuntu-weather-app-autopilot prepare-autopilot-test.sh

=== added file 'ubuntu-weather-app-autopilot/tslist.auto'
--- ubuntu-weather-app-autopilot/tslist.auto	1970-01-01 00:00:00 +0000
+++ ubuntu-weather-app-autopilot/tslist.auto	2013-08-29 18:33:39 +0000
@@ -0,0 +1,4 @@
+-
+  discovery_cmd: autopilot-list ubuntu_weather_app
+  test_cmd: autopilot-run ubuntu_weather_app.tests.{}
+

=== added directory 'unity8-autopilot'
=== added file 'unity8-autopilot/master.run'
--- unity8-autopilot/master.run	1970-01-01 00:00:00 +0000
+++ unity8-autopilot/master.run	2013-08-29 18:33:39 +0000
@@ -0,0 +1,15 @@
+---
+testsuites:
+  - name: settle-before
+    fetch_method: dev
+    fetch_location: ../systemsettle
+    include_tests:
+      - systemsettle-before
+  - name: unity8-autopilot
+    fetch_method: dev
+    fetch_location: ./
+  - name: settle-after
+    fetch_method: dev
+    fetch_location: ../systemsettle
+    include_tests:
+      - systemsettle-after

=== added file 'unity8-autopilot/setup.sh'
--- unity8-autopilot/setup.sh	1970-01-01 00:00:00 +0000
+++ unity8-autopilot/setup.sh	2013-08-29 18:33:39 +0000
@@ -0,0 +1,6 @@
+#!/bin/sh
+
+set -e
+
+NO_UNLOCK=1 PKGS="unity8-autopilot" prepare-autopilot-test.sh
+$TARGET_PREFIX sudo -i -u phablet stop unity8

=== added file 'unity8-autopilot/ts_control'
--- unity8-autopilot/ts_control	1970-01-01 00:00:00 +0000
+++ unity8-autopilot/ts_control	2013-08-29 18:33:39 +0000
@@ -0,0 +1,2 @@
+ts_setup: TARGET_PREFIX=$TARGET_PREFIX ./setup.sh
+ts_cleanup: $TARGET_PREFIX sudo -i -u phablet start unity8

=== added file 'unity8-autopilot/tslist.auto'
--- unity8-autopilot/tslist.auto	1970-01-01 00:00:00 +0000
+++ unity8-autopilot/tslist.auto	2013-08-29 18:33:39 +0000
@@ -0,0 +1,4 @@
+-
+  discovery_cmd: autopilot-list unity8 unity8 unity8.
+  test_cmd: autopilot-run unity8.{}
+

=== added directory 'upgrade'
=== added file 'upgrade/README'
--- upgrade/README	1970-01-01 00:00:00 +0000
+++ upgrade/README	2013-08-29 18:33:39 +0000
@@ -0,0 +1,3 @@
+NOTE: This test is intended to be run by UTAH using the "--from-host"
+method. This is different from other tests in this repository and should
+not be run with jenkins.sh

=== added directory 'upgrade/install_old'
=== added file 'upgrade/install_old/run.sh'
--- upgrade/install_old/run.sh	1970-01-01 00:00:00 +0000
+++ upgrade/install_old/run.sh	2013-08-29 18:33:39 +0000
@@ -0,0 +1,27 @@
+#!/bin/bash
+
+## Puts an older build on the device
+## Intersting environment variables that must be set:
+##  ANDROID_SERIAL - specify another android device
+##  NETWORK_FILE - specify an alternative network file
+##  UPGRADE_FROM - the revision to upgrade from, eg -1
+
+set -eux
+
+BASEDIR=$(dirname $(readlink -f $0))
+
+RESDIR=`pwd`/clientlogs
+
+UTAH_PHABLET_CMD="${UTAH_PHABLET_CMD-/usr/share/utah/examples/run_utah_phablet.py}"
+ANDROID_SERIAL="${ANDROID_SERIAL-015d1884b20c1c0f}"  #doanac's nexus7 at home
+NETWORK_FILE="${NETWORK_FILE-/home/ubuntu/magners-wifi}"
+UPGRADE_FROM="${UPGRADE_FROM--1}"
+CLIENT_LOGS="${CLIENT_LOGS-/tmp}"
+
+echo "INSTALLING OLD BUILD..."
+$UTAH_PHABLET_CMD -s $ANDROID_SERIAL \
+	--ubuntu-bootstrap -r $UPGRADE_FROM \
+	--network-file $NETWORK_FILE \
+	--skip-utah \
+	--pull /var/crash \
+	--results-dir=${CLIENT_LOGS}

=== added file 'upgrade/install_old/tc_control'
--- upgrade/install_old/tc_control	1970-01-01 00:00:00 +0000
+++ upgrade/install_old/tc_control	2013-08-29 18:33:39 +0000
@@ -0,0 +1,9 @@
+description: sets up a previous days build on the target
+dependencies: n/a
+action: |
+  1. install an older system image
+expected_results: |
+  1. an older system image will be installed
+type: userland
+timeout: 1800
+command: ./run.sh

=== added file 'upgrade/master.run'
--- upgrade/master.run	1970-01-01 00:00:00 +0000
+++ upgrade/master.run	2013-08-29 18:33:39 +0000
@@ -0,0 +1,5 @@
+---
+testsuites:
+  - name: upgrade
+    fetch_method: dev
+    fetch_location: ./

=== added file 'upgrade/tslist.run'
--- upgrade/tslist.run	1970-01-01 00:00:00 +0000
+++ upgrade/tslist.run	2013-08-29 18:33:39 +0000
@@ -0,0 +1,2 @@
+- test: install_old
+- test: upgrade

=== added directory 'upgrade/upgrade'
=== added file 'upgrade/upgrade/tc_control'
--- upgrade/upgrade/tc_control	1970-01-01 00:00:00 +0000
+++ upgrade/upgrade/tc_control	2013-08-29 18:33:39 +0000
@@ -0,0 +1,9 @@
+description: performs an upgrade using system-image-cli
+dependencies: a touch read-only image
+action: |
+  1. execute upgrade
+expected_results: |
+  1. it will reboot into recovery, upgrade, and boot up
+type: userland
+timeout: 1800
+command: ./upgrade.sh

=== added file 'upgrade/upgrade/upgrade.sh'
--- upgrade/upgrade/upgrade.sh	1970-01-01 00:00:00 +0000
+++ upgrade/upgrade/upgrade.sh	2013-08-29 18:33:39 +0000
@@ -0,0 +1,79 @@
+#!/bin/sh
+
+## upgrades the given target
+## Intersting environment variables that must be set:
+##  ANDROID_SERIAL - specify another android device
+ANDROID_SERIAL="${ANDROID_SERIAL-015d1884b20c1c0f}"  #doanac's nexus7 at home
+
+set -eux
+
+export ANDROID_SERIAL=$ANDROID_SERIAL
+
+phablet_reboot_wait() {
+	# TODO get this into phablet-tools
+	adb reboot
+	adb shell stop android-tools-adbd 2>/dev/null || true
+	adb wait-for-device
+	# sometimes wait-for-device comes back too quick, so wait once more
+	sleep 4s
+	adb wait-for-device
+}
+
+# try and get the system up with an actual wlan0
+phablet_get_interface() {
+	if ! adb shell ifconfig -a | grep wlan0 >/dev/null ; then
+		return 1
+	fi
+}
+
+# try and try and try to get an IP
+# network is flaky, this seems to help:
+phablet_get_ip() {
+	adb shell nmcli c list
+	uuid=$(adb shell nmcli c list | grep 802-11-wireless | tail -n1 | grep -o -E "[a-f0-9]{8}-([a-f0-9]{4}-){3}[a-f0-9]{12}")
+	tmp=$(mktemp)
+	adb shell sh -c "nmcli c up uuid $uuid ; echo ANDROID_RC=$?" | tee $tmp
+	rc=1
+	if grep "ANDROID_RC=0" $tmp >/dev/null; then
+		rc=0
+	fi
+	rm $tmp
+	return $rc
+}
+
+retry() {
+	cmd=$1
+	retries=$2
+
+	for i in $(seq $retries) ; do
+		if $cmd ; then
+			return 0
+		fi
+		times=$(($retries - $i))
+		if [ $times -ne 0 ] ; then
+			echo "$cmd: failed, retrying $(($retries - $i)) more times"
+			[ -z $reboot ] || phablet_reboot_wait
+			sleep 60
+		else
+			echo "$cmd: failed after $retries attempts"
+		fi
+	done
+	return 1
+}
+
+orig_version=$(adb shell system-image-cli -b)
+echo $orig_version | sed -e 's/build number/UPGRADING FROM VERSION/'
+
+reboot=1 retry phablet_get_interface 4
+sleep 60
+retry phablet_get_ip 4
+
+adb shell system-image-cli -v
+adb wait-for-device
+new_version=$(adb shell system-image-cli -b)
+echo $new_version | sed -e 's/build number/UPGRADED TO VERSION/'
+
+if [ "$new_version" = "$orig_version" ] ; then
+	echo "UPGRADE FAILED"
+	exit 1
+fi

=== added directory 'utils'
=== added directory 'utils/host'
=== added file 'utils/host/adb-shell'
--- utils/host/adb-shell	1970-01-01 00:00:00 +0000
+++ utils/host/adb-shell	2013-08-29 18:33:39 +0000
@@ -0,0 +1,20 @@
+#!/bin/bash
+
+# The "adb shell" command doesn't return an error if the command you execute
+# resulted in an error. This is a wrapper to return the command's true return code.
+
+# NOTE: This script uses some specific bash'isms to keep things short and simple
+
+set -eu
+
+pat='ADB_RC=([[:digit:]]+)'
+
+{
+	adb -s $ANDROID_SERIAL shell "$* ; echo ADB_RC=\$?"
+} | while read line; do
+	echo $line
+	if [[ $line =~ $pat ]] ; then
+		rc=${BASH_REMATCH[1]}
+		exit $rc
+	fi
+done

=== added file 'utils/host/autopilot-list'
--- utils/host/autopilot-list	1970-01-01 00:00:00 +0000
+++ utils/host/autopilot-list	2013-08-29 18:33:39 +0000
@@ -0,0 +1,18 @@
+#!/bin/sh
+
+set -e
+
+app=$1
+pat=$app
+rep=$app.tests.
+
+if [ -z "$app" ] ; then
+	echo "USAGE: $0 <app> [pattern] [replace]"
+	exit 1
+fi
+[ -z "$2" ] || pat=$2
+[ -z "$3" ] || rep=$3
+
+#NOTE we just use adb shell here, because we don't have to catch errors. the greps
+# will work around that
+adb shell sudo -i -u phablet bash -ic \"PYTHONPATH=/home/phablet/autopilot autopilot list $app\" | grep $pat | sed -e "s/^.*${rep}//"

=== added file 'utils/host/autopilot-run'
--- utils/host/autopilot-run	1970-01-01 00:00:00 +0000
+++ utils/host/autopilot-run	2013-08-29 18:33:39 +0000
@@ -0,0 +1,3 @@
+#!/bin/sh
+
+adb-shell sudo -i -u phablet bash -ic \"PYTHONPATH=/home/phablet/autopilot autopilot run -v $*\"

=== added file 'utils/host/prepare-autopilot-test.sh'
--- utils/host/prepare-autopilot-test.sh	1970-01-01 00:00:00 +0000
+++ utils/host/prepare-autopilot-test.sh	2013-08-29 18:33:39 +0000
@@ -0,0 +1,5 @@
+#!/bin/sh
+
+set -e
+
+adb-shell PKGS=\"$PKGS\" prepare-autopilot-test.sh

=== added directory 'utils/target'
=== added file 'utils/target/autopilot-list'
--- utils/target/autopilot-list	1970-01-01 00:00:00 +0000
+++ utils/target/autopilot-list	2013-08-29 18:33:39 +0000
@@ -0,0 +1,13 @@
+#!/bin/sh
+
+app=$1
+pat=${2:-$app}
+rep=${3:-$app.tests.}
+
+if [ -z "$app" ] ; then
+	echo "USAGE: $0 <app> [pattern] [replace]"
+	exit 1
+fi
+
+curdir=$(pwd)
+sudo -i -u phablet bash -ic "PYTHONPATH=$curdir autopilot list $app" | grep $pat | sed -e "s/^.*${rep}//"

=== added file 'utils/target/autopilot-run'
--- utils/target/autopilot-run	1970-01-01 00:00:00 +0000
+++ utils/target/autopilot-run	2013-08-29 18:33:39 +0000
@@ -0,0 +1,4 @@
+#!/bin/sh
+
+curdir=$(pwd)
+sudo -i -u phablet bash -ic "PYTHONPATH=$curdir autopilot run -v $*"

=== added file 'utils/target/prepare-autopilot-test.sh'
--- utils/target/prepare-autopilot-test.sh	1970-01-01 00:00:00 +0000
+++ utils/target/prepare-autopilot-test.sh	2013-08-29 18:33:39 +0000
@@ -0,0 +1,17 @@
+#!/bin/sh
+
+set -e
+
+#installs dependencies and unlocks screen so an autopilot test case can run
+
+if [ -n "$PKGS" ] ; then
+	MISSING=0
+	dpkg -s $PKGS 2>/dev/null >/dev/null || MISSING=1
+	if [ $MISSING -eq 1 ] ; then
+		apt-get install -yq --force-yes $PKGS
+	else
+		echo "setup not needed"
+	fi
+fi
+[ -z $NO_UNLOCK ] && unlock_screen.sh
+exit 0

=== added file 'utils/target/unlock_screen.py'
--- utils/target/unlock_screen.py	1970-01-01 00:00:00 +0000
+++ utils/target/unlock_screen.py	2013-08-29 18:33:39 +0000
@@ -0,0 +1,87 @@
+#!/usr/bin/env python
+
+from autopilot import introspection
+from autopilot.display import Display
+from autopilot.input import Pointer, Touch
+import os
+import sys
+
+
+def help():
+    print "Usage:"
+    print "Run the script without any argument to unlock with assertion"
+    print ""
+    print "option -q:"
+    print "Execute with parameter -q to unlock the screen quickly without introspection"
+
+
+def start_unity_in_testability():
+    override_file = "~/.config/upstart/unity8.override"
+
+    os.system('echo "exec unity8 -testability" > ~/.config/upstart/unity8.override')
+
+    print "----------------------------------------------------------------------"
+    print "Stopping Unity"
+    os.system('/sbin/stop unity8')
+    print "Unity stopped"
+
+    print "----------------------------------------------------------------------"
+    print "Starting Unity with testability"
+    os.system('/sbin/start unity8')
+    print "Unity started"
+
+    print "----------------------------------------------------------------------"
+    if os.path.exists(override_file):
+        os.remove(override_file)
+    print "Cleaned up upstart override"
+    print "----------------------------------------------------------------------"
+
+    print "Turning on the screen"
+    print ""
+
+
+def unlock_screen():
+    input_device = Touch.create()
+    pointing_device = Pointer(input_device)
+    conn = "com.canonical.Shell.BottomBarVisibilityCommunicator"
+    unity8 = introspection.get_proxy_object_for_existing_process(connection_name=conn)
+    greeter = unity8.select_single("Greeter")
+    x, y, w, h = greeter.globalRect
+    tx = x + w
+    ty = y + (h / 2)
+
+    pointing_device.drag(tx, ty, tx / 2, ty)
+    try:
+        greeter.shown.wait_for(False)
+    except AssertionError:
+        print "----------------------------------------------------------------------"
+        print "THE SCREEN DIDN'T UNLOCK THE FIRST TRY, NOW ATTEMPTING A BLIND SWIPE"
+        unlock_screen_blind(greeter)
+
+
+def unlock_screen_blind(greeter=None):
+    input_device = Touch.create()
+    pointing_device = Pointer(input_device)
+    x, y, w, h = Display.create(preferred_backend='UPA').get_screen_geometry(0)
+    tx = x + w
+    ty = y + (h / 2)
+
+    pointing_device.drag(tx, ty, tx / 2, ty)
+    if greeter is not None:
+        try:
+            greeter.shown.wait_for(False)
+            if greeter.shown is False:
+                print ""
+                print "THE SCREEN IS NOW UNLOCKED"
+        except AssertionError:
+            print "----------------------------------------------------------------------"
+            "THE SCREEN DIDN'T UNLOCK, RESTART THE DEVICE AND RUN THE SCRIPT AGAIN"
+
+
+if len(sys.argv) >= 2 and sys.argv[1] == '-q':
+    unlock_screen_blind()
+elif len(sys.argv) >= 2 and sys.argv[1] == '-h':
+    help()
+else:
+    start_unity_in_testability()
+    unlock_screen()

=== added file 'utils/target/unlock_screen.sh'
--- utils/target/unlock_screen.sh	1970-01-01 00:00:00 +0000
+++ utils/target/unlock_screen.sh	2013-08-29 18:33:39 +0000
@@ -0,0 +1,7 @@
+#!/bin/sh
+
+basedir=$(dirname $(readlink -f $0))
+
+#temporary workaround for bug #1207386
+chmod 666 /dev/uinput
+sudo -i -u phablet bash -ic "PYTHONPATH=$(pwd) ${basedir}/unlock_screen.py"

=== added directory 'webbrowser-app-autopilot'
=== added file 'webbrowser-app-autopilot/master.run'
--- webbrowser-app-autopilot/master.run	1970-01-01 00:00:00 +0000
+++ webbrowser-app-autopilot/master.run	2013-08-29 18:33:39 +0000
@@ -0,0 +1,15 @@
+---
+testsuites:
+  - name: settle-before
+    fetch_method: dev
+    fetch_location: ../systemsettle
+    include_tests:
+      - systemsettle-before
+  - name: webbrowser-app-autopilot
+    fetch_method: dev
+    fetch_location: ./
+  - name: settle-after
+    fetch_method: dev
+    fetch_location: ../systemsettle
+    include_tests:
+      - systemsettle-after

=== added file 'webbrowser-app-autopilot/ts_control'
--- webbrowser-app-autopilot/ts_control	1970-01-01 00:00:00 +0000
+++ webbrowser-app-autopilot/ts_control	2013-08-29 18:33:39 +0000
@@ -0,0 +1,1 @@
+ts_setup: PKGS=webbrowser-app-autopilot prepare-autopilot-test.sh

=== added file 'webbrowser-app-autopilot/tslist.auto'
--- webbrowser-app-autopilot/tslist.auto	1970-01-01 00:00:00 +0000
+++ webbrowser-app-autopilot/tslist.auto	2013-08-29 18:33:39 +0000
@@ -0,0 +1,4 @@
+-
+  discovery_cmd: autopilot-list webbrowser_app
+  test_cmd: autopilot-run webbrowser_app.tests.{}
+