def test_config_none(self):
     """Test initializing with config path set to None."""
     args = types.SimpleNamespace(confdir='')
     with helpers.environ_set_temp(self.env):
         standarddir.init(args)
         config.init()
     self.assertFalse(os.listdir(self.conf_path))

 def test_cache(self):
     """Test cache dir with XDG_CACHE_HOME not set."""
     env = {'HOME': self.temp_dir, 'XDG_CACHE_HOME': None}
     with helpers.environ_set_temp(env):
         standarddir.init(None)
         expected = os.path.join(self.temp_dir, '.cache', 'qutebrowser')
         self.assertEqual(standarddir.cache(), expected)

 def test_config(self, monkeypatch, tmpdir):
     """Test config dir with XDG_CONFIG_HOME not set."""
     monkeypatch.setenv('HOME', str(tmpdir))
     monkeypatch.delenv('XDG_CONFIG_HOME', raising=False)
     standarddir.init(None)
     expected = tmpdir / '.config' / 'qutebrowser_test'
     assert standarddir.config() == str(expected)

    def _init_modules(self):
        """Initialize all 'modules' which need to be initialized."""
        log.init.debug("Initializing readline-bridge...")
        readline_bridge = readline.ReadlineBridge()
        objreg.register('readline-bridge', readline_bridge)

        log.init.debug("Initializing directories...")
        standarddir.init()
        log.init.debug("Initializing config...")
        config.init(self._args)
        log.init.debug("Initializing crashlog...")
        self._handle_segfault()
        log.init.debug("Initializing websettings...")
        websettings.init()
        log.init.debug("Initializing quickmarks...")
        quickmark_manager = quickmarks.QuickmarkManager()
        objreg.register('quickmark-manager', quickmark_manager)
        log.init.debug("Initializing proxy...")
        proxy.init()
        log.init.debug("Initializing cookies...")
        cookie_jar = cookies.CookieJar(self)
        objreg.register('cookie-jar', cookie_jar)
        log.init.debug("Initializing cache...")
        diskcache = cache.DiskCache(self)
        objreg.register('cache', diskcache)
        log.init.debug("Initializing main window...")
        win_id = mainwindow.MainWindow.spawn(
            False if self._args.nowindow else True)
        main_window = objreg.get('main-window', scope='window', window=win_id)
        self.setActiveWindow(main_window)

 def test_basedir(self, tmpdir, typ):
     """Test --basedir."""
     expected = str(tmpdir / typ)
     args = types.SimpleNamespace(basedir=str(tmpdir))
     standarddir.init(args)
     func = getattr(standarddir, typ)
     assert func() == expected

 def test_cache(self, monkeypatch, tmpdir):
     """Test cache dir with XDG_CACHE_HOME not set."""
     monkeypatch.setenv('HOME', str(tmpdir))
     monkeypatch.delenv('XDG_CACHE_HOME', raising=False)
     standarddir.init(None)
     expected = tmpdir / '.cache' / 'qutebrowser_test'
     assert standarddir.cache() == expected

def test_init(mocker, tmpdir, args_kind):
    """Do some sanity checks for standarddir.init().

    Things like _init_cachedir_tag() are tested in more detail in other tests.
    """
    assert standarddir._locations == {}

    m_windows = mocker.patch('qutebrowser.utils.standarddir._move_windows')
    m_mac = mocker.patch('qutebrowser.utils.standarddir._move_macos')
    if args_kind == 'normal':
        args = types.SimpleNamespace(basedir=None)
    elif args_kind == 'basedir':
        args = types.SimpleNamespace(basedir=str(tmpdir))
    else:
        assert args_kind == 'none'
        args = None

    standarddir.init(args)

    assert standarddir._locations != {}
    if args_kind == 'normal':
        if sys.platform == 'darwin':
            assert not m_windows.called
            assert m_mac.called
        elif os.name == 'nt':
            assert m_windows.called
            assert not m_mac.called
        else:
            assert not m_windows.called
            assert not m_mac.called
    else:
        assert not m_windows.called
        assert not m_mac.called

 def test_data(self, monkeypatch, tmpdir):
     """Test data dir with XDG_DATA_HOME not set."""
     monkeypatch.setenv('HOME', str(tmpdir))
     monkeypatch.delenv('XDG_DATA_HOME', raising=False)
     standarddir.init(None)
     expected = tmpdir / '.local' / 'share' / 'qutebrowser_test'
     assert standarddir.data() == str(expected)

 def test_system_datadir_not_exist_linux(self, monkeypatch, tmpdir,
                                         fake_args):
     """Test that system-wide path isn't used on linux if path not exist."""
     fake_args.basedir = str(tmpdir)
     standarddir.init(fake_args)
     monkeypatch.setattr(os.path, 'exists', lambda path: False)
     assert standarddir.system_data() == standarddir.data()

 def test_system_datadir_unsupportedos(self, monkeypatch, tmpdir,
                                       fake_args):
     """Test that system-wide path is not used on non-Linux OS."""
     fake_args.basedir = str(tmpdir)
     standarddir.init(fake_args)
     monkeypatch.setattr('sys.platform', "potato")
     assert standarddir.system_data() == standarddir.data()

 def test_config_none(self, monkeypatch):
     """Test initializing with config path set to None."""
     args = types.SimpleNamespace(confdir='', datadir='', cachedir='')
     for k, v in self.env.items():
         monkeypatch.setenv(k, v)
     standarddir.init(args)
     config.init()
     assert not os.listdir(str(self.conf_path))

 def test_data(self):
     """Test data dir with XDG_DATA_HOME not set."""
     env = {'HOME': self.temp_dir, 'XDG_DATA_HOME': None}
     with helpers.environ_set_temp(env):
         standarddir.init(None)
         expected = os.path.join(self.temp_dir, '.local', 'share',
                                 'qutebrowser')
         self.assertEqual(standarddir.data(), expected)

 def test_confdir_none(self, mocker):
     """Test --confdir with None given."""
     # patch makedirs to a noop so we don't really create a directory
     mocker.patch('qutebrowser.utils.standarddir.os.makedirs')
     args = types.SimpleNamespace(confdir=None, cachedir=None, datadir=None,
                                  basedir=None)
     standarddir.init(args)
     assert standarddir.config().split(os.sep)[-1] == 'qute_test'

 def test_basedir_relative(self, tmpdir):
     """Test --basedir with a relative path."""
     basedir = (tmpdir / 'basedir')
     basedir.ensure(dir=True)
     with tmpdir.as_cwd():
         args = types.SimpleNamespace(basedir='basedir')
         standarddir.init(args)
         assert standarddir.config() == str(basedir / 'config')

 def test_runtimedir(self, tmpdir, monkeypatch):
     """Test runtime dir (which has no args)."""
     monkeypatch.setattr(
         'qutebrowser.utils.standarddir.QStandardPaths.writableLocation',
         lambda _typ: str(tmpdir))
     args = types.SimpleNamespace(confdir=None, cachedir=None, datadir=None)
     standarddir.init(args)
     assert standarddir.runtime() == str(tmpdir)

def _init_modules(args, crash_handler):
    """Initialize all 'modules' which need to be initialized.

    Args:
        args: The argparse namespace.
        crash_handler: The CrashHandler instance.
    """
    # pylint: disable=too-many-statements
    log.init.debug("Initializing save manager...")
    save_manager = savemanager.SaveManager(qApp)
    objreg.register('save-manager', save_manager)
    save_manager.add_saveable('version', _save_version)
    log.init.debug("Initializing network...")
    networkmanager.init()
    log.init.debug("Initializing readline-bridge...")
    readline_bridge = readline.ReadlineBridge()
    objreg.register('readline-bridge', readline_bridge)
    log.init.debug("Initializing directories...")
    standarddir.init(args)
    log.init.debug("Initializing config...")
    config.init(qApp)
    save_manager.init_autosave()
    log.init.debug("Initializing web history...")
    history.init(qApp)
    log.init.debug("Initializing crashlog...")
    if not args.no_err_windows:
        crash_handler.handle_segfault()
    log.init.debug("Initializing sessions...")
    sessions.init(qApp)
    log.init.debug("Initializing js-bridge...")
    js_bridge = qutescheme.JSBridge(qApp)
    objreg.register('js-bridge', js_bridge)
    log.init.debug("Initializing websettings...")
    websettings.init()
    log.init.debug("Initializing adblock...")
    host_blocker = adblock.HostBlocker()
    host_blocker.read_hosts()
    objreg.register('host-blocker', host_blocker)
    log.init.debug("Initializing quickmarks...")
    quickmark_manager = urlmarks.QuickmarkManager(qApp)
    objreg.register('quickmark-manager', quickmark_manager)
    log.init.debug("Initializing bookmarks...")
    bookmark_manager = urlmarks.BookmarkManager(qApp)
    objreg.register('bookmark-manager', bookmark_manager)
    log.init.debug("Initializing proxy...")
    proxy.init()
    log.init.debug("Initializing cookies...")
    cookie_jar = cookies.CookieJar(qApp)
    objreg.register('cookie-jar', cookie_jar)
    log.init.debug("Initializing cache...")
    diskcache = cache.DiskCache(qApp)
    objreg.register('cache', diskcache)
    log.init.debug("Initializing completions...")
    completionmodels.init()
    log.init.debug("Misc initialization...")
    _maybe_hide_mouse_cursor()
    objreg.get('config').changed.connect(_maybe_hide_mouse_cursor)

def run(args):
    """Initialize everything and run the application."""
    if args.temp_basedir:
        args.basedir = tempfile.mkdtemp(prefix='qutebrowser-basedir-')

    quitter = Quitter(args)
    objreg.register('quitter', quitter)

    log.init.debug("Initializing directories...")
    standarddir.init(args)
    utils.preload_resources()

    log.init.debug("Initializing config...")
    configinit.early_init(args)

    global q_app
    q_app = Application(args)
    q_app.setOrganizationName("qutebrowser")
    q_app.setApplicationName("qutebrowser")
    q_app.setDesktopFileName("qutebrowser")
    q_app.setApplicationVersion(qutebrowser.__version__)
    q_app.lastWindowClosed.connect(quitter.on_last_window_closed)

    if args.version:
        print(version.version())
        sys.exit(usertypes.Exit.ok)

    crash_handler = crashsignal.CrashHandler(
        app=q_app, quitter=quitter, args=args, parent=q_app)
    crash_handler.activate()
    objreg.register('crash-handler', crash_handler)

    signal_handler = crashsignal.SignalHandler(app=q_app, quitter=quitter,
                                               parent=q_app)
    signal_handler.activate()
    objreg.register('signal-handler', signal_handler)

    try:
        server = ipc.send_or_listen(args)
    except ipc.Error:
        # ipc.send_or_listen already displays the error message for us.
        # We didn't really initialize much so far, so we just quit hard.
        sys.exit(usertypes.Exit.err_ipc)

    if server is None:
        if args.backend is not None:
            log.init.warning(
                "Backend from the running instance will be used")
        sys.exit(usertypes.Exit.ok)
    else:
        server.got_args.connect(lambda args, target_arg, cwd:
                                process_pos_args(args, cwd=cwd, via_ipc=True,
                                                 target_arg=target_arg))

    init(args, crash_handler)
    ret = qt_mainloop()
    return ret

 def test_config_none(self, monkeypatch, env):
     """Test initializing with config path set to None."""
     args = types.SimpleNamespace(confdir='', datadir='', cachedir='',
                                  basedir=None)
     for k, v in env.items():
         monkeypatch.setenv(k, v)
     standarddir.init(args)
     config.init()
     assert not os.listdir(env['XDG_CONFIG_HOME'])

 def test_config_none(self, monkeypatch, env, fake_args):
     """Test initializing with config path set to None."""
     fake_args.confdir = ''
     fake_args.datadir = ''
     fake_args.cachedir = ''
     fake_args.basedir = None
     for k, v in env.items():
         monkeypatch.setenv(k, v)
     standarddir.init(fake_args)
     config.init()
     assert not os.listdir(env['XDG_CONFIG_HOME'])

 def _init_modules(self):
     """Initialize all 'modules' which need to be initialized."""
     # pylint: disable=too-many-statements
     log.init.debug("Initializing save manager...")
     save_manager = savemanager.SaveManager(self)
     objreg.register('save-manager', save_manager)
     save_manager.add_saveable('window-geometry', self._save_geometry)
     save_manager.add_saveable('version', self._save_version)
     log.init.debug("Initializing network...")
     networkmanager.init()
     log.init.debug("Initializing readline-bridge...")
     readline_bridge = readline.ReadlineBridge()
     objreg.register('readline-bridge', readline_bridge)
     log.init.debug("Initializing directories...")
     standarddir.init(self._args)
     log.init.debug("Initializing config...")
     config.init(self)
     save_manager.init_autosave()
     log.init.debug("Initializing web history...")
     history.init(self)
     log.init.debug("Initializing crashlog...")
     self._handle_segfault()
     log.init.debug("Initializing sessions...")
     sessions.init(self)
     log.init.debug("Initializing js-bridge...")
     js_bridge = qutescheme.JSBridge(self)
     objreg.register('js-bridge', js_bridge)
     log.init.debug("Initializing websettings...")
     websettings.init()
     log.init.debug("Initializing adblock...")
     host_blocker = adblock.HostBlocker()
     host_blocker.read_hosts()
     objreg.register('host-blocker', host_blocker)
     log.init.debug("Initializing quickmarks...")
     quickmark_manager = quickmarks.QuickmarkManager(self)
     objreg.register('quickmark-manager', quickmark_manager)
     log.init.debug("Initializing proxy...")
     proxy.init()
     log.init.debug("Initializing cookies...")
     cookie_jar = cookies.CookieJar(self)
     objreg.register('cookie-jar', cookie_jar)
     log.init.debug("Initializing cache...")
     diskcache = cache.DiskCache(self)
     objreg.register('cache', diskcache)
     log.init.debug("Initializing completions...")
     completionmodels.init()
     log.init.debug("Misc initialization...")
     self.maybe_hide_mouse_cursor()
     objreg.get('config').changed.connect(self.maybe_hide_mouse_cursor)