def run_xpcshell(context, **kwargs):
args = Namespace(**kwargs)
args.appPath = args.appPath or os.path.dirname(context.firefox_bin)
args.utility_path = context.bin_dir
args.testingModulesDir = context.modules_dir
if not args.xpcshell:
args.xpcshell = os.path.join(args.appPath, "xpcshell")
if not args.pluginsPath:
for path in context.ancestors(args.appPath, depth=2):
test = os.path.join(path, "plugins")
if os.path.isdir(test):
args.pluginsPath = test
break
log = mozlog.commandline.setup_logging("XPCShellTests", args,
{"mach": sys.stdout},
{"verbose": True})
if args.testPaths:
test_root = os.path.join(context.package_root, "xpcshell", "tests")
normalize = partial(context.normalize_test_path, test_root)
# pylint --py3k: W1636
args.testPaths = list(map(normalize, args.testPaths))
import runxpcshelltests
xpcshell = runxpcshelltests.XPCShellTests(log=log)
return xpcshell.runTests(**vars(args))
def run(self, metadata):
tests = self.get_arg("tests", [])
if len(tests) != 1:
# for now we support one single test
raise NotImplementedError(str(tests))
test = Path(tests[0])
if not test.exists():
raise FileNotFoundError(str(test))
# let's grab the manifest
manifest = Path(test.parent, "xpcshell.ini")
if not manifest.exists():
raise FileNotFoundError(str(manifest))
import runxpcshelltests
xpcshell = runxpcshelltests.XPCShellTests(log=self)
kwargs = {}
kwargs["testPaths"] = test.name
kwargs["verbose"] = True
kwargs["xpcshell"] = self.mach_cmd.get_binary_path("xpcshell")
kwargs["mozInfo"] = str(Path(self.topobjdir, "mozinfo.json"))
kwargs["symbolsPath"] = str(Path(self.distdir, "crashreporter-symbols"))
kwargs["logfiles"] = True
kwargs["profileName"] = "firefox"
kwargs["pluginsPath"] = str(Path(self.distdir, "plugins"))
kwargs["testingModulesDir"] = str(Path(self.topobjdir, "_tests/modules"))
kwargs["utility_path"] = self.bindir
kwargs["manifest"] = manifest
kwargs["totalChunks"] = 1
cycles = self.get_arg("cycles", 1)
self.info("Running %d cycles" % cycles)
for cycle in range(cycles):
with temp_dir() as tmp, silence():
kwargs["tempDir"] = tmp
if not xpcshell.runTests(kwargs):
raise XPCShellTestError()
self.info("Cycle %d" % (cycle + 1))
self.info("tests done.")
results = defaultdict(list)
for m in self.metrics:
for key, val in m.items():
results[key].append(val)
metadata.add_result(
{
"name": test.name,
"framework": {"name": "xpcshell"},
"transformer": "mozperftest.test.xpcshell:XPCShellData",
"results": [
{"values": measures, "name": subtest}
for subtest, measures in results.items()
],
}
)
return metadata
def _run_xpcshell_harness(self, test_dirs=None, manifest=None,
test_path=None, debug=False, shuffle=False, interactive=False,
keep_going=False):
# Obtain a reference to the xpcshell test runner.
import runxpcshelltests
dummy_log = StringIO()
xpcshell = runxpcshelltests.XPCShellTests(log=dummy_log)
self.log_manager.enable_unstructured()
tests_dir = os.path.join(self.topobjdir, '_tests', 'xpcshell')
modules_dir = os.path.join(self.topobjdir, '_tests', 'modules')
args = {
'xpcshell': os.path.join(self.bindir, 'xpcshell'),
'mozInfo': os.path.join(self.topobjdir, 'mozinfo.json'),
'symbolsPath': os.path.join(self.distdir, 'crashreporter-symbols'),
'interactive': interactive,
'keepGoing': keep_going,
'logfiles': False,
'shuffle': shuffle,
'testsRootDir': tests_dir,
'testingModulesDir': modules_dir,
'profileName': 'firefox',
'verbose': test_path is not None,
'xunitFilename': os.path.join(self.statedir, 'xpchsell.xunit.xml'),
'xunitName': 'xpcshell',
}
if manifest is not None:
args['manifest'] = manifest
elif test_dirs is not None:
if isinstance(test_dirs, list):
args['testdirs'] = test_dirs
else:
args['testdirs'] = [test_dirs]
else:
raise Exception('One of test_dirs or manifest must be provided.')
if test_path is not None:
args['testPath'] = test_path
# Python through 2.7.2 has issues with unicode in some of the
# arguments. Work around that.
filtered_args = {}
for k, v in args.items():
if isinstance(v, unicode_type):
v = v.encode('utf-8')
if isinstance(k, unicode_type):
k = k.encode('utf-8')
filtered_args[k] = v
# TODO do something with result.
xpcshell.runTests(**filtered_args)
self.log_manager.disable_unstructured()
def _run_xpcshell_harness(self,
test_dirs=None,
manifest=None,
test_path=None,
debug=False):
# Obtain a reference to the xpcshell test runner.
import runxpcshelltests
dummy_log = StringIO()
xpcshell = runxpcshelltests.XPCShellTests(log=dummy_log)
self.log_manager.enable_unstructured()
tests_dir = os.path.join(self.topobjdir, '_tests', 'xpcshell')
modules_dir = os.path.join(self.topobjdir, '_tests', 'modules')
args = {
'xpcshell': os.path.join(self.bindir, 'xpcshell'),
'mozInfo': os.path.join(self.topobjdir, 'mozinfo.json'),
'symbolsPath': os.path.join(self.distdir, 'crashreporter-symbols'),
'logfiles': False,
'testsRootDir': tests_dir,
'testingModulesDir': modules_dir,
'profileName': 'firefox',
'verbose': test_path is not None,
}
if manifest is not None:
args['manifest'] = manifest
elif test_dirs is not None:
if isinstance(test_dirs, list):
args['testdirs'] = test_dirs
else:
args['testdirs'] = [test_dirs]
else:
raise Exception('One of test_dirs or manifest must be provided.')
if test_path is not None:
args['testPath'] = test_path
# TODO do something with result.
xpcshell.runTests(**args)
self.log_manager.disable_unstructured()
def _run_xpcshell_harness(self,
manifest,
test_path=None,
shuffle=False,
interactive=False,
keep_going=False,
sequential=False,
debugger=None,
debuggerArgs=None,
debuggerInteractive=None,
rerun_failures=False,
verbose=False):
# Obtain a reference to the xpcshell test runner.
import runxpcshelltests
dummy_log = StringIO()
xpcshell = runxpcshelltests.XPCShellTests(log=dummy_log)
self.log_manager.enable_unstructured()
xpcshell_filter = TestStartFilter()
self.log_manager.terminal_handler.addFilter(xpcshell_filter)
tests_dir = os.path.join(self.topobjdir, '_tests', 'xpcshell')
modules_dir = os.path.join(self.topobjdir, '_tests', 'modules')
# We want output from the test to be written immediately if we are only
# running a single test.
verbose_output = (test_path is not None
or (manifest and len(manifest.test_paths()) == 1)
or verbose)
# We need to attach the '.exe' extension on Windows for the debugger to
# work properly.
xpcsExecutable = 'xpcshell'
if os.name == 'nt':
xpcsExecutable += '.exe'
args = {
'manifest': manifest,
'xpcshell': os.path.join(self.bindir, xpcsExecutable),
'mozInfo': os.path.join(self.topobjdir, 'mozinfo.json'),
'symbolsPath': os.path.join(self.distdir, 'crashreporter-symbols'),
'interactive': interactive,
'keepGoing': keep_going,
'logfiles': False,
'sequential': sequential,
'shuffle': shuffle,
'testsRootDir': tests_dir,
'testingModulesDir': modules_dir,
'profileName': 'firefox',
'verbose': test_path is not None,
'xunitFilename': os.path.join(self.statedir, 'xpchsell.xunit.xml'),
'xunitName': 'xpcshell',
'pluginsPath': os.path.join(self.distdir, 'plugins'),
'debugger': debugger,
'debuggerArgs': debuggerArgs,
'debuggerInteractive': debuggerInteractive,
'on_message': (lambda obj, msg: xpcshell.log.info(msg.decode('utf-8', 'replace'))) \
if verbose_output else None,
}
if test_path is not None:
args['testPath'] = test_path
# A failure manifest is written by default. If --rerun-failures is
# specified and a prior failure manifest is found, the prior manifest
# will be run. A new failure manifest is always written over any
# prior failure manifest.
failure_manifest_path = os.path.join(self.statedir,
'xpcshell.failures.ini')
rerun_manifest_path = os.path.join(self.statedir, 'xpcshell.rerun.ini')
if os.path.exists(failure_manifest_path) and rerun_failures:
shutil.move(failure_manifest_path, rerun_manifest_path)
args['manifest'] = rerun_manifest_path
elif os.path.exists(failure_manifest_path):
os.remove(failure_manifest_path)
elif rerun_failures:
print("No failures were found to re-run.")
return 0
args['failureManifest'] = failure_manifest_path
# Python through 2.7.2 has issues with unicode in some of the
# arguments. Work around that.
filtered_args = {}
for k, v in args.items():
if isinstance(v, unicode_type):
v = v.encode('utf-8')
if isinstance(k, unicode_type):
k = k.encode('utf-8')
filtered_args[k] = v
result = xpcshell.runTests(**filtered_args)
self.log_manager.terminal_handler.removeFilter(xpcshell_filter)
self.log_manager.disable_unstructured()
if not result and not xpcshell.sequential:
print("Tests were run in parallel. Try running with --sequential "
"to make sure the failures were not caused by this.")
return int(not result)
def run(self, metadata):
tests = self.get_arg("tests", [])
if len(tests) != 1:
# for now we support one single test
raise NotImplementedError(str(tests))
test = Path(tests[0])
if not test.exists():
raise FileNotFoundError(str(test))
# let's grab the manifest
manifest = Path(test.parent, "xpcshell.ini")
if not manifest.exists():
raise FileNotFoundError(str(manifest))
nodejs = self.get_arg("nodejs")
if nodejs is not None:
os.environ["MOZ_NODE_PATH"] = nodejs
import runxpcshelltests
verbose = self.get_arg("verbose")
xpcshell = runxpcshelltests.XPCShellTests(log=self)
kwargs = {}
kwargs["testPaths"] = test.name
kwargs["verbose"] = verbose
binary = self.get_arg("binary")
if binary is None:
binary = self.mach_cmd.get_binary_path("xpcshell")
kwargs["xpcshell"] = binary
binary = Path(binary)
mozinfo = self.get_arg("mozinfo")
if mozinfo is None:
mozinfo = binary.parent / ".." / "mozinfo.json"
if not mozinfo.exists():
mozinfo = Path(self.topobjdir, "mozinfo.json")
else:
mozinfo = Path(mozinfo)
kwargs["mozInfo"] = str(mozinfo)
kwargs["symbolsPath"] = str(Path(self.distdir,
"crashreporter-symbols"))
kwargs["logfiles"] = True
kwargs["profileName"] = "firefox"
plugins = binary.parent / "plugins"
if not plugins.exists():
plugins = Path(self.distdir, "plugins")
kwargs["pluginsPath"] = str(plugins)
modules = binary.parent / "modules"
if not modules.exists():
modules = Path(self.topobjdir, "_tests", "modules")
kwargs["testingModulesDir"] = str(modules)
kwargs["utility_path"] = self.bindir
kwargs["manifest"] = str(manifest)
kwargs["totalChunks"] = 1
xre_path = self.get_arg("xre-path")
if xre_path is not None:
self.info(f"Copying {xre_path} elements to {binary.parent}")
copy_tree(xre_path, str(binary.parent), update=True)
http3server = binary.parent / "http3server"
if http3server.exists():
kwargs["http3server"] = str(http3server)
cycles = self.get_arg("cycles", 1)
self.info("Running %d cycles" % cycles)
for cycle in range(cycles):
self.info("Cycle %d" % (cycle + 1))
with temp_dir() as tmp:
kwargs["tempDir"] = tmp
if not xpcshell.runTests(kwargs):
raise XPCShellTestError()
self.info("tests done.")
results = defaultdict(list)
for m in self.metrics:
for key, val in m.items():
results[key].append(val)
metadata.add_result({
"name":
test.name,
"framework": {
"name": "mozperftest"
},
"transformer":
"mozperftest.test.xpcshell:XPCShellData",
"results": [{
"values": measures,
"name": subtest
} for subtest, measures in results.items()],
})
return metadata
def _run_xpcshell_harness(self,
manifest,
test_path=None,
shuffle=False,
interactive=False,
keep_going=False,
sequential=False,
debugger=None,
debuggerArgs=None,
debuggerInteractive=None,
jsDebugger=False,
jsDebuggerPort=None,
rerun_failures=False,
verbose=False,
log=None,
test_tags=None):
# Obtain a reference to the xpcshell test runner.
import runxpcshelltests
xpcshell = runxpcshelltests.XPCShellTests(log=log)
self.log_manager.enable_unstructured()
tests_dir = os.path.join(self.topobjdir, '_tests', 'xpcshell')
modules_dir = os.path.join(self.topobjdir, '_tests', 'modules')
# We want output from the test to be written immediately if we are only
# running a single test.
single_test = (test_path is not None
or (manifest and len(manifest.test_paths()) == 1))
sequential = sequential or single_test
args = {
'manifest': manifest,
'xpcshell': self.get_binary_path('xpcshell'),
'mozInfo': os.path.join(self.topobjdir, 'mozinfo.json'),
'symbolsPath': os.path.join(self.distdir, 'crashreporter-symbols'),
'interactive': interactive,
'keepGoing': keep_going,
'logfiles': False,
'sequential': sequential,
'shuffle': shuffle,
'testsRootDir': tests_dir,
'testingModulesDir': modules_dir,
'profileName': 'firefox',
'verbose': verbose or single_test,
'xunitFilename': os.path.join(self.statedir, 'xpchsell.xunit.xml'),
'xunitName': 'xpcshell',
'pluginsPath': os.path.join(self.distdir, 'plugins'),
'debugger': debugger,
'debuggerArgs': debuggerArgs,
'debuggerInteractive': debuggerInteractive,
'jsDebugger': jsDebugger,
'jsDebuggerPort': jsDebuggerPort,
'test_tags': test_tags,
'utility_path': self.bindir,
}
if test_path is not None:
args['testPath'] = test_path
# A failure manifest is written by default. If --rerun-failures is
# specified and a prior failure manifest is found, the prior manifest
# will be run. A new failure manifest is always written over any
# prior failure manifest.
failure_manifest_path = os.path.join(self.statedir,
'xpcshell.failures.ini')
rerun_manifest_path = os.path.join(self.statedir, 'xpcshell.rerun.ini')
if os.path.exists(failure_manifest_path) and rerun_failures:
shutil.move(failure_manifest_path, rerun_manifest_path)
args['manifest'] = rerun_manifest_path
elif os.path.exists(failure_manifest_path):
os.remove(failure_manifest_path)
elif rerun_failures:
print("No failures were found to re-run.")
return 0
args['failureManifest'] = failure_manifest_path
# Python through 2.7.2 has issues with unicode in some of the
# arguments. Work around that.
filtered_args = {}
for k, v in args.items():
if isinstance(v, unicode_type):
v = v.encode('utf-8')
if isinstance(k, unicode_type):
k = k.encode('utf-8')
filtered_args[k] = v
result = xpcshell.runTests(**filtered_args)
self.log_manager.disable_unstructured()
if not result and not xpcshell.sequential:
print("Tests were run in parallel. Try running with --sequential "
"to make sure the failures were not caused by this.")
return int(not result)
def _run_xpcshell_harness(self, **kwargs):
# Obtain a reference to the xpcshell test runner.
import runxpcshelltests
log = kwargs.pop("log")
xpcshell = runxpcshelltests.XPCShellTests(log=log)
self.log_manager.enable_unstructured()
tests_dir = os.path.join(self.topobjdir, '_tests', 'xpcshell')
# We want output from the test to be written immediately if we are only
# running a single test.
single_test = (len(kwargs["testPaths"]) == 1
and os.path.isfile(kwargs["testPaths"][0])
or kwargs["manifest"] and
(len(kwargs["manifest"].test_paths()) == 1))
if single_test:
kwargs["verbose"] = True
if kwargs["xpcshell"] is None:
kwargs["xpcshell"] = self.get_binary_path('xpcshell')
if kwargs["mozInfo"] is None:
kwargs["mozInfo"] = os.path.join(self.topobjdir, 'mozinfo.json')
if kwargs["symbolsPath"] is None:
kwargs["symbolsPath"] = os.path.join(self.distdir,
'crashreporter-symbols')
if kwargs["logfiles"] is None:
kwargs["logfiles"] = False
if kwargs["profileName"] is None:
kwargs["profileName"] = "firefox"
if kwargs["pluginsPath"] is None:
kwargs['pluginsPath'] = os.path.join(self.distdir, 'plugins')
if kwargs["testingModulesDir"] is None:
kwargs["testingModulesDir"] = os.path.join(self.topobjdir,
'_tests/modules')
if kwargs["utility_path"] is None:
kwargs['utility_path'] = self.bindir
if kwargs["manifest"] is None:
kwargs["manifest"] = os.path.join(tests_dir, "xpcshell.ini")
if kwargs["failure_manifest"] is None:
kwargs["failure_manifest"] = os.path.join(self.statedir,
'xpcshell.failures.ini')
# Use the object directory for the temp directory to minimize the chance
# of file scanning. The overhead from e.g. search indexers and anti-virus
# scanners like Windows Defender can add tons of overhead to test execution.
# We encourage people to disable these things in the object directory.
temp_dir = os.path.join(self.topobjdir, 'temp')
try:
os.mkdir(temp_dir)
except OSError as e:
if e.errno != errno.EEXIST:
raise
kwargs['tempDir'] = temp_dir
# Python through 2.7.2 has issues with unicode in some of the
# arguments. Work around that.
filtered_args = {}
for k, v in kwargs.iteritems():
if isinstance(v, unicode_type):
v = v.encode('utf-8')
if isinstance(k, unicode_type):
k = k.encode('utf-8')
filtered_args[k] = v
result = xpcshell.runTests(**filtered_args)
self.log_manager.disable_unstructured()
if not result and not xpcshell.sequential:
print("Tests were run in parallel. Try running with --sequential "
"to make sure the failures were not caused by this.")
return int(not result)
def _run_xpcshell_harness(self, **kwargs):
# Obtain a reference to the xpcshell test runner.
import runxpcshelltests
log = kwargs.pop("log")
xpcshell = runxpcshelltests.XPCShellTests(log=log)
self.log_manager.enable_unstructured()
tests_dir = os.path.join(self.topobjdir, '_tests', 'xpcshell')
# We want output from the test to be written immediately if we are only
# running a single test.
single_test = (len(kwargs["testPaths"]) == 1
and os.path.isfile(kwargs["testPaths"][0])
or kwargs["manifest"] and
(len(kwargs["manifest"].test_paths()) == 1))
if single_test:
kwargs["verbose"] = True
if kwargs["xpcshell"] is None:
kwargs["xpcshell"] = self.get_binary_path('xpcshell')
if kwargs["mozInfo"] is None:
kwargs["mozInfo"] = os.path.join(self.topobjdir, 'mozinfo.json')
if kwargs["symbolsPath"] is None:
kwargs["symbolsPath"] = os.path.join(self.distdir,
'crashreporter-symbols')
if kwargs["logfiles"] is None:
kwargs["logfiles"] = False
if kwargs["profileName"] is None:
kwargs["profileName"] = "firefox"
if kwargs["pluginsPath"] is None:
kwargs['pluginsPath'] = os.path.join(self.distdir, 'plugins')
if kwargs["testingModulesDir"] is None:
kwargs["testingModulesDir"] = os.path.join(self.topobjdir,
'_tests/modules')
if kwargs["utility_path"] is None:
kwargs['utility_path'] = self.bindir
if kwargs["manifest"] is None:
kwargs["manifest"] = os.path.join(tests_dir, "xpcshell.ini")
if kwargs["failure_manifest"] is None:
kwargs["failure_manifest"] = os.path.join(self.statedir,
'xpcshell.failures.ini')
# Python through 2.7.2 has issues with unicode in some of the
# arguments. Work around that.
filtered_args = {}
for k, v in kwargs.iteritems():
if isinstance(v, unicode_type):
v = v.encode('utf-8')
if isinstance(k, unicode_type):
k = k.encode('utf-8')
filtered_args[k] = v
result = xpcshell.runTests(**filtered_args)
self.log_manager.disable_unstructured()
if not result and not xpcshell.sequential:
print("Tests were run in parallel. Try running with --sequential "
"to make sure the failures were not caused by this.")
return int(not result)
def _run_xpcshell_harness(self, **kwargs):
# Obtain a reference to the xpcshell test runner.
import runxpcshelltests
log = kwargs.pop("log")
xpcshell = runxpcshelltests.XPCShellTests(log=log)
self.log_manager.enable_unstructured()
tests_dir = os.path.join(self.topobjdir, "_tests", "xpcshell")
# We want output from the test to be written immediately if we are only
# running a single test.
single_test = (len(kwargs["testPaths"]) == 1
and os.path.isfile(kwargs["testPaths"][0])
or kwargs["manifest"] and
(len(kwargs["manifest"].test_paths()) == 1))
if single_test:
kwargs["verbose"] = True
if kwargs["xpcshell"] is None:
try:
kwargs["xpcshell"] = self.get_binary_path("xpcshell")
except BinaryNotFoundException as e:
self.log(logging.ERROR, "xpcshell-test", {"error": str(e)},
"ERROR: {error}")
self.log(logging.INFO, "xpcshell-test", {"help": e.help()},
"{help}")
return 1
if kwargs["mozInfo"] is None:
kwargs["mozInfo"] = os.path.join(self.topobjdir, "mozinfo.json")
if kwargs["symbolsPath"] is None:
kwargs["symbolsPath"] = os.path.join(self.distdir,
"crashreporter-symbols")
if kwargs["logfiles"] is None:
kwargs["logfiles"] = False
if kwargs["profileName"] is None:
kwargs["profileName"] = "firefox"
if kwargs["pluginsPath"] is None:
kwargs["pluginsPath"] = os.path.join(self.distdir, "plugins")
if kwargs["testingModulesDir"] is None:
kwargs["testingModulesDir"] = os.path.join(self.topobjdir,
"_tests/modules")
if kwargs["utility_path"] is None:
kwargs["utility_path"] = self.bindir
if kwargs["manifest"] is None:
kwargs["manifest"] = os.path.join(tests_dir, "xpcshell.ini")
if kwargs["failure_manifest"] is None:
kwargs["failure_manifest"] = os.path.join(self.statedir,
"xpcshell.failures.ini")
# Use the object directory for the temp directory to minimize the chance
# of file scanning. The overhead from e.g. search indexers and anti-virus
# scanners like Windows Defender can add tons of overhead to test execution.
# We encourage people to disable these things in the object directory.
temp_dir = os.path.join(self.topobjdir, "temp")
try:
os.mkdir(temp_dir)
except OSError as e:
if e.errno != errno.EEXIST:
raise
kwargs["tempDir"] = temp_dir
result = xpcshell.runTests(kwargs)
self.log_manager.disable_unstructured()
if not result and not xpcshell.sequential:
print("Tests were run in parallel. Try running with --sequential "
"to make sure the failures were not caused by this.")
return int(not result)