Add m-esr52 at 52.6.0

22 files changed, 1008 insertions, 0 deletions

diff --git a/testing/mozbase/mozdevice/tests/droidsut_launch.py b/testing/mozbase/mozdevice/tests/droidsut_launch.py
new file mode 100644
index 000000000..b9872e096
--- /dev/null
+++ b/testing/mozbase/mozdevice/tests/droidsut_launch.py
@@ -0,0 +1,36 @@
+from sut import MockAgent
+import mozdevice
+import logging
+import unittest
+
+
+class LaunchTest(unittest.TestCase):
+
+    def test_nouserserial(self):
+        a = MockAgent(self, commands=[("ps",
+                                       "10029	549	com.android.launcher\n"
+                                       "10066	1198	com.twitter.android"),
+                                      ("info sutuserinfo", ""),
+                                      ("exec am start -W -n "
+                                       "org.mozilla.fennec/org.mozilla.gecko.BrowserApp -a "
+                                       "android.intent.action.VIEW",
+                                       "OK\nreturn code [0]")])
+        d = mozdevice.DroidSUT("127.0.0.1", port=a.port, logLevel=logging.DEBUG)
+        d.launchFennec("org.mozilla.fennec")
+        a.wait()
+
+    def test_userserial(self):
+        a = MockAgent(self, commands=[("ps",
+                                       "10029	549	com.android.launcher\n"
+                                       "10066	1198	com.twitter.android"),
+                                      ("info sutuserinfo", "User Serial:0"),
+                                      ("exec am start --user 0 -W -n "
+                                       "org.mozilla.fennec/org.mozilla.gecko.BrowserApp -a "
+                                       "android.intent.action.VIEW",
+                                       "OK\nreturn code [0]")])
+        d = mozdevice.DroidSUT("127.0.0.1", port=a.port, logLevel=logging.DEBUG)
+        d.launchFennec("org.mozilla.fennec")
+        a.wait()
+
+if __name__ == '__main__':
+    unittest.main()
diff --git a/testing/mozbase/mozdevice/tests/manifest.ini b/testing/mozbase/mozdevice/tests/manifest.ini
new file mode 100644
index 000000000..63825c85b
--- /dev/null
+++ b/testing/mozbase/mozdevice/tests/manifest.ini
@@ -0,0 +1,23 @@
+[DEFAULT]
+skip-if = os == 'win'
+
+[sut_app.py]
+[sut_basic.py]
+[sut_chmod.py]
+[sut_copytree.py]
+[sut_fileExists.py]
+[sut_fileMethods.py]
+[sut_info.py]
+[sut_ip.py]
+[sut_kill.py]
+[sut_list.py]
+[sut_logcat.py]
+[sut_mkdir.py]
+[sut_movetree.py]
+[sut_ps.py]
+[sut_push.py]
+[sut_pull.py]
+[sut_remove.py]
+[sut_time.py]
+[sut_unpackfile.py]
+[droidsut_launch.py]
diff --git a/testing/mozbase/mozdevice/tests/sut.py b/testing/mozbase/mozdevice/tests/sut.py
new file mode 100644
index 000000000..76a5ed313
--- /dev/null
+++ b/testing/mozbase/mozdevice/tests/sut.py
@@ -0,0 +1,89 @@
+#!/usr/bin/env python
+
+# Any copyright is dedicated to the Public Domain.
+# http://creativecommons.org/publicdomain/zero/1.0/
+
+import datetime
+import socket
+import time
+
+from threading import Thread
+
+
+class MockAgent(object):
+
+    MAX_WAIT_TIME_SECONDS = 10
+    SOCKET_TIMEOUT_SECONDS = 5
+
+    def __init__(self, tester, start_commands=None, commands=[]):
+        if start_commands:
+            self.commands = start_commands
+        else:
+            self.commands = [("ver", "SUTAgentAndroid Version 1.14")]
+        self.commands = self.commands + commands
+
+        self._sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
+        self._sock.bind(("127.0.0.1", 0))
+        self._sock.listen(1)
+
+        self.tester = tester
+
+        self.thread = Thread(target=self._serve_thread)
+        self.thread.start()
+
+        self.should_stop = False
+
+    @property
+    def port(self):
+        return self._sock.getsockname()[1]
+
+    def _serve_thread(self):
+        conn = None
+        while self.commands:
+            if not conn:
+                conn, addr = self._sock.accept()
+                conn.settimeout(self.SOCKET_TIMEOUT_SECONDS)
+                conn.send("$>\x00")
+            (command, response) = self.commands.pop(0)
+            data = ''
+            timeout = datetime.datetime.now() + datetime.timedelta(
+                seconds=self.MAX_WAIT_TIME_SECONDS)
+            # The data might come in chunks, particularly if we are expecting
+            # multiple lines, as with push commands.
+            while (len(data) < len(command) and
+                   datetime.datetime.now() < timeout):
+                try:
+                    data += conn.recv(1024)
+                except socket.timeout:
+                    # We handle timeouts in the main loop.
+                    pass
+            self.tester.assertEqual(data.strip(), command)
+            # send response and prompt separately to test for bug 789496
+            # FIXME: Improve the mock agent, since overloading the meaning
+            # of 'response' is getting confusing.
+            if response is None:  # code for "shut down"
+                conn.shutdown(socket.SHUT_RDWR)
+                conn.close()
+                conn = None
+            elif type(response) is int:  # code for "time out"
+                max_timeout = 15.0
+                timeout = 0.0
+                interval = 0.1
+                while not self.should_stop and timeout < max_timeout:
+                    time.sleep(interval)
+                    timeout += interval
+                if timeout >= max_timeout:
+                    raise Exception("Maximum timeout reached! This should not "
+                                    "happen")
+                return
+            else:
+                # pull is handled specially, as we just pass back the full
+                # command line
+                if "pull" in command:
+                    conn.send(response)
+                else:
+                    conn.send("%s\n" % response)
+                conn.send("$>\x00")
+
+    def wait(self):
+        self.thread.join()
diff --git a/testing/mozbase/mozdevice/tests/sut_app.py b/testing/mozbase/mozdevice/tests/sut_app.py
new file mode 100644
index 000000000..0a5d996ae
--- /dev/null
+++ b/testing/mozbase/mozdevice/tests/sut_app.py
@@ -0,0 +1,20 @@
+#!/usr/bin/env python
+import mozdevice
+import logging
+import unittest
+from sut import MockAgent
+
+
+class TestApp(unittest.TestCase):
+
+    def test_getAppRoot(self):
+        command = [("getapproot org.mozilla.firefox",
+                    "/data/data/org.mozilla.firefox")]
+
+        m = MockAgent(self, commands=command)
+        d = mozdevice.DroidSUT("127.0.0.1", port=m.port, logLevel=logging.DEBUG)
+
+        self.assertEqual(command[0][1], d.getAppRoot('org.mozilla.firefox'))
+
+if __name__ == '__main__':
+    unittest.main()
diff --git a/testing/mozbase/mozdevice/tests/sut_basic.py b/testing/mozbase/mozdevice/tests/sut_basic.py
new file mode 100644
index 000000000..666d4915c
--- /dev/null
+++ b/testing/mozbase/mozdevice/tests/sut_basic.py
@@ -0,0 +1,73 @@
+from sut import MockAgent
+import mozdevice
+import logging
+import unittest
+
+
+class BasicTest(unittest.TestCase):
+
+    def test_init(self):
+        """Tests DeviceManager initialization."""
+        a = MockAgent(self)
+
+        mozdevice.DroidSUT("127.0.0.1", port=a.port, logLevel=logging.DEBUG)
+        # all testing done in device's constructor
+        a.wait()
+
+    def test_init_err(self):
+        """Tests error handling during initialization."""
+        a = MockAgent(self, start_commands=[("ver", "##AGENT-WARNING## No version")])
+        self.assertRaises(mozdevice.DMError,
+                          lambda: mozdevice.DroidSUT("127.0.0.1",
+                                                     port=a.port,
+                                                     logLevel=logging.DEBUG))
+        a.wait()
+
+    def test_timeout_normal(self):
+        """Tests DeviceManager timeout, normal case."""
+        a = MockAgent(self, commands=[("isdir /mnt/sdcard/tests", "TRUE"),
+                                      ("cd /mnt/sdcard/tests", ""),
+                                      ("ls", "test.txt"),
+                                      ("rm /mnt/sdcard/tests/test.txt",
+                                       "Removed the file")])
+        d = mozdevice.DroidSUT("127.0.0.1", port=a.port, logLevel=logging.DEBUG)
+        ret = d.removeFile('/mnt/sdcard/tests/test.txt')
+        self.assertEqual(ret, None)  # if we didn't throw an exception, we're ok
+        a.wait()
+
+    def test_timeout_timeout(self):
+        """Tests DeviceManager timeout, timeout case."""
+        a = MockAgent(self, commands=[("isdir /mnt/sdcard/tests", "TRUE"),
+                                      ("cd /mnt/sdcard/tests", ""),
+                                      ("ls", "test.txt"),
+                                      ("rm /mnt/sdcard/tests/test.txt", 0)])
+        d = mozdevice.DroidSUT("127.0.0.1", port=a.port, logLevel=logging.DEBUG)
+        d.default_timeout = 1
+        exceptionThrown = False
+        try:
+            d.removeFile('/mnt/sdcard/tests/test.txt')
+        except mozdevice.DMError:
+            exceptionThrown = True
+        self.assertEqual(exceptionThrown, True)
+        a.should_stop = True
+        a.wait()
+
+    def test_shell(self):
+        """Tests shell command"""
+        for cmd in [("exec foobar", False), ("execsu foobar", True)]:
+            for retcode in [1, 2]:
+                a = MockAgent(self, commands=[(cmd[0],
+                                               "\nreturn code [%s]" % retcode)])
+                d = mozdevice.DroidSUT("127.0.0.1", port=a.port)
+                exceptionThrown = False
+                try:
+                    d.shellCheckOutput(["foobar"], root=cmd[1])
+                except mozdevice.DMError:
+                    exceptionThrown = True
+                expectedException = (retcode != 0)
+                self.assertEqual(exceptionThrown, expectedException)
+
+                a.wait()
+
+if __name__ == '__main__':
+    unittest.main()
diff --git a/testing/mozbase/mozdevice/tests/sut_chmod.py b/testing/mozbase/mozdevice/tests/sut_chmod.py
new file mode 100644
index 000000000..404330c03
--- /dev/null
+++ b/testing/mozbase/mozdevice/tests/sut_chmod.py
@@ -0,0 +1,22 @@
+#!/usr/bin/env python
+import mozdevice
+import logging
+import unittest
+from sut import MockAgent
+
+
+class TestChmod(unittest.TestCase):
+
+    def test_chmod(self):
+
+        command = [('chmod /mnt/sdcard/test',
+                    'Changing permissions for /storage/emulated/legacy/Test\n'
+                    '        <empty>\n'
+                    'chmod /storage/emulated/legacy/Test ok\n')]
+        m = MockAgent(self, commands=command)
+        d = mozdevice.DroidSUT('127.0.0.1', port=m.port, logLevel=logging.DEBUG)
+
+        self.assertEqual(None, d.chmodDir('/mnt/sdcard/test'))
+
+if __name__ == '__main__':
+    unittest.main()
diff --git a/testing/mozbase/mozdevice/tests/sut_copytree.py b/testing/mozbase/mozdevice/tests/sut_copytree.py
new file mode 100644
index 000000000..ec22828d0
--- /dev/null
+++ b/testing/mozbase/mozdevice/tests/sut_copytree.py
@@ -0,0 +1,67 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+
+# This Source Code Form is subject to the terms of the Mozilla Public
+# License, v. 2.0. If a copy of the MPL was not distributed with this file,
+# You can obtain one at http://mozilla.org/MPL/2.0/.
+
+import mozdevice
+import logging
+import unittest
+from sut import MockAgent
+
+
+class CopyTreeTest(unittest.TestCase):
+
+    def test_copyFile(self):
+        commands = [('dd if=/mnt/sdcard/tests/test.txt of=/mnt/sdcard/tests/test2.txt', ''),
+                    ('isdir /mnt/sdcard/tests', 'TRUE'),
+                    ('cd /mnt/sdcard/tests', ''),
+                    ('ls', 'test.txt\ntest2.txt')]
+
+        m = MockAgent(self, commands=commands)
+        d = mozdevice.DroidSUT("127.0.0.1", port=m.port, logLevel=logging.DEBUG)
+
+        self.assertEqual(None, d.copyTree('/mnt/sdcard/tests/test.txt',
+                                          '/mnt/sdcard/tests/test2.txt'))
+        expected = (commands[3][1].strip()).split('\n')
+        self.assertEqual(expected, d.listFiles('/mnt/sdcard/tests'))
+
+    def test_copyDir(self):
+        commands = [('dd if=/mnt/sdcard/tests/foo of=/mnt/sdcard/tests/bar', ''),
+                    ('isdir /mnt/sdcard/tests', 'TRUE'),
+                    ('cd /mnt/sdcard/tests', ''),
+                    ('ls', 'foo\nbar')]
+
+        m = MockAgent(self, commands=commands)
+        d = mozdevice.DroidSUT("127.0.0.1", port=m.port,
+                               logLevel=logging.DEBUG)
+
+        self.assertEqual(None, d.copyTree('/mnt/sdcard/tests/foo',
+                                          '/mnt/sdcard/tests/bar'))
+        expected = (commands[3][1].strip()).split('\n')
+        self.assertEqual(expected, d.listFiles('/mnt/sdcard/tests'))
+
+    def test_copyNonEmptyDir(self):
+        commands = [('isdir /mnt/sdcard/tests/foo/bar', 'TRUE'),
+                    ('dd if=/mnt/sdcard/tests/foo of=/mnt/sdcard/tests/foo2', ''),
+                    ('isdir /mnt/sdcard/tests', 'TRUE'),
+                    ('cd /mnt/sdcard/tests', ''),
+                    ('ls', 'foo\nfoo2'),
+                    ('isdir /mnt/sdcard/tests/foo2', 'TRUE'),
+                    ('cd /mnt/sdcard/tests/foo2', ''),
+                    ('ls', 'bar')]
+
+        m = MockAgent(self, commands=commands)
+        d = mozdevice.DroidSUT("127.0.0.1", port=m.port,
+                               logLevel=logging.DEBUG)
+
+        self.assertTrue(d.dirExists('/mnt/sdcard/tests/foo/bar'))
+        self.assertEqual(None, d.copyTree('/mnt/sdcard/tests/foo',
+                                          '/mnt/sdcard/tests/foo2'))
+        expected = (commands[4][1].strip()).split('\n')
+        self.assertEqual(expected, d.listFiles('/mnt/sdcard/tests'))
+        self.assertTrue(d.fileExists('/mnt/sdcard/tests/foo2/bar'))
+
+if __name__ == "__main__":
+    unittest.main()
diff --git a/testing/mozbase/mozdevice/tests/sut_fileExists.py b/testing/mozbase/mozdevice/tests/sut_fileExists.py
new file mode 100644
index 000000000..702fd2de3
--- /dev/null
+++ b/testing/mozbase/mozdevice/tests/sut_fileExists.py
@@ -0,0 +1,29 @@
+from sut import MockAgent
+import mozdevice
+import unittest
+
+
+class FileExistsTest(unittest.TestCase):
+
+    commands = [('isdir /', 'TRUE'),
+                ('cd /', ''),
+                ('ls', 'init')]
+
+    def test_onRoot(self):
+        root_commands = [('isdir /', 'TRUE')]
+        a = MockAgent(self, commands=root_commands)
+        d = mozdevice.DroidSUT("127.0.0.1", port=a.port)
+        self.assertTrue(d.fileExists('/'))
+
+    def test_onNonexistent(self):
+        a = MockAgent(self, commands=self.commands)
+        d = mozdevice.DroidSUT("127.0.0.1", port=a.port)
+        self.assertFalse(d.fileExists('/doesNotExist'))
+
+    def test_onRegularFile(self):
+        a = MockAgent(self, commands=self.commands)
+        d = mozdevice.DroidSUT("127.0.0.1", port=a.port)
+        self.assertTrue(d.fileExists('/init'))
+
+if __name__ == '__main__':
+    unittest.main()
diff --git a/testing/mozbase/mozdevice/tests/sut_fileMethods.py b/testing/mozbase/mozdevice/tests/sut_fileMethods.py
new file mode 100644
index 000000000..142950a81
--- /dev/null
+++ b/testing/mozbase/mozdevice/tests/sut_fileMethods.py
@@ -0,0 +1,72 @@
+#!/usr/bin/env python
+
+import hashlib
+import mozdevice
+import logging
+import shutil
+import tempfile
+import unittest
+from sut import MockAgent
+
+
+class TestFileMethods(unittest.TestCase):
+    """ Class to test misc file methods """
+
+    content = "What is the answer to the life, universe and everything? 42"
+    h = hashlib.md5()
+    h.update(content)
+    temp_hash = h.hexdigest()
+
+    def test_validateFile(self):
+
+        with tempfile.NamedTemporaryFile() as f:
+            f.write(self.content)
+            f.flush()
+
+            # Test Valid Hashes
+            commands_valid = [("hash /sdcard/test/file", self.temp_hash)]
+
+            m = MockAgent(self, commands=commands_valid)
+            d = mozdevice.DroidSUT("127.0.0.1", port=m.port, logLevel=logging.DEBUG)
+            self.assertTrue(d.validateFile('/sdcard/test/file', f.name))
+
+            # Test invalid hashes
+            commands_invalid = [("hash /sdcard/test/file", "0this0hash0is0completely0invalid")]
+
+            m = MockAgent(self, commands=commands_invalid)
+            d = mozdevice.DroidSUT("127.0.0.1", port=m.port, logLevel=logging.DEBUG)
+            self.assertFalse(d.validateFile('/sdcard/test/file', f.name))
+
+    def test_getFile(self):
+
+        fname = "/mnt/sdcard/file"
+        commands = [("pull %s" % fname, "%s,%s\n%s" % (fname, len(self.content), self.content)),
+                    ("hash %s" % fname, self.temp_hash)]
+
+        with tempfile.NamedTemporaryFile() as f:
+            m = MockAgent(self, commands=commands)
+            d = mozdevice.DroidSUT("127.0.0.1", port=m.port, logLevel=logging.DEBUG)
+            # No error means success
+            self.assertEqual(None, d.getFile(fname, f.name))
+
+    def test_getDirectory(self):
+
+        fname = "/mnt/sdcard/file"
+        commands = [("isdir /mnt/sdcard", "TRUE"),
+                    ("isdir /mnt/sdcard", "TRUE"),
+                    ("cd /mnt/sdcard", ""),
+                    ("ls", "file"),
+                    ("isdir %s" % fname, "FALSE"),
+                    ("pull %s" % fname, "%s,%s\n%s" % (fname, len(self.content), self.content)),
+                    ("hash %s" % fname, self.temp_hash)]
+
+        tmpdir = tempfile.mkdtemp()
+        m = MockAgent(self, commands=commands)
+        d = mozdevice.DroidSUT("127.0.0.1", port=m.port, logLevel=logging.DEBUG)
+        self.assertEqual(None, d.getDirectory("/mnt/sdcard", tmpdir))
+
+        # Cleanup
+        shutil.rmtree(tmpdir)
+
+if __name__ == '__main__':
+    unittest.main()
diff --git a/testing/mozbase/mozdevice/tests/sut_info.py b/testing/mozbase/mozdevice/tests/sut_info.py
new file mode 100644
index 000000000..93f3d4258
--- /dev/null
+++ b/testing/mozbase/mozdevice/tests/sut_info.py
@@ -0,0 +1,49 @@
+#!/usr/bin/env python
+import mozdevice
+import logging
+import re
+import unittest
+from sut import MockAgent
+
+
+class TestGetInfo(unittest.TestCase):
+
+    commands = {'os': ('info os', 'JDQ39'),
+                'id': ('info id', '11:22:33:44:55:66'),
+                'uptime': ('info uptime', '0 days 0 hours 7 minutes 0 seconds 0 ms'),
+                'uptimemillis': ('info uptimemillis', '666'),
+                'systime': ('info systime', '2013/04/2 12:42:00:007'),
+                'screen': ('info screen', 'X:768 Y:1184'),
+                'rotation': ('info rotation', 'ROTATION:0'),
+                'memory': ('info memory', 'PA:1351032832, FREE: 878645248'),
+                'process': ('info process', '1000    527     system\n'
+                            '10091   3443    org.mozilla.firefox\n'
+                            '10112   3137    com.mozilla.SUTAgentAndroid\n'
+                            '10035   807     com.android.launcher'),
+                'disk': ('info disk', '/data: 6084923392 total, 980922368 available\n'
+                         '/system: 867999744 total, 332333056 available\n'
+                         '/mnt/sdcard: 6084923392 total, 980922368 available'),
+                'power': ('info power', 'Power status:\n'
+                          '  AC power OFFLINE\n'
+                          '  Battery charge LOW DISCHARGING\n'
+                          '  Remaining charge:      20%\n'
+                          '  Battery Temperature:   25.2 (c)'),
+                'sutuserinfo': ('info sutuserinfo', 'User Serial:0'),
+                'temperature': ('info temperature', 'Temperature: unknown')
+                }
+
+    def test_getInfo(self):
+
+        for directive in self.commands.keys():
+            m = MockAgent(self, commands=[self.commands[directive]])
+            d = mozdevice.DroidSUT('127.0.0.1', port=m.port, logLevel=logging.DEBUG)
+
+            expected = re.sub(r'\ +', ' ', self.commands[directive][1]).split('\n')
+            # Account for slightly different return format for 'process'
+            if directive is 'process':
+                expected = [[x] for x in expected]
+
+            self.assertEqual(d.getInfo(directive=directive)[directive], expected)
+
+if __name__ == '__main__':
+    unittest.main()
diff --git a/testing/mozbase/mozdevice/tests/sut_ip.py b/testing/mozbase/mozdevice/tests/sut_ip.py
new file mode 100644
index 000000000..31428a624
--- /dev/null
+++ b/testing/mozbase/mozdevice/tests/sut_ip.py
@@ -0,0 +1,37 @@
+#!/usr/bin/env python
+import mozdevice
+import logging
+import unittest
+from sut import MockAgent
+
+
+class TestGetIP(unittest.TestCase):
+    """ class to test IP methods """
+
+    commands = [('exec ifconfig eth0', 'eth0: ip 192.168.0.1 '
+                 'mask 255.255.255.0 flags [up broadcast running multicast]\n'
+                 'return code [0]'),
+                ('exec ifconfig wlan0', 'wlan0: ip 10.1.39.126\n'
+                 'mask 255.255.0.0 flags [up broadcast running multicast]\n'
+                 'return code [0]'),
+                ('exec ifconfig fake0', '##AGENT-WARNING## [ifconfig] '
+                 'command with arg(s) = [fake0] is currently not implemented.')
+                ]
+
+    def test_getIP_eth0(self):
+        m = MockAgent(self, commands=[self.commands[0]])
+        d = mozdevice.DroidSUT("127.0.0.1", port=m.port, logLevel=logging.DEBUG)
+        self.assertEqual('192.168.0.1', d.getIP(interfaces=['eth0']))
+
+    def test_getIP_wlan0(self):
+        m = MockAgent(self, commands=[self.commands[1]])
+        d = mozdevice.DroidSUT("127.0.0.1", port=m.port, logLevel=logging.DEBUG)
+        self.assertEqual('10.1.39.126', d.getIP(interfaces=['wlan0']))
+
+    def test_getIP_error(self):
+        m = MockAgent(self, commands=[self.commands[2]])
+        d = mozdevice.DroidSUT("127.0.0.1", port=m.port, logLevel=logging.DEBUG)
+        self.assertRaises(mozdevice.DMError, d.getIP, interfaces=['fake0'])
+
+if __name__ == '__main__':
+    unittest.main()
diff --git a/testing/mozbase/mozdevice/tests/sut_kill.py b/testing/mozbase/mozdevice/tests/sut_kill.py
new file mode 100644
index 000000000..fea2f57e0
--- /dev/null
+++ b/testing/mozbase/mozdevice/tests/sut_kill.py
@@ -0,0 +1,24 @@
+#!/usr/bin/env python
+
+import mozdevice
+import logging
+import unittest
+from sut import MockAgent
+
+
+class TestKill(unittest.TestCase):
+
+    def test_killprocess(self):
+        commands = [("ps", "1000    1486    com.android.settings\n"
+                           "10016   420 com.android.location.fused\n"
+                           "10023   335 com.android.systemui\n"),
+                    ("kill com.android.settings",
+                     "Successfully killed com.android.settings\n")]
+        m = MockAgent(self, commands=commands)
+        d = mozdevice.DroidSUT("127.0.0.1", port=m.port, logLevel=logging.DEBUG)
+        # No error raised means success
+        self.assertEqual(None,  d.killProcess("com.android.settings"))
+
+
+if __name__ == '__main__':
+    unittest.main()
diff --git a/testing/mozbase/mozdevice/tests/sut_list.py b/testing/mozbase/mozdevice/tests/sut_list.py
new file mode 100644
index 000000000..a319fd725
--- /dev/null
+++ b/testing/mozbase/mozdevice/tests/sut_list.py
@@ -0,0 +1,22 @@
+#!/usr/bin/env python
+import mozdevice
+import logging
+import unittest
+from sut import MockAgent
+
+
+class TestListFiles(unittest.TestCase):
+    commands = [("isdir /mnt/sdcard", "TRUE"),
+                ("cd /mnt/sdcard", ""),
+                ("ls", "Android\nMusic\nPodcasts\nRingtones\nAlarms\n"
+                       "Notifications\nPictures\nMovies\nDownload\nDCIM\n")]
+
+    def test_listFiles(self):
+        m = MockAgent(self, commands=self.commands)
+        d = mozdevice.DroidSUT("127.0.0.1", port=m.port, logLevel=logging.DEBUG)
+
+        expected = (self.commands[2][1].strip()).split("\n")
+        self.assertEqual(expected, d.listFiles("/mnt/sdcard"))
+
+if __name__ == '__main__':
+    unittest.main()
diff --git a/testing/mozbase/mozdevice/tests/sut_logcat.py b/testing/mozbase/mozdevice/tests/sut_logcat.py
new file mode 100644
index 000000000..b4c1a742d
--- /dev/null
+++ b/testing/mozbase/mozdevice/tests/sut_logcat.py
@@ -0,0 +1,52 @@
+#!/usr/bin/env python
+
+import mozdevice
+import logging
+import unittest
+from sut import MockAgent
+
+
+class TestLogCat(unittest.TestCase):
+    """ Class to test methods associated with logcat """
+
+    def test_getLogcat(self):
+
+        logcat_output = (
+            "07-17 00:51:10.377 I/SUTAgentAndroid( 2933): onCreate\r\n"
+            "07-17 00:51:10.457 D/dalvikvm( 2933): GC_CONCURRENT freed 351K, 17% free 2523K/3008K, paused 5ms+2ms, total 38ms\r\n"  # noqa
+            "07-17 00:51:10.497 I/SUTAgentAndroid( 2933): Caught exception creating file in /data/local/tmp: open failed: EACCES (Permission denied)\r\n"  # noqa
+            "07-17 00:51:10.507 E/SUTAgentAndroid( 2933): ERROR: Cannot access world writeable test root\r\n"  # noqa
+            "07-17 00:51:10.547 D/GeckoHealthRec( 3253): Initializing profile cache.\r\n"
+            "07-17 00:51:10.607 D/GeckoHealthRec( 3253): Looking for /data/data/org.mozilla.fennec/files/mozilla/c09kfhne.default/times.json\r\n"  # noqa
+            "07-17 00:51:10.637 D/GeckoHealthRec( 3253): Using times.json for profile creation time.\r\n"  # noqa
+            "07-17 00:51:10.707 D/GeckoHealthRec( 3253): Incorporating environment: times.json profile creation = 1374026758604\r\n"  # noqa
+            "07-17 00:51:10.507 D/GeckoHealthRec( 3253): Requested prefs.\r\n"
+            "07-17 06:50:54.907 I/SUTAgentAndroid( 3876): \r\n"
+            "07-17 06:50:54.907 I/SUTAgentAndroid( 3876): Total Private Dirty Memory         3176 kb\r\n"  # noqa
+            "07-17 06:50:54.907 I/SUTAgentAndroid( 3876): Total Proportional Set Size Memory 5679 kb\r\n"  # noqa
+            "07-17 06:50:54.907 I/SUTAgentAndroid( 3876): Total Shared Dirty Memory          9216 kb\r\n"  # noqa
+            "07-17 06:55:21.627 I/SUTAgentAndroid( 3876): 127.0.0.1 : execsu /system/bin/logcat -v time -d dalvikvm:I "  # noqa
+            "ConnectivityService:S WifiMonitor:S WifiStateTracker:S wpa_supplicant:S NetworkStateTracker:S\r\n"  # noqa
+            "07-17 06:55:21.827 I/dalvikvm-heap( 3876): Grow heap (frag case) to 3.019MB for 102496-byte allocation\r\n"  # noqa
+            "return code [0]")
+
+        inp = ("execsu /system/bin/logcat -v time -d "
+               "dalvikvm:I ConnectivityService:S WifiMonitor:S "
+               "WifiStateTracker:S wpa_supplicant:S NetworkStateTracker:S")
+
+        commands = [(inp, logcat_output)]
+        m = MockAgent(self, commands=commands)
+        d = mozdevice.DroidSUT("127.0.0.1", port=m.port, logLevel=logging.DEBUG)
+        self.assertEqual(logcat_output[:-17].replace('\r\n', '\n').splitlines(True), d.getLogcat())
+
+    def test_recordLogcat(self):
+
+        commands = [("execsu /system/bin/logcat -c", "return code [0]")]
+
+        m = MockAgent(self, commands=commands)
+        d = mozdevice.DroidSUT("127.0.0.1", port=m.port, logLevel=logging.DEBUG)
+        # No error raised means success
+        self.assertEqual(None, d.recordLogcat())
+
+if __name__ == '__main__':
+    unittest.main()
diff --git a/testing/mozbase/mozdevice/tests/sut_mkdir.py b/testing/mozbase/mozdevice/tests/sut_mkdir.py
new file mode 100644
index 000000000..bacaae324
--- /dev/null
+++ b/testing/mozbase/mozdevice/tests/sut_mkdir.py
@@ -0,0 +1,78 @@
+# Any copyright is dedicated to the Public Domain.
+# http://creativecommons.org/publicdomain/zero/1.0/
+
+import mozdevice
+import logging
+import unittest
+from sut import MockAgent
+
+
+class MkDirsTest(unittest.TestCase):
+
+    def test_mkdirs(self):
+        subTests = [{'cmds': [('isdir /mnt/sdcard/baz/boop', 'FALSE'),
+                              ('info os', 'android'),
+                              ('isdir /mnt', 'TRUE'),
+                              ('isdir /mnt/sdcard', 'TRUE'),
+                              ('isdir /mnt/sdcard/baz', 'FALSE'),
+                              ('mkdr /mnt/sdcard/baz',
+                               '/mnt/sdcard/baz successfully created'),
+                              ('isdir /mnt/sdcard/baz/boop', 'FALSE'),
+                              ('mkdr /mnt/sdcard/baz/boop',
+                               '/mnt/sdcard/baz/boop successfully created')],
+                     'expectException': False},
+                    {'cmds': [('isdir /mnt/sdcard/baz/boop', 'FALSE'),
+                              ('info os', 'android'),
+                              ('isdir /mnt', 'TRUE'),
+                              ('isdir /mnt/sdcard', 'TRUE'),
+                              ('isdir /mnt/sdcard/baz', 'FALSE'),
+                              ('mkdr /mnt/sdcard/baz',
+                               "##AGENT-WARNING## "
+                               "Could not create the directory /mnt/sdcard/baz")],
+                     'expectException': True},
+                    ]
+        for subTest in subTests:
+            a = MockAgent(self, commands=subTest['cmds'])
+
+            exceptionThrown = False
+            try:
+                d = mozdevice.DroidSUT('127.0.0.1', port=a.port,
+                                       logLevel=logging.DEBUG)
+                d.mkDirs('/mnt/sdcard/baz/boop/bip')
+            except mozdevice.DMError:
+                exceptionThrown = True
+            self.assertEqual(exceptionThrown, subTest['expectException'])
+
+            a.wait()
+
+    def test_repeated_path_part(self):
+        """
+        Ensure that all dirs are created when last path part also found
+        earlier in the path (bug 826492).
+        """
+
+        cmds = [('isdir /mnt/sdcard/foo', 'FALSE'),
+                ('info os', 'android'),
+                ('isdir /mnt', 'TRUE'),
+                ('isdir /mnt/sdcard', 'TRUE'),
+                ('isdir /mnt/sdcard/foo', 'FALSE'),
+                ('mkdr /mnt/sdcard/foo',
+                 '/mnt/sdcard/foo successfully created')]
+        a = MockAgent(self, commands=cmds)
+        d = mozdevice.DroidSUT('127.0.0.1', port=a.port,
+                               logLevel=logging.DEBUG)
+        d.mkDirs('/mnt/sdcard/foo/foo')
+        a.wait()
+
+    def test_mkdirs_on_root(self):
+        cmds = [('isdir /', 'TRUE')]
+        a = MockAgent(self, commands=cmds)
+        d = mozdevice.DroidSUT('127.0.0.1', port=a.port,
+                               logLevel=logging.DEBUG)
+        d.mkDirs('/foo')
+
+        a.wait()
+
+
+if __name__ == '__main__':
+    unittest.main()
diff --git a/testing/mozbase/mozdevice/tests/sut_movetree.py b/testing/mozbase/mozdevice/tests/sut_movetree.py
new file mode 100644
index 000000000..0e106577c
--- /dev/null
+++ b/testing/mozbase/mozdevice/tests/sut_movetree.py
@@ -0,0 +1,65 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+
+# This Source Code Form is subject to the terms of the Mozilla Public
+# License, v. 2.0. If a copy of the MPL was not distributed with this file,
+# You can obtain one at http://mozilla.org/MPL/2.0/.
+
+import mozdevice
+import logging
+import unittest
+from sut import MockAgent
+
+
+class MoveTreeTest(unittest.TestCase):
+
+    def test_moveFile(self):
+        commands = [('mv /mnt/sdcard/tests/test.txt /mnt/sdcard/tests/test1.txt', ''),
+                    ('isdir /mnt/sdcard/tests', 'TRUE'),
+                    ('cd /mnt/sdcard/tests', ''),
+                    ('ls', 'test1.txt'),
+                    ('isdir /mnt/sdcard/tests', 'TRUE'),
+                    ('cd /mnt/sdcard/tests', ''),
+                    ('ls', 'test1.txt')]
+
+        m = MockAgent(self, commands=commands)
+        d = mozdevice.DroidSUT("127.0.0.1", port=m.port, logLevel=logging.DEBUG)
+        self.assertEqual(None, d.moveTree('/mnt/sdcard/tests/test.txt',
+                                          '/mnt/sdcard/tests/test1.txt'))
+        self.assertFalse(d.fileExists('/mnt/sdcard/tests/test.txt'))
+        self.assertTrue(d.fileExists('/mnt/sdcard/tests/test1.txt'))
+
+    def test_moveDir(self):
+        commands = [("mv /mnt/sdcard/tests/foo /mnt/sdcard/tests/bar", ""),
+                    ('isdir /mnt/sdcard/tests', 'TRUE'),
+                    ('cd /mnt/sdcard/tests', ''),
+                    ('ls', 'bar')]
+
+        m = MockAgent(self, commands=commands)
+        d = mozdevice.DroidSUT("127.0.0.1", port=m.port, logLevel=logging.DEBUG)
+        self.assertEqual(None, d.moveTree('/mnt/sdcard/tests/foo',
+                                          '/mnt/sdcard/tests/bar'))
+        self.assertTrue(d.fileExists('/mnt/sdcard/tests/bar'))
+
+    def test_moveNonEmptyDir(self):
+        commands = [('isdir /mnt/sdcard/tests/foo/bar', 'TRUE'),
+                    ('mv /mnt/sdcard/tests/foo /mnt/sdcard/tests/foo2', ''),
+                    ('isdir /mnt/sdcard/tests', 'TRUE'),
+                    ('cd /mnt/sdcard/tests', ''),
+                    ('ls', 'foo2'),
+                    ('isdir /mnt/sdcard/tests/foo2', 'TRUE'),
+                    ('cd /mnt/sdcard/tests/foo2', ''),
+                    ('ls', 'bar')]
+
+        m = MockAgent(self, commands=commands)
+        d = mozdevice.DroidSUT("127.0.0.1", port=m.port,
+                               logLevel=logging.DEBUG)
+
+        self.assertTrue(d.dirExists('/mnt/sdcard/tests/foo/bar'))
+        self.assertEqual(None, d.moveTree('/mnt/sdcard/tests/foo',
+                                          '/mnt/sdcard/tests/foo2'))
+        self.assertTrue(d.fileExists('/mnt/sdcard/tests/foo2'))
+        self.assertTrue(d.fileExists('/mnt/sdcard/tests/foo2/bar'))
+
+if __name__ == "__main__":
+    unittest.main()
diff --git a/testing/mozbase/mozdevice/tests/sut_ps.py b/testing/mozbase/mozdevice/tests/sut_ps.py
new file mode 100644
index 000000000..03f431c1d
--- /dev/null
+++ b/testing/mozbase/mozdevice/tests/sut_ps.py
@@ -0,0 +1,50 @@
+from sut import MockAgent
+import mozdevice
+import unittest
+
+
+class PsTest(unittest.TestCase):
+
+    pscommands = [('ps',
+                   "10029	549	com.android.launcher\n"
+                   "10066	1198	com.twitter.android")]
+
+    bad_pscommands = [('ps',
+                       "abcdef	549	com.android.launcher\n"
+                       "10066	1198	com.twitter.android")]
+
+    def test_processList(self):
+        a = MockAgent(self,
+                      commands=self.pscommands)
+        d = mozdevice.DroidSUT("127.0.0.1", port=a.port)
+        pslist = d.getProcessList()
+        self.assertEqual(len(pslist), 2)
+        self.assertEqual(pslist[0], [549, 'com.android.launcher', 10029])
+        self.assertEqual(pslist[1], [1198, 'com.twitter.android', 10066])
+
+        a.wait()
+
+    def test_badProcessList(self):
+        a = MockAgent(self,
+                      commands=self.bad_pscommands)
+        d = mozdevice.DroidSUT("127.0.0.1", port=a.port)
+        exceptionTriggered = False
+        try:
+            d.getProcessList()
+        except mozdevice.DMError:
+            exceptionTriggered = True
+
+        self.assertTrue(exceptionTriggered)
+
+        a.wait()
+
+    def test_processExist(self):
+        for i in [('com.android.launcher', 549),
+                  ('com.fennec.android', None)]:
+            a = MockAgent(self, commands=self.pscommands)
+            d = mozdevice.DroidSUT("127.0.0.1", port=a.port)
+            self.assertEqual(d.processExist(i[0]), i[1])
+            a.wait()
+
+if __name__ == '__main__':
+    unittest.main()
diff --git a/testing/mozbase/mozdevice/tests/sut_pull.py b/testing/mozbase/mozdevice/tests/sut_pull.py
new file mode 100644
index 000000000..c9fcae42a
--- /dev/null
+++ b/testing/mozbase/mozdevice/tests/sut_pull.py
@@ -0,0 +1,47 @@
+from sut import MockAgent
+import mozdevice
+import logging
+import unittest
+
+
+class PullTest(unittest.TestCase):
+
+    def test_pull_success(self):
+        for count in [1, 4, 1024, 2048]:
+            cheeseburgers = ""
+            for i in range(count):
+                cheeseburgers += "cheeseburgers"
+
+            # pull file is kind of gross, make sure we can still execute commands after it's done
+            remoteName = "/mnt/sdcard/cheeseburgers"
+            a = MockAgent(self, commands=[("pull %s" % remoteName,
+                                           "%s,%s\n%s" % (remoteName,
+                                                          len(cheeseburgers),
+                                                          cheeseburgers)),
+                                          ("isdir /mnt/sdcard", "TRUE")])
+
+            d = mozdevice.DroidSUT("127.0.0.1", port=a.port,
+                                   logLevel=logging.DEBUG)
+            pulledData = d.pullFile("/mnt/sdcard/cheeseburgers")
+            self.assertEqual(pulledData, cheeseburgers)
+            d.dirExists('/mnt/sdcard')
+
+    def test_pull_failure(self):
+
+        # this test simulates only receiving a few bytes of what we expect
+        # to be larger file
+        remoteName = "/mnt/sdcard/cheeseburgers"
+        a = MockAgent(self, commands=[("pull %s" % remoteName,
+                                       "%s,15\n%s" % (remoteName,
+                                                      "cheeseburgh"))])
+        d = mozdevice.DroidSUT("127.0.0.1", port=a.port,
+                               logLevel=logging.DEBUG)
+        exceptionThrown = False
+        try:
+            d.pullFile("/mnt/sdcard/cheeseburgers")
+        except mozdevice.DMError:
+            exceptionThrown = True
+        self.assertTrue(exceptionThrown)
+
+if __name__ == '__main__':
+    unittest.main()
diff --git a/testing/mozbase/mozdevice/tests/sut_push.py b/testing/mozbase/mozdevice/tests/sut_push.py
new file mode 100644
index 000000000..023d5315c
--- /dev/null
+++ b/testing/mozbase/mozdevice/tests/sut_push.py
@@ -0,0 +1,88 @@
+from sut import MockAgent
+import mozfile
+import mozdevice
+import logging
+import unittest
+import hashlib
+import tempfile
+import os
+
+
+class PushTest(unittest.TestCase):
+
+    def test_push(self):
+        pushfile = "1234ABCD"
+        mdsum = hashlib.md5()
+        mdsum.update(pushfile)
+        expectedResponse = mdsum.hexdigest()
+
+        # (good response, no exception), (bad response, exception)
+        for response in [(expectedResponse, False), ("BADHASH", True)]:
+            cmd = "push /mnt/sdcard/foobar %s\r\n%s" % (len(pushfile), pushfile)
+            a = MockAgent(self, commands=[("isdir /mnt/sdcard", "TRUE"),
+                                          (cmd, response[0])])
+            exceptionThrown = False
+            with tempfile.NamedTemporaryFile() as f:
+                try:
+                    f.write(pushfile)
+                    f.flush()
+                    d = mozdevice.DroidSUT("127.0.0.1", port=a.port)
+                    d.pushFile(f.name, '/mnt/sdcard/foobar')
+                except mozdevice.DMError:
+                    exceptionThrown = True
+                self.assertEqual(exceptionThrown, response[1])
+            a.wait()
+
+    def test_push_dir(self):
+        pushfile = "1234ABCD"
+        mdsum = hashlib.md5()
+        mdsum.update(pushfile)
+        expectedFileResponse = mdsum.hexdigest()
+
+        tempdir = tempfile.mkdtemp()
+        self.addCleanup(mozfile.remove, tempdir)
+        complex_path = os.path.join(tempdir, "baz")
+        os.mkdir(complex_path)
+        f = tempfile.NamedTemporaryFile(dir=complex_path)
+        f.write(pushfile)
+        f.flush()
+
+        subTests = [{'cmds': [("isdir /mnt/sdcard/baz", "TRUE"),
+                              ("push /mnt/sdcard/baz/%s %s\r\n%s" %
+                               (os.path.basename(f.name), len(pushfile),
+                                pushfile),
+                               expectedFileResponse)],
+                     'expectException': False},
+                    {'cmds': [("isdir /mnt/sdcard/baz", "TRUE"),
+                              ("push /mnt/sdcard/baz/%s %s\r\n%s" %
+                               (os.path.basename(f.name), len(pushfile),
+                                pushfile),
+                               "BADHASH")],
+                     'expectException': True},
+                    {'cmds': [("isdir /mnt/sdcard/baz", "FALSE"),
+                              ('info os', 'android'),
+                              ("isdir /mnt", "FALSE"),
+                              ("mkdr /mnt",
+                               "##AGENT-WARNING## Could not create the directory /mnt")],
+                     'expectException': True},
+
+                    ]
+
+        for subTest in subTests:
+            a = MockAgent(self, commands=subTest['cmds'])
+
+            exceptionThrown = False
+            try:
+                d = mozdevice.DroidSUT("127.0.0.1", port=a.port,
+                                       logLevel=logging.DEBUG)
+                d.pushDir(tempdir, "/mnt/sdcard")
+            except mozdevice.DMError:
+                exceptionThrown = True
+            self.assertEqual(exceptionThrown, subTest['expectException'])
+
+            a.wait()
+
+        # FIXME: delete directory when done
+
+if __name__ == '__main__':
+    unittest.main()
diff --git a/testing/mozbase/mozdevice/tests/sut_remove.py b/testing/mozbase/mozdevice/tests/sut_remove.py
new file mode 100644
index 000000000..636190186
--- /dev/null
+++ b/testing/mozbase/mozdevice/tests/sut_remove.py
@@ -0,0 +1,24 @@
+#!/usr/bin/env python
+import mozdevice
+import logging
+import unittest
+from sut import MockAgent
+
+
+class TestRemove(unittest.TestCase):
+
+    def test_removeDir(self):
+        commands = [("isdir /mnt/sdcard/test", "TRUE"),
+                    ("rmdr /mnt/sdcard/test", "Deleting file(s) from "
+                     "/storage/emulated/legacy/Moztest\n"
+                     "        <empty>\n"
+                     "Deleting directory "
+                     "/storage/emulated/legacy/Moztest\n")]
+
+        m = MockAgent(self, commands=commands)
+        d = mozdevice.DroidSUT("127.0.0.1", port=m.port, logLevel=logging.DEBUG)
+        # No error implies we're all good
+        self.assertEqual(None, d.removeDir("/mnt/sdcard/test"))
+
+if __name__ == '__main__':
+    unittest.main()
diff --git a/testing/mozbase/mozdevice/tests/sut_time.py b/testing/mozbase/mozdevice/tests/sut_time.py
new file mode 100644
index 000000000..11dc421cb
--- /dev/null
+++ b/testing/mozbase/mozdevice/tests/sut_time.py
@@ -0,0 +1,18 @@
+#!/usr/bin/env python
+import mozdevice
+import logging
+import unittest
+from sut import MockAgent
+
+
+class TestGetCurrentTime(unittest.TestCase):
+
+    def test_getCurrentTime(self):
+        command = [('clok', '1349980200')]
+
+        m = MockAgent(self, commands=command)
+        d = mozdevice.DroidSUT("127.0.0.1", port=m.port, logLevel=logging.DEBUG)
+        self.assertEqual(d.getCurrentTime(), int(command[0][1]))
+
+if __name__ == '__main__':
+    unittest.main()
diff --git a/testing/mozbase/mozdevice/tests/sut_unpackfile.py b/testing/mozbase/mozdevice/tests/sut_unpackfile.py
new file mode 100644
index 000000000..1a531fe17
--- /dev/null
+++ b/testing/mozbase/mozdevice/tests/sut_unpackfile.py
@@ -0,0 +1,23 @@
+#!/usr/bin/env python
+
+import mozdevice
+import logging
+import unittest
+from sut import MockAgent
+
+
+class TestUnpack(unittest.TestCase):
+
+    def test_unpackFile(self):
+
+        commands = [("unzp /data/test/sample.zip /data/test/",
+                     "Checksum:          653400271\n"
+                     "1 of 1 successfully extracted\n")]
+        m = MockAgent(self, commands=commands)
+        d = mozdevice.DroidSUT("127.0.0.1", port=m.port, logLevel=logging.DEBUG)
+        # No error being thrown imples all is well
+        self.assertEqual(None, d.unpackFile("/data/test/sample.zip",
+                                            "/data/test/"))
+
+if __name__ == '__main__':
+    unittest.main()