Merge lp:~cjohnston/ubuntu-test-cases/convergence into lp:ubuntu-test-cases

[Chris Johnston]

[lp:~cjohnston/ubuntu-test-cases/convergence]

23. By Chris Johnston on 2013-08-30

Updating paths

24. By Chris Johnston on 2013-08-30

Move runlists to proper place

25. By Chris Johnston on 2013-08-30

Fix paths

26. By Chris Johnston on 2013-08-30

Move run-touch-upgrade to scripts

27. By Chris Johnston on 2013-08-30

Applying patch

28. By Chris Johnston on 2013-08-30

Fix path issue

29. By Chris Johnston on 2013-08-30

Update branches

30. By Chris Johnston on 2013-08-30

Fix path for from host

31. By Chris Johnston on 2013-09-05

Merge trunk

Unmerged revisions

31. By Chris Johnston on 2013-09-05

Merge trunk

30. By Chris Johnston on 2013-08-30

Fix path for from host

29. By Chris Johnston on 2013-08-30

Update branches

28. By Chris Johnston on 2013-08-30

Fix path issue

27. By Chris Johnston on 2013-08-30

Applying patch

26. By Chris Johnston on 2013-08-30

Move run-touch-upgrade to scripts

25. By Chris Johnston on 2013-08-30

Fix paths

24. By Chris Johnston on 2013-08-30

Move runlists to proper place

23. By Chris Johnston on 2013-08-30

Updating paths

22. By Chris Johnston on 2013-08-30

Switch to a common setup for obtaining ANDROID_SERIAL

=== added directory 'jenkins'
=== added file 'jenkins/setup_jenkins.py'
--- jenkins/setup_jenkins.py	1970-01-01 00:00:00 +0000
+++ jenkins/setup_jenkins.py	2013-08-30 19:55:55 +0000
@@ -0,0 +1,237 @@
+#!/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 collections
+import jenkins
+import jinja2
+import logging
+import os
+
+from distro_info import UbuntuDistroInfo
+DEV_SERIES = UbuntuDistroInfo().devel()
+
+
+SYSTEM_IMAGE = os.environ.get('SYSTEM_IMAGE', False)
+
+Test = collections.namedtuple('Test', ['name', 'fmt', 'restrict_to'])
+
+
+if SYSTEM_IMAGE:
+    def _test(name, fmt='{prefix}{series}-touch_ro-{type}-smoke-{testname}',
+              restrict_to=None):
+        return Test(name, fmt, restrict_to)
+else:
+    def _test(name, fmt='{prefix}{series}-touch-{type}-smoke-{testname}',
+              restrict_to=None):
+        return Test(name, fmt, restrict_to)
+
+
+TESTS = [
+    _test('install-and-boot'),
+    _test('default'),
+    _test('mediaplayer-app-autopilot'),
+    _test('gallery-app-autopilot'),
+    _test('webbrowser-app-autopilot'),
+    _test('unity8-autopilot'),
+    _test('friends-app-autopilot'),
+    _test('notes-app-autopilot'),
+    _test('camera-app-autopilot'),
+    _test('dialer-app-autopilot'),
+    _test('messaging-app-autopilot'),
+    _test('address-book-app-autopilot'),
+    _test('phone-app-connected-autopilot', restrict_to=['maguro-02']),
+    _test('share-app-autopilot'),
+    _test('calendar-app-autopilot'),
+    _test('music-app-autopilot'),
+    _test('ubuntu-calculator-app-autopilot'),
+    _test('ubuntu-clock-app-autopilot'),
+    #_test('ubuntu-docviewer-app-autopilot'),
+    _test('ubuntu-filemanager-app-autopilot'),
+    _test('ubuntu-rssreader-app-autopilot'),
+    _test('ubuntu-terminal-app-autopilot'),
+    _test('ubuntu-weather-app-autopilot'),
+    _test('sdk'),
+    _test('security'),
+]
+
+DEVICES = [
+    "mako-01",
+    "maguro-01",
+    "manta-01",
+    "grouper-02",
+]
+
+
+if SYSTEM_IMAGE:
+    #TESTS = [_test('upgrade')] + TESTS
+    TESTS += [
+        _test('smem',
+              '{prefix}{testname}-{series}-'
+              'touch_ro-armhf-install-idle-{type}'),
+        _test('memevent',
+              '{prefix}{testname}-{series}-touch_ro-armhf-default-{type}'),
+    ]
+    DEVICES = ['mako-05', 'maguro-02']
+else:
+    TESTS += [
+        _test('smem',
+              '{prefix}{testname}-{series}-touch-armhf-install-idle-{type}'),
+        _test('memevent',
+              '{prefix}{testname}-{series}-touch-armhf-default-{type}'),
+    ]
+
+
+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", "--publish", action="store_true",
+                        help="Publish at the end of the job")
+    parser.add_argument("-p", "--password",
+                        help="username to use when logging into Jenkins")
+    parser.add_argument("--prefix",
+                        help="Prefix to add to the beginning of the job name")
+    parser.add_argument("-j", "--jenkins", default="http://10.98.0.1:8080/",
+                        help="URL of jenkins instance to configure jobs in.")
+    parser.add_argument("-n", "--name", action='append',
+                        help=("Device names where the job should be executed."
+                              " Can be used more than once."))
+    parser.add_argument("--host", default='phoenix',
+                        help=("Host name where the jobs should be executed."))
+    parser.add_argument("-s", "--series", default=DEV_SERIES,
+                        help=("series of Ubuntu to download "
+                              "(default=%(default)s)"))
+    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 _get_job_name(args, device, test):
+    prefix = ""
+    if(args.prefix):
+        prefix = args.prefix + "-"
+    return test.fmt.format(prefix=prefix,
+                           series=args.series,
+                           testname=test.name,
+                           type=device[:device.index("-")])
+
+
+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)
+
+
+def _configure_job(instance, env, args, device, test):
+    tmpl_name = 'touch-{}.xml.jinja2'.format(test.name)
+    params = {
+        'host': args.host,
+        'name': device,
+        'publish': args.publish
+    }
+    params['system_image'] = True if SYSTEM_IMAGE else False
+    jobname = _get_job_name(args, device, test)
+    _publish(instance, env, args, tmpl_name, jobname, **params)
+
+
+def _configure_master(instance, env, args, device, projects):
+    device_type = device[:device.index("-")]
+    trigger_url = ('http://cdimage.ubuntu.com/ubuntu-touch/daily-preinstalled/'
+                   'pending/MD5SUMS')
+    if SYSTEM_IMAGE:
+        fmt = 'http://system-image.ubuntu.com/daily/{}/index.json'
+        trigger_url = fmt.format(device_type)
+
+    params = {
+        'host': args.host,
+        'name': device,
+        'publish': args.publish,
+        'projects': projects,
+        'trigger_url': trigger_url
+    }
+    jobname = _get_job_name(args, device, _test('master'))
+    _publish(instance, env, args, 'touch-master.xml.jinja2', jobname, **params)
+
+
+def _dryrun_func(jobname, config):
+    logging.debug(jobname)
+    logging.debug(config)
+
+
+def main():
+    logging.basicConfig(level=logging.DEBUG)
+    args = _get_parser().parse_args()
+
+    jenkins_inst = _get_jenkins(args.jenkins, args.username, args.password)
+    if args.dryrun:
+        jenkins_inst.create_job = _dryrun_func
+        jenkins_inst.reconfig_job = _dryrun_func
+
+    env = _get_environment()
+
+    device_list = args.name if args.name else DEVICES
+
+    for device in device_list:
+        projects = []
+        for test in TESTS:
+            logging.debug("configuring job for %s", test.name)
+            if not test.restrict_to or device in test.restrict_to:
+                _configure_job(jenkins_inst, env, args, device, test)
+                projects.append(_get_job_name(args, device, test))
+            else:
+                logging.info('%s not configured for %s', device, test.name)
+
+        _configure_master(jenkins_inst, env, args, device, projects)
+
+if __name__ == '__main__':
+    main()

=== added directory 'jenkins/templates'
=== added file 'jenkins/templates/touch-address-book-app-autopilot.xml.jinja2'
--- jenkins/templates/touch-address-book-app-autopilot.xml.jinja2	1970-01-01 00:00:00 +0000
+++ jenkins/templates/touch-address-book-app-autopilot.xml.jinja2	2013-08-30 19:55:55 +0000
@@ -0,0 +1,6 @@
+{% extends "touch-autopilot-base.xml.jinja2" %}
+<?xml version='1.0' encoding='UTF-8'?>
+
+{% block apptest %}
+export APP=&quot;address-book-app-autopilot&quot;
+{% endblock %}

=== 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	2013-08-30 19:55:55 +0000
@@ -0,0 +1,23 @@
+{% 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
+      </command>
+{% 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	2013-08-30 19:55:55 +0000
@@ -0,0 +1,87 @@
+<?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;
+  lp:~canonical-platform-qa/ubuntu-test-runlists/touch-runlists&#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 BUILD DATE:([0-9]+.*)</regexp>
+      <regexpForFailed>^= TOUCH BUILD DATE:([0-9]+.*)</regexpForFailed>
+      <setForMatrix>false</setForMatrix>
+    </hudson.plugins.descriptionsetter.DescriptionSetterPublisher>
+{% endblock %}
+{% block mailer %}
+    <hudson.tasks.Mailer>
+      <recipients>[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 %}
+  </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>
+{% block locks %}
+    <hudson.plugins.locksandlatches.LockWrapper>
+      <locks>
+        <hudson.plugins.locksandlatches.LockWrapper_-LockWaitConfig>
+            <name>{{name}}</name>
+        </hudson.plugins.locksandlatches.LockWrapper_-LockWaitConfig>
+      </locks>
+    </hudson.plugins.locksandlatches.LockWrapper>
+{% endblock %}
+  </buildWrappers>
+</project>

=== added file 'jenkins/templates/touch-calendar-app-autopilot.xml.jinja2'
--- jenkins/templates/touch-calendar-app-autopilot.xml.jinja2	1970-01-01 00:00:00 +0000
+++ jenkins/templates/touch-calendar-app-autopilot.xml.jinja2	2013-08-30 19:55:55 +0000
@@ -0,0 +1,6 @@
+{% extends "touch-autopilot-base.xml.jinja2" %}
+<?xml version='1.0' encoding='UTF-8'?>
+
+{% block apptest %}
+export APP=&quot;calendar-app-autopilot&quot;
+{% endblock %}

=== added file 'jenkins/templates/touch-camera-app-autopilot.xml.jinja2'
--- jenkins/templates/touch-camera-app-autopilot.xml.jinja2	1970-01-01 00:00:00 +0000
+++ jenkins/templates/touch-camera-app-autopilot.xml.jinja2	2013-08-30 19:55:55 +0000
@@ -0,0 +1,6 @@
+{% extends "touch-autopilot-base.xml.jinja2" %}
+<?xml version='1.0' encoding='UTF-8'?>
+
+{% block apptest %}
+export APP=&quot;camera-app-autopilot&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	2013-08-30 19:55:55 +0000
@@ -0,0 +1,21 @@
+{% extends "touch-base.xml.jinja2" %}
+
+{% block triggers %}
+  <triggers class="vector"/>
+{% endblock %}
+{% block timeout %}
+  <timeoutMinutes>30</timeoutMinutes>
+{% endblock timeout %}
+
+{% block shellcmds %}
+      <command>rm -rf *
+{% include "touch-setup.xml.jinja2" %}
+
+${BZRDIR}/scripts/run-touch-utah-runlist.sh -s $ANDROID_SERIAL -r lp:~cjohnston/ubuntu-test-runlists/convergence/tests/touch-smoke-default.run
+</command>
+{% endblock %}
+
+{% block artifacts %}
+      <artifacts>clientlogs/*</artifacts>
+{% endblock %}
+

=== added file 'jenkins/templates/touch-dialer-app-autopilot.xml.jinja2'
--- jenkins/templates/touch-dialer-app-autopilot.xml.jinja2	1970-01-01 00:00:00 +0000
+++ jenkins/templates/touch-dialer-app-autopilot.xml.jinja2	2013-08-30 19:55:55 +0000
@@ -0,0 +1,6 @@
+{% extends "touch-autopilot-base.xml.jinja2" %}
+<?xml version='1.0' encoding='UTF-8'?>
+
+{% block apptest %}
+export APP=&quot;dialer-app-autopilot&quot;
+{% 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	2013-08-30 19:55:55 +0000
@@ -0,0 +1,21 @@
+{% extends "touch-base.xml.jinja2" %}
+<?xml version='1.0' encoding='UTF-8'?>
+{% block triggers %}
+  <triggers class="vector"/>
+{% endblock %}
+{% block timeout %}
+  <timeoutMinutes>45</timeoutMinutes>
+{% endblock timeout %}
+
+{% block shellcmds %}
+      <command>rm -rf *
+{% include "touch-setup.xml.jinja2" %}
+
+bzr branch lp:~ubuntu-test-case-dev/ubuntu-test-cases/qa-baseline-testing
+
+qa-baseline-testing/jenkins/run-touch-eventstat.sh -s $ANDROID_SERIAL</command>
+{% endblock %}
+
+{% block artifacts %}
+      <artifacts>results/**/*</artifacts>
+{% endblock %}

=== added file 'jenkins/templates/touch-friends-app-autopilot.xml.jinja2'
--- jenkins/templates/touch-friends-app-autopilot.xml.jinja2	1970-01-01 00:00:00 +0000
+++ jenkins/templates/touch-friends-app-autopilot.xml.jinja2	2013-08-30 19:55:55 +0000
@@ -0,0 +1,6 @@
+{% extends "touch-autopilot-base.xml.jinja2" %}
+<?xml version='1.0' encoding='UTF-8'?>
+
+{% block apptest %}
+export APP=&quot;friends-app-autopilot&quot;
+{% endblock %}

=== added file 'jenkins/templates/touch-gallery-app-autopilot.xml.jinja2'
--- jenkins/templates/touch-gallery-app-autopilot.xml.jinja2	1970-01-01 00:00:00 +0000
+++ jenkins/templates/touch-gallery-app-autopilot.xml.jinja2	2013-08-30 19:55:55 +0000
@@ -0,0 +1,6 @@
+{% extends "touch-autopilot-base.xml.jinja2" %}
+<?xml version='1.0' encoding='UTF-8'?>
+
+{% block apptest %}
+export APP=&quot;gallery-app-autopilot&quot;
+{% 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	2013-08-30 19:55:55 +0000
@@ -0,0 +1,37 @@
+{% 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" %}
+
+{% if system_image %}
+export TOUCH_IMAGE=--ubuntu-bootstrap
+{% endif %}
+#### DISABLED FOR TESTING
+#Wait for images to actually show up on cdimage
+#sleep 300
+${BZRDIR}/scripts/provision.sh
+
+${BZRDIR}/scripts/run-touch-utah-runlist.sh -s $ANDROID_SERIAL -r lp:~cjohnston/ubuntu-test-cases/convergence/tests/touch-smoke-boot.run
+      </command>
+{% endblock %}
+
+{% block artifacts %}
+      <artifacts>clientlogs/*</artifacts>
+{% endblock %}
+{% block descriptionsetter %}
+    <hudson.plugins.descriptionsetter.DescriptionSetterPublisher>
+      <regexp>Download directory set to /home/ubuntu/Downloads/phablet-flash/ubuntu-touch/([0-9]+.*)</regexp>
+      <regexpForFailed>Download directory set to /home/ubuntu/Downloads/phablet-flash/ubuntu-touch/([0-9]+.*)</regexpForFailed>
+      <setForMatrix>false</setForMatrix>
+    </hudson.plugins.descriptionsetter.DescriptionSetterPublisher>
+{% 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	2013-08-30 19:55:55 +0000
@@ -0,0 +1,54 @@
+{% 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 shellblock %}{% endblock %}
+{% block extrasteps %}
+{% for project in projects %}
+    <hudson.plugins.parameterizedtrigger.TriggerBuilder>
+      <configs>
+        <hudson.plugins.parameterizedtrigger.BlockableBuildTriggerConfig>
+          <configs class="java.util.Collections$EmptyList"/>
+          <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 locks %}{% endblock %}

=== added file 'jenkins/templates/touch-mediaplayer-app-autopilot.xml.jinja2'
--- jenkins/templates/touch-mediaplayer-app-autopilot.xml.jinja2	1970-01-01 00:00:00 +0000
+++ jenkins/templates/touch-mediaplayer-app-autopilot.xml.jinja2	2013-08-30 19:55:55 +0000
@@ -0,0 +1,6 @@
+{% extends "touch-autopilot-base.xml.jinja2" %}
+<?xml version='1.0' encoding='UTF-8'?>
+
+{% block apptest %}
+export APP=&quot;mediaplayer-app-autopilot&quot;
+{% 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	2013-08-30 19:55:55 +0000
@@ -0,0 +1,9 @@
+{% 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;
+{% endblock %}

=== added file 'jenkins/templates/touch-messaging-app-autopilot.xml.jinja2'
--- jenkins/templates/touch-messaging-app-autopilot.xml.jinja2	1970-01-01 00:00:00 +0000
+++ jenkins/templates/touch-messaging-app-autopilot.xml.jinja2	2013-08-30 19:55:55 +0000
@@ -0,0 +1,6 @@
+{% extends "touch-autopilot-base.xml.jinja2" %}
+<?xml version='1.0' encoding='UTF-8'?>
+
+{% block apptest %}
+export APP=&quot;messaging-app-autopilot&quot;
+{% endblock %}

=== added file 'jenkins/templates/touch-music-app-autopilot.xml.jinja2'
--- jenkins/templates/touch-music-app-autopilot.xml.jinja2	1970-01-01 00:00:00 +0000
+++ jenkins/templates/touch-music-app-autopilot.xml.jinja2	2013-08-30 19:55:55 +0000
@@ -0,0 +1,6 @@
+{% extends "touch-autopilot-base.xml.jinja2" %}
+<?xml version='1.0' encoding='UTF-8'?>
+
+{% block apptest %}
+export APP=&quot;music-app-autopilot&quot;
+{% endblock %}

=== added file 'jenkins/templates/touch-notes-app-autopilot.xml.jinja2'
--- jenkins/templates/touch-notes-app-autopilot.xml.jinja2	1970-01-01 00:00:00 +0000
+++ jenkins/templates/touch-notes-app-autopilot.xml.jinja2	2013-08-30 19:55:55 +0000
@@ -0,0 +1,6 @@
+{% extends "touch-autopilot-base.xml.jinja2" %}
+<?xml version='1.0' encoding='UTF-8'?>
+
+{% block apptest %}
+export APP=&quot;notes-app-autopilot&quot;
+{% endblock %}

=== added file 'jenkins/templates/touch-phone-app-connected-autopilot.xml.jinja2'
--- jenkins/templates/touch-phone-app-connected-autopilot.xml.jinja2	1970-01-01 00:00:00 +0000
+++ jenkins/templates/touch-phone-app-connected-autopilot.xml.jinja2	2013-08-30 19:55:55 +0000
@@ -0,0 +1,6 @@
+{% extends "touch-autopilot-base.xml.jinja2" %}
+<?xml version='1.0' encoding='UTF-8'?>
+
+{% block apptest %}
+export APP=&quot;phone-app-connected-autopilot&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	2013-08-30 19:55:55 +0000
@@ -0,0 +1,20 @@
+{% 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}/scripts/run-touch-utah-runlist.sh -s $ANDROID_SERIAL -r lp:~cjohnston/ubuntu-test-runlists/convergence/tests/touch-smoke-sdk.run
+</command>
+{% endblock %}
+
+{% block artifacts %}
+      <artifacts>clientlogs/*</artifacts>
+{% 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	2013-08-30 19:55:55 +0000
@@ -0,0 +1,20 @@
+{% 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}/scripts/run-touch-utah-runlist.sh -s $ANDROID_SERIAL -r lp:~cjohnston/ubuntu-test-runlists/convergence/tests/touch-smoke-security.run
+</command>
+{% endblock %}
+
+{% block artifacts %}
+      <artifacts>clientlogs/*</artifacts>
+{% 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	2013-08-30 19:55:55 +0000
@@ -0,0 +1,5 @@
+BRANCH=&quot;lp:~cjohnston/ubuntu-test-cases/convergence&quot;
+BZRDIR=`echo &quot;$BRANCH&quot; | awk -F/ &apos;{ print $(NF) }&apos;`
+bzr branch ${BRANCH} ${BZRDIR}
+
+export ANDROID_SERIAL=$(${BZRDIR}/scripts/get-adb-id {{name}})

=== added file 'jenkins/templates/touch-share-app-autopilot.xml.jinja2'
--- jenkins/templates/touch-share-app-autopilot.xml.jinja2	1970-01-01 00:00:00 +0000
+++ jenkins/templates/touch-share-app-autopilot.xml.jinja2	2013-08-30 19:55:55 +0000
@@ -0,0 +1,6 @@
+{% extends "touch-autopilot-base.xml.jinja2" %}
+<?xml version='1.0' encoding='UTF-8'?>
+
+{% block apptest %}
+export APP=&quot;share-app-autopilot&quot;
+{% endblock %}

=== 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	2013-08-30 19:55:55 +0000
@@ -0,0 +1,20 @@
+{% 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" %}
+
+${BZRDIR}/scripts/run-touch-utah-runlist.sh -s $ANDROID_SERIAL -p /tmp/results -r lp:~ubuntu-test-case-dev/ubuntu-test-cases/qa-baseline-testing/runlists/smem.run
+</command>
+{% endblock %}
+
+{% block artifacts %}
+      <artifacts>clientlogs/*,results/**/*</artifacts>
+{% endblock %}

=== added file 'jenkins/templates/touch-ubuntu-calculator-app-autopilot.xml.jinja2'
--- jenkins/templates/touch-ubuntu-calculator-app-autopilot.xml.jinja2	1970-01-01 00:00:00 +0000
+++ jenkins/templates/touch-ubuntu-calculator-app-autopilot.xml.jinja2	2013-08-30 19:55:55 +0000
@@ -0,0 +1,6 @@
+{% extends "touch-autopilot-base.xml.jinja2" %}
+<?xml version='1.0' encoding='UTF-8'?>
+
+{% block apptest %}
+export APP=&quot;ubuntu-calculator-app-autopilot&quot;
+{% endblock %}

=== added file 'jenkins/templates/touch-ubuntu-clock-app-autopilot.xml.jinja2'
--- jenkins/templates/touch-ubuntu-clock-app-autopilot.xml.jinja2	1970-01-01 00:00:00 +0000
+++ jenkins/templates/touch-ubuntu-clock-app-autopilot.xml.jinja2	2013-08-30 19:55:55 +0000
@@ -0,0 +1,6 @@
+{% extends "touch-autopilot-base.xml.jinja2" %}
+<?xml version='1.0' encoding='UTF-8'?>
+
+{% block apptest %}
+export APP=&quot;ubuntu-clock-app-autopilot&quot;
+{% endblock %}

=== added file 'jenkins/templates/touch-ubuntu-clock-autopilot.xml.jinja2'
--- jenkins/templates/touch-ubuntu-clock-autopilot.xml.jinja2	1970-01-01 00:00:00 +0000
+++ jenkins/templates/touch-ubuntu-clock-autopilot.xml.jinja2	2013-08-30 19:55:55 +0000
@@ -0,0 +1,6 @@
+{% extends "touch-autopilot-base.xml.jinja2" %}
+<?xml version='1.0' encoding='UTF-8'?>
+
+{% block apptest %}
+export APP=&quot;ubuntu-clock-autopilot&quot;
+{% endblock %}

=== added file 'jenkins/templates/touch-ubuntu-docviewer-app-autopilot.xml.jinja2'
--- jenkins/templates/touch-ubuntu-docviewer-app-autopilot.xml.jinja2	1970-01-01 00:00:00 +0000
+++ jenkins/templates/touch-ubuntu-docviewer-app-autopilot.xml.jinja2	2013-08-30 19:55:55 +0000
@@ -0,0 +1,6 @@
+{% extends "touch-autopilot-base.xml.jinja2" %}
+<?xml version='1.0' encoding='UTF-8'?>
+
+{% block apptest %}
+export APP=&quot;ubuntu-docviewer-app-autopilot&quot;
+{% endblock %}

=== added file 'jenkins/templates/touch-ubuntu-filemanager-app-autopilot.xml.jinja2'
--- jenkins/templates/touch-ubuntu-filemanager-app-autopilot.xml.jinja2	1970-01-01 00:00:00 +0000
+++ jenkins/templates/touch-ubuntu-filemanager-app-autopilot.xml.jinja2	2013-08-30 19:55:55 +0000
@@ -0,0 +1,6 @@
+{% extends "touch-autopilot-base.xml.jinja2" %}
+<?xml version='1.0' encoding='UTF-8'?>
+
+{% block apptest %}
+export APP=&quot;ubuntu-filemanager-app-autopilot&quot;
+{% endblock %}

=== added file 'jenkins/templates/touch-ubuntu-rssreader-app-autopilot.xml.jinja2'
--- jenkins/templates/touch-ubuntu-rssreader-app-autopilot.xml.jinja2	1970-01-01 00:00:00 +0000
+++ jenkins/templates/touch-ubuntu-rssreader-app-autopilot.xml.jinja2	2013-08-30 19:55:55 +0000
@@ -0,0 +1,6 @@
+{% extends "touch-autopilot-base.xml.jinja2" %}
+<?xml version='1.0' encoding='UTF-8'?>
+
+{% block apptest %}
+export APP=&quot;ubuntu-rssreader-app-autopilot&quot;
+{% endblock %}

=== added file 'jenkins/templates/touch-ubuntu-terminal-app-autopilot.xml.jinja2'
--- jenkins/templates/touch-ubuntu-terminal-app-autopilot.xml.jinja2	1970-01-01 00:00:00 +0000
+++ jenkins/templates/touch-ubuntu-terminal-app-autopilot.xml.jinja2	2013-08-30 19:55:55 +0000
@@ -0,0 +1,6 @@
+{% extends "touch-autopilot-base.xml.jinja2" %}
+<?xml version='1.0' encoding='UTF-8'?>
+
+{% block apptest %}
+export APP=&quot;ubuntu-terminal-app-autopilot&quot;
+{% endblock %}

=== added file 'jenkins/templates/touch-ubuntu-weather-app-autopilot.xml.jinja2'
--- jenkins/templates/touch-ubuntu-weather-app-autopilot.xml.jinja2	1970-01-01 00:00:00 +0000
+++ jenkins/templates/touch-ubuntu-weather-app-autopilot.xml.jinja2	2013-08-30 19:55:55 +0000
@@ -0,0 +1,6 @@
+{% extends "touch-autopilot-base.xml.jinja2" %}
+<?xml version='1.0' encoding='UTF-8'?>
+
+{% block apptest %}
+export APP=&quot;ubuntu-weather-app-autopilot&quot;
+{% endblock %}

=== added file 'jenkins/templates/touch-unity8-autopilot.xml.jinja2'
--- jenkins/templates/touch-unity8-autopilot.xml.jinja2	1970-01-01 00:00:00 +0000
+++ jenkins/templates/touch-unity8-autopilot.xml.jinja2	2013-08-30 19:55:55 +0000
@@ -0,0 +1,6 @@
+{% extends "touch-autopilot-base.xml.jinja2" %}
+<?xml version='1.0' encoding='UTF-8'?>
+
+{% block apptest %}
+export APP=&quot;unity8-autopilot&quot;
+{% endblock %}

=== 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	2013-08-30 19:55:55 +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/templates/touch-webbrowser-app-autopilot.xml.jinja2'
--- jenkins/templates/touch-webbrowser-app-autopilot.xml.jinja2	1970-01-01 00:00:00 +0000
+++ jenkins/templates/touch-webbrowser-app-autopilot.xml.jinja2	2013-08-30 19:55:55 +0000
@@ -0,0 +1,6 @@
+{% extends "touch-autopilot-base.xml.jinja2" %}
+<?xml version='1.0' encoding='UTF-8'?>
+
+{% block apptest %}
+export APP=&quot;webbrowser-app-autopilot&quot;
+{% endblock %}

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

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

=== added file 'scripts/run-touch-utah-runlist.sh'
--- scripts/run-touch-utah-runlist.sh	1970-01-01 00:00:00 +0000
+++ scripts/run-touch-utah-runlist.sh	2013-08-30 19:55:55 +0000
@@ -0,0 +1,66 @@
+#!/bin/bash
+# Run tests on ubuntu-touch devices and gather the results
+# Set $RUNLIST to the runlist you wish to run
+set -x
+
+BRANCH=lp:~canonical-platform-qa/ubuntu-test-runlists/touch-runlists
+WORKSPACE=/home/phablet/workspace
+RESDIR=`pwd`/clientlogs
+UTAHFILE=${RESDIR}/utah.yaml
+UTAH_PHABLET_CMD="${UTAH_PHABLET_CMD-/usr/share/utah/examples/run_utah_phablet.py}"
+
+function show_usage() {
+    echo "USAGE: $0 -s ANDROID_SERIAL -r RUNLIST"
+    echo "     -p - List of additional files/dirs to pull from target"
+    exit 0
+}
+
+while getopts "h?p:r:s:" opt; do
+    case "$opt" in
+    h|\?)
+        show_usage
+        ;;
+    p)  PULL_LIST=$OPTARG
+        ;;
+    r)  RUNLIST=$OPTARG
+        ;;
+    s)  ANDROID_SERIAL=$OPTARG
+        ;;
+    esac
+done
+if [ -z $ANDROID_SERIAL ]; then show_usage; fi
+
+if [ -n "$PULL_LIST" ]; then
+    PULL="--pull $PULL_LIST"
+fi
+
+if [ -z $QUICK ]; then
+    adb -s $ANDROID_SERIAL reboot
+    adb -s $ANDROID_SERIAL wait-for-device
+    sleep 5
+    adb -s $ANDROID_SERIAL wait-for-device
+    phablet-network -s ${ANDROID_SERIAL} --skip-setup
+else
+    echo "SKIPPING phone reboot..."
+fi
+rm -rf ${RESDIR}
+mkdir -p ${RESDIR}
+adb -s ${ANDROID_SERIAL} pull /var/log/installer/media-info ${RESDIR}
+BUILDID=`cat ${RESDIR}/media-info | awk '{ print $(NF)}' | sed -e 's/(//' -e 's/)//'`
+echo "= TOUCH BUILD DATE:$BUILDID"
+
+${UTAH_PHABLET_CMD} \
+    -s ${ANDROID_SERIAL} \
+    --results-dir ${RESDIR} \
+    --skip-install --skip-network --skip-utah \
+    ${PULL} \
+    -l ${RUNLIST}
+
+if ! `grep "^errors: [!0]" < $UTAHFILE >/dev/null` ; then
+    echo "errors found"
+    exit 1
+fi
+if ! `grep "^failures: [!0]" < $UTAHFILE >/dev/null` ; then
+    echo "failures found"
+    exit 2
+fi

=== 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	2013-08-30 19:55:55 +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	2013-08-30 19:55:55 +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	2013-08-30 19:55:55 +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	2013-08-30 19:55:55 +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	2013-08-30 19:55:55 +0000
@@ -0,0 +1,1 @@
+ts_setup: PKGS=calendar-app-autopilot 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	2013-08-30 19:55:55 +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	2013-08-30 19:55:55 +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	2013-08-30 19:55:55 +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	2013-08-30 19:55:55 +0000
@@ -0,0 +1,4 @@
+-
+  discovery_cmd: autopilot-list camera_app
+  test_cmd: autopilot-run camera_app.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	2013-08-30 19:55:55 +0000
@@ -0,0 +1,14 @@
+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: ifconfig; ifconfig | grep wlan0
+run_as: phablet
+#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	2013-08-30 19:55:55 +0000
@@ -0,0 +1,13 @@
+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: apt-get install -y curl
+run_as: root
+#build_cmd:
+#tc_setup:
+tc_cleanup: 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	2013-08-30 19:55:55 +0000
@@ -0,0 +1,5 @@
+---
+testsuites:
+  - name: smoke_touch
+    fetch_method: bzr  # one of 'bzr', 'bzr-export', 'dev', 'git'
+    fetch_location: lp:ubuntu-test-cases/touch

=== 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	2013-08-30 19:55:55 +0000
@@ -0,0 +1,13 @@
+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: netstat -l
+run_as: phablet
+#build_cmd:
+#tc_setup:
+#tc_cleanup:

=== added directory 'tests/default/ping'
=== added file 'tests/default/ping/tc_control'
--- tests/default/ping/tc_control	1970-01-01 00:00:00 +0000
+++ tests/default/ping/tc_control	2013-08-30 19:55:55 +0000
@@ -0,0 +1,13 @@
+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: ping -c 5 $(ip route show | awk '/default via/ { print $3 }')
+run_as: phablet
+#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	2013-08-30 19:55:55 +0000
@@ -0,0 +1,10 @@
+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
+run_as: phablet

=== added file 'tests/default/pwd/test.sh'
--- tests/default/pwd/test.sh	1970-01-01 00:00:00 +0000
+++ tests/default/pwd/test.sh	2013-08-30 19:55:55 +0000
@@ -0,0 +1,7 @@
+#!/bin/bash
+echo pwd is: $(pwd)
+echo Changing to /tmp...
+cd /tmp
+echo Checking that cd worked...
+echo directory is now $(pwd), should be /tmp
+/usr/bin/test $(pwd) == '/tmp'

=== 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	2013-08-30 19:55:55 +0000
@@ -0,0 +1,13 @@
+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: route -n | grep wlan0
+run_as: phablet
+#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	2013-08-30 19:55:55 +0000
@@ -0,0 +1,124 @@
+#!/bin/bash
+
+set -e
+
+# default exit code storage
+dump_error=1
+
+calc () { awk "BEGIN{ print $* }" ;}
+
+cleanup () {
+  if ! test "$dump_error" = 0; then
+    echo "Check out the following top log taken at each retry:"
+
+    echo
+    # dumb toplog indented
+    while read line; do
+      echo "  $line"
+    done < $top_log
+    # dont rerun this logic in case we get multiple signals
+    dump_error=0
+  fi
+  rm -f $top_log $top_log.reduced
+}
+
+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)"
+   exit 129
+}
+
+while getopts "h?rp:c:d:i:m:" 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
+              ;;
+    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}
+
+# 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
+
+trap cleanup EXIT INT QUIT ILL KILL SEGV TERM
+top_log=`mktemp -t`
+
+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
+  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	2013-08-30 19:55:55 +0000
@@ -0,0 +1,10 @@
+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 -p 97.5
+run_as: root

=== added file 'tests/default/ts_control'
--- tests/default/ts_control	1970-01-01 00:00:00 +0000
+++ tests/default/ts_control	2013-08-30 19:55:55 +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	2013-08-30 19:55:55 +0000
@@ -0,0 +1,11 @@
+- test: pwd
+- test: uname
+- test: vmstat
+- test: systemsettle
+- test: netstat
+- test: ifconfig
+- test: route
+- test: ping
+- test: update
+- 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	2013-08-30 19:55:55 +0000
@@ -0,0 +1,13 @@
+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: uname -a | grep ubuntu-phablet
+run_as: 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	2013-08-30 19:55:55 +0000
@@ -0,0 +1,10 @@
+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: /usr/bin/pgrep unity8
+run_as: phablet

=== added directory 'tests/default/update'
=== added file 'tests/default/update/tc_control'
--- tests/default/update/tc_control	1970-01-01 00:00:00 +0000
+++ tests/default/update/tc_control	2013-08-30 19:55:55 +0000
@@ -0,0 +1,13 @@
+description: apt-get update works
+dependencies: apt
+action: |
+  1. apt-get update
+expected_results: |
+  1. apt-get update works
+type: userland
+timeout: 300
+command: apt-get update
+run_as: root
+#build_cmd:
+#tc_setup:
+#tc_cleanup:

=== 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	2013-08-30 19:55:55 +0000
@@ -0,0 +1,13 @@
+description: Execute vmstat and capture output
+dependencies: none
+action: |
+  1. vmstat
+expected_results: |
+  1. vmstat finishes without an error
+type: userland
+timeout: 60
+command: vmstat
+run_as: phablet
+#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	2013-08-30 19:55:55 +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	2013-08-30 19:55:55 +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	2013-08-30 19:55:55 +0000
@@ -0,0 +1,4 @@
+-
+  discovery_cmd: autopilot-list dialer_app
+  test_cmd: autopilot-run dialer_app.tests.{}
+

=== 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	2013-08-30 19:55:55 +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	2013-08-30 19:55:55 +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	2013-08-30 19:55:55 +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	2013-08-30 19:55:55 +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	2013-08-30 19:55:55 +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	2013-08-30 19:55:55 +0000
@@ -0,0 +1,4 @@
+-
+  discovery_cmd: autopilot-list gallery_app
+  test_cmd: autopilot-run gallery_app.tests.{}
+

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

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

=== added directory '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	2013-08-30 19:55:55 +0000
@@ -0,0 +1,15 @@
+---
+testsuites:
+  - name: settle-before
+    fetch_method: dev
+    fetch_location: ../systemsettle
+    include_tests:
+      - systemsettle-before
+  - name: messaging-app-autopilot
+    fetch_method: dev
+    fetch_location: ./
+  - name: settle-after
+    fetch_method: dev
+    fetch_location: ../systemsettle
+    include_tests:
+      - systemsettle-after

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

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

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

=== added file 'tests/music-app-autopilot/ts_control'
--- tests/music-app-autopilot/ts_control	1970-01-01 00:00:00 +0000
+++ tests/music-app-autopilot/ts_control	2013-08-30 19:55:55 +0000
@@ -0,0 +1,1 @@
+ts_setup: PKGS=music-app-autopilot prepare-autopilot-test.sh

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

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

=== added file 'tests/notes-app-autopilot/ts_control'
--- tests/notes-app-autopilot/ts_control	1970-01-01 00:00:00 +0000
+++ tests/notes-app-autopilot/ts_control	2013-08-30 19:55:55 +0000
@@ -0,0 +1,1 @@
+ts_setup: PKGS=notes-app-autopilot prepare-autopilot-test.sh

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

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

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

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

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

=== added file 'tests/phone-app-connected-autopilot/ts_control'
--- tests/phone-app-connected-autopilot/ts_control	1970-01-01 00:00:00 +0000
+++ tests/phone-app-connected-autopilot/ts_control	2013-08-30 19:55:55 +0000
@@ -0,0 +1,1 @@
+ts_setup: sh ./setup.sh

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

=== added file 'tests/run-touch-upgrade.sh'
--- tests/run-touch-upgrade.sh	1970-01-01 00:00:00 +0000
+++ tests/run-touch-upgrade.sh	2013-08-30 19:55:55 +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 directory 'tests/share-app-autopilot'
=== added file 'tests/share-app-autopilot/master.run'
--- tests/share-app-autopilot/master.run	1970-01-01 00:00:00 +0000
+++ tests/share-app-autopilot/master.run	2013-08-30 19:55:55 +0000
@@ -0,0 +1,15 @@
+---
+testsuites:
+  - name: settle-before
+    fetch_method: dev
+    fetch_location: ../systemsettle
+    include_tests:
+      - systemsettle-before
+  - name: share-app-autopilot
+    fetch_method: dev
+    fetch_location: ./
+  - name: settle-after
+    fetch_method: dev
+    fetch_location: ../systemsettle
+    include_tests:
+      - systemsettle-after

=== added file 'tests/share-app-autopilot/ts_control'
--- tests/share-app-autopilot/ts_control	1970-01-01 00:00:00 +0000
+++ tests/share-app-autopilot/ts_control	2013-08-30 19:55:55 +0000
@@ -0,0 +1,1 @@
+ts_setup: PKGS=share-app-autopilot prepare-autopilot-test.sh

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

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

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

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

=== added file 'tests/systemsettle/tslist.run'
--- tests/systemsettle/tslist.run	1970-01-01 00:00:00 +0000
+++ tests/systemsettle/tslist.run	2013-08-30 19:55:55 +0000
@@ -0,0 +1,2 @@
+- test: systemsettle-before
+- test: systemsettle-after

=== added file 'tests/touch-smoke-boot.run'
--- tests/touch-smoke-boot.run	1970-01-01 00:00:00 +0000
+++ tests/touch-smoke-boot.run	2013-08-30 19:55:55 +0000
@@ -0,0 +1,6 @@
+testsuites:
+  - name: usit
+    fetch_method: bzr-export
+    fetch_location: lp:ubuntu-test-cases/desktop/testsuites/usit
+    include_tests:
+      - read_write

=== added file 'tests/touch-smoke-default.run'
--- tests/touch-smoke-default.run	1970-01-01 00:00:00 +0000
+++ tests/touch-smoke-default.run	2013-08-30 19:55:55 +0000
@@ -0,0 +1,4 @@
+testsuites:
+  - name: touch
+    fetch_method: bzr-export
+    fetch_location: lp:ubuntu-test-cases/touch

=== added file 'tests/touch-smoke-sdk.run'
--- tests/touch-smoke-sdk.run	1970-01-01 00:00:00 +0000
+++ tests/touch-smoke-sdk.run	2013-08-30 19:55:55 +0000
@@ -0,0 +1,4 @@
+testsuites:
+  - name: sdk
+    fetch_method: bzr-export
+    fetch_location: lp:~ubuntu-test-case-dev/ubuntu-test-cases/package-checks/sdk

=== added file 'tests/touch-smoke-security.run'
--- tests/touch-smoke-security.run	1970-01-01 00:00:00 +0000
+++ tests/touch-smoke-security.run	2013-08-30 19:55:55 +0000
@@ -0,0 +1,4 @@
+testsuites:
+  - name: image
+    fetch_method: bzr-export
+    fetch_location: lp:~ubuntu-test-case-dev/ubuntu-test-cases/package-checks/image

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

=== added file 'tests/ubuntu-calculator-app-autopilot/ts_control'
--- tests/ubuntu-calculator-app-autopilot/ts_control	1970-01-01 00:00:00 +0000
+++ tests/ubuntu-calculator-app-autopilot/ts_control	2013-08-30 19:55:55 +0000
@@ -0,0 +1,1 @@
+ts_setup: PKGS=ubuntu-calculator-app-autopilot prepare-autopilot-test.sh

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

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

=== added file 'tests/ubuntu-clock-app-autopilot/ts_control'
--- tests/ubuntu-clock-app-autopilot/ts_control	1970-01-01 00:00:00 +0000
+++ tests/ubuntu-clock-app-autopilot/ts_control	2013-08-30 19:55:55 +0000
@@ -0,0 +1,1 @@
+ts_setup: PKGS=ubuntu-clock-app-autopilot prepare-autopilot-test.sh

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

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

=== added file 'tests/ubuntu-docviewer-app-autopilot/ts_control'
--- tests/ubuntu-docviewer-app-autopilot/ts_control	1970-01-01 00:00:00 +0000
+++ tests/ubuntu-docviewer-app-autopilot/ts_control	2013-08-30 19:55:55 +0000
@@ -0,0 +1,1 @@
+ts_setup: PKGS=ubuntu-docviewer-app-autopilot prepare-autopilot-test.sh

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

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

=== added file 'tests/ubuntu-filemanager-app-autopilot/ts_control'
--- tests/ubuntu-filemanager-app-autopilot/ts_control	1970-01-01 00:00:00 +0000
+++ tests/ubuntu-filemanager-app-autopilot/ts_control	2013-08-30 19:55:55 +0000
@@ -0,0 +1,1 @@
+ts_setup: PKGS=ubuntu-filemanager-app-autopilot prepare-autopilot-test.sh

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

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

=== added file 'tests/ubuntu-rssreader-app-autopilot/ts_control'
--- tests/ubuntu-rssreader-app-autopilot/ts_control	1970-01-01 00:00:00 +0000
+++ tests/ubuntu-rssreader-app-autopilot/ts_control	2013-08-30 19:55:55 +0000
@@ -0,0 +1,1 @@
+ts_setup: PKGS=ubuntu-rssreader-app-autopilot prepare-autopilot-test.sh

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

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

=== added file 'tests/ubuntu-terminal-app-autopilot/ts_control'
--- tests/ubuntu-terminal-app-autopilot/ts_control	1970-01-01 00:00:00 +0000
+++ tests/ubuntu-terminal-app-autopilot/ts_control	2013-08-30 19:55:55 +0000
@@ -0,0 +1,1 @@
+ts_setup: PKGS=ubuntu-terminal-app-autopilot prepare-autopilot-test.sh

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

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

=== added file 'tests/ubuntu-weather-app-autopilot/ts_control'
--- tests/ubuntu-weather-app-autopilot/ts_control	1970-01-01 00:00:00 +0000
+++ tests/ubuntu-weather-app-autopilot/ts_control	2013-08-30 19:55:55 +0000
@@ -0,0 +1,1 @@
+ts_setup: PKGS=ubuntu-weather-app-autopilot prepare-autopilot-test.sh

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

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

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

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

=== added file 'tests/unity8-autopilot/tslist.auto'
--- tests/unity8-autopilot/tslist.auto	1970-01-01 00:00:00 +0000
+++ tests/unity8-autopilot/tslist.auto	2013-08-30 19:55:55 +0000
@@ -0,0 +1,4 @@
+-
+  discovery_cmd: autopilot-list unity8 unity8 unity8.
+  test_cmd: autopilot-run unity8.{}
+

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

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

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

=== added file 'tests/upgrade/master.run'
--- tests/upgrade/master.run	1970-01-01 00:00:00 +0000
+++ tests/upgrade/master.run	2013-08-30 19:55:55 +0000
@@ -0,0 +1,5 @@
+---
+testsuites:
+  - name: upgrade
+    fetch_method: dev
+    fetch_location: ./

=== added file 'tests/upgrade/tslist.run'
--- tests/upgrade/tslist.run	1970-01-01 00:00:00 +0000
+++ tests/upgrade/tslist.run	2013-08-30 19:55:55 +0000
@@ -0,0 +1,2 @@
+- test: install_old
+- test: upgrade

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

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

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

=== added file 'tests/webbrowser-app-autopilot/ts_control'
--- tests/webbrowser-app-autopilot/ts_control	1970-01-01 00:00:00 +0000
+++ tests/webbrowser-app-autopilot/ts_control	2013-08-30 19:55:55 +0000
@@ -0,0 +1,1 @@
+ts_setup: PKGS=webbrowser-app-autopilot prepare-autopilot-test.sh

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

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

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

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

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

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

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

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

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

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