def start(self, **kwargs): if self.marionette_port is None: self.marionette_port = get_free_port() addons = [self.specialpowers_path ] if self._settings.get("special_powers") else None self.profile = self.profile_creator.create(addons=addons) self.profile.set_preferences({"marionette.port": self.marionette_port}) if self.install_fonts: self.logger.debug("Copying Ahem font to profile") font_dir = os.path.join(self.profile.profile, "fonts") if not os.path.exists(font_dir): os.makedirs(font_dir) with open(os.path.join(self.tests_root, "fonts", "Ahem.ttf"), "rb") as src: with open(os.path.join(font_dir, "Ahem.ttf"), "wb") as dest: dest.write(src.read()) self.leak_report_file = None debug_args, cmd = browser_command( self.package_name, self.binary_args if self.binary_args else [] + [cmd_arg("marionette"), "about:blank"], self.debug_info) env = get_environ(self.stylo_threads, self.chaos_mode_flags) self.runner = FennecEmulatorRunner( app=self.package_name, profile=self.profile, cmdargs=cmd[1:], env=env, symbols_path=self.symbols_path, serial=self.device_serial, # TODO - choose appropriate log dir logdir=os.getcwd(), adb_path=self.adb_binary, explicit_cleanup=True) self.logger.debug("Starting %s" % self.package_name) # connect to a running emulator self.runner.device.connect() self.runner.stop() self.runner.start(debug_args=debug_args, interactive=self.debug_info and self.debug_info.interactive) self.runner.device.device.forward( local="tcp:{}".format(self.marionette_port), remote="tcp:{}".format(self.marionette_port)) for ports in self.config.ports.values(): for port in ports: self.runner.device.device.reverse(local="tcp:{}".format(port), remote="tcp:{}".format(port)) self.logger.debug("%s Started" % self.package_name)
def start(self, **kwargs): if self.marionette_port is None: self.marionette_port = get_free_port() addons = [self.specialpowers_path ] if self._settings.get("special_powers") else None self.profile = self.profile_creator.create(addons=addons) self.profile.set_preferences({"marionette.port": self.marionette_port}) if self.install_fonts: self.logger.debug("Copying Ahem font to profile") font_dir = os.path.join(self.profile.profile, "fonts") if not os.path.exists(font_dir): os.makedirs(font_dir) with open(os.path.join(self.tests_root, "fonts", "Ahem.ttf"), "rb") as src: with open(os.path.join(font_dir, "Ahem.ttf"), "wb") as dest: dest.write(src.read()) self.leak_report_file = None debug_args, cmd = browser_command( self.package_name, self.binary_args if self.binary_args else [] + [cmd_arg("marionette"), "about:blank"], self.debug_info) env = {} env["MOZ_CRASHREPORTER"] = "1" env["MOZ_CRASHREPORTER_SHUTDOWN"] = "1" env["MOZ_DISABLE_NONLOCAL_CONNECTIONS"] = "1" env["STYLO_THREADS"] = str(self.stylo_threads) if self.chaos_mode_flags is not None: env["MOZ_CHAOSMODE"] = str(self.chaos_mode_flags) if self.enable_webrender: env["MOZ_WEBRENDER"] = "1" else: env["MOZ_WEBRENDER"] = "0" self.runner = FennecEmulatorRunner( app=self.package_name, profile=self.profile, cmdargs=cmd[1:], env=cast_env(env), symbols_path=self.symbols_path, serial=self.device_serial, # TODO - choose appropriate log dir logdir=os.getcwd()) self.logger.debug("Starting %s" % self.package_name) # connect to a running emulator self.runner.device.connect() self.runner.stop() self.runner.start(debug_args=debug_args, interactive=self.debug_info and self.debug_info.interactive) self.runner.device.device.forward( local="tcp:{}".format(self.marionette_port), remote="tcp:{}".format(self.marionette_port)) for ports in self.config.ports.values(): for port in ports: self.runner.device.device.reverse(local="tcp:{}".format(port), remote="tcp:{}".format(port)) self.logger.debug("%s Started" % self.package_name)
class FirefoxAndroidBrowser(Browser): init_timeout = 300 shutdown_timeout = 60 def __init__(self, logger, prefs_root, test_type, package_name="org.mozilla.geckoview.test", device_serial="emulator-5444", extra_prefs=None, debug_info=None, symbols_path=None, stackwalk_binary=None, certutil_binary=None, ca_certificate_path=None, e10s=False, enable_webrender=False, stackfix_dir=None, binary_args=None, timeout_multiplier=None, leak_check=False, asan=False, stylo_threads=1, chaos_mode_flags=None, config=None, browser_channel="nightly", install_fonts=False, tests_root=None, specialpowers_path=None, **kwargs): super(FirefoxAndroidBrowser, self).__init__(logger) self.prefs_root = prefs_root self.test_type = test_type self.package_name = package_name self.device_serial = device_serial self.debug_info = debug_info self.symbols_path = symbols_path self.stackwalk_binary = stackwalk_binary self.certutil_binary = certutil_binary self.ca_certificate_path = ca_certificate_path self.e10s = e10s self.enable_webrender = enable_webrender self.stackfix_dir = stackfix_dir self.binary_args = binary_args self.timeout_multiplier = timeout_multiplier self.leak_check = leak_check self.asan = asan self.stylo_threads = stylo_threads self.chaos_mode_flags = chaos_mode_flags self.config = config self.browser_channel = browser_channel self.install_fonts = install_fonts self.tests_root = tests_root self.specialpowers_path = specialpowers_path self.profile_creator = ProfileCreator(logger, prefs_root, config, test_type, extra_prefs, e10s, False, browser_channel, certutil_binary, ca_certificate_path) self.marionette_port = None self.profile = None self.runner = None self._settings = {} def settings(self, test): self._settings = { "check_leaks": self.leak_check and not test.leaks, "lsan_allowed": test.lsan_allowed, "lsan_max_stack_depth": test.lsan_max_stack_depth, "mozleak_allowed": self.leak_check and test.mozleak_allowed, "mozleak_thresholds": self.leak_check and test.mozleak_threshold, "special_powers": self.specialpowers_path and test.url_base == "/_mozilla/" } return self._settings def start(self, **kwargs): if self.marionette_port is None: self.marionette_port = get_free_port() addons = [self.specialpowers_path ] if self._settings.get("special_powers") else None self.profile = self.profile_creator.create(addons=addons) self.profile.set_preferences({"marionette.port": self.marionette_port}) if self.install_fonts: self.logger.debug("Copying Ahem font to profile") font_dir = os.path.join(self.profile.profile, "fonts") if not os.path.exists(font_dir): os.makedirs(font_dir) with open(os.path.join(self.tests_root, "fonts", "Ahem.ttf"), "rb") as src: with open(os.path.join(font_dir, "Ahem.ttf"), "wb") as dest: dest.write(src.read()) self.leak_report_file = None debug_args, cmd = browser_command( self.package_name, self.binary_args if self.binary_args else [] + [cmd_arg("marionette"), "about:blank"], self.debug_info) env = {} env["MOZ_CRASHREPORTER"] = "1" env["MOZ_CRASHREPORTER_SHUTDOWN"] = "1" env["MOZ_DISABLE_NONLOCAL_CONNECTIONS"] = "1" env["STYLO_THREADS"] = str(self.stylo_threads) if self.chaos_mode_flags is not None: env["MOZ_CHAOSMODE"] = str(self.chaos_mode_flags) if self.enable_webrender: env["MOZ_WEBRENDER"] = "1" else: env["MOZ_WEBRENDER"] = "0" self.runner = FennecEmulatorRunner( app=self.package_name, profile=self.profile, cmdargs=cmd[1:], env=cast_env(env), symbols_path=self.symbols_path, serial=self.device_serial, # TODO - choose appropriate log dir logdir=os.getcwd()) self.logger.debug("Starting %s" % self.package_name) # connect to a running emulator self.runner.device.connect() self.runner.stop() self.runner.start(debug_args=debug_args, interactive=self.debug_info and self.debug_info.interactive) self.runner.device.device.forward( local="tcp:{}".format(self.marionette_port), remote="tcp:{}".format(self.marionette_port)) for ports in self.config.ports.values(): for port in ports: self.runner.device.device.reverse(local="tcp:{}".format(port), remote="tcp:{}".format(port)) self.logger.debug("%s Started" % self.package_name) def stop(self, force=False): if self.runner is not None: if self.runner.device.connected: try: self.runner.device.device.remove_forwards() self.runner.device.device.remove_reverses() except Exception as e: self.logger.warning( "Failed to remove forwarded or reversed ports: %s" % e) # We assume that stopping the runner prompts the # browser to shut down. self.runner.stop() self.logger.debug("stopped") def pid(self): if self.runner.process_handler is None: return None try: return self.runner.process_handler.pid except AttributeError: return None def is_alive(self): if self.runner: return self.runner.is_running() return False def cleanup(self, force=False): self.stop(force) def executor_browser(self): return ExecutorBrowser, { "marionette_port": self.marionette_port, # We never want marionette to install extensions because # that doesn't work on Android; instead they are in the profile "extensions": [] } def check_crash(self, process, test): if not os.environ.get("MINIDUMP_STACKWALK", "") and self.stackwalk_binary: os.environ["MINIDUMP_STACKWALK"] = self.stackwalk_binary return bool(self.runner.check_for_crashes(test_name=test))
def start(self, **kwargs): if self.marionette_port is None: self.marionette_port = get_free_port(2828, exclude=self.used_ports) self.used_ports.add(self.marionette_port) env = {} env["MOZ_CRASHREPORTER"] = "1" env["MOZ_CRASHREPORTER_SHUTDOWN"] = "1" env["MOZ_DISABLE_NONLOCAL_CONNECTIONS"] = "1" env["STYLO_THREADS"] = str(self.stylo_threads) if self.chaos_mode_flags is not None: env["MOZ_CHAOSMODE"] = str(self.chaos_mode_flags) preferences = self.load_prefs() self.profile = FennecProfile(preferences=preferences) self.profile.set_preferences({"marionette.port": self.marionette_port, "dom.disable_open_during_load": False, "places.history.enabled": False, "dom.send_after_paint_to_content": True, "network.preload": True}) if self.leak_check and kwargs.get("check_leaks", True): self.leak_report_file = os.path.join(self.profile.profile, "runtests_leaks.log") if os.path.exists(self.leak_report_file): os.remove(self.leak_report_file) env["XPCOM_MEM_BLOAT_LOG"] = self.leak_report_file else: self.leak_report_file = None if self.ca_certificate_path is not None: self.setup_ssl() debug_args, cmd = browser_command(self.package_name, self.binary_args if self.binary_args else [] + [cmd_arg("marionette"), "about:blank"], self.debug_info) self.runner = FennecEmulatorRunner(app=self.package_name, profile=self.profile, cmdargs=cmd[1:], env=env, symbols_path=self.symbols_path, serial=self.device_serial, # TODO - choose appropriate log dir logdir=os.getcwd(), process_class=ProcessHandler, process_args={"processOutputLine": [self.on_output]}) self.logger.debug("Starting Fennec") # connect to a running emulator self.runner.device.connect() write_hosts_file(self.config, self.runner.device.device) self.runner.start(debug_args=debug_args, interactive=self.debug_info and self.debug_info.interactive) # gecko_log comes from logcat when running with device/emulator logcat_args = { "filterspec": "Gecko", "serial": self.runner.device.app_ctx.device_serial } # TODO setting logcat_args["logfile"] yields an almost empty file # even without filterspec logcat_args["stream"] = sys.stdout self.runner.device.start_logcat(**logcat_args) self.runner.device.device.forward( local="tcp:{}".format(self.marionette_port), remote="tcp:{}".format(self.marionette_port)) self.logger.debug("Fennec Started")
class FennecBrowser(FirefoxBrowser): used_ports = set() init_timeout = 300 shutdown_timeout = 60 def __init__(self, logger, prefs_root, test_type, package_name=None, device_serial="emulator-5444", **kwargs): FirefoxBrowser.__init__(self, logger, None, prefs_root, test_type, **kwargs) self._package_name = package_name self.device_serial = device_serial @property def package_name(self): """ Name of app to run on emulator. """ if self._package_name is None: self._package_name = "org.mozilla.fennec" user = os.getenv("USER") if user: self._package_name += "_" + user return self._package_name def start(self, **kwargs): if self.marionette_port is None: self.marionette_port = get_free_port(2828, exclude=self.used_ports) self.used_ports.add(self.marionette_port) env = {} env["MOZ_CRASHREPORTER"] = "1" env["MOZ_CRASHREPORTER_SHUTDOWN"] = "1" env["MOZ_DISABLE_NONLOCAL_CONNECTIONS"] = "1" env["STYLO_THREADS"] = str(self.stylo_threads) if self.chaos_mode_flags is not None: env["MOZ_CHAOSMODE"] = str(self.chaos_mode_flags) preferences = self.load_prefs() self.profile = FennecProfile(preferences=preferences) self.profile.set_preferences({"marionette.port": self.marionette_port, "dom.disable_open_during_load": False, "places.history.enabled": False, "dom.send_after_paint_to_content": True, "network.preload": True}) if self.leak_check and kwargs.get("check_leaks", True): self.leak_report_file = os.path.join(self.profile.profile, "runtests_leaks.log") if os.path.exists(self.leak_report_file): os.remove(self.leak_report_file) env["XPCOM_MEM_BLOAT_LOG"] = self.leak_report_file else: self.leak_report_file = None if self.ca_certificate_path is not None: self.setup_ssl() debug_args, cmd = browser_command(self.package_name, self.binary_args if self.binary_args else [] + [cmd_arg("marionette"), "about:blank"], self.debug_info) self.runner = FennecEmulatorRunner(app=self.package_name, profile=self.profile, cmdargs=cmd[1:], env=env, symbols_path=self.symbols_path, serial=self.device_serial, # TODO - choose appropriate log dir logdir=os.getcwd(), process_class=ProcessHandler, process_args={"processOutputLine": [self.on_output]}) self.logger.debug("Starting Fennec") # connect to a running emulator self.runner.device.connect() write_hosts_file(self.config, self.runner.device.device) self.runner.start(debug_args=debug_args, interactive=self.debug_info and self.debug_info.interactive) # gecko_log comes from logcat when running with device/emulator logcat_args = { "filterspec": "Gecko", "serial": self.runner.device.app_ctx.device_serial } # TODO setting logcat_args["logfile"] yields an almost empty file # even without filterspec logcat_args["stream"] = sys.stdout self.runner.device.start_logcat(**logcat_args) self.runner.device.device.forward( local="tcp:{}".format(self.marionette_port), remote="tcp:{}".format(self.marionette_port)) self.logger.debug("Fennec Started") def stop(self, force=False): if self.runner is not None: try: if self.runner.device.connected: self.runner.device.device.remove_forwards( "tcp:{}".format(self.marionette_port)) except Exception: traceback.print_exception(*sys.exc_info()) # We assume that stopping the runner prompts the # browser to shut down. This allows the leak log to be written for clean, stop_f in [(True, lambda: self.runner.wait(self.shutdown_timeout)), (False, lambda: self.runner.stop(signal.SIGTERM)), (False, lambda: self.runner.stop(signal.SIGKILL))]: if not force or not clean: retcode = stop_f() if retcode is not None: self.logger.info("Browser exited with return code %s" % retcode) break self.logger.debug("stopped")
def start(self, **kwargs): if self.marionette_port is None: self.marionette_port = get_free_port() env = {} env["MOZ_CRASHREPORTER"] = "1" env["MOZ_CRASHREPORTER_SHUTDOWN"] = "1" env["MOZ_DISABLE_NONLOCAL_CONNECTIONS"] = "1" env["STYLO_THREADS"] = str(self.stylo_threads) if self.chaos_mode_flags is not None: env["MOZ_CHAOSMODE"] = str(self.chaos_mode_flags) if self.enable_webrender: env["MOZ_WEBRENDER"] = "1" else: env["MOZ_WEBRENDER"] = "0" preferences = self.load_prefs() self.profile = FirefoxProfile(preferences=preferences) self.profile.set_preferences({ "marionette.port": self.marionette_port, "network.dns.localDomains": ",".join(self.config.domains_set), "dom.disable_open_during_load": False, "places.history.enabled": False, "dom.send_after_paint_to_content": True, "network.preload": True, }) if self.test_type == "reftest": self.logger.info("Setting android reftest preferences") self.profile.set_preferences({ "browser.viewport.desktopWidth": 800, # Disable high DPI "layout.css.devPixelsPerPx": "1.0", # Ensure that the full browser element # appears in the screenshot "apz.allow_zooming": False, "android.widget_paints_background": False, # Ensure that scrollbars are always painted "layout.testing.overlay-scrollbars.always-visible": True, }) if self.install_fonts: self.logger.debug("Copying Ahem font to profile") font_dir = os.path.join(self.profile.profile, "fonts") if not os.path.exists(font_dir): os.makedirs(font_dir) with open(os.path.join(self.tests_root, "fonts", "Ahem.ttf"), "rb") as src: with open(os.path.join(font_dir, "Ahem.ttf"), "wb") as dest: dest.write(src.read()) self.leak_report_file = None if self.ca_certificate_path is not None: self.setup_ssl() debug_args, cmd = browser_command( self.package_name, self.binary_args if self.binary_args else [] + [cmd_arg("marionette"), "about:blank"], self.debug_info) self.runner = FennecEmulatorRunner( app=self.package_name, profile=self.profile, cmdargs=cmd[1:], env=env, symbols_path=self.symbols_path, serial=self.device_serial, # TODO - choose appropriate log dir logdir=os.getcwd()) self.logger.debug("Starting %s" % self.package_name) # connect to a running emulator self.runner.device.connect() self.runner.stop() self.runner.start(debug_args=debug_args, interactive=self.debug_info and self.debug_info.interactive) self.runner.device.device.forward( local="tcp:{}".format(self.marionette_port), remote="tcp:{}".format(self.marionette_port)) for ports in self.config.ports.values(): for port in ports: self.runner.device.device.reverse(local="tcp:{}".format(port), remote="tcp:{}".format(port)) self.logger.debug("%s Started" % self.package_name)
class FirefoxAndroidBrowser(FirefoxBrowser): init_timeout = 300 shutdown_timeout = 60 def __init__(self, logger, prefs_root, test_type, package_name="org.mozilla.geckoview.test", device_serial="emulator-5444", **kwargs): FirefoxBrowser.__init__(self, logger, None, prefs_root, test_type, **kwargs) self.package_name = package_name self.device_serial = device_serial self.tests_root = kwargs["tests_root"] self.install_fonts = kwargs["install_fonts"] self.stackwalk_binary = kwargs["stackwalk_binary"] def start(self, **kwargs): if self.marionette_port is None: self.marionette_port = get_free_port() env = {} env["MOZ_CRASHREPORTER"] = "1" env["MOZ_CRASHREPORTER_SHUTDOWN"] = "1" env["MOZ_DISABLE_NONLOCAL_CONNECTIONS"] = "1" env["STYLO_THREADS"] = str(self.stylo_threads) if self.chaos_mode_flags is not None: env["MOZ_CHAOSMODE"] = str(self.chaos_mode_flags) if self.enable_webrender: env["MOZ_WEBRENDER"] = "1" else: env["MOZ_WEBRENDER"] = "0" preferences = self.load_prefs() self.profile = FirefoxProfile(preferences=preferences) self.profile.set_preferences({ "marionette.port": self.marionette_port, "network.dns.localDomains": ",".join(self.config.domains_set), "dom.disable_open_during_load": False, "places.history.enabled": False, "dom.send_after_paint_to_content": True, "network.preload": True, }) if self.test_type == "reftest": self.logger.info("Setting android reftest preferences") self.profile.set_preferences({ "browser.viewport.desktopWidth": 800, # Disable high DPI "layout.css.devPixelsPerPx": "1.0", # Ensure that the full browser element # appears in the screenshot "apz.allow_zooming": False, "android.widget_paints_background": False, # Ensure that scrollbars are always painted "layout.testing.overlay-scrollbars.always-visible": True, }) if self.install_fonts: self.logger.debug("Copying Ahem font to profile") font_dir = os.path.join(self.profile.profile, "fonts") if not os.path.exists(font_dir): os.makedirs(font_dir) with open(os.path.join(self.tests_root, "fonts", "Ahem.ttf"), "rb") as src: with open(os.path.join(font_dir, "Ahem.ttf"), "wb") as dest: dest.write(src.read()) self.leak_report_file = None if self.ca_certificate_path is not None: self.setup_ssl() debug_args, cmd = browser_command( self.package_name, self.binary_args if self.binary_args else [] + [cmd_arg("marionette"), "about:blank"], self.debug_info) self.runner = FennecEmulatorRunner( app=self.package_name, profile=self.profile, cmdargs=cmd[1:], env=env, symbols_path=self.symbols_path, serial=self.device_serial, # TODO - choose appropriate log dir logdir=os.getcwd()) self.logger.debug("Starting %s" % self.package_name) # connect to a running emulator self.runner.device.connect() self.runner.stop() self.runner.start(debug_args=debug_args, interactive=self.debug_info and self.debug_info.interactive) self.runner.device.device.forward( local="tcp:{}".format(self.marionette_port), remote="tcp:{}".format(self.marionette_port)) for ports in self.config.ports.values(): for port in ports: self.runner.device.device.reverse(local="tcp:{}".format(port), remote="tcp:{}".format(port)) self.logger.debug("%s Started" % self.package_name) def stop(self, force=False): if self.runner is not None: if self.runner.device.connected: try: self.runner.device.device.remove_forwards() self.runner.device.device.remove_reverses() except Exception as e: self.logger.warning( "Failed to remove forwarded or reversed ports: %s" % e) # We assume that stopping the runner prompts the # browser to shut down. self.runner.stop() self.logger.debug("stopped") def check_crash(self, process, test): if not os.environ.get("MINIDUMP_STACKWALK", "") and self.stackwalk_binary: os.environ["MINIDUMP_STACKWALK"] = self.stackwalk_binary return bool(self.runner.check_for_crashes(test_name=test))
class FennecBrowser(FirefoxBrowser): used_ports = set() init_timeout = 300 shutdown_timeout = 60 def __init__(self, logger, prefs_root, test_type, package_name=None, device_serial="emulator-5444", **kwargs): FirefoxBrowser.__init__(self, logger, None, prefs_root, test_type, **kwargs) self._package_name = package_name self.device_serial = device_serial self.tests_root = kwargs["tests_root"] self.install_fonts = kwargs["install_fonts"] @property def package_name(self): """ Name of app to run on emulator. """ if self._package_name is None: self._package_name = "org.mozilla.fennec" user = os.getenv("USER") if user: self._package_name += "_" + user return self._package_name def start(self, **kwargs): if self.marionette_port is None: self.marionette_port = get_free_port(2828, exclude=self.used_ports) self.used_ports.add(self.marionette_port) env = {} env["MOZ_CRASHREPORTER"] = "1" env["MOZ_CRASHREPORTER_SHUTDOWN"] = "1" env["MOZ_DISABLE_NONLOCAL_CONNECTIONS"] = "1" env["STYLO_THREADS"] = str(self.stylo_threads) if self.chaos_mode_flags is not None: env["MOZ_CHAOSMODE"] = str(self.chaos_mode_flags) preferences = self.load_prefs() self.profile = FirefoxProfile(preferences=preferences) self.profile.set_preferences({"marionette.port": self.marionette_port, "dom.disable_open_during_load": False, "places.history.enabled": False, "dom.send_after_paint_to_content": True, "network.preload": True}) if self.test_type == "reftest": self.logger.info("Setting android reftest preferences") self.profile.set_preferences({"browser.viewport.desktopWidth": 600, # Disable high DPI "layout.css.devPixelsPerPx": "1.0", # Ensure that the full browser element # appears in the screenshot "apz.allow_zooming": False, "android.widget_paints_background": False, # Ensure that scrollbars are always painted "ui.scrollbarFadeBeginDelay": 100000}) if self.install_fonts: self.logger.debug("Copying Ahem font to profile") font_dir = os.path.join(self.profile.profile, "fonts") if not os.path.exists(font_dir): os.makedirs(font_dir) with open(os.path.join(self.tests_root, "fonts", "Ahem.ttf"), "rb") as src: with open(os.path.join(font_dir, "Ahem.ttf"), "wb") as dest: dest.write(src.read()) if self.leak_check and kwargs.get("check_leaks", True): self.leak_report_file = os.path.join(self.profile.profile, "runtests_leaks.log") if os.path.exists(self.leak_report_file): os.remove(self.leak_report_file) env["XPCOM_MEM_BLOAT_LOG"] = self.leak_report_file else: self.leak_report_file = None if self.ca_certificate_path is not None: self.setup_ssl() debug_args, cmd = browser_command(self.package_name, self.binary_args if self.binary_args else [] + [cmd_arg("marionette"), "about:blank"], self.debug_info) self.runner = FennecEmulatorRunner(app=self.package_name, profile=self.profile, cmdargs=cmd[1:], env=env, symbols_path=self.symbols_path, serial=self.device_serial, # TODO - choose appropriate log dir logdir=os.getcwd(), process_class=ProcessHandler, process_args={"processOutputLine": [self.on_output]}) self.logger.debug("Starting %s" % self.package_name) # connect to a running emulator self.runner.device.connect() write_hosts_file(self.config, self.runner.device.device) self.runner.stop() self.runner.start(debug_args=debug_args, interactive=self.debug_info and self.debug_info.interactive) self.runner.device.device.forward( local="tcp:{}".format(self.marionette_port), remote="tcp:{}".format(self.marionette_port)) self.logger.debug("%s Started" % self.package_name) def stop(self, force=False): if self.runner is not None: if (self.runner.device.connected and len(self.runner.device.device.list_forwards()) > 0): try: self.runner.device.device.remove_forwards( "tcp:{}".format(self.marionette_port)) except Exception: self.logger.warning("Failed to remove port forwarding") # We assume that stopping the runner prompts the # browser to shut down. This allows the leak log to be written self.runner.stop() self.logger.debug("stopped")
def start(self, **kwargs): if self.marionette_port is None: self.marionette_port = get_free_port(2828, exclude=self.used_ports) self.used_ports.add(self.marionette_port) env = {} env["MOZ_CRASHREPORTER"] = "1" env["MOZ_CRASHREPORTER_SHUTDOWN"] = "1" env["MOZ_DISABLE_NONLOCAL_CONNECTIONS"] = "1" env["STYLO_THREADS"] = str(self.stylo_threads) if self.chaos_mode_flags is not None: env["MOZ_CHAOSMODE"] = str(self.chaos_mode_flags) preferences = self.load_prefs() self.profile = FennecProfile(preferences=preferences) self.profile.set_preferences({ "marionette.port": self.marionette_port, "dom.disable_open_during_load": False, "places.history.enabled": False, "dom.send_after_paint_to_content": True, "network.preload": True }) if self.leak_check and kwargs.get("check_leaks", True): self.leak_report_file = os.path.join(self.profile.profile, "runtests_leaks.log") if os.path.exists(self.leak_report_file): os.remove(self.leak_report_file) env["XPCOM_MEM_BLOAT_LOG"] = self.leak_report_file else: self.leak_report_file = None if self.ca_certificate_path is not None: self.setup_ssl() debug_args, cmd = browser_command( self.package_name, self.binary_args if self.binary_args else [] + [cmd_arg("marionette"), "about:blank"], self.debug_info) self.runner = FennecEmulatorRunner( app=self.package_name, profile=self.profile, cmdargs=cmd[1:], env=env, symbols_path=self.symbols_path, serial=self.device_serial, # TODO - choose appropriate log dir logdir=os.getcwd(), process_class=ProcessHandler, process_args={"processOutputLine": [self.on_output]}) self.logger.debug("Starting Fennec") # connect to a running emulator self.runner.device.connect() write_hosts_file(self.config, self.runner.device.device) self.runner.start(debug_args=debug_args, interactive=self.debug_info and self.debug_info.interactive) # gecko_log comes from logcat when running with device/emulator logcat_args = { "filterspec": "Gecko", "serial": self.runner.device.app_ctx.device_serial } # TODO setting logcat_args["logfile"] yields an almost empty file # even without filterspec logcat_args["stream"] = sys.stdout self.runner.device.start_logcat(**logcat_args) self.runner.device.device.forward( local="tcp:{}".format(self.marionette_port), remote="tcp:{}".format(self.marionette_port)) self.logger.debug("Fennec Started")
class FennecBrowser(FirefoxBrowser): used_ports = set() init_timeout = 300 shutdown_timeout = 60 def __init__(self, logger, prefs_root, test_type, package_name=None, device_serial="emulator-5444", **kwargs): FirefoxBrowser.__init__(self, logger, None, prefs_root, test_type, **kwargs) self._package_name = package_name self.device_serial = device_serial @property def package_name(self): """ Name of app to run on emulator. """ if self._package_name is None: self._package_name = "org.mozilla.fennec" user = os.getenv("USER") if user: self._package_name += "_" + user return self._package_name def start(self, **kwargs): if self.marionette_port is None: self.marionette_port = get_free_port(2828, exclude=self.used_ports) self.used_ports.add(self.marionette_port) env = {} env["MOZ_CRASHREPORTER"] = "1" env["MOZ_CRASHREPORTER_SHUTDOWN"] = "1" env["MOZ_DISABLE_NONLOCAL_CONNECTIONS"] = "1" env["STYLO_THREADS"] = str(self.stylo_threads) if self.chaos_mode_flags is not None: env["MOZ_CHAOSMODE"] = str(self.chaos_mode_flags) preferences = self.load_prefs() self.profile = FennecProfile(preferences=preferences) self.profile.set_preferences({ "marionette.port": self.marionette_port, "dom.disable_open_during_load": False, "places.history.enabled": False, "dom.send_after_paint_to_content": True, "network.preload": True }) if self.leak_check and kwargs.get("check_leaks", True): self.leak_report_file = os.path.join(self.profile.profile, "runtests_leaks.log") if os.path.exists(self.leak_report_file): os.remove(self.leak_report_file) env["XPCOM_MEM_BLOAT_LOG"] = self.leak_report_file else: self.leak_report_file = None if self.ca_certificate_path is not None: self.setup_ssl() debug_args, cmd = browser_command( self.package_name, self.binary_args if self.binary_args else [] + [cmd_arg("marionette"), "about:blank"], self.debug_info) self.runner = FennecEmulatorRunner( app=self.package_name, profile=self.profile, cmdargs=cmd[1:], env=env, symbols_path=self.symbols_path, serial=self.device_serial, # TODO - choose appropriate log dir logdir=os.getcwd(), process_class=ProcessHandler, process_args={"processOutputLine": [self.on_output]}) self.logger.debug("Starting Fennec") # connect to a running emulator self.runner.device.connect() write_hosts_file(self.config, self.runner.device.device) self.runner.start(debug_args=debug_args, interactive=self.debug_info and self.debug_info.interactive) # gecko_log comes from logcat when running with device/emulator logcat_args = { "filterspec": "Gecko", "serial": self.runner.device.app_ctx.device_serial } # TODO setting logcat_args["logfile"] yields an almost empty file # even without filterspec logcat_args["stream"] = sys.stdout self.runner.device.start_logcat(**logcat_args) self.runner.device.device.forward( local="tcp:{}".format(self.marionette_port), remote="tcp:{}".format(self.marionette_port)) self.logger.debug("Fennec Started") def stop(self, force=False): if self.runner is not None: try: if self.runner.device.connected: self.runner.device.device.remove_forwards("tcp:{}".format( self.marionette_port)) except Exception: traceback.print_exception(*sys.exc_info()) # We assume that stopping the runner prompts the # browser to shut down. This allows the leak log to be written for clean, stop_f in [ (True, lambda: self.runner.wait(self.shutdown_timeout)), (False, lambda: self.runner.stop(signal.SIGTERM)), (False, lambda: self.runner.stop(signal.SIGKILL)) ]: if not force or not clean: retcode = stop_f() if retcode is not None: self.logger.info("Browser exited with return code %s" % retcode) break self.logger.debug("stopped")
def start(self, **kwargs): if self.marionette_port is None: self.marionette_port = get_free_port(2828, exclude=self.used_ports) self.used_ports.add(self.marionette_port) env = {} env["MOZ_CRASHREPORTER"] = "1" env["MOZ_CRASHREPORTER_SHUTDOWN"] = "1" env["MOZ_DISABLE_NONLOCAL_CONNECTIONS"] = "1" env["STYLO_THREADS"] = str(self.stylo_threads) if self.chaos_mode_flags is not None: env["MOZ_CHAOSMODE"] = str(self.chaos_mode_flags) preferences = self.load_prefs() self.profile = FennecProfile(preferences=preferences) self.profile.set_preferences({"marionette.port": self.marionette_port, "dom.disable_open_during_load": False, "places.history.enabled": False, "dom.send_after_paint_to_content": True, "network.preload": True}) if self.install_fonts: self.logger.debug("Copying Ahem font to profile") font_dir = os.path.join(self.profile.profile, "fonts") if not os.path.exists(font_dir): os.makedirs(font_dir) with open(os.path.join(self.tests_root, "fonts", "Ahem.ttf"), "rb") as src: with open(os.path.join(font_dir, "Ahem.ttf"), "wb") as dest: dest.write(src.read()) if self.leak_check and kwargs.get("check_leaks", True): self.leak_report_file = os.path.join(self.profile.profile, "runtests_leaks.log") if os.path.exists(self.leak_report_file): os.remove(self.leak_report_file) env["XPCOM_MEM_BLOAT_LOG"] = self.leak_report_file else: self.leak_report_file = None if self.ca_certificate_path is not None: self.setup_ssl() debug_args, cmd = browser_command(self.package_name, self.binary_args if self.binary_args else [] + [cmd_arg("marionette"), "about:blank"], self.debug_info) self.runner = FennecEmulatorRunner(app=self.package_name, profile=self.profile, cmdargs=cmd[1:], env=env, symbols_path=self.symbols_path, serial=self.device_serial, # TODO - choose appropriate log dir logdir=os.getcwd(), process_class=ProcessHandler, process_args={"processOutputLine": [self.on_output]}) self.logger.debug("Starting %s" % self.package_name) # connect to a running emulator self.runner.device.connect() write_hosts_file(self.config, self.runner.device.device) self.runner.start(debug_args=debug_args, interactive=self.debug_info and self.debug_info.interactive) self.runner.device.device.forward( local="tcp:{}".format(self.marionette_port), remote="tcp:{}".format(self.marionette_port)) self.logger.debug("%s Started" % self.package_name)
def start(self, **kwargs): if self.marionette_port is None: with FennecBrowser.used_ports_lock: self.marionette_port = get_free_port(2828, exclude=self.used_ports) self.used_ports.add(self.marionette_port) env = {} env["MOZ_CRASHREPORTER"] = "1" env["MOZ_CRASHREPORTER_SHUTDOWN"] = "1" env["MOZ_DISABLE_NONLOCAL_CONNECTIONS"] = "1" env["STYLO_THREADS"] = str(self.stylo_threads) if self.chaos_mode_flags is not None: env["MOZ_CHAOSMODE"] = str(self.chaos_mode_flags) preferences = self.load_prefs() self.profile = FirefoxProfile(preferences=preferences) self.profile.set_preferences({"marionette.port": self.marionette_port, "dom.disable_open_during_load": False, "places.history.enabled": False, "dom.send_after_paint_to_content": True, "network.preload": True}) if self.test_type == "reftest": self.logger.info("Setting android reftest preferences") self.profile.set_preferences({"browser.viewport.desktopWidth": 800, # Disable high DPI "layout.css.devPixelsPerPx": "1.0", # Ensure that the full browser element # appears in the screenshot "apz.allow_zooming": False, "android.widget_paints_background": False, # Ensure that scrollbars are always painted "layout.testing.overlay-scrollbars.always-visible": True}) if self.install_fonts: self.logger.debug("Copying Ahem font to profile") font_dir = os.path.join(self.profile.profile, "fonts") if not os.path.exists(font_dir): os.makedirs(font_dir) with open(os.path.join(self.tests_root, "fonts", "Ahem.ttf"), "rb") as src: with open(os.path.join(font_dir, "Ahem.ttf"), "wb") as dest: dest.write(src.read()) if self.leak_check and kwargs.get("check_leaks", True): self.leak_report_file = os.path.join(self.profile.profile, "runtests_leaks.log") if os.path.exists(self.leak_report_file): os.remove(self.leak_report_file) env["XPCOM_MEM_BLOAT_LOG"] = self.leak_report_file else: self.leak_report_file = None if self.ca_certificate_path is not None: self.setup_ssl() debug_args, cmd = browser_command(self.package_name, self.binary_args if self.binary_args else [] + [cmd_arg("marionette"), "about:blank"], self.debug_info) self.runner = FennecEmulatorRunner(app=self.package_name, profile=self.profile, cmdargs=cmd[1:], env=env, symbols_path=self.symbols_path, serial=self.device_serial, # TODO - choose appropriate log dir logdir=os.getcwd(), process_class=ProcessHandler, process_args={"processOutputLine": [self.on_output]}) self.logger.debug("Starting %s" % self.package_name) # connect to a running emulator self.runner.device.connect() write_hosts_file(self.config, self.runner.device.device) self.runner.stop() self.runner.start(debug_args=debug_args, interactive=self.debug_info and self.debug_info.interactive) self.runner.device.device.forward( local="tcp:{}".format(self.marionette_port), remote="tcp:{}".format(self.marionette_port)) self.logger.debug("%s Started" % self.package_name)