[Android] Prepare build/android/ for catapult+devil.

build/android/pylib/base/test_dispatcher_unittest.py

 #!/usr/bin/env python
 # Copyright 2013 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.
 
 """Unittests for test_dispatcher.py."""
-# pylint: disable=R0201
-# pylint: disable=W0212
 
-import os
-import sys
+# pylint: disable=no-self-use
+# pylint: disable=protected-access
+
 import unittest
 
-
 from devil.android import device_utils
 from devil.android.sdk import adb_wrapper
+from devil.constants import exit_codes
 from devil.utils import watchdog_timer
-from pylib import constants
 from pylib.base import base_test_result
 from pylib.base import test_collection
 from pylib.base import test_dispatcher
+from pylib.constants import host_paths
 
-sys.path.append(
-    os.path.join(constants.DIR_SOURCE_ROOT, 'third_party', 'pymock'))
-import mock # pylint: disable=import-error
+with host_paths.SysPath(host_paths.PYMOCK_PATH):
+  import mock # pylint: disable=import-error
 
 
 class TestException(Exception):
   pass
 
 
 def _MockDevice(serial):
   d = mock.MagicMock(spec=device_utils.DeviceUtils)
   d.__str__.return_value = serial
   d.adb = mock.MagicMock(spec=adb_wrapper.AdbWrapper)
@@ skipping 132 matching lines @@
     test_dispatcher._TearDownRunners(runners)
     for runner in runners:
       self.assertEqual(runner.teardowns, 1)
 
   def testRetry(self):
     runners = test_dispatcher._CreateRunners(
         MockRunnerFail, [_MockDevice('0'), _MockDevice('1')])
     results, exit_code = test_dispatcher._RunAllTests(
         runners, self.test_collection_factory, 0)
     self.assertEqual(len(results.GetFail()), len(self.tests))
-    self.assertEqual(exit_code, constants.ERROR_EXIT_CODE)
+    self.assertEqual(exit_code, exit_codes.ERROR)
 
   def testReraise(self):
     runners = test_dispatcher._CreateRunners(
         MockRunnerException, [_MockDevice('0'), _MockDevice('1')])
     with self.assertRaises(TestException):
       test_dispatcher._RunAllTests(runners, self.test_collection_factory, 0)
 
 
 class TestShard(unittest.TestCase):
   """Tests test_dispatcher.RunTests with sharding."""
   @staticmethod
   def _RunShard(runner_factory):
     return test_dispatcher.RunTests(
         ['a', 'b', 'c'], runner_factory, [_MockDevice('0'), _MockDevice('1')],
         shard=True)
 
   def testShard(self):
     results, exit_code = TestShard._RunShard(MockRunner)
     self.assertEqual(len(results.GetPass()), 3)
     self.assertEqual(exit_code, 0)
 
   def testFailing(self):
     results, exit_code = TestShard._RunShard(MockRunnerFail)
     self.assertEqual(len(results.GetPass()), 0)
     self.assertEqual(len(results.GetFail()), 3)
-    self.assertEqual(exit_code, constants.ERROR_EXIT_CODE)
+    self.assertEqual(exit_code, exit_codes.ERROR)
 
   def testNoTests(self):
     results, exit_code = test_dispatcher.RunTests(
         [], MockRunner, [_MockDevice('0'), _MockDevice('1')], shard=True)
     self.assertEqual(len(results.GetAll()), 0)
-    self.assertEqual(exit_code, constants.ERROR_EXIT_CODE)
+    self.assertEqual(exit_code, exit_codes.ERROR)
 
 
 class TestReplicate(unittest.TestCase):
   """Tests test_dispatcher.RunTests with replication."""
   @staticmethod
   def _RunReplicate(runner_factory):
     return test_dispatcher.RunTests(
         ['a', 'b', 'c'], runner_factory, [_MockDevice('0'), _MockDevice('1')],
         shard=False)
 
   def testReplicate(self):
     results, exit_code = TestReplicate._RunReplicate(MockRunner)
     # We expect 6 results since each test should have been run on every device
     self.assertEqual(len(results.GetPass()), 6)
     self.assertEqual(exit_code, 0)
 
   def testFailing(self):
     results, exit_code = TestReplicate._RunReplicate(MockRunnerFail)
     self.assertEqual(len(results.GetPass()), 0)
     self.assertEqual(len(results.GetFail()), 6)
-    self.assertEqual(exit_code, constants.ERROR_EXIT_CODE)
+    self.assertEqual(exit_code, exit_codes.ERROR)
 
   def testNoTests(self):
     results, exit_code = test_dispatcher.RunTests(
         [], MockRunner, [_MockDevice('0'), _MockDevice('1')], shard=False)
     self.assertEqual(len(results.GetAll()), 0)
-    self.assertEqual(exit_code, constants.ERROR_EXIT_CODE)
+    self.assertEqual(exit_code, exit_codes.ERROR)
 
 
 if __name__ == '__main__':
   unittest.main()