Merge lp:~achiang/ubuntu-test-cases/savilerow into lp:ubuntu-test-cases

[Alex Chiang]

We have fixed a long-standing typo in the savilerow project (was sevilerow).

Pull tests from the proper source branch.

=== added file 'README-cli.rst'
--- README-cli.rst	1970-01-01 00:00:00 +0000
+++ README-cli.rst	2014-01-15 20:49:07 +0000
@@ -0,0 +1,76 @@
+Touch Testing From the CLI
+==========================
+
+The touch testing execution framework was written so that its very easy to
+run tests from home in the exact same way test are run in the lab. The only
+thigs you need are:
+
+ * This bzr branch
+ * The phablet-tools_ package
+ * An Ubuntu Touch supported_ device
+
+.. _phablet-tools: http://launchpad.net/phablet-tools
+.. _supported: http://wiki.ubuntu.com/Touch/Devices
+
+There are two pieces to touch testing, provisioning and test execution. These
+functions are independent of one another. eg, If your device already
+has the proper image/configuration, you can simply use the test-runner.
+
+Provisioning
+------------
+
+The provisioning script is a simple wrapper to commands from phablet-tools
+to get a device ready for testing. Provisioning is performed with the
+scripts/provision.sh command. Running::
+
+  ./scripts/provision.sh -h
+
+will list supported options.
+
+Executing Tests
+---------------
+
+The touch testing repository supports both autopilot and UTAH test definitions.
+
+Executing Autopilot Tests
+~~~~~~~~~~~~~~~~~~~~~~~~~
+
+One or more autopilot tests can be run on the target device using the command::
+
+  ./scripts/run-autopilot-tests.sh
+
+This is a small wrapper that uses phablet-tools to drive the tests. The
+script can run one or more autopilot tests. By default it will reboot the
+device between each test and ensure the device is settled using the
+*system-settle* script. Both of those options can be disabled via command
+line options. By default the script will create a directory named
+*clientlogs* and then a subdirectory for each testsuite with result files.
+These sub-directories include a xUnit XML formatted file, *test_results.xml*,
+as well as several log files from the device to help with debugging failures.
+
+An example testing two applications::
+
+ ./scripts/run-autopilot-tests.sh -a dropping_letters_app -a music_app
+
+Executing UTAH Tests
+~~~~~~~~~~~~~~~~~~~~
+
+Executing UTAH tests locally will require you to install the UTAH client
+package from a PPA::
+
+  sudo add-apt-repository ppa:utah/stable
+  sudo apt-get update
+  sudo apt-get install utah-client
+
+With that package installed UTAH tests can be run with::
+
+  ./scripts/jenkins.sh
+
+This script runs one test at a time and will put its test artifacts under the
+*clientlogs* directory similar to the autopilot runner. The UTAH result file
+will be named clientlogs/utah.yaml.
+
+An example of running the sdk test suite::
+
+  ./scripts/jenkins.sh -a sdk
+

=== added directory 'jenkins'
=== added file 'jenkins/production.py'
--- jenkins/production.py	1970-01-01 00:00:00 +0000
+++ jenkins/production.py	2014-01-15 20:49:07 +0000
@@ -0,0 +1,77 @@
+# The configuration matrix of our production device testing
+
+JENKINS = 'http://q-jenkins:8080'
+
+
+def _url(channel, device):
+    return 'http://system-image.ubuntu.com/%s/%s/index.json' \
+           % (channel, device)
+
+
+TRUSTY_MATRIX = [
+    {
+        'image-type': 'touch_sf4p',
+        'node-label': 'touch-daily',
+        'devices': [
+            {
+                'name': 'mako-05',
+                'trigger_url': _url('trusty-proposed', 'mako'),
+            },
+            {
+                'name': 'maguro-02',
+                'trigger_url': _url('trusty-proposed', 'maguro'),
+            },
+        ],
+    },
+    {
+        'image-type': 'touch',
+        'node-label': 'touch-daily',
+        'devices': [
+            {
+                'name': 'mako-02',
+                'trigger_url': _url('trusty-proposed', 'mako'),
+            },
+            {
+                'name': 'maguro-01',
+                'trigger_url': _url('trusty-proposed', 'maguro'),
+            },
+        ],
+    },
+    {
+        'image-type': 'touch_custom',
+        'node-label': 'touch-daily',
+        'devices': [
+            {
+                'name': 'mako-10',
+                'trigger_url': _url('trusty-proposed-customized', 'mako'),
+            },
+        ],
+        'IMAGE_OPT': 'export IMAGE_OPT="ubuntu-system -b '
+                     '--channel trusty-proposed-customized"'
+    },
+]
+
+SAUCY_MATRIX = [
+    {
+        'image-type': 'touch_mir',
+        'node-label': 'touch-daily',
+        'devices': [
+            {
+                # mako-11 should be the least utilized trusty device
+                'name': 'mako-11',
+                'trigger_url': _url('saucy-proposed', 'mako'),
+            },
+            {
+                'name': 'maguro-03',
+                'trigger_url': _url('saucy-proposed', 'maguro'),
+            },
+        ],
+        'IMAGE_OPT': 'export IMAGE_OPT="ubuntu-system -b '
+                     '--channel saucy-proposed"'
+    },
+]
+
+MATRIX = {
+    'trusty': TRUSTY_MATRIX,
+    'saucy': SAUCY_MATRIX,
+}

=== added file 'jenkins/setup_jenkins.py'
--- jenkins/setup_jenkins.py	1970-01-01 00:00:00 +0000
+++ jenkins/setup_jenkins.py	2014-01-15 20:49:07 +0000
@@ -0,0 +1,213 @@
+#!/usr/bin/env python
+
+# Ubuntu Testing Automation Harness
+# Copyright 2013 Canonical Ltd.
+
+# This program is free software: you can redistribute it and/or modify it
+# under the terms of the GNU General Public License version 3, as published
+# by the Free Software Foundation.
+
+# This program is distributed in the hope that it will be useful, but
+# WITHOUT ANY WARRANTY; without even the implied warranties of
+# MERCHANTABILITY, SATISFACTORY QUALITY, or FITNESS FOR A PARTICULAR
+# PURPOSE.  See the GNU General Public License for more details.
+
+# You should have received a copy of the GNU General Public License along
+# with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+import argparse
+import imp
+import jenkins
+import jinja2
+import logging
+import os
+
+from distro_info import UbuntuDistroInfo
+DEV_SERIES = UbuntuDistroInfo().devel()
+
+import testconfig
+
+DEFINE_MEGA = os.environ.get('MEGA', False)
+
+
+def _get_parser():
+    """Create and return command line parser.
+
+    :returns: command line parser
+    :rtype: argparse.ArgumentParser
+
+    """
+    parser = argparse.ArgumentParser(
+        description='Create/Update upgrade testing jenkins jobs.')
+    parser.add_argument("-d", "--dryrun", action="store_true",
+                        help="Dry run mode. Don't execute jenkins commands.")
+    parser.add_argument("-u", "--username",
+                        help="username to use when logging into Jenkins.")
+    parser.add_argument("-p", "--password",
+                        help="username to use when logging into Jenkins")
+    parser.add_argument("-b", "--branch", default="lp:ubuntu-test-cases/touch",
+                        help="The branch this is located. default=%(default)s")
+    parser.add_argument("-c", "--config", required=True,
+                        type=argparse.FileType('r'),
+                        help="The job config to use.")
+    parser.add_argument("-P", "--publish", action="store_true",
+                        help="Publish at the end of the job")
+    parser.add_argument("--prefix",
+                        help="Prefix to add to the beginning of the job name")
+    parser.add_argument("-s", "--series", default=DEV_SERIES,
+                        help=("series of Ubuntu to download "
+                              "(default=%(default)s)"))
+    parser.add_argument("-w", "--wait", type=int, default=300,
+                        help=("How long to wait after jenkins triggers the"
+                              "install-and-boot job (default=%(default)d)"))
+    return parser
+
+
+def _get_jenkins(url, username, password):
+    logging.info('Attempting to login to jenkins at %s', url)
+    if username is not None:
+        logging.info('...with authentication as user: %s', username)
+        instance = jenkins.Jenkins(url, username=username, password=password)
+    else:
+        logging.info('...without authentication')
+        instance = jenkins.Jenkins(url)
+
+    return instance
+
+
+def _get_environment():
+    base = os.path.join(os.path.dirname(__file__), 'templates')
+    return jinja2.Environment(
+        loader=jinja2.FileSystemLoader(base),
+        undefined=jinja2.StrictUndefined,
+        trim_blocks=True)
+
+
+def _publish(instance, env, args, template, jobname, **params):
+    tmpl = env.get_template(template)
+    cfg = tmpl.render(**params)
+    if args.dryrun:
+        _dryrun_func(jobname, cfg)
+        return
+    if instance.job_exists(jobname):
+        logging.info('reconfiguring job %s', jobname)
+        instance.reconfig_job(jobname, cfg)
+    else:
+        logging.info('creating job %s', jobname)
+        instance.create_job(jobname, cfg)
+
+
+if DEFINE_MEGA:
+    def _get_job_name(args, device_type, image_type):
+        prefix = ""
+        if(args.prefix):
+            prefix = args.prefix + "-"
+
+        return '{}{}-{}-{}-smoke'.format(
+            prefix, args.series, image_type, device_type)
+
+    def _configure_jobs(instance, env, args, config_item, device, tests):
+        name = device['name']
+        defserial = '$(${BZRDIR}/scripts/get-adb-id ${NODE_NAME})'
+
+        params = {
+            'name': name,
+            'serial': device.get('serial', defserial),
+            'publish': args.publish,
+            'branch': args.branch,
+            'trigger_url': device['trigger_url'],
+            'imagetype': config_item['image-type'],
+            'image_opt': config_item.get('IMAGE_OPT', ''),
+            'statsd_key': config_item.get('statsd-key', ''),
+        }
+
+        job = _get_job_name(args, name, config_item['image-type'])
+        _publish(instance, env, args, 'touch-smoke.xml.jinja2', job, **params)
+else:
+    def _get_job_name(args, device, test, image_type):
+        prefix = ""
+        if(args.prefix):
+            prefix = args.prefix + "-"
+        return test.fmt.format(prefix=prefix,
+                               series=args.series,
+                               testname=test.name,
+                               imagetype=image_type,
+                               type=device[:device.index("-")])
+
+    def _configure_job(instance, env, args, config_item, device, test):
+        tmpl_name = 'touch-{}.xml.jinja2'.format(test.name)
+        if type(test) == testconfig.APTest:
+            tmpl_name = 'touch-autopilot-base.xml.jinja2'
+        defserial = '$(${BZRDIR}/scripts/get-adb-id %s)' % device['name']
+        params = {
+            'host': config_item['node-label'],
+            'name': device['name'],
+            'serial': device.get('serial', defserial),
+            'publish': args.publish,
+            'branch': args.branch,
+            'wait': args.wait,
+            'imagetype': config_item['image-type'],
+            'image_opt': config_item.get('IMAGE_OPT', ''),
+            'testname': test.name,
+        }
+        job = _get_job_name(args, params['name'], test, params['imagetype'])
+        _publish(instance, env, args, tmpl_name, job, **params)
+        return job
+
+    def _configure_master(instance, env, args, projects, config_item, device):
+        params = {
+            'host': config_item['node-label'],
+            'name': device['name'],
+            'publish': args.publish,
+            'branch': args.branch,
+            'projects': projects,
+            'trigger_url': device['trigger_url'],
+        }
+        image_type = config_item['image-type']
+        test = testconfig.Test('master')
+        job = _get_job_name(args, device['name'], test, image_type)
+        _publish(instance, env, args, 'touch-master.xml.jinja2', job, **params)
+
+        job = 'smoke-master-free'
+        _publish(instance, env, args,
+                 'touch-master-free.xml.jinja2', job, **params)
+
+    def _configure_jobs(instance, env, args, config_item, device, tests):
+        projects = []
+        for test in tests:
+            logging.debug("configuring %s job for %s",
+                          device['name'], test.name)
+            p = _configure_job(instance, env, args, config_item, device, test)
+            projects.append(p)
+        _configure_master(instance, env, args, projects, config_item, device)
+
+
+def _dryrun_func(jobname, config):
+    logging.debug(jobname)
+    logging.debug(config)
+
+
+def main():
+    logging.basicConfig(level=logging.DEBUG)
+    args = _get_parser().parse_args()
+
+    config = imp.load_source('', 'config.py', args.config)
+    if args.series not in config.MATRIX:
+        print('"%s" series is not supported by this config.' % args.series)
+        exit(1)
+
+    jenkins_inst = _get_jenkins(config.JENKINS, args.username, args.password)
+    if args.dryrun:
+        jenkins_inst.create_job = _dryrun_func
+        jenkins_inst.reconfig_job = _dryrun_func
+
+    env = _get_environment()
+
+    for item in config.MATRIX[args.series]:
+        for device in item['devices']:
+            tests = testconfig.TESTSUITES
+            tests = testconfig.filter_tests(tests, item['image-type'])
+            _configure_jobs(jenkins_inst, env, args, item, device, tests)
+
+if __name__ == '__main__':
+    main()

=== added file 'jenkins/staging.py'
--- jenkins/staging.py	1970-01-01 00:00:00 +0000
+++ jenkins/staging.py	2014-01-15 20:49:07 +0000
@@ -0,0 +1,26 @@
+# The configuration matrix of our staging device testing
+
+import os
+
+if not os.environ.get('MEGA', False):
+    raise RuntimeError('staging server only supports MEGA jobs')
+
+JENKINS = 'http://jenkins-dev-image-test:8080/'
+
+TRUSTY_MATRIX = [
+    {
+        'image-type': 'touch',
+        'node-label': 'touch-dev',
+        'statsd-key': 'ubuntu-ci.test-execution-service.staging',
+        'devices': [
+            {
+                'name': 'mako',
+                'trigger_url': 'http://system-image.ubuntu.com/trusty-proposed/mako/index.json'
+            }
+        ],
+    },
+]
+
+MATRIX = {
+    'trusty': TRUSTY_MATRIX,
+}

=== added directory 'jenkins/templates'
=== added file 'jenkins/templates/touch-autopilot-base.xml.jinja2'
--- jenkins/templates/touch-autopilot-base.xml.jinja2	1970-01-01 00:00:00 +0000
+++ jenkins/templates/touch-autopilot-base.xml.jinja2	2014-01-15 20:49:07 +0000
@@ -0,0 +1,31 @@
+{% extends "touch-base.xml.jinja2" %}
+<?xml version='1.0' encoding='UTF-8'?>
+{% block triggers %}
+  <triggers class="vector"/>
+{% endblock %}
+{% block timeout %}
+  <timeoutMinutes>30</timeoutMinutes>
+{% endblock timeout %}
+
+{% block shellcmds %}
+      <command>set -e
+rm -rf *
+{% include "touch-setup.xml.jinja2" %}
+
+{% block apptest %}{% endblock %}
+
+${BZRDIR}/scripts/jenkins.sh -s $ANDROID_SERIAL -a {{testname}} $EXTRA_PULLS
+      </command>
+{% endblock %}
+
+{% block junitresults %}
+    <hudson.tasks.junit.JUnitResultArchiver>
+      <testResults>clientlogs/*.xml</testResults>
+      <keepLongStdio>true</keepLongStdio>
+      <testDataPublishers/>
+    </hudson.tasks.junit.JUnitResultArchiver>
+{% endblock %}
+
+{% block artifacts %}
+      <artifacts>clientlogs/*, **/jenkins.sh</artifacts>
+{% endblock %}

=== added file 'jenkins/templates/touch-base.xml.jinja2'
--- jenkins/templates/touch-base.xml.jinja2	1970-01-01 00:00:00 +0000
+++ jenkins/templates/touch-base.xml.jinja2	2014-01-15 20:49:07 +0000
@@ -0,0 +1,79 @@
+<?xml version='1.0' encoding='UTF-8'?>
+<project>
+  <actions/>
+  <description>
+&lt;pre&gt;
+#NOTE: Automatically created from a script as part of daily smoke testing&#xd;
+  {{branch}}&#xd;
+&lt;/pre&gt;
+  </description>
+  <keepDependencies>false</keepDependencies>
+  <properties>
+    <hudson.plugins.throttleconcurrents.ThrottleJobProperty>
+      <maxConcurrentPerNode>0</maxConcurrentPerNode>
+      <maxConcurrentTotal>0</maxConcurrentTotal>
+      <throttleEnabled>false</throttleEnabled>
+      <throttleOption>project</throttleOption>
+    </hudson.plugins.throttleconcurrents.ThrottleJobProperty>
+    <hudson.plugins.build__publisher.ExternalProjectProperty/>
+  </properties>
+  <scm class="hudson.scm.NullSCM"/>
+  <assignedNode>{{ host }}</assignedNode>
+  <canRoam>false</canRoam>
+  <disabled>false</disabled>
+  <blockBuildWhenDownstreamBuilding>false</blockBuildWhenDownstreamBuilding>
+  <blockBuildWhenUpstreamBuilding>false</blockBuildWhenUpstreamBuilding>
+{% block triggers %}{% endblock %}
+  <concurrentBuild>false</concurrentBuild>
+  <builders>
+{% block shellblock %}
+    <hudson.tasks.Shell>
+{% block shellcmds %}{% endblock %}
+    </hudson.tasks.Shell>
+{% endblock %}
+{% block extrasteps %}{% endblock %}
+  </builders>
+  <publishers>
+{% block artifactblock %}
+    <hudson.tasks.ArtifactArchiver>
+{% block artifacts %}{% endblock %}
+      <latestOnly>false</latestOnly>
+    </hudson.tasks.ArtifactArchiver>
+{% endblock %}
+{% block descriptionsetter %}
+    <hudson.plugins.descriptionsetter.DescriptionSetterPublisher>
+      <regexp>^= TOUCH IMAGE VERSION:([0-9]+.*)</regexp>
+      <regexpForFailed>^= TOUCH IMAGE VERSION:([0-9]+.*)</regexpForFailed>
+      <setForMatrix>false</setForMatrix>
+    </hudson.plugins.descriptionsetter.DescriptionSetterPublisher>
+{% endblock %}
+{% block mailer %}
+    <hudson.tasks.Mailer>
+      <recipients>[e-mail] [e-mail]</recipients>
+      <dontNotifyEveryUnstableBuild>false</dontNotifyEveryUnstableBuild>
+      <sendToIndividuals>false</sendToIndividuals>
+    </hudson.tasks.Mailer>
+{% endblock %}
+{% if publish %}
+{% block buildpublisher %}
+    <hudson.plugins.build__publisher.BuildPublisher>
+      <publishUnstableBuilds>true</publishUnstableBuilds>
+      <publishFailedBuilds>true</publishFailedBuilds>
+      <postActions class="vector"/>
+    </hudson.plugins.build__publisher.BuildPublisher>
+{% endblock %}
+{% endif %}
+{% block buildtrigger %}{% endblock %}
+{% block junitresults %}{% endblock %}
+  </publishers>
+  <buildWrappers>
+      <hudson.plugins.build__timeout.BuildTimeoutWrapper>
+          {% block timeout %}{% endblock %}
+      <failBuild>true</failBuild>
+      <writingDescription>false</writingDescription>
+      <timeoutPercentage>0</timeoutPercentage>
+      <timeoutType>absolute</timeoutType>
+      <timeoutMinutesElasticDefault>3</timeoutMinutesElasticDefault>
+    </hudson.plugins.build__timeout.BuildTimeoutWrapper>
+  </buildWrappers>
+</project>

=== added file 'jenkins/templates/touch-click_image_tests.xml.jinja2'
--- jenkins/templates/touch-click_image_tests.xml.jinja2	1970-01-01 00:00:00 +0000
+++ jenkins/templates/touch-click_image_tests.xml.jinja2	2014-01-15 20:49:07 +0000
@@ -0,0 +1,8 @@
+{% extends "touch-autopilot-base.xml.jinja2" %}
+<?xml version='1.0' encoding='UTF-8'?>
+
+{% block apptest %}
+export APP=&quot;click_image_tests&quot;
+{% endblock %}
+
+{% block junitresults %}{% endblock %}

=== added file 'jenkins/templates/touch-customizations.xml.jinja2'
--- jenkins/templates/touch-customizations.xml.jinja2	1970-01-01 00:00:00 +0000
+++ jenkins/templates/touch-customizations.xml.jinja2	2014-01-15 20:49:07 +0000
@@ -0,0 +1,6 @@
+{% extends "touch-autopilot-base.xml.jinja2" %}
+<?xml version='1.0' encoding='UTF-8'?>
+
+{% block apptest %}
+export APP=&quot;customizations&quot;
+{% endblock %}

=== added file 'jenkins/templates/touch-default.xml.jinja2'
--- jenkins/templates/touch-default.xml.jinja2	1970-01-01 00:00:00 +0000
+++ jenkins/templates/touch-default.xml.jinja2	2014-01-15 20:49:07 +0000
@@ -0,0 +1,9 @@
+{% extends "touch-autopilot-base.xml.jinja2" %}
+<?xml version='1.0' encoding='UTF-8'?>
+
+{% block apptest %}
+export APP=&quot;default&quot;
+{% endblock %}
+
+{% block junitresults %}{% endblock %}
+

=== added file 'jenkins/templates/touch-eventstat.xml.jinja2'
--- jenkins/templates/touch-eventstat.xml.jinja2	1970-01-01 00:00:00 +0000
+++ jenkins/templates/touch-eventstat.xml.jinja2	2014-01-15 20:49:07 +0000
@@ -0,0 +1,20 @@
+{% extends "touch-base.xml.jinja2" %}
+
+{% block timeout %}
+  <timeoutMinutes>45</timeoutMinutes>
+{% endblock timeout %}
+
+{% block shellcmds %}
+      <command>set -e
+rm -rf *
+{% include "touch-setup.xml.jinja2" %}
+
+export APP=eventstat
+
+${BZRDIR}/scripts/jenkins.sh -s $ANDROID_SERIAL -a $APP -p /tmp/results
+      </command>
+{% endblock %}
+
+{% block artifacts %}
+      <artifacts>clientlogs/*, **/jenkins.sh</artifacts>
+{% endblock %}

=== added file 'jenkins/templates/touch-install-and-boot.xml.jinja2'
--- jenkins/templates/touch-install-and-boot.xml.jinja2	1970-01-01 00:00:00 +0000
+++ jenkins/templates/touch-install-and-boot.xml.jinja2	2014-01-15 20:49:07 +0000
@@ -0,0 +1,29 @@
+{% extends "touch-base.xml.jinja2" %}
+<?xml version='1.0' encoding='UTF-8'?>
+{% block triggers %}
+  <triggers class="vector"/>
+{% endblock %}
+{% block timeout %}
+  <timeoutMinutes>30</timeoutMinutes>
+{% endblock timeout %}
+
+{% block shellcmds %}
+      <command>set -e
+apt-cache policy phablet-tools
+rm -rf *
+mkdir clientlogs
+
+{% include "touch-setup.xml.jinja2" %}
+
+#Wait for images to actually show up on cdimage
+sleep {{wait}}
+{{image_opt}}
+${BZRDIR}/scripts/provision.sh -s $ANDROID_SERIAL -i {{imagetype}} -w
+
+${BZRDIR}/scripts/jenkins.sh -s $ANDROID_SERIAL -a install-and-boot
+      </command>
+{% endblock %}
+
+{% block artifacts %}
+      <artifacts>clientlogs/*</artifacts>
+{% endblock %}

=== added file 'jenkins/templates/touch-master-free.xml.jinja2'
--- jenkins/templates/touch-master-free.xml.jinja2	1970-01-01 00:00:00 +0000
+++ jenkins/templates/touch-master-free.xml.jinja2	2014-01-15 20:49:07 +0000
@@ -0,0 +1,20 @@
+{% extends "touch-base.xml.jinja2" %}
+
+{% block timeout %}
+  <timeoutMinutes>10</timeoutMinutes>
+{% endblock timeout %}
+
+{% block shellcmds %}
+      <command>set -e
+rm -rf *
+{% include "touch-setup.xml.jinja2" %}
+
+echo LOCK_FILE=$LOCK_FILE > device-lock
+${BZRDIR}/scripts/device free --tokenfile device-lock
+      </command>
+{% endblock %}
+
+{% block artifactblock %}{% endblock %}
+{% block descriptionsetter %}{% endblock %}
+{% block buildpublisher %}{% endblock %}
+{% block mailer %}{% endblock %}

=== added file 'jenkins/templates/touch-master.xml.jinja2'
--- jenkins/templates/touch-master.xml.jinja2	1970-01-01 00:00:00 +0000
+++ jenkins/templates/touch-master.xml.jinja2	2014-01-15 20:49:07 +0000
@@ -0,0 +1,84 @@
+{% extends "touch-base.xml.jinja2" %}
+{% block triggers %}
+  <triggers class="vector">
+    <com.redfin.hudson.UrlChangeTrigger>
+      <spec></spec>
+      <url>{{trigger_url}}</url>
+    </com.redfin.hudson.UrlChangeTrigger>
+  </triggers>
+{% endblock %}
+
+{% block shellcmds %}
+      <command>set -e
+rm -rf *
+{% include "touch-setup.xml.jinja2" %}
+
+mv .device.$$ device-lock
+      </command>
+{% endblock %}
+
+{% block extrasteps %}
+{% for project in projects %}
+    <hudson.plugins.parameterizedtrigger.TriggerBuilder>
+      <configs>
+        <hudson.plugins.parameterizedtrigger.BlockableBuildTriggerConfig>
+	  <configs>
+            <hudson.plugins.parameterizedtrigger.FileBuildParameters>
+              <propertiesFile>device-lock</propertiesFile>
+              <failTriggerOnMissing>true</failTriggerOnMissing>
+            </hudson.plugins.parameterizedtrigger.FileBuildParameters>
+          </configs>
+          <projects>{{project}}</projects>
+          <condition>ALWAYS</condition>
+          <triggerWithNoParameters>false</triggerWithNoParameters>
+          <block>
+{% if "install-and-boot" in project %}
+            <buildStepFailureThreshold>
+              <name>FAILURE</name>
+              <ordinal>2</ordinal>
+              <color>RED</color>
+            </buildStepFailureThreshold>
+{% endif %}
+            <unstableThreshold>
+              <name>UNSTABLE</name>
+              <ordinal>1</ordinal>
+              <color>YELLOW</color>
+            </unstableThreshold>
+{% if "install-and-boot" in project or "default" in project %}
+            <failureThreshold>
+              <name>FAILURE</name>
+              <ordinal>2</ordinal>
+              <color>RED</color>
+            </failureThreshold>
+{% endif %}
+          </block>
+          <buildAllNodesWithLabel>false</buildAllNodesWithLabel>
+        </hudson.plugins.parameterizedtrigger.BlockableBuildTriggerConfig>
+      </configs>
+    </hudson.plugins.parameterizedtrigger.TriggerBuilder>
+{% endfor %}
+{% endblock %}
+{% block timeout %}
+  <timeoutMinutes>300</timeoutMinutes>
+{% endblock timeout %}
+{% block artifactblock %}{% endblock %}
+{% block descriptionsetter %}{% endblock %}
+{% block buildpublisher %}{% endblock %}
+{% block mailer %}{% endblock %}
+{% block buildtrigger %}
+    <hudson.plugins.parameterizedtrigger.BuildTrigger>
+      <configs>
+        <hudson.plugins.parameterizedtrigger.BuildTriggerConfig>
+          <configs>
+            <hudson.plugins.parameterizedtrigger.FileBuildParameters>
+              <propertiesFile>device-lock</propertiesFile>
+              <failTriggerOnMissing>true</failTriggerOnMissing>
+            </hudson.plugins.parameterizedtrigger.FileBuildParameters>
+          </configs>
+          <projects>smoke-master-free</projects>
+          <condition>ALWAYS</condition>
+          <triggerWithNoParameters>false</triggerWithNoParameters>
+        </hudson.plugins.parameterizedtrigger.BuildTriggerConfig>
+      </configs>
+    </hudson.plugins.parameterizedtrigger.BuildTrigger>
+{% endblock %}

=== added file 'jenkins/templates/touch-memevent.xml.jinja2'
--- jenkins/templates/touch-memevent.xml.jinja2	1970-01-01 00:00:00 +0000
+++ jenkins/templates/touch-memevent.xml.jinja2	2014-01-15 20:49:07 +0000
@@ -0,0 +1,10 @@
+{% extends "touch-autopilot-base.xml.jinja2" %}
+<?xml version='1.0' encoding='UTF-8'?>
+{% block timeout %}
+  <timeoutMinutes>30</timeoutMinutes>
+{% endblock timeout %}
+
+{% block apptest %}
+export APP=&quot;memevent&quot;
+export EXTRA_PULLS=&quot;-p /tmp/memory_usage.json&quot;
+{% endblock %}

=== added file 'jenkins/templates/touch-sdk.xml.jinja2'
--- jenkins/templates/touch-sdk.xml.jinja2	1970-01-01 00:00:00 +0000
+++ jenkins/templates/touch-sdk.xml.jinja2	2014-01-15 20:49:07 +0000
@@ -0,0 +1,9 @@
+{% extends "touch-autopilot-base.xml.jinja2" %}
+<?xml version='1.0' encoding='UTF-8'?>
+
+{% block apptest %}
+export APP=&quot;sdk&quot;
+{% endblock %}
+
+{% block junitresults %}{% endblock %}
+

=== added file 'jenkins/templates/touch-security.xml.jinja2'
--- jenkins/templates/touch-security.xml.jinja2	1970-01-01 00:00:00 +0000
+++ jenkins/templates/touch-security.xml.jinja2	2014-01-15 20:49:07 +0000
@@ -0,0 +1,9 @@
+{% extends "touch-autopilot-base.xml.jinja2" %}
+<?xml version='1.0' encoding='UTF-8'?>
+
+{% block apptest %}
+export APP=&quot;security&quot;
+{% endblock %}
+
+{% block junitresults %}{% endblock %}
+

=== added file 'jenkins/templates/touch-setup.xml.jinja2'
--- jenkins/templates/touch-setup.xml.jinja2	1970-01-01 00:00:00 +0000
+++ jenkins/templates/touch-setup.xml.jinja2	2014-01-15 20:49:07 +0000
@@ -0,0 +1,18 @@
+BRANCH=&quot;{{branch}}&quot;
+BZRDIR=`echo &quot;$BRANCH&quot; | awk -F/ &apos;{ print $(NF) }&apos;`
+BZRDIR=$(readlink -f $BZRDIR)
+bzr branch ${BRANCH} ${BZRDIR}
+
+device_free() {
+  if [ -f .device.$$ ] ; then
+    ${BZRDIR}/scripts/device free
+  fi
+}
+
+if [ -z $ANDROID_SERIAL ] ; then
+  echo No device lock found. Aquiring...
+  ${BZRDIR}/scripts/device get --name {{name}}
+  . ./.device.$$  # source in the device serial
+  trap "exit -2" TERM INT
+  trap device_free EXIT
+fi

=== added file 'jenkins/templates/touch-smem.xml.jinja2'
--- jenkins/templates/touch-smem.xml.jinja2	1970-01-01 00:00:00 +0000
+++ jenkins/templates/touch-smem.xml.jinja2	2014-01-15 20:49:07 +0000
@@ -0,0 +1,22 @@
+{% extends "touch-base.xml.jinja2" %}
+
+{% block triggers %}
+  <triggers class="vector"/>
+{% endblock %}
+{% block timeout %}
+  <timeoutMinutes>60</timeoutMinutes>
+{% endblock timeout %}
+
+{% block shellcmds %}
+      <command>rm -rf *
+{% include "touch-setup.xml.jinja2" %}
+
+export APP=smem
+
+${BZRDIR}/scripts/jenkins.sh -s $ANDROID_SERIAL -a $APP -p /tmp/results
+</command>
+{% endblock %}
+
+{% block artifacts %}
+      <artifacts>clientlogs/**/*</artifacts>
+{% endblock %}

=== added file 'jenkins/templates/touch-smoke.xml.jinja2'
--- jenkins/templates/touch-smoke.xml.jinja2	1970-01-01 00:00:00 +0000
+++ jenkins/templates/touch-smoke.xml.jinja2	2014-01-15 20:49:07 +0000
@@ -0,0 +1,147 @@
+<?xml version='1.0' encoding='UTF-8'?>
+<project>
+  <actions/>
+  <description>
+<![CDATA[
+This job provides a flexible way to execute all the tests in our daily image
+testing process that contribute to the
+<a href="http://reports.qa.ubuntu.com/smokeng/">QA Dashboard</a>.
+The job is parameterized to give flexibility in what gets tested. A couple of
+common ways to run this job are:
+<dl>
+  <dt>Full Test Run</dt>
+  <dd>TESTS=ALL</dd>
+  <dd>APPS=ALL</dd>
+  <dd>PACKAGES=ALL</dd>
+  <dt>Re-run a Failed Autopilot Test</dt>
+  <dd>INSTALL_URL=http://jenkins-dev-image-test:8080/job/saucy-touch_ro-mako/9</dd>
+  <dd>APPS=share_app</dd>
+  <dt>Run Several Autopilot Tests on Latest Build</dt>
+  <dd>APPS=share_app music_app</dd>
+  <dd>PACKAGES=share-app-autopilot</dd>
+  <dt>Run All Tests Under Utah</dt>
+  <dd>TESTS=ALL_INCLUDING_AUTOPILOT</dd>
+</dl>
+<pre>
+#NOTE: Automatically created from a script as part of daily smoke testing
+  {{branch}}
+</pre>
+{% if statsd_key %}
+<h3>Graphite Reports</h3>
+<ul>
+  <li><a href="https://graphite.engineering.canonical.com/graphlot/?width=841&height=770&&target=alias%28scale%28statsd.{{statsd_key}}.{{imagetype}}.provision.mean%2C0.000016667%29%2C%22Provisioning%20Time(minutes)%22%29&target=alias%28scale%28statsd.{{statsd_key}}.{{imagetype}}.test_autopilot.mean%2C0.000016667%29%2C%22Autopilot%20Tests%20Time%22%29&target=alias%28scale%28statsd.{{statsd_key}}.{{imagetype}}.test_utah.mean%2C0.000016667%29%2C%22UTAH%20Tests%20Time%22%29&from=-1weeks">Timings (1 week)</a></li>
+  <li><a href="https://graphite.engineering.canonical.com/graphlot/?width=841&height=770&&target=alias%28scale%28statsd.{{statsd_key}}.{{imagetype}}.provision.mean%2C0.000016667%29%2C%22Provisioning%20Time(minutes)%22%29&target=alias%28scale%28statsd.{{statsd_key}}.{{imagetype}}.test_autopilot.mean%2C0.000016667%29%2C%22Autopilot%20Tests%20Time%22%29&target=alias%28scale%28statsd.{{statsd_key}}.{{imagetype}}.test_utah.mean%2C0.000016667%29%2C%22UTAH%20Tests%20Time%22%29&from=-4weeks">Timings (4 weeks)</a></li>
+</ul>
+{% endif %}
+]]>
+  </description>
+  <keepDependencies>false</keepDependencies>
+  <properties>
+    <hudson.model.ParametersDefinitionProperty>
+      <parameterDefinitions>
+        <hudson.model.StringParameterDefinition>
+          <name>INSTALL_URL</name>
+          <description>A URL to the previous job. If provided this job will use the same install options as it used. If the device executing the job happens to have the exact same image, then provisioning can be skipped.
+	  </description>
+          <defaultValue></defaultValue>
+        </hudson.model.StringParameterDefinition>
+        <hudson.model.StringParameterDefinition>
+          <name>TESTS</name>
+          <description>A space separated list of utah tests to run. "ALL" can be used to run all known tests.
+	  </description>
+          <defaultValue></defaultValue>
+        </hudson.model.StringParameterDefinition>
+        <hudson.model.StringParameterDefinition>
+          <name>APPS</name>
+          <description>A space separated list of autopilot tests to run. "ALL" can be used to run all known tests.
+	  </description>
+          <defaultValue></defaultValue>
+        </hudson.model.StringParameterDefinition>
+	<hudson.model.StringParameterDefinition>
+          <name>PACKAGES</name>
+          <description>A space separated list of packages to install. "ALL" can be used to install required packages for all known autopilot tests.
+	  </description>
+          <defaultValue>ALL</defaultValue>
+        </hudson.model.StringParameterDefinition>
+	<hudson.model.StringParameterDefinition>
+          <name>PPAS</name>
+          <description>A space separated list of PPAs to configure on the device.
+	  </description>
+          <defaultValue></defaultValue>
+        </hudson.model.StringParameterDefinition>
+      </parameterDefinitions>
+    </hudson.model.ParametersDefinitionProperty>
+    <com.sonyericsson.rebuild.RebuildSettings>
+      <autoRebuild>false</autoRebuild>
+    </com.sonyericsson.rebuild.RebuildSettings>
+  </properties>
+  <scm class="hudson.scm.NullSCM"/>
+  <assignedNode>{{ name }}</assignedNode>
+  <canRoam>false</canRoam>
+  <disabled>false</disabled>
+  <blockBuildWhenDownstreamBuilding>false</blockBuildWhenDownstreamBuilding>
+  <blockBuildWhenUpstreamBuilding>false</blockBuildWhenUpstreamBuilding>
+  <triggers class="vector"/>
+  <concurrentBuild>true</concurrentBuild>
+  <builders>
+    <hudson.tasks.Shell>
+      <command>set -e
+BRANCH=&quot;{{branch}}&quot;
+BZRDIR=`echo &quot;$BRANCH&quot; | awk -F/ &apos;{ print $(NF) }&apos;`
+BZRDIR=$(readlink -f $BZRDIR)
+[ -d $BZRDIR ] &amp;&amp; rm -rf $BZRDIR
+bzr branch ${BRANCH} ${BZRDIR}
+
+export ANDROID_SERIAL={{serial}}
+export IMAGE_TYPE={{imagetype}}
+{% if statsd_key %}
+export STATSD_KEY={{statsd_key}}.{{imagetype}}
+{% endif %}
+
+{{image_opt}}
+${BZRDIR}/scripts/run-smoke
+      </command>
+    </hudson.tasks.Shell>
+  </builders>
+  <publishers>
+    <hudson.tasks.ArtifactArchiver>
+      <artifacts>clientlogs/**</artifacts>
+      <latestOnly>false</latestOnly>
+    </hudson.tasks.ArtifactArchiver>
+    <hudson.tasks.junit.JUnitResultArchiver>
+      <testResults>clientlogs/**/test_results.xml</testResults>
+      <keepLongStdio>true</keepLongStdio>
+      <testDataPublishers>
+        <hudson.plugins.junitattachments.AttachmentPublisher/>
+      </testDataPublishers>
+    </hudson.tasks.junit.JUnitResultArchiver>
+    <hudson.plugins.descriptionsetter.DescriptionSetterPublisher>
+      <regexp>^= TOUCH IMAGE VERSION:([0-9]+.*)</regexp>
+      <regexpForFailed>^= TOUCH IMAGE VERSION:([0-9]+.*)</regexpForFailed>
+      <setForMatrix>false</setForMatrix>
+    </hudson.plugins.descriptionsetter.DescriptionSetterPublisher>
+{% if publish %}
+    <hudson.tasks.Mailer>
+      <recipients>[e-mail]</recipients>
+      <dontNotifyEveryUnstableBuild>false</dontNotifyEveryUnstableBuild>
+      <sendToIndividuals>false</sendToIndividuals>
+    </hudson.tasks.Mailer>
+    <hudson.plugins.build__publisher.BuildPublisher>
+      <publishUnstableBuilds>true</publishUnstableBuilds>
+      <publishFailedBuilds>true</publishFailedBuilds>
+      <postActions class="vector"/>
+    </hudson.plugins.build__publisher.BuildPublisher>
+{% endif %}
+  </publishers>
+  <buildWrappers>
+      <hudson.plugins.build__timeout.BuildTimeoutWrapper>
+          <timeoutMinutes>180</timeoutMinutes>
+      <failBuild>true</failBuild>
+      <writingDescription>false</writingDescription>
+      <timeoutPercentage>0</timeoutPercentage>
+      <timeoutType>absolute</timeoutType>
+      <timeoutMinutesElasticDefault>3</timeoutMinutesElasticDefault>
+    </hudson.plugins.build__timeout.BuildTimeoutWrapper>
+  </buildWrappers>
+</project>
+

=== added file 'jenkins/templates/touch-upgrade.xml.jinja2'
--- jenkins/templates/touch-upgrade.xml.jinja2	1970-01-01 00:00:00 +0000
+++ jenkins/templates/touch-upgrade.xml.jinja2	2014-01-15 20:49:07 +0000
@@ -0,0 +1,28 @@
+{% extends "touch-base.xml.jinja2" %}
+<?xml version='1.0' encoding='UTF-8'?>
+{% block triggers %}
+  <triggers class="vector"/>
+{% endblock %}
+{% block timeout %}
+  <timeoutMinutes>30</timeoutMinutes>
+{% endblock timeout %}
+
+{% block shellcmds %}
+      <command>rm -rf *
+{% include "touch-setup.xml.jinja2" %}
+
+${BZRDIR}/scrips/run-touch-upgrade.sh
+</command>
+{% endblock %}
+
+{% block artifacts %}
+      <artifacts>clientlogs/*, **/jenkins.sh</artifacts>
+{% endblock %}
+
+{% block descriptionsetter %}
+    <hudson.plugins.descriptionsetter.DescriptionSetterPublisher>
+      <regexp>^UPGRADED TO VERSION: (.*)</regexp>
+      <regexpForFailed>^UPGRADED TO VERSION: (.*)</regexpForFailed>
+      <setForMatrix>false</setForMatrix>
+    </hudson.plugins.descriptionsetter.DescriptionSetterPublisher>
+{% endblock %}

=== added file 'jenkins/testconfig.py'
--- jenkins/testconfig.py	1970-01-01 00:00:00 +0000
+++ jenkins/testconfig.py	2014-01-15 20:49:07 +0000
@@ -0,0 +1,171 @@
+#!/usr/bin/env python
+
+# Ubuntu Testing Automation Harness
+# Copyright 2013 Canonical Ltd.
+
+# This program is free software: you can redistribute it and/or modify it
+# under the terms of the GNU General Public License version 3, as published
+# by the Free Software Foundation.
+
+# This program is distributed in the hope that it will be useful, but
+# WITHOUT ANY WARRANTY; without even the implied warranties of
+# MERCHANTABILITY, SATISFACTORY QUALITY, or FITNESS FOR A PARTICULAR
+# PURPOSE.  See the GNU General Public License for more details.
+
+# You should have received a copy of the GNU General Public License along
+# with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+import argparse
+
+DEF_FMT = '{prefix}{series}-{imagetype}-{type}-smoke-{testname}'
+IDLE_FMT = '{prefix}{testname}-{series}-{imagetype}-armhf-install-idle-{type}'
+
+
+class Test(object):
+    def __init__(self, name, fmt=DEF_FMT):
+        self.name = name
+        self.fmt = fmt
+
+
+class APTest(Test):
+    def __init__(self, name, app=None, pkgs=None):
+        Test.__init__(self, name)
+        self.pkgs = pkgs
+        if not app:
+            # convert share-app-autopilot to share_app
+            app = name.replace('-', '_').replace('_autopilot', '')
+        self.app = app
+
+
+TESTSUITES = [
+    Test('install-and-boot'),
+    Test('default'),
+]
+TESTSUITES += [
+    APTest('friends-app-autopilot', pkgs=['friends-app-autopilot']),
+    APTest('mediaplayer-app-autopilot', pkgs=['mediaplayer-app-autopilot']),
+    APTest('gallery-app-autopilot', pkgs=['gallery-app-autopilot']),
+    APTest('webbrowser-app-autopilot', pkgs=['webbrowser-app-autopilot']),
+    APTest('unity8-autopilot', 'unity8', pkgs=['python-gi']),
+    APTest('notes-app-autopilot'),
+    APTest('camera-app-autopilot', pkgs=['camera-app-autopilot']),
+    APTest('dialer-app-autopilot', pkgs=['dialer-app-autopilot']),
+    APTest('messaging-app-autopilot', pkgs=['messaging-app-autopilot']),
+    APTest('address-book-app-autopilot', pkgs=['address-book-app-autopilot']),
+    APTest('calendar-app-autopilot'),
+    APTest('music-app-autopilot'),
+    APTest('dropping-letters-app-autopilot'),
+    APTest('ubuntu-calculator-app-autopilot'),
+    APTest('ubuntu-clock-app-autopilot'),
+    APTest('ubuntu-filemanager-app-autopilot'),
+    APTest('ubuntu-rssreader-app-autopilot'),
+    APTest('ubuntu-terminal-app-autopilot'),
+    APTest('ubuntu-weather-app-autopilot'),
+    APTest('ubuntu-ui-toolkit-autopilot', 'ubuntuuitoolkit',
+           ['ubuntu-ui-toolkit-autopilot']),
+    APTest('ubuntu-system-settings-online-accounts-autopilot',
+           'online_accounts_ui',
+           ['ubuntu-system-settings-online-accounts-autopilot']),
+]
+TESTSUITES += [
+    Test('click_image_tests'),
+    Test('sdk'),
+    Test('security'),
+    Test('eventstat', IDLE_FMT),
+    Test('smem', IDLE_FMT),
+    Test('memevent',
+         '{prefix}{testname}-{series}-{imagetype}-armhf-default-{type}'),
+]
+
+
+def filter_tests(tests, image_type):
+    if image_type:
+        func = globals().get('get_tests_%s' % image_type)
+        if func:
+            tests = func(tests)
+        elif image_type not in ['touch', 'touch_mir']:
+            print('Unsupported image type: %s' % image_type)
+            exit(1)
+    return tests
+
+
+def _get_tests(test_type, image_type):
+    tests = [t for t in TESTSUITES if type(t) == test_type]
+    return filter_tests(tests, image_type)
+
+
+def _handle_utah(args):
+    tests = _get_tests(Test, args.image_type)
+    if args.with_autopilot:
+        tests += _get_tests(APTest, args.image_type)
+    # NOTE: this is only called by MEGA jobs, so we can skip install-and-boot
+    print(' '.join([t.name for t in tests if t.name != 'install-and-boot']))
+
+
+def _handle_ap_apps(args):
+    tests = _get_tests(APTest, args.image_type)
+    print(' '.join([t.app for t in tests]))
+
+
+def _handle_ap_packages(args):
+    pkgs = []
+    tests = _get_tests(APTest, args.image_type)
+    for test in tests:
+        if not args.app or test.app in args.app:
+            if test.pkgs:
+                pkgs.extend(test.pkgs)
+    print(' '.join(pkgs))
+
+
+def get_tests_touch_sf4p(common_tests):
+    tests = []
+    test_set = [
+        'install-and-boot',
+        'default',
+        'unity8-autopilot',
+    ]
+
+    tests = [t for t in common_tests if t.name in test_set]
+    return tests
+
+
+def get_tests_touch_custom(common_tests):
+    tests = common_tests
+    tests.insert(1, Test('customizations'))
+    return tests
+
+
+def _get_parser():
+    parser = argparse.ArgumentParser(
+        description='List information on configured tests for touch')
+    sub = parser.add_subparsers(title='Commands', metavar='')
+
+    p = sub.add_parser('utah', help='List UTAH tests')
+    p.set_defaults(func=_handle_utah)
+    p.add_argument('-i', '--image-type',
+                   help='Return list of test configured for an image type.')
+    p.add_argument('-a', '--with-autopilot', action='store_true',
+                   help='Include autopilot tests that can be run under UTAH.')
+
+    p = sub.add_parser('apps', help='List autopilot application names')
+    p.set_defaults(func=_handle_ap_apps)
+    p.add_argument('-i', '--image-type',
+                   help='Return list of test configured for an image type.')
+
+    p = sub.add_parser('packages', help='List packages required for autopilot')
+    p.set_defaults(func=_handle_ap_packages)
+    g = p.add_mutually_exclusive_group()
+    g.add_argument('-i', '--image-type',
+                   help='''If no apps are listed, limit to tests for an
+                        image type.''')
+    g.add_argument('-a', '--app', action='append',
+                   help='Autopilot test application. eg share_app')
+    return parser
+
+
+def main():
+    args = _get_parser().parse_args()
+    return args.func(args)
+
+if __name__ == '__main__':
+    exit(main())

=== added directory 'scripts'
=== renamed directory 'scripts' => 'scripts.moved'
=== added file 'scripts/assert-image'
--- scripts/assert-image	1970-01-01 00:00:00 +0000
+++ scripts/assert-image	2014-01-15 20:49:07 +0000
@@ -0,0 +1,25 @@
+#!/bin/sh
+
+set -e
+
+BASEDIR=$(readlink -f $(dirname $0)/..)
+
+# a simple script to ensure the proper image is installed on the target
+
+[ -z $INSTALL_URL ] && echo "= INSTALL_URL not set. Using target as-is." && exit 0
+
+echo "Ensuring target has proper image..."
+REQUIRED_UUID=$(curl ${INSTALL_URL}/artifact/clientlogs/.ci-uuid)
+ACTUAL_UUID=$(adb shell "cat /home/phablet/.ci-uuid | tr -d '\r\n'")
+if [ "$REQUIRED_UUID" != "$ACTUAL_UUID" ] ; then
+	echo "= UUIDs $REQUIRED_UUID != $ACTUAL_UUID"
+	ARGS=$(curl ${INSTALL_URL}/artifact/clientlogs/.ci-flash-args | tr -d '\r\n')
+	CUST=$(curl ${INSTALL_URL}/artifact/clientlogs/.ci-customizations | tr -d '\r\n')
+	echo "reprovisioning device with: $ARGS"
+	echo "customizing device with: $CUST"
+	UUID=$REQUIRED_UUID IMAGE_OPT=$ARGS CUSTOMIZATIONS=$CUST \
+		${BASEDIR}/scripts/provision.sh
+else
+	echo "= UUIDS match, reusing image on target"
+fi
+

=== added file 'scripts/combine_results'
--- scripts/combine_results	1970-01-01 00:00:00 +0000
+++ scripts/combine_results	2014-01-15 20:49:07 +0000
@@ -0,0 +1,94 @@
+#!/usr/bin/env python3
+
+"""
+We always run the system-settle test before and after an autopilot test. This
+script takes the results of the before/after results and combines them in with
+the junit xml results from the autopilot test so we have one unified report.
+"""
+
+
+import os
+import sys
+
+from xml.etree import ElementTree
+
+
+def _build_node(classname, name, rcfile, stdout):
+    e = ElementTree.Element('testcase')
+    e.attrib['classname'] = classname
+    e.attrib['name'] = 'settle_%s' % name
+    rc = int(open(rcfile).read())
+    if rc != 0:
+        f = ElementTree.Element('failure')
+        e.append(f)
+        f.attrib['type'] = 'testtools.testresult.real._StringException'
+        f.text = open(stdout).read()
+    return e, rc != 0
+
+
+def _get_results(apfile):
+    try:
+        tree = ElementTree.parse(apfile)
+    except Exception as ex:
+        e = ElementTree.Element('testsuite')
+        tree = ElementTree.ElementTree(e)
+        e.attrib['errors'] = '1'
+        e.attrib['failures'] = '0'
+        e.attrib['tests'] = '1'
+
+        # make a guess at the classname:
+        classname = os.path.basename(os.path.dirname(apfile))
+
+        t = ElementTree.Element('testcase')
+        e.append(t)
+        t.attrib['classname'] = classname
+        t.attrib['name'] = 'phablet-test-run'
+
+        f = ElementTree.Element('failure')
+        t.append(f)
+        f.attrib['type'] = 'testtools.testresult.real._StringException'
+        f.text = str(ex)
+
+    return tree
+
+
+def _get_classname(results):
+    return results[0].attrib.get('classname', '???').split('.')[0]
+
+
+def combine(resdir):
+    ap_file = os.path.join(resdir, 'test_results.xml')
+    tree = _get_results(ap_file)
+    ap_results = tree.getroot()
+
+    errors = int(ap_results.attrib['errors'])
+
+    classname = _get_classname(ap_results)
+
+    rc = os.path.join(resdir, 'settle_before.rc')
+    log = os.path.join(resdir, 'settle_before.log')
+    node, failed = _build_node(classname, 'before', rc, log)
+    ap_results.insert(0, node)
+    if failed:
+        errors += 1
+
+    rc = os.path.join(resdir, 'settle_after.rc')
+    log = os.path.join(resdir, 'settle_after.log')
+    node, failed = _build_node(classname, 'after', rc, log)
+    ap_results.append(node)
+    if failed:
+        errors += 1
+
+    num = int(ap_results.attrib['tests']) + 2
+    ap_results.attrib['tests'] = str(num)
+    ap_results.attrib['errors'] = str(errors)
+
+    tree.write(ap_file)
+
+
+if __name__ == '__main__':
+    if len(sys.argv) != 2:
+        print('usage: {} <results directory>'.format(sys.argv[0]))
+        sys.exit(1)
+
+    combine(sys.argv[1])

=== added file 'scripts/device'
--- scripts/device	1970-01-01 00:00:00 +0000
+++ scripts/device	2014-01-15 20:49:07 +0000
@@ -0,0 +1,191 @@
+#!/usr/bin/python
+
+import argparse
+import contextlib
+import fcntl
+import imp
+import logging
+import os
+import sys
+import time
+
+
+class DeviceException(Exception):
+    """Just a handy way to pass errors to the CLI."""
+    pass
+
+
[e-mail]
+def _device_pool(args):
+    lockfile = os.path.join(args.device_pool, 'lockfile')
+    with open(lockfile, 'w') as f:
+        logging.debug('aquiring lock for device pool')
+        try:
+            fcntl.lockf(f, fcntl.LOCK_EX)
+            yield args.device_pool
+        finally:
+            fcntl.lockf(f, fcntl.LOCK_UN)
+
+
+def _get_tokenfile():
+    return '.device.%d' % os.getppid()
+
+
+def _lock_device(device_file):
+    logging.info('locking file %s', device_file)
+
+    name = os.path.basename(device_file)
+    lockfile = device_file + '.lck'
+
+    with open(device_file) as f:
+        contents = f.read()
+        with open(_get_tokenfile(), 'w') as w:
+            w.write(contents)
+            if contents[-1] != '\n':
+                w.write('\n')
+            w.write('DEVICE_NAME=%s\n' % name)
+            w.write('LOCK_FILE=%s\n' % lockfile)
+    os.rename(device_file, lockfile)
+
+
+def _get_by_name(args):
+    loops = 0
+    while True:
+        with _device_pool(args) as pool:
+            f = os.path.join(pool, args.name)
+            if os.path.exists(f):
+                _lock_device(f)
+                break
+            elif os.path.exists(f + '.lck'):
+                # throttle back logging as time progresses
+                if (loops < 10) or \
+                   (loops < 100 and loops % 4 == 0) or \
+                   (loops % 12 == 0):
+                    logging.info(
+                        'device is locked, waiting... attempts(%d)', loops)
+            else:
+                raise DeviceException('No such device exists.')
+        time.sleep(5)
+        loops += 1
+
+
+def _get_by_type(args):
+    while True:
+        with _device_pool(args) as pool:
+            match = False
+            for d in os.listdir(pool):
+                if args.type in d:
+                    match = True
+                    if not d.endswith('.lck'):
+                        _lock_device(os.path.join(pool, d))
+                        return
+            if not match:
+                raise DeviceException(
+                    'No "%s" devices found in pool.' % args.type)
+        time.sleep(5)
+
+
+def _get_by_env(args, jobname):
+    # find the device portion of a string like:
+    #  saucy-touch_ro-DEVICETYPE-smoke-ubuntu-terminal-app-autopilot
+    parts = jobname.split('-')
+    if len(parts) < 3:
+        raise DeviceException('Invalid jobname: %s.' % jobname)
+    args.type = parts[2]
+    _get_by_type(args)
+
+
+def _device_get(args):
+    job = os.environ.get('JOBNAME', False)
+
+    if args.name:
+        _get_by_name(args)
+    elif args.type:
+        _get_by_type(args)
+    elif job:
+        _get_by_env(args, job)
+    else:
+        raise DeviceException('no device, type or $JOBNAME specified.')
+
+
+def _device_free(args):
+    if not os.path.exists(args.tokenfile):
+        raise DeviceException('tokenfile(%s) does not exist.' % args.tokenfile)
+
+    lockfile = None
+    with open(args.tokenfile) as f:
+        for line in f.readlines():
+            if line.startswith('LOCK_FILE='):
+                lockfile = line.split('=', 2)[1].strip()
+                break
+
+    device_file = os.path.splitext(lockfile)[0]
+    with _device_pool(args):
+        logging.info('releasing lock for %s', device_file)
+        os.rename(lockfile, device_file)
+    os.unlink(args.tokenfile)
+
+
+def _populate(args):
+    if os.path.exists(args.device_pool):
+        raise DeviceException('pool(%s) already exists.' % args.device_pool)
+    os.makedirs(args.device_pool)
+
+    # jump through some hoops to import this module since it has dashes
+    # and doesn't have a .py extension
+    module = 'get-adb-id'
+    fname = os.path.join(os.path.dirname(__file__), module)
+    adb = imp.load_source(module, fname)
+
+    # import the config
+    config_module = imp.load_source('config', args.config)
+    for config in config_module.MATRIX.values():
+        for item in config:
+            for device in item['devices']:
+                name = device['name']
+                serial = device.get('serial', None)
+                if not serial:
+                    serial = adb.DEVICES[name]
+                with open(os.path.join(args.device_pool, name), 'w') as f:
+                    f.write('ANDROID_SERIAL=%s' % serial)
+
+
+def _get_args():
+    parser = argparse.ArgumentParser(
+        description='''Provides a mechanism to aquire a lock on a device in
+                    a given resource pool. The lock info will be written in
+                    the format .device.<calling pid>. This file can be sourced
+                    by a shell script to get ANDROID_SERIAL etc.''')
+    parser.add_argument('--device-pool', default='/var/lib/jenkins/ci-devices',
+                        help='location of the device pool. %(default)s')
+
+    sub = parser.add_subparsers(title='Commands', metavar='')
+    p = sub.add_parser('get', help='Aquire a lock on an idle device.')
+    grp = p.add_mutually_exclusive_group()
+    grp.add_argument('--name', help='Get device by name')
+    grp.add_argument('--type', help='Get device by type')
+    p.set_defaults(func=_device_get)
+
+    p = sub.add_parser('free', help='Release a lock on a device.')
+    p.add_argument('--tokenfile', default=_get_tokenfile(),
+                   help='token file for device reservation. %(default)s')
+    p.set_defaults(func=_device_free)
+
+    p = sub.add_parser('populate', help='Initialize a device pool for usage')
+    p.add_argument('-c', '--config', required=True,
+                   help='The jenkins config to find devices in.')
+    p.set_defaults(func=_populate)
+
+    return parser.parse_args()
+
+
+if __name__ == '__main__':
+    logging.basicConfig(level=logging.INFO)
+    args = _get_args()
+    rc = 0
+    try:
+        args.func(args)
+    except DeviceException as e:
+        rc = 1
+        print('ERROR: %s' % e)
+    sys.exit(rc)

=== added file 'scripts/get-adb-id'
--- scripts/get-adb-id	1970-01-01 00:00:00 +0000
+++ scripts/get-adb-id	2014-01-15 20:49:07 +0000
@@ -0,0 +1,39 @@
+#!/usr/bin/python
+
+import sys
+
+DEVICES = {
+    "maguro-01": "0149BD7E0A019003",
+    "maguro-02": "0149BD7E0200E00F",
+    "maguro-03": "0149C7A50A00C011",
+    "maguro-04": "0149BDCC0500701B",
+    "maguro-05": "0149BD3418014013",
+    "maguro-06": "014E058C0F00C013",
+    "maguro-07": "01498FE717002014",
+    "mako-01": "01aa3d7a5dcba4a2",
+    "mako-02": "01ade38b552014d4",
+    "mako-03": "04c6714ed7c863f2",
+    "mako-05": "01b22f82dc5cec63",
+    "mako-06": "04ed70928fdc13ba",
+    "mako-07": "01e2f64788556934",
+    "mako-08": "04ea16a163930769",
+    "mako-10": "01ce848e48dfa6a2",
+    "mako-11": "04ed727c929709ba",
+    "grouper-02": "015d1884951c020e",
+    "grouper-03": "015d18ad5c27f80d",
+    "grouper-04": "015d188445242611",
+    "grouper-05": "015d21d9151c0019",
+    "manta-01": "R32D102RPZL",
+    "manta-02": "R32D102RPPK",
+    "manta-04": "R32D203DDZR",
+    "manta-05": "R32D203DMBY",
+}
+
+if __name__ == '__main__':
+    name = sys.argv[1]
+
+    try:
+        print(DEVICES[name])
+    except KeyError:
+        print("Unknown device name: '%s'" % name)
+        sys.exit(-1)

=== added file 'scripts/jenkins.sh'
--- scripts/jenkins.sh	1970-01-01 00:00:00 +0000
+++ scripts/jenkins.sh	2014-01-15 20:49:07 +0000
@@ -0,0 +1,186 @@
+#!/bin/bash
+
+## This is the script jenkins should run to execute various touch applications
+
+set -e
+
+BASEDIR=$(dirname $(readlink -f $0))/..
+
+RESDIR="${RESDIR-`pwd`/clientlogs}"
+UTAHFILE=${RESDIR}/utah.yaml
+UTAH_PHABLET_CMD="${UTAH_PHABLET_CMD-/usr/share/utah/examples/run_utah_phablet.py}"
+
+
+usage() {
+	cat <<EOF
+usage: $0 -a APP [-s ANDROID_SERIAL] [-p FILE -p FILE ...] [-Q]
+
+Provisions the given device with the latest build
+
+OPTIONS:
+  -h	Show this message
+  -s    Specify the serial of the device to install
+  -a    The application under the "tests" directory to test
+  -p    Extra file to pull from target (absolute path or relative to /home/phablet)
+  -Q    "Quick" don't do a reboot of the device before running the test
+
+EOF
+}
+
+PIDS=""
+
+cleanup() {
+	set +e
+	echo "killing child pids: $PIDS"
+	for p in $PIDS ; do
+		kill $p
+	done
+}
+
+test_from_host() {
+	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
+
+	[ -z $ANDROID_SERIAL ] || ADBOPTS="-s $ANDROID_SERIAL"
+
+	sudo TARGET_PREFIX=$TARGET_PREFIX PATH="${PATH}" ${UTAH_PHABLET_CMD} \
+		${ADBOPTS} \
+		--from-host \
+		--whoopsie \
+		--results-dir ${RESDIR} \
+		--skip-install --skip-network --skip-utah \
+		--pull /var/crash \
+		--pull /home/phablet/.cache/upstart \
+		--pull /tmp/xmlresults \
+		$EXTRA_PULL \
+		-l ${TESTSUITE_HOST}/master.run
+
+	# make sure the user running this script can remove its artifacts.
+	sudo chown -R `whoami` ${RESDIR}
+}
+
+assert_image() {
+	[ -z $INSTALL_URL ] && return
+	echo "Ensuring target has proper image..."
+	REQUIRED_UUID=$(curl ${INSTALL_URL}/artifact/clientlogs/.ci-uuid)
+	ACTUAL_UUID=$(adb shell "cat /home/phablet/.ci-uuid | tr -d '\r\n'")
+	if [ "$REQUIRED_UUID" != "$ACTUAL_UUID" ] ; then
+		echo "UUIDs $REQUIRED_UUID != $ACTUAL_UUID, reprovisioning device..."
+		ARGS=$(curl ${INSTALL_URL}/artifact/clientlogs/.ci-utah-args | tr -d '\r\n')
+		UUID=$REQUIRED_UUID IMAGE_OPT=$ARGS ${BASEDIR}/scripts/provision.sh
+	else
+		echo "UUIDS match"
+	fi
+}
+
+main() {
+	rm -rf $RESDIR
+	mkdir $RESDIR
+
+	assert_image
+
+	# print the build date so the jenkins job can use it as the
+	# build description
+	adb pull /var/log/installer/media-info ${RESDIR}
+	BUILDID=$(adb shell cat /home/phablet/.ci-version)
+	echo "= TOUCH IMAGE VERSION:$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 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 wait-for-device
+		sleep 5
+		adb wait-for-device
+		phablet-network --skip-setup -t 90s
+		adb shell powerd-cli active &
+		PIDS="$PIDS $!"
+		adb shell powerd-cli display on &
+		PIDS="$PIDS $!"
+	else
+		echo "SKIPPING phone reboot..."
+	fi
+
+	${BASEDIR}/utils/host/adb-shell "aa-clickhook -f --include=/usr/share/autopilot-touch/apparmor/click.rules"
+
+	echo "launching test from the host...."
+	test_from_host
+	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
+}
+
+while getopts p:s:a:Qh opt; do
+    case $opt in
+    h)
+        usage
+        exit 0
+        ;;
+    s)
+        export ANDROID_SERIAL=$OPTARG
+        ;;
+    a)
+        APP=$OPTARG
+        ;;
+	p)
+		EXTRA_PULL_FILE=$OPTARG
+
+		if [ ! -z $EXTRA_PULL_FILE ]; then
+			# relative paths are assumed to be relative to /home/phablet
+			E_P_START=`echo $EXTRA_PULL_FILE | cut -c1`
+
+			if [ $E_P_START = '/' ]; then
+				EXTRA_PULL="$EXTRA_PULL --pull $EXTRA_PULL_FILE"
+			else
+				EXTRA_PULL="$EXTRA_PULL --pull /home/phablet/$EXTRA_PULL_FILE"
+			fi
+		fi
+		;;
+    Q)
+        QUICK=1
+        ;;
+  esac
+done
+
+if [ -z $ANDROID_SERIAL ] ; then
+    # ensure we only have one device attached
+    lines=$(adb devices | wc -l)
+    if [ $lines -gt 3 ] ; then
+        echo "ERROR: More than one device attached, please use -s option"
+	echo
+        usage
+        exit 1
+    fi
+fi
+if [ -z $APP ] ; then
+    echo "ERROR: No app specified"
+    usage
+    exit 1
+fi
+
+TESTSUITE_HOST=$(readlink -f ${BASEDIR}/tests/${APP})
+TESTSUITE_TARGET_BASE=/tmp/tests
+TESTSUITE_TARGET=${TESTSUITE_TARGET_BASE}/$(basename ${TESTSUITE_HOST})
+
+trap cleanup TERM INT EXIT
+main

=== added file 'scripts/provision.sh'
--- scripts/provision.sh	1970-01-01 00:00:00 +0000
+++ scripts/provision.sh	2014-01-15 20:49:07 +0000
@@ -0,0 +1,126 @@
+#!/bin/bash
+
+## This is the script jenkins should run to provision a device in the lab
+
+set -e
+
+BASEDIR=$(dirname $(readlink -f $0))
+
+RESDIR=`pwd`/clientlogs
+
+NETWORK_FILE="${NETWORK_FILE-/home/ubuntu/magners-wifi}"
+
+IMAGE_OPT="${IMAGE_OPT-ubuntu-system -b --channel trusty-proposed}"
+UUID="${UUID-$(uuidgen -r)}"
+
+usage() {
+cat <<EOF
+usage: $0 [-s ANDROID_SERIAL] [-n NETWORK_FILE] [-P ppa] [-p package] [-w]
+
+Provisions the given device with the latest build
+
+OPTIONS:
+  -h	Show this message
+  -s    Specify the serial of the device to install
+  -n    Select network file
+  -P    add the ppa to the target (can be repeated)
+  -p    add the package to the target (can be repeated)
+  -w    make the system writeable (implied with -p and -P arguments)
+
+EOF
+}
+
+image_info() {
+	# mark the version we installed in /home/phablet/.ci-[uuid,flash-args]
+	# adb shell messes up \n's with \r\n's so do the whole of the regex on the target
+	IMAGEVER=$(adb shell "system-image-cli -i | sed -n -e 's/version version: \([0-9]*\)/\1/p' -e 's/version ubuntu: \([0-9]*\)/\1/p' -e 's/version device: \([0-9]*\)/\1/p' | paste -s -d:")
+	CHAN=$(adb shell "system-image-cli -i | sed -n -e 's/channel: \(.*\)/\1/p' | paste -s -d:")
+	REV=$(echo $IMAGEVER | cut -d: -f1)
+	echo "$IMAGE_OPT" | grep -q "\-\-revision" || IMAGE_OPT="${IMAGE_OPT} --revision $REV"
+	echo "$IMAGE_OPT" | grep -q "\-\-channel" || IMAGE_OPT="${IMAGE_OPT} --channel $CHAN"
+	adb shell "echo '${IMAGEVER}' > /home/phablet/.ci-version"
+	echo $UUID > $RESDIR/.ci-uuid
+	adb push $RESDIR/.ci-uuid /home/phablet/
+	cat > $RESDIR/.ci-flash-args <<EOF
+$IMAGE_OPT
+EOF
+	adb push $RESDIR/.ci-flash-args /home/phablet/.ci-flash-args
+	echo $CUSTOMIZE > $RESDIR/.ci-customizations
+	adb push $RESDIR/.ci-customizations /home/phablet/.ci-customizations
+}
+
+log() {
+	echo = $(date): $*
+}
+
+while getopts i:s:n:P:p:wh opt; do
+	case $opt in
+	h)
+		usage
+		exit 0
+		;;
+	n)
+		NETWORK_FILE=$OPTARG
+		;;
+	s)
+		export ANDROID_SERIAL=$OPTARG
+		;;
+	i)
+		IMAGE_TYPE=$OPTARG
+		;;
+	w)
+		# making this a non-zero length string enables the logic
+		CUSTOMIZE=" "
+		;;
+	P)
+		CUSTOMIZE="$CUSTOMIZE --ppa $OPTARG"
+		;;
+	p)
+		CUSTOMIZE="$CUSTOMIZE -p $OPTARG"
+		;;
+	esac
+done
+
+if [ -z $ANDROID_SERIAL ] ; then
+	# ensure we only have one device attached
+	lines=$(adb devices | wc -l)
+	if [ $lines -gt 3 ] ; then
+		echo "ERROR: More than one device attached, please use -s option"
+		echo
+		usage
+		exit 1
+	fi
+fi
+
+set -x
+[ -d $RESDIR ] && rm -rf $RESDIR
+mkdir -p $RESDIR
+
+log "FLASHING DEVICE"
+phablet-flash $IMAGE_OPT
+adb wait-for-device
+sleep 20  #give the system a little time
+
+log "SETTING UP CLICK PACKAGES"
+phablet-click-test-setup
+
+log "SETTING UP WIFI"
+phablet-network -n $NETWORK_FILE
+
+if [ "$IMAGE_TYPE" = "touch_sf4p" ]; then
+    adb shell rm -f /home/phablet/.display-mir
+fi
+
+phablet-config edges-intro --disable
+
+# get our target-based utilities into our PATH
+adb push ${BASEDIR}/../utils/target /home/phablet/bin
+
+image_info
+
+if [ -n "$CUSTOMIZE" ] ; then
+	log "CUSTOMIZING IMAGE"
+	phablet-config writable-image $CUSTOMIZE
+        # Make sure whoopsie-upload-all can work (bug #1245524)
+        adb shell "sed -i '/Waiting for whoopsie/ a\    subprocess.call([\"restart\", \"whoopsie\"])' /usr/share/apport/whoopsie-upload-all"
+fi

=== added file 'scripts/reboot-and-wait'
--- scripts/reboot-and-wait	1970-01-01 00:00:00 +0000
+++ scripts/reboot-and-wait	2014-01-15 20:49:07 +0000
@@ -0,0 +1,41 @@
+#!/usr/bin/python
+
+import argparse
+import logging
+import time
+
+from phabletutils.device import AndroidBridge
+
+
+def _get_arg_parser():
+    parser = argparse.ArgumentParser(
+        description='Reboot device and waits for networking to become active.')
+    parser.add_argument('-s', '--serial', help='Device serial')
+    parser.add_argument('-n', '--num-tries', type=int, default=3,
+                        help='''How many times to retry on failure.
+                             default=%(default)d''')
+    return parser
+
+
+def main(args):
+    device = AndroidBridge(args.serial)
+    device.wait_for_device()
+    for i in range(args.num_tries):
+        device.reboot()
+        device.wait_for_device()
+        time.sleep(5)
+        device.wait_for_device()
+        try:
+            device.wait_for_network()
+            return 0
+        except:
+            pass  # try the loop again
+    logging.error('device failed to start and activate networking')
+    return 1
+
+
+if __name__ == '__main__':
+    logging.basicConfig(level=logging.INFO)
+    logging.getLogger().name = 'reboot-and-wait'
+    args = _get_arg_parser().parse_args()
+    exit(main(args))

=== added file 'scripts/run-autopilot-tests.sh'
--- scripts/run-autopilot-tests.sh	1970-01-01 00:00:00 +0000
+++ scripts/run-autopilot-tests.sh	2014-01-15 20:49:07 +0000
@@ -0,0 +1,185 @@
+#!/bin/sh
+
+set -e
+
+BASEDIR=$(dirname $(readlink -f $0))/..
+RESDIR=`pwd`/clientlogs
+
+export PATH=${BASEDIR}/utils/host:${PATH}
+export TARGET_PREFIX=adb-shell
+
+
+usage() {
+	cat <<EOF
+usage: $0 -a APP [-s ANDROID_SERIAL] [-Q] [-o results_dir] [-S]
+
+Runs a set of autopilot tests on the target
+
+OPTIONS:
+  -h	Show this message
+  -s    Specify the serial of the device to test
+  -a    The application to test (can be repeated)
+  -o    Specify the directory to place results in.
+        Default: $RESDIR
+  -Q    "Quick" don't do a reboot of the device before/between testsuites.
+  -S    Skip the system-settle tests that run before/after each testsuite.
+
+EOF
+}
+
+log_error() {
+	echo ERROR: $* >> ${RESDIR}/runner-errors.txt
+}
+
+system_settle() {
+	[ -z $NOSETTLE ] || return 0
+
+	label=$1
+	odir=$2
+	rc=0
+	settle=${BASEDIR}/tests/systemsettle/systemsettle.sh
+	{
+		export UTAH_PROBE_DIR=${odir}  # needed for log file location
+		timeout 120s $settle -c5 -d6 -p 97.5 -l $label || rc=1
+		echo $rc > ${odir}/settle_${label}.rc
+	} 2>&1 | tee ${odir}/settle_${label}.log
+
+	if [ "$label" = "after" ] ; then
+		${BASEDIR}/scripts/combine_results ${odir}
+	fi
+}
+
+test_app() {
+	app=$1
+
+	odir=${RESDIR}/${app}
+	[ -d $odir ] && rm -rf $odir
+	mkdir -p $odir || return 1
+
+	system_settle before $odir
+	phablet-config autopilot --dbus-probe enable || \
+		(log_error "'autopilot dbus-probe enable' failed"; return 1)
+
+	NOSHELL=""
+	[ "$app" = "unity8" ] && NOSHELL="-n"
+
+	if adb-shell /home/phablet/bin/unlock_screen.sh ; then
+		phablet-test-run \
+			$NOSHELL \
+			-o ${odir} \
+			-a /var/crash -a /home/phablet/.cache/upstart \
+			-v $app || true
+	else
+		log_error "screen unlock failed, skipping $app"
+	fi
+	system_settle after $odir
+}
+
+reboot_wait() {
+	if [ -z $QUICK ] ; then
+		${BASEDIR}/scripts/reboot-and-wait
+		files="/var/crash/* /home/phablet/.cache/upstart/*.log"
+		if ! adb shell rm -rf "$FILES" ; then
+			log_error "unable to remove crash and log files, retrying"
+			adb wait-for-device
+			adb shell rm -rf "$FILES"
+		fi
+	else
+		echo "SKIPPING phone reboot..."
+	fi
+}
+
+grab_powerd() {
+	echo "grabbing powerd cli locks..."
+	adb shell powerd-cli active &
+	PIDS="$!"
+	adb shell powerd-cli display on &
+	PIDS="$PIDS $!"
+}
+
+release_powerd() {
+	if [ -n "$PIDS" ] ; then
+		echo "killing child pids: $PIDS"
+		for p in $PIDS ; do
+			kill $p || true
+		done
+		PIDS=""
+	fi
+}
+
+main() {
+	# print the build date so the jenkins job can use it as the
+	# build description
+	BUILDID=$(adb shell cat /home/phablet/.ci-version)
+	echo "= TOUCH IMAGE VERSION:$BUILDID"
+
+	[ -d $RESDIR ] || mkdir -p $RESDIR
+
+	set -x
+
+	for app in $APPS ; do
+		set +x
+		echo "========================================================"
+		echo "= testing $app"
+		echo "========================================================"
+		set -x
+		reboot_wait
+
+		grab_powerd
+
+		if ! test_app $app ; then
+			log_error "testing $app, retrying"
+			# we sometimes see sporatic adb failures that seem to
+			# related to MTP. This adds a retry for the test.
+			# test_app only fails on a device error (not a test
+			# case error)
+			adb wait-for-device
+			test_app $app
+		fi
+
+		release_powerd
+	done
+}
+
+while getopts s:a:o:QSh opt; do
+	case $opt in
+	h)
+		usage
+		exit 0
+		;;
+	s)
+		export ANDROID_SERIAL=$OPTARG
+		;;
+	o)
+		RESDIR=$OPTARG
+		;;
+	a)
+		APPS="$APPS $OPTARG"
+		;;
+	Q)
+		QUICK=1
+		;;
+	S)
+		NOSETTLE=1
+		;;
+	esac
+done
+
+if [ -z $ANDROID_SERIAL ] ; then
+	# ensure we only have one device attached
+	lines=$(adb devices | wc -l)
+	if [ $lines -gt 3 ] ; then
+		echo "ERROR: More than one device attached, please use -s option"
+		echo
+		usage
+		exit 1
+	fi
+fi
+if [ -z "$APPS" ] ; then
+	echo "ERROR: No app specified"
+	usage
+	exit 1
+fi
+
+trap release_powerd TERM INT EXIT
+main

=== added file 'scripts/run-smoke'
--- scripts/run-smoke	1970-01-01 00:00:00 +0000
+++ scripts/run-smoke	2014-01-15 20:49:07 +0000
@@ -0,0 +1,221 @@
+#!/usr/bin/python
+
+import argparse
+import logging
+import os
+import shutil
+import subprocess
+
+import statsd
+
+log = logging.getLogger()
+script_dir = os.path.dirname(__file__)
+res_dir = os.path.join(os.getcwd(), 'clientlogs')
+
+
+class SerialAction(argparse.Action):
+    def __call__(self, parser, namespace, values, option_string=None):
+        log.info('android serial: %s', values[0])
+        os.environ['ANDROID_SERIAL'] = values[0]
+
+
+class DebugAction(argparse.Action):
+    def __call__(self, parser, namespace, values, option_string=None):
+        log.setLevel(level=logging.DEBUG)
+        log.debug('debug logging enabled')
+
+
+def _serial_required():
+    required = 'ANDROID_SERIAL' not in os.environ
+    if required:
+        try:
+            out = subprocess.check_output(['adb', 'devices'])
+            required = (len(out.decode().split('\n')) != 4)
+        except subprocess.CalledProcessError as e:
+            logging.debug('error getting adb devices: %s', e)
+    return required
+
+
+def _get_parser():
+    parser = argparse.ArgumentParser(
+        description='Run the complete test-execution-service suite.')
+
+    parser.add_argument('-s', '--serial', action=SerialAction, nargs=1,
+                        required=_serial_required(),
+                        help='Android serial if more than one device present')
+    parser.add_argument('--debug', action=DebugAction, nargs=0,
+                        help='''Enable debug logging.''')
+
+    parser.add_argument('--install-url',
+                        help='''Flash with image from previous jenkins job.
+                        This option will check if the device already has image
+                        noted from this URL and will skip provisioning. The URL
+                        should be the path the job like:
+                        http://q-jenkins:8080/job/<your job>/<build number>''')
+    parser.add_argument('-p', '--package', action='append',
+                        help='Additional packages to install on target.')
+    parser.add_argument('-P', '--ppa', action='append',
+                        help='Additional PPA to configure on target.')
+    parser.add_argument('-a', '--app', action='append',
+                        help='Autopilot tests tor run.')
+    parser.add_argument('-t', '--test', action='append',
+                        help='UTAH tests tor run.')
+    parser.add_argument('--image-opt',
+                        help='Options to pass to phablet-flash')
+    parser.add_argument('--image-type', default='touch',
+                        help='''Image type being tested. This can be changed
+                        to 'touch_sf4p' so that SurfaceFlinger will be used
+                        instead of Mir. default=%(default)s''')
+    return parser
+
+
+def _arg_from_env(args, attr, envkey, array):
+    val = os.environ.get(envkey, False)
+    if val:
+        if array:
+            setattr(args, attr, val.split())
+        else:
+            setattr(args, attr, val)
+        del os.environ[envkey]
+
+
+def _merge_env(args):
+    '''When run in Jenkins everything comes as environment variables.
+
+    Its makes a much simpler job this way. While command line args are
+    much easier for a user.
+    '''
+    _arg_from_env(args, 'app', 'APPS', True)
+    _arg_from_env(args, 'test', 'TESTS', True)
+    _arg_from_env(args, 'package', 'PACKAGES', True)
+    _arg_from_env(args, 'ppa', 'PPAS', True)
+    _arg_from_env(args, 'image_opt', 'IMAGE_OPT', False)
+    _arg_from_env(args, 'image_type', 'IMAGE_TYPE', False)
+    _arg_from_env(args, 'install_url', 'INSTALL_URL', False)
+
+
+def _assert_args(args):
+    if args.install_url:
+        # this means you shouldn't specify packages, ppas, or image options
+        if args.package or args.ppa or args.image_opt:
+            msg = 'ERROR: --install-url can\'t be used with ' \
+                  '--package, -ppa, or --image_opt'
+            print(msg)
+            return False
+
+    # don't bother the install_url check, a user might be copy/pasting and
+    # doesn't hurt. Its just good to not encourage it.
+    _merge_env(args)
+
+    script = os.path.join(script_dir, '../jenkins/testconfig.py')
+    if args.package and args.package[0] == 'ALL':
+        logging.info('Discovering all required dependencies')
+        out = subprocess.check_output(
+            [script, 'packages', '-i', args.image_type])
+        args.package = [x for x in out.decode().split()]
+
+    if args.app and args.app[0] == 'ALL':
+        logging.info('Discovering all autopilot tests')
+        out = subprocess.check_output(
+            [script, 'apps', '-i', args.image_type])
+        args.app = [x for x in out.decode().split()]
+
+    if args.test and args.test[0].startswith('ALL'):
+        logging.info('Discovering all UTAH tests')
+        argv = [script, 'utah', '-i', args.image_type]
+        if args.test[0] == 'ALL_INCLUDING_AUTOPILOT':
+            argv.append('-a')
+        out = subprocess.check_output(argv)
+        args.test = [x for x in out.decode().split()]
+
+    logging.debug('ARGS: %r', args)
+
+    statsd.gauge_it('PACKAGES', args.package)
+    statsd.gauge_it('APPS', args.app)
+    statsd.gauge_it('TESTS', args.test)
+
+    return True
+
+
+def _run(args, ignore_error=False):
+    try:
+        logging.info('Running: %s', ' '.join(args))
+        subprocess.check_call(args)
+    except subprocess.CalledProcessError:
+        if ignore_error:
+            logging.error('failed to run %r, continuing', args)
+        else:
+            exit(1)
+
+
+def _assert_image(args):
+    log.info('checking if device has proper image ...')
+    os.environ['INSTALL_URL'] = args.install_url
+    _run([os.path.join(script_dir, 'assert-image')])
+
+
+def _provision(args):
+    log.info('provisioning device ...')
+    if args.image_opt:
+        log.debug('overriding IMAGE_OPT with: %s', args.image_opt)
+        os.environ['IMAGE_OPT'] = args.image_opt
+
+    cargs = [os.path.join(script_dir, 'provision.sh'), '-i', args.image_type]
+
+    if args.package:
+        for p in args.package:
+            cargs.extend(['-p', p])
+    if args.ppa:
+        for p in args.ppa:
+            cargs.extend(['-P', p])
+
+    with statsd.time_it('provision'):
+        _run(cargs)
+
+
+def _test_autopilot(args):
+    if args.app:
+        cargs = [os.path.join(script_dir, 'run-autopilot-tests.sh')]
+        for app in args.app:
+            cargs.extend(['-a', app])
+        with statsd.time_it('APPS'):
+            _run(cargs)
+
+
+def _test_utah(args):
+    if args.test:
+        cargs = [os.path.join(script_dir, 'jenkins.sh')]
+        with statsd.time_it('TESTS'):
+            for test in args.test:
+                os.environ['RESDIR'] = os.path.join(res_dir, test)
+                _run(cargs + ['-a', test], ignore_error=True)
+
+
+def main(args):
+    with statsd.time_it('main'):
+        if os.path.exists(res_dir):
+            logging.info('deleting old result directory: %s', res_dir)
+            shutil.rmtree(res_dir)
+        os.mkdir(res_dir)
+
+        if args.install_url:
+            _assert_image(args)
+        else:
+            _provision(args)
+
+        _test_autopilot(args)
+
+        _test_utah(args)
+
+    return 0
+
+
+if __name__ == '__main__':
+    logging.basicConfig(level=logging.INFO)
+    log.name = 'run-smoke'
+
+    args = _get_parser().parse_args()
+    if not _assert_args(args):
+        exit(1)
+
+    exit(main(args))

=== added file 'scripts/run-touch-upgrade.sh'
--- scripts/run-touch-upgrade.sh	1970-01-01 00:00:00 +0000
+++ scripts/run-touch-upgrade.sh	2014-01-15 20:49:07 +0000
@@ -0,0 +1,46 @@
+#!/bin/bash
+
+## This is the script jenkins should run to test upgrading a system image
+## in the lab.
+## Intersting environment variables that must be set:
+##  ANDROID_SERIAL - specify another android device
+##  RUNLIST - the path the runlist
+##  NETWORK_FILE - specify an alternative network file (passed to runlist)
+##  UPGRADE_FROM - the revision to upgrade from, eg -1 (passed to runlist)
+
+set -eux
+
+BASEDIR=$(dirname $(readlink -f $0))
+
+RESDIR=`pwd`/clientlogs
+
+UTAH_PHABLET_CMD="${UTAH_PHABLET_CMD-/usr/share/utah/examples/run_utah_phablet.py}"
+RUNLIST=${RUNLIST-"`pwd`/smoke-touch-apps/upgrade/master.run"}
+ANDROID_SERIAL="${ANDROID_SERIAL-015d1884b20c1c0f}"  #doanac's nexus7 at home
+NETWORK_FILE="${NETWORK_FILE-/home/ubuntu/magners-wifi}"
+
+rm -rf clientlogs
+mkdir clientlogs
+
+export ANDROID_SERIAL=$ANDROID_SERIAL
+
+set +e
+sudo NETWORK_FILE=$NETWORK_FILE \
+	$UTAH_PHABLET_CMD -s $ANDROID_SERIAL \
+	--from-host --skip-install --skip-utah --skip-network  -l $RUNLIST \
+	--results-dir=$RESDIR
+EXITCODE=$?
+
+UTAHFILE=$RESDIR/utah.yaml
+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

=== added file 'scripts/statsd.py'
--- scripts/statsd.py	1970-01-01 00:00:00 +0000
+++ scripts/statsd.py	2014-01-15 20:49:07 +0000
@@ -0,0 +1,35 @@
+#!/usr/bin/python
+
+import os
+import contextlib
+import time
+
+
+_namespace = os.environ.get('STATSD_KEY')
+if _namespace:
+    from txstatsd.client import UdpStatsDClient
+    from txstatsd.metrics.timermetric import TimerMetric
+    from txstatsd.metrics.gaugemetric import GaugeMetric
+    _host = os.environ.get('SERVER', 'snakefruit.canonical.com')
+    _port = int(os.environ.get('PORT', '10041'))
+    _client = UdpStatsDClient(_host, _port)
+    _client.connect()
+
+
[e-mail]
+def time_it(key):
+    start = time.time()
+    try:
+        yield
+    finally:
+        if _namespace:
+            m = TimerMetric(_client, _namespace + '.' + key)
+            m.mark(time.time() - start)
+
+
+def gauge_it(key, array):
+    val = 0
+    if array:
+        val = len(array)
+    if _namespace:
+        GaugeMetric(_client, _namespace + '.' + key).mark(val)

=== added directory 'selftests'
=== added file 'selftests/test_reboot_and_wait.py'
--- selftests/test_reboot_and_wait.py	1970-01-01 00:00:00 +0000
+++ selftests/test_reboot_and_wait.py	2014-01-15 20:49:07 +0000
@@ -0,0 +1,66 @@
+# Ubuntu Test Cases for Touch
+# Copyright 2013 Canonical Ltd.
+
+# This program is free software: you can redistribute it and/or modify it
+# under the terms of the GNU General Public License version 3, as published
+# by the Free Software Foundation.
+
+# This program is distributed in the hope that it will be useful, but
+# WITHOUT ANY WARRANTY; without even the implied warranties of
+# MERCHANTABILITY, SATISFACTORY QUALITY, or FITNESS FOR A PARTICULAR
+# PURPOSE.  See the GNU General Public License for more details.
+
+# You should have received a copy of the GNU General Public License along
+# with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+from __future__ import print_function
+
+import imp
+import mock
+import os
+import unittest
+
+
+class TestRebootAndWait(unittest.TestCase):
+
+    """Simple set of tests to make sure the reboot-and-wait command works."""
+
+    def setUp(self):
+        # do some trickery to load this as module
+        module = 'reboot-and-wait'
+        fname = os.path.join(os.path.dirname(__file__), '../scripts', module)
+        m = imp.load_source(module, fname)
+        self._main = m.main
+        self._get_parser = m._get_arg_parser
+
+    @mock.patch('phabletutils.device.AndroidBridge.reboot')
+    def testRebootFail(self, reboot):
+        reboot.side_effect = RuntimeError('foo')
+        args = self._get_parser().parse_args([])
+        with self.assertRaisesRegexp(RuntimeError, 'foo'):
+            self._main(args)
+
+    @mock.patch('phabletutils.device.AndroidBridge.reboot')
+    @mock.patch('phabletutils.device.AndroidBridge.wait_for_device')
+    def testWaitForDeviceFail(self, wait_for, reboot):
+        wait_for.side_effect = RuntimeError('foo')
+        args = self._get_parser().parse_args([])
+        with self.assertRaisesRegexp(RuntimeError, 'foo'):
+            self._main(args)
+        reboot.assert_called_once_with()
+
+    @mock.patch('phabletutils.device.AndroidBridge.reboot')
+    @mock.patch('phabletutils.device.AndroidBridge.wait_for_device')
+    @mock.patch('phabletutils.device.AndroidBridge.wait_for_network')
+    def testRetries(self, wait_for_net, wait_for_dev, reboot):
+        args = self._get_parser().parse_args([])
+        wait_for_net.side_effect = RuntimeError('foo')
+        self.assertEquals(1, self._main(args))
+        self.assertEquals(args.num_tries, reboot.call_count)
+
+        # now make sure it can recover after a single network failure
+        reboot.reset_mock()
+        wait_for_net.reset_mock()
+        wait_for_net.side_effect = [RuntimeError('foo'), None]
+        self.assertEquals(0, self._main(args))
+        self.assertEquals(2, reboot.call_count)

=== added file 'selftests/test_run_smoke.py'
--- selftests/test_run_smoke.py	1970-01-01 00:00:00 +0000
+++ selftests/test_run_smoke.py	2014-01-15 20:49:07 +0000
@@ -0,0 +1,141 @@
+# Ubuntu Test Cases for Touch
+# Copyright 2013 Canonical Ltd.
+
+# This program is free software: you can redistribute it and/or modify it
+# under the terms of the GNU General Public License version 3, as published
+# by the Free Software Foundation.
+
+# This program is distributed in the hope that it will be useful, but
+# WITHOUT ANY WARRANTY; without even the implied warranties of
+# MERCHANTABILITY, SATISFACTORY QUALITY, or FITNESS FOR A PARTICULAR
+# PURPOSE.  See the GNU General Public License for more details.
+
+# You should have received a copy of the GNU General Public License along
+# with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+import imp
+import mock
+import os
+import subprocess
+import sys
+import unittest
+
+
+class TestRunSmoke(unittest.TestCase):
+
+    """Simple set of tests to make sure the smoke-run command works."""
+
+    def setUp(self):
+        # load the module
+        module = 'run-smoke'
+        path = os.path.join(os.path.dirname(__file__), '../scripts')
+        sys.path.append(path)
+        fname = os.path.join(path, module)
+        self.run_smoke = imp.load_source(module, fname)
+        if 'ANDROID_SERIAL' in os.environ:
+            del os.environ['ANDROID_SERIAL']
+
+    @mock.patch.dict('os.environ')
+    @mock.patch('subprocess.check_output')
+    def testSerialRequired(self, check_output):
+        '''Ensure android serial is required when appropriate'''
+        check_output.return_value = '1'.encode()
+        self.assertTrue(self.run_smoke._serial_required())
+
+        check_output.return_value = '1\n2\n3\n4'.encode()
+        self.assertFalse(self.run_smoke._serial_required())
+
+        check_output.return_value = '1\n2\n3\n4\n5'.encode()
+        self.assertTrue(self.run_smoke._serial_required())
+
+        # make sure serial isn't required if specified in env
+        os.environ['ANDROID_SERIAL'] = 'foo'
+        check_output.return_value = '1\n2\n3\n4\n5'.encode()
+        self.assertFalse(self.run_smoke._serial_required())
+
+    @mock.patch('statsd.gauge_it')
+    def testAssertArgs(self, gauge):
+        '''Ensure install-url is used properly'''
+        patterns = [
+            (['--install-url', 'x', '-p', 'x'], False),
+            (['--install-url', 'x', '-P', 'x'], False),
+            (['--install-url', 'x', '--image-opt', 'x'], False),
+            (['-p', 'x', '-P', 'x', '--image-opt', 'x'], True),
+        ]
+        for pat, val in patterns:
+            args = self.run_smoke._get_parser().parse_args(['-s', 'foo'] + pat)
+            self.assertEqual(val, self.run_smoke._assert_args(args))
+
+        # ensure the -p ALL pulls in all packages
+        gauge.reset_mock()
+        args = self.run_smoke._get_parser().parse_args(['-p', 'ALL'])
+        self.assertTrue(self.run_smoke._assert_args(args))
+        self.assertTrue(len(args.package) > 1)
+        args = gauge.call_args_list[0][0]
+        self.assertEqual('PACKAGES', args[0])
+        self.assertLess(1, len(args[1]))
+
+        args = gauge.call_args_list[1][0]
+        self.assertEqual('APPS', args[0])
+        self.assertIsNone(args[1])
+        args = gauge.call_args_list[2][0]
+        self.assertEqual('TESTS', args[0])
+        self.assertIsNone(args[1])
+
+        # don't bother checking gauge calls for the remaining "ALL" tests
+
+        # ensure the -a ALL pulls in all APPS
+        args = self.run_smoke._get_parser().parse_args(['-a', 'ALL'])
+        self.assertTrue(self.run_smoke._assert_args(args))
+        self.assertTrue(len(args.app) > 1)
+
+        # ensure the -t ALL pulls in all TESTS
+        args = self.run_smoke._get_parser().parse_args(['-t', 'ALL'])
+        self.assertTrue(self.run_smoke._assert_args(args))
+        self.assertTrue(len(args.test) > 1)
+
+    def testAssertArgsEnv(self):
+        '''Ensure we pull in environment variables that jenkins uses.'''
+        with mock.patch.dict('os.environ'):
+            os.environ['APPS'] = 'apps'
+            os.environ['TESTS'] = 'tests'
+            os.environ['PACKAGES'] = 'packages'
+            os.environ['PPAS'] = 'ppas'
+            os.environ['IMAGE_TYPE'] = 'type'
+            os.environ['INSTALL_URL'] = 'url'
+            os.environ['IMAGE_OPT'] = 'opts opts'
+            os.environ['ANDROID_SERIAL'] = 'foo'
+
+            args = self.run_smoke._get_parser().parse_args([])
+            self.assertTrue(self.run_smoke._assert_args(args))
+
+            self.assertEqual(args.app, ['apps'])
+            self.assertEqual(args.test, ['tests'])
+            self.assertEqual(args.package, ['packages'])
+            self.assertEqual(args.ppa, ['ppas'])
+            self.assertEqual(args.image_type, 'type')
+            self.assertEqual(args.install_url, 'url')
+            self.assertEqual(args.image_opt, 'opts opts')
+
+    def testProvision(self):
+        orig = os.environ.get('IMAGE_OPT', '')
+        with mock.patch.object(self.run_smoke, '_run') as run:
+            args = self.run_smoke._get_parser().parse_args(
+                ['-s', 'foo', '--image-opt', 'FOOBAR', '-p', '1', '-p', '2'])
+            self.run_smoke._provision(args)
+            self.assertTrue(run.called)
+            val = os.environ.get('IMAGE_OPT')
+            os.environ['IMAGE_OPT'] = orig
+            self.assertEqual('FOOBAR', val)
+
+    def testUtahTests(self):
+        args = self.run_smoke._get_parser().parse_args(
+            ['-s', 'foo', '-t', 'a', '-t', 'b'])
+        with mock.patch.object(self.run_smoke, '_run') as run:
+            with mock.patch.dict('os.environ'):
+                run.side_effects = [subprocess.CalledProcessError, None]
+                self.run_smoke._test_utah(args)
+                p = os.path.join(self.run_smoke.res_dir, 'b')
+                # ensuring b ran means, that we handled the failure of test
+                # 'a' and that the environment is setup correctly
+                self.assertEqual(os.environ['RESDIR'], p)

=== added file 'selftests/test_statsd.py'
--- selftests/test_statsd.py	1970-01-01 00:00:00 +0000
+++ selftests/test_statsd.py	2014-01-15 20:49:07 +0000
@@ -0,0 +1,64 @@
+# Ubuntu Test Cases for Touch
+# Copyright 2013 Canonical Ltd.
+
+# This program is free software: you can redistribute it and/or modify it
+# under the terms of the GNU General Public License version 3, as published
+# by the Free Software Foundation.
+
+# This program is distributed in the hope that it will be useful, but
+# WITHOUT ANY WARRANTY; without even the implied warranties of
+# MERCHANTABILITY, SATISFACTORY QUALITY, or FITNESS FOR A PARTICULAR
+# PURPOSE.  See the GNU General Public License for more details.
+
+# You should have received a copy of the GNU General Public License along
+# with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+import os
+import mock
+import unittest
+import sys
+import time
+
+path = os.path.join(os.path.dirname(__file__), '../scripts')
+sys.path.append(path)
+
+import statsd
+
+
+class TestStatsd(unittest.TestCase):
+
+    def setUp(self):
+        self.origkey = os.environ.get('STATSD_KEY')
+        os.environ['STATSD_KEY'] = 'prefix'
+        reload(statsd)
+
+    def tearDown(self):
+        if not self.origkey:
+            del os.environ['STATSD_KEY']
+        else:
+            os.environ['STATSD_KEY'] = self.origkey
+        reload(statsd)
+
+    """Simple set of tests to make sure the statsd calls work."""
+
+    @mock.patch('txstatsd.metrics.metric.Metric.write')
+    def testGaugeIt(self, _statsd):
+        statsd.gauge_it('foo', None)
+        _statsd.assert_called_with('prefix.foo:0|g')
+        _statsd.reset_mock()
+
+        statsd.gauge_it('foo', [])
+        _statsd.assert_called_with('prefix.foo:0|g')
+        _statsd.reset_mock()
+
+        statsd.gauge_it('foo', [1, 2, 3])
+        _statsd.assert_called_with('prefix.foo:3|g')
+        _statsd.reset_mock()
+
+    @mock.patch('txstatsd.metrics.metric.Metric.write')
+    def testTimeIt(self, _statsd):
+        with statsd.time_it('foo'):
+            time.sleep(0.1)
+        # should have a timing of about 100ms
+        self.assertRegexpMatches(
+            _statsd.call_args[0][0], 'prefix.foo:100.[\d+]|ms')

=== added directory 'tests'
=== added directory 'tests/address-book-app-autopilot'
=== added file 'tests/address-book-app-autopilot/master.run'
--- tests/address-book-app-autopilot/master.run	1970-01-01 00:00:00 +0000
+++ tests/address-book-app-autopilot/master.run	2014-01-15 20:49:07 +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 'tests/address-book-app-autopilot/ts_control'
--- tests/address-book-app-autopilot/ts_control	1970-01-01 00:00:00 +0000
+++ tests/address-book-app-autopilot/ts_control	2014-01-15 20:49:07 +0000
@@ -0,0 +1,1 @@
+ts_setup: PKGS=address-book-app-autopilot prepare-autopilot-test.sh

=== added file 'tests/address-book-app-autopilot/tslist.auto'
--- tests/address-book-app-autopilot/tslist.auto	1970-01-01 00:00:00 +0000
+++ tests/address-book-app-autopilot/tslist.auto	2014-01-15 20:49:07 +0000
@@ -0,0 +1,4 @@
+-
+  discovery_cmd: autopilot-list address_book_app
+  test_cmd: autopilot-run address_book_app.tests.{}
+

=== added directory 'tests/calendar-app-autopilot'
=== added file 'tests/calendar-app-autopilot/master.run'
--- tests/calendar-app-autopilot/master.run	1970-01-01 00:00:00 +0000
+++ tests/calendar-app-autopilot/master.run	2014-01-15 20:49:07 +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 'tests/calendar-app-autopilot/ts_control'
--- tests/calendar-app-autopilot/ts_control	1970-01-01 00:00:00 +0000
+++ tests/calendar-app-autopilot/ts_control	2014-01-15 20:49:07 +0000
@@ -0,0 +1,1 @@
+ts_setup: PKGS=python-dateutil prepare-autopilot-test.sh

=== added file 'tests/calendar-app-autopilot/tslist.auto'
--- tests/calendar-app-autopilot/tslist.auto	1970-01-01 00:00:00 +0000
+++ tests/calendar-app-autopilot/tslist.auto	2014-01-15 20:49:07 +0000
@@ -0,0 +1,4 @@
+-
+  discovery_cmd: autopilot-list calendar_app
+  test_cmd: autopilot-run calendar_app.tests.{}
+

=== added directory 'tests/camera-app-autopilot'
=== added file 'tests/camera-app-autopilot/master.run'
--- tests/camera-app-autopilot/master.run	1970-01-01 00:00:00 +0000
+++ tests/camera-app-autopilot/master.run	2014-01-15 20:49:07 +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 'tests/camera-app-autopilot/ts_control'
--- tests/camera-app-autopilot/ts_control	1970-01-01 00:00:00 +0000
+++ tests/camera-app-autopilot/ts_control	2014-01-15 20:49:07 +0000
@@ -0,0 +1,1 @@
+ts_setup: PKGS=camera-app-autopilot prepare-autopilot-test.sh

=== added file 'tests/camera-app-autopilot/tslist.auto'
--- tests/camera-app-autopilot/tslist.auto	1970-01-01 00:00:00 +0000
+++ tests/camera-app-autopilot/tslist.auto	2014-01-15 20:49:07 +0000
@@ -0,0 +1,4 @@
+-
+  discovery_cmd: autopilot-list camera_app
+  test_cmd: autopilot-run camera_app.tests.{}
+

=== added directory 'tests/click_image_tests'
=== added directory 'tests/click_image_tests/check_preinstalled_list'
=== added file 'tests/click_image_tests/check_preinstalled_list/check_preinstalled_list.py'
--- tests/click_image_tests/check_preinstalled_list/check_preinstalled_list.py	1970-01-01 00:00:00 +0000
+++ tests/click_image_tests/check_preinstalled_list/check_preinstalled_list.py	2014-01-15 20:49:07 +0000
@@ -0,0 +1,61 @@
+#!/usr/bin/python3
+# Copyright (C) 2013 Canonical Ltd.
+# Author: Sergio Schvezov <[e-mail]>
+
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation; version 3 of the License.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+import subprocess
+import unittest
+import urllib.request
+
+
+click_list_url = \
+    'http://people.canonical.com/~ubuntu-archive/click_packages/click_list'
+
+
+def get_install_list():
+    request = urllib.request.urlopen(click_list_url).read().decode('utf-8')
+    click_files = [x for x in request.split('\n') if x]
+    click_apps = {}
+    for entry in click_files:
+        entry_parts = entry.split('_')
+        click_apps[entry_parts[0]] = entry_parts[1]
+    return click_apps
+
+
+def get_image_list():
+    click_list = subprocess.check_output(
+        ['adb', 'shell', 'sudo', '-u', 'phablet',
+         'bash', '-ic', 'click list']).decode('utf-8').split('\n')
+    click_entries = [x for x in click_list if x]
+    click_apps = {}
+    for entry in click_entries:
+        entry_parts = entry.split('\t')
+        click_apps[entry_parts[0]] = entry_parts[1].strip()
+    return click_apps
+
+
+class ClickPreinstalled(unittest.TestCase):
+
+    def setUp(self):
+        self.image_list = get_image_list()
+        self.install_list = get_install_list()
+        print('Search for %s on image' % self.install_list.keys())
+
+    def testPreinstalled(self):
+        for entry in self.install_list:
+            self.assertIn(entry, self.image_list.keys())
+
+
+if __name__ == '__main__':
+    unittest.main()

=== added file 'tests/click_image_tests/check_preinstalled_list/tc_control'
--- tests/click_image_tests/check_preinstalled_list/tc_control	1970-01-01 00:00:00 +0000
+++ tests/click_image_tests/check_preinstalled_list/tc_control	2014-01-15 20:49:07 +0000
@@ -0,0 +1,10 @@
+description: check that all the expected click packages are installed
+dependencies: a touch read-only image
+action: |
+  1. download the list of click packages
+  2. list the current click packages installed on the device
+expected_results: |
+  1. the current list of click packages from the archive should match
+type: userland
+timeout: 120
+command: ./check_preinstalled_list.py

=== added file 'tests/click_image_tests/master.run'
--- tests/click_image_tests/master.run	1970-01-01 00:00:00 +0000
+++ tests/click_image_tests/master.run	2014-01-15 20:49:07 +0000
@@ -0,0 +1,5 @@
+---
+testsuites:
+  - name: click_image_tests
+    fetch_method: dev
+    fetch_location: ./

=== added file 'tests/click_image_tests/tslist.run'
--- tests/click_image_tests/tslist.run	1970-01-01 00:00:00 +0000
+++ tests/click_image_tests/tslist.run	2014-01-15 20:49:07 +0000
@@ -0,0 +1,1 @@
+- test: check_preinstalled_list

=== added directory 'tests/customizations'
=== added file 'tests/customizations/master.run'
--- tests/customizations/master.run	1970-01-01 00:00:00 +0000
+++ tests/customizations/master.run	2014-01-15 20:49:07 +0000
@@ -0,0 +1,5 @@
+---
+testsuites:
+  - name: customizations
+    fetch_method: dev
+    fetch_location: ./

=== added file 'tests/customizations/setup.sh'
--- tests/customizations/setup.sh	1970-01-01 00:00:00 +0000
+++ tests/customizations/setup.sh	2014-01-15 20:49:07 +0000
@@ -0,0 +1,10 @@
+#!/bin/sh
+
+set -ex
+
+BZR_HOME=/dev/null bzr branch lp:~savilerow-team/savilerow/tests customization_tests
+
+# copy the autopilot scripts over if needed (ie we are testing from HOST)
+[ -z $ANDROID_SERIAL ] || adb push ./customization_tests /home/phablet/autopilot/customization_tests
+
+prepare-autopilot-test.sh

=== added file 'tests/customizations/ts_control'
--- tests/customizations/ts_control	1970-01-01 00:00:00 +0000
+++ tests/customizations/ts_control	2014-01-15 20:49:07 +0000
@@ -0,0 +1,1 @@
+ts_setup: ./setup.sh

=== added file 'tests/customizations/tslist.auto'
--- tests/customizations/tslist.auto	1970-01-01 00:00:00 +0000
+++ tests/customizations/tslist.auto	2014-01-15 20:49:07 +0000
@@ -0,0 +1,4 @@
+-
+  discovery_cmd: autopilot-list customization_tests
+  test_cmd: autopilot-run customization_tests.tests.{}
+

=== added directory 'tests/default'
=== added directory 'tests/default/ifconfig'
=== added file 'tests/default/ifconfig/tc_control'
--- tests/default/ifconfig/tc_control	1970-01-01 00:00:00 +0000
+++ tests/default/ifconfig/tc_control	2014-01-15 20:49:07 +0000
@@ -0,0 +1,13 @@
+description: make sure wlan0 exists
+dependencies: none
+action: |
+  1. ifconfig
+  2. Make sure there is a wlan0
+expected_results: |
+  1. there is a wlan0 on the system
+type: userland
+timeout: 60
+command: $TARGET_PREFIX ifconfig | grep wlan0
+#build_cmd:
+#tc_setup:
+#tc_cleanup:

=== added directory 'tests/default/install'
=== added file 'tests/default/install/tc_control'
--- tests/default/install/tc_control	1970-01-01 00:00:00 +0000
+++ tests/default/install/tc_control	2014-01-15 20:49:07 +0000
@@ -0,0 +1,12 @@
+description: apt-get install works
+dependencies: openssh-server
+action: |
+  1. apt-get install -y curl
+expected_results: |
+  1. apt-get install can install a package and ends with exit code 0
+type: userland
+timeout: 120
+command: $TARGET_PREFIX apt-get install -y curl
+#build_cmd:
+#tc_setup:
+tc_cleanup: $TARGET_PREFIX apt-get remove -y curl

=== added file 'tests/default/master.run'
--- tests/default/master.run	1970-01-01 00:00:00 +0000
+++ tests/default/master.run	2014-01-15 20:49:07 +0000
@@ -0,0 +1,5 @@
+---
+testsuites:
+  - name: smoke_touch
+    fetch_method: dev
+    fetch_location: ./

=== added directory 'tests/default/netstat'
=== added file 'tests/default/netstat/tc_control'
--- tests/default/netstat/tc_control	1970-01-01 00:00:00 +0000
+++ tests/default/netstat/tc_control	2014-01-15 20:49:07 +0000
@@ -0,0 +1,12 @@
+description: netstat -l lists all the services
+dependencies: none
+action: |
+  1. netstat -l
+expected_results: |
+  1. netstat shows output and exists cleanly
+type: userland
+timeout: 60
+command: $TARGET_PREFIX netstat -l
+#build_cmd:
+#tc_setup:
+#tc_cleanup:

=== added directory 'tests/default/ping'
=== added file 'tests/default/ping/pingtest.sh'
--- tests/default/ping/pingtest.sh	1970-01-01 00:00:00 +0000
+++ tests/default/ping/pingtest.sh	2014-01-15 20:49:07 +0000
@@ -0,0 +1,12 @@
+#!/bin/sh
+
+set -e
+
+if [ -z $TARGET_PREFIX ] ; then
+    echo "RUNNING ON TARGET"
+    ping -c 5 $(ip route show | head -n1 |cut -d" " -f3)
+else
+    echo "RUNNING FROM HOST"
+    ${TARGET_PREFIX} ping -c 5 '$(ip route show | head -n1 |cut -d" " -f3)'
+fi
+

=== added file 'tests/default/ping/tc_control'
--- tests/default/ping/tc_control	1970-01-01 00:00:00 +0000
+++ tests/default/ping/tc_control	2014-01-15 20:49:07 +0000
@@ -0,0 +1,12 @@
+description: ping -c 5 $gateway
+dependencies: None
+action: |
+  1. ping -c 5 $gateway
+expected_results: |
+  1. ping ends without an error
+type: userland
+timeout: 60
+command: ./pingtest.sh
+#build_cmd:
+#tc_setup:
+#tc_cleanup:

=== added directory 'tests/default/pwd'
=== added file 'tests/default/pwd/tc_control'
--- tests/default/pwd/tc_control	1970-01-01 00:00:00 +0000
+++ tests/default/pwd/tc_control	2014-01-15 20:49:07 +0000
@@ -0,0 +1,9 @@
+description: pwd works
+dependencies: none
+action: |
+  1. cd to /tmp and verify which is the current directory
+expected_results: |
+  1. Current directory is /tmp
+type: userland
+timeout: 60
+command: ./test.sh

=== added file 'tests/default/pwd/test.sh'
--- tests/default/pwd/test.sh	1970-01-01 00:00:00 +0000
+++ tests/default/pwd/test.sh	2014-01-15 20:49:07 +0000
@@ -0,0 +1,18 @@
+#!/bin/sh
+
+set -e
+
+if [ -n "$TARGET_PREFIX" ] ; then
+	echo "RUNNING FROM HOST"
+else
+	echo "RUNNING ON TARGET"
+	TARGET_PREFIX="/bin/sh -c"
+fi
+
+#when it comes from adb we get a \r\n that should be removed
+dir=$($TARGET_PREFIX "cd /tmp; pwd" | head -n1 | tr -d '\r\n')
+if [ $dir != "/tmp" ] ; then
+	echo "failed to change directory"
+	exit 1
+fi
+exit 0

=== added directory 'tests/default/route'
=== added file 'tests/default/route/tc_control'
--- tests/default/route/tc_control	1970-01-01 00:00:00 +0000
+++ tests/default/route/tc_control	2014-01-15 20:49:07 +0000
@@ -0,0 +1,12 @@
+description: route shows wlan0 routes
+dependencies: none
+action: |
+  1. route -n | grep wlan0
+expected_results: |
+  1. route shows wlan0 routes
+type: userland
+timeout: 60
+command: $TARGET_PREFIX route -n | grep wlan0
+#build_cmd:
+#tc_setup:
+#tc_cleanup:

=== added directory 'tests/default/systemsettle'
=== added file 'tests/default/systemsettle/systemsettle.sh'
--- tests/default/systemsettle/systemsettle.sh	1970-01-01 00:00:00 +0000
+++ tests/default/systemsettle/systemsettle.sh	2014-01-15 20:49:07 +0000
@@ -0,0 +1,120 @@
+#!/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 "  target prefix = $TARGET_PREFIX"
+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 'tests/default/systemsettle/tc_control'
--- tests/default/systemsettle/tc_control	1970-01-01 00:00:00 +0000
+++ tests/default/systemsettle/tc_control	2014-01-15 20:49:07 +0000
@@ -0,0 +1,9 @@
+description: check if system settles to idle average > 99.25%
+dependencies: none
+action: |
+  1. Take CPU load samples for 10 minutes and fail if average idle never goes above 99.25% percent
+expected_results: |
+  1. When doing nothing, system calms down to at least 99.25% idle level
+type: userland
+timeout: 720
+command: ./systemsettle.sh -c5 -d6 -p 97.5

=== added file 'tests/default/ts_control'
--- tests/default/ts_control	1970-01-01 00:00:00 +0000
+++ tests/default/ts_control	2014-01-15 20:49:07 +0000
@@ -0,0 +1,3 @@
+#build_cmd: echo building
+#ts_setup: echo setting up
+#ts_cleanup: echo cleaning up

=== added file 'tests/default/tslist.run'
--- tests/default/tslist.run	1970-01-01 00:00:00 +0000
+++ tests/default/tslist.run	2014-01-15 20:49:07 +0000
@@ -0,0 +1,10 @@
+- test: pwd
+- test: uname
+- test: vmstat
+- test: systemsettle
+- test: netstat
+- test: ifconfig
+- test: route
+- test: ping
+- test: install
+- test: unity8

=== added directory 'tests/default/uname'
=== added file 'tests/default/uname/tc_control'
--- tests/default/uname/tc_control	1970-01-01 00:00:00 +0000
+++ tests/default/uname/tc_control	2014-01-15 20:49:07 +0000
@@ -0,0 +1,12 @@
+description: uname shows an ubuntu-phablet image installed
+dependencies: CHANGE_ME
+action: |
+  1. uname -a|grep ubuntu-phablet
+expected_results: |
+  1. ubuntu-phablet is installed as expected
+type: userland
+timeout: 60
+command: $TARGET_PREFIX uname -a | grep ubuntu-phablet
+#build_cmd:
+#tc_setup:
+#tc_cleanup:

=== added directory 'tests/default/unity8'
=== added file 'tests/default/unity8/tc_control'
--- tests/default/unity8/tc_control	1970-01-01 00:00:00 +0000
+++ tests/default/unity8/tc_control	2014-01-15 20:49:07 +0000
@@ -0,0 +1,9 @@
+description: check for unity8 process
+dependencies: None
+action: |
+  1. pgrep unity8
+expected_results: |
+  1. pgrep exits with 0, indicating it found a matching process
+type: userland
+timeout: 60
+command: $TARGET_PREFIX /usr/bin/pgrep unity8

=== added directory 'tests/default/vmstat'
=== added file 'tests/default/vmstat/tc_control'
--- tests/default/vmstat/tc_control	1970-01-01 00:00:00 +0000
+++ tests/default/vmstat/tc_control	2014-01-15 20:49:07 +0000
@@ -0,0 +1,12 @@
+description: Execute vmstat and capture output
+dependencies: none
+action: |
+  1. vmstat
+expected_results: |
+  1. vmstat finishes without an error
+type: userland
+timeout: 60
+command: $TARGET_PREFIX vmstat
+#build_cmd:
+#tc_setup:
+#tc_cleanup:

=== added directory 'tests/dialer-app-autopilot'
=== added file 'tests/dialer-app-autopilot/master.run'
--- tests/dialer-app-autopilot/master.run	1970-01-01 00:00:00 +0000
+++ tests/dialer-app-autopilot/master.run	2014-01-15 20:49:07 +0000
@@ -0,0 +1,15 @@
+---
+testsuites:
+  - name: settle-before
+    fetch_method: dev
+    fetch_location: ../systemsettle
+    include_tests:
+      - systemsettle-before
+  - name: dialer-app-autopilot
+    fetch_method: dev
+    fetch_location: ./
+  - name: settle-after
+    fetch_method: dev
+    fetch_location: ../systemsettle
+    include_tests:
+      - systemsettle-after

=== added file 'tests/dialer-app-autopilot/ts_control'
--- tests/dialer-app-autopilot/ts_control	1970-01-01 00:00:00 +0000
+++ tests/dialer-app-autopilot/ts_control	2014-01-15 20:49:07 +0000
@@ -0,0 +1,1 @@
+ts_setup: PKGS="dialer-app-autopilot ubuntu-ui-toolkit-autopilot" prepare-autopilot-test.sh

=== added file 'tests/dialer-app-autopilot/tslist.auto'
--- tests/dialer-app-autopilot/tslist.auto	1970-01-01 00:00:00 +0000
+++ tests/dialer-app-autopilot/tslist.auto	2014-01-15 20:49:07 +0000
@@ -0,0 +1,4 @@
+-
+  discovery_cmd: autopilot-list dialer_app
+  test_cmd: autopilot-run dialer_app.tests.{}
+

=== added directory 'tests/dropping-letters-app-autopilot'
=== added file 'tests/dropping-letters-app-autopilot/master.run'
--- tests/dropping-letters-app-autopilot/master.run	1970-01-01 00:00:00 +0000
+++ tests/dropping-letters-app-autopilot/master.run	2014-01-15 20:49:07 +0000
@@ -0,0 +1,15 @@
+---
+testsuites:
+  - name: settle-before
+    fetch_method: dev
+    fetch_location: ../systemsettle
+    include_tests:
+      - systemsettle-before
+  - name: dropping-letters-app-autopilot
+    fetch_method: dev
+    fetch_location: ./
+  - name: settle-after
+    fetch_method: dev
+    fetch_location: ../systemsettle
+    include_tests:
+      - systemsettle-after

=== added file 'tests/dropping-letters-app-autopilot/ts_control'
--- tests/dropping-letters-app-autopilot/ts_control	1970-01-01 00:00:00 +0000
+++ tests/dropping-letters-app-autopilot/ts_control	2014-01-15 20:49:07 +0000
@@ -0,0 +1,1 @@
+ts_setup: prepare-autopilot-test.sh

=== added file 'tests/dropping-letters-app-autopilot/tslist.auto'
--- tests/dropping-letters-app-autopilot/tslist.auto	1970-01-01 00:00:00 +0000
+++ tests/dropping-letters-app-autopilot/tslist.auto	2014-01-15 20:49:07 +0000
@@ -0,0 +1,4 @@
+-
+  discovery_cmd: autopilot-list dropping_letters_app
+  test_cmd: autopilot-run dropping_letters_app.tests.{}
+

=== added directory 'tests/eventstat'
=== added directory 'tests/eventstat/eventstat'
=== added file 'tests/eventstat/eventstat/eventstat.sh'
--- tests/eventstat/eventstat/eventstat.sh	1970-01-01 00:00:00 +0000
+++ tests/eventstat/eventstat/eventstat.sh	2014-01-15 20:49:07 +0000
@@ -0,0 +1,5 @@
+#!/bin/bash
+: ${DURATION:=60}
+: ${COUNT:=10}
+${TARGET_PREFIX} "echo \"{\\\"duration\\\": $DURATION, \\\"count\\\": $COUNT}\" > /tmp/results/options.json"
+${TARGET_PREFIX} "eventstat -CSl -r /tmp/results/eventstat.csv $DURATION $COUNT > /tmp/results/eventstat.log"

=== added file 'tests/eventstat/eventstat/setup.sh'
--- tests/eventstat/eventstat/setup.sh	1970-01-01 00:00:00 +0000
+++ tests/eventstat/eventstat/setup.sh	2014-01-15 20:49:07 +0000
@@ -0,0 +1,7 @@
+#!/bin/bash
+
+${TARGET_PREFIX} mkdir -p /tmp/results
+NO_UNLOCK=1 PKGS="eventstat" prepare-autopilot-test.sh
+#Let the system quiet down for a little while
+sleep 300
+

=== added file 'tests/eventstat/eventstat/tc_control'
--- tests/eventstat/eventstat/tc_control	1970-01-01 00:00:00 +0000
+++ tests/eventstat/eventstat/tc_control	2014-01-15 20:49:07 +0000
@@ -0,0 +1,12 @@
+description: Gather memory usage information
+dependencies: none
+action: |
+  1. gather eventstat data
+expected_results: |
+  1. eventstat.log should be saved to /tmp/results
+type: userland
+timeout: 800
+command: ./eventstat.sh
+#build_cmd:
+tc_setup: ./setup.sh
+#tc_cleanup:

=== added file 'tests/eventstat/master.run'
--- tests/eventstat/master.run	1970-01-01 00:00:00 +0000
+++ tests/eventstat/master.run	2014-01-15 20:49:07 +0000
@@ -0,0 +1,5 @@
+---
+testsuites:
+  - name: eventstat
+    fetch_method: dev
+    fetch_location: ./

=== added file 'tests/eventstat/tslist.run'
--- tests/eventstat/tslist.run	1970-01-01 00:00:00 +0000
+++ tests/eventstat/tslist.run	2014-01-15 20:49:07 +0000
@@ -0,0 +1,1 @@
+- test: eventstat

=== added directory 'tests/friends-app-autopilot'
=== added file 'tests/friends-app-autopilot/master.run'
--- tests/friends-app-autopilot/master.run	1970-01-01 00:00:00 +0000
+++ tests/friends-app-autopilot/master.run	2014-01-15 20:49:07 +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 'tests/friends-app-autopilot/ts_control'
--- tests/friends-app-autopilot/ts_control	1970-01-01 00:00:00 +0000
+++ tests/friends-app-autopilot/ts_control	2014-01-15 20:49:07 +0000
@@ -0,0 +1,1 @@
+ts_setup: PKGS=friends-app-autopilot prepare-autopilot-test.sh

=== added file 'tests/friends-app-autopilot/tslist.auto'
--- tests/friends-app-autopilot/tslist.auto	1970-01-01 00:00:00 +0000
+++ tests/friends-app-autopilot/tslist.auto	2014-01-15 20:49:07 +0000
@@ -0,0 +1,4 @@
+-
+  discovery_cmd: autopilot-list friends_app
+  test_cmd: autopilot-run friends_app.tests.{}
+

=== added directory 'tests/gallery-app-autopilot'
=== added file 'tests/gallery-app-autopilot/master.run'
--- tests/gallery-app-autopilot/master.run	1970-01-01 00:00:00 +0000
+++ tests/gallery-app-autopilot/master.run	2014-01-15 20:49:07 +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 'tests/gallery-app-autopilot/ts_control'
--- tests/gallery-app-autopilot/ts_control	1970-01-01 00:00:00 +0000
+++ tests/gallery-app-autopilot/ts_control	2014-01-15 20:49:07 +0000
@@ -0,0 +1,1 @@
+ts_setup: PKGS=gallery-app-autopilot prepare-autopilot-test.sh

=== added file 'tests/gallery-app-autopilot/tslist.auto'
--- tests/gallery-app-autopilot/tslist.auto	1970-01-01 00:00:00 +0000
+++ tests/gallery-app-autopilot/tslist.auto	2014-01-15 20:49:07 +0000
@@ -0,0 +1,4 @@
+-
+  discovery_cmd: autopilot-list gallery_app
+  test_cmd: autopilot-run gallery_app.tests.{}
+

=== added directory 'tests/install-and-boot'
=== added directory 'tests/install-and-boot/boot'
=== added file 'tests/install-and-boot/boot/tc_control'
--- tests/install-and-boot/boot/tc_control	1970-01-01 00:00:00 +0000
+++ tests/install-and-boot/boot/tc_control	2014-01-15 20:49:07 +0000
@@ -0,0 +1,9 @@
+description: Ensures the target system has booted
+dependencies: provision.sh was run
+action: |
+  1. checks adb-shell works
+expected_results: |
+  1. adb-shell is active to the target
+type: userland
+timeout: 60
+command: adb-shell /bin/true

=== added file 'tests/install-and-boot/master.run'
--- tests/install-and-boot/master.run	1970-01-01 00:00:00 +0000
+++ tests/install-and-boot/master.run	2014-01-15 20:49:07 +0000
@@ -0,0 +1,5 @@
+---
+testsuites:
+  - name: install-and-boot
+    fetch_method: dev
+    fetch_location: ./

=== added file 'tests/install-and-boot/tslist.run'
--- tests/install-and-boot/tslist.run	1970-01-01 00:00:00 +0000
+++ tests/install-and-boot/tslist.run	2014-01-15 20:49:07 +0000
@@ -0,0 +1,1 @@
+- test: boot

=== added directory 'tests/mediaplayer-app-autopilot'
=== added file 'tests/mediaplayer-app-autopilot/master.run'
--- tests/mediaplayer-app-autopilot/master.run	1970-01-01 00:00:00 +0000
+++ tests/mediaplayer-app-autopilot/master.run	2014-01-15 20:49:07 +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 'tests/mediaplayer-app-autopilot/ts_control'
--- tests/mediaplayer-app-autopilot/ts_control	1970-01-01 00:00:00 +0000
+++ tests/mediaplayer-app-autopilot/ts_control	2014-01-15 20:49:07 +0000
@@ -0,0 +1,1 @@
+ts_setup: PKGS=mediaplayer-app-autopilot prepare-autopilot-test.sh

=== added file 'tests/mediaplayer-app-autopilot/tslist.auto'
--- tests/mediaplayer-app-autopilot/tslist.auto	1970-01-01 00:00:00 +0000
+++ tests/mediaplayer-app-autopilot/tslist.auto	2014-01-15 20:49:07 +0000
@@ -0,0 +1,4 @@
+-
+  discovery_cmd: autopilot-list mediaplayer_app
+  test_cmd: autopilot-run mediaplayer_app.tests.{}
+

=== added directory 'tests/memevent'
=== added file 'tests/memevent/master.run'
--- tests/memevent/master.run	1970-01-01 00:00:00 +0000
+++ tests/memevent/master.run	2014-01-15 20:49:07 +0000
@@ -0,0 +1,5 @@
+---
+testsuites:
+  - name: memevent
+    fetch_method: dev
+    fetch_location: ./

=== added file 'tests/memevent/setup.sh'
--- tests/memevent/setup.sh	1970-01-01 00:00:00 +0000
+++ tests/memevent/setup.sh	2014-01-15 20:49:07 +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 'tests/memevent/ts_control'
--- tests/memevent/ts_control	1970-01-01 00:00:00 +0000
+++ tests/memevent/ts_control	2014-01-15 20:49:07 +0000
@@ -0,0 +1,1 @@
+ts_setup: ./setup.sh

=== added file 'tests/memevent/tslist.auto'
--- tests/memevent/tslist.auto	1970-01-01 00:00:00 +0000
+++ tests/memevent/tslist.auto	2014-01-15 20:49:07 +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 'tests/memevent/ubuntu_test_cases'
=== added file 'tests/memevent/ubuntu_test_cases/__init__.py'
--- tests/memevent/ubuntu_test_cases/__init__.py	1970-01-01 00:00:00 +0000
+++ tests/memevent/ubuntu_test_cases/__init__.py	2014-01-15 20:49:07 +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 'tests/memevent/ubuntu_test_cases/memory_usage_measurement'
=== added file 'tests/memevent/ubuntu_test_cases/memory_usage_measurement/__init__.py'
--- tests/memevent/ubuntu_test_cases/memory_usage_measurement/__init__.py	1970-01-01 00:00:00 +0000
+++ tests/memevent/ubuntu_test_cases/memory_usage_measurement/__init__.py	2014-01-15 20:49:07 +0000
@@ -0,0 +1,1 @@
+"""Event based memory usage measurements test cases."""

=== added directory 'tests/memevent/ubuntu_test_cases/memory_usage_measurement/apps'
=== added file 'tests/memevent/ubuntu_test_cases/memory_usage_measurement/apps/__init__.py'
--- tests/memevent/ubuntu_test_cases/memory_usage_measurement/apps/__init__.py	1970-01-01 00:00:00 +0000
+++ tests/memevent/ubuntu_test_cases/memory_usage_measurement/apps/__init__.py	2014-01-15 20:49:07 +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 'tests/memevent/ubuntu_test_cases/memory_usage_measurement/apps/browser.py'
--- tests/memevent/ubuntu_test_cases/memory_usage_measurement/apps/browser.py	1970-01-01 00:00:00 +0000
+++ tests/memevent/ubuntu_test_cases/memory_usage_measurement/apps/browser.py	2014-01-15 20:49:07 +0000
@@ -0,0 +1,103 @@
+"""Browser application to write autopilot test cases easily."""
+
+from testtools.matchers import Contains, Equals
+
+from ubuntuuitoolkit.emulators import UbuntuUIToolkitEmulatorBase
+from webbrowser_app.emulators.browser import Browser
+
+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."""
+
+        toolbar = self.window.get_toolbar()
+        self.tc.assertThat(toolbar.opened, Eventually(Equals(False)))
+        self.tc.assertThat(toolbar.animating, Eventually(Equals(False)))
+
+    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.window.open_toolbar()
+        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',
+            emulator_base=UbuntuUIToolkitEmulatorBase
+        )
+        self.window = self.app.select_single(Browser)
+        self.window.visible.wait_for(True)
+
+    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 'tests/memevent/ubuntu_test_cases/memory_usage_measurement/apps/camera.py'
--- tests/memevent/ubuntu_test_cases/memory_usage_measurement/apps/camera.py	1970-01-01 00:00:00 +0000
+++ tests/memevent/ubuntu_test_cases/memory_usage_measurement/apps/camera.py	2014-01-15 20:49:07 +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 'tests/memevent/ubuntu_test_cases/memory_usage_measurement/apps/gallery.py'
--- tests/memevent/ubuntu_test_cases/memory_usage_measurement/apps/gallery.py	1970-01-01 00:00:00 +0000
+++ tests/memevent/ubuntu_test_cases/memory_usage_measurement/apps/gallery.py	2014-01-15 20:49:07 +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 'tests/memevent/ubuntu_test_cases/memory_usage_measurement/apps/media_player.py'
--- tests/memevent/ubuntu_test_cases/memory_usage_measurement/apps/media_player.py	1970-01-01 00:00:00 +0000
+++ tests/memevent/ubuntu_test_cases/memory_usage_measurement/apps/media_player.py	2014-01-15 20:49:07 +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 'tests/memevent/ubuntu_test_cases/memory_usage_measurement/matchers.py'
--- tests/memevent/ubuntu_test_cases/memory_usage_measurement/matchers.py	1970-01-01 00:00:00 +0000
+++ tests/memevent/ubuntu_test_cases/memory_usage_measurement/matchers.py	2014-01-15 20:49:07 +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 'tests/memevent/ubuntu_test_cases/memory_usage_measurement/probes.py'
--- tests/memevent/ubuntu_test_cases/memory_usage_measurement/probes.py	1970-01-01 00:00:00 +0000
+++ tests/memevent/ubuntu_test_cases/memory_usage_measurement/probes.py	2014-01-15 20:49:07 +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 'tests/memevent/ubuntu_test_cases/memory_usage_measurement/smem-tabs'
--- tests/memevent/ubuntu_test_cases/memory_usage_measurement/smem-tabs	1970-01-01 00:00:00 +0000
+++ tests/memevent/ubuntu_test_cases/memory_usage_measurement/smem-tabs	2014-01-15 20:49:07 +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 'tests/memevent/ubuntu_test_cases/memory_usage_measurement/tests'
=== added file 'tests/memevent/ubuntu_test_cases/memory_usage_measurement/tests/__init__.py'
--- tests/memevent/ubuntu_test_cases/memory_usage_measurement/tests/__init__.py	1970-01-01 00:00:00 +0000
+++ tests/memevent/ubuntu_test_cases/memory_usage_measurement/tests/__init__.py	2014-01-15 20:49:07 +0000
@@ -0,0 +1,1 @@
+"""Event based memory usage measurements test cases."""

=== added file 'tests/memevent/ubuntu_test_cases/memory_usage_measurement/tests/test_memory_usage.py'
--- tests/memevent/ubuntu_test_cases/memory_usage_measurement/tests/test_memory_usage.py	1970-01-01 00:00:00 +0000
+++ tests/memevent/ubuntu_test_cases/memory_usage_measurement/tests/test_memory_usage.py	2014-01-15 20:49:07 +0000
@@ -0,0 +1,80 @@
+"""Measure touch applications memory usage."""
+
+import json
+import logging
+import os
+
+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://acid3.acidtests.org/'
+            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 = '/tmp/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 'tests/messaging-app-autopilot'
=== added file 'tests/messaging-app-autopilot/master.run'
--- tests/messaging-app-autopilot/master.run	1970-01-01 00:00:00 +0000
+++ tests/messaging-app-autopilot/master.run	2014-01-15 20:49:07 +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: ./