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

build/android/pylib/instrumentation/instrumentation_test_instance.py

 # Copyright 2015 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.
 
 import logging
 import os
 import pickle
 import re
 import sys
 
 from devil.android import apk_helper
 from devil.android import md5sum
-from devil.utils import cmd_helper
 from pylib import constants
-from pylib import flag_changer
 from pylib.base import base_test_result
 from pylib.base import test_instance
 from pylib.instrumentation import test_result
 from pylib.instrumentation import instrumentation_parser
 from pylib.utils import proguard
 
 sys.path.append(
     os.path.join(constants.DIR_SOURCE_ROOT, 'build', 'util', 'lib', 'common'))
-import unittest_util
+import unittest_util # pylint: disable=import-error
 
 # Ref: http://developer.android.com/reference/android/app/Activity.html
 _ACTIVITY_RESULT_CANCELED = 0
 _ACTIVITY_RESULT_OK = -1
 
 _DEFAULT_ANNOTATIONS = [
     'Smoke', 'SmallTest', 'MediumTest', 'LargeTest',
     'EnormousTest', 'IntegrationTest']
 _EXTRA_ENABLE_HTTP_SERVER = (
     'org.chromium.chrome.test.ChromeInstrumentationTestRunner.'
@@ skipping 317 matching lines @@
               [None, 'chrome', 'test', 'data', device_rel_path])])
 
   def GetDataDependencies(self):
     return self._data_deps
 
   def GetTests(self):
     pickle_path = '%s-proguard.pickle' % self.test_jar
     try:
       tests = self._GetTestsFromPickle(pickle_path, self.test_jar)
     except self.ProguardPickleException as e:
-      logging.info('Getting tests from JAR via proguard. (%s)' % str(e))
+      logging.info('Getting tests from JAR via proguard. (%s)', str(e))
       tests = self._GetTestsFromProguard(self.test_jar)
       self._SaveTestsToPickle(pickle_path, self.test_jar, tests)
     return self._InflateTests(self._FilterTests(tests))
 
   class ProguardPickleException(Exception):
     pass
 
   def _GetTestsFromPickle(self, pickle_path, jar_path):
     if not os.path.exists(pickle_path):
       raise self.ProguardPickleException('%s does not exist.' % pickle_path)
     if os.path.getmtime(pickle_path) <= os.path.getmtime(jar_path):
       raise self.ProguardPickleException(
           '%s newer than %s.' % (jar_path, pickle_path))
 
     with open(pickle_path, 'r') as pickle_file:
       pickle_data = pickle.loads(pickle_file.read())
     jar_md5 = md5sum.CalculateHostMd5Sums(jar_path)[jar_path]
 
     try:
       if pickle_data['VERSION'] != _PICKLE_FORMAT_VERSION:
         raise self.ProguardPickleException('PICKLE_FORMAT_VERSION has changed.')
       if pickle_data['JAR_MD5SUM'] != jar_md5:
         raise self.ProguardPickleException('JAR file MD5 sum differs.')
       return pickle_data['TEST_METHODS']
     except TypeError as e:
       logging.error(pickle_data)
       raise self.ProguardPickleException(str(e))
 
+  # pylint: disable=no-self-use
   def _GetTestsFromProguard(self, jar_path):
     p = proguard.Dump(jar_path)
 
     def is_test_class(c):
       return c['class'].endswith('Test')
 
     def is_test_method(m):
       return m['method'].startswith('test')
 
     class_lookup = dict((c['class'], c) for c in p['classes'])
@@ skipping 115 matching lines @@
   def GenerateTestResults(
       result_code, result_bundle, statuses, start_ms, duration_ms):
     return GenerateTestResults(result_code, result_bundle, statuses,
                                start_ms, duration_ms)
 
   #override
   def TearDown(self):
     if self._isolate_delegate:
       self._isolate_delegate.Clear()