Revision control

Copy as Markdown

# Copyright (C) 2019 The Qt Company Ltd.
# SPDX-License-Identifier: LicenseRef-Qt-Commercial OR GPL-3.0-only WITH Qt-GPL-exception-1.0
import subprocess
from subprocess import PIPE
import platform
import os
import shutil
import stat
import re
import atexit
from pathlib import Path
from packaging import version
from xml.dom import minidom
import json
isWindowsOS = (platform.system() == 'Windows')
exeExt = '.exe' if isWindowsOS else ''
# Set up our global variables
thisScriptDir = os.path.dirname(os.path.realpath(__file__))
os.environ["QT_LANCELOT_SERVER"] = "lancelot.intra.qt.io"
exitStatus = 0
gitUser = os.environ.get("GIT_USER") if os.environ.get(
"GIT_USER") else "Your Name"
gitEmail = os.environ.get("GIT_EMAIL") if os.environ.get(
"GIT_EMAIL") else "you@example.com"
testMode = "patchtest" if os.environ.get('GERRIT_EVENT_TYPE') else "headtest"
if testMode == "patchtest":
eventType = os.environ.get('GERRIT_EVENT_TYPE')
gerritProject = os.environ.get('GERRIT_PROJECT')
gerritOwner = os.environ.get('GERRIT_CHANGE_OWNER_NAME')
gerritUploaderEmail = os.environ.get('GERRIT_PATCHSET_UPLOADER_EMAIL')
subject = os.environ.get('GERRIT_CHANGE_SUBJECT')
refSpec = [os.environ.get('GERRIT_REFSPEC')] if os.environ.get(
'GERRIT_REFSPEC') else "" # Needs to be in list format
repo = gerritProject if gerritProject.find(
'/') == -1 else gerritProject[gerritProject.find('/') + 1: len(gerritProject)]
try:
temp = refSpec[0].split(" ")
if temp.find(" ") > -1:
refSpec = temp
temp = ""
except Exception:
pass
# Only use the gerrit event type if this is a patchtest
branch = os.environ.get('GERRIT_BRANCH') if os.environ.get('GERRIT_BRANCH') and os.environ.get(
'GERRIT_EVENT_TYPE') else os.environ.get('BRANCH')
workspace = os.environ.get("WORKSPACE")
baseDir = f'{os.environ.get("WORKSPACE")}/{branch}'
rebuildAll = os.environ.get(
'LB_REBUILD') if os.environ.get('LB_REBUILD') else False
refBaseDir = baseDir + "/ref"
commentfile = f"{workspace}/gerrit-comment.txt"
outputfile = f"{workspace}/output.txt"
buildCores = os.environ.get(
"BUILD_CORES") if os.environ.get("BUILD_CORES") else str(os.cpu_count())
VSDevEnv = os.environ.get("VS_DEV_ENV")
flexBisonDir = os.environ.get("FLEX_BISON_DIR") if os.environ.get(
"FLEX_BISON_DIR") else os.path.normpath(f"{workspace}/flex_bison") # Windows only
JOMPath = os.environ.get("JOM_PATH") if os.environ.get(
"JOM_PATH") else f"{workspace}/JOM/jom.exe" # Windows only
defaultLancelotConfigureOpts = [os.environ.get("LANCELOT_CONFIGURE_OPTIONS")] if os.environ.get(
"LANCELOT_CONFIGURE_OPTIONS") else []
try:
temp = defaultLancelotConfigureOpts[0].split(" ")
if temp.find(" ") > -1:
defaultLancelotConfigureOpts = temp
temp = ""
except Exception:
pass
compiler = "make" # Windows will set this to JOM
defaultPATH = os.environ.get("PATH")
# Used for title headers to make logs more human readable.
hr = "#######################"
hhr = "###########"
def setWindowsEnv():
global compiler
print("Configuring Windows environment variables...")
os.environ["PATH"] = defaultPATH
# runs the vsDevCmd file from the visual studio installation
vars = subprocess.check_output([VSDevEnv, '&&', 'set'])
# splits the output of the batch file and saves PATH variables from
# the batch to the local os.environ
for var in vars.splitlines():
var = var.decode('cp1252')
k, _, v = map(str.strip, var.strip().partition('='))
if k.startswith('?'):
continue
os.environ[k] = v
if os.path.lexists(flexBisonDir):
os.environ["PATH"] += (";" + os.path.normpath(flexBisonDir))
if os.path.lexists(JOMPath):
os.environ["PATH"] += (";" + os.path.dirname(os.path.normpath(JOMPath)))
compiler = shutil.which("jom.exe")
if compiler:
print(f"Found JOM at {compiler}")
else:
print(f"{hr} ERROR: JOM NOT FOUND ON SYSTEM. ABORTING... {hr}")
print("See README.md for more information on how to specify a JOM location.")
exit(1)
flex = shutil.which("flex.exe")
bison = shutil.which("bison.exe")
if not flex or not bison:
print(f"{hr} ERROR: FLEX OR BISON NOT FOUND ON SYSTEM. ABORTING... {hr}")
print("See README.md for more information on how to acquire flex bison.")
exit(1)
# catch for deleting files to try a less clean way of forcing deletion.
def on_rm_error(func, path, exc_info):
# path contains the path of the file that couldn't be removed
# let's just assume that it's read-only and unlink it.
try:
os.chmod(path, stat.S_IWRITE)
os.unlink(path)
except Exception as e:
print(
"There was an error removing a file from disk. Exception: {0}".format(e))
def resetOutput():
print(f"{hhr} Resetting output and comment files...")
with open(commentfile, "w") as comment_file:
comment_file.write("TestRunAborted")
if os.path.exists(outputfile):
try:
os.remove(outputfile)
except OSError as e:
print(e)
def version_gt(branch: str, reference: str):
return version.parse(branch) > version.parse(reference)
def setConfigureOptions():
extraopts = []
lancelotConfigureOpts = defaultLancelotConfigureOpts
if version_gt(branch, "5.8"):
extraopts.extend(["-no-feature-sql", "-no-feature-vnc"])
if version_gt(branch, "5.9"):
extraopts.extend(["-no-feature-xcb-native-painting"])
lancelotConfigureOpts.extend([
"-prefix", f"{os.path.normpath(os.path.join(os.getcwd(), '..', 'Install'))}",
"-release",
"-opensource",
"-confirm-license",
"-nomake", "examples",
"-nomake", "tests",
"-no-widgets",
"-no-feature-concurrent",
"-no-openssl",
])
if isWindowsOS:
print("Running on windows. Forcing '-opengl desktop' configure option")
lancelotConfigureOpts.extend([
"-opengl", "desktop"
])
else:
print("Running on Linux or macOS. Forcing '-no-eglfs' and '-no-linuxfb' configure options")
lancelotConfigureOpts.extend([
"-no-eglfs",
"-no-linuxfb"
])
return lancelotConfigureOpts
def checkResult():
if (os.access(outputfile, os.R_OK)):
with open(outputfile, 'r') as output_file:
content = output_file.readlines()
lastLine = ""
for line in content:
if 'http://' in line and 'fuzzy match' not in line.lower():
lastLine = line.strip()[line.strip().rfind(
"description: \"") + 1:-1]
with open(commentfile, "w") as comment_file:
comment_file.write(lastLine if lastLine else "Okay")
if lastLine:
print(f"Check Result found mismatches.")
return 1 # Some mismatches were found
return 0
def exitTrap():
if (checkResult()):
print("Mismatch detected: ")
with open(commentfile, 'r') as content:
for line in content.readlines():
print(line)
exit(exitStatus)
def applyPatches(module, cherryPickType):
args = ""
print("Applying patches...")
### Temporary Patches ###
if (cherryPickType == "no-commit"):
args = "-n"
skipArgs = (not args)
if (module == "qtbase"):
try: # merge-base gives no output if not ancestor.
subprocess.run(["git", "merge-base", "--is-ancestor", "c23e3f4822", "HEAD"],
stdout=PIPE, universal_newlines=True,
shell=isWindowsOS).stdout.splitlines()[0]
except IndexError:
# 'Add commandline option to lancelot tests for forcing baseline update'
print(
'PATCH: Add commandline option to lancelot tests for forcing baseline update')
subprocess.run(["git", "cherry-pick", "c23e3f4822"] if skipArgs else ["git",
"cherry-pick",
args,
"c23e3f4822"],
universal_newlines=True, shell=isWindowsOS)
# 'WIP: exclude a blending test from qpainter lancelot on macOS core gl'
print('PATCH: Exclude a blending test from qpainter lancelot on macOS core gl')
subprocess.run(["git", "fetch", "https://codereview.qt-project.org/qt/qtbase",
"refs/changes/58/238358/1"], universal_newlines=True, shell=isWindowsOS)
# Fails for old Qt where coregl test did not exist, revert if so
print("PATCH: Fails for old Qt where coregl test did not exist, revert if so")
if(subprocess.run(["git", "cherry-pick", "FETCH_HEAD"] if skipArgs else ["git",
"cherry-pick",
args,
"FETCH_HEAD"],
stdout=PIPE, universal_newlines=True, shell=isWindowsOS).stdout):
subprocess.run(["git", "checkout", "HEAD", "tests/auto/other/lancelot/tst_lancelot.cpp"],
universal_newlines=True, shell=isWindowsOS)
print("Done Applying patches...\n")
def clone(directory, module):
print(f"Cloning module [{module}] into {directory}")
if (not os.path.isdir(f"{directory}/{module}")):
# Set git user and email if it's not set on this machine.
try:
email = subprocess.run(["git", "config", "--global", "--get", "user.email"],
stdout=PIPE, universal_newlines=True,
shell=isWindowsOS).stdout.splitlines()[0]
if (email == "you@example.com" or (gitEmail != email and gitEmail != "you@example.com")):
subprocess.run(["git", "config", "--global", "user.email",
gitEmail], universal_newlines=True, shell=isWindowsOS)
except IndexError:
subprocess.run(["git", "config", "--global", "user.email",
gitEmail], universal_newlines=True, shell=isWindowsOS)
try:
name = subprocess.run(["git", "config", "--global", "--get", "user.name"],
stdout=PIPE, universal_newlines=True,
shell=isWindowsOS).stdout.splitlines()[0]
if (name == "Your Name" or (gitUser != name and gitUser != "Your Name")):
subprocess.run(["git", "config", "--global", "user.name",
gitUser], universal_newlines=True, shell=isWindowsOS)
except IndexError:
subprocess.run(["git", "config", "--global", "user.name",
gitUser], universal_newlines=True, shell=isWindowsOS)
subprocess.run(["git", "clone", f"git://code.qt.io/qt/{module}.git", "--branch",
branch, f"{directory}/{module}"], universal_newlines=True,
shell=isWindowsOS)
else:
print("Path exists. No new clone required.")
def build(directory, module, sha, testType):
print(f"\n{hhr} Building {module} {testType} {hhr}\n")
print(f"Changing directory to {directory}/{module}")
os.chdir(f"{directory}/{module}")
print("Cleaning repo...")
subprocess.run(["git", "clean", "-dqfx"],
universal_newlines=True, shell=isWindowsOS)
print("Fetching changes...")
subprocess.run(["git", "fetch"], universal_newlines=True,
shell=isWindowsOS)
print(f"Resetting repo to SHA: {sha}...")
subprocess.run(["git", "reset", "--hard", sha],
universal_newlines=True, shell=isWindowsOS)
if (testMode == "patchtest" and testType == "test" and repo == module):
print(f"Entering Test Mode: [patchtest: {module}/test]")
applyPatches(module, "commit")
print("Fetching refspecs from gerrit...")
for ref in refSpec:
print(f"Fetching {module}/{ref}")
subprocess.run(
["git", "fetch",
universal_newlines=True, shell=isWindowsOS)
confirmCherryPickSHA = subprocess.run(['git', 'rev-parse', 'FETCH_HEAD'],
stdout=PIPE, stderr=PIPE, shell=False,
universal_newlines=True).stdout
print(f"Cherry picking {confirmCherryPickSHA}")
subprocess.run(["git", "cherry-pick", "FETCH_HEAD"],
universal_newlines=True, shell=isWindowsOS)
else:
print(f"Entering Test Mode: [{testType}: {module}]")
applyPatches(module, "no-commit")
if (module == "qtbase"):
lancelotConfigureOpts = setConfigureOptions()
if isWindowsOS:
configurecmd = ["configure.bat"]
else:
configurecmd = ["./configure"]
if lancelotConfigureOpts:
configurecmd.extend(lancelotConfigureOpts)
print("Now configuring qtbase with", configurecmd)
with open("configure.out", "w") as configure_log:
proc = subprocess.run(configurecmd, stdout=configure_log,
stderr=configure_log, universal_newlines=True, shell=isWindowsOS)
if proc.returncode:
print(f"{hr} ERROR Configuring {module}. Failing build {hr}")
if os.path.exists("config.summary"):
print(f"{hhr} Dumping Configure Summary {hhr}")
with open("config.summary") as configSummary:
print(configSummary.read())
print(f"{hhr} End of Configure Summary {hhr}")
else:
print(f"{hhr} Dumping Configure log tail {hhr}")
with open("configure.out") as configure_log_readback:
print("\n".join(configure_log_readback.readlines()[-20:]))
print(f"{hhr} End of Configure log tail {hhr}")
exit(proc.returncode)
else:
print("Running qmake...")
subprocess.run(
[f"{directory}/Install/bin/qmake{exeExt}"], universal_newlines=True)
with open("build.out", "a") as build_log:
print(f"Running Make for {module}/{testType}...")
proc = subprocess.run([compiler, "-j", buildCores], stdout=build_log,
stderr=build_log, universal_newlines=True, shell=isWindowsOS)
if proc.returncode:
print(f"{hr} ERROR Building {module}. Failing build {hr}")
print(f"{hhr} Dumping Build log tail {hhr}")
with open("build.out") as build_log_readback:
print("\n".join(build_log_readback.readlines()[-20:]))
print(f"{hhr} End of Build log tail {hhr}")
exit(proc.returncode)
print(f"Running Make Install for {module}/{testType}...")
proc = subprocess.run([compiler, "install", "-j", buildCores],
stdout=build_log, stderr=build_log, universal_newlines=True,
shell=isWindowsOS)
if proc.returncode:
print(f"{hr} ERROR Installing {module}. Failing build {hr}")
exit(proc.returncode)
if (isWindowsOS):
print("Cloning WinDeployQt...")
clone(directory, "qttools")
print(f"Changing directory to {directory}/qttools/src/windeployqt")
os.chdir(f"{directory}/qttools/src/windeployqt")
print("\nRunning QMake for WindeployQt...")
subprocess.run([f"{directory}/Install/bin/qmake{exeExt}"],
universal_newlines=True, shell=isWindowsOS)
print("Running Make for WindeployQt...")
proc = subprocess.run([compiler, "-j", buildCores],
universal_newlines=True, shell=isWindowsOS)
if proc.returncode:
print(f"{hr} ERROR Building windeployqt. Failing build {hr}")
exit(proc.returncode)
print("\nRunning Make Install for WindeployQt...")
proc = subprocess.run([compiler, "install", "-j", buildCores],
universal_newlines=True, shell=isWindowsOS)
if proc.returncode:
print(f"{hr} ERROR Installing windeployqt. Failing build {hr}")
exit(proc.returncode)
print("Done building WinDeployQt. Success!")
def getSha(directory, module, shaType):
print(f"Retrieving SHA for {module}/{shaType}")
shafile = ""
sha = "none"
if (shaType == "head"):
subprocess.run(["git", "fetch"], cwd=f'{directory}/{module}',
stdout=PIPE, stderr=PIPE, universal_newlines=True)
sha = subprocess.run(["git", "rev-parse", f"origin/{branch}"], cwd=f"{directory}/{module}",
stdout=PIPE, stderr=PIPE,
universal_newlines=True).stdout.splitlines()[0]
if (module != "qtbase"):
sha = f"{sha}_{getSha(directory, 'qtbase', 'build')}"
else:
shafile = f"{directory}/{module}_{shaType}.sha"
print(f"Pulling SHA from file: '{shafile}'")
if (os.path.isfile(shafile)):
with open(shafile) as sha_file:
try:
sha = sha_file.readlines()[0]
except IndexError:
print(
f"Unexpected error: The shafile at {shafile} seems to be empty.")
return
else:
print(f"SHA file {directory}/{module}_{shaType}.sha not found.")
print(f"SHA for {module}/{shaType}: {sha}")
return sha
def storeSha(directory, module, shaType, sha):
shaFile = f"{directory}/{module}_{shaType}.sha"
with open(shaFile, "w") as sha_file:
sha_file.writelines(sha)
with open(shaFile, "r") as sha_file:
print(
f"Wrote data for {module}/{shaType} '{sha_file.readlines()}' to {shaFile}")
def clearShas(directory):
# print(f"Clearing shas: {', '.join(Path(directory).glob('*.sha'))}")
for f in Path(directory).glob("*.sha"):
try:
f.unlink()
except Exception as e:
print(e)
def updateRefBuild(module):
print(f"{hhr} Starting update to reference build...")
clone(refBaseDir, module)
headSHA = getSha(refBaseDir, module, "head")
buildSHA = getSha(refBaseDir, module, "build")
if (buildSHA == headSHA):
print("Build SHA matches HEAD SHA. No need to update the ref build now.")
return
print(
f"Build and HEAD shas do not match. Rebuilding {module}\n\
Build SHA: {buildSHA}\nHEAD SHA: {headSHA}")
if (module == "qtbase"):
# Rebuilding qtbase invalidates the other builds and baselines
print("Clearing shas since we're updating qtbase...")
clearShas(refBaseDir)
build(refBaseDir, module, headSHA[0: headSHA.find(
'_') if headSHA.find('_') > 0 else len(headSHA)], "ref")
storeSha(refBaseDir, module, "build", headSHA)
def parseResults(file: str) -> ():
testFunctionsXML = []
testNames = []
testFailures = {}
testCount = 0
try:
xmldoc = minidom.parse(file)
testFunctionsXML = xmldoc.getElementsByTagName('TestFunction')
for item in testFunctionsXML:
testFailures[item.attributes['name'].value] = []
testNames.append(item.attributes['name'].value)
incidentsXML = item.getElementsByTagName('Incident')
for incident in incidentsXML:
testCount += 1
if incident.attributes['type'].value == 'fail':
testFailures[item.attributes['name'].value].append(
{
"file": incident.childNodes[1].firstChild.nodeValue,
"description": incident.childNodes[3].firstChild.nodeValue
})
except FileNotFoundError:
print(f"ERROR: No results file found. It's most likely that the test executable failed to complete.\n file tried: {file}")
return (False, False, "File Not Found")
except Exception as e:
print(e)
for name in testNames:
if len(testFailures[name]) == 0:
del testFailures[name]
return (testFailures, testCount, False)
def runTest(testBaseDir, module, testType):
args = []
out = ""
testDir = ""
testApp = ""
testArgs = []
baseSHA = ""
baseCommit = ""
if (module == "qtbase"):
testDir = "tests/auto/other/lancelot"
testApp = "tst_lancelot"
testArgs = []
quickbackends = "default"
elif (module == "qtdeclarative"):
testDir = "tests/manual/scenegraph_lancelot"
testApp = "tst_scenegraph"
testArgs.append("testRendering")
if version_gt(branch, "5.9"):
quickbackends = ["default"]
else:
quickbackends = ["default", "software"]
print(f"\n{hr} Running {testApp} {testType} {hr}\n")
print(f"Changing directory to {testBaseDir}/{module}/{testDir}")
os.chdir(f"{testBaseDir}/{module}/{testDir}")
print("Running qmake...")
subprocess.run(
[f"{testBaseDir}/Install/bin/qmake{exeExt}"], universal_newlines=True)
with open("build.out", "w") as build_log:
print(f"Running Make for {testApp}")
subprocess.run([compiler, "-j", f"{buildCores}"], stdout=build_log,
universal_newlines=True, shell=isWindowsOS)
if isWindowsOS:
if testApp == "tst_lancelot":
# Deploy DLL files to the test with windeployqt
subprocess.run([f"{testBaseDir}/Install/bin/windeployqt.exe", f"{testApp}.exe"],
cwd=f"{testBaseDir}/{module}/{testDir}/release",
universal_newlines=True, shell=isWindowsOS)
elif testApp == "tst_scenegraph":
subprocess.run([f"{testBaseDir}/Install/bin/windeployqt.exe", f"{testApp}.exe"],
cwd=f"{testBaseDir}/{module}/{testDir}",
universal_newlines=True, shell=isWindowsOS)
subprocess.run([f"{testBaseDir}/Install/bin/windeployqt.exe", "qmlscenegrabber.exe"],
cwd=f"{testBaseDir}/{module}/{testDir}",
universal_newlines=True, shell=isWindowsOS)
try:
os.remove("hostinfo.txt")
except Exception:
pass # Error is expected if file doesn't exist yet.
# Hostinfo.txt carries info about this testrun and the client running the
# tests to baselinetest.cpp for use in connecting to the lancelot host.
print(f"Writing hostinfo to {os.getcwd()}/hostinfo.txt")
with open("hostinfo.txt", "w+") as host_info:
if (module == "qtbase"):
baseSHA = getSha(refBaseDir, "qtbase", "build")
baseCommit = subprocess.run(["git", "show", "-s", "--pretty=\"%H [%an] [%ad] %s\"",
baseSHA], stdout=PIPE, stderr=PIPE,
universal_newlines=True).stdout
host_info.writelines([f"QtBaseCommit: {baseCommit}\n"])
if (os.environ.get("LANCELOT_PROJECT")):
host_info.writelines(
[f"Project: {os.environ.get('LANCELOT_PROJECT')}\n"])
host_info.writelines([
f"GitBranch: {branch}\n",
f"BUILD_TAG: {os.environ.get('BUILD_TAG')}\n",
f"BUILD_URL: {os.environ.get('BUILD_URL')}\n"
])
if (testMode == "patchtest"):
host_info.writelines([
f"GERRIT_PROJECT: {gerritProject}\n",
f"GERRIT_CHANGE_URL: {os.environ.get('GERRIT_CHANGE_URL')}\n",
f"GERRIT_CHANGE_SUBJECT: {subject}\n",
f"GERRIT_PATCHSET_NUMBER: {os.environ.get('GERRIT_PATCHSET_NUMBER')}\n",
f"GERRIT_REFSPEC: {refSpec}\n"
])
out = outputfile
if (testMode == "patchtest"):
if (testType == "ref"):
print(f"{hhr} Setting test app output to devnull and uploading \
new baselines to Lancelot.")
args.append("-setbaselines")
out = os.devnull
else:
print(f"{hhr} Active Test run. Not setting any baselines.")
args.append("-nosetbaselines")
if (os.environ.get("LANCELOT_FAKE_MISMATCH")):
print(f"{hhr} Forced fake mismatch run. Tests will always mismatch!")
args.append("-simfail")
for backend in quickbackends:
with open("hostinfo.txt", "a") as host_info:
host_info.writelines([f"QT_QUICK_BACKEND: {backend}\n"])
if (backend == "default"):
try:
del os.environ["QT_QUICK_BACKENDS"]
except KeyError:
pass
else:
os.environ["QT_QUICK_BACKENDS"] = backend
commandString = [f"{testBaseDir}/{module}/{testDir}/\
{'release' if isWindowsOS and testApp == 'tst_lancelot' else ''}/{testApp}{exeExt}",
"-o", "results.xml,xml"]
if args:
commandString.extend(args)
if testArgs:
commandString.extend(testArgs)
print(
f"About to run test {commandString} with QT_QUICK_BACKEND: {backend}")
with open("hostinfo.txt", 'r') as host_info:
print(
f"\nHost information to be sent to Lancelot server:\n{hr}\n\
{''.join(host_info.readlines())}{hr}\n")
with open(out, "w", newline='\n') as output_file:
subprocess.run(
commandString, universal_newlines=True, shell=False)
print("Parsing results.xml...")
resultsData, testCount, error = parseResults(
f"{testBaseDir}/{module}/{testDir}/results.xml")
if error:
break
elif not testCount:
print("ERROR: Test executable ran, but no test cases were executed!")
break
formattedResults = json.dumps(resultsData, indent=2)
output_file.write(
formattedResults if resultsData else "ALL PASS")
print(f"{testCount} total test cases run.")
print(f"Results:\n{formattedResults if resultsData else 'ALL PASS'}")
print(f"Dumping results to {out}\n")
if (testType != "ref" and checkResult()): # ignore mismatches if we're doing ref
print("Found mismatches on a real test run. Aborting...")
break
def updateBaselines(module):
print(f"\n{hhr} Updating baselines for {module}")
buildSHA = ""
blSHA = ""
updateRefBuild(module)
buildSHA = getSha(refBaseDir, module, "build")
blSHA = getSha(refBaseDir, module, "baselines")
print(f"Build SHA:{buildSHA}\nBaseline SHA: {blSHA}")
if (blSHA == buildSHA):
print("baseline and Build SHAs match. No need to update baselines.")
return
print(
f"Baseline and Build shas do not match. Updating baselines with new build.")
runTest(refBaseDir, module, "ref")
storeSha(refBaseDir, module, "baselines", buildSHA)
def updateQtBase(directory, repo):
blSHA = ""
blBaseSHA = ""
buildSHA = ""
blSHA = getSha(refBaseDir, "qtbase", "baselines")
blBaseSHA = blSHA[0: blSHA.find(
'_') if blSHA.find('_') > 0 else len(blSHA)]
buildSHA = getSha(directory, "qtbase", "build")
if (blBaseSHA == buildSHA):
return # No need to build since there's no change.
clone(directory, "qtbase")
build(directory, "qtbase", blBaseSHA, "ref")
storeSha(directory, "qtbase", "build", blBaseSHA)
def testRepo(workdir, module):
print(f"Starting test process for {module}...")
sha = ""
clone(workdir, module)
sha = getSha(refBaseDir, module, "baselines")
build(workdir, module, sha[0: sha.find('_')
if sha.find('_') > 0 else len(sha)], "test")
runTest(workdir, module, "test")
# Don't bother continuing if we already have identified trouble
if (checkResult()):
exit(exitStatus)
def doPatchTest():
print(f"{hr} Performing Patch test...")
workdir = ""
updateBaselines("qtbase")
updateBaselines("qtdeclarative")
print(f"{hhr} Finished updating baselines...")
# Commit modifies qtbase. Test both qtbase and qtdeclarative rendering.
if (repo == "qtbase"):
print(f"{hhr} Starting full test")
workdir = baseDir + "/fulltest"
testRepo(workdir, "qtbase")
resetOutput()
testRepo(workdir, "qtdeclarative")
else:
# Only test modified repo
print(f"{hhr} Starting qtdeclarative repo test...")
workdir = baseDir + "/repotest"
updateQtBase(workdir, repo)
testRepo(workdir, repo)
print(f"{hhr} Finished Patch Testing...")
def doHeadTest():
print(f"{hr} Performing HEAD test...")
global exitStatus
updateBaselines("qtbase")
exitStatus += checkResult()
resetOutput()
updateBaselines("qtdeclarative")
exitStatus += checkResult()
if (not exitStatus): # Write Okay as comment if exitStatus is still 0.
print(f"{hr} PASS: Head test completed with no errors or mismatches {hr}")
with open(commentfile, "w") as comment_file:
comment_file.write("Okay")
if __name__ == "__main__":
resetOutput() # Reset our output and comment files, just in case.
atexit.register(exitTrap) # Set the exit trap
if isWindowsOS:
setWindowsEnv()
if (testMode == "patchtest"):
print(f"{hhr}\n{gerritOwner}: {subject}\n{hhr}")
if (eventType != "manualtrigger"):
if (subject):
# exit if the gerrit change is a WIP, DOC, or merge request.
r = re.compile('(^doc\\b|^wip\\b|^merge\\b)')
if r.search(subject.lower()):
print("WIP/Doc/Merge commit. Ignoring.")
exit(0)
if gerritUploaderEmail == "qt_ci_bot@qt-project.org":
print(f"{hhr} CI-Generated patchset, ignoring.")
exit(0)
if (repo != "qtbase" and repo != "qtdeclarative"):
print(f"Error. Unknown Repo: {repo}")
exit(0)
if (not refSpec):
print("In Patch mode, but no refspec given. Exiting.")
exit(0)
if (not branch):
print("Error: No branch specifified. This is required. Exiting.")
exit(0)
if(rebuildAll):
# Test to make sure the targets exist so we don't delete something unintentional.
if (branch and os.path.isdir(workspace) and os.path.isdir(baseDir)):
shutil.rmtree(baseDir, onerror=on_rm_error)
if not os.path.exists(baseDir):
os.makedirs(baseDir)
if not os.path.exists(refBaseDir):
os.makedirs(refBaseDir)
if (testMode == "patchtest"):
doPatchTest()
else:
doHeadTest()