def ParseArgs(args=None):
defaults = parser.get_default_values()
for k, v in defaults.__dict__.items():
if k in self.__dict__ and self.__dict__[k] != None:
continue
self.__dict__[k] = v
ret = real_parse(args, self) # pylint: disable=E1121
if self.verbosity >= 2:
logging.getLogger().setLevel(logging.DEBUG)
elif self.verbosity:
logging.getLogger().setLevel(logging.INFO)
else:
logging.getLogger().setLevel(logging.WARNING)
if self.browser_executable and not self.browser_type:
self.browser_type = 'exact'
if self.browser_type == 'list':
try:
types = browser_finder.GetAllAvailableBrowserTypes(self)
except browser_finder.BrowserFinderException, ex:
sys.stderr.write('ERROR: ' + str(ex))
sys.exit(1)
sys.stdout.write('Available browsers:\n')
sys.stdout.write(' %s\n' % '\n '.join(types))
sys.exit(0)
def ParseArgs(args=None):
defaults = parser.get_default_values()
for k, v in defaults.__dict__.items():
if k in self.__dict__ and self.__dict__[k] != None:
continue
self.__dict__[k] = v
ret = real_parse(args, self) # pylint: disable=E1121
if self.verbosity >= 2:
logging.basicConfig(level=logging.DEBUG)
elif self.verbosity:
logging.basicConfig(level=logging.INFO)
else:
logging.basicConfig(level=logging.WARNING)
if ((self.profiler_tool and not self.profiler_dir)
or (not self.profiler_tool and self.profiler_dir)):
sys.stderr.write(
'Must use --profiler-tool and --profiler-dir together.\n')
sys.exit(1)
if self.browser_executable and not self.browser_type:
self.browser_type = 'exact'
if not self.browser_executable and not self.browser_type:
sys.stderr.write('Must provide --browser=<type>. ' +
'Use --browser=list for valid options.\n')
sys.exit(1)
if self.browser_type == 'list':
try:
types = browser_finder.GetAllAvailableBrowserTypes(self)
except browser_finder.BrowserFinderException, ex:
sys.stderr.write('ERROR: ' + str(ex))
sys.exit(1)
sys.stdout.write('Available browsers:\n')
sys.stdout.write(' %s\n' % '\n '.join(types))
sys.exit(0)
def GetAvailableBrowserTypes():
if telemetry == None:
sys.stderr.write(
'Could not find telemetry in $PYTHONPATH. No browsers will run\n')
return ''
from telemetry.core import browser_finder
finder_options = browser_options.BrowserFinderOptions()
return ','.join(
browser_finder.GetAllAvailableBrowserTypes(finder_options) + ['any'])
def _GetPossibleBrowser(self, finder_options):
"""Return a possible_browser with the given options."""
possible_browser = browser_finder.FindBrowser(finder_options)
if not possible_browser:
raise browser_finder_exceptions.BrowserFinderException(
'No browser found.\n\nAvailable browsers:\n%s\n' % '\n'.join(
browser_finder.GetAllAvailableBrowserTypes(finder_options))
)
finder_options.browser_options.browser_type = (
possible_browser.browser_type)
return possible_browser
def ParseArgs(args=None):
defaults = parser.get_default_values()
for k, v in defaults.__dict__.items():
if k in self.__dict__ and self.__dict__[k] != None:
continue
self.__dict__[k] = v
ret = real_parse(args, self) # pylint: disable=E1121
if self.verbosity >= 2:
logging.basicConfig(level=logging.DEBUG)
elif self.verbosity:
logging.basicConfig(level=logging.INFO)
else:
logging.basicConfig(level=logging.WARNING)
if self.browser_executable and not self.browser_type:
self.browser_type = 'exact'
if not self.browser_executable and not self.browser_type:
sys.stderr.write('Must provide --browser=<type>. ' +
'Use --browser=list for valid options.\n')
sys.exit(1)
if self.browser_type == 'list':
types = browser_finder.GetAllAvailableBrowserTypes(self)
sys.stderr.write('Available browsers:\n')
sys.stdout.write(' %s\n' % '\n '.join(types))
sys.exit(1)
if self.extra_browser_args_as_string: # pylint: disable=E1101
tmp = shlex.split(self.extra_browser_args_as_string) # pylint: disable=E1101
self.extra_browser_args.extend(tmp)
delattr(self, 'extra_browser_args_as_string')
if self.extra_wpr_args_as_string: # pylint: disable=E1101
tmp = shlex.split(self.extra_wpr_args_as_string) # pylint: disable=E1101
self.extra_wpr_args.extend(tmp)
delattr(self, 'extra_wpr_args_as_string')
if self.profile_type == 'default':
self.dont_override_profile = True
elif self.profile_type != 'clean':
self.profile_dir = profile_types.GetProfileDir(
self.profile_type)
delattr(self, 'profile_type')
return ret
def _GetPossibleBrowser(self, test, finder_options):
"""Return a possible_browser with the given options. """
possible_browser = browser_finder.FindBrowser(finder_options)
if not possible_browser:
raise browser_finder_exceptions.BrowserFinderException(
'No browser found.\n\nAvailable browsers:\n%s\n' %
'\n'.join(browser_finder.GetAllAvailableBrowserTypes(finder_options)))
finder_options.browser_options.browser_type = (
possible_browser.browser_type)
(enabled, msg) = decorators.IsEnabled(test, possible_browser)
if (not enabled and
not finder_options.run_disabled_tests):
logging.warning(msg)
logging.warning('You are trying to run a disabled test.')
logging.warning('Pass --also-run-disabled-tests to squelch this message.')
sys.exit(0)
if possible_browser.IsRemote():
possible_browser.RunRemote()
sys.exit(0)
return possible_browser
def Run(test, page_set, expectations, finder_options, results):
"""Runs a given test against a given page_set with the given options."""
test.ValidatePageSet(page_set)
# Create a possible_browser with the given options.
try:
possible_browser = browser_finder.FindBrowser(finder_options)
except browser_finder.BrowserTypeRequiredException, e:
sys.stderr.write(str(e) + '\n')
sys.exit(-1)
if not possible_browser:
sys.stderr.write(
'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)
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)
"""Runs a given test against a given page_set with the given options."""
results = results_options.PrepareResults(test, finder_options)
browser_options = finder_options.browser_options
test.ValidatePageSet(page_set)
# Create a possible_browser with the given options.
test.CustomizeBrowserOptions(finder_options)
try:
possible_browser = browser_finder.FindBrowser(finder_options)
except browser_finder.BrowserTypeRequiredException, e:
sys.stderr.write(str(e) + '\n')
sys.exit(1)
if not possible_browser:
sys.stderr.write('No browser found. Available browsers:\n' + '\n'.join(
browser_finder.GetAllAvailableBrowserTypes(finder_options)) + '\n')
sys.exit(1)
browser_options.browser_type = possible_browser.browser_type
# Reorder page set based on options.
pages = _ShuffleAndFilterPageSet(page_set, finder_options)
if (not finder_options.allow_live_sites
and browser_options.wpr_mode != wpr_modes.WPR_RECORD):
pages = _CheckArchives(page_set, pages, results)
# Verify credentials path.
credentials_path = None
if page_set.credentials_path:
credentials_path = os.path.join(os.path.dirname(page_set.file_path),
def Main(args):
options = browser_options.BrowserOptions()
parser = options.CreateParser(
'rendering_microbenchmark_test.py <sitelist>')
# TODO(nduca): Add test specific options here, if any.
options, args = parser.parse_args(args)
if len(args) != 1:
parser.print_usage()
return 255
urls = []
with open(args[0], 'r') as f:
for url in f.readlines():
url = url.strip()
if not re.match('(.+)://', url):
url = 'http://%s' % url
urls.append(url)
options.extra_browser_args.append('--enable-gpu-benchmarking')
browser_to_create = browser_finder.FindBrowser(options)
if not browser_to_create:
sys.stderr.write('No browser found! Supported types: %s' %
browser_finder.GetAllAvailableBrowserTypes(options))
return 255
with browser_to_create.Create() as b:
tab = b.tabs[0]
# Check browser for benchmark API. Can only be done on non-chrome URLs.
tab.Navigate('http://www.google.com')
import time
time.sleep(2)
tab.WaitForDocumentReadyStateToBeComplete()
if tab.EvaluateJavaScript(
'window.chrome.gpuBenchmarking === undefined'):
print 'Browser does not support gpu benchmarks API.'
return 255
if tab.EvaluateJavaScript(
'window.chrome.gpuBenchmarking.runRenderingBenchmarks === undefined'
):
print 'Browser does not support rendering benchmarks API.'
return 255
# Run the test. :)
first_line = []
def DumpResults(url, results):
if len(first_line) == 0:
cols = ['url']
for r in results:
cols.append(r['benchmark'])
print ','.join(cols)
first_line.append(0)
cols = [url]
for r in results:
cols.append(str(r['result']))
print ','.join(cols)
for u in urls:
tab.Navigate(u)
tab.WaitForDocumentReadyStateToBeInteractiveOrBetter()
results = tab.EvaluateJavaScript(
'window.chrome.gpuBenchmarking.runRenderingBenchmarks();')
DumpResults(url, results)
return 0
