def testGetRequiredLibrariesForVTuneProfile(self):
vtune_db_output = os.path.join(
util.GetUnittestDataDir(), 'sample_vtune_db_output')
with open(vtune_db_output, 'rb') as f:
vtune_db_output = pickle.load(f)
mock_cursor = simple_mock.MockObject()
mock_cursor.ExpectCall(
'execute').WithArgs(simple_mock.DONT_CARE).WillReturn(vtune_db_output)
mock_conn = simple_mock.MockObject()
mock_conn.ExpectCall('cursor').WillReturn(mock_cursor)
mock_conn.ExpectCall('close')
mock_sqlite3 = simple_mock.MockObject()
mock_sqlite3.ExpectCall(
'connect').WithArgs(simple_mock.DONT_CARE).WillReturn(mock_conn)
real_sqlite3 = android_profiling_helper.sqlite3
android_profiling_helper.sqlite3 = mock_sqlite3
try:
libs = android_profiling_helper.GetRequiredLibrariesForVTuneProfile('foo')
self.assertEqual(libs, set([
'/data/app-lib/com.google.android.apps.chrome-1/libchrome.2019.0.so',
'/system/lib/libdvm.so',
'/system/lib/libc.so',
'/system/lib/libm.so']))
finally:
android_profiling_helper.sqlite3 = real_sqlite3
def testGetRequiredLibrariesForPerfProfile(self):
perf_output = os.path.join(
util.GetUnittestDataDir(), 'sample_perf_report_output.txt')
with open(perf_output) as f:
perf_output = f.read()
mock_popen = simple_mock.MockObject()
mock_popen.ExpectCall('communicate').WillReturn([None, perf_output])
mock_subprocess = simple_mock.MockObject()
mock_subprocess.ExpectCall(
'Popen').WithArgs(simple_mock.DONT_CARE).WillReturn(mock_popen)
mock_subprocess.SetAttribute('PIPE', simple_mock.MockObject())
real_subprocess = android_profiling_helper.subprocess
android_profiling_helper.subprocess = mock_subprocess
try:
libs = android_profiling_helper.GetRequiredLibrariesForPerfProfile('foo')
self.assertEqual(libs, set([
'/data/app-lib/com.google.android.apps.chrome-2/libchrome.2016.0.so',
'/system/lib/libart.so',
'/system/lib/libc.so',
'/system/lib/libm.so']))
finally:
android_profiling_helper.subprocess = real_subprocess
def testSubObjectMismatch(self):
mock = simple_mock.MockObject()
mock.bar = simple_mock.MockObject(mock)
mock.ExpectCall('foo').WithArgs(_, 4)
mock.bar.ExpectCall('baz')
self.assertRaises(Exception, lambda: mock.bar.baz()) # pylint: disable=W0108
def testSubObject(self):
mock = simple_mock.MockObject()
mock.bar = simple_mock.MockObject(mock)
mock.ExpectCall('foo').WithArgs(_, 4)
mock.bar.ExpectCall('baz')
mock.foo(0, 4)
mock.bar.baz()
def _ExpectProcesses(self, args):
mock_subprocess = simple_mock.MockObject()
mock_subprocess.SetAttribute('PIPE', simple_mock.MockObject())
for arg in args:
mock_popen = simple_mock.MockObject()
mock_popen.ExpectCall('communicate').WillReturn(arg[1][1:])
mock_popen.ExpectCall('poll').WillReturn(arg[1][0])
mock_subprocess.ExpectCall(
'Popen').WithArgs(arg[0]).WillReturn(mock_popen)
trybot_browser_finder.subprocess = mock_subprocess
def testSysfsReadFailed(self):
mock_power_monitor = simple_mock.MockObject()
mock_power_monitor.ExpectCall('CanMonitorPower').WillReturn(False)
mock_adb = simple_mock.MockObject()
mock_adb.ExpectCall('GetFileContents', _).WillReturn([])
mock_device_utils = simple_mock.MockObject()
setattr(mock_device_utils, 'old_interface', mock_adb)
monitor = android_temperature_monitor.AndroidTemperatureMonitor(
mock_power_monitor, mock_device_utils)
self.assertTrue(monitor.CanMonitorPower())
monitor.StartMonitoringPower(None)
measurements = monitor.StopMonitoringPower()
self.assertTrue('identifier' in measurements)
self.assertTrue('component_utilization' not in measurements)
def _LoginUsingMock(self, backend, login_page_url, email_element_id,
password_element_id): # pylint: disable=R0201
tab = simple_mock.MockObject()
config = {'username': '******', 'password': '******'}
tab.ExpectCall('Navigate', login_page_url)
tab.ExpectCall('EvaluateJavaScript', _).WillReturn(False)
tab.ExpectCall('EvaluateJavaScript', _).WillReturn(True)
tab.ExpectCall('EvaluateJavaScript', _).WillReturn(False)
tab.ExpectCall('WaitForDocumentReadyStateToBeInteractiveOrBetter')
def VerifyEmail(js):
assert email_element_id in js
assert 'blah' in js
tab.ExpectCall('ExecuteJavaScript', _).WhenCalled(VerifyEmail)
def VerifyPw(js):
assert password_element_id in js
assert 'largh' in js
tab.ExpectCall('ExecuteJavaScript', _).WhenCalled(VerifyPw)
def VerifySubmit(js):
assert '.submit' in js
tab.ExpectCall('ExecuteJavaScript', _).WhenCalled(VerifySubmit)
# Checking for form still up.
tab.ExpectCall('EvaluateJavaScript', _).WillReturn(False)
backend.LoginNeeded(tab, config)
def SetUpCycler(self, args, setup_memory_module=False):
cycler = page_cycler.PageCycler()
options = browser_options.BrowserFinderOptions()
options.browser_options.platform = FakePlatform()
parser = options.CreateParser()
page_runner.AddCommandLineArgs(parser)
cycler.AddCommandLineArgs(parser)
cycler.SetArgumentDefaults(parser)
parser.parse_args(args)
page_runner.ProcessCommandLineArgs(parser, options)
cycler.ProcessCommandLineArgs(parser, options)
cycler.CustomizeBrowserOptions(options.browser_options)
if setup_memory_module:
# Mock out memory metrics; the real ones require a real browser.
mock_memory_metric = MockMemoryMetric()
mock_memory_module = simple_mock.MockObject()
mock_memory_module.ExpectCall('MemoryMetric').WithArgs(
simple_mock.DONT_CARE).WillReturn(mock_memory_metric)
real_memory_module = page_cycler.memory
try:
page_cycler.memory = mock_memory_module
browser = FakeBrowser()
cycler.WillStartBrowser(options.browser_options.platform)
cycler.DidStartBrowser(browser)
finally:
page_cycler.memory = real_memory_module
return cycler
def testCacheHandled(self):
cycler = self.setupCycler(
['--pageset-repeat=5', '--cold-load-percent=50'])
# Mock out memory metrics; the real ones require a real browser.
mock_memory_metric = MockMemoryMetric()
mock_memory_module = simple_mock.MockObject()
mock_memory_module.ExpectCall('MemoryMetric').WithArgs(
simple_mock.DONT_CARE).WillReturn(mock_memory_metric)
real_memory_module = page_cycler.memory
try:
page_cycler.memory = mock_memory_module
cycler.DidStartBrowser(None)
finally:
page_cycler.memory = real_memory_module
class FakePage(object):
def __init__(self, url):
self.url = url
class FakeTab(object):
def __init__(self):
self.clear_cache_calls = 0
def ClearCache(self):
self.clear_cache_calls += 1
def EvaluateJavaScript(self, _):
return 1
def WaitForJavaScriptExpression(self, _, __):
pass
url_name = "http://fakepage.com"
page = FakePage(url_name)
tab = FakeTab()
results = page_measurement_results.PageMeasurementResults()
for i in range(5):
cycler.WillNavigateToPage(page, tab)
self.assertEqual(
max(0, i - 2), tab.clear_cache_calls,
"Iteration %d tab.clear_cache_calls %d" %
(i, tab.clear_cache_calls))
num_results = len(results.page_results)
results.WillMeasurePage(page)
cycler.MeasurePage(page, tab, results)
results.DidMeasurePage()
self.assertEqual(num_results + 1, len(results.page_results))
result = results[-1]
self.assertEqual(result.page, page)
self.assertEqual(1, len(result.values))
self.assertEqual(result.values[0].trace_name, 'page_load_time')
self.assertEqual(result.values[0].units, 'ms')
self.assertEqual(result.values[0].chart_name,
'warm_times' if i < 3 else 'cold_times')
cycler.DidNavigateToPage(page, tab)
def test_find_all_browser_types_non_trybot_browser(self):
finder_options = browser_options.BrowserFinderOptions(
browser_type='release')
trybot_browser_finder.urllib2 = simple_mock.MockObject()
self.assertEquals(
[],
# pylint: disable=W0212
sorted(trybot_browser_finder.FindAllBrowserTypes(finder_options)))
def testNoAttmptToMonitorIfIncapable(self):
mock_power_monitor = simple_mock.MockObject()
mock_power_monitor.ExpectCall('CanMonitorPower').WillReturn(False)
temperature_monitor = TemperatureMonitorForTesting(mock_power_monitor, 42.0)
self.assertTrue(temperature_monitor.CanMonitorPower())
temperature_monitor.StartMonitoringPower(None)
power_results = temperature_monitor.StopMonitoringPower()
self.assertTrue(
temperature_monitor.PowerMeasurementsConsistent(power_results))
def testOnCall(self):
mock = simple_mock.MockObject()
handler_called = []
def Handler(arg0):
assert arg0 == 7
handler_called.append(True)
mock.ExpectCall('baz', 7).WhenCalled(Handler)
mock.baz(7)
self.assertTrue(len(handler_called) > 0)
def _LoginUsingMock(self, backend, login_page_url, email_element_id,
password_element_id, form_element_id,
already_logged_in_js): # pylint: disable=R0201
tab = simple_mock.MockObject()
ar = simple_mock.MockObject()
config = {'username': '******', 'password': '******'}
tab.ExpectCall('Navigate', login_page_url)
tab.ExpectCall('EvaluateJavaScript',
already_logged_in_js).WillReturn(False)
tab.ExpectCall('WaitForDocumentReadyStateToBeInteractiveOrBetter')
ar.ExpectCall(
'WaitForJavaScriptCondition',
'(document.querySelector("#%s") !== null) || (%s)' %
(form_element_id, already_logged_in_js), 60)
ar.ExpectCall('WaitForNavigate')
def VerifyEmail(js):
assert email_element_id in js
assert 'blah' in js
tab.ExpectCall('ExecuteJavaScript', _).WhenCalled(VerifyEmail)
def VerifyPw(js):
assert password_element_id in js
assert 'largh' in js
tab.ExpectCall('ExecuteJavaScript', _).WhenCalled(VerifyPw)
def VerifySubmit(js):
assert '.submit' in js or '.click' in js
tab.ExpectCall('ExecuteJavaScript', _).WhenCalled(VerifySubmit)
# Checking for form still up.
tab.ExpectCall('EvaluateJavaScript', _).WillReturn(False)
backend.LoginNeeded(tab, ar, config)
def testPerfProfiler(self):
options = options_for_unittests.GetCopy()
if not perf_profiler.PerfProfiler.is_supported(options.browser_type):
logging.warning('PerfProfiler is not supported. Skipping test')
return
profile_file = os.path.join(util.GetUnittestDataDir(),
'perf_report_output.txt')
perf_report_output = open(profile_file, 'r').read()
mock_popen = simple_mock.MockObject()
mock_popen.ExpectCall('communicate').WillReturn([perf_report_output])
mock_subprocess = simple_mock.MockObject()
mock_subprocess.ExpectCall('Popen').WithArgs(
simple_mock.DONT_CARE).WillReturn(mock_popen)
setattr(mock_subprocess, 'PIPE', simple_mock.MockObject())
real_subprocess = perf_profiler.subprocess
perf_profiler.subprocess = mock_subprocess
try:
self.assertEqual(
perf_profiler.PerfProfiler.GetTopSamples(
'linux', profile_file, 10),
{
'v8::internal::StaticMarkingVisitor::MarkMapContents':
63615201,
'v8::internal::RelocIterator::next': 38271931,
'v8::internal::LAllocator::MeetConstraintsBetween':
42913933,
'v8::internal::FlexibleBodyVisitor::Visit': 31909537,
'v8::internal::LiveRange::CreateAssignedOperand': 42913933,
'void v8::internal::RelocInfo::Visit': 96878864,
'WebCore::HTMLTokenizer::nextToken': 48240439,
'v8::internal::Scanner::ScanIdentifierOrKeyword': 46054550,
'sk_memset32_SSE2': 45121317,
'v8::internal::HeapObject::Size': 39786862
})
finally:
perf_profiler.subprocess = real_subprocess
def test_find_all_browser_types_list(self):
finder_options = browser_options.BrowserFinderOptions(browser_type='list')
trybot_browser_finder.urllib2 = simple_mock.MockObject()
trybot_browser_finder.urllib2.ExpectCall('urlopen').WithArgs(
'http://build.chromium.org/p/tryserver.chromium.perf/json').WillReturn(
StringIO.StringIO(json.dumps({'builders': {
'android_nexus4_perf_bisect': 'stuff',
'mac_10_9_perf_bisect': 'otherstuff',
'win_perf_bisect_builder': 'not a trybot',
}})))
self.assertEquals(
['trybot-android-nexus4', 'trybot-mac-10-9'],
# pylint: disable=W0212
sorted(trybot_browser_finder.FindAllBrowserTypes(finder_options)))
def testVTuneProfilerIsSupported(self):
options = options_for_unittests.GetCopy()
mock_subprocess = simple_mock.MockObject()
mock_subprocess.ExpectCall(
'Popen').WithArgs(simple_mock.DONT_CARE).WillReturn(MockPopen(0))
mock_subprocess.SetAttribute('PIPE', simple_mock.MockObject())
mock_subprocess.SetAttribute('STDOUT', simple_mock.MockObject())
real_subprocess = vtune_profiler.subprocess
vtune_profiler.subprocess = mock_subprocess
if options.browser_type.startswith('android'):
# On Android we're querying if 'su' is available.
mock_subprocess.ExpectCall('Popen').WithArgs(
simple_mock.DONT_CARE).WillReturn(MockPopen(0, 'su', None))
try:
self.assertTrue(
vtune_profiler.VTuneProfiler.is_supported(options.browser_type) or
sys.platform != 'linux2' or
options.browser_type.startswith('cros'))
finally:
vtune_profiler.subprocess = real_subprocess
def testPowerMonitoringResultsWereUpdated(self):
mock_power_monitor = simple_mock.MockObject()
mock_power_monitor.ExpectCall('CanMonitorPower').WillReturn(True)
fake_measurement = {'identifier' : '123'}
mock_power_monitor.ExpectCall('StartMonitoringPower', _)
mock_power_monitor.ExpectCall('StopMonitoringPower').WillReturn(
fake_measurement)
temperature_monitor = TemperatureMonitorForTesting(mock_power_monitor, 24.0)
self.assertTrue(temperature_monitor.CanMonitorPower())
temperature_monitor.StartMonitoringPower(None)
measurements = temperature_monitor.StopMonitoringPower()
self.assertTrue(
temperature_monitor.PowerMeasurementsConsistent(measurements))
self.assertEqual('123', measurements['identifier'])
def setupCycler(self, args, setup_memory_module=False):
cycler = page_cycler.PageCycler()
options = browser_options.BrowserFinderOptions()
parser = options.CreateParser()
cycler.AddCommandLineOptions(parser)
parser.parse_args(args)
cycler.CustomizeBrowserOptions(options)
if setup_memory_module:
# Mock out memory metrics; the real ones require a real browser.
mock_memory_metric = MockMemoryMetric()
mock_memory_module = simple_mock.MockObject()
mock_memory_module.ExpectCall('MemoryMetric').WithArgs(
simple_mock.DONT_CARE).WillReturn(mock_memory_metric)
real_memory_module = page_cycler.memory
try:
page_cycler.memory = mock_memory_module
cycler.DidStartBrowser(None)
finally:
page_cycler.memory = real_memory_module
return cycler
def testArgsDontCare(self):
mock = simple_mock.MockObject()
mock.ExpectCall('foo').WithArgs(_, 4)
mock.foo(4, 4)
def __init__(self): self.PIPE = simple_mock.MockObject() self.STDOUT = simple_mock.MockObject() self._num_collect_calls = 0 self._num_stop_calls = 0
def testBasic(self):
mock = simple_mock.MockObject()
mock.ExpectCall('foo')
mock.foo()
def testReturn(self):
mock = simple_mock.MockObject()
mock.ExpectCall('foo').WillReturn(7)
ret = mock.foo()
self.assertEquals(ret, 7)
def testArgs(self):
mock = simple_mock.MockObject()
mock.ExpectCall('foo').WithArgs(3, 4)
mock.foo(3, 4)
def testArgs2(self):
mock = simple_mock.MockObject()
mock.ExpectCall('foo', 3, 4)
mock.foo(3, 4)
def testArgsMismatch(self):
mock = simple_mock.MockObject()
mock.ExpectCall('foo').WithArgs(3, 4)
self.assertRaises(Exception, lambda: mock.foo(4, 4))
