diff options
Diffstat (limited to 'layout/tools/reftest/runreftestb2g.py')
| -rw-r--r-- | layout/tools/reftest/runreftestb2g.py | 425 |
1 files changed, 425 insertions, 0 deletions
diff --git a/layout/tools/reftest/runreftestb2g.py b/layout/tools/reftest/runreftestb2g.py new file mode 100644 index 000000000..6a6346ece --- /dev/null +++ b/layout/tools/reftest/runreftestb2g.py @@ -0,0 +1,425 @@ +# 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/. + +import ConfigParser +import os +import sys +import tempfile +import traceback + +# We need to know our current directory so that we can serve our test files from it. +here = os.path.abspath(os.path.dirname(__file__)) +if here not in sys.path: + sys.path.insert(0, here) + +from automation import Automation +from b2gautomation import B2GRemoteAutomation +from runreftestmulet import run_test_harness as run_mulet_reftests +from output import OutputHandler +from remotereftest import RemoteReftestResolver, ReftestServer +from runreftest import RefTest +import reftestcommandline + +from marionette_harness import Marionette +from mozdevice import DeviceManagerADB, DMError + + +class ProfileConfigParser(ConfigParser.RawConfigParser): + """Subclass of RawConfigParser that outputs .ini files in the exact + format expected for profiles.ini, which is slightly different + than the default format. + """ + + def optionxform(self, optionstr): + return optionstr + + def write(self, fp): + if self._defaults: + fp.write("[%s]\n" % ConfigParser.DEFAULTSECT) + for (key, value) in self._defaults.items(): + fp.write("%s=%s\n" % (key, str(value).replace('\n', '\n\t'))) + fp.write("\n") + for section in self._sections: + fp.write("[%s]\n" % section) + for (key, value) in self._sections[section].items(): + if key == "__name__": + continue + if (value is not None) or (self._optcre == self.OPTCRE): + key = "=".join((key, str(value).replace('\n', '\n\t'))) + fp.write("%s\n" % (key)) + fp.write("\n") + +class B2GRemoteReftest(RefTest): + + _devicemanager = None + use_marionette = False + localProfile = None + remoteApp = '' + profile = None + resolver_cls = RemoteReftestResolver + + def __init__(self, automation, devicemanager, options, scriptDir): + RefTest.__init__(self) + self.automation = automation + self._devicemanager = devicemanager + self.runSSLTunnel = False + self.remoteTestRoot = options.remoteTestRoot + self.remoteProfile = options.remoteProfile + self.automation.setRemoteProfile(self.remoteProfile) + self.localLogName = options.localLogName + self.remoteLogFile = options.remoteLogFile + self.bundlesDir = '/system/b2g/distribution/bundles' + self.remoteMozillaPath = '/data/b2g/mozilla' + self.remoteProfilesIniPath = os.path.join(self.remoteMozillaPath, 'profiles.ini') + self.originalProfilesIni = None + self.scriptDir = scriptDir + self.SERVER_STARTUP_TIMEOUT = 90 + if self.automation.IS_DEBUG_BUILD: + self.SERVER_STARTUP_TIMEOUT = 180 + + def cleanup(self, profileDir): + # Pull results back from device + if (self.remoteLogFile): + try: + self._devicemanager.getFile(self.remoteLogFile, self.localLogName) + except: + print "ERROR: We were not able to retrieve the info from %s" % self.remoteLogFile + sys.exit(5) + + # Delete any bundled extensions + if profileDir: + extensionDir = os.path.join(profileDir, 'extensions', 'staged') + for filename in os.listdir(extensionDir): + try: + self._devicemanager._checkCmd(['shell', 'rm', '-rf', + os.path.join(self.bundlesDir, filename)]) + except DMError: + pass + + # Restore the original profiles.ini. + if self.originalProfilesIni: + try: + if not self.automation._is_emulator: + self.restoreProfilesIni() + os.remove(self.originalProfilesIni) + except: + pass + + if not self.automation._is_emulator: + self._devicemanager.removeFile(self.remoteLogFile) + self._devicemanager.removeDir(self.remoteProfile) + self._devicemanager.removeDir(self.remoteTestRoot) + + # We've restored the original profile, so reboot the device so that + # it gets picked up. + self.automation.rebootDevice() + + RefTest.cleanup(self, profileDir) + if getattr(self, 'pidFile', '') != '': + try: + os.remove(self.pidFile) + os.remove(self.pidFile + ".xpcshell.pid") + except: + print "Warning: cleaning up pidfile '%s' was unsuccessful from the test harness" % self.pidFile + + def findPath(self, paths, filename = None): + for path in paths: + p = path + if filename: + p = os.path.join(p, filename) + if os.path.exists(self.getFullPath(p)): + return path + return None + + 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" + + 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 stopWebServer(self, options): + if hasattr(self, 'server'): + self.server.stop() + + def restoreProfilesIni(self): + # restore profiles.ini on the device to its previous state + if not self.originalProfilesIni or not os.access(self.originalProfilesIni, os.F_OK): + raise DMError('Unable to install original profiles.ini; file not found: %s', + self.originalProfilesIni) + + self._devicemanager.pushFile(self.originalProfilesIni, self.remoteProfilesIniPath) + + def updateProfilesIni(self, profilePath): + # update profiles.ini on the device to point to the test profile + self.originalProfilesIni = tempfile.mktemp() + self._devicemanager.getFile(self.remoteProfilesIniPath, self.originalProfilesIni) + + config = ProfileConfigParser() + config.read(self.originalProfilesIni) + for section in config.sections(): + if 'Profile' in section: + config.set(section, 'IsRelative', 0) + config.set(section, 'Path', profilePath) + + newProfilesIni = tempfile.mktemp() + with open(newProfilesIni, 'wb') as configfile: + config.write(configfile) + + self._devicemanager.pushFile(newProfilesIni, self.remoteProfilesIniPath) + try: + os.remove(newProfilesIni) + except: + pass + + + def createReftestProfile(self, options, manifests): + profile = RefTest.createReftestProfile(self, options, manifests, + server=options.remoteWebServer) + profileDir = profile.profile + + prefs = {} + + # Turn off the locale picker screen + prefs["browser.firstrun.show.localepicker"] = False + prefs["b2g.system_startup_url"] = "app://test-container.gaiamobile.org/index.html" + prefs["b2g.system_manifest_url"] = "app://test-container.gaiamobile.org/manifest.webapp" + prefs["dom.ipc.tabs.disabled"] = False + prefs["dom.mozBrowserFramesEnabled"] = True + prefs["font.size.inflation.emPerLine"] = 0 + prefs["font.size.inflation.minTwips"] = 0 + prefs["network.dns.localDomains"] = "app://test-container.gaiamobile.org" + prefs["reftest.browser.iframe.enabled"] = False + prefs["reftest.remote"] = True + + # Make sure we disable system updates + prefs["app.update.enabled"] = False + prefs["app.update.url"] = "" + # Disable webapp updates + prefs["webapps.update.enabled"] = False + # Disable tiles also + prefs["browser.newtabpage.directory.source"] = "" + prefs["browser.newtabpage.directory.ping"] = "" + + # Set the extra prefs. + profile.set_preferences(prefs) + + # Copy the profile to the device. + self._devicemanager.removeDir(self.remoteProfile) + try: + self._devicemanager.pushDir(profileDir, self.remoteProfile) + except DMError: + print "Automation Error: Unable to copy profile to device." + raise + + # Copy the extensions to the B2G bundles dir. + extensionDir = os.path.join(profileDir, 'extensions', 'staged') + # need to write to read-only dir + self._devicemanager._checkCmd(['remount']) + for filename in os.listdir(extensionDir): + self._devicemanager._checkCmd(['shell', 'rm', '-rf', + os.path.join(self.bundlesDir, filename)]) + try: + self._devicemanager.pushDir(extensionDir, self.bundlesDir) + except DMError: + print "Automation Error: Unable to copy extensions to device." + raise + + self.updateProfilesIni(self.remoteProfile) + + options.profilePath = self.remoteProfile + return profile + + def copyExtraFilesToProfile(self, options, profile): + profileDir = profile.profile + RefTest.copyExtraFilesToProfile(self, options, profile) + try: + self._devicemanager.pushDir(profileDir, options.remoteProfile) + except DMError: + print "Automation Error: Failed to copy extra files to device" + raise + + def environment(self, **kwargs): + return self.automation.environment(**kwargs) + + def runApp(self, profile, binary, cmdargs, env, + timeout=None, debuggerInfo=None, + symbolsPath=None, options=None, + valgrindPath=None, valgrindArgs=None, valgrindSuppFiles=None): + + outputHandler = OutputHandler(self.log, options.utilityPath, options.symbolsPath) + status = self.automation.runApp(None, env, + binary, + profile.profile, + cmdargs, + utilityPath=options.utilityPath, + xrePath=options.xrePath, + debuggerInfo=debuggerInfo, + symbolsPath=symbolsPath, + timeout=timeout, + outputHandler=outputHandler) + return status + + +def run_test_harness(parser, options): + if options.mulet: + return run_mulet_reftests(parser, options) + + auto = B2GRemoteAutomation(None, "fennec") + + # create our Marionette instance + kwargs = {} + if options.emulator: + kwargs['emulator'] = options.emulator + auto.setEmulator(True) + if options.noWindow: + kwargs['noWindow'] = True + if options.geckoPath: + kwargs['gecko_path'] = options.geckoPath + if options.logdir: + kwargs['logdir'] = options.logdir + if options.busybox: + kwargs['busybox'] = options.busybox + if options.symbolsPath: + kwargs['symbols_path'] = options.symbolsPath + if options.emulator_res: + kwargs['emulator_res'] = options.emulator_res + if options.b2gPath: + kwargs['homedir'] = options.b2gPath + if options.marionette: + host,port = options.marionette.split(':') + kwargs['host'] = host + kwargs['port'] = int(port) + if options.adb_path: + kwargs['adb_path'] = options.adb_path + marionette = Marionette(**kwargs) + auto.marionette = marionette + + if options.emulator: + dm = marionette.emulator.dm + else: + # create the DeviceManager + kwargs = {'adbPath': options.adb_path, + 'deviceRoot': options.remoteTestRoot} + if options.deviceIP: + kwargs.update({'host': options.deviceIP, + 'port': options.devicePort}) + dm = DeviceManagerADB(**kwargs) + auto.setDeviceManager(dm) + + parser.validate_remote(options, auto) + + # TODO fix exception + if not options.ignoreWindowSize: + parts = dm.getInfo('screen')['screen'][0].split() + width = int(parts[0].split(':')[1]) + height = int(parts[1].split(':')[1]) + if (width < 1366 or height < 1050): + print "ERROR: Invalid screen resolution %sx%s, please adjust to 1366x1050 or higher" % (width, height) + return 1 + + auto.setProduct("b2g") + auto.test_script = os.path.join(here, 'b2g_start_script.js') + auto.test_script_args = [options.remoteWebServer, options.httpPort] + + reftest = B2GRemoteReftest(auto, dm, options, here) + parser.validate(options, reftest) + + logParent = os.path.dirname(options.remoteLogFile) + dm.mkDir(logParent); + auto.setRemoteLog(options.remoteLogFile) + auto.setServerInfo(options.webServer, options.httpPort, options.sslPort) + + # Hack in a symbolic link for jsreftest + os.system("ln -s %s %s" % (os.path.join('..', 'jsreftest'), os.path.join(here, 'jsreftest'))) + + + # Start the webserver + retVal = 1 + try: + retVal = reftest.startWebServer(options) + if retVal: + return retVal + procName = options.app.split('/')[-1] + if (dm.processExist(procName)): + dm.killProcess(procName) + + retVal = reftest.runTests(options.tests, options) + except: + print "Automation Error: Exception caught while running tests" + traceback.print_exc() + reftest.stopWebServer(options) + try: + reftest.cleanup(None) + except: + pass + return 1 + + reftest.stopWebServer(options) + return retVal + + +if __name__ == "__main__": + parser = reftestcommandline.B2GArgumentParser() + options = parser.parse_args() + sys.exit(run_test_harness(parser, options)) |