# Use of this source code is governed by a BSD-style license that can be
# found in the LICENSE file.
-import collections
import logging
import optparse
import os
self._append_to_existing_wpr = False
self._last_archive_path = None
self._first_browser = True
- self.first_page = collections.defaultdict(lambda: True)
self.profiler_dir = None
def StartBrowserIfNeeded(self, test, page_set, page, possible_browser,
# Create a browser.
if not self.browser:
test.CustomizeBrowserOptionsForSinglePage(page, finder_options)
- self.browser = possible_browser.Create()
- self.browser.credentials.credentials_path = credentials_path
-
- # Set up WPR path on the new browser.
- self.browser.SetReplayArchivePath(archive_path,
+ possible_browser.SetReplayArchivePath(archive_path,
self._append_to_existing_wpr,
page_set.make_javascript_deterministic)
+ possible_browser.SetCredentialsPath(credentials_path)
self._last_archive_path = page.archive_path
- test.WillStartBrowser(self.browser)
- self.browser.Start()
+ test.WillStartBrowser(possible_browser.platform)
+ self.browser = possible_browser.Create()
test.DidStartBrowser(self.browser)
if self._first_browser:
logging.info(' %s', workaround)
else:
logging.info('No GPU devices')
+ else:
+ logging.warning('System info not supported')
else:
# Set up WPR path if it changed.
if page.archive_path and self._last_archive_path != page.archive_path:
finder_options.pageset_repeat != 1)
if is_repeating:
output_file = util.GetSequentialFileName(output_file)
- self.browser.StartProfiling(finder_options.profiler, output_file)
+ self.browser.platform.profiling_controller.Start(
+ finder_options.profiler, output_file)
def StopProfiling(self):
if self.browser:
- self.browser.StopProfiling()
+ self.browser.platform.profiling_controller.Stop()
class PageState(object):
def PreparePage(self, test=None):
if self.page.is_file:
- server_started = self.tab.browser.SetHTTPServerDirectories(
- self.page.page_set.serving_dirs | set([self.page.serving_dir]))
- if server_started and test:
- test.DidStartHTTPServer(self.tab)
+ self.tab.browser.SetHTTPServerDirectories(
+ self.page.page_set.serving_dirs | set([self.page.serving_dir]))
if self.page.credentials:
if not self.tab.browser.credentials.LoginNeeded(
'before proceeding with the next page in the pageset.')
group.add_option('--pageset-repeat', default=1, type='int',
help='Number of times to repeat the entire pageset.')
+ group.add_option('--max-failures', default=None, type='int',
+ help='Maximum number of test failures before aborting '
+ 'the run. Defaults to the number specified by the '
+ 'PageTest.')
parser.add_option_group(group)
# WPR options
max_attempts = test.attempts
attempt_num = 0
while attempt_num < max_attempts:
- attempt_num = attempt_num + 1
+ attempt_num += 1
try:
results.WillAttemptPageRun(attempt_num, max_attempts)
logging.warning(str(e))
-def _UpdatePageSetArchivesIfChanged(page_set):
+@decorators.Cache
+def _UpdateCredentials(page_set):
# Attempt to download the credentials file.
if page_set.credentials_path:
try:
logging.warning('Cannot retrieve credential file %s due to cloud storage '
'error %s', page_set.credentials_path, str(e))
+
+@decorators.Cache
+def _UpdatePageSetArchivesIfChanged(page_set):
# Scan every serving directory for .sha1 files
# and download them from Cloud Storage. Assume all data is public.
all_serving_dirs = page_set.serving_dirs.copy()
sys.exit(-1)
if not possible_browser:
sys.stderr.write(
- 'No browser found. Available browsers:\n' +
- '\n'.join(browser_finder.GetAllAvailableBrowserTypes(finder_options)) +
- '\n')
+ 'No browser found. Available browsers:\n%s\n' %
+ '\n'.join(browser_finder.GetAllAvailableBrowserTypes(finder_options)))
sys.exit(-1)
browser_options = possible_browser.finder_options.browser_options
browser_options.browser_type = possible_browser.browser_type
test.CustomizeBrowserOptions(browser_options)
- should_run = decorators.IsEnabled(test, possible_browser)
-
- should_run = should_run or finder_options.run_disabled_tests
-
- if not should_run:
+ if (not decorators.IsEnabled(test, possible_browser) and
+ not finder_options.run_disabled_tests):
logging.warning('You are trying to run a disabled test.')
logging.warning('Pass --also-run-disabled-tests to squelch this message.')
return
+ if possible_browser.IsRemote():
+ possible_browser.RunRemote()
+ sys.exit(0)
+
# Reorder page set based on options.
pages = _ShuffleAndFilterPageSet(page_set, finder_options)
- if (not finder_options.use_live_sites and
- browser_options.wpr_mode != wpr_modes.WPR_RECORD):
- _UpdatePageSetArchivesIfChanged(page_set)
- pages = _CheckArchives(page_set, pages, results)
+ if not finder_options.use_live_sites:
+ _UpdateCredentials(page_set)
+ if browser_options.wpr_mode != wpr_modes.WPR_RECORD:
+ _UpdatePageSetArchivesIfChanged(page_set)
+ pages = _CheckArchives(page_set, pages, results)
# Verify credentials path.
credentials_path = None
return
state = _RunState()
- # TODO(dtu): Move results creation and results_for_current_run into RunState.
+ pages_with_discarded_first_result = set()
+ max_failures = finder_options.max_failures # command-line gets priority
+ if max_failures is None:
+ max_failures = test.max_failures # may be None
try:
test.WillRunTest(finder_options)
- for _ in xrange(0, finder_options.pageset_repeat):
+ for _ in xrange(finder_options.pageset_repeat):
for page in pages:
if test.IsExiting():
break
-
- test.WillRunPageRepeats(page)
- for _ in xrange(0, finder_options.page_repeat):
+ for _ in xrange(finder_options.page_repeat):
results.WillRunPage(page)
try:
_PrepareAndRunPage(
test, page_set, expectations, finder_options, browser_options,
page, credentials_path, possible_browser, results, state)
finally:
- discard_run = False
- if state.first_page[page]:
- state.first_page[page] = False
- if test.discard_first_result:
- discard_run = True
+ discard_run = (test.discard_first_result and
+ page not in pages_with_discarded_first_result)
+ if discard_run:
+ pages_with_discarded_first_result.add(page)
results.DidRunPage(page, discard_run=discard_run)
- test.DidRunPageRepeats(page)
- if (not test.max_failures is None and
- len(results.failures) > test.max_failures):
+ if max_failures is not None and len(results.failures) > max_failures:
logging.error('Too many failures. Aborting.')
test.RequestExit()
-
finally:
test.DidRunTest(state.browser, results)
state.StopBrowser()
- return
-
def _ShuffleAndFilterPageSet(page_set, finder_options):
if finder_options.pageset_shuffle_order_file:
return page_set.ReorderPageSet(finder_options.pageset_shuffle_order_file)
-
pages = [page for page in page_set.pages[:]
if not page.disabled and page_filter.PageFilter.IsSelected(page)]
-
if finder_options.pageset_shuffle:
- random.Random().shuffle(pages)
-
+ random.shuffle(pages)
return pages
def _CheckArchives(page_set, pages, results):
"""Returns a subset of pages that are local or have WPR archives.
- Logs warnings if any are missing."""
- page_set_has_live_sites = False
- for page in pages:
- if not page.is_local:
- page_set_has_live_sites = True
- break
-
- # Potential problems with the entire page set.
- if page_set_has_live_sites:
+ Logs warnings if any are missing.
+ """
+ # Warn of any problems with the entire page set.
+ if any(not p.is_local for p in pages):
if not page_set.archive_data_file:
logging.warning('The page set is missing an "archive_data_file" '
'property. Skipping any live sites. To include them, '
'.gclient using http://goto/read-src-internal, '
'or create a new archive using record_wpr.')
- # Potential problems with individual pages.
+ # Warn of any problems with individual pages and return valid pages.
pages_missing_archive_path = []
pages_missing_archive_data = []
-
+ valid_pages = []
for page in pages:
- if page.is_local:
- continue
-
- if not page.archive_path:
+ if not page.is_local and not page.archive_path:
pages_missing_archive_path.append(page)
- elif not os.path.isfile(page.archive_path):
+ elif not page.is_local and not os.path.isfile(page.archive_path):
pages_missing_archive_data.append(page)
-
+ else:
+ valid_pages.append(page)
if pages_missing_archive_path:
logging.warning('The page set archives for some pages do not exist. '
'Skipping those pages. To fix this, record those pages '
'Skipping those pages. To fix this, record those pages '
'using record_wpr. To ignore this warning and run '
'against live sites, pass the flag --use-live-sites.')
-
for page in pages_missing_archive_path + pages_missing_archive_data:
results.WillRunPage(page)
results.AddValue(failure.FailureValue.FromMessage(
page, 'Page set archive doesn\'t exist.'))
results.DidRunPage(page)
-
- return [page for page in pages if page not in
- pages_missing_archive_path + pages_missing_archive_data]
+ return valid_pages
def _RunPage(test, page, state, expectation, results):
results.AddValue(skip.SkipValue(page, 'Skipped by test expectations'))
return
- logging.info('Running %s', page.url)
-
page_state = PageState(page, test.TabForPage(page, state.browser))
def ProcessError():
projects / platform / framework / web / crosswalk.git / blobdiff