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")
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.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)
