test/utils/python/generate_java_main.py

#!/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 Main file from a classes.xml file.
"""

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 utils and mixins.
sys.path.append(str(Path(BUILD_TOP)/"art"/"test"/"utils"/"python"))

from testgen.utils import get_copyright
import testgen.mixins as mixins

from collections import namedtuple
import itertools
import functools
import xml.etree.ElementTree as ET

class MainClass(mixins.DumpMixin, mixins.Named, mixins.JavaFileMixin):
  """
  A mainclass and main method for this test.
  """

  MAIN_CLASS_TEMPLATE = """{copyright}
class Main {{
{test_groups}
{test_funcs}
{main_func}
}}
"""

  MAIN_FUNCTION_TEMPLATE = """
  public static void main(String[] args) {{
    {test_group_invoke}
  }}
"""

  TEST_GROUP_INVOKE_TEMPLATE = """
    {test_name}();
"""

  def __init__(self):
    """
    Initialize this MainClass
    """
    self.tests = set()
    self.global_funcs = set()

  def add_instance(self, it):
    """
    Add an instance test for the given class
    """
    self.tests.add(it)

  def add_func(self, f):
    """
    Add a function to the class
    """
    self.global_funcs.add(f)

  def get_name(self):
    """
    Get the name of this class
    """
    return "Main"

  def __str__(self):
    """
    Print this class
    """
    all_tests = sorted(self.tests)
    test_invoke = ""
    test_groups = ""
    for t in all_tests:
      test_groups += str(t)
    for t in sorted(all_tests):
      test_invoke += self.TEST_GROUP_INVOKE_TEMPLATE.format(test_name=t.get_name())
    main_func = self.MAIN_FUNCTION_TEMPLATE.format(test_group_invoke=test_invoke)

    funcs = ""
    for f in self.global_funcs:
      funcs += str(f)
    return self.MAIN_CLASS_TEMPLATE.format(copyright = get_copyright('java'),
                                           test_groups=test_groups,
                                           main_func=main_func, test_funcs=funcs)


class InstanceTest(mixins.Named, mixins.NameComparableMixin):
  """
  A method that runs tests for a particular concrete type, It calls the test
  cases for running it in all possible ways.
  """

  INSTANCE_TEST_TEMPLATE = """
  public static void {test_name}() {{
    System.out.println("Testing for type {ty}");
    String s = "{ty}";
    {ty} v = new {ty}();

    {invokes}

    System.out.println("End testing for type {ty}");
  }}
"""

  TEST_INVOKE_TEMPLATE = """
    {fname}(s, v);
"""

  def __init__(self, main, ty):
    """
    Initialize this test group for the given type
    """
    self.ty = ty
    self.main = main
    self.funcs = set()
    self.main.add_instance(self)

  def get_name(self):
    """
    Get the name of this test group
    """
    return "TEST_NAME_"+self.ty

  def add_func(self, f):
    """
    Add a test function to this test group
    """
    self.main.add_func(f)
    self.funcs.add(f)

  def __str__(self):
    """
    Returns the java code for this function
    """
    func_invokes = ""
    for f in sorted(self.funcs, key=lambda a: (a.func, a.farg)):
      func_invokes += self.TEST_INVOKE_TEMPLATE.format(fname=f.get_name(),
                                                       farg=f.farg)

    return self.INSTANCE_TEST_TEMPLATE.format(test_name=self.get_name(), ty=self.ty,
                                              invokes=func_invokes)

class Func(mixins.Named, mixins.NameComparableMixin):
  """
  A single test case that attempts to invoke a function on receiver of a given type.
  """

  TEST_FUNCTION_TEMPLATE = """
  public static void {fname}(String s, {farg} v) {{
    try {{
      System.out.printf("%s-{invoke_type:<9} {farg:>9}.{callfunc}()='%s'\\n", s, v.{callfunc}());
      return;
    }} catch (Error e) {{
      System.out.printf("%s-{invoke_type} on {farg}: {callfunc}() threw exception!\\n", s);
      if (e instanceof IncompatibleClassChangeError) {{
        System.out.printf("Exception is of type %s\\n", e.getClass().getName());
      }} else {{
        e.printStackTrace(System.out);
      }}
    }}
  }}
"""

  def __init__(self, func, farg, invoke):
    """
    Initialize this test function for the given invoke type and argument
    """
    self.func = func
    self.farg = farg
    self.invoke = invoke

  def get_name(self):
    """
    Get the name of this test
    """
    return "Test_Func_{}_{}_{}".format(self.func, self.farg, self.invoke)

  def __str__(self):
    """
    Get the java code for this test function
    """
    return self.TEST_FUNCTION_TEMPLATE.format(fname=self.get_name(),
                                              farg=self.farg,
                                              invoke_type=self.invoke,
                                              callfunc=self.func)

def flatten_classes(classes, c):
  """
  Iterate over all the classes 'c' can be used as
  """
  while c:
    yield c
    c = classes.get(c.super_class)

def flatten_class_methods(classes, c):
  """
  Iterate over all the methods 'c' can call
  """
  for c1 in flatten_classes(classes, c):
    yield from c1.methods

def flatten_interfaces(dat, c):
  """
  Iterate over all the interfaces 'c' transitively implements
  """
  def get_ifaces(cl):
    for i2 in cl.implements:
      yield dat.interfaces[i2]
      yield from get_ifaces(dat.interfaces[i2])

  for cl in flatten_classes(dat.classes, c):
    yield from get_ifaces(cl)

def flatten_interface_methods(dat, i):
  """
  Iterate over all the interface methods 'c' can call
  """
  yield from i.methods
  for i2 in flatten_interfaces(dat, i):
    yield from i2.methods

def make_main_class(dat):
  """
  Creates a Main.java file that runs all the tests
  """
  m = MainClass()
  for c in dat.classes.values():
    i = InstanceTest(m, c.name)
    for clazz in flatten_classes(dat.classes, c):
      for meth in flatten_class_methods(dat.classes, clazz):
        i.add_func(Func(meth, clazz.name, 'virtual'))
      for iface in flatten_interfaces(dat, clazz):
        for meth in flatten_interface_methods(dat, iface):
          i.add_func(Func(meth, clazz.name, 'virtual'))
          i.add_func(Func(meth, iface.name, 'interface'))
  return m

class TestData(namedtuple("TestData", ['classes', 'interfaces'])):
  """
  A class representing the classes.xml document.
  """
  pass

class Clazz(namedtuple("Clazz", ["name", "methods", "super_class", "implements"])):
  """
  A class representing a class element in the classes.xml document.
  """
  pass

class IFace(namedtuple("IFace", ["name", "methods", "super_class", "implements"])):
  """
  A class representing an interface element in the classes.xml document.
  """
  pass

def parse_xml(xml):
  """
  Parse the xml description of this test.
  """
  classes = dict()
  ifaces  = dict()
  root = ET.fromstring(xml)
  for iface in root.find("interfaces"):
    name = iface.attrib['name']
    implements = [a.text for a in iface.find("implements")]
    methods = [a.text for a in iface.find("methods")]
    ifaces[name] = IFace(name = name,
                         super_class = iface.attrib['super'],
                         methods = methods,
                         implements = implements)
  for clazz in root.find('classes'):
    name = clazz.attrib['name']
    implements = [a.text for a in clazz.find("implements")]
    methods = [a.text for a in clazz.find("methods")]
    classes[name] = Clazz(name = name,
                          super_class = clazz.attrib['super'],
                          methods = methods,
                          implements = implements)
  return TestData(classes, ifaces)

def main(argv):
  java_dir = Path(argv[1])
  if not java_dir.exists() or not java_dir.is_dir():
    print("{} is not a valid java dir".format(java_dir), file=sys.stderr)
    sys.exit(1)
  class_data = parse_xml((java_dir / "classes.xml").open().read())
  make_main_class(class_data).dump(java_dir)

if __name__ == '__main__':
  main(sys.argv)