def _test_plugins_blocked_for_urls(self, policy_value):
"""Verify CrOS enforces the PluginsBlockedForUrls policy.
When PluginsBlockedForUrls is undefined, plugins shall be run on
all pages. When PluginsBlockedForUrls contains one or more URLs,
plugins shall be run on all pages except those whose domain matches
any of the listed URLs.
@param policy_value: policy value expected.
"""
# Set a low audio volume to avoid annoying people during tests.
audio_helper.set_volume_levels(10, 100)
# Kill any running Shockwave Flash processes.
self._stop_flash_if_running()
# Open page with an embedded flash file.
tab = self.navigate_to_url(self.TEST_URL)
self._wait_for_page_ready(tab)
# Check if Shockwave Flash process is running.
plugin_is_running = self._is_flash_running()
logging.info('plugin_is_running: %r', plugin_is_running)
# String |WEB_HOST| will be found in string |policy_value| for
# cases that expect the plugin to be run.
if policy_value is not None and self.WEB_HOST in policy_value:
if plugin_is_running:
raise error.TestFail('Plugins should not run.')
else:
if not plugin_is_running:
raise error.TestFail('Plugins should run.')
tab.Close()
def run_once(self):
"""Entry point of this test"""
audio_helper.set_volume_levels(self._volume_level, self._capture_gain)
success = False
# Run loopback latency check once, which takes at most 1 sec to
# complete and parse the latency values measured in loopback path
# and reported by system. Assert the difference is within
# acceptable range.
result = audio_helper.loopback_latency_check(n=_NOISE_THRESHOLD)
if result:
diff = abs(result[0] - result[1])
logging.info(
'Tested latency with threshold %d.\nMeasured %d,'
'reported %d uS, diff %d us\n', _NOISE_THRESHOLD, result[0],
result[1], diff)
# Difference between measured and reported latency should
# within _LATENCY_DIFF_LIMIT_US.
if diff < _LATENCY_DIFF_LIMIT_US:
success = True
else:
# Raise error if audio is not detected at all in the loopback path.
raise error.TestError('Audio not detected at threshold %d' %
_NOISE_THRESHOLD)
if not success:
# Test fails when latency difference is greater then the limit.
raise error.TestFail(
'Latency difference too much, diff limit '
'%d us, measured %d us, reported %d us' %
(_LATENCY_DIFF_LIMIT_US, result[0], result[1]))
def run_once(self, run_time_sec=60):
if run_time_sec < 10:
raise error.TestFail('Must run for at least 10 seconds')
with chrome.Chrome():
# Audio loop time should be significantly shorter than
# |run_time_sec| time, so that the total playback time doesn't
# exceed it by much.
audio_loop_time_sec = min(10, run_time_sec / 10 + 0.5)
# Set a low audio volume to avoid annoying people during tests.
audio_helper.set_volume_levels(10, 100)
# Start playing audio file.
self._enable_audio_playback = True
thread = threading.Thread(target=self._play_audio,
args=(audio_loop_time_sec, ))
thread.start()
# Restart powerd with timeouts for quick idle events.
gap_ms = run_time_sec * 1000 / 4
dim_ms = min(10000, gap_ms)
off_ms = min(20000, gap_ms * 2)
suspend_ms = min(30000, gap_ms * 3)
prefs = {
'disable_idle_suspend': 0,
'ignore_external_policy': 1,
'plugged_dim_ms': dim_ms,
'plugged_off_ms': off_ms,
'plugged_suspend_ms': suspend_ms,
'unplugged_dim_ms': dim_ms,
'unplugged_off_ms': off_ms,
'unplugged_suspend_ms': suspend_ms
}
self._pref_change = power_utils.PowerPrefChanger(prefs)
# Set an alarm to wake up the system in case the audio detector
# fails and the system suspends.
alarm_time = rtc.get_seconds() + run_time_sec
rtc.set_wake_alarm(alarm_time)
time.sleep(run_time_sec)
# Stop powerd to avoid suspending when the audio stops.
utils.system_output('stop powerd')
# Stop audio and wait for the audio thread to terminate.
self._enable_audio_playback = False
thread.join(timeout=(audio_loop_time_sec * 2))
if thread.is_alive():
logging.error('Audio thread did not terminate at end of test.')
# Check powerd's log to make sure that no suspend took place.
powerd_log_path = '/var/log/power_manager/powerd.LATEST'
log = open(powerd_log_path, 'r').read()
if log.find('Starting suspend') != -1:
err_str = 'System suspended while audio was playing.'
raise error.TestFail(err_str)
def initialize(self, pdash_note='', seconds_period=5):
"""Create and mount ram disk to download video."""
super(power_VideoPlayback,
self).initialize(seconds_period=seconds_period,
pdash_note=pdash_note)
utils.run('mkdir -p %s' % self._RAMDISK)
# Don't throw an exception on errors.
result = utils.run('mount -t ramfs -o context=u:object_r:tmpfs:s0 '
'ramfs %s' % self._RAMDISK,
ignore_status=True)
if result.exit_status:
logging.info('cannot mount ramfs with context=u:object_r:tmpfs:s0,'
' trying plain mount')
# Try again without selinux options. This time fail on error.
utils.run('mount -t ramfs ramfs %s' % self._RAMDISK)
audio_helper.set_volume_levels(10, 10)
def run_once(self, run_time_sec=60):
if run_time_sec < 10:
raise error.TestFail('Must run for at least 10 seconds')
with chrome.Chrome():
# Audio loop time should be significantly shorter than
# |run_time_sec| time, so that the total playback time doesn't
# exceed it by much.
audio_loop_time_sec = min(10, run_time_sec / 10 + 0.5)
# Set a low audio volume to avoid annoying people during tests.
audio_helper.set_volume_levels(10, 100)
# Start a subprocess that uses dbus-monitor to listen for suspend
# announcements from powerd and writes the output to a log.
dbus_log_fd, dbus_log_name = tempfile.mkstemp()
os.unlink(dbus_log_name)
dbus_log = os.fdopen(dbus_log_fd)
dbus_proc = subprocess.Popen(
'dbus-monitor --monitor --system ' +
'"type=\'signal\',interface=\'org.chromium.PowerManager\',' +
'member=\'SuspendImminent\'"',
shell=True,
stdout=dbus_log)
# Start playing audio file.
self._enable_audio_playback = True
thread = threading.Thread(target=self._play_audio,
args=(audio_loop_time_sec, ))
thread.start()
# Restart powerd with timeouts for quick idle events.
gap_ms = run_time_sec * 1000 / 4
dim_ms = min(10000, gap_ms)
off_ms = min(20000, gap_ms * 2)
suspend_ms = min(30000, gap_ms * 3)
prefs = {
'disable_idle_suspend': 0,
'ignore_external_policy': 1,
'plugged_dim_ms': dim_ms,
'plugged_off_ms': off_ms,
'plugged_suspend_ms': suspend_ms,
'unplugged_dim_ms': dim_ms,
'unplugged_off_ms': off_ms,
'unplugged_suspend_ms': suspend_ms
}
self._pref_change = power_utils.PowerPrefChanger(prefs)
# Set an alarm to wake up the system in case the audio detector
# fails and the system suspends.
alarm_time = rtc.get_seconds() + run_time_sec
rtc.set_wake_alarm(alarm_time)
time.sleep(run_time_sec)
# Stop powerd to avoid suspending when the audio stops.
utils.system_output('stop powerd')
# Stop audio and wait for the audio thread to terminate.
self._enable_audio_playback = False
thread.join(timeout=(audio_loop_time_sec * 2))
if thread.is_alive():
logging.error('Audio thread did not terminate at end of test.')
# Check the D-Bus log to make sure that no suspend took place.
# dbus-monitor logs messages about its initial connection to the bus
# in addition to the signals that we asked it for, so look for the
# signal name in its output.
dbus_proc.kill()
dbus_log.seek(0)
if 'SuspendImminent' in dbus_log.read():
err_str = 'System suspended while audio was playing.'
raise error.TestFail(err_str)
def run_once(self):
"""Test main loop."""
t0 = time.time()
# record the PSR related info.
psr = power_utils.DisplayPanelSelfRefresh(init_time=t0)
try:
self._keyboard_backlight = power_utils.KbdBacklight()
self._set_keyboard_backlight_level()
except power_utils.KbdBacklightException as e:
logging.info("Assuming no keyboard backlight due to :: %s", str(e))
self._keyboard_backlight = None
measurements = []
if self._power_status.battery:
measurements += \
[power_status.SystemPower(self._power_status.battery_path)]
if power_utils.has_powercap_support():
measurements += power_rapl.create_powercap()
elif power_utils.has_rapl_support():
measurements += power_rapl.create_rapl()
self._checkpoint_logger = power_status.CheckpointLogger()
self._plog = power_status.PowerLogger(measurements,
seconds_period=20,
checkpoint_logger=self._checkpoint_logger)
self._tlog = power_status.TempLogger([],
seconds_period=20,
checkpoint_logger=self._checkpoint_logger)
self._clog = power_status.CPUStatsLogger(
seconds_period=20,
checkpoint_logger=self._checkpoint_logger)
self._meas_logs = [self._plog, self._tlog, self._clog]
for log in self._meas_logs:
log.start()
if self._log_mem_bandwidth:
self._mlog = memory_bandwidth_logger.MemoryBandwidthLogger(
raw=False, seconds_period=2)
self._mlog.start()
# record start time and end time for each task
self._task_tracker = []
ext_path = os.path.join(os.path.dirname(__file__), 'extension')
self._tmp_keyvals['username'] = self._username
arc_mode = arc_common.ARC_MODE_DISABLED
if utils.is_arc_available():
arc_mode = arc_common.ARC_MODE_ENABLED
try:
self._browser = chrome.Chrome(extension_paths=[ext_path],
gaia_login=self._gaia_login,
username=self._username,
password=self._password,
arc_mode=arc_mode)
except exceptions.LoginException:
# already failed guest login
if not self._gaia_login:
raise
self._gaia_login = False
logging.warn("Unable to use GAIA acct %s. Using GUEST instead.\n",
self._username)
self._browser = chrome.Chrome(extension_paths=[ext_path],
gaia_login=self._gaia_login)
if not self._gaia_login:
self._tmp_keyvals['username'] = '******'
extension = self._browser.get_extension(ext_path)
for k in params_dict:
if getattr(self, params_dict[k]) is not '':
extension.ExecuteJavaScript('var %s = %s;' %
(k, getattr(self, params_dict[k])))
# This opens a trap start page to capture tabs opened for first login.
# It will be closed when startTest is run.
extension.ExecuteJavaScript('chrome.windows.create(null, null);')
for i in range(self._loop_count):
start_time = time.time()
extension.ExecuteJavaScript('startTest();')
# the power test extension will report its status here
latch = self._testServer.add_wait_url('/status')
# this starts a thread in the server that listens to log
# information from the script
script_logging = self._testServer.add_wait_url(url='/log')
# dump any log entry that comes from the script into
# the debug log
self._testServer.add_url_handler(url='/log',\
handler_func=(lambda handler, forms, loop_counter=i:\
_extension_log_handler(handler, forms, loop_counter)))
pagetime_tracking = self._testServer.add_wait_url(url='/pagetime')
self._testServer.add_url_handler(url='/pagetime',\
handler_func=(lambda handler, forms, test_instance=self,
loop_counter=i:\
_extension_page_time_info_handler(handler, forms,
loop_counter,
test_instance)))
# setup a handler to simulate waking up the base of a detachable
# on user interaction. On scrolling, wake for 1s, on page
# navigation, wake for 10s.
self._testServer.add_url(url='/pagenav')
self._testServer.add_url(url='/scroll')
self._testServer.add_url_handler(url='/pagenav',
handler_func=(lambda handler, args, plt=self:
plt._detachable_handler.wake_base(10000)))
self._testServer.add_url_handler(url='/scroll',
handler_func=(lambda handler, args, plt=self:
plt._detachable_handler.wake_base(1000)))
# reset backlight level since powerd might've modified it
# based on ambient light
self._set_backlight_level()
self._set_lightbar_level()
if self._keyboard_backlight:
self._set_keyboard_backlight_level()
audio_helper.set_volume_levels(self._volume_level,
self._mic_gain)
low_battery = self._do_wait(self._verbose, self._loop_time,
latch)
script_logging.set()
pagetime_tracking.set()
self._log_loop_checkpoint(i, start_time, time.time())
if self._verbose:
logging.debug('loop %d completed', i)
if low_battery:
logging.info('Exiting due to low battery')
break
# done with logging from the script, so we can collect that thread
t1 = time.time()
psr.refresh()
self._tmp_keyvals['minutes_battery_life_tested'] = (t1 - t0) / 60
self._tmp_keyvals.update(psr.get_keyvals())
def run_once(self):
t0 = time.time()
# record the PSR related info.
psr = power_utils.DisplayPanelSelfRefresh(init_time=t0)
try:
self._keyboard_backlight = power_utils.KbdBacklight()
self._set_keyboard_backlight_level()
except power_utils.KbdBacklightException as e:
logging.info("Assuming no keyboard backlight due to :: %s", str(e))
self._keyboard_backlight = None
measurements = \
[power_status.SystemPower(self._power_status.battery_path)]
if power_utils.has_rapl_support():
measurements += power_rapl.create_rapl()
self._plog = power_status.PowerLogger(measurements, seconds_period=20)
self._tlog = power_status.TempLogger([], seconds_period=20)
self._plog.start()
self._tlog.start()
if self._log_mem_bandwidth:
self._mlog = memory_bandwidth_logger.MemoryBandwidthLogger(
raw=False, seconds_period=2)
self._mlog.start()
ext_path = os.path.join(os.path.dirname(__file__), 'extension')
self._tmp_keyvals['username'] = self._username
try:
self._browser = chrome.Chrome(extension_paths=[ext_path],
gaia_login=self._gaia_login,
username=self._username,
password=self._password)
except exceptions.LoginException:
# already failed guest login
if not self._gaia_login:
raise
self._gaia_login = False
logging.warn("Unable to use GAIA acct %s. Using GUEST instead.\n",
self._username)
self._browser = chrome.Chrome(extension_paths=[ext_path],
gaia_login=self._gaia_login)
if not self._gaia_login:
self._tmp_keyvals['username'] = '******'
extension = self._browser.get_extension(ext_path)
for k in params_dict:
if getattr(self, params_dict[k]) is not '':
extension.ExecuteJavaScript('var %s = %s;' %
(k, getattr(self, params_dict[k])))
# This opens a trap start page to capture tabs opened for first login.
# It will be closed when startTest is run.
extension.ExecuteJavaScript('chrome.windows.create(null, null);')
for i in range(self._loop_count):
start_time = time.time()
extension.ExecuteJavaScript('startTest();')
# the power test extension will report its status here
latch = self._testServer.add_wait_url('/status')
# this starts a thread in the server that listens to log
# information from the script
script_logging = self._testServer.add_wait_url(url='/log')
# dump any log entry that comes from the script into
# the debug log
self._testServer.add_url_handler(url='/log',\
handler_func=(lambda handler, forms, loop_counter=i:\
_extension_log_handler(handler, forms, loop_counter)))
pagelt_tracking = self._testServer.add_wait_url(url='/pagelt')
self._testServer.add_url_handler(url='/pagelt',\
handler_func=(lambda handler, forms, tracker=self, loop_counter=i:\
_extension_page_load_info_handler(handler, forms, loop_counter, self)))
# reset backlight level since powerd might've modified it
# based on ambient light
self._set_backlight_level()
self._set_lightbar_level()
if self._keyboard_backlight:
self._set_keyboard_backlight_level()
audio_helper.set_volume_levels(self._volume_level, self._mic_gain)
low_battery = self._do_wait(self._verbose, self._loop_time, latch)
script_logging.set()
pagelt_tracking.set()
self._plog.checkpoint('loop%d' % (i), start_time)
self._tlog.checkpoint('loop%d' % (i), start_time)
if self._verbose:
logging.debug('loop %d completed', i)
if low_battery:
logging.info('Exiting due to low battery')
break
# done with logging from the script, so we can collect that thread
t1 = time.time()
psr.refresh()
self._tmp_keyvals['minutes_battery_life_tested'] = (t1 - t0) / 60
self._tmp_keyvals.update(psr.get_keyvals())
def run_once(self):
t0 = time.time()
# record the PSR counter
psr_t0 = self._get_psr_counter()
try:
kblight = power_utils.KbdBacklight()
kblight.set(self._kblight_percent)
self._tmp_keyvals['percent_kbd_backlight'] = kblight.get()
except power_utils.KbdBacklightException as e:
logging.info("Assuming no keyboard backlight due to :: %s", str(e))
kblight = None
measurements = \
[power_status.SystemPower(self._power_status.battery_path)]
if power_utils.has_rapl_support():
measurements += power_rapl.create_rapl()
self._plog = power_status.PowerLogger(measurements, seconds_period=20)
self._tlog = power_status.TempLogger([], seconds_period=20)
self._plog.start()
self._tlog.start()
if self._log_mem_bandwidth:
self._mlog = memory_bandwidth_logger.MemoryBandwidthLogger(
raw=False, seconds_period=2)
self._mlog.start()
ext_path = os.path.join(os.path.dirname(__file__), 'extension')
self._browser = chrome.Chrome(extension_paths=[ext_path],
gaia_login=True,
username=self._username,
password=self._password)
extension = self._browser.get_extension(ext_path)
for k in params_dict:
if getattr(self, params_dict[k]) is not '':
extension.ExecuteJavaScript('var %s = %s;' %
(k, getattr(self, params_dict[k])))
# This opens a trap start page to capture tabs opened for first login.
# It will be closed when startTest is run.
extension.ExecuteJavaScript('chrome.windows.create(null, null);')
for i in range(self._loop_count):
start_time = time.time()
extension.ExecuteJavaScript('startTest();')
# the power test extension will report its status here
latch = self._testServer.add_wait_url('/status')
# reset backlight level since powerd might've modified it
# based on ambient light
self._set_backlight_level()
self._set_lightbar_level()
if kblight:
kblight.set(self._kblight_percent)
audio_helper.set_volume_levels(self._volume_level, self._mic_gain)
low_battery = self._do_wait(self._verbose, self._loop_time, latch)
self._plog.checkpoint('loop%d' % (i), start_time)
self._tlog.checkpoint('loop%d' % (i), start_time)
if self._verbose:
logging.debug('loop %d completed', i)
if low_battery:
logging.info('Exiting due to low battery')
break
t1 = time.time()
self._tmp_keyvals['minutes_battery_life_tested'] = (t1 - t0) / 60
if psr_t0:
self._tmp_keyvals['psr_residency'] = \
(self._get_psr_counter() - psr_t0) / (10 * (t1 - t0))