def save(self, name, last_window=False, load_next_time=False):
        """Save a named session.

        Args:
            last_window: If set, saves the saved self._last_window_session
                         instead of the currently open state.
            load_next_time: If set, prepares this session to be load next time.
        """
        path = self._get_session_path(name)

        log.misc.debug("Saving session {} to {}...".format(name, path))
        if last_window:
            data = self._last_window_session
            assert data is not None
        else:
            data = self._save_all()
        log.misc.vdebug("Saving data: {}".format(data))
        try:
            with qtutils.savefile_open(path) as f:
                yaml.dump(data, f, Dumper=YamlDumper, default_flow_style=False,
                          encoding='utf-8', allow_unicode=True)
        except (OSError, UnicodeEncodeError, yaml.YAMLError) as e:
            raise SessionError(e)
        else:
            self.update_completion.emit()
        if load_next_time:
            state_config = objreg.get('state-config')
            state_config['general']['session'] = name

 def save(self):
     """Save the config file."""
     if not os.path.exists(self._configdir):
         os.makedirs(self._configdir, 0o755)
     log.destroy.debug("Saving config to {}".format(self._configfile))
     with qtutils.savefile_open(self._configfile) as f:
         self.write(f)

 def test_binary(self, tmpdir):
     """Test with binary data."""
     filename = tmpdir / 'foo'
     with qtutils.savefile_open(str(filename), binary=True) as f:
         f.write(b'\xde\xad\xbe\xef')
     assert tmpdir.listdir() == [filename]
     assert filename.read_binary() == b'\xde\xad\xbe\xef'

 def save(self):
     """Save the key config file."""
     if self._configfile is None:
         return
     log.destroy.debug("Saving key config to {}".format(self._configfile))
     with qtutils.savefile_open(self._configfile, encoding='utf-8') as f:
         data = str(self)
         f.write(data)

 def test_utf8(self, data, tmpdir):
     """Test with UTF8 data."""
     filename = tmpdir / 'foo'
     filename.write("Old data")
     with qtutils.savefile_open(str(filename)) as f:
         f.write(data)
     assert tmpdir.listdir() == [filename]
     assert filename.read_text(encoding='utf-8') == data

 def save(self):
     """Save the config file."""
     limit = config.get(*self._limit)
     if limit == 0:
         return
     self._prepare_save()
     with qtutils.savefile_open(self._configfile, self._binary) as f:
         self._write(f, self.data[-limit:])

 def save(self):
     """Save the config file."""
     if self._configdir is None:
         return
     configfile = os.path.join(self._configdir, self._fname)
     log.destroy.debug("Saving config to {}".format(configfile))
     with qtutils.savefile_open(configfile) as f:
         f.write(str(self))

    def test_failing_commit(self, tmpdir):
        """Test with the file being closed before committing."""
        filename = tmpdir / 'foo'
        with pytest.raises(OSError, match='Commit failed!'):
            with qtutils.savefile_open(str(filename), binary=True) as f:
                f.write(b'Hello')
                f.dev.cancelWriting()  # provoke failing commit

        assert tmpdir.listdir() == []

    def test_failing_flush(self, tmpdir):
        """Test with the file being closed before flushing."""
        filename = tmpdir / 'foo'
        with pytest.raises(ValueError, match="IO operation on closed device!"):
            with qtutils.savefile_open(str(filename), binary=True) as f:
                f.write(b'Hello')
                f.dev.commit()  # provoke failing flush

        assert tmpdir.listdir() == [filename]

    def _save(self):
        """Save the changed settings to the YAML file."""
        data = {'config_version': self.VERSION, 'global': self.values}
        with qtutils.savefile_open(self._filename) as f:
            f.write(textwrap.dedent("""
                # DO NOT edit this file by hand, qutebrowser will overwrite it.
                # Instead, create a config.py - see :help for details.

            """.lstrip('\n')))
            utils.yaml_dump(data, f)

    def test_mock_exception(self, qsavefile_mock):
        """Test with a mock and an exception in the block."""
        qsavefile_mock.open.return_value = True

        with pytest.raises(SavefileTestException):
            with qtutils.savefile_open('filename'):
                raise SavefileTestException

        qsavefile_mock.open.assert_called_once_with(QIODevice.WriteOnly)
        qsavefile_mock.cancelWriting.assert_called_once_with()

 def save(self):
     """Save the config file."""
     limit = -1 if self._limit is None else config.get(*self._limit)
     if limit == 0:
         return
     if not os.path.exists(self._configdir):
         os.makedirs(self._configdir, 0o755)
     log.destroy.debug("Saving config to {}".format(self._configfile))
     with qtutils.savefile_open(self._configfile, self._binary) as f:
         self.write(f, limit)

    def test_failing_flush(self, tmpdir):
        """Test with the file being closed before flushing."""
        filename = tmpdir / "foo"
        with pytest.raises(ValueError) as excinfo:
            with qtutils.savefile_open(str(filename), binary=True) as f:
                f.write(b"Hello")
                f.dev.commit()  # provoke failing flush

        assert str(excinfo.value) == "IO operation on closed device!"
        assert tmpdir.listdir() == [filename]

 def test_existing_dir(self, tmpdir):
     """Test with the filename already occupied by a directory."""
     filename = tmpdir / "foo"
     filename.mkdir()
     with pytest.raises(OSError) as excinfo:
         with qtutils.savefile_open(str(filename)):
             pass
     errors = ["Filename refers to a directory", "Commit failed!"]  # Qt >= 5.4  # older Qt versions
     assert str(excinfo.value) in errors
     assert tmpdir.listdir() == [filename]

    def test_failing_commit(self, tmpdir):
        """Test with the file being closed before comitting."""
        filename = tmpdir / 'foo'
        with pytest.raises(OSError) as excinfo:
            with qtutils.savefile_open(str(filename), binary=True) as f:
                f.write(b'Hello')
                f.dev.commit()  # provoke failing "real" commit

        assert str(excinfo.value) == "Commit failed!"
        assert tmpdir.listdir() == [filename]

 def test_exception(self, tmpdir):
     """Test with an exception in the block."""
     filename = tmpdir / 'foo'
     filename.write("Old content")
     with pytest.raises(SavefileTestException):
         with qtutils.savefile_open(str(filename)) as f:
             f.write("Hello World!")
             raise SavefileTestException
     assert tmpdir.listdir() == [filename]
     assert filename.read_text(encoding='utf-8') == "Old content"

 def save(self):
     """Save the config file."""
     limit = config.get(*self._limit)
     if limit == 0:
         return
     do_save = self._prepare_save()
     if not do_save:
         return
     assert self._configfile is not None
     with qtutils.savefile_open(self._configfile, self._binary) as f:
         self._write(f, self.data[-limit:])

    def test_mock_open_error(self, qsavefile_mock):
        """Test with a mock and a failing open()."""
        qsavefile_mock.open.return_value = False
        qsavefile_mock.errorString.return_value = "Hello World"

        with pytest.raises(OSError, match="Hello World"):
            with qtutils.savefile_open('filename'):
                pass

        qsavefile_mock.open.assert_called_once_with(QIODevice.WriteOnly)
        qsavefile_mock.cancelWriting.assert_called_once_with()

    def test_mock_commit_failed(self, qsavefile_mock):
        """Test with a mock and an exception in the block."""
        qsavefile_mock.open.return_value = True
        qsavefile_mock.commit.return_value = False

        with pytest.raises(OSError, match="Commit failed!"):
            with qtutils.savefile_open('filename'):
                pass

        qsavefile_mock.open.assert_called_once_with(QIODevice.WriteOnly)
        assert not qsavefile_mock.cancelWriting.called
        assert not qsavefile_mock.errorString.called

    def test_line_endings(self, tmpdir):
        """Make sure line endings are translated correctly.

        See https://github.com/The-Compiler/qutebrowser/issues/309
        """
        filename = tmpdir / 'foo'
        with qtutils.savefile_open(str(filename)) as f:
            f.write('foo\nbar\nbaz')
        data = filename.read_binary()
        if os.name == 'nt':
            assert data == b'foo\r\nbar\r\nbaz'
        else:
            assert data == b'foo\nbar\nbaz'