#!/usr/bin/python2.7
# Copyright (C) 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.
#
# Generate a CTS test XML file from a text file containing every single class#method per line
#
# For example, given an input file:
#
# foo.txt:
# com.android.ClassName#methodNameA
# com.android.ClassName#methodNameB
#
# Will generate the output file:
#
# TestPackage.xml:
# <TestPackage>
# <TestSuite name="com">
# <TestSuite name="android">
# <TestCase name="ClassName">
# <Test name="methodNameA" />
# <Test name="methodNameB" />
# </TestCase>
# </TestSuite>
# </TestSuite>
# </TestPackage>
#
import argparse
import sys
INDENTATION_INCREASE=2
class BaseNode(object):
def __init__(self, name=None):
self._children = []
self._name = name
self._properties = []
def _get_children(self):
return self._children
def _set_children(self, value):
self._children = value
children = property(_get_children, _set_children, doc="Get/set list of children BaseNode")
def append_child(self, child):
self._children.append(child)
def has_children(self):
return not not self._children
def _get_name(self):
return self._name
def _set_name(self, value):
self._name = value
name = property(_get_name, _set_name, doc="Get/set the name property of the current XML node")
def _get_type_name(self):
return type(self).__name__
type_name = property(_get_type_name, doc="Get the name of the current XML node")
def _set_properties(self, value):
self._properties = value
def _get_properties(self):
return self._properties
properties = property(_get_properties, _set_properties, doc="Get/set additional XML properties such as appPackageName (as a dict)")
def write_xml(self, out, indent=0):
out.write(' ' * indent)
out.write('<' + self.type_name)
if self.name is not None:
out.write(' name="')
out.write(self.name)
out.write('"')
if self.properties:
for key, value in self.properties.iteritems():
out.write(' ' + key + '="' + value + '"')
if not self.has_children():
out.write(' />')
out.write('\n')
return
out.write('>\n')
#TODO: print all the properties
for child in self.children:
child.write_xml(out, indent + INDENTATION_INCREASE)
out.write(' ' * indent)
out.write('</' + self.type_name + '>')
out.write('\n')
class _SuiteContainer(BaseNode):
def get_or_create_suite(self, package_list):
debug_print("get_or_create_suite, package_list = " + str(package_list))
debug_print("name = " + self.name)
# If we are empty, then we just reached the TestSuite which we actually wanted. Return.
if not package_list:
return self
current_package = package_list[0]
rest_of_packages = package_list[1:]
# If a suite already exists for the requested package, then have it look/create recursively.
for child in self.children:
if child.name == current_package:
return child.get_or_create_suite(rest_of_packages)
# No suite exists yet, create it recursively
new_suite = TestSuite(name=current_package)
self.append_child(new_suite)
return new_suite.get_or_create_suite(rest_of_packages)
class TestPackage(_SuiteContainer):
def add_class_and_method(self, fq_class_name, method):
debug_print("add_class_and_method, fq_class_name=" + fq_class_name + ", method=" + method)
package_list = fq_class_name.split(".")[:-1] # a.b.c -> ['a', 'b']
just_class_name = fq_class_name.split(".")[-1] # a.b.c -> 'c'
test_suite = self.get_or_create_suite(package_list)
if test_suite == self:
raise Exception("The suite cannot be the package")
return test_suite.add_class_and_method(just_class_name, method)
class TestSuite(_SuiteContainer):
def add_class_and_method(self, just_class_name, method_name):
test_case = self.get_or_create_test_case(just_class_name)
return test_case.add_method(method_name)
def get_or_create_test_case(self, just_class_name):
for child in self.children:
if child.name == just_class_name:
return child
new_test_case = TestCase(name=just_class_name)
self.append_child(new_test_case)
return new_test_case
class TestCase(BaseNode):
def add_method(self, method_name):
tst = Test(name=method_name)
self.append_child(tst)
return tst
class Test(BaseNode):
def __init__(self, name):
super(Test, self).__init__(name)
self._children = None
def debug_print(x):
#print x
pass
def build_xml_test_package(input, name, xml_properties):
root = TestPackage(name=name)
for line in input:
class_and_method_name = line.split('#')
fq_class_name = class_and_method_name[0].strip()
method_name = class_and_method_name[1].strip()
root.add_class_and_method(fq_class_name, method_name)
root.properties = xml_properties
return root
def write_xml(out, test_package):
out.write('<?xml version="1.0" encoding="UTF-8"?>\n')
test_package.write_xml(out)
def main():
parser = argparse.ArgumentParser(description='Process a test methods list file to generate CTS test xml.')
# Named required
parser.add_argument('--cts-name', help="name (e.g. CtsJdwp)", required=True)
parser.add_argument('--app-package-name', help="appPackageName (e.g. android.jdwp)", required=True)
parser.add_argument('--jar-path', help="jarPath (e.g. CtsJdwp.jar)", required=True)
# Named optionals
parser.add_argument('--test-type', help="testType (default testNGDeviceTest)",
default="testNGDeviceTest")
parser.add_argument('--runtime-args', help="runtimeArgs (e.g. -XXlib:libart.so)")
parser.add_argument('--version', help="version (default 1.0)", default="1.0")
# Positional optionals
parser.add_argument('input-filename', nargs='?',
help='name of the cts test file (stdin by default)')
parser.add_argument('output-filename', nargs='?',
help='name of the cts output file (stdout by default)')
# Map named arguments into the xml <TestPackage> property key name
argv_to_xml = {
'app_package_name' : 'appPackageName',
'jar_path' : 'jarPath',
'test_type' : 'testType',
'runtime_args' : 'runtimeArgs',
'version' : 'version'
}
args = parser.parse_args()
argv = vars(args) # convert Namespace to Dict
xml_properties = {}
for key, value in argv_to_xml.iteritems():
if argv.get(key):
xml_properties[value] = argv[key]
debug_print(argv['input-filename'])
debug_print(argv['output-filename'])
name_in = argv['input-filename']
name_out = argv['output-filename']
file_in = name_in and open(name_in, "r") or sys.stdin
file_out = name_out and open(name_out, "w+") or sys.stdout
# read all the input
test_package = build_xml_test_package(file_in, args.cts_name, xml_properties)
# write all the output
write_xml(file_out, test_package)
if __name__ == "__main__":
main()