def disableImages(self):
		fireFoxProfile = FirefoxProfile()	# Nuovo profilo di FireFox #(anonimo credo, ma non importa, a meno che non voglia crearne uno, salvarlo e caricarlo da qua) 
		
		fireFoxProfile.set_preference('permissions.default.stylesheet', 2)						# no CSS
		fireFoxProfile.set_preference('permissions.default.image', 2)							# no Image
		# fireFoxProfile.set_preference('dom.ipc.plugins.enabled.libflashplayer.so','false')	# no Flash 
		return fireFoxProfile	# restituico il profilo appena creato

        def webdriver_class():
            profile = FirefoxProfile()

            # Make sure Firefox WebDriver addon works, even if it could not be verified
            profile.set_preference('xpinstall.signatures.required', False)
            webdriver = Firefox(profile)
            return webdriver

def setup_slow_browser():
    # Start the browser
    profile = FirefoxProfile()
    # When inserting many lines of text the Javascript process takes ages
    profile.set_preference('dom.max_script_run_time', 10*60)
    profile.set_preference('dom.max_chrome_script_run_time', 10*60)
    world.slow_browser = webdriver.Firefox(firefox_profile=profile)

def setup_browser():
    world.browser = None
    browser = getattr(settings, 'BROWSER', None)
    if browser is None:
        raise Exception('Please configure a browser in settings_test.py')
    elif browser == 'Firefox':
        ff_profile = FirefoxProfile()
        ff_profile.set_preference("webdriver_enable_native_events", False)
        world.browser = webdriver.Firefox(ff_profile)
    elif browser == 'Chrome':
        world.browser = webdriver.Chrome()
    elif browser == "Headless":
        world.browser = webdriver.PhantomJS(
            desired_capabilities={'handlesAlerts': True})

    world.client = client.Client()
    world.using_selenium = False

    world.browser.set_window_position(0, 0)
    world.browser.set_window_size(1024, 768)

    # Wait implicitly for 2 seconds
    world.browser.implicitly_wait(2)

    # stash
    world.memory = {}

def setup_browser():
    world.browser = None
    browser = getattr(settings, 'BROWSER', None)
    if browser is None:
        raise Exception('Please configure a browser in settings_test.py')
    elif browser == 'Firefox':
        ff_profile = FirefoxProfile()
        ff_profile.set_preference("webdriver_enable_native_events", False)
        world.browser = webdriver.Firefox(ff_profile)
    elif browser == 'Chrome':
        world.browser = webdriver.Chrome()
    elif browser == "Headless":
        world.browser = webdriver.PhantomJS(
            desired_capabilities={'handlesAlerts': True})
        cmd = "window.moveTo(0, 1); window.resizeTo(%s, %s);" % (1024, 768)
        world.browser.execute_script(cmd)

    world.client = client.Client()
    world.using_selenium = False

    # Make the browser size at least 1024x768
    world.browser.execute_script("window.moveTo(0, 1); "
                                 "window.resizeTo(1024, 768);")

    # Wait implicitly for 2 seconds
    world.browser.implicitly_wait(5)

    # stash
    world.memory = {}

def setup_browser():
    firefox_profile = FirefoxProfile()
    # Reduce bandwidth consumption and increase speed by disabling images, Flash
    firefox_profile.set_preference('permissions.default.image', 2)
    firefox_profile.set_preference('dom.ipc.plugins.enabled.libflashplayer.so',
                                  'false')
    return webdriver.Firefox(firefox_profile)

def launch_browser():

    if env.RUNNING_BROWSER.upper() == "FIREFOX":
        # the end of the browser process , the end of the browser driven process
        os.popen("TASKKILL /F /IM firefoxdriver.exe")

        fp = FirefoxProfile()
        fp.native_events_enabled = False

        binary_path = PublicImp.common.get_value_from_conf("FIREFOX_BINARY_PATH")

        if binary_path == "":
            env.driver = selenium.webdriver.Firefox(firefox_profile=fp)
        else:
            fb = FirefoxBinary(firefox_path=binary_path)
            env.driver = selenium.webdriver.Firefox(firefox_profile=fp, firefox_binary=fb)

    elif env.RUNNING_BROWSER.upper() == "CHROME":
        os.popen("TASKKILL /F /IM chromedriver.exe")

        binary_path = PublicImp.common.get_value_from_conf("CHROME_BINARY_PATH")
        chromedriver = PublicImp.common.get_value_from_conf("DRIVER_CHROME")

        if binary_path == "":
            os.environ["webdriver.chrome.driver"] = chromedriver
            env.driver = selenium.webdriver.Chrome(executable_path=chromedriver)
        else:
            opts = Options()
            opts.binary_location = binary_path
            os.environ["webdriver.chrome.driver"] = chromedriver
            env.driver = selenium.webdriver.Chrome(executable_path=chromedriver, chrome_options=opts)

    elif env.RUNNING_BROWSER.upper() == "IE":
        os.popen("TASKKILL /F /IM IEDriverServer.exe")

        dc = DesiredCapabilities.INTERNETEXPLORER.copy()

        dc['acceptSslCerts'] = True
        dc['nativeEvents'] = True

        iedriver = PublicImp.common.get_value_from_conf("DRIVER_IE")
        os.environ["webdriver.ie.driver"] = iedriver
        env.driver = selenium.webdriver.Ie(executable_path=iedriver, capabilities=dc)

    else:
        return False

    env.platformName = env.RUNNING_BROWSER

    env.TEST_URL = PublicImp.common.get_value_from_conf("TESTING_URL")
    env.driver.get(env.TEST_URL)
    env.driver.maximize_window()

    time.sleep(3)
    env.driver.refresh()
    # env.driver.set_window_size(480, 800)
    time.sleep(3)

    return True

 def setUp(self):
     ''' set up test '''
     os.environ["DISPLAY"] = ":99"
     ffx_bin = FirefoxBinary("/usr/bin/firefox")
     ffx_profile = FirefoxProfile()
     ffx_profile.accept_untrusted_certs = True
     self.driver = webdriver.Firefox(firefox_binary=ffx_bin,
                                     firefox_profile=ffx_profile)

    def get_driver(self):
        from selenium.webdriver import Firefox as FirefoxWebDriver
        from selenium.webdriver import Chrome as ChromeDriver
        from selenium.webdriver import Remote as RemoteDriver

        # Lazilly gets the driver one time cant call in begin since ssh tunnel
        # may not be created
        if self._driver:
            return self._driver

        if self._driver_type == 'firefox':
            from selenium.webdriver.firefox.firefox_profile import FirefoxProfile  # noqa
            fp = FirefoxProfile()

            for override in self._ff_profile_overrides:
                pref, value = override.split('=')
                fp.set_preference(pref, literal_eval(value))

            self._profile = fp

            if self._firefox_binary is None:
                self._driver = FirefoxWebDriver(firefox_profile=self._profile)
            else:
                from selenium.webdriver.firefox.firefox_binary import FirefoxBinary  # noqa
                binary = FirefoxBinary(self._firefox_binary)
                self._driver = FirefoxWebDriver(
                    firefox_profile=self._profile,
                    firefox_binary=binary
                )
        elif self._driver_type == 'chrome':
            self._driver = ChromeDriver()
        else:
            timeout = 60
            step = 1
            current = 0
            while current < timeout:
                try:
                    self._driver = RemoteDriver(
                        'http://%s:%s/wd/hub' % (
                            self._remote_server_address,
                            self._selenium_port,
                        ),
                        self._driver_type,
                        'WINDOWS',
                    )
                    break
                except URLError:
                    time.sleep(step)
                    current += step
                except BadStatusLine:
                    self._driver = None
                    break
            if current >= timeout:
                raise URLError('timeout')

        monkey_patch_methods(self._driver)
        return self._driver

    def setUpClass(cls):
        from selenium.webdriver.firefox.firefox_profile import FirefoxProfile
        profile = FirefoxProfile()
        profile.set_preference('geo.prompt.testing', True)
        profile.set_preference('geo.prompt.testing.allow', True)
        cls.browser = webdriver.Firefox(profile)

        cls.browser.implicitly_wait(10)
        super(RegistrationTests, cls).setUpClass()

def setup_browser():
    ff_profile = FirefoxProfile()
    ff_profile.set_preference("webdriver_enable_native_events", False)
    world.firefox = webdriver.Firefox(ff_profile)
    world.client = client.Client()
    world.using_selenium = False

    # Make the browser size at least 1024x768
    world.firefox.execute_script("window.moveTo(0, 1); window.resizeTo(1024, 768);")

 def testCopyFromSource(self):
     dir_name = tempfile.mkdtemp()
     self._create_dummy_file(dir_name)
     profile = FirefoxProfile()
     profile.copy_profile_source(dir_name)
     profile_dir = profile.path
     dst_pref_file = open(os.path.join(profile_dir, self.DUMMY_FILE_NAME))
     content = dst_pref_file.read()
     self.assertEquals(self.DUMMY_FILE_CONTENT, content)

def setup_browser(variables):
    world.using_selenium = False
    if skip_selenium():
        world.browser = None
        world.skipping = False
    else:
        ff_profile = FirefoxProfile()
        ff_profile.set_preference("webdriver_enable_native_events", False)
        world.firefox = webdriver.Firefox(ff_profile)
        world.using_selenium = False
    world.client = client.Client()

def disableImages(self):
    ## get the Firefox profile object
    firefoxProfile = FirefoxProfile()
    ## Disable CSS
    #firefoxProfile.set_preference('permissions.default.stylesheet', 2)
    ## Disable images
    firefoxProfile.set_preference('permissions.default.image', 2)
    ## Disable Flash
    firefoxProfile.set_preference('dom.ipc.plugins.enabled.libflashplayer.so',
                                  'false')
    ## Set the modified profile while creating the browser object 
    self.browserHandle = webdriver.Firefox(firefoxProfile)

 def __init__(self):
     firefox_profile = FirefoxProfile()
     # we need to turn off stylesheets because otherwise Selenium couldn't find
     # the the buttons in tests
     firefox_profile.set_preference('permissions.default.stylesheet', 2)
     super(WebDriver, self).__init__(
             command_executor='http://127.0.0.1:4444/wd/hub',
             browser_profile=firefox_profile,
             desired_capabilities=DesiredCapabilities.FIREFOX)
     self.set_page_load_timeout(60)
     self.implicitly_wait(60)
     self.base_url = "http://oioioi:8000"
     self.delete_all_cookies()

 def getDriver(self):
     if os.environ.get("WEBDRIVER", None) == "chrome":
         os.environ['PATH'] += ":/usr/lib/chromium-browser"
         logging.basicConfig(level=logging.DEBUG)
         options = Options()
         options.add_argument("--no-sandbox")
         theDriver = webdriver.Chrome(chrome_options = options)
     else:
         profile_directory = os.path.join(os.path.dirname(__file__), "firefox-client-nossl-profile")
         profile = FirefoxProfile(profile_directory)
         profile.set_preference("security.default_personal_cert", "Select Automatically")
         theDriver = webdriver.Firefox(firefox_profile=profile)
     return theDriver

    def __init__(self):
        firefox_profile = FirefoxProfile()
        firefox_profile.set_preference('extensions.logging.enabled', 'false')

        self._patch_subprocess()
        self.driver = Firefox(firefox_profile)
        self._unpatch_subprocess()

        self.element_class = WebDriverElement

        self._cookie_manager = CookieManager(self.driver)

        super(WebDriver, self).__init__()

 def __init__(self):
     if config.RunInBrowser:
         ffProfile = FirefoxProfile()
         ffProfile.set_preference('permissions.default.image', 2)
         self.driver = webdriver.Firefox(ffProfile)
     else:
         service_args = ['--load-images=false', '--ignore-ssl-errors=true', '--proxy-type=none']
         phantomBinary = config.get_main_dir() + "\\Resources\\phantomjs.exe"
         dcap = dict(webdriver.DesiredCapabilities.PHANTOMJS)
         dcap["phantomjs.page.settings.userAgent"] = (
             "Mozilla/5.0 (Windows NT 6.2) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/31.0.1650.63 Safari/537.36")
         self.driver = webdriver.PhantomJS(executable_path=phantomBinary, desired_capabilities=dcap,
                                           service_args=service_args)
     self.driver.implicitly_wait(10)

    def setUp(self):
        profile = FirefoxProfile()
        # Ignore certification
        profile.set_preference("webdriver_assume_untrusted_issuer", False)
        profile.set_preference("webdriver_accept_untrusted_certs", True)
        profile.accept_untrusted_certs = True
        
        # Set user agent
        profile.set_preference("general.useragent.override", "Mozilla/5.0 (iPhone; CPU iPhone OS 8_0 like Mac OS X) AppleWebKit/600.1.4 (KHTML, like Gecko) Version/8.0 Mobile/12A365 Safari/600.1.4")
        profile.update_preferences()
        self.driver = webdriver.Firefox(profile)

        self.base_url = "http://m.finance.yahoo.co.jp/"
        self.driver.implicitly_wait(30)
        self.accept_next_alert = True

def get_args(driver=None,
             download_dir=None,
             download_ftypes=None,
             firefox_pref=None,
             firefox_prof_dir=None,
             remote_url=None,
             executable=None,
             headless=False,
             driver_kwargs=None):
    """Construct arguments to be passed to webdriver on initialization."""
    kwargs = {}

    firefox_profile_preferences = dict({
        'browser.download.folderList': 2,
        'browser.download.manager.showWhenStarting': False,
        'browser.download.dir': download_dir,
        'browser.helperApps.neverAsk.saveToDisk': download_ftypes,
        'browser.helperApps.alwaysAsk.force': False,
        'pdfjs.disabled': True,  # disable internal ff pdf viewer to allow auto pdf download
    }, **firefox_pref or {})

    if driver == 'firefox':
        kwargs['profile_preferences'] = firefox_profile_preferences
        kwargs['profile'] = firefox_prof_dir
    elif driver == 'remote':
        if remote_url:
            kwargs['url'] = remote_url
        kwargs['keep_alive'] = True
        profile = FirefoxProfile(firefox_prof_dir)
        for key, value in firefox_profile_preferences.items():
            profile.set_preference(key, value)
        kwargs['firefox_profile'] = profile.encoded

        # remote geckodriver does not support the firefox_profile desired
        # capatibility. Instead `moz:firefoxOptions` should be used:
        # https://github.com/mozilla/geckodriver#firefox-capabilities
        kwargs['moz:firefoxOptions'] = driver_kwargs.get('moz:firefoxOptions', {})
        kwargs['moz:firefoxOptions']['profile'] = profile.encoded
    elif driver in ('chrome',):
        if executable:
            kwargs['executable_path'] = executable

        if headless:
            kwargs["headless"] = headless

    if driver_kwargs:
        kwargs.update(driver_kwargs)
    return kwargs