#!/usr/bin/python3
|
#
|
# Copyright (C) 2015 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.
|
|
"""
|
Generate java test files for test 966.
|
"""
|
|
import generate_smali as base
|
import os
|
import sys
|
from pathlib import Path
|
|
BUILD_TOP = os.getenv("ANDROID_BUILD_TOP")
|
if BUILD_TOP is None:
|
print("ANDROID_BUILD_TOP not set. Please run build/envsetup.sh", file=sys.stderr)
|
sys.exit(1)
|
|
# Allow us to import mixins.
|
sys.path.append(str(Path(BUILD_TOP)/"art"/"test"/"utils"/"python"))
|
|
import testgen.mixins as mixins
|
import functools
|
import operator
|
import subprocess
|
|
class JavaConverter(mixins.DumpMixin, mixins.Named, mixins.JavaFileMixin):
|
"""
|
A class that can convert a SmaliFile to a JavaFile.
|
"""
|
def __init__(self, inner):
|
self.inner = inner
|
|
def get_name(self):
|
"""Gets the name of this file."""
|
return self.inner.get_name()
|
|
def __str__(self):
|
out = ""
|
for line in str(self.inner).splitlines(keepends = True):
|
if line.startswith("#"):
|
out += line[1:]
|
return out
|
|
class Compiler:
|
def __init__(self, sources, javac, temp_dir, classes_dir):
|
self.javac = javac
|
self.temp_dir = temp_dir
|
self.classes_dir = classes_dir
|
self.sources = sources
|
|
def compile_files(self, args, files):
|
"""
|
Compile the files given with the arguments given.
|
"""
|
args = args.split()
|
files = list(map(str, files))
|
cmd = ['sh', '-a', '-e', '--', str(self.javac)] + args + files
|
print("Running compile command: {}".format(cmd))
|
subprocess.check_call(cmd)
|
print("Compiled {} files".format(len(files)))
|
|
def execute(self):
|
"""
|
Compiles this test, doing partial compilation as necessary.
|
"""
|
# Compile Main and all classes first. Force all interfaces to be default so that there will be
|
# no compiler problems (works since classes only implement 1 interface).
|
for f in self.sources:
|
if isinstance(f, base.TestInterface):
|
JavaConverter(f.get_specific_version(base.InterfaceType.default)).dump(self.temp_dir)
|
else:
|
JavaConverter(f).dump(self.temp_dir)
|
self.compile_files("-d {}".format(self.classes_dir), self.temp_dir.glob("*.java"))
|
|
# Now we compile the interfaces
|
ifaces = set(i for i in self.sources if isinstance(i, base.TestInterface))
|
filters = (lambda a: a.is_default(), lambda a: not a.is_default())
|
converters = (lambda a: JavaConverter(a.get_specific_version(base.InterfaceType.default)),
|
lambda a: JavaConverter(a.get_specific_version(base.InterfaceType.empty)))
|
while len(ifaces) != 0:
|
for iface_filter, iface_converter in zip(filters, converters):
|
# Find those ifaces where there are no (uncompiled) interfaces that are subtypes.
|
tops = set(filter(lambda a: iface_filter(a) and not any(map(lambda i: a in i.get_super_types(), ifaces)), ifaces))
|
files = []
|
# Dump these ones, they are getting compiled.
|
for f in tops:
|
out = JavaConverter(f)
|
out.dump(self.temp_dir)
|
files.append(self.temp_dir / out.get_file_name())
|
# Force all superinterfaces of these to be empty so there will be no conflicts
|
overrides = functools.reduce(operator.or_, map(lambda i: i.get_super_types(), tops), set())
|
for overridden in overrides:
|
out = iface_converter(overridden)
|
out.dump(self.temp_dir)
|
files.append(self.temp_dir / out.get_file_name())
|
self.compile_files("-d {outdir} -cp {outdir}".format(outdir = self.classes_dir), files)
|
# Remove these from the set of interfaces to be compiled.
|
ifaces -= tops
|
print("Finished compiling all files.")
|
return
|
|
def main(argv):
|
javac_exec = Path(argv[1])
|
if not javac_exec.exists() or not javac_exec.is_file():
|
print("{} is not a shell script".format(javac_exec), file=sys.stderr)
|
sys.exit(1)
|
temp_dir = Path(argv[2])
|
if not temp_dir.exists() or not temp_dir.is_dir():
|
print("{} is not a valid source dir".format(temp_dir), file=sys.stderr)
|
sys.exit(1)
|
classes_dir = Path(argv[3])
|
if not classes_dir.exists() or not classes_dir.is_dir():
|
print("{} is not a valid classes directory".format(classes_dir), file=sys.stderr)
|
sys.exit(1)
|
expected_txt = Path(argv[4])
|
mainclass, all_files = base.create_all_test_files()
|
|
with expected_txt.open('w') as out:
|
print(mainclass.get_expected(), file=out)
|
print("Wrote expected output")
|
|
Compiler(all_files, javac_exec, temp_dir, classes_dir).execute()
|
|
if __name__ == '__main__':
|
main(sys.argv)
|
