def __init__(self, supports_tab_control, supports_extensions, browser_options, output_profile_path, extensions_to_load): super(ChromeBrowserBackend, self).__init__( supports_extensions=supports_extensions, browser_options=browser_options, tab_list_backend=tab_list_backend.TabListBackend) self._port = None self._supports_tab_control = supports_tab_control self._tracing_backend = None self._system_info_backend = None self._output_profile_path = output_profile_path self._extensions_to_load = extensions_to_load if browser_options.netsim: self.wpr_port_pairs = forwarders.PortPairs( http=forwarders.PortPair(80, 80), https=forwarders.PortPair(443, 443), dns=forwarders.PortPair(53, 53)) else: self.wpr_port_pairs = forwarders.PortPairs( http=forwarders.PortPair(0, 0), https=forwarders.PortPair(0, 0), dns=None) if (self.browser_options.dont_override_profile and not options_for_unittests.AreSet()): sys.stderr.write('Warning: Not overriding profile. This can cause ' 'unexpected effects due to profile-specific settings, ' 'such as about:flags settings, cookies, and ' 'extensions.\n')
def testZeroIsOkayForRemotePorts(self): started_ports = (8080, 8443, None) wpr_port_pairs = forwarders.PortPairs(http=forwarders.PortPair(0, 0), https=forwarders.PortPair(0, 0), dns=None) expected_port_pairs = forwarders.PortPairs( http=forwarders.PortPair(8080, 0), https=forwarders.PortPair(8443, 0), dns=None) self.assertEqual( expected_port_pairs, network_controller_backend._ForwarderPortPairs( started_ports, wpr_port_pairs))
def testCombineStartedAndRemotePorts(self): started_ports = (8888, 4343, 5353) wpr_port_pairs = forwarders.PortPairs(http=forwarders.PortPair(0, 80), https=forwarders.PortPair( 0, 443), dns=forwarders.PortPair(0, 53)) expected_port_pairs = forwarders.PortPairs( http=forwarders.PortPair(8888, 80), https=forwarders.PortPair(4343, 443), dns=forwarders.PortPair(5353, 53)) self.assertEqual( expected_port_pairs, network_controller_backend._ForwarderPortPairs( started_ports, wpr_port_pairs))
def _ForwarderPortPairs(started_ports, wpr_port_pairs): """Return PortPairs with started local ports and requested remote ports. The local host is where Telemetry is run. The remote is host where the target application is run. The local and remote hosts may be the same (e.g., testing a desktop browser) or different (e.g., testing an android browser). The remote ports may be zero. In that case, the forwarder determines the remote ports. Args: started_ports: a tuple of of integer ports from which to forward: (HTTP_PORT, HTTPS_PORT, DNS_PORT) # DNS_PORT may be None wpr_port_pairs: a forwarders.PortPairs instance where the remote ports, if set, are used. Returns: a forwarders.PortPairs instance used to create the forwarder. """ local_http_port, local_https_port, local_dns_port = started_ports return forwarders.PortPairs( forwarders.PortPair(local_http_port, wpr_port_pairs.http.remote_port), forwarders.PortPair(local_https_port, wpr_port_pairs.https.remote_port), (forwarders.PortPair(local_dns_port, wpr_port_pairs.dns.remote_port) if wpr_port_pairs.dns is not None else None))
def testGetRemotePortAndIsHTTPServerRunningOnPort(self): with self._GetCRI() as cri: # Create local server. sock = socket.socket() sock.bind(('', 0)) port = sock.getsockname()[1] sock.listen(0) # Get remote port and ensure that it was unused. remote_port = cri.GetRemotePort() self.assertFalse(cri.IsHTTPServerRunningOnPort(remote_port)) # Forward local server's port to remote device's remote_port. forwarder = cros_forwarder.CrOsForwarderFactory(cri).Create( forwarders.PortPairs(http=forwarders.PortPair( port, remote_port), https=None, dns=None)) # At this point, remote device should be able to connect to local server. self.assertTrue(cri.IsHTTPServerRunningOnPort(remote_port)) # Next remote port shouldn't be the same as remote_port, since remote_port # is now in use. self.assertTrue(cri.GetRemotePort() != remote_port) # Close forwarder and local server ports. forwarder.Close() sock.close() # Device should no longer be able to connect to remote_port since it is no # longer in use. self.assertFalse(cri.IsHTTPServerRunningOnPort(remote_port))
def Start(self, local_server_controller): assert self._subprocess == None self._local_server_controller = local_server_controller self.host_ip = local_server_controller.host_ip server_args = self.GetBackendStartupArgs() server_args_as_json = json.dumps(server_args) server_module_name = self._server_backend_class.__module__ self._devnull = open(os.devnull, 'w') cmd = [sys.executable, '-m', __name__] cmd.extend(["run_backend"]) cmd.extend([server_module_name, self._server_backend_class.__name__, server_args_as_json]) env = os.environ.copy() env['PYTHONPATH'] = os.pathsep.join(sys.path) cwd = os.path.abspath( os.path.join(os.path.dirname(__file__), '..', '..')) self._subprocess = subprocess.Popen( cmd, cwd=cwd, env=env, stdout=subprocess.PIPE) named_ports = self._GetNamedPortsFromBackend() named_port_pair_map = {'http': None, 'https': None, 'dns': None} for name, port in named_ports: assert name in named_port_pair_map, '%s forwarding is unsupported' % name named_port_pair_map[name] = ( forwarders.PortPair(port, local_server_controller.GetRemotePort(port))) self.forwarder = local_server_controller.CreateForwarder( forwarders.PortPairs(**named_port_pair_map))
def testPortMismatchRaisesPortsMismatchError(self): # The do_nothing_forward cannot forward from one port to another. port_pairs = forwarders.PortPairs(http=forwarders.PortPair(80, 80), https=forwarders.PortPair(8443, 443), dns=None) with self.assertRaises(do_nothing_forwarder.PortsMismatchError): TestDoNothingForwarder(port_pairs)
def Start(self): # Escape all commas in the startup arguments we pass to Chrome # because dbus-send delimits array elements by commas startup_args = [ a.replace(',', '\\,') for a in self.GetBrowserStartupArgs() ] # Restart Chrome with the login extension and remote debugging. logging.info('Restarting Chrome with flags and login') args = [ 'dbus-send', '--system', '--type=method_call', '--dest=org.chromium.SessionManager', '/org/chromium/SessionManager', 'org.chromium.SessionManagerInterface.EnableChromeTesting', 'boolean:true', 'array:string:"%s"' % ','.join(startup_args) ] self._cri.RunCmdOnDevice(args) if not self._cri.local: self._port = util.GetUnreservedAvailableLocalPort() self._forwarder = self.forwarder_factory.Create( forwarders.PortPairs(http=forwarders.PortPair( self._port, self._remote_debugging_port), https=None, dns=None), forwarding_flag='L') try: self._WaitForBrowserToComeUp(wait_for_extensions=False) self._PostBrowserStartupInitialization() except: import traceback traceback.print_exc() self.Close() raise # chrome_branch_number is set in _PostBrowserStartupInitialization. # Without --skip-hwid-check (introduced in crrev.com/203397), devices/VMs # will be stuck on the bad hwid screen. if self.chrome_branch_number <= 1500 and not self.hwid: raise exceptions.LoginException( 'Hardware id not set on device/VM. --skip-hwid-check not supported ' 'with chrome branches 1500 or earlier.') util.WaitFor(lambda: self.oobe_exists, 10) if self.browser_options.auto_login: if self._is_guest: pid = self.pid self._NavigateGuestLogin() # Guest browsing shuts down the current browser and launches an # incognito browser in a separate process, which we need to wait for. util.WaitFor(lambda: pid != self.pid, 10) self._WaitForBrowserToComeUp() else: self._NavigateLogin() logging.info('Browser is up!')
def __init__(self, browser_options, backend_settings, use_rndis_forwarder, output_profile_path, extensions_to_load, target_arch, android_platform_backend): super(AndroidBrowserBackend, self).__init__( supports_tab_control=backend_settings.supports_tab_control, supports_extensions=False, browser_options=browser_options, output_profile_path=output_profile_path, extensions_to_load=extensions_to_load) if len(extensions_to_load) > 0: raise browser_backend.ExtensionsNotSupportedException( 'Android browser does not support extensions.') # Initialize fields so that an explosion during init doesn't break in Close. self._android_platform_backend = android_platform_backend self._backend_settings = backend_settings self._saved_cmdline = '' self._target_arch = target_arch self._saved_sslflag = '' # TODO(tonyg): This is flaky because it doesn't reserve the port that it # allocates. Need to fix this. self._port = adb_commands.AllocateTestServerPort() # Disables android.net SSL certificate check. This is necessary for # applications using the android.net stack to work with proxy HTTPS server # created by telemetry if self._backend_settings.relax_ssl_check: self._saved_sslflag = self._adb.device().GetProp( 'socket.relaxsslcheck') self._adb.device().SetProp('socket.relaxsslcheck', 'yes') # Kill old browser. self._KillBrowser() if self._adb.device().old_interface.CanAccessProtectedFileContents(): if self.browser_options.profile_dir: self._backend_settings.PushProfile( self.browser_options.profile_dir, self._adb) elif not self.browser_options.dont_override_profile: self._backend_settings.RemoveProfile(self._adb) self._forwarder_factory = android_forwarder.AndroidForwarderFactory( self._adb, use_rndis_forwarder) if self.browser_options.netsim or use_rndis_forwarder: assert use_rndis_forwarder, 'Netsim requires RNDIS forwarding.' self.wpr_port_pairs = forwarders.PortPairs( http=forwarders.PortPair(0, 80), https=forwarders.PortPair(0, 443), dns=forwarders.PortPair(0, 53)) # Set the debug app if needed. if self._adb.IsUserBuild(): logging.debug('User build device, setting debug app') self._adb.device().RunShellCommand( 'am set-debug-app --persistent %s' % self._backend_settings.package)
def Start(self): # Escape all commas in the startup arguments we pass to Chrome # because dbus-send delimits array elements by commas startup_args = [ a.replace(',', '\\,') for a in self.GetBrowserStartupArgs() ] # Restart Chrome with the login extension and remote debugging. logging.info('Restarting Chrome with flags and login') args = [ 'dbus-send', '--system', '--type=method_call', '--dest=org.chromium.SessionManager', '/org/chromium/SessionManager', 'org.chromium.SessionManagerInterface.EnableChromeTesting', 'boolean:true', 'array:string:"%s"' % ','.join(startup_args) ] self._cri.RunCmdOnDevice(args) if not self._cri.local: self._port = util.GetUnreservedAvailableLocalPort() self._forwarder = self.forwarder_factory.Create( forwarders.PortPairs(http=forwarders.PortPair( self._port, self._remote_debugging_port), https=None, dns=None), forwarding_flag='L') try: self._WaitForBrowserToComeUp(wait_for_extensions=False) self._PostBrowserStartupInitialization() except: import traceback traceback.print_exc() self.Close() raise util.WaitFor(lambda: self.oobe_exists, 10) if self.browser_options.auto_login: if self._is_guest: pid = self.pid self.oobe.NavigateGuestLogin() # Guest browsing shuts down the current browser and launches an # incognito browser in a separate process, which we need to wait for. util.WaitFor(lambda: pid != self.pid, 10) elif self.browser_options.gaia_login: try: self.oobe.NavigateGaiaLogin(self._username, self._password) except util.TimeoutException: self._cri.TakeScreenShot('gaia-login') raise else: self.oobe.NavigateFakeLogin(self._username, self._password) self._WaitForLogin() logging.info('Browser is up!')
def __init__(self, browser_type, browser_options, cri, is_guest, extensions_to_load): super(CrOSBrowserBackend, self).__init__(is_content_shell=False, supports_extensions=not is_guest, browser_options=browser_options, output_profile_path=None, extensions_to_load=extensions_to_load) from telemetry.core.backends.chrome import chrome_browser_options assert isinstance(browser_options, chrome_browser_options.CrosBrowserOptions) # Initialize fields so that an explosion during init doesn't break in Close. self._browser_type = browser_type self._cri = cri self._is_guest = is_guest self._forwarder = None self.wpr_port_pairs = forwarders.PortPairs( http=forwarders.PortPair(self.wpr_port_pairs.http.local_port, self._cri.GetRemotePort()), https=forwarders.PortPair(self.wpr_port_pairs.https.local_port, self._cri.GetRemotePort()), dns=None) self._remote_debugging_port = self._cri.GetRemotePort() self._port = self._remote_debugging_port self._SetBranchNumber(self._GetChromeVersion()) # Copy extensions to temp directories on the device. # Note that we also perform this copy locally to ensure that # the owner of the extensions is set to chronos. for e in extensions_to_load: output = cri.RunCmdOnDevice( ['mktemp', '-d', '/tmp/extension_XXXXX']) extension_dir = output[0].rstrip() cri.PushFile(e.path, extension_dir) cri.Chown(extension_dir) e.local_path = os.path.join(extension_dir, os.path.basename(e.path)) # Ensure the UI is running and logged out. self._RestartUI() util.WaitFor(self.IsBrowserRunning, 20) # Delete test user's cryptohome vault (user data directory). if not self.browser_options.dont_override_profile: self._cri.RunCmdOnDevice([ 'cryptohome', '--action=remove', '--force', '--user=%s' % self.browser_options.username ]) if self.browser_options.profile_dir: cri.RmRF(self.profile_directory) cri.PushFile(self.browser_options.profile_dir + '/Default', self.profile_directory) cri.Chown(self.profile_directory)
def __init__(self, adb, port_pairs): super(AndroidForwarder, self).__init__(port_pairs) self._device = adb.device() forwarder.Forwarder.Map([(p.remote_port, p.local_port) for p in port_pairs if p], self._device) self._port_pairs = forwarders.PortPairs(*[ forwarders.PortPair( p.local_port, forwarder.Forwarder.DevicePortForHostPort(p.local_port)) if p else None for p in port_pairs])
def testChecksOnlyHttpHttps(self): port_pairs = forwarders.PortPairs(http=forwarders.PortPair(80, 80), https=forwarders.PortPair(443, 443), dns=forwarders.PortPair(53, 53)) f = TestDoNothingForwarder(port_pairs) expected_connected_addresses = [ ('127.0.0.1', 80), ('127.0.0.1', 443), # Port 53 is skipped because it is UDP and does not support connections. ] self.assertEqual(expected_connected_addresses, f.connected_addresses)
def testNoDnsStillChecksHttpHttps(self): port_pairs = forwarders.PortPairs(http=forwarders.PortPair(5566, 5566), https=forwarders.PortPair( 7788, 7788), dns=None) f = TestDoNothingForwarder(port_pairs) expected_connected_addresses = [ ('127.0.0.1', 5566), ('127.0.0.1', 7788), ] self.assertEqual(expected_connected_addresses, f.connected_addresses)
def __init__(self, is_content_shell, supports_extensions, browser_options, output_profile_path, extensions_to_load): super(ChromeBrowserBackend, self).__init__(is_content_shell=is_content_shell, supports_extensions=supports_extensions, browser_options=browser_options, tab_list_backend=tab_list_backend.TabListBackend) self._port = None self._inspector_protocol_version = 0 self._chrome_branch_number = None self._tracing_backend = None self._system_info_backend = None self._output_profile_path = output_profile_path self._extensions_to_load = extensions_to_load if browser_options.netsim: self.wpr_port_pairs = forwarders.PortPairs( http=forwarders.PortPair(80, 80), https=forwarders.PortPair(443, 443), dns=forwarders.PortPair(53, 53)) else: self.wpr_port_pairs = forwarders.PortPairs( http=forwarders.PortPair(0, 0), https=forwarders.PortPair(0, 0), dns=None) if (self.browser_options.dont_override_profile and not options_for_unittests.AreSet()): sys.stderr.write( 'Warning: Not overriding profile. This can cause ' 'unexpected effects due to profile-specific settings, ' 'such as about:flags settings, cookies, and ' 'extensions.\n') self._misc_web_contents_backend = ( misc_web_contents_backend.MiscWebContentsBackend(self)) self._extension_dict_backend = None if supports_extensions: self._extension_dict_backend = ( extension_dict_backend.ExtensionDictBackend(self))
def __init__(self, android_platform_backend, browser_options, backend_settings, use_rndis_forwarder, output_profile_path, extensions_to_load, target_arch): assert isinstance(android_platform_backend, android_platform_backend_module.AndroidPlatformBackend) super(AndroidBrowserBackend, self).__init__( android_platform_backend, supports_tab_control=backend_settings.supports_tab_control, supports_extensions=False, browser_options=browser_options, output_profile_path=output_profile_path, extensions_to_load=extensions_to_load) if len(extensions_to_load) > 0: raise browser_backend.ExtensionsNotSupportedException( 'Android browser does not support extensions.') # Initialize fields so that an explosion during init doesn't break in Close. self._backend_settings = backend_settings self._saved_cmdline = '' self._target_arch = target_arch self._saved_sslflag = '' # TODO(tonyg): This is flaky because it doesn't reserve the port that it # allocates. Need to fix this. self._port = adb_commands.AllocateTestServerPort() # TODO(wuhu): Move to network controller backend. self._platform_backend.InstallTestCa() # Kill old browser. self._KillBrowser() if self._adb.device().old_interface.CanAccessProtectedFileContents(): if self.browser_options.profile_dir: self._platform_backend.PushProfile( self._backend_settings.package, self.browser_options.profile_dir) elif not self.browser_options.dont_override_profile: self._platform_backend.RemoveProfile( self._backend_settings.package, self._backend_settings.profile_ignore_list) self._forwarder_factory = android_forwarder.AndroidForwarderFactory( self._adb, use_rndis_forwarder) if self.browser_options.netsim or use_rndis_forwarder: assert use_rndis_forwarder, 'Netsim requires RNDIS forwarding.' self.wpr_port_pairs = forwarders.PortPairs( http=forwarders.PortPair(0, 80), https=forwarders.PortPair(0, 443), dns=forwarders.PortPair(0, 53)) # Set the debug app if needed. self._platform_backend.SetDebugApp(self._backend_settings.package)
def __init__(self, driver_creator, supports_extensions, browser_options): super(WebDriverBrowserBackend, self).__init__(supports_extensions=supports_extensions, browser_options=browser_options, tab_list_backend=webdriver_tab_list_backend. WebDriverTabListBackend) self._driver_creator = driver_creator self._driver = None self.wpr_port_pairs = forwarders.PortPairs( http=forwarders.PortPair(80, 80), https=forwarders.PortPair(443, 443), dns=forwarders.PortPair(53, 53))
def __init__(self, cros_platform_backend, browser_options, cri, is_guest, extensions_to_load): super(CrOSBrowserBackend, self).__init__(cros_platform_backend, supports_tab_control=True, supports_extensions=not is_guest, browser_options=browser_options, output_profile_path=None, extensions_to_load=extensions_to_load) assert browser_options.IsCrosBrowserOptions() # Initialize fields so that an explosion during init doesn't break in Close. self._cri = cri self._is_guest = is_guest self._forwarder = None self.wpr_port_pairs = forwarders.PortPairs( http=forwarders.PortPair( self.wpr_port_pairs.http.local_port, self.GetRemotePort(self.wpr_port_pairs.http.local_port)), https=forwarders.PortPair( self.wpr_port_pairs.https.local_port, self.GetRemotePort(self.wpr_port_pairs.http.local_port)), dns=None) self._remote_debugging_port = self._cri.GetRemotePort() self._port = self._remote_debugging_port # Copy extensions to temp directories on the device. # Note that we also perform this copy locally to ensure that # the owner of the extensions is set to chronos. for e in extensions_to_load: extension_dir = cri.RunCmdOnDevice( ['mktemp', '-d', '/tmp/extension_XXXXX'])[0].rstrip() cri.PushFile(e.path, extension_dir) cri.Chown(extension_dir) e.local_path = os.path.join(extension_dir, os.path.basename(e.path)) self._cri.RestartUI(self.browser_options.clear_enterprise_policy) util.WaitFor(self.IsBrowserRunning, 20) # Delete test user's cryptohome vault (user data directory). if not self.browser_options.dont_override_profile: self._cri.RunCmdOnDevice([ 'cryptohome', '--action=remove', '--force', '--user=%s' % self._username ]) if self.browser_options.profile_dir: cri.RmRF(self.profile_directory) cri.PushFile(self.browser_options.profile_dir + '/Default', self.profile_directory) cri.Chown(self.profile_directory)
def __init__(self, browser_options, backend_settings, use_rndis_forwarder, output_profile_path, extensions_to_load): super(AndroidBrowserBackend, self).__init__( is_content_shell=backend_settings.is_content_shell, supports_extensions=False, browser_options=browser_options, output_profile_path=output_profile_path, extensions_to_load=extensions_to_load) if len(extensions_to_load) > 0: raise browser_backend.ExtensionsNotSupportedException( 'Android browser does not support extensions.') # Initialize fields so that an explosion during init doesn't break in Close. self._adb = backend_settings.adb self._backend_settings = backend_settings self._saved_cmdline = '' # TODO(tonyg): This is flaky because it doesn't reserve the port that it # allocates. Need to fix this. self._port = adb_commands.AllocateTestServerPort() # Kill old browser. self._adb.CloseApplication(self._backend_settings.package) if self._adb.Adb().CanAccessProtectedFileContents(): if self.browser_options.profile_dir: self._backend_settings.PushProfile( self.browser_options.profile_dir) elif not self.browser_options.dont_override_profile: self._backend_settings.RemoveProfile() self._forwarder_factory = android_forwarder.AndroidForwarderFactory( self._adb, use_rndis_forwarder) if self.browser_options.netsim: assert use_rndis_forwarder, 'Netsim requires RNDIS forwarding.' self.wpr_port_pairs = forwarders.PortPairs( http=forwarders.PortPair(0, 80), https=forwarders.PortPair(0, 443), dns=forwarders.PortPair(0, 53)) # Set the debug app if needed. if self._adb.IsUserBuild(): logging.debug('User build device, setting debug app') self._adb.RunShellCommand('am set-debug-app --persistent %s' % self._backend_settings.package)
def __init__(self, browser_backend, path, is_record_mode, is_append_mode, make_javascript_deterministic): self._browser_backend = browser_backend self._forwarder = None self._web_page_replay = None self._is_record_mode = is_record_mode self._is_append_mode = is_append_mode wpr_args = browser_backend.browser_options.extra_wpr_args if self._is_record_mode: if self._is_append_mode: wpr_args.append('--append') else: wpr_args.append('--record') if not make_javascript_deterministic: wpr_args.append('--inject_scripts=') browser_backend.AddReplayServerOptions(wpr_args) self._web_page_replay = webpagereplay.ReplayServer( path, self._browser_backend.forwarder_factory.host_ip, browser_backend.wpr_port_pairs.dns.local_port if browser_backend.wpr_port_pairs.dns else 0, browser_backend.wpr_port_pairs.http.local_port, browser_backend.wpr_port_pairs.https.local_port, wpr_args) # Remove --no-dns_forwarding if it wasn't explicitly requested by backend. if '--no-dns_forwarding' not in wpr_args: self._web_page_replay.replay_options.remove('--no-dns_forwarding') self._web_page_replay.StartServer() browser_backend.wpr_port_pairs = forwarders.PortPairs( http=forwarders.PortPair( self._web_page_replay.http_port, browser_backend.wpr_port_pairs.http.remote_port or self._web_page_replay.http_port), https=forwarders.PortPair( self._web_page_replay.https_port, browser_backend.wpr_port_pairs.https.remote_port or self._web_page_replay.https_port), dns=forwarders.PortPair( self._web_page_replay.dns_port, browser_backend.wpr_port_pairs.dns.remote_port or self._web_page_replay.dns_port) if browser_backend.wpr_port_pairs.dns else None) self._forwarder = browser_backend.forwarder_factory.Create( browser_backend.wpr_port_pairs)
def main(): # Install APK adb = GetAdb() adb.device().EnableRoot() adb.device().Install(APP_APK) # Start USB reverse tethering. # Port map is ignored for tethering; must create one to placate assertions. named_port_pair_map = { 'http': (forwarders.PortPair(0, 0)), 'https': None, 'dns': None } port_pairs = forwarders.PortPairs(**named_port_pair_map) forwarder = GetForwarderFactory(adb).Create(port_pairs) # Start HTTP server. http_server_doc_root = GenerateHttpTestResources() config_file = tempfile.NamedTemporaryFile() http_server = lighttpd_server.LighttpdServer( http_server_doc_root, port=HTTP_PORT, base_config_path=config_file.name) GenerateLighttpdConfig(config_file, http_server_doc_root, http_server) assert http_server.StartupHttpServer() config_file.close() # Start QUIC server. quic_server_doc_root = GenerateQuicTestResources(adb) quic_server = QuicServer(quic_server_doc_root) quic_server.StartupQuicServer(adb) # Launch Telemetry's benchmark_runner on CronetPerfTestBenchmark. # By specifying this file's directory as the benchmark directory, it will # allow benchmark_runner to in turn open this file up and find the # CronetPerfTestBenchmark class to run the benchmark. top_level_dir = os.path.dirname(os.path.realpath(__file__)) runner_config = benchmark_runner.ProjectConfig( top_level_dir=top_level_dir, benchmark_dirs=[top_level_dir]) sys.argv.insert(1, 'run') sys.argv.insert(2, 'run.CronetPerfTestBenchmark') sys.argv.insert(3, '--android-rndis') benchmark_runner.main(runner_config) # Shutdown. quic_server.ShutdownQuicServer() shutil.rmtree(quic_server_doc_root) http_server.ShutdownHttpServer() shutil.rmtree(http_server_doc_root)
class ForwardingArgsTest(unittest.TestCase): port_pairs = forwarders.PortPairs(http=forwarders.PortPair(111, 222), https=forwarders.PortPair(333, 444), dns=None) def testForwardingArgsReverse(self): forwarding_args = cros_forwarder.CrOsSshForwarder._ForwardingArgs( use_remote_port_forwarding=True, host_ip='5.5.5.5', port_pairs=self.port_pairs) self.assertEqual(['-R222:5.5.5.5:111', '-R444:5.5.5.5:333'], forwarding_args) def testForwardingArgs(self): forwarding_args = cros_forwarder.CrOsSshForwarder._ForwardingArgs( use_remote_port_forwarding=False, host_ip='2.2.2.2', port_pairs=self.port_pairs) self.assertEqual(['-L111:2.2.2.2:222', '-L333:2.2.2.2:444'], forwarding_args)
def __init__(self, http_ports, https_ports, dns_ports): self.wpr_port_pairs = forwarders.PortPairs( http=forwarders.PortPair(*http_ports), https=forwarders.PortPair(*https_ports), dns=forwarders.PortPair(*dns_ports) if dns_ports else None) self.forwarder_factory = FakeForwarderFactory()
def __init__(self, http_ports, https_ports, dns_ports): self.wpr_port_pairs = forwarders.PortPairs( http=forwarders.PortPair(*http_ports), https=forwarders.PortPair(*https_ports), dns=forwarders.PortPair(*dns_ports) if dns_ports else None)
def testConnectionTimeoutRaisesConnectionError(self): port_pairs = forwarders.PortPairs(http=forwarders.PortPair(80, 80), https=forwarders.PortPair(8443, 443), dns=None) with self.assertRaises(do_nothing_forwarder.ConnectionError): TestErrorDoNothingForwarder(port_pairs)