tools/testng/gen-test-list-xml.py - platform/cts - Gitiles

 #!/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()
	#!/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()