def startWebServer(self, options):
""" Create the webserver on the host and start it up """
remoteXrePath = options.xrePath
remoteProfilePath = options.profilePath
remoteUtilityPath = options.utilityPath
localAutomation = Automation()
localAutomation.IS_WIN32 = False
localAutomation.IS_LINUX = False
localAutomation.IS_MAC = False
localAutomation.UNIXISH = False
hostos = sys.platform
if hostos in ['mac', 'darwin']:
localAutomation.IS_MAC = True
elif hostos in ['linux', 'linux2']:
localAutomation.IS_LINUX = True
localAutomation.UNIXISH = True
elif hostos in ['win32', 'win64']:
localAutomation.BIN_SUFFIX = ".exe"
localAutomation.IS_WIN32 = True
paths = [options.xrePath,
localAutomation.DIST_BIN,
self._automation._product,
os.path.join('..', self._automation._product)]
options.xrePath = self.findPath(paths)
if options.xrePath == None:
print "ERROR: unable to find xulrunner path for %s, please specify with --xre-path" % (os.name)
sys.exit(1)
paths.append("bin")
paths.append(os.path.join("..", "bin"))
xpcshell = "xpcshell"
if (os.name == "nt"):
xpcshell += ".exe"
if (options.utilityPath):
paths.insert(0, options.utilityPath)
options.utilityPath = self.findPath(paths, xpcshell)
if options.utilityPath == None:
print "ERROR: unable to find utility path for %s, please specify with --utility-path" % (os.name)
sys.exit(1)
# httpd-path is specified by standard makefile targets and may be specified
# on the command line to select a particular version of httpd.js. If not
# specified, try to select the one from xre.zip, as required in bug 882932.
if not options.httpdPath:
options.httpdPath = os.path.join(options.utilityPath, "components")
options.profilePath = tempfile.mkdtemp()
self.server = MochitestServer(localAutomation, options)
self.server.start()
if (options.pidFile != ""):
f = open(options.pidFile + ".xpcshell.pid", 'w')
f.write("%s" % self.server._process.pid)
f.close()
self.server.ensureReady(self.SERVER_STARTUP_TIMEOUT)
options.xrePath = remoteXrePath
options.utilityPath = remoteUtilityPath
options.profilePath = remoteProfilePath
def __init__(self, deviceManager, appName = ''):
self._devicemanager = deviceManager
self._appName = appName
self._remoteProfile = None
# Default our product to fennec
self._product = "fennec"
Automation.__init__(self)
def main():
automation = Automation()
parser = OptionParser()
reftest = RefTest(automation)
# we want to pass down everything from automation.__all__
addCommonOptions(parser,
defaults=dict(zip(automation.__all__,
[getattr(automation, x) for x in automation.__all__])))
automation.addCommonOptions(parser)
parser.add_option("--appname",
action = "store", type = "string", dest = "app",
default = os.path.join(SCRIPT_DIRECTORY, automation.DEFAULT_APP),
help = "absolute path to application, overriding default")
parser.add_option("--extra-profile-file",
action = "append", dest = "extraProfileFiles",
default = [],
help = "copy specified files/dirs to testing profile")
parser.add_option("--timeout",
action = "store", dest = "timeout", type = "int",
default = 5 * 60, # 5 minutes per bug 479518
help = "reftest will timeout in specified number of seconds. [default %default s].")
parser.add_option("--leak-threshold",
action = "store", type = "int", dest = "leakThreshold",
default = 0,
help = "fail if the number of bytes leaked through "
"refcounted objects (or bytes in classes with "
"MOZ_COUNT_CTOR and MOZ_COUNT_DTOR) is greater "
"than the given number")
parser.add_option("--utility-path",
action = "store", type = "string", dest = "utilityPath",
default = automation.DIST_BIN,
help = "absolute path to directory containing utility "
"programs (xpcshell, ssltunnel, certutil)")
options, args = parser.parse_args()
if len(args) != 1:
print >>sys.stderr, "No reftest.list specified."
sys.exit(1)
options.app = reftest.getFullPath(options.app)
if not os.path.exists(options.app):
print """Error: Path %(app)s doesn't exist.
Are you executing $objdir/_tests/reftest/runreftest.py?""" \
% {"app": options.app}
sys.exit(1)
if options.xrePath is None:
options.xrePath = os.path.dirname(options.app)
else:
# allow relative paths
options.xrePath = reftest.getFullPath(options.xrePath)
if options.symbolsPath:
options.symbolsPath = reftest.getFullPath(options.symbolsPath)
options.utilityPath = reftest.getFullPath(options.utilityPath)
sys.exit(reftest.runTests(args[0], options))
def __init__(self, device, appName='', remoteProfile=None, remoteLog=None,
processArgs=None):
self.device = device
self.appName = appName
self.remoteProfile = remoteProfile
self.remoteLog = remoteLog
self.processArgs = processArgs or {}
self.lastTestSeen = "remoteautomation.py"
Automation.__init__(self)
def startWebServer(self, options):
""" Create the webserver on the host and start it up """
remoteXrePath = options.xrePath
remoteProfilePath = options.profilePath
remoteUtilityPath = options.utilityPath
localAutomation = Automation()
localAutomation.IS_WIN32 = False
localAutomation.IS_LINUX = False
localAutomation.IS_MAC = False
localAutomation.UNIXISH = False
hostos = sys.platform
if hostos in ["mac", "darwin"]:
localAutomation.IS_MAC = True
elif hostos in ["linux", "linux2"]:
localAutomation.IS_LINUX = True
localAutomation.UNIXISH = True
elif hostos in ["win32", "win64"]:
localAutomation.BIN_SUFFIX = ".exe"
localAutomation.IS_WIN32 = True
paths = [
options.xrePath,
localAutomation.DIST_BIN,
self._automation._product,
os.path.join("..", self._automation._product),
]
options.xrePath = self.findPath(paths)
if options.xrePath == None:
print "ERROR: unable to find xulrunner path for %s, please specify with --xre-path" % (os.name)
sys.exit(1)
paths.append("bin")
paths.append(os.path.join("..", "bin"))
xpcshell = "xpcshell"
if os.name == "nt":
xpcshell += ".exe"
if options.utilityPath:
paths.insert(0, options.utilityPath)
options.utilityPath = self.findPath(paths, xpcshell)
if options.utilityPath == None:
print "ERROR: unable to find utility path for %s, please specify with --utility-path" % (os.name)
sys.exit(1)
options.profilePath = tempfile.mkdtemp()
self.server = MochitestServer(localAutomation, options)
self.server.start()
if options.pidFile != "":
f = open(options.pidFile + ".xpcshell.pid", "w")
f.write("%s" % self.server._process.pid)
f.close()
self.server.ensureReady(self.SERVER_STARTUP_TIMEOUT)
options.xrePath = remoteXrePath
options.utilityPath = remoteUtilityPath
options.profilePath = remoteProfilePath
def __init__(self, deviceManager, appName = '', remoteLog = None):
self._devicemanager = deviceManager
self._appName = appName
self._remoteProfile = None
self._remoteLog = remoteLog
# Default our product to fennec
self._product = "fennec"
self.lastTestSeen = "remoteautomation.py"
Automation.__init__(self)
def startWebServer(self, options):
""" Create the webserver on the host and start it up """
remoteXrePath = options.xrePath
remoteUtilityPath = options.utilityPath
localAutomation = Automation()
localAutomation.IS_WIN32 = False
localAutomation.IS_LINUX = False
localAutomation.IS_MAC = False
localAutomation.UNIXISH = False
hostos = sys.platform
if hostos == "mac" or hostos == "darwin":
localAutomation.IS_MAC = True
elif hostos == "linux" or hostos == "linux2":
localAutomation.IS_LINUX = True
localAutomation.UNIXISH = True
elif hostos == "win32" or hostos == "win64":
localAutomation.BIN_SUFFIX = ".exe"
localAutomation.IS_WIN32 = True
paths = [
options.xrePath,
localAutomation.DIST_BIN,
self.automation._product,
os.path.join("..", self.automation._product),
]
options.xrePath = self.findPath(paths)
if options.xrePath == None:
print "ERROR: unable to find xulrunner path for %s, please specify with --xre-path" % (os.name)
return 1
paths.append("bin")
paths.append(os.path.join("..", "bin"))
xpcshell = "xpcshell"
if os.name == "nt":
xpcshell += ".exe"
if options.utilityPath:
paths.insert(0, options.utilityPath)
options.utilityPath = self.findPath(paths, xpcshell)
if options.utilityPath == None:
print "ERROR: unable to find utility path for %s, please specify with --utility-path" % (os.name)
return 1
options.serverProfilePath = tempfile.mkdtemp()
self.server = ReftestServer(localAutomation, options, self.scriptDir)
retVal = self.server.start()
if retVal:
return retVal
retVal = self.server.ensureReady(self.SERVER_STARTUP_TIMEOUT)
if retVal:
return retVal
options.xrePath = remoteXrePath
options.utilityPath = remoteUtilityPath
return 0
def __init__(self, deviceManager, appName='', remoteLog=None,
marionette=None):
self._devicemanager = deviceManager
self._appName = appName
self._remoteProfile = None
self._remoteLog = remoteLog
self.marionette = marionette
# Default our product to b2g
self._product = "b2g"
Automation.__init__(self)
def __init__(self, deviceManager, appName='', remoteLog=None,
marionette=None, context_chrome=True):
self._devicemanager = deviceManager
self._appName = appName
self._remoteProfile = None
self._remoteLog = remoteLog
self.marionette = marionette
self.context_chrome = context_chrome
self._is_emulator = False
# Default our product to b2g
self._product = "b2g"
# Default log finish to mochitest standard
self.logFinish = 'INFO SimpleTest FINISHED'
Automation.__init__(self)
def makeLocalAutomation(self):
localAutomation = Automation()
localAutomation.IS_WIN32 = False
localAutomation.IS_LINUX = False
localAutomation.IS_MAC = False
localAutomation.UNIXISH = False
hostos = sys.platform
if (hostos == 'mac' or hostos == 'darwin'):
localAutomation.IS_MAC = True
elif (hostos == 'linux' or hostos == 'linux2'):
localAutomation.IS_LINUX = True
localAutomation.UNIXISH = True
elif (hostos == 'win32' or hostos == 'win64'):
localAutomation.BIN_SUFFIX = ".exe"
localAutomation.IS_WIN32 = True
return localAutomation
def checkForCrashes(self, directory, symbolsPath):
self.checkForANRs()
logcat = self._devicemanager.getLogcat(filterOutRegexps=fennecLogcatFilters)
javaException = mozcrash.check_for_java_exception(logcat)
if javaException:
return True
# If crash reporting is disabled (MOZ_CRASHREPORTER!=1), we can't say
# anything.
if not self.CRASHREPORTER:
return False
try:
dumpDir = tempfile.mkdtemp()
remoteCrashDir = self._remoteProfile + '/minidumps/'
if not self._devicemanager.dirExists(remoteCrashDir):
# If crash reporting is enabled (MOZ_CRASHREPORTER=1), the
# minidumps directory is automatically created when Fennec
# (first) starts, so its lack of presence is a hint that
# something went wrong.
print "Automation Error: No crash directory (%s) found on remote device" % remoteCrashDir
# Whilst no crash was found, the run should still display as a failure
return True
self._devicemanager.getDirectory(remoteCrashDir, dumpDir)
crashed = Automation.checkForCrashes(self, dumpDir, symbolsPath)
finally:
try:
shutil.rmtree(dumpDir)
except:
print "WARNING: unable to remove directory: %s" % dumpDir
return crashed
def makeLocalAutomation(self):
localAutomation = Automation()
localAutomation.IS_WIN32 = False
localAutomation.IS_LINUX = False
localAutomation.IS_MAC = False
localAutomation.UNIXISH = False
hostos = sys.platform
if hostos == "mac" or hostos == "darwin":
localAutomation.IS_MAC = True
elif hostos == "linux" or hostos == "linux2":
localAutomation.IS_LINUX = True
localAutomation.UNIXISH = True
elif hostos == "win32" or hostos == "win64":
localAutomation.BIN_SUFFIX = ".exe"
localAutomation.IS_WIN32 = True
return localAutomation
def startWebServer(self, options):
""" Create the webserver on the host and start it up """
remoteXrePath = options.xrePath
remoteProfilePath = options.profilePath
remoteUtilityPath = options.utilityPath
localAutomation = Automation()
localAutomation.IS_WIN32 = False
localAutomation.IS_LINUX = False
localAutomation.IS_MAC = False
localAutomation.UNIXISH = False
hostos = sys.platform
if (hostos == 'mac' or hostos == 'darwin'):
localAutomation.IS_MAC = True
elif (hostos == 'linux' or hostos == 'linux2'):
localAutomation.IS_LINUX = True
localAutomation.UNIXISH = True
elif (hostos == 'win32' or hostos == 'win64'):
localAutomation.BIN_SUFFIX = ".exe"
localAutomation.IS_WIN32 = True
paths = [options.xrePath, localAutomation.DIST_BIN, self._automation._product, os.path.join('..', self._automation._product)]
options.xrePath = self.findPath(paths)
if options.xrePath == None:
print "ERROR: unable to find xulrunner path for %s, please specify with --xre-path" % (os.name)
sys.exit(1)
paths.append("bin")
paths.append(os.path.join("..", "bin"))
xpcshell = "xpcshell"
if (os.name == "nt"):
xpcshell += ".exe"
if (options.utilityPath):
paths.insert(0, options.utilityPath)
options.utilityPath = self.findPath(paths, xpcshell)
if options.utilityPath == None:
print "ERROR: unable to find utility path for %s, please specify with --utility-path" % (os.name)
sys.exit(1)
options.profilePath = tempfile.mkdtemp()
self.server = MochitestServer(localAutomation, options)
self.server.start()
self.server.ensureReady(self.SERVER_STARTUP_TIMEOUT)
options.xrePath = remoteXrePath
options.utilityPath = remoteUtilityPath
options.profilePath = remoteProfilePath
def buildCommandLine(self, app, debuggerInfo, profileDir, testURL, extraArgs):
# if remote profile is specified, use that instead
if (self._remoteProfile):
profileDir = self._remoteProfile
cmd, args = Automation.buildCommandLine(self, app, debuggerInfo, profileDir, testURL, extraArgs)
return app, args
def __init__(self, deviceManager, appName='', remoteLog=None,
marionette=None):
self._devicemanager = deviceManager
self._appName = appName
self._remoteProfile = None
self._remoteLog = remoteLog
self.marionette = marionette
self._is_emulator = False
self.test_script = None
self.test_script_args = None
# Default our product to b2g
self._product = "b2g"
self.lastTestSeen = "b2gautomation.py"
# Default log finish to mochitest standard
self.logFinish = 'INFO SimpleTest FINISHED'
Automation.__init__(self)
def main():
automation = Automation()
mochitest = Mochitest(automation)
parser = MochitestOptions(automation, mochitest.SCRIPT_DIRECTORY)
options, args = parser.parse_args()
options = parser.verifyOptions(options, mochitest)
if options == None:
sys.exit(1)
options.utilityPath = mochitest.getFullPath(options.utilityPath)
options.certPath = mochitest.getFullPath(options.certPath)
if options.symbolsPath and not isURL(options.symbolsPath):
options.symbolsPath = mochitest.getFullPath(options.symbolsPath)
automation.setServerInfo(options.webServer, options.httpPort, options.sslPort, options.webSocketPort)
sys.exit(mochitest.runTests(options))
def initializeProfile(self, profileDir, extraPrefs=[],
useServerLocations=False,
initialProfile=None):
# add b2g specific prefs
extraPrefs.extend(["browser.manifestURL='dummy (bug 772307)'"])
return Automation.initializeProfile(self, profileDir,
extraPrefs,
useServerLocations,
initialProfile)
def buildCommandLine(self, app, debuggerInfo, profileDir, testURL,
extraArgs):
# if remote profile is specified, use that instead
if (self._remoteProfile):
profileDir = self._remoteProfile
cmd, args = Automation.buildCommandLine(self, app, debuggerInfo,
profileDir, testURL, extraArgs)
return app, args
def __init__(self,
deviceManager,
appName='',
remoteLog=None,
marionette=None):
self._devicemanager = deviceManager
self._appName = appName
self._remoteProfile = None
self._remoteLog = remoteLog
self.marionette = marionette
self._is_emulator = False
self.test_script = None
self.test_script_args = None
# Default our product to b2g
self._product = "b2g"
self.lastTestSeen = "b2gautomation.py"
# Default log finish to mochitest standard
self.logFinish = 'INFO SimpleTest FINISHED'
Automation.__init__(self)
def __init__(self, automation=None):
super(Mochitest, self).__init__()
self.automation = automation or Automation()
# Max time in seconds to wait for server startup before tests will fail -- if
# this seems big, it's mostly for debug machines where cold startup
# (particularly after a build) takes forever.
if self.automation.IS_DEBUG_BUILD:
self.SERVER_STARTUP_TIMEOUT = 180
else:
self.SERVER_STARTUP_TIMEOUT = 90
def main():
automation = Automation()
mochitest = Mochitest(automation)
parser = MochitestOptions(automation, mochitest.SCRIPT_DIRECTORY)
options, args = parser.parse_args()
options = parser.verifyOptions(options, mochitest)
if options == None:
sys.exit(1)
options.utilityPath = mochitest.getFullPath(options.utilityPath)
options.certPath = mochitest.getFullPath(options.certPath)
if options.symbolsPath and not isURL(options.symbolsPath):
options.symbolsPath = mochitest.getFullPath(options.symbolsPath)
automation.setServerInfo(options.webServer,
options.httpPort,
options.sslPort,
options.webSocketPort)
sys.exit(mochitest.runTests(options))
def __init__(self, automation, **kwargs):
self._automation = automation or Automation()
MochitestOptions.__init__(self)
for option in self.remote_options:
self.add_argument(*option[0], **option[1])
defaults = {}
defaults["logFile"] = "mochitest.log"
defaults["autorun"] = True
defaults["closeWhenDone"] = True
defaults["utilityPath"] = None
self.set_defaults(**defaults)
def checkForCrashes(self, directory, symbolsPath):
self.checkForANRs()
self.checkForTombstones()
try:
logcat = self._devicemanager.getLogcat(
filterOutRegexps=fennecLogcatFilters)
except DMError:
print "getLogcat threw DMError; re-trying just once..."
time.sleep(1)
logcat = self._devicemanager.getLogcat(
filterOutRegexps=fennecLogcatFilters)
javaException = mozcrash.check_for_java_exception(logcat)
if javaException:
return True
# If crash reporting is disabled (MOZ_CRASHREPORTER!=1), we can't say
# anything.
if not self.CRASHREPORTER:
return False
try:
dumpDir = tempfile.mkdtemp()
remoteCrashDir = self._remoteProfile + '/minidumps/'
if not self._devicemanager.dirExists(remoteCrashDir):
# If crash reporting is enabled (MOZ_CRASHREPORTER=1), the
# minidumps directory is automatically created when Fennec
# (first) starts, so its lack of presence is a hint that
# something went wrong.
print "Automation Error: No crash directory (%s) found on remote device" % remoteCrashDir
# Whilst no crash was found, the run should still display as a failure
return True
self._devicemanager.getDirectory(remoteCrashDir, dumpDir)
logger = get_default_logger()
if logger is not None:
crashed = mozcrash.log_crashes(logger,
dumpDir,
symbolsPath,
test=self.lastTestSeen)
else:
crashed = Automation.checkForCrashes(self, dumpDir,
symbolsPath)
finally:
try:
shutil.rmtree(dumpDir)
except:
print "WARNING: unable to remove directory: %s" % dumpDir
return crashed
def __init__(self, parent=None):
super(MainDialog, self).__init__(parent)
tabWidget = QtGui.QTabWidget(self)
system_tab = SysOption()
self.automation_tab = Automation()
tabWidget.addTab(self.automation_tab, self.tr("自动化下单"))
tabWidget.addTab(system_tab, self.tr('系统设置'))
# 网格布局
self.mainLayout = QtGui.QGridLayout(self)
self.mainLayout.addWidget(tabWidget)
# 设置标题
self.setWindowTitle(u'吾宁当当自动下单')
# 设置500左右避免某些低分辨率电脑界面超出屏幕范围
self.resize(1000, 500)
def __init__(self, automation=None, **kwargs):
self._automation = automation or Automation()
optparse.OptionParser.__init__(self, **kwargs)
defaults = {}
# we want to pass down everything from self._automation.__all__
addCommonOptions(self, defaults=dict(zip(self._automation.__all__,
[getattr(self._automation, x) for x in self._automation.__all__])))
for option in self.mochitest_options:
self.add_option(*option[0], **option[1])
self.set_defaults(**defaults)
self.set_usage(self.__doc__)
def buildCommandLine(self, app, debuggerInfo, profileDir, testURL, extraArgs):
# If remote profile is specified, use that instead
if (self._remoteProfile):
profileDir = self._remoteProfile
cmd, args = Automation.buildCommandLine(self, app, debuggerInfo, profileDir, testURL, extraArgs)
# Remove -foreground if it exists, if it doesn't this just returns
try:
args.remove('-foreground')
except:
pass
#TODO: figure out which platform require NO_EM_RESTART
# return app, ['--environ:NO_EM_RESTART=1'] + args
return app, args
def runVMCommand(self, command, expectedErrors=[], silent=False):
""" runs a command in the VM using the vmrun.exe helper """
commandString = ""
for part in command:
commandString += str(part) + " "
if not silent:
self.automation.log.info(
"INFO | runtests.py | Running command: %s" % commandString)
commonErrors = [
"Error: Invalid user name or password for the guest OS",
"Unable to connect to host."
]
expectedErrors.extend(commonErrors)
# VMware can't run commands until the VM has fully loaded so keep running
# this command in a loop until it succeeds or we try 100 times.
errorString = ""
for i in range(100):
process = Automation.Process(command, stdout=PIPE)
result = process.wait()
if result == 0:
break
for line in process.stdout.readlines():
line = line.strip()
if not line:
continue
errorString = line
break
expected = False
for error in expectedErrors:
if errorString.startswith(error):
expected = True
if not expected:
self.automation.log.warning(
"WARNING | runtests.py | Command \"%s\" "
"failed with result %d, : %s" %
(commandString, result, errorString))
break
if not silent:
self.automation.log.info(
"INFO | runtests.py | Running command again.")
return (result, process.stdout.readlines())
def buildCommandLine(self, app, debuggerInfo, profileDir, testURL, extraArgs):
# If remote profile is specified, use that instead
if self._remoteProfile:
profileDir = self._remoteProfile
# Hack for robocop, if app is "am" and extraArgs contains the rest of the stuff, lets
# assume extraArgs is all we need
if app == "am" and extraArgs[0] in ('instrument', 'start'):
return app, extraArgs
cmd, args = Automation.buildCommandLine(
self, app, debuggerInfo, profileDir, testURL, extraArgs)
try:
args.remove('-foreground')
except Exception:
pass
return app, args
def test_login(self):
# test login with improper credentials
a = Automation(username='', password='')
res1 = a.handle_login()
assert not res1
print(res1)
# test login with proper credentials
a = Automation(username='******', password='******')
res2 = a.handle_login()
assert res2
print(res2)
def __init__(self, automation, mochitest, **kwargs):
defaults = {}
self._automation = automation or Automation()
MochitestOptions.__init__(self, mochitest.SCRIPT_DIRECTORY)
def checkPathCallback(option, opt_str, value, parser):
path = mochitest.getFullPath(value)
if not os.path.exists(path):
raise OptionValueError("Path %s does not exist for %s option" %
(path, opt_str))
setattr(parser.values, option.dest, path)
self.add_option(
"--with-vmware-vm",
action="callback",
type="string",
dest="vmx",
callback=checkPathCallback,
help="launches the given VM and runs mochitests inside")
defaults["vmx"] = None
self.add_option(
"--with-vmrun-executable",
action="callback",
type="string",
dest="vmrun",
callback=checkPathCallback,
help="specifies the vmrun.exe to use for VMware control")
defaults["vmrun"] = None
self.add_option("--shutdown-vm-when-done",
action="store_true",
dest="shutdownVM",
help="shuts down the VM when mochitests complete")
defaults["shutdownVM"] = False
self.add_option("--repeat-until-failure",
action="store_true",
dest="repeatUntilFailure",
help="Runs tests continuously until failure")
defaults["repeatUntilFailure"] = False
self.set_defaults(**defaults)
def buildCommandLine(self, app, debuggerInfo, profileDir, testURL, extraArgs):
# If remote profile is specified, use that instead
if (self._remoteProfile):
profileDir = self._remoteProfile
# Hack for robocop, if app & testURL == None and extraArgs contains the rest of the stuff, lets
# assume extraArgs is all we need
if app == "am" and extraArgs[0] in RemoteAutomation._specialAmCommands:
return app, extraArgs
cmd, args = Automation.buildCommandLine(self, app, debuggerInfo, profileDir, testURL, extraArgs)
# Remove -foreground if it exists, if it doesn't this just returns
try:
args.remove('-foreground')
except:
pass
#TODO: figure out which platform require NO_EM_RESTART
# return app, ['--environ:NO_EM_RESTART=1'] + args
return app, args
def buildCommandLine(self, app, debuggerInfo, profileDir, testURL, extraArgs):
# If remote profile is specified, use that instead
if (self._remoteProfile):
profileDir = self._remoteProfile
# Hack for robocop, if app & testURL == None and extraArgs contains the rest of the stuff, lets
# assume extraArgs is all we need
if app == "am" and extraArgs[0] == "instrument":
return app, extraArgs
cmd, args = Automation.buildCommandLine(self, app, debuggerInfo, profileDir, testURL, extraArgs)
# Remove -foreground if it exists, if it doesn't this just returns
try:
args.remove('-foreground')
except:
pass
#TODO: figure out which platform require NO_EM_RESTART
# return app, ['--environ:NO_EM_RESTART=1'] + args
return app, args
def main():
automation = Automation()
parser = ReftestOptions(automation)
reftest = RefTest(automation)
options, args = parser.parse_args()
if len(args) != 1:
print >> sys.stderr, "No reftest.list specified."
sys.exit(1)
options.app = reftest.getFullPath(options.app)
if not os.path.exists(options.app):
print """Error: Path %(app)s doesn't exist.
Are you executing $objdir/_tests/reftest/runreftest.py?""" \
% {"app": options.app}
sys.exit(1)
if options.xrePath is None:
options.xrePath = os.path.dirname(options.app)
else:
# allow relative paths
options.xrePath = reftest.getFullPath(options.xrePath)
if options.symbolsPath and not isURL(options.symbolsPath):
options.symbolsPath = reftest.getFullPath(options.symbolsPath)
options.utilityPath = reftest.getFullPath(options.utilityPath)
if options.totalChunks is not None and options.thisChunk is None:
print "thisChunk must be specified when totalChunks is specified"
sys.exit(1)
if options.totalChunks:
if not 1 <= options.thisChunk <= options.totalChunks:
print "thisChunk must be between 1 and totalChunks"
sys.exit(1)
if options.logFile:
options.logFile = reftest.getFullPath(options.logFile)
sys.exit(reftest.runTests(args[0], options))
def __init__(self, automation, options):
if isinstance(options, optparse.Values):
options = vars(options)
self._automation = automation or Automation()
self._closeWhenDone = options['closeWhenDone']
self._utilityPath = options['utilityPath']
self._xrePath = options['xrePath']
self._profileDir = options['profilePath']
self.webServer = options['webServer']
self.httpPort = options['httpPort']
self.shutdownURL = "http://%(server)s:%(port)s/server/shutdown" % {
"server": self.webServer,
"port": self.httpPort
}
self.testPrefix = "'webapprt_'" if options.get(
'webapprtContent') else "undefined"
if options.get('httpdPath'):
self._httpdPath = options['httpdPath']
else:
self._httpdPath = '.'
self._httpdPath = os.path.abspath(self._httpdPath)
def startWebServer(self, options):
""" Create the webserver on the host and start it up """
remoteXrePath = options.xrePath
remoteUtilityPath = options.utilityPath
localAutomation = Automation()
paths = [
options.xrePath, localAutomation.DIST_BIN,
self.automation._product,
os.path.join('..', self.automation._product)
]
options.xrePath = self.findPath(paths)
if options.xrePath == None:
print "ERROR: unable to find xulrunner path for %s, please specify with --xre-path" % (
os.name)
sys.exit(1)
paths.append("bin")
paths.append(os.path.join("..", "bin"))
xpcshell = "xpcshell"
if (os.name == "nt"):
xpcshell += ".exe"
if (options.utilityPath):
paths.insert(0, options.utilityPath)
options.utilityPath = self.findPath(paths, xpcshell)
if options.utilityPath == None:
print "ERROR: unable to find utility path for %s, please specify with --utility-path" % (
os.name)
sys.exit(1)
options.serverProfilePath = tempfile.mkdtemp()
self.server = ReftestServer(localAutomation, options)
self.server.start()
self.server.ensureReady(self.SERVER_STARTUP_TIMEOUT)
options.xrePath = remoteXrePath
options.utilityPath = remoteUtilityPath
def checkForCrashes(self, directory, symbolsPath):
logcat = self._devicemanager.getLogcat(filterOutRegexps=fennecLogcatFilters)
javaException = self.checkForJavaException(logcat)
if javaException:
return True
try:
dumpDir = tempfile.mkdtemp()
remoteCrashDir = self._remoteProfile + '/minidumps/'
if not self._devicemanager.dirExists(remoteCrashDir):
# As of this writing, the minidumps directory is automatically
# created when fennec (first) starts, so its lack of presence
# is a hint that something went wrong.
print "Automation Error: No crash directory (%s) found on remote device" % remoteCrashDir
# Whilst no crash was found, the run should still display as a failure
return True
self._devicemanager.getDirectory(remoteCrashDir, dumpDir)
crashed = Automation.checkForCrashes(self, dumpDir, symbolsPath)
finally:
try:
shutil.rmtree(dumpDir)
except:
print "WARNING: unable to remove directory: %s" % dumpDir
return crashed
def run_mochitest_test(self, suite=None, test_file=None, debugger=None,
shuffle=False, keep_open=False, rerun_failures=False, no_autorun=False,
repeat=0, slow=False):
"""Runs a mochitest.
test_file is a path to a test file. It can be a relative path from the
top source directory, an absolute filename, or a directory containing
test files.
suite is the type of mochitest to run. It can be one of ('plain',
'chrome', 'browser', 'metro', 'a11y').
debugger is a program name or path to a binary (presumably a debugger)
to run the test in. e.g. 'gdb'
shuffle is whether test order should be shuffled (defaults to false).
keep_open denotes whether to keep the browser open after tests
complete.
"""
# TODO Bug 794506 remove once mach integrates with virtualenv.
build_path = os.path.join(self.topobjdir, 'build')
if build_path not in sys.path:
sys.path.append(build_path)
if rerun_failures and test_file:
print('Cannot specify both --rerun-failures and a test path.')
return 1
# Need to call relpath before os.chdir() below.
test_path = ''
if test_file:
test_path = self._wrap_path_argument(test_file).relpath()
tests_dir = os.path.abspath(os.path.join(self.topobjdir, '_tests'))
mochitest_dir = os.path.join(tests_dir, 'testing', 'mochitest')
failure_file_path = os.path.join(self.statedir, 'mochitest_failures.json')
if rerun_failures and not os.path.exists(failure_file_path):
print('No failure file present. Did you run mochitests before?')
return 1
from automation import Automation
# runtests.py is ambiguous, so we load the file/module manually.
if 'mochitest' not in sys.modules:
import imp
path = os.path.join(mochitest_dir, 'runtests.py')
with open(path, 'r') as fh:
imp.load_module('mochitest', fh, path,
('.py', 'r', imp.PY_SOURCE))
import mochitest
# This is required to make other components happy. Sad, isn't it?
os.chdir(self.topobjdir)
automation = Automation()
runner = mochitest.Mochitest(automation)
opts = mochitest.MochitestOptions(automation, tests_dir)
options, args = opts.parse_args([])
# Need to set the suite options before verifyOptions below.
if suite == 'plain':
# Don't need additional options for plain.
pass
elif suite == 'chrome':
options.chrome = True
elif suite == 'browser':
options.browserChrome = True
elif suite == 'metro':
options.immersiveMode = True
options.browserChrome = True
elif suite == 'a11y':
options.a11y = True
else:
raise Exception('None or unrecognized mochitest suite type.')
options = opts.verifyOptions(options, runner)
if options is None:
raise Exception('mochitest option validator failed.')
options.autorun = not no_autorun
options.closeWhenDone = not keep_open
options.shuffle = shuffle
options.consoleLevel = 'INFO'
options.repeat = repeat
options.runSlower = slow
options.testingModulesDir = os.path.join(tests_dir, 'modules')
options.extraProfileFiles.append(os.path.join(self.distdir, 'plugins'))
options.symbolsPath = os.path.join(self.distdir, 'crashreporter-symbols')
options.failureFile = failure_file_path
automation.setServerInfo(options.webServer, options.httpPort,
options.sslPort, options.webSocketPort)
if test_path:
test_root = runner.getTestRoot(options)
test_root_file = mozpack.path.join(mochitest_dir, test_root, test_path)
if not os.path.exists(test_root_file):
print('Specified test path does not exist: %s' % test_root_file)
print('You may need to run |mach build| to build the test files.')
return 1
options.testPath = test_path
env = {'TEST_PATH': test_path}
if rerun_failures:
options.testManifest = failure_file_path
if debugger:
options.debugger = debugger
return runner.runTests(options)
#!/usr/bin/env python
# This Source Code Form is subject to the terms of the Mozilla Public
# License, v. 2.0. If a copy of the MPL was not distributed with this
# file, You can obtain one at http://mozilla.org/MPL/2.0/.
"""
Runs the Bloat test harness
"""
import optparse
import sys
import os
import shutil
from automation import Automation
automation = Automation()
from automationutils import checkForCrashes
class BloatRunTestOptions(optparse.OptionParser):
"""Parses Bloat runtest.py commandline options."""
def __init__(self, **kwargs):
optparse.OptionParser.__init__(self, **kwargs)
defaults = {}
self.add_option("--distdir",
action = "store", type = "string", dest = "distdir",
help = "object directory of build to run")
defaults["distdir"] = "distdir-tb"
self.add_option("--bin",
def __init__(self, automation=None):
self.automation = automation or Automation()
OptionParser.__init__(self)
defaults = {}
# we want to pass down everything from automation.__all__
addCommonOptions(self,
defaults=dict(
zip(self.automation.__all__, [
getattr(self.automation, x)
for x in self.automation.__all__
])))
self.automation.addCommonOptions(self)
self.add_option(
"--appname",
action="store",
type="string",
dest="app",
default=os.path.join(SCRIPT_DIRECTORY,
self.automation.DEFAULT_APP),
help="absolute path to application, overriding default")
self.add_option("--extra-profile-file",
action="append",
dest="extraProfileFiles",
default=[],
help="copy specified files/dirs to testing profile")
self.add_option(
"--timeout",
action="store",
dest="timeout",
type="int",
default=5 * 60, # 5 minutes per bug 479518
help=
"reftest will timeout in specified number of seconds. [default %default s]."
)
self.add_option("--leak-threshold",
action="store",
type="int",
dest="defaultLeakThreshold",
default=0,
help="fail if the number of bytes leaked in default "
"processes through refcounted objects (or bytes "
"in classes with MOZ_COUNT_CTOR and MOZ_COUNT_DTOR) "
"is greater than the given number")
self.add_option("--utility-path",
action="store",
type="string",
dest="utilityPath",
default=self.automation.DIST_BIN,
help="absolute path to directory containing utility "
"programs (xpcshell, ssltunnel, certutil)")
defaults["utilityPath"] = self.automation.DIST_BIN
self.add_option("--total-chunks",
type="int",
dest="totalChunks",
help="how many chunks to split the tests up into")
defaults["totalChunks"] = None
self.add_option("--this-chunk",
type="int",
dest="thisChunk",
help="which chunk to run between 1 and --total-chunks")
defaults["thisChunk"] = None
self.add_option("--log-file",
action="store",
type="string",
dest="logFile",
default=None,
help="file to log output to in addition to stdout")
defaults["logFile"] = None
self.add_option("--skip-slow-tests",
dest="skipSlowTests",
action="store_true",
help="skip tests marked as slow when running")
defaults["skipSlowTests"] = False
self.add_option(
"--ignore-window-size",
dest="ignoreWindowSize",
action="store_true",
help=
"ignore the window size, which may cause spurious failures and passes"
)
defaults["ignoreWindowSize"] = False
self.add_option(
"--install-extension",
action="append",
dest="extensionsToInstall",
help="install the specified extension in the testing profile. "
"The extension file's name should be <id>.xpi where <id> is "
"the extension's id as indicated in its install.rdf. "
"An optional path can be specified too.")
defaults["extensionsToInstall"] = []
self.add_option("--run-tests-in-parallel",
action="store_true",
dest="runTestsInParallel",
help="run tests in parallel if possible")
self.add_option("--no-run-tests-in-parallel",
action="store_false",
dest="runTestsInParallel",
help="do not run tests in parallel")
defaults["runTestsInParallel"] = False
self.add_option("--setenv",
action="append",
type="string",
dest="environment",
metavar="NAME=VALUE",
help="sets the given variable in the application's "
"environment")
defaults["environment"] = []
self.add_option(
"--filter",
action="store",
type="string",
dest="filter",
help="specifies a regular expression (as could be passed to the JS "
"RegExp constructor) to test against URLs in the reftest manifest; "
"only test items that have a matching test URL will be run.")
defaults["filter"] = None
self.add_option("--shuffle",
action="store_true",
dest="shuffle",
help="run reftests in random order")
defaults["shuffle"] = False
self.add_option(
"--focus-filter-mode",
action="store",
type="string",
dest="focusFilterMode",
help="filters tests to run by whether they require focus. "
"Valid values are `all', `needs-focus', or `non-needs-focus'. "
"Defaults to `all'.")
defaults["focusFilterMode"] = "all"
self.add_option("--e10s",
action="store_true",
dest="e10s",
help="enables content processes")
defaults["e10s"] = False
self.set_defaults(**defaults)
def __init__(self, automation=None):
self.automation = automation or Automation()
SCRIPT_DIR = os.path.abspath(os.path.realpath(os.path.dirname(sys.argv[0])))
sys.path.insert(0, SCRIPT_DIR)
from automation import Automation
from automationutils import getDebuggerInfo, addCommonOptions
PORT = 8888
PROFILE_DIRECTORY = os.path.abspath(os.path.join(SCRIPT_DIR, "./pgoprofile"))
MOZ_JAR_LOG_DIR = os.path.abspath(os.path.join(os.path.join(os.getenv("OBJDIR"), "dist"), "jarlog"))
os.chdir(SCRIPT_DIR)
class EasyServer(SocketServer.TCPServer):
allow_reuse_address = True
if __name__ == '__main__':
from optparse import OptionParser
automation = Automation()
parser = OptionParser()
addCommonOptions(parser)
options, args = parser.parse_args()
debuggerInfo = getDebuggerInfo(".", options.debugger, options.debuggerArgs,
options.debuggerInteractive)
httpd = EasyServer(("", PORT), SimpleHTTPServer.SimpleHTTPRequestHandler)
t = threading.Thread(target=httpd.serve_forever)
t.setDaemon(True) # don't hang on exit
t.start()
automation.setServerInfo("localhost", PORT)
def startWebServer(self, options):
""" Create the webserver on the host and start it up """
remoteXrePath = options.xrePath
remoteProfilePath = self.remoteProfile
remoteUtilityPath = options.utilityPath
localAutomation = Automation()
localAutomation.IS_WIN32 = False
localAutomation.IS_LINUX = False
localAutomation.IS_MAC = False
localAutomation.UNIXISH = False
hostos = sys.platform
if hostos in ['mac', 'darwin']:
localAutomation.IS_MAC = True
elif hostos in ['linux', 'linux2']:
localAutomation.IS_LINUX = True
localAutomation.UNIXISH = True
elif hostos in ['win32', 'win64']:
localAutomation.BIN_SUFFIX = ".exe"
localAutomation.IS_WIN32 = True
paths = [
options.xrePath, localAutomation.DIST_BIN,
self.automation._product,
os.path.join('..', self.automation._product)
]
options.xrePath = self.findPath(paths)
if options.xrePath == None:
print "ERROR: unable to find xulrunner path for %s, please specify with --xre-path" % (
os.name)
sys.exit(1)
paths.append("bin")
paths.append(os.path.join("..", "bin"))
xpcshell = "xpcshell"
if (os.name == "nt"):
xpcshell += ".exe"
if (options.utilityPath):
paths.insert(0, options.utilityPath)
options.utilityPath = self.findPath(paths, xpcshell)
if options.utilityPath == None:
print "ERROR: unable to find utility path for %s, please specify with --utility-path" % (
os.name)
sys.exit(1)
xpcshell = os.path.join(options.utilityPath, xpcshell)
if self.automation.elf_arm(xpcshell):
raise Exception('xpcshell at %s is an ARM binary; please use '
'the --utility-path argument to specify the path '
'to a desktop version.' % xpcshell)
options.serverProfilePath = tempfile.mkdtemp()
self.server = ReftestServer(localAutomation, options, self.scriptDir)
retVal = self.server.start()
if retVal:
return retVal
if (options.pidFile != ""):
f = open(options.pidFile + ".xpcshell.pid", 'w')
f.write("%s" % self.server._process.pid)
f.close()
retVal = self.server.ensureReady(self.SERVER_STARTUP_TIMEOUT)
if retVal:
return retVal
options.xrePath = remoteXrePath
options.utilityPath = remoteUtilityPath
options.profilePath = remoteProfilePath
return 0
def makeLocalAutomation(self):
localAutomation = Automation()
localAutomation.IS_WIN32 = False
localAutomation.IS_LINUX = False
localAutomation.IS_MAC = False
localAutomation.UNIXISH = False
hostos = sys.platform
if (hostos == 'mac' or hostos == 'darwin'):
localAutomation.IS_MAC = True
elif (hostos == 'linux' or hostos == 'linux2'):
localAutomation.IS_LINUX = True
localAutomation.UNIXISH = True
elif (hostos == 'win32' or hostos == 'win64'):
localAutomation.BIN_SUFFIX = ".exe"
localAutomation.IS_WIN32 = True
return localAutomation
def installExtension(self, extensionSource, profileDir, extensionID=None):
# Bug 827504 - installing special-powers extension separately causes problems in B2G
if extensionID != "*****@*****.**":
Automation.installExtension(self, extensionSource, profileDir, extensionID)
from github import Github
from automation import Automation
github = Github('rbalves')
projects = github.get_formatted_repositories()
automation = Automation()
automation.add_projects(projects)
import jsbridge
import mozmill
import socket
import copy
# Python 2.6 has the json module, but Python 2.5 doesn't.
try:
import json
except ImportError:
import simplejson as json
SCRIPT_DIRECTORY = os.path.abspath(os.path.realpath(os.path.dirname(sys.argv[0])))
sys.path.append(SCRIPT_DIRECTORY)
from automation import Automation
automation = Automation()
# --------------------------------------------------------------
# TODO: this is a hack for mozbase without virtualenv, remove with bug 849900
#
here = os.path.dirname(__file__)
mozbase = os.path.realpath(os.path.join(os.path.dirname(here), 'mozbase'))
try:
import mozcrash
except:
deps = ['mozcrash',
'mozlog']
for dep in deps:
module = os.path.join(mozbase, dep)
if module not in sys.path:
def runBrowser():
parser = OptionParser()
# we want to pass down everything from automation.__all__
parser.add_option("--valgrind",
action="store_true", dest="valgrind",
default=False,
help="use valgrind with the options given in --vgargs")
parser.add_option("--vgargs",
action="store", dest="vgargs",
default=None,
help="space-separated arguments to give to valgrind")
parser.add_option("--symbols-dir",
action="store", dest="symbolsDir",
default=None)
parser.add_option("--leak-log-file",
action="store", dest="leakLogFile",
default=None)
parser.add_option("--background",
action="store_true", dest="background",
default=False)
options, args = parser.parse_args(sys.argv)
reftestScriptDir = args[1]
utilityDir = args[2]
profileDir = args[3]
url = args[4]
sys.path.append(reftestScriptDir)
sys.path.append(os.path.join(reftestScriptDir, "..", "mozbase", "mozinfo"))
sys.path.append(os.path.join(reftestScriptDir, "..", "mozbase", "mozfile"))
try:
from automation import Automation
except ImportError:
# The first time running from a local objdir, I get "ImportError: No module named mozcrash".
# The correct fix is to use virtualenv: https://bugzilla.mozilla.org/show_bug.cgi?id=903616#c12
# For now, just try again.
from automation import Automation
automation = Automation()
theapp = os.path.join(reftestScriptDir, automation.DEFAULT_APP)
if not os.path.exists(theapp):
print "RUNBROWSER ERROR | runbrowser.py | Application %s doesn't exist." % theapp
sys.exit(1)
print "theapp: " + theapp
xrePath = os.path.dirname(theapp)
if options.valgrind:
raise Exception("runbrowser isn't working with Valgrind at the moment.")
#print "About to use valgrind"
#debuggerInfoVG = automationutils.getDebuggerInfo(oldcwd, "valgrind", "", False)
#debuggerInfoVG["args"] = options.vgargs.split(" ")
#if automation.IS_MAC:
# debuggerInfoVG["args"].append("--dsymutil=yes")
#slowness = 3.0
else:
debuggerInfoVG = None
slowness = 1.0
# browser environment
browserEnv = automation.environment(xrePath=xrePath)
gatherAssertionStacks = not automation.IS_WIN32 # bug 573306
browserEnv["XPCOM_DEBUG_BREAK"] = "stack" if gatherAssertionStacks else "warn"
browserEnv["MOZ_GDB_SLEEP"] = "2" # seconds
if not options.valgrind and "-asan" not in theapp:
browserEnv["MallocScribble"] = "1"
browserEnv["MallocPreScribble"] = "1"
if options.valgrind and automation.IS_LINUX:
browserEnv["G_SLICE"] = "always-malloc"
if automation.IS_DEBUG_BUILD and not options.valgrind and options.leakLogFile:
browserEnv["XPCOM_MEM_LEAK_LOG"] = options.leakLogFile
browserEnv["MOZ_DISABLE_SAFE_MODE_KEY"] = "1"
# Defeat Lion's misguided attempt to stop Firefox from crashing repeatedly.
# (I suspect "restorecount.txt" is the most important file to remove.)
removeDirIfExists(os.path.expanduser("~/Library/Saved Application State/org.mozilla.nightly.savedState"))
removeDirIfExists(os.path.expanduser("~/Library/Saved Application State/org.mozilla.nightlydebug.savedState"))
cmdLineArgs = []
if "#fuzz=" in url:
cmdLineArgs.append("-fuzzinject")
cmdLineArgs.append(url)
print "RUNBROWSER INFO | runbrowser.py | runApp: start."
print "RUNBROWSER INFO | runbrowser.py | " + url
if options.background:
automation.buildCommandLine = stripForegroundArg(automation.buildCommandLine)
status = automation.runApp(None, browserEnv, theapp, profileDir, cmdLineArgs,
utilityPath=utilityDir,
xrePath=xrePath,
symbolsPath=options.symbolsDir,
debuggerInfo=debuggerInfoVG,
maxTime=400.0 * slowness,
timeout=200.0 * slowness)
print "RUNBROWSER INFO | runbrowser.py | runApp: exited with status " + str(status)
if __name__ == '__main__':
logger.remove()
my_format = ("<level>{level: <8}</level> |"
"<cyan>{name}</cyan>:<cyan>{function}</cyan>:"
"<cyan>{line}</cyan> - <level>{message}</level>")
logger.add(sys.stdout, colorize=True, format=my_format, level='DEBUG')
try:
input_file = open(sys.argv[1], 'r')
except OSError:
logger.exception("Can't open input json file")
sys.exit(1)
try:
fa = json.load(input_file, object_hook=lambda d: Automation(**d))
except json.JSONDecodeError:
logger.exception("Input json parsing error")
sys.exit(1)
try:
dfa = minimize(determinate(fa))
except Exception:
logger.exception("There was an error during automate processing")
sys.exit(1)
try:
output_file = open(sys.argv[2], 'w')
except OSError:
logger.exception("Can't open output json file")
sys.exit(1)
def run_desktop_test(self, suite=None, test_file=None, debugger=None,
debugger_args=None, shuffle=False, keep_open=False, rerun_failures=False,
no_autorun=False, repeat=0, run_until_failure=False, slow=False):
"""Runs a mochitest.
test_file is a path to a test file. It can be a relative path from the
top source directory, an absolute filename, or a directory containing
test files.
suite is the type of mochitest to run. It can be one of ('plain',
'chrome', 'browser', 'metro', 'a11y').
debugger is a program name or path to a binary (presumably a debugger)
to run the test in. e.g. 'gdb'
debugger_args are the arguments passed to the debugger.
shuffle is whether test order should be shuffled (defaults to false).
keep_open denotes whether to keep the browser open after tests
complete.
"""
if rerun_failures and test_file:
print('Cannot specify both --rerun-failures and a test path.')
return 1
# Need to call relpath before os.chdir() below.
test_path = ''
if test_file:
test_path = self._wrap_path_argument(test_file).relpath()
failure_file_path = os.path.join(self.statedir, 'mochitest_failures.json')
if rerun_failures and not os.path.exists(failure_file_path):
print('No failure file present. Did you run mochitests before?')
return 1
from StringIO import StringIO
from automation import Automation
# runtests.py is ambiguous, so we load the file/module manually.
if 'mochitest' not in sys.modules:
import imp
path = os.path.join(self.mochitest_dir, 'runtests.py')
with open(path, 'r') as fh:
imp.load_module('mochitest', fh, path,
('.py', 'r', imp.PY_SOURCE))
import mochitest
# This is required to make other components happy. Sad, isn't it?
os.chdir(self.topobjdir)
automation = Automation()
# Automation installs its own stream handler to stdout. Since we want
# all logging to go through us, we just remove their handler.
remove_handlers = [l for l in logging.getLogger().handlers
if isinstance(l, logging.StreamHandler)]
for handler in remove_handlers:
logging.getLogger().removeHandler(handler)
runner = mochitest.Mochitest(automation)
opts = mochitest.MochitestOptions(automation)
options, args = opts.parse_args([])
appname = ''
if sys.platform.startswith('darwin'):
appname = os.path.join(self.distdir, self.substs['MOZ_MACBUNDLE_NAME'],
'Contents', 'MacOS', 'webapprt-stub' + automation.BIN_SUFFIX)
else:
appname = os.path.join(self.distdir, 'bin', 'webapprt-stub' +
automation.BIN_SUFFIX)
# Need to set the suite options before verifyOptions below.
if suite == 'plain':
# Don't need additional options for plain.
pass
elif suite == 'chrome':
options.chrome = True
elif suite == 'browser':
options.browserChrome = True
elif suite == 'metro':
options.immersiveMode = True
options.browserChrome = True
elif suite == 'a11y':
options.a11y = True
elif suite == 'webapprt-content':
options.webapprtContent = True
options.app = appname
elif suite == 'webapprt-chrome':
options.webapprtChrome = True
options.app = appname
options.browserArgs.append("-test-mode")
else:
raise Exception('None or unrecognized mochitest suite type.')
options.autorun = not no_autorun
options.closeWhenDone = not keep_open
options.shuffle = shuffle
options.consoleLevel = 'INFO'
options.repeat = repeat
options.runUntilFailure = run_until_failure
options.runSlower = slow
options.testingModulesDir = os.path.join(self.tests_dir, 'modules')
options.extraProfileFiles.append(os.path.join(self.distdir, 'plugins'))
options.symbolsPath = os.path.join(self.distdir, 'crashreporter-symbols')
options.failureFile = failure_file_path
if test_path:
test_root = runner.getTestRoot(options)
test_root_file = mozpack.path.join(self.mochitest_dir, test_root, test_path)
if not os.path.exists(test_root_file):
print('Specified test path does not exist: %s' % test_root_file)
print('You may need to run |mach build| to build the test files.')
return 1
options.testPath = test_path
if rerun_failures:
options.testManifest = failure_file_path
if debugger:
options.debugger = debugger
if debugger_args:
if options.debugger == None:
print("--debugger-args passed, but no debugger specified.")
return 1
options.debuggerArgs = debugger_args
options = opts.verifyOptions(options, runner)
if options is None:
raise Exception('mochitest option validator failed.')
automation.setServerInfo(options.webServer, options.httpPort,
options.sslPort, options.webSocketPort)
# We need this to enable colorization of output.
self.log_manager.enable_unstructured()
# Output processing is a little funky here. The old make targets
# grepped the log output from TEST-UNEXPECTED-* and printed these lines
# after test execution. Ideally the test runner would expose a Python
# API for obtaining test results and we could just format failures
# appropriately. Unfortunately, it doesn't yet do that. So, we capture
# all output to a buffer then "grep" the buffer after test execution.
# Bug 858197 tracks a Python API that would facilitate this.
test_output = StringIO()
handler = logging.StreamHandler(test_output)
handler.addFilter(UnexpectedFilter())
handler.setFormatter(StructuredHumanFormatter(0, write_times=False))
logging.getLogger().addHandler(handler)
result = runner.runTests(options)
# Need to remove our buffering handler before we echo failures or else
# it will catch them again!
logging.getLogger().removeHandler(handler)
self.log_manager.disable_unstructured()
if test_output.getvalue():
result = 1
for line in test_output.getvalue().splitlines():
self.log(logging.INFO, 'unexpected', {'msg': line}, '{msg}')
return result
def run_mochitest_test(self,
suite=None,
test_file=None,
debugger=None,
shuffle=False,
keep_open=False,
rerun_failures=False,
no_autorun=False,
repeat=0,
slow=False):
"""Runs a mochitest.
test_file is a path to a test file. It can be a relative path from the
top source directory, an absolute filename, or a directory containing
test files.
suite is the type of mochitest to run. It can be one of ('plain',
'chrome', 'browser', 'metro', 'a11y').
debugger is a program name or path to a binary (presumably a debugger)
to run the test in. e.g. 'gdb'
shuffle is whether test order should be shuffled (defaults to false).
keep_open denotes whether to keep the browser open after tests
complete.
"""
# TODO Bug 794506 remove once mach integrates with virtualenv.
build_path = os.path.join(self.topobjdir, 'build')
if build_path not in sys.path:
sys.path.append(build_path)
if rerun_failures and test_file:
print('Cannot specify both --rerun-failures and a test path.')
return 1
# Need to call relpath before os.chdir() below.
test_path = ''
if test_file:
test_path = self._wrap_path_argument(test_file).relpath()
tests_dir = os.path.join(self.topobjdir, '_tests')
mochitest_dir = os.path.join(tests_dir, 'testing', 'mochitest')
failure_file_path = os.path.join(self.statedir,
'mochitest_failures.json')
if rerun_failures and not os.path.exists(failure_file_path):
print('No failure file present. Did you run mochitests before?')
return 1
from StringIO import StringIO
from automation import Automation
# runtests.py is ambiguous, so we load the file/module manually.
if 'mochitest' not in sys.modules:
import imp
path = os.path.join(mochitest_dir, 'runtests.py')
with open(path, 'r') as fh:
imp.load_module('mochitest', fh, path,
('.py', 'r', imp.PY_SOURCE))
import mochitest
# This is required to make other components happy. Sad, isn't it?
os.chdir(self.topobjdir)
automation = Automation()
# Automation installs its own stream handler to stdout. Since we want
# all logging to go through us, we just remove their handler.
remove_handlers = [
l for l in logging.getLogger().handlers
if isinstance(l, logging.StreamHandler)
]
for handler in remove_handlers:
logging.getLogger().removeHandler(handler)
runner = mochitest.Mochitest(automation)
opts = mochitest.MochitestOptions(automation, tests_dir)
options, args = opts.parse_args([])
# Need to set the suite options before verifyOptions below.
if suite == 'plain':
# Don't need additional options for plain.
pass
elif suite == 'chrome':
options.chrome = True
elif suite == 'browser':
options.browserChrome = True
elif suite == 'metro':
options.immersiveMode = True
options.browserChrome = True
elif suite == 'a11y':
options.a11y = True
else:
raise Exception('None or unrecognized mochitest suite type.')
options = opts.verifyOptions(options, runner)
if options is None:
raise Exception('mochitest option validator failed.')
options.autorun = not no_autorun
options.closeWhenDone = not keep_open
options.shuffle = shuffle
options.consoleLevel = 'INFO'
options.repeat = repeat
options.runSlower = slow
options.testingModulesDir = os.path.join(tests_dir, 'modules')
options.extraProfileFiles.append(os.path.join(self.distdir, 'plugins'))
options.symbolsPath = os.path.join(self.distdir,
'crashreporter-symbols')
options.failureFile = failure_file_path
automation.setServerInfo(options.webServer, options.httpPort,
options.sslPort, options.webSocketPort)
if test_path:
test_root = runner.getTestRoot(options)
test_root_file = mozpack.path.join(mochitest_dir, test_root,
test_path)
if not os.path.exists(test_root_file):
print('Specified test path does not exist: %s' %
test_root_file)
print(
'You may need to run |mach build| to build the test files.'
)
return 1
options.testPath = test_path
env = {'TEST_PATH': test_path}
if rerun_failures:
options.testManifest = failure_file_path
if debugger:
options.debugger = debugger
# We need this to enable colorization of output.
self.log_manager.enable_unstructured()
# Output processing is a little funky here. The old make targets
# grepped the log output from TEST-UNEXPECTED-* and printed these lines
# after test execution. Ideally the test runner would expose a Python
# API for obtaining test results and we could just format failures
# appropriately. Unfortunately, it doesn't yet do that. So, we capture
# all output to a buffer then "grep" the buffer after test execution.
# Bug 858197 tracks a Python API that would facilitate this.
test_output = StringIO()
handler = logging.StreamHandler(test_output)
handler.addFilter(UnexpectedFilter())
handler.setFormatter(StructuredHumanFormatter(0, write_times=False))
logging.getLogger().addHandler(handler)
result = runner.runTests(options)
# Need to remove our buffering handler before we echo failures or else
# it will catch them again!
logging.getLogger().removeHandler(handler)
self.log_manager.disable_unstructured()
if test_output.getvalue():
for line in test_output.getvalue().splitlines():
self.log(logging.INFO, 'unexpected', {'msg': line}, '{msg}')
return result
def startWebServer(self, options):
""" Create the webserver on the host and start it up """
remoteXrePath = options.xrePath
remoteProfilePath = options.profilePath
remoteUtilityPath = options.utilityPath
localAutomation = Automation()
localAutomation.IS_WIN32 = False
localAutomation.IS_LINUX = False
localAutomation.IS_MAC = False
localAutomation.UNIXISH = False
hostos = sys.platform
if (hostos == 'mac' or hostos == 'darwin'):
localAutomation.IS_MAC = True
elif (hostos == 'linux' or hostos == 'linux2'):
localAutomation.IS_LINUX = True
localAutomation.UNIXISH = True
elif (hostos == 'win32' or hostos == 'win64'):
localAutomation.BIN_SUFFIX = ".exe"
localAutomation.IS_WIN32 = True
paths = [options.xrePath, localAutomation.DIST_BIN, self._automation._product, os.path.join('..', self._automation._product)]
options.xrePath = self.findPath(paths)
if options.xrePath == None:
print "ERROR: unable to find xulrunner path for %s, please specify with --xre-path" % (os.name)
sys.exit(1)
paths.append("bin")
paths.append(os.path.join("..", "bin"))
xpcshell = "xpcshell"
if (os.name == "nt"):
xpcshell += ".exe"
if (options.utilityPath):
paths.insert(0, options.utilityPath)
options.utilityPath = self.findPath(paths, xpcshell)
if options.utilityPath == None:
print "ERROR: unable to find utility path for %s, please specify with --utility-path" % (os.name)
sys.exit(1)
xpcshell_path = os.path.join(options.utilityPath, xpcshell)
if localAutomation.elf_arm(xpcshell_path):
self.error('xpcshell at %s is an ARM binary; please use '
'the --utility-path argument to specify the path '
'to a desktop version.' % xpcshell)
options.profilePath = tempfile.mkdtemp()
self.server = MochitestServer(localAutomation, options)
self.server.start()
if (options.pidFile != ""):
f = open(options.pidFile + ".xpcshell.pid", 'w')
f.write("%s" % self.server._process.pid)
f.close()
self.server.ensureReady(self.SERVER_STARTUP_TIMEOUT)
options.xrePath = remoteXrePath
options.utilityPath = remoteUtilityPath
options.profilePath = remoteProfilePath
# the provisions above, a recipient may use your version of this file under
# the terms of any one of the MPL, the GPL or the LGPL.
#
# ***** END LICENSE BLOCK *****
"""
Runs the Bloat test harness
"""
import optparse
import sys
import os
import shutil
from automation import Automation
automation = Automation()
from automationutils import checkForCrashes
class BloatRunTestOptions(optparse.OptionParser):
"""Parses Bloat runtest.py commandline options."""
def __init__(self, **kwargs):
optparse.OptionParser.__init__(self, **kwargs)
defaults = {}
self.add_option("--distdir",
action = "store", type = "string", dest = "distdir",
help = "object directory of build to run")
defaults["distdir"] = "distdir-tb"
self.add_option("--bin",
def __init__(self, automation, **kwargs):
defaults = {}
self._automation = automation or Automation()
MochitestOptions.__init__(self)
self.add_option("--remote-app-path", action="store",
type = "string", dest = "remoteAppPath",
help = "Path to remote executable relative to device root using only forward slashes. Either this or app must be specified but not both")
defaults["remoteAppPath"] = None
self.add_option("--deviceIP", action="store",
type = "string", dest = "deviceIP",
help = "ip address of remote device to test")
defaults["deviceIP"] = None
self.add_option("--dm_trans", action="store",
type = "string", dest = "dm_trans",
help = "the transport to use to communicate with device: [adb|sut]; default=sut")
defaults["dm_trans"] = "sut"
self.add_option("--devicePort", action="store",
type = "string", dest = "devicePort",
help = "port of remote device to test")
defaults["devicePort"] = 20701
self.add_option("--remote-product-name", action="store",
type = "string", dest = "remoteProductName",
help = "The executable's name of remote product to test - either fennec or firefox, defaults to fennec")
defaults["remoteProductName"] = "fennec"
self.add_option("--remote-logfile", action="store",
type = "string", dest = "remoteLogFile",
help = "Name of log file on the device relative to the device root. PLEASE ONLY USE A FILENAME.")
defaults["remoteLogFile"] = None
self.add_option("--remote-webserver", action = "store",
type = "string", dest = "remoteWebServer",
help = "ip address where the remote web server is hosted at")
defaults["remoteWebServer"] = None
self.add_option("--http-port", action = "store",
type = "string", dest = "httpPort",
help = "http port of the remote web server")
defaults["httpPort"] = automation.DEFAULT_HTTP_PORT
self.add_option("--ssl-port", action = "store",
type = "string", dest = "sslPort",
help = "ssl port of the remote web server")
defaults["sslPort"] = automation.DEFAULT_SSL_PORT
self.add_option("--robocop-ini", action = "store",
type = "string", dest = "robocopIni",
help = "name of the .ini file containing the list of tests to run")
defaults["robocopIni"] = ""
self.add_option("--robocop", action = "store",
type = "string", dest = "robocop",
help = "name of the .ini file containing the list of tests to run. [DEPRECATED- please use --robocop-ini")
defaults["robocop"] = ""
self.add_option("--robocop-apk", action = "store",
type = "string", dest = "robocopApk",
help = "name of the Robocop APK to use for ADB test running")
defaults["robocopApk"] = ""
self.add_option("--robocop-path", action = "store",
type = "string", dest = "robocopPath",
help = "Path to the folder where robocop.apk is located at. Primarily used for ADB test running. [DEPRECATED- please use --robocop-apk]")
defaults["robocopPath"] = ""
self.add_option("--robocop-ids", action = "store",
type = "string", dest = "robocopIds",
help = "name of the file containing the view ID map (fennec_ids.txt)")
defaults["robocopIds"] = ""
self.add_option("--remoteTestRoot", action = "store",
type = "string", dest = "remoteTestRoot",
help = "remote directory to use as test root (eg. /mnt/sdcard/tests or /data/local/tests)")
defaults["remoteTestRoot"] = None
defaults["logFile"] = "mochitest.log"
defaults["autorun"] = True
defaults["closeWhenDone"] = True
defaults["testPath"] = ""
defaults["app"] = None
defaults["utilityPath"] = None
self.set_defaults(**defaults)
def main():
a = Automation(username='******', password='******')
a.run_test()
def startWebServer(self, options):
""" Create the webserver on the host and start it up """
remoteXrePath = options.xrePath
remoteProfilePath = options.profilePath
remoteUtilityPath = options.utilityPath
localAutomation = Automation()
localAutomation.IS_WIN32 = False
localAutomation.IS_LINUX = False
localAutomation.IS_MAC = False
localAutomation.UNIXISH = False
hostos = sys.platform
if hostos == "mac" or hostos == "darwin":
localAutomation.IS_MAC = True
elif hostos == "linux" or hostos == "linux2":
localAutomation.IS_LINUX = True
localAutomation.UNIXISH = True
elif hostos == "win32" or hostos == "win64":
localAutomation.BIN_SUFFIX = ".exe"
localAutomation.IS_WIN32 = True
paths = [
options.xrePath,
localAutomation.DIST_BIN,
self._automation._product,
os.path.join("..", self._automation._product),
]
options.xrePath = self.findPath(paths)
if options.xrePath == None:
log.error("unable to find xulrunner path for %s, please specify with --xre-path", os.name)
sys.exit(1)
xpcshell = "xpcshell"
if os.name == "nt":
xpcshell += ".exe"
if options.utilityPath:
paths = [options.utilityPath, options.xrePath]
else:
paths = [options.xrePath]
options.utilityPath = self.findPath(paths, xpcshell)
if options.utilityPath == None:
log.error("unable to find utility path for %s, please specify with --utility-path", os.name)
sys.exit(1)
# httpd-path is specified by standard makefile targets and may be specified
# on the command line to select a particular version of httpd.js. If not
# specified, try to select the one from hostutils.zip, as required in bug 882932.
if not options.httpdPath:
options.httpdPath = os.path.join(options.utilityPath, "components")
xpcshell_path = os.path.join(options.utilityPath, xpcshell)
if localAutomation.elf_arm(xpcshell_path):
log.error(
"xpcshell at %s is an ARM binary; please use "
"the --utility-path argument to specify the path "
"to a desktop version." % xpcshell_path
)
sys.exit(1)
options.profilePath = tempfile.mkdtemp()
self.server = MochitestServer(options)
self.server.start()
if options.pidFile != "":
f = open(options.pidFile + ".xpcshell.pid", "w")
f.write("%s" % self.server._process.pid)
f.close()
self.server.ensureReady(self.SERVER_STARTUP_TIMEOUT)
options.xrePath = remoteXrePath
options.utilityPath = remoteUtilityPath
options.profilePath = remoteProfilePath
def startWebServer(self, options):
""" Create the webserver on the host and start it up """
remoteXrePath = options.xrePath
remoteUtilityPath = options.utilityPath
localAutomation = Automation()
localAutomation.IS_WIN32 = False
localAutomation.IS_LINUX = False
localAutomation.IS_MAC = False
localAutomation.UNIXISH = False
hostos = sys.platform
if (hostos == 'mac' or hostos == 'darwin'):
localAutomation.IS_MAC = True
elif (hostos == 'linux' or hostos == 'linux2'):
localAutomation.IS_LINUX = True
localAutomation.UNIXISH = True
elif (hostos == 'win32' or hostos == 'win64'):
localAutomation.BIN_SUFFIX = ".exe"
localAutomation.IS_WIN32 = True
paths = [
options.xrePath, localAutomation.DIST_BIN,
self.automation._product,
os.path.join('..', self.automation._product)
]
options.xrePath = self.findPath(paths)
if options.xrePath == None:
print "ERROR: unable to find xulrunner path for %s, please specify with --xre-path" % (
os.name)
return 1
paths.append("bin")
paths.append(os.path.join("..", "bin"))
xpcshell = "xpcshell"
if (os.name == "nt"):
xpcshell += ".exe"
if (options.utilityPath):
paths.insert(0, options.utilityPath)
options.utilityPath = self.findPath(paths, xpcshell)
if options.utilityPath == None:
print "ERROR: unable to find utility path for %s, please specify with --utility-path" % (
os.name)
return 1
options.serverProfilePath = tempfile.mkdtemp()
self.server = ReftestServer(localAutomation, options, self.scriptDir)
retVal = self.server.start()
if retVal:
return retVal
retVal = self.server.ensureReady(self.SERVER_STARTUP_TIMEOUT)
if retVal:
return retVal
options.xrePath = remoteXrePath
options.utilityPath = remoteUtilityPath
return 0
def runBrowser():
parser = OptionParser()
# we want to pass down everything from automation.__all__
parser.add_option("--valgrind",
action="store_true",
dest="valgrind",
default=False,
help="use valgrind with the options given in --vgargs")
parser.add_option("--vgargs",
action="store",
dest="vgargs",
default=None,
help="space-separated arguments to give to valgrind")
parser.add_option("--symbols-dir",
action="store",
dest="symbolsDir",
default=None)
parser.add_option("--leak-log-file",
action="store",
dest="leakLogFile",
default=None)
parser.add_option("--background",
action="store_true",
dest="background",
default=False)
options, args = parser.parse_args(sys.argv)
reftestScriptDir = args[1]
utilityDir = args[2]
profileDir = args[3]
url = args[4]
sys.path.append(reftestScriptDir)
sys.path.append(os.path.join(reftestScriptDir, "..", "mozbase", "mozinfo"))
sys.path.append(os.path.join(reftestScriptDir, "..", "mozbase", "mozfile"))
try:
from automation import Automation
except ImportError:
# The first time running from a local objdir, I get "ImportError: No module named mozcrash".
# The correct fix is to use virtualenv: https://bugzilla.mozilla.org/show_bug.cgi?id=903616#c12
# For now, just try again.
from automation import Automation
automation = Automation()
theapp = os.path.join(reftestScriptDir, automation.DEFAULT_APP)
if not os.path.exists(theapp):
print "RUNBROWSER ERROR | runbrowser.py | Application %s doesn't exist." % theapp
sys.exit(1)
print "theapp: " + theapp
xrePath = os.path.dirname(theapp)
if options.valgrind:
raise Exception(
"runbrowser isn't working with Valgrind at the moment.")
#print "About to use valgrind"
#debuggerInfoVG = automationutils.getDebuggerInfo(oldcwd, "valgrind", "", False)
#debuggerInfoVG["args"] = options.vgargs.split(" ")
#if automation.IS_MAC:
# debuggerInfoVG["args"].append("--dsymutil=yes")
#slowness = 3.0
else:
debuggerInfoVG = None
slowness = 1.0
# browser environment
browserEnv = automation.environment(xrePath=xrePath)
gatherAssertionStacks = False # windows output entangling (bug 573306); mac symbolizing slowness and output bloat
if gatherAssertionStacks:
browserEnv["XPCOM_DEBUG_BREAK"] = "stack"
browserEnv["MOZ_GDB_SLEEP"] = "2" # seconds
if not options.valgrind and "-asan" not in theapp:
browserEnv["MallocScribble"] = "1"
browserEnv["MallocPreScribble"] = "1"
if options.valgrind and automation.IS_LINUX:
browserEnv["G_SLICE"] = "always-malloc"
if automation.IS_DEBUG_BUILD and not options.valgrind and options.leakLogFile:
browserEnv["XPCOM_MEM_LEAK_LOG"] = options.leakLogFile
browserEnv["MOZ_DISABLE_SAFE_MODE_KEY"] = "1"
# Defeat Lion's misguided attempt to stop Firefox from crashing repeatedly.
# (I suspect "restorecount.txt" is the most important file to remove.)
removeDirIfExists(
os.path.expanduser(
"~/Library/Saved Application State/org.mozilla.nightly.savedState")
)
removeDirIfExists(
os.path.expanduser(
"~/Library/Saved Application State/org.mozilla.nightlydebug.savedState"
))
cmdLineArgs = []
if "#fuzz=" in url:
cmdLineArgs.append("-fuzzinject")
cmdLineArgs.append(url)
print "RUNBROWSER INFO | runbrowser.py | runApp: start."
print "RUNBROWSER INFO | runbrowser.py | " + url
if options.background:
automation.buildCommandLine = stripForegroundArg(
automation.buildCommandLine)
status = automation.runApp(None,
browserEnv,
theapp,
profileDir,
cmdLineArgs,
utilityPath=utilityDir,
xrePath=xrePath,
symbolsPath=options.symbolsDir,
debuggerInfo=debuggerInfoVG,
maxTime=400.0 * slowness,
timeout=200.0 * slowness)
print "RUNBROWSER INFO | runbrowser.py | runApp: exited with status " + str(
status)
