[Android] Add a custom pylintrc for build/android/.

build/android/pylib/base/test_dispatcher.py

 # 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.
 
 """Dispatches tests, either sharding or replicating them.
 
 Performs the following steps:
 * Create a test collection factory, using the given tests
   - If sharding: test collection factory returns the same shared test collection
     to all test runners
@@ skipping 153 matching lines @@
     num_retries: Number of retries for a test.
     timeout: Watchdog timeout in seconds.
     tag_results_with_device: If True, appends the name of the device on which
         the test was run to the test name. Used when replicating to identify
         which device ran each copy of the test, and to ensure each copy of the
         test is recorded separately.
 
   Returns:
     A tuple of (TestRunResults object, exit code)
   """
-  logging.warning('Running tests with %s test runners.' % (len(runners)))
+  logging.warning('Running tests with %s test runners.', len(runners))
   results = []
   exit_code = 0
   run_results = base_test_result.TestRunResults()
   watcher = watchdog_timer.WatchdogTimer(timeout)
   test_collections = [test_collection_factory() for _ in runners]
 
   threads = [
       reraiser_thread.ReraiserThread(
           _RunTestsFromQueue,
           [r, tc, results, watcher, num_retries, tag_results_with_device],
           name=r.device_serial[-4:])
       for r, tc in zip(runners, test_collections)]
 
   workers = reraiser_thread.ReraiserThreadGroup(threads)
   workers.StartAll()
 
   try:
     workers.JoinAll(watcher)
   except device_errors.CommandFailedError:
     logging.exception('Command failed on device.')
   except device_errors.CommandFailedError:
     logging.exception('Command timed out on device.')
   except device_errors.DeviceUnreachableError:
     logging.exception('Device became unreachable.')
 
   if not all((len(tc) == 0 for tc in test_collections)):
-    logging.error('Only ran %d tests (all devices are likely offline).' %
+    logging.error('Only ran %d tests (all devices are likely offline).',
                   len(results))
     for tc in test_collections:
       run_results.AddResults(base_test_result.BaseTestResult(
           t, base_test_result.ResultType.UNKNOWN) for t in tc.test_names())
 
   for r in results:
     run_results.AddTestRunResults(r)
   if not run_results.DidRunPass():
     exit_code = constants.ERROR_EXIT_CODE
   return (run_results, exit_code)
 
 
 def _CreateRunners(runner_factory, devices, timeout=None):
   """Creates a test runner for each device and calls SetUp() in parallel.
 
   Note: if a device is unresponsive the corresponding TestRunner will not be
     included in the returned list.
 
   Args:
     runner_factory: Callable that takes a device and index and returns a
       TestRunner object.
     devices: List of device serial numbers as strings.
     timeout: Watchdog timeout in seconds, defaults to the default timeout.
 
   Returns:
     A list of TestRunner objects.
   """
-  logging.warning('Creating %s test runners.' % len(devices))
+  logging.warning('Creating %s test runners.', len(devices))
   runners = []
   counter = _ThreadSafeCounter()
   threads = reraiser_thread.ReraiserThreadGroup(
       [reraiser_thread.ReraiserThread(_SetUp,
                                       [runner_factory, d, runners, counter],
                                       name=str(d)[-4:])
        for d in devices])
   threads.StartAll()
   threads.JoinAll(watchdog_timer.WatchdogTimer(timeout))
   return runners
@@ skipping 84 matching lines @@
                len(tests_expanded), log_string, str(tests_expanded))
   runners = _CreateRunners(runner_factory, devices, setup_timeout)
   try:
     return _RunAllTests(runners, test_collection_factory,
                         num_retries, test_timeout, tag_results_with_device)
   finally:
     try:
       _TearDownRunners(runners, setup_timeout)
     except device_errors.DeviceUnreachableError as e:
       logging.warning('Device unresponsive during TearDown: [%s]', e)
-    except Exception as e:
-      logging.error('Unexpected exception caught during TearDown: %s' % str(e))
+    except Exception: # pylint: disable=broad-except
+      logging.exception('Unexpected exception caught during TearDown')