#!/usr/bin/env python
|
#
|
# Copyright 2016 - The Android Open Source Project
|
#
|
# Licensed under the Apache License, Version 2.0 (the "License");
|
# you may not use this file except in compliance with the License.
|
# You may obtain a copy of the License at
|
#
|
# http://www.apache.org/licenses/LICENSE-2.0
|
#
|
# Unless required by applicable law or agreed to in writing, software
|
# distributed under the License is distributed on an "AS IS" BASIS,
|
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
# See the License for the specific language governing permissions and
|
# limitations under the License.
|
#
|
|
import os
|
import argparse
|
import math
|
|
|
class Module(object):
|
"""class used to represent a ltp module
|
|
Attribute:
|
_lines: list of string, lines of module text
|
_header: list of string, first line of module splited by :=
|
_type: string, type of module
|
_path: string, path of module
|
_output_dir: string, output directory of module
|
"""
|
_lines = None
|
_header = None
|
_type = None
|
_path = None
|
_output_dir = None
|
|
def __init__(self, output_dir):
|
self._output_dir = output_dir
|
|
def parse(self, module_text):
|
"""parse a module text
|
|
Args:
|
module_text: string, one block of ltp module build rule.
|
output_dir: string, ltp compile output directory
|
|
Return:
|
None if the input text is not a ltp module
|
Self if parsed succesfully
|
"""
|
self._lines = module_text.splitlines()
|
if len(self._lines) < 2:
|
self._type = None
|
return None
|
self._header = self._lines[0].split(' := ')
|
if len(self._header) < 2:
|
self._type = None
|
return None
|
self._type = self._header[0]
|
self._path = self._header[1]
|
return self
|
|
def IsBuildSuccess(self, counts):
|
"""Check whether a given module specified in Android.mk file
|
is succesfully built
|
|
Returns:
|
True if success
|
"""
|
if self._type is None:
|
return False
|
|
counts[self._type] = counts.get(self._type, 0) + 1
|
|
success = {"module_testname": self.IsBuildSuccessModuleTestname,
|
"module_libname": self.IsBuildSuccessModuleLibname,
|
"module_prebuilt": self.IsBuildSuccessModulePrebuilt,
|
}[self._type]()
|
|
if not success:
|
print " Module build failed: " + os.path.basename(self._path)
|
return success
|
|
def IsBuildSuccessModuleTestname(self):
|
"""Check whether a given ltp test module in Android.mk file
|
is succesfully built
|
|
Args:
|
module_path: string, the path of module on the first
|
line of the block
|
|
Returns:
|
True if success
|
"""
|
|
return os.path.isfile(self._output_dir + \
|
"testcases/bin/" + \
|
os.path.basename(self._path))
|
|
def IsBuildSuccessModuleLibname(self):
|
"""Check whether a given ltp lib module in Android.mk file
|
is succesfully built
|
|
Args:
|
module_path: the path of module on the first line of
|
the block
|
|
Returns:
|
True if success
|
"""
|
# TODO(yuexima) check lib build
|
print "Checking module_lib is not supported now, " + \
|
"assuming build success: " + self._path
|
return True
|
|
def IsBuildSuccessModulePrebuilt(self):
|
"""Check whether a given prebuilt module in Android.mk file
|
is succesfully built
|
|
Args:
|
module_path: string, the path of module on the first
|
line of the block
|
|
Returns:
|
True if success
|
"""
|
return os.path.isfile(self._output_dir + self._path)
|
|
|
class LtpModuleChecker(object):
|
"""LTP module result check class.
|
Checks for success build of each module in LTP's Android.mk file
|
and rewrite it with only successfully built modules.
|
"""
|
_output_dir = ""
|
_file_path_android_ltp_mk = ""
|
_module_counts = {}
|
|
def __init__(self, android_build_top, ltp_dir, target_product):
|
self._output_dir = android_build_top + '/out/target/product/' + \
|
target_product + '/data/nativetest/ltp/'
|
self._file_path_android_ltp_mk = ltp_dir + '/Android.ltp.mk'
|
|
def Read(self, file_path):
|
"""Read a file and return its entire content
|
|
Args:
|
file_path: string, file path
|
|
Returns:
|
entire file content in string format
|
"""
|
with open(file_path, 'r') as file:
|
return file.read()
|
|
def LoadModules(self):
|
"""Read the LTP Android.mk file and seperate modules into
|
a list of string
|
"""
|
return self.Read(self._file_path_android_ltp_mk).split("\n\n")
|
|
def CheckModules(self):
|
"""Start the LTP module build result checking and counting."""
|
modules = [Module(self._output_dir).parse(module)
|
for module in self.LoadModules()]
|
modules_succeed = \
|
[module for module in modules
|
if module is not None and
|
module.IsBuildSuccess(self._module_counts)
|
]
|
|
print "module type counts:"
|
print self._module_counts
|
|
print str(len(modules_succeed)) + \
|
" of " + str(sum([self._module_counts[i]
|
for i in self._module_counts])) + \
|
" modules were succesfully built."
|
print "--Check complete."
|
|
|
def main():
|
parser = argparse.ArgumentParser(
|
description='Generate Android.mk from parsed LTP make output')
|
parser.add_argument(
|
'--android_build_top',
|
dest='android_build_top',
|
required=True,
|
help='android build top directory')
|
parser.add_argument(
|
'--ltp_dir',
|
dest='ltp_dir',
|
required=True,
|
help='directory for the forked ltp project')
|
parser.add_argument(
|
'--target_product',
|
dest='target_product',
|
required=True,
|
help='target product name, \
|
such as "bullhead", "angler", etc.')
|
args = parser.parse_args()
|
|
checker = LtpModuleChecker(args.android_build_top, args.ltp_dir,
|
args.target_product)
|
checker.CheckModules()
|
|
|
if __name__ == '__main__':
|
main()
|
