def b2g_pre_run():
dm_type = os.environ.get('DM_TRANS', 'adb')
if dm_type == 'adb':
self.b2g_pid = get_b2g_pid(get_dm(self.marionette))
def run_tests(self, tests):
self.reset_test_stats()
self.start_time = time.time()
need_external_ip = True
if not self.marionette:
self.start_marionette()
if self.emulator:
self.marionette.emulator.wait_for_homescreen(self.marionette)
# Retrieve capabilities for later use
if not self._capabilities:
self.capabilities
# if we're working against a desktop version, we usually don't need
# an external ip
if self._capabilities['device'] == "desktop":
need_external_ip = False
# Gaia sets server_root and that means we shouldn't spin up our own httpd
if not self.httpd:
if self.server_root is None or os.path.isdir(self.server_root):
self.logger.info("starting httpd")
self.start_httpd(need_external_ip)
self.marionette.baseurl = self.httpd.get_url()
self.logger.info("running httpd on %s" % self.marionette.baseurl)
else:
self.marionette.baseurl = self.server_root
self.logger.info("using remote content from %s" % self.marionette.baseurl)
for test in tests:
self.add_test(test)
# ensure we have only tests files with names starting with 'test_'
invalid_tests = \
[t['filepath'] for t in self.tests
if not os.path.basename(t['filepath']).startswith('test_')]
if invalid_tests:
raise Exception("Tests file names must starts with 'test_'."
" Invalid test names:\n %s"
% '\n '.join(invalid_tests))
version_info = mozversion.get_version(binary=self.bin,
sources=self.sources,
dm_type=os.environ.get('DM_TRANS', 'adb'),
device_serial=self.device_serial,
adb_host=self.marionette.adb_host,
adb_port=self.marionette.adb_port)
device_info = None
if self.capabilities['device'] != 'desktop' and self.capabilities['browserName'] == 'B2G':
dm = get_dm(self.marionette)
device_info = dm.getInfo()
self.logger.suite_start(self.tests,
version_info=version_info,
device_info=device_info)
for test in self.manifest_skipped_tests:
name = os.path.basename(test['path'])
self.logger.test_start(name)
self.logger.test_end(name,
'SKIP',
message=test['disabled'])
self.todo += 1
interrupted = None
try:
counter = self.repeat
while counter >=0:
round = self.repeat - counter
if round > 0:
self.logger.info('\nREPEAT %d\n-------' % round)
self.run_test_sets()
counter -= 1
except KeyboardInterrupt:
# in case of KeyboardInterrupt during the test execution
# we want to display current test results.
# so we keep the exception to raise it later.
interrupted = sys.exc_info()
try:
self._print_summary(tests)
except:
# raise only the exception if we were not interrupted
if not interrupted:
raise
finally:
# reraise previous interruption now
if interrupted:
raise interrupted[0], interrupted[1], interrupted[2]
def b2g_pre_run():
dm_type = os.environ.get('DM_TRANS', 'adb')
if dm_type == 'adb':
self.b2g_pid = get_b2g_pid(get_dm(self.marionette))
def run_tests(self, tests):
assert len(tests) > 0
assert len(self.test_handlers) > 0
self.reset_test_stats()
self.start_time = time.time()
need_external_ip = True
if not self.marionette:
self.start_marionette()
# if we're working against a desktop version, we usually don't need
# an external ip
if self.capabilities['device'] == "desktop":
need_external_ip = False
self.logger.info('Initial Profile Destination is '
'"{}"'.format(self.marionette.profile_path))
# Gaia sets server_root and that means we shouldn't spin up our own httpd
if not self.httpd:
if self.server_root is None or os.path.isdir(self.server_root):
self.logger.info("starting httpd")
self.start_httpd(need_external_ip)
self.marionette.baseurl = self.httpd.get_url()
self.logger.info("running httpd on %s" % self.marionette.baseurl)
else:
self.marionette.baseurl = self.server_root
self.logger.info("using remote content from %s" % self.marionette.baseurl)
device_info = None
if self.capabilities['device'] != 'desktop' and self.capabilities['browserName'] == 'B2G':
dm = get_dm(self.marionette)
device_info = dm.getInfo()
# Add Android version (SDK level) to mozinfo so that manifest entries
# can be conditional on android_version.
androidVersion = dm.shellCheckOutput(['getprop', 'ro.build.version.sdk'])
self.logger.info(
"Android sdk version '%s'; will use this to filter manifests" % androidVersion)
mozinfo.info['android_version'] = androidVersion
for test in tests:
self.add_test(test)
# ensure we have only tests files with names starting with 'test_'
invalid_tests = \
[t['filepath'] for t in self.tests
if not os.path.basename(t['filepath']).startswith('test_')]
if invalid_tests:
raise Exception("Tests file names must starts with 'test_'."
" Invalid test names:\n %s"
% '\n '.join(invalid_tests))
self.logger.info("running with e10s: {}".format(self.e10s))
version_info = mozversion.get_version(binary=self.bin,
sources=self.sources,
dm_type=os.environ.get('DM_TRANS', 'adb'),
device_serial=self.device_serial,
adb_host=self.marionette.adb_host,
adb_port=self.marionette.adb_port)
self.logger.suite_start(self.tests,
version_info=version_info,
device_info=device_info)
for test in self.manifest_skipped_tests:
name = os.path.basename(test['path'])
self.logger.test_start(name)
self.logger.test_end(name,
'SKIP',
message=test['disabled'])
self.todo += 1
interrupted = None
try:
counter = self.repeat
while counter >=0:
round = self.repeat - counter
if round > 0:
self.logger.info('\nREPEAT %d\n-------' % round)
self.run_test_sets()
counter -= 1
except KeyboardInterrupt:
# in case of KeyboardInterrupt during the test execution
# we want to display current test results.
# so we keep the exception to raise it later.
interrupted = sys.exc_info()
try:
self._print_summary(tests)
except:
# raise only the exception if we were not interrupted
if not interrupted:
raise
finally:
# reraise previous interruption now
if interrupted:
raise interrupted[0], interrupted[1], interrupted[2]
def run(self, test):
dm_type = os.environ.get('DM_TRANS', 'adb')
if dm_type == 'adb':
self.b2g_pid = get_b2g_pid(get_dm(self.marionette))
return super(B2GMarionetteTextTestRunner, self).run(test)
def run_tests(self, tests):
self.reset_test_stats()
self.start_time = time.time()
need_external_ip = True
if not self.marionette:
self.start_marionette()
if self.emulator:
self.marionette.emulator.wait_for_homescreen(self.marionette)
# Retrieve capabilities for later use
if not self._capabilities:
self.capabilities
# if we're working against a desktop version, we usually don't need
# an external ip
if self._capabilities['device'] == "desktop":
need_external_ip = False
# Gaia sets server_root and that means we shouldn't spin up our own httpd
if not self.httpd:
if self.server_root is None or os.path.isdir(self.server_root):
self.logger.info("starting httpd")
self.start_httpd(need_external_ip)
self.marionette.baseurl = self.httpd.get_url()
self.logger.info("running httpd on %s" % self.marionette.baseurl)
else:
self.marionette.baseurl = self.server_root
self.logger.info("using remote content from %s" % self.marionette.baseurl)
for test in tests:
self.add_test(test)
version_info = mozversion.get_version(binary=self.bin,
sources=self.sources,
dm_type=os.environ.get('DM_TRANS', 'adb'),
device_serial=self.device_serial,
adb_host=self.marionette.adb_host,
adb_port=self.marionette.adb_port)
device_info = None
if self.capabilities['device'] != 'desktop' and self.capabilities['browserName'] == 'B2G':
dm = get_dm(self.marionette)
device_info = dm.getInfo()
self.logger.suite_start(self.tests,
version_info=version_info,
device_info=device_info)
for test in self.manifest_skipped_tests:
name = os.path.basename(test['path'])
self.logger.test_start(name)
self.logger.test_end(name,
'SKIP',
message=test['disabled'])
self.todo += 1
counter = self.repeat
while counter >=0:
round = self.repeat - counter
if round > 0:
self.logger.info('\nREPEAT %d\n-------' % round)
self.run_test_sets()
counter -= 1
self.logger.info('\nSUMMARY\n-------')
self.logger.info('passed: %d' % self.passed)
if self.unexpected_successes == 0:
self.logger.info('failed: %d' % self.failed)
else:
self.logger.info('failed: %d (unexpected sucesses: %d)' % (self.failed, self.unexpected_successes))
if self.skipped == 0:
self.logger.info('todo: %d' % self.todo)
else:
self.logger.info('todo: %d (skipped: %d)' % (self.todo, self.skipped))
if self.failed > 0:
self.logger.info('\nFAILED TESTS\n-------')
for failed_test in self.failures:
self.logger.info('%s' % failed_test[0])
try:
self.marionette.check_for_crash()
except:
traceback.print_exc()
self.end_time = time.time()
self.elapsedtime = self.end_time - self.start_time
if self.xml_output:
xml_dir = os.path.dirname(os.path.abspath(self.xml_output))
if not os.path.exists(xml_dir):
os.makedirs(xml_dir)
with open(self.xml_output, 'w') as f:
f.write(self.generate_xml(self.results))
if self.marionette.instance:
self.marionette.instance.close()
self.marionette.instance = None
self.marionette.cleanup()
for run_tests in self.mixin_run_tests:
run_tests(tests)
if self.shuffle:
self.logger.info("Using seed where seed is:%d" % self.shuffle_seed)
self.logger.suite_end()
def b2g_pre_run():
dm_type = os.environ.get("DM_TRANS", "adb")
if dm_type == "adb":
self.b2g_pid = get_b2g_pid(get_dm(self.marionette))
def run_tests(self, tests):
self.reset_test_stats()
self.start_time = time.time()
need_external_ip = True
if not self.marionette:
self.start_marionette()
if self.emulator:
self.marionette.emulator.wait_for_homescreen(self.marionette)
# Retrieve capabilities for later use
if not self._capabilities:
self.capabilities
# if we're working against a desktop version, we usually don't need
# an external ip
if self._capabilities['device'] == "desktop":
need_external_ip = False
# Gaia sets server_root and that means we shouldn't spin up our own httpd
if not self.httpd:
if self.server_root is None or os.path.isdir(self.server_root):
self.logger.info("starting httpd")
self.start_httpd(need_external_ip)
self.marionette.baseurl = self.httpd.get_url()
self.logger.info("running httpd on %s" % self.marionette.baseurl)
else:
self.marionette.baseurl = self.server_root
self.logger.info("using remote content from %s" % self.marionette.baseurl)
for test in tests:
self.add_test(test)
version_info = mozversion.get_version(binary=self.bin,
sources=self.sources,
dm_type=os.environ.get('DM_TRANS', 'adb'),
device_serial=self.device_serial,
adb_host=self.marionette.adb_host,
adb_port=self.marionette.adb_port)
device_info = None
if self.capabilities['device'] != 'desktop' and self.capabilities['browserName'] == 'B2G':
dm = get_dm(self.marionette)
device_info = dm.getInfo()
self.logger.suite_start(self.tests,
version_info=version_info,
device_info=device_info)
for test in self.manifest_skipped_tests:
name = os.path.basename(test['path'])
self.logger.test_start(name)
self.logger.test_end(name,
'SKIP',
message=test['disabled'])
self.todo += 1
counter = self.repeat
while counter >=0:
round = self.repeat - counter
if round > 0:
self.logger.info('\nREPEAT %d\n-------' % round)
self.run_test_sets()
counter -= 1
self.logger.info('\nSUMMARY\n-------')
self.logger.info('passed: %d' % self.passed)
if self.unexpected_successes == 0:
self.logger.info('failed: %d' % self.failed)
else:
self.logger.info('failed: %d (unexpected sucesses: %d)' % (self.failed, self.unexpected_successes))
if self.skipped == 0:
self.logger.info('todo: %d' % self.todo)
else:
self.logger.info('todo: %d (skipped: %d)' % (self.todo, self.skipped))
if self.failed > 0:
self.logger.info('\nFAILED TESTS\n-------')
for failed_test in self.failures:
self.logger.info('%s' % failed_test[0])
try:
self.marionette.check_for_crash()
except:
traceback.print_exc()
self.end_time = time.time()
self.elapsedtime = self.end_time - self.start_time
if self.xml_output:
xml_dir = os.path.dirname(os.path.abspath(self.xml_output))
if not os.path.exists(xml_dir):
os.makedirs(xml_dir)
with open(self.xml_output, 'w') as f:
f.write(self.generate_xml(self.results))
if self.marionette.instance:
self.marionette.instance.close()
self.marionette.instance = None
self.marionette.cleanup()
for run_tests in self.mixin_run_tests:
run_tests(tests)
if self.shuffle:
self.logger.info("Using seed where seed is:%d" % self.shuffle_seed)
self.logger.suite_end()
def run_tests(self, tests):
self.reset_test_stats()
self.start_time = time.time()
need_external_ip = True
if not self.marionette:
self.start_marionette()
if self.emulator:
self.marionette.emulator.wait_for_homescreen(self.marionette)
# Retrieve capabilities for later use
if not self._capabilities:
self.capabilities
# if we're working against a desktop version, we usually don't need
# an external ip
if self._capabilities['device'] == "desktop":
need_external_ip = False
# Gaia sets server_root and that means we shouldn't spin up our own httpd
if not self.httpd:
if self.server_root is None or os.path.isdir(self.server_root):
self.logger.info("starting httpd")
self.start_httpd(need_external_ip)
self.marionette.baseurl = self.httpd.get_url()
self.logger.info("running httpd on %s" %
self.marionette.baseurl)
else:
self.marionette.baseurl = self.server_root
self.logger.info("using remote content from %s" %
self.marionette.baseurl)
for test in tests:
self.add_test(test)
# ensure we have only tests files with names starting with 'test_'
invalid_tests = \
[t['filepath'] for t in self.tests
if not os.path.basename(t['filepath']).startswith('test_')]
if invalid_tests:
raise Exception("Tests file names must starts with 'test_'."
" Invalid test names:\n %s" %
'\n '.join(invalid_tests))
version_info = mozversion.get_version(
binary=self.bin,
sources=self.sources,
dm_type=os.environ.get('DM_TRANS', 'adb'),
device_serial=self.device_serial,
adb_host=self.marionette.adb_host,
adb_port=self.marionette.adb_port)
device_info = None
if self.capabilities['device'] != 'desktop' and self.capabilities[
'browserName'] == 'B2G':
dm = get_dm(self.marionette)
device_info = dm.getInfo()
self.logger.suite_start(self.tests,
version_info=version_info,
device_info=device_info)
for test in self.manifest_skipped_tests:
name = os.path.basename(test['path'])
self.logger.test_start(name)
self.logger.test_end(name, 'SKIP', message=test['disabled'])
self.todo += 1
interrupted = None
try:
counter = self.repeat
while counter >= 0:
round = self.repeat - counter
if round > 0:
self.logger.info('\nREPEAT %d\n-------' % round)
self.run_test_sets()
counter -= 1
except KeyboardInterrupt:
# in case of KeyboardInterrupt during the test execution
# we want to display current test results.
# so we keep the exception to raise it later.
interrupted = sys.exc_info()
try:
self._print_summary(tests)
except:
# raise only the exception if we were not interrupted
if not interrupted:
raise
finally:
# reraise previous interruption now
if interrupted:
raise interrupted[0], interrupted[1], interrupted[2]
