Cache device apk checksums in device_utils.py

build/android/pylib/device/device_utils_test.py

 #!/usr/bin/env python
 # Copyright 2014 The Chromium Authors. All rights reserved.
 # Use of this source code is governed by a BSD-style license that can be
 # found in the LICENSE file.
 
 """
 Unit tests for the contents of device_utils.py (mostly DeviceUtils).
 """
 
 # pylint: disable=C0321
@@ skipping 293 matching lines @@
         self.call.adb.Shell('echo $EXTERNAL_STORAGE'), '/fake/storage/path\n'):
       self.assertEquals('/fake/storage/path',
                         self.device.GetExternalStoragePath())
 
   def testGetExternalStoragePath_fails(self):
     with self.assertCall(self.call.adb.Shell('echo $EXTERNAL_STORAGE'), '\n'):
       with self.assertRaises(device_errors.CommandFailedError):
         self.device.GetExternalStoragePath()
 
 
-class DeviceUtilsGetApplicationPathsTest(DeviceUtilsTest):
+class DeviceUtils_GetApplicationPathsInternalTest(DeviceUtilsTest):
 
-  def testGetApplicationPaths_exists(self):
+  def test_GetApplicationPathsInternal_exists(self):
     with self.assertCalls(
         (self.call.adb.Shell('getprop ro.build.version.sdk'), '19\n'),
         (self.call.adb.Shell('pm path android'),
          'package:/path/to/android.apk\n')):
       self.assertEquals(['/path/to/android.apk'],
-                        self.device.GetApplicationPaths('android'))
+                        self.device._GetApplicationPathsInternal('android'))
 
-  def testGetApplicationPaths_notExists(self):
+  def test_GetApplicationPathsInternal_notExists(self):
     with self.assertCalls(
         (self.call.adb.Shell('getprop ro.build.version.sdk'), '19\n'),
         (self.call.adb.Shell('pm path not.installed.app'), '')):
       self.assertEquals([],
-                        self.device.GetApplicationPaths('not.installed.app'))
+          self.device._GetApplicationPathsInternal('not.installed.app'))
 
-  def testGetApplicationPaths_fails(self):
+  def test_GetApplicationPathsInternal_fails(self):
     with self.assertCalls(
         (self.call.adb.Shell('getprop ro.build.version.sdk'), '19\n'),
         (self.call.adb.Shell('pm path android'),
          self.CommandError('ERROR. Is package manager running?\n'))):
       with self.assertRaises(device_errors.CommandFailedError):
-        self.device.GetApplicationPaths('android')
+        self.device._GetApplicationPathsInternal('android')
 
 
 class DeviceUtilsGetApplicationDataDirectoryTest(DeviceUtilsTest):
 
   def testGetApplicationDataDirectory_exists(self):
     with self.assertCall(
         self.call.device._RunPipedShellCommand(
             'pm dump foo.bar.baz | grep dataDir='),
         ['dataDir=/data/data/foo.bar.baz']):
       self.assertEquals(
@@ skipping 11 matching lines @@
 @mock.patch('time.sleep', mock.Mock())
 class DeviceUtilsWaitUntilFullyBootedTest(DeviceUtilsTest):
 
   def testWaitUntilFullyBooted_succeedsNoWifi(self):
     with self.assertCalls(
         self.call.adb.WaitForDevice(),
         # sd_card_ready
         (self.call.device.GetExternalStoragePath(), '/fake/storage/path'),
         (self.call.adb.Shell('test -d /fake/storage/path'), ''),
         # pm_ready
-        (self.call.device.GetApplicationPaths('android'),
+        (self.call.device._GetApplicationPathsInternal('android',
+                                                       skip_cache=True),
          ['package:/some/fake/path']),
         # boot_completed
         (self.call.device.GetProp('sys.boot_completed'), '1')):
       self.device.WaitUntilFullyBooted(wifi=False)
 
   def testWaitUntilFullyBooted_succeedsWithWifi(self):
     with self.assertCalls(
         self.call.adb.WaitForDevice(),
         # sd_card_ready
         (self.call.device.GetExternalStoragePath(), '/fake/storage/path'),
         (self.call.adb.Shell('test -d /fake/storage/path'), ''),
         # pm_ready
-        (self.call.device.GetApplicationPaths('android'),
+        (self.call.device._GetApplicationPathsInternal('android',
+                                                       skip_cache=True),
          ['package:/some/fake/path']),
         # boot_completed
         (self.call.device.GetProp('sys.boot_completed'), '1'),
         # wifi_enabled
         (self.call.adb.Shell('dumpsys wifi'),
          'stuff\nWi-Fi is enabled\nmore stuff\n')):
       self.device.WaitUntilFullyBooted(wifi=True)
 
   def testWaitUntilFullyBooted_deviceNotInitiallyAvailable(self):
     with self.assertCalls(
         self.call.adb.WaitForDevice(),
         # sd_card_ready
         (self.call.device.GetExternalStoragePath(), self.AdbCommandError()),
         # sd_card_ready
         (self.call.device.GetExternalStoragePath(), self.AdbCommandError()),
         # sd_card_ready
         (self.call.device.GetExternalStoragePath(), self.AdbCommandError()),
         # sd_card_ready
         (self.call.device.GetExternalStoragePath(), self.AdbCommandError()),
         # sd_card_ready
         (self.call.device.GetExternalStoragePath(), '/fake/storage/path'),
         (self.call.adb.Shell('test -d /fake/storage/path'), ''),
         # pm_ready
-        (self.call.device.GetApplicationPaths('android'),
+        (self.call.device._GetApplicationPathsInternal('android',
+                                                       skip_cache=True),
          ['package:/some/fake/path']),
         # boot_completed
         (self.call.device.GetProp('sys.boot_completed'), '1')):
       self.device.WaitUntilFullyBooted(wifi=False)
 
   def testWaitUntilFullyBooted_sdCardReadyFails_noPath(self):
     with self.assertCalls(
         self.call.adb.WaitForDevice(),
         # sd_card_ready
         (self.call.device.GetExternalStoragePath(), self.CommandError())):
@@ skipping 16 matching lines @@
       with self.assertRaises(device_errors.CommandTimeoutError):
         self.device.WaitUntilFullyBooted(wifi=False)
 
   def testWaitUntilFullyBooted_devicePmFails(self):
     with self.assertCalls(
         self.call.adb.WaitForDevice(),
         # sd_card_ready
         (self.call.device.GetExternalStoragePath(), '/fake/storage/path'),
         (self.call.adb.Shell('test -d /fake/storage/path'), ''),
         # pm_ready
-        (self.call.device.GetApplicationPaths('android'), self.CommandError()),
+        (self.call.device._GetApplicationPathsInternal('android',
+                                                       skip_cache=True),
+         self.CommandError()),
         # pm_ready
-        (self.call.device.GetApplicationPaths('android'), self.CommandError()),
+        (self.call.device._GetApplicationPathsInternal('android',
+                                                       skip_cache=True),
+         self.CommandError()),
         # pm_ready
-        (self.call.device.GetApplicationPaths('android'), self.TimeoutError())):
+        (self.call.device._GetApplicationPathsInternal('android',
+                                                       skip_cache=True),
+         self.TimeoutError())):
       with self.assertRaises(device_errors.CommandTimeoutError):
         self.device.WaitUntilFullyBooted(wifi=False)
 
   def testWaitUntilFullyBooted_bootFails(self):
     with self.assertCalls(
         self.call.adb.WaitForDevice(),
         # sd_card_ready
         (self.call.device.GetExternalStoragePath(), '/fake/storage/path'),
         (self.call.adb.Shell('test -d /fake/storage/path'), ''),
         # pm_ready
-        (self.call.device.GetApplicationPaths('android'),
+        (self.call.device._GetApplicationPathsInternal('android',
+                                                       skip_cache=True),
          ['package:/some/fake/path']),
         # boot_completed
         (self.call.device.GetProp('sys.boot_completed'), '0'),
         # boot_completed
         (self.call.device.GetProp('sys.boot_completed'), '0'),
         # boot_completed
         (self.call.device.GetProp('sys.boot_completed'), self.TimeoutError())):
       with self.assertRaises(device_errors.CommandTimeoutError):
         self.device.WaitUntilFullyBooted(wifi=False)
 
   def testWaitUntilFullyBooted_wifiFails(self):
     with self.assertCalls(
         self.call.adb.WaitForDevice(),
         # sd_card_ready
         (self.call.device.GetExternalStoragePath(), '/fake/storage/path'),
         (self.call.adb.Shell('test -d /fake/storage/path'), ''),
         # pm_ready
-        (self.call.device.GetApplicationPaths('android'),
+        (self.call.device._GetApplicationPathsInternal('android',
+                                                       skip_cache=True),
          ['package:/some/fake/path']),
         # boot_completed
         (self.call.device.GetProp('sys.boot_completed'), '1'),
         # wifi_enabled
         (self.call.adb.Shell('dumpsys wifi'), 'stuff\nmore stuff\n'),
         # wifi_enabled
         (self.call.adb.Shell('dumpsys wifi'), 'stuff\nmore stuff\n'),
         # wifi_enabled
         (self.call.adb.Shell('dumpsys wifi'), self.TimeoutError())):
       with self.assertRaises(device_errors.CommandTimeoutError):
@@ skipping 25 matching lines @@
         (self.call.device.IsOnline(), False),
         self.call.device.WaitUntilFullyBooted(wifi=True)):
       self.device.Reboot(block=True, wifi=True)
 
 
 class DeviceUtilsInstallTest(DeviceUtilsTest):
 
   def testInstall_noPriorInstall(self):
     with self.assertCalls(
         (mock.call.pylib.utils.apk_helper.GetPackageName('/fake/test/app.apk'),
-         'this.is.a.test.package'),
-        (self.call.device.GetApplicationPaths('this.is.a.test.package'), []),
+         'test.package'),
+        (self.call.device._GetApplicationPathsInternal('test.package'), []),
         self.call.adb.Install('/fake/test/app.apk', reinstall=False)):
       self.device.Install('/fake/test/app.apk', retries=0)
 
   def testInstall_differentPriorInstall(self):
     with self.assertCalls(
         (mock.call.pylib.utils.apk_helper.GetPackageName('/fake/test/app.apk'),
-         'this.is.a.test.package'),
-        (self.call.device.GetApplicationPaths('this.is.a.test.package'),
-         ['/fake/data/app/this.is.a.test.package.apk']),
-        (self.call.device._GetChangedAndStaleFiles(
-            '/fake/test/app.apk', '/fake/data/app/this.is.a.test.package.apk'),
-         ([('/fake/test/app.apk', '/fake/data/app/this.is.a.test.package.apk')],
-          [])),
-        self.call.adb.Uninstall('this.is.a.test.package'),
+         'test.package'),
+        (self.call.device._GetApplicationPathsInternal('test.package'),
+         ['/fake/data/app/test.package.apk']),
+        (self.call.device._ComputeStaleApks('test.package',
+            ['/fake/test/app.apk']),
+         (['/fake/test/app.apk'], None)),
+        self.call.adb.Uninstall('test.package', False),
         self.call.adb.Install('/fake/test/app.apk', reinstall=False)):
       self.device.Install('/fake/test/app.apk', retries=0)
 
   def testInstall_differentPriorInstall_reinstall(self):
     with self.assertCalls(
         (mock.call.pylib.utils.apk_helper.GetPackageName('/fake/test/app.apk'),
-         'this.is.a.test.package'),
-        (self.call.device.GetApplicationPaths('this.is.a.test.package'),
-         ['/fake/data/app/this.is.a.test.package.apk']),
-        (self.call.device._GetChangedAndStaleFiles(
-            '/fake/test/app.apk', '/fake/data/app/this.is.a.test.package.apk'),
-         ([('/fake/test/app.apk', '/fake/data/app/this.is.a.test.package.apk')],
-          [])),
+         'test.package'),
+        (self.call.device._GetApplicationPathsInternal('test.package'),
+         ['/fake/data/app/test.package.apk']),
+        (self.call.device._ComputeStaleApks('test.package',
+            ['/fake/test/app.apk']),
+         (['/fake/test/app.apk'], None)),
         self.call.adb.Install('/fake/test/app.apk', reinstall=True)):
       self.device.Install('/fake/test/app.apk', reinstall=True, retries=0)
 
   def testInstall_identicalPriorInstall(self):
     with self.assertCalls(
         (mock.call.pylib.utils.apk_helper.GetPackageName('/fake/test/app.apk'),
-         'this.is.a.test.package'),
-        (self.call.device.GetApplicationPaths('this.is.a.test.package'),
-         ['/fake/data/app/this.is.a.test.package.apk']),
-        (self.call.device._GetChangedAndStaleFiles(
-            '/fake/test/app.apk', '/fake/data/app/this.is.a.test.package.apk'),
-         ([], []))):
+         'test.package'),
+        (self.call.device._GetApplicationPathsInternal('test.package'),
+         ['/fake/data/app/test.package.apk']),
+        (self.call.device._ComputeStaleApks('test.package',
+            ['/fake/test/app.apk']),
+         ([], None))):
       self.device.Install('/fake/test/app.apk', retries=0)
 
   def testInstall_fails(self):
     with self.assertCalls(
         (mock.call.pylib.utils.apk_helper.GetPackageName('/fake/test/app.apk'),
-         'this.is.a.test.package'),
-        (self.call.device.GetApplicationPaths('this.is.a.test.package'), []),
+         'test.package'),
+        (self.call.device._GetApplicationPathsInternal('test.package'), []),
         (self.call.adb.Install('/fake/test/app.apk', reinstall=False),
          self.CommandError('Failure\r\n'))):
       with self.assertRaises(device_errors.CommandFailedError):
         self.device.Install('/fake/test/app.apk', retries=0)
 
 class DeviceUtilsInstallSplitApkTest(DeviceUtilsTest):
 
   def testInstallSplitApk_noPriorInstall(self):
     with self.assertCalls(
         (self.call.device._CheckSdkLevel(21)),
         (mock.call.pylib.sdk.split_select.SelectSplits(
             self.device, 'base.apk',
             ['split1.apk', 'split2.apk', 'split3.apk']),
          ['split2.apk']),
         (mock.call.pylib.utils.apk_helper.GetPackageName('base.apk'),
-         'this.is.a.test.package'),
-        (self.call.device.GetApplicationPaths('this.is.a.test.package'), []),
+         'test.package'),
+        (self.call.device._GetApplicationPathsInternal('test.package'), []),
         (self.call.adb.InstallMultiple(
             ['base.apk', 'split2.apk'], partial=None, reinstall=False))):
       self.device.InstallSplitApk('base.apk',
           ['split1.apk', 'split2.apk', 'split3.apk'], retries=0)
 
   def testInstallSplitApk_partialInstall(self):
     with self.assertCalls(
         (self.call.device._CheckSdkLevel(21)),
         (mock.call.pylib.sdk.split_select.SelectSplits(
             self.device, 'base.apk',
             ['split1.apk', 'split2.apk', 'split3.apk']),
          ['split2.apk']),
         (mock.call.pylib.utils.apk_helper.GetPackageName('base.apk'),
          'test.package'),
-        (self.call.device.GetApplicationPaths('test.package'),
+        (self.call.device._GetApplicationPathsInternal('test.package'),
          ['base-on-device.apk', 'split2-on-device.apk']),
-        (mock.call.pylib.utils.md5sum.CalculateDeviceMd5Sums(
-            ['base-on-device.apk', 'split2-on-device.apk'], self.device),
-         {'base-on-device.apk': 'AAA', 'split2-on-device.apk': 'BBB'}),
-        (mock.call.pylib.utils.md5sum.CalculateHostMd5Sums(
-            ['base.apk', 'split2.apk']),
-         {'base.apk': 'AAA', 'split2.apk': 'CCC'}),
+        (self.call.device._ComputeStaleApks('test.package',
+                                            ['base.apk', 'split2.apk']),
+         (['split2.apk'], None)),
         (self.call.adb.InstallMultiple(
             ['split2.apk'], partial='test.package', reinstall=True))):
       self.device.InstallSplitApk('base.apk',
           ['split1.apk', 'split2.apk', 'split3.apk'], reinstall=True, retries=0)
 
 
+class DeviceUtilsUninstallTest(DeviceUtilsTest):
+
+  def testUninstall_callsThrough(self):
+    with self.assertCalls(
+        self.call.adb.Uninstall('test.package', True)):
+      self.device.Uninstall('test.package', True)
+
+
 class DeviceUtilsRunShellCommandTest(DeviceUtilsTest):
 
   def setUp(self):
     super(DeviceUtilsRunShellCommandTest, self).setUp()
     self.device.NeedsSU = mock.Mock(return_value=False)
 
   def testRunShellCommand_commandAsList(self):
     with self.assertCall(self.call.adb.Shell('pm list packages'), ''):
       self.device.RunShellCommand(['pm', 'list', 'packages'])
 
@@ skipping 252 matching lines @@
   def testStartActivity_actionOnly(self):
     test_intent = intent.Intent(action='android.intent.action.VIEW')
     with self.assertCall(
         self.call.adb.Shell('am start '
                             '-a android.intent.action.VIEW'),
         'Starting: Intent { act=android.intent.action.VIEW }'):
       self.device.StartActivity(test_intent)
 
   def testStartActivity_success(self):
     test_intent = intent.Intent(action='android.intent.action.VIEW',
-                                package='this.is.a.test.package',
+                                package='test.package',
                                 activity='.Main')
     with self.assertCall(
         self.call.adb.Shell('am start '
                             '-a android.intent.action.VIEW '
-                            '-n this.is.a.test.package/.Main'),
+                            '-n test.package/.Main'),
         'Starting: Intent { act=android.intent.action.VIEW }'):
       self.device.StartActivity(test_intent)
 
   def testStartActivity_failure(self):
     test_intent = intent.Intent(action='android.intent.action.VIEW',
-                                package='this.is.a.test.package',
+                                package='test.package',
                                 activity='.Main')
     with self.assertCall(
         self.call.adb.Shell('am start '
                             '-a android.intent.action.VIEW '
-                            '-n this.is.a.test.package/.Main'),
+                            '-n test.package/.Main'),
         'Error: Failed to start test activity'):
       with self.assertRaises(device_errors.CommandFailedError):
         self.device.StartActivity(test_intent)
 
   def testStartActivity_blocking(self):
     test_intent = intent.Intent(action='android.intent.action.VIEW',
-                                package='this.is.a.test.package',
+                                package='test.package',
                                 activity='.Main')
     with self.assertCall(
         self.call.adb.Shell('am start '
                             '-W '
                             '-a android.intent.action.VIEW '
-                            '-n this.is.a.test.package/.Main'),
+                            '-n test.package/.Main'),
         'Starting: Intent { act=android.intent.action.VIEW }'):
       self.device.StartActivity(test_intent, blocking=True)
 
   def testStartActivity_withCategory(self):
     test_intent = intent.Intent(action='android.intent.action.VIEW',
-                                package='this.is.a.test.package',
+                                package='test.package',
                                 activity='.Main',
                                 category='android.intent.category.HOME')
     with self.assertCall(
         self.call.adb.Shell('am start '
                             '-a android.intent.action.VIEW '
                             '-c android.intent.category.HOME '
-                            '-n this.is.a.test.package/.Main'),
+                            '-n test.package/.Main'),
         'Starting: Intent { act=android.intent.action.VIEW }'):
       self.device.StartActivity(test_intent)
 
   def testStartActivity_withMultipleCategories(self):
     test_intent = intent.Intent(action='android.intent.action.VIEW',
-                                package='this.is.a.test.package',
+                                package='test.package',
                                 activity='.Main',
                                 category=['android.intent.category.HOME',
                                           'android.intent.category.BROWSABLE'])
     with self.assertCall(
         self.call.adb.Shell('am start '
                             '-a android.intent.action.VIEW '
                             '-c android.intent.category.HOME '
                             '-c android.intent.category.BROWSABLE '
-                            '-n this.is.a.test.package/.Main'),
+                            '-n test.package/.Main'),
         'Starting: Intent { act=android.intent.action.VIEW }'):
       self.device.StartActivity(test_intent)
 
   def testStartActivity_withData(self):
     test_intent = intent.Intent(action='android.intent.action.VIEW',
-                                package='this.is.a.test.package',
+                                package='test.package',
                                 activity='.Main',
                                 data='http://www.google.com/')
     with self.assertCall(
         self.call.adb.Shell('am start '
                             '-a android.intent.action.VIEW '
                             '-d http://www.google.com/ '
-                            '-n this.is.a.test.package/.Main'),
+                            '-n test.package/.Main'),
         'Starting: Intent { act=android.intent.action.VIEW }'):
       self.device.StartActivity(test_intent)
 
   def testStartActivity_withStringExtra(self):
     test_intent = intent.Intent(action='android.intent.action.VIEW',
-                                package='this.is.a.test.package',
+                                package='test.package',
                                 activity='.Main',
                                 extras={'foo': 'test'})
     with self.assertCall(
         self.call.adb.Shell('am start '
                             '-a android.intent.action.VIEW '
-                            '-n this.is.a.test.package/.Main '
+                            '-n test.package/.Main '
                             '--es foo test'),
         'Starting: Intent { act=android.intent.action.VIEW }'):
       self.device.StartActivity(test_intent)
 
   def testStartActivity_withBoolExtra(self):
     test_intent = intent.Intent(action='android.intent.action.VIEW',
-                                package='this.is.a.test.package',
+                                package='test.package',
                                 activity='.Main',
                                 extras={'foo': True})
     with self.assertCall(
         self.call.adb.Shell('am start '
                             '-a android.intent.action.VIEW '
-                            '-n this.is.a.test.package/.Main '
+                            '-n test.package/.Main '
                             '--ez foo True'),
         'Starting: Intent { act=android.intent.action.VIEW }'):
       self.device.StartActivity(test_intent)
 
   def testStartActivity_withIntExtra(self):
     test_intent = intent.Intent(action='android.intent.action.VIEW',
-                                package='this.is.a.test.package',
+                                package='test.package',
                                 activity='.Main',
                                 extras={'foo': 123})
     with self.assertCall(
         self.call.adb.Shell('am start '
                             '-a android.intent.action.VIEW '
-                            '-n this.is.a.test.package/.Main '
+                            '-n test.package/.Main '
                             '--ei foo 123'),
         'Starting: Intent { act=android.intent.action.VIEW }'):
       self.device.StartActivity(test_intent)
 
   def testStartActivity_withTraceFile(self):
     test_intent = intent.Intent(action='android.intent.action.VIEW',
-                                package='this.is.a.test.package',
+                                package='test.package',
                                 activity='.Main')
     with self.assertCall(
         self.call.adb.Shell('am start '
                             '--start-profiler test_trace_file.out '
                             '-a android.intent.action.VIEW '
-                            '-n this.is.a.test.package/.Main'),
+                            '-n test.package/.Main'),
         'Starting: Intent { act=android.intent.action.VIEW }'):
       self.device.StartActivity(test_intent,
                                 trace_file_name='test_trace_file.out')
 
   def testStartActivity_withForceStop(self):
     test_intent = intent.Intent(action='android.intent.action.VIEW',
-                                package='this.is.a.test.package',
+                                package='test.package',
                                 activity='.Main')
     with self.assertCall(
         self.call.adb.Shell('am start '
                             '-S '
                             '-a android.intent.action.VIEW '
-                            '-n this.is.a.test.package/.Main'),
+                            '-n test.package/.Main'),
         'Starting: Intent { act=android.intent.action.VIEW }'):
       self.device.StartActivity(test_intent, force_stop=True)
 
   def testStartActivity_withFlags(self):
     test_intent = intent.Intent(action='android.intent.action.VIEW',
-                                package='this.is.a.test.package',
+                                package='test.package',
                                 activity='.Main',
                                 flags='0x10000000')
     with self.assertCall(
         self.call.adb.Shell('am start '
                             '-a android.intent.action.VIEW '
-                            '-n this.is.a.test.package/.Main '
+                            '-n test.package/.Main '
                             '-f 0x10000000'),
         'Starting: Intent { act=android.intent.action.VIEW }'):
       self.device.StartActivity(test_intent)
 
 
 class DeviceUtilsStartInstrumentationTest(DeviceUtilsTest):
 
   def testStartInstrumentation_nothing(self):
     with self.assertCalls(
         self.call.device.RunShellCommand(
@@ skipping 144 matching lines @@
         (self.call.device.RunShellCommand(
             ['dumpsys', 'window', 'windows'], check_return=True,
             large_output=True),
          ['mCurrentFocus Launcher'])):
       self.device.GoHome()
 
 class DeviceUtilsForceStopTest(DeviceUtilsTest):
 
   def testForceStop(self):
     with self.assertCall(
-        self.call.adb.Shell('am force-stop this.is.a.test.package'),
+        self.call.adb.Shell('am force-stop test.package'),
         ''):
-      self.device.ForceStop('this.is.a.test.package')
+      self.device.ForceStop('test.package')
 
 
 class DeviceUtilsClearApplicationStateTest(DeviceUtilsTest):
 
   def testClearApplicationState_packageDoesntExist(self):
     with self.assertCalls(
         (self.call.adb.Shell('getprop ro.build.version.sdk'), '17\n'),
-        (self.call.device.GetApplicationPaths('this.package.does.not.exist'),
+        (self.call.device._GetApplicationPathsInternal('does.not.exist'),
          [])):
-      self.device.ClearApplicationState('this.package.does.not.exist')
+      self.device.ClearApplicationState('does.not.exist')
 
   def testClearApplicationState_packageDoesntExistOnAndroidJBMR2OrAbove(self):
     with self.assertCalls(
         (self.call.adb.Shell('getprop ro.build.version.sdk'), '18\n'),
         (self.call.adb.Shell('pm clear this.package.does.not.exist'),
          'Failed\r\n')):
       self.device.ClearApplicationState('this.package.does.not.exist')
 
   def testClearApplicationState_packageExists(self):
     with self.assertCalls(
         (self.call.adb.Shell('getprop ro.build.version.sdk'), '17\n'),
-        (self.call.device.GetApplicationPaths('this.package.exists'),
+        (self.call.device._GetApplicationPathsInternal('this.package.exists'),
          ['/data/app/this.package.exists.apk']),
         (self.call.adb.Shell('pm clear this.package.exists'),
          'Success\r\n')):
       self.device.ClearApplicationState('this.package.exists')
 
   def testClearApplicationState_packageExistsOnAndroidJBMR2OrAbove(self):
     with self.assertCalls(
         (self.call.adb.Shell('getprop ro.build.version.sdk'), '18\n'),
         (self.call.adb.Shell('pm clear this.package.exists'),
          'Success\r\n')):
@@ skipping 608 matching lines @@
 
 
 class DeviceUtilsClientCache(DeviceUtilsTest):
 
   def testClientCache_twoCaches(self):
     self.device._cache['test'] = 0
     client_cache_one = self.device.GetClientCache('ClientOne')
     client_cache_one['test'] = 1
     client_cache_two = self.device.GetClientCache('ClientTwo')
     client_cache_two['test'] = 2
-    self.assertEqual(self.device._cache, {'test': 0})
+    self.assertEqual(self.device._cache['test'], 0)
     self.assertEqual(client_cache_one, {'test': 1})
     self.assertEqual(client_cache_two, {'test': 2})
     self.device._ClearCache()
-    self.assertEqual(self.device._cache, {})
+    self.assertTrue('test' not in self.device._cache)
     self.assertEqual(client_cache_one, {})
     self.assertEqual(client_cache_two, {})
 
   def testClientCache_multipleInstances(self):
     client_cache_one = self.device.GetClientCache('ClientOne')
     client_cache_one['test'] = 1
     client_cache_two = self.device.GetClientCache('ClientOne')
     self.assertEqual(client_cache_one, {'test': 1})
     self.assertEqual(client_cache_two, {'test': 1})
     self.device._ClearCache()
@@ skipping 61 matching lines @@
         self.call.device.WriteFile(mock.ANY, mock.ANY),
         (self.call.device.RunShellCommand(
             ['source', mock_temp_file ], as_root=True)),
         self.call.adb.WaitForDevice()):
       self.device.RestartAdbd()
 
 
 if __name__ == '__main__':
   logging.getLogger().setLevel(logging.DEBUG)
   unittest.main(verbosity=2)