def setUp(self):
        self.page = helpers.get_webpage()
        self.history = self.page.history()
        self.assertEqual(self.history.count(), 0)

        self.items = [
            Item(QUrl('https://www.heise.de/'), QUrl('http://www.heise.de/'),
                 'heise'),
            Item(QUrl('http://example.com/%E2%80%A6'),
                 QUrl('http://example.com/%E2%80%A6'), 'percent', active=True),
            Item(QUrl('http://example.com/?foo=bar'),
                 QUrl('http://original.url.example.com/'), 'arg',
                 user_data={'foo': 23, 'bar': 42}),
            # From https://github.com/OtterBrowser/otter-browser/issues/709#issuecomment-74749471
            Item(QUrl('http://github.com/OtterBrowser/24/134/2344/otter-browser/issues/709/'),
                 QUrl('http://github.com/OtterBrowser/24/134/2344/otter-browser/issues/709/'),
                 'Page not found | github',
                 user_data={'zoom': 149, 'scroll-pos': QPoint(0, 0)}),
            Item(QUrl('https://mail.google.com/mail/u/0/#label/some+label/234lkjsd0932lkjf884jqwerdf4'),
                 QUrl('https://mail.google.com/mail/u/0/#label/some+label/234lkjsd0932lkjf884jqwerdf4'),
                 '"some label" - [email protected] - Gmail"',
                 user_data={'zoom': 120, 'scroll-pos': QPoint(0, 0)}),
        ]
        stream, _data, self.user_data = tabhistory.serialize(self.items)
        qtutils.deserialize_stream(stream, self.history)

    def setup(self, webpage):
        self.page = webpage
        self.history = self.page.history()
        assert self.history.count() == 0

        stream, _data, self.user_data = tabhistory.serialize(self.ITEMS)
        qtutils.deserialize_stream(stream, self.history)

 def _set_data(self, browser, tab_id, items):
     """Helper function for test_long_output."""
     history = browser.widgets()[tab_id].page().history()
     stream, _data, user_data = tabhistory.serialize(items)
     qtutils.deserialize_stream(stream, history)
     for i, data in enumerate(user_data):
         history.itemAt(i).setUserData(data)

def test_empty(empty_history):
    """Check tabhistory.serialize with no items."""
    items = []
    stream, _data, user_data = tabhistory.serialize(items)
    qtutils.deserialize_stream(stream, empty_history)
    assert empty_history.count() == 0
    assert empty_history.currentItemIndex() == 0
    assert not user_data

 def test_deserialize_writeonly_stream(self):
     """Test deserialize_stream with a write-only stream."""
     data = QByteArray()
     obj = QPoint()
     stream = QDataStream(data, QIODevice.WriteOnly)
     with pytest.raises(OSError, match="The data stream has read past the "
                        "end of the data in the underlying device."):
         qtutils.deserialize_stream(stream, obj)

 def test_deserialize_writeonly_stream(self):
     """Test deserialize_stream with a write-only stream."""
     data = QByteArray()
     obj = QPoint()
     stream = QDataStream(data, QIODevice.WriteOnly)
     with pytest.raises(OSError) as excinfo:
         qtutils.deserialize_stream(stream, obj)
     assert str(excinfo.value) == ("The data stream has read past the end " "of the data in the underlying device.")

 def test_empty(self):
     """Check tabhistory.serialize with no items."""
     items = []
     stream, _data, user_data = tabhistory.serialize(items)
     qtutils.deserialize_stream(stream, self.history)
     self.assertEqual(self.history.count(), 0)
     self.assertEqual(self.history.currentItemIndex(), 0)
     self.assertFalse(user_data)

    def test_deserialize_pre_error_mock(self, stream_mock):
        """Test deserialize_stream with an error already set."""
        stream_mock.status.return_value = QDataStream.ReadCorruptData

        with pytest.raises(OSError) as excinfo:
            qtutils.deserialize_stream(stream_mock, QPoint())

        assert not stream_mock.__rshift__.called
        assert str(excinfo.value) == "The data stream has read corrupt data."

    def test_deserialize_post_error_mock(self, stream_mock):
        """Test deserialize_stream with an error while deserializing."""
        obj = QPoint()
        stream_mock.__rshift__.side_effect = lambda _other: self._set_status(stream_mock, QDataStream.ReadCorruptData)

        with pytest.raises(OSError) as excinfo:
            qtutils.deserialize_stream(stream_mock, obj)

        assert stream_mock.__rshift__.called_once_with(obj)
        assert str(excinfo.value) == "The data stream has read corrupt data."

 def load_items(self, items):
     stream, _data, cur_data = tabhistory.serialize(items)
     qtutils.deserialize_stream(stream, self._history)
     if cur_data is not None:
         if 'zoom' in cur_data:
             self._tab.zoom.set_factor(cur_data['zoom'])
         if ('scroll-pos' in cur_data and
                 self._tab.scroller.pos_px() == QPoint(0, 0)):
             QTimer.singleShot(0, functools.partial(
                 self._tab.scroller.to_point, cur_data['scroll-pos']))

 def load_items(self, items):
     stream, _data, user_data = tabhistory.serialize(items)
     qtutils.deserialize_stream(stream, self._history)
     for i, data in enumerate(user_data):
         self._history.itemAt(i).setUserData(data)
     cur_data = self._history.currentItem().userData()
     if cur_data is not None:
         if "zoom" in cur_data:
             self._tab.zoom.set_factor(cur_data["zoom"])
         if "scroll-pos" in cur_data and self._tab.scroller.pos_px() == QPoint(0, 0):
             QTimer.singleShot(0, functools.partial(self._tab.scroller.to_point, cur_data["scroll-pos"]))

    def test_round_trip_real_stream(self):
        """Test a round trip with a real QDataStream."""
        src_obj = QPoint(23, 42)
        dest_obj = QPoint()
        data = QByteArray()

        write_stream = QDataStream(data, QIODevice.WriteOnly)
        qtutils.serialize_stream(write_stream, src_obj)

        read_stream = QDataStream(data, QIODevice.ReadOnly)
        qtutils.deserialize_stream(read_stream, dest_obj)

        assert src_obj == dest_obj

    def load_items(self, items):
        stream, _data, cur_data = tabhistory.serialize(items)
        qtutils.deserialize_stream(stream, self._history)

        @pyqtSlot()
        def _on_load_finished():
            self._tab.scroller.to_point(cur_data['scroll-pos'])
            self._tab.load_finished.disconnect(_on_load_finished)

        if cur_data is not None:
            if 'zoom' in cur_data:
                self._tab.zoom.set_factor(cur_data['zoom'])
            if ('scroll-pos' in cur_data and
                    self._tab.scroller.pos_px() == QPoint(0, 0)):
                self._tab.load_finished.connect(_on_load_finished)

 def load_history(self, entries):
     """Load the history from a list of TabHistoryItem objects."""
     stream, _data, user_data = tabhistory.serialize(entries)
     history = self.history()
     qtutils.deserialize_stream(stream, history)
     for i, data in enumerate(user_data):
         history.itemAt(i).setUserData(data)
     cur_data = history.currentItem().userData()
     if cur_data is not None:
         frame = self.mainFrame()
         if 'zoom' in cur_data:
             frame.page().view().zoom_perc(cur_data['zoom'] * 100)
         if ('scroll-pos' in cur_data and
                 frame.scrollPosition() == QPoint(0, 0)):
             QTimer.singleShot(0, functools.partial(
                 frame.setScrollPosition, cur_data['scroll-pos']))

    def load_items(self, items):
        if items:
            self._tab.predicted_navigation.emit(items[-1].url)

        stream, _data, user_data = tabhistory.serialize(items)
        qtutils.deserialize_stream(stream, self._history)
        for i, data in enumerate(user_data):
            self._history.itemAt(i).setUserData(data)
        cur_data = self._history.currentItem().userData()
        if cur_data is not None:
            if 'zoom' in cur_data:
                self._tab.zoom.set_factor(cur_data['zoom'])
            if ('scroll-pos' in cur_data and
                    self._tab.scroller.pos_px() == QPoint(0, 0)):
                QTimer.singleShot(0, functools.partial(
                    self._tab.scroller.to_point, cur_data['scroll-pos']))

    def get(self, items):
        """Get the serialized history for the given items.

        Args:
            items: A list of TabHistoryItems.

        Return:
            A list of serialized items, as dicts.
        """
        history = self.webview.page().history()

        stream, _data, user_data = tabhistory.serialize(items)
        qtutils.deserialize_stream(stream, history)
        for i, data in enumerate(user_data):
            history.itemAt(i).setUserData(data)

        d = self.sess_man._save_tab(self.webview, active=True)
        new_history = d['history']
        assert len(new_history) == len(items)
        return new_history

def objects(empty_history):
    """Fixture providing a history (and userdata) filled with example data."""
    stream, _data, user_data = tabhistory.serialize(ITEMS)
    qtutils.deserialize_stream(stream, empty_history)
    return Objects(history=empty_history, user_data=user_data)

 def set_data(items):
     history = browser.widgets()[0].page().history()
     stream, _data, user_data = tabhistory.serialize(items)
     qtutils.deserialize_stream(stream, history)
     for i, data in enumerate(user_data):
         history.itemAt(i).setUserData(data)