def _gather_crash_info(self):
        """Gather crash information to display.

        Args:
            pages: A list of the open pages (URLs as strings)
            cmdhist: A list with the command history (as strings)
            exc: An exception tuple (type, value, traceback)
        """
        self._crash_info = [
            ("How did it happen?", ""),
        ]
        try:
            self._crash_info.append(("Contact info",
                                     "User: {}".format(getpass.getuser())))
        except Exception:
            self._crash_info.append(("Contact info", traceback.format_exc()))
        try:
            self._crash_info.append(("Version info", version.version()))
        except Exception:
            self._crash_info.append(("Version info", traceback.format_exc()))
        try:
            conf = objreg.get('config')
            self._crash_info.append(("Config", conf.dump_userconfig()))
        except Exception:
            self._crash_info.append(("Config", traceback.format_exc()))

    def _gather_crash_info(self):
        """Gather crash information to display.

        Args:
            pages: A list of lists of the open pages (URLs as strings)
            cmdhist: A list with the command history (as strings)
            exc: An exception tuple (type, value, traceback)
        """
        try:
            application = QApplication.instance()
            launch_time = application.launch_time.ctime()
            self._crash_info.append(('Launch time', launch_time))
        except Exception:
            self._crash_info.append(("Launch time", traceback.format_exc()))
        try:
            self._crash_info.append(("Version info", version.version()))
        except Exception:
            self._crash_info.append(("Version info", traceback.format_exc()))
        try:
            conf = objreg.get('config')
            self._crash_info.append(("Config", conf.dump_userconfig()))
        except Exception:
            self._crash_info.append(("Config", traceback.format_exc()))
        try:
            self._crash_info.append(
                ("Environment", _get_environment_vars()))
        except Exception:
            self._crash_info.append(("Environment", traceback.format_exc()))

 def test_qt_version(self, monkeypatch):
     """Test the python version in the output."""
     monkeypatch.setattr('qutebrowser.utils.version.QT_VERSION_STR', '12.3')
     monkeypatch.setattr('qutebrowser.utils.version.qVersion',
                         lambda: '45.6')
     lines = version.version().splitlines()
     assert lines[3] == 'Qt: 12.3, runtime: 45.6'

    def _gather_crash_info(self):
        """Gather crash information to display.

        Args:
            pages: A list of lists of the open pages (URLs as strings)
            cmdhist: A list with the command history (as strings)
            exc: An exception tuple (type, value, traceback)
        """
        try:
            application = QApplication.instance()
            launch_time = application.launch_time.ctime()
            crash_time = datetime.datetime.now().ctime()
            text = 'Launch: {}\nCrash: {}'.format(launch_time, crash_time)
            self._crash_info.append(('Timestamps', text))
        except Exception:
            self._crash_info.append(("Launch time", traceback.format_exc()))
        try:
            self._crash_info.append(("Version info", version.version()))
        except Exception:
            self._crash_info.append(("Version info", traceback.format_exc()))
        try:
            self._crash_info.append(("Config",
                                     config.instance.dump_userconfig()))
        except Exception:
            self._crash_info.append(("Config", traceback.format_exc()))
        try:
            self._crash_info.append(("Environment", _get_environment_vars()))
        except Exception:
            self._crash_info.append(("Environment", traceback.format_exc()))

def dump_exception_info(exc, pages, cmdhist, objects):
    """Dump exception info to stderr.

    Args:
        exc: An exception tuple (type, value, traceback)
        pages: A list of lists of the open pages (URLs as strings)
        cmdhist: A list with the command history (as strings)
        objects: A list of all QObjects as string.
    """
    print(file=sys.stderr)
    print("\n\n===== Handling exception with --no-err-windows... =====\n\n",
          file=sys.stderr)
    print("\n---- Exceptions ----", file=sys.stderr)
    print(''.join(traceback.format_exception(*exc)), file=sys.stderr)
    print("\n---- Version info ----", file=sys.stderr)
    try:
        print(version.version(), file=sys.stderr)
    except Exception:
        traceback.print_exc()
    print("\n---- Config ----", file=sys.stderr)
    try:
        conf = objreg.get('config')
        print(conf.dump_userconfig(), file=sys.stderr)
    except Exception:
        traceback.print_exc()
    print("\n---- Commandline args ----", file=sys.stderr)
    print(' '.join(sys.argv[1:]), file=sys.stderr)
    print("\n---- Open pages ----", file=sys.stderr)
    print('\n\n'.join('\n'.join(e) for e in pages), file=sys.stderr)
    print("\n---- Command history ----", file=sys.stderr)
    print('\n'.join(cmdhist), file=sys.stderr)
    print("\n---- Objects ----", file=sys.stderr)
    print(objects, file=sys.stderr)

def run(args):
    """Initialize everthing and run the application."""
    # pylint: disable=too-many-statements
    if args.version:
        print(version.version())
        print()
        print()
        print(qutebrowser.__copyright__)
        print()
        print(version.GPL_BOILERPLATE.strip())
        sys.exit(usertypes.Exit.ok)

    if args.temp_basedir:
        args.basedir = tempfile.mkdtemp(prefix='qutebrowser-basedir-')

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

    global qApp
    qApp = Application(args)
    qApp.lastWindowClosed.connect(quitter.on_last_window_closed)

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

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

    try:
        sent = ipc.send_to_running_instance(args)
        if sent:
            sys.exit(usertypes.Exit.ok)
        log.init.debug("Starting IPC server...")
        server = ipc.IPCServer(args, qApp)
        objreg.register('ipc-server', server)
        server.got_args.connect(lambda args, cwd:
                                process_pos_args(args, cwd=cwd, via_ipc=True))
    except ipc.AddressInUseError as e:
        # This could be a race condition...
        log.init.debug("Got AddressInUseError, trying again.")
        time.sleep(500)
        sent = ipc.send_to_running_instance(args)
        if sent:
            sys.exit(usertypes.Exit.ok)
        else:
            ipc.display_error(e, args)
            sys.exit(usertypes.Exit.err_ipc)
    except ipc.Error as e:
        ipc.display_error(e, args)
        # We didn't really initialize much so far, so we just quit hard.
        sys.exit(usertypes.Exit.err_ipc)

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

 def test_frozen(self, monkeypatch, frozen, expected):
     """Test "Frozen: ..." in the version output."""
     if frozen:
         monkeypatch.setattr(sys, 'frozen', True, raising=False)
     else:
         monkeypatch.delattr(sys, 'frozen', raising=False)
     lines = version.version().splitlines()
     assert lines[9] == expected

 def test_platform(self, monkeypatch):
     """Test platform in the version output."""
     monkeypatch.setattr('qutebrowser.utils.version.platform.platform',
                         lambda: 'toaster')
     monkeypatch.setattr('qutebrowser.utils.version.platform.architecture',
                         lambda: ('64bit', ''))
     lines = version.version().splitlines()
     assert lines[10] == 'Platform: toaster, 64bit'

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_python_version(self, monkeypatch):
     """Test the python version in the output."""
     monkeypatch.setattr(
         'qutebrowser.utils.version.platform.python_implementation',
         lambda: 'python_implementation')
     monkeypatch.setattr(
         'qutebrowser.utils.version.platform.python_version',
         lambda: 'python_version')
     lines = version.version().splitlines()
     assert lines[2] == 'python_implementation: python_version'

def run(args):
    """Initialize everything and run the application."""
    # pylint: disable=too-many-statements
    if args.version:
        print(version.version(short=True))
        print()
        print()
        print(qutebrowser.__copyright__)
        print()
        print(version.GPL_BOILERPLATE.strip())
        sys.exit(usertypes.Exit.ok)

    if args.temp_basedir:
        args.basedir = tempfile.mkdtemp(prefix='qutebrowser-basedir-')

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

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

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

    signal_handler = crashsignal.SignalHandler(app=qApp, quitter=quitter,
                                               parent=qApp)
    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:
        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_os_info(self, monkeypatch):
     """Test OS info in the output."""
     monkeypatch.setattr('qutebrowser.utils.version._os_info',
                         lambda: ['Hello', 'World'])
     lines = version.version().splitlines()
     assert (lines[11], lines[12]) == ('Hello', 'World')

    def __init__(self, args):
        """Constructor.

        Args:
            Argument namespace from argparse.
        """
        self._quit_status = {
            'crash': True,
            'tabs': False,
            'main': False,
        }
        self._shutting_down = False
        self._crashdlg = None
        self._crashlogfile = None
        self._commandrunner = None

        if args.debug:
            # We don't enable this earlier because some imports trigger
            # warnings (which are not our fault).
            warnings.simplefilter('default')

        qt_args = qtutils.get_args(args)
        log.init.debug("Qt arguments: {}, based on {}".format(qt_args, args))
        super().__init__(qt_args)
        sys.excepthook = self._exception_hook

        self._args = args
        objreg.register('args', args)
        QTimer.singleShot(0, self._process_init_args)

        objreg.register('app', self)

        if self._args.version:
            print(version.version())
            print()
            print()
            print(qutebrowser.__copyright__)
            print()
            print(version.GPL_BOILERPLATE.strip())
            sys.exit(0)

        log.init.debug("Starting init...")
        self.setQuitOnLastWindowClosed(False)
        self.setOrganizationName("qutebrowser")
        self.setApplicationName("qutebrowser")
        self.setApplicationVersion(qutebrowser.__version__)
        utils.actute_warning()
        self._init_modules()

        log.init.debug("Initializing eventfilter...")
        mode_manager = objreg.get('mode-manager')
        self.installEventFilter(mode_manager)

        log.init.debug("Connecting signals...")
        self._connect_signals()
        modeman.enter(usertypes.KeyMode.normal, 'init')

        log.init.debug("Showing mainwindow...")
        if not args.nowindow:
            objreg.get('main-window').show()

        log.init.debug("Applying python hacks...")
        self._python_hacks()

        log.init.debug("Init done!")

        if self._crashdlg is not None:
            self._crashdlg.raise_()

def test_version_output(git_commit, frozen, style, equal_qt, with_webkit,
                        stubs, monkeypatch):
    """Test version.version()."""
    import_path = os.path.abspath('/IMPORTPATH')
    patches = {
        'qutebrowser.__file__': os.path.join(import_path, '__init__.py'),
        'qutebrowser.__version__': 'VERSION',
        '_git_str': lambda: ('GIT COMMIT' if git_commit else None),
        'platform.python_implementation': lambda: 'PYTHON IMPLEMENTATION',
        'platform.python_version': lambda: 'PYTHON VERSION',
        'PYQT_VERSION_STR': 'PYQT VERSION',
        'QT_VERSION_STR': 'QT VERSION',
        'qVersion': (lambda:
                     'QT VERSION' if equal_qt else 'QT RUNTIME VERSION'),
        '_module_versions': lambda: ['MODULE VERSION 1', 'MODULE VERSION 2'],
        '_pdfjs_version': lambda: 'PDFJS VERSION',
        'qWebKitVersion': (lambda: 'WEBKIT VERSION') if with_webkit else None,
        'QSslSocket': FakeQSslSocket('SSL VERSION'),
        'platform.platform': lambda: 'PLATFORM',
        'platform.architecture': lambda: ('ARCHITECTURE', ''),
        '_os_info': lambda: ['OS INFO 1', 'OS INFO 2'],
        '_path_info': lambda: {'PATH DESC': 'PATH NAME'},
        'QApplication': (stubs.FakeQApplication(style='STYLE') if style else
                         stubs.FakeQApplication(instance=None)),
    }

    for attr, val in patches.items():
        monkeypatch.setattr('qutebrowser.utils.version.' + attr, val)

    if frozen:
        monkeypatch.setattr(sys, 'frozen', True, raising=False)
    else:
        monkeypatch.delattr(sys, 'frozen', raising=False)

    template = textwrap.dedent("""
        qutebrowser vVERSION
        {git_commit}
        PYTHON IMPLEMENTATION: PYTHON VERSION
        Qt: {qt}
        PyQt: PYQT VERSION

        MODULE VERSION 1
        MODULE VERSION 2
        pdf.js: PDFJS VERSION
        Webkit: {webkit}
        SSL: SSL VERSION
        {style}
        Platform: PLATFORM, ARCHITECTURE
        Frozen: {frozen}
        Imported from {import_path}
        OS INFO 1
        OS INFO 2

        Paths:
        PATH DESC: PATH NAME
    """.lstrip('\n'))

    substitutions = {
        'git_commit': 'Git commit: GIT COMMIT\n' if git_commit else '',
        'style': '\nStyle: STYLE' if style else '',
        'qt': ('QT VERSION' if equal_qt else
               'QT RUNTIME VERSION (compiled QT VERSION)'),
        'frozen': str(frozen),
        'import_path': import_path,
        'webkit': 'WEBKIT VERSION' if with_webkit else 'no'
    }

    expected = template.rstrip('\n').format(**substitutions)
    assert version.version() == expected

 def test_ssl(self, monkeypatch):
     """Test SSL version in the output."""
     monkeypatch.setattr('qutebrowser.utils.version.QSslSocket',
                         FakeQSslSocket('1.0.1'))
     lines = version.version().splitlines()
     assert lines[7] == 'SSL: 1.0.1'

 def test_harfbuzz_set(self, monkeypatch):
     """Test harfbuzz output with QT_HARFBUZZ set."""
     monkeypatch.setenv('QT_HARFBUZZ', 'new')
     lines = version.version().splitlines()
     assert lines[6] == 'Harfbuzz: new'

def test_version_output(params, stubs, monkeypatch):
    """Test version.version()."""
    class FakeWebEngineProfile:
        def httpUserAgent(self):
            return 'Toaster/4.0.4 Chrome/CHROMIUMVERSION Teapot/4.1.8'

    import_path = os.path.abspath('/IMPORTPATH')
    patches = {
        'qutebrowser.__file__': os.path.join(import_path, '__init__.py'),
        'qutebrowser.__version__': 'VERSION',
        '_git_str': lambda: ('GIT COMMIT' if params.git_commit else None),
        'platform.python_implementation': lambda: 'PYTHON IMPLEMENTATION',
        'platform.python_version': lambda: 'PYTHON VERSION',
        'PYQT_VERSION_STR': 'PYQT VERSION',
        'earlyinit.qt_version': lambda: 'QT VERSION',
        '_module_versions': lambda: ['MODULE VERSION 1', 'MODULE VERSION 2'],
        '_pdfjs_version': lambda: 'PDFJS VERSION',
        'QSslSocket': FakeQSslSocket('SSL VERSION', params.ssl_support),
        'platform.platform': lambda: 'PLATFORM',
        'platform.architecture': lambda: ('ARCHITECTURE', ''),
        '_os_info': lambda: ['OS INFO 1', 'OS INFO 2'],
        '_path_info': lambda: {'PATH DESC': 'PATH NAME'},
        'QApplication': (stubs.FakeQApplication(style='STYLE')
                         if params.style else
                         stubs.FakeQApplication(instance=None)),
        'QLibraryInfo.location': (lambda _loc: 'QT PATH'),
        'sql.version': lambda: 'SQLITE VERSION',
    }

    substitutions = {
        'git_commit': '\nGit commit: GIT COMMIT' if params.git_commit else '',
        'style': '\nStyle: STYLE' if params.style else '',
        'qt': 'QT VERSION',
        'frozen': str(params.frozen),
        'import_path': import_path,
    }

    if params.with_webkit:
        patches['qWebKitVersion'] = lambda: 'WEBKIT VERSION'
        patches['objects.backend'] = usertypes.Backend.QtWebKit
        patches['QWebEngineProfile'] = None
        substitutions['backend'] = 'new QtWebKit (WebKit WEBKIT VERSION)'
    else:
        monkeypatch.delattr(version, 'qtutils.qWebKitVersion', raising=False)
        patches['objects.backend'] = usertypes.Backend.QtWebEngine
        patches['QWebEngineProfile'] = FakeWebEngineProfile
        substitutions['backend'] = 'QtWebEngine (Chromium CHROMIUMVERSION)'

    if params.known_distribution:
        patches['distribution'] = lambda: version.DistributionInfo(
            parsed=version.Distribution.arch, version=None,
            pretty='LINUX DISTRIBUTION', id='arch')
        substitutions['linuxdist'] = ('\nLinux distribution: '
                                      'LINUX DISTRIBUTION (arch)')
        substitutions['osinfo'] = ''
    else:
        patches['distribution'] = lambda: None
        substitutions['linuxdist'] = ''
        substitutions['osinfo'] = 'OS INFO 1\nOS INFO 2\n'

    substitutions['ssl'] = 'SSL VERSION' if params.ssl_support else 'no'

    for name, val in patches.items():
        monkeypatch.setattr('qutebrowser.utils.version.' + name, val)

    if params.frozen:
        monkeypatch.setattr(sys, 'frozen', True, raising=False)
    else:
        monkeypatch.delattr(sys, 'frozen', raising=False)

    template = textwrap.dedent("""
        qutebrowser vVERSION{git_commit}
        Backend: {backend}

        PYTHON IMPLEMENTATION: PYTHON VERSION
        Qt: {qt}
        PyQt: PYQT VERSION

        MODULE VERSION 1
        MODULE VERSION 2
        pdf.js: PDFJS VERSION
        sqlite: SQLITE VERSION
        QtNetwork SSL: {ssl}
        {style}
        Platform: PLATFORM, ARCHITECTURE{linuxdist}
        Frozen: {frozen}
        Imported from {import_path}
        Qt library executable path: QT PATH, data path: QT PATH
        {osinfo}
        Paths:
        PATH DESC: PATH NAME
    """.lstrip('\n'))

    expected = template.rstrip('\n').format(**substitutions)
    assert version.version() == expected

    def __init__(self, args):
        """Constructor.

        Args:
            Argument namespace from argparse.
        """
        # pylint: disable=too-many-statements
        self._quit_status = {
            'crash': True,
            'tabs': False,
            'main': False,
        }
        self.geometry = None
        self._shutting_down = False
        self._crashdlg = None
        self._crashlogfile = None

        qt_args = qtutils.get_args(args)
        log.init.debug("Qt arguments: {}, based on {}".format(qt_args, args))
        super().__init__(qt_args)
        sys.excepthook = self._exception_hook

        self._args = args
        objreg.register('args', args)

        objreg.register('app', self)

        if self._args.version:
            print(version.version())
            print()
            print()
            print(qutebrowser.__copyright__)
            print()
            print(version.GPL_BOILERPLATE.strip())
            sys.exit(0)

        try:
            sent = ipc.send_to_running_instance(self._args.command)
            if sent:
                sys.exit(0)
            log.init.debug("Starting IPC server...")
            ipc.init()
        except ipc.IPCError as e:
            text = ('{}\n\nMaybe another instance is running but '
                    'frozen?'.format(e))
            msgbox = QMessageBox(QMessageBox.Critical, "Error while "
                                 "connecting to running instance!", text)
            msgbox.exec_()
            # We didn't really initialize much so far, so we just quit hard.
            sys.exit(1)

        log.init.debug("Starting init...")
        self.setQuitOnLastWindowClosed(False)
        self.setOrganizationName("qutebrowser")
        self.setApplicationName("qutebrowser")
        self.setApplicationVersion(qutebrowser.__version__)
        self._init_icon()
        utils.actute_warning()
        try:
            self._init_modules()
        except (OSError, UnicodeDecodeError) as e:
            msgbox = QMessageBox(
                QMessageBox.Critical, "Error while initializing!",
                "Error while initializing: {}".format(e))
            msgbox.exec_()
            sys.exit(1)
        QTimer.singleShot(0, self._process_args)

        log.init.debug("Initializing eventfilter...")
        self._event_filter = modeman.EventFilter(self)
        self.installEventFilter(self._event_filter)

        log.init.debug("Connecting signals...")
        self._connect_signals()

        log.init.debug("Setting up signal handlers...")
        self._setup_signals()

        QDesktopServices.setUrlHandler('http', self.open_desktopservices_url)
        QDesktopServices.setUrlHandler('https', self.open_desktopservices_url)
        QDesktopServices.setUrlHandler('qute', self.open_desktopservices_url)

        log.init.debug("Init done!")

        if self._crashdlg is not None:
            self._crashdlg.raise_()

 def test_module_versions(self, monkeypatch):
     """Test module versions in the output."""
     monkeypatch.setattr('qutebrowser.utils.version._module_versions',
                         lambda: ['Hello', 'World'])
     lines = version.version().splitlines()
     assert (lines[5], lines[6]) == ('Hello', 'World')

 def test_pyqt_version(self, monkeypatch):
     """Test the PyQt version in the output."""
     monkeypatch.setattr('qutebrowser.utils.version.PYQT_VERSION_STR',
                         '78.9')
     lines = version.version().splitlines()
     assert lines[4] == 'PyQt: 78.9'