| import argparse |
| import string |
| |
| class TestGroup: |
| def __init__(self, name, parent = None): |
| self.parent = parent |
| self.name = name |
| self.testGroups = {} |
| self.testCases = {} |
| |
| if parent: |
| assert not name in parent.testGroups |
| parent.testGroups[name] = self |
| |
| def getName (self): |
| return self.name |
| |
| def getPath (self): |
| if self.parent: |
| return self.parent.getPath() + "." + self.name |
| else: |
| return self.name |
| |
| def hasGroup(self, groupName): |
| return groupName in self.testGroups |
| |
| def getGroup(self, groupName): |
| return self.testGroups[groupName] |
| |
| def hasTest(self, testName): |
| return testName in self.testCases |
| |
| def getTest(self, testName): |
| return self.testCases[testName] |
| |
| def hasTestCases(self): |
| return len(self.testCases) != 0 |
| |
| def hasTestGroups(self): |
| return len(self.testGroups) != 0 |
| |
| def getTestCases(self): |
| return self.testCases.values() |
| |
| def getTestGroups(self): |
| return self.testGroups.values() |
| |
| class TestCase: |
| def __init__(self, name, parent): |
| self.name = name |
| self.parent = parent |
| |
| assert not name in self.parent.testCases |
| self.parent.testCases[name] = self |
| |
| def getPath (self): |
| return self.parent.getPath() + "." + self.name |
| |
| def getName(self): |
| return self.name |
| |
| def addGroupToHierarchy(rootGroup, path): |
| pathComponents = string.split(path, ".") |
| currentGroup = rootGroup |
| |
| assert pathComponents[0] == rootGroup.getName() |
| |
| for i in range(1, len(pathComponents)): |
| component = pathComponents[i] |
| |
| if currentGroup.hasGroup(component): |
| currentGroup = currentGroup.getGroup(component) |
| else: |
| currentGroup = TestGroup(component, parent=currentGroup) |
| |
| def addTestToHierarchy(rootGroup, path): |
| pathComponents = string.split(path, ".") |
| currentGroup = rootGroup |
| |
| assert pathComponents[0] == rootGroup.getName() |
| |
| for i in range(1, len(pathComponents)): |
| component = pathComponents[i] |
| |
| if i == len(pathComponents) - 1: |
| TestCase(component, currentGroup) |
| else: |
| if currentGroup.hasGroup(component): |
| currentGroup = currentGroup.getGroup(component) |
| else: |
| currentGroup = TestGroup(component, parent=currentGroup) |
| |
| def loadTestHierarchy (input): |
| line = input.readline() |
| rootGroup = None |
| |
| if line.startswith("GROUP: "): |
| groupName = line[len("GROUP: "):-1] |
| rootGroup = TestGroup(groupName) |
| else: |
| assert False |
| |
| for line in input: |
| if line.startswith("GROUP: "): |
| groupPath = line[len("GROUP: "):-1]; |
| addGroupToHierarchy(rootGroup, groupPath) |
| elif line.startswith("TEST: "): |
| testPath = line[len("TEST: "):-1] |
| addTestToHierarchy(rootGroup, testPath) |
| else: |
| assert False |
| |
| return rootGroup |
| |
| def hasFilteredCases(group, includeTests): |
| for child in group.getTestCases(): |
| if child.getPath() in includeTests: |
| return True |
| |
| for child in group.getTestGroups(): |
| if hasFilteredCases(child, includeTests): |
| return True |
| |
| return False |
| |
| def addFilteredTest(parent, group, includeTests): |
| for child in group.getTestGroups(): |
| if hasFilteredCases(child, includeTests): |
| newChild = TestGroup(child.getName(), parent) |
| addFilteredTest(newChild, child, includeTests) |
| |
| for child in group.getTestCases(): |
| if child.getPath() in includeTests: |
| TestCase(child.getName(), parent) |
| |
| def filterTests(includeTests, group): |
| root = TestGroup(group.getName()) |
| |
| addFilteredTest(root, group, includeTests) |
| |
| return root |
| |
| def writeAndroidCTSTest(test, output): |
| output.write('<Test name="%s" />\n' % test.getName()) |
| |
| def writeAndroidCTSTestCase(group, output): |
| assert group.hasTestCases() |
| assert not group.hasTestGroups() |
| |
| output.write('<TestCase name="%s">\n' % group.getName()) |
| |
| for testCase in group.getTestCases(): |
| writeAndroidCTSTest(testCase, output) |
| |
| output.write('</TestCase>\n') |
| |
| def writeAndroidCTSTestSuite(group, output): |
| output.write('<TestSuite name="%s">\n' % group.getName()) |
| |
| for childGroup in group.getTestGroups(): |
| if childGroup.hasTestCases(): |
| assert not childGroup.hasTestGroups() |
| writeAndroidCTSTestCase(childGroup, output) |
| elif childGroup.hasTestGroups(): |
| writeAndroidCTSTestSuite(childGroup, output) |
| # \note Skips groups without testcases or child groups |
| |
| output.write('</TestSuite>\n') |
| |
| def writeAndroidCTSFile(rootGroup, output, mustpass, name="dEQP-GLES3", appPackageName="com.drawelements.deqp.gles3"): |
| output.write('<?xml version="1.0" encoding="UTF-8"?>\n') |
| output.write('<TestPackage name="%s" appPackageName="%s" testType="deqpTest">\n' % (name, appPackageName)) |
| |
| writeAndroidCTSTestSuite(filterTests(mustpass, rootGroup), output) |
| |
| output.write('</TestPackage>\n') |
| |
| if __name__ == "__main__": |
| parser = argparse.ArgumentParser() |
| parser.add_argument('input', type=argparse.FileType('r'), help="Input dEQP test hierarchy in txt format.") |
| parser.add_argument('output', type=argparse.FileType('w'), help="Output file for Android CTS test file.") |
| parser.add_argument('--name', dest="name", type=str, required=True, help="Name of the test package") |
| parser.add_argument('--package', dest="package", type=str, required=True, help="Name of the app package") |
| parser.add_argument('--must-pass', dest="mustpass", type=argparse.FileType('r'), required=True, help="Must pass file") |
| |
| args = parser.parse_args() |
| |
| rootGroup = loadTestHierarchy(args.input) |
| writeAndroidCTSFile(rootGroup, args.output, name=args.name, appPackageName=args.package, mustpass=set(map(lambda x : x.rstrip(), args.mustpass.readlines()))) |