Merge "Apply pylint to scripts/manifest_check*.py" am: da513b1e

import sys

from xml.dom import minidom

from manifest import android_ns

from manifest import get_children_with_tag

from manifest import parse_manifest

    """Parse commandline arguments."""

    parser = argparse.ArgumentParser()

  parser.add_argument('--uses-library', dest='uses_libraries',

    parser.add_argument(

        '--uses-library',

        dest='uses_libraries',

        action='append',

        help='specify uses-library entries known to the build system')

  parser.add_argument('--optional-uses-library',

    parser.add_argument(

        '--optional-uses-library',

        dest='optional_uses_libraries',

        action='append',

                      help='specify uses-library entries known to the build system with required:false')

  parser.add_argument('--enforce-uses-libraries',

        help='specify uses-library entries known to the build system with '

        'required:false'

    )

    parser.add_argument(

        '--enforce-uses-libraries',

        dest='enforce_uses_libraries',

        action='store_true',

                      help='check the uses-library entries known to the build system against the manifest')

  parser.add_argument('--enforce-uses-libraries-relax',

        help='check the uses-library entries known to the build system against '

        'the manifest'

    )

    parser.add_argument(

        '--enforce-uses-libraries-relax',

        dest='enforce_uses_libraries_relax',

        action='store_true',

        help='do not fail immediately, just save the error message to file')

  parser.add_argument('--enforce-uses-libraries-status',

    parser.add_argument(

        '--enforce-uses-libraries-status',

        dest='enforce_uses_libraries_status',

        help='output file to store check status (error message)')

  parser.add_argument('--extract-target-sdk-version',

    parser.add_argument(

        '--extract-target-sdk-version',

        dest='extract_target_sdk_version',

        action='store_true',

        help='print the targetSdkVersion from the manifest')

  parser.add_argument('--dexpreopt-config',

    parser.add_argument(

        '--dexpreopt-config',

        dest='dexpreopt_configs',

        action='append',

        help='a paths to a dexpreopt.config of some library')

  parser.add_argument('--aapt',

                      dest='aapt',

                      help='path to aapt executable')

  parser.add_argument('--output', '-o', dest='output', help='output AndroidManifest.xml file')

    parser.add_argument('--aapt', dest='aapt', help='path to aapt executable')

    parser.add_argument(

        '--output', '-o', dest='output', help='output AndroidManifest.xml file')

    parser.add_argument('input', help='input AndroidManifest.xml file')

    return parser.parse_args()

def enforce_uses_libraries(manifest, required, optional, relax, is_apk, path):

    """Verify that the <uses-library> tags in the manifest match those provided

  by the build system.

  Args:

    is_apk:   if the manifest comes from an APK or an XML file

    """

    if is_apk:

    manifest_required, manifest_optional, tags = extract_uses_libs_apk(manifest)

        manifest_required, manifest_optional, tags = extract_uses_libs_apk(

            manifest)

    else:

    manifest_required, manifest_optional, tags = extract_uses_libs_xml(manifest)

        manifest_required, manifest_optional, tags = extract_uses_libs_xml(

            manifest)

    # Trim namespace component. Normally Soong does that automatically when it

    # handles module names specified in Android.bp properties. However not all

    if manifest_required == required and manifest_optional == optional:

        return None

    #pylint: disable=line-too-long

    errmsg = ''.join([

        'mismatch in the <uses-library> tags between the build system and the '

        'manifest:\n',

        '\t- required libraries in build system: [%s]\n' % ', '.join(required),

    '\t                 vs. in the manifest: [%s]\n' % ', '.join(manifest_required),

        '\t                 vs. in the manifest: [%s]\n' %

        ', '.join(manifest_required),

        '\t- optional libraries in build system: [%s]\n' % ', '.join(optional),

    '\t                 vs. in the manifest: [%s]\n' % ', '.join(manifest_optional),

        '\t                 vs. in the manifest: [%s]\n' %

        ', '.join(manifest_optional),

        '\t- tags in the manifest (%s):\n' % path,

        '\t\t%s\n' % '\t\t'.join(tags),

        'note: the following options are available:\n',

        '\t- to temporarily disable the check for the whole product, set ',

        'PRODUCT_BROKEN_VERIFY_USES_LIBRARIES := true in the product makefiles\n',

        '\t- to fix the check, make build system properties coherent with the '

      'manifest\n',

    '\t- see build/make/Changes.md for details\n'])

        'manifest\n', '\t- see build/make/Changes.md for details\n'

    ])

    #pylint: enable=line-too-long

    if not relax:

        raise ManifestMismatchError(errmsg)

    return errmsg

MODULE_NAMESPACE = re.compile("^//[^:]+:")

MODULE_NAMESPACE = re.compile('^//[^:]+:')

def trim_namespace_parts(modules):

  """Trim the namespace part of each module, if present. Leave only the name."""

    """Trim the namespace part of each module, if present.

    Leave only the name.

    """

    trimmed = []

    for module in modules:

    for match in re.finditer(pattern, badging):

        lines.append(match.group(0))

        libname = match.group(2)

    if match.group(1) == None:

        if match.group(1) is None:

            required.append(libname)

        else:

            optional.append(libname)

    return required, optional, tags

def extract_uses_libs_xml(xml):

def extract_uses_libs_xml(xml): #pylint: disable=inconsistent-return-statements

    """Extract <uses-library> tags from the manifest."""

    manifest = parse_manifest(xml)

    elems = get_children_with_tag(manifest, 'application')

    application = elems[0] if len(elems) == 1 else None

  if len(elems) > 1:

    if len(elems) > 1: #pylint: disable=no-else-raise

        raise RuntimeError('found multiple <application> tags')

    elif not elems:

    if uses_libraries or optional_uses_libraries:

        if uses_libraries or optional_uses_libraries: #pylint: disable=undefined-variable

            raise ManifestMismatchError('no <application> tag found')

        return

    libs = get_children_with_tag(application, 'uses-library')

    required = [uses_library_name(x) for x in libs if uses_library_required(x)]

  optional = [uses_library_name(x) for x in libs if not uses_library_required(x)]

    optional = [

        uses_library_name(x) for x in libs if not uses_library_required(x)

    ]

    # render <uses-library> tags as XML for a pretty error message

    tags = []

def first_unique_elements(l):

    result = []

  [result.append(x) for x in l if x not in result]

    for x in l:

        if x not in result:

            result.append(x)

    return result

    lib: a <uses-library> tag.

    """

    name = lib.getAttributeNodeNS(android_ns, 'name')

  return name.value if name is not None else ""

    return name.value if name is not None else ''

def uses_library_required(lib):

    manifest: manifest (either parsed XML or aapt dump of APK)

    is_apk:   if the manifest comes from an APK or an XML file

    """

  if is_apk:

    if is_apk: #pylint: disable=no-else-return

        return extract_target_sdk_version_apk(manifest)

    else:

        return extract_target_sdk_version_xml(manifest)

    # Get or insert the uses-sdk element

    uses_sdk = get_children_with_tag(manifest, 'uses-sdk')

  if len(uses_sdk) > 1:

    if len(uses_sdk) > 1: #pylint: disable=no-else-raise

        raise RuntimeError('found multiple uses-sdk elements')

    elif len(uses_sdk) == 0:

        raise RuntimeError('missing uses-sdk element')

        # processed in different ways.

        is_apk = args.input.endswith('.apk')

        if is_apk:

      aapt = args.aapt if args.aapt != None else "aapt"

      manifest = subprocess.check_output([aapt, "dump", "badging", args.input])

            aapt = args.aapt if args.aapt is not None else 'aapt'

            manifest = subprocess.check_output(

                [aapt, 'dump', 'badging', args.input])

        else:

            manifest = minidom.parse(args.input)

        if args.enforce_uses_libraries:

      # Load dexpreopt.config files and build a mapping from module names to

      # library names. This is necessary because build system addresses

      # libraries by their module name (`uses_libs`, `optional_uses_libs`,

      # `LOCAL_USES_LIBRARIES`, `LOCAL_OPTIONAL_LIBRARY_NAMES` all contain

      # module names), while the manifest addresses libraries by their name.

            # Load dexpreopt.config files and build a mapping from module

            # names to library names. This is necessary because build system

            # addresses libraries by their module name (`uses_libs`,

            # `optional_uses_libs`, `LOCAL_USES_LIBRARIES`,

            # `LOCAL_OPTIONAL_LIBRARY_NAMES` all contain module names), while

            # the manifest addresses libraries by their name.

            mod_to_lib = load_dexpreopt_configs(args.dexpreopt_configs)

            required = translate_libnames(args.uses_libraries, mod_to_lib)

      optional = translate_libnames(args.optional_uses_libraries, mod_to_lib)

            optional = translate_libnames(args.optional_uses_libraries,

                                          mod_to_lib)

      # Check if the <uses-library> lists in the build system agree with those

      # in the manifest. Raise an exception on mismatch, unless the script was

      # passed a special parameter to suppress exceptions.

            # Check if the <uses-library> lists in the build system agree with

            # those in the manifest. Raise an exception on mismatch, unless the

            # script was passed a special parameter to suppress exceptions.

            errmsg = enforce_uses_libraries(manifest, required, optional,

        args.enforce_uses_libraries_relax, is_apk, args.input)

                                            args.enforce_uses_libraries_relax,

                                            is_apk, args.input)

      # Create a status file that is empty on success, or contains an error

      # message on failure. When exceptions are suppressed, dexpreopt command

      # command will check file size to determine if the check has failed.

            # Create a status file that is empty on success, or contains an

            # error message on failure. When exceptions are suppressed,

            # dexpreopt command command will check file size to determine if

            # the check has failed.

            if args.enforce_uses_libraries_status:

                with open(args.enforce_uses_libraries_status, 'w') as f:

          if not errmsg == None:

            f.write("%s\n" % errmsg)

                    if not errmsg is not None:

                        f.write('%s\n' % errmsg)

        if args.extract_target_sdk_version:

            try:

                print(extract_target_sdk_version(manifest, is_apk))

      except:

        # Failed; don't crash, return "any" SDK version. This will result in

        # dexpreopt not adding any compatibility libraries.

            except: #pylint: disable=bare-except

                # Failed; don't crash, return "any" SDK version. This will

                # result in dexpreopt not adding any compatibility libraries.

                print(10000)

        if args.output:

      # XML output is supposed to be written only when this script is invoked

      # with XML input manifest, not with an APK.

            # XML output is supposed to be written only when this script is

            # invoked with XML input manifest, not with an APK.

            if is_apk:

                raise RuntimeError('cannot save APK manifest as XML')

        print('error: ' + str(err), file=sys.stderr)

        sys.exit(-1)

if __name__ == '__main__':

    main()

class EnforceUsesLibrariesTest(unittest.TestCase):

    """Unit tests for add_extract_native_libs function."""

  def run_test(self, xml, apk, uses_libraries=[], optional_uses_libraries=[]):

    def run_test(self, xml, apk, uses_libraries=[], optional_uses_libraries=[]): #pylint: disable=dangerous-default-value

        doc = minidom.parseString(xml)

        try:

            relax = False

      manifest_check.enforce_uses_libraries(doc, uses_libraries,

        optional_uses_libraries, relax, False, 'path/to/X/AndroidManifest.xml')

            manifest_check.enforce_uses_libraries(

                doc, uses_libraries, optional_uses_libraries, relax, False,

                'path/to/X/AndroidManifest.xml')

            manifest_check.enforce_uses_libraries(apk, uses_libraries,

        optional_uses_libraries, relax, True, 'path/to/X/X.apk')

                                                  optional_uses_libraries,

                                                  relax, True,

                                                  'path/to/X/X.apk')

            return True

        except manifest_check.ManifestMismatchError:

            return False

    xml_tmpl = (

      '<?xml version="1.0" encoding="utf-8"?>\n'

      '<manifest xmlns:android="http://schemas.android.com/apk/res/android">\n'

      '    <application>\n'

      '    %s\n'

      '    </application>\n'

      '</manifest>\n')

        '<?xml version="1.0" encoding="utf-8"?>\n<manifest '

        'xmlns:android="http://schemas.android.com/apk/res/android">\n    '

        '<application>\n    %s\n    </application>\n</manifest>\n')

    apk_tmpl = (

        "package: name='com.google.android.something' versionCode='100'\n"

        "sdkVersion:'29'\n"

        "targetSdkVersion:'29'\n"

        "uses-permission: name='android.permission.ACCESS_NETWORK_STATE'\n"

      "%s\n"

        '%s\n'

        "densities: '160' '240' '320' '480' '640' '65534")

    def test_uses_library(self):

        self.assertFalse(matches)

    def test_multiple_uses_library(self):

    xml = self.xml_tmpl % ('\n'.join([uses_library_xml('foo'),

        xml = self.xml_tmpl % ('\n'.join(

            [uses_library_xml('foo'),

             uses_library_xml('bar')]))

    apk = self.apk_tmpl % ('\n'.join([uses_library_apk('foo'),

        apk = self.apk_tmpl % ('\n'.join(

            [uses_library_apk('foo'),

             uses_library_apk('bar')]))

        matches = self.run_test(xml, apk, uses_libraries=['foo', 'bar'])

        self.assertTrue(matches)

    def test_multiple_optional_uses_library(self):

    xml = self.xml_tmpl % ('\n'.join([uses_library_xml('foo', required_xml(False)),

                                      uses_library_xml('bar', required_xml(False))]))

    apk = self.apk_tmpl % ('\n'.join([uses_library_apk('foo', required_apk(False)),

                                      uses_library_apk('bar', required_apk(False))]))

    matches = self.run_test(xml, apk, optional_uses_libraries=['foo', 'bar'])

        xml = self.xml_tmpl % ('\n'.join([

            uses_library_xml('foo', required_xml(False)),

            uses_library_xml('bar', required_xml(False))

        ]))

        apk = self.apk_tmpl % ('\n'.join([

            uses_library_apk('foo', required_apk(False)),

            uses_library_apk('bar', required_apk(False))

        ]))

        matches = self.run_test(

            xml, apk, optional_uses_libraries=['foo', 'bar'])

        self.assertTrue(matches)

    def test_order_uses_library(self):

    xml = self.xml_tmpl % ('\n'.join([uses_library_xml('foo'),

        xml = self.xml_tmpl % ('\n'.join(

            [uses_library_xml('foo'),

             uses_library_xml('bar')]))

    apk = self.apk_tmpl % ('\n'.join([uses_library_apk('foo'),

        apk = self.apk_tmpl % ('\n'.join(

            [uses_library_apk('foo'),

             uses_library_apk('bar')]))

        matches = self.run_test(xml, apk, uses_libraries=['bar', 'foo'])

        self.assertFalse(matches)

    def test_order_optional_uses_library(self):

    xml = self.xml_tmpl % ('\n'.join([uses_library_xml('foo', required_xml(False)),

                                      uses_library_xml('bar', required_xml(False))]))

    apk = self.apk_tmpl % ('\n'.join([uses_library_apk('foo', required_apk(False)),

                                      uses_library_apk('bar', required_apk(False))]))

    matches = self.run_test(xml, apk, optional_uses_libraries=['bar', 'foo'])

        xml = self.xml_tmpl % ('\n'.join([

            uses_library_xml('foo', required_xml(False)),

            uses_library_xml('bar', required_xml(False))

        ]))

        apk = self.apk_tmpl % ('\n'.join([

            uses_library_apk('foo', required_apk(False)),

            uses_library_apk('bar', required_apk(False))

        ]))

        matches = self.run_test(

            xml, apk, optional_uses_libraries=['bar', 'foo'])

        self.assertFalse(matches)

    def test_duplicate_uses_library(self):

    xml = self.xml_tmpl % ('\n'.join([uses_library_xml('foo'),

        xml = self.xml_tmpl % ('\n'.join(

            [uses_library_xml('foo'),

             uses_library_xml('foo')]))

    apk = self.apk_tmpl % ('\n'.join([uses_library_apk('foo'),

        apk = self.apk_tmpl % ('\n'.join(

            [uses_library_apk('foo'),

             uses_library_apk('foo')]))

        matches = self.run_test(xml, apk, uses_libraries=['foo'])

        self.assertTrue(matches)

    def test_duplicate_optional_uses_library(self):

    xml = self.xml_tmpl % ('\n'.join([uses_library_xml('foo', required_xml(False)),

                                      uses_library_xml('foo', required_xml(False))]))

    apk = self.apk_tmpl % ('\n'.join([uses_library_apk('foo', required_apk(False)),

                                      uses_library_apk('foo', required_apk(False))]))

        xml = self.xml_tmpl % ('\n'.join([

            uses_library_xml('foo', required_xml(False)),

            uses_library_xml('foo', required_xml(False))

        ]))

        apk = self.apk_tmpl % ('\n'.join([

            uses_library_apk('foo', required_apk(False)),

            uses_library_apk('foo', required_apk(False))

        ]))

        matches = self.run_test(xml, apk, optional_uses_libraries=['foo'])

        self.assertTrue(matches)

    def test_mixed(self):

    xml = self.xml_tmpl % ('\n'.join([uses_library_xml('foo'),

                                      uses_library_xml('bar', required_xml(False))]))

    apk = self.apk_tmpl % ('\n'.join([uses_library_apk('foo'),

                                      uses_library_apk('bar', required_apk(False))]))

    matches = self.run_test(xml, apk, uses_libraries=['foo'],

                            optional_uses_libraries=['bar'])

        xml = self.xml_tmpl % ('\n'.join([

            uses_library_xml('foo'),

            uses_library_xml('bar', required_xml(False))

        ]))

        apk = self.apk_tmpl % ('\n'.join([

            uses_library_apk('foo'),

            uses_library_apk('bar', required_apk(False))

        ]))

        matches = self.run_test(

            xml, apk, uses_libraries=['foo'], optional_uses_libraries=['bar'])

        self.assertTrue(matches)

    def test_mixed_with_namespace(self):

    xml = self.xml_tmpl % ('\n'.join([uses_library_xml('foo'),

                                      uses_library_xml('bar', required_xml(False))]))

    apk = self.apk_tmpl % ('\n'.join([uses_library_apk('foo'),

                                      uses_library_apk('bar', required_apk(False))]))

    matches = self.run_test(xml, apk, uses_libraries=['//x/y/z:foo'],

        xml = self.xml_tmpl % ('\n'.join([

            uses_library_xml('foo'),

            uses_library_xml('bar', required_xml(False))

        ]))

        apk = self.apk_tmpl % ('\n'.join([

            uses_library_apk('foo'),

            uses_library_apk('bar', required_apk(False))

        ]))

        matches = self.run_test(

            xml,

            apk,

            uses_libraries=['//x/y/z:foo'],

            optional_uses_libraries=['//x/y/z:bar'])

        self.assertTrue(matches)

class ExtractTargetSdkVersionTest(unittest.TestCase):

    def run_test(self, xml, apk, version):

        doc = minidom.parseString(xml)

        v = manifest_check.extract_target_sdk_version(doc, is_apk=False)

        self.assertEqual(v, version)

    xml_tmpl = (

      '<?xml version="1.0" encoding="utf-8"?>\n'

      '<manifest xmlns:android="http://schemas.android.com/apk/res/android">\n'

      '    <uses-sdk android:minSdkVersion="28" android:targetSdkVersion="%s" />\n'

      '</manifest>\n')

        '<?xml version="1.0" encoding="utf-8"?>\n<manifest '

        'xmlns:android="http://schemas.android.com/apk/res/android">\n    '

        '<uses-sdk android:minSdkVersion="28" android:targetSdkVersion="%s" '

        '/>\n</manifest>\n')

    apk_tmpl = (

        "package: name='com.google.android.something' versionCode='100'\n"

        "uses-permission: name='android.permission.ACCESS_NETWORK_STATE'\n")

    def test_targert_sdk_version_28(self):

    xml = self.xml_tmpl % "28"

    apk = self.apk_tmpl % "28"

    self.run_test(xml, apk, "28")

        xml = self.xml_tmpl % '28'

        apk = self.apk_tmpl % '28'

        self.run_test(xml, apk, '28')

    def test_targert_sdk_version_29(self):

    xml = self.xml_tmpl % "29"

    apk = self.apk_tmpl % "29"

    self.run_test(xml, apk, "29")

        xml = self.xml_tmpl % '29'

        apk = self.apk_tmpl % '29'

        self.run_test(xml, apk, '29')

if __name__ == '__main__':

    unittest.main(verbosity=2)